wxt 0.3.2 → 0.4.1

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/core/utils/getInternalConfig.ts
 import path2, { resolve as resolve6 } from "node:path";
 import * as vite2 from "vite";
-import { consola } from "consola";
+import { LogLevels, consola } from "consola";
 
 // src/core/utils/entrypoints.ts
 import path, { relative, resolve } from "node:path";
@@ -9,11 +9,11 @@ import path, { relative, resolve } from "node:path";
 // src/core/utils/paths.ts
 import nodePath from "node:path";
 import * as vite from "vite";
-function normalizePath2(path5) {
-  return vite.normalizePath(path5);
+function normalizePath2(path7) {
+  return vite.normalizePath(path7);
 }
-function unnormalizePath(path5) {
-  return nodePath.normalize(path5);
+function unnormalizePath(path7) {
+  return nodePath.normalize(path7);
 }
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
@@ -195,7 +195,9 @@ function multipageMove(entrypoints, config) {
           (entry) => !!normalizePath2(entry.inputPath).endsWith(oldBundlePath)
         );
         if (entrypoint == null) {
-          config.logger.debug("No entrypoint found for", oldBundlePath);
+          config.logger.debug(
+            `No entrypoint found for ${oldBundlePath}, leaving in chunks directory`
+          );
           continue;
         }
         const newBundlePath = getEntrypointBundlePath(
@@ -302,12 +304,22 @@ function virtualEntrypoin(type, config) {
 }
 
 // src/core/vite-plugins/tsconfigPaths.ts
-import paths from "vite-tsconfig-paths";
 function tsconfigPaths(config) {
-  const fn = typeof paths === "function" ? paths : paths.default;
-  return fn({
-    root: config.root
-  });
+  return {
+    name: "wxt:aliases",
+    async config() {
+      return {
+        resolve: {
+          alias: {
+            "@@": config.root,
+            "~~": config.root,
+            "@": config.srcDir,
+            "~": config.srcDir
+          }
+        }
+      };
+    }
+  };
 }
 
 // src/core/vite-plugins/noopBackground.ts
@@ -361,14 +373,14 @@ function createFsCache(wxtDir) {
   const getPath = (key) => resolve5(wxtDir, "cache", encodeURIComponent(key));
   return {
     async set(key, value) {
-      const path5 = getPath(key);
-      await ensureDir2(dirname3(path5));
-      await fs3.writeFile(path5, value, "utf-8");
+      const path7 = getPath(key);
+      await ensureDir2(dirname3(path7));
+      await fs3.writeFile(path7, value, "utf-8");
     },
     async get(key) {
-      const path5 = getPath(key);
+      const path7 = getPath(key);
       try {
-        return await fs3.readFile(path5, "utf-8");
+        return await fs3.readFile(path7, "utf-8");
       } catch {
         return void 0;
       }
@@ -432,6 +444,9 @@ async function getInternalConfig(config, command) {
   const outBaseDir = path2.resolve(root, ".output");
   const outDir = path2.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
   const logger = config.logger ?? consola;
+  const debug = !!config.debug;
+  if (debug)
+    logger.level = LogLevels.debug;
   const baseConfig = {
     root,
     outDir,
@@ -441,6 +456,7 @@ async function getInternalConfig(config, command) {
     manifestVersion,
     mode,
     command,
+    debug,
     logger,
     vite: config.vite ?? {},
     imports: config.imports ?? {},
@@ -473,7 +489,7 @@ async function getInternalConfig(config, command) {
     userConfig.entrypointsDir ?? "entrypoints"
   );
   const publicDir = resolve6(root, userConfig.publicDir ?? "public");
-  const wxtDir = resolve6(srcDir, ".wxt");
+  const wxtDir = resolve6(root, ".wxt");
   const typesDir = resolve6(wxtDir, "types");
   const env = { mode, browser, manifestVersion, command };
   const userManifest = await resolveManifestConfig(env, userConfig.manifest);
@@ -539,7 +555,7 @@ async function resolveManifestConfig(env, manifest) {
 }
 
 // src/index.ts
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 import * as vite6 from "vite";
 
 // src/core/utils/arrays.ts
@@ -636,7 +652,7 @@ function findEffectedSteps(changedFile, currentOutput) {
 
 // src/index.ts
 import { Mutex } from "async-mutex";
-import { consola as consola2 } from "consola";
+import { consola as consola3 } from "consola";
 import { relative as relative5 } from "node:path";
 
 // src/core/build/buildEntrypoints.ts
@@ -809,16 +825,16 @@ function removeImportStatements(text) {
 }
 
 // src/core/utils/importTsFile.ts
-async function importTsFile(path5, config) {
-  config.logger.debug("Loading file metadata:", path5);
-  const normalPath = normalizePath2(path5);
+async function importTsFile(path7, config) {
+  config.logger.debug("Loading file metadata:", path7);
+  const normalPath = normalizePath2(path7);
   const unimport2 = createUnimport2({
     ...getUnimportOptions(config),
     // Only allow specific imports, not all from the project
     dirs: []
   });
   await unimport2.init();
-  const text = await fs7.readFile(path5, "utf-8");
+  const text = await fs7.readFile(path7, "utf-8");
   const textNoImports = removeImportStatements(text);
   const { code } = await unimport2.injectImports(textNoImports);
   config.logger.debug(
@@ -842,7 +858,7 @@ async function importTsFile(path5, config) {
     }
   });
   try {
-    return await jiti(path5);
+    return await jiti(path7);
   } catch (err) {
     config.logger.error(err);
     throw err;
@@ -862,9 +878,9 @@ async function findEntrypoints(config) {
   let hasBackground = false;
   await Promise.all(
     relativePaths.map(async (relativePath) => {
-      const path5 = resolve9(config.entrypointsDir, relativePath);
+      const path7 = resolve9(config.entrypointsDir, relativePath);
       const matchingGlob = pathGlobs.find(
-        (glob3) => minimatch(relativePath, glob3)
+        (glob4) => minimatch(relativePath, glob4)
       );
       if (matchingGlob == null) {
         return config.logger.warn(
@@ -882,35 +898,35 @@ ${JSON.stringify(
       let entrypoint;
       switch (type) {
         case "popup":
-          entrypoint = await getPopupEntrypoint(config, path5);
+          entrypoint = await getPopupEntrypoint(config, path7);
           break;
         case "options":
-          entrypoint = await getOptionsEntrypoint(config, path5);
+          entrypoint = await getOptionsEntrypoint(config, path7);
           break;
         case "background":
-          entrypoint = await getBackgroundEntrypoint(config, path5);
+          entrypoint = await getBackgroundEntrypoint(config, path7);
           hasBackground = true;
           break;
         case "content-script":
           entrypoint = await getContentScriptEntrypoint(
             config,
-            getEntrypointName(config.entrypointsDir, path5),
-            path5
+            getEntrypointName(config.entrypointsDir, path7),
+            path7
           );
           break;
         case "content-script-style":
           entrypoint = {
             type,
-            name: getEntrypointName(config.entrypointsDir, path5),
-            inputPath: path5,
+            name: getEntrypointName(config.entrypointsDir, path7),
+            inputPath: path7,
             outputDir: resolve9(config.outDir, CONTENT_SCRIPT_OUT_DIR)
           };
           break;
         default:
           entrypoint = {
             type,
-            name: getEntrypointName(config.entrypointsDir, path5),
-            inputPath: path5,
+            name: getEntrypointName(config.entrypointsDir, path7),
+            inputPath: path7,
             outputDir: config.outDir
           };
       }
@@ -934,9 +950,9 @@ ${JSON.stringify(
   }
   return entrypoints;
 }
-async function getPopupEntrypoint(config, path5) {
+async function getPopupEntrypoint(config, path7) {
   const options = {};
-  const content = await fs8.readFile(path5, "utf-8");
+  const content = await fs8.readFile(path7, "utf-8");
   const { document } = parseHTML2(content);
   const title = document.querySelector("title");
   if (title != null)
@@ -960,13 +976,13 @@ async function getPopupEntrypoint(config, path5) {
     type: "popup",
     name: "popup",
     options,
-    inputPath: path5,
+    inputPath: path7,
     outputDir: config.outDir
   };
 }
-async function getOptionsEntrypoint(config, path5) {
+async function getOptionsEntrypoint(config, path7) {
   const options = {};
-  const content = await fs8.readFile(path5, "utf-8");
+  const content = await fs8.readFile(path7, "utf-8");
   const { document } = parseHTML2(content);
   const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
   if (openInTabContent) {
@@ -984,15 +1000,15 @@ async function getOptionsEntrypoint(config, path5) {
     type: "options",
     name: "options",
     options,
-    inputPath: path5,
+    inputPath: path7,
     outputDir: config.outDir
   };
 }
-async function getBackgroundEntrypoint(config, path5) {
+async function getBackgroundEntrypoint(config, path7) {
   let options = {};
-  if (path5 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+  if (path7 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
     const defaultExport = await importTsFile(
-      path5,
+      path7,
       config
     );
     if (defaultExport == null) {
@@ -1004,14 +1020,14 @@ async function getBackgroundEntrypoint(config, path5) {
   return {
     type: "background",
     name: "background",
-    inputPath: path5,
+    inputPath: path7,
     outputDir: config.outDir,
     options
   };
 }
-async function getContentScriptEntrypoint(config, name, path5) {
+async function getContentScriptEntrypoint(config, name, path7) {
   const { main: _, ...options } = await importTsFile(
-    path5,
+    path7,
     config
   );
   if (options == null) {
@@ -1019,8 +1035,8 @@ async function getContentScriptEntrypoint(config, name, path5) {
   }
   return {
     type: "content-script",
-    name: getEntrypointName(config.entrypointsDir, path5),
-    inputPath: path5,
+    name: getEntrypointName(config.entrypointsDir, path7),
+    inputPath: path7,
     outputDir: resolve9(config.outDir, CONTENT_SCRIPT_OUT_DIR),
     options
   };
@@ -1071,11 +1087,52 @@ var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
 import { createUnimport as createUnimport3 } from "unimport";
 import fs9 from "fs-extra";
 import { relative as relative4, resolve as resolve10 } from "path";
+import path4 from "node:path";
+
+// src/core/utils/i18n.ts
+var predefinedMessages = {
+  "@@extension_id": {
+    message: "<browser.runtime.id>",
+    description: "The extension or app ID; you might use this string to construct URLs for resources inside the extension. Even unlocalized extensions can use this message.\nNote: You can't use this message in a manifest file."
+  },
+  "@@ui_locale": {
+    message: "<browser.i18n.getUiLocale()>",
+    description: ""
+  },
+  "@@bidi_dir": {
+    message: "<ltr|rtl>",
+    description: 'The text direction for the current locale, either "ltr" for left-to-right languages such as English or "rtl" for right-to-left languages such as Japanese.'
+  },
+  "@@bidi_reversed_dir": {
+    message: "<rtl|ltr>",
+    description: `If the @@bidi_dir is "ltr", then this is "rtl"; otherwise, it's "ltr".`
+  },
+  "@@bidi_start_edge": {
+    message: "<left|right>",
+    description: `If the @@bidi_dir is "ltr", then this is "left"; otherwise, it's "right".`
+  },
+  "@@bidi_end_edge": {
+    message: "<right|left>",
+    description: `If the @@bidi_dir is "ltr", then this is "right"; otherwise, it's "left".`
+  }
+};
+function parseI18nMessages(messagesJson) {
+  return Object.entries({
+    ...predefinedMessages,
+    ...messagesJson
+  }).map(([name, details]) => ({
+    name,
+    ...details
+  }));
+}
+
+// src/core/build/generateTypesDir.ts
 async function generateTypesDir(entrypoints, config) {
   await fs9.ensureDir(config.typesDir);
   const references = [];
   references.push(await writeImportsDeclarationFile(config));
   references.push(await writePathsDeclarationFile(entrypoints, config));
+  references.push(await writeI18nDeclarationFile(config));
   references.push(await writeGlobalsDeclarationFile(config));
   const mainReference = await writeMainDeclarationFile(references, config);
   await writeTsConfigFile(mainReference, config);
@@ -1100,14 +1157,14 @@ async function writePathsDeclarationFile(entrypoints, config) {
       config.outDir,
       entry.inputPath.endsWith(".html") ? ".html" : ".js"
     )
-  ).concat(await getPublicFiles(config)).map(normalizePath2).map((path5) => `    | "/${path5}"`).sort().join("\n");
+  ).concat(await getPublicFiles(config)).map(normalizePath2).map((path7) => `    | "/${path7}"`).sort().join("\n");
   const template = `// Generated by wxt
 import "wxt/browser";
 
 declare module "wxt/browser" {
   type PublicPath =
 {{ union }}
-  export interface ProjectRuntime extends Runtime.Static {
+  export interface WxtRuntime extends Runtime.Static {
     getURL(path: PublicPath): string;
   }
 }
@@ -1118,6 +1175,59 @@ declare module "wxt/browser" {
   );
   return filePath;
 }
+async function writeI18nDeclarationFile(config) {
+  const filePath = resolve10(config.typesDir, "i18n.d.ts");
+  const defaultLocale = config.manifest.default_locale;
+  const template = `// Generated by wxt
+import "wxt/browser";
+
+declare module "wxt/browser" {
+  /**
+   * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
+   */
+  interface GetMessageOptions {
+    /**
+     * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
+     */
+    escapeLt?: boolean
+  }
+
+  export interface WxtI18n extends I18n.Static {
+{{ overrides }}
+  }
+}
+`;
+  let messages;
+  if (defaultLocale) {
+    const defaultLocalePath = path4.resolve(
+      config.publicDir,
+      "_locales",
+      defaultLocale,
+      "messages.json"
+    );
+    const content = JSON.parse(await fs9.readFile(defaultLocalePath, "utf-8"));
+    messages = parseI18nMessages(content);
+  } else {
+    messages = parseI18nMessages({});
+  }
+  const overrides = messages.map((message) => {
+    return `    /**
+     * ${message.description ?? "No message description."}
+     * 
+     * "${message.message}"
+     */
+    getMessage(
+      messageName: "${message.name}",
+      substitutions?: string | string[],
+      options?: GetMessageOptions,
+    ): string;`;
+  });
+  await fs9.writeFile(
+    filePath,
+    template.replace("{{ overrides }}", overrides.join("\n"))
+  );
+  return filePath;
+}
 async function writeGlobalsDeclarationFile(config) {
   const filePath = resolve10(config.typesDir, "globals.d.ts");
   const globals = getGlobals(config);
@@ -1151,6 +1261,8 @@ async function writeMainDeclarationFile(references, config) {
 }
 async function writeTsConfigFile(mainReference, config) {
   const dir = config.wxtDir;
+  const rootPath = normalizePath2(relative4(dir, config.root));
+  const srcPath = normalizePath2(relative4(dir, config.srcDir));
   await fs9.writeFile(
     resolve10(dir, "tsconfig.json"),
     `{
@@ -1165,16 +1277,15 @@ async function writeTsConfigFile(mainReference, config) {
     "strict": true,
     "lib": ["DOM", "WebWorker"],
     "skipLibCheck": true,
-    "baseUrl": "${normalizePath2(relative4(dir, config.root))}",
     "paths": {
-      "@@": ["."],
-      "@@/*": ["./*"],
-      "~~": ["."],
-      "~~/*": ["./*"],
-      "@": ["${normalizePath2(relative4(config.root, config.srcDir))}"],
-      "@/*": ["${normalizePath2(relative4(config.root, config.srcDir))}/*"],
-      "~": ["${normalizePath2(relative4(config.root, config.srcDir))}"],
-      "~/*": ["${normalizePath2(relative4(config.root, config.srcDir))}/*"]
+      "@@": ["${rootPath}"],
+      "@@/*": ["${rootPath}/*"],
+      "~~": ["${rootPath}"],
+      "~~/*": ["${rootPath}/*"],
+      "@": ["${srcPath}"],
+      "@/*": ["${srcPath}/*"],
+      "~": ["${srcPath}"],
+      "~/*": ["${srcPath}/*"]
     }
   },
   "include": [
@@ -1500,7 +1611,7 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
           map.set(hash, [script]);
         return map;
       }, /* @__PURE__ */ new Map());
-      manifest.content_scripts = Array.from(hashToEntrypointsMap.entries()).map(
+      const newContentScripts = Array.from(hashToEntrypointsMap.entries()).map(
         ([, scripts]) => ({
           ...mapWxtOptionsToContentScript(scripts[0].options),
           // TOOD: Sorting css and js arrays here so we get consistent test results... but we
@@ -1511,6 +1622,10 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
           ).sort()
         })
       );
+      if (newContentScripts.length >= 0) {
+        manifest.content_scripts ??= [];
+        manifest.content_scripts.push(...newContentScripts);
+      }
     }
   }
 }
@@ -1659,7 +1774,7 @@ function formatDuration(duration) {
 import { resolve as resolve13 } from "path";
 
 // src/core/log/printFileList.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import pc from "picocolors";
 import fs12 from "fs-extra";
 import { filesize } from "filesize";
@@ -1697,8 +1812,8 @@ async function printFileList(log, header, baseDir, files) {
   const fileRows = await Promise.all(
     files.map(async (file, i) => {
       const parts = [
-        path4.relative(process.cwd(), baseDir) + path4.sep,
-        path4.relative(baseDir, file)
+        path5.relative(process.cwd(), baseDir) + path5.sep,
+        path5.relative(baseDir, file)
       ];
       const prefix = i === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
       const color = getChunkColor(file);
@@ -1829,7 +1944,7 @@ function createWebExtRunner() {
         config.logger.warn("Cannot open safari automatically.");
         return;
       }
-      const webExtLogger = await import("web-ext/util/logger");
+      const webExtLogger = await import("web-ext-run/util/logger");
       webExtLogger.consoleStream.write = ({ level, msg, name }) => {
         if (level >= ERROR_LOG_LEVEL)
           config.logger.error(name, msg);
@@ -1866,7 +1981,7 @@ function createWebExtRunner() {
       };
       config.logger.debug("web-ext config:", finalConfig);
       config.logger.debug("web-ext options:", options);
-      const webExt = await import("web-ext");
+      const webExt = await import("web-ext-run");
       runner = await webExt.default.cmd.run(finalConfig, options);
     },
     async closeBrowser() {
@@ -1911,8 +2026,8 @@ async function setupServer(serverInfo, config) {
   const reloadExtension = () => {
     viteServer.ws.send("wxt:reload-extension");
   };
-  const reloadPage = (path5) => {
-    viteServer.ws.send("wxt:reload-page", path5);
+  const reloadPage = (path7) => {
+    viteServer.ws.send("wxt:reload-page", path7);
   };
   const reloadContentScript = (contentScript) => {
     viteServer.ws.send("wxt:reload-content-script", contentScript);
@@ -1958,13 +2073,48 @@ function reloadContentScripts(steps, config, server) {
 }
 function reloadHtmlPages(groups, server, config) {
   groups.flat().forEach((entry) => {
-    const path5 = getEntrypointBundlePath(entry, config.outDir, ".html");
-    server.reloadPage(path5);
+    const path7 = getEntrypointBundlePath(entry, config.outDir, ".html");
+    server.reloadPage(path7);
+  });
+}
+
+// src/core/clean.ts
+import path6 from "node:path";
+import glob3 from "fast-glob";
+import fs14 from "fs-extra";
+import { consola as consola2 } from "consola";
+import pc3 from "picocolors";
+async function clean(root = process.cwd()) {
+  consola2.info("Cleaning Project");
+  const tempDirs = [
+    "node_modules/.vite",
+    "node_modules/.cache",
+    "**/.wxt",
+    ".output/*"
+  ];
+  consola2.debug("Looking for:", tempDirs.map(pc3.cyan).join(", "));
+  const directories = await glob3(tempDirs, {
+    cwd: path6.resolve(root),
+    absolute: true,
+    onlyDirectories: true,
+    deep: 2
   });
+  if (directories.length === 0) {
+    consola2.debug("No generated files found.");
+    return;
+  }
+  consola2.debug(
+    "Found:",
+    directories.map((dir) => pc3.cyan(path6.relative(root, dir))).join(", ")
+  );
+  for (const directory of directories) {
+    await fs14.rm(directory, { force: true, recursive: true });
+    consola2.debug("Deleted " + pc3.cyan(path6.relative(root, directory)));
+  }
 }
 
 // package.json
-var version2 = "0.3.2";
+var version2 = "0.4.1";
 
 // src/core/utils/defineConfig.ts
 function defineConfig(config) {
@@ -1998,10 +2148,10 @@ async function createServer2(config) {
   server.ws.on("wxt:background-initialized", () => {
     reloadContentScripts(server.currentOutput.steps, internalConfig, server);
   });
-  server.watcher.on("all", async (event, path5, _stats) => {
-    if (path5.startsWith(internalConfig.outBaseDir))
+  server.watcher.on("all", async (event, path7, _stats) => {
+    if (path7.startsWith(internalConfig.outBaseDir))
       return;
-    changeQueue.push([event, path5]);
+    changeQueue.push([event, path7]);
     await fileChangedMutex.runExclusive(async () => {
       const fileChanges = changeQueue.splice(0, changeQueue.length);
       if (fileChanges.length === 0)
@@ -2010,13 +2160,13 @@ async function createServer2(config) {
       if (changes.type === "no-change")
         return;
       internalConfig.logger.info(
-        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => pc3.dim(relative5(internalConfig.root, file))).join(", ")}`
+        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => pc4.dim(relative5(internalConfig.root, file))).join(", ")}`
       );
       const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
-        return pc3.cyan(
+        return pc4.cyan(
           relative5(internalConfig.outDir, getEntrypointOutputFile(entry, ""))
         );
-      }).join(pc3.dim(", "));
+      }).join(pc4.dim(", "));
       internalConfig = await getLatestInternalConfig();
       internalConfig.server = server;
       const { output: newOutput } = await rebuild(
@@ -2037,13 +2187,14 @@ async function createServer2(config) {
           reloadContentScripts(changes.changedSteps, internalConfig, server);
           break;
       }
-      consola2.success(`Reloaded: ${rebuiltNames}`);
+      consola3.success(`Reloaded: ${rebuiltNames}`);
     });
   });
   return server;
 }
 export {
   build2 as build,
+  clean,
   createServer2 as createServer,
   defineConfig,
   defineRunnerConfig,