@danielx/civet 0.6.36 → 0.6.38

package/dist/bun-civet.mjs

@@ -2,11 +2,11 @@ import { plugin } from "bun";
 await plugin({
   name: "Civet loader",
   setup: async function(builder) {
-    ({ compile } = await import("./main.mjs"));
-    ({ readFileSync } = await import("fs"));
+    const { compile } = await import("./main.mjs");
+    const { readFileSync } = await import("fs");
     return builder.onLoad({ filter: /\.civet$/ }, function({ path }) {
-      source = readFileSync(path, "utf8");
-      contents = compile(source);
+      const source = readFileSync(path, "utf8");
+      const contents = compile(source);
       return {
         contents,
         loader: "tsx"

package/dist/civet

@@ -1,20 +1,39 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // source/cli.civet
 var import_main = require("./main.js");
 var import_config = require("./config.js");
-var prune;
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
 var version;
-var encoding;
-var fs;
-var path;
 var parseArgs;
 var readFiles;
 var repl;
 var cli;
 var indexOf = [].indexOf;
-({ prune } = import_main.generate);
 version = function() {
   return require("../package.json").version;
 };
@@ -60,9 +79,7 @@ if (process.argv.includes("--help")) {
 `);
   process.exit(0);
 }
-encoding = "utf8";
-fs = require("fs/promises");
-path = require("path");
+var encoding = "utf8";
 parseArgs = function(args) {
   var options, filenames, scriptArgs, i, endOfArgs, arg;
   options = {};
@@ -167,7 +184,7 @@ readFiles = async function* (filenames, options) {
         process.stdin.setEncoding(encoding);
         filename = "<stdin>";
         try {
-          filename = await fs.realpath("/dev/stdin");
+          filename = await import_promises.default.realpath("/dev/stdin");
         } catch (e) {
         }
         if (process.stdin.isTTY) {
@@ -196,7 +213,7 @@ readFiles = async function* (filenames, options) {
           })()).join("");
         }
       } else {
-        content = await fs.readFile(filename, { encoding });
+        content = await import_promises.default.readFile(filename, { encoding });
       }
       results1.push(yield { filename, content, stdin });
     } catch (error) {
@@ -284,7 +301,7 @@ repl = function(options) {
   });
 };
 cli = async function() {
-  var argv, filenames, scriptArgs, options, filename, error, content, stdin, output, outputPath, outputFilename, optionsPath, stat, esm, child;
+  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)));
   if (options.config !== false) {
@@ -330,7 +347,7 @@ cli = async function() {
       if (stdin && !options.output || options.output === "-") {
         results3.push(process.stdout.write(output));
       } else {
-        outputPath = path.parse(filename);
+        outputPath = import_path.default.parse(filename);
         delete outputPath.base;
         if (options.js) {
           outputPath.ext += ".jsx";
@@ -338,13 +355,13 @@ cli = async function() {
           outputPath.ext += ".tsx";
         }
         if (options.output) {
-          optionsPath = path.parse(options.output);
+          optionsPath = import_path.default.parse(options.output);
           try {
-            stat = await fs.stat(options.output);
+            stat = await import_promises.default.stat(options.output);
           } catch {
             stat = null;
           }
-          if (stat?.isDirectory() || options.output.endsWith(path.sep) || options.output.endsWith("/")) {
+          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;
@@ -356,11 +373,11 @@ cli = async function() {
           }
         }
         if (outputPath.dir) {
-          fs.mkdir(outputPath.dir, { recursive: true });
+          import_promises.default.mkdir(outputPath.dir, { recursive: true });
         }
-        outputFilename = path.format(outputPath);
+        outputFilename = import_path.default.format(outputPath);
         try {
-          results3.push(await fs.writeFile(outputFilename, output));
+          results3.push(await import_promises.default.writeFile(outputFilename, output));
         } catch (error2) {
           console.error(`${outputFilename} failed to write:`);
           results3.push(console.error(error2));
@@ -372,32 +389,45 @@ cli = async function() {
         if (stdin) {
           filename = `.stdin-${process.pid}.civet`;
           try {
-            await fs.writeFile(filename, content, { encoding });
+            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);
           }
         }
-        child = require("child_process").spawnSync(argv[0], [
-          "--loader",
-          "@danielx/civet/esm",
-          filename,
-          ...scriptArgs
-        ], { stdio: "inherit" });
-        if (stdin) {
-          await fs.unlink(filename);
+        ;
+        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);
+        if (process.env.NODE_OPTIONS) {
+          execArgv.push(process.env.NODE_OPTIONS);
+        }
+        if (isDebug) {
+          execArgv.push("--inspect=" + (process.debugPort + 1));
         }
-        results3.push(process.exit(child.status));
+        child = fork(filename, [
+          ...scriptArgs
+        ], {
+          execArgv,
+          stdio: "inherit"
+        });
+        results3.push(child.on("exit", async function(code) {
+          if (stdin) {
+            await import_promises.default.unlink(filename);
+          }
+          return process.exit(code ?? 1);
+        }));
       } else {
         require("../register.js");
         try {
-          module.filename = await fs.realpath(filename);
+          module.filename = await import_promises.default.realpath(filename);
         } catch {
           module.filename = filename;
         }
         process.argv = ["civet", module.filename, ...scriptArgs];
-        module.paths = require("module")._nodeModulePaths(path.dirname(module.filename));
+        module.paths = require("module")._nodeModulePaths(import_path.default.dirname(module.filename));
         try {
           results3.push(module._compile(output, module.filename));
         } catch (error2) {

package/dist/esbuild.js

@@ -37,6 +37,7 @@ module.exports = __toCommonJS(esbuild_exports);
 // src/index.ts
 var import_unplugin = require("unplugin");
 var import_civet = __toESM(require("@danielx/civet"));
+var import_ts_diagnostic = require("@danielx/civet/ts-diagnostic");
 var fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_typescript = __toESM(require("typescript"));
@@ -52,15 +53,19 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   if (options.dts && options.js) {
     throw new Error("Can't have both `dts` and `js` be set to `true`.");
   }
-  const transpileToJS = options.js ?? !options.dts;
+  if (options.typecheck && options.js) {
+    throw new Error("Can't have both `typecheck` and `js` be set to `true`.");
+  }
+  const transpileToJS = options.js ?? !(options.dts || options.typecheck);
   const outExt = options.outputExtension ?? (transpileToJS ? ".jsx" : ".tsx");
   let fsMap = /* @__PURE__ */ new Map();
+  const sourceMaps = /* @__PURE__ */ new Map();
   let compilerOptions;
   return {
     name: "unplugin-civet",
     enforce: "pre",
     async buildStart() {
-      if (options.dts) {
+      if (options.dts || options.typecheck) {
         const configPath = import_typescript.default.findConfigFile(process.cwd(), import_typescript.default.sys.fileExists);
         if (!configPath) {
           throw new Error("Could not find 'tsconfig.json'");
@@ -86,7 +91,7 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
       }
     },
     buildEnd() {
-      if (options.dts) {
+      if (options.dts || options.typecheck) {
         const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), import_typescript.default);
         const host = tsvfs.createVirtualCompilerHost(
           system,
@@ -98,20 +103,55 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
           options: compilerOptions,
           host: host.compilerHost
         });
-        for (const file of fsMap.keys()) {
-          const sourceFile = program.getSourceFile(file);
-          program.emit(
-            sourceFile,
-            (filePath, content) => {
-              this.emitFile({
-                source: content,
-                fileName: import_path.default.relative(process.cwd(), filePath),
-                type: "asset"
-              });
+        const diagnostics = import_typescript.default.getPreEmitDiagnostics(program).map((diagnostic) => {
+          const file = diagnostic.file;
+          if (!file)
+            return diagnostic;
+          const sourceMap = sourceMaps.get(file.fileName);
+          if (!sourceMap)
+            return diagnostic;
+          const sourcemapLines = sourceMap.data.lines;
+          const range = (0, import_ts_diagnostic.remapRange)(
+            {
+              start: diagnostic.start || 0,
+              end: (diagnostic.start || 0) + (diagnostic.length || 1)
             },
-            void 0,
-            true
+            sourcemapLines
           );
+          return {
+            ...diagnostic,
+            messageText: (0, import_ts_diagnostic.flattenDiagnosticMessageText)(diagnostic.messageText),
+            length: diagnostic.length,
+            start: range.start
+          };
+        });
+        if (diagnostics.length > 0) {
+          console.error(
+            import_typescript.default.formatDiagnosticsWithColorAndContext(diagnostics, formatHost)
+          );
+        }
+        if (options.dts) {
+          for (const file of fsMap.keys()) {
+            const sourceFile = program.getSourceFile(file);
+            program.emit(
+              sourceFile,
+              async (filePath, content) => {
+                const dir = import_path.default.dirname(filePath);
+                await fs.promises.mkdir(dir, { recursive: true });
+                const pathFromDistDir = import_path.default.relative(
+                  compilerOptions.outDir ?? process.cwd(),
+                  filePath
+                );
+                this.emitFile({
+                  source: content,
+                  fileName: pathFromDistDir,
+                  type: "asset"
+                });
+              },
+              void 0,
+              true
+            );
+          }
         }
       }
     },
@@ -135,13 +175,20 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
         return null;
       const filename = import_path.default.resolve(process.cwd(), id.slice(0, -outExt.length));
       const code = await fs.promises.readFile(filename, "utf-8");
+      const compiled = import_civet.default.compile(code, {
+        // inlineMap: true,
+        filename: id,
+        js: transpileToJS,
+        sourceMap: true
+      });
+      sourceMaps.set(import_path.default.resolve(process.cwd(), id), compiled.sourceMap);
+      const jsonSourceMap = compiled.sourceMap.json(
+        import_path.default.basename(id.replace(/\.[jt]sx$/, "")),
+        import_path.default.basename(id)
+      );
       let transformed = {
-        code: import_civet.default.compile(code, {
-          inlineMap: true,
-          filename: id,
-          js: transpileToJS
-        }),
-        map: null
+        code: compiled.code,
+        map: jsonSourceMap
       };
       if (options.transformOutput)
         transformed = await options.transformOutput(transformed.code, id);
@@ -150,8 +197,12 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
     transform(code, id) {
       if (!/\.civet\.tsx?$/.test(id))
         return null;
-      if (options.dts) {
-        fsMap.set(import_path.default.resolve(process.cwd(), id), code);
+      if (options.dts || options.typecheck) {
+        const resolved = import_path.default.resolve(process.cwd(), id);
+        fsMap.set(resolved, code);
+        const slash = resolved.replace(/\\/g, "/");
+        if (resolved !== slash)
+          fsMap.set(slash, code);
       }
       return null;
     },