update

dist_ts/constants.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" resolution-mode="require"/>
+declare const DEBOUNCE = 300;
+declare const DEPTH = 20;
+declare const LIMIT = 10000000;
+declare const PLATFORM: NodeJS.Platform;
+declare const IS_LINUX: boolean;
+declare const IS_MAC: boolean;
+declare const IS_WINDOWS: boolean;
+declare const HAS_NATIVE_RECURSION: boolean;
+declare const POLLING_INTERVAL = 3000;
+declare const POLLING_TIMEOUT = 20000;
+declare const RENAME_TIMEOUT = 1250;
+export { DEBOUNCE, DEPTH, LIMIT, HAS_NATIVE_RECURSION, IS_LINUX, IS_MAC, IS_WINDOWS, PLATFORM, POLLING_INTERVAL, POLLING_TIMEOUT, RENAME_TIMEOUT };

dist_ts/constants.js

@@ -0,0 +1,17 @@
+/* IMPORT */
+import os from 'node:os';
+/* MAIN */
+const DEBOUNCE = 300;
+const DEPTH = 20;
+const LIMIT = 10_000_000;
+const PLATFORM = os.platform();
+const IS_LINUX = (PLATFORM === 'linux');
+const IS_MAC = (PLATFORM === 'darwin');
+const IS_WINDOWS = (PLATFORM === 'win32');
+const HAS_NATIVE_RECURSION = IS_MAC || IS_WINDOWS;
+const POLLING_INTERVAL = 3000;
+const POLLING_TIMEOUT = 20000;
+const RENAME_TIMEOUT = 1250;
+/* EXPORT */
+export { DEBOUNCE, DEPTH, LIMIT, HAS_NATIVE_RECURSION, IS_LINUX, IS_MAC, IS_WINDOWS, PLATFORM, POLLING_INTERVAL, POLLING_TIMEOUT, RENAME_TIMEOUT };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLFlBQVk7QUFFWixPQUFPLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFekIsVUFBVTtBQUVWLE1BQU0sUUFBUSxHQUFHLEdBQUcsQ0FBQztBQUVyQixNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7QUFFakIsTUFBTSxLQUFLLEdBQUcsVUFBVSxDQUFDO0FBRXpCLE1BQU0sUUFBUSxHQUFHLEVBQUUsQ0FBQyxRQUFRLEVBQUcsQ0FBQztBQUVoQyxNQUFNLFFBQVEsR0FBRyxDQUFFLFFBQVEsS0FBSyxPQUFPLENBQUUsQ0FBQztBQUUxQyxNQUFNLE1BQU0sR0FBRyxDQUFFLFFBQVEsS0FBSyxRQUFRLENBQUUsQ0FBQztBQUV6QyxNQUFNLFVBQVUsR0FBRyxDQUFFLFFBQVEsS0FBSyxPQUFPLENBQUUsQ0FBQztBQUU1QyxNQUFNLG9CQUFvQixHQUFHLE1BQU0sSUFBSSxVQUFVLENBQUM7QUFFbEQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUM7QUFFOUIsTUFBTSxlQUFlLEdBQUcsS0FBSyxDQUFDO0FBRTlCLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQztBQUU1QixZQUFZO0FBRVosT0FBTyxFQUFDLFFBQVEsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLG9CQUFvQixFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFDLENBQUMifQ==

dist_ts/dettle/debounce.d.ts

@@ -0,0 +1,7 @@
+import type { FN, Debounced } from './types.js';
+declare const debounce: <Args extends unknown[]>(fn: FN<Args, unknown>, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}) => Debounced<Args>;
+export default debounce;

dist_ts/dettle/debounce.js

@@ -0,0 +1,92 @@
+/* IMPORT */
+/* MAIN */
+const debounce = (fn, wait = 1, options) => {
+    /* VARIABLES */
+    wait = Math.max(1, wait);
+    const leading = options?.leading ?? false;
+    const trailing = options?.trailing ?? true;
+    const maxWait = Math.max(options?.maxWait ?? Infinity, wait);
+    let args;
+    let timeout;
+    let timestampCall = 0;
+    let timestampInvoke = 0;
+    /* HELPERS */
+    const getInstantData = () => {
+        const timestamp = Date.now();
+        const elapsedCall = timestamp - timestampCall;
+        const elapsedInvoke = timestamp - timestampInvoke;
+        const isInvoke = (elapsedCall >= wait || elapsedInvoke >= maxWait);
+        return [timestamp, isInvoke];
+    };
+    const invoke = (timestamp) => {
+        timestampInvoke = timestamp;
+        if (!args)
+            return; // This should never happen
+        const _args = args;
+        args = undefined;
+        fn.apply(undefined, _args);
+    };
+    const onCancel = () => {
+        resetTimeout(0);
+    };
+    const onFlush = () => {
+        if (!timeout)
+            return;
+        onCancel();
+        invoke(Date.now());
+    };
+    const onLeading = (timestamp) => {
+        timestampInvoke = timestamp;
+        if (leading)
+            return invoke(timestamp);
+    };
+    const onTrailing = (timestamp) => {
+        if (trailing && args)
+            return invoke(timestamp);
+        args = undefined;
+    };
+    const onTimeout = () => {
+        timeout = undefined;
+        const [timestamp, isInvoking] = getInstantData();
+        if (isInvoking)
+            return onTrailing(timestamp);
+        return updateTimeout(timestamp);
+    };
+    const updateTimeout = (timestamp) => {
+        const elapsedCall = timestamp - timestampCall;
+        const elapsedInvoke = timestamp - timestampInvoke;
+        const remainingCall = wait - elapsedCall;
+        const remainingInvoke = maxWait - elapsedInvoke;
+        const ms = Math.min(remainingCall, remainingInvoke);
+        return resetTimeout(ms);
+    };
+    const resetTimeout = (ms) => {
+        if (timeout)
+            clearTimeout(timeout);
+        if (ms <= 0)
+            return;
+        timeout = setTimeout(onTimeout, ms);
+    };
+    /* DEBOUNCED */
+    const debounced = (...argsLatest) => {
+        const [timestamp, isInvoking] = getInstantData();
+        const hadTimeout = !!timeout;
+        args = argsLatest;
+        timestampCall = timestamp;
+        if (isInvoking || !timeout)
+            resetTimeout(wait);
+        if (isInvoking) {
+            if (!hadTimeout)
+                return onLeading(timestamp);
+            return invoke(timestamp);
+        }
+    };
+    /* DEBOUNCED UTILITIES */
+    debounced.cancel = onCancel;
+    debounced.flush = onFlush;
+    /* RETURN */
+    return debounced;
+};
+/* EXPORT */
+export default debounce;
+//# sourceMappingURL=data:application/json;base64,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

dist_ts/dettle/index.d.ts

@@ -0,0 +1,3 @@
+import debounce from './debounce.js';
+import throttle from './throttle.js';
+export { debounce, throttle };

dist_ts/dettle/index.js

@@ -0,0 +1,6 @@
+/* IMPORT */
+import debounce from './debounce.js';
+import throttle from './throttle.js';
+/* EXPORT */
+export { debounce, throttle };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kZXR0bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsWUFBWTtBQUVaLE9BQU8sUUFBUSxNQUFNLGVBQWUsQ0FBQztBQUNyQyxPQUFPLFFBQVEsTUFBTSxlQUFlLENBQUM7QUFFckMsWUFBWTtBQUVaLE9BQU8sRUFBQyxRQUFRLEVBQUUsUUFBUSxFQUFDLENBQUMifQ==

dist_ts/dettle/throttle.d.ts

@@ -0,0 +1,6 @@
+import type { FN, Throttled } from './types.js';
+declare const throttle: <Args extends unknown[]>(fn: FN<Args, unknown>, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}) => Throttled<Args>;
+export default throttle;

dist_ts/dettle/throttle.js

@@ -0,0 +1,13 @@
+/* IMPORT */
+import debounce from './debounce.js';
+/* MAIN */
+const throttle = (fn, wait = 1, options) => {
+    return debounce(fn, wait, {
+        maxWait: wait,
+        leading: options?.leading ?? true,
+        trailing: options?.trailing ?? true
+    });
+};
+/* EXPORT */
+export default throttle;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhyb3R0bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kZXR0bGUvdGhyb3R0bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsWUFBWTtBQUVaLE9BQU8sUUFBUSxNQUFNLGVBQWUsQ0FBQztBQUdyQyxVQUFVO0FBRVYsTUFBTSxRQUFRLEdBQUcsQ0FBMkIsRUFBcUIsRUFBRSxPQUFlLENBQUMsRUFBRSxPQUFtRCxFQUFvQixFQUFFO0lBRTVKLE9BQU8sUUFBUSxDQUFHLEVBQUUsRUFBRSxJQUFJLEVBQUU7UUFDMUIsT0FBTyxFQUFFLElBQUk7UUFDYixPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sSUFBSSxJQUFJO1FBQ2pDLFFBQVEsRUFBRSxPQUFPLEVBQUUsUUFBUSxJQUFJLElBQUk7S0FDcEMsQ0FBQyxDQUFDO0FBRUwsQ0FBQyxDQUFDO0FBRUYsWUFBWTtBQUVaLGVBQWUsUUFBUSxDQUFDIn0=

dist_ts/dettle/types.d.ts

@@ -0,0 +1,11 @@
+type Callback = () => void;
+type FN<Args extends unknown[], Return> = (...args: Args) => Return;
+type Debounced<Args extends unknown[]> = FN<Args, void> & {
+    cancel: Callback;
+    flush: Callback;
+};
+type Throttled<Args extends unknown[]> = FN<Args, void> & {
+    cancel: Callback;
+    flush: Callback;
+};
+export type { Callback, FN, Debounced, Throttled };

dist_ts/dettle/types.js

@@ -0,0 +1,3 @@
+/* MAIN */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kZXR0bGUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsVUFBVSJ9

dist_ts/enums.d.ts

@@ -0,0 +1,28 @@
+declare const enum FileType {
+    DIR = 1,
+    FILE = 2
+}
+declare const enum FSTargetEvent {
+    CHANGE = "change",
+    RENAME = "rename"
+}
+declare const enum FSWatcherEvent {
+    CHANGE = "change",
+    ERROR = "error"
+}
+declare const enum TargetEvent {
+    ADD = "add",
+    ADD_DIR = "addDir",
+    CHANGE = "change",
+    RENAME = "rename",
+    RENAME_DIR = "renameDir",
+    UNLINK = "unlink",
+    UNLINK_DIR = "unlinkDir"
+}
+declare const enum WatcherEvent {
+    ALL = "all",
+    CLOSE = "close",
+    ERROR = "error",
+    READY = "ready"
+}
+export { FileType, FSTargetEvent, FSWatcherEvent, TargetEvent, WatcherEvent };

dist_ts/enums.js

@@ -0,0 +1,36 @@
+/* MAIN */
+var FileType;
+(function (FileType) {
+    FileType[FileType["DIR"] = 1] = "DIR";
+    FileType[FileType["FILE"] = 2] = "FILE";
+})(FileType || (FileType = {}));
+var FSTargetEvent;
+(function (FSTargetEvent) {
+    FSTargetEvent["CHANGE"] = "change";
+    FSTargetEvent["RENAME"] = "rename";
+})(FSTargetEvent || (FSTargetEvent = {}));
+var FSWatcherEvent;
+(function (FSWatcherEvent) {
+    FSWatcherEvent["CHANGE"] = "change";
+    FSWatcherEvent["ERROR"] = "error";
+})(FSWatcherEvent || (FSWatcherEvent = {}));
+var TargetEvent;
+(function (TargetEvent) {
+    TargetEvent["ADD"] = "add";
+    TargetEvent["ADD_DIR"] = "addDir";
+    TargetEvent["CHANGE"] = "change";
+    TargetEvent["RENAME"] = "rename";
+    TargetEvent["RENAME_DIR"] = "renameDir";
+    TargetEvent["UNLINK"] = "unlink";
+    TargetEvent["UNLINK_DIR"] = "unlinkDir";
+})(TargetEvent || (TargetEvent = {}));
+var WatcherEvent;
+(function (WatcherEvent) {
+    WatcherEvent["ALL"] = "all";
+    WatcherEvent["CLOSE"] = "close";
+    WatcherEvent["ERROR"] = "error";
+    WatcherEvent["READY"] = "ready";
+})(WatcherEvent || (WatcherEvent = {}));
+/* EXPORT */
+export { FileType, FSTargetEvent, FSWatcherEvent, TargetEvent, WatcherEvent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9lbnVtcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxVQUFVO0FBRVYsSUFBVyxRQUdWO0FBSEQsV0FBVyxRQUFRO0lBQ2pCLHFDQUFPLENBQUE7SUFDUCx1Q0FBUSxDQUFBO0FBQ1YsQ0FBQyxFQUhVLFFBQVEsS0FBUixRQUFRLFFBR2xCO0FBRUQsSUFBVyxhQUdWO0FBSEQsV0FBVyxhQUFhO0lBQ3RCLGtDQUFpQixDQUFBO0lBQ2pCLGtDQUFpQixDQUFBO0FBQ25CLENBQUMsRUFIVSxhQUFhLEtBQWIsYUFBYSxRQUd2QjtBQUVELElBQVcsY0FHVjtBQUhELFdBQVcsY0FBYztJQUN2QixtQ0FBaUIsQ0FBQTtJQUNqQixpQ0FBZSxDQUFBO0FBQ2pCLENBQUMsRUFIVSxjQUFjLEtBQWQsY0FBYyxRQUd4QjtBQUVELElBQVcsV0FRVjtBQVJELFdBQVcsV0FBVztJQUNwQiwwQkFBVyxDQUFBO0lBQ1gsaUNBQWtCLENBQUE7SUFDbEIsZ0NBQWlCLENBQUE7SUFDakIsZ0NBQWlCLENBQUE7SUFDakIsdUNBQXdCLENBQUE7SUFDeEIsZ0NBQWlCLENBQUE7SUFDakIsdUNBQXdCLENBQUE7QUFDMUIsQ0FBQyxFQVJVLFdBQVcsS0FBWCxXQUFXLFFBUXJCO0FBRUQsSUFBVyxZQUtWO0FBTEQsV0FBVyxZQUFZO0lBQ3JCLDJCQUFXLENBQUE7SUFDWCwrQkFBZSxDQUFBO0lBQ2YsK0JBQWUsQ0FBQTtJQUNmLCtCQUFlLENBQUE7QUFDakIsQ0FBQyxFQUxVLFlBQVksS0FBWixZQUFZLFFBS3RCO0FBRUQsWUFBWTtBQUVaLE9BQU8sRUFBQyxRQUFRLEVBQUUsYUFBYSxFQUFFLGNBQWMsRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFDLENBQUMifQ==

dist_ts/lazy_map_set.d.ts

@@ -0,0 +1,10 @@
+declare class LazyMapSet<K, V> {
+    private map;
+    clear(): void;
+    delete(key: K, value?: V): boolean;
+    find(key: K, iterator: (value: V) => boolean): V | undefined;
+    get(key: K): Set<V> | V | undefined;
+    has(key: K, value?: V): boolean;
+    set(key: K, value: V): this;
+}
+export default LazyMapSet;

dist_ts/lazy_map_set.js

@@ -0,0 +1,82 @@
+/* IMPORT */
+import Utils from './utils.js';
+/* MAIN */
+//TODO: Maybe publish this as a standalone module
+class LazyMapSet {
+    constructor() {
+        /* VARIABLES */
+        this.map = new Map();
+    }
+    /* API */
+    clear() {
+        this.map.clear();
+    }
+    delete(key, value) {
+        if (Utils.lang.isUndefined(value)) {
+            return this.map.delete(key);
+        }
+        else if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                const deleted = values.delete(value);
+                if (!values.size) {
+                    this.map.delete(key);
+                }
+                return deleted;
+            }
+            else if (values === value) {
+                this.map.delete(key);
+                return true;
+            }
+        }
+        return false;
+    }
+    find(key, iterator) {
+        if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                return Array.from(values).find(iterator);
+            }
+            else if (iterator(values)) { //TSC
+                return values;
+            }
+        }
+        return undefined;
+    }
+    get(key) {
+        return this.map.get(key);
+    }
+    has(key, value) {
+        if (Utils.lang.isUndefined(value)) {
+            return this.map.has(key);
+        }
+        else if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                return values.has(value);
+            }
+            else {
+                return (values === value);
+            }
+        }
+        return false;
+    }
+    set(key, value) {
+        if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                values.add(value);
+            }
+            else if (values !== value) {
+                this.map.set(key, new Set([values, value])); //TSC
+            }
+        }
+        else {
+            this.map.set(key, value);
+        }
+        return this;
+    }
+}
+/* EXPORT */
+export default LazyMapSet;
+//# sourceMappingURL=data:application/json;base64,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

dist_ts/promise-make-naked/constants.d.ts

@@ -0,0 +1,2 @@
+declare const NOOP: () => void;
+export { NOOP };

dist_ts/promise-make-naked/constants.js

@@ -0,0 +1,5 @@
+/* MAIN */
+const NOOP = () => { };
+/* EXPORT */
+export { NOOP };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvcHJvbWlzZS1tYWtlLW5ha2VkL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxVQUFVO0FBRVYsTUFBTSxJQUFJLEdBQUcsR0FBUyxFQUFFLEdBQUUsQ0FBQyxDQUFDO0FBRTVCLFlBQVk7QUFFWixPQUFPLEVBQUMsSUFBSSxFQUFDLENBQUMifQ==

dist_ts/promise-make-naked/index.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from './types.js';
+declare const makeNakedPromise: {
+    <T>(): Result<T>;
+    wrap<T_1>(fn: (result: Result<T_1>) => void): Promise<T_1>;
+};
+export default makeNakedPromise;

dist_ts/promise-make-naked/index.js

@@ -0,0 +1,32 @@
+/* IMPORT */
+import { NOOP } from './constants.js';
+/* MAIN */
+const makeNakedPromise = () => {
+    let resolve = NOOP;
+    let reject = NOOP;
+    let resolved = false;
+    let rejected = false;
+    const promise = new Promise((res, rej) => {
+        resolve = value => {
+            resolved = true;
+            return res(value);
+        };
+        reject = value => {
+            rejected = true;
+            return rej(value);
+        };
+    });
+    const isPending = () => !resolved && !rejected;
+    const isResolved = () => resolved;
+    const isRejected = () => rejected;
+    return { promise, resolve, reject, isPending, isResolved, isRejected };
+};
+/* UTILITIES */
+makeNakedPromise.wrap = async (fn) => {
+    const result = makeNakedPromise();
+    await fn(result);
+    return result.promise;
+};
+/* EXPORT */
+export default makeNakedPromise;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wcm9taXNlLW1ha2UtbmFrZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsWUFBWTtBQUVaLE9BQU8sRUFBQyxJQUFJLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUdwQyxVQUFVO0FBRVYsTUFBTSxnQkFBZ0IsR0FBRyxHQUFrQixFQUFFO0lBRTNDLElBQUksT0FBTyxHQUFzQixJQUFJLENBQUM7SUFDdEMsSUFBSSxNQUFNLEdBQWtCLElBQUksQ0FBQztJQUVqQyxJQUFJLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFDckIsSUFBSSxRQUFRLEdBQUcsS0FBSyxDQUFDO0lBRXJCLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFNLENBQUUsR0FBRyxFQUFFLEdBQUcsRUFBUyxFQUFFO1FBRXBELE9BQU8sR0FBRyxLQUFLLENBQUMsRUFBRTtZQUNoQixRQUFRLEdBQUcsSUFBSSxDQUFDO1lBQ2hCLE9BQU8sR0FBRyxDQUFHLEtBQUssQ0FBRSxDQUFDO1FBQ3ZCLENBQUMsQ0FBQztRQUVGLE1BQU0sR0FBRyxLQUFLLENBQUMsRUFBRTtZQUNmLFFBQVEsR0FBRyxJQUFJLENBQUM7WUFDaEIsT0FBTyxHQUFHLENBQUcsS0FBSyxDQUFFLENBQUM7UUFDdkIsQ0FBQyxDQUFDO0lBRUosQ0FBQyxDQUFDLENBQUM7SUFFSCxNQUFNLFNBQVMsR0FBRyxHQUFZLEVBQUUsQ0FBQyxDQUFDLFFBQVEsSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN4RCxNQUFNLFVBQVUsR0FBRyxHQUFZLEVBQUUsQ0FBQyxRQUFRLENBQUM7SUFDM0MsTUFBTSxVQUFVLEdBQUcsR0FBWSxFQUFFLENBQUMsUUFBUSxDQUFDO0lBRTNDLE9BQU8sRUFBQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFVBQVUsRUFBQyxDQUFDO0FBRXZFLENBQUMsQ0FBQztBQUVGLGVBQWU7QUFFZixnQkFBZ0IsQ0FBQyxJQUFJLEdBQUcsS0FBSyxFQUFPLEVBQWlDLEVBQWUsRUFBRTtJQUVwRixNQUFNLE1BQU0sR0FBRyxnQkFBZ0IsRUFBTSxDQUFDO0lBRXRDLE1BQU0sRUFBRSxDQUFHLE1BQU0sQ0FBRSxDQUFDO0lBRXBCLE9BQU8sTUFBTSxDQUFDLE9BQU8sQ0FBQztBQUV4QixDQUFDLENBQUM7QUFFRixZQUFZO0FBRVosZUFBZSxnQkFBZ0IsQ0FBQyJ9

dist_ts/promise-make-naked/types.d.ts

@@ -0,0 +1,11 @@
+type PromiseResolve<T> = (value: T | PromiseLike<T>) => void;
+type PromiseReject = (reason?: unknown) => void;
+type Result<T> = {
+    promise: Promise<T>;
+    resolve: PromiseResolve<T>;
+    reject: PromiseReject;
+    isPending: () => boolean;
+    isResolved: () => boolean;
+    isRejected: () => boolean;
+};
+export type { PromiseResolve, PromiseReject, Result };

dist_ts/promise-make-naked/types.js

@@ -0,0 +1,3 @@
+/* MAIN */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wcm9taXNlLW1ha2UtbmFrZWQvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsVUFBVSJ9

dist_ts/tiny-readdir/index.d.ts

@@ -0,0 +1,3 @@
+import type { Options, Result } from './types.js';
+declare const readdir: (rootPath: string, options?: Options) => Promise<Result>;
+export default readdir;

dist_ts/tiny-readdir/types.d.ts

@@ -0,0 +1,28 @@
+type Callback = () => void;
+type Options = {
+    depth?: number;
+    limit?: number;
+    followSymlinks?: boolean;
+    ignore?: ((targetPath: string) => boolean) | RegExp;
+    signal?: {
+        aborted: boolean;
+    };
+};
+type ResultDirectory = {
+    directories: string[];
+    directoriesNames: Set<string>;
+    directoriesNamesToPaths: Record<string, string[]>;
+    files: string[];
+    filesNames: Set<string>;
+    filesNamesToPaths: Record<string, string[]>;
+    symlinks: string[];
+    symlinksNames: Set<string>;
+    symlinksNamesToPaths: Record<string, string[]>;
+};
+type ResultDirectories = {
+    [path: string]: ResultDirectory;
+};
+type Result = ResultDirectory & {
+    map: ResultDirectories;
+};
+export type { Callback, Options, ResultDirectory, ResultDirectories, Result };

dist_ts/tiny-readdir/types.js

@@ -0,0 +1,3 @@
+/* HELPERS */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90aW55LXJlYWRkaXIvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsYUFBYSJ9

dist_ts/tiny-readdir/utils.d.ts

@@ -0,0 +1,8 @@
+import type { Callback } from './types.js';
+declare const isFunction: (value: unknown) => value is Function;
+declare const makeCounterPromise: () => {
+    promise: Promise<void>;
+    increment: Callback;
+    decrement: Callback;
+};
+export { isFunction, makeCounterPromise };

dist_ts/tiny-readdir/utils.js

@@ -0,0 +1,23 @@
+/* IMPORT */
+import makeNakedPromise from '../promise-make-naked/index.js';
+/* MAIN */
+const isFunction = (value) => {
+    return (typeof value === 'function');
+};
+const makeCounterPromise = () => {
+    const { promise, resolve } = makeNakedPromise();
+    let counter = 0;
+    const increment = () => {
+        counter += 1;
+    };
+    const decrement = () => {
+        counter -= 1;
+        if (counter)
+            return;
+        resolve();
+    };
+    return { promise, increment, decrement };
+};
+/* EXPORT */
+export { isFunction, makeCounterPromise };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90aW55LXJlYWRkaXIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsWUFBWTtBQUVaLE9BQU8sZ0JBQWdCLE1BQU0sZ0NBQWdDLENBQUM7QUFHOUQsVUFBVTtBQUVWLE1BQU0sVUFBVSxHQUFHLENBQUUsS0FBYyxFQUFzQixFQUFFO0lBRXpELE9BQU8sQ0FBRSxPQUFPLEtBQUssS0FBSyxVQUFVLENBQUUsQ0FBQztBQUV6QyxDQUFDLENBQUM7QUFFRixNQUFNLGtCQUFrQixHQUFHLEdBQXlFLEVBQUU7SUFFcEcsTUFBTSxFQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUMsR0FBRyxnQkFBZ0IsRUFBUyxDQUFDO0lBRXJELElBQUksT0FBTyxHQUFHLENBQUMsQ0FBQztJQUVoQixNQUFNLFNBQVMsR0FBRyxHQUFTLEVBQUU7UUFFM0IsT0FBTyxJQUFJLENBQUMsQ0FBQztJQUVmLENBQUMsQ0FBQztJQUVGLE1BQU0sU0FBUyxHQUFHLEdBQVMsRUFBRTtRQUUzQixPQUFPLElBQUksQ0FBQyxDQUFDO1FBRWIsSUFBSyxPQUFPO1lBQUcsT0FBTztRQUV0QixPQUFPLEVBQUcsQ0FBQztJQUViLENBQUMsQ0FBQztJQUVGLE9BQU8sRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxDQUFDO0FBRTNDLENBQUMsQ0FBQztBQUVGLFlBQVk7QUFFWixPQUFPLEVBQUMsVUFBVSxFQUFFLGtCQUFrQixFQUFDLENBQUMifQ==

dist_ts/types.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { FSWatcher, BigIntStats } from 'node:fs';
+import type { FSTargetEvent, TargetEvent } from './enums.js';
+import type WatcherStats from './watcher_stats.js';
+type ResultDirectory = {
+    directories: string[];
+    directoriesNames: Set<string>;
+    directoriesNamesToPaths: Record<string, string[]>;
+    files: string[];
+    filesNames: Set<string>;
+    filesNamesToPaths: Record<string, string[]>;
+    symlinks: string[];
+    symlinksNames: Set<string>;
+    symlinksNamesToPaths: Record<string, string[]>;
+};
+type ResultDirectories = {
+    [path: string]: ResultDirectory;
+};
+type Callback = () => void;
+type Disposer = () => void;
+type Event = [TargetEvent, Path, Path?];
+type FSHandler = (event?: FSTargetEvent, targetName?: string) => void;
+type Handler = (event: TargetEvent, targetPath: Path, targetPathNext?: Path) => void;
+type HandlerBatched = (event?: FSTargetEvent, targetPath?: Path, isInitial?: boolean) => Promise<void>;
+type Ignore = ((targetPath: Path) => boolean) | RegExp;
+type INO = bigint | number;
+type Path = string;
+type ReaddirMap = ResultDirectories;
+type Stats = BigIntStats;
+type LocksAdd = Map<INO, () => void>;
+type LocksUnlink = Map<INO, () => Path>;
+type LocksPair = {
+    add: LocksAdd;
+    unlink: LocksUnlink;
+};
+type LockConfig = {
+    ino?: INO;
+    targetPath: Path;
+    locks: LocksPair;
+    events: {
+        add: TargetEvent.ADD | TargetEvent.ADD_DIR;
+        change?: TargetEvent.CHANGE;
+        rename: TargetEvent.RENAME | TargetEvent.RENAME_DIR;
+        unlink: TargetEvent.UNLINK | TargetEvent.UNLINK_DIR;
+    };
+};
+type PollerConfig = {
+    options: WatcherOptions;
+    targetPath: Path;
+};
+type SubwatcherConfig = {
+    options: WatcherOptions;
+    targetPath: Path;
+};
+type WatcherConfig = {
+    handler: Handler;
+    watcher: FSWatcher;
+    options: WatcherOptions;
+    folderPath: Path;
+    filePath?: Path;
+};
+type WatcherOptions = {
+    debounce?: number;
+    depth?: number;
+    limit?: number;
+    ignore?: Ignore;
+    ignoreInitial?: boolean;
+    native?: boolean;
+    persistent?: boolean;
+    pollingInterval?: number;
+    pollingTimeout?: number;
+    readdirMap?: ReaddirMap;
+    recursive?: boolean;
+    renameDetection?: boolean;
+    renameTimeout?: number;
+};
+export type { Callback, Disposer, Event, FSHandler, FSWatcher, Handler, HandlerBatched, Ignore, INO, Path, ReaddirMap, Stats, LocksAdd, LocksUnlink, LocksPair, LockConfig, PollerConfig, SubwatcherConfig, WatcherConfig, WatcherOptions, WatcherStats };

dist_ts/types.js

@@ -0,0 +1,3 @@
+/* IMPORT */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxZQUFZIn0=

dist_ts/utils.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Callback, Ignore, ReaddirMap, Stats } from './types.js';
+declare const Utils: {
+    lang: {
+        debounce: <Args extends unknown[]>(fn: import("./dettle/types.js").FN<Args, unknown>, wait?: number, options?: {
+            leading?: boolean;
+            trailing?: boolean;
+            maxWait?: number;
+        }) => import("./dettle/types.js").Debounced<Args>;
+        attempt: <T>(fn: () => T) => Error | T;
+        castArray: <T_1>(x: T_1 | T_1[]) => T_1[];
+        castError: (exception: unknown) => Error;
+        defer: (callback: Callback) => NodeJS.Timeout;
+        isArray: (value: unknown) => value is unknown[];
+        isError: (value: unknown) => value is Error;
+        isFunction: (value: unknown) => value is Function;
+        isNaN: (value: unknown) => value is number;
+        isNumber: (value: unknown) => value is number;
+        isPrimitive: (value: unknown) => value is string | number | bigint | boolean | symbol;
+        isShallowEqual: (x: any, y: any) => boolean;
+        isSet: (value: unknown) => value is Set<unknown>;
+        isString: (value: unknown) => value is string;
+        isUndefined: (value: unknown) => value is undefined;
+        noop: () => undefined;
+        uniq: <T_2>(arr: T_2[]) => T_2[];
+    };
+    fs: {
+        getDepth: (targetPath: string) => number;
+        getRealPath: (targetPath: string, native?: boolean) => string | undefined;
+        isSubPath: (targetPath: string, subPath: string) => boolean;
+        poll: (targetPath: string, timeout?: number) => Promise<Stats | undefined>;
+        readdir: (rootPath: string, ignore?: Ignore, depth?: number, limit?: number, signal?: {
+            aborted: boolean;
+        }, readdirMap?: ReaddirMap) => Promise<[string[], string[]]>;
+    };
+};
+export default Utils;

dist_ts/watcher.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import { TargetEvent } from './enums.js';
+import WatcherHandler from './watcher_handler.js';
+import WatcherLocker from './watcher_locker.js';
+import WatcherPoller from './watcher_poller.js';
+import type { Callback, Disposer, Handler, Ignore, Path, PollerConfig, SubwatcherConfig, WatcherOptions, WatcherConfig } from './types.js';
+declare class Watcher extends EventEmitter {
+    _closed: boolean;
+    _ready: boolean;
+    _closeAborter: AbortController;
+    _closeSignal: {
+        aborted: boolean;
+    };
+    _closeWait: Promise<void>;
+    _readyWait: Promise<void>;
+    _locker: WatcherLocker;
+    _roots: Set<Path>;
+    _poller: WatcherPoller;
+    _pollers: Set<PollerConfig>;
+    _subwatchers: Set<SubwatcherConfig>;
+    _watchers: Record<Path, WatcherConfig[]>;
+    _watchersLock: Promise<void>;
+    _watchersRestorable: Record<Path, WatcherConfig>;
+    _watchersRestoreTimeout?: NodeJS.Timeout;
+    constructor(target?: Path[] | Path | Handler, options?: WatcherOptions | Handler, handler?: Handler);
+    isClosed(): boolean;
+    isIgnored(targetPath: Path, ignore?: Ignore): boolean;
+    isReady(): boolean;
+    close(): boolean;
+    error(exception: unknown): boolean;
+    event(event: TargetEvent, targetPath: Path, targetPathNext?: Path): boolean;
+    ready(): boolean;
+    pollerExists(targetPath: Path, options: WatcherOptions): boolean;
+    subwatcherExists(targetPath: Path, options: WatcherOptions): boolean;
+    watchersClose(folderPath?: Path, filePath?: Path, recursive?: boolean): void;
+    watchersLock(callback: Callback): Promise<void>;
+    watchersRestore(): void;
+    watcherAdd(config: WatcherConfig, baseWatcherHandler?: WatcherHandler): Promise<WatcherHandler>;
+    watcherClose(config: WatcherConfig): void;
+    watcherExists(folderPath: Path, options: WatcherOptions, handler: Handler, filePath?: Path): boolean;
+    watchDirectories(foldersPaths: Path[], options: WatcherOptions, handler: Handler, filePath?: Path, baseWatcherHandler?: WatcherHandler): Promise<WatcherHandler | undefined>;
+    watchDirectory(folderPath: Path, options: WatcherOptions, handler: Handler, filePath?: Path, baseWatcherHandler?: WatcherHandler): Promise<void>;
+    watchFileOnce(filePath: Path, options: WatcherOptions, callback: Callback): Promise<void>;
+    watchFile(filePath: Path, options: WatcherOptions, handler: Handler): Promise<void>;
+    watchPollingOnce(targetPath: Path, options: WatcherOptions, callback: Callback): Promise<void>;
+    watchPolling(targetPath: Path, options: WatcherOptions, callback: Callback): Promise<Disposer>;
+    watchUnknownChild(targetPath: Path, options: WatcherOptions, handler: Handler): Promise<void>;
+    watchUnknownTarget(targetPath: Path, options: WatcherOptions, handler: Handler): Promise<void>;
+    watchPaths(targetPaths: Path[], options: WatcherOptions, handler: Handler): Promise<void>;
+    watchPath(targetPath: Path, options: WatcherOptions, handler: Handler): Promise<void>;
+    watch(target?: Path[] | Path | Handler, options?: WatcherOptions | Handler, handler?: Handler): Promise<void>;
+}
+export default Watcher;

dist_ts/watcher_handler.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { FSTargetEvent } from './enums.js';
+import type Watcher from './watcher.js';
+import type { Event, FSWatcher, Handler, HandlerBatched, Path, WatcherOptions, WatcherConfig } from './types.js';
+declare class WatcherHandler {
+    base?: WatcherHandler;
+    watcher: Watcher;
+    handler: Handler;
+    handlerBatched: HandlerBatched;
+    fswatcher: FSWatcher;
+    options: WatcherOptions;
+    folderPath: Path;
+    filePath?: Path;
+    constructor(watcher: Watcher, config: WatcherConfig, base?: WatcherHandler);
+    _isSubRoot(targetPath: Path): boolean;
+    _makeHandlerBatched(delay?: number): (event: FSTargetEvent, targetPath?: Path, isInitial?: boolean) => Promise<void>;
+    eventsDeduplicate(events: Event[]): Event[];
+    eventsPopulate(targetPaths: Path[], events?: Event[], isInitial?: boolean): Promise<Event[]>;
+    eventsPopulateAddDir(targetPaths: Path[], targetPath: Path, events?: Event[], isInitial?: boolean): Promise<Event[]>;
+    eventsPopulateUnlinkDir(targetPaths: Path[], targetPath: Path, events?: Event[], isInitial?: boolean): Promise<Event[]>;
+    onTargetAdd(targetPath: Path): void;
+    onTargetAddDir(targetPath: Path): void;
+    onTargetChange(targetPath: Path): void;
+    onTargetUnlink(targetPath: Path): void;
+    onTargetUnlinkDir(targetPath: Path): void;
+    onTargetEvent(event: Event): void;
+    onTargetEvents(events: Event[]): void;
+    onWatcherEvent(event?: FSTargetEvent, targetPath?: Path, isInitial?: boolean): Promise<void>;
+    onWatcherChange(event?: FSTargetEvent, targetName?: string | null): void;
+    onWatcherError(error: NodeJS.ErrnoException): void;
+    init(): Promise<void>;
+    initWatcherEvents(): Promise<void>;
+    initInitialEvents(): Promise<void>;
+}
+export default WatcherHandler;

dist_ts/watcher_locker.d.ts

@@ -0,0 +1,32 @@
+import { TargetEvent } from './enums.js';
+import type Watcher from './watcher.js';
+import type { Path, LocksAdd, LocksUnlink, LocksPair, LockConfig } from './types.js';
+declare class WatcherLocker {
+    _locksAdd: LocksAdd;
+    _locksAddDir: LocksAdd;
+    _locksUnlink: LocksUnlink;
+    _locksUnlinkDir: LocksUnlink;
+    _locksDir: LocksPair;
+    _locksFile: LocksPair;
+    _watcher: Watcher;
+    static DIR_EVENTS: {
+        readonly add: TargetEvent.ADD_DIR;
+        readonly rename: TargetEvent.RENAME_DIR;
+        readonly unlink: TargetEvent.UNLINK_DIR;
+    };
+    static FILE_EVENTS: {
+        readonly add: TargetEvent.ADD;
+        readonly change: TargetEvent.CHANGE;
+        readonly rename: TargetEvent.RENAME;
+        readonly unlink: TargetEvent.UNLINK;
+    };
+    constructor(watcher: Watcher);
+    getLockAdd(config: LockConfig, timeout?: number): void;
+    getLockUnlink(config: LockConfig, timeout?: number): void;
+    getLockTargetAdd(targetPath: Path, timeout?: number): void;
+    getLockTargetAddDir(targetPath: Path, timeout?: number): void;
+    getLockTargetUnlink(targetPath: Path, timeout?: number): void;
+    getLockTargetUnlinkDir(targetPath: Path, timeout?: number): void;
+    reset(): void;
+}
+export default WatcherLocker;

dist_ts/watcher_locks_resolver.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+declare const WatcherLocksResolver: {
+    interval: number;
+    intervalId: NodeJS.Timeout;
+    fns: Map<Function, number>;
+    init: () => void;
+    reset: () => void;
+    add: (fn: Function, timeout: number) => void;
+    remove: (fn: Function) => void;
+    resolve: () => void;
+};
+export default WatcherLocksResolver;

dist_ts/watcher_locks_resolver.js

@@ -0,0 +1,43 @@
+/* MAIN */
+// Registering a single interval scales much better than registering N timeouts
+// Timeouts are respected within the interval margin
+const WatcherLocksResolver = {
+    /* VARIABLES */
+    interval: 100,
+    intervalId: undefined,
+    fns: new Map(),
+    /* LIFECYCLE API */
+    init: () => {
+        if (WatcherLocksResolver.intervalId)
+            return;
+        WatcherLocksResolver.intervalId = setInterval(WatcherLocksResolver.resolve, WatcherLocksResolver.interval);
+    },
+    reset: () => {
+        if (!WatcherLocksResolver.intervalId)
+            return;
+        clearInterval(WatcherLocksResolver.intervalId);
+        delete WatcherLocksResolver.intervalId;
+    },
+    /* API */
+    add: (fn, timeout) => {
+        WatcherLocksResolver.fns.set(fn, Date.now() + timeout);
+        WatcherLocksResolver.init();
+    },
+    remove: (fn) => {
+        WatcherLocksResolver.fns.delete(fn);
+    },
+    resolve: () => {
+        if (!WatcherLocksResolver.fns.size)
+            return WatcherLocksResolver.reset();
+        const now = Date.now();
+        for (const [fn, timestamp] of WatcherLocksResolver.fns) {
+            if (timestamp >= now)
+                continue; // We should still wait some more for this
+            WatcherLocksResolver.remove(fn);
+            fn();
+        }
+    }
+};
+/* EXPORT */
+export default WatcherLocksResolver;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2hlcl9sb2Nrc19yZXNvbHZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3dhdGNoZXJfbG9ja3NfcmVzb2x2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsVUFBVTtBQUVWLCtFQUErRTtBQUMvRSxvREFBb0Q7QUFFcEQsTUFBTSxvQkFBb0IsR0FBRztJQUUzQixlQUFlO0lBRWYsUUFBUSxFQUFFLEdBQUc7SUFDYixVQUFVLEVBQUUsU0FBdUM7SUFDbkQsR0FBRyxFQUFFLElBQUksR0FBRyxFQUFxQjtJQUVqQyxtQkFBbUI7SUFFbkIsSUFBSSxFQUFFLEdBQVMsRUFBRTtRQUVmLElBQUssb0JBQW9CLENBQUMsVUFBVTtZQUFHLE9BQU87UUFFOUMsb0JBQW9CLENBQUMsVUFBVSxHQUFHLFdBQVcsQ0FBRyxvQkFBb0IsQ0FBQyxPQUFPLEVBQUUsb0JBQW9CLENBQUMsUUFBUSxDQUFFLENBQUM7SUFFaEgsQ0FBQztJQUVELEtBQUssRUFBRSxHQUFTLEVBQUU7UUFFaEIsSUFBSyxDQUFDLG9CQUFvQixDQUFDLFVBQVU7WUFBRyxPQUFPO1FBRS9DLGFBQWEsQ0FBRyxvQkFBb0IsQ0FBQyxVQUFVLENBQUUsQ0FBQztRQUVsRCxPQUFPLG9CQUFvQixDQUFDLFVBQVUsQ0FBQztJQUV6QyxDQUFDO0lBRUQsU0FBUztJQUVULEdBQUcsRUFBRSxDQUFFLEVBQVksRUFBRSxPQUFlLEVBQVMsRUFBRTtRQUU3QyxvQkFBb0IsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFHLEVBQUUsRUFBRSxJQUFJLENBQUMsR0FBRyxFQUFHLEdBQUcsT0FBTyxDQUFFLENBQUM7UUFFM0Qsb0JBQW9CLENBQUMsSUFBSSxFQUFHLENBQUM7SUFFL0IsQ0FBQztJQUVELE1BQU0sRUFBRSxDQUFFLEVBQVksRUFBUyxFQUFFO1FBRS9CLG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUcsRUFBRSxDQUFFLENBQUM7SUFFekMsQ0FBQztJQUVELE9BQU8sRUFBRSxHQUFTLEVBQUU7UUFFbEIsSUFBSyxDQUFDLG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxJQUFJO1lBQUcsT0FBTyxvQkFBb0IsQ0FBQyxLQUFLLEVBQUcsQ0FBQztRQUUzRSxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFHLENBQUM7UUFFeEIsS0FBTSxNQUFNLENBQUMsRUFBRSxFQUFFLFNBQVMsQ0FBQyxJQUFJLG9CQUFvQixDQUFDLEdBQUcsRUFBRyxDQUFDO1lBRXpELElBQUssU0FBUyxJQUFJLEdBQUc7Z0JBQUcsU0FBUyxDQUFDLDBDQUEwQztZQUU1RSxvQkFBb0IsQ0FBQyxNQUFNLENBQUcsRUFBRSxDQUFFLENBQUM7WUFFbkMsRUFBRSxFQUFHLENBQUM7UUFFUixDQUFDO0lBRUgsQ0FBQztDQUVGLENBQUM7QUFFRixZQUFZO0FBRVosZUFBZSxvQkFBb0IsQ0FBQyJ9

dist_ts/watcher_poller.d.ts

@@ -0,0 +1,17 @@
+import { FileType, TargetEvent } from './enums.js';
+import LazyMapSet from './lazy_map_set.js';
+import WatcherStats from './watcher_stats.js';
+import type { INO, Path } from './types.js';
+declare class WatcherPoller {
+    inos: Partial<Record<TargetEvent, Record<Path, [INO, FileType]>>>;
+    paths: LazyMapSet<INO, Path>;
+    stats: Map<Path, WatcherStats>;
+    getIno(targetPath: Path, event: TargetEvent, type?: FileType): INO | undefined;
+    getStats(targetPath: Path): WatcherStats | undefined;
+    poll(targetPath: Path, timeout?: number): Promise<WatcherStats | undefined>;
+    reset(): void;
+    update(targetPath: Path, timeout?: number): Promise<TargetEvent[]>;
+    updateIno(targetPath: Path, event: TargetEvent, stats: WatcherStats): void;
+    updateStats(targetPath: Path, stats?: WatcherStats): void;
+}
+export default WatcherPoller;

dist_ts/watcher_stats.d.ts

@@ -0,0 +1,17 @@
+import type { INO, Stats } from './types.js';
+declare class WatcherStats {
+    ino: INO;
+    size: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    _isFile: boolean;
+    _isDirectory: boolean;
+    _isSymbolicLink: boolean;
+    constructor(stats: Stats);
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+}
+export default WatcherStats;

dist_ts/watcher_stats.js

@@ -0,0 +1,30 @@
+/* IMPORT */
+/* MAIN */
+// An more memory-efficient representation of the useful subset of stats objects
+class WatcherStats {
+    /* CONSTRUCTOR */
+    constructor(stats) {
+        this.ino = (stats.ino <= Number.MAX_SAFE_INTEGER) ? Number(stats.ino) : stats.ino;
+        this.size = Number(stats.size);
+        this.atimeMs = Number(stats.atimeMs);
+        this.mtimeMs = Number(stats.mtimeMs);
+        this.ctimeMs = Number(stats.ctimeMs);
+        this.birthtimeMs = Number(stats.birthtimeMs);
+        this._isFile = stats.isFile();
+        this._isDirectory = stats.isDirectory();
+        this._isSymbolicLink = stats.isSymbolicLink();
+    }
+    /* API */
+    isFile() {
+        return this._isFile;
+    }
+    isDirectory() {
+        return this._isDirectory;
+    }
+    isSymbolicLink() {
+        return this._isSymbolicLink;
+    }
+}
+/* EXPORT */
+export default WatcherStats;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2hlcl9zdGF0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3dhdGNoZXJfc3RhdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsWUFBWTtBQUlaLFVBQVU7QUFFVixnRkFBZ0Y7QUFFaEYsTUFBTSxZQUFZO0lBY2hCLGlCQUFpQjtJQUVqQixZQUFjLEtBQVk7UUFFeEIsSUFBSSxDQUFDLEdBQUcsR0FBRyxDQUFFLEtBQUssQ0FBQyxHQUFHLElBQUksTUFBTSxDQUFDLGdCQUFnQixDQUFFLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBRyxLQUFLLENBQUMsR0FBRyxDQUFFLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUM7UUFDdkYsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUcsS0FBSyxDQUFDLElBQUksQ0FBRSxDQUFDO1FBQ2xDLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFHLEtBQUssQ0FBQyxPQUFPLENBQUUsQ0FBQztRQUN4QyxJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBRyxLQUFLLENBQUMsT0FBTyxDQUFFLENBQUM7UUFDeEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBRSxDQUFDO1FBQ3hDLElBQUksQ0FBQyxXQUFXLEdBQUcsTUFBTSxDQUFHLEtBQUssQ0FBQyxXQUFXLENBQUUsQ0FBQztRQUNoRCxJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQyxNQUFNLEVBQUcsQ0FBQztRQUMvQixJQUFJLENBQUMsWUFBWSxHQUFHLEtBQUssQ0FBQyxXQUFXLEVBQUcsQ0FBQztRQUN6QyxJQUFJLENBQUMsZUFBZSxHQUFHLEtBQUssQ0FBQyxjQUFjLEVBQUcsQ0FBQztJQUVqRCxDQUFDO0lBRUQsU0FBUztJQUVULE1BQU07UUFFSixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFFdEIsQ0FBQztJQUVELFdBQVc7UUFFVCxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7SUFFM0IsQ0FBQztJQUVELGNBQWM7UUFFWixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUM7SUFFOUIsQ0FBQztDQUVGO0FBRUQsWUFBWTtBQUVaLGVBQWUsWUFBWSxDQUFDIn0=