wxt 0.20.13 → 0.20.15

package/dist/utils/content-script-ui/types.d.mts

@@ -0,0 +1,107 @@
+//#region src/utils/content-script-ui/types.d.ts
+/** @module wxt/utils/content-script-ui/types */
+interface ContentScriptUi<TMounted> extends MountFunctions {
+  mounted: TMounted | undefined;
+}
+type ContentScriptUiOptions<TMounted> = ContentScriptPositioningOptions & ContentScriptAnchoredOptions & {
+  /**
+   * Callback called before the UI is removed from the webpage. Use to cleanup your UI, like
+   * unmounting your Vue or React apps.
+   *
+   * Note that this callback is called only when `ui.remove` is called - that means it is
+   * not called automatically when the anchor is removed, unless you use `autoMount`.
+   */
+  onRemove?: (mounted: TMounted | undefined) => void;
+};
+type ContentScriptOverlayAlignment = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/**
+ * ![Visualization of different append modes](https://wxt.dev/content-script-ui-append.png)
+ */
+type ContentScriptAppendMode = 'last' | 'first' | 'replace' | 'before' | 'after' | ((anchor: Element, ui: Element) => void);
+interface ContentScriptInlinePositioningOptions {
+  position: 'inline';
+}
+interface ContentScriptOverlayPositioningOptions {
+  position: 'overlay';
+  /**
+   * The `z-index` used on the `wrapper` element. Set to a positive number to show your UI over website
+   * content.
+   */
+  zIndex?: number;
+  /**
+   * When using `type: "overlay"`, the mounted element is 0px by 0px in size. Alignment specifies
+   * which corner is aligned with that 0x0 pixel space.
+   *
+   * ![Visualization of alignment options](https://wxt.dev/content-script-ui-alignment.png)
+   *
+   * @default "top-left"
+   */
+  alignment?: ContentScriptOverlayAlignment;
+}
+interface ContentScriptModalPositioningOptions {
+  position: 'modal';
+  /**
+   * The `z-index` used on the `shadowHost`. Set to a positive number to show your UI over website
+   * content.
+   */
+  zIndex?: number;
+}
+/**
+ * Choose between `"inline"`, `"overlay"`, or `"modal"` positions.
+ *
+ * ![Visualization of different types](https://wxt.dev/content-script-ui-position.png)
+ */
+type ContentScriptPositioningOptions = ContentScriptInlinePositioningOptions | ContentScriptOverlayPositioningOptions | ContentScriptModalPositioningOptions;
+interface ContentScriptAnchoredOptions {
+  /**
+   * A CSS selector, XPath expression, element, or function that returns one of the three. Along with `append`, the
+   * `anchor` dictates where in the page the UI will be added.
+   */
+  anchor?: string | Element | null | undefined | (() => string | Element | null | undefined);
+  /**
+   * In combination with `anchor`, decide how to add the UI to the DOM.
+   *
+   * - `"last"` (default) - Add the UI as the last child of the `anchor` element
+   * - `"first"` - Add the UI as the first child of the `anchor` element
+   * - `"replace"` - Replace the `anchor` element with the UI.
+   * - `"before"` - Add the UI as the sibling before the `anchor` element
+   * - `"after"` - Add the UI as the sibling after the `anchor` element
+   * - `(anchor, ui) => void` - Customizable function that let's you add the UI to the DOM
+   */
+  append?: ContentScriptAppendMode | ((anchor: Element, ui: Element) => void);
+}
+interface BaseMountFunctions {
+  /**
+   * Function that mounts or remounts the UI on the page.
+   */
+  mount: () => void;
+  /**
+   * Function that removes the UI from the webpage.
+   */
+  remove: () => void;
+}
+interface MountFunctions extends BaseMountFunctions {
+  /**
+   * Call `ui.autoMount()` to automatically mount and remove the UI as the anchor is dynamically added/removed by the webpage.
+   */
+  autoMount: (options?: AutoMountOptions) => void;
+}
+type AutoMountOptions = {
+  /**
+   * When true, only mount and unmount a UI once.
+   */
+  once?: boolean;
+  /**
+   * The callback triggered when `StopAutoMount` is called.
+   */
+  onStop?: () => void;
+};
+type StopAutoMount = () => void;
+interface AutoMount {
+  /**
+   * Stop watching the anchor element for changes, but keep the UI mounted.
+   */
+  stopAutoMount: StopAutoMount;
+}
+//#endregion
+export { AutoMount, AutoMountOptions, BaseMountFunctions, ContentScriptAnchoredOptions, ContentScriptAppendMode, ContentScriptInlinePositioningOptions, ContentScriptModalPositioningOptions, ContentScriptOverlayAlignment, ContentScriptOverlayPositioningOptions, ContentScriptPositioningOptions, ContentScriptUi, ContentScriptUiOptions, MountFunctions, StopAutoMount };

package/dist/utils/content-script-ui/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/utils/{define-app-config.d.ts → define-app-config.d.mts}

@@ -1,6 +1,6 @@
+//#region src/utils/define-app-config.d.ts
 /** @module wxt/utils/define-app-config */
-export interface WxtAppConfig {
-}
+interface WxtAppConfig {}
 /**
  * Runtime app config defined in `<srcDir>/app.config.ts`.
  *
@@ -17,4 +17,6 @@ export interface WxtAppConfig {
  * }
  * ```
  */
-export declare function defineAppConfig(config: WxtAppConfig): WxtAppConfig;
+declare function defineAppConfig(config: WxtAppConfig): WxtAppConfig;
+//#endregion
+export { WxtAppConfig, defineAppConfig };

package/dist/utils/define-app-config.mjs

@@ -1,3 +1,23 @@
-export function defineAppConfig(config) {
-  return config;
+//#region src/utils/define-app-config.ts
+/**
+* Runtime app config defined in `<srcDir>/app.config.ts`.
+*
+* You can add fields to this interface via ["Module Augmentation"](https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation):
+*
+* ```ts
+* // app.config.ts
+* import 'wxt/utils/define-app-config';
+*
+* declare module "wxt/utils/define-app-config" {
+*   export interface WxtAppConfig {
+*     analytics: AnalyticsConfig
+*   }
+* }
+* ```
+*/
+function defineAppConfig(config) {
+	return config;
 }
+
+//#endregion
+export { defineAppConfig };

package/dist/utils/define-background.d.mts

@@ -0,0 +1,7 @@
+import { BackgroundDefinition } from "../types.mjs";
+
+//#region src/utils/define-background.d.ts
+declare function defineBackground(main: () => void): BackgroundDefinition;
+declare function defineBackground(definition: BackgroundDefinition): BackgroundDefinition;
+//#endregion
+export { defineBackground };

package/dist/utils/define-background.mjs

@@ -1,4 +1,8 @@
-export function defineBackground(arg) {
-  if (arg == null || typeof arg === "function") return { main: arg };
-  return arg;
+//#region src/utils/define-background.ts
+function defineBackground(arg) {
+	if (arg == null || typeof arg === "function") return { main: arg };
+	return arg;
 }
+
+//#endregion
+export { defineBackground };

package/dist/utils/define-content-script.d.mts

@@ -0,0 +1,6 @@
+import { ContentScriptDefinition } from "../types.mjs";
+
+//#region src/utils/define-content-script.d.ts
+declare function defineContentScript(definition: ContentScriptDefinition): ContentScriptDefinition;
+//#endregion
+export { defineContentScript };

package/dist/utils/define-content-script.mjs

@@ -1,3 +1,7 @@
-export function defineContentScript(definition) {
-  return definition;
+//#region src/utils/define-content-script.ts
+function defineContentScript(definition) {
+	return definition;
 }
+
+//#endregion
+export { defineContentScript };

package/dist/utils/define-unlisted-script.d.mts

@@ -0,0 +1,7 @@
+import { UnlistedScriptDefinition } from "../types.mjs";
+
+//#region src/utils/define-unlisted-script.d.ts
+declare function defineUnlistedScript(main: () => void): UnlistedScriptDefinition;
+declare function defineUnlistedScript(definition: UnlistedScriptDefinition): UnlistedScriptDefinition;
+//#endregion
+export { defineUnlistedScript };

package/dist/utils/define-unlisted-script.mjs

@@ -1,4 +1,8 @@
-export function defineUnlistedScript(arg) {
-  if (arg == null || typeof arg === "function") return { main: arg };
-  return arg;
+//#region src/utils/define-unlisted-script.ts
+function defineUnlistedScript(arg) {
+	if (arg == null || typeof arg === "function") return { main: arg };
+	return arg;
 }
+
+//#endregion
+export { defineUnlistedScript };

package/dist/utils/define-wxt-plugin.d.mts

@@ -0,0 +1,6 @@
+import { WxtPlugin } from "../types.mjs";
+
+//#region src/utils/define-wxt-plugin.d.ts
+declare function defineWxtPlugin(plugin: WxtPlugin): WxtPlugin;
+//#endregion
+export { defineWxtPlugin };

package/dist/utils/define-wxt-plugin.mjs

@@ -1,3 +1,7 @@
-export function defineWxtPlugin(plugin) {
-  return plugin;
+//#region src/utils/define-wxt-plugin.ts
+function defineWxtPlugin(plugin) {
+	return plugin;
 }
+
+//#endregion
+export { defineWxtPlugin };

package/dist/utils/inject-script.d.mts

@@ -0,0 +1,41 @@
+import * as wxt_browser0 from "wxt/browser";
+
+//#region src/utils/inject-script.d.ts
+type ScriptPublicPath = Extract<wxt_browser0.PublicPath, `${string}.js`>;
+/**
+ * This function can only be called inside content scripts.
+ *
+ * Inject an unlisted script into the page. Scripts are added to the `<head>`
+ * element or `document.documentElement` if there is no head.
+ *
+ * Make sure to add the injected script to your manifest's
+ * `web_accessible_resources`.
+ *
+ * @returns A result object containing the created script element.
+ */
+declare function injectScript(path: ScriptPublicPath, options?: InjectScriptOptions): Promise<InjectScriptResult>;
+interface InjectScriptOptions {
+  /**
+   * By default, the injected script is removed from the DOM after being
+   * injected. To disable this behavior, set this flag to true.
+   */
+  keepInDom?: boolean;
+  /**
+   * Modify the script element just before it is added to the DOM.
+   *
+   * It can be used to e.g. modify `script.async`/`script.defer`, add event
+   * listeners to the element, or pass data to the script via `script.dataset`
+   * (which can be accessed by the script via `document.currentScript`).
+   */
+  modifyScript?: (script: HTMLScriptElement) => Promise<void> | void;
+}
+interface InjectScriptResult {
+  /**
+   * The created script element. It can be used to e.g. send messages to the
+   * script in the form of custom events. The script can add an event listener
+   * for them via `document.currentScript`.
+   */
+  script: HTMLScriptElement;
+}
+//#endregion
+export { InjectScriptOptions, InjectScriptResult, ScriptPublicPath, injectScript };

package/dist/utils/inject-script.mjs

@@ -1,38 +1,48 @@
 import { browser } from "wxt/browser";
-export async function injectScript(path, options) {
-  const url = browser.runtime.getURL(path);
-  const script = document.createElement("script");
-  if (browser.runtime.getManifest().manifest_version === 2) {
-    script.text = await fetch(url).then((res) => res.text());
-  } else {
-    script.src = url;
-  }
-  const loadedPromise = makeLoadedPromise(script);
-  await options?.modifyScript?.(script);
-  (document.head ?? document.documentElement).append(script);
-  if (!options?.keepInDom) {
-    script.remove();
-  }
-  await loadedPromise;
-  return {
-    script
-  };
+
+//#region src/utils/inject-script.ts
+/** @module wxt/utils/inject-script */
+/**
+* This function can only be called inside content scripts.
+*
+* Inject an unlisted script into the page. Scripts are added to the `<head>`
+* element or `document.documentElement` if there is no head.
+*
+* Make sure to add the injected script to your manifest's
+* `web_accessible_resources`.
+*
+* @returns A result object containing the created script element.
+*/
+async function injectScript(path, options) {
+	const url = browser.runtime.getURL(path);
+	const script = document.createElement("script");
+	if (browser.runtime.getManifest().manifest_version === 2) script.text = await fetch(url).then((res) => res.text());
+	else script.src = url;
+	const loadedPromise = makeLoadedPromise(script);
+	await options?.modifyScript?.(script);
+	(document.head ?? document.documentElement).append(script);
+	if (!options?.keepInDom) script.remove();
+	await loadedPromise;
+	return { script };
 }
 function makeLoadedPromise(script) {
-  return new Promise((resolve, reject) => {
-    const onload = () => {
-      resolve();
-      cleanup();
-    };
-    const onerror = () => {
-      reject(new Error(`Failed to load script: ${script.src}`));
-      cleanup();
-    };
-    const cleanup = () => {
-      script.removeEventListener("load", onload);
-      script.removeEventListener("error", onerror);
-    };
-    script.addEventListener("load", onload);
-    script.addEventListener("error", onerror);
-  });
+	return new Promise((resolve, reject) => {
+		const onload = () => {
+			resolve();
+			cleanup();
+		};
+		const onerror = () => {
+			reject(/* @__PURE__ */ new Error(`Failed to load script: ${script.src}`));
+			cleanup();
+		};
+		const cleanup = () => {
+			script.removeEventListener("load", onload);
+			script.removeEventListener("error", onerror);
+		};
+		script.addEventListener("load", onload);
+		script.addEventListener("error", onerror);
+	});
 }
+
+//#endregion
+export { injectScript };

package/dist/utils/internal/custom-events.d.mts

@@ -0,0 +1,9 @@
+//#region src/utils/internal/custom-events.d.ts
+declare class WxtLocationChangeEvent extends Event {
+  readonly newUrl: URL;
+  readonly oldUrl: URL;
+  static EVENT_NAME: string;
+  constructor(newUrl: URL, oldUrl: URL);
+}
+//#endregion
+export { WxtLocationChangeEvent };

package/dist/utils/internal/custom-events.mjs

@@ -1,12 +1,20 @@
 import { browser } from "wxt/browser";
-export class WxtLocationChangeEvent extends Event {
-  constructor(newUrl, oldUrl) {
-    super(WxtLocationChangeEvent.EVENT_NAME, {});
-    this.newUrl = newUrl;
-    this.oldUrl = oldUrl;
-  }
-  static EVENT_NAME = getUniqueEventName("wxt:locationchange");
-}
-export function getUniqueEventName(eventName) {
-  return `${browser?.runtime?.id}:${import.meta.env.ENTRYPOINT}:${eventName}`;
+
+//#region src/utils/internal/custom-events.ts
+var WxtLocationChangeEvent = class WxtLocationChangeEvent extends Event {
+	static EVENT_NAME = getUniqueEventName("wxt:locationchange");
+	constructor(newUrl, oldUrl) {
+		super(WxtLocationChangeEvent.EVENT_NAME, {});
+		this.newUrl = newUrl;
+		this.oldUrl = oldUrl;
+	}
+};
+/**
+* Returns an event name unique to the extension and content script that's running.
+*/
+function getUniqueEventName(eventName) {
+	return `${browser?.runtime?.id}:${import.meta.env.ENTRYPOINT}:${eventName}`;
 }
+
+//#endregion
+export { WxtLocationChangeEvent, getUniqueEventName };

package/dist/utils/internal/location-watcher.mjs

@@ -1,22 +1,25 @@
 import { WxtLocationChangeEvent } from "./custom-events.mjs";
-export function createLocationWatcher(ctx) {
-  let interval;
-  let oldUrl;
-  return {
-    /**
-     * Ensure the location watcher is actively looking for URL changes. If it's already watching,
-     * this is a noop.
-     */
-    run() {
-      if (interval != null) return;
-      oldUrl = new URL(location.href);
-      interval = ctx.setInterval(() => {
-        let newUrl = new URL(location.href);
-        if (newUrl.href !== oldUrl.href) {
-          window.dispatchEvent(new WxtLocationChangeEvent(newUrl, oldUrl));
-          oldUrl = newUrl;
-        }
-      }, 1e3);
-    }
-  };
+
+//#region src/utils/internal/location-watcher.ts
+/**
+* Create a util that watches for URL changes, dispatching the custom event when detected. Stops
+* watching when content script is invalidated.
+*/
+function createLocationWatcher(ctx) {
+	let interval;
+	let oldUrl;
+	return { run() {
+		if (interval != null) return;
+		oldUrl = new URL(location.href);
+		interval = ctx.setInterval(() => {
+			let newUrl = new URL(location.href);
+			if (newUrl.href !== oldUrl.href) {
+				window.dispatchEvent(new WxtLocationChangeEvent(newUrl, oldUrl));
+				oldUrl = newUrl;
+			}
+		}, 1e3);
+	} };
 }
+
+//#endregion
+export { createLocationWatcher };

package/dist/utils/internal/logger.mjs

@@ -1,15 +1,18 @@
+//#region src/utils/internal/logger.ts
 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);
-  }
+	if (import.meta.env.MODE === "production") return;
+	if (typeof args[0] === "string") method(`[wxt] ${args.shift()}`, ...args);
+	else method("[wxt]", ...args);
 }
-export const 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)
+/**
+* Wrapper around `console` with a "[wxt]" prefix
+*/
+const 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)
 };
+
+//#endregion
+export { logger };

package/dist/utils/match-patterns.d.mts

@@ -0,0 +1 @@
+export * from "@webext-core/match-patterns";

package/dist/utils/match-patterns.mjs

@@ -1 +1,3 @@
-export * from "@webext-core/match-patterns";
+export * from "@webext-core/match-patterns"
+
+export {  };

package/dist/utils/{split-shadow-root-css.d.ts → split-shadow-root-css.d.mts}

@@ -1,3 +1,4 @@
+//#region src/utils/split-shadow-root-css.d.ts
 /** @module wxt/utils/split-shadow-root-css */
 /**
  * Given a CSS string that will be loaded into a shadow root, split it into two parts:
@@ -5,7 +6,9 @@
  * - `shadowCss`: CSS that needs to be applied to the shadow root
  * @param css
  */
-export declare function splitShadowRootCss(css: string): {
-    documentCss: string;
-    shadowCss: string;
+declare function splitShadowRootCss(css: string): {
+  documentCss: string;
+  shadowCss: string;
 };
+//#endregion
+export { splitShadowRootCss };

package/dist/utils/split-shadow-root-css.mjs

@@ -1,9 +1,18 @@
+//#region src/utils/split-shadow-root-css.ts
+/** @module wxt/utils/split-shadow-root-css */
 const AT_RULE_BLOCKS = /(\s*@(property|font-face)[\s\S]*?{[\s\S]*?})/gm;
-export function splitShadowRootCss(css) {
-  const documentCss = Array.from(css.matchAll(AT_RULE_BLOCKS), (m) => m[0]).join("").trim();
-  const shadowCss = css.replace(AT_RULE_BLOCKS, "").trim();
-  return {
-    documentCss,
-    shadowCss
-  };
+/**
+* Given a CSS string that will be loaded into a shadow root, split it into two parts:
+* - `documentCss`: CSS that needs to be applied to the document (like `@property`)
+* - `shadowCss`: CSS that needs to be applied to the shadow root
+* @param css
+*/
+function splitShadowRootCss(css) {
+	return {
+		documentCss: Array.from(css.matchAll(AT_RULE_BLOCKS), (m) => m[0]).join("").trim(),
+		shadowCss: css.replace(AT_RULE_BLOCKS, "").trim()
+	};
 }
+
+//#endregion
+export { splitShadowRootCss };

package/dist/utils/storage.d.mts

@@ -0,0 +1 @@
+export * from "@wxt-dev/storage";

package/dist/utils/storage.mjs

@@ -1 +1,3 @@
-export * from "@wxt-dev/storage";
+export * from "@wxt-dev/storage"
+
+export {  };

package/dist/version.d.mts

@@ -0,0 +1,4 @@
+//#region src/version.d.ts
+declare const version = "{{version}}";
+//#endregion
+export { version };

package/dist/version.mjs

@@ -1 +1,5 @@
-export const version = "0.20.13";
+//#region src/version.ts
+const version = "0.20.15";
+
+//#endregion
+export { version };

package/dist/virtual/background-entrypoint.d.mts

@@ -0,0 +1,4 @@
+//#region src/virtual/background-entrypoint.d.ts
+declare let result: any;
+//#endregion
+export { result as default };