wxt 0.18.15 → 0.19.0

package/dist/core/utils/building/resolve-config.mjs

@@ -0,0 +1,364 @@
+import { loadConfig } from "c12";
+import path from "node:path";
+import { createFsCache } from "../../utils/cache.mjs";
+import consola, { LogLevels } from "consola";
+import defu from "defu";
+import fs from "fs-extra";
+import { normalizePath } from "../paths.mjs";
+import glob from "fast-glob";
+import { builtinModules } from "../../../builtin-modules/index.mjs";
+import { getEslintVersion } from "../eslint.mjs";
+export async function resolveConfig(inlineConfig, command) {
+  let userConfig = {};
+  let userConfigMetadata;
+  if (inlineConfig.configFile !== false) {
+    const { config: loadedConfig, ...metadata } = await loadConfig({
+      configFile: inlineConfig.configFile,
+      name: "wxt",
+      cwd: inlineConfig.root ?? process.cwd(),
+      rcFile: false,
+      jitiOptions: {
+        esmResolve: true
+      }
+    });
+    userConfig = loadedConfig ?? {};
+    userConfigMetadata = metadata;
+  }
+  const mergedConfig = await mergeInlineConfig(inlineConfig, userConfig);
+  const debug = mergedConfig.debug ?? false;
+  const logger = mergedConfig.logger ?? consola;
+  if (debug) logger.level = LogLevels.debug;
+  const browser = mergedConfig.browser ?? "chrome";
+  const manifestVersion = mergedConfig.manifestVersion ?? (browser === "firefox" || browser === "safari" ? 2 : 3);
+  const mode = mergedConfig.mode ?? COMMAND_MODES[command];
+  const env = { browser, command, manifestVersion, mode };
+  const root = path.resolve(
+    inlineConfig.root ?? userConfig.root ?? process.cwd()
+  );
+  const wxtDir = path.resolve(root, ".wxt");
+  const wxtModuleDir = await resolveWxtModuleDir();
+  const srcDir = path.resolve(root, mergedConfig.srcDir ?? root);
+  const entrypointsDir = path.resolve(
+    srcDir,
+    mergedConfig.entrypointsDir ?? "entrypoints"
+  );
+  const modulesDir = path.resolve(srcDir, mergedConfig.modulesDir ?? "modules");
+  if (await isDirMissing(entrypointsDir)) {
+    logMissingDir(logger, "Entrypoints", entrypointsDir);
+  }
+  const filterEntrypoints = !!mergedConfig.filterEntrypoints?.length ? new Set(mergedConfig.filterEntrypoints) : void 0;
+  const publicDir = path.resolve(srcDir, mergedConfig.publicDir ?? "public");
+  if (await isDirMissing(publicDir)) {
+    logMissingDir(logger, "Public", publicDir);
+  }
+  const typesDir = path.resolve(wxtDir, "types");
+  const outBaseDir = path.resolve(root, mergedConfig.outDir ?? ".output");
+  const outDir = path.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const reloadCommand = mergedConfig.dev?.reloadCommand ?? "Alt+R";
+  const runnerConfig = await loadConfig({
+    name: "web-ext",
+    cwd: root,
+    globalRc: true,
+    rcFile: ".webextrc",
+    overrides: inlineConfig.runner,
+    defaults: userConfig.runner
+  });
+  const alias = Object.fromEntries(
+    Object.entries({
+      ...mergedConfig.alias,
+      "@": srcDir,
+      "~": srcDir,
+      "@@": root,
+      "~~": root
+    }).map(([key, value]) => [key, path.resolve(root, value)])
+  );
+  let devServerConfig;
+  if (command === "serve") {
+    let port = mergedConfig.dev?.server?.port;
+    if (port == null || !isFinite(port)) {
+      const { default: getPort, portNumbers } = await import("get-port");
+      port = await getPort({ port: portNumbers(3e3, 3010) });
+    }
+    devServerConfig = {
+      port,
+      hostname: mergedConfig.dev?.server?.hostname ?? "localhost"
+    };
+  }
+  const userModules = await resolveWxtUserModules(
+    modulesDir,
+    mergedConfig.modules
+  );
+  const moduleOptions = userModules.reduce(
+    (map, module) => {
+      if (module.configKey) {
+        map[module.configKey] = // @ts-expect-error
+        mergedConfig[module.configKey];
+      }
+      return map;
+    },
+    {}
+  );
+  const extensionApi = mergedConfig.extensionApi ?? "webextension-polyfill";
+  return {
+    browser,
+    command,
+    debug,
+    entrypointsDir,
+    modulesDir,
+    filterEntrypoints,
+    env,
+    fsCache: createFsCache(wxtDir),
+    imports: await getUnimportOptions(
+      wxtDir,
+      srcDir,
+      logger,
+      extensionApi,
+      mergedConfig
+    ),
+    logger,
+    manifest: await resolveManifestConfig(env, mergedConfig.manifest),
+    manifestVersion,
+    mode,
+    outBaseDir,
+    outDir,
+    publicDir,
+    wxtModuleDir,
+    root,
+    runnerConfig,
+    srcDir,
+    typesDir,
+    wxtDir,
+    zip: resolveZipConfig(root, outBaseDir, mergedConfig),
+    transformManifest: mergedConfig.transformManifest,
+    analysis: resolveAnalysisConfig(root, mergedConfig),
+    userConfigMetadata: userConfigMetadata ?? {},
+    alias,
+    extensionApi,
+    browserModule: extensionApi === "chrome" ? "wxt/browser/chrome" : "wxt/browser",
+    entrypointLoader: mergedConfig.entrypointLoader ?? "vite-node",
+    experimental: defu(mergedConfig.experimental, {}),
+    dev: {
+      server: devServerConfig,
+      reloadCommand
+    },
+    hooks: mergedConfig.hooks ?? {},
+    vite: mergedConfig.vite ?? (() => ({})),
+    builtinModules,
+    userModules,
+    plugins: [],
+    ...moduleOptions
+  };
+}
+async function resolveManifestConfig(env, manifest) {
+  return typeof manifest === "function" ? await manifest(env) : await (manifest ?? {});
+}
+async function mergeInlineConfig(inlineConfig, userConfig) {
+  const imports = inlineConfig.imports === false || userConfig.imports === false ? false : userConfig.imports == null && inlineConfig.imports == null ? void 0 : defu(inlineConfig.imports ?? {}, userConfig.imports ?? {});
+  const manifest = async (env) => {
+    const user = await resolveManifestConfig(env, userConfig.manifest);
+    const inline = await resolveManifestConfig(env, inlineConfig.manifest);
+    return defu(inline, user);
+  };
+  const transformManifest = (manifest2) => {
+    userConfig.transformManifest?.(manifest2);
+    inlineConfig.transformManifest?.(manifest2);
+  };
+  const merged = defu(inlineConfig, userConfig);
+  const builderConfig = await mergeBuilderConfig(
+    merged.logger ?? consola,
+    inlineConfig,
+    userConfig
+  );
+  return {
+    ...merged,
+    // Custom merge values
+    transformManifest,
+    imports,
+    manifest,
+    ...builderConfig
+  };
+}
+function resolveZipConfig(root, outBaseDir, mergedConfig) {
+  const downloadedPackagesDir = path.resolve(root, ".wxt/local_modules");
+  return {
+    name: void 0,
+    sourcesTemplate: "{{name}}-{{version}}-sources.zip",
+    artifactTemplate: "{{name}}-{{version}}-{{browser}}.zip",
+    sourcesRoot: root,
+    includeSources: [],
+    compressionLevel: 9,
+    ...mergedConfig.zip,
+    excludeSources: [
+      "**/node_modules",
+      // WXT files
+      "**/web-ext.config.ts",
+      // Hidden files
+      "**/.*",
+      // Tests
+      "**/__tests__/**",
+      "**/*.+(test|spec).?(c|m)+(j|t)s?(x)",
+      // Output directory
+      `${path.relative(root, outBaseDir)}/**`,
+      // From user
+      ...mergedConfig.zip?.excludeSources ?? []
+    ],
+    downloadPackages: mergedConfig.zip?.downloadPackages ?? [],
+    downloadedPackagesDir
+  };
+}
+function resolveAnalysisConfig(root, mergedConfig) {
+  const analysisOutputFile = path.resolve(
+    root,
+    mergedConfig.analysis?.outputFile ?? "stats.html"
+  );
+  const analysisOutputDir = path.dirname(analysisOutputFile);
+  const analysisOutputName = path.parse(analysisOutputFile).name;
+  return {
+    enabled: mergedConfig.analysis?.enabled ?? false,
+    open: mergedConfig.analysis?.open ?? false,
+    template: mergedConfig.analysis?.template ?? "treemap",
+    outputFile: analysisOutputFile,
+    outputDir: analysisOutputDir,
+    outputName: analysisOutputName,
+    keepArtifacts: mergedConfig.analysis?.keepArtifacts ?? false
+  };
+}
+async function getUnimportOptions(wxtDir, srcDir, logger, extensionApi, config) {
+  if (config.imports === false) return false;
+  const defaultOptions = {
+    debugLog: logger.debug,
+    imports: [
+      { name: "defineConfig", from: "wxt" },
+      { name: "fakeBrowser", from: "wxt/testing" }
+    ],
+    presets: [
+      {
+        package: "wxt/client",
+        // There seems to be a bug in unimport that thinks "options" is an
+        // export from wxt/client, but it doesn't actually exist... so it's
+        // ignored.
+        ignore: ["options"]
+      },
+      {
+        package: extensionApi === "chrome" ? "wxt/browser/chrome" : "wxt/browser"
+      },
+      { package: "wxt/sandbox" },
+      { package: "wxt/storage" }
+    ],
+    warn: logger.warn,
+    dirs: ["components", "composables", "hooks", "utils"],
+    dirsScanOptions: {
+      cwd: srcDir
+    },
+    eslintrc: await getUnimportEslintOptions(wxtDir, config.imports?.eslintrc)
+  };
+  return defu(
+    config.imports ?? {},
+    defaultOptions
+  );
+}
+async function getUnimportEslintOptions(wxtDir, options) {
+  const rawEslintEnabled = options?.enabled ?? "auto";
+  let eslintEnabled;
+  switch (rawEslintEnabled) {
+    case "auto":
+      const version = await getEslintVersion();
+      let major = parseInt(version[0]);
+      if (major <= 8) eslintEnabled = 8;
+      else if (major >= 9) eslintEnabled = 9;
+      else eslintEnabled = 8;
+      break;
+    case true:
+      eslintEnabled = 8;
+      break;
+    default:
+      eslintEnabled = rawEslintEnabled;
+  }
+  return {
+    enabled: eslintEnabled,
+    filePath: path.resolve(
+      wxtDir,
+      eslintEnabled === 9 ? "eslint-auto-imports.mjs" : "eslintrc-auto-import.json"
+    ),
+    globalsPropValue: true
+  };
+}
+async function resolveWxtModuleDir() {
+  const requireResolve = globalThis.require?.resolve ?? (await import("node:module")).default.createRequire(import.meta.url).resolve;
+  return path.resolve(requireResolve("wxt"), "../..");
+}
+async function isDirMissing(dir) {
+  return !await fs.exists(dir);
+}
+function logMissingDir(logger, name, expected) {
+  logger.warn(
+    `${name} directory not found: ./${normalizePath(
+      path.relative(process.cwd(), expected)
+    )}`
+  );
+}
+const COMMAND_MODES = {
+  build: "production",
+  serve: "development"
+};
+export async function mergeBuilderConfig(logger, inlineConfig, userConfig) {
+  const vite = await import("vite").catch((err) => {
+    logger.debug("Failed to import vite:", err);
+  });
+  if (vite) {
+    return {
+      vite: async (env) => {
+        const resolvedInlineConfig = await inlineConfig.vite?.(env) ?? {};
+        const resolvedUserConfig = await userConfig.vite?.(env) ?? {};
+        return vite.mergeConfig(resolvedUserConfig, resolvedInlineConfig);
+      }
+    };
+  }
+  throw Error("Builder not found. Make sure vite is installed.");
+}
+export async function resolveWxtUserModules(modulesDir, modules = []) {
+  const npmModules = await Promise.all(
+    modules.map(async (moduleId) => {
+      const mod = await import(
+        /* @vite-ignore */
+        moduleId
+      );
+      if (mod.default == null) {
+        throw Error("Module missing default export: " + moduleId);
+      }
+      return {
+        ...mod.default,
+        type: "node_module",
+        id: moduleId
+      };
+    })
+  );
+  const localModulePaths = await glob(["*.[tj]s", "*/index.[tj]s"], {
+    cwd: modulesDir,
+    onlyFiles: true
+  }).catch(() => []);
+  const localModules = await Promise.all(
+    localModulePaths.map(async (file) => {
+      const absolutePath = normalizePath(path.resolve(modulesDir, file));
+      const { config } = await loadConfig({
+        configFile: absolutePath,
+        globalRc: false,
+        rcFile: false,
+        packageJson: false,
+        envName: false,
+        dotenv: false
+      });
+      if (config == null)
+        throw Error(
+          `No config found for ${file}. Did you forget to add a default export?`
+        );
+      config.name ??= file;
+      return {
+        ...config,
+        type: "local",
+        id: absolutePath
+      };
+    })
+  );
+  return [...npmModules, ...localModules];
+}

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

@@ -0,0 +1,8 @@
+import { FsCache } from '../../types';
+/**
+ * A basic file system cache stored at `<srcDir>/.wxt/cache/<key>`. Just caches a string in a
+ * file for the given key.
+ *
+ * @param srcDir Absolute path to source directory. See `InternalConfig.srcDir`
+ */
+export declare function createFsCache(wxtDir: string): FsCache;

package/dist/core/utils/cache.mjs

@@ -0,0 +1,21 @@
+import fs, { ensureDir } from "fs-extra";
+import { dirname, resolve } from "path";
+import { writeFileIfDifferent } from "./fs.mjs";
+export function createFsCache(wxtDir) {
+  const getPath = (key) => resolve(wxtDir, "cache", encodeURIComponent(key));
+  return {
+    async set(key, value) {
+      const path = getPath(key);
+      await ensureDir(dirname(path));
+      await writeFileIfDifferent(path, value);
+    },
+    async get(key) {
+      const path = getPath(key);
+      try {
+        return await fs.readFile(path, "utf-8");
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}

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

@@ -0,0 +1,3 @@
+export declare function defineCommand<TArgs extends any[]>(cb: (...args: TArgs) => void | boolean | Promise<void | boolean>, options?: {
+    disableFinishedLog?: boolean;
+}): (...args: TArgs) => Promise<void>;

package/dist/core/utils/cli.mjs

@@ -0,0 +1,26 @@
+import { LogLevels, consola } from "consola";
+import { printHeader } from "./log/index.mjs";
+import { formatDuration } from "./time.mjs";
+export function defineCommand(cb, options) {
+  return async (...args) => {
+    const isDebug = !!args.find((arg) => arg?.debug);
+    if (isDebug) {
+      consola.level = LogLevels.debug;
+    }
+    const startTime = Date.now();
+    try {
+      printHeader();
+      const ongoing = await cb(...args);
+      if (!ongoing && !options?.disableFinishedLog)
+        consola.success(
+          `Finished in ${formatDuration(Date.now() - startTime)}`
+        );
+    } catch (err) {
+      consola.fail(
+        `Command failed after ${formatDuration(Date.now() - startTime)}`
+      );
+      consola.error(err);
+      process.exit(1);
+    }
+  };
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Module ID used to build the background in dev mode if the extension doesn't include a background
+ * script/service worker.
+ */
+export declare const VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";

package/dist/core/utils/constants.mjs

@@ -0,0 +1 @@
+export const VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";

package/dist/core/utils/content-scripts.d.ts

@@ -0,0 +1,11 @@
+import type { Manifest, Scripting } from 'wxt/browser';
+import { ContentScriptEntrypoint, ResolvedConfig } from '../../types';
+/**
+ * Returns a unique and consistent string hash based on a content scripts options.
+ *
+ * It is able to recognize default values,
+ */
+export declare function hashContentScriptOptions(options: ContentScriptEntrypoint['options']): string;
+export declare function mapWxtOptionsToContentScript(options: ContentScriptEntrypoint['options'], js: string[] | undefined, css: string[] | undefined): Manifest.ContentScript;
+export declare function mapWxtOptionsToRegisteredContentScript(options: ContentScriptEntrypoint['options'], js: string[] | undefined, css: string[] | undefined): Omit<Scripting.RegisteredContentScript, 'id'>;
+export declare function getContentScriptJs(config: ResolvedConfig, entrypoint: ContentScriptEntrypoint): string[];

package/dist/core/utils/content-scripts.mjs

@@ -0,0 +1,60 @@
+import { getEntrypointBundlePath } from "./entrypoints.mjs";
+export function hashContentScriptOptions(options) {
+  const simplifiedOptions = mapWxtOptionsToContentScript(
+    options,
+    void 0,
+    void 0
+  );
+  Object.keys(simplifiedOptions).forEach((key) => {
+    if (simplifiedOptions[key] == null) delete simplifiedOptions[key];
+  });
+  const withDefaults = {
+    exclude_globs: [],
+    exclude_matches: [],
+    include_globs: [],
+    match_about_blank: false,
+    run_at: "document_idle",
+    all_frames: false,
+    // @ts-expect-error - not in type
+    match_origin_as_fallback: false,
+    world: "ISOLATED",
+    ...simplifiedOptions
+  };
+  return JSON.stringify(
+    Object.entries(withDefaults).map(([key, value]) => {
+      if (Array.isArray(value)) return [key, value.sort()];
+      else return [key, value];
+    }).sort((l, r) => l[0].localeCompare(r[0]))
+  );
+}
+export function mapWxtOptionsToContentScript(options, js, css) {
+  return {
+    matches: options.matches,
+    all_frames: options.allFrames,
+    match_about_blank: options.matchAboutBlank,
+    exclude_globs: options.excludeGlobs,
+    exclude_matches: options.excludeMatches,
+    include_globs: options.includeGlobs,
+    run_at: options.runAt,
+    css,
+    js,
+    // @ts-expect-error: untyped chrome options
+    match_origin_as_fallback: options.matchOriginAsFallback,
+    world: options.world
+  };
+}
+export function mapWxtOptionsToRegisteredContentScript(options, js, css) {
+  return {
+    allFrames: options.allFrames,
+    excludeMatches: options.excludeMatches,
+    matches: options.matches,
+    runAt: options.runAt,
+    js,
+    css,
+    // @ts-expect-error: Chrome accepts this, not typed in webextension-polyfill (https://developer.chrome.com/docs/extensions/reference/scripting/#type-RegisteredContentScript)
+    world: options.world
+  };
+}
+export function getContentScriptJs(config, entrypoint) {
+  return [getEntrypointBundlePath(entrypoint, config.outDir, ".js")];
+}

package/dist/core/utils/content-security-policy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Directive names that make up CSPs. There are more, this is all I need for the plugin.
+ */
+export type CspDirective = 'default-src' | 'script-src' | 'object-src';
+export declare class ContentSecurityPolicy {
+    private static DIRECTIVE_ORDER;
+    data: Record<string, string[]>;
+    constructor(csp?: string);
+    /**
+     * Ensure a set of values are listed under a directive.
+     */
+    add(directive: CspDirective, ...newValues: string[]): ContentSecurityPolicy;
+    toString(): string;
+}

package/dist/core/utils/content-security-policy.mjs

@@ -0,0 +1,39 @@
+export class ContentSecurityPolicy {
+  static DIRECTIVE_ORDER = {
+    "default-src": 0,
+    "script-src": 1,
+    "object-src": 2
+  };
+  data;
+  constructor(csp) {
+    if (csp) {
+      const sections = csp.split(";").map((section) => section.trim());
+      this.data = sections.reduce((data, section) => {
+        const [key, ...values] = section.split(" ").map((item) => item.trim());
+        if (key) data[key] = values;
+        return data;
+      }, {});
+    } else {
+      this.data = {};
+    }
+  }
+  /**
+   * Ensure a set of values are listed under a directive.
+   */
+  add(directive, ...newValues) {
+    const values = this.data[directive] ?? [];
+    newValues.forEach((newValue) => {
+      if (!values.includes(newValue)) values.push(newValue);
+    });
+    this.data[directive] = values;
+    return this;
+  }
+  toString() {
+    const directives = Object.entries(this.data).sort(([l], [r]) => {
+      const lo = ContentSecurityPolicy.DIRECTIVE_ORDER[l] ?? 2;
+      const ro = ContentSecurityPolicy.DIRECTIVE_ORDER[r] ?? 2;
+      return lo - ro;
+    });
+    return directives.map((entry) => entry.flat().join(" ")).join("; ") + ";";
+  }
+}

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

@@ -0,0 +1,25 @@
+import { Entrypoint, PerBrowserOption, ResolvedPerBrowserOptions, TargetBrowser } from '../../types';
+export declare function getEntrypointName(entrypointsDir: string, inputPath: string): string;
+export declare function getEntrypointOutputFile(entrypoint: Entrypoint, ext: string): string;
+/**
+ * Return's the entrypoint's output path relative to the output directory. Used for paths in the
+ * manifest and rollup's bundle.
+ */
+export declare function getEntrypointBundlePath(entrypoint: Entrypoint, outDir: string, ext: string): string;
+/**
+ * Given an entrypoint option, resolve it's value based on a target browser.
+ */
+export declare function resolvePerBrowserOption<T>(option: PerBrowserOption<T>, browser: TargetBrowser): T;
+/**
+ * Given an entrypoint option, resolve it's value based on a target browser.
+ *
+ * defaultIcon is special, it's the only key that's a record, which can confuse this function. So
+ * it's been manually excluded from resolution.
+ */
+export declare function resolvePerBrowserOptions<T extends Record<string, any>, TKeys extends keyof T>(options: T, browser: TargetBrowser): ResolvedPerBrowserOptions<T, TKeys>;
+/**
+ * Returns true when the entrypoint is an HTML entrypoint.
+ *
+ * Naively just checking the file extension of the input path.
+ */
+export declare function isHtmlEntrypoint(entrypoint: Entrypoint): boolean;

package/dist/core/utils/entrypoints.mjs

@@ -0,0 +1,31 @@
+import path, { relative, resolve } from "node:path";
+import { normalizePath } from "./paths.mjs";
+export function getEntrypointName(entrypointsDir, inputPath) {
+  const relativePath = path.relative(entrypointsDir, inputPath);
+  const name = relativePath.split(/[\.\/\\]/, 2)[0];
+  return name;
+}
+export function getEntrypointOutputFile(entrypoint, ext) {
+  return resolve(entrypoint.outputDir, `${entrypoint.name}${ext}`);
+}
+export function getEntrypointBundlePath(entrypoint, outDir, ext) {
+  return normalizePath(
+    relative(outDir, getEntrypointOutputFile(entrypoint, ext))
+  );
+}
+export function resolvePerBrowserOption(option, browser) {
+  if (typeof option === "object" && !Array.isArray(option))
+    return option[browser];
+  return option;
+}
+export function resolvePerBrowserOptions(options, browser) {
+  return Object.fromEntries(
+    Object.entries(options).map(([key, value]) => [
+      key,
+      key === "defaultIcon" ? value : resolvePerBrowserOption(value, browser)
+    ])
+  );
+}
+export function isHtmlEntrypoint(entrypoint) {
+  return entrypoint.inputPath.endsWith(".html");
+}

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

@@ -0,0 +1 @@
+export declare function getEslintVersion(): Promise<string[]>;

package/dist/core/utils/eslint.mjs

@@ -0,0 +1,11 @@
+export async function getEslintVersion() {
+  try {
+    const require = (await import("node:module")).default.createRequire(
+      import.meta.url
+    );
+    const { ESLint } = require("eslint");
+    return ESLint.version?.split(".") ?? [];
+  } catch (error) {
+    return [];
+  }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Only write the contents to a file if it results in a change. This prevents unnecessary file
+ * watchers from being triggered, like WXT's dev server or the TS language server in editors.
+ *
+ * @param file The file to write to.
+ * @param newContents The new text content to write.
+ */
+export declare function writeFileIfDifferent(file: string, newContents: string): Promise<void>;
+/**
+ * Get all the files in the project's public directory. Returned paths are relative to the
+ * `config.publicDir`.
+ */
+export declare function getPublicFiles(): Promise<string[]>;

package/dist/core/utils/fs.mjs

@@ -0,0 +1,15 @@
+import fs from "fs-extra";
+import glob from "fast-glob";
+import { unnormalizePath } from "./paths.mjs";
+import { wxt } from "../wxt.mjs";
+export async function writeFileIfDifferent(file, newContents) {
+  const existingContents = await fs.readFile(file, "utf-8").catch(() => void 0);
+  if (existingContents !== newContents) {
+    await fs.writeFile(file, newContents);
+  }
+}
+export async function getPublicFiles() {
+  if (!await fs.exists(wxt.config.publicDir)) return [];
+  const files = await glob("**/*", { cwd: wxt.config.publicDir });
+  return files.map(unnormalizePath);
+}

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

@@ -0,0 +1,11 @@
+import { ResolvedConfig } from '../../types';
+export declare function getGlobals(config: ResolvedConfig): Array<{
+    name: string;
+    value: any;
+    type: string;
+}>;
+export declare function getEntrypointGlobals(entrypointName: string): {
+    name: string;
+    value: string;
+    type: string;
+}[];