wxt 0.19.17 → 0.19.19

package/dist/client/content-scripts/content-script-context.d.ts

@@ -99,11 +99,13 @@ export declare class ContentScriptContext implements AbortController {
      * ctx.addEventListener(document, "visibilitychange", () => {
      *   // ...
      * });
-     * ctx.addEventListener(document, "wxt:locationchange", () => {
+     * ctx.addEventListener(window, "wxt:locationchange", () => {
      *   // ...
      * });
      */
-    addEventListener<TTarget extends EventTarget, TType extends keyof WxtContentScriptEventMap>(target: TTarget, type: TType, handler: (event: WxtContentScriptEventMap[TType]) => void, options?: AddEventListenerOptions): void;
+    addEventListener<TType extends keyof WxtWindowEventMap>(target: Window, type: TType, handler: (event: WxtWindowEventMap[TType]) => void, options?: AddEventListenerOptions): void;
+    addEventListener<TType extends keyof DocumentEventMap>(target: Document, type: keyof DocumentEventMap, handler: (event: DocumentEventMap[TType]) => void, options?: AddEventListenerOptions): void;
+    addEventListener<TTarget extends EventTarget>(target: TTarget, ...params: Parameters<TTarget['addEventListener']>): void;
     /**
      * @internal
      * Abort the abort controller and execute all `onInvalidated` listeners.
@@ -114,7 +116,6 @@ export declare class ContentScriptContext implements AbortController {
         ignoreFirstEvent?: boolean;
     }): void;
 }
-interface WxtContentScriptEventMap extends WindowEventMap {
+export interface WxtWindowEventMap extends WindowEventMap {
     'wxt:locationchange': WxtLocationChangeEvent;
 }
-export {};

package/dist/client/content-scripts/content-script-context.mjs

@@ -109,30 +109,12 @@ export class ContentScriptContext {
     this.onInvalidated(() => cancelIdleCallback(id));
     return id;
   }
-  /**
-   * Call `target.addEventListener` and remove the event listener when the context is invalidated.
-   *
-   * Includes additional events useful for content scripts:
-   *
-   * - `"wxt:locationchange"` - Triggered when HTML5 history mode is used to change URL. Content
-   *   scripts are not reloaded when navigating this way, so this can be used to reset the content
-   *   script state on URL change, or run custom code.
-   *
-   * @example
-   * ctx.addEventListener(document, "visibilitychange", () => {
-   *   // ...
-   * });
-   * ctx.addEventListener(document, "wxt:locationchange", () => {
-   *   // ...
-   * });
-   */
   addEventListener(target, type, handler, options) {
     if (type === "wxt:locationchange") {
       if (this.isValid) this.locationWatcher.run();
     }
     target.addEventListener?.(
       type.startsWith("wxt:") ? getUniqueEventName(type) : type,
-      // @ts-expect-error: Event don't match, but that's OK, EventTarget doesn't allow custom types in the callback
       handler,
       {
         ...options,

package/dist/core/create-server.mjs

@@ -20,6 +20,7 @@ import {
   getContentScriptJs,
   mapWxtOptionsToRegisteredContentScript
 } from "./utils/content-scripts.mjs";
+import { createKeyboardShortcuts } from "./keyboard-shortcuts.mjs";
 export async function createServer(inlineConfig) {
   await registerWxt("serve", inlineConfig);
   wxt.server = await createServerInternal();
@@ -67,16 +68,19 @@ async function createServerInternal() {
       await builderServer.listen();
       wxt.logger.success(`Started dev server @ ${server.origin}`);
       await wxt.hooks.callHook("server:started", wxt, server);
-      await buildAndOpenBrowser();
       server.ws.on("wxt:background-initialized", () => {
         if (server.currentOutput == null) return;
         reloadContentScripts(server.currentOutput.steps, server);
       });
+      await buildAndOpenBrowser();
       const reloadOnChange = createFileReloader(server);
       server.watcher.on("all", reloadOnChange);
+      keyboardShortcuts.start();
+      keyboardShortcuts.printHelp();
     },
     async stop() {
       wasStopped = true;
+      keyboardShortcuts.stop();
       await runner.closeBrowser();
       await builderServer.close();
       await wxt.hooks.callHook("server:closed", wxt, server);
@@ -101,11 +105,14 @@ async function createServerInternal() {
     },
     async restartBrowser() {
       await runner.closeBrowser();
+      keyboardShortcuts.stop();
       await wxt.reloadConfig();
       runner = await createExtensionRunner();
       await runner.openBrowser();
+      keyboardShortcuts.start();
     }
   };
+  const keyboardShortcuts = createKeyboardShortcuts(server);
   const buildAndOpenBrowser = async () => {
     server.currentOutput = await internalBuild();
     try {

package/dist/core/keyboard-shortcuts.d.ts

@@ -0,0 +1,10 @@
+import { WxtDevServer } from '../types';
+export interface KeyboardShortcutWatcher {
+    start(): void;
+    stop(): void;
+    printHelp(): void;
+}
+/**
+ * Function that creates a keyboard shortcut handler for the extension.
+ */
+export declare function createKeyboardShortcuts(server: WxtDevServer): KeyboardShortcutWatcher;

package/dist/core/keyboard-shortcuts.mjs

@@ -0,0 +1,39 @@
+import readline from "node:readline";
+import { wxt } from "./wxt.mjs";
+import pc from "picocolors";
+export function createKeyboardShortcuts(server) {
+  let isWatching = false;
+  let rl;
+  const handleInput = (line) => {
+    if (line.trim() === "o") {
+      server.restartBrowser();
+    }
+  };
+  return {
+    start() {
+      if (isWatching) return;
+      rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false
+        // Don't intercept ctrl+C, ctrl+Z, etc
+      });
+      rl.on("line", handleInput);
+      isWatching = true;
+    },
+    stop() {
+      if (!isWatching) return;
+      if (rl) {
+        rl.close();
+        rl = void 0;
+      }
+      isWatching = false;
+    },
+    printHelp() {
+      if (!wxt.config.runnerConfig.config.disabled) {
+        wxt.logger.info(
+          `${pc.dim("Press")} ${pc.bold("o + enter")} ${pc.dim("to reopen the browser")}`
+        );
+      }
+    }
+  };
+}

package/dist/core/utils/building/find-entrypoints.mjs

@@ -39,12 +39,7 @@ export async function findEntrypoints() {
     );
     if (matchingGlob) {
       const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
-      results.push({
-        name,
-        inputPath,
-        type,
-        skipped: wxt.config.filterEntrypoints != null && !wxt.config.filterEntrypoints.has(name)
-      });
+      results.push({ name, inputPath, type });
     }
     return results;
   }, []);
@@ -52,7 +47,7 @@ export async function findEntrypoints() {
   preventDuplicateEntrypointNames(entrypointInfos);
   let hasBackground = false;
   const env = createExtensionEnvironment();
-  const entrypoints = await env.run(
+  const entrypointsWithoutSkipped = await env.run(
     () => Promise.all(
       entrypointInfos.map(async (info) => {
         const { type } = info;
@@ -97,45 +92,32 @@ export async function findEntrypoints() {
     )
   );
   if (wxt.config.command === "serve" && !hasBackground) {
-    entrypoints.push(
+    entrypointsWithoutSkipped.push(
       await getBackgroundEntrypoint({
         inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
         name: "background",
-        type: "background",
-        skipped: false
+        type: "background"
       })
     );
   }
+  const entrypoints = entrypointsWithoutSkipped.map((entry) => ({
+    ...entry,
+    skipped: isEntrypointSkipped(entry)
+  }));
   wxt.logger.debug("All entrypoints:", entrypoints);
-  const skippedEntrypointNames = entrypointInfos.filter((item) => item.skipped).map((item) => item.name);
+  const skippedEntrypointNames = entrypoints.filter((item) => item.skipped).map((item) => item.name);
   if (skippedEntrypointNames.length) {
     wxt.logger.warn(
-      `Filter excluded the following entrypoints:
-${skippedEntrypointNames.map((item) => `${pc.dim("-")} ${pc.cyan(item)}`).join("\n")}`
+      [
+        "The following entrypoints have been skipped:",
+        ...skippedEntrypointNames.map(
+          (item) => `${pc.dim("-")} ${pc.cyan(item)}`
+        )
+      ].join("\n")
     );
   }
-  const targetEntrypoints = entrypoints.filter((entry) => {
-    const { include, exclude } = entry.options;
-    if (include?.length && exclude?.length) {
-      wxt.logger.warn(
-        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`
-      );
-      return false;
-    }
-    if (exclude?.length && !include?.length) {
-      return !exclude.includes(wxt.config.browser);
-    }
-    if (include?.length && !exclude?.length) {
-      return include.includes(wxt.config.browser);
-    }
-    if (skippedEntrypointNames.includes(entry.name)) {
-      return false;
-    }
-    return true;
-  });
-  wxt.logger.debug(`${wxt.config.browser} entrypoints:`, targetEntrypoints);
-  await wxt.hooks.callHook("entrypoints:resolved", wxt, targetEntrypoints);
-  return targetEntrypoints;
+  await wxt.hooks.callHook("entrypoints:resolved", wxt, entrypoints);
+  return entrypoints;
 }
 function preventDuplicateEntrypointNames(files) {
   const namesToPaths = files.reduce(
@@ -196,8 +178,7 @@ async function getPopupEntrypoint(info) {
     name: "popup",
     options: resolvePerBrowserOptions(options, wxt.config.browser),
     inputPath: info.inputPath,
-    outputDir: wxt.config.outDir,
-    skipped: info.skipped
+    outputDir: wxt.config.outDir
   };
 }
 async function getOptionsEntrypoint(info) {
@@ -216,8 +197,7 @@ async function getOptionsEntrypoint(info) {
     name: "options",
     options: resolvePerBrowserOptions(options, wxt.config.browser),
     inputPath: info.inputPath,
-    outputDir: wxt.config.outDir,
-    skipped: info.skipped
+    outputDir: wxt.config.outDir
   };
 }
 async function getUnlistedPageEntrypoint(info) {
@@ -230,14 +210,12 @@ async function getUnlistedPageEntrypoint(info) {
     name: info.name,
     inputPath: info.inputPath,
     outputDir: wxt.config.outDir,
-    options,
-    skipped: info.skipped
+    options
   };
 }
 async function getUnlistedScriptEntrypoint({
   inputPath,
-  name,
-  skipped
+  name
 }) {
   const defaultExport = await wxt.builder.importEntrypoint(inputPath);
   if (defaultExport == null) {
@@ -251,14 +229,12 @@ async function getUnlistedScriptEntrypoint({
     name,
     inputPath,
     outputDir: wxt.config.outDir,
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    skipped
+    options: resolvePerBrowserOptions(options, wxt.config.browser)
   };
 }
 async function getBackgroundEntrypoint({
   inputPath,
-  name,
-  skipped
+  name
 }) {
   let options = {};
   if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
@@ -279,14 +255,12 @@ async function getBackgroundEntrypoint({
     name,
     inputPath,
     outputDir: wxt.config.outDir,
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    skipped
+    options: resolvePerBrowserOptions(options, wxt.config.browser)
   };
 }
 async function getContentScriptEntrypoint({
   inputPath,
-  name,
-  skipped
+  name
 }) {
   const defaultExport = await wxt.builder.importEntrypoint(inputPath);
   if (defaultExport == null) {
@@ -305,8 +279,7 @@ async function getContentScriptEntrypoint({
     name,
     inputPath,
     outputDir: resolve(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    skipped
+    options: resolvePerBrowserOptions(options, wxt.config.browser)
   };
 }
 async function getSidepanelEntrypoint(info) {
@@ -332,8 +305,7 @@ async function getSidepanelEntrypoint(info) {
     name: info.name,
     options: resolvePerBrowserOptions(options, wxt.config.browser),
     inputPath: info.inputPath,
-    outputDir: wxt.config.outDir,
-    skipped: info.skipped
+    outputDir: wxt.config.outDir
   };
 }
 async function getHtmlEntrypointOptions(info, keyMap, queries, parsers) {
@@ -357,6 +329,25 @@ async function getHtmlEntrypointOptions(info, keyMap, queries, parsers) {
   });
   return options;
 }
+function isEntrypointSkipped(entry) {
+  if (wxt.config.filterEntrypoints != null) {
+    return !wxt.config.filterEntrypoints.has(entry.name);
+  }
+  const { include, exclude } = entry.options;
+  if (include?.length && exclude?.length) {
+    wxt.logger.warn(
+      `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint skipped.`
+    );
+    return true;
+  }
+  if (exclude?.length && !include?.length) {
+    return exclude.includes(wxt.config.browser);
+  }
+  if (include?.length && !exclude?.length) {
+    return !include.includes(wxt.config.browser);
+  }
+  return false;
+}
 const PATH_GLOB_TO_TYPE_MAP = {
   "sandbox.html": "sandbox",
   "sandbox/index.html": "sandbox",

package/dist/core/utils/building/group-entrypoints.d.ts

@@ -1,7 +1,7 @@
 import { Entrypoint, EntrypointGroup } from '../../../types';
 /**
- * Entrypoints can be build in groups. HTML pages can all be built together in a single step, while
- * content scripts must be build individually.
+ * Entrypoints are built in groups. HTML pages can all be built together in a single step,
+ * content scripts must be build individually, etc.
  *
  * This function returns the entrypoints put into these types of groups.
  */

package/dist/core/utils/building/group-entrypoints.mjs

@@ -2,6 +2,7 @@ export function groupEntrypoints(entrypoints) {
   const groupIndexMap = {};
   const groups = [];
   for (const entry of entrypoints) {
+    if (entry.skipped) continue;
     let group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
     if (entry.type === "background" && entry.options.type === "module") {
       group = "esm";

package/dist/core/utils/manifest.mjs

@@ -45,9 +45,13 @@ export async function generateManifest(entrypoints, buildOutput) {
     baseManifest
   );
   if (wxt.config.command === "serve" && wxt.config.dev.reloadCommand) {
-    if (manifest.commands && Object.keys(manifest.commands).length >= 4) {
+    if (manifest.commands && // If the following limit is exceeded, Chrome will fail to load the extension.
+    // Error: "Too many commands specified for 'commands': The maximum is 4."
+    Object.values(manifest.commands).filter(
+      (command) => command.suggested_key
+    ).length >= 4) {
       warnings.push([
-        "Extension already has 4 registered commands, WXT's reload command is disabled"
+        "Extension already has 4 registered commands with suggested keys, WXT's reload command is disabled"
       ]);
     } else {
       manifest.commands ??= {};

package/dist/core/utils/testing/fake-objects.d.ts

@@ -1,4 +1,4 @@
-import { type Manifest } from 'wxt/browser';
+import type { Manifest } from 'wxt/browser';
 import { ResolvedConfig, WxtDevServer, BackgroundEntrypoint, ContentScriptEntrypoint, GenericEntrypoint, OptionsEntrypoint, PopupEntrypoint, OutputChunk, OutputFile, OutputAsset, BuildOutput, BuildStepOutput, UserManifest, Wxt, SidepanelEntrypoint } from '../../../types';
 type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
@@ -8781,7 +8781,7 @@ export declare const fakeBuildStepOutput: (overrides?: {
         moduleIds?: (string | undefined)[] | undefined;
     } | undefined)[] | undefined;
 } | undefined) => BuildStepOutput;
-export declare const fakeManifestCommand: (overrides?: any) => Commands.Command;
+export declare const fakeManifestCommand: (overrides?: any) => Manifest.WebExtensionManifestCommandsType;
 export declare const fakeDevServer: (overrides?: {
     currentOutput?: {
         manifest?: any;

package/dist/core/utils/testing/fake-objects.mjs

@@ -301,10 +301,14 @@ export const fakeBuildStepOutput = fakeObjectCreator(() => ({
 }));
 export const fakeManifestCommand = fakeObjectCreator(() => ({
   description: faker.string.sample(),
-  shortcut: `${faker.helpers.arrayElement(["ctrl", "alt"])}+${faker.number.int({
-    min: 0,
-    max: 9
-  })}`
+  suggested_key: {
+    default: `${faker.helpers.arrayElement(["ctrl", "alt"])}+${faker.number.int(
+      {
+        min: 0,
+        max: 9
+      }
+    )}`
+  }
 }));
 export const fakeDevServer = fakeObjectCreator(() => ({
   hostname: "localhost",

package/dist/core/wxt.mjs

@@ -19,6 +19,11 @@ export async function registerWxt(command, inlineConfig = {}) {
       return config.logger;
     },
     async reloadConfig() {
+      if (wxt.config.dev.server?.port) {
+        inlineConfig.dev ??= {};
+        inlineConfig.dev.server ??= {};
+        inlineConfig.dev.server.port = wxt.config.dev.server.port;
+      }
       wxt.config = await resolveConfig(inlineConfig, command);
       await wxt.hooks.callHook("config:resolved", wxt);
     },

package/dist/core/zip.mjs

@@ -5,7 +5,7 @@ import { getPackageJson } from "./utils/package.mjs";
 import { minimatch } from "minimatch";
 import { formatDuration } from "./utils/time.mjs";
 import { printFileList } from "./utils/log/printFileList.mjs";
-import { internalBuild } from "./utils/building/index.mjs";
+import { findEntrypoints, internalBuild } from "./utils/building/index.mjs";
 import { registerWxt, wxt } from "./wxt.mjs";
 import JSZip from "jszip";
 import glob from "fast-glob";
@@ -34,6 +34,14 @@ export async function zip(config) {
   zipFiles.push(outZipPath);
   await wxt.hooks.callHook("zip:extension:done", wxt, outZipPath);
   if (wxt.config.zip.zipSources) {
+    const entrypoints = await findEntrypoints();
+    const skippedEntrypoints = entrypoints.filter((entry) => entry.skipped);
+    const excludeSources = [
+      ...wxt.config.zip.excludeSources,
+      ...skippedEntrypoints.map(
+        (entry) => path.relative(wxt.config.zip.sourcesRoot, entry.inputPath)
+      )
+    ].map((paths) => paths.replaceAll("\\", "/"));
     await wxt.hooks.callHook("zip:sources:start", wxt);
     const { overrides, files: downloadedPackages } = await downloadPrivatePackages();
     const sourcesZipFilename = applyTemplate(wxt.config.zip.sourcesTemplate);
@@ -43,7 +51,7 @@ export async function zip(config) {
     );
     await zipDir(wxt.config.zip.sourcesRoot, sourcesZipPath, {
       include: wxt.config.zip.includeSources,
-      exclude: wxt.config.zip.excludeSources,
+      exclude: excludeSources,
       transform(absolutePath, zipPath, content) {
         if (zipPath.endsWith("package.json")) {
           return addOverridesToPackageJson(absolutePath, content, overrides);

package/dist/types.d.ts

@@ -44,6 +44,7 @@ export interface InlineConfig {
      * A list of entrypoint names (`"popup"`, `"options"`, etc.) to build. Will speed up the build if
      * your extension has lots of entrypoints, and you don't need to build all of them to develop a
      * feature.
+     * If specified, this completely overrides the `include`/`exclude` option provided per-entrypoint.
      */
     filterEntrypoints?: string[];
     /**
@@ -682,7 +683,14 @@ export interface BaseEntrypoint {
      * subdirectory of it.
      */
     outputDir: string;
-    skipped: boolean;
+    /**
+     * When true, the entrypoint will not be built by WXT. Normally this is set
+     * based on the `filterEntrypoints` config or the entrypoint's
+     * `include`/`exclude` options defined inside the file.
+     *
+     * See https://wxt.dev/guide/essentials/target-different-browsers.html#filtering-entrypoints
+     */
+    skipped?: boolean;
 }
 export interface GenericEntrypoint extends BaseEntrypoint {
     type: 'sandbox' | 'bookmarks' | 'history' | 'newtab' | 'devtools' | 'unlisted-page' | 'unlisted-script' | 'unlisted-style' | 'content-script-style';

package/dist/version.mjs

@@ -1 +1 @@
-export const version = "0.19.17";
+export const version = "0.19.19";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wxt",
   "type": "module",
-  "version": "0.19.17",
+  "version": "0.19.19",
   "description": "Next gen framework for developing web extensions",
   "repository": {
     "type": "git",