wxt 0.18.15 → 0.19.0

package/dist/sandbox.d.ts

@@ -1,16 +0,0 @@
-import { U as UnlistedScriptDefinition, B as BackgroundDefinition, C as ContentScriptDefinition, W as WxtPlugin } from './define-app-config-bg54F_lV.js';
-export { a as WxtAppConfig, d as defineAppConfig } from './define-app-config-bg54F_lV.js';
-export * from '@webext-core/match-patterns';
-import 'webextension-polyfill';
-
-declare function defineUnlistedScript(main: () => void): UnlistedScriptDefinition;
-declare function defineUnlistedScript(definition: UnlistedScriptDefinition): UnlistedScriptDefinition;
-
-declare function defineBackground(main: () => void): BackgroundDefinition;
-declare function defineBackground(definition: BackgroundDefinition): BackgroundDefinition;
-
-declare function defineContentScript(definition: ContentScriptDefinition): ContentScriptDefinition;
-
-declare function defineWxtPlugin(plugin: WxtPlugin): WxtPlugin;
-
-export { defineBackground, defineContentScript, defineUnlistedScript, defineWxtPlugin };

package/dist/sandbox.js

@@ -1,36 +0,0 @@
-// src/sandbox/define-unlisted-script.ts
-function defineUnlistedScript(arg) {
-  if (typeof arg === "function") return { main: arg };
-  return arg;
-}
-
-// src/sandbox/define-background.ts
-function defineBackground(arg) {
-  if (typeof arg === "function") return { main: arg };
-  return arg;
-}
-
-// src/sandbox/define-content-script.ts
-function defineContentScript(definition) {
-  return definition;
-}
-
-// src/sandbox/define-wxt-plugin.ts
-function defineWxtPlugin(plugin) {
-  return plugin;
-}
-
-// src/sandbox/define-app-config.ts
-function defineAppConfig(config) {
-  return config;
-}
-
-// src/sandbox/index.ts
-export * from "@webext-core/match-patterns";
-export {
-  defineAppConfig,
-  defineBackground,
-  defineContentScript,
-  defineUnlistedScript,
-  defineWxtPlugin
-};

package/dist/storage.cjs

@@ -1,439 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/storage.ts
-var storage_exports = {};
-__export(storage_exports, {
-  storage: () => storage
-});
-module.exports = __toCommonJS(storage_exports);
-
-// src/browser.ts
-var import_webextension_polyfill = __toESM(require("webextension-polyfill"), 1);
-var browser = import_webextension_polyfill.default;
-
-// src/storage.ts
-var import_lite = require("dequal/lite");
-
-// src/sandbox/utils/logger.ts
-var import_meta = {};
-function print(method, ...args) {
-  if (import_meta.env.MODE === "production") return;
-  if (typeof args[0] === "string") {
-    const message = args.shift();
-    method(`[wxt] ${message}`, ...args);
-  } else {
-    method("[wxt]", ...args);
-  }
-}
-var logger = {
-  debug: (...args) => print(console.debug, ...args),
-  log: (...args) => print(console.log, ...args),
-  warn: (...args) => print(console.warn, ...args),
-  error: (...args) => print(console.error, ...args)
-};
-
-// src/core/utils/arrays.ts
-function toArray(a) {
-  return Array.isArray(a) ? a : [a];
-}
-
-// src/storage.ts
-var storage = createStorage();
-function createStorage() {
-  const drivers = {
-    local: createDriver("local"),
-    session: createDriver("session"),
-    sync: createDriver("sync"),
-    managed: createDriver("managed")
-  };
-  const getDriver = (area) => {
-    const driver = drivers[area];
-    if (driver == null) {
-      const areaNames = Object.keys(drivers).join(", ");
-      throw Error(`Invalid area "${area}". Options: ${areaNames}`);
-    }
-    return driver;
-  };
-  const resolveKey = (key) => {
-    const deliminatorIndex = key.indexOf(":");
-    const driverArea = key.substring(0, deliminatorIndex);
-    const driverKey = key.substring(deliminatorIndex + 1);
-    if (driverKey == null)
-      throw Error(
-        `Storage key should be in the form of "area:key", but received "${key}"`
-      );
-    return {
-      driverArea,
-      driverKey,
-      driver: getDriver(driverArea)
-    };
-  };
-  const getMetaKey = (key) => key + "$";
-  const getValueOrDefault = (value, defaultValue) => value ?? defaultValue ?? null;
-  const getMetaValue = (properties) => typeof properties === "object" && !Array.isArray(properties) ? properties : {};
-  const getItem = async (driver, driverKey, opts) => {
-    const res = await driver.getItem(driverKey);
-    return getValueOrDefault(res, opts?.defaultValue);
-  };
-  const getMeta = async (driver, driverKey) => {
-    const metaKey = getMetaKey(driverKey);
-    const res = await driver.getItem(metaKey);
-    return getMetaValue(res);
-  };
-  const setItem = async (driver, driverKey, value) => {
-    await driver.setItem(driverKey, value ?? null);
-  };
-  const setMeta = async (driver, driverKey, properties) => {
-    const metaKey = getMetaKey(driverKey);
-    const existingFields = getMetaValue(await driver.getItem(metaKey));
-    const newFields = { ...existingFields };
-    Object.entries(properties).forEach(([key, value]) => {
-      if (value == null) {
-        delete newFields[key];
-      } else {
-        newFields[key] = value;
-      }
-    });
-    await driver.setItem(metaKey, newFields);
-  };
-  const removeItem = async (driver, driverKey, opts) => {
-    await driver.removeItem(driverKey);
-    if (opts?.removeMeta) {
-      const metaKey = getMetaKey(driverKey);
-      await driver.removeItem(metaKey);
-    }
-  };
-  const removeMeta = async (driver, driverKey, properties) => {
-    const metaKey = getMetaKey(driverKey);
-    if (properties == null) {
-      await driver.removeItem(metaKey);
-    } else {
-      const newFields = getMetaValue(await driver.getItem(metaKey));
-      toArray(properties).forEach((field) => delete newFields[field]);
-      await driver.setItem(metaKey, newFields);
-    }
-  };
-  const watch = (driver, driverKey, cb) => {
-    return driver.watch(driverKey, cb);
-  };
-  const storage2 = {
-    getItem: async (key, opts) => {
-      const { driver, driverKey } = resolveKey(key);
-      return await getItem(driver, driverKey, opts);
-    },
-    getItems: async (keys) => {
-      const areaToKeyMap = /* @__PURE__ */ new Map();
-      const keyToOptsMap = /* @__PURE__ */ new Map();
-      keys.forEach((key) => {
-        let keyStr;
-        let opts;
-        if (typeof key === "string") {
-          keyStr = key;
-        } else {
-          keyStr = key.key;
-          opts = key.options;
-        }
-        const { driverArea, driverKey } = resolveKey(keyStr);
-        const keys2 = areaToKeyMap.get(driverArea) ?? [];
-        areaToKeyMap.set(driverArea, keys2.concat(driverKey));
-        keyToOptsMap.set(keyStr, opts);
-      });
-      const results = await Promise.all(
-        Array.from(areaToKeyMap.entries()).map(async ([driverArea, keys2]) => {
-          const driverResults = await drivers[driverArea].getItems(keys2);
-          return driverResults.map((driverResult) => {
-            const key = `${driverArea}:${driverResult.key}`;
-            const value = getValueOrDefault(
-              driverResult.value,
-              keyToOptsMap.get(key)?.defaultValue
-            );
-            return { key, value };
-          });
-        })
-      );
-      return results.flat();
-    },
-    getMeta: async (key) => {
-      const { driver, driverKey } = resolveKey(key);
-      return await getMeta(driver, driverKey);
-    },
-    setItem: async (key, value) => {
-      const { driver, driverKey } = resolveKey(key);
-      await setItem(driver, driverKey, value);
-    },
-    setItems: async (values) => {
-      const areaToKeyValueMap = /* @__PURE__ */ new Map();
-      values.forEach(({ key, value }) => {
-        const { driverArea, driverKey } = resolveKey(key);
-        const values2 = areaToKeyValueMap.get(driverArea) ?? [];
-        areaToKeyValueMap.set(
-          driverArea,
-          values2.concat({ key: driverKey, value })
-        );
-      });
-      await Promise.all(
-        Array.from(areaToKeyValueMap.entries()).map(
-          async ([driverArea, values2]) => {
-            const driver = getDriver(driverArea);
-            await driver.setItems(values2);
-          }
-        )
-      );
-    },
-    setMeta: async (key, properties) => {
-      const { driver, driverKey } = resolveKey(key);
-      await setMeta(driver, driverKey, properties);
-    },
-    removeItem: async (key, opts) => {
-      const { driver, driverKey } = resolveKey(key);
-      await removeItem(driver, driverKey, opts);
-    },
-    removeItems: async (keys) => {
-      const areaToKeysMap = /* @__PURE__ */ new Map();
-      keys.forEach((key) => {
-        let keyStr;
-        let opts;
-        if (typeof key === "string") {
-          keyStr = key;
-        } else {
-          keyStr = key.key;
-          opts = key.options;
-        }
-        const { driverArea, driverKey } = resolveKey(keyStr);
-        const areaKeys = areaToKeysMap.get(driverArea) ?? [];
-        areaKeys.push(driverKey);
-        if (opts?.removeMeta) {
-          areaKeys.push(getMetaKey(driverKey));
-        }
-        areaToKeysMap.set(driverArea, areaKeys);
-      });
-      await Promise.all(
-        Array.from(areaToKeysMap.entries()).map(async ([driverArea, keys2]) => {
-          const driver = getDriver(driverArea);
-          await driver.removeItems(keys2);
-        })
-      );
-    },
-    removeMeta: async (key, properties) => {
-      const { driver, driverKey } = resolveKey(key);
-      await removeMeta(driver, driverKey, properties);
-    },
-    snapshot: async (base, opts) => {
-      const driver = getDriver(base);
-      const data = await driver.snapshot();
-      opts?.excludeKeys?.forEach((key) => {
-        delete data[key];
-        delete data[getMetaKey(key)];
-      });
-      return data;
-    },
-    restoreSnapshot: async (base, data) => {
-      const driver = getDriver(base);
-      await driver.restoreSnapshot(data);
-    },
-    watch: (key, cb) => {
-      const { driver, driverKey } = resolveKey(key);
-      return watch(driver, driverKey, cb);
-    },
-    unwatch() {
-      Object.values(drivers).forEach((driver) => {
-        driver.unwatch();
-      });
-    },
-    defineItem: (key, opts) => {
-      const { driver, driverKey } = resolveKey(key);
-      const { version: targetVersion = 1, migrations = {} } = opts ?? {};
-      if (targetVersion < 1) {
-        throw Error(
-          "Storage item version cannot be less than 1. Initial versions should be set to 1, not 0."
-        );
-      }
-      const migrate = async () => {
-        const driverMetaKey = getMetaKey(driverKey);
-        const [{ value }, { value: meta }] = await driver.getItems([
-          driverKey,
-          driverMetaKey
-        ]);
-        if (value == null) return;
-        const currentVersion = meta?.v ?? 1;
-        if (currentVersion > targetVersion) {
-          throw Error(
-            `Version downgrade detected (v${currentVersion} -> v${targetVersion}) for "${key}"`
-          );
-        }
-        logger.debug(
-          `Running storage migration for ${key}: v${currentVersion} -> v${targetVersion}`
-        );
-        const migrationsToRun = Array.from(
-          { length: targetVersion - currentVersion },
-          (_, i) => currentVersion + i + 1
-        );
-        let migratedValue = value;
-        for (const migrateToVersion of migrationsToRun) {
-          migratedValue = await migrations?.[migrateToVersion]?.(migratedValue) ?? migratedValue;
-        }
-        await driver.setItems([
-          { key: driverKey, value: migratedValue },
-          { key: driverMetaKey, value: { ...meta, v: targetVersion } }
-        ]);
-        logger.debug(
-          `Storage migration completed for ${key} v${targetVersion}`,
-          { migratedValue }
-        );
-      };
-      const migrationsDone = opts?.migrations == null ? Promise.resolve() : migrate().catch((err) => {
-        logger.error(`Migration failed for ${key}`, err);
-      });
-      const getDefaultValue = () => opts?.defaultValue ?? null;
-      return {
-        get defaultValue() {
-          return getDefaultValue();
-        },
-        getValue: async () => {
-          await migrationsDone;
-          return await getItem(driver, driverKey, opts);
-        },
-        getMeta: async () => {
-          await migrationsDone;
-          return await getMeta(driver, driverKey);
-        },
-        setValue: async (value) => {
-          await migrationsDone;
-          return await setItem(driver, driverKey, value);
-        },
-        setMeta: async (properties) => {
-          await migrationsDone;
-          return await setMeta(driver, driverKey, properties);
-        },
-        removeValue: async (opts2) => {
-          await migrationsDone;
-          return await removeItem(driver, driverKey, opts2);
-        },
-        removeMeta: async (properties) => {
-          await migrationsDone;
-          return await removeMeta(driver, driverKey, properties);
-        },
-        watch: (cb) => watch(
-          driver,
-          driverKey,
-          (newValue, oldValue) => cb(newValue ?? getDefaultValue(), oldValue ?? getDefaultValue())
-        ),
-        migrate
-      };
-    }
-  };
-  return storage2;
-}
-function createDriver(storageArea) {
-  const getStorageArea = () => {
-    if (browser.runtime == null) {
-      throw Error(
-        [
-          "'wxt/storage' must be loaded in a web extension environment",
-          "\n - If thrown during a build, see https://github.com/wxt-dev/wxt/issues/371",
-          " - If thrown during tests, mock 'wxt/browser' correctly. See https://wxt.dev/guide/go-further/testing.html\n"
-        ].join("\n")
-      );
-    }
-    if (browser.storage == null) {
-      throw Error(
-        "You must add the 'storage' permission to your manifest to use 'wxt/storage'"
-      );
-    }
-    const area = browser.storage[storageArea];
-    if (area == null)
-      throw Error(`"browser.storage.${storageArea}" is undefined`);
-    return area;
-  };
-  const watchListeners = /* @__PURE__ */ new Set();
-  return {
-    getItem: async (key) => {
-      const res = await getStorageArea().get(key);
-      return res[key];
-    },
-    getItems: async (keys) => {
-      const result = await getStorageArea().get(keys);
-      return keys.map((key) => ({ key, value: result[key] ?? null }));
-    },
-    setItem: async (key, value) => {
-      if (value == null) {
-        await getStorageArea().remove(key);
-      } else {
-        await getStorageArea().set({ [key]: value });
-      }
-    },
-    setItems: async (values) => {
-      const map = values.reduce(
-        (map2, { key, value }) => {
-          map2[key] = value;
-          return map2;
-        },
-        {}
-      );
-      await getStorageArea().set(map);
-    },
-    removeItem: async (key) => {
-      await getStorageArea().remove(key);
-    },
-    removeItems: async (keys) => {
-      await getStorageArea().remove(keys);
-    },
-    snapshot: async () => {
-      return await getStorageArea().get();
-    },
-    restoreSnapshot: async (data) => {
-      await getStorageArea().set(data);
-    },
-    watch(key, cb) {
-      const listener = (changes) => {
-        const change = changes[key];
-        if (change == null) return;
-        if ((0, import_lite.dequal)(change.newValue, change.oldValue)) return;
-        cb(change.newValue ?? null, change.oldValue ?? null);
-      };
-      getStorageArea().onChanged.addListener(listener);
-      watchListeners.add(listener);
-      return () => {
-        getStorageArea().onChanged.removeListener(listener);
-        watchListeners.delete(listener);
-      };
-    },
-    unwatch() {
-      watchListeners.forEach((listener) => {
-        getStorageArea().onChanged.removeListener(listener);
-      });
-      watchListeners.clear();
-    }
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  storage
-});

package/dist/storage.d.cts

@@ -1,200 +0,0 @@
-declare const storage: WxtStorage;
-interface WxtStorage {
-    /**
-     * Get an item from storage, or return `null` if it doesn't exist.
-     *
-     * @example
-     * await storage.getItem<number>("local:installDate");
-     */
-    getItem<T>(key: StorageItemKey, opts?: GetItemOptions<T>): Promise<T | null>;
-    /**
-     * Get multiple items from storage. The return order is guaranteed to be the same as the order
-     * requested.
-     *
-     * @example
-     * await storage.getItems(["local:installDate", "session:someCounter"]);
-     */
-    getItems(keys: Array<StorageItemKey | {
-        key: StorageItemKey;
-        options?: GetItemOptions<any>;
-    }>): Promise<Array<{
-        key: StorageItemKey;
-        value: any;
-    }>>;
-    /**
-     * Return an object containing metadata about the key. Object is stored at `key + "$"`. If value
-     * is not an object, it returns an empty object.
-     *
-     * @example
-     * await storage.getMeta("local:installDate");
-     */
-    getMeta<T extends Record<string, unknown>>(key: StorageItemKey): Promise<T>;
-    /**
-     * Set a value in storage. Setting a value to `null` or `undefined` is equivalent to calling
-     * `removeItem`.
-     *
-     * @example
-     * await storage.setItem<number>("local:installDate", Date.now());
-     */
-    setItem<T>(key: StorageItemKey, value: T | null): Promise<void>;
-    /**
-     * Set multiple values in storage. If a value is set to `null` or `undefined`, the key is removed.
-     *
-     * @example
-     * await storage.setItem([
-     *   { key: "local:installDate", value: Date.now() },
-     *   { key: "session:someCounter, value: 5 },
-     * ]);
-     */
-    setItems(values: Array<{
-        key: StorageItemKey;
-        value: any;
-    }>): Promise<void>;
-    /**
-     * Sets metadata properties. If some properties are already set, but are not included in the
-     * `properties` parameter, they will not be removed.
-     *
-     * @example
-     * await storage.setMeta("local:installDate", { appVersion });
-     */
-    setMeta<T extends Record<string, unknown>>(key: StorageItemKey, properties: T | null): Promise<void>;
-    /**
-     * Removes an item from storage.
-     *
-     * @example
-     * await storage.removeItem("local:installDate");
-     */
-    removeItem(key: StorageItemKey, opts?: RemoveItemOptions): Promise<void>;
-    /**
-     * Remove a list of keys from storage.
-     */
-    removeItems(keys: Array<StorageItemKey | {
-        key: StorageItemKey;
-        options?: RemoveItemOptions;
-    }>): Promise<void>;
-    /**
-     * Remove the entire metadata for a key, or specific properties by name.
-     *
-     * @example
-     * // Remove all metadata properties from the item
-     * await storage.removeMeta("local:installDate");
-     *
-     * // Remove only specific the "v" field
-     * await storage.removeMeta("local:installDate", "v")
-     */
-    removeMeta(key: StorageItemKey, properties?: string | string[]): Promise<void>;
-    /**
-     * Return all the items in storage.
-     */
-    snapshot(base: StorageArea, opts?: SnapshotOptions): Promise<Record<string, unknown>>;
-    /**
-     * Restores the results of `snapshot`. If new properties have been saved since the snapshot, they are
-     * not overridden. Only values existing in the snapshot are overridden.
-     */
-    restoreSnapshot(base: StorageArea, data: any): Promise<void>;
-    /**
-     * Watch for changes to a specific key in storage.
-     */
-    watch<T>(key: StorageItemKey, cb: WatchCallback<T | null>): Unwatch;
-    /**
-     * Remove all watch listeners.
-     */
-    unwatch(): void;
-    /**
-     * Define a storage item with a default value, type, or versioning.
-     *
-     * Read full docs: https://wxt.dev/guide/extension-apis/storage.html#defining-storage-items
-     */
-    defineItem<TValue, TMetadata extends Record<string, unknown> = {}>(key: StorageItemKey): WxtStorageItem<TValue | null, TMetadata>;
-    defineItem<TValue, TMetadata extends Record<string, unknown> = {}>(key: StorageItemKey, options: WxtStorageItemOptions<TValue>): WxtStorageItem<TValue, TMetadata>;
-}
-interface WxtStorageItem<TValue, TMetadata extends Record<string, unknown>> {
-    defaultValue: TValue;
-    /**
-     * Get the latest value from storage.
-     */
-    getValue(): Promise<TValue>;
-    /**
-     * Get metadata.
-     */
-    getMeta(): Promise<NullablePartial<TMetadata>>;
-    /**
-     * Set the value in storage.
-     */
-    setValue(value: TValue): Promise<void>;
-    /**
-     * Set metadata properties.
-     */
-    setMeta(properties: NullablePartial<TMetadata>): Promise<void>;
-    /**
-     * Remove the value from storage.
-     */
-    removeValue(opts?: RemoveItemOptions): Promise<void>;
-    /**
-     * Remove all metadata or certain properties from metadata.
-     */
-    removeMeta(properties?: string[]): Promise<void>;
-    /**
-     * Listen for changes to the value in storage.
-     */
-    watch(cb: WatchCallback<TValue>): Unwatch;
-    /**
-     * If there are migrations defined on the storage item, migrate to the latest version.
-     *
-     * **This function is ran automatically whenever the extension updates**, so you don't have to call it
-     * manually.
-     */
-    migrate(): Promise<void>;
-}
-type StorageArea = 'local' | 'session' | 'sync' | 'managed';
-type StorageItemKey = `${StorageArea}:${string}`;
-interface GetItemOptions<T> {
-    /**
-     * Value returned from `getValue` when it would otherwise return null.
-     */
-    defaultValue?: T;
-}
-interface RemoveItemOptions {
-    /**
-     * Optionally remove metadata when deleting a key.
-     *
-     * @default false
-     */
-    removeMeta?: boolean;
-}
-interface SnapshotOptions {
-    /**
-     * Exclude a list of keys. The storage area prefix should be removed since the snapshot is for a
-     * specific storage area already.
-     */
-    excludeKeys?: string[];
-}
-interface WxtStorageItemOptions<T> {
-    defaultValue: T;
-    /**
-     * Provide a version number for the storage item to enable migrations. When changing the version
-     * in the future, migration functions will be ran on application startup.
-     */
-    version?: number;
-    /**
-     * A map of version numbers to the functions used to migrate the data to that version.
-     */
-    migrations?: Record<number, (oldValue: any) => any>;
-}
-/**
- * Same as `Partial`, but includes `| null`. It makes all the properties of an object optional and
- * nullable.
- */
-type NullablePartial<T> = {
-    [key in keyof T]+?: T[key] | undefined | null;
-};
-/**
- * Callback called when a value in storage is changed.
- */
-type WatchCallback<T> = (newValue: T, oldValue: T) => void;
-/**
- * Call to remove a watch listener
- */
-type Unwatch = () => void;
-
-export { type GetItemOptions, type NullablePartial, type RemoveItemOptions, type SnapshotOptions, type StorageArea, type StorageItemKey, type Unwatch, type WatchCallback, type WxtStorage, type WxtStorageItem, type WxtStorageItemOptions, storage };