@unplugin-pwa/core 0.0.0 → 0.0.2

package/dist/logs.mjs

@@ -0,0 +1,19 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { INSPECTOR_BASE_PATH } from "./constants.mjs";
+import { errStyle } from "@vite-pwa/workbox-build/utils/colors";
+// src/logs.ts
+const inspectorWithInjectManifestWarning = [
+	`\n${errStyle(["yellow", "bold"], "[Vite PWA]")} ${errStyle("yellow", "Vite PWA Inspector won't work as expected")}:\n`,
+	`You are using ${errStyle("cyan", "inject-manifest")} strategy, your service worker is ${errStyle("cyan", "static")}.`,
+	`If you want to see ${errStyle("cyan", "Vite PWA Inspector")}, you can:`,
+	`  - use hard refresh when opening ${errStyle("cyan", "Vite PWA Inspector")} page to bypass the service worker interception or`,
+	`  - you can add ${errStyle("green", `'${INSPECTOR_BASE_PATH}'`)} to your ${errStyle("cyan", "NavigationRoute denylist option")}:`,
+	`    ${errStyle("green", "registerRoute(new NavigationRoute(createHandlerBoundToURL('index.html'), { denylist: [/^\\/__unplugin_pwa_inspector/] }))")}\n`
+].join("\n");
+export { inspectorWithInjectManifestWarning };

package/dist/package-DpKc2x3j.mjs

@@ -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.
+*/
+// package.json
+var version = "0.0.2";
+export { version as t };

package/dist/prepare-pwa-context.d.mts

@@ -0,0 +1,11 @@
+/*!
+  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 declare function preparePWAContext<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType>(ctx: PWAPluginContext<B, UserStrategy, T>): PWAPluginContext<B, UserStrategy, T>;

package/dist/prepare-pwa-context.mjs

@@ -0,0 +1,135 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { DEV_SW_NAME, FILE_SW_REGISTER } from "./constants.mjs";
+import { isDualServiceWorker } from "./dual-sw-utilities.mjs";
+import { createGenerateRegisterSW } from "./create-generate-register-sw-script.mjs";
+import { createWebManifestHtmlLink } from "./create-web-manifest-html-link.mjs";
+// src/prepare-pwa-context.ts
+function preparePWAContext(ctx) {
+	ctx.webManifestData = () => {
+		const options = ctx.resolvedOptions;
+		if (!options.manifest) return void 0;
+		const url = options.manifestFilename;
+		const manifest = createWebManifestHtmlLink(ctx);
+		return {
+			href: `${ctx.devEnvironment ? options.base : options.buildBase}${url}`,
+			useCredentials: options.useCredentials,
+			toLinkTag: () => {
+				return manifest;
+			}
+		};
+	};
+	ctx.registerSWData = async () => {
+		const options = ctx.resolvedOptions;
+		if (options.disable || ctx.devEnvironment && !options.devOptions?.enabled) return void 0;
+		let mode = options.injectRegister;
+		if (!mode || ctx.useImportRegister) return;
+		if (mode === "auto") {
+			options.injectRegister = "script";
+			mode = "script";
+		}
+		let type = "classic";
+		let script;
+		let shouldRegisterSW = options.injectRegister === "inline" || options.injectRegister === "script" || options.injectRegister === "script-defer";
+		if (ctx.devEnvironment) {
+			if (options.devOptions?.enabled === true) {
+				type = options.devOptions?.type ?? "classic";
+				script = await createGenerateRegisterSW(ctx, true, true);
+				shouldRegisterSW = true;
+			}
+		} else {
+			script = await createGenerateRegisterSW(ctx, false, true);
+			shouldRegisterSW = true;
+		}
+		const base = ctx.devEnvironment ? options.base : options.buildBase;
+		return {
+			shouldRegisterSW,
+			module: isDualServiceWorker(ctx),
+			mode,
+			scope: options.scope,
+			inlinePath: `${base}${ctx.devEnvironment ? DEV_SW_NAME : FILE_SW_REGISTER}`,
+			registerPath: `${base}${FILE_SW_REGISTER}`,
+			type,
+			toScriptTag: () => {
+				return script;
+			}
+		};
+	};
+	ctx.build = {
+		generateSW: async () => {
+			switch (ctx.bundler) {
+				case "vite": return await import("@vite-pwa/workbox-build/build/vite/generate-sw").then(({ generateSW: runGenerateSW }) => runGenerateSW(ctx.resolvedOptions.generateSW));
+				case "vite-legacy": return await import("@vite-pwa/workbox-build/build/vite/legacy-generate-sw").then(({ generateSWLegacy: runGenerateSWLegacy }) => runGenerateSWLegacy(ctx.resolvedOptions.generateSW));
+				case "rspack":
+				case "webpack": return await import("@vite-pwa/workbox-build/build/rolldown/generate-sw").then(({ generateSW: runGenerateSW }) => runGenerateSW(ctx.resolvedOptions.generateSW));
+			}
+		},
+		buildSW: async () => {
+			switch (ctx.bundler) {
+				case "vite": return await import("@vite-pwa/workbox-build/build/vite/build-sw").then(({ buildSW: runBuildSW }) => runBuildSW(ctx.resolvedOptions.buildSW));
+				case "vite-legacy": return await import("@vite-pwa/workbox-build/build/vite/legacy-build-sw").then(({ buildSWLegacy: runBuildSWLegacy }) => runBuildSWLegacy(ctx.resolvedOptions.buildSW));
+				case "rspack":
+				case "webpack": return await import("@vite-pwa/workbox-build/build/rolldown/build-sw").then(({ buildSW: runBuildSW }) => runBuildSW(ctx.bundler === "webpack" ? ctx.resolvedOptions.buildSW : ctx.resolvedOptions.buildSW));
+			}
+		},
+		injectManifest: () => import("@vite-pwa/workbox-build/inject-manifest").then(({ injectManifest: runInjectManifest }) => runInjectManifest(ctx.resolvedOptions.injectManifest)),
+		selfDestroyingSW: () => import("@vite-pwa/workbox-build/self-destroying-sw").then(({ selfDestroyingSW: runSelfDestroyingSW }) => runSelfDestroyingSW(ctx.resolvedOptions.selfDestroying)).then(() => Promise.resolve(true))
+	};
+	ctx.dev = {
+		options: {
+			swName: "",
+			swGenerated: false,
+			registerSWGenerated: false,
+			registerVirtualSWGenerated: false,
+			hmrEntryPointGenerated: false,
+			swType: ctx.consumerOptions.devOptions?.type ?? "classic",
+			swAssetKeys: /* @__PURE__ */ new Set(),
+			swAssetsPaths: /* @__PURE__ */ new Map(),
+			tempFolder: void 0,
+			swNames: {
+				hasNames: false,
+				name: "",
+				classic: "",
+				module: "",
+				path: "",
+				classicPath: "",
+				modulePath: "",
+				devSWDest: ""
+			},
+			globDirectory: ""
+		},
+		generateSW: async (options) => {
+			switch (ctx.bundler) {
+				case "vite": return await import("@vite-pwa/workbox-build/build/vite/generate-sw").then(({ generateSW: runGenerateSW }) => runGenerateSW(Object.assign({}, ctx.resolvedOptions.generateSW ?? {}, options)));
+				case "vite-legacy": return await import("@vite-pwa/workbox-build/build/vite/legacy-generate-sw").then(({ generateSWLegacy: runGenerateSWLegacy }) => runGenerateSWLegacy(Object.assign({}, ctx.resolvedOptions.generateSW ?? {}, options)));
+				case "rspack":
+				case "webpack": return await import("@vite-pwa/workbox-build/build/rolldown/generate-sw").then(({ generateSW: runGenerateSW }) => runGenerateSW(Object.assign({}, ctx.resolvedOptions.generateSW ?? {}, options)));
+			}
+		},
+		buildSW: async (options) => {
+			switch (ctx.bundler) {
+				case "vite": return await import("@vite-pwa/workbox-build/build/vite/build-sw").then(({ buildSW: runBuildSW }) => runBuildSW(Object.assign({}, ctx.resolvedOptions.buildSW ?? {}, options)));
+				case "vite-legacy": return await import("@vite-pwa/workbox-build/build/vite/legacy-build-sw").then(({ buildSWLegacy: runBuildSWLegacy }) => runBuildSWLegacy(Object.assign({}, ctx.resolvedOptions.buildSW ?? {}, options)));
+				case "rspack":
+				case "webpack": return await import("@vite-pwa/workbox-build/build/rolldown/build-sw").then(({ buildSW: runBuildSW }) => runBuildSW(ctx.bundler === "webpack" ? Object.assign({}, ctx.resolvedOptions.buildSW ?? {}, options) : Object.assign({}, ctx.resolvedOptions.buildSW ?? {}, options)));
+			}
+		},
+		injectManifest: (options) => import("@vite-pwa/workbox-build/inject-manifest").then(({ injectManifest: runInjectManifest }) => runInjectManifest(Object.assign({}, ctx.resolvedOptions.injectManifest ?? {}, options))),
+		selfDestroyingSW: (options) => import("@vite-pwa/workbox-build/self-destroying-sw").then(({ selfDestroyingSW: runSelfDestroyingSW }) => runSelfDestroyingSW(options)).then(() => Promise.resolve(true))
+	};
+	ctx.runBuild = async () => {
+		switch (ctx.strategy) {
+			case "self-destroy-sw": return await ctx.build.selfDestroyingSW();
+			case "build-sw": return await ctx.build.buildSW();
+			case "generate-sw": return await ctx.build.generateSW();
+			case "inject-manifest": return await ctx.build.injectManifest();
+		}
+	};
+	return ctx;
+}
+export { preparePWAContext };

package/dist/prepare-sw-names.d.mts

@@ -0,0 +1,11 @@
+/*!
+  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 declare function prepareSwNames<B extends Bundler, UserStrategy extends VitePWAStrategy, T extends SWType>(ctx: PWAPluginContext<B, UserStrategy, T>): void;

package/dist/prepare-sw-names.mjs

@@ -0,0 +1,45 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { normalizePath as normalizePath$1 } from "./helpers.mjs";
+import { extractSwDestNameFromSource, resolveSWNames } from "@vite-pwa/workbox-build/utils/resolve-sw-names";
+import path from "node:path";
+// src/prepare-sw-names.ts
+function prepareSwNames(ctx) {
+	let options;
+	let filename;
+	let swSrc;
+	switch (ctx.strategy) {
+		case "generate-sw":
+			swSrc = "";
+			options = ctx.resolvedOptions.generateSW;
+			filename = ctx.consumerOptions.filename = normalizePath$1(path.resolve(ctx.outDir, ctx.consumerOptions.filename || "sw.js"));
+			ctx.resolvedOptions.generateSW.swDest = filename;
+			break;
+		case "inject-manifest":
+			options = ctx.resolvedOptions.injectManifest;
+			swSrc = ctx.resolvedOptions.injectManifest.swSrc;
+			filename = ctx.consumerOptions.filename = normalizePath$1(path.resolve(ctx.outDir, ctx.consumerOptions.filename || extractSwDestNameFromSource(swSrc)));
+			ctx.resolvedOptions.injectManifest.swDest = filename;
+			break;
+		case "build-sw":
+			options = ctx.resolvedOptions.buildSW;
+			swSrc = extractSwDestNameFromSource(ctx.resolvedOptions.buildSW.swSrc);
+			filename = ctx.consumerOptions.filename = normalizePath$1(path.resolve(ctx.outDir, ctx.consumerOptions.filename || extractSwDestNameFromSource(swSrc)));
+			ctx.resolvedOptions.buildSW.swDest = filename;
+	}
+	if (options) {
+		const { swDest, classicSWDest, moduleSWDest } = resolveSWNames(filename, swSrc, ctx.strategy === "generate-sw");
+		ctx.swNames = {
+			hasNames: true,
+			name: swDest,
+			classic: classicSWDest,
+			module: moduleSWDest
+		};
+	}
+}
+export { prepareSwNames };

package/dist/pwa-assets/build.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 { t as AssetsGeneratorContext } from "../types-B60e7Nq4.mjs";
+export declare function generate(assetsGeneratorContext: AssetsGeneratorContext): Promise<void>;

package/dist/pwa-assets/build.mjs

@@ -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 { mkdir } from "node:fs/promises";
+import { generateAssets } from "@vite-pwa/assets-generator/api/generate-assets";
+// src/pwa-assets/build.ts
+async function generate(assetsGeneratorContext) {
+	await mkdir(assetsGeneratorContext.imageOutDir, { recursive: true });
+	await generateAssets(assetsGeneratorContext.assetsInstructions, true, assetsGeneratorContext.imageOutDir);
+}
+export { generate };

package/dist/pwa-assets/config.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 { t as AssetsGeneratorContext } from "../types-B60e7Nq4.mjs";
+import { PWAPluginContext } from "../context-types.mjs";
+export declare function loadAssetsGeneratorContext(ctx: PWAPluginContext<any, any, any>, assetsGeneratorContext?: AssetsGeneratorContext): Promise<AssetsGeneratorContext | undefined>;

package/dist/pwa-assets/config.mjs

@@ -0,0 +1,136 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { normalizePath } from "../helpers.mjs";
+import fs from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+import { errStyle } from "@vite-pwa/workbox-build/utils/colors";
+import { access, readFile } from "node:fs/promises";
+import { instructions } from "@vite-pwa/assets-generator/api/instructions";
+import { loadConfig } from "@vite-pwa/assets-generator/config";
+// src/pwa-assets/config.ts
+async function loadAssetsGeneratorContext(ctx, assetsGeneratorContext) {
+	const root = ctx.rootDir;
+	const { config, sources } = await loadConfiguration(root, ctx);
+	if (!config.preset) {
+		console.error([
+			"",
+			errStyle("cyan", `PWA v${ctx.version}`),
+			errStyle("red", "ERROR: No preset for assets generator found")
+		].join("\n"));
+		return;
+	}
+	const { preset, images, headLinkOptions: userHeadLinkOptions } = config;
+	if (!images) {
+		console.error([
+			"",
+			errStyle("cyan", `PWA v${ctx.version}`),
+			errStyle("red", "ERROR: No image provided for assets generator")
+		].join("\n"));
+		return;
+	}
+	if (Array.isArray(images)) {
+		if (!images.length) {
+			console.error([
+				"",
+				errStyle("cyan", `PWA v${ctx.version}`),
+				errStyle("red", "ERROR: No image provided for assets generator")
+			].join("\n"));
+			return;
+		}
+		if (images.length > 1) {
+			console.error([
+				"",
+				errStyle("cyan", `PWA v${ctx.version}`),
+				errStyle("red", "ERROR: Only one image is supported for assets generator")
+			].join("\n"));
+			return;
+		}
+	}
+	const pwaAssets = ctx.resolvedOptions.pwaAssets;
+	const image = await pwaAssets.integration?.resolveImage?.(Array.isArray(images) ? images[0] : images);
+	const useImage = image ?? (Array.isArray(images) ? images[0] : images);
+	const imageFile = image ?? await tryToResolveImage(root, sources, useImage);
+	const publicDir = image ? dirname(image) : pwaAssets.integration?.publicDir ?? resolve(root, ctx.publicDir);
+	const outDir = pwaAssets.integration?.outDir ?? resolve(root, ctx.outDir);
+	const imageName = relative(publicDir, imageFile);
+	const imageOutDir = dirname(resolve(outDir, imageName));
+	const xhtml = userHeadLinkOptions?.xhtml === true;
+	const includeId = userHeadLinkOptions?.includeId === true;
+	const assetsInstructions = await instructions({
+		imageResolver: () => readFile(imageFile),
+		imageName,
+		preset,
+		faviconPreset: userHeadLinkOptions?.preset ?? pwaAssets.htmlPreset,
+		htmlLinks: {
+			xhtml,
+			includeId
+		},
+		basePath: pwaAssets.integration?.baseUrl || ctx.base,
+		resolveSvgName: userHeadLinkOptions?.resolveSvgName ?? ((name) => basename(name))
+	});
+	const { includeHtmlHeadLinks = true, overrideManifestIcons: useOverrideManifestIcons, injectThemeColor = false } = pwaAssets;
+	const overrideManifestIcons = ctx.resolvedOptions.manifest === false || !ctx.resolvedOptions.manifest ? false : "icons" in ctx.resolvedOptions.manifest ? useOverrideManifestIcons : true;
+	if (assetsGeneratorContext === void 0) return {
+		lastModified: Date.now(),
+		assetsInstructions,
+		cache: /* @__PURE__ */ new Map(),
+		useImage,
+		imageFile,
+		publicDir,
+		outDir,
+		imageName,
+		imageOutDir,
+		xhtml,
+		includeId,
+		sources: sources.map((source) => normalizePath(source)),
+		injectThemeColor,
+		includeHtmlHeadLinks,
+		overrideManifestIcons
+	};
+	assetsGeneratorContext.lastModified = Date.now();
+	assetsGeneratorContext.assetsInstructions = assetsInstructions;
+	assetsGeneratorContext.useImage = useImage;
+	assetsGeneratorContext.imageFile = imageFile;
+	assetsGeneratorContext.outDir = outDir;
+	assetsGeneratorContext.imageName = imageName;
+	assetsGeneratorContext.imageOutDir = imageOutDir;
+	assetsGeneratorContext.xhtml = xhtml;
+	assetsGeneratorContext.includeId = includeId;
+	assetsGeneratorContext.injectThemeColor = injectThemeColor;
+	assetsGeneratorContext.includeHtmlHeadLinks = includeHtmlHeadLinks;
+	assetsGeneratorContext.overrideManifestIcons = overrideManifestIcons;
+	assetsGeneratorContext.cache.clear();
+}
+async function loadConfiguration(root, ctx) {
+	const pwaAssets = ctx.resolvedOptions.pwaAssets;
+	if (pwaAssets.config === false) return await loadConfig(root, {
+		config: false,
+		preset: pwaAssets.preset,
+		images: pwaAssets.images,
+		logLevel: "silent"
+	});
+	return await loadConfig(root, typeof pwaAssets.config === "boolean" ? root : { config: pwaAssets.config });
+}
+async function checkFileExists(pathname) {
+	try {
+		await access(pathname, fs.constants.R_OK);
+	} catch {
+		return false;
+	}
+	return true;
+}
+async function tryToResolveImage(root, sources, image) {
+	const imagePath = resolve(root, image);
+	if (await checkFileExists(imagePath)) return imagePath;
+	for (const source of sources) {
+		const sourceImage = resolve(dirname(source), image);
+		if (await checkFileExists(sourceImage)) return sourceImage;
+	}
+	return imagePath;
+}
+export { loadAssetsGeneratorContext };

package/dist/pwa-assets/dev.d.mts

@@ -0,0 +1,11 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { s as ResolvedIconAsset, t as AssetsGeneratorContext } from "../types-B60e7Nq4.mjs";
+import { PWAPluginContext } from "../context-types.mjs";
+export declare function findIconAsset(path: string, { assetsInstructions, cache, lastModified }: AssetsGeneratorContext): ResolvedIconAsset | undefined;
+export declare function checkHotUpdate(file: string, ctx: PWAPluginContext<any, any, any>, assetsGeneratorContext: AssetsGeneratorContext): Promise<boolean>;

package/dist/pwa-assets/dev.mjs

@@ -0,0 +1,35 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { loadAssetsGeneratorContext } from "./config.mjs";
+// src/pwa-assets/dev.ts
+function findIconAsset(path, { assetsInstructions, cache, lastModified }) {
+	let resolved = cache.get(path);
+	if (resolved) {
+		resolved.age = Date.now() - lastModified;
+		return resolved;
+	}
+	const iconAsset = assetsInstructions.transparent[path] ?? assetsInstructions.maskable[path] ?? assetsInstructions.apple[path] ?? assetsInstructions.favicon[path] ?? assetsInstructions.appleSplashScreen[path];
+	if (!iconAsset) return;
+	if (iconAsset) {
+		resolved = {
+			path,
+			mimeType: iconAsset.mimeType,
+			buffer: iconAsset.buffer(),
+			lastModified: Date.now(),
+			age: 0
+		};
+		cache.set(path, resolved);
+		return resolved;
+	}
+}
+async function checkHotUpdate(file, ctx, assetsGeneratorContext) {
+	const result = assetsGeneratorContext.sources.includes(file);
+	if (result) await loadAssetsGeneratorContext(ctx, assetsGeneratorContext);
+	return result;
+}
+export { checkHotUpdate, findIconAsset };

package/dist/pwa-assets/generator.d.mts

@@ -0,0 +1,20 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { a as PWAHtmlAssets, i as PWAAssetsIcons, s as ResolvedIconAsset } from "../types-B60e7Nq4.mjs";
+import { PWAPluginContext } from "../context-types.mjs";
+export declare function loadInstructions(ctx: PWAPluginContext<any, any, any>): Promise<{
+  sources: () => string[];
+  generate: () => Promise<void>;
+  findIconAsset: (path: string) => ResolvedIconAsset | undefined;
+  resolveHtmlAssets: () => PWAHtmlAssets;
+  transformIndexHtml: (html: string) => string;
+  injectManifestIcons: () => void;
+  instructions: () => import("@vite-pwa/assets-generator/api").ImageAssetsInstructions;
+  icons: () => PWAAssetsIcons;
+  checkHotUpdate: (file: string) => Promise<boolean>;
+} | undefined>;

package/dist/pwa-assets/generator.mjs

@@ -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.
+*/
+import { generate } from "./build.mjs";
+import { loadAssetsGeneratorContext } from "./config.mjs";
+import { checkHotUpdate, findIconAsset } from "./dev.mjs";
+import { extractIcons } from "./utils.mjs";
+import { resolveHtmlAssets, transformIndexHtml } from "./html.mjs";
+import { injectManifestIcons } from "./manifest.mjs";
+// src/pwa-assets/generator.ts
+async function loadInstructions(ctx) {
+	const assetsGeneratorContext = await loadAssetsGeneratorContext(ctx);
+	if (!assetsGeneratorContext) return;
+	const sources = Array.from(assetsGeneratorContext.sources);
+	return {
+		sources: () => sources,
+		generate: () => generate(assetsGeneratorContext),
+		findIconAsset: (path) => findIconAsset(path, assetsGeneratorContext),
+		resolveHtmlAssets: () => resolveHtmlAssets(ctx, assetsGeneratorContext),
+		transformIndexHtml: (html) => transformIndexHtml(html, ctx, assetsGeneratorContext),
+		injectManifestIcons: () => injectManifestIcons(ctx, assetsGeneratorContext),
+		instructions: () => assetsGeneratorContext.assetsInstructions,
+		icons: () => extractIcons(assetsGeneratorContext.assetsInstructions),
+		checkHotUpdate: (file) => checkHotUpdate(file, ctx, assetsGeneratorContext)
+	};
+}
+export { loadInstructions };

package/dist/pwa-assets/html.d.mts

@@ -0,0 +1,11 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { a as PWAHtmlAssets, t as AssetsGeneratorContext } from "../types-B60e7Nq4.mjs";
+import { PWAPluginContext } from "../context-types.mjs";
+export declare function transformIndexHtml(html: string, ctx: PWAPluginContext<any, any, any>, assetsGeneratorContext: AssetsGeneratorContext): string;
+export declare function resolveHtmlAssets(ctx: PWAPluginContext<any, any, any>, assetsGeneratorContext: AssetsGeneratorContext): PWAHtmlAssets;

package/dist/pwa-assets/html.mjs

@@ -0,0 +1,47 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+import { checkForHtmlHead } from "../html.mjs";
+import { mapLink } from "./utils.mjs";
+import { generateHtmlMarkup } from "@vite-pwa/assets-generator/api/generate-html-markup";
+// src/pwa-assets/html.ts
+function transformIndexHtml(html, ctx, assetsGeneratorContext) {
+	if (assetsGeneratorContext.injectThemeColor) {
+		const manifest = ctx.resolvedOptions.manifest;
+		if (manifest && "theme_color" in manifest && manifest.theme_color) html = checkForHtmlHead(html).replace("</head>", `\n<meta name="theme-color" content="${manifest.theme_color}"></head>`);
+	}
+	if (assetsGeneratorContext.includeHtmlHeadLinks) {
+		const link = generateHtmlMarkup(assetsGeneratorContext.assetsInstructions);
+		if (link.length) html = checkForHtmlHead(html).replace("</head>", `\n${link.join("\n")}</head>`);
+	}
+	return html;
+}
+function resolveHtmlAssets(ctx, assetsGeneratorContext) {
+	const header = {
+		links: [],
+		themeColor: void 0
+	};
+	if (assetsGeneratorContext.injectThemeColor) {
+		const manifest = ctx.resolvedOptions.manifest;
+		if (manifest && "theme_color" in manifest && manifest.theme_color) header.themeColor = {
+			name: "theme-color",
+			content: manifest.theme_color
+		};
+	}
+	if (assetsGeneratorContext.includeHtmlHeadLinks) {
+		const includeId = assetsGeneratorContext.includeId;
+		const instruction = assetsGeneratorContext.assetsInstructions;
+		const favicon = Array.from(Object.values(instruction.favicon));
+		const apple = Array.from(Object.values(instruction.apple));
+		const appleSplashScreen = Array.from(Object.values(instruction.appleSplashScreen));
+		favicon.forEach((icon) => icon.linkObject && header.links.push(mapLink(includeId, icon.linkObject)));
+		apple.forEach((icon) => icon.linkObject && header.links.push(mapLink(includeId, icon.linkObject)));
+		appleSplashScreen.forEach((icon) => icon.linkObject && header.links.push(mapLink(includeId, icon.linkObject)));
+	}
+	return header;
+}
+export { resolveHtmlAssets, transformIndexHtml };

package/dist/pwa-assets/manifest.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 { t as AssetsGeneratorContext } from "../types-B60e7Nq4.mjs";
+import { PWAPluginContext } from "../context-types.mjs";
+export declare function injectManifestIcons(ctx: PWAPluginContext<any, any, any>, assetsGeneratorContext: AssetsGeneratorContext): void;

package/dist/pwa-assets/manifest.mjs

@@ -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 { generateManifestIconsEntry } from "@vite-pwa/assets-generator/api/generate-manifest-icons-entry";
+// src/pwa-assets/manifest.ts
+function injectManifestIcons(ctx, assetsGeneratorContext) {
+	if (!assetsGeneratorContext.overrideManifestIcons) return;
+	const manifest = ctx.resolvedOptions.manifest;
+	if (manifest) manifest.icons = generateManifestIconsEntry("object", assetsGeneratorContext.assetsInstructions).icons;
+}
+export { injectManifestIcons };

package/dist/pwa-assets/options.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 { p as PWAAssetsOptions, v as ResolvedPWAAssetsOptions } from "../types-BhwjnGLn.mjs";
+export declare function resolvePWAAssetsOptions(options?: PWAAssetsOptions): false | ResolvedPWAAssetsOptions;

package/dist/pwa-assets/options.mjs

@@ -0,0 +1,34 @@
+/*!
+  MIT License
+  
+  Copyright (c) 2020-PRESENT Anthony Fu <https://github.com/antfu>
+
+  https://github.com/userquin/quini-pwa-monorepo/blob/main/LICENSE.
+*/
+// src/pwa-assets/options.ts
+function resolvePWAAssetsOptions(options) {
+	if (!options) return false;
+	const { disabled, preset = "minimal-2023", image = "public/favicon.svg", htmlPreset = "2023", overrideManifestIcons = false, includeHtmlHeadLinks = true, injectThemeColor = true, integration } = options ?? {};
+	const resolvedConfiguration = {
+		disabled: true,
+		config: false,
+		preset: false,
+		images: [image],
+		htmlPreset,
+		overrideManifestIcons,
+		includeHtmlHeadLinks,
+		injectThemeColor,
+		integration
+	};
+	if (disabled === true) return resolvedConfiguration;
+	if ("config" in options && !!options.config) {
+		resolvedConfiguration.disabled = false;
+		resolvedConfiguration.config = options.config;
+		return resolvedConfiguration;
+	}
+	if (preset === false) return resolvedConfiguration;
+	resolvedConfiguration.disabled = false;
+	resolvedConfiguration.preset = preset;
+	return resolvedConfiguration;
+}
+export { resolvePWAAssetsOptions };

package/dist/pwa-assets/types.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 { a as PWAHtmlAssets, i as PWAAssetsIcons, n as ColorSchemeMeta, o as PWAHtmlLink, r as PWAAssetsGenerator, s as ResolvedIconAsset, t as AssetsGeneratorContext } from "../types-B60e7Nq4.mjs";
+export { AssetsGeneratorContext, ColorSchemeMeta, PWAAssetsGenerator, PWAAssetsIcons, PWAHtmlAssets, PWAHtmlLink, ResolvedIconAsset };