@danielx/civet 0.7.15 → 0.7.17

package/dist/webpack.js

@@ -1,524 +0,0 @@
-"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/webpack.ts
-var webpack_exports = {};
-__export(webpack_exports, {
-  default: () => webpack_default
-});
-module.exports = __toCommonJS(webpack_exports);
-
-// src/index.ts
-var import_unplugin = require("unplugin");
-var import_civet = __toESM(require("@danielx/civet"));
-var import_config = require("@danielx/civet/config");
-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"));
-
-// src/constants.ts
-var DEFAULT_EXTENSIONS = [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"];
-
-// src/index.ts
-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";
-  let compileOptions = {};
-  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;
-  let configErrors;
-  let configFileNames;
-  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()
-    };
-  };
-  const cache = options.cache ? /* @__PURE__ */ new Map() : void 0;
-  return {
-    name: "unplugin-civet",
-    enforce: "pre",
-    async buildStart() {
-      if (transformTS || options.ts === "tsc") {
-        let mogrify2 = function(key) {
-          if (key in config && Array.isArray(config[key])) {
-            config[key] = config[key].map((item) => {
-              if (typeof item !== "string")
-                return item;
-              return item.replace(/\.civet\b(?!\.)/g, ".civet.tsx");
-            });
-          }
-        };
-        var mogrify = mogrify2;
-        const ts = await tsPromise;
-        const civetConfigPath = "config" in options ? options.config : await (0, import_config.findInDir)(process.cwd());
-        if (civetConfigPath) {
-          compileOptions = await (0, import_config.loadConfig)(civetConfigPath);
-        }
-        compileOptions.parseOptions = {
-          ...compileOptions.parseOptions,
-          ...options.parseOptions
-        };
-        const tsConfigPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists);
-        if (!tsConfigPath) {
-          throw new Error("Could not find 'tsconfig.json'");
-        }
-        const { config, error } = ts.readConfigFile(
-          tsConfigPath,
-          ts.sys.readFile
-        );
-        if (error) {
-          console.error(ts.formatDiagnostic(error, getFormatHost(ts.sys)));
-          throw error;
-        }
-        mogrify2("files");
-        const system = { ...ts.sys };
-        const { readDirectory: systemReadDirectory } = system;
-        system.readDirectory = (path2, extensions, excludes, includes, depth) => {
-          extensions = [...extensions ?? [], ".civet"];
-          return systemReadDirectory(path2, extensions, excludes, includes, depth).map((name) => name.endsWith(".civet") ? name + ".tsx" : name);
-        };
-        const configContents = ts.parseJsonConfigFileContent(
-          config,
-          system,
-          process.cwd()
-        );
-        configErrors = configContents.errors;
-        configFileNames = configContents.fileNames;
-        compilerOptions = {
-          ...configContents.options,
-          target: ts.ScriptTarget.ESNext,
-          composite: false
-        };
-        compilerOptions.jsx ?? (compilerOptions.jsx = ts.JsxEmit.Preserve);
-        compilerOptionsWithSourceMap = {
-          ...compilerOptions,
-          sourceMap: true
-        };
-        fsMap = /* @__PURE__ */ new Map();
-      }
-    },
-    async buildEnd(useConfigFileNames = false) {
-      if (transformTS) {
-        const ts = await tsPromise;
-        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), ts);
-        const {
-          fileExists: systemFileExists,
-          readFile: systemReadFile,
-          readDirectory: systemReadDirectory
-        } = 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.readDirectory = (path2) => systemReadDirectory(path2).map((name) => name.endsWith(".civet") ? name + ".tsx" : name);
-        system.readFile = (filename, encoding = "utf-8") => {
-          if (import_path.default.basename(filename) === "package.json") {
-            let recurse2 = function(node) {
-              if (node && typeof node === "object") {
-                for (const key in node) {
-                  const value = node[key];
-                  if (typeof value === "string") {
-                    if (value.endsWith(".civet")) {
-                      node[key] = value + ".tsx";
-                      modified = true;
-                    }
-                  } else if (value) {
-                    recurse2(value);
-                  }
-                }
-              }
-            };
-            var recurse = recurse2;
-            const json = systemReadFile(filename, encoding);
-            if (!json)
-              return json;
-            const parsed = JSON.parse(json);
-            let modified = false;
-            recurse2(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);
-          const civetFilename = filename.slice(0, -4);
-          const rawCivetSource = fs.readFileSync(civetFilename, {
-            encoding
-          });
-          const compiledTS = import_civet.default.compile(rawCivetSource, {
-            ...compileOptions,
-            filename,
-            js: false,
-            sync: true
-            // TS readFile API seems to need to be synchronous
-          });
-          fsMap.set(filename, compiledTS);
-          return compiledTS;
-        };
-        const host = tsvfs.createVirtualCompilerHost(
-          system,
-          compilerOptions,
-          ts
-        );
-        host.compilerHost.getDirectories = system.getDirectories;
-        const program = ts.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
-          };
-        });
-        if (configErrors?.length) {
-          diagnostics.unshift(...configErrors);
-        }
-        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);
-      let mtime;
-      if (cache) {
-        mtime = (await fs.promises.stat(filename)).mtimeMs;
-        const 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;
-      const civetOptions = {
-        ...compileOptions,
-        filename: id,
-        sourceMap: true
-      };
-      if (options.ts === "civet" && !transformTS) {
-        compiled = await import_civet.default.compile(rawCivetSource, {
-          ...civetOptions,
-          js: true
-        });
-      } else {
-        const compiledTS = await import_civet.default.compile(rawCivetSource, {
-          ...civetOptions,
-          js: false
-        });
-        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 = 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;
-          }
-        }
-      }
-      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);
-      cache?.set(filename, { mtime, result: transformed });
-      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 = DEFAULT_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/webpack.ts
-var webpack_default = src_default.webpack;

package/dist/webpack.mjs

@@ -1,9 +0,0 @@
-import {
-  src_default
-} from "./unplugin-shared.mjs";
-
-// src/webpack.ts
-var webpack_default = src_default.webpack;
-export {
-  webpack_default as default
-};