@serwist/strategies 9.0.0-preview.9 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/strategies",
-  "version": "9.0.0-preview.9",
+  "version": "9.0.0",
   "type": "module",
   "description": "A service worker helper library implementing common caching strategies.",
   "files": [
@@ -17,7 +17,7 @@
   ],
   "author": "Google's Web DevRel Team, Serwist's Team",
   "license": "MIT",
-  "repository": "serwist/serwist",
+  "repository": "https://github.com/serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
   "main": "./dist/index.js",
@@ -30,12 +30,12 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/core": "9.0.0-preview.9"
+    "serwist": "9.0.0"
   },
   "devDependencies": {
-    "rollup": "4.9.6",
-    "typescript": "5.4.0-dev.20240206",
-    "@serwist/constants": "9.0.0-preview.9"
+    "rollup": "4.14.3",
+    "typescript": "5.5.0-dev.20240415",
+    "@serwist/configs": "9.0.0"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"
@@ -47,7 +47,6 @@
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
-    "dev": "rollup --config rollup.config.js --watch",
     "lint": "biome lint ./src",
     "typecheck": "tsc"
   }

package/src/index.ts

@@ -1,34 +1,2 @@
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-import { CacheFirst } from "./CacheFirst.js";
-import { CacheOnly } from "./CacheOnly.js";
-import type { NetworkFirstOptions } from "./NetworkFirst.js";
-import { NetworkFirst } from "./NetworkFirst.js";
-import type { NetworkOnlyOptions } from "./NetworkOnly.js";
-import { NetworkOnly } from "./NetworkOnly.js";
-import { StaleWhileRevalidate } from "./StaleWhileRevalidate.js";
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import { StrategyHandler } from "./StrategyHandler.js";
-
-// See https://github.com/GoogleChrome/workbox/issues/2946
-declare global {
-  interface FetchEvent {
-    // See https://github.com/GoogleChrome/workbox/issues/2974
-    readonly preloadResponse: Promise<any>;
-  }
-}
-
-/**
- * There are common caching strategies that most service workers will need
- * and use. This module provides simple implementations of these strategies.
- */
-export { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate, Strategy, StrategyHandler };
-
-export type { NetworkFirstOptions, NetworkOnlyOptions, StrategyOptions };
+export { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate, Strategy, StrategyHandler } from "serwist";
+export type { NetworkFirstOptions, NetworkOnlyOptions, StrategyOptions } from "serwist";

package/dist/CacheFirst.d.ts

@@ -1,23 +0,0 @@
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-/**
- * An implementation of the [cache first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-first-falling-back-to-network)
- * request strategy.
- *
- * A cache first strategy is useful for assets that have been revisioned,
- * such as URLs like `/styles/example.a8f5f1.css`, since they
- * can be cached for long periods of time.
- *
- * If the network request fails, and there is no cache match, this will throw
- * a `SerwistError` exception.
- */
-export declare class CacheFirst extends Strategy {
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-}
-//# sourceMappingURL=CacheFirst.d.ts.map

package/dist/CacheFirst.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CacheFirst.d.ts","sourceRoot":"","sources":["../src/CacheFirst.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,QAAQ;IACtC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CAsD7E"}

package/dist/CacheOnly.d.ts

@@ -1,20 +0,0 @@
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-/**
- * An implementation of the [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only)
- * request strategy.
- *
- * This class is useful if you want to take advantage of any Serwist plugin.
- *
- * If there is no cache match, this will throw a `SerwistError` exception.
- */
-export declare class CacheOnly extends Strategy {
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-}
-//# sourceMappingURL=CacheOnly.d.ts.map

package/dist/CacheOnly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CacheOnly.d.ts","sourceRoot":"","sources":["../src/CacheOnly.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,QAAQ;IACrC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA4B7E"}

package/dist/NetworkFirst.d.ts

@@ -1,60 +0,0 @@
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-export interface NetworkFirstOptions extends StrategyOptions {
-    /**
-     * If set, any network requests that fail to respond within the timeout will fallback to the cache.
-     */
-    networkTimeoutSeconds?: number;
-}
-export declare class NetworkFirst extends Strategy {
-    private readonly _networkTimeoutSeconds;
-    /**
-     * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache)
-     * request strategy.
-     *
-     * By default, this strategy will cache responses with a 200 status code as
-     * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
-     * Opaque responses are are cross-origin requests where the response doesn't
-     * support [CORS](https://enable-cors.org/).
-     *
-     * If the network request fails, and there is no cache match, this will throw
-     * a `SerwistError` exception.
-     *
-     * @param options
-     * This option can be used to combat
-     * "[lie-fi](https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi)"
-     * scenarios.
-     */
-    constructor(options?: NetworkFirstOptions);
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-    /**
-     * @param options
-     * @returns
-     * @private
-     */
-    private _getTimeoutPromise;
-    /**
-     * @param options
-     * @param options.timeoutId
-     * @param options.request
-     * @param options.logs A reference to the logs Array.
-     * @param options.event
-     * @returns
-     *
-     * @private
-     */
-    _getNetworkPromise({ timeoutId, request, logs, handler, }: {
-        request: Request;
-        logs: any[];
-        timeoutId?: number;
-        handler: StrategyHandler;
-    }): Promise<Response | undefined>;
-}
-//# sourceMappingURL=NetworkFirst.d.ts.map

package/dist/NetworkFirst.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NetworkFirst.d.ts","sourceRoot":"","sources":["../src/NetworkFirst.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI5D,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,qBAAa,YAAa,SAAQ,QAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD;;;;;;;;;;;;;;;;OAgBG;gBACS,OAAO,GAAE,mBAAwB;IAsB7C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgE5E;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;;;;;;;;OASG;IACG,kBAAkB,CAAC,EACvB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAO,GACR,EAAE;QACD,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,EAAE,GAAG,EAAE,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,eAAe,CAAC;KAC1B,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAqClC"}

package/dist/NetworkOnly.d.ts

@@ -1,31 +0,0 @@
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-export interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" | "matchOptions"> {
-    /**
-     * If set, any network requests that fail to respond within the timeout will result in a network error.
-     */
-    networkTimeoutSeconds?: number;
-}
-export declare class NetworkOnly extends Strategy {
-    private readonly _networkTimeoutSeconds;
-    /**
-     * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-only)
-     * request strategy.
-     *
-     * This class is useful if you want to take advantage of any Serwist plugin.
-     *
-     * If the network request fails, this will throw a `SerwistError` exception.
-     *
-     * @param options
-     */
-    constructor(options?: NetworkOnlyOptions);
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-}
-//# sourceMappingURL=NetworkOnly.d.ts.map

package/dist/NetworkOnly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NetworkOnly.d.ts","sourceRoot":"","sources":["../src/NetworkOnly.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,cAAc,CAAC;IAC7F;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,qBAAa,WAAY,SAAQ,QAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD;;;;;;;;;OASG;gBACS,OAAO,GAAE,kBAAuB;IAM5C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA+C7E"}

package/dist/StaleWhileRevalidate.d.ts

@@ -1,34 +0,0 @@
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-export declare class StaleWhileRevalidate extends Strategy {
-    /**
-     * An implementation of the
-     * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#stale-while-revalidate)
-     * request strategy.
-     *
-     * Resources are requested from both the cache and the network in parallel.
-     * The strategy will respond with the cached version if available, otherwise
-     * wait for the network response. The cache is updated with the network response
-     * with each successful request.
-     *
-     * By default, this strategy will cache responses with a 200 status code as
-     * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
-     * Opaque responses are cross-origin requests where the response doesn't
-     * support [CORS](https://enable-cors.org/).
-     *
-     * If the network request fails, and there is no cache match, this will throw
-     * a `SerwistError` exception.
-     *
-     * @param options
-     */
-    constructor(options?: StrategyOptions);
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-}
-//# sourceMappingURL=StaleWhileRevalidate.d.ts.map

package/dist/StaleWhileRevalidate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StaleWhileRevalidate.d.ts","sourceRoot":"","sources":["../src/StaleWhileRevalidate.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI5D,qBAAa,oBAAqB,SAAQ,QAAQ;IAChD;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,OAAO,GAAE,eAAoB;IAUzC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CAsD7E"}

package/dist/Strategy.d.ts

@@ -1,83 +0,0 @@
-import type { HandlerCallbackOptions, RouteHandlerObject, SerwistPlugin } from "@serwist/core";
-import { StrategyHandler } from "./StrategyHandler.js";
-export interface StrategyOptions {
-    /**
-     * Cache name to store and retrieve requests. Defaults to cache names provided by `@serwist/core`.
-     */
-    cacheName?: string;
-    /**
-     * [Plugins](https://developers.google.com/web/tools/workbox/guides/using-plugins)
-     * to use in conjunction with this caching strategy.
-     */
-    plugins?: SerwistPlugin[];
-    /**
-     * Values passed along to the [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
-     * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) `fetch()` requests made by this strategy.
-     */
-    fetchOptions?: RequestInit;
-    /**
-     * The [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
-     * for any `cache.match()` or `cache.put()` calls made by this strategy.
-     */
-    matchOptions?: CacheQueryOptions;
-}
-/**
- * Classes extending the `Strategy` based class should implement this method,
- * and leverage `@serwist/strategies`'s `StrategyHandler` arg to perform all
- * fetching and cache logic, which will ensure all relevant cache, cache options,
- * fetch options and plugins are used (per the current strategy instance).
- */
-export declare abstract class Strategy implements RouteHandlerObject {
-    cacheName: string;
-    plugins: SerwistPlugin[];
-    fetchOptions?: RequestInit;
-    matchOptions?: CacheQueryOptions;
-    protected abstract _handle(request: Request, handler: StrategyHandler): Promise<Response | undefined>;
-    /**
-     * Creates a new instance of the strategy and sets all documented option
-     * properties as public instance properties.
-     *
-     * Note: if a custom strategy class extends the base Strategy class and does
-     * not need more than these properties, it does not need to define its own
-     * constructor.
-     *
-     * @param options
-     */
-    constructor(options?: StrategyOptions);
-    /**
-     * Perform a request strategy and returns a `Promise` that will resolve with
-     * a `Response`, invoking all relevant plugin callbacks.
-     *
-     * When a strategy instance is registered with a `@serwist/routing` Route, this method is automatically
-     * called when the route matches.
-     *
-     * Alternatively, this method can be used in a standalone `FetchEvent`
-     * listener by passing it to `event.respondWith()`.
-     *
-     * @param options A `FetchEvent` or an object with the properties listed below.
-     * @param options.request A request to run this strategy for.
-     * @param options.event The event associated with the request.
-     * @param options.url
-     * @param options.params
-     */
-    handle(options: FetchEvent | HandlerCallbackOptions): Promise<Response>;
-    /**
-     * Similar to `@serwist/strategies`'s `Strategy.handle`, but
-     * instead of just returning a `Promise` that resolves to a `Response` it
-     * it will return an tuple of `[response, done]` promises, where the former
-     * (`response`) is equivalent to what `handle()` returns, and the latter is a
-     * Promise that will resolve once any promises that were added to
-     * `event.waitUntil()` as part of performing the strategy have completed.
-     *
-     * You can await the `done` promise to ensure any extra work performed by
-     * the strategy (usually caching responses) completes successfully.
-     *
-     * @param options A `FetchEvent` or `HandlerCallbackOptions` object.
-     * @returns A tuple of [response, done] promises that can be used to determine when the response resolves as
-     * well as when the handler has completed all its work.
-     */
-    handleAll(options: FetchEvent | HandlerCallbackOptions): [Promise<Response>, Promise<void>];
-    _getResponse(handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<Response>;
-    _awaitComplete(responseDone: Promise<Response>, handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<void>;
-}
-//# sourceMappingURL=Strategy.d.ts.map

package/dist/Strategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Strategy.d.ts","sourceRoot":"","sources":["../src/Strategy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG/F,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED;;;;;GAKG;AACH,8BAAsB,QAAS,YAAW,kBAAkB;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,YAAY,CAAC,EAAE,iBAAiB,CAAC;IAEjC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAErG;;;;;;;;;OASG;gBACS,OAAO,GAAE,eAAoB;IAOzC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKvE;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAsBrF,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyCnG,cAAc,CAAC,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CAqCzI"}

package/dist/StrategyHandler.d.ts

@@ -1,187 +0,0 @@
-import type { HandlerCallbackOptions, SerwistPlugin, SerwistPluginCallbackParam } from "@serwist/core";
-import type { Strategy } from "./Strategy.js";
-/**
- * A class created every time a Strategy instance instance calls `Strategy.handle` or
- * `Strategy.handleAll` that wraps all fetch and cache actions around plugin callbacks
- * and keeps track of when the strategy is "done" (i.e. all added `event.waitUntil()` promises
- * have resolved).
- */
-export declare class StrategyHandler {
-    /**
-     * The request the strategy is performing (passed to the strategy's
-     * `handle()` or `handleAll()` method).
-     */
-    request: Request;
-    /**
-     * A `URL` instance of `request.url` (if passed to the strategy's
-     * `handle()` or `handleAll()` method).
-     * Note: the `url` param will be present if the strategy was invoked
-     * from a `@serwist/routing.Route` object.
-     */
-    url?: URL;
-    /**
-     * The event associated with this request.
-     */
-    event: ExtendableEvent;
-    /**
-     * A `param` value (if passed to the strategy's
-     * `handle()` or `handleAll()` method).
-     * Note: the `param` param will be present if the strategy was invoked
-     * from a `@serwist/routing.Route` object and the `@serwist/strategies.matchCallback`
-     * returned a truthy value (it will be that value).
-     */
-    params?: any;
-    private _cacheKeys;
-    private readonly _strategy;
-    private readonly _extendLifetimePromises;
-    private readonly _handlerDeferred;
-    private readonly _plugins;
-    private readonly _pluginStateMap;
-    /**
-     * Creates a new instance associated with the passed strategy and event
-     * that's handling the request.
-     *
-     * The constructor also initializes the state that will be passed to each of
-     * the plugins handling this request.
-     *
-     * @param strategy
-     * @param options
-     */
-    constructor(strategy: Strategy, options: HandlerCallbackOptions);
-    /**
-     * Fetches a given request (and invokes any applicable plugin callback
-     * methods) using the `fetchOptions` (for non-navigation requests) and
-     * `plugins` defined on the `Strategy` object.
-     *
-     * The following plugin lifecycle methods are invoked when using this method:
-     * - `requestWillFetch()`
-     * - `fetchDidSucceed()`
-     * - `fetchDidFail()`
-     *
-     * @param input The URL or request to fetch.
-     * @returns
-     */
-    fetch(input: RequestInfo): Promise<Response>;
-    /**
-     * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on
-     * the response generated by `this.fetch()`.
-     *
-     * The call to `this.cachePut()` automatically invokes `this.waitUntil()`,
-     * so you do not have to manually call `waitUntil()` on the event.
-     *
-     * @param input The request or URL to fetch and cache.
-     * @returns
-     */
-    fetchAndCachePut(input: RequestInfo): Promise<Response>;
-    /**
-     * Matches a request from the cache (and invokes any applicable plugin
-     * callback methods) using the `cacheName`, `matchOptions`, and `plugins`
-     * defined on the strategy object.
-     *
-     * The following plugin lifecycle methods are invoked when using this method:
-     * - cacheKeyWillByUsed()
-     * - cachedResponseWillByUsed()
-     *
-     * @param key The Request or URL to use as the cache key.
-     * @returns A matching response, if found.
-     */
-    cacheMatch(key: RequestInfo): Promise<Response | undefined>;
-    /**
-     * Puts a request/response pair in the cache (and invokes any applicable
-     * plugin callback methods) using the `cacheName` and `plugins` defined on
-     * the strategy object.
-     *
-     * The following plugin lifecycle methods are invoked when using this method:
-     * - cacheKeyWillByUsed()
-     * - cacheWillUpdate()
-     * - cacheDidUpdate()
-     *
-     * @param key The request or URL to use as the cache key.
-     * @param response The response to cache.
-     * @returns `false` if a cacheWillUpdate caused the response
-     * not be cached, and `true` otherwise.
-     */
-    cachePut(key: RequestInfo, response: Response): Promise<boolean>;
-    /**
-     * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and
-     * executes any of those callbacks found in sequence. The final `Request`
-     * object returned by the last plugin is treated as the cache key for cache
-     * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have
-     * been registered, the passed request is returned unmodified
-     *
-     * @param request
-     * @param mode
-     * @returns
-     */
-    getCacheKey(request: Request, mode: "read" | "write"): Promise<Request>;
-    /**
-     * Returns true if the strategy has at least one plugin with the given
-     * callback.
-     *
-     * @param name The name of the callback to check for.
-     * @returns
-     */
-    hasCallback<C extends keyof SerwistPlugin>(name: C): boolean;
-    /**
-     * Runs all plugin callbacks matching the given name, in order, passing the
-     * given param object (merged ith the current plugin state) as the only
-     * argument.
-     *
-     * Note: since this method runs all plugins, it's not suitable for cases
-     * where the return value of a callback needs to be applied prior to calling
-     * the next callback. See `@serwist/strategies.iterateCallbacks` for how to handle that case.
-     *
-     * @param name The name of the callback to run within each plugin.
-     * @param param The object to pass as the first (and only) param when executing each callback. This object will be merged with the
-     * current plugin state prior to callback execution.
-     */
-    runCallbacks<C extends keyof NonNullable<SerwistPlugin>>(name: C, param: Omit<SerwistPluginCallbackParam[C], "state">): Promise<void>;
-    /**
-     * Accepts a callback and returns an iterable of matching plugin callbacks,
-     * where each callback is wrapped with the current handler state (i.e. when
-     * you call each callback, whatever object parameter you pass it will
-     * be merged with the plugin's current state).
-     *
-     * @param name The name fo the callback to run
-     * @returns
-     */
-    iterateCallbacks<C extends keyof SerwistPlugin>(name: C): Generator<NonNullable<SerwistPlugin[C]>>;
-    /**
-     * Adds a promise to the
-     * [extend lifetime promises](https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises)
-     * of the event event associated with the request being handled (usually a `FetchEvent`).
-     *
-     * Note: you can await
-     * `@serwist/strategies.StrategyHandler.doneWaiting`
-     * to know when all added promises have settled.
-     *
-     * @param promise A promise to add to the extend lifetime promises of
-     * the event that triggered the request.
-     */
-    waitUntil<T>(promise: Promise<T>): Promise<T>;
-    /**
-     * Returns a promise that resolves once all promises passed to
-     * `@serwist/strategies.StrategyHandler.waitUntil` have settled.
-     *
-     * Note: any work done after `doneWaiting()` settles should be manually
-     * passed to an event's `waitUntil()` method (not this handler's
-     * `waitUntil()` method), otherwise the service worker thread my be killed
-     * prior to your work completing.
-     */
-    doneWaiting(): Promise<void>;
-    /**
-     * Stops running the strategy and immediately resolves any pending
-     * `waitUntil()` promises.
-     */
-    destroy(): void;
-    /**
-     * This method will call `cacheWillUpdate` on the available plugins (or use
-     * status === 200) to determine if the response is safe and valid to cache.
-     *
-     * @param response
-     * @returns
-     * @private
-     */
-    _ensureResponseSafeToCache(response: Response): Promise<Response | undefined>;
-}
-//# sourceMappingURL=StrategyHandler.d.ts.map

package/dist/StrategyHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StrategyHandler.d.ts","sourceRoot":"","sources":["../src/StrategyHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAiB,aAAa,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAYtH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAM9C;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B;;;OAGG;IACI,OAAO,EAAG,OAAO,CAAC;IACzB;;;;;OAKG;IACI,GAAG,CAAC,EAAE,GAAG,CAAC;IACjB;;OAEG;IACI,KAAK,EAAE,eAAe,CAAC;IAC9B;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,GAAG,CAAC;IAEpB,OAAO,CAAC,UAAU,CAA+B;IAEjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAiB;IACzD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgB;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IAEpE;;;;;;;;;OASG;gBACS,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,sBAAsB;IA4B/D;;;;;;;;;;;;OAYG;IACG,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyElD;;;;;;;;;OASG;IACG,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAS7D;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IA+BjE;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IA8FtE;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB7E;;;;;;OAMG;IACH,WAAW,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO;IAS5D;;;;;;;;;;;;OAYG;IACG,YAAY,CAAC,CAAC,SAAS,MAAM,WAAW,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3I;;;;;;;;OAQG;IACF,gBAAgB,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAgBnG;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK7C;;;;;;;;OAQG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAOlC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAIf;;;;;;;OAOG;IACG,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAuCpF"}

package/dist/plugins/cacheOkAndOpaquePlugin.d.ts

@@ -1,3 +0,0 @@
-import type { SerwistPlugin } from "@serwist/core";
-export declare const cacheOkAndOpaquePlugin: SerwistPlugin;
-//# sourceMappingURL=cacheOkAndOpaquePlugin.d.ts.map

package/dist/plugins/cacheOkAndOpaquePlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cacheOkAndOpaquePlugin.d.ts","sourceRoot":"","sources":["../../src/plugins/cacheOkAndOpaquePlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,eAAO,MAAM,sBAAsB,EAAE,aAepC,CAAC"}

package/dist/utils/messages.d.ts

@@ -1,5 +0,0 @@
-export declare const messages: {
-    strategyStart: (strategyName: string, request: Request) => string;
-    printFinalResponse: (response?: Response) => void;
-};
-//# sourceMappingURL=messages.d.ts.map

package/dist/utils/messages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/utils/messages.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,QAAQ;kCACW,MAAM,WAAW,OAAO,KAAG,MAAM;oCAC/B,QAAQ,KAAG,IAAI;CAOhD,CAAC"}

package/src/CacheFirst.ts

@@ -1,87 +0,0 @@
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-import { assert, SerwistError, logger } from "@serwist/core/internal";
-
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-import { messages } from "./utils/messages.js";
-
-/**
- * An implementation of the [cache first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-first-falling-back-to-network)
- * request strategy.
- *
- * A cache first strategy is useful for assets that have been revisioned,
- * such as URLs like `/styles/example.a8f5f1.css`, since they
- * can be cached for long periods of time.
- *
- * If the network request fails, and there is no cache match, this will throw
- * a `SerwistError` exception.
- */
-export class CacheFirst extends Strategy {
-  /**
-   * @private
-   * @param request A request to run this strategy for.
-   * @param handler The event that triggered the request.
-   * @returns
-   */
-  async _handle(request: Request, handler: StrategyHandler): Promise<Response> {
-    const logs = [];
-
-    if (process.env.NODE_ENV !== "production") {
-      assert!.isInstance(request, Request, {
-        moduleName: "@serwist/strategies",
-        className: this.constructor.name,
-        funcName: "makeRequest",
-        paramName: "request",
-      });
-    }
-
-    let response = await handler.cacheMatch(request);
-
-    let error: Error | undefined = undefined;
-    if (!response) {
-      if (process.env.NODE_ENV !== "production") {
-        logs.push(`No response found in the '${this.cacheName}' cache. Will respond with a network request.`);
-      }
-      try {
-        response = await handler.fetchAndCachePut(request);
-      } catch (err) {
-        if (err instanceof Error) {
-          error = err;
-        }
-      }
-
-      if (process.env.NODE_ENV !== "production") {
-        if (response) {
-          logs.push("Got response from network.");
-        } else {
-          logs.push("Unable to get a response from the network.");
-        }
-      }
-    } else {
-      if (process.env.NODE_ENV !== "production") {
-        logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
-      }
-    }
-
-    if (process.env.NODE_ENV !== "production") {
-      logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-      for (const log of logs) {
-        logger.log(log);
-      }
-      messages.printFinalResponse(response);
-      logger.groupEnd();
-    }
-
-    if (!response) {
-      throw new SerwistError("no-response", { url: request.url, error });
-    }
-    return response;
-  }
-}