unplugin-env 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -1914,7 +1914,7 @@ var require_scan = __commonJS({
         isExtglob = false;
         isGlob = false;
       }
-      let base2 = str;
+      let base = str;
       let prefix = "";
       let glob = "";
       if (start > 0) {
@@ -1922,31 +1922,31 @@ var require_scan = __commonJS({
         str = str.slice(start);
         lastIndex -= start;
       }
-      if (base2 && isGlob === true && lastIndex > 0) {
-        base2 = str.slice(0, lastIndex);
+      if (base && isGlob === true && lastIndex > 0) {
+        base = str.slice(0, lastIndex);
         glob = str.slice(lastIndex);
       } else if (isGlob === true) {
-        base2 = "";
+        base = "";
         glob = str;
       } else {
-        base2 = str;
+        base = str;
       }
-      if (base2 && base2 !== "" && base2 !== "/" && base2 !== str) {
-        if (isPathSeparator(base2.charCodeAt(base2.length - 1))) {
-          base2 = base2.slice(0, -1);
+      if (base && base !== "" && base !== "/" && base !== str) {
+        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+          base = base.slice(0, -1);
         }
       }
       if (opts.unescape === true) {
         if (glob) glob = utils.removeBackslashes(glob);
-        if (base2 && backslashes === true) {
-          base2 = utils.removeBackslashes(base2);
+        if (base && backslashes === true) {
+          base = utils.removeBackslashes(base);
         }
       }
       const state = {
         prefix,
         input,
         start,
-        base: base2,
+        base,
         glob,
         isBrace,
         isBracket,
@@ -3499,28 +3499,28 @@ var require_tasks = __commonJS({
     function groupPatternsByBaseDirectory(patterns) {
       const group = {};
       return patterns.reduce((collection, pattern) => {
-        const base2 = utils.pattern.getBaseDirectory(pattern);
-        if (base2 in collection) {
-          collection[base2].push(pattern);
+        const base = utils.pattern.getBaseDirectory(pattern);
+        if (base in collection) {
+          collection[base].push(pattern);
         } else {
-          collection[base2] = [pattern];
+          collection[base] = [pattern];
         }
         return collection;
       }, group);
     }
     exports2.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
     function convertPatternGroupsToTasks(positive, negative, dynamic) {
-      return Object.keys(positive).map((base2) => {
-        return convertPatternGroupToTask(base2, positive[base2], negative, dynamic);
+      return Object.keys(positive).map((base) => {
+        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
       });
     }
     exports2.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
-    function convertPatternGroupToTask(base2, positive, negative, dynamic) {
+    function convertPatternGroupToTask(base, positive, negative, dynamic) {
       return {
         dynamic,
         positive,
         negative,
-        base: base2,
+        base,
         patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
       };
     }
@@ -4460,8 +4460,8 @@ var require_async3 = __commonJS({
       onEnd(callback) {
         this._emitter.once("end", callback);
       }
-      _pushToQueue(directory, base2) {
-        const queueItem = { directory, base: base2 };
+      _pushToQueue(directory, base) {
+        const queueItem = { directory, base };
         this._queue.push(queueItem, (error) => {
           if (error !== null) {
             this._handleError(error);
@@ -4488,19 +4488,19 @@ var require_async3 = __commonJS({
         this._isDestroyed = true;
         this._emitter.emit("error", error);
       }
-      _handleEntry(entry, base2) {
+      _handleEntry(entry, base) {
         if (this._isDestroyed || this._isFatalError) {
           return;
         }
         const fullpath = entry.path;
-        if (base2 !== void 0) {
-          entry.path = common.joinPathSegments(base2, entry.name, this._settings.pathSegmentSeparator);
+        if (base !== void 0) {
+          entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
         }
         if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
           this._emitEntry(entry);
         }
         if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
-          this._pushToQueue(fullpath, base2 === void 0 ? void 0 : entry.path);
+          this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
         }
       }
       _emitEntry(entry) {
@@ -4608,19 +4608,19 @@ var require_sync3 = __commonJS({
         this._handleQueue();
         return this._storage;
       }
-      _pushToQueue(directory, base2) {
-        this._queue.add({ directory, base: base2 });
+      _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
       }
       _handleQueue() {
         for (const item of this._queue.values()) {
           this._handleDirectory(item.directory, item.base);
         }
       }
-      _handleDirectory(directory, base2) {
+      _handleDirectory(directory, base) {
         try {
           const entries = this._scandir(directory, this._settings.fsScandirSettings);
           for (const entry of entries) {
-            this._handleEntry(entry, base2);
+            this._handleEntry(entry, base);
           }
         } catch (error) {
           this._handleError(error);
@@ -4632,16 +4632,16 @@ var require_sync3 = __commonJS({
         }
         throw error;
       }
-      _handleEntry(entry, base2) {
+      _handleEntry(entry, base) {
         const fullpath = entry.path;
-        if (base2 !== void 0) {
-          entry.path = common.joinPathSegments(base2, entry.name, this._settings.pathSegmentSeparator);
+        if (base !== void 0) {
+          entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
         }
         if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
           this._pushToStorage(entry);
         }
         if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
-          this._pushToQueue(fullpath, base2 === void 0 ? void 0 : entry.path);
+          this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
         }
       }
       _pushToStorage(entry) {
@@ -5537,14 +5537,14 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_fs3 = require("fs");
-var import_node_process4 = __toESM(require("process"), 1);
+var import_node_process5 = __toESM(require("process"), 1);
 var import_unplugin = require("unplugin");
 
 // src/core/compress.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_node_process2 = __toESM(require("process"), 1);
-var import_archiver = __toESM(require("archiver"), 1);
+var import_zip_lib = require("zip-lib");
 
 // node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -6056,39 +6056,37 @@ var Log = class {
 };
 
 // src/core/compress.ts
-async function createCompress(options) {
-  const { outDir, ignoreBase } = options;
+async function createCompress(options, outDir) {
+  const { ignoreBase } = options;
   const zipFilePath = import_node_path.default.resolve(import_node_process2.default.cwd(), `${import_node_path.default.basename(outDir)}.zip`);
-  Log.log("Compressing the directory", outDir);
-  return new Promise((resolve, reject) => {
-    try {
-      const output = import_node_fs.default.createWriteStream(zipFilePath);
-      const archive = (0, import_archiver.default)("zip");
-      output.on("close", () => {
-        Log.success("Successfully compressed to", `${zipFilePath} (${(archive.pointer() / 1024 / 1024).toFixed(1)} MB)`);
-        resolve(null);
-      });
-      archive.on("warning", (err) => {
-        if (err.code === "ENOENT")
-          Log.log("File not found during compression:", err.message);
-        else
-          Log.log("Compression warning:", err.message);
-      });
-      archive.on("error", (err) => {
-        Log.error("Compression error:", err);
-        reject(err);
-      });
-      archive.pipe(output);
-      const absoluteOutDir = import_node_path.default.resolve(outDir);
-      archive.directory(absoluteOutDir, ignoreBase ? false : import_node_path.default.basename(outDir));
-      archive.finalize();
-    } catch (error) {
-      Log.error("Error compressing the directory", error);
-      throw error;
-    }
-  });
+  const absoluteOutDir = import_node_path.default.resolve(outDir);
+  Log.log("Compressing directory:", absoluteOutDir);
+  try {
+    const zip = new import_zip_lib.Zip();
+    if (ignoreBase) {
+      zip.addFolder(absoluteOutDir);
+    } else {
+      zip.addFolder(absoluteOutDir, import_node_path.default.basename(outDir));
+    }
+    await zip.archive(zipFilePath);
+    const stat = import_node_fs.default.statSync(zipFilePath);
+    const size = stat.size;
+    const readableSize = size > 1024 * 1024 ? `${(size / 1024 / 1024).toFixed(1)} MB` : `${(size / 1024).toFixed(1)} KB`;
+    Log.success(
+      "Successfully compressed to:",
+      `${zipFilePath} (${readableSize})`
+    );
+    return null;
+  } catch (error) {
+    Log.error("Compression error:", error);
+    throw error;
+  }
 }
 
+// src/core/options.ts
+var import_node_process4 = __toESM(require("process"), 1);
+var import_utils = require("@antfu/utils");
+
 // src/core/generate.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = __toESM(require("path"), 1);
@@ -6109,14 +6107,15 @@ function mergeObjects(prodObj, devObj) {
     }
   }
 }
-async function generateScript(options, mode, base2) {
+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)", {
     absolute: true,
     cwd: folder
   });
-  const testReg = mode === "serve" ? serve : build;
+  const { mode, base } = context;
+  const testReg = mode === "dev" ? serve : build;
   let target = "";
   let source = "";
   let code = "";
@@ -6145,7 +6144,7 @@ ${versionInfo}`;
   const formatCode = code;
   return {
     code,
-    script: `  <script type="text/javascript" src="${base2}${fileName}"></script>
+    script: `  <script type="text/javascript" src="${base}${fileName}"></script>
 </head>`,
     emit: {
       type: "asset",
@@ -6157,7 +6156,7 @@ ${versionInfo}`;
 }
 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 === "serve" ? "runtime" : "built"} on %c${options.date}%c", "color: green;", '', "color: blue;", '')`;
+  return `console.info("Version: %c${pkg?.version}%c -  ${mode === "dev" ? "runtime" : "built"} on %c${options.datetime}%c", "color: green;", '', "color: blue;", '')`;
 }
 async function findFolder(directoryPath, dir) {
   const ignore = /* @__PURE__ */ new Set(["dist", "node_modules", "playground", "example", "test", "jest", "tests", "locales", "public", ".git", ".github", ".vscode"]);
@@ -6181,7 +6180,6 @@ async function findFolder(directoryPath, dir) {
 }
 
 // src/core/options.ts
-var import_utils = require("@antfu/utils");
 function resolveOptions(options) {
   const defaults = {
     env: {
@@ -6192,8 +6190,7 @@ function resolveOptions(options) {
       build: /prod/i
     },
     compress: {
-      outDir: "dist",
-      ignoreBase: true
+      ignoreBase: false
     }
   };
   const mergeOptions = (0, import_utils.deepMerge)(defaults, options);
@@ -6203,67 +6200,160 @@ function resolveOptions(options) {
   });
   return {
     ...mergeOptions,
-    date: formatter.format(/* @__PURE__ */ new Date())
+    datetime: formatter.format(/* @__PURE__ */ new Date())
   };
 }
+function createUnifiedContext(resolved) {
+  const ctx = {
+    framework: "",
+    base: "/",
+    outDir: "dist",
+    mode: "build",
+    scriptInfo: {
+      code: "",
+      script: "",
+      emit: {
+        type: "asset",
+        source: "",
+        fileName: ""
+      },
+      watchFiles: []
+    },
+    get isDev() {
+      return this.mode === "dev";
+    },
+    get isBuild() {
+      return this.mode === "build";
+    },
+    // --- VITE ---
+    async setVite(config) {
+      this.framework = "vite";
+      this.base = config.base || "/";
+      this.outDir = config.build?.outDir || "dist";
+      this.mode = config.command === "serve" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- ROLLUP ---
+    async setRollup(options) {
+      this.framework = "rollup";
+      this.outDir = options.dir || "dist";
+      this.mode = import_node_process4.default.env.ROLLUP_WATCH ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- WEBPACK ---
+    async setWebpack(compiler) {
+      this.framework = "webpack";
+      this.base = compiler.options.output?.publicPath || "/";
+      this.outDir = compiler.options.output?.path || "dist";
+      const raw = compiler.options.mode || "production";
+      this.mode = raw === "development" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- RSPACK ---
+    async setRspack(compiler) {
+      this.framework = "rspack";
+      this.base = compiler.options.output?.publicPath || "/";
+      this.outDir = compiler.options.output?.path || "dist";
+      const raw = compiler.options.mode || "production";
+      this.mode = raw === "development" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- ESBUILD ---
+    async setEsbuild(build) {
+      this.framework = "esbuild";
+      this.outDir = build.initialOptions.outdir || "dist";
+      this.mode = build.initialOptions.watch ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- FARM ---
+    async setFarm(compiler) {
+      this.framework = "farm";
+      this.base = compiler.config.output?.publicPath || "/";
+      this.outDir = compiler.config.output?.path || "dist";
+      const raw = compiler.config.mode || "production";
+      this.mode = raw === "development" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- ROLLDOWN ---
+    async setRolldown(options) {
+      this.framework = "rolldown";
+      this.outDir = options.dir || "dist";
+      this.mode = import_node_process4.default.env.ROLLDOWN_WATCH ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    }
+  };
+  return ctx;
+}
 
 // src/index.ts
 var virtualEnvId = "virtual:env";
 var resolvedVirtualEnvId = `\0${virtualEnvId}`;
-var base = "";
 var unpluginFactory = (options = {}) => {
   const resolved = resolveOptions(options);
+  const ctx = createUnifiedContext(resolved);
   return [{
-    name: "plugin-env-serve",
-    apply: "serve",
+    name: "plugin-env",
     enforce: "post",
-    configResolved(config) {
-      base = config.base;
+    rollup: {
+      outputOptions(outputOptions) {
+        ctx.setRollup(outputOptions);
+        return outputOptions;
+      }
     },
-    async resolveId(id) {
-      if (id.startsWith(virtualEnvId))
-        return resolvedVirtualEnvId;
+    vite: {
+      async configResolved(config) {
+        await ctx.setVite(config);
+      }
     },
-    async load(id) {
-      if (id.startsWith(resolvedVirtualEnvId)) {
-        const { code, watchFiles } = await generateScript(resolved, "serve", base);
-        watchFiles.forEach((file) => {
-          this.addWatchFile(file);
-        });
-        return code;
+    async webpack(compiler) {
+      await ctx.setWebpack(compiler);
+    },
+    rspack: async (compiler) => {
+      await ctx.setRspack(compiler);
+    },
+    esbuild: {
+      async setup(build) {
+        await ctx.setEsbuild(build);
       }
-    }
-  }, {
-    name: "unplugin-env-build",
-    apply: "build",
-    enforce: "post",
-    configResolved(config) {
-      base = config.base;
     },
-    resolveId(id) {
+    async farm(compiler) {
+      await ctx.setFarm(compiler);
+    },
+    rolldown: {
+      async outputOptions(outputOptions) {
+        await ctx.setRolldown(outputOptions);
+      }
+    },
+    async resolveId(id) {
       if (id.startsWith(virtualEnvId))
         return resolvedVirtualEnvId;
     },
     async load(id) {
-      const { emit, script } = await generateScript(resolved, "build", base);
-      if (id.startsWith(resolvedVirtualEnvId)) {
-        this.emitFile(emit);
-        return "";
-      }
-      if (id.endsWith(".html")) {
-        let code = await import_node_fs3.promises.readFile(id, "utf8");
-        code = code.replace(/<\/head>/g, script);
-        return {
-          code
-        };
+      const { code, watchFiles, emit, script } = ctx.scriptInfo;
+      if (ctx.isDev) {
+        if (id.startsWith(resolvedVirtualEnvId)) {
+          watchFiles.forEach((file) => {
+            this.addWatchFile(file);
+          });
+          return code;
+        }
+      } else {
+        if (id.startsWith(resolvedVirtualEnvId)) {
+          this.emitFile(emit);
+          return "";
+        }
+        if (id.endsWith(".html")) {
+          let code2 = await import_node_fs3.promises.readFile(id, "utf-8");
+          code2 = code2.replace(/<\/head>/g, script);
+          return { code: code2 };
+        }
       }
-      return null;
     },
     buildEnd: () => {
-      import_node_process4.default.on("beforeExit", async () => {
+      import_node_process5.default.on("beforeExit", async () => {
         const { compress } = resolved;
-        await createCompress(compress);
-        import_node_process4.default.exit(0);
+        await createCompress(compress, ctx.outDir);
+        import_node_process5.default.exit(0);
       });
     }
   }];

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   index_default,
   unplugin,
   unpluginFactory
-} from "./chunk-QWCQIGEO.js";
+} from "./chunk-IQADAXMX.js";
 export {
   index_default as default,
   unplugin,