wxt 0.18.15 → 0.19.0

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

@@ -0,0 +1,322 @@
+import { resolve } from "path";
+import { faker } from "@faker-js/faker";
+import merge from "lodash.merge";
+import { mock } from "vitest-mock-extended";
+import { vi } from "vitest";
+import { setWxtForTesting } from "../../../core/wxt.mjs";
+faker.seed(import.meta.test.SEED);
+function fakeObjectCreator(base) {
+  return (overrides) => merge(base(), overrides);
+}
+export function fakeFileName() {
+  return faker.string.alphanumeric() + "." + faker.string.alpha({ length: 3 });
+}
+export function fakeFile(root = process.cwd()) {
+  return resolve(root, fakeFileName());
+}
+export function fakeDir(root = process.cwd()) {
+  return resolve(root, faker.string.alphanumeric());
+}
+export const fakeEntrypoint = () => faker.helpers.arrayElement([
+  fakePopupEntrypoint,
+  fakeGenericEntrypoint,
+  fakeOptionsEntrypoint,
+  fakeBackgroundEntrypoint,
+  fakeContentScriptEntrypoint,
+  fakeUnlistedScriptEntrypoint
+])();
+export const fakeContentScriptEntrypoint = fakeObjectCreator(() => ({
+  type: "content-script",
+  inputPath: fakeFile("src"),
+  name: faker.string.alpha(),
+  options: {
+    matches: [],
+    matchAboutBlank: faker.datatype.boolean(),
+    matchOriginAsFallback: faker.helpers.arrayElement([
+      true,
+      false,
+      void 0
+    ]),
+    runAt: faker.helpers.arrayElement([
+      "document_start",
+      "document_end",
+      "document_idle",
+      void 0
+    ])
+  },
+  outputDir: fakeDir(".output"),
+  skipped: faker.datatype.boolean()
+}));
+export const fakeBackgroundEntrypoint = fakeObjectCreator(
+  () => ({
+    type: "background",
+    inputPath: "entrypoints/background.ts",
+    name: "background",
+    options: {
+      persistent: faker.datatype.boolean(),
+      type: faker.helpers.maybe(() => "module")
+    },
+    outputDir: fakeDir(".output"),
+    skipped: faker.datatype.boolean()
+  })
+);
+export const fakeUnlistedScriptEntrypoint = fakeObjectCreator(() => ({
+  type: "unlisted-script",
+  inputPath: fakeFile("src"),
+  name: faker.string.alpha(),
+  outputDir: fakeDir(".output"),
+  options: {},
+  skipped: faker.datatype.boolean()
+}));
+export const fakeOptionsEntrypoint = fakeObjectCreator(
+  () => ({
+    type: "options",
+    inputPath: "entrypoints/options.html",
+    name: "options",
+    outputDir: fakeDir(".output"),
+    options: {
+      browserStyle: faker.datatype.boolean(),
+      chromeStyle: faker.datatype.boolean(),
+      openInTab: faker.datatype.boolean()
+    },
+    skipped: faker.datatype.boolean()
+  })
+);
+export const fakePopupEntrypoint = fakeObjectCreator(() => ({
+  type: "popup",
+  inputPath: "entrypoints/popup.html",
+  name: "popup",
+  outputDir: fakeDir(".output"),
+  options: {
+    defaultTitle: faker.helpers.arrayElement([
+      faker.person.fullName(),
+      void 0
+    ]),
+    defaultIcon: faker.helpers.arrayElement([
+      {
+        "16": "icon/16.png",
+        "24": "icon/24.png",
+        "64": "icon/64.png"
+      }
+    ]),
+    mv2Key: faker.helpers.arrayElement([
+      "browser_action",
+      "page_action",
+      void 0
+    ])
+  },
+  skipped: faker.datatype.boolean()
+}));
+export const fakeSidepanelEntrypoint = fakeObjectCreator(
+  () => ({
+    type: "sidepanel",
+    inputPath: "entrypoints/sidepanel.html",
+    name: "sidepanel",
+    outputDir: fakeDir(".output"),
+    options: {
+      defaultTitle: faker.helpers.arrayElement([
+        faker.person.fullName(),
+        void 0
+      ]),
+      defaultIcon: faker.helpers.arrayElement([
+        {
+          "16": "icon/16.png",
+          "24": "icon/24.png",
+          "64": "icon/64.png"
+        }
+      ]),
+      openAtInstall: faker.helpers.arrayElement([true, false, void 0])
+    },
+    skipped: faker.datatype.boolean()
+  })
+);
+export const fakeGenericEntrypoint = fakeObjectCreator(
+  () => ({
+    type: faker.helpers.arrayElement([
+      "sandbox",
+      "bookmarks",
+      "history",
+      "newtab",
+      "devtools",
+      "unlisted-page",
+      "unlisted-script"
+    ]),
+    inputPath: fakeFile("src"),
+    name: faker.string.alpha(),
+    outputDir: fakeDir(".output"),
+    options: {},
+    skipped: faker.datatype.boolean()
+  })
+);
+export const fakeOutputChunk = fakeObjectCreator(() => ({
+  type: "chunk",
+  fileName: faker.string.alphanumeric(),
+  moduleIds: []
+}));
+export const fakeOutputAsset = fakeObjectCreator(() => ({
+  type: "asset",
+  fileName: fakeFileName()
+}));
+export function fakeOutputFile() {
+  return faker.helpers.arrayElement([fakeOutputAsset(), fakeOutputChunk()]);
+}
+export const fakeManifest = fakeObjectCreator(
+  () => ({
+    manifest_version: faker.helpers.arrayElement([2, 3]),
+    name: faker.string.alphanumeric(),
+    version: `${faker.number.int()}.${faker.number.int()}.${faker.number.int()}`
+  })
+);
+export const fakeUserManifest = fakeObjectCreator(() => ({
+  name: faker.string.alphanumeric(),
+  version: `${faker.number.int()}.${faker.number.int()}.${faker.number.int()}`
+}));
+export function fakeArray(createItem, count = 3) {
+  const array = [];
+  for (let i = 0; i < count; i++) {
+    array.push(createItem());
+  }
+  return array;
+}
+export const fakeResolvedConfig = fakeObjectCreator(() => {
+  const browser = faker.helpers.arrayElement(["chrome", "firefox"]);
+  const command = faker.helpers.arrayElement(["build", "serve"]);
+  const manifestVersion = faker.helpers.arrayElement([2, 3]);
+  const mode = faker.helpers.arrayElement(["development", "production"]);
+  return {
+    browser,
+    command,
+    entrypointsDir: fakeDir(),
+    modulesDir: fakeDir(),
+    builtinModules: [],
+    userModules: [],
+    env: { browser, command, manifestVersion, mode },
+    fsCache: mock(),
+    imports: {
+      eslintrc: {
+        enabled: faker.helpers.arrayElement([false, 8, 9]),
+        filePath: fakeFile(),
+        globalsPropValue: faker.helpers.arrayElement([
+          true,
+          false,
+          "readable",
+          "readonly",
+          "writable",
+          "writeable"
+        ])
+      }
+    },
+    logger: mock(),
+    manifest: fakeUserManifest(),
+    manifestVersion,
+    mode,
+    outBaseDir: fakeDir(),
+    outDir: fakeDir(),
+    publicDir: fakeDir(),
+    root: fakeDir(),
+    wxtModuleDir: fakeDir(),
+    runnerConfig: {
+      config: {}
+    },
+    debug: faker.datatype.boolean(),
+    srcDir: fakeDir(),
+    typesDir: fakeDir(),
+    wxtDir: fakeDir(),
+    analysis: {
+      enabled: false,
+      open: false,
+      template: "treemap",
+      outputFile: fakeFile(),
+      outputDir: fakeDir(),
+      outputName: "stats",
+      keepArtifacts: false
+    },
+    zip: {
+      artifactTemplate: "{{name}}-{{version}}.zip",
+      includeSources: [],
+      excludeSources: [],
+      sourcesRoot: fakeDir(),
+      sourcesTemplate: "{{name}}-sources.zip",
+      name: faker.person.firstName().toLowerCase(),
+      downloadedPackagesDir: fakeDir(),
+      downloadPackages: [],
+      compressionLevel: 9
+    },
+    transformManifest: () => {
+    },
+    userConfigMetadata: {},
+    alias: {},
+    extensionApi: "webextension-polyfill",
+    browserModule: "wxt/browser",
+    entrypointLoader: "vite-node",
+    experimental: {},
+    dev: {
+      reloadCommand: "Alt+R"
+    },
+    hooks: {},
+    vite: () => ({}),
+    plugins: []
+  };
+});
+export const fakeWxt = fakeObjectCreator(() => ({
+  config: fakeResolvedConfig(),
+  hooks: mock(),
+  logger: mock(),
+  reloadConfig: vi.fn(),
+  pm: mock(),
+  server: faker.helpers.arrayElement([void 0, fakeWxtDevServer()]),
+  builder: mock()
+}));
+export const fakeWxtDevServer = fakeObjectCreator(() => ({
+  currentOutput: fakeBuildOutput(),
+  hostname: "localhost",
+  origin: "http://localhost:3000",
+  port: 3e3,
+  reloadContentScript: vi.fn(),
+  reloadExtension: vi.fn(),
+  reloadPage: vi.fn(),
+  restart: vi.fn(),
+  restartBrowser: vi.fn(),
+  start: vi.fn(),
+  stop: vi.fn(),
+  transformHtml: vi.fn(),
+  watcher: mock(),
+  ws: mock()
+}));
+export function setFakeWxt(overrides) {
+  const wxt = fakeWxt(overrides);
+  setWxtForTesting(wxt);
+  return wxt;
+}
+export const fakeBuildOutput = fakeObjectCreator(() => ({
+  manifest: fakeManifest(),
+  publicAssets: fakeArray(fakeOutputAsset),
+  steps: fakeArray(fakeBuildStepOutput)
+}));
+export const fakeBuildStepOutput = fakeObjectCreator(() => ({
+  chunks: fakeArray(fakeOutputChunk),
+  entrypoints: fakeArray(fakeEntrypoint)
+}));
+export const fakeManifestCommand = fakeObjectCreator(() => ({
+  description: faker.string.sample(),
+  shortcut: `${faker.helpers.arrayElement(["ctrl", "alt"])}+${faker.number.int({
+    min: 0,
+    max: 9
+  })}`
+}));
+export const fakeDevServer = fakeObjectCreator(() => ({
+  hostname: "localhost",
+  origin: "http://localhost",
+  port: 5173,
+  reloadContentScript: vi.fn(),
+  reloadExtension: vi.fn(),
+  reloadPage: vi.fn(),
+  restart: vi.fn(),
+  restartBrowser: vi.fn(),
+  stop: vi.fn(),
+  start: vi.fn(),
+  watcher: mock(),
+  transformHtml: vi.fn(),
+  ws: mock(),
+  currentOutput: void 0
+}));

package/dist/core/utils/time.d.ts

@@ -0,0 +1,9 @@
+export declare function formatDuration(duration: number): string;
+/**
+ * Add a timeout to a promise.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, duration: number): Promise<T>;
+/**
+ * @deprecated Don't use in production, just for testing and slowing things down.
+ */
+export declare function sleep(ms: number): Promise<void>;

package/dist/core/utils/time.mjs

@@ -0,0 +1,17 @@
+export function formatDuration(duration) {
+  if (duration < 1e3) return `${duration} ms`;
+  if (duration < 1e4) return `${(duration / 1e3).toFixed(3)} s`;
+  if (duration < 6e4) return `${(duration / 1e3).toFixed(1)} s`;
+  return `${(duration / 1e3).toFixed(0)} s`;
+}
+export function withTimeout(promise, duration) {
+  return new Promise((res, rej) => {
+    const timeout = setTimeout(() => {
+      rej(`Promise timed out after ${duration}ms`);
+    }, duration);
+    promise.then(res).catch(rej).finally(() => clearTimeout(timeout));
+  });
+}
+export function sleep(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}

package/dist/core/utils/transform.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Removes any code used at runtime related to an entrypoint's main function.
+ * - Removes or clears out `main` function from returned object
+ * - TODO: Removes unused imports after main function has been removed to prevent importing runtime modules
+ */
+export declare function removeMainFunctionCode(code: string): {
+    code: string;
+    map?: string;
+};

package/dist/core/utils/transform.mjs

@@ -0,0 +1,17 @@
+import { parseModule } from "magicast";
+export function removeMainFunctionCode(code) {
+  const mod = parseModule(code);
+  emptyMainFunction(mod);
+  return mod.generate();
+}
+function emptyMainFunction(mod) {
+  if (mod.exports?.default?.$type === "function-call") {
+    if (mod.exports.default.$ast?.arguments?.[0]?.body) {
+      mod.exports.default.$ast.arguments[0].body.body = [];
+    } else if (mod.exports.default.$ast?.arguments?.[0]?.properties) {
+      mod.exports.default.$ast.arguments[0].properties = mod.exports.default.$ast.arguments[0].properties.filter(
+        (prop) => prop.key.name !== "main"
+      );
+    }
+  }
+}

package/dist/core/utils/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Remove optional from key, but keep undefined if present
+ *
+ * @example
+ * type Test = NullablyRequired<{a?: string, b: number}>
+ * // type Test = {a: string | undefined, b: number}
+ */
+export type NullablyRequired<T> = {
+    [K in keyof Required<T>]: T[K];
+};

package/dist/core/utils/validation.d.ts

@@ -0,0 +1,15 @@
+import { Entrypoint } from '../../types';
+export declare function validateEntrypoints(entrypoints: Entrypoint[]): ValidationResults;
+export interface ValidationResult {
+    type: 'warning' | 'error';
+    message: string;
+    entrypoint: Entrypoint;
+    value: any;
+}
+export interface ValidationResults {
+    errors: ValidationResult[];
+    errorCount: number;
+    warningCount: number;
+}
+export declare class ValidationError extends Error {
+}

package/dist/core/utils/validation.mjs

@@ -0,0 +1,55 @@
+export function validateEntrypoints(entrypoints) {
+  const errors = entrypoints.flatMap((entrypoint) => {
+    switch (entrypoint.type) {
+      case "content-script":
+        return validateContentScriptEntrypoint(entrypoint);
+      default:
+        return validateBaseEntrypoint(entrypoint);
+    }
+  });
+  let errorCount = 0;
+  let warningCount = 0;
+  for (const err of errors) {
+    if (err.type === "warning") warningCount++;
+    else errorCount++;
+  }
+  return {
+    errors,
+    errorCount,
+    warningCount
+  };
+}
+function validateContentScriptEntrypoint(definition) {
+  const errors = validateBaseEntrypoint(definition);
+  if (definition.options.matches == null) {
+    errors.push({
+      type: "error",
+      message: "`matches` is required",
+      value: definition.options.matches,
+      entrypoint: definition
+    });
+  }
+  return errors;
+}
+function validateBaseEntrypoint(definition) {
+  const errors = [];
+  if (definition.options.exclude != null && !Array.isArray(definition.options.exclude)) {
+    errors.push({
+      type: "error",
+      message: "`exclude` must be an array of browser names",
+      value: definition.options.exclude,
+      entrypoint: definition
+    });
+  }
+  if (definition.options.include != null && !Array.isArray(definition.options.include)) {
+    errors.push({
+      type: "error",
+      message: "`include` must be an array of browser names",
+      value: definition.options.include,
+      entrypoint: definition
+    });
+  }
+  return errors;
+}
+export class ValidationError extends Error {
+}

package/dist/core/utils/virtual-modules.d.ts

@@ -0,0 +1,22 @@
+export declare const virtualEntrypointTypes: ("background" | "unlisted-script" | "content-script-main-world" | "content-script-isolated-world")[];
+export type VirtualEntrypointType = (typeof virtualEntrypointTypes)[0];
+/**
+ * All the names of entrypoint files in the `src/virtual/` and `dist/virtual/` directories, minus the extension.
+ */
+export declare const virtualEntrypointModuleNames: ("background-entrypoint" | "unlisted-script-entrypoint" | "content-script-main-world-entrypoint" | "content-script-isolated-world-entrypoint")[];
+/**
+ * Name of entrypoint files in the `src/virtual/` and `dist/virtual/` directories, minus the extension.
+ */
+export type VirtualEntrypointModuleName = (typeof virtualEntrypointModuleNames)[0];
+/**
+ * All the names of files in the `src/virtual/` and `dist/virtual/` directories, minus the extension.
+ */
+export declare const virtualModuleNames: ("background-entrypoint" | "unlisted-script-entrypoint" | "content-script-main-world-entrypoint" | "content-script-isolated-world-entrypoint" | "mock-browser" | "reload-html")[];
+/**
+ * Name of files in the `src/virtual/` and `dist/virtual/` directories, minus the extension.
+ */
+export type VirtualModuleName = (typeof virtualModuleNames)[0];
+/**
+ * Import alias used for importing a virtual module
+ */
+export type VirtualModuleId = `virtual:wxt-${VirtualModuleName}`;

package/dist/core/utils/virtual-modules.mjs

@@ -0,0 +1,14 @@
+export const virtualEntrypointTypes = [
+  "content-script-main-world",
+  "content-script-isolated-world",
+  "background",
+  "unlisted-script"
+];
+export const virtualEntrypointModuleNames = virtualEntrypointTypes.map(
+  (name) => `${name}-entrypoint`
+);
+export const virtualModuleNames = [
+  ...virtualEntrypointModuleNames,
+  "mock-browser",
+  "reload-html"
+];

package/dist/core/utils/wsl.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns true when running on WSL or WSL2.
+ */
+export declare function isWsl(): Promise<boolean>;

package/dist/core/utils/wsl.mjs

@@ -0,0 +1,4 @@
+export async function isWsl() {
+  const { default: isWsl2 } = await import("is-wsl");
+  return isWsl2;
+}

package/dist/core/wxt.d.ts

@@ -0,0 +1,19 @@
+import { InlineConfig, ResolvedConfig, Wxt, WxtCommand, WxtDevServer } from '../types';
+/**
+ * Global variable set once `createWxt` is called once. Since this variable is used everywhere, this
+ * global can be used instead of passing the variable as a function parameter everywhere.
+ */
+export declare let wxt: Wxt;
+/**
+ * Create and register a global instance of the Wxt interface for use throughout the project.
+ */
+export declare function registerWxt(command: WxtCommand, inlineConfig?: InlineConfig, getServer?: (config: ResolvedConfig) => Promise<WxtDevServer>): Promise<void>;
+/**
+ * @internal ONLY USE FOR TESTING.
+ *
+ * @example
+ * setWxtForTesting(fakeWxt({ ... }));
+ * // Or use the shorthand
+ * setFakeWxt({ ... })
+ */
+export declare function setWxtForTesting(testInstance: Wxt): void;

package/dist/core/wxt.mjs

@@ -0,0 +1,41 @@
+import { resolveConfig } from "./utils/building/index.mjs";
+import { createHooks } from "hookable";
+import { createWxtPackageManager } from "./package-managers/index.mjs";
+import { createViteBuilder } from "./builders/vite/index.mjs";
+import { builtinModules } from "../builtin-modules/index.mjs";
+export let wxt;
+export async function registerWxt(command, inlineConfig = {}, getServer) {
+  const hooks = createHooks();
+  const config = await resolveConfig(inlineConfig, command);
+  const server = await getServer?.(config);
+  const builder = await createViteBuilder(config, hooks, server);
+  const pm = await createWxtPackageManager(config.root);
+  wxt = {
+    config,
+    hooks,
+    get logger() {
+      return config.logger;
+    },
+    async reloadConfig() {
+      wxt.config = await resolveConfig(inlineConfig, command);
+    },
+    pm,
+    builder,
+    server
+  };
+  const initModule = async (module) => {
+    if (module.hooks) wxt.hooks.addHooks(module.hooks);
+    await module.setup?.(
+      wxt,
+      // @ts-expect-error: Untyped configKey field
+      module.configKey ? config[module.configKey] : void 0
+    );
+  };
+  for (const builtinModule of builtinModules) await initModule(builtinModule);
+  for (const userModule of config.userModules) await initModule(userModule);
+  wxt.hooks.addHooks(config.hooks);
+  await wxt.hooks.callHook("ready", wxt);
+}
+export function setWxtForTesting(testInstance) {
+  wxt = testInstance;
+}

package/dist/core/zip.d.ts

@@ -0,0 +1,7 @@
+import { InlineConfig } from '../types';
+/**
+ * Build and zip the extension for distribution.
+ * @param config Optional config that will override your `<root>/wxt.config.ts`.
+ * @returns A list of all files included in the ZIP.
+ */
+export declare function zip(config?: InlineConfig): Promise<string[]>;