@baukit/pwa-web 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Koss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# @baukit/pwa-web
+
+`@baukit/pwa-web` decides which caching strategy a PWA service worker should apply to a request.
+The decision is a pure function over the request's method, URL, mode, and destination. Nothing in
+this package reads `self`, `caches`, `clients`, or `location`, so every branch is unit-testable in
+plain Node.
+
+Products own the cache names, precache list, install and activate handlers, and offline fallback
+copy. This package owns the classification and the strategy execution around whatever cache the
+product supplies.
+
+## Classifying a request
+
+```ts
+import { CACHE_STRATEGIES, decideCacheStrategy } from '@baukit/pwa-web';
+
+decideCacheStrategy(
+  { url: '/api/v1/sync/pull?since=12', method: 'GET' },
+  { appOrigin: 'https://app.example.com', neverCachedPathPrefixes: ['/api/v1/sync'] },
+);
+// 'network-only'
+```
+
+The rules run in this order:
+
+1. A path under any `neverCachedPathPrefixes` entry is `network-only`. The list is empty by
+   default, so no endpoint is special until a product names one. A sync endpoint belongs here:
+   replaying a stale delta corrupts the local database.
+2. Any non-GET method is `network-only`.
+3. A path under any `apiPathPrefixes` entry (default `['/api']`) gets `apiStrategy`, default
+   `network-first`.
+4. A navigation (`mode === 'navigate'`) gets `defaultStrategy`, default `network-first`. When
+   `navigationFallback` is set, `createFetchHandler` looks up that app-shell path if the selected
+   strategy fails and the original request is not cached.
+5. A same-origin request whose destination, file extension, or path prefix marks it static gets
+   `staticStrategy`, default `cache-first`.
+6. Everything else gets `defaultStrategy`.
+
+Prefix matching is segment-aware: `/api` matches `/api` and `/api/v1/me` but not `/apiary`.
+Extension matching reads the last path segment only, so `/v1.2/plans` is not a static asset.
+Cross-origin assets never reach `cache-first`, because a service worker should not fill its cache
+with another origin's responses.
+
+### Options
+
+| Option                    | Default                                          | Purpose                                                         |
+| ------------------------- | ------------------------------------------------ | --------------------------------------------------------------- |
+| `appOrigin`               | required                                         | Base for relative URLs and the same-origin test                 |
+| `neverCachedPathPrefixes` | `[]`                                             | Paths that must always hit the network, such as a sync endpoint |
+| `apiPathPrefixes`         | `['/api']`                                       | Paths treated as API reads                                      |
+| `navigationFallback`      | unset                                            | Cached app-shell path used after an offline navigation miss     |
+| `staticPathPrefixes`      | `[]`                                             | Extensionless static paths, such as `/_expo/static/`            |
+| `staticDestinations`      | audio, font, image, script, style, video, worker | `Request.destination` values that mean static                   |
+| `staticExtensions`        | common web asset extensions                      | File extensions that mean static                                |
+| `apiStrategy`             | `network-first`                                  | Strategy for API reads                                          |
+| `staticStrategy`          | `cache-first`                                    | Strategy for static assets                                      |
+| `defaultStrategy`         | `network-first`                                  | Strategy for everything else                                    |
+
+`createCacheStrategyDecider(options)` binds the options once and returns a function of the
+request, which is what an install-time asset scan wants.
+
+`navigationFallback` applies only to same-origin GET requests with `mode: 'navigate'`. API routes
+and paths in `neverCachedPathPrefixes` never use it, even if a caller supplies `mode: 'navigate'`.
+The selected `defaultStrategy` still runs first. The handler checks the fallback path only after
+that strategy cannot return a network response or a cached response for the requested URL. With no
+fallback configured, navigation misses keep the previous behavior and reject with the network
+error. The product must precache the fallback path.
+
+## Running the strategy
+
+`createFetchHandler` executes the chosen strategy through ports the product provides. It never
+constructs a `Cache` or calls the global `fetch` itself, so the same handler runs under Vitest
+with plain objects.
+
+```js
+// public/sw.js
+import { createFetchHandler } from '/pwa-web.js';
+
+const STATIC_CACHE = 'app-static-v1';
+const SHELL_CACHE = 'app-shell-v1';
+
+const handleFetch = createFetchHandler({
+  appOrigin: self.location.origin,
+  neverCachedPathPrefixes: ['/api/v1/sync'],
+  navigationFallback: '/index.html',
+  staticPathPrefixes: ['/_expo/static/'],
+  ports: {
+    fetch: (request, init) => fetch(request, init),
+    matchCache: (request) => caches.match(request),
+    putCache: async (strategy, request, response) => {
+      const name = strategy === 'cache-first' ? STATIC_CACHE : SHELL_CACHE;
+      const cache = await caches.open(name);
+      await cache.put(request, response);
+    },
+    isCacheable: (response) => response.ok && response.type !== 'error',
+    cloneResponse: (response) => response.clone(),
+  },
+  onRevalidateError: () => {
+    // A background refresh failure must not surface to the page.
+  },
+});
+
+self.addEventListener('fetch', (event) => {
+  event.respondWith(handleFetch(event.request));
+});
+```
+
+Behavior per strategy:
+
+- `network-only` fetches with `cache: 'no-store'` and never writes to the cache.
+- `cache-first` returns a hit, otherwise fetches and stores a cacheable response.
+- `network-first` fetches and stores a cacheable response, and falls back to the cache when the
+  fetch throws. If the request is an eligible navigation and its own cache entry is absent,
+  `navigationFallback` supplies one final cache lookup. With nothing cached it rethrows.
+- `stale-while-revalidate` returns the cached response and refreshes in the background. On a
+  miss it awaits the network. A background failure goes to `onRevalidateError`.
+
+`putCache` receives the strategy that produced the response, which is how the snippet above
+routes static assets and shell responses into different caches.
+
+## Build a service worker without a bundler
+
+The package exports ESM for `import` and CommonJS for `require`. Build scripts can load either
+format directly:
+
+```js
+const { decideCacheStrategy } = require('@baukit/pwa-web');
+```
+
+A service worker copied to `public/` cannot resolve `node_modules`. The following
+`scripts/build-sw.mjs` reads the installed ESM files, removes their module syntax, and writes one
+classic script. It exposes the package through `globalThis.BaukitPwa`, so a classic worker can use
+`importScripts('/sw-strategy.js')`.
+
+```js
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const outputPath = process.argv[2] ?? 'public/sw-strategy.js';
+const entryPath = fileURLToPath(import.meta.resolve('@baukit/pwa-web'));
+const distDir = dirname(entryPath);
+
+async function readDistFile(name) {
+  const source = await readFile(join(distDir, name), 'utf8');
+  return source
+    .replace(/import\s*\{[^}]+\}\s*from\s*['"]\.\/cache-strategy\.js['"];\s*/s, '')
+    .replace(/^export /gm, '')
+    .replace(/^\/\/# sourceMappingURL=.*$/gm, '')
+    .trim();
+}
+
+const source = `// Generated by scripts/build-sw.mjs. Do not edit.
+${await readDistFile('cache-strategy.js')}
+${await readDistFile('fetch-handler.js')}
+globalThis.BaukitPwa = Object.freeze({
+  CACHE_STRATEGIES,
+  createCacheStrategyDecider,
+  createFetchHandler,
+  decideCacheStrategy,
+});
+`;
+
+await writeFile(outputPath, source);
+```
+
+Add generation and drift checks to the product's `package.json`:
+
+```json
+{
+  "scripts": {
+    "build:sw": "node scripts/build-sw.mjs public/sw-strategy.js",
+    "build:sw:check": "sh -c 'tmp=$(mktemp); trap \"rm -f $tmp\" EXIT; node scripts/build-sw.mjs \"$tmp\" && diff -u public/sw-strategy.js \"$tmp\"'"
+  }
+}
+```
+
+Run `build:sw` after updating `@baukit/pwa-web`. Commit the generated file and run
+`build:sw:check` in CI. The diff fails when the installed package and committed worker differ.
+
+## What this package does not do
+
+It does not register the service worker, precache an app shell, version caches, prompt for
+updates, or supply an offline page. Those depend on the product's build output and copy.

package/dist/cache-strategy.d.ts

@@ -0,0 +1,33 @@
+export declare const CACHE_STRATEGIES: {
+    readonly cacheFirst: "cache-first";
+    readonly networkFirst: "network-first";
+    readonly networkOnly: "network-only";
+    readonly staleWhileRevalidate: "stale-while-revalidate";
+};
+export type CacheStrategy = (typeof CACHE_STRATEGIES)[keyof typeof CACHE_STRATEGIES];
+export interface CacheStrategyRequest {
+    readonly url: string;
+    readonly method?: string;
+    readonly mode?: string;
+    readonly destination?: string;
+}
+export interface CacheStrategyOptions {
+    readonly appOrigin: string;
+    readonly apiPathPrefixes?: readonly string[];
+    readonly neverCachedPathPrefixes?: readonly string[];
+    readonly navigationFallback?: string;
+    readonly staticPathPrefixes?: readonly string[];
+    readonly staticDestinations?: readonly string[];
+    readonly staticExtensions?: readonly string[];
+    readonly apiStrategy?: CacheStrategy;
+    readonly staticStrategy?: CacheStrategy;
+    readonly defaultStrategy?: CacheStrategy;
+}
+export interface CacheStrategyDecision {
+    readonly strategy: CacheStrategy;
+    readonly navigationFallback?: string;
+}
+export declare function decideCacheStrategyDecision(request: CacheStrategyRequest, options: CacheStrategyOptions): CacheStrategyDecision;
+export declare function decideCacheStrategy(request: CacheStrategyRequest, options: CacheStrategyOptions): CacheStrategy;
+export declare function createCacheStrategyDecider(options: CacheStrategyOptions): (request: CacheStrategyRequest) => CacheStrategy;
+//# sourceMappingURL=cache-strategy.d.ts.map

package/dist/cache-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-strategy.d.ts","sourceRoot":"","sources":["../src/cache-strategy.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAErF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,uBAAuB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC;IACrC,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC;IACxC,QAAQ,CAAC,eAAe,CAAC,EAAE,aAAa,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACtC;AA+DD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,oBAAoB,GAC5B,qBAAqB,CA4CvB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,oBAAoB,GAC5B,aAAa,CAEf;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,oBAAoB,GAC5B,CAAC,OAAO,EAAE,oBAAoB,KAAK,aAAa,CAElD"}

package/dist/cache-strategy.js

@@ -0,0 +1,93 @@
+export const CACHE_STRATEGIES = {
+    cacheFirst: 'cache-first',
+    networkFirst: 'network-first',
+    networkOnly: 'network-only',
+    staleWhileRevalidate: 'stale-while-revalidate',
+};
+const DEFAULT_API_PATH_PREFIXES = ['/api'];
+const DEFAULT_STATIC_DESTINATIONS = [
+    'audio',
+    'font',
+    'image',
+    'script',
+    'style',
+    'video',
+    'worker',
+];
+const DEFAULT_STATIC_EXTENSIONS = [
+    'avif',
+    'css',
+    'gif',
+    'ico',
+    'jpeg',
+    'jpg',
+    'js',
+    'json',
+    'mjs',
+    'mp3',
+    'mp4',
+    'ogg',
+    'otf',
+    'png',
+    'svg',
+    'ttf',
+    'webmanifest',
+    'webp',
+    'woff',
+    'woff2',
+];
+function matchesPathPrefix(pathname, prefix) {
+    if (prefix.length === 0) {
+        return false;
+    }
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function matchesAnyPathPrefix(pathname, prefixes) {
+    return prefixes.some((prefix) => matchesPathPrefix(pathname, prefix));
+}
+function hasStaticExtension(pathname, extensions) {
+    const lastSegment = pathname.slice(pathname.lastIndexOf('/') + 1);
+    const dotIndex = lastSegment.lastIndexOf('.');
+    if (dotIndex <= 0) {
+        return false;
+    }
+    const extension = lastSegment.slice(dotIndex + 1).toLowerCase();
+    return extensions.includes(extension);
+}
+function startsWithAny(pathname, prefixes) {
+    return prefixes.some((prefix) => prefix.length > 0 && pathname.startsWith(prefix));
+}
+export function decideCacheStrategyDecision(request, options) {
+    const { appOrigin, apiPathPrefixes = DEFAULT_API_PATH_PREFIXES, navigationFallback, neverCachedPathPrefixes = [], staticPathPrefixes = [], staticDestinations = DEFAULT_STATIC_DESTINATIONS, staticExtensions = DEFAULT_STATIC_EXTENSIONS, apiStrategy = CACHE_STRATEGIES.networkFirst, staticStrategy = CACHE_STRATEGIES.cacheFirst, defaultStrategy = CACHE_STRATEGIES.networkFirst, } = options;
+    const parsed = new URL(request.url, appOrigin);
+    const { pathname } = parsed;
+    const sameOrigin = parsed.origin === appOrigin;
+    if (matchesAnyPathPrefix(pathname, neverCachedPathPrefixes)) {
+        return { strategy: CACHE_STRATEGIES.networkOnly };
+    }
+    const method = (request.method ?? 'GET').toUpperCase();
+    if (method !== 'GET') {
+        return { strategy: CACHE_STRATEGIES.networkOnly };
+    }
+    if (matchesAnyPathPrefix(pathname, apiPathPrefixes)) {
+        return { strategy: apiStrategy };
+    }
+    if (request.mode === 'navigate') {
+        if (navigationFallback !== undefined && sameOrigin) {
+            return { strategy: defaultStrategy, navigationFallback };
+        }
+        return { strategy: defaultStrategy };
+    }
+    const staticAsset = (request.destination !== undefined && staticDestinations.includes(request.destination)) ||
+        hasStaticExtension(pathname, staticExtensions) ||
+        startsWithAny(pathname, staticPathPrefixes);
+    return { strategy: sameOrigin && staticAsset ? staticStrategy : defaultStrategy };
+}
+export function decideCacheStrategy(request, options) {
+    return decideCacheStrategyDecision(request, options).strategy;
+}
+export function createCacheStrategyDecider(options) {
+    return (request) => decideCacheStrategy(request, options);
+}
+//# sourceMappingURL=cache-strategy.js.map

package/dist/cache-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-strategy.js","sourceRoot":"","sources":["../src/cache-strategy.ts"],"names":[],"mappings":"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"}

package/dist/cjs/cache-strategy.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_STRATEGIES = void 0;
+exports.decideCacheStrategyDecision = decideCacheStrategyDecision;
+exports.decideCacheStrategy = decideCacheStrategy;
+exports.createCacheStrategyDecider = createCacheStrategyDecider;
+exports.CACHE_STRATEGIES = {
+    cacheFirst: 'cache-first',
+    networkFirst: 'network-first',
+    networkOnly: 'network-only',
+    staleWhileRevalidate: 'stale-while-revalidate',
+};
+const DEFAULT_API_PATH_PREFIXES = ['/api'];
+const DEFAULT_STATIC_DESTINATIONS = [
+    'audio',
+    'font',
+    'image',
+    'script',
+    'style',
+    'video',
+    'worker',
+];
+const DEFAULT_STATIC_EXTENSIONS = [
+    'avif',
+    'css',
+    'gif',
+    'ico',
+    'jpeg',
+    'jpg',
+    'js',
+    'json',
+    'mjs',
+    'mp3',
+    'mp4',
+    'ogg',
+    'otf',
+    'png',
+    'svg',
+    'ttf',
+    'webmanifest',
+    'webp',
+    'woff',
+    'woff2',
+];
+function matchesPathPrefix(pathname, prefix) {
+    if (prefix.length === 0) {
+        return false;
+    }
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function matchesAnyPathPrefix(pathname, prefixes) {
+    return prefixes.some((prefix) => matchesPathPrefix(pathname, prefix));
+}
+function hasStaticExtension(pathname, extensions) {
+    const lastSegment = pathname.slice(pathname.lastIndexOf('/') + 1);
+    const dotIndex = lastSegment.lastIndexOf('.');
+    if (dotIndex <= 0) {
+        return false;
+    }
+    const extension = lastSegment.slice(dotIndex + 1).toLowerCase();
+    return extensions.includes(extension);
+}
+function startsWithAny(pathname, prefixes) {
+    return prefixes.some((prefix) => prefix.length > 0 && pathname.startsWith(prefix));
+}
+function decideCacheStrategyDecision(request, options) {
+    const { appOrigin, apiPathPrefixes = DEFAULT_API_PATH_PREFIXES, navigationFallback, neverCachedPathPrefixes = [], staticPathPrefixes = [], staticDestinations = DEFAULT_STATIC_DESTINATIONS, staticExtensions = DEFAULT_STATIC_EXTENSIONS, apiStrategy = exports.CACHE_STRATEGIES.networkFirst, staticStrategy = exports.CACHE_STRATEGIES.cacheFirst, defaultStrategy = exports.CACHE_STRATEGIES.networkFirst, } = options;
+    const parsed = new URL(request.url, appOrigin);
+    const { pathname } = parsed;
+    const sameOrigin = parsed.origin === appOrigin;
+    if (matchesAnyPathPrefix(pathname, neverCachedPathPrefixes)) {
+        return { strategy: exports.CACHE_STRATEGIES.networkOnly };
+    }
+    const method = (request.method ?? 'GET').toUpperCase();
+    if (method !== 'GET') {
+        return { strategy: exports.CACHE_STRATEGIES.networkOnly };
+    }
+    if (matchesAnyPathPrefix(pathname, apiPathPrefixes)) {
+        return { strategy: apiStrategy };
+    }
+    if (request.mode === 'navigate') {
+        if (navigationFallback !== undefined && sameOrigin) {
+            return { strategy: defaultStrategy, navigationFallback };
+        }
+        return { strategy: defaultStrategy };
+    }
+    const staticAsset = (request.destination !== undefined && staticDestinations.includes(request.destination)) ||
+        hasStaticExtension(pathname, staticExtensions) ||
+        startsWithAny(pathname, staticPathPrefixes);
+    return { strategy: sameOrigin && staticAsset ? staticStrategy : defaultStrategy };
+}
+function decideCacheStrategy(request, options) {
+    return decideCacheStrategyDecision(request, options).strategy;
+}
+function createCacheStrategyDecider(options) {
+    return (request) => decideCacheStrategy(request, options);
+}

package/dist/cjs/fetch-handler.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFetchHandler = createFetchHandler;
+const cache_strategy_js_1 = require("./cache-strategy.js");
+async function cacheFirst(request, ports) {
+    const cached = await ports.matchCache(request);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const response = await ports.fetch(request);
+    if (ports.isCacheable(response)) {
+        await ports.putCache(cache_strategy_js_1.CACHE_STRATEGIES.cacheFirst, request, ports.cloneResponse(response));
+    }
+    return response;
+}
+async function networkFirst(request, ports) {
+    try {
+        const response = await ports.fetch(request);
+        if (ports.isCacheable(response)) {
+            await ports.putCache(cache_strategy_js_1.CACHE_STRATEGIES.networkFirst, request, ports.cloneResponse(response));
+        }
+        return response;
+    }
+    catch (error) {
+        const cached = await ports.matchCache(request);
+        if (cached !== undefined) {
+            return cached;
+        }
+        throw error;
+    }
+}
+async function staleWhileRevalidate(request, ports, onRevalidateError) {
+    const cached = await ports.matchCache(request);
+    const revalidate = (async () => {
+        const response = await ports.fetch(request);
+        if (ports.isCacheable(response)) {
+            await ports.putCache(cache_strategy_js_1.CACHE_STRATEGIES.staleWhileRevalidate, request, ports.cloneResponse(response));
+        }
+        return response;
+    })();
+    if (cached === undefined) {
+        return revalidate;
+    }
+    revalidate.catch((error) => {
+        onRevalidateError?.(error);
+    });
+    return cached;
+}
+function createFetchHandler(options) {
+    const { ports, onRevalidateError, ...strategyOptions } = options;
+    return async (request) => {
+        const { strategy, navigationFallback } = (0, cache_strategy_js_1.decideCacheStrategyDecision)(request, strategyOptions);
+        try {
+            switch (strategy) {
+                case cache_strategy_js_1.CACHE_STRATEGIES.networkOnly:
+                    return await ports.fetch(request, { cache: 'no-store' });
+                case cache_strategy_js_1.CACHE_STRATEGIES.cacheFirst:
+                    return await cacheFirst(request, ports);
+                case cache_strategy_js_1.CACHE_STRATEGIES.staleWhileRevalidate:
+                    return await staleWhileRevalidate(request, ports, onRevalidateError);
+                case cache_strategy_js_1.CACHE_STRATEGIES.networkFirst:
+                    return await networkFirst(request, ports);
+            }
+        }
+        catch (error) {
+            if (navigationFallback !== undefined) {
+                const fallback = await ports.matchCache(navigationFallback);
+                if (fallback !== undefined) {
+                    return fallback;
+                }
+            }
+            throw error;
+        }
+    };
+}

package/dist/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFetchHandler = exports.decideCacheStrategy = exports.createCacheStrategyDecider = exports.CACHE_STRATEGIES = void 0;
+var cache_strategy_js_1 = require("./cache-strategy.js");
+Object.defineProperty(exports, "CACHE_STRATEGIES", { enumerable: true, get: function () { return cache_strategy_js_1.CACHE_STRATEGIES; } });
+Object.defineProperty(exports, "createCacheStrategyDecider", { enumerable: true, get: function () { return cache_strategy_js_1.createCacheStrategyDecider; } });
+Object.defineProperty(exports, "decideCacheStrategy", { enumerable: true, get: function () { return cache_strategy_js_1.decideCacheStrategy; } });
+var fetch_handler_js_1 = require("./fetch-handler.js");
+Object.defineProperty(exports, "createFetchHandler", { enumerable: true, get: function () { return fetch_handler_js_1.createFetchHandler; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/fetch-handler.d.ts

@@ -0,0 +1,19 @@
+import { type CacheStrategy, type CacheStrategyOptions, type CacheStrategyRequest } from './cache-strategy.js';
+export interface FetchLikeRequest extends CacheStrategyRequest {
+    readonly url: string;
+}
+export interface FetchHandlerPorts<TRequest extends FetchLikeRequest, TResponse> {
+    readonly fetch: (request: TRequest, init?: {
+        readonly cache?: 'no-store';
+    }) => Promise<TResponse>;
+    readonly matchCache: (request: TRequest | string) => Promise<TResponse | undefined>;
+    readonly putCache: (strategy: CacheStrategy, request: TRequest, response: TResponse) => Promise<void>;
+    readonly isCacheable: (response: TResponse) => boolean;
+    readonly cloneResponse: (response: TResponse) => TResponse;
+}
+export interface FetchHandlerOptions<TRequest extends FetchLikeRequest, TResponse> extends CacheStrategyOptions {
+    readonly ports: FetchHandlerPorts<TRequest, TResponse>;
+    readonly onRevalidateError?: (error: unknown) => void;
+}
+export declare function createFetchHandler<TRequest extends FetchLikeRequest, TResponse>(options: FetchHandlerOptions<TRequest, TResponse>): (request: TRequest) => Promise<TResponse>;
+//# sourceMappingURL=fetch-handler.d.ts.map

package/dist/fetch-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-handler.d.ts","sourceRoot":"","sources":["../src/fetch-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB;IAC5D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB,CAAC,QAAQ,SAAS,gBAAgB,EAAE,SAAS;IAC7E,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAA;KAAE,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IAClG,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,KAAK,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IACpF,QAAQ,CAAC,QAAQ,EAAE,CACjB,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,QAAQ,EACjB,QAAQ,EAAE,SAAS,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO,CAAC;IACvD,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,SAAS,CAAC;CAC5D;AAED,MAAM,WAAW,mBAAmB,CAClC,QAAQ,SAAS,gBAAgB,EACjC,SAAS,CACT,SAAQ,oBAAoB;IAC5B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IACvD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACvD;AAiED,wBAAgB,kBAAkB,CAAC,QAAQ,SAAS,gBAAgB,EAAE,SAAS,EAC7E,OAAO,EAAE,mBAAmB,CAAC,QAAQ,EAAE,SAAS,CAAC,GAChD,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,SAAS,CAAC,CA0B3C"}

package/dist/fetch-handler.js

@@ -0,0 +1,73 @@
+import { CACHE_STRATEGIES, decideCacheStrategyDecision, } from './cache-strategy.js';
+async function cacheFirst(request, ports) {
+    const cached = await ports.matchCache(request);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const response = await ports.fetch(request);
+    if (ports.isCacheable(response)) {
+        await ports.putCache(CACHE_STRATEGIES.cacheFirst, request, ports.cloneResponse(response));
+    }
+    return response;
+}
+async function networkFirst(request, ports) {
+    try {
+        const response = await ports.fetch(request);
+        if (ports.isCacheable(response)) {
+            await ports.putCache(CACHE_STRATEGIES.networkFirst, request, ports.cloneResponse(response));
+        }
+        return response;
+    }
+    catch (error) {
+        const cached = await ports.matchCache(request);
+        if (cached !== undefined) {
+            return cached;
+        }
+        throw error;
+    }
+}
+async function staleWhileRevalidate(request, ports, onRevalidateError) {
+    const cached = await ports.matchCache(request);
+    const revalidate = (async () => {
+        const response = await ports.fetch(request);
+        if (ports.isCacheable(response)) {
+            await ports.putCache(CACHE_STRATEGIES.staleWhileRevalidate, request, ports.cloneResponse(response));
+        }
+        return response;
+    })();
+    if (cached === undefined) {
+        return revalidate;
+    }
+    revalidate.catch((error) => {
+        onRevalidateError?.(error);
+    });
+    return cached;
+}
+export function createFetchHandler(options) {
+    const { ports, onRevalidateError, ...strategyOptions } = options;
+    return async (request) => {
+        const { strategy, navigationFallback } = decideCacheStrategyDecision(request, strategyOptions);
+        try {
+            switch (strategy) {
+                case CACHE_STRATEGIES.networkOnly:
+                    return await ports.fetch(request, { cache: 'no-store' });
+                case CACHE_STRATEGIES.cacheFirst:
+                    return await cacheFirst(request, ports);
+                case CACHE_STRATEGIES.staleWhileRevalidate:
+                    return await staleWhileRevalidate(request, ports, onRevalidateError);
+                case CACHE_STRATEGIES.networkFirst:
+                    return await networkFirst(request, ports);
+            }
+        }
+        catch (error) {
+            if (navigationFallback !== undefined) {
+                const fallback = await ports.matchCache(navigationFallback);
+                if (fallback !== undefined) {
+                    return fallback;
+                }
+            }
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=fetch-handler.js.map

package/dist/fetch-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-handler.js","sourceRoot":"","sources":["../src/fetch-handler.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { CACHE_STRATEGIES, createCacheStrategyDecider, decideCacheStrategy, type CacheStrategy, type CacheStrategyOptions, type CacheStrategyRequest, } from './cache-strategy.js';
+export { createFetchHandler, type FetchHandlerOptions, type FetchHandlerPorts, type FetchLikeRequest, } from './fetch-handler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { CACHE_STRATEGIES, createCacheStrategyDecider, decideCacheStrategy, } from './cache-strategy.js';
+export { createFetchHandler, } from './fetch-handler.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,mBAAmB,GAIpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,GAInB,MAAM,oBAAoB,CAAC"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@baukit/pwa-web",
+  "version": "0.1.0",
+  "description": "Pure-function caching-strategy decisions for PWA service workers.",
+  "license": "MIT",
+  "author": "Patrick Koss",
+  "homepage": "https://github.com/PatrickKoss/baukit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PatrickKoss/baukit.git",
+    "directory": "typescript/packages/pwa-web"
+  },
+  "bugs": {
+    "url": "https://github.com/PatrickKoss/baukit/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "typescript": "6.0.3",
+    "vitest": "4.1.10"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node --input-type=module -e \"import { writeFileSync } from 'node:fs'; writeFileSync('dist/cjs/package.json', '{\\\"type\\\":\\\"commonjs\\\"}\\\\n')\"",
+    "test": "vitest run --config ../../vitest.config.ts",
+    "lint": "eslint src --max-warnings=0",
+    "format:check": "prettier --check src package.json tsconfig.json tsconfig.cjs.json"
+  }
+}