@danielx/civet 0.8.0 → 0.8.2

package/dist/civet

@@ -400,45 +400,27 @@ ${" ".repeat(error.column - 1)}^ ${error.header}`);
           }
           return callback(null, output);
         }
+        const parseOptions = {
+          ...options.parseOptions,
+          repl: true
+        };
         let ast;
         try {
-          ast = await (0, import_main.compile)(input, { ...options, filename, ast: true });
+          ast = await (0, import_main.compile)(input, { ...options, parseOptions, filename, ast: true });
         } catch (error) {
           showError2(error);
           return callback(null, void 0);
         }
-        const topLevelAwait = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast);
-        if (topLevelAwait) {
-          const [prologue, rest] = (0, import_main.parse)(input, {
-            startRule: "ProloguePrefix",
-            filename: "--civet argument"
-          });
-          const prefix = input.slice(0, -rest.length);
-          const coffee = prologue.some((p) => p.type === "CivetPrologue" && (p.config.coffeeCompat || p.config.coffeeDo));
-          ast = await (0, import_main.compile)(
-            prefix + (coffee ? "(do ->\n" : "async do\n") + rest.replace(/^/gm, " ") + (coffee ? ")" : ""),
-            { ...options, filename, ast: true }
-          );
-          import_main.lib.gatherRecursive(ast, ($) => $.type === "BlockStatement").forEach((topBlock) => {
-            return import_main.lib.gatherRecursiveWithinFunction(topBlock, ($1) => $1.type === "Declaration").forEach((decl) => {
-              const type = decl.children.shift();
-              if (!Array.isArray(ast)) {
-                ast = [ast];
-              }
-              return ast.unshift(`var ${decl.names.join(",")};`);
-            });
-          });
-        }
         let errors = [];
         try {
-          output = (0, import_main.generate)(ast, { errors });
+          output = (0, import_main.generate)(ast, { ...options, errors, sourceMap: void 0 });
         } catch (error) {
           console.error(error);
           return callback(null, void 0);
         }
         if (errors.length) {
           errors = [];
-          (0, import_main.generate)(ast, { errors, sourceMap: (0, import_main.SourceMap)(input) });
+          (0, import_main.generate)(ast, { ...options, errors, sourceMap: (0, import_main.SourceMap)(input) });
           showError2(errors[0]);
           return callback(null, void 0);
         }
@@ -451,7 +433,7 @@ ${" ".repeat(error.column - 1)}^ ${error.header}`);
         } catch (error) {
           return callback(error, void 0);
         }
-        if (topLevelAwait) {
+        if (ast.topLevelAwait) {
           let ok = true;
           try {
             return result = await result;
@@ -546,7 +528,8 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
     const unpluginOptions = {
       ...options,
       ts: options.js ? "civet" : "preserve",
-      outputExtension: ".tsx"
+      outputExtension: ".tsx",
+      declarationExtension: options.outputExt?.replace(/\.[jt]sx?$/i, ".d.ts")
     };
     (unpluginOptions.parseOptions ??= {}).rewriteCivetImports = ".civet.jsx";
     unplugin = (0, import_unplugin.rawPlugin)(unpluginOptions, { framework: "civet-cli" });
@@ -559,8 +542,16 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
   if (options.repl) {
     return repl(args, options);
   }
+  process.stdout.on("error", (e) => {
+    if (["EPIPE", "EOF"].includes(e.code)) {
+      return process.exit(0);
+    } else {
+      console.error(e);
+      return process.exit(1);
+    }
+  });
   let errors = 0;
-  for await (const { filename, error, content, stdin } of readFiles(filenames, options.eval)) {
+  for await (let { filename, error, content, stdin } of readFiles(filenames, options.eval)) {
     if (error) {
       console.error(`${filename} failed to load:`);
       console.error(error);
@@ -583,14 +574,6 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
       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) {
@@ -626,14 +609,24 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
         }
       }
     } else if (options.run) {
-      const esm = /^\s*(import|export)\b/m.test(output);
+      let ref1;
+      {
+        if (typeof output === "string" && /\b(await|import|export)\b/.test(output)) {
+          const ast = await (0, import_main.compile)(content, { ...options, ast: true, filename });
+          ref1 = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast) || import_main.lib.hasExportDeclaration(ast);
+        } else {
+          ref1 = void 0;
+        }
+      }
+      ;
+      const esm = ref1;
       if (esm) {
         if (stdin) {
-          const filename2 = `.stdin-${process.pid}.civet`;
+          filename = `.stdin-${process.pid}.civet`;
           try {
-            await import_promises.default.writeFile(filename2, content, { encoding });
+            await import_promises.default.writeFile(filename, content, { encoding });
           } catch (e) {
-            console.error(`Could not write ${filename2} for Civet ESM mode:`);
+            console.error(`Could not write ${filename} for Civet ESM mode:`);
             console.error(e);
             process.exit(1);
           }
@@ -706,9 +699,9 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
         }
       }, !filenames.length);
     } catch (error) {
-      let ref1;
-      if (ref1 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
-        const match = ref1;
+      let ref2;
+      if (ref2 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
+        const match = ref2;
         return process.exitCode = Math.min(255, errors + +match[1]);
       } else {
         process.exitCode = 1;