@unplugin-pwa/core 0.0.0 → 0.0.2

package/dist/config.mjs

@@ -0,0 +1,293 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { resolvePWAAssetsOptions } from "./pwa-assets/options.mjs";
+import { normalizePath } from "@vite-pwa/workbox-build/utils/resolve-sw-names";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { errStyle } from "@vite-pwa/workbox-build/utils/colors";
+// src/config.ts
+function deepMergeObject(magicast, object) {
+	if (typeof object === "object" && object !== null) for (const key in object) {
+		const magicastValue = magicast[key];
+		const objectValue = object[key];
+		if (magicastValue === objectValue) continue;
+		if (typeof magicastValue === "object" && magicastValue !== null && typeof objectValue === "object" && objectValue !== null) deepMergeObject(magicastValue, objectValue);
+		else magicast[key] = objectValue;
+	}
+}
+const DEFAULT_CONFIG_FILES = [
+	"pwa.config.js",
+	"pwa.config.ts",
+	"pwa.config.mjs",
+	"pwa.config.mts"
+];
+/**
+* Loads the PWA configuration from a specified path.
+*
+* If the `path` options is not provided, it will return the provided options as is.
+*
+* Otherwise, it will attempt to load the configuration from the specified path
+* and merge it with the provided options if `mergeOptions` is set to true.
+*
+* @param options The partial PWA options to load.
+* @returns The resolved PWA options, merged with the provided options if `mergeOptions` is set to true.
+*/
+async function loadConfiguration(options) {
+	if (!options.path) return options;
+	const cwd = path.resolve(process.cwd(), options.cwd || ".");
+	const configPath = path.isAbsolute(options.path) ? options.path : path.resolve(cwd, options.path);
+	const configModule = await import(pathToFileURL(configPath).href).then((m) => m.default ?? m.options ?? m.config ?? m);
+	const external = typeof configModule === "function" ? await configModule() : configModule;
+	if (options.mergeOptions) deepMergeObject(external, options);
+	external.path = normalizePath(configPath);
+	return external;
+}
+/**
+* Loads the first existing default configuration file from the current working directory.
+*
+* The default configuration files are searched in the following order:
+* - `pwa.config.js`
+* - `pwa.config.ts`
+* - `pwa.config.mjs`
+* - `pwa.config.mts`
+*
+* @param cwd The current working directory to search for the default configuration files. Defaults to `process.cwd()`.
+* @returns The path to the first existing default configuration file, or `undefined` if none are found.
+*/
+function resolveDefaultConfig(cwd = process.cwd()) {
+	for (const name of DEFAULT_CONFIG_FILES) {
+		const candidate = path.resolve(cwd, name);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+}
+/**
+* Loads the default manifest using the `package.json` file.
+*
+* @param options The resolved PWA options.
+*/
+function prepareManifest(options) {
+	if (options.manifest === false) return;
+	const pkg = fs.existsSync("package.json") ? JSON.parse(fs.readFileSync("package.json", "utf-8")) : {};
+	options.manifest = Object.assign({}, {
+		name: pkg.name,
+		short_name: pkg.name,
+		description: pkg.description,
+		start_url: options.base,
+		display: "standalone",
+		background_color: "#ffffff",
+		theme_color: "#42b883",
+		lang: "en",
+		scope: options.scope
+	}, options.manifest ?? {});
+}
+function checkInjectRegister(strategy, injectRegister, swType, color, buildWarning) {
+	return swType === "classic-and-module" && injectRegister === "inline" ? [
+		`\n${errStyle([color, "bold"], "[Vite PWA]")} ${errStyle(color, "WRONG CONFIGURATION")}:`,
+		`You are using ${errStyle("cyan", "inline")} for inject register with dual service worker registration.`,
+		`Specify other value at ${errStyle("cyan", "injectRegister")} option${buildWarning}.\n`
+	].join("\n") : void 0;
+}
+function checkOptions(isDev, consumerOptions, resolvedOptions) {
+	const isDevEnabled = consumerOptions.devOptions?.enabled === true;
+	const isWarning = isDev && !isDevEnabled;
+	const color = isWarning ? "yellow" : "red";
+	const warning = isWarning ? `, ${errStyle("yellow", "running build command will fail")}` : "";
+	let message;
+	switch (resolvedOptions.strategy) {
+		case "inject-manifest": {
+			const { swType } = resolvedOptions.injectManifest;
+			if (swType === "classic-and-module") message = [
+				`\n${errStyle([color, "bold"], "[Vite PWA]")} ${errStyle(color, "WRONG CONFIGURATION")}:`,
+				`You are using ${errStyle("cyan", String(consumerOptions.strategies))} with ${errStyle("cyan", swType)} service worker type.`,
+				`Specify ${errStyle("green", "classic")} or ${errStyle("green", "module")} at ${errStyle("cyan", "swType")} option${warning}.\n`
+			].join("\n");
+			break;
+		}
+		case "generate-sw":
+			message = checkInjectRegister("generate-sw", resolvedOptions.injectRegister, resolvedOptions.generateSW.swType, color, warning);
+			break;
+		case "build-sw": message = checkInjectRegister("build-sw", consumerOptions.injectRegister, resolvedOptions.buildSW.swType, color, warning);
+	}
+	if (message) {
+		if (isWarning) console.warn(message);
+		else throw new Error(message);
+	}
+	return resolvedOptions;
+}
+/**
+* Resolves the PWA configuration based on the provided options and resolver options.
+*
+* This function will search for the PWA configuration file if the `path` option is not provided,
+* and will merge the loaded configuration with the provided options.
+*
+* When using `inject-manifest`, the `resolverOptions.isWrongInjectManifest` callback must resolve if the strategy is wrong, the implementation should be:
+* - if the service worker with `.ts` or `.mts` extension, then, it is `build-sw` and not `inject-manifest` strategy: must return true
+* - if the service worker outside public dir, then, it is `build-sw` and not `inject-manifest` strategy: must return true
+* - otherwise must return false
+*
+* @param pwaOptions The PWA options to resolve.
+* @param resolverOptions The resolver options containing environment information and callbacks.
+* @returns The resolved PWA options.
+*/
+async function resolvePwaConfiguration(pwaOptions, resolverOptions) {
+	const resolvedPath = pwaOptions.path ?? resolveDefaultConfig(pwaOptions.cwd);
+	const { pwaAssets, filename = "sw.js", strategies = "generateSW", swType = "classic", includeManifest = true, includeManifestIcons = true, includeManifestShortcutIcons = true, includeManifestScreenshots = false, disable = false, injectRegister = "auto", registerType = "prompt", useCredentials = false, manifestFilename = "manifest.webmanifest", minify, maximumFileSizeToCacheInBytes, throwMaximumFileSizeToCacheInBytes, additionalManifestEntries, additionalManifestEntriesGenerator, manifest, updateViaCache = "imports", ...rest } = await loadConfiguration(Object.assign({}, pwaOptions, { path: resolvedPath }));
+	const resolvedPwaAssets = resolvePWAAssetsOptions(pwaAssets);
+	switch (strategies) {
+		case "generateSW":
+		case "generate-sw": {
+			const { workbox, generateSW, ...strategyOptions } = rest;
+			if (workbox && !generateSW) console.warn([
+				`\n${errStyle(["yellow", "bold"], "[Vite PWA]")} ${errStyle("yellow", "DEPRECATION WARNING")}:`,
+				`You are using ${errStyle("cyan", "workbox")} option, which is now deprecated.`,
+				`Please replace ${errStyle("cyan", "workbox")} with ${errStyle("green", "generateSW")} option.`,
+				`${errStyle("cyan", "workbox")} option will be removed in the next major version.\n`
+			].join("\n"));
+			const { inlineWorkboxRuntime = false, workboxRuntimeCompatible = true, ...generateSWOptions } = generateSW ?? workbox ?? {};
+			return checkOptions(resolverOptions.isDev, pwaOptions, Object.assign({}, strategyOptions, {
+				strategy: "generate-sw",
+				swType,
+				includeManifest,
+				includeManifestIcons,
+				includeManifestShortcutIcons,
+				includeManifestScreenshots,
+				disable,
+				injectRegister,
+				registerType,
+				useCredentials,
+				manifest,
+				manifestFilename,
+				minify,
+				updateViaCache,
+				pwaAssets: resolvedPwaAssets
+			}, { generateSW: Object.assign(generateSWOptions, {
+				inlineWorkboxRuntime,
+				workboxRuntimeCompatible,
+				swDest: filename,
+				swType,
+				minify,
+				maximumFileSizeToCacheInBytes,
+				throwMaximumFileSizeToCacheInBytes,
+				additionalManifestEntries,
+				additionalManifestEntriesGenerator
+			}) }));
+		}
+		case "injectManifest":
+		case "inject-manifest": {
+			const swSrcName = pwaOptions.injectManifest?.swSrc;
+			if (!swSrcName) throw new Error([`\n${errStyle(["red", "bold"], "[Vite PWA]")} ${errStyle("red", "WRONG CONFIGURATION")}:`, `You are using ${errStyle("cyan", strategies)} option without ${errStyle("cyan", "swSrc")} option.\n`].join("\n"));
+			const isTS = swSrcName.endsWith(".ts") || swSrcName.endsWith(".mts");
+			if (isTS || await resolverOptions.isWrongInjectManifest(normalizePath(path.resolve(process.cwd(), swSrcName)))) {
+				const isWarning = resolverOptions.isDev && !(pwaOptions?.devOptions?.enabled === true);
+				const warning = isWarning ? `, ${errStyle("yellow", "running build command will fail")}` : "";
+				const color = isWarning ? "yellow" : "red";
+				const message = [
+					`\n${errStyle([color, "bold"], "[Vite PWA]")} ${errStyle(color, "WRONG CONFIGURATION")}:`,
+					`You are using ${errStyle("cyan", strategies)} option with a service worker ${isTS ? "using TypeScript" : "as static asset"}.`,
+					`Please migrate to ${errStyle("green", "buildSW")} option${warning}.`,
+					`${errStyle("cyan", strategies)} option should be only used when you need to inject a manifest into an existing service worker.\n`
+				].join("\n");
+				if (isWarning) console.warn(message);
+				else throw new Error(message);
+				return checkOptions(resolverOptions.isDev, pwaOptions, Object.assign({}, rest, {
+					strategy: "build-sw",
+					swType,
+					includeManifest,
+					includeManifestIcons,
+					includeManifestShortcutIcons,
+					includeManifestScreenshots,
+					disable,
+					injectRegister,
+					registerType,
+					useCredentials,
+					manifest,
+					manifestFilename,
+					minify,
+					updateViaCache,
+					pwaAssets: resolvedPwaAssets
+				}, { buildSW: Object.assign(rest.injectManifest ?? {}, {
+					swDest: filename,
+					swType,
+					minify,
+					maximumFileSizeToCacheInBytes,
+					throwMaximumFileSizeToCacheInBytes,
+					additionalManifestEntries,
+					additionalManifestEntriesGenerator
+				}) }));
+			}
+			return checkOptions(resolverOptions.isDev, pwaOptions, Object.assign({}, rest, {
+				strategy: "inject-manifest",
+				swType,
+				includeManifest,
+				includeManifestIcons,
+				includeManifestShortcutIcons,
+				includeManifestScreenshots,
+				disable,
+				injectRegister,
+				registerType,
+				useCredentials,
+				manifest,
+				manifestFilename,
+				minify,
+				updateViaCache,
+				pwaAssets: resolvedPwaAssets
+			}, { injectManifest: Object.assign(rest.injectManifest ?? {}, {
+				swDest: filename,
+				maximumFileSizeToCacheInBytes,
+				throwMaximumFileSizeToCacheInBytes,
+				additionalManifestEntries,
+				additionalManifestEntriesGenerator
+			}) }));
+		}
+		case "build-sw":
+		case "buildSW": {
+			const { inlineWorkboxRuntime = true, workboxRuntimeCompatible = true, ...buildSWOptions } = rest.buildSW ?? {};
+			return checkOptions(resolverOptions.isDev, pwaOptions, Object.assign({}, rest, {
+				strategy: "build-sw",
+				swType,
+				includeManifest,
+				includeManifestIcons,
+				includeManifestShortcutIcons,
+				includeManifestScreenshots,
+				disable,
+				injectRegister,
+				registerType,
+				useCredentials,
+				manifest,
+				manifestFilename,
+				minify,
+				updateViaCache,
+				pwaAssets: resolvedPwaAssets
+			}, { buildSW: Object.assign(buildSWOptions, {
+				inlineWorkboxRuntime,
+				workboxRuntimeCompatible,
+				swDest: filename,
+				swType,
+				minify,
+				maximumFileSizeToCacheInBytes,
+				throwMaximumFileSizeToCacheInBytes,
+				additionalManifestEntries,
+				additionalManifestEntriesGenerator
+			}) }));
+		}
+		case "self-destroy-sw":
+		case "selfDestroySW": throw new Error([
+			`\n${errStyle(["red", "bold"], "[Vite PWA] self-destroying")} ${errStyle("red", "strategy is no longer supported directly in the build process.")}`,
+			"  It has been replaced by an interactive Self Destroying SW CLI. This tool will safely generate",
+			"  the necessary auto-destroying Service Workers for your specific setup (including dual classic/ESM builds)",
+			"  and update your config automatically.",
+			"  The Self Destroying SW CLI is not yet available, in the meantime check:",
+			"  https://github.com/vite-pwa/unplugin-pwa/blob/main/packages/vite/BREAKING-CHANGES.md#1-do-i-need-to-change-my-service-worker-setup-read-this-first",
+			"\n"
+		].join("\n"));
+	}
+	throw new Error("Unknown strategy, please use one of the following: \"generateSW\", \"injectManifest\", \"buildSW\"");
+}
+export { DEFAULT_CONFIG_FILES, loadConfiguration, prepareManifest, resolveDefaultConfig, resolvePwaConfiguration };

package/dist/constants.d.mts

@@ -0,0 +1,31 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+export declare const FILE_SW_REGISTER = "registerSW.js";
+export declare const VIRTUAL_MODULES_MAP: Record<string, string>;
+export declare const VIRTUAL_MODULES_RESOLVED_PREFIX = "/@unplugin-pwa/";
+export declare const VIRTUAL_MODULES: string[];
+export declare const PWA_INFO_VIRTUAL = "virtual:pwa-info";
+export declare const RESOLVED_PWA_INFO_VIRTUAL = "\0virtual:pwa-info";
+export declare const PWA_ASSETS_HEAD_VIRTUAL = "virtual:pwa-assets/head";
+export declare const RESOLVED_PWA_ASSETS_HEAD_VIRTUAL = "\0virtual:pwa-assets/head";
+export declare const PWA_ASSETS_ICONS_VIRTUAL = "virtual:pwa-assets/icons";
+export declare const RESOLVED_PWA_ASSETS_ICONS_VIRTUAL = "\0virtual:pwa-assets/icons";
+export declare const DEV_SW_NAME = "dev-sw.js?dev-sw";
+export declare const DEV_SW_VIRTUAL = "/@unplugin-pwa/pwa-entry-point-loaded";
+export declare const DEV_SW_VIRTUAL_VIRTUAL = "virtual:pwa-entry-point-loaded";
+export declare const RESOLVED_DEV_SW_VIRTUAL_VIRTUAL = "\0virtual:pwa-entry-point-loaded";
+export declare const RESOLVED_DEV_SW_VIRTUAL = "\0/@unplugin-pwa/pwa-entry-point-loaded";
+export declare const DEV_READY_NAME = "unplugin-pwa:dev-ready";
+export declare const DEV_REGISTER_SW_NAME = "unplugin-pwa:register-sw";
+export declare const DEV_PWA_ASSETS_NAME = "unplugin-pwa:pwa-assets";
+export declare const DEV_SWITCHER_NAME = "unplugin-pwa:pwa-switcher";
+export declare const DEV_PWA_DUAL_SW_SWITCHER_NAME = "./switcher.js";
+export declare const DEV_PWA_REGISTER_NAME = "./register.js";
+export declare const INSPECTOR_BASE_PATH = "/__unplugin_pwa_inspector";
+export declare const INSPECTOR_BASE_PATH_URL = "/__unplugin_pwa_inspector/";
+export declare const INSPECTOR_BASE_PATH_API = "/__unplugin_pwa_inspector_api";

package/dist/constants.mjs

@@ -0,0 +1,41 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+// src/constants.ts
+const FILE_SW_REGISTER = "registerSW.js";
+const VIRTUAL_MODULES_MAP = {
+	"virtual:pwa-register": "register",
+	"virtual:pwa-register/vue": "vue",
+	"virtual:pwa-register/svelte": "svelte",
+	"virtual:pwa-register/react": "react",
+	"virtual:pwa-register/react-legacy": "react-legacy",
+	"virtual:pwa-register/preact": "preact",
+	"virtual:pwa-register/solid": "solid"
+};
+const VIRTUAL_MODULES_RESOLVED_PREFIX = "/@unplugin-pwa/";
+const VIRTUAL_MODULES = /* @__PURE__ */ Object.keys(VIRTUAL_MODULES_MAP);
+const PWA_INFO_VIRTUAL = "virtual:pwa-info";
+const RESOLVED_PWA_INFO_VIRTUAL = `\0${PWA_INFO_VIRTUAL}`;
+const PWA_ASSETS_HEAD_VIRTUAL = "virtual:pwa-assets/head";
+const RESOLVED_PWA_ASSETS_HEAD_VIRTUAL = `\0${PWA_ASSETS_HEAD_VIRTUAL}`;
+const PWA_ASSETS_ICONS_VIRTUAL = "virtual:pwa-assets/icons";
+const RESOLVED_PWA_ASSETS_ICONS_VIRTUAL = `\0${PWA_ASSETS_ICONS_VIRTUAL}`;
+const DEV_SW_NAME = "dev-sw.js?dev-sw";
+const DEV_SW_VIRTUAL = `${VIRTUAL_MODULES_RESOLVED_PREFIX}pwa-entry-point-loaded`;
+const DEV_SW_VIRTUAL_VIRTUAL = "virtual:pwa-entry-point-loaded";
+const RESOLVED_DEV_SW_VIRTUAL_VIRTUAL = `\0${DEV_SW_VIRTUAL_VIRTUAL}`;
+const RESOLVED_DEV_SW_VIRTUAL = `\0${DEV_SW_VIRTUAL}`;
+const DEV_READY_NAME = "unplugin-pwa:dev-ready";
+const DEV_REGISTER_SW_NAME = "unplugin-pwa:register-sw";
+const DEV_PWA_ASSETS_NAME = "unplugin-pwa:pwa-assets";
+const DEV_SWITCHER_NAME = "unplugin-pwa:pwa-switcher";
+const DEV_PWA_DUAL_SW_SWITCHER_NAME = "./switcher.js";
+const DEV_PWA_REGISTER_NAME = "./register.js";
+const INSPECTOR_BASE_PATH = "/__unplugin_pwa_inspector";
+const INSPECTOR_BASE_PATH_URL = `${INSPECTOR_BASE_PATH}/`;
+const INSPECTOR_BASE_PATH_API = `${INSPECTOR_BASE_PATH}_api`;
+export { DEV_PWA_ASSETS_NAME, DEV_PWA_DUAL_SW_SWITCHER_NAME, DEV_PWA_REGISTER_NAME, DEV_READY_NAME, DEV_REGISTER_SW_NAME, DEV_SWITCHER_NAME, DEV_SW_NAME, DEV_SW_VIRTUAL, DEV_SW_VIRTUAL_VIRTUAL, FILE_SW_REGISTER, INSPECTOR_BASE_PATH, INSPECTOR_BASE_PATH_API, INSPECTOR_BASE_PATH_URL, PWA_ASSETS_HEAD_VIRTUAL, PWA_ASSETS_ICONS_VIRTUAL, PWA_INFO_VIRTUAL, RESOLVED_DEV_SW_VIRTUAL, RESOLVED_DEV_SW_VIRTUAL_VIRTUAL, RESOLVED_PWA_ASSETS_HEAD_VIRTUAL, RESOLVED_PWA_ASSETS_ICONS_VIRTUAL, RESOLVED_PWA_INFO_VIRTUAL, VIRTUAL_MODULES, VIRTUAL_MODULES_MAP, VIRTUAL_MODULES_RESOLVED_PREFIX };

package/dist/context-types.d.mts

@@ -0,0 +1,155 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { r as PWAAssetsGenerator } from "./types-B60e7Nq4.mjs";
+import { C as VitePWAOptions, T as WebManifestData, m as RegisterSWData, w as VitePWAStrategy, y as ResolvedVitePWAOptions } from "./types-BhwjnGLn.mjs";
+import { Hookable } from "hookable";
+import { BuildResult, SWType } from "@vite-pwa/workbox-build/types";
+import { BuildGenerateSWOptions, BuildWithSourcesResult } from "@vite-pwa/workbox-build/build/types";
+import { InjectManifestStrategyOptions, SelfDestroyingStrategyOptions } from "@vite-pwa/workbox-build/config/types";
+export type Bundler = 'vite' | 'vite-legacy' | 'webpack' | 'rspack';
+export type BuildSWType<B extends Bundler, T extends SWType> = B extends 'vite' ? import('@vite-pwa/workbox-build/build/vite/types').BuildServiceWorkerOptions<T> : B extends 'vite-legacy' ? import('@vite-pwa/workbox-build/build/vite/legacy-types').LegacyBuildServiceWorkerOptions<T> : import('@vite-pwa/workbox-build/build/rolldown/types').BuildServiceWorkerOptions<T>;
+export type ExtractStrategy<UserStrategy extends VitePWAStrategy> = UserStrategy extends 'generateSW' ? 'generate-sw' : UserStrategy extends 'generate-sw' ? 'generate-sw' : UserStrategy extends 'buildSW' ? 'build-sw' : UserStrategy extends 'build-sw' ? 'build-sw' : UserStrategy extends 'injectManifest' ? 'inject-manifest' : UserStrategy extends 'inject-manifest' ? 'inject-manifest' : UserStrategy extends 'selfDestroySW' ? 'self-destroy-sw' : UserStrategy extends 'self-destroy-sw' ? 'self-destroy-sw' : 'generate-sw';
+export interface PWABuildContext {
+  generateSW: () => Promise<BuildResult>;
+  buildSW: () => Promise<BuildWithSourcesResult>;
+  injectManifest: () => Promise<BuildResult>;
+  selfDestroyingSW: () => Promise<boolean>;
+}
+export interface SWNames {
+  hasNames: boolean;
+  name: string;
+  classic: string;
+  module: string;
+}
+export interface DevSWNames extends SWNames {
+  path: string;
+  classicPath: string;
+  modulePath: string;
+  devSWDest: string;
+}
+/**
+ * The type of PWA asset.
+ */
+export type PwaAsset = 'register-sw' | 'virtual-register-sw';
+/**
+ * Custom PWA asset resolver for `registerSW.js` and PWA virtual modules.
+ *
+ * When `virtual-register-sw` the virtualName won't be undefined:
+ * - 'register' for `virtual:pwa-register`
+ * - 'vue' for `virtual:pwa-register/vue`
+ * - 'svelte' for `virtual:pwa-register/svelte`
+ * - 'react' for `virtual:pwa-register/react`
+ * - 'react-legacy' for `virtual:pwa-register/react-legacy`
+ * - 'preact' for `virtual:pwa-register/preact`
+ * - 'solid' for `virtual:pwa-register/solid`
+ *
+ * @param asset The asset type to resolve
+ * @param virtualName The virtual module name when asset is `virtual-register-sw`
+ * @return The generated PWA asset
+ */
+export type CustomPwaAssetResolver = (asset: PwaAsset, virtualName?: string) => Promise<string>;
+export interface PWABuildDevContext<B extends Bundler, T extends SWType> {
+  options: {
+    /**
+     * The current service worker name.
+     */
+    swName: string;
+    /**
+     * The current service worker type.
+     */
+    swType: WorkerType;
+    swGenerated: boolean;
+    registerSWGenerated: boolean;
+    registerVirtualSWGenerated: boolean;
+    hmrEntryPointGenerated: boolean;
+    navigateFallbackAllowlist?: RegExp[];
+    swAssetKeys: Set<string>;
+    swAssetsPaths: Map<string, string>;
+    tempFolder: string;
+    /**
+     * Hook to allow remove prefixes: for example _nuxt/
+     */
+    mapSWSourcemapFile?: (url: string) => string | undefined;
+    /**
+     * Names and paths to resolve service workers.
+     */
+    swNames: DevSWNames;
+    /**
+     * The globDirectory to cache only entry point.
+     */
+    globDirectory: string;
+  };
+  generateSW: (options: Partial<BuildGenerateSWOptions<T>>) => Promise<BuildResult>;
+  buildSW: (options: Partial<BuildSWType<B, T>>) => Promise<BuildWithSourcesResult>;
+  injectManifest: (options: Partial<InjectManifestStrategyOptions>) => Promise<BuildResult>;
+  selfDestroyingSW: (options: SelfDestroyingStrategyOptions) => Promise<boolean>;
+}
+export interface ConfigurePWAOptions {
+  outDir: string;
+  /**
+   * Used to generate the dontCache
+   */
+  immutableAssets: string;
+  cwd: string;
+}
+export type HookResult = void | Promise<void>;
+export interface PWAHooks {
+  'context:ready': (error?: unknown) => HookResult;
+  'service-worker:generated': () => HookResult;
+  'service-worker:switched': () => HookResult;
+}
+export interface PWAPluginContext<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType> {
+  bundler: B;
+  version: string;
+  strategy: ExtractStrategy<UserStrategy>;
+  consumerOptions: Partial<VitePWAOptions<UserStrategy, T>>;
+  externalConfigurationLoader: boolean;
+  resolvedOptions: Partial<ResolvedVitePWAOptions<ExtractStrategy<UserStrategy>, T>>;
+  useImportRegister: boolean;
+  devEnvironment: boolean;
+  isPreview: boolean;
+  hmrRequiresSwitcher?: true;
+  pwaAssetsGenerator: Promise<PWAAssetsGenerator | undefined>;
+  build: PWABuildContext;
+  dev: PWABuildDevContext<B, T>;
+  publicDir: string;
+  rootDir: string;
+  outDir: string;
+  base: string;
+  sources: Set<string>;
+  swNames: SWNames;
+  /**
+   * When using `inject-manifest` this hook will resolve if the service worker is inside public directory.
+   *
+   * Integrations can override this hook, for example, Vite integration will check the `publicDir`, or Nuxt will
+   * check Nitro public dirs.
+   */
+  injectManifestSWAtPublicDir: () => boolean;
+  /**
+   * The custom resolver to resolve PWA assets for `registerSW.js` and virtual PWA modules.
+   */
+  customPwaAssetResolver: CustomPwaAssetResolver;
+  /**
+   * Returns the PWA web manifest url for the manifest link:
+   * <link rel="manifest" href="<webManifestUrl>" />
+   *
+   * Will also return if the manifest will require credentials:
+   * <link rel="manifest" href="<webManifestUrl>" crossorigin="use-credentials" />
+   */
+  webManifestData: () => WebManifestData | undefined;
+  /**
+   * How the service worker is being registered in the application.
+   *
+   * This option will help some integrations to inject the corresponding script in the head.
+   */
+  registerSWData: () => Promise<RegisterSWData & {
+    module: boolean;
+  } | undefined>;
+  runBuild: () => Promise<BuildResult | boolean>;
+  hooks: Hookable<PWAHooks>;
+}

package/dist/context.d.mts

@@ -0,0 +1,15 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { C as VitePWAOptions, w as VitePWAStrategy } from "./types-BhwjnGLn.mjs";
+import { Bundler, PWAPluginContext } from "./context-types.mjs";
+import { SWType } from "@vite-pwa/workbox-build/types";
+export declare function createPWAContext<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType>(bundler: B, userOptions?: Partial<VitePWAOptions<UserStrategy, T>>): PWAPluginContext<B, UserStrategy, T>;
+export declare function createVitePWAContext<UserStrategy extends VitePWAStrategy, T extends SWType>(userOptions?: Partial<VitePWAOptions<UserStrategy, T>>): PWAPluginContext<'vite', UserStrategy, T>;
+export declare function createViteLegacyPWAContext<UserStrategy extends VitePWAStrategy, T extends SWType>(userOptions?: Partial<VitePWAOptions<UserStrategy, T>>): PWAPluginContext<'vite-legacy', UserStrategy, T>;
+export declare function createWebpackPWAContext<UserStrategy extends VitePWAStrategy, T extends SWType>(userOptions?: Partial<VitePWAOptions<UserStrategy, T>>): PWAPluginContext<'webpack', UserStrategy, T>;
+export declare function createRspackPWAContext<UserStrategy extends VitePWAStrategy, T extends SWType>(userOptions?: Partial<VitePWAOptions<UserStrategy, T>>): PWAPluginContext<'rspack', UserStrategy, T>;

package/dist/context.mjs

@@ -0,0 +1,58 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { t as version } from "./package-DpKc2x3j.mjs";
+import { preparePWAContext } from "./prepare-pwa-context.mjs";
+import process from "node:process";
+import { Hookable } from "hookable";
+// src/context.ts
+function createPWAContext(bundler, userOptions = {}) {
+	return preparePWAContext({
+		bundler,
+		version,
+		strategy: void 0,
+		consumerOptions: userOptions,
+		externalConfigurationLoader: false,
+		resolvedOptions: void 0,
+		useImportRegister: false,
+		devEnvironment: false,
+		isPreview: false,
+		pwaAssetsGenerator: Promise.resolve(void 0),
+		build: void 0,
+		dev: void 0,
+		base: void 0,
+		swNames: {
+			hasNames: false,
+			name: "",
+			classic: "",
+			module: ""
+		},
+		sources: /* @__PURE__ */ new Set(),
+		outDir: void 0,
+		publicDir: void 0,
+		rootDir: process.cwd(),
+		customPwaAssetResolver: void 0,
+		webManifestData: void 0,
+		registerSWData: void 0,
+		runBuild: void 0,
+		injectManifestSWAtPublicDir: void 0,
+		hooks: new Hookable()
+	});
+}
+function createVitePWAContext(userOptions = {}) {
+	return createPWAContext("vite", userOptions);
+}
+function createViteLegacyPWAContext(userOptions = {}) {
+	return createPWAContext("vite-legacy", userOptions);
+}
+function createWebpackPWAContext(userOptions = {}) {
+	return createPWAContext("webpack", userOptions);
+}
+function createRspackPWAContext(userOptions = {}) {
+	return createPWAContext("rspack", userOptions);
+}
+export { createPWAContext, createRspackPWAContext, createViteLegacyPWAContext, createVitePWAContext, createWebpackPWAContext };

package/dist/create-generate-register-sw-script.d.mts

@@ -0,0 +1,15 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { PWAPluginContext } from "./context-types.mjs";
+/**
+ * Creates the `registerSW.js` script to be added to the HTML entry point.
+ * @param ctx The PWA Context.
+ * @param dev For dev server
+ * @param injectAtDev Inject the script at dev server?
+ */
+export declare function createGenerateRegisterSW(ctx: PWAPluginContext<any, any, any>, dev: boolean, injectAtDev?: boolean): Promise<string | undefined>;

package/dist/create-generate-register-sw-script.mjs

@@ -0,0 +1,27 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { FILE_SW_REGISTER } from "./constants.mjs";
+import { isDualServiceWorker } from "./dual-sw-utilities.mjs";
+import { generateRegisterSW } from "./generate-register-sw.mjs";
+// src/create-generate-register-sw-script.ts
+/**
+* Creates the `registerSW.js` script to be added to the HTML entry point.
+* @param ctx The PWA Context.
+* @param dev For dev server
+* @param injectAtDev Inject the script at dev server?
+*/
+async function createGenerateRegisterSW(ctx, dev, injectAtDev = true) {
+	if (dev && !injectAtDev) return;
+	const options = isDualServiceWorker(ctx) ? " type=\"module\"" : "";
+	if (ctx.resolvedOptions.injectRegister === "inline") return `<script id="unplugin-pwa:inline-sw"${options}>${await generateRegisterSW(ctx)}<\/script>`;
+	if (ctx.resolvedOptions.injectRegister === "script" || ctx.resolvedOptions.injectRegister === "script-defer") {
+		const hasDefer = ctx.resolvedOptions.injectRegister === "script-defer";
+		return `<script id="unplugin-pwa:register-sw" src="${dev ? ctx.resolvedOptions.base : ctx.resolvedOptions.buildBase}${FILE_SW_REGISTER}"${hasDefer ? " defer" : ""}${options}><\/script>`;
+	}
+}
+export { createGenerateRegisterSW };

package/dist/create-web-manifest-html-link.d.mts

@@ -0,0 +1,13 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { PWAPluginContext } from "./context-types.mjs";
+/**
+ * Creates the PWA web manifest link to be added to the HTML entry point.
+ * @param ctx The PWA Context.
+ */
+export declare function createWebManifestHtmlLink(ctx: PWAPluginContext<any, any, any>): string;