@danielx/civet 0.9.0 → 0.9.2

package/dist/node-worker.mjs

@@ -0,0 +1,29 @@
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\node-worker.civet.jsx
+import { parentPort } from "node:worker_threads";
+import module from "node:module";
+try {
+  module.enableCompileCache();
+} catch (e) {
+}
+(async () => {
+  {
+    const { compile } = await import("./main.mjs");
+    return parentPort.on("message", async ({ id, op, args }) => {
+      try {
+        let result;
+        switch (op) {
+          case "compile": {
+            result = await compile(...args);
+            break;
+          }
+          default: {
+            throw `Unknown operation: ${op}`;
+          }
+        }
+        return parentPort.postMessage({ id, result });
+      } catch (error) {
+        return parentPort.postMessage({ id, error });
+      }
+    });
+  }
+})();

package/dist/ts-diagnostic.js

@@ -1,4 +1,3 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -16,20 +15,18 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ts_diagnostic_exports = {};
-__export(ts_diagnostic_exports, {
+var ts_diagnostic_civet_exports = {};
+__export(ts_diagnostic_civet_exports, {
   flattenDiagnosticMessageText: () => flattenDiagnosticMessageText,
   remapPosition: () => remapPosition,
   remapRange: () => remapRange
 });
-module.exports = __toCommonJS(ts_diagnostic_exports);
+module.exports = __toCommonJS(ts_diagnostic_civet_exports);
 function remapPosition(position, sourcemapLines) {
-  if (!sourcemapLines)
-    return position;
+  if (!sourcemapLines) return position;
   const { line, character } = position;
   const textLine = sourcemapLines[line];
-  if (!textLine?.length)
-    return position;
+  if (!textLine?.length) return position;
   let i = 0, p = 0, l = textLine.length, lastMapping, lastMappingPosition = 0;
   while (i < l) {
     const mapping = textLine[i];

package/dist/ts-diagnostic.mjs

@@ -1,10 +1,8 @@
 function remapPosition(position, sourcemapLines) {
-  if (!sourcemapLines)
-    return position;
+  if (!sourcemapLines) return position;
   const { line, character } = position;
   const textLine = sourcemapLines[line];
-  if (!textLine?.length)
-    return position;
+  if (!textLine?.length) return position;
   let i = 0, p = 0, l = textLine.length, lastMapping, lastMappingPosition = 0;
   while (i < l) {
     const mapping = textLine[i];

package/dist/types.d.ts

@@ -49,6 +49,10 @@ declare module "@danielx/civet" {
     hits?: string
     trace?: string
     parseOptions?: ParseOptions
+    /** Specifying an empty array will prevent ParseErrors from being thrown */
+    errors?: ParseError[]
+    /** Number of parallel threads to compile with (Node only) */
+    threads?: number
   }
   export type GenerateOptions = Omit<CompileOptions, "sourceMap"> & {
     sourceMap?: undefined | SourceMap

package/dist/unplugin/unplugin.d.ts

@@ -12,6 +12,8 @@ export type PluginOptions = {
     js?: boolean;
     /** @deprecated Use "emitDeclaration" instead */
     dts?: boolean;
+    /** Number of parallel threads to compile with (Node only) */
+    threads?: number;
     /** Cache compilation results based on file mtime (useful for serve or watch mode) */
     cache?: boolean;
     /** config filename, or null to not look for default config file */

package/dist/unplugin/unplugin.js

@@ -53,7 +53,7 @@ DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error";
 DiagnosticCategory[DiagnosticCategory["Suggestion"] = 2] = "Suggestion";
 DiagnosticCategory[DiagnosticCategory["Message"] = 3] = "Message";
 var civetExtension = /\.civet$/;
-var isCivetTranspiled = /(\.civet)(\.[jt]sx)([?#].*)?$/;
+var isCivetTranspiled = /(\.civet)(\.[jt]sx)?([?#].*)?$/;
 var postfixRE = /[?#].*$/s;
 var isWindows = import_os.default.platform() === "win32";
 var windowsSlashRE = /\\/g;
@@ -102,12 +102,10 @@ function implicitCivet(file) {
   return;
 }
 var rawPlugin = (options = {}, meta) => {
-  if (options.dts)
-    options.emitDeclaration = options.dts;
+  if (options.dts) options.emitDeclaration = options.dts;
   let compileOptions = {};
   let ts = options.ts;
-  if (options.js)
-    ts = "civet";
+  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";
@@ -142,7 +140,7 @@ var rawPlugin = (options = {}, meta) => {
       getCanonicalFileName: sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
     };
   };
-  const cache = options.cache ? /* @__PURE__ */ new Map() : void 0;
+  const cache = !(options.cache === false) ? /* @__PURE__ */ new Map() : void 0;
   const plugin = {
     name: "unplugin-civet",
     enforce: "pre",
@@ -155,6 +153,9 @@ var rawPlugin = (options = {}, meta) => {
         ...compileOptions.parseOptions,
         ...options.parseOptions
       };
+      if (options.threads != null) {
+        compileOptions.threads = options.threads;
+      }
       if (transformTS || ts === "tsc") {
         let mogrify = function(key) {
           if (key in config && Array.isArray(config[key])) {
@@ -218,10 +219,8 @@ var rawPlugin = (options = {}, meta) => {
           readDirectory: systemReadDirectory
         } = system;
         system.fileExists = (filename) => {
-          if (!filename.endsWith(".civet.tsx"))
-            return systemFileExists(filename);
-          if (fsMap.has(filename))
-            return true;
+          if (!filename.endsWith(".civet.tsx")) return systemFileExists(filename);
+          if (fsMap.has(filename)) return true;
           return systemFileExists(filename.slice(0, -4));
         };
         system.readDirectory = (path2) => {
@@ -258,10 +257,8 @@ var rawPlugin = (options = {}, meta) => {
             recurse(parsed.imports);
             return modified ? JSON.stringify(parsed) : json;
           }
-          if (!filename.endsWith(".civet.tsx"))
-            return systemReadFile(filename, encoding);
-          if (fsMap.has(filename))
-            return fsMap.get(filename);
+          if (!filename.endsWith(".civet.tsx")) return systemReadFile(filename, encoding);
+          if (fsMap.has(filename)) return fsMap.get(filename);
           const civetFilename = filename.slice(0, -4);
           const rawCivetSource = fs.readFileSync(civetFilename, {
             encoding
@@ -290,11 +287,9 @@ var rawPlugin = (options = {}, meta) => {
         });
         const diagnostics = ts2.getPreEmitDiagnostics(program).map((diagnostic) => {
           const file = diagnostic.file;
-          if (!file)
-            return diagnostic;
+          if (!file) return diagnostic;
           const sourceMap = sourceMaps.get(file.fileName);
-          if (!sourceMap)
-            return diagnostic;
+          if (!sourceMap) return diagnostic;
           const sourcemapLines = sourceMap.data.lines;
           const range = (0, import_ts_diagnostic.remapRange)(
             {
@@ -323,14 +318,10 @@ var rawPlugin = (options = {}, meta) => {
           if (options.typecheck) {
             let failures = [];
             if (typeof options.typecheck === "string") {
-              if (options.typecheck.includes("error"))
-                failures.push(DiagnosticCategory.Error);
-              if (options.typecheck.includes("warning"))
-                failures.push(DiagnosticCategory.Warning);
-              if (options.typecheck.includes("suggestion"))
-                failures.push(DiagnosticCategory.Suggestion);
-              if (options.typecheck.includes("message"))
-                failures.push(DiagnosticCategory.Message);
+              if (options.typecheck.includes("error")) failures.push(DiagnosticCategory.Error);
+              if (options.typecheck.includes("warning")) failures.push(DiagnosticCategory.Warning);
+              if (options.typecheck.includes("suggestion")) failures.push(DiagnosticCategory.Suggestion);
+              if (options.typecheck.includes("message")) failures.push(DiagnosticCategory.Message);
               if (options.typecheck.includes("all")) {
                 failures = { includes: () => true };
               }
@@ -383,7 +374,9 @@ var rawPlugin = (options = {}, meta) => {
                     import_path.default.dirname(
                       import_path.default.resolve(esbuildOptions.outdir, pathFromDistDir)
                     ),
-                    { recursive: true }
+                    {
+                      recursive: true
+                    }
                   );
                 }
                 return this.emitFile({
@@ -408,8 +401,7 @@ var rawPlugin = (options = {}, meta) => {
       if (aliasResolver != null) {
         id = aliasResolver(id);
       }
-      if (/\0/.test(id))
-        return null;
+      if (/\0/.test(id)) return null;
       if (plugin.__virtualModulePrefix && importer?.startsWith(plugin.__virtualModulePrefix)) {
         importer = decodeURIComponent(importer.slice(plugin.__virtualModulePrefix.length));
       }
@@ -423,14 +415,11 @@ var rawPlugin = (options = {}, meta) => {
       }
       ;
       let resolvedId = ref2;
-      if (!resolvedId)
-        return null;
+      if (!resolvedId) return null;
       if (!resolvedId.endsWith(".civet")) {
-        if (!implicitExtension)
-          return null;
+        if (!implicitExtension) return null;
         const implicitId = implicitCivet(resolvedId);
-        if (!implicitId)
-          return null;
+        if (!implicitId) return null;
         resolvedId = implicitId;
       }
       if (options2.scan && meta.framework === "vite") {
@@ -448,114 +437,130 @@ var rawPlugin = (options = {}, meta) => {
       }
       const basename = id.slice(0, match.index + match[1].length);
       const filename = import_path.default.resolve(rootDir, basename);
-      let mtime;
-      if (cache) {
+      let mtime, cached, resolve;
+      if (cache != null) {
         mtime = (await fs.promises.stat(filename)).mtimeMs;
-        const cached = cache?.get(filename);
+        cached = cache?.get(filename);
         if (cached && cached.mtime === mtime) {
-          return cached.result;
-        }
-      }
-      const rawCivetSource = await fs.promises.readFile(filename, "utf-8");
-      this.addWatchFile(filename);
-      let compiled;
-      let sourceMap;
-      const civetOptions = {
-        ...compileOptions,
-        filename: id,
-        errors: []
-      };
-      function checkErrors() {
-        if (civetOptions.errors.length) {
-          throw new import_civet.default.ParseErrors(civetOptions.errors);
+          if (cached.promise) {
+            await cached.promise;
+          }
+          if (cached.result) {
+            return cached.result;
+          }
         }
-        ;
-        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,
-          sourceMap: civetSourceMap
+        const promise = new Promise((r) => {
+          resolve = r;
         });
-        sourceMap = civetSourceMap;
-        checkErrors();
-      } else {
-        const compiledTS = await import_civet.default.generate(ast, {
+        cache.set(filename, cached = { mtime, promise });
+      }
+      try {
+        let checkErrors = function() {
+          if (civetOptions.errors.length) {
+            throw new import_civet.default.ParseErrors(civetOptions.errors);
+          }
+          ;
+          return;
+        };
+        this.addWatchFile(filename);
+        let compiled;
+        let sourceMap;
+        const civetOptions = {
+          ...compileOptions,
+          filename: id,
+          errors: []
+        };
+        const rawCivetSource = await fs.promises.readFile(filename, "utf-8");
+        const ast = await import_civet.default.compile(rawCivetSource, {
           ...civetOptions,
-          js: false,
-          sourceMap: civetSourceMap
+          ast: true
         });
-        checkErrors();
-        switch (ts) {
-          case "esbuild": {
-            const esbuildTransform = (await import("esbuild")).transform;
-            const result = await esbuildTransform(compiledTS, {
-              jsx: "preserve",
-              loader: "tsx",
-              sourcefile: id,
-              sourcemap: "external"
-            });
-            compiled = result.code;
-            sourceMap = result.map;
-            break;
+        const civetSourceMap = (0, import_civet.SourceMap)(rawCivetSource);
+        if (ts === "civet") {
+          compiled = await import_civet.default.generate(ast, {
+            ...civetOptions,
+            js: true,
+            sourceMap: civetSourceMap
+          });
+          sourceMap = civetSourceMap;
+          checkErrors();
+        } else {
+          const compiledTS = await import_civet.default.generate(ast, {
+            ...civetOptions,
+            js: false,
+            sourceMap: civetSourceMap
+          });
+          checkErrors();
+          switch (ts) {
+            case "esbuild": {
+              const esbuildTransform = (await import("esbuild")).transform;
+              const result = await esbuildTransform(compiledTS, {
+                jsx: "preserve",
+                loader: "tsx",
+                sourcefile: id,
+                sourcemap: "external"
+              });
+              compiled = result.code;
+              sourceMap = result.map;
+              break;
+            }
+            case "tsc": {
+              const tsTranspile = (await tsPromise).transpileModule;
+              const result = tsTranspile(compiledTS, {
+                compilerOptions: compilerOptionsWithSourceMap
+              });
+              compiled = result.outputText;
+              sourceMap = result.sourceMapText;
+              break;
+            }
+            case "preserve": {
+              compiled = compiledTS;
+              break;
+            }
           }
-          case "tsc": {
-            const tsTranspile = (await tsPromise).transpileModule;
-            const result = tsTranspile(compiledTS, {
-              compilerOptions: compilerOptionsWithSourceMap
-            });
-            compiled = result.outputText;
-            sourceMap = result.sourceMapText;
-            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");
+            }
           }
-          case "preserve": {
-            compiled = compiledTS;
-            break;
+          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);
           }
         }
-      }
-      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 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,
+          map: jsonSourceMap
+        };
+        if (options.transformOutput) {
+          transformed = await options.transformOutput(transformed.code, id);
         }
-        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);
+        if (cached != null) {
+          cached.result = transformed;
+          delete cached.promise;
         }
+        return transformed;
+      } finally {
+        resolve?.();
       }
-      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,
-        map: jsonSourceMap
-      };
-      if (options.transformOutput) {
-        transformed = await options.transformOutput(transformed.code, id);
-      }
-      cache?.set(filename, { mtime, result: transformed });
-      return transformed;
     },
     esbuild: {
       config(options2) {