@unplugin-pwa/core 0.0.1 → 0.0.2

package/dist/additional-manifest-entries.d.mts

@@ -0,0 +1,10 @@
+/*!
+  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";
+import { ManifestEntry } from "@vite-pwa/workbox-build/types";
+export declare function additionalManifestEntriesFactory(ctx: PWAPluginContext<any, any, any>, mapFile: (url: string) => string): () => AsyncGenerator<string | ManifestEntry, undefined, void>;

package/dist/additional-manifest-entries.mjs

@@ -0,0 +1,60 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { generateWebManifest } from "./generate-web-manifest.mjs";
+// src/additional-manifest-entries.ts
+function additionalManifestEntriesFactory(ctx, mapFile) {
+	return async function* additionalManifestEntries() {
+		const { includeManifest, includeManifestIcons, includeAssets, includeManifestShortcutIcons, includeManifestScreenshots } = ctx.resolvedOptions;
+		if (includeManifest || includeManifestIcons || includeAssets || includeManifestScreenshots || includeManifestShortcutIcons) {
+			const manifest = ctx.resolvedOptions.manifest;
+			const [{ hash }, { readFile }] = await Promise.all([import("node:crypto"), import("node:fs/promises")]);
+			if (manifest) {
+				if (includeManifest) yield {
+					url: ctx.resolvedOptions.manifestFilename,
+					revision: hash("md5", generateWebManifest(ctx), "hex")
+				};
+				if (includeManifestIcons && manifest.icons) {
+					const consumerIcons = /* @__PURE__ */ new Set();
+					if (ctx.consumerOptions.manifest && ctx.consumerOptions.manifest.icons) {
+						for (const icon of ctx.consumerOptions.manifest.icons) if (icon.src) consumerIcons.add(mapFile(icon.src));
+					}
+					for (const icon of manifest.icons) if (icon.src) {
+						const path = mapFile(icon.src);
+						if (!consumerIcons.has(path)) continue;
+						yield {
+							url: icon.src,
+							revision: hash("md5", await readFile(path, "utf-8"), "hex")
+						};
+					}
+				}
+				if (includeManifestShortcutIcons && manifest.shortcuts) {
+					for (const shortcut of manifest.shortcuts) if (shortcut.icons) {
+						for (const icons of shortcut.icons) if (icons.src) yield {
+							url: icons.src,
+							revision: hash("md5", await readFile(mapFile(icons.src), "utf-8"), "hex")
+						};
+					}
+				}
+				if (includeManifestScreenshots && manifest.screenshots) for (const screenshot of manifest.screenshots) yield {
+					url: screenshot.src,
+					revision: hash("md5", await readFile(mapFile(screenshot.src), "utf-8"), "hex")
+				};
+				if (includeAssets) {
+					const assets = typeof includeAssets === "string" ? [includeAssets] : includeAssets;
+					for (const asset of assets) yield {
+						url: asset,
+						revision: hash("md5", await readFile(mapFile(asset), "utf-8"), "hex")
+					};
+				}
+			}
+		}
+		const consumerGenerator = ctx.consumerOptions.additionalManifestEntriesGenerator;
+		if (consumerGenerator) yield* consumerGenerator();
+	};
+}
+export { additionalManifestEntriesFactory };

package/dist/build-pwa-asset.d.mts

@@ -0,0 +1,18 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { w as VitePWAStrategy } from "./types-BhwjnGLn.mjs";
+import { Bundler, PWAPluginContext } from "./context-types.mjs";
+import { SWType } from "@vite-pwa/workbox-build/types";
+export type DependenciesResolved = NonNullable<Pick<import('rolldown').Plugin, 'resolveId' | 'load'>>;
+/**
+ * This module will build `registerSW` or any virtual module.
+ * @param code The code to build.
+ * @param ctx The context of the PWA bundler.
+ * @param resolver Rolldown hooks to resolve dependencies.
+ */
+export declare function buildPwaAsset<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType>(code: string, ctx: PWAPluginContext<B, UserStrategy, T>, resolver?: DependenciesResolved): Promise<string>;

package/dist/build-pwa-asset.mjs

@@ -0,0 +1,87 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { resolveSWNames } from "@vite-pwa/workbox-build/utils/resolve-sw-names";
+// src/build-pwa-asset.ts
+/**
+* This module will build `registerSW` or any virtual module.
+* @param code The code to build.
+* @param ctx The context of the PWA bundler.
+* @param resolver Rolldown hooks to resolve dependencies.
+*/
+async function buildPwaAsset(code, ctx, resolver) {
+	const { filename = "sw.js" } = ctx.consumerOptions;
+	const { strategy, scope, buildBase, base: useBase, buildSW, injectManifest, updateViaCache } = ctx.resolvedOptions;
+	const useGenerateSW = strategy === "generate-sw";
+	const { swDestPath, classicSWDestPath, moduleSWDestPath } = resolveSWNames(filename, strategy === "generate-sw" ? "" : strategy === "build-sw" ? buildSW.swSrc : injectManifest.swSrc, useGenerateSW);
+	let swType = "classic";
+	if (ctx.devEnvironment) {
+		if (ctx.resolvedOptions.devOptions?.type === "module") swType = "module";
+	} else if (ctx.resolvedOptions.swType === "module") swType = "module";
+	const devEnabled = ctx.resolvedOptions.devOptions?.enabled === true;
+	const base = ctx.devEnvironment ? useBase : buildBase;
+	return await buildPwaAssetWithRolldown(code, {
+		"import.meta.PWA_ESM_FALLBACK_SW": JSON.stringify(ctx.resolvedOptions.swType === "classic-and-module"),
+		"import.meta.PWA_SELF_DESTROYING_SW": JSON.stringify(ctx.strategy === "self-destroy-sw"),
+		"import.meta.PWA_SW_URL": JSON.stringify(`${base}${swDestPath}`),
+		"import.meta.PWA_SW_CLASSIC_URL": JSON.stringify(`${base}${classicSWDestPath}`),
+		"import.meta.PWA_SW_MODULE_URL": JSON.stringify(`${base}${moduleSWDestPath}`),
+		"import.meta.PWA_SW_SCOPE": JSON.stringify(scope),
+		"import.meta.PWA_SW_TYPE": JSON.stringify(swType),
+		"import.meta.PWA_SW_UPDATE_VIA_CACHE": JSON.stringify(updateViaCache),
+		"import.meta.PWA_DEV_SERVER": JSON.stringify(ctx.devEnvironment),
+		"import.meta.PWA_SW_AUTO_UPDATE": JSON.stringify(ctx.resolvedOptions.registerType === "autoUpdate"),
+		"import.meta.PWA_DEV_ENABLED": JSON.stringify(devEnabled),
+		"import.meta.PWA_DEV_UI_ENABLED": JSON.stringify(devEnabled && ctx.resolvedOptions.devOptions?.enableUISwitcher === true),
+		"import.meta.PWA_DEV_CURRENT_SW_TYPE": JSON.stringify(ctx.dev.options.swType)
+	}, ctx.devEnvironment, ctx.resolvedOptions.minify, resolver);
+}
+async function writeAsset(instance, options) {
+	try {
+		return await instance.generate(options);
+	} finally {
+		await instance.close();
+	}
+}
+async function buildPwaAssetWithRolldown(code, define, isDev, minify, resolver) {
+	const { rolldown } = await import("rolldown");
+	const input = "asset.js";
+	const plugins = [{
+		name: "pwa-asset-resolver",
+		resolveId(id) {
+			return id === input ? input : void 0;
+		},
+		load(id) {
+			return id === input ? code : void 0;
+		}
+	}];
+	if (resolver) plugins.push({
+		name: "pwa-asset-custom-resolver",
+		resolveId: resolver.resolveId,
+		load: resolver.load
+	});
+	return (await writeAsset(await rolldown({
+		input,
+		platform: "browser",
+		treeshake: true,
+		logLevel: "warn",
+		plugins,
+		transform: { define }
+	}), {
+		format: "esm",
+		topLevelVar: true,
+		cleanDir: false,
+		comments: {
+			legal: !isDev && !minify,
+			jsdoc: false,
+			annotation: false
+		},
+		minify: isDev ? false : minify,
+		codeSplitting: false
+	})).output.find((e) => e.fileName === input && e.type === "chunk").code;
+}
+export { buildPwaAsset };

package/dist/config.d.mts

@@ -0,0 +1,75 @@
+/*!
+  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, y as ResolvedVitePWAOptions } from "./types-BhwjnGLn.mjs";
+import { ExtractStrategy } from "./context-types.mjs";
+import { SWType } from "@vite-pwa/workbox-build/types";
+export declare const DEFAULT_CONFIG_FILES: readonly ["pwa.config.js", "pwa.config.ts", "pwa.config.mjs", "pwa.config.mts"];
+export type LoaderType<S extends VitePWAStrategy, T extends SWType> = VitePWAOptions<S, T> | (() => VitePWAOptions<S, T>) | (() => Promise<VitePWAOptions<S, T>>);
+/**
+ * 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.
+ */
+export declare function loadConfiguration<S extends VitePWAStrategy, T extends SWType>(options: Partial<VitePWAOptions<S, T>>): Promise<Partial<VitePWAOptions<S, T>>>;
+/**
+ * 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.
+ */
+export declare function resolveDefaultConfig(cwd?: string): string | undefined;
+/**
+ * Loads the default manifest using the `package.json` file.
+ *
+ * @param options The resolved PWA options.
+ */
+export declare function prepareManifest(options: ResolvedVitePWAOptions<any, any>): void;
+/**
+ * The resolver options containing environment information and callbacks for `resolvePwaConfiguration`.
+ */
+export interface ResolverOptions {
+  /**
+   * Whether the current environment is a development environment.
+   */
+  isDev: boolean;
+  /**
+   * When using `inject-manifest`, this 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
+   */
+  isWrongInjectManifest: (swSrc: string) => boolean | Promise<boolean>;
+}
+/**
+ * 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.
+ */
+export declare function resolvePwaConfiguration<UserStrategy extends VitePWAStrategy, T extends SWType>(pwaOptions: Partial<VitePWAOptions<UserStrategy, T>>, resolverOptions: ResolverOptions): Promise<ResolvedVitePWAOptions<ExtractStrategy<UserStrategy>, T>>;

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 };