@danielx/civet 0.11.9 → 0.11.11

package/dist/civet

@@ -111,6 +111,12 @@ async function parseArgs(args, isTTY = process.stdin.isTTY) {
         options.compile = true;
         break;
       }
+      case "-w":
+      case "--watch": {
+        options.watch = true;
+        options.compile = true;
+        break;
+      }
       case "-o":
       case "--output": {
         options.output = args[++i];
@@ -223,13 +229,21 @@ async function parseArgs(args, isTTY = process.stdin.isTTY) {
   if (options.typecheck || options.emitDeclaration) {
     options.typescript = true;
   }
+  if (options.watch && options.typescript) {
+    console.error(`--watch is not compatible with --typecheck or --emit-declaration`);
+    errors++;
+  }
+  if (options.watch && !filenames.some((f) => f !== "-")) {
+    console.error(`--watch requires one or more input filenames`);
+    errors++;
+  }
   if (options.maxErrors == null && process.env.CIVET_TYPECHECK_MAX_ERRORS) {
     const parsed = parseInt(process.env.CIVET_TYPECHECK_MAX_ERRORS, 10);
     if (!isNaN(parsed)) {
       options.maxErrors = parsed;
     }
   }
-  if (!(filenames.length || options.typescript || options.eval)) {
+  if (!(filenames.length || options.typescript || options.eval || options.watch)) {
     if (isTTY) {
       options.repl = true;
     } else {
@@ -269,55 +283,77 @@ async function parseArgs(args, isTTY = process.stdin.isTTY) {
   options.run = isRun();
   return { filenames, scriptArgs, options };
 }
-async function* readFiles(filenames, evalString) {
+function readFiles(filenames, evalString) {
+  if ((() => {
+    let results1 = 0;
+    for (const filename of filenames) {
+      if (!(filename === "-")) continue;
+      ++results1;
+    }
+    return results1;
+  })() > 1) {
+    return [
+      Promise.resolve({
+        filename: "<stdin>",
+        error: new Error("Cannot read from stdin more than once."),
+        stdin: true
+      })
+    ];
+  }
+  let reads = [];
   if (evalString != null) {
-    yield {
+    reads.push(Promise.resolve({
       filename: "<eval>",
       content: evalString + "\n",
       stdin: true
-    };
+    }));
   }
   for (let i2 = 0, len1 = filenames.length; i2 < len1; i2++) {
     let filename = filenames[i2];
-    const stdin = filename === "-";
-    try {
-      let content;
-      if (stdin) {
-        process.stdin.setEncoding(encoding);
-        filename = "<stdin>";
+    reads.push((async () => {
+      {
+        const stdin = filename === "-";
         try {
-          filename = await import_promises.default.realpath("/dev/stdin");
-        } catch (e) {
-        }
-        if (process.stdin.isTTY) {
-          const lines = [];
-          const rl = (await import("node:readline")).createInterface(process.stdin, process.stdout);
-          rl.on("line", (buffer) => lines.push(buffer + "\n"));
-          content = await new Promise((resolve, reject) => {
-            rl.on("SIGINT", () => {
-              return reject("^C");
-            });
-            return rl.on("close", () => {
-              return resolve(lines.join(""));
-            });
-          });
-        } else {
-          content = (await (async () => {
-            const results1 = [];
-            for await (const chunk of process.stdin) {
-              results1.push(chunk);
+          let content;
+          if (stdin) {
+            process.stdin.setEncoding(encoding);
+            filename = "<stdin>";
+            try {
+              filename = await import_promises.default.realpath("/dev/stdin");
+            } catch (e) {
+            }
+            if (process.stdin.isTTY) {
+              const lines = [];
+              const rl = (await import("node:readline")).createInterface(process.stdin, process.stdout);
+              rl.on("line", (buffer) => lines.push(buffer + "\n"));
+              content = await new Promise((resolve, reject) => {
+                rl.on("SIGINT", () => {
+                  return reject("^C");
+                });
+                return rl.on("close", () => {
+                  return resolve(lines.join(""));
+                });
+              });
+            } else {
+              content = (await (async () => {
+                const results2 = [];
+                for await (const chunk of process.stdin) {
+                  results2.push(chunk);
+                }
+                return results2;
+              })()).join("");
             }
-            return results1;
-          })()).join("");
+          } else {
+            content = await import_promises.default.readFile(filename, { encoding });
+          }
+          return { filename, content, stdin };
+        } catch (error) {
+          return { filename, error, stdin };
         }
-      } else {
-        content = await import_promises.default.readFile(filename);
       }
-      yield { filename, content, stdin };
-    } catch (error) {
-      yield { filename, error, stdin };
-    }
+    })());
   }
+  return reads;
 }
 function makeOutputFilename(filename, options) {
   let ref1;
@@ -427,8 +463,19 @@ async function repl(args, options) {
             if (error.errors != null) {
               error = error.errors[0];
             }
-            return console.log(`${input.split("\n").slice(0, error.line).join("\n")}
-${" ".repeat(error.column - 1)}^ ${error.header}`);
+            const parseError = error;
+            let ref3;
+            if (typeof parseError.line === "number") {
+              ref3 = parseError.line;
+            } else ref3 = 1;
+            const line = ref3;
+            let ref4;
+            if (typeof parseError.column === "number") {
+              ref4 = parseError.column;
+            } else ref4 = 1;
+            const column = ref4;
+            return console.log(`${input.split("\n").slice(0, line).join("\n")}
+${" ".repeat(column - 1)}^ ${parseError.header}`);
           } else {
             return console.error(error);
           }
@@ -557,6 +604,7 @@ Options:
   --version        Show the version number
   -o / --output XX Specify output directory and/or extension, or filename
   -c / --compile   Compile input files to TypeScript (or JavaScript)
+  -w / --watch     Watch input files and recompile on change (implies -c)
   -e / --eval XX   Evaluate specified code (or compile it with -c)
   --config XX      Specify a config file (default scans for a config.civet, civet.json, civetconfig.civet or civetconfig.json file, optionally in a .config directory, or starting with a .)
   --civet XX       Specify civet compiler flag, as in "civet XX" prologue
@@ -605,9 +653,9 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
         require("typescript");
       } catch {
         const modulePkg = require("node:module");
-        let ref3;
-        if (ref3 = __dirname.match(/([/\\]@danielx)?[/\\][cC]ivet[/\\]dist[/\\]?$/)) {
-          const match = ref3;
+        let ref5;
+        if (ref5 = __dirname.match(/([/\\]@danielx)?[/\\][cC]ivet[/\\]dist[/\\]?$/)) {
+          const match = ref5;
           if (match[1]) {
             modulePkg.globalPaths?.push(import_node_path.default.join(__dirname, "..", "..", ".."));
           } else {
@@ -653,132 +701,244 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
       }
     });
   }
-  let errors = 0;
-  for await (let { filename, error, content, stdin } of readFiles(filenames, options.eval)) {
-    if (error) {
-      console.error(`${filename} failed to load:`);
-      console.error(error);
-      errors++;
-      continue;
-    }
-    const outputFilename = makeOutputFilename(filename, options);
-    let output;
-    try {
-      if (unplugin != null) {
-        output = (await unplugin.load.call({
-          addWatchFile() {
-            ;
+  let errorCount = 0;
+  const results3 = [];
+  for (const result of readFiles(filenames, options.eval).map((readFile) => {
+    return (async () => {
+      {
+        let { filename, error: loadError, content, stdin } = await readFile;
+        const outputFilename = makeOutputFilename(filename, options);
+        const errors = [];
+        let stdout;
+        let output;
+        if (loadError) {
+          errors.push(`${filename} failed to load:`, loadError);
+        } else {
+          try {
+            if (unplugin != null) {
+              output = (await unplugin.load.call({
+                addWatchFile() {
+                  ;
+                }
+              }, `${filename}.tsx`)).code;
+            } else {
+              output = await (0, import_main.compile)(content, { ...options, filename, outputFilename });
+            }
+          } catch (error) {
+            errors.push(error);
           }
-        }, `${filename}.tsx`)).code;
-      } else {
-        output = await (0, import_main.compile)(content, { ...options, filename, outputFilename });
-      }
-    } catch (error2) {
-      console.error(error2);
-      errors++;
-      continue;
-    }
-    if (options.ast) {
-      process.stdout.write(JSON.stringify(output, null, 2));
-    } else if (options.compile) {
-      if (stdin && !options.output || options.output === "-") {
-        process.stdout.write(output);
-      } else {
-        const outputDir = import_node_path.default.dirname(outputFilename);
-        if (!(outputDir === ".")) {
-          await import_promises.default.mkdir(outputDir, { recursive: true });
         }
-        try {
-          await import_promises.default.writeFile(outputFilename, output);
-        } catch (error2) {
-          console.error(`${outputFilename} failed to write:`);
-          console.error(error2);
-          errors++;
+        if (!errors.length) {
+          output = output;
+          if (options.ast) {
+            stdout = JSON.stringify(output, null, 2);
+          } else if (options.compile) {
+            if (stdin && !options.output || options.output === "-") {
+              stdout = output;
+            } else {
+              const outputDir = import_node_path.default.dirname(outputFilename);
+              if (!(outputDir === ".")) {
+                await import_promises.default.mkdir(outputDir, { recursive: true });
+              }
+              try {
+                await import_promises.default.writeFile(outputFilename, output);
+              } catch (error) {
+                errors.push(`${outputFilename} failed to write:`, error);
+              }
+            }
+          } else if (options.run) {
+            let ref6;
+            {
+              if (typeof output === "string" && /\b(await|import|export)\b/.test(output)) {
+                const ast = await (0, import_main.compile)(content, { ...options, ast: true, filename });
+                ref6 = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast) || import_main.lib.hasExportDeclaration(ast);
+              } else {
+                ref6 = void 0;
+              }
+            }
+            ;
+            const esm = ref6;
+            if (esm) {
+              if (stdin) {
+                filename = `.stdin-${process.pid}.civet`;
+                try {
+                  await import_promises.default.writeFile(filename, content, { encoding });
+                } catch (e) {
+                  console.error(`Could not write ${filename} for Civet ESM mode:`);
+                  console.error(e);
+                  process.exit(1);
+                }
+              }
+              const { fork } = await import("node:child_process");
+              const { register } = await import("node:module");
+              let execArgv;
+              if (register) {
+                const { join } = await import("path");
+                const { pathToFileURL } = await import("node:url");
+                execArgv = [
+                  "--import",
+                  pathToFileURL(join(__dirname, "../register.js")).href
+                ];
+              } else {
+                execArgv = [
+                  "--loader",
+                  "@danielx/civet/esm",
+                  // ESM
+                  "--require",
+                  "@danielx/civet/register"
+                  // CJS
+                ];
+              }
+              const debugRe = /--debug|--inspect/;
+              const isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS ?? "");
+              if (isDebug) {
+                execArgv.push("--inspect=" + (process.debugPort + 1));
+              }
+              const child = fork(filename, [
+                ...scriptArgs
+              ], {
+                execArgv,
+                stdio: "inherit"
+              });
+              child.on("exit", async (code) => {
+                if (stdin) {
+                  await import_promises.default.unlink(filename);
+                }
+                return process.exit(code ?? 1);
+              });
+              for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+                process.on(signal, () => child.kill(signal));
+              }
+            } else {
+              await import("../register.js");
+              try {
+                module.filename = await import_promises.default.realpath(filename);
+              } catch {
+                module.filename = filename;
+              }
+              process.argv = ["civet", module.filename, ...scriptArgs];
+              module.paths = (await import("node:module"))._nodeModulePaths(import_node_path.default.dirname(module.filename));
+              try {
+                module._compile(output, module.filename);
+              } catch (error) {
+                console.error(`${filename} crashed while running in CJS mode:`);
+                console.error(error);
+                process.exit(1);
+              }
+            }
+          }
         }
+        return { errors, stdout };
       }
-    } else if (options.run) {
-      let ref4;
-      {
-        if (typeof output === "string" && /\b(await|import|export)\b/.test(output)) {
-          const ast = await (0, import_main.compile)(content, { ...options, ast: true, filename });
-          ref4 = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast) || import_main.lib.hasExportDeclaration(ast);
+    })();
+  })) {
+    const { errors, stdout } = await result;
+    if (stdout != null) {
+      process.stdout.write(stdout);
+    }
+    for (const error of errors) {
+      console.error(error);
+    }
+    if (errors.length) {
+      results3.push(errorCount++);
+    } else {
+      results3.push(void 0);
+    }
+  }
+  results3;
+  if (options.watch) {
+    const fsSync = (await import("node:fs")).default;
+    console.error(`Civet watching for changes... (Ctrl+C to stop)`);
+    const debounceTimers = /* @__PURE__ */ new Map();
+    const watchers = /* @__PURE__ */ new Map();
+    const rewatchTimers = /* @__PURE__ */ new Map();
+    const recompile = async (filename) => {
+      const outputFilename = makeOutputFilename(filename, options);
+      try {
+        const content = await import_promises.default.readFile(filename, encoding);
+        const output = await (0, import_main.compile)(content, { ...options, filename, outputFilename });
+        if (options.output === "-") {
+          process.stdout.write(output);
         } else {
-          ref4 = void 0;
+          const outputDir = import_node_path.default.dirname(outputFilename);
+          if (!(outputDir === ".")) {
+            await import_promises.default.mkdir(outputDir, { recursive: true });
+          }
+          await import_promises.default.writeFile(outputFilename, output);
+          console.error(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Compiled ${filename} -> ${outputFilename}`);
         }
+      } catch (error) {
+        console.error(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Failed to compile ${filename}:`);
+        console.error(error);
       }
-      ;
-      const esm = ref4;
-      if (esm) {
-        if (stdin) {
-          filename = `.stdin-${process.pid}.civet`;
-          try {
-            await import_promises.default.writeFile(filename, content, { encoding });
-          } catch (e) {
-            console.error(`Could not write ${filename} for Civet ESM mode:`);
-            console.error(e);
-            process.exit(1);
+    };
+    const scheduleRebuild = (filename) => {
+      const existing = debounceTimers.get(filename);
+      if (existing != null) {
+        clearTimeout(existing);
+      }
+      const cb = () => {
+        debounceTimers.delete(filename);
+        return void recompile(filename);
+      };
+      debounceTimers.set(filename, setTimeout(cb, 100));
+    };
+    const startWatching = (filename) => {
+      try {
+        const watcher = fsSync.watch(filename, (eventType) => {
+          if (!(eventType === "change" || eventType === "rename")) {
+            return;
           }
-        }
-        const { fork } = await import("node:child_process");
-        const { register } = await import("node:module");
-        let execArgv;
-        if (register) {
-          const { join } = await import("path");
-          const { pathToFileURL } = await import("node:url");
-          execArgv = [
-            "--import",
-            pathToFileURL(join(__dirname, "../register.js")).href
-          ];
-        } else {
-          execArgv = [
-            "--loader",
-            "@danielx/civet/esm",
-            // ESM
-            "--require",
-            "@danielx/civet/register"
-            // CJS
-          ];
-        }
-        const debugRe = /--debug|--inspect/;
-        const isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS ?? "");
-        if (isDebug) {
-          execArgv.push("--inspect=" + (process.debugPort + 1));
-        }
-        const child = fork(filename, [
-          ...scriptArgs
-        ], {
-          execArgv,
-          stdio: "inherit"
-        });
-        child.on("exit", async (code) => {
-          if (stdin) {
-            await import_promises.default.unlink(filename);
+          scheduleRebuild(filename);
+          if (eventType === "rename") {
+            watchers.get(filename)?.close();
+            watchers.delete(filename);
+            const existing = rewatchTimers.get(filename);
+            if (existing != null) {
+              clearTimeout(existing);
+            }
+            const timer = setTimeout(
+              () => {
+                rewatchTimers.delete(filename);
+                return startWatching(filename);
+              },
+              100
+            );
+            return rewatchTimers.set(filename, timer);
           }
-          return process.exit(code ?? 1);
+          ;
+          return;
         });
-        for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-          process.on(signal, () => child.kill(signal));
+        watchers.set(filename, watcher);
+      } catch (error) {
+        console.error(`Could not watch ${filename}:`);
+        console.error(error);
+      }
+    };
+    for (const filename of filenames) {
+      if (!fsSync.existsSync(filename)) {
+        continue;
+      }
+      startWatching(filename);
+    }
+    return {
+      close: () => {
+        for (const watcher of watchers.values()) {
+          watcher.close();
         }
-      } else {
-        await import("../register.js");
-        try {
-          module.filename = await import_promises.default.realpath(filename);
-        } catch {
-          module.filename = filename;
+        watchers.clear();
+        for (const timer of debounceTimers.values()) {
+          clearTimeout(timer);
         }
-        process.argv = ["civet", module.filename, ...scriptArgs];
-        module.paths = (await import("node:module"))._nodeModulePaths(import_node_path.default.dirname(module.filename));
-        try {
-          module._compile(output, module.filename);
-        } catch (error2) {
-          console.error(`${filename} crashed while running in CJS mode:`);
-          console.error(error2);
-          process.exit(1);
+        debounceTimers.clear();
+        for (const timer of rewatchTimers.values()) {
+          clearTimeout(timer);
         }
+        return rewatchTimers.clear();
       }
-    }
+    };
   }
-  process.exitCode = Math.min(255, errors);
+  process.exitCode = Math.min(255, errorCount);
   if (unplugin != null) {
     try {
       const pending = [];
@@ -797,10 +957,10 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
       }, !filenames.length);
       return await Promise.all(pending);
     } catch (error) {
-      let ref5;
-      if (ref5 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
-        const match = ref5;
-        return process.exitCode = Math.min(255, errors + +match[1]);
+      let ref7;
+      if (ref7 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
+        const match = ref7;
+        return process.exitCode = Math.min(255, errorCount + +match[1]);
       } else {
         process.exitCode = 1;
         throw error;