@highstate/designer 0.2.2 → 0.3.3

package/.output/server/node_modules/watcher/dist/watcher.js

@@ -0,0 +1,396 @@
+/* IMPORT */
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEPTH, LIMIT, HAS_NATIVE_RECURSION, POLLING_INTERVAL } from './constants.js';
+import { TargetEvent, WatcherEvent } from './enums.js';
+import Utils from './utils.js';
+import WatcherHandler from './watcher_handler.js';
+import WatcherLocker from './watcher_locker.js';
+import WatcherPoller from './watcher_poller.js';
+/* MAIN */
+class Watcher extends EventEmitter {
+    /* CONSTRUCTOR */
+    constructor(target, options, handler) {
+        super();
+        this._closed = false;
+        this._ready = false;
+        this._closeAborter = new AbortController();
+        this._closeSignal = this._closeAborter.signal;
+        this.on(WatcherEvent.CLOSE, () => this._closeAborter.abort());
+        this._closeWait = new Promise(resolve => this.on(WatcherEvent.CLOSE, resolve));
+        this._readyWait = new Promise(resolve => this.on(WatcherEvent.READY, resolve));
+        this._locker = new WatcherLocker(this);
+        this._roots = new Set();
+        this._poller = new WatcherPoller();
+        this._pollers = new Set();
+        this._subwatchers = new Set();
+        this._watchers = {};
+        this._watchersLock = Promise.resolve();
+        this._watchersRestorable = {};
+        this.watch(target, options, handler);
+    }
+    /* API */
+    isClosed() {
+        return this._closed;
+    }
+    isIgnored(targetPath, ignore) {
+        return !!ignore && (Utils.lang.isFunction(ignore) ? !!ignore(targetPath) : ignore.test(targetPath));
+    }
+    isReady() {
+        return this._ready;
+    }
+    close() {
+        this._locker.reset();
+        this._poller.reset();
+        this._roots.clear();
+        this.watchersClose();
+        if (this.isClosed())
+            return false;
+        this._closed = true;
+        return this.emit(WatcherEvent.CLOSE);
+    }
+    error(exception) {
+        if (this.isClosed())
+            return false;
+        const error = Utils.lang.castError(exception);
+        return this.emit(WatcherEvent.ERROR, error);
+    }
+    event(event, targetPath, targetPathNext) {
+        if (this.isClosed())
+            return false;
+        this.emit(WatcherEvent.ALL, event, targetPath, targetPathNext);
+        return this.emit(event, targetPath, targetPathNext);
+    }
+    ready() {
+        if (this.isClosed() || this.isReady())
+            return false;
+        this._ready = true;
+        return this.emit(WatcherEvent.READY);
+    }
+    pollerExists(targetPath, options) {
+        for (const poller of this._pollers) {
+            if (poller.targetPath !== targetPath)
+                continue;
+            if (!Utils.lang.isShallowEqual(poller.options, options))
+                continue;
+            return true;
+        }
+        return false;
+    }
+    subwatcherExists(targetPath, options) {
+        for (const subwatcher of this._subwatchers) {
+            if (subwatcher.targetPath !== targetPath)
+                continue;
+            if (!Utils.lang.isShallowEqual(subwatcher.options, options))
+                continue;
+            return true;
+        }
+        return false;
+    }
+    watchersClose(folderPath, filePath, recursive = true) {
+        if (!folderPath) {
+            for (const folderPath in this._watchers) {
+                this.watchersClose(folderPath, filePath, false);
+            }
+        }
+        else {
+            const configs = this._watchers[folderPath];
+            if (configs) {
+                for (const config of [...configs]) { // It's important to clone the array, as items will be deleted from it also
+                    if (filePath && config.filePath !== filePath)
+                        continue;
+                    this.watcherClose(config);
+                }
+            }
+            if (recursive) {
+                for (const folderPathOther in this._watchers) {
+                    if (!Utils.fs.isSubPath(folderPath, folderPathOther))
+                        continue;
+                    this.watchersClose(folderPathOther, filePath, false);
+                }
+            }
+        }
+    }
+    watchersLock(callback) {
+        return this._watchersLock.then(() => {
+            return this._watchersLock = new Promise(async (resolve) => {
+                await callback();
+                resolve();
+            });
+        });
+    }
+    watchersRestore() {
+        delete this._watchersRestoreTimeout;
+        const watchers = Object.entries(this._watchersRestorable);
+        this._watchersRestorable = {};
+        for (const [targetPath, config] of watchers) {
+            this.watchPath(targetPath, config.options, config.handler);
+        }
+    }
+    async watcherAdd(config, baseWatcherHandler) {
+        const { folderPath } = config;
+        const configs = this._watchers[folderPath] = (this._watchers[folderPath] || []);
+        configs.push(config);
+        const watcherHandler = new WatcherHandler(this, config, baseWatcherHandler);
+        await watcherHandler.init();
+        return watcherHandler;
+    }
+    watcherClose(config) {
+        config.watcher.close();
+        const configs = this._watchers[config.folderPath];
+        if (configs) {
+            const index = configs.indexOf(config);
+            configs.splice(index, 1);
+            if (!configs.length) {
+                delete this._watchers[config.folderPath];
+            }
+        }
+        const rootPath = config.filePath || config.folderPath;
+        const isRoot = this._roots.has(rootPath);
+        if (isRoot) {
+            this._watchersRestorable[rootPath] = config;
+            if (!this._watchersRestoreTimeout) {
+                this._watchersRestoreTimeout = Utils.lang.defer(() => this.watchersRestore());
+            }
+        }
+    }
+    watcherExists(folderPath, options, handler, filePath) {
+        const configsSibling = this._watchers[folderPath];
+        if (!!configsSibling?.find(config => config.handler === handler && (!config.filePath || config.filePath === filePath) && config.options.ignore === options.ignore && !!config.options.native === !!options.native && (!options.recursive || config.options.recursive)))
+            return true;
+        let folderAncestorPath = path.dirname(folderPath);
+        for (let depth = 1; depth < Infinity; depth++) {
+            const configsAncestor = this._watchers[folderAncestorPath];
+            if (!!configsAncestor?.find(config => (depth === 1 || (config.options.recursive && depth <= (config.options.depth ?? DEPTH))) && config.handler === handler && (!config.filePath || config.filePath === filePath) && config.options.ignore === options.ignore && !!config.options.native === !!options.native && (!options.recursive || (config.options.recursive && (HAS_NATIVE_RECURSION && config.options.native !== false)))))
+                return true;
+            if (!HAS_NATIVE_RECURSION)
+                break; // No other ancestor will possibly be found
+            const folderAncestorPathNext = path.dirname(folderPath);
+            if (folderAncestorPath === folderAncestorPathNext)
+                break;
+            folderAncestorPath = folderAncestorPathNext;
+        }
+        return false;
+    }
+    async watchDirectories(foldersPaths, options, handler, filePath, baseWatcherHandler) {
+        if (this.isClosed())
+            return;
+        foldersPaths = Utils.lang.uniq(foldersPaths).sort();
+        let watcherHandlerLast;
+        for (const folderPath of foldersPaths) {
+            if (this.isIgnored(folderPath, options.ignore))
+                continue;
+            if (this.watcherExists(folderPath, options, handler, filePath))
+                continue;
+            try {
+                const watcherOptions = (!options.recursive || (HAS_NATIVE_RECURSION && options.native !== false)) ? options : { ...options, recursive: false }; // Ensuring recursion is explicitly disabled if not available
+                const watcher = fs.watch(folderPath, watcherOptions);
+                const watcherConfig = { watcher, handler, options, folderPath, filePath };
+                const watcherHandler = watcherHandlerLast = await this.watcherAdd(watcherConfig, baseWatcherHandler);
+                const isRoot = this._roots.has(filePath || folderPath);
+                if (isRoot) {
+                    const parentOptions = { ...options, ignoreInitial: true, recursive: false }; // Ensuring only the parent folder is being watched
+                    const parentFolderPath = path.dirname(folderPath);
+                    const parentFilePath = folderPath;
+                    await this.watchDirectories([parentFolderPath], parentOptions, handler, parentFilePath, watcherHandler);
+                    //TODO: Watch parents recursively with the following code, which requires other things to be changed too though
+                    // while ( true ) {
+                    //   await this.watchDirectories ( [parentFolderPath], parentOptions, handler, parentFilePath, watcherHandler );
+                    //   const parentFolderPathNext = path.dirname ( parentFolderPath );
+                    //   if ( parentFolderPath === parentFolderPathNext ) break;
+                    //   parentFilePath = parentFolderPath;
+                    //   parentFolderPath = parentFolderPathNext;
+                    // }
+                }
+            }
+            catch (error) {
+                this.error(error);
+            }
+        }
+        return watcherHandlerLast;
+    }
+    async watchDirectory(folderPath, options, handler, filePath, baseWatcherHandler) {
+        if (this.isClosed())
+            return;
+        if (this.isIgnored(folderPath, options.ignore))
+            return;
+        if (!options.recursive || (HAS_NATIVE_RECURSION && options.native !== false)) {
+            return this.watchersLock(() => {
+                return this.watchDirectories([folderPath], options, handler, filePath, baseWatcherHandler);
+            });
+        }
+        else {
+            options = { ...options, recursive: true }; // Ensuring recursion is explicitly enabled
+            const depth = options.depth ?? DEPTH;
+            const limit = options.limit ?? LIMIT;
+            const [folderSubPaths] = await Utils.fs.readdir(folderPath, options.ignore, depth, limit, this._closeSignal, options.readdirMap);
+            return this.watchersLock(async () => {
+                const watcherHandler = await this.watchDirectories([folderPath], options, handler, filePath, baseWatcherHandler);
+                if (folderSubPaths.length) {
+                    const folderPathDepth = Utils.fs.getDepth(folderPath);
+                    for (const folderSubPath of folderSubPaths) {
+                        const folderSubPathDepth = Utils.fs.getDepth(folderSubPath);
+                        const subDepth = Math.max(0, depth - (folderSubPathDepth - folderPathDepth));
+                        const subOptions = { ...options, depth: subDepth }; // Updating the maximum depth to account for depth of the sub path
+                        await this.watchDirectories([folderSubPath], subOptions, handler, filePath, baseWatcherHandler || watcherHandler);
+                    }
+                }
+            });
+        }
+    }
+    async watchFileOnce(filePath, options, callback) {
+        if (this.isClosed())
+            return;
+        options = { ...options, ignoreInitial: false }; // Ensuring initial events are detected too
+        if (this.subwatcherExists(filePath, options))
+            return;
+        const config = { targetPath: filePath, options };
+        const handler = (event, targetPath) => {
+            if (targetPath !== filePath)
+                return;
+            stop();
+            callback();
+        };
+        const watcher = new Watcher(handler);
+        const start = () => {
+            this._subwatchers.add(config);
+            this.on(WatcherEvent.CLOSE, stop); // Ensuring the subwatcher is stopped on close
+            watcher.watchFile(filePath, options, handler);
+        };
+        const stop = () => {
+            this._subwatchers.delete(config);
+            this.removeListener(WatcherEvent.CLOSE, stop); // Ensuring there are no leftover listeners
+            watcher.close();
+        };
+        return start();
+    }
+    async watchFile(filePath, options, handler) {
+        if (this.isClosed())
+            return;
+        if (this.isIgnored(filePath, options.ignore))
+            return;
+        options = { ...options, recursive: false }; // Ensuring recursion is explicitly disabled
+        const folderPath = path.dirname(filePath);
+        return this.watchDirectory(folderPath, options, handler, filePath);
+    }
+    async watchPollingOnce(targetPath, options, callback) {
+        if (this.isClosed())
+            return;
+        let isDone = false;
+        const poller = new WatcherPoller();
+        const disposer = await this.watchPolling(targetPath, options, async () => {
+            if (isDone)
+                return;
+            const events = await poller.update(targetPath, options.pollingTimeout);
+            if (!events.length)
+                return; // Nothing actually changed, skipping
+            if (isDone)
+                return; // Another async callback has done the work already, skipping
+            isDone = true;
+            disposer();
+            callback();
+        });
+    }
+    async watchPolling(targetPath, options, callback) {
+        if (this.isClosed())
+            return Utils.lang.noop;
+        if (this.pollerExists(targetPath, options))
+            return Utils.lang.noop;
+        const watcherOptions = { ...options, interval: options.pollingInterval ?? POLLING_INTERVAL }; // Ensuring a default interval is set
+        const config = { targetPath, options };
+        const start = () => {
+            this._pollers.add(config);
+            this.on(WatcherEvent.CLOSE, stop); // Ensuring polling is stopped on close
+            fs.watchFile(targetPath, watcherOptions, callback);
+        };
+        const stop = () => {
+            this._pollers.delete(config);
+            this.removeListener(WatcherEvent.CLOSE, stop); // Ensuring there are no leftover listeners
+            fs.unwatchFile(targetPath, callback);
+        };
+        Utils.lang.attempt(start);
+        return () => Utils.lang.attempt(stop);
+    }
+    async watchUnknownChild(targetPath, options, handler) {
+        if (this.isClosed())
+            return;
+        const watch = () => this.watchPath(targetPath, options, handler);
+        return this.watchFileOnce(targetPath, options, watch);
+    }
+    async watchUnknownTarget(targetPath, options, handler) {
+        if (this.isClosed())
+            return;
+        const watch = () => this.watchPath(targetPath, options, handler);
+        return this.watchPollingOnce(targetPath, options, watch);
+    }
+    async watchPaths(targetPaths, options, handler) {
+        if (this.isClosed())
+            return;
+        targetPaths = Utils.lang.uniq(targetPaths).sort();
+        const isParallelizable = targetPaths.every((targetPath, index) => targetPaths.every((t, i) => i === index || !Utils.fs.isSubPath(targetPath, t))); // All paths are about separate subtrees, so we can start watching in parallel safely //TODO: Find parallelizable chunks rather than using an all or nothing approach
+        if (isParallelizable) { // Watching in parallel
+            await Promise.all(targetPaths.map(targetPath => {
+                return this.watchPath(targetPath, options, handler);
+            }));
+        }
+        else { // Watching serially
+            for (const targetPath of targetPaths) {
+                await this.watchPath(targetPath, options, handler);
+            }
+        }
+    }
+    async watchPath(targetPath, options, handler) {
+        if (this.isClosed())
+            return;
+        targetPath = path.resolve(targetPath);
+        if (this.isIgnored(targetPath, options.ignore))
+            return;
+        const stats = await Utils.fs.poll(targetPath, options.pollingTimeout);
+        if (!stats) {
+            const parentPath = path.dirname(targetPath);
+            const parentStats = await Utils.fs.poll(parentPath, options.pollingTimeout);
+            if (parentStats?.isDirectory()) {
+                return this.watchUnknownChild(targetPath, options, handler);
+            }
+            else {
+                return this.watchUnknownTarget(targetPath, options, handler);
+            }
+        }
+        else if (stats.isFile()) {
+            return this.watchFile(targetPath, options, handler);
+        }
+        else if (stats.isDirectory()) {
+            return this.watchDirectory(targetPath, options, handler);
+        }
+        else {
+            this.error(`"${targetPath}" is not supported`);
+        }
+    }
+    async watch(target, options, handler = Utils.lang.noop) {
+        if (Utils.lang.isFunction(target))
+            return this.watch([], {}, target);
+        if (Utils.lang.isUndefined(target))
+            return this.watch([], options, handler);
+        if (Utils.lang.isFunction(options))
+            return this.watch(target, {}, options);
+        if (Utils.lang.isUndefined(options))
+            return this.watch(target, {}, handler);
+        if (this.isClosed())
+            return;
+        if (this.isReady())
+            options.readdirMap = undefined; // Only usable before initialization
+        const targetPaths = Utils.lang.castArray(target);
+        targetPaths.forEach(targetPath => this._roots.add(targetPath));
+        await this.watchPaths(targetPaths, options, handler);
+        if (this.isClosed())
+            return;
+        if (handler !== Utils.lang.noop) {
+            this.on(WatcherEvent.ALL, handler);
+        }
+        options.readdirMap = undefined; // Only usable before initialization
+        this.ready();
+    }
+}
+/* EXPORT */
+export default Watcher;

package/.output/server/node_modules/watcher/dist/watcher_handler.js

@@ -0,0 +1,248 @@
+/* IMPORT */
+import path from 'node:path';
+import { DEBOUNCE, DEPTH, LIMIT, HAS_NATIVE_RECURSION, IS_WINDOWS } from './constants.js';
+import { FSTargetEvent, FSWatcherEvent, TargetEvent } from './enums.js';
+import Utils from './utils.js';
+/* MAIN */
+class WatcherHandler {
+    /* CONSTRUCTOR */
+    constructor(watcher, config, base) {
+        this.base = base;
+        this.watcher = watcher;
+        this.handler = config.handler;
+        this.fswatcher = config.watcher;
+        this.options = config.options;
+        this.folderPath = config.folderPath;
+        this.filePath = config.filePath;
+        this.handlerBatched = this.base ? this.base.onWatcherEvent.bind(this.base) : this._makeHandlerBatched(this.options.debounce); //UGLY
+    }
+    /* HELPERS */
+    _isSubRoot(targetPath) {
+        if (this.filePath) {
+            return targetPath === this.filePath;
+        }
+        else {
+            return targetPath === this.folderPath || Utils.fs.isSubPath(this.folderPath, targetPath);
+        }
+    }
+    _makeHandlerBatched(delay = DEBOUNCE) {
+        return (() => {
+            let lock = this.watcher._readyWait; // ~Ensuring no two flushes are active in parallel, or before the watcher is ready
+            let initials = [];
+            let regulars = new Set();
+            const flush = async (initials, regulars) => {
+                const initialEvents = this.options.ignoreInitial ? [] : initials;
+                const regularEvents = await this.eventsPopulate([...regulars]);
+                const events = this.eventsDeduplicate([...initialEvents, ...regularEvents]);
+                this.onTargetEvents(events);
+            };
+            const flushDebounced = Utils.lang.debounce(() => {
+                if (this.watcher.isClosed())
+                    return;
+                lock = flush(initials, regulars);
+                initials = [];
+                regulars = new Set();
+            }, delay);
+            return async (event, targetPath = '', isInitial = false) => {
+                if (isInitial) { // Poll immediately
+                    await this.eventsPopulate([targetPath], initials, true);
+                }
+                else { // Poll later
+                    regulars.add(targetPath);
+                }
+                lock.then(flushDebounced);
+            };
+        })();
+    }
+    /* EVENT HELPERS */
+    eventsDeduplicate(events) {
+        if (events.length < 2)
+            return events;
+        const targetsEventPrev = {};
+        return events.reduce((acc, event) => {
+            const [targetEvent, targetPath] = event;
+            const targetEventPrev = targetsEventPrev[targetPath];
+            if (targetEvent === targetEventPrev)
+                return acc; // Same event, ignoring
+            if (targetEvent === TargetEvent.CHANGE && targetEventPrev === TargetEvent.ADD)
+                return acc; // "change" after "add", ignoring
+            targetsEventPrev[targetPath] = targetEvent;
+            acc.push(event);
+            return acc;
+        }, []);
+    }
+    async eventsPopulate(targetPaths, events = [], isInitial = false) {
+        await Promise.all(targetPaths.map(async (targetPath) => {
+            const targetEvents = await this.watcher._poller.update(targetPath, this.options.pollingTimeout);
+            await Promise.all(targetEvents.map(async (event) => {
+                events.push([event, targetPath]);
+                if (event === TargetEvent.ADD_DIR) {
+                    await this.eventsPopulateAddDir(targetPaths, targetPath, events, isInitial);
+                }
+                else if (event === TargetEvent.UNLINK_DIR) {
+                    await this.eventsPopulateUnlinkDir(targetPaths, targetPath, events, isInitial);
+                }
+            }));
+        }));
+        return events;
+    }
+    ;
+    async eventsPopulateAddDir(targetPaths, targetPath, events = [], isInitial = false) {
+        if (isInitial)
+            return events;
+        const depth = this.options.recursive ? this.options.depth ?? DEPTH : Math.min(1, this.options.depth ?? DEPTH);
+        const limit = this.options.limit ?? LIMIT;
+        const [directories, files] = await Utils.fs.readdir(targetPath, this.options.ignore, depth, limit, this.watcher._closeSignal);
+        const targetSubPaths = [...directories, ...files];
+        await Promise.all(targetSubPaths.map(targetSubPath => {
+            if (this.watcher.isIgnored(targetSubPath, this.options.ignore))
+                return;
+            if (targetPaths.includes(targetSubPath))
+                return;
+            return this.eventsPopulate([targetSubPath], events, true);
+        }));
+        return events;
+    }
+    async eventsPopulateUnlinkDir(targetPaths, targetPath, events = [], isInitial = false) {
+        if (isInitial)
+            return events;
+        for (const folderPathOther of this.watcher._poller.stats.keys()) {
+            if (!Utils.fs.isSubPath(targetPath, folderPathOther))
+                continue;
+            if (targetPaths.includes(folderPathOther))
+                continue;
+            await this.eventsPopulate([folderPathOther], events, true);
+        }
+        return events;
+    }
+    /* EVENT HANDLERS */
+    onTargetAdd(targetPath) {
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetAdd(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.ADD, targetPath);
+            }
+        }
+    }
+    onTargetAddDir(targetPath) {
+        if (targetPath !== this.folderPath && this.options.recursive && (!HAS_NATIVE_RECURSION && this.options.native !== false)) {
+            this.watcher.watchDirectory(targetPath, this.options, this.handler, undefined, this.base || this);
+        }
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetAddDir(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.ADD_DIR, targetPath);
+            }
+        }
+    }
+    onTargetChange(targetPath) {
+        if (this._isSubRoot(targetPath)) {
+            this.watcher.event(TargetEvent.CHANGE, targetPath);
+        }
+    }
+    onTargetUnlink(targetPath) {
+        this.watcher.watchersClose(path.dirname(targetPath), targetPath, false);
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetUnlink(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.UNLINK, targetPath);
+            }
+        }
+    }
+    onTargetUnlinkDir(targetPath) {
+        this.watcher.watchersClose(path.dirname(targetPath), targetPath, false);
+        this.watcher.watchersClose(targetPath);
+        if (this._isSubRoot(targetPath)) {
+            if (this.options.renameDetection) {
+                this.watcher._locker.getLockTargetUnlinkDir(targetPath, this.options.renameTimeout);
+            }
+            else {
+                this.watcher.event(TargetEvent.UNLINK_DIR, targetPath);
+            }
+        }
+    }
+    onTargetEvent(event) {
+        const [targetEvent, targetPath] = event;
+        if (targetEvent === TargetEvent.ADD) {
+            this.onTargetAdd(targetPath);
+        }
+        else if (targetEvent === TargetEvent.ADD_DIR) {
+            this.onTargetAddDir(targetPath);
+        }
+        else if (targetEvent === TargetEvent.CHANGE) {
+            this.onTargetChange(targetPath);
+        }
+        else if (targetEvent === TargetEvent.UNLINK) {
+            this.onTargetUnlink(targetPath);
+        }
+        else if (targetEvent === TargetEvent.UNLINK_DIR) {
+            this.onTargetUnlinkDir(targetPath);
+        }
+    }
+    onTargetEvents(events) {
+        for (const event of events) {
+            this.onTargetEvent(event);
+        }
+    }
+    onWatcherEvent(event, targetPath, isInitial = false) {
+        return this.handlerBatched(event, targetPath, isInitial);
+    }
+    onWatcherChange(event = FSTargetEvent.CHANGE, targetName) {
+        if (this.watcher.isClosed())
+            return;
+        const targetPath = path.resolve(this.folderPath, targetName || '');
+        if (this.filePath && targetPath !== this.folderPath && targetPath !== this.filePath)
+            return;
+        if (this.watcher.isIgnored(targetPath, this.options.ignore))
+            return;
+        this.onWatcherEvent(event, targetPath);
+    }
+    onWatcherError(error) {
+        if (IS_WINDOWS && error.code === 'EPERM') { // This may happen when a folder is deleted
+            this.onWatcherChange(FSTargetEvent.CHANGE, '');
+        }
+        else {
+            this.watcher.error(error);
+        }
+    }
+    /* API */
+    async init() {
+        await this.initWatcherEvents();
+        await this.initInitialEvents();
+    }
+    async initWatcherEvents() {
+        const onChange = this.onWatcherChange.bind(this);
+        this.fswatcher.on(FSWatcherEvent.CHANGE, onChange);
+        const onError = this.onWatcherError.bind(this);
+        this.fswatcher.on(FSWatcherEvent.ERROR, onError);
+    }
+    async initInitialEvents() {
+        const isInitial = !this.watcher.isReady(); // "isInitial" => is ignorable via the "ignoreInitial" option
+        if (this.filePath) { // Single initial path
+            if (this.watcher._poller.stats.has(this.filePath))
+                return; // Already polled
+            await this.onWatcherEvent(FSTargetEvent.CHANGE, this.filePath, isInitial);
+        }
+        else { // Multiple initial paths
+            const depth = this.options.recursive && (HAS_NATIVE_RECURSION && this.options.native !== false) ? this.options.depth ?? DEPTH : Math.min(1, this.options.depth ?? DEPTH);
+            const limit = this.options.limit ?? LIMIT;
+            const [directories, files] = await Utils.fs.readdir(this.folderPath, this.options.ignore, depth, limit, this.watcher._closeSignal, this.options.readdirMap);
+            const targetPaths = [this.folderPath, ...directories, ...files];
+            await Promise.all(targetPaths.map(targetPath => {
+                if (this.watcher._poller.stats.has(targetPath))
+                    return; // Already polled
+                if (this.watcher.isIgnored(targetPath, this.options.ignore))
+                    return;
+                return this.onWatcherEvent(FSTargetEvent.CHANGE, targetPath, isInitial);
+            }));
+        }
+    }
+}
+/* EXPORT */
+export default WatcherHandler;