@unplugin-pwa/core 0.0.1 → 0.0.3

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-zuOn_aH6.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;

package/dist/create-web-manifest-html-link.mjs

@@ -0,0 +1,21 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+// src/create-web-manifest-html-link.ts
+/**
+* Creates the PWA web manifest link to be added to the HTML entry point.
+* @param ctx The PWA Context.
+*/
+function createWebManifestHtmlLink(ctx) {
+	const options = ctx.resolvedOptions;
+	const crossorigin = options.useCredentials ? " crossorigin=\"use-credentials\"" : "";
+	if (ctx.devEnvironment) {
+		const name = `${options.base}${options.manifestFilename || "manifest.webmanifest"}`;
+		return options.manifest ? `<link rel="manifest" href="${name}"${crossorigin}>` : "";
+	} else return options.manifest ? `<link rel="manifest" href="${options.buildBase}${options.manifestFilename}"${crossorigin}>` : "";
+}
+export { createWebManifestHtmlLink };

package/dist/dev/prepare-sw-names-and-glob-directory.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";
+/**
+ * Prepare the service worker names, the glob directory and the temp folder.
+ *
+ * **NOTE**: if the PWA plugin context has `swNames.hasNames` set to `true` at the dev options, this function will return immediately.
+ *
+ * @param ctx The PWA Vite plugin context.
+ */
+export declare function prepareSwNamesAndGlobDirectory<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType>(ctx: PWAPluginContext<B, UserStrategy, T>): Promise<void>;

package/dist/dev/prepare-sw-names-and-glob-directory.mjs

@@ -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 { isDualServiceWorker } from "../dual-sw-utilities.mjs";
+import { prepareTempFolder } from "./prepare-temp-folder.mjs";
+import { normalizePath, resolveSWNames } from "@vite-pwa/workbox-build/utils/resolve-sw-names";
+import path from "node:path";
+import process from "node:process";
+// src/dev/prepare-sw-names-and-glob-directory.ts
+/**
+* Prepare the service worker names, the glob directory and the temp folder.
+*
+* **NOTE**: if the PWA plugin context has `swNames.hasNames` set to `true` at the dev options, this function will return immediately.
+*
+* @param ctx The PWA Vite plugin context.
+*/
+async function prepareSwNamesAndGlobDirectory(ctx) {
+	if (ctx.dev.options.swNames.hasNames) return;
+	let options;
+	let swSrc;
+	switch (ctx.strategy) {
+		case "generate-sw":
+			swSrc = "";
+			options = ctx.resolvedOptions.generateSW;
+			break;
+		case "inject-manifest":
+			options = ctx.resolvedOptions.injectManifest;
+			swSrc = ctx.resolvedOptions.injectManifest.swSrc;
+			break;
+		case "build-sw":
+			options = ctx.resolvedOptions.buildSW;
+			swSrc = ctx.resolvedOptions.buildSW.swSrc;
+	}
+	if (options) {
+		await prepareTempFolder(ctx);
+		const internalDevOptions = ctx.dev.options;
+		const folder = internalDevOptions.tempFolder;
+		const root = process.cwd();
+		let relativeSwDest;
+		let devSWDest;
+		if (path.isAbsolute(ctx.outDir)) devSWDest = normalizePath(path.relative(root, path.resolve(folder, options.swDest)));
+		else {
+			const outputFolder = path.resolve(process.cwd(), ctx.outDir);
+			relativeSwDest = path.relative(outputFolder, options.swDest);
+			devSWDest = normalizePath(path.relative(root, path.resolve(folder, relativeSwDest)));
+		}
+		const { swDest, swDestPath, classicSWDest, classicSWDestPath, moduleSWDest, moduleSWDestPath } = resolveSWNames(devSWDest, swSrc, ctx.strategy === "generate-sw");
+		if (isDualServiceWorker(ctx)) {
+			if (ctx.resolvedOptions.devOptions?.type === "module") {
+				internalDevOptions.swName = moduleSWDest;
+				internalDevOptions.swType = "module";
+			} else {
+				internalDevOptions.swName = classicSWDest;
+				internalDevOptions.swType = "classic";
+			}
+		} else {
+			internalDevOptions.swName = swDest;
+			internalDevOptions.swType = ctx.resolvedOptions.devOptions?.type === "module" ? "module" : "classic";
+		}
+		internalDevOptions.globDirectory = normalizePath(path.relative(root, folder));
+		internalDevOptions.swNames.devSWDest = devSWDest;
+		internalDevOptions.swNames.path = normalizePath(path.resolve(root, swDest));
+		internalDevOptions.swNames.name = swDestPath;
+		internalDevOptions.swNames.classic = classicSWDestPath;
+		internalDevOptions.swNames.classicPath = normalizePath(path.resolve(root, classicSWDest));
+		internalDevOptions.swNames.module = moduleSWDestPath;
+		internalDevOptions.swNames.modulePath = normalizePath(path.resolve(root, moduleSWDest));
+		internalDevOptions.swNames.hasNames = true;
+	}
+}
+export { prepareSwNamesAndGlobDirectory };

package/dist/dev/prepare-temp-folder.d.mts

@@ -0,0 +1,9 @@
+/*!
+  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";
+export declare function prepareTempFolder(ctx: PWAPluginContext<any, any, any>): Promise<void>;

package/dist/dev/prepare-temp-folder.mjs

@@ -0,0 +1,44 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+// src/dev/prepare-temp-folder.ts
+function tryStatSync(file) {
+	try {
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+function findNearestNodeModules(basedir) {
+	while (basedir) {
+		const pkgPath = path.join(basedir, "node_modules");
+		if (tryStatSync(pkgPath)?.isDirectory()) return pkgPath;
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
+}
+function resolveTempFolder() {
+	const base = pathToFileURL(`${process.cwd()}/`).href;
+	const nodeModulesDir = typeof process.versions.deno === "string" ? void 0 : findNearestNodeModules(base);
+	return nodeModulesDir ? path.resolve(nodeModulesDir, ".pwa-dev-dist") : path.resolve(process.cwd(), base, ".pwa-dev-dist");
+}
+async function prepareTempFolder(ctx) {
+	const internalOptions = ctx.dev.options;
+	const tempFolderResolver = ctx.resolvedOptions.devOptions?.resolveTempFolder;
+	const tempFolder = internalOptions.tempFolder ? internalOptions.tempFolder : tempFolderResolver ? await tempFolderResolver() : resolveTempFolder();
+	fs.rmSync(tempFolder, {
+		force: true,
+		recursive: true
+	});
+	fs.mkdirSync(tempFolder, { recursive: true });
+	ctx.dev.options.tempFolder = tempFolder;
+}
+export { prepareTempFolder };

package/dist/dual-sw-utilities.d.mts

@@ -0,0 +1,9 @@
+/*!
+  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";
+export declare function isDualServiceWorker(ctx: PWAPluginContext<any, any, any>): boolean;

package/dist/dual-sw-utilities.mjs

@@ -0,0 +1,16 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+// src/dual-sw-utilities.ts
+function isDualServiceWorker(ctx) {
+	switch (ctx.strategy) {
+		case "generate-sw": return ctx.resolvedOptions.generateSW?.swType === "classic-and-module";
+		case "build-sw": return ctx.resolvedOptions.buildSW?.swType === "classic-and-module";
+	}
+	return false;
+}
+export { isDualServiceWorker };

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

@@ -0,0 +1,14 @@
+/*!
+  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";
+/**
+ * Generates `registerSW.js` file for the service worker registration.
+ * @param ctx The PWA plugin context.
+ * @return The code of `registerSW.js` or `undefined` if it is not required.
+ */
+export declare function generateRegisterSW(ctx: PWAPluginContext<any, any, any>): Promise<string | undefined>;

package/dist/generate-register-sw.mjs

@@ -0,0 +1,22 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import "./constants.mjs";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+// src/generate-register-sw.ts
+/**
+* Generates `registerSW.js` file for the service worker registration.
+* @param ctx The PWA plugin context.
+* @return The code of `registerSW.js` or `undefined` if it is not required.
+*/
+async function generateRegisterSW(ctx) {
+	if (ctx.resolvedOptions.injectRegister === "auto") ctx.resolvedOptions.injectRegister = ctx.useImportRegister ? null : "script";
+	if (!(ctx.resolvedOptions.injectRegister === "script" || ctx.resolvedOptions.injectRegister === "script-defer") || existsSync(resolve(ctx.publicDir, "registerSW.js"))) return;
+	return await ctx.customPwaAssetResolver("register-sw");
+}
+export { generateRegisterSW };

package/dist/generate-web-manifest.d.mts

@@ -0,0 +1,9 @@
+/*!
+  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";
+export declare function generateWebManifest(ctx: PWAPluginContext<any, any, any>): string;

package/dist/generate-web-manifest.mjs

@@ -0,0 +1,12 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+// src/generate-web-manifest.ts
+function generateWebManifest(ctx) {
+	return `${JSON.stringify(ctx.resolvedOptions.manifest, null, ctx.resolvedOptions.minify ? 0 : 2)}\n`;
+}
+export { generateWebManifest };

package/dist/helpers.d.mts

@@ -0,0 +1,33 @@
+/*!
+  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 { ManifestEntry, SWType } from "@vite-pwa/workbox-build/types";
+export declare function normalizePath(path: string): string;
+export declare function resolveFrom(base: string, value: string): string;
+export declare function resolveSWSrc(base: string, value: string): string;
+export declare function isAbsolute(url: string): RegExpMatchArray | null;
+export declare function resolveBasePath(base: string): string;
+export declare function prepareAdditionalManifestEntriesGenerator(ctx: PWAPluginContext<any, any, any>): () => AsyncGenerator<string | ManifestEntry, undefined, void>;
+/**
+ * Loads the default manifest and normalizes the manifest icons' purpose and scope_extensions.
+ *
+ * **NOTE**: this function calls `prepareManifest` to load the default manifest.
+ *
+ * @param ctx The resolved Vite PWA plugin context
+ */
+export declare function normalizeManifest(ctx: PWAPluginContext<any, any, any>): void;
+export declare function preparePWAAssetsGenerator<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType>(ctx: PWAPluginContext<B, UserStrategy, T>): void;
+/**
+ * Configures the PWA strategy at the resolved PWA options.
+ * @param ctx The PWA context.
+ * @param cwd The current working directory.
+ * @param outDir The output directory.
+ * @param immutableAssets The immutable assets directory.
+ */
+export declare function preparePWAStrategy<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType>(ctx: PWAPluginContext<B, UserStrategy, T>, cwd: string, outDir: string, immutableAssets: string): Promise<void>;