wxt 0.18.15 → 0.19.0

package/dist/core/initialize.d.ts

@@ -0,0 +1,5 @@
+export declare function initialize(options: {
+    directory: string;
+    template: string;
+    packageManager: string;
+}): Promise<void>;

package/dist/core/initialize.mjs

@@ -0,0 +1,128 @@
+import prompts from "prompts";
+import { consola } from "consola";
+import { downloadTemplate } from "giget";
+import fs from "fs-extra";
+import path from "node:path";
+import pc from "picocolors";
+export async function initialize(options) {
+  consola.info("Initalizing new project");
+  const templates = await listTemplates();
+  const defaultTemplate = templates.find(
+    (template) => template.name === options.template?.toLowerCase().trim()
+  );
+  const input = await prompts(
+    [
+      {
+        name: "directory",
+        type: () => options.directory == null ? "text" : void 0,
+        message: "Project Directory",
+        initial: options.directory
+      },
+      {
+        name: "template",
+        type: () => defaultTemplate == null ? "select" : void 0,
+        message: "Choose a template",
+        choices: templates.map((template) => ({
+          title: TEMPLATE_COLORS[template.name]?.(template.name) ?? template.name,
+          value: template
+        }))
+      },
+      {
+        name: "packageManager",
+        type: () => options.packageManager == null ? "select" : void 0,
+        message: "Package Manager",
+        choices: [
+          { title: pc.red("npm"), value: "npm" },
+          { title: pc.yellow("pnpm"), value: "pnpm" },
+          { title: pc.cyan("yarn"), value: "yarn" },
+          {
+            title: `${pc.magenta("bun")}${pc.gray(" (experimental)")}`,
+            value: "bun"
+          }
+        ]
+      }
+    ],
+    {
+      onCancel: () => process.exit(1)
+    }
+  );
+  input.directory ??= options.directory;
+  input.template ??= defaultTemplate;
+  input.packageManager ??= options.packageManager;
+  const isExists = await fs.pathExists(input.directory);
+  if (isExists) {
+    const isEmpty = (await fs.readdir(input.directory)).length === 0;
+    if (!isEmpty) {
+      consola.error(
+        `The directory ${path.resolve(input.directory)} is not empty. Aborted.`
+      );
+      process.exit(1);
+    }
+  }
+  await cloneProject(input);
+  const cdPath = path.relative(process.cwd(), path.resolve(input.directory));
+  console.log();
+  consola.log(
+    `\u2728 WXT project created with the ${TEMPLATE_COLORS[input.template.name]?.(input.template.name) ?? input.template.name} template.`
+  );
+  console.log();
+  consola.log("Next steps:");
+  let step = 0;
+  if (cdPath !== "") consola.log(`  ${++step}.`, pc.cyan(`cd ${cdPath}`));
+  consola.log(`  ${++step}.`, pc.cyan(`${input.packageManager} install`));
+  console.log();
+}
+async function listTemplates() {
+  try {
+    const res = await fetch("https://ungh.cc/repos/wxt-dev/wxt/files/main");
+    if (res.status >= 300)
+      throw Error(`Request failed with status ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    return data.files.map((item) => item.path.match(/templates\/(.+)\/package\.json/)?.[1]).filter((name) => name != null).map((name) => ({ name, path: `templates/${name}` })).sort((l, r) => {
+      const lWeight = TEMPLATE_SORT_WEIGHT[l.name] ?? Number.MAX_SAFE_INTEGER;
+      const rWeight = TEMPLATE_SORT_WEIGHT[r.name] ?? Number.MAX_SAFE_INTEGER;
+      const diff = lWeight - rWeight;
+      if (diff !== 0) return diff;
+      return l.name.localeCompare(r.name);
+    });
+  } catch (err) {
+    consola.error(err);
+    throw Error(`Failed to load templates`);
+  }
+}
+async function cloneProject({
+  directory,
+  template,
+  packageManager
+}) {
+  const { default: ora } = await import("ora");
+  const spinner = ora("Downloading template").start();
+  try {
+    await downloadTemplate(`gh:wxt-dev/wxt/${template.path}`, {
+      dir: directory,
+      force: true
+    });
+    await fs.move(
+      path.join(directory, "_gitignore"),
+      path.join(directory, ".gitignore")
+    ).catch(
+      (err) => consola.warn("Failed to move _gitignore to .gitignore:", err)
+    );
+    spinner.succeed();
+  } catch (err) {
+    spinner.fail();
+    throw Error(`Failed to setup new project: ${JSON.stringify(err, null, 2)}`);
+  }
+}
+const TEMPLATE_COLORS = {
+  vanilla: pc.blue,
+  vue: pc.green,
+  react: pc.cyan,
+  svelte: pc.red,
+  solid: pc.blue
+};
+const TEMPLATE_SORT_WEIGHT = {
+  vanilla: 0,
+  vue: 1,
+  react: 2
+};

package/dist/core/package-managers/bun.d.ts

@@ -0,0 +1,2 @@
+import { WxtPackageManagerImpl } from './types';
+export declare const bun: WxtPackageManagerImpl;

package/dist/core/package-managers/bun.mjs

@@ -0,0 +1,19 @@
+import { dedupeDependencies, npm } from "./npm.mjs";
+export const bun = {
+  overridesKey: "overrides",
+  // But also supports "resolutions"
+  downloadDependency(...args) {
+    return npm.downloadDependency(...args);
+  },
+  async listDependencies(options) {
+    const args = ["pm", "ls"];
+    if (options?.all) {
+      args.push("--all");
+    }
+    const { execa } = await import("execa");
+    const res = await execa("bun", args, { cwd: options?.cwd });
+    return dedupeDependencies(
+      res.stdout.split("\n").slice(1).map((line) => line.trim()).map((line) => /.* (@?\S+)@(\S+)$/.exec(line)).filter((match) => !!match).map(([_, name, version]) => ({ name, version }))
+    );
+  }
+};

package/dist/core/package-managers/index.d.ts

@@ -0,0 +1,2 @@
+import { WxtPackageManager } from '../../types';
+export declare function createWxtPackageManager(root: string): Promise<WxtPackageManager>;

package/dist/core/package-managers/index.mjs

@@ -0,0 +1,65 @@
+import {
+  detectPackageManager,
+  addDependency,
+  addDevDependency,
+  ensureDependencyInstalled,
+  installDependencies,
+  removeDependency
+} from "nypm";
+import { bun } from "./bun.mjs";
+import { yarn } from "./yarn.mjs";
+import { pnpm } from "./pnpm.mjs";
+import { npm } from "./npm.mjs";
+export async function createWxtPackageManager(root) {
+  const pm = await detectPackageManager(root, {
+    includeParentDirs: true
+  });
+  const requirePm = (cb) => {
+    if (pm == null) throw Error("Could not detect package manager");
+    return cb(pm);
+  };
+  return {
+    get name() {
+      return requirePm((pm2) => pm2.name);
+    },
+    get command() {
+      return requirePm((pm2) => pm2.command);
+    },
+    get version() {
+      return requirePm((pm2) => pm2.version);
+    },
+    get majorVersion() {
+      return requirePm((pm2) => pm2.majorVersion);
+    },
+    get lockFile() {
+      return requirePm((pm2) => pm2.lockFile);
+    },
+    get files() {
+      return requirePm((pm2) => pm2.files);
+    },
+    addDependency,
+    addDevDependency,
+    ensureDependencyInstalled,
+    installDependencies,
+    removeDependency,
+    get overridesKey() {
+      return requirePm((pm2) => packageManagers[pm2.name].overridesKey);
+    },
+    downloadDependency(...args) {
+      return requirePm(
+        (pm2) => packageManagers[pm2.name].downloadDependency(...args)
+      );
+    },
+    listDependencies(...args) {
+      return requirePm(
+        (pm2) => packageManagers[pm2.name].listDependencies(...args)
+      );
+    }
+  };
+}
+const packageManagers = {
+  npm,
+  pnpm,
+  bun,
+  yarn
+};

package/dist/core/package-managers/npm.d.ts

@@ -0,0 +1,17 @@
+import { Dependency } from '../../types';
+import { WxtPackageManagerImpl } from './types';
+export declare const npm: WxtPackageManagerImpl;
+export declare function flattenNpmListOutput(projects: NpmListProject[]): Dependency[];
+export declare function dedupeDependencies(dependencies: Dependency[]): Dependency[];
+export interface NpmListProject {
+    name: string;
+    dependencies?: Record<string, NpmListDependency>;
+    devDependencies?: Record<string, NpmListDependency>;
+}
+export interface NpmListDependency {
+    version: string;
+    resolved?: string;
+    overridden?: boolean;
+    dependencies?: Record<string, NpmListDependency>;
+    devDependencies?: Record<string, NpmListDependency>;
+}

package/dist/core/package-managers/npm.mjs

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { ensureDir } from "fs-extra";
+export const npm = {
+  overridesKey: "overrides",
+  async downloadDependency(id, downloadDir) {
+    await ensureDir(downloadDir);
+    const { execa } = await import("execa");
+    const res = await execa("npm", ["pack", id, "--json"], {
+      cwd: downloadDir
+    });
+    const packed = JSON.parse(res.stdout);
+    return path.resolve(downloadDir, packed[0].filename);
+  },
+  async listDependencies(options) {
+    const args = ["ls", "--json"];
+    if (options?.all) {
+      args.push("--depth", "Infinity");
+    }
+    const { execa } = await import("execa");
+    const res = await execa("npm", args, { cwd: options?.cwd });
+    const project = JSON.parse(res.stdout);
+    return flattenNpmListOutput([project]);
+  }
+};
+export function flattenNpmListOutput(projects) {
+  const queue = projects.flatMap(
+    (project) => {
+      const acc = [];
+      if (project.dependencies) acc.push(project.dependencies);
+      if (project.devDependencies) acc.push(project.devDependencies);
+      return acc;
+    }
+  );
+  const dependencies = [];
+  while (queue.length > 0) {
+    Object.entries(queue.pop()).forEach(([name, meta]) => {
+      dependencies.push({
+        name,
+        version: meta.version
+      });
+      if (meta.dependencies) queue.push(meta.dependencies);
+      if (meta.devDependencies) queue.push(meta.devDependencies);
+    });
+  }
+  return dedupeDependencies(dependencies);
+}
+export function dedupeDependencies(dependencies) {
+  const hashes = /* @__PURE__ */ new Set();
+  return dependencies.filter((dep) => {
+    const hash = `${dep.name}@${dep.version}`;
+    if (hashes.has(hash)) {
+      return false;
+    } else {
+      hashes.add(hash);
+      return true;
+    }
+  });
+}

package/dist/core/package-managers/pnpm.d.ts

@@ -0,0 +1,2 @@
+import { WxtPackageManagerImpl } from './types';
+export declare const pnpm: WxtPackageManagerImpl;

package/dist/core/package-managers/pnpm.mjs

@@ -0,0 +1,21 @@
+import { flattenNpmListOutput, npm } from "./npm.mjs";
+export const pnpm = {
+  overridesKey: "resolutions",
+  // "pnpm.overrides" has a higher priority, but I don't want to deal with nesting
+  downloadDependency(...args) {
+    return npm.downloadDependency(...args);
+  },
+  async listDependencies(options) {
+    const args = ["ls", "-r", "--json"];
+    if (options?.all) {
+      args.push("--depth", "Infinity");
+    }
+    if (typeof process !== "undefined" && process.env.WXT_PNPM_IGNORE_WORKSPACE === "true") {
+      args.push("--ignore-workspace");
+    }
+    const { execa } = await import("execa");
+    const res = await execa("pnpm", args, { cwd: options?.cwd });
+    const projects = JSON.parse(res.stdout);
+    return flattenNpmListOutput(projects);
+  }
+};

package/dist/core/package-managers/types.d.ts

@@ -0,0 +1,2 @@
+import { WxtPackageManager } from '../../types';
+export type WxtPackageManagerImpl = Pick<WxtPackageManager, 'downloadDependency' | 'listDependencies' | 'overridesKey'>;

package/dist/core/package-managers/yarn.d.ts

@@ -0,0 +1,2 @@
+import { WxtPackageManagerImpl } from './types';
+export declare const yarn: WxtPackageManagerImpl;

package/dist/core/package-managers/yarn.mjs

@@ -0,0 +1,31 @@
+import { dedupeDependencies, npm } from "./npm.mjs";
+export const yarn = {
+  overridesKey: "resolutions",
+  downloadDependency(...args) {
+    return npm.downloadDependency(...args);
+  },
+  async listDependencies(options) {
+    const args = ["list", "--json"];
+    if (options?.all) {
+      args.push("--depth", "Infinity");
+    }
+    const { execa } = await import("execa");
+    const res = await execa("yarn", args, { cwd: options?.cwd });
+    const tree = res.stdout.split("\n").map((line) => JSON.parse(line)).find((line) => line.type === "tree")?.data;
+    if (tree == null) throw Error("'yarn list --json' did not output a tree");
+    const queue = [...tree.trees];
+    const dependencies = [];
+    while (queue.length > 0) {
+      const { name: treeName, children } = queue.pop();
+      const match = /(@?\S+)@(\S+)$/.exec(treeName);
+      if (match) {
+        const [_, name, version] = match;
+        dependencies.push({ name, version });
+      }
+      if (children != null) {
+        queue.push(...children);
+      }
+    }
+    return dedupeDependencies(dependencies);
+  }
+};

package/dist/core/prepare.d.ts

@@ -0,0 +1,2 @@
+import { InlineConfig } from '../types';
+export declare function prepare(config: InlineConfig): Promise<void>;

package/dist/core/prepare.mjs

@@ -0,0 +1,8 @@
+import { findEntrypoints, generateTypesDir } from "./utils/building/index.mjs";
+import { registerWxt, wxt } from "./wxt.mjs";
+export async function prepare(config) {
+  await registerWxt("build", config);
+  wxt.logger.info("Generating types...");
+  const entrypoints = await findEntrypoints();
+  await generateTypesDir(entrypoints);
+}

package/dist/core/runners/index.d.ts

@@ -0,0 +1,2 @@
+import { ExtensionRunner } from '../../types';
+export declare function createExtensionRunner(): Promise<ExtensionRunner>;

package/dist/core/runners/index.mjs

@@ -0,0 +1,12 @@
+import { createWslRunner } from "./wsl.mjs";
+import { createWebExtRunner } from "./web-ext.mjs";
+import { createSafariRunner } from "./safari.mjs";
+import { createManualRunner } from "./manual.mjs";
+import { isWsl } from "../utils/wsl.mjs";
+import { wxt } from "../wxt.mjs";
+export async function createExtensionRunner() {
+  if (wxt.config.browser === "safari") return createSafariRunner();
+  if (await isWsl()) return createWslRunner();
+  if (wxt.config.runnerConfig.config?.disabled) return createManualRunner();
+  return createWebExtRunner();
+}

package/dist/core/runners/manual.d.ts

@@ -0,0 +1,5 @@
+import { ExtensionRunner } from '../../types';
+/**
+ * The manual runner tells the user to load the unpacked extension manually.
+ */
+export declare function createManualRunner(): ExtensionRunner;

package/dist/core/runners/manual.mjs

@@ -0,0 +1,16 @@
+import { relative } from "node:path";
+import { wxt } from "../wxt.mjs";
+export function createManualRunner() {
+  return {
+    async openBrowser() {
+      wxt.logger.info(
+        `Load "${relative(
+          process.cwd(),
+          wxt.config.outDir
+        )}" as an unpacked extension manually`
+      );
+    },
+    async closeBrowser() {
+    }
+  };
+}

package/dist/core/runners/safari.d.ts

@@ -0,0 +1,5 @@
+import { ExtensionRunner } from '../../types';
+/**
+ * The Safari runner just logs a warning message because `web-ext` doesn't work with Safari.
+ */
+export declare function createSafariRunner(): ExtensionRunner;

package/dist/core/runners/safari.mjs

@@ -0,0 +1,16 @@
+import { relative } from "node:path";
+import { wxt } from "../wxt.mjs";
+export function createSafariRunner() {
+  return {
+    async openBrowser() {
+      wxt.logger.warn(
+        `Cannot Safari using web-ext. Load "${relative(
+          process.cwd(),
+          wxt.config.outDir
+        )}" as an unpacked extension manually`
+      );
+    },
+    async closeBrowser() {
+    }
+  };
+}

package/dist/core/runners/web-ext.d.ts

@@ -0,0 +1,5 @@
+import { ExtensionRunner } from '../../types';
+/**
+ * Create an `ExtensionRunner` backed by `web-ext`.
+ */
+export declare function createWebExtRunner(): ExtensionRunner;

package/dist/core/runners/web-ext.mjs

@@ -0,0 +1,78 @@
+import { formatDuration } from "../utils/time.mjs";
+import defu from "defu";
+import { wxt } from "../wxt.mjs";
+export function createWebExtRunner() {
+  let runner;
+  return {
+    async openBrowser() {
+      const startTime = Date.now();
+      if (wxt.config.browser === "firefox" && wxt.config.manifestVersion === 3) {
+        throw Error(
+          "Dev mode does not support Firefox MV3. For alternatives, see https://github.com/wxt-dev/wxt/issues/230#issuecomment-1806881653"
+        );
+      }
+      const webExtLogger = await import("web-ext-run/util/logger");
+      webExtLogger.consoleStream.write = ({ level, msg, name }) => {
+        if (level >= ERROR_LOG_LEVEL) wxt.logger.error(name, msg);
+        if (level >= WARN_LOG_LEVEL) wxt.logger.warn(msg);
+      };
+      const wxtUserConfig = wxt.config.runnerConfig.config;
+      const userConfig = {
+        console: wxtUserConfig?.openConsole,
+        devtools: wxtUserConfig?.openDevtools,
+        startUrl: wxtUserConfig?.startUrls,
+        keepProfileChanges: wxtUserConfig?.keepProfileChanges,
+        ...wxt.config.browser === "firefox" ? {
+          firefox: wxtUserConfig?.binaries?.firefox,
+          firefoxProfile: wxtUserConfig?.firefoxProfile,
+          prefs: wxtUserConfig?.firefoxPrefs,
+          args: wxtUserConfig?.firefoxArgs
+        } : {
+          chromiumBinary: wxtUserConfig?.binaries?.[wxt.config.browser],
+          chromiumProfile: wxtUserConfig?.chromiumProfile,
+          chromiumPref: defu(
+            wxtUserConfig?.chromiumPref,
+            DEFAULT_CHROMIUM_PREFS
+          ),
+          args: wxtUserConfig?.chromiumArgs
+        }
+      };
+      const finalConfig = {
+        ...userConfig,
+        target: wxt.config.browser === "firefox" ? "firefox-desktop" : "chromium",
+        sourceDir: wxt.config.outDir,
+        // Don't add a "Reload Manager" extension alongside dev extension, WXT
+        // already handles reloads intenrally.
+        noReloadManagerExtension: true,
+        // WXT handles reloads, so disable auto-reload behaviors in web-ext
+        noReload: true,
+        noInput: true
+      };
+      const options = {
+        // Don't call `process.exit(0)` after starting web-ext
+        shouldExitProgram: false
+      };
+      wxt.logger.debug("web-ext config:", finalConfig);
+      wxt.logger.debug("web-ext options:", options);
+      const webExt = await import("web-ext-run");
+      runner = await webExt.default.cmd.run(finalConfig, options);
+      const duration = Date.now() - startTime;
+      wxt.logger.success(`Opened browser in ${formatDuration(duration)}`);
+    },
+    async closeBrowser() {
+      return await runner?.exit();
+    }
+  };
+}
+const WARN_LOG_LEVEL = 40;
+const ERROR_LOG_LEVEL = 50;
+const DEFAULT_CHROMIUM_PREFS = {
+  devtools: {
+    synced_preferences_sync_disabled: {
+      // Remove content scripts from sourcemap debugger ignore list so stack traces
+      // and log locations show up properly, see:
+      // https://github.com/wxt-dev/wxt/issues/236#issuecomment-1915364520
+      skipContentScripts: false
+    }
+  }
+};

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

@@ -0,0 +1,5 @@
+import { ExtensionRunner } from '../../types';
+/**
+ * The WSL runner just logs a warning message because `web-ext` doesn't work in WSL.
+ */
+export declare function createWslRunner(): ExtensionRunner;

package/dist/core/runners/wsl.mjs

@@ -0,0 +1,16 @@
+import { relative } from "node:path";
+import { wxt } from "../wxt.mjs";
+export function createWslRunner() {
+  return {
+    async openBrowser() {
+      wxt.logger.warn(
+        `Cannot open browser when using WSL. Load "${relative(
+          process.cwd(),
+          wxt.config.outDir
+        )}" as an unpacked extension manually`
+      );
+    },
+    async closeBrowser() {
+    }
+  };
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Checks if `predicate` returns truthy for all elements of the array.
+ */
+export declare function every<T>(array: T[], predicate: (item: T, index: number) => boolean): boolean;
+/**
+ * Returns true when any of the predicates return true;
+ */
+export declare function some<T>(array: T[], predicate: (item: T, index: number) => boolean): boolean;
+/**
+ * Convert an item or array to an array.
+ */
+export declare function toArray<T>(a: T | T[]): T[];
+export declare function filterTruthy<T>(array: Array<T | undefined>): T[];

package/dist/{chunk-BERPNPEZ.js → core/utils/arrays.mjs}

@@ -1,20 +1,16 @@
-// src/core/utils/arrays.ts
-function every(array, predicate) {
+export function every(array, predicate) {
   for (let i = 0; i < array.length; i++)
     if (!predicate(array[i], i)) return false;
   return true;
 }
-function some(array, predicate) {
+export function some(array, predicate) {
   for (let i = 0; i < array.length; i++)
     if (predicate(array[i], i)) return true;
   return false;
 }
-function toArray(a) {
+export function toArray(a) {
   return Array.isArray(a) ? a : [a];
 }
-
-export {
-  every,
-  some,
-  toArray
-};
+export function filterTruthy(array) {
+  return array.filter((item) => !!item);
+}

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

@@ -0,0 +1,3 @@
+import { BuildOutput, EntrypointGroup } from '../../../types';
+import type { Ora } from 'ora';
+export declare function buildEntrypoints(groups: EntrypointGroup[], spinner: Ora): Promise<Omit<BuildOutput, 'manifest'>>;

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

@@ -0,0 +1,47 @@
+import { getPublicFiles } from "../../utils/fs.mjs";
+import fs from "fs-extra";
+import { dirname, resolve } from "path";
+import pc from "picocolors";
+import { wxt } from "../../wxt.mjs";
+import { toArray } from "../arrays.mjs";
+export async function buildEntrypoints(groups, spinner) {
+  const steps = [];
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    const groupNames = toArray(group).map((e) => e.name);
+    const groupNameColored = groupNames.join(pc.dim(", "));
+    spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNameColored}`;
+    try {
+      steps.push(await wxt.builder.build(group));
+    } catch (err) {
+      spinner.stop().clear();
+      wxt.logger.error(err);
+      throw Error(`Failed to build ${groupNames.join(", ")}`, { cause: err });
+    }
+  }
+  const publicAssets = await copyPublicDirectory();
+  return { publicAssets, steps };
+}
+async function copyPublicDirectory() {
+  const files = (await getPublicFiles()).map((file) => ({
+    absoluteSrc: resolve(wxt.config.publicDir, file),
+    relativeDest: file
+  }));
+  await wxt.hooks.callHook("build:publicAssets", wxt, files);
+  if (files.length === 0) return [];
+  const publicAssets = [];
+  for (const file of files) {
+    const absoluteDest = resolve(wxt.config.outDir, file.relativeDest);
+    await fs.ensureDir(dirname(absoluteDest));
+    if ("absoluteSrc" in file) {
+      await fs.copyFile(file.absoluteSrc, absoluteDest);
+    } else {
+      await fs.writeFile(absoluteDest, file.contents, "utf8");
+    }
+    publicAssets.push({
+      type: "asset",
+      fileName: file.relativeDest
+    });
+  }
+  return publicAssets;
+}