wxt 0.11.1 → 0.12.0

package/bin/wxt.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli.js';

package/dist/{chunk-65FJ5ESC.js → chunk-UY7NE73P.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "0.11.1";
+var version = "0.12.0";
 
 // src/core/utils/arrays.ts
 function every(array, predicate) {
@@ -1029,7 +1029,8 @@ async function craeteViteBuilder(inlineConfig, userConfig, wxtConfig) {
       devHtmlPrerender(wxtConfig),
       unimport(wxtConfig),
       virtualEntrypoint("background", wxtConfig),
-      virtualEntrypoint("content-script", wxtConfig),
+      virtualEntrypoint("content-script-isolated-world", wxtConfig),
+      virtualEntrypoint("content-script-main-world", wxtConfig),
       virtualEntrypoint("unlisted-script", wxtConfig),
       devServerGlobals(wxtConfig),
       tsconfigPaths(wxtConfig),
@@ -1043,12 +1044,17 @@ async function craeteViteBuilder(inlineConfig, userConfig, wxtConfig) {
     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;
+    let virtualEntrypointType;
+    switch (entrypoint.type) {
+      case "background":
+      case "unlisted-script":
+        virtualEntrypointType = entrypoint.type;
+        break;
+      case "content-script":
+        virtualEntrypointType = entrypoint.options.world === "MAIN" ? "content-script-main-world" : "content-script-isolated-world";
+        break;
+    }
+    const entry = virtualEntrypointType ? `virtual:wxt-${virtualEntrypointType}?${entrypoint.inputPath}` : entrypoint.inputPath;
     const plugins = [
       entrypointGroupGlobals(entrypoint)
     ];
@@ -1209,7 +1215,10 @@ async function getInternalConfig(inlineConfig, command, server) {
     const { config: loadedConfig, ...metadata } = await loadConfig({
       name: "wxt",
       cwd: inlineConfig.root ?? process.cwd(),
-      rcFile: false
+      rcFile: false,
+      jitiOptions: {
+        esmResolve: true
+      }
     });
     userConfig = loadedConfig ?? {};
     userConfigMetadata = metadata;
@@ -1418,7 +1427,7 @@ var ENTRY_TYPE_TO_GROUP_MAP = {
 import createJITI from "jiti";
 import { createUnimport as createUnimport3 } from "unimport";
 import fs7 from "fs-extra";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve8 } from "node:path";
 
 // src/core/utils/strings.ts
 function kebabCaseAlphanumeric(str) {
@@ -1432,14 +1441,14 @@ function removeImportStatements(text) {
 }
 function removeProjectImportStatements(text) {
   const noImports = removeImportStatements(text);
-  return `import { defineContentScript, defineBackground } from 'wxt/client';
-import { defineUnlistedScript } from 'wxt/sandbox';
+  return `import { defineUnlistedScript, defineContentScript, defineBackground } from 'wxt/sandbox';
 
 ${noImports}`;
 }
 
 // src/core/utils/building/import-entrypoint.ts
 import { transformSync } from "esbuild";
+import { fileURLToPath } from "node:url";
 async function importEntrypointFile(path6, config) {
   config.logger.debug("Loading file metadata:", path6);
   const normalPath = normalizePath(path6);
@@ -1455,30 +1464,42 @@ async function importEntrypointFile(path6, config) {
   config.logger.debug(
     ["Text:", text, "No imports:", textNoImports, "Code:", code].join("\n")
   );
-  const jiti = createJITI(__filename, {
-    cache: false,
-    debug: config.debug,
-    esmResolve: true,
-    alias: {
-      "webextension-polyfill": resolve8(
-        config.root,
-        "node_modules/wxt/dist/virtual/mock-browser.js"
-      )
-    },
-    // Continue using node to load TS files even if `bun run --bun` is detected. Jiti does not
-    // respect the custom transform function when using it's native bun option.
-    experimentalBun: false,
-    // List of extensions to transform with esbuild
-    extensions: [".ts", ".cts", ".mts", ".tsx", ".js", ".cjs", ".mjs", ".jsx"],
-    transform(opts) {
-      const isEntrypoint = opts.filename === normalPath;
-      return transformSync(
-        // Use modified source code for entrypoints
-        isEntrypoint ? code : opts.source,
-        getEsbuildOptions(opts)
-      );
+  const jiti = createJITI(
+    typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url),
+    {
+      cache: false,
+      debug: config.debug,
+      esmResolve: true,
+      alias: {
+        "webextension-polyfill": resolve8(
+          config.root,
+          "node_modules/wxt/dist/virtual/mock-browser.js"
+        )
+      },
+      // Continue using node to load TS files even if `bun run --bun` is detected. Jiti does not
+      // respect the custom transform function when using it's native bun option.
+      experimentalBun: false,
+      // List of extensions to transform with esbuild
+      extensions: [
+        ".ts",
+        ".cts",
+        ".mts",
+        ".tsx",
+        ".js",
+        ".cjs",
+        ".mjs",
+        ".jsx"
+      ],
+      transform(opts) {
+        const isEntrypoint = opts.filename === normalPath;
+        return transformSync(
+          // Use modified source code for entrypoints
+          isEntrypoint ? code : opts.source,
+          getEsbuildOptions(opts)
+        );
+      }
     }
-  });
+  );
   try {
     const res = await jiti(path6);
     return res.default;
@@ -2203,51 +2224,47 @@ async function combineAnalysisStats(config) {
 // src/core/utils/building/find-entrypoints.ts
 import glob3 from "fast-glob";
 async function findEntrypoints(config) {
-  const relativePaths = await glob3("**/*", {
+  const relativePaths = await glob3(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
     cwd: config.entrypointsDir
   });
   relativePaths.sort();
   const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
-  let hasBackground = false;
-  const possibleEntrypoints = await Promise.all(
-    relativePaths.map(async (relativePath) => {
-      const path6 = resolve12(config.entrypointsDir, relativePath);
-      const matchingGlob = pathGlobs.find(
-        (glob4) => minimatch(relativePath, glob4)
-      );
-      if (matchingGlob == null) {
-        config.logger.warn(
-          `${relativePath} does not match any known entrypoint. Known entrypoints:
-${JSON.stringify(
-            PATH_GLOB_TO_TYPE_MAP,
-            null,
-            2
-          )}`
-        );
-        return;
-      }
+  const entrypointInfos = relativePaths.reduce((results, relativePath) => {
+    const inputPath = resolve12(config.entrypointsDir, relativePath);
+    const name = getEntrypointName(config.entrypointsDir, inputPath);
+    const matchingGlob = pathGlobs.find(
+      (glob4) => minimatch(relativePath, glob4)
+    );
+    if (matchingGlob) {
       const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
-      if (type === "ignored")
-        return;
+      results.push({ name, inputPath, type });
+    }
+    return results;
+  }, []);
+  preventNoEntrypoints(config, entrypointInfos);
+  preventDuplicateEntrypointNames(config, entrypointInfos);
+  let hasBackground = false;
+  const entrypoints = await Promise.all(
+    entrypointInfos.map(async (info) => {
+      const { type } = info;
       switch (type) {
         case "popup":
-          return await getPopupEntrypoint(config, path6);
+          return await getPopupEntrypoint(config, info);
         case "options":
-          return await getOptionsEntrypoint(config, path6);
+          return await getOptionsEntrypoint(config, info);
         case "background":
           hasBackground = true;
-          return await getBackgroundEntrypoint(config, path6);
+          return await getBackgroundEntrypoint(config, info);
         case "content-script":
-          return await getContentScriptEntrypoint(config, path6);
+          return await getContentScriptEntrypoint(config, info);
         case "unlisted-page":
-          return await getUnlistedPageEntrypoint(config, path6);
+          return await getUnlistedPageEntrypoint(config, info);
         case "unlisted-script":
-          return await getUnlistedScriptEntrypoint(config, path6);
+          return await getUnlistedScriptEntrypoint(config, info);
         case "content-script-style":
           return {
+            ...info,
             type,
-            name: getEntrypointName(config.entrypointsDir, path6),
-            inputPath: path6,
             outputDir: resolve12(config.outDir, CONTENT_SCRIPT_OUT_DIR),
             options: {
               include: void 0,
@@ -2256,9 +2273,8 @@ ${JSON.stringify(
           };
         default:
           return {
+            ...info,
             type,
-            name: getEntrypointName(config.entrypointsDir, path6),
-            inputPath: path6,
             outputDir: config.outDir,
             options: {
               include: void 0,
@@ -2268,25 +2284,13 @@ ${JSON.stringify(
       }
     })
   );
-  const entrypoints = possibleEntrypoints.filter(
-    (entry) => !!entry
-  );
-  const existingNames = {};
-  entrypoints.forEach((entrypoint) => {
-    const withSameName = existingNames[entrypoint.name];
-    if (withSameName) {
-      throw Error(
-        `Multiple entrypoints with the name "${entrypoint.name}" detected, but only one is allowed: ${[
-          relative4(config.root, withSameName.inputPath),
-          relative4(config.root, entrypoint.inputPath)
-        ].join(", ")}`
-      );
-    }
-    existingNames[entrypoint.name] = entrypoint;
-  });
   if (config.command === "serve" && !hasBackground) {
     entrypoints.push(
-      await getBackgroundEntrypoint(config, VIRTUAL_NOOP_BACKGROUND_MODULE_ID)
+      await getBackgroundEntrypoint(config, {
+        inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
+        name: "background",
+        type: "background"
+      })
     );
   }
   config.logger.debug("All entrypoints:", entrypoints);
@@ -2309,6 +2313,41 @@ ${JSON.stringify(
   config.logger.debug(`${config.browser} entrypoints:`, targetEntrypoints);
   return targetEntrypoints;
 }
+function preventDuplicateEntrypointNames(config, files) {
+  const namesToPaths = files.reduce(
+    (map, { name, inputPath }) => {
+      map[name] ??= [];
+      map[name].push(inputPath);
+      return map;
+    },
+    {}
+  );
+  const errorLines = Object.entries(namesToPaths).reduce(
+    (lines, [name, absolutePaths]) => {
+      if (absolutePaths.length > 1) {
+        lines.push(`- ${name}`);
+        absolutePaths.forEach((absolutePath) => {
+          lines.push(`  - ${relative4(config.root, absolutePath)}`);
+        });
+      }
+      return lines;
+    },
+    []
+  );
+  if (errorLines.length > 0) {
+    const errorContent = errorLines.join("\n");
+    throw Error(
+      `Multiple entrypoints with the same name detected, only one entrypoint for each name is allowed.
+
+${errorContent}`
+    );
+  }
+}
+function preventNoEntrypoints(config, files) {
+  if (files.length === 0) {
+    throw Error(`No entrypoints found in ${config.entrypointsDir}`);
+  }
+}
 function getHtmlBaseOptions(document) {
   const options = {};
   const includeContent = document.querySelector("meta[name='manifest.include']")?.getAttribute("content");
@@ -2321,8 +2360,8 @@ function getHtmlBaseOptions(document) {
   }
   return options;
 }
-async function getPopupEntrypoint(config, path6) {
-  const content = await fs12.readFile(path6, "utf-8");
+async function getPopupEntrypoint(config, { inputPath, name }) {
+  const content = await fs12.readFile(inputPath, "utf-8");
   const { document } = parseHTML2(content);
   const options = getHtmlBaseOptions(document);
   const title = document.querySelector("title");
@@ -2351,12 +2390,12 @@ async function getPopupEntrypoint(config, path6) {
     type: "popup",
     name: "popup",
     options,
-    inputPath: path6,
+    inputPath,
     outputDir: config.outDir
   };
 }
-async function getOptionsEntrypoint(config, path6) {
-  const content = await fs12.readFile(path6, "utf-8");
+async function getOptionsEntrypoint(config, { inputPath, name }) {
+  const content = await fs12.readFile(inputPath, "utf-8");
   const { document } = parseHTML2(content);
   const options = getHtmlBaseOptions(document);
   const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
@@ -2375,25 +2414,24 @@ async function getOptionsEntrypoint(config, path6) {
     type: "options",
     name: "options",
     options,
-    inputPath: path6,
+    inputPath,
     outputDir: config.outDir
   };
 }
-async function getUnlistedPageEntrypoint(config, path6) {
-  const content = await fs12.readFile(path6, "utf-8");
+async function getUnlistedPageEntrypoint(config, { inputPath, name }) {
+  const content = await fs12.readFile(inputPath, "utf-8");
   const { document } = parseHTML2(content);
   return {
     type: "unlisted-page",
-    name: getEntrypointName(config.entrypointsDir, path6),
-    inputPath: path6,
+    name: getEntrypointName(config.entrypointsDir, inputPath),
+    inputPath,
     outputDir: config.outDir,
     options: getHtmlBaseOptions(document)
   };
 }
-async function getUnlistedScriptEntrypoint(config, path6) {
-  const name = getEntrypointName(config.entrypointsDir, path6);
+async function getUnlistedScriptEntrypoint(config, { inputPath, name }) {
   const defaultExport = await importEntrypointFile(
-    path6,
+    inputPath,
     config
   );
   if (defaultExport == null) {
@@ -2406,17 +2444,16 @@ async function getUnlistedScriptEntrypoint(config, path6) {
   return {
     type: "unlisted-script",
     name,
-    inputPath: path6,
+    inputPath,
     outputDir: config.outDir,
     options
   };
 }
-async function getBackgroundEntrypoint(config, path6) {
-  const name = "background";
+async function getBackgroundEntrypoint(config, { inputPath, name }) {
   let options = {};
-  if (path6 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+  if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
     const defaultExport = await importEntrypointFile(
-      path6,
+      inputPath,
       config
     );
     if (defaultExport == null) {
@@ -2430,7 +2467,7 @@ async function getBackgroundEntrypoint(config, path6) {
   return {
     type: "background",
     name,
-    inputPath: path6,
+    inputPath,
     outputDir: config.outDir,
     options: {
       ...options,
@@ -2439,9 +2476,8 @@ async function getBackgroundEntrypoint(config, path6) {
     }
   };
 }
-async function getContentScriptEntrypoint(config, path6) {
-  const name = getEntrypointName(config.entrypointsDir, path6);
-  const { main: _, ...options } = await importEntrypointFile(path6, config);
+async function getContentScriptEntrypoint(config, { inputPath, name }) {
+  const { main: _, ...options } = await importEntrypointFile(inputPath, config);
   if (options == null) {
     throw Error(
       `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
@@ -2450,7 +2486,7 @@ async function getContentScriptEntrypoint(config, path6) {
   return {
     type: "content-script",
     name,
-    inputPath: path6,
+    inputPath,
     outputDir: resolve12(config.outDir, CONTENT_SCRIPT_OUT_DIR),
     options
   };
@@ -2489,12 +2525,10 @@ var PATH_GLOB_TO_TYPE_MAP = {
   "options/index.html": "options",
   "*.html": "unlisted-page",
   "*/index.html": "unlisted-page",
-  "*.[jt]s": "unlisted-script",
-  "*/index.ts": "unlisted-script",
+  "*.[jt]s?(x)": "unlisted-script",
+  "*/index.[jt]s?(x)": "unlisted-script",
   [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
-  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
-  // Don't warn about any files in subdirectories, like CSS or JS entrypoints for HTML files or tests
-  "*/**": "ignored"
+  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style"
 };
 var CONTENT_SCRIPT_OUT_DIR = "content-scripts";