run npm install to generate a package lock

node_modules/watcher/dist/watcher_locker.js

@@ -0,0 +1,139 @@
+/* IMPORT */
+import { RENAME_TIMEOUT } from './constants.js';
+import { FileType, TargetEvent } from './enums.js';
+import Utils from './utils.js';
+import WatcherLocksResolver from './watcher_locks_resolver.js';
+/* MAIN */
+//TODO: Use a better name for this thing, maybe "RenameDetector"
+class WatcherLocker {
+    /* CONSTRUCTOR */
+    constructor(watcher) {
+        this._watcher = watcher;
+        this.reset();
+    }
+    /* API */
+    getLockAdd(config, timeout = RENAME_TIMEOUT) {
+        const { ino, targetPath, events, locks } = config;
+        const emit = () => {
+            const otherPath = this._watcher._poller.paths.find(ino || -1, path => path !== targetPath); // Maybe this is actually a rename in a case-insensitive filesystem
+            if (otherPath && otherPath !== targetPath) {
+                if (Utils.fs.getRealPath(targetPath, true) === otherPath)
+                    return; //TODO: This seems a little too special-casey
+                this._watcher.event(events.rename, otherPath, targetPath);
+            }
+            else {
+                this._watcher.event(events.add, targetPath);
+            }
+        };
+        if (!ino)
+            return emit();
+        const cleanup = () => {
+            locks.add.delete(ino);
+            WatcherLocksResolver.remove(free);
+        };
+        const free = () => {
+            cleanup();
+            emit();
+        };
+        WatcherLocksResolver.add(free, timeout);
+        const resolve = () => {
+            const unlink = locks.unlink.get(ino);
+            if (!unlink)
+                return; // No matching "unlink" lock found, skipping
+            cleanup();
+            const targetPathPrev = unlink();
+            if (targetPath === targetPathPrev) {
+                if (events.change) {
+                    if (this._watcher._poller.stats.has(targetPath)) {
+                        this._watcher.event(events.change, targetPath);
+                    }
+                }
+            }
+            else {
+                this._watcher.event(events.rename, targetPathPrev, targetPath);
+            }
+        };
+        locks.add.set(ino, resolve);
+        resolve();
+    }
+    getLockUnlink(config, timeout = RENAME_TIMEOUT) {
+        const { ino, targetPath, events, locks } = config;
+        const emit = () => {
+            this._watcher.event(events.unlink, targetPath);
+        };
+        if (!ino)
+            return emit();
+        const cleanup = () => {
+            locks.unlink.delete(ino);
+            WatcherLocksResolver.remove(free);
+        };
+        const free = () => {
+            cleanup();
+            emit();
+        };
+        WatcherLocksResolver.add(free, timeout);
+        const overridden = () => {
+            cleanup();
+            return targetPath;
+        };
+        locks.unlink.set(ino, overridden);
+        locks.add.get(ino)?.();
+    }
+    getLockTargetAdd(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.ADD, FileType.FILE);
+        return this.getLockAdd({
+            ino,
+            targetPath,
+            events: WatcherLocker.FILE_EVENTS,
+            locks: this._locksFile
+        }, timeout);
+    }
+    getLockTargetAddDir(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.ADD_DIR, FileType.DIR);
+        return this.getLockAdd({
+            ino,
+            targetPath,
+            events: WatcherLocker.DIR_EVENTS,
+            locks: this._locksDir
+        }, timeout);
+    }
+    getLockTargetUnlink(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.UNLINK, FileType.FILE);
+        return this.getLockUnlink({
+            ino,
+            targetPath,
+            events: WatcherLocker.FILE_EVENTS,
+            locks: this._locksFile
+        }, timeout);
+    }
+    getLockTargetUnlinkDir(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.UNLINK_DIR, FileType.DIR);
+        return this.getLockUnlink({
+            ino,
+            targetPath,
+            events: WatcherLocker.DIR_EVENTS,
+            locks: this._locksDir
+        }, timeout);
+    }
+    reset() {
+        this._locksAdd = new Map();
+        this._locksAddDir = new Map();
+        this._locksUnlink = new Map();
+        this._locksUnlinkDir = new Map();
+        this._locksDir = { add: this._locksAddDir, unlink: this._locksUnlinkDir };
+        this._locksFile = { add: this._locksAdd, unlink: this._locksUnlink };
+    }
+}
+WatcherLocker.DIR_EVENTS = {
+    add: TargetEvent.ADD_DIR,
+    rename: TargetEvent.RENAME_DIR,
+    unlink: TargetEvent.UNLINK_DIR
+};
+WatcherLocker.FILE_EVENTS = {
+    add: TargetEvent.ADD,
+    change: TargetEvent.CHANGE,
+    rename: TargetEvent.RENAME,
+    unlink: TargetEvent.UNLINK
+};
+/* EXPORT */
+export default WatcherLocker;