@danielx/civet 0.6.89 → 0.6.91

package/README.md

@@ -16,8 +16,7 @@ The modern way to write TypeScript.
 - [Civet VSCode Extension](https://marketplace.visualstudio.com/items?itemName=DanielX.civet)
 - [Discord Server](https://discord.gg/xkrW9GebBc)
 - Plugins for
-  [Vite, esbuild, Rollup, Webpack, Rspack](integration/unplugin)
-  (including metaframeworks such as Astro),
+  [Vite, esbuild, Astro, Rollup, Webpack, Rspack](integration/unplugin)
   <!--
   [esbuild](source/esbuild-plugin.civet),
   [Vite](https://github.com/edemaine/vite-plugin-civet),

package/dist/astro.d.mts

@@ -0,0 +1,15 @@
+import { PluginOptions } from './unplugin.mjs';
+import 'unplugin';
+
+interface AstroIntegration {
+    name: string;
+    hooks: {
+        "astro:config:setup": (data: {
+            updateConfig: (config: unknown) => void;
+        }) => void;
+    };
+}
+
+declare function export_default(opts?: PluginOptions): AstroIntegration;
+
+export { export_default as default };

package/dist/astro.d.ts

@@ -0,0 +1,15 @@
+import { PluginOptions } from './unplugin.js';
+import 'unplugin';
+
+interface AstroIntegration {
+    name: string;
+    hooks: {
+        "astro:config:setup": (data: {
+            updateConfig: (config: unknown) => void;
+        }) => void;
+    };
+}
+
+declare function export_default(opts?: PluginOptions): AstroIntegration;
+
+export { export_default as default };

package/dist/astro.js

@@ -0,0 +1,452 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/astro.ts
+var astro_exports = {};
+__export(astro_exports, {
+  default: () => astro_default
+});
+module.exports = __toCommonJS(astro_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 tsvfs = __toESM(require("@typescript/vfs"));
+var import_os = __toESM(require("os"));
+var isCivetTranspiled = /(\.civet)(\.[jt]sx)([?#].*)?$/;
+var postfixRE = /[?#].*$/s;
+var isWindows = import_os.default.platform() === "win32";
+var windowsSlashRE = /\\/g;
+function cleanCivetId(id) {
+  return id.replace(postfixRE, "").replace(/\.[jt]sx$/, "");
+}
+function tryStatSync(file) {
+  try {
+    return fs.statSync(file, { throwIfNoEntry: false });
+  } catch {
+    return void 0;
+  }
+}
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return import_path.default.posix.normalize(isWindows ? slash(id) : id);
+}
+function tryFsResolve(file) {
+  const fileStat = tryStatSync(file);
+  if (fileStat?.isFile())
+    return normalizePath(file);
+  return void 0;
+}
+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))
+    return;
+  const civet2 = file + ".civet";
+  if (tryFsResolve(civet2))
+    return civet2;
+  return;
+}
+var rawPlugin = (options = {}, meta) => {
+  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");
+  const implicitExtension = options.implicitExtension ?? true;
+  let fsMap = /* @__PURE__ */ new Map();
+  const sourceMaps = /* @__PURE__ */ new Map();
+  let compilerOptions, compilerOptionsWithSourceMap;
+  let rootDir = process.cwd();
+  let esbuildOptions;
+  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 (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 } = ts.readConfigFile(
+          configPath,
+          ts.sys.readFile
+        );
+        if (error) {
+          console.error(ts.formatDiagnostic(error, getFormatHost(ts.sys)));
+          throw error;
+        }
+        const configContents = ts.parseJsonConfigFileContent(
+          config,
+          ts.sys,
+          process.cwd()
+        );
+        compilerOptions = {
+          ...configContents.options,
+          target: ts.ScriptTarget.ESNext,
+          composite: false
+        };
+        compilerOptions.jsx ?? (compilerOptions.jsx = "preserve");
+        compilerOptionsWithSourceMap = {
+          ...compilerOptions,
+          sourceMap: true
+        };
+        fsMap = /* @__PURE__ */ new Map();
+      }
+    },
+    async buildEnd() {
+      if (transformTS) {
+        const ts = await tsPromise;
+        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), ts);
+        const { fileExists: systemFileExists, readFile: systemReadFile } = system;
+        system.fileExists = (filename) => {
+          if (!filename.endsWith(".civet.tsx"))
+            return systemFileExists(filename);
+          if (fsMap.has(filename))
+            return true;
+          return systemFileExists(filename.slice(0, -4));
+        };
+        system.readFile = (filename, encoding = "utf-8") => {
+          if (!filename.endsWith(".civet.tsx"))
+            return systemReadFile(filename);
+          if (fsMap.has(filename))
+            return fsMap.get(filename);
+          const civetFilename = filename.slice(0, -4);
+          const rawCivetSource = fs.readFileSync(civetFilename, {
+            encoding
+          });
+          const compiledTS = import_civet.default.compile(rawCivetSource, {
+            filename,
+            js: false
+          });
+          fsMap.set(filename, compiledTS);
+          return compiledTS;
+        };
+        const host = tsvfs.createVirtualCompilerHost(
+          system,
+          compilerOptions,
+          ts
+        );
+        const program = ts.createProgram({
+          rootNames: [...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
+          };
+        });
+        if (diagnostics.length > 0) {
+          console.error(
+            ts.formatDiagnosticsWithColorAndContext(
+              diagnostics,
+              getFormatHost(ts.sys)
+            )
+          );
+          if (options.typecheck) {
+            let failures = [];
+            if (typeof options.typecheck === "string") {
+              if (options.typecheck.includes("error"))
+                failures.push(1 /* Error */);
+              if (options.typecheck.includes("warning"))
+                failures.push(0 /* Warning */);
+              if (options.typecheck.includes("suggestion"))
+                failures.push(2 /* Suggestion */);
+              if (options.typecheck.includes("message"))
+                failures.push(3 /* Message */);
+              if (options.typecheck.includes("all")) {
+                failures = { includes: () => true };
+              }
+            } else {
+              failures.push(1 /* Error */);
+            }
+            const count = diagnostics.filter((d) => failures.includes(d.category)).length;
+            if (count) {
+              const reason = count === diagnostics.length ? count : `${count} out of ${diagnostics.length}`;
+              throw new Error(`Aborting build because of ${reason} TypeScript diagnostic${diagnostics.length > 1 ? "s" : ""} above`);
+            }
+          }
+        }
+        if (options.emitDeclaration) {
+          if (meta.framework === "esbuild" && !esbuildOptions.outdir) {
+            console.log("WARNING: Civet unplugin's `emitDeclaration` requires esbuild's `outdir` option to be set;");
+          }
+          for (const file of fsMap.keys()) {
+            const slashed = slash(file);
+            if (file !== slashed) {
+              fsMap.delete(slashed);
+            }
+          }
+          for (const file of fsMap.keys()) {
+            const sourceFile = program.getSourceFile(file);
+            program.emit(
+              sourceFile,
+              (filePath, content) => {
+                const pathFromDistDir = import_path.default.relative(
+                  compilerOptions.outDir ?? process.cwd(),
+                  filePath
+                );
+                if (meta.framework === "esbuild") {
+                  fs.mkdirSync(
+                    import_path.default.dirname(
+                      import_path.default.resolve(esbuildOptions.outdir, pathFromDistDir)
+                    ),
+                    { recursive: true }
+                  );
+                }
+                this.emitFile({
+                  source: content,
+                  fileName: pathFromDistDir,
+                  type: "asset"
+                });
+              },
+              void 0,
+              true,
+              // emitDtsOnly
+              void 0,
+              // @ts-ignore @internal interface
+              true
+              // forceDtsEmit
+            );
+          }
+        }
+      }
+    },
+    resolveId(id, importer, options2) {
+      if (/\0/.test(id))
+        return null;
+      id = cleanCivetId(id);
+      let resolvedId = import_path.default.isAbsolute(id) ? resolveAbsolutePath(rootDir, id, implicitExtension) : import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+      if (!resolvedId)
+        return null;
+      if (!resolvedId.endsWith(".civet")) {
+        if (!implicitExtension)
+          return null;
+        const implicitId = implicitCivet(resolvedId);
+        if (!implicitId)
+          return null;
+        resolvedId = implicitId;
+      }
+      if (options2.scan && meta.framework === "vite") {
+        resolvedId = `\0${resolvedId}`;
+      }
+      return resolvedId + outExt;
+    },
+    loadInclude(id) {
+      return isCivetTranspiled.test(id);
+    },
+    async load(id) {
+      const match = isCivetTranspiled.exec(id);
+      if (!match)
+        return null;
+      const basename = id.slice(0, match.index + match[1].length);
+      const filename = import_path.default.resolve(rootDir, basename);
+      const rawCivetSource = await fs.promises.readFile(filename, "utf-8");
+      this.addWatchFile(filename);
+      let compiled;
+      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
+        });
+        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) {
+          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: compilerOptionsWithSourceMap }
+            );
+            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 = compiled.sourceMap && (typeof compiled.sourceMap === "string" ? JSON.parse(compiled.sourceMap) : compiled.sourceMap.json(
+        import_path.default.basename(id.replace(/\.[jt]sx$/, "")),
+        import_path.default.basename(id)
+      ));
+      let transformed = {
+        code: compiled.code,
+        map: jsonSourceMap
+      };
+      if (options.transformOutput)
+        transformed = await options.transformOutput(transformed.code, id);
+      return transformed;
+    },
+    esbuild: {
+      config(options2) {
+        esbuildOptions = options2;
+      }
+    },
+    vite: {
+      config(config) {
+        var _a;
+        rootDir = import_path.default.resolve(process.cwd(), config.root ?? "");
+        if (implicitExtension) {
+          config.resolve ?? (config.resolve = {});
+          (_a = config.resolve).extensions ?? (_a.extensions = []);
+          config.resolve.extensions.push(".civet");
+        }
+      },
+      async transformIndexHtml(html) {
+        return html.replace(
+          /<!--[^]*?-->|<[^<>]*>/g,
+          (tag) => tag.replace(
+            /<\s*script\b[^<>]*>/gi,
+            (script) => (
+              // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+              script.replace(
+                /([:_\p{ID_Start}][:\p{ID_Continue}]*)(\s*=\s*("[^"]*"|'[^']*'|[^\s"'=<>`]*))?/gu,
+                (attr, name, value) => name.toLowerCase() === "src" && value ? attr.replace(
+                  /(\.civet)(['"]?)$/,
+                  (_, extension, endQuote) => `${extension}${outExt}?transform${endQuote}`
+                ) : attr
+              )
+            )
+          )
+        );
+      },
+      handleHotUpdate({ file, server, modules }) {
+        if (!file.endsWith(".civet"))
+          return;
+        const resolvedId = slash(import_path.default.resolve(file) + outExt);
+        const module2 = server.moduleGraph.getModuleById(resolvedId);
+        if (module2) {
+          server.moduleGraph.onFileChange(resolvedId);
+          return [...modules, module2];
+        }
+        return modules;
+      }
+    }
+  };
+};
+var unplugin = (0, import_unplugin.createUnplugin)(rawPlugin);
+var src_default = unplugin;
+
+// src/astro.ts
+function astro_default(opts = {}) {
+  return {
+    name: "@danielx/civet",
+    hooks: {
+      "astro:config:setup": ({ updateConfig }) => {
+        updateConfig({
+          vite: {
+            plugins: [src_default.vite(opts)]
+          }
+        });
+      }
+    }
+  };
+}

package/dist/astro.mjs

@@ -0,0 +1,22 @@
+import {
+  src_default
+} from "./unplugin-shared.mjs";
+
+// src/astro.ts
+function astro_default(opts = {}) {
+  return {
+    name: "@danielx/civet",
+    hooks: {
+      "astro:config:setup": ({ updateConfig }) => {
+        updateConfig({
+          vite: {
+            plugins: [src_default.vite(opts)]
+          }
+        });
+      }
+    }
+  };
+}
+export {
+  astro_default as default
+};