@kensio/yulin 1.6.0 → 1.7.0

package/dist/cli/watch/sim-watch-child.js

@@ -0,0 +1,62 @@
+import { simWatchMessages } from "../../watch/sim-watch.config.js";
+import { isWatchPathMessage } from "./sim-watch-child-message.js";
+import { SimWatchChildProcess } from "./sim-watch-child-process.js";
+import { SimWatchChildShutdown } from "./sim-watch-child-shutdown.js";
+/**
+ * One run of the supervised command.
+ *
+ * A restart is a new instance of this rather than anything swapped in place. A
+ * handler is a function reference out of the user's own module graph, and a new
+ * process re-imports it with no module cache to defeat, so a restart is correct
+ * by construction where an in-process swap would have to invalidate an import
+ * graph that ESM does not expose.
+ */
+export class SimWatchChild {
+    properties;
+    run;
+    startedAt = Date.now();
+    stopping = false;
+    onMessage = (message) => {
+        if (isWatchPathMessage(message, simWatchMessages.path)) {
+            this.properties.onPath(message.path);
+        }
+        if (isWatchPathMessage(message, simWatchMessages.heldPath)) {
+            this.properties.onHeldPath(message.path);
+        }
+    };
+    onProcessExit = (code, signal) => {
+        if (!this.stopping) {
+            this.properties.onExit(code, signal);
+        }
+    };
+    constructor(properties) {
+        this.properties = properties;
+        this.run = new SimWatchChildProcess(properties);
+        this.run.process.on("message", this.onMessage);
+        this.run.process.on("exit", this.onProcessExit);
+    }
+    /**
+     * How long this process has been running.
+     */
+    ranForMs() {
+        return Date.now() - this.startedAt;
+    }
+    /**
+     * Fail if the command could not be run at all, rather than letting it look
+     * like a process that started and stopped.
+     */
+    async started() {
+        await this.run.spawned;
+    }
+    /**
+     * Stop this process, giving it a moment to tell its browsers first.
+     */
+    async stop() {
+        this.stopping = true;
+        await new SimWatchChildShutdown({
+            process: this.run.process,
+            finished: this.run.finished,
+        }).stop();
+    }
+}
+//# sourceMappingURL=sim-watch-child.js.map

package/dist/cli/watch/sim-watch-child.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-child.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-child.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAYtE;;;;;;;;GAQG;AACH,MAAM,OAAO,aAAa;IACP,UAAU,CAA0B;IACpC,GAAG,CAAuB;IAC1B,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAChC,QAAQ,GAAG,KAAK,CAAC;IAER,SAAS,GAAG,CAAC,OAAgB,EAAQ,EAAE;QACtD,IAAI,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;YACvD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACvC,CAAC;QAED,IAAI,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC3D,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC,CAAC;IAEe,aAAa,GAAG,CAC/B,IAAmB,EACnB,MAA6B,EACvB,EAAE;QACR,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACvC,CAAC;IACH,CAAC,CAAC;IAEF,YAAY,UAAmC;QAC7C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,GAAG,GAAG,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;QAEhD,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC/C,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAErB,MAAM,IAAI,qBAAqB,CAAC;YAC9B,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO;YACzB,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,QAAQ;SAC5B,CAAC,CAAC,IAAI,EAAE,CAAC;IACZ,CAAC;CACF"}

package/dist/cli/watch/sim-watch-command.d.ts

@@ -0,0 +1,22 @@
+import { SimWatchReporter } from "./sim-watch-reporter.js";
+interface SimWatchCommandProperties {
+    readonly cwd?: string;
+    readonly reporter?: SimWatchReporter;
+}
+/**
+ * The `yulin watch` command.
+ *
+ * Ctrl-C is handled here rather than left to the default, because the default
+ * would take the supervisor down and leave the process it started running.
+ */
+export declare class SimWatchCommand {
+    private readonly cwd;
+    private readonly reporter;
+    constructor(properties?: SimWatchCommandProperties);
+    /**
+     * Run the command, and report the exit code it should leave behind.
+     */
+    run(argv: readonly string[]): Promise<number>;
+}
+export {};
+//# sourceMappingURL=sim-watch-command.d.ts.map

package/dist/cli/watch/sim-watch-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-command.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-command.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,UAAU,yBAAyB;IACjC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CACtC;AAED;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAE5C,YAAY,UAAU,GAAE,yBAA8B,EAKrD;IAED;;OAEG;IACG,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAoBlD;CACF"}

package/dist/cli/watch/sim-watch-command.js

@@ -0,0 +1,41 @@
+import { SimWatchArguments } from "./sim-watch-arguments.js";
+import { SimWatchReporter } from "./sim-watch-reporter.js";
+import { SimWatchSupervisor } from "./sim-watch-supervisor.js";
+/**
+ * The `yulin watch` command.
+ *
+ * Ctrl-C is handled here rather than left to the default, because the default
+ * would take the supervisor down and leave the process it started running.
+ */
+export class SimWatchCommand {
+    cwd;
+    reporter;
+    constructor(properties = {}) {
+        const { cwd = process.cwd(), reporter = new SimWatchReporter({ cwd }) } = properties;
+        this.cwd = cwd;
+        this.reporter = reporter;
+    }
+    /**
+     * Run the command, and report the exit code it should leave behind.
+     */
+    async run(argv) {
+        const supervisor = new SimWatchSupervisor({
+            watchArguments: SimWatchArguments.parse(argv),
+            cwd: this.cwd,
+            reporter: this.reporter,
+        });
+        const interrupt = () => {
+            supervisor.interrupt();
+        };
+        process.on("SIGINT", interrupt);
+        process.on("SIGTERM", interrupt);
+        try {
+            return await supervisor.run();
+        }
+        finally {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", interrupt);
+        }
+    }
+}
+//# sourceMappingURL=sim-watch-command.js.map

package/dist/cli/watch/sim-watch-command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-command.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAO/D;;;;;GAKG;AACH,MAAM,OAAO,eAAe;IACT,GAAG,CAAS;IACZ,QAAQ,CAAmB;IAE5C,YAAY,UAAU,GAA8B,EAAE;QACpD,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,GAAG,IAAI,gBAAgB,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GACrE,UAAU,CAAC;QACb,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,IAAuB;QAC/B,MAAM,UAAU,GAAG,IAAI,kBAAkB,CAAC;YACxC,cAAc,EAAE,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC;YAC7C,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;QAEH,MAAM,SAAS,GAAG,GAAS,EAAE;YAC3B,UAAU,CAAC,SAAS,EAAE,CAAC;QACzB,CAAC,CAAC;QAEF,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QAChC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAEjC,IAAI,CAAC;YACH,OAAO,MAAM,UAAU,CAAC,GAAG,EAAE,CAAC;QAChC,CAAC;gBAAS,CAAC;YACT,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;YACjC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;CACF"}

package/dist/cli/watch/sim-watch-event-path.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Works out which path a filesystem event was about.
+ *
+ * Node reports a watch event as the watched target plus a file name, and both
+ * halves have cases where that is not the whole story. A watch on a single file
+ * reports that file whatever name the event carries. A directory watch reports
+ * a change to the directory itself with no name at all, and on macOS with the
+ * directory's own name, neither of which says anything about a file in it.
+ *
+ * Wrong answers here are restarts nobody asked for, so this is kept apart from
+ * the watching and answered on its own.
+ */
+export declare class SimWatchEventPath {
+    private readonly target;
+    private readonly recursive;
+    constructor(target: string, recursive: boolean);
+    /**
+     * The path that changed, or nothing when the event named none.
+     */
+    of(fileName: string | null): string | undefined;
+    /**
+     * A directory holding a file of its own name is unusual but allowed, so the
+     * one that does not exist is the event about the directory.
+     */
+    private namesTheDirectoryItself;
+}
+//# sourceMappingURL=sim-watch-event-path.d.ts.map

package/dist/cli/watch/sim-watch-event-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-event-path.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-event-path.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IAEpC,YAAY,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAG7C;IAED;;OAEG;IACH,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAgB9C;IAED;;;OAGG;IACH,OAAO,CAAC,uBAAuB;CAUhC"}

package/dist/cli/watch/sim-watch-event-path.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Works out which path a filesystem event was about.
+ *
+ * Node reports a watch event as the watched target plus a file name, and both
+ * halves have cases where that is not the whole story. A watch on a single file
+ * reports that file whatever name the event carries. A directory watch reports
+ * a change to the directory itself with no name at all, and on macOS with the
+ * directory's own name, neither of which says anything about a file in it.
+ *
+ * Wrong answers here are restarts nobody asked for, so this is kept apart from
+ * the watching and answered on its own.
+ */
+export class SimWatchEventPath {
+    target;
+    recursive;
+    constructor(target, recursive) {
+        this.target = target;
+        this.recursive = recursive;
+    }
+    /**
+     * The path that changed, or nothing when the event named none.
+     */
+    of(fileName) {
+        if (!this.recursive) {
+            return this.target;
+        }
+        if (fileName === null || fileName.length === 0) {
+            return undefined;
+        }
+        const changedPath = path.join(this.target, fileName);
+        if (this.namesTheDirectoryItself(fileName, changedPath)) {
+            return undefined;
+        }
+        return changedPath;
+    }
+    /**
+     * A directory holding a file of its own name is unusual but allowed, so the
+     * one that does not exist is the event about the directory.
+     */
+    namesTheDirectoryItself(fileName, changedPath) {
+        return (fileName === path.basename(this.target) &&
+            // eslint-disable-next-line security/detect-non-literal-fs-filename
+            !fs.existsSync(changedPath));
+    }
+}
+//# sourceMappingURL=sim-watch-event-path.js.map

package/dist/cli/watch/sim-watch-event-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-event-path.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-event-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,iBAAiB;IACX,MAAM,CAAS;IACf,SAAS,CAAU;IAEpC,YAAY,MAAc,EAAE,SAAkB;QAC5C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,EAAE,CAAC,QAAuB;QACxB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;QAED,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/C,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAErD,IAAI,IAAI,CAAC,uBAAuB,CAAC,QAAQ,EAAE,WAAW,CAAC,EAAE,CAAC;YACxD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;OAGG;IACK,uBAAuB,CAC7B,QAAgB,EAChB,WAAmB;QAEnB,OAAO,CACL,QAAQ,KAAK,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;YACvC,mEAAmE;YACnE,CAAC,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,CAC5B,CAAC;IACJ,CAAC;CACF"}

package/dist/cli/watch/sim-watch-ignore.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decides which changed paths are worth restarting for.
+ *
+ * A watch that fires on everything under the working directory fires mostly on
+ * things the project generated, so the ignore list is what makes one save one
+ * restart rather than a stream of them.
+ */
+export declare class SimWatchIgnore {
+    /**
+     * Whether a changed path should be passed over.
+     */
+    ignores(changedPath: string): boolean;
+    private isCdkAsset;
+}
+//# sourceMappingURL=sim-watch-ignore.d.ts.map

package/dist/cli/watch/sim-watch-ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-ignore.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-ignore.ts"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CASpC;IAED,OAAO,CAAC,UAAU;CAUnB"}

package/dist/cli/watch/sim-watch-ignore.js

@@ -0,0 +1,64 @@
+import path from "node:path";
+// Directories nothing worth restarting for is ever written into. `dist` is on
+// the list because a dev script runs from source; a project that runs from its
+// build output is watching the build's inputs anyway.
+const ignoredDirectoryNames = new Set([
+    ".cache",
+    ".git",
+    ".idea",
+    ".next",
+    ".nyc_output",
+    ".tmp",
+    ".turbo",
+    ".vscode",
+    "coverage",
+    "dist",
+    "node_modules",
+]);
+// CDK writes each asset into its own directory inside its output directory.
+// The template there is worth watching and the copies of the handler code
+// beside it are not, since their source is being watched already.
+//
+// Only inside that output directory: `asset.` is an ordinary way to start the
+// name of a source file, and `src/asset.config.ts` is a file someone edits.
+const cdkOutputDirectoryName = "cdk.out";
+const cdkAssetPrefix = "asset.";
+// Editors write, rename and delete around the file being saved. Reacting to the
+// working files means restarting several times for one save, or restarting for
+// a file that is gone by the time anything reads it.
+const editorFilePatterns = [
+    /~$/u,
+    /^\.#/u,
+    /^#.*#$/u,
+    /\.sw[a-p]$/u,
+    /^\.goutputstream/u,
+    /^\d{4}$/u,
+    /^\.DS_Store$/u,
+];
+/**
+ * Decides which changed paths are worth restarting for.
+ *
+ * A watch that fires on everything under the working directory fires mostly on
+ * things the project generated, so the ignore list is what makes one save one
+ * restart rather than a stream of them.
+ */
+export class SimWatchIgnore {
+    /**
+     * Whether a changed path should be passed over.
+     */
+    ignores(changedPath) {
+        const segments = changedPath.split(path.sep).filter(Boolean);
+        const fileName = segments.at(-1) ?? "";
+        return (segments.some((segment) => ignoredDirectoryNames.has(segment)) ||
+            this.isCdkAsset(segments) ||
+            editorFilePatterns.some((pattern) => pattern.test(fileName)));
+    }
+    isCdkAsset(segments) {
+        const at = segments.indexOf(cdkOutputDirectoryName);
+        return (at !== -1 &&
+            segments
+                .slice(at + 1)
+                .some((segment) => segment.startsWith(cdkAssetPrefix)));
+    }
+}
+//# sourceMappingURL=sim-watch-ignore.js.map

package/dist/cli/watch/sim-watch-ignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-ignore.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-ignore.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,8EAA8E;AAC9E,+EAA+E;AAC/E,sDAAsD;AACtD,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC;IACpC,QAAQ;IACR,MAAM;IACN,OAAO;IACP,OAAO;IACP,aAAa;IACb,MAAM;IACN,QAAQ;IACR,SAAS;IACT,UAAU;IACV,MAAM;IACN,cAAc;CACf,CAAC,CAAC;AAEH,4EAA4E;AAC5E,0EAA0E;AAC1E,kEAAkE;AAClE,EAAE;AACF,8EAA8E;AAC9E,4EAA4E;AAC5E,MAAM,sBAAsB,GAAG,SAAS,CAAC;AACzC,MAAM,cAAc,GAAG,QAAQ,CAAC;AAEhC,gFAAgF;AAChF,+EAA+E;AAC/E,qDAAqD;AACrD,MAAM,kBAAkB,GAAG;IACzB,KAAK;IACL,OAAO;IACP,SAAS;IACT,aAAa;IACb,mBAAmB;IACnB,UAAU;IACV,eAAe;CAChB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,OAAO,cAAc;IACzB;;OAEG;IACH,OAAO,CAAC,WAAmB;QACzB,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC7D,MAAM,QAAQ,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAEvC,OAAO,CACL,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;YACzB,kBAAkB,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAC7D,CAAC;IACJ,CAAC;IAEO,UAAU,CAAC,QAA2B;QAC5C,MAAM,EAAE,GAAG,QAAQ,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAEpD,OAAO,CACL,EAAE,KAAK,CAAC,CAAC;YACT,QAAQ;iBACL,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC;iBACb,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CACzD,CAAC;IACJ,CAAC;CACF"}

package/dist/cli/watch/sim-watch-loop-guard.d.ts

@@ -0,0 +1,35 @@
+interface SimWatchLoopGuardProperties {
+    readonly selfInflictedMs?: number;
+    readonly loopRestarts?: number;
+}
+/**
+ * Thrown when a process keeps restarting itself.
+ */
+export declare class SimWatchRestartLoop extends Error {
+    readonly name = "SimWatchRestartLoop";
+    constructor(changedPath: string, restarts: number);
+}
+/**
+ * Spots a process that restarts itself.
+ *
+ * Setup that writes into a watched path, such as synthesizing a template or
+ * seeding a mounted Bucket directory, changes a file the supervisor is watching
+ * as a direct result of having started. Left alone that restarts forever, at
+ * whatever rate the setup takes, which looks like the machine being busy rather
+ * than like a mistake. A change arriving before the process has been up long,
+ * from the same path, several times in a row, is that and not a person typing.
+ */
+export declare class SimWatchLoopGuard {
+    private readonly selfInflictedMs;
+    private readonly loopRestarts;
+    private lastPath;
+    private consecutive;
+    constructor(properties?: SimWatchLoopGuardProperties);
+    /**
+     * Note a restart, and refuse one that is the process restarting itself.
+     */
+    check(changedPath: string, processRanForMs: number): void;
+    private selfInflicted;
+}
+export {};
+//# sourceMappingURL=sim-watch-loop-guard.d.ts.map

package/dist/cli/watch/sim-watch-loop-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-loop-guard.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-loop-guard.ts"],"names":[],"mappings":"AAEA,UAAU,2BAA2B;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,SAAyB,IAAI,yBAAyB;IAEtD,YAAY,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAMhD;CACF;AAED;;;;;;;;;GASG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,WAAW,CAAK;IAExB,YAAY,UAAU,GAAE,2BAAgC,EAOvD;IAED;;OAEG;IACH,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAYxD;IAED,OAAO,CAAC,aAAa;CAKtB"}

package/dist/cli/watch/sim-watch-loop-guard.js

@@ -0,0 +1,51 @@
+import { simWatchConfig } from "../../watch/sim-watch.config.js";
+/**
+ * Thrown when a process keeps restarting itself.
+ */
+export class SimWatchRestartLoop extends Error {
+    name = "SimWatchRestartLoop";
+    constructor(changedPath, restarts) {
+        super(`Restart loop: ${changedPath} changed straight after startup ${String(restarts)} times in a row. ` +
+            `Something in the process writes to a watched path, so watching it restarts the process, which writes to it again. ` +
+            `Write it outside the working directory, or to a directory watch ignores such as .tmp.`);
+    }
+}
+/**
+ * Spots a process that restarts itself.
+ *
+ * Setup that writes into a watched path, such as synthesizing a template or
+ * seeding a mounted Bucket directory, changes a file the supervisor is watching
+ * as a direct result of having started. Left alone that restarts forever, at
+ * whatever rate the setup takes, which looks like the machine being busy rather
+ * than like a mistake. A change arriving before the process has been up long,
+ * from the same path, several times in a row, is that and not a person typing.
+ */
+export class SimWatchLoopGuard {
+    selfInflictedMs;
+    loopRestarts;
+    lastPath;
+    consecutive = 0;
+    constructor(properties = {}) {
+        const { selfInflictedMs = simWatchConfig.selfInflictedMs, loopRestarts = simWatchConfig.loopRestarts, } = properties;
+        this.selfInflictedMs = selfInflictedMs;
+        this.loopRestarts = loopRestarts;
+    }
+    /**
+     * Note a restart, and refuse one that is the process restarting itself.
+     */
+    check(changedPath, processRanForMs) {
+        if (!this.selfInflicted(changedPath, processRanForMs)) {
+            this.lastPath = changedPath;
+            this.consecutive = 1;
+            return;
+        }
+        this.consecutive += 1;
+        if (this.consecutive >= this.loopRestarts) {
+            throw new SimWatchRestartLoop(changedPath, this.consecutive);
+        }
+    }
+    selfInflicted(changedPath, processRanForMs) {
+        return (changedPath === this.lastPath && processRanForMs < this.selfInflictedMs);
+    }
+}
+//# sourceMappingURL=sim-watch-loop-guard.js.map

package/dist/cli/watch/sim-watch-loop-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-loop-guard.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-loop-guard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAOjE;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IACnB,IAAI,GAAG,qBAAqB,CAAC;IAEtD,YAAY,WAAmB,EAAE,QAAgB;QAC/C,KAAK,CACH,iBAAiB,WAAW,mCAAmC,MAAM,CAAC,QAAQ,CAAC,mBAAmB;YAChG,oHAAoH;YACpH,uFAAuF,CAC1F,CAAC;IACJ,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,iBAAiB;IACX,eAAe,CAAS;IACxB,YAAY,CAAS;IAC9B,QAAQ,CAAqB;IAC7B,WAAW,GAAG,CAAC,CAAC;IAExB,YAAY,UAAU,GAAgC,EAAE;QACtD,MAAM,EACJ,eAAe,GAAG,cAAc,CAAC,eAAe,EAChD,YAAY,GAAG,cAAc,CAAC,YAAY,GAC3C,GAAG,UAAU,CAAC;QACf,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAmB,EAAE,eAAuB;QAChD,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,eAAe,CAAC,EAAE,CAAC;YACtD,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC;YAC5B,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;YACrB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC;QAEtB,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAC1C,MAAM,IAAI,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,WAAmB,EAAE,eAAuB;QAChE,OAAO,CACL,WAAW,KAAK,IAAI,CAAC,QAAQ,IAAI,eAAe,GAAG,IAAI,CAAC,eAAe,CACxE,CAAC;IACJ,CAAC;CACF"}

package/dist/cli/watch/sim-watch-reporter.d.ts

@@ -0,0 +1,38 @@
+interface SimWatchReporterProperties {
+    readonly write?: (line: string) => void;
+    readonly cwd?: string;
+}
+/**
+ * What `yulin watch` says in the terminal.
+ *
+ * It writes to standard error so the supervised process keeps standard output
+ * to itself, which matters when that output is being piped somewhere. Paths are
+ * reported relative to the working directory, since an absolute path in a
+ * restart line is mostly the part that has not changed.
+ */
+export declare class SimWatchReporter {
+    private readonly write;
+    private readonly cwd;
+    constructor(properties?: SimWatchReporterProperties);
+    /**
+     * Report the first start, so it is clear the supervisor is there.
+     */
+    started(command: string): void;
+    /**
+     * Report a restart, and what it cost.
+     */
+    restarted(changedPath: string, tookMs: number): void;
+    /**
+     * Report a process that stopped on its own, which is a setup error rather
+     * than a reason to stop watching.
+     */
+    exited(code: number | null, signal: NodeJS.Signals | null): void;
+    /**
+     * Report something that stops the watcher.
+     */
+    failed(error: Error): void;
+    private line;
+    private relative;
+}
+export {};
+//# sourceMappingURL=sim-watch-reporter.d.ts.map

package/dist/cli/watch/sim-watch-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-reporter.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-reporter.ts"],"names":[],"mappings":"AAEA,UAAU,0BAA0B;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YAAY,UAAU,GAAE,0BAA+B,EAStD;IAED;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED;;OAEG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAInD;IAED;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,GAAG,IAAI,CAI/D;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAEzB;IAED,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,QAAQ;CAajB"}

package/dist/cli/watch/sim-watch-reporter.js

@@ -0,0 +1,65 @@
+import path from "node:path";
+/**
+ * What `yulin watch` says in the terminal.
+ *
+ * It writes to standard error so the supervised process keeps standard output
+ * to itself, which matters when that output is being piped somewhere. Paths are
+ * reported relative to the working directory, since an absolute path in a
+ * restart line is mostly the part that has not changed.
+ */
+export class SimWatchReporter {
+    write;
+    cwd;
+    constructor(properties = {}) {
+        const { write = (line) => {
+            process.stderr.write(line);
+        }, cwd = process.cwd(), } = properties;
+        this.write = write;
+        this.cwd = cwd;
+    }
+    /**
+     * Report the first start, so it is clear the supervisor is there.
+     */
+    started(command) {
+        this.line(`watching ${this.relative(this.cwd)}, running ${command}`);
+    }
+    /**
+     * Report a restart, and what it cost.
+     */
+    restarted(changedPath, tookMs) {
+        this.line(`restarted in ${String(Math.round(tookMs))}ms after ${this.relative(changedPath)}`);
+    }
+    /**
+     * Report a process that stopped on its own, which is a setup error rather
+     * than a reason to stop watching.
+     */
+    exited(code, signal) {
+        this.line(`process exited (${describeExit(code, signal)}), waiting for a change`);
+    }
+    /**
+     * Report something that stops the watcher.
+     */
+    failed(error) {
+        this.line(error.message);
+    }
+    line(message) {
+        this.write(`yulin watch: ${message}\n`);
+    }
+    relative(target) {
+        const relative = path.relative(this.cwd, target);
+        if (relative.length === 0) {
+            return ".";
+        }
+        if (relative.startsWith("..")) {
+            return target;
+        }
+        return relative;
+    }
+}
+function describeExit(code, signal) {
+    if (signal !== null) {
+        return signal;
+    }
+    return `code ${String(code ?? 0)}`;
+}
+//# sourceMappingURL=sim-watch-reporter.js.map

package/dist/cli/watch/sim-watch-reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-reporter.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-reporter.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAO7B;;;;;;;GAOG;AACH,MAAM,OAAO,gBAAgB;IACV,KAAK,CAAyB;IAC9B,GAAG,CAAS;IAE7B,YAAY,UAAU,GAA+B,EAAE;QACrD,MAAM,EACJ,KAAK,GAAG,CAAC,IAAY,EAAQ,EAAE;YAC7B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC,EACD,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,GACpB,GAAG,UAAU,CAAC;QACf,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,OAAe;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,OAAO,EAAE,CAAC,CAAC;IACvE,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,WAAmB,EAAE,MAAc;QAC3C,IAAI,CAAC,IAAI,CACP,gBAAgB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,YAAY,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CACnF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,IAAmB,EAAE,MAA6B;QACvD,IAAI,CAAC,IAAI,CACP,mBAAmB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,yBAAyB,CACvE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAY;QACjB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAEO,IAAI,CAAC,OAAe;QAC1B,IAAI,CAAC,KAAK,CAAC,gBAAgB,OAAO,IAAI,CAAC,CAAC;IAC1C,CAAC;IAEO,QAAQ,CAAC,MAAc;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAEjD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC;QACb,CAAC;QAED,IAAI,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9B,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF;AAED,SAAS,YAAY,CACnB,IAAmB,EACnB,MAA6B;IAE7B,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,QAAQ,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC;AACrC,CAAC"}

package/dist/cli/watch/sim-watch-restarts.d.ts

@@ -0,0 +1,30 @@
+interface SimWatchRestartsProperties {
+    readonly restart: (changedPath: string) => Promise<void>;
+    readonly onFailure: (error: unknown) => void;
+}
+/**
+ * Runs restarts one at a time, and does not lose an edit made during one.
+ *
+ * Changes arrive whenever they arrive, and a restart takes as long as the
+ * project takes to start. Running two at once would leave two processes racing
+ * for the same port, and dropping the second would mean a save silently doing
+ * nothing, so a change that arrives mid-restart waits for its turn.
+ *
+ * Only the latest is kept. A restart takes whatever is on disk at the time, so
+ * two changes queued behind one restart are one restart.
+ */
+export declare class SimWatchRestarts {
+    private readonly restart;
+    private readonly onFailure;
+    private running;
+    private queuedPath;
+    constructor(properties: SimWatchRestartsProperties);
+    /**
+     * Restart for a change, now or as soon as the current restart is done.
+     */
+    request(changedPath: string): void;
+    private run;
+    private drain;
+}
+export {};
+//# sourceMappingURL=sim-watch-restarts.d.ts.map

package/dist/cli/watch/sim-watch-restarts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-restarts.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-restarts.ts"],"names":[],"mappings":"AAAA,UAAU,0BAA0B;IAClC,QAAQ,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C;AAED;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IACjE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IACrD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAqB;IAEvC,YAAY,UAAU,EAAE,0BAA0B,EAIjD;IAED;;OAEG;IACH,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAYjC;YAEa,GAAG;YAgBH,KAAK;CAYpB"}

package/dist/cli/watch/sim-watch-restarts.js

@@ -0,0 +1,62 @@
+/**
+ * Runs restarts one at a time, and does not lose an edit made during one.
+ *
+ * Changes arrive whenever they arrive, and a restart takes as long as the
+ * project takes to start. Running two at once would leave two processes racing
+ * for the same port, and dropping the second would mean a save silently doing
+ * nothing, so a change that arrives mid-restart waits for its turn.
+ *
+ * Only the latest is kept. A restart takes whatever is on disk at the time, so
+ * two changes queued behind one restart are one restart.
+ */
+export class SimWatchRestarts {
+    restart;
+    onFailure;
+    running = false;
+    queuedPath;
+    constructor(properties) {
+        const { restart, onFailure } = properties;
+        this.restart = restart;
+        this.onFailure = onFailure;
+    }
+    /**
+     * Restart for a change, now or as soon as the current restart is done.
+     */
+    request(changedPath) {
+        if (this.running) {
+            this.queuedPath = changedPath;
+            return;
+        }
+        this.running = true;
+        // eslint-disable-next-line unicorn/prefer-await
+        this.run(changedPath).catch((error) => {
+            this.onFailure(error);
+        });
+    }
+    async run(changedPath) {
+        try {
+            await this.restart(changedPath);
+        }
+        catch (error) {
+            // A restart that failed is the end of this run. Whatever asked for it
+            // decides what happens next, and a change queued behind it would be a
+            // restart nobody is waiting for any more.
+            this.queuedPath = undefined;
+            throw error;
+        }
+        finally {
+            this.running = false;
+        }
+        await this.drain();
+    }
+    async drain() {
+        const queuedPath = this.queuedPath;
+        this.queuedPath = undefined;
+        if (queuedPath === undefined) {
+            return;
+        }
+        this.running = true;
+        await this.run(queuedPath);
+    }
+}
+//# sourceMappingURL=sim-watch-restarts.js.map

package/dist/cli/watch/sim-watch-restarts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-restarts.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-restarts.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,gBAAgB;IACV,OAAO,CAAyC;IAChD,SAAS,CAA2B;IAC7C,OAAO,GAAG,KAAK,CAAC;IAChB,UAAU,CAAqB;IAEvC,YAAY,UAAsC;QAChD,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,UAAU,CAAC;QAC1C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,WAAmB;QACzB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,gDAAgD;QAChD,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;YAC7C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,GAAG,CAAC,WAAmB;QACnC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAClC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,sEAAsE;YACtE,sEAAsE;YACtE,0CAA0C;YAC1C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC5B,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;QAED,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAEO,KAAK,CAAC,KAAK;QACjB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAE5B,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,MAAM,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC7B,CAAC;CACF"}