unplugin-env 1.0.3 → 1.0.5

package/dist/types.d.ts

@@ -6,28 +6,36 @@ interface Options {
          */
         globalName?: string;
         /**
-         * 配置文件名
+         * 输出文件名
          * manifest.js
          */
-        fileName?: string;
+        emitFileName?: string;
         /**
-         * config.dev|prod.ts配置文件存放位置
+         * 输出目录
+         * assets
+         */
+        emitDir?: string;
+        /**
+         * config.dev|prod.ts 配置文件存放位置
          * config
          */
-        dir?: string;
+        configDir?: string;
         /**
          * 用于正则，文件名中包含其中的开发环境
          * /dev|development/i
          */
-        serve?: RegExp;
+        devMatch?: RegExp;
         /**
          * 用于正则，文件名中包含其中的生产环境
          * /prod|production/i
          */
-        build?: RegExp;
+        buildMatch?: RegExp;
     };
     compress?: {
-        ignoreBase?: boolean;
+        /**
+         * 是否保留外层目录
+         */
+        includeBaseDir?: boolean;
     };
 }
 type DeepRequired<T> = {

package/dist/vite.cjs

@@ -1147,7 +1147,7 @@ var require_parse = __commonJS({
       CHAR_NO_BREAK_SPACE,
       CHAR_ZERO_WIDTH_NOBREAK_SPACE
     } = require_constants();
-    var parse = (input, options = {}) => {
+    var parse2 = (input, options = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -1347,7 +1347,7 @@ var require_parse = __commonJS({
       push({ type: "eos" });
       return ast;
     };
-    module2.exports = parse;
+    module2.exports = parse2;
   }
 });
 
@@ -1358,7 +1358,7 @@ var require_braces = __commonJS({
     var stringify = require_stringify();
     var compile = require_compile();
     var expand = require_expand();
-    var parse = require_parse();
+    var parse2 = require_parse();
     var braces = (input, options = {}) => {
       let output = [];
       if (Array.isArray(input)) {
@@ -1378,7 +1378,7 @@ var require_braces = __commonJS({
       }
       return output;
     };
-    braces.parse = (input, options = {}) => parse(input, options);
+    braces.parse = (input, options = {}) => parse2(input, options);
     braces.stringify = (input, options = {}) => {
       if (typeof input === "string") {
         return stringify(braces.parse(input, options), options);
@@ -2031,7 +2031,7 @@ var require_parse2 = __commonJS({
     var syntaxError = (type, char) => {
       return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
-    var parse = (input, options) => {
+    var parse2 = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -2180,7 +2180,7 @@ var require_parse2 = __commonJS({
             output = token.close = `)$))${extglobStar}`;
           }
           if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-            const expression = parse(rest, { ...options, fastpaths: false }).output;
+            const expression = parse2(rest, { ...options, fastpaths: false }).output;
             output = token.close = `)${expression})${extglobStar})`;
           }
           if (token.prev.type === "bos") {
@@ -2705,7 +2705,7 @@ var require_parse2 = __commonJS({
       }
       return state;
     };
-    parse.fastpaths = (input, options) => {
+    parse2.fastpaths = (input, options) => {
       const opts = { ...options };
       const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       const len = input.length;
@@ -2771,7 +2771,7 @@ var require_parse2 = __commonJS({
       }
       return source;
     };
-    module2.exports = parse;
+    module2.exports = parse2;
   }
 });
 
@@ -2781,7 +2781,7 @@ var require_picomatch = __commonJS({
     "use strict";
     var path3 = require("path");
     var scan = require_scan();
-    var parse = require_parse2();
+    var parse2 = require_parse2();
     var utils = require_utils2();
     var constants = require_constants2();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -2869,7 +2869,7 @@ var require_picomatch = __commonJS({
     picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
     picomatch.parse = (pattern, options) => {
       if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
-      return parse(pattern, { ...options, fastpaths: false });
+      return parse2(pattern, { ...options, fastpaths: false });
     };
     picomatch.scan = (input, options) => scan(input, options);
     picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
@@ -2895,10 +2895,10 @@ var require_picomatch = __commonJS({
       }
       let parsed = { negated: false, fastpaths: true };
       if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-        parsed.output = parse.fastpaths(input, options);
+        parsed.output = parse2.fastpaths(input, options);
       }
       if (!parsed.output) {
-        parsed = parse(input, options);
+        parsed = parse2(input, options);
       }
       return picomatch.compileRe(parsed, options, returnOutput, returnState);
     };
@@ -6058,13 +6058,13 @@ var Log = class {
 
 // src/core/compress.ts
 async function createCompress(options, outDir) {
-  const { ignoreBase } = options;
+  const { includeBaseDir } = options;
   const zipFilePath = import_node_path.default.resolve(import_node_process2.default.cwd(), `${import_node_path.default.basename(outDir)}.zip`);
   const absoluteOutDir = import_node_path.default.resolve(outDir);
   Log.log("Compressing directory:", absoluteOutDir);
   try {
     const zip = new import_zip_lib.Zip();
-    if (ignoreBase) {
+    if (!includeBaseDir) {
       zip.addFolder(absoluteOutDir);
     } else {
       zip.addFolder(absoluteOutDir, import_node_path.default.basename(outDir));
@@ -6089,12 +6089,13 @@ var import_node_process4 = __toESM(require("process"), 1);
 var import_utils = require("@antfu/utils");
 
 // src/core/generate.ts
+var import_node_child_process = require("child_process");
 var import_node_fs2 = require("fs");
 var import_node_path2 = __toESM(require("path"), 1);
 var import_node_process3 = __toESM(require("process"), 1);
 var import_fast_glob = __toESM(require_out4(), 1);
-var import_local_pkg = require("local-pkg");
-var import_recast = __toESM(require("recast"), 1);
+var recast = __toESM(require("recast"), 1);
+var import_typescript = __toESM(require("recast/parsers/typescript.js"), 1);
 function mergeObjects(prodObj, devObj) {
   const prodProps = new Map(prodObj.properties.map((p) => [p.key.name || p.key.value, p]));
   for (const prop of devObj.properties) {
@@ -6109,89 +6110,263 @@ function mergeObjects(prodObj, devObj) {
   }
 }
 async function generateScript(options, context) {
-  const { dir, fileName, globalName, serve, build } = options.env;
-  const folder = await findFolder(import_node_process3.default.cwd(), dir);
-  const files = await (0, import_fast_glob.default)("*.+(js|ts)", {
+  const { configDir, emitFileName, emitDir, globalName, devMatch, buildMatch } = options.env;
+  const folder = await resolveConfigFolder(import_node_process3.default.cwd(), configDir);
+  if (!folder)
+    throw new Error(`[unplugin-env] Config directory "${configDir}" not found from ${import_node_process3.default.cwd()}`);
+  const files = await (0, import_fast_glob.default)("*.{js,ts}", {
     absolute: true,
     cwd: folder
   });
+  if (!files.length)
+    throw new Error(`[unplugin-env] No config files found in ${folder}`);
   const { mode, base } = context;
-  const testReg = mode === "dev" ? serve : build;
+  const testReg = mode === "dev" ? devMatch : buildMatch;
   let target = "";
   let source = "";
   let code = "";
-  const name = fileName;
+  let targetFile = "";
+  let sourceFile = "";
+  const resolvedEmitFileName = resolveEmitFileName(emitDir, emitFileName);
   for (const file of files) {
     try {
       const mod = await import_node_fs2.promises.readFile(file, "utf-8");
-      if (testReg?.test(file))
+      if (testReg?.test(file)) {
         target = mod;
-      else
+        targetFile = file;
+      } else {
         source = mod;
+        sourceFile = file;
+      }
     } catch (error) {
       console.error(`Error loading file ${file}:`, error);
     }
   }
-  const targetAst = import_recast.default.parse(target);
-  const sourceAst = import_recast.default.parse(source);
-  const targetExport = targetAst.program.body.find((n) => n.type === "ExportDefaultDeclaration").declaration;
-  const sourceExport = sourceAst.program.body.find((n) => n.type === "ExportDefaultDeclaration").declaration;
+  if (files.length === 1) {
+    if (!target) {
+      target = source;
+      targetFile = sourceFile;
+    }
+    if (!source) {
+      source = target;
+      sourceFile = targetFile;
+    }
+  }
+  if (!target || !targetFile)
+    throw new Error(`[unplugin-env] No file matched "${testReg}" in ${folder}`);
+  if (!source || !sourceFile)
+    throw new Error(`[unplugin-env] No base config file found in ${folder}`);
+  const targetAst = parseConfig(target, targetFile);
+  const sourceAst = parseConfig(source, sourceFile);
+  const targetExport = getDefaultExportObject(targetAst, targetFile);
+  const sourceExport = getDefaultExportObject(sourceAst, sourceFile);
   mergeObjects(sourceExport, targetExport);
-  const mergedCode = import_recast.default.print(sourceExport).code;
+  const mergedCode = recast.print(sourceExport).code;
   const returnedTarget = mergedCode;
   const versionInfo = await generateVersion(options, mode);
   code = `window.${globalName}=${returnedTarget};
 ${versionInfo}`;
   const formatCode = code;
+  const viteIgnoreAttr = context.framework === "vite" ? " vite-ignore" : "";
+  const scriptSrc = joinBasePath(base, resolvedEmitFileName);
   return {
     code,
-    script: `  <script type="text/javascript" src="${base}${fileName}"></script>
+    script: `  <script type="text/javascript"${viteIgnoreAttr} src="${scriptSrc}"></script>
 </head>`,
     emit: {
       type: "asset",
-      fileName: name,
+      fileName: resolvedEmitFileName,
       source: formatCode
     },
     watchFiles: files
   };
 }
+async function getFullPackageJson(cwd = import_node_process3.default.cwd()) {
+  const pkgPath = import_node_path2.default.resolve(cwd, "package.json");
+  const content = await import_node_fs2.promises.readFile(pkgPath, "utf-8");
+  return JSON.parse(content);
+}
+function wrapText(text, maxLen) {
+  const lines = [];
+  let current = "";
+  for (const char of text) {
+    current += char;
+    if (current.length >= maxLen) {
+      lines.push(current);
+      current = "";
+    }
+  }
+  if (current)
+    lines.push(current);
+  return lines;
+}
+function parseConfig(code, filePath) {
+  const parser = filePath.endsWith(".ts") ? import_typescript.default : void 0;
+  return parser ? recast.parse(code, { parser }) : recast.parse(code);
+}
+function getDefaultExportObject(ast, filePath) {
+  const exportNode = ast?.program?.body?.find((node) => node.type === "ExportDefaultDeclaration");
+  if (!exportNode?.declaration)
+    throw new Error(`[unplugin-env] ${filePath} must have a default export of an object`);
+  let decl = exportNode.declaration;
+  if (decl.type === "TSAsExpression" || decl.type === "TSTypeAssertion")
+    decl = decl.expression;
+  if (decl.type === "CallExpression" && decl.arguments?.[0]?.type === "ObjectExpression")
+    decl = decl.arguments[0];
+  if (decl.type !== "ObjectExpression")
+    throw new Error(`[unplugin-env] ${filePath} default export must be an object literal`);
+  return decl;
+}
+function joinBasePath(base, resourcePath) {
+  const safeBase = base && base.endsWith("/") ? base : `${base || "/"}`.replace(/\/?$/, "/");
+  const safeFile = resourcePath.replace(/^\/+/, "");
+  return `${safeBase}${safeFile}`;
+}
+function resolveEmitFileName(emitDir, emitFileName) {
+  const normalizedFile = emitFileName.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!emitDir)
+    return normalizedFile;
+  const normalizedDir = emitDir.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!normalizedDir)
+    return normalizedFile;
+  const prefix = `${normalizedDir}/`;
+  if (normalizedFile === normalizedDir || normalizedFile.startsWith(prefix))
+    return normalizedFile;
+  return import_node_path2.default.posix.join(normalizedDir, normalizedFile);
+}
+async function resolveConfigFolder(root, configDir) {
+  if (!configDir)
+    return "";
+  const candidate = import_node_path2.default.isAbsolute(configDir) ? configDir : import_node_path2.default.resolve(root, configDir);
+  try {
+    const stat = await import_node_fs2.promises.stat(candidate);
+    if (stat.isDirectory())
+      return candidate;
+  } catch {
+  }
+  return findFolder(root, configDir);
+}
 async function generateVersion(options, mode) {
-  const pkg = await (0, import_local_pkg.getPackageInfo)(import_node_process3.default.cwd());
-  return `console.info("Version: %c${pkg?.version}%c -  ${mode === "dev" ? "runtime" : "built"} on %c${options.datetime}%c", "color: green;", '', "color: blue;", '')`;
+  const pkg = await getFullPackageJson(import_node_process3.default.cwd());
+  const name = pkg?.name ?? "Unknown App";
+  const version = `v${pkg?.version ?? "0.0.0"}`;
+  const branchName = getBranchName() || "unknown";
+  const commitHash = getCommitHash() || "unknown";
+  const datetime = options.datetime;
+  const stateLabel = mode === "dev" ? "runtime" : "built";
+  const stateColor = mode === "dev" ? "#059669" : "#2563EB";
+  const MAX_DESC_LINE_LEN = 36;
+  const rawDesc = pkg?.description ?? "unknown";
+  const descLines = wrapText(rawDesc, MAX_DESC_LINE_LEN);
+  const baseLines = [
+    `${name}  ${version}  ${stateLabel}`,
+    `Branch : ${branchName}`,
+    `Commit : ${commitHash}`,
+    `Time   : ${datetime}`,
+    `Desc   : ${descLines[0]}`,
+    ...descLines.slice(1).map((l) => `         ${l}`)
+  ];
+  const maxLen = Math.max(...baseLines.map((l) => l.length));
+  const divider = "-".repeat(maxLen + 4);
+  const textParts = [
+    `${divider}
+`,
+    ` ${name} `,
+    ` ${version} `,
+    ` ${stateLabel}
+`,
+    `${divider}
+`,
+    ` Branch :`,
+    ` ${branchName}
+`,
+    ` Commit :`,
+    ` ${commitHash}
+`,
+    ` Time   :`,
+    ` ${datetime}
+`,
+    ` Desc   :`,
+    ` ${descLines[0]}
+`,
+    ...descLines.slice(1).map((l) => `          ${l}
+`),
+    `${divider}`
+  ];
+  const styles3 = [
+    "color:#9CA3AF",
+    // divider
+    "color:#111827;font-weight:600",
+    // name
+    "color:#2563EB;font-weight:600",
+    // version
+    `color:${stateColor};font-weight:600`,
+    // state
+    "color:#9CA3AF",
+    // divider
+    "color:#6B7280",
+    // Branch label
+    "color:#111827",
+    "color:#6B7280",
+    // Commit label
+    "color:#111827",
+    "color:#6B7280",
+    // Time label
+    "color:#2563EB",
+    "color:#6B7280",
+    // Desc label
+    "color:#4B5563",
+    ...descLines.slice(1).map(() => "color:#4B5563"),
+    "color:#9CA3AF"
+    // divider
+  ];
+  return `
+console.log(
+  ${JSON.stringify(`%c${textParts.join("%c")}`)},
+  ${styles3.map((s) => JSON.stringify(s)).join(",\n  ")}
+)
+`.trim();
 }
 async function findFolder(directoryPath, dir) {
   const ignore = /* @__PURE__ */ new Set(["dist", "node_modules", "playground", "example", "test", "jest", "tests", "locales", "public", ".git", ".github", ".vscode"]);
-  const files = await import_node_fs2.promises.readdir(directoryPath);
-  const filePaths = files.filter((item) => !ignore.has(item));
+  const entries = await import_node_fs2.promises.readdir(directoryPath, { withFileTypes: true });
+  const dirLower = dir.toLowerCase();
+  const filePaths = entries.filter((entry) => !ignore.has(entry.name));
   let nestedFolder = "";
-  for (const file of filePaths) {
-    const fullFilePath = import_node_path2.default.join(directoryPath, file);
-    const stat = await import_node_fs2.promises.stat(fullFilePath);
-    if (stat.isDirectory()) {
-      if (file.toLowerCase() === dir) {
-        return fullFilePath;
-      } else {
-        nestedFolder = await findFolder(fullFilePath, dir);
-        if (nestedFolder)
-          return nestedFolder;
-      }
-    }
+  for (const entry of filePaths) {
+    if (!entry.isDirectory())
+      continue;
+    const fullFilePath = import_node_path2.default.join(directoryPath, entry.name);
+    if (entry.name.toLowerCase() === dirLower)
+      return fullFilePath;
+    nestedFolder = await findFolder(fullFilePath, dir);
+    if (nestedFolder)
+      return nestedFolder;
   }
   return "";
 }
+function getBranchName() {
+  const branchName = (0, import_node_child_process.execSync)("git rev-parse --abbrev-ref HEAD").toString().trim();
+  return branchName;
+}
+function getCommitHash() {
+  const commitHash = (0, import_node_child_process.execSync)("git rev-parse HEAD").toString().trim();
+  return commitHash.slice(0, 8);
+}
 
 // src/core/options.ts
 function resolveOptions(options) {
   const defaults = {
     env: {
-      dir: "config",
-      fileName: "manifest.js",
+      configDir: "config",
+      emitFileName: "manifest.js",
+      emitDir: "",
       globalName: "manifest",
-      serve: /dev/i,
-      build: /prod/i
+      devMatch: /dev/i,
+      buildMatch: /prod/i
     },
     compress: {
-      ignoreBase: false
+      includeBaseDir: true
     }
   };
   const mergeOptions = (0, import_utils.deepMerge)(defaults, options);
@@ -6288,16 +6463,33 @@ function createUnifiedContext(resolved) {
 
 // src/index.ts
 var virtualEnvId = "virtual:env";
+var virtualEnvAliasId = "virtual-env";
 var resolvedVirtualEnvId = `\0${virtualEnvId}`;
+var resolvedVirtualEnvAliasId = `\0${virtualEnvAliasId}`;
+function isVirtualEnvId(id) {
+  return id.startsWith(virtualEnvId) || id.startsWith(virtualEnvAliasId);
+}
+function resolveVirtualEnvId(id) {
+  return id.startsWith(virtualEnvAliasId) ? resolvedVirtualEnvAliasId : resolvedVirtualEnvId;
+}
+function isResolvedVirtualEnvId(id) {
+  return id.startsWith(resolvedVirtualEnvId) || id.startsWith(resolvedVirtualEnvAliasId);
+}
 var unpluginFactory = (options = {}) => {
   const resolved = resolveOptions(options);
   const ctx = createUnifiedContext(resolved);
+  let frameworkReady = null;
+  let legacyEmitHooked = false;
   return [{
     name: "plugin-env",
     enforce: "post",
     rollup: {
+      async buildStart() {
+        const outputOptions = { dir: ctx.outDir };
+        await ctx.setRollup(outputOptions);
+      },
       outputOptions(outputOptions) {
-        ctx.setRollup(outputOptions);
+        ctx.outDir = outputOptions.dir || ctx.outDir;
         return outputOptions;
       }
     },
@@ -6307,10 +6499,82 @@ var unpluginFactory = (options = {}) => {
       }
     },
     async webpack(compiler) {
-      await ctx.setWebpack(compiler);
+      frameworkReady = ctx.setWebpack(compiler);
+      const webpackLib = compiler.webpack;
+      const RawSource = webpackLib?.sources?.RawSource;
+      compiler.hooks.thisCompilation.tap("plugin-env", (compilation) => {
+        if (webpackLib?.Compilation?.PROCESS_ASSETS_STAGE_PRE_PROCESS) {
+          const { Compilation, sources } = webpackLib;
+          compilation.hooks.processAssets.tapPromise(
+            { name: "plugin-env", stage: Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS },
+            async () => {
+              await frameworkReady;
+              const manifestName = ctx.scriptInfo.emit.fileName;
+              if (!manifestName)
+                return;
+              const asset = compilation.getAsset(manifestName);
+              if (!asset || asset.info?.minimized)
+                return;
+              compilation.updateAsset(manifestName, asset.source, { ...asset.info, minimized: true });
+            }
+          );
+          compilation.hooks.processAssets.tapPromise(
+            { name: "plugin-env", stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE },
+            async (assets) => {
+              await frameworkReady;
+              const { script } = ctx.scriptInfo;
+              if (!script)
+                return;
+              const scriptTag = script.replace(/<\/head>\s*$/i, "").trim();
+              for (const name of Object.keys(assets)) {
+                if (!name.endsWith(".html"))
+                  continue;
+                const asset = compilation.getAsset(name);
+                const html = asset?.source.source().toString() || "";
+                if (!html || html.includes(scriptTag))
+                  continue;
+                const nextHtml = html.replace(/<\/head>/i, script);
+                if (nextHtml !== html)
+                  compilation.updateAsset(name, new sources.RawSource(nextHtml));
+              }
+            }
+          );
+        } else if (!legacyEmitHooked) {
+          legacyEmitHooked = true;
+          compiler.hooks.emit.tapAsync("plugin-env", (comp, cb) => {
+            const run = () => {
+              const { script } = ctx.scriptInfo;
+              if (!script)
+                return cb();
+              const scriptTag = script.replace(/<\/head>\s*$/i, "").trim();
+              for (const name of Object.keys(comp.assets)) {
+                if (!name.endsWith(".html"))
+                  continue;
+                const asset = comp.assets[name];
+                const html = asset?.source().toString() || "";
+                if (!html || html.includes(scriptTag))
+                  continue;
+                const nextHtml = html.replace(/<\/head>/i, script);
+                if (nextHtml !== html) {
+                  comp.assets[name] = RawSource ? new RawSource(nextHtml) : {
+                    source: () => nextHtml,
+                    size: () => nextHtml.length
+                  };
+                }
+              }
+              cb();
+            };
+            if (frameworkReady) {
+              frameworkReady.then(run).catch((error) => cb(error));
+            } else {
+              run();
+            }
+          });
+        }
+      });
     },
     rspack: async (compiler) => {
-      await ctx.setRspack(compiler);
+      frameworkReady = ctx.setRspack(compiler);
     },
     esbuild: {
       async setup(build) {
@@ -6326,35 +6590,62 @@ var unpluginFactory = (options = {}) => {
       }
     },
     async resolveId(id) {
-      if (id.startsWith(virtualEnvId))
-        return resolvedVirtualEnvId;
+      if (isVirtualEnvId(id))
+        return resolveVirtualEnvId(id);
+    },
+    loadInclude(id) {
+      if (isResolvedVirtualEnvId(id) || isVirtualEnvId(id))
+        return true;
+      if (id.endsWith(".html")) {
+        return ctx.framework === "vite" || ctx.framework === "rollup" || ctx.framework === "rolldown";
+      }
+      return false;
     },
     async load(id) {
+      if (frameworkReady)
+        await frameworkReady;
       const { code, watchFiles, emit, script } = ctx.scriptInfo;
       if (ctx.isDev) {
-        if (id.startsWith(resolvedVirtualEnvId)) {
+        if (isResolvedVirtualEnvId(id)) {
           watchFiles.forEach((file) => {
             this.addWatchFile(file);
           });
           return code;
         }
       } else {
-        if (id.startsWith(resolvedVirtualEnvId)) {
+        if (isResolvedVirtualEnvId(id)) {
           this.emitFile(emit);
           return "";
         }
-        if (id.endsWith(".html")) {
+        const canTransformHtml = ctx.framework === "vite" || ctx.framework === "rollup" || ctx.framework === "rolldown";
+        if (canTransformHtml && id.endsWith(".html")) {
           let code2 = await import_node_fs3.promises.readFile(id, "utf-8");
           code2 = code2.replace(/<\/head>/g, script);
           return { code: code2 };
         }
       }
     },
+    transformInclude(id) {
+      return /\.(?:c|m)?(?:j|t)sx?$/.test(id);
+    },
+    async transform(code, id) {
+      if (ctx.framework !== "webpack" && ctx.framework !== "rspack")
+        return;
+      if (!id.match(/\.(?:c|m)?(?:j|t)sx?$/))
+        return;
+      if (!code.includes(virtualEnvId))
+        return;
+      return code.replaceAll(virtualEnvId, virtualEnvAliasId);
+    },
     buildEnd: () => {
-      import_node_process5.default.on("beforeExit", async () => {
+      import_node_process5.default.on("beforeExit", () => {
         const { compress } = resolved;
-        await createCompress(compress, ctx.outDir);
-        import_node_process5.default.exit(0);
+        createCompress(compress, ctx.outDir).then(() => {
+          import_node_process5.default.exit(0);
+        }).catch((error) => {
+          import_node_process5.default.exitCode = 1;
+          throw error;
+        });
       });
     }
   }];

package/dist/vite.js

@@ -5,8 +5,8 @@
     
 import {
   vite_default
-} from "./chunk-7PNJWMAM.js";
-import "./chunk-IQADAXMX.js";
+} from "./chunk-GGVUS5GJ.js";
+import "./chunk-2DBNCJJW.js";
 export {
   vite_default as default
 };