@danielx/civet 0.8.11 → 0.8.13

package/dist/types.d.ts

@@ -49,6 +49,9 @@ declare module "@danielx/civet" {
     trace?: string
     parseOptions?: ParseOptions
   }
+  export type GenerateOptions = Omit<CompileOptions, "sourceMap"> & {
+    sourceMap?: undefined | SourceMap
+  }
   export type SyncCompileOptions = CompileOptions &
     { parseOptions?: { comptime?: false } }
 
@@ -61,6 +64,7 @@ declare module "@danielx/civet" {
       lines: SourceMapping[][]
     }
   }
+  export function SourceMap(source: string): SourceMap
 
   // TODO: Import ParseError class from Hera
   export type ParseError = {
@@ -93,7 +97,12 @@ declare module "@danielx/civet" {
   /** Warning: No caching */
   export function parseProgram<T extends CompileOptions>(source: string, options?: T):
     T extends { comptime: true } ? Promise<CivetAST> : CivetAST
-  export function generate(ast: CivetAST, options?: CompileOptions): string
+  export function generate(ast: CivetAST, options?: GenerateOptions): string
+
+  export const lib: {
+    gatherRecursive(ast: CivetAST, predicate: (node: CivetAST) => boolean): CivetAST[]
+    gatherRecursiveAll(ast: CivetAST, predicate: (node: CivetAST) => boolean): CivetAST[]
+  }
 
   const Civet: {
     version: string
@@ -101,6 +110,9 @@ declare module "@danielx/civet" {
     isCompileError: typeof isCompileError
     parse: typeof parse
     generate: typeof generate
+    SourceMap: typeof SourceMap
+    ParseError: typeof ParseError
+    ParseErrors: typeof ParseErrors
     sourcemap: {
       locationTable(input: string): number[]
       lookupLineColumn(table: number[], pos: number): [number, number]

package/dist/unplugin/unplugin.js

@@ -68,8 +68,8 @@ function cleanCivetId(id) {
 function tryStatSync(file) {
   try {
     return fs.statSync(file, { throwIfNoEntry: false });
-  } catch {
-    return void 0;
+  } catch (e) {
+    return;
   }
 }
 function slash(p) {
@@ -80,30 +80,44 @@ function normalizePath(id) {
 }
 function tryFsResolve(file) {
   const fileStat = tryStatSync(file);
-  if (fileStat?.isFile())
+  if (fileStat?.isFile()) {
     return normalizePath(file);
-  return void 0;
+  }
+  ;
+  return;
 }
 function resolveAbsolutePath(rootDir, id, implicitExtension) {
   const file = import_path.default.join(rootDir, id);
   return tryFsResolve(file) || implicitExtension && implicitCivet(file) || tryFsResolve(id) || implicitExtension && implicitCivet(id);
 }
 function implicitCivet(file) {
-  if (tryFsResolve(file))
+  if (tryFsResolve(file)) {
     return;
+  }
   const civet2 = file + ".civet";
-  if (tryFsResolve(civet2))
+  if (tryFsResolve(civet2)) {
     return civet2;
+  }
+  ;
   return;
 }
 var rawPlugin = (options = {}, meta) => {
   if (options.dts)
     options.emitDeclaration = options.dts;
-  if (options.js)
-    options.ts = "civet";
   let compileOptions = {};
+  let ts = options.ts;
+  if (options.js)
+    ts = "civet";
+  if (!(ts != null)) {
+    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.');
+    ts = "civet";
+  }
+  if (!["civet", "esbuild", "tsc", "preserve"].includes(ts)) {
+    console.log(`WARNING: Invalid option ts: ${JSON.stringify(ts)}; switching to "civet"`);
+    ts = "civet";
+  }
   const transformTS = options.emitDeclaration || options.typecheck;
-  const outExt = options.outputExtension ?? (options.ts === "preserve" ? ".tsx" : ".jsx");
+  const outExt = options.outputExtension ?? (ts === "preserve" ? ".tsx" : ".jsx");
   const implicitExtension = options.implicitExtension ?? true;
   let aliasResolver;
   let fsMap = /* @__PURE__ */ new Map();
@@ -113,7 +127,14 @@ var rawPlugin = (options = {}, meta) => {
   let esbuildOptions;
   let configErrors;
   let configFileNames;
-  const tsPromise = transformTS || options.ts === "tsc" ? import("typescript").then(($) => $.default) : null;
+  let ref;
+  if (transformTS || ts === "tsc") {
+    ref = import("typescript").then(($1) => $1.default);
+  } else {
+    ref = void 0;
+  }
+  ;
+  const tsPromise = ref;
   const getFormatHost = (sys) => {
     return {
       getCurrentDirectory: () => sys.getCurrentDirectory(),
@@ -134,39 +155,40 @@ var rawPlugin = (options = {}, meta) => {
         ...compileOptions.parseOptions,
         ...options.parseOptions
       };
-      if (transformTS || options.ts === "tsc") {
+      if (transformTS || ts === "tsc") {
         let mogrify = function(key) {
           if (key in config && Array.isArray(config[key])) {
             return config[key] = config[key].map((item) => {
-              if (typeof item !== "string")
+              if (!(typeof item === "string")) {
                 return item;
+              }
               return item.replace(/\.civet\b(?!\.)/g, ".civet.tsx");
             });
           }
           ;
           return;
         };
-        const ts = await tsPromise;
-        const tsConfigPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists);
+        const ts2 = await tsPromise;
+        const tsConfigPath = ts2.findConfigFile(process.cwd(), ts2.sys.fileExists);
         if (!tsConfigPath) {
           throw new Error("Could not find 'tsconfig.json'");
         }
-        const { config, error } = ts.readConfigFile(
+        const { config, error } = ts2.readConfigFile(
           tsConfigPath,
-          ts.sys.readFile
+          ts2.sys.readFile
         );
         if (error) {
-          console.error(ts.formatDiagnostic(error, getFormatHost(ts.sys)));
+          console.error(ts2.formatDiagnostic(error, getFormatHost(ts2.sys)));
           throw error;
         }
         mogrify("files");
-        const system = { ...ts.sys };
+        const system = { ...ts2.sys };
         const { readDirectory: systemReadDirectory } = system;
         system.readDirectory = (path2, extensions, excludes, includes, depth) => {
           extensions = [...extensions ?? [], ".civet"];
-          return systemReadDirectory(path2, extensions, excludes, includes, depth).map(($1) => $1.endsWith(".civet") ? $1 + ".tsx" : $1);
+          return systemReadDirectory(path2, extensions, excludes, includes, depth).map(($2) => $2.endsWith(".civet") ? $2 + ".tsx" : $2);
         };
-        const configContents = ts.parseJsonConfigFileContent(
+        const configContents = ts2.parseJsonConfigFileContent(
           config,
           system,
           process.cwd()
@@ -175,10 +197,10 @@ var rawPlugin = (options = {}, meta) => {
         configFileNames = configContents.fileNames;
         compilerOptions = {
           ...configContents.options,
-          target: ts.ScriptTarget.ESNext,
+          target: ts2.ScriptTarget.ESNext,
           composite: false
         };
-        compilerOptions.jsx ??= ts.JsxEmit.Preserve;
+        compilerOptions.jsx ??= ts2.JsxEmit.Preserve;
         compilerOptionsWithSourceMap = {
           ...compilerOptions,
           sourceMap: true
@@ -188,8 +210,8 @@ var rawPlugin = (options = {}, meta) => {
     },
     async buildEnd(useConfigFileNames = false) {
       if (transformTS) {
-        const ts = await tsPromise;
-        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), ts);
+        const ts2 = await tsPromise;
+        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), ts2);
         const {
           fileExists: systemFileExists,
           readFile: systemReadFile,
@@ -203,12 +225,17 @@ var rawPlugin = (options = {}, meta) => {
           return systemFileExists(filename.slice(0, -4));
         };
         system.readDirectory = (path2) => {
-          return systemReadDirectory(path2).map(($2) => $2.endsWith(".civet") ? $2 + ".tsx" : $2);
+          return systemReadDirectory(path2).map(($3) => $3.endsWith(".civet") ? $3 + ".tsx" : $3);
+        };
+        const tsCompileOptions = {
+          ...compileOptions,
+          rewriteCivetImports: false,
+          rewriteTsImports: true
         };
         system.readFile = (filename, encoding = "utf-8") => {
           if (import_path.default.basename(filename) === "package.json") {
             let recurse = function(node) {
-              if (node && typeof node === "object") {
+              if (node != null && typeof node === "object") {
                 for (const key in node) {
                   const value = node[key];
                   if (typeof value === "string") {
@@ -223,8 +250,9 @@ var rawPlugin = (options = {}, meta) => {
               }
             };
             const json = systemReadFile(filename, encoding);
-            if (!json)
+            if (!json) {
               return json;
+            }
             const parsed = JSON.parse(json);
             let modified = false;
             recurse(parsed.imports);
@@ -238,58 +266,58 @@ var rawPlugin = (options = {}, meta) => {
           const rawCivetSource = fs.readFileSync(civetFilename, {
             encoding
           });
-          const compiledTS = import_civet.default.compile(rawCivetSource, {
-            ...compileOptions,
+          const { code: compiledTS, sourceMap } = import_civet.default.compile(rawCivetSource, {
+            ...tsCompileOptions,
             filename,
             js: false,
+            sourceMap: true,
             sync: true
             // TS readFile API seems to need to be synchronous
           });
           fsMap.set(filename, compiledTS);
+          sourceMaps.set(filename, sourceMap);
           return compiledTS;
         };
         const host = tsvfs.createVirtualCompilerHost(
           system,
           compilerOptions,
-          ts
+          ts2
         );
-        const program = ts.createProgram({
+        const program = ts2.createProgram({
           rootNames: useConfigFileNames ? configFileNames : [...fsMap.keys()],
           options: compilerOptions,
           host: host.compilerHost
         });
-        const diagnostics = ts.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)
-              },
-              sourcemapLines
-            );
-            return {
-              ...diagnostic,
-              messageText: (0, import_ts_diagnostic.flattenDiagnosticMessageText)(diagnostic.messageText),
-              length: diagnostic.length,
-              start: range.start
-            };
-          }
-        );
+        const diagnostics = ts2.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)
+            },
+            sourcemapLines
+          );
+          return {
+            ...diagnostic,
+            messageText: (0, import_ts_diagnostic.flattenDiagnosticMessageText)(diagnostic.messageText),
+            length: diagnostic.length,
+            start: range.start
+          };
+        });
         if (configErrors?.length) {
           diagnostics.unshift(...configErrors);
         }
         if (diagnostics.length > 0) {
           console.error(
-            ts.formatDiagnosticsWithColorAndContext(
+            ts2.formatDiagnosticsWithColorAndContext(
               diagnostics,
-              getFormatHost(ts.sys)
+              getFormatHost(ts2.sys)
             )
           );
           if (options.typecheck) {
@@ -337,9 +365,9 @@ var rawPlugin = (options = {}, meta) => {
                   } else {
                     console.log(`WARNING: No .d.ts extension in ${filePath}`);
                   }
-                  let ref;
-                  if (ref = filePath.match(civetExtension)) {
-                    const match = ref;
+                  let ref1;
+                  if (ref1 = filePath.match(civetExtension)) {
+                    const match = ref1;
                     filePath = filePath.slice(0, -match[0].length);
                   } else {
                     console.log(`WARNING: No .civet extension in ${filePath}`);
@@ -375,6 +403,7 @@ var rawPlugin = (options = {}, meta) => {
         }
       }
     },
+    // forceDtsEmit
     resolveId(id, importer, options2) {
       if (aliasResolver != null) {
         id = aliasResolver(id);
@@ -386,14 +415,14 @@ var rawPlugin = (options = {}, meta) => {
       }
       let postfix;
       ({ id, postfix } = cleanCivetId(id));
-      let ref1;
+      let ref2;
       if (import_path.default.isAbsolute(id)) {
-        ref1 = resolveAbsolutePath(rootDir, id, implicitExtension);
+        ref2 = resolveAbsolutePath(rootDir, id, implicitExtension);
       } else {
-        ref1 = import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+        ref2 = import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
       }
       ;
-      let resolvedId = ref1;
+      let resolvedId = ref2;
       if (!resolvedId)
         return null;
       if (!resolvedId.endsWith(".civet")) {
@@ -414,8 +443,9 @@ var rawPlugin = (options = {}, meta) => {
     },
     async load(id) {
       const match = isCivetTranspiled.exec(id);
-      if (!match)
+      if (!match) {
         return null;
+      }
       const basename = id.slice(0, match.index + match[1].length);
       const filename = import_path.default.resolve(rootDir, basename);
       let mtime;
@@ -429,82 +459,96 @@ var rawPlugin = (options = {}, meta) => {
       const rawCivetSource = await fs.promises.readFile(filename, "utf-8");
       this.addWatchFile(filename);
       let compiled;
+      let sourceMap;
       const civetOptions = {
         ...compileOptions,
         filename: id,
-        sourceMap: true
+        errors: []
       };
-      if (options.ts === "civet" && !transformTS) {
-        compiled = await import_civet.default.compile(rawCivetSource, {
+      function checkErrors() {
+        if (civetOptions.errors.length) {
+          throw new import_civet.default.ParseErrors(civetOptions.errors);
+        }
+        ;
+        return;
+      }
+      const ast = await import_civet.default.compile(rawCivetSource, {
+        ...civetOptions,
+        ast: true
+      });
+      const civetSourceMap = (0, import_civet.SourceMap)(rawCivetSource);
+      if (ts === "civet") {
+        compiled = await import_civet.default.generate(ast, {
           ...civetOptions,
-          js: true
+          js: true,
+          sourceMap: civetSourceMap
         });
+        sourceMap = civetSourceMap;
+        checkErrors();
       } else {
-        const compiledTS = await import_civet.default.compile(rawCivetSource, {
+        const compiledTS = await import_civet.default.generate(ast, {
           ...civetOptions,
-          js: false
+          js: false,
+          sourceMap: civetSourceMap
         });
-        const resolved = filename + outExt;
-        sourceMaps.set(
-          resolved,
-          compiledTS.sourceMap
-        );
-        if (transformTS) {
-          const tsx = filename + ".tsx";
-          fsMap.set(tsx, compiledTS.code);
-          const slashed = slash(tsx);
-          if (tsx !== slashed)
-            fsMap.set(slashed, compiledTS.code);
-        }
-        switch (options.ts) {
+        checkErrors();
+        switch (ts) {
           case "esbuild": {
             const esbuildTransform = (await import("esbuild")).transform;
-            const result = await esbuildTransform(compiledTS.code, {
+            const result = await esbuildTransform(compiledTS, {
               jsx: "preserve",
               loader: "tsx",
               sourcefile: id,
               sourcemap: "external"
             });
-            compiled = { code: result.code, sourceMap: result.map };
+            compiled = result.code;
+            sourceMap = result.map;
             break;
           }
           case "tsc": {
             const tsTranspile = (await tsPromise).transpileModule;
-            const result = tsTranspile(
-              compiledTS.code,
-              { compilerOptions: compilerOptionsWithSourceMap }
-            );
-            compiled = {
-              code: result.outputText,
-              sourceMap: result.sourceMapText
-            };
+            const result = tsTranspile(compiledTS, {
+              compilerOptions: compilerOptionsWithSourceMap
+            });
+            compiled = result.outputText;
+            sourceMap = result.sourceMapText;
             break;
           }
           case "preserve": {
             compiled = compiledTS;
             break;
           }
-          case "civet":
-          default: {
-            compiled = await import_civet.default.compile(rawCivetSource, {
-              ...civetOptions,
-              js: 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;
+        }
+      }
+      if (transformTS) {
+        for (let ref3 = import_civet.lib.gatherRecursive(ast, ($) => $.type === "ModuleSpecifier"), i = 0, len = ref3.length; i < len; i++) {
+          const _spec = ref3[i];
+          const spec = _spec;
+          if (spec.module?.input) {
+            spec.module.token = spec.module.input.replace(/\.([mc])?ts(['"])$/, ".$1js$2");
           }
         }
+        const compiledTS = await import_civet.default.generate(ast, {
+          ...civetOptions,
+          js: false,
+          sourceMap: civetSourceMap
+        });
+        checkErrors();
+        const tsx = filename + ".tsx";
+        fsMap.set(tsx, compiledTS);
+        sourceMaps.set(tsx, civetSourceMap);
+        const slashed = slash(tsx);
+        if (!(tsx === slashed)) {
+          fsMap.set(slashed, compiledTS);
+          sourceMaps.set(slashed, civetSourceMap);
+        }
       }
-      const jsonSourceMap = compiled.sourceMap && (typeof compiled.sourceMap === "string" ? JSON.parse(compiled.sourceMap) : compiled.sourceMap.json(
+      const jsonSourceMap = sourceMap && (typeof sourceMap === "string" ? JSON.parse(sourceMap) : sourceMap.json(
         import_path.default.basename(id.replace(/\.[jt]sx$/, "")),
         import_path.default.basename(id)
       ));
       let transformed = {
-        code: compiled.code,
+        code: compiled,
         map: jsonSourceMap
       };
       if (options.transformOutput) {
@@ -515,7 +559,7 @@ var rawPlugin = (options = {}, meta) => {
     },
     esbuild: {
       config(options2) {
-        return esbuildOptions = options2;
+        esbuildOptions = options2;
       }
     },
     vite: {
@@ -562,9 +606,9 @@ var rawPlugin = (options = {}, meta) => {
         compiler.options.resolve.extensions.unshift(".civet");
       }
       return aliasResolver = (id) => {
-        let ref2;
-        for (const key in ref2 = compiler.options.resolve.alias) {
-          const value = ref2[key];
+        let ref4;
+        for (const key in ref4 = compiler.options.resolve.alias) {
+          const value = ref4[key];
           if (key.endsWith("$")) {
             if (id === key.slice(0, -1)) {
               return typeof value === "string" ? value : "\0";