unplugin-env 1.0.3 → 1.0.5

package/README.md

@@ -151,6 +151,32 @@ build({
 
 <br></details>
 
+## Options
+
+```ts
+Starter({
+  env: {
+    configDir: 'config',
+    emitFileName: 'manifest.js',
+    emitDir: 'assets',
+    globalName: 'manifest',
+    devMatch: /dev/i,
+    buildMatch: /prod/i,
+  },
+  compress: {
+    includeBaseDir: true,
+  },
+})
+```
+
+- `env.configDir`: directory to locate config files.
+- `env.emitFileName`: output file name for the emitted asset and injected script.
+- `env.emitDir`: subdirectory under the build output directory.
+- `env.globalName`: global variable name on `window`.
+- `env.devMatch`: regex to pick the dev config file.
+- `env.buildMatch`: regex to pick the build config file.
+- `compress.includeBaseDir`: keep the top-level folder inside the zip.
+
 ## System Requirements
 
 ### Runtime Environment

package/README.zh-CN.md

@@ -153,6 +153,32 @@ build({
 
 <br></details>
 
+## 配置项
+
+```ts
+Starter({
+  env: {
+    configDir: 'config',
+    emitFileName: 'manifest.js',
+    emitDir: 'assets',
+    globalName: 'manifest',
+    devMatch: /dev/i,
+    buildMatch: /prod/i,
+  },
+  compress: {
+    includeBaseDir: true,
+  },
+})
+```
+
+- `env.configDir`: 配置文件所在目录。
+- `env.emitFileName`: 输出文件名（用于 emit 和注入脚本）。
+- `env.emitDir`: 输出子目录（相对于构建输出目录）。
+- `env.globalName`: 挂到 `window` 的全局变量名。
+- `env.devMatch`: 匹配开发环境配置文件的正则。
+- `env.buildMatch`: 匹配生产环境配置文件的正则。
+- `compress.includeBaseDir`: 压缩时是否保留顶层目录。
+
 ## 系统要求详情
 
 ### 运行环境

package/dist/{chunk-IQADAXMX.js → chunk-2DBNCJJW.js}

@@ -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;
     };
-    module.exports = parse;
+    module.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;
     };
-    module.exports = parse;
+    module.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);
     };
@@ -6050,13 +6050,13 @@ var Log = class {
 
 // src/core/compress.ts
 async function createCompress(options, outDir) {
-  const { ignoreBase } = options;
+  const { includeBaseDir } = options;
   const zipFilePath = path.resolve(process3.cwd(), `${path.basename(outDir)}.zip`);
   const absoluteOutDir = path.resolve(outDir);
   Log.log("Compressing directory:", absoluteOutDir);
   try {
     const zip = new Zip();
-    if (ignoreBase) {
+    if (!includeBaseDir) {
       zip.addFolder(absoluteOutDir);
     } else {
       zip.addFolder(absoluteOutDir, path.basename(outDir));
@@ -6082,11 +6082,12 @@ import { deepMerge } from "@antfu/utils";
 
 // src/core/generate.ts
 var import_fast_glob = __toESM(require_out4(), 1);
+import { execSync } from "child_process";
 import { promises as fs2 } from "fs";
 import path2 from "path";
 import process4 from "process";
-import { getPackageInfo } from "local-pkg";
-import recast from "recast";
+import * as recast from "recast";
+import tsParser from "recast/parsers/typescript.js";
 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) {
@@ -6101,33 +6102,56 @@ function mergeObjects(prodObj, devObj) {
   }
 }
 async function generateScript(options, context) {
-  const { dir, fileName, globalName, serve, build } = options.env;
-  const folder = await findFolder(process4.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(process4.cwd(), configDir);
+  if (!folder)
+    throw new Error(`[unplugin-env] Config directory "${configDir}" not found from ${process4.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 fs2.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 = recast.parse(target);
-  const sourceAst = recast.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 = recast.print(sourceExport).code;
   const returnedTarget = mergedCode;
@@ -6135,55 +6159,206 @@ async function generateScript(options, context) {
   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 = process4.cwd()) {
+  const pkgPath = path2.resolve(cwd, "package.json");
+  const content = await fs2.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") ? tsParser : 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 path2.posix.join(normalizedDir, normalizedFile);
+}
+async function resolveConfigFolder(root, configDir) {
+  if (!configDir)
+    return "";
+  const candidate = path2.isAbsolute(configDir) ? configDir : path2.resolve(root, configDir);
+  try {
+    const stat = await fs2.stat(candidate);
+    if (stat.isDirectory())
+      return candidate;
+  } catch {
+  }
+  return findFolder(root, configDir);
+}
 async function generateVersion(options, mode) {
-  const pkg = await getPackageInfo(process4.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(process4.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 fs2.readdir(directoryPath);
-  const filePaths = files.filter((item) => !ignore.has(item));
+  const entries = await fs2.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 = path2.join(directoryPath, file);
-    const stat = await fs2.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 = path2.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 = execSync("git rev-parse --abbrev-ref HEAD").toString().trim();
+  return branchName;
+}
+function getCommitHash() {
+  const commitHash = 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 = deepMerge(defaults, options);
@@ -6280,16 +6455,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;
       }
     },
@@ -6299,10 +6491,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) {
@@ -6318,35 +6582,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 fs3.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: () => {
-      process6.on("beforeExit", async () => {
+      process6.on("beforeExit", () => {
         const { compress } = resolved;
-        await createCompress(compress, ctx.outDir);
-        process6.exit(0);
+        createCompress(compress, ctx.outDir).then(() => {
+          process6.exit(0);
+        }).catch((error) => {
+          process6.exitCode = 1;
+          throw error;
+        });
       });
     }
   }];