Spaces:
Configuration error
Configuration error
// TypeScript Version: 3.0 | |
/// <reference types="node" /> | |
import * as fs from "fs"; | |
import { EventEmitter } from "events"; | |
import { Matcher } from 'anymatch'; | |
export class FSWatcher extends EventEmitter implements fs.FSWatcher { | |
options: WatchOptions; | |
/** | |
* Constructs a new FSWatcher instance with optional WatchOptions parameter. | |
*/ | |
constructor(options?: WatchOptions); | |
/** | |
* Add files, directories, or glob patterns for tracking. Takes an array of strings or just one | |
* string. | |
*/ | |
add(paths: string | ReadonlyArray<string>): this; | |
/** | |
* Stop watching files, directories, or glob patterns. Takes an array of strings or just one | |
* string. | |
*/ | |
unwatch(paths: string | ReadonlyArray<string>): this; | |
/** | |
* Returns an object representing all the paths on the file system being watched by this | |
* `FSWatcher` instance. The object's keys are all the directories (using absolute paths unless | |
* the `cwd` option was used), and the values are arrays of the names of the items contained in | |
* each directory. | |
*/ | |
getWatched(): { | |
[directory: string]: string[]; | |
}; | |
/** | |
* Removes all listeners from watched files. | |
*/ | |
close(): Promise<void>; | |
on(event: 'add'|'addDir'|'change', listener: (path: string, stats?: fs.Stats) => void): this; | |
on(event: 'all', listener: (eventName: 'add'|'addDir'|'change'|'unlink'|'unlinkDir', path: string, stats?: fs.Stats) => void): this; | |
/** | |
* Error occurred | |
*/ | |
on(event: 'error', listener: (error: Error) => void): this; | |
/** | |
* Exposes the native Node `fs.FSWatcher events` | |
*/ | |
on(event: 'raw', listener: (eventName: string, path: string, details: any) => void): this; | |
/** | |
* Fires when the initial scan is complete | |
*/ | |
on(event: 'ready', listener: () => void): this; | |
on(event: 'unlink'|'unlinkDir', listener: (path: string) => void): this; | |
on(event: string, listener: (...args: any[]) => void): this; | |
} | |
export interface WatchOptions { | |
/** | |
* Indicates whether the process should continue to run as long as files are being watched. If | |
* set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`, | |
* even if the process continues to run. | |
*/ | |
persistent?: boolean; | |
/** | |
* ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to | |
* be ignored. The whole relative or absolute path is tested, not just filename. If a function | |
* with two arguments is provided, it gets called twice per path - once with a single argument | |
* (the path), second time with two arguments (the path and the | |
* [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path). | |
*/ | |
ignored?: Matcher; | |
/** | |
* If set to `false` then `add`/`addDir` events are also emitted for matching paths while | |
* instantiating the watching as chokidar discovers these file paths (before the `ready` event). | |
*/ | |
ignoreInitial?: boolean; | |
/** | |
* When `false`, only the symlinks themselves will be watched for changes instead of following | |
* the link references and bubbling events through the link's path. | |
*/ | |
followSymlinks?: boolean; | |
/** | |
* The base directory from which watch `paths` are to be derived. Paths emitted with events will | |
* be relative to this. | |
*/ | |
cwd?: string; | |
/** | |
* If set to true then the strings passed to .watch() and .add() are treated as literal path | |
* names, even if they look like globs. Default: false. | |
*/ | |
disableGlobbing?: boolean; | |
/** | |
* Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU | |
* utilization, consider setting this to `false`. It is typically necessary to **set this to | |
* `true` to successfully watch files over a network**, and it may be necessary to successfully | |
* watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides | |
* the `useFsEvents` default. | |
*/ | |
usePolling?: boolean; | |
/** | |
* Whether to use the `fsevents` watching interface if available. When set to `true` explicitly | |
* and `fsevents` is available this supercedes the `usePolling` setting. When set to `false` on | |
* OS X, `usePolling: true` becomes the default. | |
*/ | |
useFsEvents?: boolean; | |
/** | |
* If relying upon the [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object that | |
* may get passed with `add`, `addDir`, and `change` events, set this to `true` to ensure it is | |
* provided even in cases where it wasn't already available from the underlying watch events. | |
*/ | |
alwaysStat?: boolean; | |
/** | |
* If set, limits how many levels of subdirectories will be traversed. | |
*/ | |
depth?: number; | |
/** | |
* Interval of file system polling. | |
*/ | |
interval?: number; | |
/** | |
* Interval of file system polling for binary files. ([see list of binary extensions](https://gi | |
* thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json)) | |
*/ | |
binaryInterval?: number; | |
/** | |
* Indicates whether to watch files that don't have read permissions if possible. If watching | |
* fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed | |
* silently. | |
*/ | |
ignorePermissionErrors?: boolean; | |
/** | |
* `true` if `useFsEvents` and `usePolling` are `false`). Automatically filters out artifacts | |
* that occur when using editors that use "atomic writes" instead of writing directly to the | |
* source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a `change` | |
* event rather than `unlink` then `add`. If the default of 100 ms does not work well for you, | |
* you can override it by setting `atomic` to a custom value, in milliseconds. | |
*/ | |
atomic?: boolean | number; | |
/** | |
* can be set to an object in order to adjust timing params: | |
*/ | |
awaitWriteFinish?: AwaitWriteFinishOptions | boolean; | |
} | |
export interface AwaitWriteFinishOptions { | |
/** | |
* Amount of time in milliseconds for a file size to remain constant before emitting its event. | |
*/ | |
stabilityThreshold?: number; | |
/** | |
* File size polling interval. | |
*/ | |
pollInterval?: number; | |
} | |
/** | |
* produces an instance of `FSWatcher`. | |
*/ | |
export function watch( | |
paths: string | ReadonlyArray<string>, | |
options?: WatchOptions | |
): FSWatcher; | |