unplugin-pwa-nuxt 0.0.0-stage → 4.5.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020-present Jimmy Chen
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,97 @@
-# Temporary Holding Version
+# unplugin-pwa-nuxt
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Apache-2.0 licensed][badge-license]][url-license]
+[![NPM version][badge-npm-version]][url-npm]
+[![NPM downloads][badge-npm-downloads]][url-npm]
+[![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
+
+This package is a Nuxt PWA module on [`@unplugin-pwa/vite`](https://github.com/vite-pwa/unplugin-pwa), for Nuxt 5 and Nitro 3 only. It builds your service worker once Nitro has copied the app into its public folder, so its precache lists every file the server serves, keeps the worker from answering a navigation to a route your server owns, links the manifest in the page's head and registers the worker with a client plugin that provides `$pwa`.
+
+Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/unplugin-pwa-nuxt).
+
+## Table of Contents
+
+- 🚀 [Getting Started](#getting-started)
+- 🧩 [Key Exports](#key-exports)
+- 📝 [Usage](#usage)
+- ⚖️ [License](#license)
+
+---
+
+## <a name="getting-started">🚀 Getting Started</a>
+
+```bash
+pnpm i unplugin-pwa-nuxt
+```
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({ modules: ["unplugin-pwa-nuxt"] });
+```
+
+## <a name="key-exports">🧩 Key Exports</a>
+
+| Export                                          | Kind      | Purpose                                                                                                                         |
+| :---------------------------------------------- | :-------- | :------------------------------------------------------------------------------------------------------------------------------ |
+| `default`                                       | const     | The Nuxt module, set up from the `pwa` config key                                                                               |
+| `ModuleOptions`                                 | interface | The engine's own options, typed and unchanged, plus `periodicSyncForUpdates`, the seconds between checks for a newer worker     |
+| `Pwa`                                           | interface | `$pwa`, with `needRefresh`, `offlineReady`, `registrationError` and `updateServiceWorker()`                                     |
+| `virtual:unplugin-pwa-nuxt/navigation-denylist` | module    | The server's routes as `RegExp`s, imported by a worker built from source; its types are `unplugin-pwa-nuxt/navigation-denylist` |
+
+## <a name="usage">📝 Usage</a>
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ["unplugin-pwa-nuxt"],
+  pwa: {
+    // The worker is TypeScript, built with its precache list injected
+    buildSW: { swSrc: "service-worker/sw.ts" },
+    manifest: { name: "My app", short_name: "App", theme_color: "#ffffff" },
+    // A new worker waits until `$pwa.updateServiceWorker()` is called
+    registerType: "prompt",
+    strategies: "buildSW",
+    // Checks for a newer worker hourly, so a tab left open for days is offered it
+    periodicSyncForUpdates: 3600,
+  },
+});
+```
+
+```ts
+// service-worker/sw.ts
+/// <reference types="unplugin-pwa-nuxt/navigation-denylist" />
+import { navigationDenylist } from "virtual:unplugin-pwa-nuxt/navigation-denylist";
+import { createHandlerBoundToURL, precacheAndRoute } from "@vite-pwa/workbox-swkit/precaching";
+import { NavigationRoute, registerRoute } from "@vite-pwa/workbox-swkit/routing";
+
+declare let self: ServiceWorkerGlobalScope & { __WB_MANIFEST: { revision: null | string; url: string }[] };
+
+precacheAndRoute([...self.__WB_MANIFEST, { revision: null, url: "/" }]);
+// An API route or a file the server serves is the server's to answer, not the shell's
+registerRoute(new NavigationRoute(createHandlerBoundToURL("/"), { denylist: navigationDenylist }));
+// `$pwa.updateServiceWorker()` sends this message, and a worker built from source is the one that must act on it
+self.addEventListener("message", (event) => {
+  if (event.data?.type === "SKIP_WAITING") event.waitUntil(self.skipWaiting());
+});
+```
+
+```vue
+<script setup lang="ts">
+const { $pwa } = useNuxtApp();
+</script>
+
+<template>
+  <button v-if="$pwa?.needRefresh" @click="$pwa.updateServiceWorker()">Reload for the new version</button>
+</template>
+```
+
+## <a name="license">⚖️ License</a>
+
+Licensed under [Apache-2.0][url-license].
+
+[badge-license]: https://img.shields.io/github/license/Esposter/Esposter.svg?color=blue
+[url-license]: https://github.com/Esposter/Esposter/blob/main/LICENSE
+[badge-npm-version]: https://img.shields.io/npm/v/unplugin-pwa-nuxt/latest?color=brightgreen
+[url-npm]: https://www.npmjs.com/package/unplugin-pwa-nuxt/v/latest
+[badge-npm-unpacked-size]: https://img.shields.io/npm/unpacked-size/unplugin-pwa-nuxt/latest?label=npm
+[badge-npm-downloads]: https://img.shields.io/npm/dm/unplugin-pwa-nuxt.svg

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { ModuleOptions } from "./models/ModuleOptions.js";
+import { Pwa } from "./runtime/models/Pwa.js";
+import { NuxtModule } from "@nuxt/schema";
+declare module "@nuxt/schema" {
+  interface NuxtConfig {
+    pwa?: ModuleOptions;
+  }
+}
+declare const pwaModule: NuxtModule<ModuleOptions>;
+export { type ModuleOptions, type Pwa, pwaModule as default };

package/dist/index.js

@@ -0,0 +1,59 @@
+import { MODULE_NAME } from "./runtime/constants.js";
+import { buildServiceWorker } from "./services/buildServiceWorker.js";
+import { configurePwaOptions } from "./services/configurePwaOptions.js";
+import { getNitroNavigationDenylist } from "./services/getNitroNavigationDenylist.js";
+import { getTypeTemplate } from "./services/getTypeTemplate.js";
+import { getVitePlugins } from "./services/getVitePlugins.js";
+import { addPluginTemplate, addTypeTemplate, addVitePlugin, createResolver, defineNuxtModule } from "@nuxt/kit";
+import { createCustomVitePWAContext } from "@unplugin-pwa/vite/vite-context";
+// src/module.ts
+const pwaModule = defineNuxtModule({
+	defaults: ({ options }) => ({
+		base: options.app.baseURL,
+		scope: options.app.baseURL
+	}),
+	meta: {
+		compatibility: { nuxt: ">=5.0.0-0" },
+		configKey: "pwa",
+		name: MODULE_NAME
+	},
+	setup({ periodicSyncForUpdates, ...pwaOptions }, nuxt) {
+		if (pwaOptions.disable) return;
+		const resolver = createResolver(import.meta.url);
+		const { baseURL } = nuxt.options.app;
+		const { manifest, manifestFilename = "manifest.webmanifest", useCredentials } = pwaOptions;
+		if (manifest) {
+			const { head } = nuxt.options.app;
+			head.link = [...head.link ?? [], {
+				href: `${baseURL}${manifestFilename}`,
+				rel: "manifest",
+				...useCredentials && { crossorigin: "use-credentials" }
+			}];
+		}
+		addPluginTemplate({
+			filename: `${MODULE_NAME}.client.mjs`,
+			getContents: () => [
+				"import { useRegisterSW } from 'virtual:pwa-register/vue'",
+				`import { createPwaPlugin } from ${JSON.stringify(resolver.resolve("./runtime/createPwaPlugin"))}`,
+				"",
+				`export default createPwaPlugin(useRegisterSW, ${JSON.stringify(periodicSyncForUpdates)})`,
+				""
+			].join("\n"),
+			mode: "client"
+		});
+		addTypeTemplate({
+			filename: `types/${MODULE_NAME}.d.ts`,
+			getContents: getTypeTemplate
+		});
+		const context = createCustomVitePWAContext("vite", true, {
+			...pwaOptions,
+			injectRegister: false
+		});
+		addVitePlugin(() => getVitePlugins(context), { server: false });
+		nuxt.hook("nitro:init", (nitro) => {
+			context.configurePWAOptions = () => configurePwaOptions(context, nuxt, nitro.options.output.publicDir, () => getNitroNavigationDenylist(nitro));
+			nuxt.hook("nitro:build:public-assets", () => buildServiceWorker(context, nuxt, nitro));
+		});
+	}
+});
+export { pwaModule as default };

package/dist/models/ModuleOptions.d.ts

@@ -0,0 +1,9 @@
+import { VitePWAOptions, VitePWAStrategy } from "@unplugin-pwa/core";
+import { SWType } from "@vite-pwa/workbox-build/types";
+export interface ModuleOptions extends Partial<VitePWAOptions<VitePWAStrategy, SWType>> {
+  /**
+   * Seconds between checks for a new service worker. Absent, only the browser's own navigation check runs.
+   */
+  periodicSyncForUpdates?: number;
+  pwaAssets?: never;
+}

package/dist/runtime/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const MODULE_NAME = "unplugin-pwa-nuxt";
+export declare const NAVIGATION_DENYLIST_MODULE: `virtual:${typeof MODULE_NAME}/navigation-denylist`;

package/dist/runtime/constants.js

@@ -0,0 +1,4 @@
+// src/runtime/constants.ts
+const MODULE_NAME = "unplugin-pwa-nuxt";
+const NAVIGATION_DENYLIST_MODULE = `virtual:${MODULE_NAME}/navigation-denylist`;
+export { MODULE_NAME, NAVIGATION_DENYLIST_MODULE };

package/dist/runtime/createPwaPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Pwa } from "./models/Pwa.js";
+import { UseRegisterSW } from "./models/UseRegisterSW.js";
+import { ObjectPlugin } from "nuxt/app";
+/**
+ * Registers the worker, through `useRegisterSW` from the engine's register module, once the app is up and provides `$pwa`: whether a new worker waits (`needRefresh`) or the
+ * app can now run offline (`offlineReady`), and how to activate the waiting one. `periodicSyncForUpdates` is the
+ * seconds between checks for a newer worker, none when absent.
+ */
+export declare const createPwaPlugin: (useRegisterSW: UseRegisterSW, periodicSyncForUpdates?: number) => ObjectPlugin<{
+  pwa: Pwa;
+}>;

package/dist/runtime/createPwaPlugin.js

@@ -0,0 +1,37 @@
+import { MODULE_NAME } from "./constants.js";
+import { getResultAsync, getSynchronizedFunction, noop } from "@esposter/shared";
+import { defineNuxtPlugin } from "nuxt/app";
+import { reactive, ref } from "vue";
+// src/runtime/createPwaPlugin.ts
+/**
+* Registers the worker, through `useRegisterSW` from the engine's register module, once the app is up and provides `$pwa`: whether a new worker waits (`needRefresh`) or the
+* app can now run offline (`offlineReady`), and how to activate the waiting one. `periodicSyncForUpdates` is the
+* seconds between checks for a newer worker, none when absent.
+*/
+const createPwaPlugin = (useRegisterSW, periodicSyncForUpdates) => defineNuxtPlugin({
+	enforce: "post",
+	name: `${MODULE_NAME}:client`,
+	parallel: true,
+	setup() {
+		const registrationError = ref(false);
+		const { needRefresh, offlineReady, updateServiceWorker } = useRegisterSW({
+			immediate: true,
+			onRegisteredSW: (_swUrl, registration) => {
+				if (!registration || !periodicSyncForUpdates) return;
+				setInterval(getSynchronizedFunction(async () => {
+					if (window.navigator.onLine && !registration.installing) await getResultAsync(() => registration.update()).match(noop, console.error);
+				}), periodicSyncForUpdates * 1e3);
+			},
+			onRegisterError: () => {
+				registrationError.value = true;
+			}
+		});
+		return { provide: { pwa: reactive({
+			needRefresh,
+			offlineReady,
+			registrationError,
+			updateServiceWorker
+		}) } };
+	}
+});
+export { createPwaPlugin };

package/dist/runtime/models/Pwa.d.ts

@@ -0,0 +1,6 @@
+export interface Pwa {
+  needRefresh: boolean;
+  offlineReady: boolean;
+  registrationError: boolean;
+  updateServiceWorker: () => Promise<void>;
+}

package/dist/runtime/models/Pwa.js

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

package/dist/runtime/models/UseRegisterSW.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from "vue";
+export type UseRegisterSW = (options: {
+  immediate: boolean;
+  onRegisteredSW: (swUrl: string, registration?: ServiceWorkerRegistration) => void;
+  onRegisterError: (error: unknown) => void;
+}) => {
+  needRefresh: Ref<boolean>;
+  offlineReady: Ref<boolean>;
+  updateServiceWorker: () => Promise<void>;
+};

package/dist/runtime/models/UseRegisterSW.js

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

package/dist/services/buildServiceWorker.js

@@ -0,0 +1,34 @@
+import { createManifestTransform } from "./createManifestTransform.js";
+import { getImmutableAssets } from "./getImmutableAssets.js";
+import { getNitroNavigationDenylist } from "./getNitroNavigationDenylist.js";
+import { getStrategyOptions } from "./getStrategyOptions.js";
+import { globSync } from "node:fs";
+// src/services/buildServiceWorker.ts
+const PAYLOAD_PATTERN = "**/_payload.json";
+/**
+* The worker is built from what Nitro has already copied into its public folder, which is every file the precache
+* lists, so it is built here and not as the client bundle closes. What the precache holds and where a navigation falls
+* back to are settled here too, since they depend on what Nitro prerendered and which routes the server answers.
+*/
+const buildServiceWorker = async (context, nuxt, nitro) => {
+	if (context.resolvedOptions.disable) return;
+	const { baseURL } = nuxt.options.app;
+	const immutableAssets = getImmutableAssets(nuxt);
+	const options = getStrategyOptions(context);
+	if (options) {
+		const payloadPatterns = globSync(PAYLOAD_PATTERN, { cwd: nitro.options.output.publicDir }).length > 0 ? [PAYLOAD_PATTERN] : [];
+		options.globPatterns ??= [
+			"**/*.{js,css,html}",
+			...payloadPatterns,
+			`${immutableAssets}/builds/meta/*.json`
+		];
+		options.manifestTransforms ??= [createManifestTransform(baseURL, `${immutableAssets}/`)];
+	}
+	const { generateSW } = context.resolvedOptions;
+	if (context.strategy === "generate-sw" && generateSW) {
+		if (!("navigateFallback" in generateSW)) generateSW.navigateFallback = baseURL;
+		generateSW.navigateFallbackDenylist ??= getNitroNavigationDenylist(nitro);
+	}
+	await context.runBuild();
+};
+export { buildServiceWorker };

package/dist/services/configurePwaOptions.js

@@ -0,0 +1,27 @@
+import { createNavigationDenylistPlugin } from "./createNavigationDenylistPlugin.js";
+import { getImmutableAssets } from "./getImmutableAssets.js";
+import { resolve } from "node:path";
+// src/services/configurePwaOptions.ts
+/**
+* Where the engine resolves its options, the paths a Nuxt app fixes: the worker is written into the folder Nitro
+* serves, and a worker built from source can import the server's navigation denylist. `getNavigationDenylist` is read
+* as the worker is built, since the server's routes are only settled by then. The engine reads the manifest's icons from
+* Vite's `publicDir`, which Nuxt turns off since Nitro serves the folder, so it is Nuxt's own public folder here.
+*/
+const configurePwaOptions = (context, nuxt, outDir, getNavigationDenylist) => {
+	const { buildSW } = context.resolvedOptions;
+	context.publicDir = resolve(nuxt.options.rootDir, nuxt.options.dir.public);
+	if (buildSW) {
+		const { plugins } = buildSW;
+		buildSW.plugins = (swType) => [plugins?.(swType), createNavigationDenylistPlugin(getNavigationDenylist)];
+	}
+	if (context.devEnvironment) return void 0;
+	context.outDir = outDir;
+	context.resolvedOptions.outDir = outDir;
+	return {
+		cwd: process.cwd(),
+		immutableAssets: getImmutableAssets(nuxt),
+		outDir
+	};
+};
+export { configurePwaOptions };

package/dist/services/createManifestTransform.js

@@ -0,0 +1,25 @@
+// src/services/createManifestTransform.ts
+const HTML_SUFFIX_REGEX = /(?:^|\/)index\.html$|\.html$/u;
+/**
+* Nuxt serves a prerendered page at its route, not at its file, so a precached `about/index.html` or `about.html` is
+* keyed as `about` and the entry for the app's own `index.html` as the base URL. A build's app manifest is named by its
+* content, so its revision is the name and workbox never re-downloads one it already holds.
+*/
+const createManifestTransform = (baseURL, buildAssetsDirectory) => (entries) => ({
+	manifest: entries.map((entry) => {
+		if (entry.url.endsWith(".html")) {
+			const route = entry.url.replace(HTML_SUFFIX_REGEX, "");
+			return {
+				...entry,
+				url: route === "" ? baseURL : route
+			};
+		}
+		if (entry.url.startsWith(`${buildAssetsDirectory}builds/meta/`)) return {
+			...entry,
+			revision: null
+		};
+		return entry;
+	}),
+	warnings: []
+});
+export { createManifestTransform };

package/dist/services/createNavigationDenylistPlugin.js

@@ -0,0 +1,13 @@
+import { NAVIGATION_DENYLIST_MODULE } from "../runtime/constants.js";
+// src/services/createNavigationDenylistPlugin.ts
+const RESOLVED_NAVIGATION_DENYLIST_MODULE = `\0${NAVIGATION_DENYLIST_MODULE}`;
+const createNavigationDenylistPlugin = (getNavigationDenylist) => ({
+	load(id) {
+		if (id === RESOLVED_NAVIGATION_DENYLIST_MODULE) return `export const navigationDenylist = [${getNavigationDenylist().join(",")}];`;
+	},
+	name: "unplugin-pwa-nuxt:navigation-denylist",
+	resolveId(id) {
+		if (id === "virtual:unplugin-pwa-nuxt/navigation-denylist") return RESOLVED_NAVIGATION_DENYLIST_MODULE;
+	}
+});
+export { createNavigationDenylistPlugin };

package/dist/services/createWorkboxWindowPlugin.js

@@ -0,0 +1,12 @@
+import { MODULE_NAME } from "../runtime/constants.js";
+import { fileURLToPath } from "node:url";
+// src/services/createWorkboxWindowPlugin.ts
+const WORKBOX_WINDOW_SPECIFIERS = /* @__PURE__ */ new Set(["@vite-pwa/workbox-window", "@vite-pwa/workbox-window/esm-sw-detector"]);
+const createWorkboxWindowPlugin = () => ({
+	enforce: "pre",
+	name: `${MODULE_NAME}:workbox-window`,
+	resolveId(id) {
+		if (WORKBOX_WINDOW_SPECIFIERS.has(id)) return fileURLToPath(import.meta.resolve(id));
+	}
+});
+export { createWorkboxWindowPlugin };

package/dist/services/getImmutableAssets.js

@@ -0,0 +1,4 @@
+// src/services/getImmutableAssets.ts
+const SLASH_ENDS_REGEX = /^\/|\/$/gu;
+const getImmutableAssets = ({ options }) => options.app.buildAssetsDir.replaceAll(SLASH_ENDS_REGEX, "");
+export { getImmutableAssets };

package/dist/services/getNavigationDenylist.js

@@ -0,0 +1,26 @@
+// src/services/getNavigationDenylist.ts
+const CATCH_ALL_ROUTES = /* @__PURE__ */ new Set([
+	"",
+	"/",
+	"/**"
+]);
+const MULTI_SEGMENT_WILDCARD = "**";
+const MULTI_SEGMENT_PATTERN = "(?:/.*)?";
+const SINGLE_SEGMENT_PATTERN = "/[^/]+";
+const getSegmentPattern = (segment) => {
+	if (segment.startsWith(MULTI_SEGMENT_WILDCARD)) return MULTI_SEGMENT_PATTERN;
+	if (segment.startsWith(":") || segment.startsWith("*")) return SINGLE_SEGMENT_PATTERN;
+	return RegExp.escape(`/${segment}`);
+};
+const splitSegments = (path) => path.split("/").filter(Boolean);
+/**
+* The paths a navigation must not be answered with the app shell for: the server's own routes, which the worker would
+* otherwise swallow into the cached page. Each route becomes one anchored pattern, so `/api/**` denies `/api` and what
+* is under it but never `/apiary`, and the list is deduplicated and sorted so the generated worker is the same on every
+* build.
+*/
+const getNavigationDenylist = (routes, baseURL) => {
+	const baseSegments = splitSegments(baseURL);
+	return [...new Set(routes.filter((route) => !CATCH_ALL_ROUTES.has(route)).map((route) => `^${[...baseSegments.map((segment) => RegExp.escape(`/${segment}`)), ...splitSegments(route).map((segment) => getSegmentPattern(segment))].join("")}$`))].toSorted().map((source) => new RegExp(source, "u"));
+};
+export { getNavigationDenylist };

package/dist/services/getNitroNavigationDenylist.js

@@ -0,0 +1,5 @@
+import { getNavigationDenylist } from "./getNavigationDenylist.js";
+import { getNitroNavigationRoutes } from "./getNitroNavigationRoutes.js";
+// src/services/getNitroNavigationDenylist.ts
+const getNitroNavigationDenylist = (nitro) => getNavigationDenylist(getNitroNavigationRoutes(nitro), nitro.options.baseURL);
+export { getNitroNavigationDenylist };

package/dist/services/getNitroNavigationRoutes.js

@@ -0,0 +1,3 @@
+// src/services/getNitroNavigationRoutes.ts
+const getNitroNavigationRoutes = ({ routing }) => routing.routes.routes.filter(({ method }) => method === "" || method.toUpperCase() === "GET").map(({ route }) => route);
+export { getNitroNavigationRoutes };

package/dist/services/getStrategyOptions.js

@@ -0,0 +1,10 @@
+// src/services/getStrategyOptions.ts
+const getStrategyOptions = ({ resolvedOptions, strategy }) => {
+	switch (strategy) {
+		case "build-sw": return resolvedOptions.buildSW;
+		case "generate-sw": return resolvedOptions.generateSW;
+		case "inject-manifest": return resolvedOptions.injectManifest;
+		default: return;
+	}
+};
+export { getStrategyOptions };

package/dist/services/getTypeTemplate.js

@@ -0,0 +1,20 @@
+import { MODULE_NAME } from "../runtime/constants.js";
+// src/services/getTypeTemplate.ts
+const getTypeTemplate = () => `// Generated by ${MODULE_NAME}
+import type { Pwa } from '${MODULE_NAME}'
+
+declare module '#app' {
+  interface NuxtApp {
+    $pwa?: Pwa
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $pwa?: Pwa
+  }
+}
+
+export {}
+`;
+export { getTypeTemplate };

package/dist/services/getVitePlugins.js

@@ -0,0 +1,18 @@
+import { createWorkboxWindowPlugin } from "./createWorkboxWindowPlugin.js";
+import { BuildPwaAssetsPlugin } from "@unplugin-pwa/vite/plugins/build-pwa-assets";
+import { DevPlugin } from "@unplugin-pwa/vite/plugins/dev";
+import { DevMiddlewarePlugin } from "@unplugin-pwa/vite/plugins/dev-middleware";
+import { InfoPlugin } from "@unplugin-pwa/vite/plugins/info";
+import { MainPlugin } from "@unplugin-pwa/vite/plugins/main";
+import { VirtualModulesPlugin } from "@unplugin-pwa/vite/plugins/virtual-modules";
+// src/services/getVitePlugins.ts
+const getVitePlugins = (context) => [
+	MainPlugin(context),
+	VirtualModulesPlugin(context),
+	InfoPlugin(context),
+	DevPlugin(context),
+	DevMiddlewarePlugin(context),
+	BuildPwaAssetsPlugin(context),
+	createWorkboxWindowPlugin()
+];
+export { getVitePlugins };

package/navigation-denylist.d.ts

@@ -0,0 +1,5 @@
+// The server's routes as patterns, which a service worker built from source imports to leave a navigation to one to the
+// Server. The module resolves it as the worker is built
+declare module "virtual:unplugin-pwa-nuxt/navigation-denylist" {
+  export const navigationDenylist: RegExp[];
+}

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "unplugin-pwa-nuxt",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "4.5.0",
+  "description": "Nuxt PWA module on unplugin-pwa — a service worker built by the app, its manifest and its client plugin, for Nuxt 5 and Nitro 3 only",
+  "keywords": [
+    "typescript"
+  ],
+  "homepage": "https://github.com/Esposter/Esposter/blob/main/packages/unplugin-pwa-nuxt#readme",
+  "bugs": {
+    "url": "https://github.com/Esposter/Esposter/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "Jimmy Chen",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Esposter/Esposter.git"
+  },
+  "files": [
+    "dist",
+    "navigation-denylist.d.ts"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "dist/index.d.ts",
+  "imports": {
+    "#src/*": "./src/*.ts"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json",
+    "./navigation-denylist": {
+      "types": "./navigation-denylist.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "test": "vitest",
+    "typecheck": "tsrs --fast"
+  },
+  "dependencies": {
+    "@esposter/shared": "4.5.0",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@5x",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@5x",
+    "@unplugin-pwa/core": "^0.0.3",
+    "@unplugin-pwa/vite": "^0.0.3",
+    "@vite-pwa/workbox-build": "^8.0.13",
+    "@vite-pwa/workbox-window": "^8.0.13"
+  },
+  "devDependencies": {
+    "@esposter/configuration": "4.5.0",
+    "@esposter/shared-node": "4.5.0",
+    "@nuxt/nitro-server": "npm:@nuxt/nitro-server-nightly@5x",
+    "@types/node": "^26.6.6",
+    "@vite-pwa/workbox-swkit": "^8.0.13",
+    "tsdown": "^0.23.5",
+    "vite": "^8.3.5"
+  },
+  "peerDependencies": {
+    "nitro": "npm:nitro-nightly@latest",
+    "nuxt": "npm:nuxt-nightly@5x",
+    "vue": "^3.5.44"
+  },
+  "gitHead": "e30c001f3b4b15693e75fb53092d62a97ade4d2b"
+}