@ms-cloudpack/file-watcher 0.1.3 → 0.2.0

package/README.md

@@ -16,19 +16,22 @@ const watcher = createWatcher();
 const unwatch = watcher.watch({ path: 'path/to/package' }, () => console.log(`package changed`));
 ```
 
-3. To dispose, call the returned `unwatch`, or call `watcher.unwatchAll` to unsubscribe from all watchers.
+3. To dispose, call the returned `unwatch`, or call `watcher.dispose` to unsubscribe from all watchers.
 
 ```ts
 // Dispose an individual watcher.
 await unwatch();
 
 // Dispose all watchers.
-await watcher.unwatchAll();
+await watcher.dispose();
 ```
 
+### `createWatcher` options
+
+- `type` (`'default' | 'fork'`, optional): By default, this will create a watcher in the same thread. Use `type: 'fork'` to create the watcher in a forked process.
+
 ### `watcher.watch` options
 
-| Name           | Type     | Description                                                                               |
-| -------------- | -------- | ----------------------------------------------------------------------------------------- |
-| `path`         | string   | The absolute base path to be watched.                                                     |
-| `watchedPaths` | string[] | Relative paths from the base path to watch. Defaults to `package.json` and `src/` folder. |
+- `path` (`string`): The absolute root path to be watched.
+- `id` (`string`, optional): ID for the watch job (defaults to `path`). If you call `watch` twice using the same `id`, subsequent calls will be ignored.
+- `watchedPaths` (`string[]`, optional): Relative paths/globs from the root path to watch. Defaults to `*.json` and `src/**/*`, excluding `node_modules`.

package/lib/BaseWatcher.d.ts

@@ -0,0 +1,22 @@
+import type { UnwatchCallback, WatchChangeCallback, Watcher, WatchOptions, WatchOptionsWithId } from './types/Watcher.js';
+/**
+ * Base class for watcher implementations.
+ */
+export declare abstract class BaseWatcher implements Watcher {
+    /** Watcher is disposed or disposing */
+    private _disposeCalled;
+    /** Mapping from ID to change callback */
+    protected _onChangeCallbacks: Record<string, WatchChangeCallback>;
+    /** Mapping from ID to unwatch callback */
+    private _unwatchCallbacks;
+    /** Number of IDs currently being watched (just used for testing) */
+    get activeWatchCount(): number;
+    watch(baseOptions: WatchOptions, onChange: WatchChangeCallback): UnwatchCallback;
+    unwatch(id: string): Promise<void>;
+    dispose(): Promise<void>;
+    protected abstract _watch(options: WatchOptionsWithId, onChange: WatchChangeCallback): UnwatchCallback;
+    /** By default, calls all the unwatch callbacks. Override for custom dispose logic. */
+    protected _dispose(): Promise<void>;
+    protected _isDisposed(): boolean;
+}
+//# sourceMappingURL=BaseWatcher.d.ts.map

package/lib/BaseWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseWatcher.d.ts","sourceRoot":"","sources":["../src/BaseWatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,OAAO,EACP,YAAY,EACZ,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,8BAAsB,WAAY,YAAW,OAAO;IAClD,uCAAuC;IACvC,OAAO,CAAC,cAAc,CAAS;IAC/B,yCAAyC;IACzC,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAM;IACvE,0CAA0C;IAC1C,OAAO,CAAC,iBAAiB,CAAuC;IAEhE,oEAAoE;IACpE,IAAW,gBAAgB,IAAI,MAAM,CAEpC;IAEM,KAAK,CAAC,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,mBAAmB,GAAG,eAAe;IA8B1E,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKlC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOrC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,mBAAmB,GAAG,eAAe;IAEtG,sFAAsF;cACtE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzC,SAAS,CAAC,WAAW,IAAI,OAAO;CAGjC"}

package/lib/BaseWatcher.js

@@ -0,0 +1,59 @@
+/**
+ * Base class for watcher implementations.
+ */
+export class BaseWatcher {
+    constructor() {
+        /** Watcher is disposed or disposing */
+        this._disposeCalled = false;
+        /** Mapping from ID to change callback */
+        this._onChangeCallbacks = {};
+        /** Mapping from ID to unwatch callback */
+        this._unwatchCallbacks = {};
+    }
+    /** Number of IDs currently being watched (just used for testing) */
+    get activeWatchCount() {
+        return Object.keys(this._unwatchCallbacks).length;
+    }
+    watch(baseOptions, onChange) {
+        if (this._isDisposed()) {
+            throw new Error('Watcher has been disposed.');
+        }
+        const { id = baseOptions.path } = baseOptions;
+        if (!this._unwatchCallbacks[id]) {
+            this._onChangeCallbacks[id] = onChange;
+            // Watch the path using the child class's implementation
+            const unwatch = this._watch({ ...baseOptions, id }, onChange);
+            // Make an unwatch wrapper to clean up parent class state
+            let calledUnwatch = false;
+            this._unwatchCallbacks[id] = async () => {
+                // The same unwatch callback might be returned multiple times in case of duplicate calls
+                // for the same ID. Only do the cleanup once.
+                if (!calledUnwatch) {
+                    calledUnwatch = true;
+                    await unwatch();
+                    delete this._unwatchCallbacks[id];
+                    delete this._onChangeCallbacks[id];
+                }
+            };
+        }
+        return this._unwatchCallbacks[id];
+    }
+    async unwatch(id) {
+        // The wrapper code at the callback definition in watch() handles cleanup of callback records.
+        await this._unwatchCallbacks[id]?.();
+    }
+    async dispose() {
+        this._disposeCalled = true;
+        await this._dispose();
+        this._unwatchCallbacks = {};
+        this._onChangeCallbacks = {};
+    }
+    /** By default, calls all the unwatch callbacks. Override for custom dispose logic. */
+    async _dispose() {
+        await Promise.all(Object.values(this._unwatchCallbacks).map((unwatch) => unwatch()));
+    }
+    _isDisposed() {
+        return this._disposeCalled;
+    }
+}
+//# sourceMappingURL=BaseWatcher.js.map

package/lib/BaseWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseWatcher.js","sourceRoot":"","sources":["../src/BaseWatcher.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,OAAgB,WAAW;IAAjC;QACE,uCAAuC;QAC/B,mBAAc,GAAG,KAAK,CAAC;QAC/B,yCAAyC;QAC/B,uBAAkB,GAAwC,EAAE,CAAC;QACvE,0CAA0C;QAClC,sBAAiB,GAAoC,EAAE,CAAC;IA2DlE,CAAC;IAzDC,oEAAoE;IACpE,IAAW,gBAAgB;QACzB,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC;IACpD,CAAC;IAEM,KAAK,CAAC,WAAyB,EAAE,QAA6B;QACnE,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QAED,MAAM,EAAE,EAAE,GAAG,WAAW,CAAC,IAAI,EAAE,GAAG,WAAW,CAAC;QAE9C,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,EAAE,CAAC;YAChC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC;YAEvC,wDAAwD;YACxD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,WAAW,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;YAE9D,yDAAyD;YACzD,IAAI,aAAa,GAAG,KAAK,CAAC;YAC1B,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,EAAE;gBACtC,wFAAwF;gBACxF,6CAA6C;gBAC7C,IAAI,CAAC,aAAa,EAAE,CAAC;oBACnB,aAAa,GAAG,IAAI,CAAC;oBACrB,MAAM,OAAO,EAAE,CAAC;oBAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;oBAClC,OAAO,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;IACpC,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,EAAU;QAC7B,8FAA8F;QAC9F,MAAM,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;IACvC,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QACtB,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;QAC5B,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;IAC/B,CAAC;IAID,sFAAsF;IAC5E,KAAK,CAAC,QAAQ;QACtB,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACvF,CAAC;IAES,WAAW;QACnB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;CACF","sourcesContent":["import type {\n  UnwatchCallback,\n  WatchChangeCallback,\n  Watcher,\n  WatchOptions,\n  WatchOptionsWithId,\n} from './types/Watcher.js';\n\n/**\n * Base class for watcher implementations.\n */\nexport abstract class BaseWatcher implements Watcher {\n  /** Watcher is disposed or disposing */\n  private _disposeCalled = false;\n  /** Mapping from ID to change callback */\n  protected _onChangeCallbacks: Record<string, WatchChangeCallback> = {};\n  /** Mapping from ID to unwatch callback */\n  private _unwatchCallbacks: Record<string, UnwatchCallback> = {};\n\n  /** Number of IDs currently being watched (just used for testing) */\n  public get activeWatchCount(): number {\n    return Object.keys(this._unwatchCallbacks).length;\n  }\n\n  public watch(baseOptions: WatchOptions, onChange: WatchChangeCallback): UnwatchCallback {\n    if (this._isDisposed()) {\n      throw new Error('Watcher has been disposed.');\n    }\n\n    const { id = baseOptions.path } = baseOptions;\n\n    if (!this._unwatchCallbacks[id]) {\n      this._onChangeCallbacks[id] = onChange;\n\n      // Watch the path using the child class's implementation\n      const unwatch = this._watch({ ...baseOptions, id }, onChange);\n\n      // Make an unwatch wrapper to clean up parent class state\n      let calledUnwatch = false;\n      this._unwatchCallbacks[id] = async () => {\n        // The same unwatch callback might be returned multiple times in case of duplicate calls\n        // for the same ID. Only do the cleanup once.\n        if (!calledUnwatch) {\n          calledUnwatch = true;\n          await unwatch();\n          delete this._unwatchCallbacks[id];\n          delete this._onChangeCallbacks[id];\n        }\n      };\n    }\n\n    return this._unwatchCallbacks[id];\n  }\n\n  public async unwatch(id: string): Promise<void> {\n    // The wrapper code at the callback definition in watch() handles cleanup of callback records.\n    await this._unwatchCallbacks[id]?.();\n  }\n\n  public async dispose(): Promise<void> {\n    this._disposeCalled = true;\n    await this._dispose();\n    this._unwatchCallbacks = {};\n    this._onChangeCallbacks = {};\n  }\n\n  protected abstract _watch(options: WatchOptionsWithId, onChange: WatchChangeCallback): UnwatchCallback;\n\n  /** By default, calls all the unwatch callbacks. Override for custom dispose logic. */\n  protected async _dispose(): Promise<void> {\n    await Promise.all(Object.values(this._unwatchCallbacks).map((unwatch) => unwatch()));\n  }\n\n  protected _isDisposed(): boolean {\n    return this._disposeCalled;\n  }\n}\n"]}

package/lib/DefaultWatcher.d.ts

@@ -0,0 +1,9 @@
+import type { UnwatchCallback, WatchChangeCallback, WatchOptionsWithId } from './types/Watcher.js';
+import { BaseWatcher } from './BaseWatcher.js';
+/**
+ * Watch for changes using chokidar in the current process.
+ */
+export declare class DefaultWatcher extends BaseWatcher {
+    protected _watch(options: WatchOptionsWithId, onChange: WatchChangeCallback): UnwatchCallback;
+}
+//# sourceMappingURL=DefaultWatcher.d.ts.map

package/lib/DefaultWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultWatcher.d.ts","sourceRoot":"","sources":["../src/DefaultWatcher.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI/C;;GAEG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAI7C,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,mBAAmB,GAAG,eAAe;CAkB9F"}

package/lib/DefaultWatcher.js

@@ -0,0 +1,46 @@
+import chokidar from 'chokidar';
+import path from 'path';
+import { BaseWatcher } from './BaseWatcher.js';
+const defaultWatchPaths = ['src/**/*', '*.json', '!**/node_modules/**/*'];
+/**
+ * Watch for changes using chokidar in the current process.
+ */
+export class DefaultWatcher extends BaseWatcher {
+    // TODO: Ideally if this is called multiple times with a different ID but the same root path and
+    // same watch paths, a single chokidar watcher should be created and shared. But this involves a
+    // lot of extra tracking logic and isn't essential until SSR is actually being used in an app.
+    _watch(options, onChange) {
+        const { path: rootPath, watchPaths = defaultWatchPaths } = options;
+        const { positiveGlobs, negativeGlobs } = separateGlobs(watchPaths);
+        const paths = positiveGlobs.map((relPath) => path.resolve(rootPath, relPath));
+        const ignored = negativeGlobs.map((relPath) => path.resolve(rootPath, relPath));
+        // For efficiency, don't follow symlinks, and don't send 'add' events after the initial scan.
+        let watcher = chokidar
+            .watch(paths, { ignored, followSymlinks: false, ignoreInitial: true })
+            .on('change', (filePath) => {
+            onChange(filePath);
+        });
+        return async () => {
+            await watcher?.close();
+            watcher = undefined;
+        };
+    }
+}
+/**
+ * This function separates positive and negative globs to later on ignore the negative ones.
+ * This is necessary because chokidar does not support negative globs well.
+ */
+function separateGlobs(globs) {
+    const positiveGlobs = [];
+    const negativeGlobs = [];
+    for (const glob of globs) {
+        if (glob.startsWith('!')) {
+            negativeGlobs.push(glob.slice(1));
+        }
+        else {
+            positiveGlobs.push(glob);
+        }
+    }
+    return { positiveGlobs, negativeGlobs };
+}
+//# sourceMappingURL=DefaultWatcher.js.map

package/lib/DefaultWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultWatcher.js","sourceRoot":"","sources":["../src/DefaultWatcher.ts"],"names":[],"mappings":"AAAA,OAAO,QAA4B,MAAM,UAAU,CAAC;AACpD,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,iBAAiB,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,uBAAuB,CAAC,CAAC;AAE1E;;GAEG;AACH,MAAM,OAAO,cAAe,SAAQ,WAAW;IAC7C,gGAAgG;IAChG,gGAAgG;IAChG,8FAA8F;IACpF,MAAM,CAAC,OAA2B,EAAE,QAA6B;QACzE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,GAAG,iBAAiB,EAAE,GAAG,OAAO,CAAC;QACnE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;QAC9E,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;QAEhF,6FAA6F;QAC7F,IAAI,OAAO,GAA0B,QAAQ;aAC1C,KAAK,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;aACrE,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE;YACzB,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEL,OAAO,KAAK,IAAI,EAAE;YAChB,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC;YACvB,OAAO,GAAG,SAAS,CAAC;QACtB,CAAC,CAAC;IACJ,CAAC;CACF;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,KAAe;IACpC,MAAM,aAAa,GAAa,EAAE,CAAC;IACnC,MAAM,aAAa,GAAa,EAAE,CAAC;IAEnC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACN,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC;AAC1C,CAAC","sourcesContent":["import chokidar, { type FSWatcher } from 'chokidar';\nimport path from 'path';\nimport type { UnwatchCallback, WatchChangeCallback, WatchOptionsWithId } from './types/Watcher.js';\nimport { BaseWatcher } from './BaseWatcher.js';\n\nconst defaultWatchPaths = ['src/**/*', '*.json', '!**/node_modules/**/*'];\n\n/**\n * Watch for changes using chokidar in the current process.\n */\nexport class DefaultWatcher extends BaseWatcher {\n  // TODO: Ideally if this is called multiple times with a different ID but the same root path and\n  // same watch paths, a single chokidar watcher should be created and shared. But this involves a\n  // lot of extra tracking logic and isn't essential until SSR is actually being used in an app.\n  protected _watch(options: WatchOptionsWithId, onChange: WatchChangeCallback): UnwatchCallback {\n    const { path: rootPath, watchPaths = defaultWatchPaths } = options;\n    const { positiveGlobs, negativeGlobs } = separateGlobs(watchPaths);\n    const paths = positiveGlobs.map((relPath) => path.resolve(rootPath, relPath));\n    const ignored = negativeGlobs.map((relPath) => path.resolve(rootPath, relPath));\n\n    // For efficiency, don't follow symlinks, and don't send 'add' events after the initial scan.\n    let watcher: FSWatcher | undefined = chokidar\n      .watch(paths, { ignored, followSymlinks: false, ignoreInitial: true })\n      .on('change', (filePath) => {\n        onChange(filePath);\n      });\n\n    return async () => {\n      await watcher?.close();\n      watcher = undefined;\n    };\n  }\n}\n\n/**\n * This function separates positive and negative globs to later on ignore the negative ones.\n * This is necessary because chokidar does not support negative globs well.\n */\nfunction separateGlobs(globs: string[]): { positiveGlobs: string[]; negativeGlobs: string[] } {\n  const positiveGlobs: string[] = [];\n  const negativeGlobs: string[] = [];\n\n  for (const glob of globs) {\n    if (glob.startsWith('!')) {\n      negativeGlobs.push(glob.slice(1));\n    } else {\n      positiveGlobs.push(glob);\n    }\n  }\n\n  return { positiveGlobs, negativeGlobs };\n}\n"]}

package/lib/ForkWatcher.d.ts

@@ -0,0 +1,15 @@
+import type { UnwatchCallback, WatchOptions } from './types/Watcher.js';
+import { BaseWatcher } from './BaseWatcher.js';
+/**
+ * Creates a watcher in a fork which can watch a package and notify the client when it changes.
+ */
+export declare class ForkWatcher extends BaseWatcher {
+    private _child;
+    constructor();
+    protected _watch(options: Required<WatchOptions>): UnwatchCallback;
+    protected _dispose(): Promise<void>;
+    protected _isDisposed(): boolean;
+    /** Typed wrapper for `this._child.send()`. No-op if `_child` is disposed. */
+    private _sendMessage;
+}
+//# sourceMappingURL=ForkWatcher.d.ts.map

package/lib/ForkWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForkWatcher.d.ts","sourceRoot":"","sources":["../src/ForkWatcher.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAK/C;;GAEG;AACH,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,MAAM,CAA2B;;IAyBzC,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,eAAe;cAQlD,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAYzC,SAAS,CAAC,WAAW,IAAI,OAAO;IAIhC,6EAA6E;IAC7E,OAAO,CAAC,YAAY;CAGrB"}

package/lib/ForkWatcher.js

@@ -0,0 +1,54 @@
+import path from 'path';
+import { fork } from 'child_process';
+import { fileURLToPath } from 'url';
+import { BaseWatcher } from './BaseWatcher.js';
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const watcherForkWrapper = path.resolve(currentDir, 'watcherForkWrapper.js');
+/**
+ * Creates a watcher in a fork which can watch a package and notify the client when it changes.
+ */
+export class ForkWatcher extends BaseWatcher {
+    constructor() {
+        super();
+        this._child = fork(watcherForkWrapper);
+        this._child.on('message', (message) => {
+            switch (message.type) {
+                case 'change':
+                    if (this._isDisposed()) {
+                        throw new Error('Watcher has been disposed.');
+                    }
+                    this._onChangeCallbacks[message.id]?.(message.changedPath);
+                    break;
+                case 'error':
+                    console.error(`An error occurred while watching files: ${message.error}`);
+                    break;
+                default:
+                    console.warn(`Unknown message type: ${JSON.stringify(message)}`);
+            }
+        });
+    }
+    _watch(options) {
+        this._sendMessage({ type: 'watch', options });
+        return () => {
+            this._sendMessage({ type: 'unwatch', id: options.id });
+        };
+    }
+    async _dispose() {
+        await new Promise((r) => {
+            if (!this._child) {
+                return r();
+            }
+            this._child.on('close', r);
+            this._sendMessage({ type: 'shutdown' });
+            this._child = undefined;
+        });
+    }
+    _isDisposed() {
+        return !this._child || super._isDisposed();
+    }
+    /** Typed wrapper for `this._child.send()`. No-op if `_child` is disposed. */
+    _sendMessage(message) {
+        this._child?.send(message);
+    }
+}
+//# sourceMappingURL=ForkWatcher.js.map

package/lib/ForkWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForkWatcher.js","sourceRoot":"","sources":["../src/ForkWatcher.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,IAAI,EAAqB,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AAGpC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAChE,MAAM,kBAAkB,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,uBAAuB,CAAC,CAAC;AAE7E;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,WAAW;IAG1C;QACE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAEvC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAqB,EAAE,EAAE;YAClD,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;gBACrB,KAAK,QAAQ;oBACX,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;wBACvB,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;oBAChD,CAAC;oBACD,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC3D,MAAM;gBAER,KAAK,OAAO;oBACV,OAAO,CAAC,KAAK,CAAC,2CAA2C,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;oBAC1E,MAAM;gBAER;oBACE,OAAO,CAAC,IAAI,CAAC,yBAAyB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACrE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAES,MAAM,CAAC,OAA+B;QAC9C,IAAI,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAE9C,OAAO,GAAG,EAAE;YACV,IAAI,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;QACzD,CAAC,CAAC;IACJ,CAAC;IAES,KAAK,CAAC,QAAQ;QACtB,MAAM,IAAI,OAAO,CAAO,CAAC,CAAC,EAAE,EAAE;YAC5B,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACjB,OAAO,CAAC,EAAE,CAAC;YACb,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;YAC3B,IAAI,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YACxC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC1B,CAAC,CAAC,CAAC;IACL,CAAC;IAES,WAAW;QACnB,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;IAC7C,CAAC;IAED,6EAA6E;IACrE,YAAY,CAAC,OAAsB;QACzC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;CACF","sourcesContent":["import path from 'path';\nimport { fork, type ChildProcess } from 'child_process';\nimport { fileURLToPath } from 'url';\nimport type { ChildMessage, ParentMessage } from './types/WatchMessages.js';\nimport type { UnwatchCallback, WatchOptions } from './types/Watcher.js';\nimport { BaseWatcher } from './BaseWatcher.js';\n\nconst currentDir = path.dirname(fileURLToPath(import.meta.url));\nconst watcherForkWrapper = path.resolve(currentDir, 'watcherForkWrapper.js');\n\n/**\n * Creates a watcher in a fork which can watch a package and notify the client when it changes.\n */\nexport class ForkWatcher extends BaseWatcher {\n  private _child: ChildProcess | undefined;\n\n  constructor() {\n    super();\n    this._child = fork(watcherForkWrapper);\n\n    this._child.on('message', (message: ChildMessage) => {\n      switch (message.type) {\n        case 'change':\n          if (this._isDisposed()) {\n            throw new Error('Watcher has been disposed.');\n          }\n          this._onChangeCallbacks[message.id]?.(message.changedPath);\n          break;\n\n        case 'error':\n          console.error(`An error occurred while watching files: ${message.error}`);\n          break;\n\n        default:\n          console.warn(`Unknown message type: ${JSON.stringify(message)}`);\n      }\n    });\n  }\n\n  protected _watch(options: Required<WatchOptions>): UnwatchCallback {\n    this._sendMessage({ type: 'watch', options });\n\n    return () => {\n      this._sendMessage({ type: 'unwatch', id: options.id });\n    };\n  }\n\n  protected async _dispose(): Promise<void> {\n    await new Promise<void>((r) => {\n      if (!this._child) {\n        return r();\n      }\n\n      this._child.on('close', r);\n      this._sendMessage({ type: 'shutdown' });\n      this._child = undefined;\n    });\n  }\n\n  protected _isDisposed(): boolean {\n    return !this._child || super._isDisposed();\n  }\n\n  /** Typed wrapper for `this._child.send()`. No-op if `_child` is disposed. */\n  private _sendMessage(message: ParentMessage): void {\n    this._child?.send(message);\n  }\n}\n"]}

package/lib/createWatcher.d.ts

@@ -1,13 +1,14 @@
-export interface WatchOptions {
-    path: string;
-    watchPaths?: string[];
-}
-export interface Watcher {
-    watch(options: WatchOptions, onPackageChanged: () => void): () => Promise<void>;
-    unwatchAll(): Promise<void>;
-}
+import type { Watcher } from './types/Watcher.js';
 /**
- * Creates a watcher which can watch a package and notify the client when it changes.
+ * Create a file watcher. By default, the watcher will run in the main thread.
+ * Use `{ type: 'fork' }` to run the watcher in a forked process.
  */
-export declare function createWatcher(): Watcher;
+export declare function createWatcher(options?: {
+    /**
+     * By default, the watcher will run in the main thread.
+     * Specify `'fork'` to run the watcher in a forked process.
+     * @default 'default'
+     */
+    type?: 'default' | 'fork';
+}): Watcher;
 //# sourceMappingURL=createWatcher.d.ts.map

package/lib/createWatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createWatcher.d.ts","sourceRoot":"","sources":["../src/createWatcher.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,CAAC,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAQD;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CA4CvC"}
+{"version":3,"file":"createWatcher.d.ts","sourceRoot":"","sources":["../src/createWatcher.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE;IACtC;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC3B,GAAG,OAAO,CAKV"}

package/lib/createWatcher.js

@@ -1,47 +1,13 @@
-import chokidar from 'chokidar';
-import { resolve } from 'path';
-// TODO: This list of watched paths is hardcoded, but really it shouldn't be. In fact, this whole file
-// probably shouldn't be here. I think lage should be responsible for understanding what "bundle" means
-// (we can provide a definition) and what its inputs are and what it depends on. Then when we call
-// ensurePackageBundled, lage can ensure watching is happening for the full graph of tasks.
-const defaultWatchPaths = ['src/**', '*.json', '!**/node_modules/**'];
+import { DefaultWatcher } from './DefaultWatcher.js';
+import { ForkWatcher } from './ForkWatcher.js';
 /**
- * Creates a watcher which can watch a package and notify the client when it changes.
+ * Create a file watcher. By default, the watcher will run in the main thread.
+ * Use `{ type: 'fork' }` to run the watcher in a forked process.
  */
-export function createWatcher() {
-    const watchedPaths = new Set();
-    const watchers = new Set();
-    return {
-        watch(options, onPackageChanged) {
-            const { path, watchPaths = defaultWatchPaths } = options;
-            const paths = watchPaths.map((relPath) => resolve(path, relPath)).filter((p) => !watchedPaths.has(p));
-            let watcher;
-            if (paths.length) {
-                // Add paths to watchedPaths to avoid watching them again.
-                paths.forEach((p) => watchedPaths.add(p));
-                // Watch source and register a handler which will rebundle the changed package and notify the client on
-                // success. Note that if failures happen, the client will receive the error notification automatically.
-                watcher = chokidar.watch(paths).on('change', onPackageChanged);
-                watchers.add(watcher);
-            }
-            // Return a dispose function to individually clean up.
-            return async () => {
-                if (watcher) {
-                    const w = watcher;
-                    watcher = undefined;
-                    watchers.delete(w);
-                    for (const watchedPath of paths) {
-                        watchedPaths.delete(watchedPath);
-                    }
-                    await w.close();
-                }
-            };
-        },
-        async unwatchAll() {
-            await Promise.all(Array.from(watchers).map((w) => w.close()));
-            watchers.clear();
-            watchedPaths.clear();
-        },
-    };
+export function createWatcher(options) {
+    if (options?.type === 'fork') {
+        return new ForkWatcher();
+    }
+    return new DefaultWatcher();
 }
 //# sourceMappingURL=createWatcher.js.map

package/lib/createWatcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"createWatcher.js","sourceRoot":"","sources":["../src/createWatcher.ts"],"names":[],"mappings":"AACA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAY/B,sGAAsG;AACtG,uGAAuG;AACvG,kGAAkG;AAClG,2FAA2F;AAC3F,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,qBAAqB,CAAC,CAAC;AAEtE;;GAEG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IACvC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAa,CAAC;IAEtC,OAAO;QACL,KAAK,CAAC,OAAqB,EAAE,gBAA4B;YACvD,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,iBAAiB,EAAE,GAAG,OAAO,CAAC;YACzD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACtG,IAAI,OAA8B,CAAC;YAEnC,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;gBACjB,0DAA0D;gBAC1D,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBAE1C,uGAAuG;gBACvG,uGAAuG;gBACvG,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;gBAE/D,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACxB,CAAC;YAED,sDAAsD;YACtD,OAAO,KAAK,IAAI,EAAE;gBAChB,IAAI,OAAO,EAAE,CAAC;oBACZ,MAAM,CAAC,GAAG,OAAO,CAAC;oBAElB,OAAO,GAAG,SAAS,CAAC;oBACpB,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;oBAEnB,KAAK,MAAM,WAAW,IAAI,KAAK,EAAE,CAAC;wBAChC,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;oBACnC,CAAC;oBAED,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC;gBAClB,CAAC;YACH,CAAC,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,UAAU;YACd,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC9D,QAAQ,CAAC,KAAK,EAAE,CAAC;YACjB,YAAY,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { FSWatcher } from 'chokidar';\nimport chokidar from 'chokidar';\nimport { resolve } from 'path';\n\nexport interface WatchOptions {\n  path: string;\n  watchPaths?: string[];\n}\n\nexport interface Watcher {\n  watch(options: WatchOptions, onPackageChanged: () => void): () => Promise<void>;\n  unwatchAll(): Promise<void>;\n}\n\n// TODO: This list of watched paths is hardcoded, but really it shouldn't be. In fact, this whole file\n// probably shouldn't be here. I think lage should be responsible for understanding what \"bundle\" means\n// (we can provide a definition) and what its inputs are and what it depends on. Then when we call\n// ensurePackageBundled, lage can ensure watching is happening for the full graph of tasks.\nconst defaultWatchPaths = ['src/**', '*.json', '!**/node_modules/**'];\n\n/**\n * Creates a watcher which can watch a package and notify the client when it changes.\n */\nexport function createWatcher(): Watcher {\n  const watchedPaths = new Set<string>();\n  const watchers = new Set<FSWatcher>();\n\n  return {\n    watch(options: WatchOptions, onPackageChanged: () => void) {\n      const { path, watchPaths = defaultWatchPaths } = options;\n      const paths = watchPaths.map((relPath) => resolve(path, relPath)).filter((p) => !watchedPaths.has(p));\n      let watcher: FSWatcher | undefined;\n\n      if (paths.length) {\n        // Add paths to watchedPaths to avoid watching them again.\n        paths.forEach((p) => watchedPaths.add(p));\n\n        // Watch source and register a handler which will rebundle the changed package and notify the client on\n        // success. Note that if failures happen, the client will receive the error notification automatically.\n        watcher = chokidar.watch(paths).on('change', onPackageChanged);\n\n        watchers.add(watcher);\n      }\n\n      // Return a dispose function to individually clean up.\n      return async () => {\n        if (watcher) {\n          const w = watcher;\n\n          watcher = undefined;\n          watchers.delete(w);\n\n          for (const watchedPath of paths) {\n            watchedPaths.delete(watchedPath);\n          }\n\n          await w.close();\n        }\n      };\n    },\n\n    async unwatchAll() {\n      await Promise.all(Array.from(watchers).map((w) => w.close()));\n      watchers.clear();\n      watchedPaths.clear();\n    },\n  };\n}\n"]}
+{"version":3,"file":"createWatcher.js","sourceRoot":"","sources":["../src/createWatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG/C;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,OAO7B;IACC,IAAI,OAAO,EAAE,IAAI,KAAK,MAAM,EAAE,CAAC;QAC7B,OAAO,IAAI,WAAW,EAAE,CAAC;IAC3B,CAAC;IACD,OAAO,IAAI,cAAc,EAAE,CAAC;AAC9B,CAAC","sourcesContent":["import { DefaultWatcher } from './DefaultWatcher.js';\nimport { ForkWatcher } from './ForkWatcher.js';\nimport type { Watcher } from './types/Watcher.js';\n\n/**\n * Create a file watcher. By default, the watcher will run in the main thread.\n * Use `{ type: 'fork' }` to run the watcher in a forked process.\n */\nexport function createWatcher(options?: {\n  /**\n   * By default, the watcher will run in the main thread.\n   * Specify `'fork'` to run the watcher in a forked process.\n   * @default 'default'\n   */\n  type?: 'default' | 'fork';\n}): Watcher {\n  if (options?.type === 'fork') {\n    return new ForkWatcher();\n  }\n  return new DefaultWatcher();\n}\n"]}

package/lib/index.d.ts

@@ -1,3 +1,3 @@
+export type { Watcher, WatchOptions } from './types/Watcher.js';
 export { createWatcher } from './createWatcher.js';
-export type { Watcher, WatchOptions } from './createWatcher.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC","sourcesContent":["export { createWatcher } from './createWatcher.js';\nexport type { Watcher, WatchOptions } from './createWatcher.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC","sourcesContent":["export type { Watcher, WatchOptions } from './types/Watcher.js';\nexport { createWatcher } from './createWatcher.js';\n"]}

package/lib/types/WatchMessages.d.ts

@@ -0,0 +1,25 @@
+import type { WatchOptions, WatchOptionsWithId } from './Watcher.js';
+type WatchMessage = {
+    type: 'watch';
+    options: Required<WatchOptions>;
+};
+type UnwatchMessage = Pick<WatchOptionsWithId, 'id'> & {
+    type: 'unwatch';
+};
+type ShutdownMessage = {
+    type: 'shutdown';
+};
+/** Message from the parent to the child in `ForkWatcher` */
+export type ParentMessage = WatchMessage | UnwatchMessage | ShutdownMessage;
+type ChangeMessage = Pick<WatchOptionsWithId, 'id'> & {
+    type: 'change';
+    changedPath: string;
+};
+type ErrorMessage = {
+    type: 'error';
+    error: Error;
+};
+/** Message from the child to the parent in `ForkWatcher` */
+export type ChildMessage = ChangeMessage | ErrorMessage;
+export {};
+//# sourceMappingURL=WatchMessages.d.ts.map

package/lib/types/WatchMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WatchMessages.d.ts","sourceRoot":"","sources":["../../src/types/WatchMessages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAErE,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;CACjC,CAAC;AAEF,KAAK,cAAc,GAAG,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,GAAG;IACrD,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,cAAc,GAAG,eAAe,CAAC;AAE5E,KAAK,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,GAAG;IACpD,IAAI,EAAE,QAAQ,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,4DAA4D;AAC5D,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,YAAY,CAAC"}

package/lib/types/WatchMessages.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=WatchMessages.js.map

package/lib/types/WatchMessages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WatchMessages.js","sourceRoot":"","sources":["../../src/types/WatchMessages.ts"],"names":[],"mappings":"","sourcesContent":["import type { WatchOptions, WatchOptionsWithId } from './Watcher.js';\n\ntype WatchMessage = {\n  type: 'watch';\n  options: Required<WatchOptions>;\n};\n\ntype UnwatchMessage = Pick<WatchOptionsWithId, 'id'> & {\n  type: 'unwatch';\n};\n\ntype ShutdownMessage = {\n  type: 'shutdown';\n};\n\n/** Message from the parent to the child in `ForkWatcher` */\nexport type ParentMessage = WatchMessage | UnwatchMessage | ShutdownMessage;\n\ntype ChangeMessage = Pick<WatchOptionsWithId, 'id'> & {\n  type: 'change';\n  changedPath: string;\n};\n\ntype ErrorMessage = {\n  type: 'error';\n  error: Error;\n};\n\n/** Message from the child to the parent in `ForkWatcher` */\nexport type ChildMessage = ChangeMessage | ErrorMessage;\n"]}

package/lib/types/Watcher.d.ts

@@ -0,0 +1,36 @@
+export interface WatchOptions {
+    /**
+     * Absolute path to the root directory where watching should happen.
+     */
+    path: string;
+    /**
+     * ID for the watch job (defaults to `path`).
+     * If you call `watch` twice using the same `id`, subsequent calls will be ignored.
+     */
+    id?: string;
+    /**
+     * Path globs to watch, relative to `path`.
+     * Defaults to `['src/**', '*.json', '!**\/node_modules/**']`
+     */
+    watchPaths?: string[];
+}
+export type WatchOptionsWithId = WatchOptions & Required<Pick<WatchOptions, 'id'>>;
+/**
+ * Callback when a watched path changes.
+ * @param changedPath Absolute path to the file that changed.
+ */
+export type WatchChangeCallback = (changedPath: string) => void;
+/** Callback to unwatch a path */
+export type UnwatchCallback = () => void | Promise<void>;
+export interface Watcher {
+    /**
+     * Watch a path for changes.
+     * @returns Callback to unwatch the path.
+     */
+    watch(options: WatchOptions, onChange: WatchChangeCallback): UnwatchCallback;
+    /** Remove watchers for a specific ID (path) */
+    unwatch(id: string): Promise<void>;
+    /** Dispose all watchers. The Watcher object can't be reused afer this. */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=Watcher.d.ts.map

package/lib/types/Watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Watcher.d.ts","sourceRoot":"","sources":["../../src/types/Watcher.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC;AAEnF;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;AAEhE,iCAAiC;AACjC,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzD,MAAM,WAAW,OAAO;IACtB;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,mBAAmB,GAAG,eAAe,CAAC;IAE7E,+CAA+C;IAC/C,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC,0EAA0E;IAC1E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/lib/types/Watcher.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Watcher.js.map

package/lib/types/Watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Watcher.js","sourceRoot":"","sources":["../../src/types/Watcher.ts"],"names":[],"mappings":"","sourcesContent":["export interface WatchOptions {\n  /**\n   * Absolute path to the root directory where watching should happen.\n   */\n  path: string;\n\n  /**\n   * ID for the watch job (defaults to `path`).\n   * If you call `watch` twice using the same `id`, subsequent calls will be ignored.\n   */\n  id?: string;\n\n  /**\n   * Path globs to watch, relative to `path`.\n   * Defaults to `['src/**', '*.json', '!**\\/node_modules/**']`\n   */\n  watchPaths?: string[];\n}\n\nexport type WatchOptionsWithId = WatchOptions & Required<Pick<WatchOptions, 'id'>>;\n\n/**\n * Callback when a watched path changes.\n * @param changedPath Absolute path to the file that changed.\n */\nexport type WatchChangeCallback = (changedPath: string) => void;\n\n/** Callback to unwatch a path */\nexport type UnwatchCallback = () => void | Promise<void>;\n\nexport interface Watcher {\n  /**\n   * Watch a path for changes.\n   * @returns Callback to unwatch the path.\n   */\n  watch(options: WatchOptions, onChange: WatchChangeCallback): UnwatchCallback;\n\n  /** Remove watchers for a specific ID (path) */\n  unwatch(id: string): Promise<void>;\n\n  /** Dispose all watchers. The Watcher object can't be reused afer this. */\n  dispose(): Promise<void>;\n}\n"]}

package/lib/watcherForkWrapper.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watcherForkWrapper.d.ts.map

package/lib/watcherForkWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcherForkWrapper.d.ts","sourceRoot":"","sources":["../src/watcherForkWrapper.ts"],"names":[],"mappings":""}

package/lib/watcherForkWrapper.js

@@ -0,0 +1,38 @@
+import { DefaultWatcher } from './DefaultWatcher.js';
+/**
+ * `ForkWatcher` runs this file to initialize the watcher in a child process.
+ */
+function initializeWatcher() {
+    const watcher = new DefaultWatcher();
+    process.on('message', (message) => {
+        (async () => {
+            switch (message.type) {
+                case 'watch':
+                    {
+                        watcher.watch(message.options, (changedPath) => {
+                            sendMessage({ type: 'change', id: message.options.id, changedPath });
+                        });
+                    }
+                    break;
+                case 'unwatch':
+                    await watcher.unwatch(message.id);
+                    break;
+                case 'shutdown':
+                    await watcher.dispose();
+                    // eslint-disable-next-line no-restricted-properties -- rule isn't relevant for exiting a child process
+                    process.exit(0);
+            }
+        })().catch((error) => {
+            sendMessage({ type: 'error', error: error });
+        });
+    });
+}
+/** Typed wrapper for `process.send()` */
+function sendMessage(message) {
+    process.send?.(message);
+}
+// Prevent the process from exiting immediately.
+// This is handled by the parent process instead with the shutdown message.
+process.on('SIGINT', () => { });
+initializeWatcher();
+//# sourceMappingURL=watcherForkWrapper.js.map

package/lib/watcherForkWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcherForkWrapper.js","sourceRoot":"","sources":["../src/watcherForkWrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD;;GAEG;AACH,SAAS,iBAAiB;IACxB,MAAM,OAAO,GAAG,IAAI,cAAc,EAAE,CAAC;IAErC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAsB,EAAE,EAAE;QAC/C,CAAC,KAAK,IAAI,EAAE;YACV,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;gBACrB,KAAK,OAAO;oBACV,CAAC;wBACC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,EAAE;4BAC7C,WAAW,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;wBACvE,CAAC,CAAC,CAAC;oBACL,CAAC;oBACD,MAAM;gBAER,KAAK,SAAS;oBACZ,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;oBAClC,MAAM;gBAER,KAAK,UAAU;oBACb,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;oBACxB,uGAAuG;oBACvG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,CAAC;QACH,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAc,EAAE,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,yCAAyC;AACzC,SAAS,WAAW,CAAC,OAAqB;IACxC,OAAO,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC;AAC1B,CAAC;AAED,gDAAgD;AAChD,2EAA2E;AAC3E,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;AAE/B,iBAAiB,EAAE,CAAC","sourcesContent":["import { DefaultWatcher } from './DefaultWatcher.js';\nimport type { ChildMessage, ParentMessage } from './types/WatchMessages.js';\n\n/**\n * `ForkWatcher` runs this file to initialize the watcher in a child process.\n */\nfunction initializeWatcher() {\n  const watcher = new DefaultWatcher();\n\n  process.on('message', (message: ParentMessage) => {\n    (async () => {\n      switch (message.type) {\n        case 'watch':\n          {\n            watcher.watch(message.options, (changedPath) => {\n              sendMessage({ type: 'change', id: message.options.id, changedPath });\n            });\n          }\n          break;\n\n        case 'unwatch':\n          await watcher.unwatch(message.id);\n          break;\n\n        case 'shutdown':\n          await watcher.dispose();\n          // eslint-disable-next-line no-restricted-properties -- rule isn't relevant for exiting a child process\n          process.exit(0);\n      }\n    })().catch((error) => {\n      sendMessage({ type: 'error', error: error as Error });\n    });\n  });\n}\n\n/** Typed wrapper for `process.send()` */\nfunction sendMessage(message: ChildMessage) {\n  process.send?.(message);\n}\n\n// Prevent the process from exiting immediately.\n// This is handled by the parent process instead with the shutdown message.\nprocess.on('SIGINT', () => {});\n\ninitializeWatcher();\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ms-cloudpack/file-watcher",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "A file watcher abstraction for use with Cloudpack.",
   "license": "MIT",
   "type": "module",
@@ -18,6 +18,7 @@
     "chokidar": "^3.5.3"
   },
   "devDependencies": {
+    "@ms-cloudpack/environment": "*",
     "@ms-cloudpack/eslint-plugin-internal": "^0.0.1",
     "@ms-cloudpack/scripts": "^0.0.1",
     "@ms-cloudpack/test-utilities": "^0.5.0"