wxt 0.10.4 → 0.11.0

package/dist/testing.cjs

@@ -44,8 +44,8 @@ var import_node_path2 = __toESM(require("path"), 1);
 // src/core/utils/paths.ts
 var import_node_path = __toESM(require("path"), 1);
 var import_normalize_path = __toESM(require("normalize-path"), 1);
-function normalizePath(path7) {
-  return (0, import_normalize_path.default)(path7);
+function normalizePath(path6) {
+  return (0, import_normalize_path.default)(path6);
 }
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
@@ -56,14 +56,22 @@ function getEntrypointName(entrypointsDir, inputPath) {
   const name = relativePath.split(/[\.\/\\]/, 2)[0];
   return name;
 }
+function getEntrypointOutputFile(entrypoint, ext) {
+  return (0, import_node_path2.resolve)(entrypoint.outputDir, `${entrypoint.name}${ext}`);
+}
+function getEntrypointBundlePath(entrypoint, outDir, ext) {
+  return normalizePath(
+    (0, import_node_path2.relative)(outDir, getEntrypointOutputFile(entrypoint, ext))
+  );
+}
 
-// src/core/vite-plugins/devHtmlPrerender.ts
+// src/core/builders/vite/plugins/devHtmlPrerender.ts
 var import_linkedom = require("linkedom");
-var import_path = require("path");
+var import_node_path3 = require("path");
 var reactRefreshPreamble = "";
 function devHtmlPrerender(config) {
   const htmlReloadId = "@wxt/reload-html";
-  const resolvedHtmlReloadId = (0, import_path.resolve)(
+  const resolvedHtmlReloadId = (0, import_node_path3.resolve)(
     config.root,
     "node_modules/wxt/dist/virtual/reload-html.js"
   );
@@ -94,11 +102,11 @@ function devHtmlPrerender(config) {
             const src = element.getAttribute(attr);
             if (!src)
               return;
-            if ((0, import_path.isAbsolute)(src)) {
+            if ((0, import_node_path3.isAbsolute)(src)) {
               element.setAttribute(attr, server.origin + src);
             } else if (src.startsWith(".")) {
-              const abs = (0, import_path.resolve)((0, import_path.dirname)(id), src);
-              const pathname = (0, import_path.relative)(config.root, abs);
+              const abs = (0, import_node_path3.resolve)((0, import_node_path3.dirname)(id), src);
+              const pathname = (0, import_node_path3.relative)(config.root, abs);
               element.setAttribute(attr, `${server.origin}/${pathname}`);
             }
           });
@@ -123,11 +131,7 @@ function devHtmlPrerender(config) {
         const originalUrl = `${server.origin}${ctx.path}`;
         const name = getEntrypointName(config.entrypointsDir, ctx.filename);
         const url = `${server.origin}/${name}.html`;
-        const serverHtml = await server.transformIndexHtml(
-          url,
-          html,
-          originalUrl
-        );
+        const serverHtml = await server.transformHtml(url, html, originalUrl);
         const { document } = (0, import_linkedom.parseHTML)(serverHtml);
         const reactRefreshScript = Array.from(
           document.querySelectorAll("script[type=module]")
@@ -175,20 +179,18 @@ function devHtmlPrerender(config) {
   ];
 }
 
-// src/core/vite-plugins/devServerGlobals.ts
-function devServerGlobals(internalConfig) {
+// src/core/builders/vite/plugins/devServerGlobals.ts
+function devServerGlobals(config) {
   return {
     name: "wxt:dev-server-globals",
     config() {
-      if (internalConfig.server == null || internalConfig.command == "build")
+      if (config.server == null || config.command == "build")
         return;
       return {
         define: {
           __DEV_SERVER_PROTOCOL__: JSON.stringify("ws:"),
-          __DEV_SERVER_HOSTNAME__: JSON.stringify(
-            internalConfig.server.hostname
-          ),
-          __DEV_SERVER_PORT__: JSON.stringify(internalConfig.server.port)
+          __DEV_SERVER_HOSTNAME__: JSON.stringify(config.server.hostname),
+          __DEV_SERVER_PORT__: JSON.stringify(config.server.port)
         }
       };
     }
@@ -247,7 +249,7 @@ async function fetchCached(url, config) {
   return content;
 }
 
-// src/core/vite-plugins/download.ts
+// src/core/builders/vite/plugins/download.ts
 function download(config) {
   return {
     name: "wxt:download",
@@ -264,15 +266,70 @@ function download(config) {
   };
 }
 
-// src/core/vite-plugins/multipageMove.ts
-var import_node_path3 = require("path");
+// src/core/builders/vite/plugins/multipageMove.ts
+var import_node_path4 = require("path");
 var import_fs_extra = __toESM(require("fs-extra"), 1);
+function multipageMove(entrypoints, config) {
+  return {
+    name: "wxt:multipage-move",
+    async writeBundle(_, bundle) {
+      for (const oldBundlePath in bundle) {
+        const entrypoint = entrypoints.find(
+          (entry) => !!normalizePath(entry.inputPath).endsWith(oldBundlePath)
+        );
+        if (entrypoint == null) {
+          config.logger.debug(
+            `No entrypoint found for ${oldBundlePath}, leaving in chunks directory`
+          );
+          continue;
+        }
+        const newBundlePath = getEntrypointBundlePath(
+          entrypoint,
+          config.outDir,
+          (0, import_node_path4.extname)(oldBundlePath)
+        );
+        if (newBundlePath === oldBundlePath) {
+          config.logger.debug(
+            "HTML file is already in the correct location",
+            oldBundlePath
+          );
+          continue;
+        }
+        const oldAbsPath = (0, import_node_path4.resolve)(config.outDir, oldBundlePath);
+        const newAbsPath = (0, import_node_path4.resolve)(config.outDir, newBundlePath);
+        await (0, import_fs_extra.ensureDir)((0, import_node_path4.dirname)(newAbsPath));
+        await import_fs_extra.default.move(oldAbsPath, newAbsPath, { overwrite: true });
+        const renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+      removeEmptyDirs(config.outDir);
+    }
+  };
+}
+async function removeEmptyDirs(dir) {
+  const files = await import_fs_extra.default.readdir(dir);
+  for (const file of files) {
+    const filePath = (0, import_node_path4.join)(dir, file);
+    const stats = await import_fs_extra.default.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await import_fs_extra.default.rmdir(dir);
+  } catch {
+  }
+}
 
-// src/core/vite-plugins/unimport.ts
+// src/core/builders/vite/plugins/unimport.ts
 var import_unimport = require("unimport");
 
 // src/core/utils/unimport.ts
-var import_vite = require("vite");
+var import_defu = require("defu");
 function getUnimportOptions(config) {
   if (config.imports === false)
     return false;
@@ -291,14 +348,11 @@ function getUnimportOptions(config) {
     warn: config.logger.warn,
     dirs: ["components", "composables", "hooks", "utils"]
   };
-  return (0, import_vite.mergeConfig)(
-    defaultOptions,
-    config.imports
-  );
+  return (0, import_defu.defu)(config.imports, defaultOptions);
 }
 
-// src/core/vite-plugins/unimport.ts
-var import_path2 = require("path");
+// src/core/builders/vite/plugins/unimport.ts
+var import_path = require("path");
 var ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".js",
   ".jsx",
@@ -320,16 +374,16 @@ function unimport(config) {
     async transform(code, id) {
       if (id.includes("node_modules"))
         return;
-      if (!ENABLED_EXTENSIONS.has((0, import_path2.extname)(id)))
+      if (!ENABLED_EXTENSIONS.has((0, import_path.extname)(id)))
         return;
       return unimport2.injectImports(code, id);
     }
   };
 }
 
-// src/core/vite-plugins/virtualEntrypoint.ts
+// src/core/builders/vite/plugins/virtualEntrypoint.ts
 var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var import_path3 = require("path");
+var import_path2 = require("path");
 function virtualEntrypoint(type, config) {
   const virtualId = `virtual:wxt-${type}?`;
   const resolvedVirtualId = `\0${virtualId}`;
@@ -347,7 +401,7 @@ function virtualEntrypoint(type, config) {
         return;
       const inputPath = id.replace(resolvedVirtualId, "");
       const template = await import_fs_extra2.default.readFile(
-        (0, import_path3.resolve)(
+        (0, import_path2.resolve)(
           config.root,
           `node_modules/wxt/dist/virtual/${type}-entrypoint.js`
         ),
@@ -358,7 +412,7 @@ function virtualEntrypoint(type, config) {
   };
 }
 
-// src/core/vite-plugins/tsconfigPaths.ts
+// src/core/builders/vite/plugins/tsconfigPaths.ts
 function tsconfigPaths(config) {
   return {
     name: "wxt:aliases",
@@ -372,7 +426,10 @@ function tsconfigPaths(config) {
   };
 }
 
-// src/core/vite-plugins/noopBackground.ts
+// src/core/utils/constants.ts
+var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+
+// src/core/builders/vite/plugins/noopBackground.ts
 function noopBackground() {
   const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
   const resolvedVirtualModuleId = "\0" + virtualModuleId;
@@ -390,9 +447,32 @@ export default defineBackground(() => void 0)`;
     }
   };
 }
-var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
 
-// src/core/vite-plugins/bundleAnalysis.ts
+// src/core/builders/vite/plugins/cssEntrypoints.ts
+function cssEntrypoints(entrypoint, config) {
+  return {
+    name: "wxt:css-entrypoint",
+    config() {
+      return {
+        build: {
+          rollupOptions: {
+            output: {
+              assetFileNames: () => getEntrypointBundlePath(entrypoint, config.outDir, ".css")
+            }
+          }
+        }
+      };
+    },
+    generateBundle(_, bundle) {
+      Object.keys(bundle).forEach((file) => {
+        if (file.endsWith(".js"))
+          delete bundle[file];
+      });
+    }
+  };
+}
+
+// src/core/builders/vite/plugins/bundleAnalysis.ts
 var import_rollup_plugin_visualizer = require("rollup-plugin-visualizer");
 var increment = 0;
 function bundleAnalysis() {
@@ -448,11 +528,20 @@ function getGlobals(config) {
     }
   ];
 }
+function getEntrypointGlobals(entrypointName) {
+  return [
+    {
+      name: surroundInUnderscore("ENTRYPOINT"),
+      value: entrypointName,
+      type: `string`
+    }
+  ];
+}
 function surroundInUnderscore(name) {
   return `__${name}__`;
 }
 
-// src/core/vite-plugins/globals.ts
+// src/core/builders/vite/plugins/globals.ts
 function globals(config) {
   return {
     name: "wxt:globals",
@@ -468,8 +557,8 @@ function globals(config) {
   };
 }
 
-// src/core/vite-plugins/webextensionPolyfillAlias.ts
-var import_node_path4 = __toESM(require("path"), 1);
+// src/core/builders/vite/plugins/webextensionPolyfillAlias.ts
+var import_node_path5 = __toESM(require("path"), 1);
 function webextensionPolyfillAlias(config) {
   return {
     name: "wxt:webextension-polyfill-test-alias",
@@ -477,7 +566,7 @@ function webextensionPolyfillAlias(config) {
       return {
         resolve: {
           alias: {
-            "webextension-polyfill": import_node_path4.default.resolve(
+            "webextension-polyfill": import_node_path5.default.resolve(
               config.root,
               "node_modules/wxt/dist/virtual/mock-browser"
             )
@@ -488,7 +577,7 @@ function webextensionPolyfillAlias(config) {
   };
 }
 
-// src/core/vite-plugins/webextensionPolyfillInlineDeps.ts
+// src/core/builders/vite/plugins/webextensionPolyfillInlineDeps.ts
 function webextensionPolyfillInlineDeps() {
   return {
     name: "wxt:testing-inline-deps",
@@ -507,7 +596,7 @@ function webextensionPolyfillInlineDeps() {
   };
 }
 
-// src/core/vite-plugins/excludeBrowserPolyfill.ts
+// src/core/builders/vite/plugins/excludeBrowserPolyfill.ts
 function excludeBrowserPolyfill(config) {
   const virtualId = "virtual:wxt-webextension-polyfill-disabled";
   return {
@@ -531,13 +620,26 @@ function excludeBrowserPolyfill(config) {
   };
 }
 
-// src/core/utils/building/build-entrypoints.ts
-var vite = __toESM(require("vite"), 1);
+// src/core/builders/vite/plugins/entrypointGroupGlobals.ts
+function entrypointGroupGlobals(entrypointGroup) {
+  return {
+    name: "wxt:entrypoint-group-globals",
+    config() {
+      const define = {};
+      let name = Array.isArray(entrypointGroup) ? "html" : entrypointGroup.name;
+      for (const global of getEntrypointGlobals(name)) {
+        define[global.name] = JSON.stringify(global.value);
+      }
+      return {
+        define
+      };
+    }
+  };
+}
 
 // src/core/utils/fs.ts
 var import_fs_extra3 = __toESM(require("fs-extra"), 1);
 var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
 async function writeFileIfDifferent(file, newContents) {
   const existingContents = await import_fs_extra3.default.readFile(file, "utf-8").catch(() => void 0);
   if (existingContents !== newContents) {
@@ -605,23 +707,22 @@ var import_node_path6 = __toESM(require("path"), 1);
 // src/core/utils/building/get-internal-config.ts
 var import_c12 = require("c12");
 var import_node_path7 = __toESM(require("path"), 1);
-var vite2 = __toESM(require("vite"), 1);
 
 // src/core/utils/cache.ts
 var import_fs_extra7 = __toESM(require("fs-extra"), 1);
-var import_path4 = require("path");
+var import_path3 = require("path");
 function createFsCache(wxtDir) {
-  const getPath = (key) => (0, import_path4.resolve)(wxtDir, "cache", encodeURIComponent(key));
+  const getPath = (key) => (0, import_path3.resolve)(wxtDir, "cache", encodeURIComponent(key));
   return {
     async set(key, value) {
-      const path7 = getPath(key);
-      await (0, import_fs_extra7.ensureDir)((0, import_path4.dirname)(path7));
-      await writeFileIfDifferent(path7, value);
+      const path6 = getPath(key);
+      await (0, import_fs_extra7.ensureDir)((0, import_path3.dirname)(path6));
+      await writeFileIfDifferent(path6, value);
     },
     async get(key) {
-      const path7 = getPath(key);
+      const path6 = getPath(key);
       try {
-        return await import_fs_extra7.default.readFile(path7, "utf-8");
+        return await import_fs_extra7.default.readFile(path6, "utf-8");
       } catch {
         return void 0;
       }
@@ -631,8 +732,204 @@ function createFsCache(wxtDir) {
 
 // src/core/utils/building/get-internal-config.ts
 var import_consola = __toESM(require("consola"), 1);
-var import_defu = __toESM(require("defu"), 1);
-async function getInternalConfig(inlineConfig, command) {
+
+// src/core/builders/vite/index.ts
+async function craeteViteBuilder(inlineConfig, userConfig, wxtConfig) {
+  const vite = await import("vite");
+  const getBaseConfig = async () => {
+    const resolvedInlineConfig = await inlineConfig.vite?.(wxtConfig.env) ?? {};
+    const resolvedUserConfig = await userConfig.vite?.(wxtConfig.env) ?? {};
+    const config = vite.mergeConfig(
+      resolvedUserConfig,
+      resolvedInlineConfig
+    );
+    config.root = wxtConfig.root;
+    config.configFile = false;
+    config.logLevel = "warn";
+    config.mode = wxtConfig.mode;
+    config.build ??= {};
+    config.build.outDir = wxtConfig.outDir;
+    config.build.emptyOutDir = false;
+    config.plugins ??= [];
+    config.plugins.push(
+      download(wxtConfig),
+      devHtmlPrerender(wxtConfig),
+      unimport(wxtConfig),
+      virtualEntrypoint("background", wxtConfig),
+      virtualEntrypoint("content-script", wxtConfig),
+      virtualEntrypoint("unlisted-script", wxtConfig),
+      devServerGlobals(wxtConfig),
+      tsconfigPaths(wxtConfig),
+      noopBackground(),
+      globals(wxtConfig),
+      excludeBrowserPolyfill(wxtConfig)
+    );
+    if (wxtConfig.analysis.enabled) {
+      config.plugins.push(bundleAnalysis());
+    }
+    return config;
+  };
+  const getLibModeConfig = (entrypoint) => {
+    const isVirtual = [
+      "background",
+      "content-script",
+      "unlisted-script"
+    ].includes(entrypoint.type);
+    const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
+    const plugins = [
+      entrypointGroupGlobals(entrypoint)
+    ];
+    if (entrypoint.type === "content-script-style" || entrypoint.type === "unlisted-style") {
+      plugins.push(cssEntrypoints(entrypoint, wxtConfig));
+    }
+    const libMode = {
+      mode: wxtConfig.mode,
+      plugins,
+      build: {
+        lib: {
+          entry,
+          formats: ["iife"],
+          name: "_",
+          fileName: entrypoint.name
+        },
+        rollupOptions: {
+          output: {
+            // There's only a single output for this build, so we use the desired bundle path for the
+            // entry output (like "content-scripts/overlay.js")
+            entryFileNames: getEntrypointBundlePath(
+              entrypoint,
+              wxtConfig.outDir,
+              ".js"
+            ),
+            // Output content script CSS to `content-scripts/`, but all other scripts are written to
+            // `assets/`.
+            assetFileNames: ({ name }) => {
+              if (entrypoint.type === "content-script" && name?.endsWith("css")) {
+                return `content-scripts/${entrypoint.name}.[ext]`;
+              } else {
+                return `assets/${entrypoint.name}.[ext]`;
+              }
+            }
+          }
+        }
+      },
+      define: {
+        // See https://github.com/aklinker1/vite-plugin-web-extension/issues/96
+        "process.env.NODE_ENV": JSON.stringify(wxtConfig.mode)
+      }
+    };
+    return libMode;
+  };
+  const getMultiPageConfig = (entrypoints) => {
+    return {
+      mode: wxtConfig.mode,
+      plugins: [
+        multipageMove(entrypoints, wxtConfig),
+        entrypointGroupGlobals(entrypoints)
+      ],
+      build: {
+        rollupOptions: {
+          input: entrypoints.reduce((input, entry) => {
+            input[entry.name] = entry.inputPath;
+            return input;
+          }, {}),
+          output: {
+            // Include a hash to prevent conflicts
+            chunkFileNames: "chunks/[name]-[hash].js",
+            // Include a hash to prevent conflicts
+            entryFileNames: "chunks/[name]-[hash].js",
+            // We can't control the "name", so we need a hash to prevent conflicts
+            assetFileNames: "assets/[name]-[hash].[ext]"
+          }
+        }
+      }
+    };
+  };
+  const getCssConfig = (entrypoint) => {
+    return {
+      mode: wxtConfig.mode,
+      plugins: [entrypointGroupGlobals(entrypoint)],
+      build: {
+        rollupOptions: {
+          input: {
+            [entrypoint.name]: entrypoint.inputPath
+          },
+          output: {
+            assetFileNames: () => {
+              if (entrypoint.type === "content-script-style") {
+                return `content-scripts/${entrypoint.name}.[ext]`;
+              } else {
+                return `assets/${entrypoint.name}.[ext]`;
+              }
+            }
+          }
+        }
+      }
+    };
+  };
+  return {
+    name: "Vite",
+    version: vite.version,
+    async build(group) {
+      let entryConfig;
+      if (Array.isArray(group))
+        entryConfig = getMultiPageConfig(group);
+      else if (group.inputPath.endsWith(".css"))
+        entryConfig = getCssConfig(group);
+      else
+        entryConfig = getLibModeConfig(group);
+      const buildConfig = vite.mergeConfig(await getBaseConfig(), entryConfig);
+      const result = await vite.build(buildConfig);
+      return {
+        entrypoints: group,
+        chunks: getBuildOutputChunks(result)
+      };
+    },
+    async createServer(info) {
+      const serverConfig = {
+        server: {
+          port: info.port,
+          strictPort: true,
+          host: info.hostname,
+          origin: info.origin
+        }
+      };
+      const baseConfig = await getBaseConfig();
+      const viteServer = await vite.createServer(
+        vite.mergeConfig(baseConfig, serverConfig)
+      );
+      const server = {
+        async listen() {
+          await viteServer.listen(info.port);
+        },
+        transformHtml(...args) {
+          return viteServer.transformIndexHtml(...args);
+        },
+        ws: {
+          send(message, payload) {
+            return viteServer.ws.send(message, payload);
+          },
+          on(message, cb) {
+            viteServer.ws.on(message, cb);
+          }
+        },
+        watcher: viteServer.watcher
+      };
+      return server;
+    }
+  };
+}
+function getBuildOutputChunks(result) {
+  if ("on" in result)
+    throw Error("wxt does not support vite watch mode.");
+  if (Array.isArray(result))
+    return result.flatMap(({ output }) => output);
+  return result.output;
+}
+
+// src/core/utils/building/get-internal-config.ts
+var import_defu2 = __toESM(require("defu"), 1);
+async function getInternalConfig(inlineConfig, command, server) {
   let userConfig = {};
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
@@ -702,8 +999,6 @@ async function getInternalConfig(inlineConfig, command) {
     runnerConfig,
     srcDir,
     typesDir,
-    vite: () => ({}),
-    // Real value added after this object is initialized.
     wxtDir,
     zip: resolveInternalZipConfig(root, mergedConfig),
     transformManifest(manifest) {
@@ -718,10 +1013,18 @@ async function getInternalConfig(inlineConfig, command) {
     alias,
     experimental: {
       includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
-    }
+    },
+    server
+  };
+  const builder = await craeteViteBuilder(
+    inlineConfig,
+    userConfig,
+    finalConfig
+  );
+  return {
+    ...finalConfig,
+    builder
   };
-  finalConfig.vite = (env2) => resolveInternalViteConfig(env2, mergedConfig, finalConfig);
-  return finalConfig;
 }
 async function resolveManifestConfig(env, manifest) {
   return await (typeof manifest === "function" ? manifest(env) : manifest ?? {});
@@ -733,26 +1036,18 @@ function mergeInlineConfig(inlineConfig, userConfig) {
   } else if (userConfig.imports == null && inlineConfig.imports == null) {
     imports = void 0;
   } else {
-    imports = vite2.mergeConfig(
-      userConfig.imports ?? {},
-      inlineConfig.imports ?? {}
-    );
+    imports = (0, import_defu2.default)(inlineConfig.imports ?? {}, userConfig.imports ?? {});
   }
   const manifest = async (env) => {
     const user = await resolveManifestConfig(env, userConfig.manifest);
     const inline = await resolveManifestConfig(env, inlineConfig.manifest);
-    return vite2.mergeConfig(user, inline);
+    return (0, import_defu2.default)(inline, user);
   };
-  const viteConfig = async (env) => {
-    const user = await userConfig.vite?.(env);
-    const inline = await inlineConfig.vite?.(env);
-    return vite2.mergeConfig(user ?? {}, inline ?? {});
-  };
-  const runner = (0, import_defu.default)(
+  const runner = (0, import_defu2.default)(
     inlineConfig.runner ?? {},
     userConfig.runner ?? {}
   );
-  const zip = (0, import_defu.default)(
+  const zip = (0, import_defu2.default)(
     inlineConfig.zip ?? {},
     userConfig.zip ?? {}
   );
@@ -771,7 +1066,6 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     runner,
     srcDir: inlineConfig.srcDir ?? userConfig.srcDir,
     outDir: inlineConfig.outDir ?? userConfig.outDir,
-    vite: viteConfig,
     zip,
     analysis: {
       enabled: inlineConfig.analysis?.enabled ?? userConfig.analysis?.enabled,
@@ -785,6 +1079,7 @@ function mergeInlineConfig(inlineConfig, userConfig) {
       ...userConfig.experimental,
       ...inlineConfig.experimental
     },
+    vite: void 0,
     transformManifest: void 0
   };
 }
@@ -809,38 +1104,6 @@ function resolveInternalZipConfig(root, mergedConfig) {
     ]
   };
 }
-async function resolveInternalViteConfig(env, mergedConfig, finalConfig) {
-  const internalVite = await mergedConfig.vite?.(env) ?? {};
-  internalVite.root = finalConfig.root;
-  internalVite.configFile = false;
-  internalVite.logLevel = "warn";
-  internalVite.mode = env.mode;
-  internalVite.build ??= {};
-  internalVite.build.outDir = finalConfig.outDir;
-  internalVite.build.emptyOutDir = false;
-  internalVite.plugins ??= [];
-  internalVite.plugins.push(download(finalConfig));
-  internalVite.plugins.push(devHtmlPrerender(finalConfig));
-  internalVite.plugins.push(unimport(finalConfig));
-  internalVite.plugins.push(
-    virtualEntrypoint("background", finalConfig)
-  );
-  internalVite.plugins.push(
-    virtualEntrypoint("content-script", finalConfig)
-  );
-  internalVite.plugins.push(
-    virtualEntrypoint("unlisted-script", finalConfig)
-  );
-  internalVite.plugins.push(devServerGlobals(finalConfig));
-  internalVite.plugins.push(tsconfigPaths(finalConfig));
-  internalVite.plugins.push(noopBackground());
-  if (finalConfig.analysis.enabled) {
-    internalVite.plugins.push(bundleAnalysis());
-  }
-  internalVite.plugins.push(globals(finalConfig));
-  internalVite.plugins.push(excludeBrowserPolyfill(finalConfig));
-  return internalVite;
-}
 
 // src/core/utils/building/import-entrypoint.ts
 var import_jiti = __toESM(require("jiti"), 1);
@@ -850,7 +1113,6 @@ var import_esbuild = require("esbuild");
 
 // src/core/utils/building/internal-build.ts
 var import_picocolors4 = __toESM(require("picocolors"), 1);
-var vite3 = __toESM(require("vite"), 1);
 var import_fs_extra12 = __toESM(require("fs-extra"), 1);
 
 // src/core/utils/log/printFileList.ts
@@ -887,7 +1149,7 @@ var import_fs_extra10 = __toESM(require("fs-extra"), 1);
 
 // src/core/utils/manifest.ts
 var import_immer = require("immer");
-var import_defu2 = __toESM(require("defu"), 1);
+var import_defu3 = __toESM(require("defu"), 1);
 
 // src/testing/wxt-vitest-plugin.ts
 function WxtVitest(inlineConfig) {