@danielx/civet 0.6.69 → 0.6.71

package/dist/civet

@@ -28,15 +28,9 @@ var import_main = require("./main.js");
 var import_config = require("./config.js");
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
-var version;
-var parseArgs;
-var readFiles;
-var repl;
-var cli;
-var indexOf = [].indexOf;
-version = function() {
+function version() {
   return require("../package.json").version;
-};
+}
 if (process.argv.includes("--version")) {
   console.log(version());
   process.exit(0);
@@ -68,6 +62,7 @@ Options:
   -o / --output XX Specify output directory and/or extension, or filename
   -c / --compile   Compile input files to TypeScript (or JavaScript)
   --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
   --no-config      Don't scan for a config file
   --js             Strip out all type annotations; default to .jsx extension
   --ast            Print the AST instead of the compiled code
@@ -76,41 +71,42 @@ Options:
 
 You can use - to read from stdin or (prefixed by -o) write to stdout.
 
+By default, .civet imports get rewritten to use the output extension.
+You can override this behavior via: --civet rewriteCivetImports=.ext
+
 `);
   process.exit(0);
 }
 var encoding = "utf8";
-parseArgs = function(args) {
-  var options, filenames, scriptArgs, i, endOfArgs, arg;
-  options = {};
+function parseArgs(args) {
+  const options = {};
   Object.defineProperty(options, "run", {
     get: function() {
       return !(this.ast || this.compile);
     }
   });
-  filenames = [];
-  scriptArgs = null;
-  i = 0;
-  endOfArgs = function(j) {
+  const filenames = [];
+  let scriptArgs = [];
+  let i = 0;
+  function endOfArgs(j) {
     i = args.length;
     if (j >= args.length) {
       return;
     }
     if (options.run) {
       filenames.push(args[j]);
-      return scriptArgs = args.slice(j + 1);
+      scriptArgs = args.slice(j + 1);
     } else {
-      return filenames.push(...args.slice(j));
+      filenames.push(...args.slice(j));
     }
-  };
+  }
   while (i < args.length) {
-    arg = args[i];
+    const arg = args[i];
     if (/^-\w{2,}$/.test(arg)) {
       args.splice(i, 1 + i - i, ...(() => {
-        var char;
         const results = [];
         for (let ref = arg.slice(1), i1 = 0, len = ref.length; i1 < len; i1++) {
-          char = ref[i1];
+          const char = ref[i1];
           results.push(`-${char}`);
         }
         return results;
@@ -136,6 +132,15 @@ parseArgs = function(args) {
         options.config = false;
         break;
       }
+      case "--civet": {
+        Object.assign(
+          options.parseOptions ??= {},
+          (0, import_main.parse)(`civet ${args[++i]}`, {
+            startRule: "CivetPrologueContent"
+          }).config
+        );
+        break;
+      }
       case "--ast": {
         options.ast = true;
         break;
@@ -178,14 +183,14 @@ parseArgs = function(args) {
     i++;
   }
   return { filenames, scriptArgs, options };
-};
-readFiles = async function* (filenames, options) {
-  var filename, stdin, lines, rl, content;
+}
+async function* readFiles(filenames) {
   const results1 = [];
   for (let i2 = 0, len1 = filenames.length; i2 < len1; i2++) {
-    filename = filenames[i2];
-    stdin = filename === "-";
+    let filename = filenames[i2];
+    const stdin = filename === "-";
     try {
+      let content;
       if (stdin) {
         process.stdin.setEncoding(encoding);
         filename = "<stdin>";
@@ -194,24 +199,21 @@ readFiles = async function* (filenames, options) {
         } catch (e) {
         }
         if (process.stdin.isTTY) {
-          lines = [];
-          rl = require("readline").createInterface(process.stdin, process.stdout);
-          rl.on("line", function(buffer) {
-            return lines.push(buffer + "\n");
-          });
-          content = await new Promise(function(resolve, reject) {
-            rl.on("SIGINT", function() {
+          const lines = [];
+          const rl = (await import("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", function() {
+            return rl.on("close", () => {
               return resolve(lines.join(""));
             });
           });
         } else {
           content = (await (async () => {
-            var chunk;
             const results2 = [];
-            for await (chunk of process.stdin) {
+            for await (const chunk of process.stdin) {
               results2.push(chunk);
             }
             return results2;
@@ -227,9 +229,8 @@ readFiles = async function* (filenames, options) {
   }
   ;
   return results1;
-};
-repl = function(options) {
-  var nodeRepl, vm, r;
+}
+async function repl(options) {
   console.log(`Civet ${version()} REPL.  Enter a blank line to ${(() => {
     switch (false) {
       case !options.ast: {
@@ -243,12 +244,10 @@ repl = function(options) {
       }
     }
   })()} code.`);
-  global.quit = global.exit = function() {
-    return process.exit(0);
-  };
-  nodeRepl = require("repl");
-  vm = require("vm");
-  return r = nodeRepl.start({
+  global.quit = global.exit = () => process.exit(0);
+  const nodeRepl = await import("repl");
+  const vm = await import("vm");
+  const r = nodeRepl.start({
     prompt: (() => {
       switch (false) {
         case !options.ast: {
@@ -262,53 +261,54 @@ repl = function(options) {
         }
       }
     })(),
-    writer: options.ast ? function(obj) {
+    writer: options.ast ? (obj) => {
       try {
         return JSON.stringify(obj, null, 2);
       } catch (e) {
         console.log(`Failed to stringify: ${e}`);
-        return obj;
+        return "";
       }
-    } : options.compile ? function(obj) {
+    } : options.compile ? (obj) => {
       if (typeof obj === "string") {
         return obj?.replace(/\n*$/, "");
       } else {
-        return obj;
+        return "";
       }
     } : void 0,
     eval: function(input, context, filename, callback) {
-      var output, result;
       if (input === "\n") {
-        return callback(null);
-      } else if (indexOf.call(["quit\n", "exit\n", "quit()\n", "exit()\n"], input) >= 0) {
+        return callback(null, void 0);
+      } else if (input in ["quit\n", "exit\n", "quit()\n", "exit()\n"]) {
         return process.exit(0);
       } else if (input.endsWith("\n\n")) {
+        let output;
         try {
           output = (0, import_main.compile)(input, { ...options, filename });
         } catch (error) {
           console.error(error);
-          return callback("");
+          return callback(null, void 0);
         }
         if (options.compile || options.ast) {
           return callback(null, output);
         } else {
+          let result;
           try {
             result = vm.runInContext(output, context, { filename });
           } catch (error) {
-            return callback(error);
+            return callback(error, void 0);
           }
           return callback(null, result);
         }
       } else {
-        return callback(new nodeRepl.Recoverable("Enter a blank line to execute code."));
+        return callback(new nodeRepl.Recoverable(new Error("Enter a blank line to execute code.")), null);
       }
     }
   });
-};
-cli = async function() {
-  var argv, filenames, scriptArgs, options, filename, error, content, stdin, output, outputPath, outputFilename, optionsPath, stat, esm, execArgv, debugRe, isDebug, child;
-  argv = process.argv;
-  ({ filenames, scriptArgs, options } = parseArgs(argv.slice(2)));
+  return r;
+}
+async function cli() {
+  const argv = process.argv;
+  let { filenames, scriptArgs, options } = parseArgs(argv.slice(2));
   if (options.config !== false) {
     options.config ??= await (0, import_config.findConfig)(process.cwd());
   }
@@ -333,13 +333,37 @@ cli = async function() {
   if (options.repl) {
     return repl(options);
   }
+  let outputDir, outputExt, outputPath;
+  if (options.output) {
+    const optionsPath = import_path.default.parse(options.output);
+    let stat;
+    try {
+      stat = await import_promises.default.stat(options.output);
+    } catch {
+      stat = null;
+    }
+    if (stat?.isDirectory() || options.output.endsWith(import_path.default.sep) || options.output.endsWith("/")) {
+      outputDir = options.output;
+    } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
+      outputExt = optionsPath.base;
+      if (optionsPath.dir) {
+        outputDir = optionsPath.dir;
+      }
+    } else {
+      outputPath = optionsPath;
+    }
+    if (options.output !== "-") {
+      (options.parseOptions ??= {}).rewriteCivetImports ??= outputExt ?? ".civet" + (options.js ? ".jsx" : ".tsx");
+    }
+  }
   const results3 = [];
-  for await ({ filename, error, content, stdin } of readFiles(filenames, options)) {
+  for await (const { filename, error, content, stdin } of readFiles(filenames)) {
     if (error) {
       console.error(`${filename} failed to load:`);
       console.error(error);
       continue;
     }
+    let output;
     try {
       output = (0, import_main.compile)(content, { ...options, filename });
     } catch (error2) {
@@ -352,72 +376,63 @@ cli = async function() {
       if (stdin && !options.output || options.output === "-") {
         results3.push(process.stdout.write(output));
       } else {
-        outputPath = import_path.default.parse(filename);
-        delete outputPath.base;
+        let targetPath = import_path.default.parse(filename);
+        delete targetPath.base;
         if (options.js) {
-          outputPath.ext += ".jsx";
+          targetPath.ext += ".jsx";
         } else {
-          outputPath.ext += ".tsx";
+          targetPath.ext += ".tsx";
         }
-        if (options.output) {
-          optionsPath = import_path.default.parse(options.output);
-          try {
-            stat = await import_promises.default.stat(options.output);
-          } catch {
-            stat = null;
-          }
-          if (stat?.isDirectory() || options.output.endsWith(import_path.default.sep) || options.output.endsWith("/")) {
-            outputPath.dir = options.output;
-          } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
-            outputPath.ext = optionsPath.base;
-            if (optionsPath.dir) {
-              outputPath.dir = optionsPath.dir;
-            }
-          } else {
-            outputPath = optionsPath;
-          }
+        if (outputDir != null) {
+          targetPath.dir = outputDir;
+        }
+        if (outputExt != null) {
+          targetPath.ext = outputExt;
         }
-        if (outputPath.dir) {
-          import_promises.default.mkdir(outputPath.dir, { recursive: true });
+        if (outputPath != null) {
+          targetPath = outputPath;
         }
-        outputFilename = import_path.default.format(outputPath);
+        if (targetPath.dir) {
+          import_promises.default.mkdir(targetPath.dir, { recursive: true });
+        }
+        const targetFilename = import_path.default.format(targetPath);
         try {
-          results3.push(await import_promises.default.writeFile(outputFilename, output));
+          results3.push(await import_promises.default.writeFile(targetFilename, output));
         } catch (error2) {
-          console.error(`${outputFilename} failed to write:`);
+          console.error(`${targetFilename} failed to write:`);
           results3.push(console.error(error2));
         }
       }
     } else {
-      esm = /^\s*(import|export)\b/m.test(output);
+      const esm = /^\s*(import|export)\b/m.test(output);
       if (esm) {
         if (stdin) {
-          filename = `.stdin-${process.pid}.civet`;
+          const filename2 = `.stdin-${process.pid}.civet`;
           try {
-            await import_promises.default.writeFile(filename, content, { encoding });
+            await import_promises.default.writeFile(filename2, content, { encoding });
           } catch (e) {
-            console.error(`Could not write ${filename} for Civet ESM mode:`);
+            console.error(`Could not write ${filename2} for Civet ESM mode:`);
             console.error(e);
             process.exit(1);
           }
         }
         const { fork } = await import("child_process");
-        execArgv = ["--loader", "@danielx/civet/esm"];
-        debugRe = /--debug|--inspect/;
-        isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS);
+        const execArgv = ["--loader", "@danielx/civet/esm"];
+        const debugRe = /--debug|--inspect/;
+        const isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS ?? "");
         if (process.env.NODE_OPTIONS) {
           execArgv.push(process.env.NODE_OPTIONS);
         }
         if (isDebug) {
           execArgv.push("--inspect=" + (process.debugPort + 1));
         }
-        child = fork(filename, [
+        const child = fork(filename, [
           ...scriptArgs
         ], {
           execArgv,
           stdio: "inherit"
         });
-        results3.push(child.on("exit", async function(code) {
+        results3.push(child.on("exit", async (code) => {
           if (stdin) {
             await import_promises.default.unlink(filename);
           }
@@ -444,7 +459,7 @@ cli = async function() {
   }
   ;
   return results3;
-};
+}
 if (require.main === module) {
   cli();
 }