@danielx/civet 0.6.51 → 0.6.53

package/dist/esbuild.js

@@ -40,22 +40,15 @@ 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"));
 var tsvfs = __toESM(require("@typescript/vfs"));
 var import_os = __toESM(require("os"));
-var formatHost = {
-  getCurrentDirectory: () => import_typescript.default.sys.getCurrentDirectory(),
-  getNewLine: () => import_typescript.default.sys.newLine,
-  getCanonicalFileName: import_typescript.default.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
-};
-var isCivet = (id) => /\.civet$/.test(id);
-var isCivetTranspiled = (id) => /\.civet\.[jt]sx(\?transform)?$/.test(id);
-var isCivetTranspiledTS = (id) => /\.civet\.tsx$/.test(id);
-var postfixRE = /(\.[jt]sx)?[?#].*$/s;
+var isCivet = (id) => /\.civet([?#].*)?$/.test(id);
+var isCivetTranspiled = (id) => /\.civet\.[jt]sx([?#].*)?$/.test(id);
+var postfixRE = /[?#].*$/s;
 var isWindows = import_os.default.platform() === "win32";
 var windowsSlashRE = /\\/g;
 function cleanCivetId(id) {
-  return id.replace(postfixRE, "");
+  return id.replace(postfixRE, "").replace(/\.[jt]sx$/, "");
 }
 function tryStatSync(file) {
   try {
@@ -83,61 +76,69 @@ function resolveAbsolutePath(rootDir, id) {
   return resolved;
 }
 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`.");
-  }
-  if (options.typecheck && options.js) {
-    throw new Error("Can't have both `typecheck` and `js` be set to `true`.");
-  }
-  const transpileToJS = options.js ?? false;
-  const outExt = options.outputExtension ?? (transpileToJS ? ".jsx" : ".tsx");
+  if (options.dts)
+    options.emitDeclaration = options.dts;
+  if (options.js)
+    options.ts = "civet";
+  const transformTS = options.emitDeclaration || options.typecheck;
+  const outExt = options.outputExtension ?? (options.ts === "preserve" ? ".tsx" : ".jsx");
   let fsMap = /* @__PURE__ */ new Map();
   const sourceMaps = /* @__PURE__ */ new Map();
   let compilerOptions;
   let rootDir = process.cwd();
+  const tsPromise = transformTS || options.ts === "tsc" ? import("typescript").then((m) => m.default) : null;
+  const getFormatHost = (sys) => {
+    return {
+      getCurrentDirectory: () => sys.getCurrentDirectory(),
+      getNewLine: () => sys.newLine,
+      getCanonicalFileName: sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+    };
+  };
   return {
     name: "unplugin-civet",
     enforce: "pre",
     async buildStart() {
-      if (options.dts || options.typecheck) {
-        const configPath = import_typescript.default.findConfigFile(process.cwd(), import_typescript.default.sys.fileExists);
+      if (transformTS || options.ts === "tsc") {
+        const ts = await tsPromise;
+        const configPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists);
         if (!configPath) {
           throw new Error("Could not find 'tsconfig.json'");
         }
-        const { config, error } = import_typescript.default.readConfigFile(
+        const { config, error } = ts.readConfigFile(
           configPath,
-          import_typescript.default.sys.readFile
+          ts.sys.readFile
         );
         if (error) {
-          console.error(import_typescript.default.formatDiagnostic(error, formatHost));
+          console.error(ts.formatDiagnostic(error, getFormatHost(ts.sys)));
           throw error;
         }
-        const configContents = import_typescript.default.parseJsonConfigFileContent(
+        const configContents = ts.parseJsonConfigFileContent(
           config,
-          import_typescript.default.sys,
+          ts.sys,
           process.cwd()
         );
         compilerOptions = {
           ...configContents.options,
-          target: import_typescript.default.ScriptTarget.ESNext
+          target: ts.ScriptTarget.ESNext
         };
         fsMap = /* @__PURE__ */ new Map();
       }
     },
-    buildEnd() {
-      if (options.dts || options.typecheck) {
-        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), import_typescript.default);
+    async buildEnd() {
+      if (transformTS) {
+        const ts = await tsPromise;
+        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), ts);
         const host = tsvfs.createVirtualCompilerHost(
           system,
           compilerOptions,
-          import_typescript.default
+          ts
         );
-        const program = import_typescript.default.createProgram({
+        const program = ts.createProgram({
           rootNames: [...fsMap.keys()],
           options: compilerOptions,
           host: host.compilerHost
         });
-        const diagnostics = import_typescript.default.getPreEmitDiagnostics(program).map((diagnostic) => {
+        const diagnostics = ts.getPreEmitDiagnostics(program).map((diagnostic) => {
           const file = diagnostic.file;
           if (!file)
             return diagnostic;
@@ -161,10 +162,13 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
         });
         if (diagnostics.length > 0) {
           console.error(
-            import_typescript.default.formatDiagnosticsWithColorAndContext(diagnostics, formatHost)
+            ts.formatDiagnosticsWithColorAndContext(
+              diagnostics,
+              getFormatHost(ts.sys)
+            )
           );
         }
-        if (options.dts) {
+        if (options.emitDeclaration) {
           for (const file of fsMap.keys()) {
             const sourceFile = program.getSourceFile(file);
             program.emit(
@@ -209,16 +213,74 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
       if (!isCivetTranspiled(id))
         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 rawCivetSource = await fs.promises.readFile(filename, "utf-8");
       this.addWatchFile(filename);
-      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(
+      let compiled = void 0;
+      if (options.ts === "civet" && !transformTS) {
+        compiled = import_civet.default.compile(rawCivetSource, {
+          filename: id,
+          js: true,
+          sourceMap: true
+        });
+      } else {
+        const compiledTS = import_civet.default.compile(rawCivetSource, {
+          filename: id,
+          js: false,
+          sourceMap: true
+        });
+        sourceMaps.set(
+          import_path.default.resolve(process.cwd(), id),
+          compiledTS.sourceMap
+        );
+        if (transformTS) {
+          const resolved = import_path.default.resolve(process.cwd(), id);
+          fsMap.set(resolved, compiledTS.code);
+          const slashed = slash(resolved);
+          if (resolved !== slashed)
+            fsMap.set(slashed, rawCivetSource);
+        }
+        switch (options.ts) {
+          case "esbuild": {
+            const esbuildTransform = (await import("esbuild")).transform;
+            const result = await esbuildTransform(compiledTS.code, {
+              jsx: "preserve",
+              loader: "tsx",
+              sourcefile: id,
+              sourcemap: "external"
+            });
+            compiled = { code: result.code, sourceMap: result.map };
+            break;
+          }
+          case "tsc": {
+            const tsTranspile = (await tsPromise).transpileModule;
+            const result = tsTranspile(compiledTS.code, { compilerOptions });
+            compiled = {
+              code: result.outputText,
+              sourceMap: result.sourceMapText ?? ""
+            };
+            break;
+          }
+          case "preserve": {
+            compiled = compiledTS;
+            break;
+          }
+          case "civet":
+          default: {
+            compiled = import_civet.default.compile(rawCivetSource, {
+              filename: id,
+              js: true,
+              sourceMap: true
+            });
+            if (options.ts == void 0) {
+              console.log(
+                'WARNING: You are using the default mode for `options.ts` which is `"civet"`. This mode does not support all TS features. If this is intentional, you should explicitly set `options.ts` to `"civet"`, or choose a different mode.'
+              );
+            }
+            break;
+          }
+        }
+      }
+      const jsonSourceMap = typeof compiled.sourceMap == "string" ? compiled.sourceMap : compiled.sourceMap.json(
         import_path.default.basename(id.replace(/\.[jt]sx$/, "")),
         import_path.default.basename(id)
       );
@@ -230,33 +292,9 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
         transformed = await options.transformOutput(transformed.code, id);
       return transformed;
     },
-    transformInclude(id) {
-      return isCivetTranspiledTS(id);
-    },
-    transform(code, id) {
-      if (!isCivetTranspiledTS(id))
-        return null;
-      if (options.dts || options.typecheck) {
-        const resolved = import_path.default.resolve(process.cwd(), id);
-        fsMap.set(resolved, code);
-        const slashed = slash(resolved);
-        if (resolved !== slashed)
-          fsMap.set(slashed, code);
-      }
-      return null;
-    },
     vite: {
-      config(config, { command }) {
+      config(config) {
         rootDir = import_path.default.resolve(process.cwd(), config.root ?? "");
-        if (command === "build") {
-          return {
-            esbuild: {
-              include: [/\.civet$/],
-              loader: "tsx"
-            }
-          };
-        }
-        return null;
       },
       async transformIndexHtml(html) {
         return html.replace(