@alxia/react-router 0.8.1 → 0.10.0

package/dist/pwa/model/precache-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precache-list.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/precache-list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,wEAAwE;AACxE,KAAK,cAAc,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE9E,mEAAmE;AACnE,MAAM,MAAM,eAAe,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CACvC,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,aAAa,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAKrE,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CASpE;AAED,2FAA2F;AAC3F,wBAAgB,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,aAAa,EAAE,CAcvE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC5B,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,EAAE,MAAM,EACf,IAAI,SAAa,GACf,aAAa,EAAE,CAQjB"}

package/dist/pwa/model/registration.d.ts

@@ -0,0 +1,39 @@
+/** What the registration reads of `navigator.serviceWorker`. */
+export type ServiceWorkerContainerLike = Pick<ServiceWorkerContainer, 'controller' | 'addEventListener' | 'register'>;
+/**
+ * Calls `onWaiting` with each new version that finished installing while an
+ * older one controls the page: the one waiting now, and each found later.
+ * A first install controls nothing yet, so it offers nothing.
+ */
+export declare function watchForUpdates(registration: ServiceWorkerRegistration, container: Pick<ServiceWorkerContainerLike, 'controller'>, onWaiting: (worker: ServiceWorker) => void): void;
+/** Moves this page onto a waiting worker: `apply(worker)`. */
+export type ApplyUpdate = (worker: Pick<ServiceWorker, 'postMessage' | 'state'>) => void;
+/**
+ * The one update path of a page, created once: `apply(worker)` activates
+ * the waiting worker and reloads once, when it takes control, so the page
+ * runs the version its assets came from.
+ *
+ * - Several tabs: another tab may have activated the worker already. Its
+ *   `controllerchange` reached this page before anyone asked, so this page
+ *   did not reload (a form may be half filled); its "Reload" then reloads
+ *   at once, the worker being active.
+ * - Clicked twice, or a `controllerchange` after a direct reload: one
+ *   reload, never two.
+ */
+export declare function createUpdater(container: Pick<ServiceWorkerContainerLike, 'controller' | 'addEventListener'>, reload?: () => void): ApplyUpdate;
+/** Runs `run` once the page has loaded: registering never competes with it. */
+export declare function afterLoad(run: () => void): void;
+export interface RegisterOptions {
+    /** The worker's path. `SERVICE_WORKER_URL` by default. */
+    url?: string;
+    /** The scope it controls. `'/'` by default. */
+    scope?: string;
+}
+/**
+ * Registers the worker and watches for updates, handing each waiting worker
+ * to `onWaiting` with the page's one `apply` (`createUpdater`, made on the
+ * first call: one per page). A tab coming back to the foreground checks for
+ * an update, as a long-lived page otherwise would only on its next full load.
+ */
+export declare function registerServiceWorker(container: ServiceWorkerContainerLike, onWaiting: (worker: ServiceWorker, apply: ApplyUpdate) => void, options?: RegisterOptions): Promise<ServiceWorkerRegistration>;
+//# sourceMappingURL=registration.d.ts.map

package/dist/pwa/model/registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/registration.ts"],"names":[],"mappings":"AAEA,gEAAgE;AAChE,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAC5C,sBAAsB,EACtB,YAAY,GAAG,kBAAkB,GAAG,UAAU,CAC9C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,YAAY,EAAE,yBAAyB,EACvC,SAAS,EAAE,IAAI,CAAC,0BAA0B,EAAE,YAAY,CAAC,EACzD,SAAS,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,GACxC,IAAI,CAWN;AAED,8DAA8D;AAC9D,MAAM,MAAM,WAAW,GAAG,CACzB,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,KAChD,IAAI,CAAC;AAEV;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC5B,SAAS,EAAE,IAAI,CACd,0BAA0B,EAC1B,YAAY,GAAG,kBAAkB,CACjC,EACD,MAAM,GAAE,MAAM,IAAqC,GACjD,WAAW,CAoBb;AAED,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,CAG/C;AAED,MAAM,WAAW,eAAe;IAC/B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAID;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAC1C,SAAS,EAAE,0BAA0B,EACrC,SAAS,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,EAC9D,OAAO,GAAE,eAAoB,GAC3B,OAAO,CAAC,yBAAyB,CAAC,CAiBpC"}

package/dist/pwa/model/start-service-worker.d.ts

@@ -0,0 +1,24 @@
+import type { ServiceWorkerContainerLike } from './registration';
+import type { UpdateNoticeStore } from './update-notice';
+/** What starting reads of the browser: `navigator`, which may have no worker. */
+export interface ServiceWorkerEnvironment {
+    navigator: object & {
+        serviceWorker?: ServiceWorkerContainerLike;
+    };
+}
+export interface StartServiceWorkerOptions {
+    enabled: boolean;
+    url?: string;
+    scope?: string;
+    notice: Pick<UpdateNoticeStore, 'offer'>;
+    onError?: (error: unknown) => void;
+}
+/**
+ * The body of `useServiceWorker`'s effect, a plain function so that it is
+ * tested without React: registers after `load` when `enabled` and the
+ * browser has a worker container, offers each waiting version to `notice`,
+ * and hands a failed registration to `onError`. The listeners it adds live
+ * for the page.
+ */
+export declare function startServiceWorker(environment: ServiceWorkerEnvironment, options: StartServiceWorkerOptions): void;
+//# sourceMappingURL=start-service-worker.d.ts.map

package/dist/pwa/model/start-service-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-service-worker.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/start-service-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAEjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,iFAAiF;AACjF,MAAM,WAAW,wBAAwB;IACxC,SAAS,EAAE,MAAM,GAAG;QAAE,aAAa,CAAC,EAAE,0BAA0B,CAAA;KAAE,CAAC;CACnE;AAED,MAAM,WAAW,yBAAyB;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;IACzC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACnC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,WAAW,EAAE,wBAAwB,EACrC,OAAO,EAAE,yBAAyB,GAChC,IAAI,CAgBN"}

package/dist/pwa/model/storable.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether a response may be stored: a full, same-origin 200 of a static
+ * content type, that the server marked `public` (alxia does on every
+ * static file it serves; a route answering an image, a user's photo, does
+ * not), not private nor no-store, and that does not vary on who asks.
+ */
+export declare function isStorable(response: Response): boolean;
+//# sourceMappingURL=storable.d.ts.map

package/dist/pwa/model/storable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storable.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/storable.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAYtD"}

package/dist/pwa/model/update-notice.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The session's "Later": the notice stays hidden until the next visit.
+ * `sessionStorage` is per origin, so one key serves every app; a second
+ * argument of `createUpdateNotice` names another.
+ */
+export declare const UPDATE_LATER_KEY = "alxia.update-later";
+/** The part of `Storage` the notice reads and writes. */
+export type NoticeStorage = {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+};
+/** What the notice offers while a new version waits. */
+export type UpdateNotice = {
+    /** Moves the page onto the new version: the worker's `apply`. */
+    reload: () => void;
+    /** Hides the notice until the next visit (the tab's session). */
+    later: () => void;
+};
+/** What `createUpdateNotice` returns: the shape `useSyncExternalStore` takes. */
+export interface UpdateNoticeStore {
+    /** A new version waits: `apply` moves the page onto it. */
+    offer(apply: () => void): void;
+    /** The notice to show, if any (the same object until it changes). */
+    current(): UpdateNotice | undefined;
+    /** Calls `listener` on each change; returns the function that stops it. */
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * The update notice's state: offered by the worker's registration, read by
+ * the banners, hidden for the session by "Later". `storage` is the session's
+ * (`sessionStorage`), which may be missing or throw (private mode, blocked
+ * storage): the notice then hides for this page only. It is a function so
+ * that nothing reads the global at load.
+ */
+export declare function createUpdateNotice(storage: () => NoticeStorage | undefined, key?: string): UpdateNoticeStore;
+/** `sessionStorage`, or nothing where there is none (the server). */
+export declare const sessionStore: () => NoticeStorage | undefined;
+//# sourceMappingURL=update-notice.d.ts.map

package/dist/pwa/model/update-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-notice.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/update-notice.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AAErD,yDAAyD;AACzD,MAAM,MAAM,aAAa,GAAG;IAC3B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1C,CAAC;AAEF,wDAAwD;AACxD,MAAM,MAAM,YAAY,GAAG;IAC1B,iEAAiE;IACjE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,iEAAiE;IACjE,KAAK,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAEF,iFAAiF;AACjF,MAAM,WAAW,iBAAiB;IACjC,2DAA2D;IAC3D,KAAK,CAAC,KAAK,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC/B,qEAAqE;IACrE,OAAO,IAAI,YAAY,GAAG,SAAS,CAAC;IACpC,2EAA2E;IAC3E,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC5C;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,MAAM,aAAa,GAAG,SAAS,EACxC,GAAG,GAAE,MAAyB,GAC5B,iBAAiB,CAyCnB;AAED,qEAAqE;AACrE,eAAO,MAAM,YAAY,QAAO,aAAa,GAAG,SACmB,CAAC"}

package/dist/pwa/model/worker-contract.d.ts

@@ -0,0 +1,61 @@
+/**
+ * What the service worker and the page agree on: the worker's address, the
+ * offline page, the message that applies an update, and the names of the
+ * caches the worker owns. Dependency-free: the worker bundles it, with no
+ * DOM and no React.
+ */
+/** Where the build writes the worker; registered with scope `/`. */
+export declare const SERVICE_WORKER_URL = "/service-worker.js";
+/** The page served when a navigation fails for want of a network. */
+export declare const OFFLINE_URL = "/offline.html";
+/** The message a page posts to a waiting worker to make it take over. */
+export declare const SKIP_WAITING = "SKIP_WAITING";
+export interface WorkerContractOptions {
+    /**
+     * Every Cache Storage cache the worker owns is named
+     * `<cachePrefix>-<kind>-<version>` (kind: letters and digits; version:
+     * no `-`); a cache of another shape is never swept.
+     * Required: two apps on one origin must not share it.
+     */
+    cachePrefix: string;
+    /**
+     * Bumped when a cache's content changes shape: the next worker deletes
+     * every cache of the prefix that has another version when it activates.
+     * `'v1'` by default; not empty, and without a `-`.
+     */
+    cacheVersion?: string;
+    /** `SERVICE_WORKER_URL` by default. */
+    serviceWorkerUrl?: string;
+    /** `OFFLINE_URL` by default. */
+    offlineUrl?: string;
+}
+export type CacheNames = {
+    /**
+     * The offline page and the hashed scripts and stylesheets of every route.
+     * `<prefix>-precache-<version>` is the name Workbox builds from
+     * `setCacheNameDetails({ prefix, precache: 'precache', suffix: version })`.
+     */
+    readonly precache: string;
+    /** `/assets/*` bundles: hashed names, so cache-first. */
+    readonly assets: string;
+    /** Icons, sprites, the logo: stale-while-revalidate. */
+    readonly static: string;
+};
+export interface WorkerContract {
+    readonly cachePrefix: string;
+    readonly cacheVersion: string;
+    readonly serviceWorkerUrl: string;
+    readonly offlineUrl: string;
+    readonly cacheNames: CacheNames;
+    /** The caches a worker deletes on activate: the prefix's, of another version. */
+    obsoleteCaches(names: readonly string[]): string[];
+    /**
+     * The caches `clearAppCaches()` deletes: all of the prefix's but the
+     * current precache, which holds the offline page and the app's code, never
+     * a user's data.
+     */
+    clearableCaches(names: readonly string[]): string[];
+}
+/** Builds the contract of one app from its cache prefix. */
+export declare function defineWorkerContract(options: WorkerContractOptions): WorkerContract;
+//# sourceMappingURL=worker-contract.d.ts.map

package/dist/pwa/model/worker-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-contract.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/worker-contract.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,oEAAoE;AACpE,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAEvD,qEAAqE;AACrE,eAAO,MAAM,WAAW,kBAAkB,CAAC;AAE3C,yEAAyE;AACzE,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAE3C,MAAM,WAAW,qBAAqB;IACrC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,UAAU,GAAG;IACxB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,iFAAiF;IACjF,cAAc,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IACnD;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;CACpD;AAED,4DAA4D;AAC5D,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,qBAAqB,GAC5B,cAAc,CA+ChB"}

package/dist/pwa/react/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `@alxia/react-router/pwa/react`: the hooks of an installable app's page.
+ * `react` is its only import (an optional peer of the package), and what it
+ * shares with `/pwa` is a chunk of that entry.
+ */
+export { useOnline } from './use-online';
+export { type ServiceWorkerOptions, useServiceWorker, } from './use-service-worker';
+export { updateNotice, useUpdateNotice } from './use-update-notice';
+//# sourceMappingURL=index.d.ts.map

package/dist/pwa/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pwa/react/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EACN,KAAK,oBAAoB,EACzB,gBAAgB,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/pwa/react/index.js

@@ -0,0 +1,75 @@
+import {
+  afterLoad2,
+  registerServiceWorker2,
+  createUpdateNotice2,
+  sessionStore2
+} from "../../chunks/index-9xv2a8et.js";
+
+// src/pwa/react/use-online.ts
+import { useSyncExternalStore } from "react";
+function subscribe(onChange) {
+  window.addEventListener("online", onChange);
+  window.addEventListener("offline", onChange);
+  return () => {
+    window.removeEventListener("online", onChange);
+    window.removeEventListener("offline", onChange);
+  };
+}
+function useOnline() {
+  return useSyncExternalStore(subscribe, () => navigator.onLine, () => true);
+}
+// src/pwa/react/use-service-worker.ts
+import { useEffect, useRef } from "react";
+
+// src/pwa/model/start-service-worker.ts
+function startServiceWorker(environment, options) {
+  const { navigator: navigator2 } = environment;
+  if (!options.enabled || !("serviceWorker" in navigator2))
+    return;
+  const container = navigator2.serviceWorker;
+  if (!container)
+    return;
+  const { url, scope, notice, onError } = options;
+  afterLoad2(() => {
+    registerServiceWorker2(container, (worker, apply) => notice.offer(() => apply(worker)), {
+      ...url !== undefined && { url },
+      ...scope !== undefined && { scope }
+    }).catch((error) => onError?.(error));
+  });
+}
+
+// src/pwa/react/use-update-notice.ts
+import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+var updateNotice = createUpdateNotice2(sessionStore2);
+function useUpdateNotice(notice = updateNotice) {
+  return useSyncExternalStore2((listener) => notice.subscribe(listener), () => notice.current(), () => {
+    return;
+  });
+}
+
+// src/pwa/react/use-service-worker.ts
+function useServiceWorker(options) {
+  const { enabled, url, scope, notice = updateNotice } = options;
+  const onError = useRef(options.onError);
+  useEffect(() => {
+    onError.current = options.onError;
+  });
+  useEffect(() => {
+    startServiceWorker({ navigator }, {
+      enabled,
+      notice,
+      onError: (error) => onError.current?.(error),
+      ...url !== undefined && { url },
+      ...scope !== undefined && { scope }
+    });
+  }, [enabled, url, scope, notice]);
+}
+export {
+  updateNotice,
+  useOnline,
+  useServiceWorker,
+  useUpdateNotice
+};
+
+//# debugId=DC45CFDED1D0414264756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/pwa/react/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/pwa/react/use-online.ts", "../src/pwa/react/use-service-worker.ts", "../src/pwa/model/start-service-worker.ts", "../src/pwa/react/use-update-notice.ts"],
+  "sourcesContent": [
+    "import { useSyncExternalStore } from 'react';\n\nfunction subscribe(onChange: () => void) {\n\twindow.addEventListener('online', onChange);\n\twindow.addEventListener('offline', onChange);\n\treturn () => {\n\t\twindow.removeEventListener('online', onChange);\n\t\twindow.removeEventListener('offline', onChange);\n\t};\n}\n\n/**\n * Whether the browser says it is online. Online on the server and during\n * hydration, so the first client render matches the server's.\n */\nexport function useOnline(): boolean {\n\treturn useSyncExternalStore(\n\t\tsubscribe,\n\t\t() => navigator.onLine,\n\t\t() => true,\n\t);\n}\n",
+    "import { useEffect, useRef } from 'react';\nimport { startServiceWorker } from '../model/start-service-worker';\nimport type { UpdateNoticeStore } from '../model/update-notice';\nimport { updateNotice } from './use-update-notice';\n\nexport interface ServiceWorkerOptions {\n\t/**\n\t * Whether to register at all. The app decides, typically\n\t * `import.meta.env.PROD`: a worker under a dev server caches the code being\n\t * edited. This package never reads `import.meta.env` itself.\n\t */\n\tenabled: boolean;\n\t/** The worker's path. `SERVICE_WORKER_URL` by default. */\n\turl?: string;\n\t/** The scope it controls. `'/'` by default. */\n\tscope?: string;\n\t/** Where a waiting version is offered. The page's `updateNotice` by default. */\n\tnotice?: UpdateNoticeStore;\n\t/**\n\t * Called when registering fails (private mode, a blocked script). The app\n\t * works without a worker, so by default the error is dropped. An `onError`\n\t * that throws becomes an unhandled rejection.\n\t */\n\tonError?: (error: unknown) => void;\n}\n\n/**\n * Registers the service worker after `load` when `enabled`, in a browser\n * that has one. When a new version waits, `notice` offers it (`useUpdateNotice`\n * reads it); nothing activates it unasked. Does nothing on the server.\n *\n * The options are read when the effect runs, which is on mount and when\n * `enabled`, `url`, `scope` or `notice` change; `onError` is always the\n * latest. The listeners it adds (the update check, the controller change)\n * stay for the page's life: there is no cleanup, a page has one worker.\n */\nexport function useServiceWorker(options: ServiceWorkerOptions): void {\n\tconst { enabled, url, scope, notice = updateNotice } = options;\n\tconst onError = useRef(options.onError);\n\tuseEffect(() => {\n\t\tonError.current = options.onError;\n\t});\n\tuseEffect(() => {\n\t\tstartServiceWorker(\n\t\t\t{ navigator },\n\t\t\t{\n\t\t\t\tenabled,\n\t\t\t\tnotice,\n\t\t\t\tonError: (error) => onError.current?.(error),\n\t\t\t\t...(url !== undefined && { url }),\n\t\t\t\t...(scope !== undefined && { scope }),\n\t\t\t},\n\t\t);\n\t}, [enabled, url, scope, notice]);\n}\n",
+    "import type { ServiceWorkerContainerLike } from './registration';\nimport { afterLoad, registerServiceWorker } from './registration';\nimport type { UpdateNoticeStore } from './update-notice';\n\n/** What starting reads of the browser: `navigator`, which may have no worker. */\nexport interface ServiceWorkerEnvironment {\n\tnavigator: object & { serviceWorker?: ServiceWorkerContainerLike };\n}\n\nexport interface StartServiceWorkerOptions {\n\tenabled: boolean;\n\turl?: string;\n\tscope?: string;\n\tnotice: Pick<UpdateNoticeStore, 'offer'>;\n\tonError?: (error: unknown) => void;\n}\n\n/**\n * The body of `useServiceWorker`'s effect, a plain function so that it is\n * tested without React: registers after `load` when `enabled` and the\n * browser has a worker container, offers each waiting version to `notice`,\n * and hands a failed registration to `onError`. The listeners it adds live\n * for the page.\n */\nexport function startServiceWorker(\n\tenvironment: ServiceWorkerEnvironment,\n\toptions: StartServiceWorkerOptions,\n): void {\n\tconst { navigator } = environment;\n\tif (!options.enabled || !('serviceWorker' in navigator)) return;\n\tconst container = navigator.serviceWorker;\n\tif (!container) return;\n\tconst { url, scope, notice, onError } = options;\n\tafterLoad(() => {\n\t\tregisterServiceWorker(\n\t\t\tcontainer,\n\t\t\t(worker, apply) => notice.offer(() => apply(worker)),\n\t\t\t{\n\t\t\t\t...(url !== undefined && { url }),\n\t\t\t\t...(scope !== undefined && { scope }),\n\t\t\t},\n\t\t).catch((error: unknown) => onError?.(error));\n\t});\n}\n",
+    "import { useSyncExternalStore } from 'react';\nimport {\n\tcreateUpdateNotice,\n\tsessionStore,\n\ttype UpdateNotice,\n\ttype UpdateNoticeStore,\n} from '../model/update-notice';\n\n/**\n * The page's one notice, which `useServiceWorker` offers and\n * `useUpdateNotice` reads. It lives here, not in `/pwa`, so that the model a\n * worker bundle imports makes nothing at load.\n */\nexport const updateNotice: UpdateNoticeStore = createUpdateNotice(sessionStore);\n\n/**\n * The update notice to show: a new version waits and \"Later\" was not asked.\n * None on the server. `notice` is the page's `updateNotice` unless the app\n * made a store of its own.\n */\nexport function useUpdateNotice(\n\tnotice: UpdateNoticeStore = updateNotice,\n): UpdateNotice | undefined {\n\treturn useSyncExternalStore(\n\t\t(listener) => notice.subscribe(listener),\n\t\t() => notice.current(),\n\t\t() => undefined,\n\t);\n}\n"
+  ],
+  "mappings": ";;;;;;;;AAAA;AAEA,SAAS,SAAS,CAAC,UAAsB;AAAA,EACxC,OAAO,iBAAiB,UAAU,QAAQ;AAAA,EAC1C,OAAO,iBAAiB,WAAW,QAAQ;AAAA,EAC3C,OAAO,MAAM;AAAA,IACZ,OAAO,oBAAoB,UAAU,QAAQ;AAAA,IAC7C,OAAO,oBAAoB,WAAW,QAAQ;AAAA;AAAA;AAQzC,SAAS,SAAS,GAAY;AAAA,EACpC,OAAO,qBACN,WACA,MAAM,UAAU,QAChB,MAAM,IACP;AAAA;;ACpBD;;;ACwBO,SAAS,kBAAkB,CACjC,aACA,SACO;AAAA,EACP,QAAQ,0BAAc;AAAA,EACtB,IAAI,CAAC,QAAQ,WAAW,EAAE,mBAAmB;AAAA,IAAY;AAAA,EACzD,MAAM,YAAY,WAAU;AAAA,EAC5B,IAAI,CAAC;AAAA,IAAW;AAAA,EAChB,QAAQ,KAAK,OAAO,QAAQ,YAAY;AAAA,EACxC,WAAU,MAAM;AAAA,IACf,uBACC,WACA,CAAC,QAAQ,UAAU,OAAO,MAAM,MAAM,MAAM,MAAM,CAAC,GACnD;AAAA,SACK,QAAQ,aAAa,EAAE,IAAI;AAAA,SAC3B,UAAU,aAAa,EAAE,MAAM;AAAA,IACpC,CACD,EAAE,MAAM,CAAC,UAAmB,UAAU,KAAK,CAAC;AAAA,GAC5C;AAAA;;;AC1CF,iCAAS;AAaF,IAAM,eAAkC,oBAAmB,aAAY;AAOvE,SAAS,eAAe,CAC9B,SAA4B,cACD;AAAA,EAC3B,OAAO,sBACN,CAAC,aAAa,OAAO,UAAU,QAAQ,GACvC,MAAM,OAAO,QAAQ,GACrB,MAAG;AAAA,IAAG;AAAA,GACP;AAAA;;;AFSM,SAAS,gBAAgB,CAAC,SAAqC;AAAA,EACrE,QAAQ,SAAS,KAAK,OAAO,SAAS,iBAAiB;AAAA,EACvD,MAAM,UAAU,OAAO,QAAQ,OAAO;AAAA,EACtC,UAAU,MAAM;AAAA,IACf,QAAQ,UAAU,QAAQ;AAAA,GAC1B;AAAA,EACD,UAAU,MAAM;AAAA,IACf,mBACC,EAAE,UAAU,GACZ;AAAA,MACC;AAAA,MACA;AAAA,MACA,SAAS,CAAC,UAAU,QAAQ,UAAU,KAAK;AAAA,SACvC,QAAQ,aAAa,EAAE,IAAI;AAAA,SAC3B,UAAU,aAAa,EAAE,MAAM;AAAA,IACpC,CACD;AAAA,KACE,CAAC,SAAS,KAAK,OAAO,MAAM,CAAC;AAAA;",
+  "debugId": "DC45CFDED1D0414264756E2164756E21",
+  "names": []
+}

package/dist/pwa/react/use-online.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether the browser says it is online. Online on the server and during
+ * hydration, so the first client render matches the server's.
+ */
+export declare function useOnline(): boolean;
+//# sourceMappingURL=use-online.d.ts.map

package/dist/pwa/react/use-online.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-online.d.ts","sourceRoot":"","sources":["../../../src/pwa/react/use-online.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAMnC"}

package/dist/pwa/react/use-service-worker.d.ts

@@ -0,0 +1,33 @@
+import type { UpdateNoticeStore } from '../model/update-notice';
+export interface ServiceWorkerOptions {
+    /**
+     * Whether to register at all. The app decides, typically
+     * `import.meta.env.PROD`: a worker under a dev server caches the code being
+     * edited. This package never reads `import.meta.env` itself.
+     */
+    enabled: boolean;
+    /** The worker's path. `SERVICE_WORKER_URL` by default. */
+    url?: string;
+    /** The scope it controls. `'/'` by default. */
+    scope?: string;
+    /** Where a waiting version is offered. The page's `updateNotice` by default. */
+    notice?: UpdateNoticeStore;
+    /**
+     * Called when registering fails (private mode, a blocked script). The app
+     * works without a worker, so by default the error is dropped. An `onError`
+     * that throws becomes an unhandled rejection.
+     */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Registers the service worker after `load` when `enabled`, in a browser
+ * that has one. When a new version waits, `notice` offers it (`useUpdateNotice`
+ * reads it); nothing activates it unasked. Does nothing on the server.
+ *
+ * The options are read when the effect runs, which is on mount and when
+ * `enabled`, `url`, `scope` or `notice` change; `onError` is always the
+ * latest. The listeners it adds (the update check, the controller change)
+ * stay for the page's life: there is no cleanup, a page has one worker.
+ */
+export declare function useServiceWorker(options: ServiceWorkerOptions): void;
+//# sourceMappingURL=use-service-worker.d.ts.map

package/dist/pwa/react/use-service-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-service-worker.d.ts","sourceRoot":"","sources":["../../../src/pwa/react/use-service-worker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,MAAM,WAAW,oBAAoB;IACpC;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAkBpE"}

package/dist/pwa/react/use-update-notice.d.ts

@@ -0,0 +1,14 @@
+import { type UpdateNotice, type UpdateNoticeStore } from '../model/update-notice';
+/**
+ * The page's one notice, which `useServiceWorker` offers and
+ * `useUpdateNotice` reads. It lives here, not in `/pwa`, so that the model a
+ * worker bundle imports makes nothing at load.
+ */
+export declare const updateNotice: UpdateNoticeStore;
+/**
+ * The update notice to show: a new version waits and "Later" was not asked.
+ * None on the server. `notice` is the page's `updateNotice` unless the app
+ * made a store of its own.
+ */
+export declare function useUpdateNotice(notice?: UpdateNoticeStore): UpdateNotice | undefined;
+//# sourceMappingURL=use-update-notice.d.ts.map

package/dist/pwa/react/use-update-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-update-notice.d.ts","sourceRoot":"","sources":["../../../src/pwa/react/use-update-notice.ts"],"names":[],"mappings":"AACA,OAAO,EAGN,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,iBAAoD,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,MAAM,GAAE,iBAAgC,GACtC,YAAY,GAAG,SAAS,CAM1B"}

package/dist/pwa/server/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `@alxia/react-router/pwa/server`: the server's side of an installable
+ * app, `noCache` for the worker's script. `@alxia/core` is its only import,
+ * so keep it out of the page and the worker.
+ */
+export { noCache, revalidated, WORKER_POLICY } from './no-cache';
+//# sourceMappingURL=index.d.ts.map

package/dist/pwa/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pwa/server/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/pwa/server/index.js

@@ -0,0 +1,18 @@
+// src/pwa/server/no-cache.ts
+import { defineMiddleware, withHeaders } from "@alxia/core";
+var WORKER_POLICY = "default-src 'none'; connect-src 'self'";
+function revalidated(response, policy = WORKER_POLICY) {
+  return withHeaders(response, (headers) => {
+    headers.set("cache-control", "no-cache");
+    headers.set("content-security-policy", policy);
+  });
+}
+var noCache = defineMiddleware(async (_ctx, next) => revalidated(await next()));
+export {
+  WORKER_POLICY,
+  noCache,
+  revalidated
+};
+
+//# debugId=D042AA38FD15BC2064756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/pwa/server/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/pwa/server/no-cache.ts"],
+  "sourcesContent": [
+    "import { defineMiddleware, withHeaders } from '@alxia/core';\n\n/**\n * The service worker's own policy: a worker takes the policy its script\n * came with, not the pages'. It runs no other script and fetches this site\n * only (the precache, navigations); its routes never fetch another origin.\n */\nexport const WORKER_POLICY = \"default-src 'none'; connect-src 'self'\";\n\n/**\n * The worker's script with `Cache-Control: no-cache`: the client's\n * top-level files are served for an hour, and the worker's script must be\n * revalidated on every update check, or an update waits that long. And with\n * the worker's policy (`WORKER_POLICY`, or your own `policy`), which no\n * other static file needs: none of them is a document but an offline page,\n * which carries its own in a `<meta>`.\n */\nexport function revalidated(\n\tresponse: Response,\n\tpolicy: string = WORKER_POLICY,\n): Response {\n\treturn withHeaders(response, (headers) => {\n\t\theaders.set('cache-control', 'no-cache');\n\t\theaders.set('content-security-policy', policy);\n\t});\n}\n\n/**\n * For `use(SERVICE_WORKER_URL, noCache)` in `createServer({ beforeAll })`,\n * before the client's files: they answer without calling `next` for a\n * middleware declared after them.\n */\nexport const noCache = defineMiddleware(async (_ctx, next) =>\n\trevalidated(await next()),\n);\n"
+  ],
+  "mappings": ";AAAA;AAOO,IAAM,gBAAgB;AAUtB,SAAS,WAAW,CAC1B,UACA,SAAiB,eACN;AAAA,EACX,OAAO,YAAY,UAAU,CAAC,YAAY;AAAA,IACzC,QAAQ,IAAI,iBAAiB,UAAU;AAAA,IACvC,QAAQ,IAAI,2BAA2B,MAAM;AAAA,GAC7C;AAAA;AAQK,IAAM,UAAU,iBAAiB,OAAO,MAAM,SACpD,YAAY,MAAM,KAAK,CAAC,CACzB;",
+  "debugId": "D042AA38FD15BC2064756E2164756E21",
+  "names": []
+}

package/dist/pwa/server/no-cache.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The service worker's own policy: a worker takes the policy its script
+ * came with, not the pages'. It runs no other script and fetches this site
+ * only (the precache, navigations); its routes never fetch another origin.
+ */
+export declare const WORKER_POLICY = "default-src 'none'; connect-src 'self'";
+/**
+ * The worker's script with `Cache-Control: no-cache`: the client's
+ * top-level files are served for an hour, and the worker's script must be
+ * revalidated on every update check, or an update waits that long. And with
+ * the worker's policy (`WORKER_POLICY`, or your own `policy`), which no
+ * other static file needs: none of them is a document but an offline page,
+ * which carries its own in a `<meta>`.
+ */
+export declare function revalidated(response: Response, policy?: string): Response;
+/**
+ * For `use(SERVICE_WORKER_URL, noCache)` in `createServer({ beforeAll })`,
+ * before the client's files: they answer without calling `next` for a
+ * middleware declared after them.
+ */
+export declare const noCache: NoInfer<import("@alxia/core").Middleware<import("@alxia/core").Empty, Promise<Response>>>;
+//# sourceMappingURL=no-cache.d.ts.map

package/dist/pwa/server/no-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-cache.d.ts","sourceRoot":"","sources":["../../../src/pwa/server/no-cache.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,aAAa,2CAA2C,CAAC;AAEtE;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,QAAQ,EAAE,QAAQ,EAClB,MAAM,GAAE,MAAsB,GAC5B,QAAQ,CAKV;AAED;;;;GAIG;AACH,eAAO,MAAM,OAAO,2FAEnB,CAAC"}

package/dist/pwa/worker/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `@alxia/react-router/pwa/worker`: the service worker on Workbox. Import it
+ * from a service worker bundle alone, never from a page. The six `workbox-*`
+ * packages (`core`, `expiration`, `navigation-preload`, `precaching`,
+ * `routing`, `strategies`, optional peers) are its only package imports.
+ */
+export type { ExpirationOptions, WorkerOptions } from './plan';
+export { startWorker } from './start-worker';
+//# sourceMappingURL=index.d.ts.map

package/dist/pwa/worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pwa/worker/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/pwa/worker/index.js

@@ -0,0 +1,144 @@
+import {
+  cachingFor2,
+  isStorable2
+} from "../../chunks/index-zdbqzcjp.js";
+import {
+  injectedPrecache
+} from "../../chunks/index-59vhfj6n.js";
+import {
+  SKIP_WAITING2
+} from "../../chunks/index-rfr02vg4.js";
+
+// src/pwa/worker/start-worker.ts
+import {
+  clientsClaim,
+  setCacheNameDetails
+} from "workbox-core";
+import { ExpirationPlugin } from "workbox-expiration";
+import * as navigationPreload from "workbox-navigation-preload";
+import { matchPrecache, precacheAndRoute } from "workbox-precaching";
+import { registerRoute } from "workbox-routing";
+import {
+  CacheFirst,
+  NetworkOnly,
+  StaleWhileRevalidate
+} from "workbox-strategies";
+
+// src/pwa/worker/plan.ts
+var THIRTY_DAYS = 30 * 24 * 60 * 60;
+function workerPlan(options, injected) {
+  const { contract } = options;
+  if (!contract) {
+    throw new TypeError("startWorker(): contract is required: pass defineWorkerContract({ cachePrefix }) from @alxia/react-router/pwa.");
+  }
+  const precache = options.precache ?? injected;
+  if (!precache) {
+    throw new Error("startWorker(): no precache list. Build this worker with alxia() from @alxia/react-router/vite (app/service-worker.ts) or buildWorker() from @alxia/react-router/pwa/build, which write it in.");
+  }
+  const offlineUrl = contract.offlineUrl;
+  const hasOffline = precache.some((entry) => entry.url.split("?")[0] === offlineUrl);
+  return {
+    cacheNameDetails: {
+      prefix: contract.cachePrefix,
+      precache: "precache",
+      suffix: contract.cacheVersion
+    },
+    precache,
+    routes: [
+      {
+        caching: "navigation",
+        strategy: "network-only",
+        fallback: hasOffline ? offlineUrl : undefined
+      },
+      {
+        caching: "immutable",
+        strategy: "cache-first",
+        cacheName: contract.cacheNames.assets,
+        expiration: { maxEntries: 200, ...options.assets }
+      },
+      {
+        caching: "static",
+        strategy: "stale-while-revalidate",
+        cacheName: contract.cacheNames.static,
+        expiration: {
+          maxEntries: 100,
+          maxAgeSeconds: THIRTY_DAYS,
+          ...options.static
+        }
+      }
+    ],
+    navigationPreload: options.navigationPreload ?? true
+  };
+}
+function matcher(caching, origin, options) {
+  return ({ request }) => cachingFor2(request, origin(), {
+    ...options.caching,
+    contract: options.contract
+  }) === caching;
+}
+var storableOnly = {
+  async cacheWillUpdate({
+    response
+  }) {
+    return isStorable2(response) ? response : null;
+  }
+};
+function isSkipWaiting(data) {
+  return data?.type === SKIP_WAITING2;
+}
+async function deleteObsoleteCaches(contract, storage) {
+  const names = await storage.keys();
+  await Promise.all(contract.obsoleteCaches(names).map((name) => storage.delete(name)));
+}
+
+// src/pwa/worker/scope.ts
+var workerScope = () => globalThis;
+
+// src/pwa/worker/start-worker.ts
+function startWorker(options) {
+  const plan = workerPlan(options, injectedPrecache());
+  const scope = workerScope();
+  const { contract } = options;
+  setCacheNameDetails(plan.cacheNameDetails);
+  precacheAndRoute([...plan.precache], {
+    cleanURLs: false,
+    directoryIndex: ""
+  });
+  if (plan.navigationPreload)
+    navigationPreload.enable();
+  for (const route of plan.routes) {
+    const match = matcher(route.caching, () => scope.location.origin, options);
+    if (route.strategy === "network-only") {
+      const { fallback } = route;
+      registerRoute(match, new NetworkOnly({
+        plugins: fallback ? [{ handlerDidError: async () => matchPrecache(fallback) }] : []
+      }));
+      continue;
+    }
+    const Strategy = route.strategy === "cache-first" ? CacheFirst : StaleWhileRevalidate;
+    registerRoute(match, new Strategy({
+      cacheName: route.cacheName,
+      plugins: [
+        storableOnly,
+        new ExpirationPlugin({
+          ...route.expiration,
+          purgeOnQuotaError: true
+        })
+      ]
+    }));
+  }
+  clientsClaim();
+  scope.addEventListener("activate", (event) => {
+    event.waitUntil(deleteObsoleteCaches(contract, caches));
+  });
+  scope.addEventListener("message", (event) => {
+    if (isSkipWaiting(event.data))
+      scope.skipWaiting();
+  });
+}
+export {
+  startWorker
+};
+
+//# debugId=52EB15D1D020B66D64756E2164756E21
+//# sourceMappingURL=index.js.map