@alxia/react-router 0.8.0 → 0.9.0

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

@@ -0,0 +1,46 @@
+import { type WorkerContract } from './worker-contract';
+/**
+ * Which requests the service worker caches, and how. Pure, so that what is
+ * never cached is tested, not hoped for.
+ *
+ * - `navigation`: a page load. Always from the network, never stored; the
+ *   offline page answers only when the network fails.
+ * - `immutable`: a hashed bundle: cache-first.
+ * - `static`: another same-origin static file (icon, sprite, logo):
+ *   stale-while-revalidate.
+ * - `none`: left to the browser, untouched: every non-GET, any other
+ *   origin, React Router's `.data` and `/__manifest`, the worker and the
+ *   manifest themselves, the app's own `never` paths, and anything carrying
+ *   credentials.
+ */
+export type Caching = 'navigation' | 'immutable' | 'static' | 'none';
+/** What a `Request` exposes that the decision reads. */
+export interface RequestFacts {
+    readonly method: string;
+    readonly url: string;
+    readonly mode: string;
+    readonly destination: string;
+    readonly headers: Pick<Headers, 'has'>;
+}
+export interface CachingOptions {
+    /**
+     * The worker's own path, never cached. Wins over `contract`;
+     * `SERVICE_WORKER_URL` when neither is given.
+     */
+    serviceWorkerUrl?: string;
+    /** The app's contract, whose `serviceWorkerUrl` is never cached. */
+    contract?: Pick<WorkerContract, 'serviceWorkerUrl'>;
+    /** The web app manifest's path, never cached. `MANIFEST_PATH` by default. */
+    manifestPath?: string;
+    /** Paths of the app answered fresh every time, such as `(p) => p.startsWith('/api/')`. */
+    never?: (path: string) => boolean;
+    /**
+     * Which static paths are immutable (cache-first) rather than static.
+     * `(path) => path.startsWith('/assets/')` by default, as `serveClient`
+     * serves them.
+     */
+    immutable?: (path: string) => boolean;
+}
+/** How the worker answers `request`, for an app served at `origin`. */
+export declare function cachingFor(request: RequestFacts, origin: string, options?: CachingOptions): Caching;
+//# sourceMappingURL=caching.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"caching.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/caching.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE5E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,OAAO,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAErE,wDAAwD;AACxD,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC9B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;IACpD,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACtC;AAOD,uEAAuE;AACvE,wBAAgB,UAAU,CACzB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC1B,OAAO,CAwBT"}

package/dist/pwa/model/clear-app-caches.d.ts

@@ -0,0 +1,9 @@
+import type { WorkerContract } from './worker-contract';
+/**
+ * Deletes every cache the service worker filled, but the offline page.
+ * For sign-out: what the caches hold is static and public by design, and
+ * clearing them leaves nothing behind anyway. Safe where Cache Storage does
+ * not exist (server, old browsers).
+ */
+export declare function clearAppCaches(contract: Pick<WorkerContract, 'clearableCaches'>): Promise<void>;
+//# sourceMappingURL=clear-app-caches.d.ts.map

package/dist/pwa/model/clear-app-caches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-app-caches.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/clear-app-caches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;;GAKG;AACH,wBAAsB,cAAc,CACnC,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,iBAAiB,CAAC,GAC/C,OAAO,CAAC,IAAI,CAAC,CAIf"}

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

@@ -0,0 +1,80 @@
+/** Where the server serves the manifest, and the document head links it. */
+export declare const MANIFEST_PATH = "/manifest.webmanifest";
+/**
+ * Cacheable for an hour, like the icons; the language travels in `?lang=`.
+ * Its own policy, which loads nothing: the pages' one carries a nonce, and
+ * a nonce never goes in a response a cache may keep.
+ */
+export declare const MANIFEST_HEADERS: {
+    readonly 'content-type': "application/manifest+json; charset=utf-8";
+    readonly 'cache-control': "public, max-age=3600";
+    readonly vary: "Accept-Language";
+    readonly 'content-security-policy': "default-src 'none'; frame-ancestors 'none'";
+};
+/**
+ * The manifest's URL for a page in `language`. A browser fetches the
+ * manifest without cookies, so a `language` cookie would not reach it: the
+ * page names its language in the query instead.
+ */
+export declare function manifestHref(language: string, path?: string): string;
+/**
+ * `?lang=` when it names one of `supported`, else `fallback`: the request's
+ * Accept-Language, never its cookie, so `Vary: Accept-Language` holds.
+ */
+export declare function manifestLanguage<L extends string>(url: URL, supported: readonly L[], fallback: L): L;
+export type ManifestIcon = {
+    src: string;
+    sizes: string;
+    type: string;
+    purpose?: 'any' | 'maskable' | 'monochrome';
+};
+/**
+ * The four icons `@vite-pwa/assets-generator`'s `minimal2023Preset` writes
+ * to `public/`: 64, 192 and 512 pixels, and a maskable 512.
+ */
+export declare const MINIMAL_2023_ICONS: readonly ManifestIcon[];
+export interface WebAppManifestOptions {
+    name: string;
+    /** `name` by default. */
+    shortName?: string;
+    description: string;
+    /** The language of `name` and `description`. */
+    lang: string;
+    /** `'ltr'` by default. */
+    dir?: 'ltr' | 'rtl' | 'auto';
+    themeColor: string;
+    backgroundColor: string;
+    categories?: readonly string[];
+    /** `MINIMAL_2023_ICONS` by default. */
+    icons?: readonly ManifestIcon[];
+    /** `'/'` by default: the same in every language, so a language switch never makes a second app. */
+    id?: string;
+    /** `'/'` by default. */
+    startUrl?: string;
+    /** `'/'` by default. */
+    scope?: string;
+    /** `'standalone'` by default. */
+    display?: 'standalone' | 'fullscreen' | 'minimal-ui' | 'browser';
+}
+/** The web app manifest's JSON, with its snake_case keys. */
+export type WebAppManifest = {
+    id: string;
+    name: string;
+    short_name: string;
+    description: string;
+    lang: string;
+    dir: 'ltr' | 'rtl' | 'auto';
+    start_url: string;
+    scope: string;
+    display: 'standalone' | 'fullscreen' | 'minimal-ui' | 'browser';
+    theme_color: string;
+    background_color: string;
+    categories?: string[];
+    icons: ManifestIcon[];
+};
+/**
+ * A web app manifest from the app's own (translated) texts and colours.
+ * `id`, `start_url` and `scope` default to `'/'` whatever the language.
+ */
+export declare function webAppManifest(options: WebAppManifestOptions): WebAppManifest;
+//# sourceMappingURL=manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/pwa/model/manifest.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,eAAO,MAAM,aAAa,0BAA0B,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,MAAsB,GAC1B,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAChD,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,SAAS,CAAC,EAAE,EACvB,QAAQ,EAAE,CAAC,GACT,CAAC,CAGH;AAED,MAAM,MAAM,YAAY,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,KAAK,GAAG,UAAU,GAAG,YAAY,CAAC;CAC5C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,YAAY,EAYrD,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,uCAAuC;IACvC,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC,mGAAmG;IACnG,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,OAAO,CAAC,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;CACjE;AAED,6DAA6D;AAC7D,MAAM,MAAM,cAAc,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,KAAK,EAAE,YAAY,EAAE,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAgB7E"}

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

@@ -0,0 +1,40 @@
+/**
+ * What the service worker precaches, read from a build: every script and
+ * stylesheet React Router's manifest names (the client entry and each
+ * route's module, imports and CSS), and the manifest itself, so a client
+ * navigation offline to a route never visited still finds its code. Only
+ * hashed `/assets/` files: a new build names new files, so each precaches
+ * under its own URL, revision `null`. Chunks only a component loads on
+ * demand stay out: a cache-first route stores them the first time they load.
+ *
+ * Dependency-free: a build script runs it at build time.
+ */
+/** A route or the entry, as `window.__reactRouterManifest` lists it. */
+type ManifestModule = {
+    module?: string;
+    imports?: string[];
+    css?: string[];
+};
+/** The parts of React Router's browser manifest the list reads. */
+export type BrowserManifest = {
+    url: string;
+    entry: ManifestModule;
+    routes: Record<string, ManifestModule>;
+};
+/** A Workbox precache entry: a hashed URL needs no revision. */
+export type PrecacheEntry = {
+    url: string;
+    revision: string | null;
+};
+/** Reads `window.__reactRouterManifest={…};` (build/client/assets/manifest-*.js). */
+export declare function parseBrowserManifest(source: string): BrowserManifest;
+/** The hashed scripts and stylesheets every route needs, the manifest's own file first. */
+export declare function precacheList(manifest: BrowserManifest): PrecacheEntry[];
+/**
+ * The precache entries of the files among `assetFiles` (the names in
+ * build/client/assets) that `include` matches, sorted, under `base`: fonts
+ * an app keeps offline, say. The regex is the app's.
+ */
+export declare function assetPrecache(assetFiles: readonly string[], include: RegExp, base?: string): PrecacheEntry[];
+export {};
+//# sourceMappingURL=precache-list.d.ts.map

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-zqa30gr7.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": []
+}