@danielx/civet 0.7.4 → 0.7.6

package/dist/bun-civet.mjs

@@ -3,10 +3,10 @@ await plugin({
   name: "Civet loader",
   setup: async function(builder) {
     const { compile } = await import("./main.mjs");
-    const { readFileSync } = await import("fs");
-    return builder.onLoad({ filter: /\.civet$/ }, function({ path }) {
-      const source = readFileSync(path, "utf8");
-      const contents = compile(source);
+    const { readFile } = await import("node:fs/promises");
+    return builder.onLoad({ filter: /\.civet$/ }, async function({ path }) {
+      const source = await readFile(path, "utf8");
+      const contents = await compile(source, { comptime: true });
       return {
         contents,
         loader: "tsx"

package/dist/civet

@@ -228,7 +228,7 @@ async function* readFiles(filenames) {
         }
         if (process.stdin.isTTY) {
           const lines = [];
-          const rl = (await import("readline")).createInterface(process.stdin, process.stdout);
+          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", () => {
@@ -259,11 +259,11 @@ async function* readFiles(filenames) {
   return results1;
 }
 async function repl(options) {
-  const vm = await import("vm");
+  const vm = await import("node:vm");
   let importModuleDynamically = vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER;
   if (!importModuleDynamically) {
     if (vm.SourceTextModule != null) {
-      const { pathToFileURL } = await import("url");
+      const { pathToFileURL } = await import("node:url");
       importModuleDynamically = (specifier) => {
         if (/^\.\.?[/\\]/.test(specifier)) {
           return import(pathToFileURL(import_path.default.join(process.cwd(), specifier)));
@@ -273,11 +273,11 @@ async function repl(options) {
       };
     } else {
       const execArgv = ["--experimental-vm-modules"];
-      const { register } = await import("module");
+      const { register } = await import("node:module");
       if (process.env.NODE_OPTIONS) {
         execArgv.push(process.env.NODE_OPTIONS);
       }
-      const { fork } = await import("child_process");
+      const { fork } = await import("node:child_process");
       fork(__filename, process.argv.slice(2), {
         execArgv,
         stdio: "inherit"
@@ -300,7 +300,7 @@ async function repl(options) {
     }
   })()} code.`);
   global.quit = global.exit = () => process.exit(0);
-  const nodeRepl = await import("repl");
+  const nodeRepl = await import("node:repl");
   const r = nodeRepl.start({
     prompt: (() => {
       switch (false) {
@@ -346,20 +346,20 @@ async function repl(options) {
         let output;
         if (options.compile || options.ast) {
           try {
-            output = (0, import_main.compile)(input, { ...options, filename });
+            output = await (0, import_main.compile)(input, { ...options, filename });
           } catch (error) {
             console.error(error);
             return callback(null, void 0);
           }
           return callback(null, output);
         }
-        let ast = (0, import_main.compile)(input, { ...options, filename, ast: true });
+        let ast = await (0, import_main.compile)(input, { ...options, filename, ast: true });
         const topLevelAwait = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast);
         if (topLevelAwait) {
           const [prologue, rest] = (0, import_main.parse)(input, { startRule: "ProloguePrefix" });
           const prefix = input.slice(0, -rest.length);
           const coffee = prologue.some((p) => p.type === "CivetPrologue" && (p.config.coffeeCompat || p.config.coffeeDo));
-          ast = (0, import_main.compile)(
+          ast = await (0, import_main.compile)(
             prefix + (coffee ? "(do ->\n" : "async do\n") + rest.replace(/^/gm, " ") + (coffee ? ")" : ""),
             { ...options, filename, ast: true }
           );
@@ -493,13 +493,21 @@ async function cli() {
           }
         }, `${filename}.tsx`)).code;
       } else {
-        output = (0, import_main.compile)(content, { ...options, filename });
+        output = await (0, import_main.compile)(content, { ...options, filename });
       }
     } catch (error2) {
       console.error(error2);
       errors++;
       continue;
     }
+    process.stdout.on("error", (e) => {
+      if (["EPIPE", "EOF"].includes(e.code)) {
+        return process.exit(0);
+      } else {
+        console.error(e);
+        return process.exit(1);
+      }
+    });
     if (options.ast) {
       process.stdout.write(JSON.stringify(output, null, 2));
     } else if (options.compile) {
@@ -547,8 +555,8 @@ async function cli() {
             process.exit(1);
           }
         }
-        const { fork } = await import("child_process");
-        const { register } = await import("module");
+        const { fork } = await import("node:child_process");
+        const { register } = await import("node:module");
         let execArgv;
         if (register) {
           execArgv = ["--import", "@danielx/civet/register"];

package/dist/config.js

@@ -96,7 +96,10 @@ async function loadConfig(path2) {
   } else {
     let js;
     try {
-      js = (0, import_main.compile)(config, { js: true });
+      js = (0, import_main.compile)(config, {
+        js: true,
+        sync: true
+      });
     } catch (e) {
       throw new Error(`Error compiling Civet config file ${path2}: ${e}`);
     }

package/dist/esbuild-plugin.js

@@ -90,7 +90,7 @@ var civet = function(options = {}) {
         try {
           const source = await (0, import_promises.readFile)(args.path, "utf8");
           const filename = import_path.default.relative(process.cwd(), args.path);
-          const compiled = (0, import_main.compile)(source, {
+          const compiled = await (0, import_main.compile)(source, {
             filename,
             inlineMap,
             js

package/dist/esbuild.js

@@ -166,9 +166,9 @@ var rawPlugin = (options = {}, meta) => {
           const compiledTS = import_civet.default.compile(rawCivetSource, {
             filename,
             js: false,
-            parseOptions: {
-              comptime: Boolean(options.comptime)
-            }
+            comptime: Boolean(options.comptime),
+            sync: true
+            // TS readFile API seems to need to be synchronous
           });
           fsMap.set(filename, compiledTS);
           return compiledTS;
@@ -321,12 +321,12 @@ var rawPlugin = (options = {}, meta) => {
         }
       };
       if (options.ts === "civet" && !transformTS) {
-        compiled = import_civet.default.compile(rawCivetSource, {
+        compiled = await import_civet.default.compile(rawCivetSource, {
           ...civetOptions,
           js: true
         });
       } else {
-        const compiledTS = import_civet.default.compile(rawCivetSource, {
+        const compiledTS = await import_civet.default.compile(rawCivetSource, {
           ...civetOptions,
           js: false
         });
@@ -372,7 +372,7 @@ var rawPlugin = (options = {}, meta) => {
           }
           case "civet":
           default: {
-            compiled = import_civet.default.compile(rawCivetSource, {
+            compiled = await import_civet.default.compile(rawCivetSource, {
               ...civetOptions,
               js: true
             });

package/dist/esm.mjs

@@ -50,7 +50,7 @@ async function load(url, context, next) {
   if (context.format === "civet") {
     const path = fileURLToPath(url);
     const source = readFileSync(path, "utf8");
-    const { code: tsSource, sourceMap } = compile(source, {
+    const { code: tsSource, sourceMap } = await compile(source, {
       filename: path,
       sourceMap: true,
       js: true