@effectionx/watch 0.1.1

package/script/watch.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watch = watch;
+const mod_js_1 = require("./deps/jsr.io/@std/fs/1.0.19/mod.js");
+const mod_js_2 = require("./deps/jsr.io/@std/path/1.1.2/mod.js");
+const chokidar_1 = __importDefault(require("chokidar"));
+const effection_1 = require("effection");
+const ignore_1 = __importDefault(require("ignore"));
+const pipe_js_1 = require("./deps/jsr.io/@gordonb/pipe/0.1.0/pipe.js");
+const promises_1 = require("node:fs/promises");
+const process_1 = require("@effectionx/process");
+const stream_helpers_js_1 = require("./stream-helpers.js");
+/**
+ * Create a watch configuration that observes file system changes and executes a command
+ * when changes are detected. The watch can be consumed as a stream of process starts.
+ *
+ * @example
+ * ```ts
+ * const watcher = yield* watch({
+ *  path: './src',
+ *  cmd: 'npm test'
+ * });
+ * ```
+ *
+ * @param options - Configuration options for the watch
+ * @param options.path - The directory path to watch for changes
+ * @param options.cmd - The command to execute when changes are detected
+ * @param options.event - The type of event to watch for ('all' or 'change', defaults to 'all')
+ *
+ * @returns A Stream that emits `Result<Process>` for each command execution
+ *
+ * @remarks
+ * - Uses chokidar for file system watching
+ * - Respects .gitignore patterns if present
+ * - Implements debouncing to prevent rapid successive executions
+ * - Filters out stale events using the fresh() function
+ *
+ * @throws Will throw an error if the process execution fails
+ *
+ * @see {@link WatchOptions} for configuration options
+ * @see {@link Process} for process execution details
+ */
+function watch(options) {
+    return (0, effection_1.resource)(function* (provide) {
+        let starts = (0, effection_1.createChannel)();
+        let input = (0, effection_1.createSignal)();
+        let gitignored = yield* findIgnores(options.path);
+        let watcher = chokidar_1.default.watch(options.path, {
+            ignored: (path) => {
+                let relpath = (0, mod_js_2.relative)(options.path, path);
+                let isGit = relpath === ".git" || relpath.startsWith(".git");
+                return isGit || gitignored(path);
+            },
+            ignoreInitial: true,
+        });
+        let { event = "all" } = options;
+        watcher.on(event, (...args) => {
+            if (event !== "all") {
+                args.unshift(event);
+            }
+            let [, path] = args;
+            if (fresh(500)(args) && !gitignored(path)) {
+                input.send(args);
+            }
+        });
+        let changes = yield* (0, pipe_js_1.pipe)(input, (0, stream_helpers_js_1.debounce)(100));
+        let subscription = yield* starts;
+        yield* (0, effection_1.spawn)(function* () {
+            while (true) {
+                let task = yield* (0, effection_1.spawn)(function* () {
+                    let restarting = (0, effection_1.withResolvers)();
+                    try {
+                        let process = yield* (0, process_1.exec)(options.cmd, options.execOptions);
+                        yield* starts.send({
+                            result: (0, effection_1.Ok)(process),
+                            restarting: restarting.operation,
+                        });
+                    }
+                    catch (error) {
+                        yield* starts.send({
+                            result: (0, effection_1.Err)(error),
+                            restarting: restarting.operation,
+                        });
+                    }
+                    yield* changes.next();
+                    restarting.resolve();
+                });
+                yield* task;
+            }
+        });
+        try {
+            yield* provide(subscription);
+        }
+        finally {
+            yield* (0, effection_1.until)(watcher.close());
+        }
+    });
+}
+/**
+ * locate a `.gitignore` file if it exists and use it to filter
+ * out any change events against paths that are matched by it
+ */
+function* findIgnores(path) {
+    let gitignore = (0, mod_js_2.join)(path, ".gitignore");
+    if (yield* (0, effection_1.call)(() => (0, mod_js_1.exists)(gitignore))) {
+        let ignores = (0, ignore_1.default)();
+        let buffer = yield* (0, effection_1.call)(() => (0, promises_1.readFile)(gitignore));
+        ignores.add(buffer.toString());
+        return (pathname) => {
+            let relativePathname = (0, mod_js_2.relative)(path, pathname).trim();
+            return relativePathname !== "" && ignores.ignores(relativePathname);
+        };
+    }
+    else {
+        return () => false;
+    }
+}
+function fresh(staletime) {
+    return ([, , stats]) => {
+        return !stats || Date.now() - stats.mtimeMs < staletime;
+    };
+}