@serwist/strategies 9.0.0-preview.0 → 9.0.0-preview.10

package/dist/CacheFirst.d.ts

@@ -1,7 +1,7 @@
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
 /**
- * An implementation of a [cache first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-first-falling-back-to-network)
+ * 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,
@@ -11,7 +11,7 @@ import type { StrategyHandler } from "./StrategyHandler.js";
  * If the network request fails, and there is no cache match, this will throw
  * a `SerwistError` exception.
  */
-declare class CacheFirst extends Strategy {
+export declare class CacheFirst extends Strategy {
     /**
      * @private
      * @param request A request to run this strategy for.
@@ -20,5 +20,4 @@ declare class CacheFirst extends Strategy {
      */
     _handle(request: Request, handler: StrategyHandler): Promise<Response>;
 }
-export { CacheFirst };
 //# sourceMappingURL=CacheFirst.d.ts.map

package/dist/CacheFirst.d.ts.map

@@ -1 +1 @@
-{"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,cAAM,UAAW,SAAQ,QAAQ;IAC/B;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CAsD7E;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"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,14 +1,14 @@
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
 /**
- * An implementation of a [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only)
+ * 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.
  */
-declare class CacheOnly extends Strategy {
+export declare class CacheOnly extends Strategy {
     /**
      * @private
      * @param request A request to run this strategy for.
@@ -17,5 +17,4 @@ declare class CacheOnly extends Strategy {
      */
     _handle(request: Request, handler: StrategyHandler): Promise<Response>;
 }
-export { CacheOnly };
 //# sourceMappingURL=CacheOnly.d.ts.map

package/dist/CacheOnly.d.ts.map

@@ -1 +1 @@
-{"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,cAAM,SAAU,SAAQ,QAAQ;IAC9B;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA4B7E;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"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

@@ -7,21 +7,20 @@ export interface NetworkFirstOptions extends StrategyOptions {
      */
     networkTimeoutSeconds?: number;
 }
-/**
- * An implementation of a [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.
- */
-declare class NetworkFirst extends Strategy {
+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)"
@@ -58,5 +57,4 @@ declare class NetworkFirst extends Strategy {
         handler: StrategyHandler;
     }): Promise<Response | undefined>;
 }
-export { NetworkFirst };
 //# sourceMappingURL=NetworkFirst.d.ts.map

package/dist/NetworkFirst.d.ts.map

@@ -1 +1 @@
-{"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;;;;;;;;;;;GAWG;AACH,cAAM,YAAa,SAAQ,QAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD;;;;;OAKG;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;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"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,23 +1,22 @@
 import type { StrategyOptions } from "./Strategy.js";
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
-interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" | "matchOptions"> {
+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;
 }
-/**
- * An implementation of a [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.
- */
-declare class NetworkOnly extends Strategy {
+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);
@@ -29,6 +28,4 @@ declare class NetworkOnly extends Strategy {
      */
     _handle(request: Request, handler: StrategyHandler): Promise<Response>;
 }
-export { NetworkOnly };
-export type { NetworkOnlyOptions };
 //# sourceMappingURL=NetworkOnly.d.ts.map

package/dist/NetworkOnly.d.ts.map

@@ -1 +1 @@
-{"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,UAAU,kBAAmB,SAAQ,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,cAAc,CAAC;IACtF;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,cAAM,WAAY,SAAQ,QAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD;;OAEG;gBACS,OAAO,GAAE,kBAAuB;IAM5C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA+C7E;AAED,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,kBAAkB,EAAE,CAAC"}
+{"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,26 +1,25 @@
 import type { StrategyOptions } from "./Strategy.js";
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
-/**
- * An implementation of a
- * [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.
- */
-declare class StaleWhileRevalidate extends Strategy {
+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);
@@ -32,5 +31,4 @@ declare class StaleWhileRevalidate extends Strategy {
      */
     _handle(request: Request, handler: StrategyHandler): Promise<Response>;
 }
-export { StaleWhileRevalidate };
 //# sourceMappingURL=StaleWhileRevalidate.d.ts.map

package/dist/StaleWhileRevalidate.d.ts.map

@@ -1 +1 @@
-{"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;;;;;;;;;;;;;;;;;GAiBG;AACH,cAAM,oBAAqB,SAAQ,QAAQ;IACzC;;OAEG;gBACS,OAAO,GAAE,eAAoB;IAUzC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CAsD7E;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC"}
+{"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

@@ -27,7 +27,7 @@ export interface StrategyOptions {
  * fetching and cache logic, which will ensure all relevant cache, cache options,
  * fetch options and plugins are used (per the current strategy instance).
  */
-declare abstract class Strategy implements RouteHandlerObject {
+export declare abstract class Strategy implements RouteHandlerObject {
     cacheName: string;
     plugins: SerwistPlugin[];
     fetchOptions?: RequestInit;
@@ -80,5 +80,4 @@ declare abstract class Strategy implements RouteHandlerObject {
     _getResponse(handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<Response>;
     _awaitComplete(responseDone: Promise<Response>, handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<void>;
 }
-export { Strategy };
 //# sourceMappingURL=Strategy.d.ts.map

package/dist/Strategy.d.ts.map

@@ -1 +1 @@
-{"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,uBAAe,QAAS,YAAW,kBAAkB;IACnD,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;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"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

@@ -6,7 +6,7 @@ import type { Strategy } from "./Strategy.js";
  * and keeps track of when the strategy is "done" (i.e. all added `event.waitUntil()` promises
  * have resolved).
  */
-declare class StrategyHandler {
+export declare class StrategyHandler {
     /**
      * The request the strategy is performing (passed to the strategy's
      * `handle()` or `handleAll()` method).
@@ -184,5 +184,4 @@ declare class StrategyHandler {
      */
     _ensureResponseSafeToCache(response: Response): Promise<Response | undefined>;
 }
-export { StrategyHandler };
 //# sourceMappingURL=StrategyHandler.d.ts.map

package/dist/StrategyHandler.d.ts.map

@@ -1 +1 @@
-{"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,cAAM,eAAe;IACnB;;;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;IA4FtE;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAsB7E;;;;;;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;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"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/index.js

@@ -3,48 +3,18 @@ import { assert, Deferred, logger, getFriendlyURL, SerwistError, timeout, cacheM
 function toRequest(input) {
     return typeof input === "string" ? new Request(input) : input;
 }
-/**
- * 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).
- */ class StrategyHandler {
-    /**
-   * The request the strategy is performing (passed to the strategy's
-   * `handle()` or `handleAll()` method).
-   */ 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;
-    /**
-   * The event associated with this request.
-   */ event;
-    /**
-   * 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;
+class StrategyHandler {
+    request;
+    url;
+    event;
+    params;
     _cacheKeys = {};
     _strategy;
     _extendLifetimePromises;
     _handlerDeferred;
     _plugins;
     _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, options){
+    constructor(strategy, options){
         if (process.env.NODE_ENV !== "production") {
             assert.isInstance(options.event, ExtendableEvent, {
                 moduleName: "@serwist/strategies",
@@ -58,8 +28,6 @@ function toRequest(input) {
         this._strategy = strategy;
         this._handlerDeferred = new Deferred();
         this._extendLifetimePromises = [];
-        // Copy the plugins list (since it's mutable on the strategy),
-        // so any mutations don't affect this handler instance.
         this._plugins = [
             ...strategy.plugins
         ];
@@ -69,19 +37,7 @@ function toRequest(input) {
         }
         this.event.waitUntil(this._handlerDeferred.promise);
     }
-    /**
-   * 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
-   */ async fetch(input) {
+    async fetch(input) {
         const { event } = this;
         let request = toRequest(input);
         if (request.mode === "navigate" && event instanceof FetchEvent && event.preloadResponse) {
@@ -93,9 +49,6 @@ function toRequest(input) {
                 return possiblePreloadResponse;
             }
         }
-        // If there is a fetchDidFail plugin, we need to save a clone of the
-        // original request before it's either modified by a requestWillFetch
-        // plugin or before the original request's body is consumed via fetch().
         const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
         try {
             for (const cb of this.iterateCallbacks("requestWillFetch")){
@@ -111,13 +64,9 @@ function toRequest(input) {
                 });
             }
         }
-        // The request can be altered by plugins with `requestWillFetch` making
-        // the original request (most likely from a `fetch` event) different
-        // from the Request we make. Pass both to `fetchDidFail` to aid debugging.
         const pluginFilteredRequest = request.clone();
         try {
             let fetchResponse;
-            // See https://github.com/GoogleChrome/workbox/issues/1796
             fetchResponse = await fetch(request, request.mode === "navigate" ? undefined : this._strategy.fetchOptions);
             if (process.env.NODE_ENV !== "production") {
                 logger.debug(`Network request for '${getFriendlyURL(request.url)}' returned a response with status '${fetchResponse.status}'.`);
@@ -134,8 +83,6 @@ function toRequest(input) {
             if (process.env.NODE_ENV !== "production") {
                 logger.log(`Network request for '${getFriendlyURL(request.url)}' threw an error.`, error);
             }
-            // `originalRequest` will only exist if a `fetchDidFail` callback
-            // is being used (see above).
             if (originalRequest) {
                 await this.runCallbacks("fetchDidFail", {
                     error: error,
@@ -147,33 +94,13 @@ function toRequest(input) {
             throw error;
         }
     }
-    /**
-   * 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
-   */ async fetchAndCachePut(input) {
+    async fetchAndCachePut(input) {
         const response = await this.fetch(input);
         const responseClone = response.clone();
         void this.waitUntil(this.cachePut(input, responseClone));
         return 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.
-   */ async cacheMatch(key) {
+    async cacheMatch(key) {
         const request = toRequest(key);
         let cachedResponse;
         const { cacheName, matchOptions } = this._strategy;
@@ -203,24 +130,8 @@ function toRequest(input) {
         }
         return cachedResponse;
     }
-    /**
-   * 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.
-   */ async cachePut(key, response) {
+    async cachePut(key, response) {
         const request = toRequest(key);
-        // Run in the next task to avoid blocking other cache reads.
-        // https://github.com/w3c/ServiceWorker/issues/1397
         await timeout(0);
         const effectiveRequest = await this.getCacheKey(request, "write");
         if (process.env.NODE_ENV !== "production") {
@@ -230,11 +141,6 @@ function toRequest(input) {
                     method: effectiveRequest.method
                 });
             }
-            // See https://github.com/GoogleChrome/workbox/issues/2818
-            const vary = response.headers.get("Vary");
-            if (vary) {
-                logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`);
-            }
         }
         if (!response) {
             if (process.env.NODE_ENV !== "production") {
@@ -253,21 +159,23 @@ function toRequest(input) {
         }
         const { cacheName, matchOptions } = this._strategy;
         const cache = await self.caches.open(cacheName);
+        if (process.env.NODE_ENV !== "production") {
+            const vary = response.headers.get("Vary");
+            if (vary && matchOptions?.ignoreVary !== true) {
+                logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`);
+            }
+        }
         const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
-        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(// TODO(philipwalton): the `__WB_REVISION__` param is a precaching
-        // feature. Consider into ways to only add this behavior if using
-        // precaching.
-        cache, effectiveRequest.clone(), [
+        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(cache, effectiveRequest.clone(), [
             "__WB_REVISION__"
         ], matchOptions) : null;
         if (process.env.NODE_ENV !== "production") {
-            logger.debug(`Updating the '${cacheName}' cache with a new Response ` + `for ${getFriendlyURL(effectiveRequest.url)}.`);
+            logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
         }
         try {
             await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);
         } catch (error) {
             if (error instanceof Error) {
-                // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError
                 if (error.name === "QuotaExceededError") {
                     await executeQuotaErrorCallbacks();
                 }
@@ -285,17 +193,7 @@ function toRequest(input) {
         }
         return true;
     }
-    /**
-   * 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
-   */ async getCacheKey(request, mode) {
+    async getCacheKey(request, mode) {
         const key = `${request.url} | ${mode}`;
         if (!this._cacheKeys[key]) {
             let effectiveRequest = request;
@@ -304,7 +202,6 @@ function toRequest(input) {
                     mode,
                     request: effectiveRequest,
                     event: this.event,
-                    // params has a type any can't change right now.
                     params: this.params
                 }));
             }
@@ -312,13 +209,7 @@ function toRequest(input) {
         }
         return this._cacheKeys[key];
     }
-    /**
-   * 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(name) {
+    hasCallback(name) {
         for (const plugin of this._strategy.plugins){
             if (name in plugin) {
                 return true;
@@ -326,34 +217,12 @@ function toRequest(input) {
         }
         return false;
     }
-    /**
-   * 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.
-   */ async runCallbacks(name, param) {
+    async runCallbacks(name, param) {
         for (const callback of this.iterateCallbacks(name)){
-            // TODO(philipwalton): not sure why `any` is needed. It seems like
-            // this should work with `as SerwistPluginCallbackParam[C]`.
             await callback(param);
         }
     }
-    /**
-   * 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(name) {
+    *iterateCallbacks(name) {
         for (const plugin of this._strategy.plugins){
             if (typeof plugin[name] === "function") {
                 const state = this._pluginStateMap.get(plugin);
@@ -362,57 +231,26 @@ function toRequest(input) {
                         ...param,
                         state
                     };
-                    // TODO(philipwalton): not sure why `any` is needed. It seems like
-                    // this should work with `as WorkboxPluginCallbackParam[C]`.
                     return plugin[name](statefulParam);
                 };
                 yield statefulCallback;
             }
         }
     }
-    /**
-   * 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(promise) {
+    waitUntil(promise) {
         this._extendLifetimePromises.push(promise);
         return promise;
     }
-    /**
-   * 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.
-   */ async doneWaiting() {
+    async doneWaiting() {
         let promise = undefined;
         while(promise = this._extendLifetimePromises.shift()){
             await promise;
         }
     }
-    /**
-   * Stops running the strategy and immediately resolves any pending
-   * `waitUntil()` promises.
-   */ destroy() {
+    destroy() {
         this._handlerDeferred.resolve(null);
     }
-    /**
-   * 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
-   */ async _ensureResponseSafeToCache(response) {
+    async _ensureResponseSafeToCache(response) {
         let responseToCache = response;
         let pluginsUsed = false;
         for (const callback of this.iterateCallbacks("cacheWillUpdate")){
@@ -446,66 +284,22 @@ function toRequest(input) {
     }
 }
 
-/**
- * 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).
- */ class Strategy {
+class Strategy {
     cacheName;
     plugins;
     fetchOptions;
     matchOptions;
-    /**
-   * 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 = {}){
+    constructor(options = {}){
         this.cacheName = privateCacheNames.getRuntimeName(options.cacheName);
         this.plugins = options.plugins || [];
         this.fetchOptions = options.fetchOptions;
         this.matchOptions = options.matchOptions;
     }
-    /**
-   * 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) {
+    handle(options) {
         const [responseDone] = this.handleAll(options);
         return responseDone;
     }
-    /**
-   * 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) {
-        // Allow for flexible options to be passed.
+    handleAll(options) {
         if (options instanceof FetchEvent) {
             options = {
                 event: options,
@@ -522,7 +316,6 @@ function toRequest(input) {
         });
         const responseDone = this._getResponse(handler, request, event);
         const handlerDone = this._awaitComplete(responseDone, handler, request, event);
-        // Return an array of promises, suitable for use with Promise.all().
         return [
             responseDone,
             handlerDone
@@ -536,9 +329,6 @@ function toRequest(input) {
         let response = undefined;
         try {
             response = await this._handle(request, handler);
-            // The "official" Strategy subclasses all throw this error automatically,
-            // but in case a third-party Strategy doesn't, ensure that we have a
-            // consistent failure when there's no response or an error response.
             if (response === undefined || response.type === "error") {
                 throw new SerwistError("no-response", {
                     url: request.url
@@ -578,11 +368,7 @@ function toRequest(input) {
         let error = undefined;
         try {
             response = await responseDone;
-        } catch (error) {
-        // Ignore errors, as response errors should be caught via the `response`
-        // promise above. The `done` promise will only throw for errors in
-        // promises passed to `handler.waitUntil()`.
-        }
+        } catch (error) {}
         try {
             await handler.runCallbacks("handlerDidRespond", {
                 event,
@@ -619,23 +405,8 @@ const messages = {
     }
 };
 
-/**
- * An implementation of a [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.
- */ 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, handler) {
+class CacheFirst extends Strategy {
+    async _handle(request, handler) {
         const logs = [];
         if (process.env.NODE_ENV !== "production") {
             assert.isInstance(request, Request, {
@@ -688,20 +459,8 @@ const messages = {
     }
 }
 
-/**
- * An implementation of a [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.
- */ class CacheOnly extends Strategy {
-    /**
-   * @private
-   * @param request A request to run this strategy for.
-   * @param handler The event that triggered the request.
-   * @returns
-   */ async _handle(request, handler) {
+class CacheOnly extends Strategy {
+    async _handle(request, handler) {
         if (process.env.NODE_ENV !== "production") {
             assert.isInstance(request, Request, {
                 moduleName: "@serwist/strategies",
@@ -730,21 +489,8 @@ const messages = {
     }
 }
 
-/*
-  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.
-*/ const cacheOkAndOpaquePlugin = {
-    /**
-   * Returns a valid response (to allow caching) if the status is 200 (OK) or
-   * 0 (opaque).
-   *
-   * @param options
-   * @returns
-   * @private
-   */ cacheWillUpdate: async ({ response })=>{
+const cacheOkAndOpaquePlugin = {
+    cacheWillUpdate: async ({ response })=>{
         if (response.status === 200 || response.status === 0) {
             return response;
         }
@@ -752,28 +498,10 @@ const messages = {
     }
 };
 
-/**
- * An implementation of a [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.
- */ class NetworkFirst extends Strategy {
+class NetworkFirst extends Strategy {
     _networkTimeoutSeconds;
-    /**
-   * @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 = {}){
+    constructor(options = {}){
         super(options);
-        // If this instance contains no plugins with a 'cacheWillUpdate' callback,
-        // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list.
         if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
             this.plugins.unshift(cacheOkAndOpaquePlugin);
         }
@@ -789,12 +517,7 @@ const messages = {
             }
         }
     }
-    /**
-   * @private
-   * @param request A request to run this strategy for.
-   * @param handler The event that triggered the request.
-   * @returns
-   */ async _handle(request, handler) {
+    async _handle(request, handler) {
         const logs = [];
         if (process.env.NODE_ENV !== "production") {
             assert.isInstance(request, Request, {
@@ -823,13 +546,7 @@ const messages = {
         });
         promises.push(networkPromise);
         const response = await handler.waitUntil((async ()=>{
-            // Promise.race() will resolve as soon as the first promise resolves.
-            return await handler.waitUntil(Promise.race(promises)) || // If Promise.race() resolved with null, it might be due to a network
-            // timeout + a cache miss. If that were to happen, we'd rather wait until
-            // the networkPromise resolves instead of returning null.
-            // Note that it's fine to await an already-resolved promise, so we don't
-            // have to check to see if it's still "in flight".
-            await networkPromise;
+            return await handler.waitUntil(Promise.race(promises)) || await networkPromise;
         })());
         if (process.env.NODE_ENV !== "production") {
             logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
@@ -846,12 +563,7 @@ const messages = {
         }
         return response;
     }
-    /**
-   * @param options
-   * @returns
-   * @private
-   */ _getTimeoutPromise({ request, logs, handler }) {
-        // biome-ignore lint/suspicious/noImplicitAnyLet: setTimeout is typed with Node.js's typings, so we can't use number | undefined here.
+    _getTimeoutPromise({ request, logs, handler }) {
         let timeoutId;
         const timeoutPromise = new Promise((resolve)=>{
             const onNetworkTimeout = async ()=>{
@@ -867,16 +579,7 @@ const messages = {
             id: timeoutId
         };
     }
-    /**
-   * @param options
-   * @param options.timeoutId
-   * @param options.request
-   * @param options.logs A reference to the logs Array.
-   * @param options.event
-   * @returns
-   *
-   * @private
-   */ async _getNetworkPromise({ timeoutId, request, logs, handler }) {
+    async _getNetworkPromise({ timeoutId, request, logs, handler }) {
         let error = undefined;
         let response = undefined;
         try {
@@ -910,27 +613,13 @@ const messages = {
     }
 }
 
-/**
- * An implementation of a [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.
- */ class NetworkOnly extends Strategy {
+class NetworkOnly extends Strategy {
     _networkTimeoutSeconds;
-    /**
-   * @param options
-   */ constructor(options = {}){
+    constructor(options = {}){
         super(options);
         this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
     }
-    /**
-   * @private
-   * @param request A request to run this strategy for.
-   * @param handler The event that triggered the request.
-   * @returns
-   */ async _handle(request, handler) {
+    async _handle(request, handler) {
         if (process.env.NODE_ENV !== "production") {
             assert.isInstance(request, Request, {
                 moduleName: "@serwist/strategies",
@@ -978,40 +667,14 @@ const messages = {
     }
 }
 
-/**
- * An implementation of a
- * [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.
- */ class StaleWhileRevalidate extends Strategy {
-    /**
-   * @param options
-   */ constructor(options = {}){
+class StaleWhileRevalidate extends Strategy {
+    constructor(options = {}){
         super(options);
-        // If this instance contains no plugins with a 'cacheWillUpdate' callback,
-        // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list.
         if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
             this.plugins.unshift(cacheOkAndOpaquePlugin);
         }
     }
-    /**
-   * @private
-   * @param request A request to run this strategy for.
-   * @param handler The event that triggered the request.
-   * @returns
-   */ async _handle(request, handler) {
+    async _handle(request, handler) {
         const logs = [];
         if (process.env.NODE_ENV !== "production") {
             assert.isInstance(request, Request, {
@@ -1021,10 +684,7 @@ const messages = {
                 paramName: "request"
             });
         }
-        const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(()=>{
-        // Swallow this error because a 'no-response' error will be thrown in
-        // main handler return flow. This will be in the `waitUntil()` flow.
-        });
+        const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(()=>{});
         void handler.waitUntil(fetchAndCachePromise);
         let response = await handler.cacheMatch(request);
         let error = undefined;
@@ -1037,8 +697,6 @@ const messages = {
                 logs.push(`No response found in the '${this.cacheName}' cache. Will wait for the network response.`);
             }
             try {
-                // NOTE(philipwalton): Really annoying that we have to type cast here.
-                // https://github.com/microsoft/TypeScript/issues/20006
                 response = await fetchAndCachePromise;
             } catch (err) {
                 if (err instanceof Error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/strategies",
-  "version": "9.0.0-preview.0",
+  "version": "9.0.0-preview.10",
   "type": "module",
   "description": "A service worker helper library implementing common caching strategies.",
   "files": [
@@ -30,12 +30,12 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/core": "9.0.0-preview.0"
+    "@serwist/core": "9.0.0-preview.10"
   },
   "devDependencies": {
     "rollup": "4.9.6",
-    "typescript": "5.4.0-dev.20240203",
-    "@serwist/constants": "9.0.0-preview.0"
+    "typescript": "5.4.0-dev.20240206",
+    "@serwist/constants": "9.0.0-preview.10"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/CacheFirst.ts

@@ -13,7 +13,7 @@ import type { StrategyHandler } from "./StrategyHandler.js";
 import { messages } from "./utils/messages.js";
 
 /**
- * An implementation of a [cache first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-first-falling-back-to-network)
+ * 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,
@@ -23,7 +23,7 @@ import { messages } from "./utils/messages.js";
  * If the network request fails, and there is no cache match, this will throw
  * a `SerwistError` exception.
  */
-class CacheFirst extends Strategy {
+export class CacheFirst extends Strategy {
   /**
    * @private
    * @param request A request to run this strategy for.
@@ -85,5 +85,3 @@ class CacheFirst extends Strategy {
     return response;
   }
 }
-
-export { CacheFirst };

package/src/CacheOnly.ts

@@ -13,14 +13,14 @@ import type { StrategyHandler } from "./StrategyHandler.js";
 import { messages } from "./utils/messages.js";
 
 /**
- * An implementation of a [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only)
+ * 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.
  */
-class CacheOnly extends Strategy {
+export class CacheOnly extends Strategy {
   /**
    * @private
    * @param request A request to run this strategy for.
@@ -56,5 +56,3 @@ class CacheOnly extends Strategy {
     return response;
   }
 }
-
-export { CacheOnly };

package/src/NetworkFirst.ts

@@ -21,22 +21,21 @@ export interface NetworkFirstOptions extends StrategyOptions {
   networkTimeoutSeconds?: number;
 }
 
-/**
- * An implementation of a [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.
- */
-class NetworkFirst extends Strategy {
+export class NetworkFirst extends Strategy {
   private readonly _networkTimeoutSeconds: number;
 
   /**
+   * 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)"
@@ -227,5 +226,3 @@ class NetworkFirst extends Strategy {
     return response;
   }
 }
-
-export { NetworkFirst };

package/src/NetworkOnly.ts

@@ -13,25 +13,24 @@ import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
 import { messages } from "./utils/messages.js";
 
-interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" | "matchOptions"> {
+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;
 }
 
-/**
- * An implementation of a [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.
- */
-class NetworkOnly extends Strategy {
+export class NetworkOnly extends Strategy {
   private readonly _networkTimeoutSeconds: number;
 
   /**
+   * 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 = {}) {
@@ -94,6 +93,3 @@ class NetworkOnly extends Strategy {
     return response;
   }
 }
-
-export { NetworkOnly };
-export type { NetworkOnlyOptions };

package/src/StaleWhileRevalidate.ts

@@ -14,26 +14,25 @@ import type { StrategyHandler } from "./StrategyHandler.js";
 import { cacheOkAndOpaquePlugin } from "./plugins/cacheOkAndOpaquePlugin.js";
 import { messages } from "./utils/messages.js";
 
-/**
- * An implementation of a
- * [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.
- */
-class StaleWhileRevalidate extends Strategy {
+export 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 = {}) {
@@ -107,5 +106,3 @@ class StaleWhileRevalidate extends Strategy {
     return response;
   }
 }
-
-export { StaleWhileRevalidate };

package/src/Strategy.ts

@@ -39,7 +39,7 @@ export interface StrategyOptions {
  * fetching and cache logic, which will ensure all relevant cache, cache options,
  * fetch options and plugins are used (per the current strategy instance).
  */
-abstract class Strategy implements RouteHandlerObject {
+export abstract class Strategy implements RouteHandlerObject {
   cacheName: string;
   plugins: SerwistPlugin[];
   fetchOptions?: RequestInit;
@@ -201,5 +201,3 @@ abstract class Strategy implements RouteHandlerObject {
     }
   }
 }
-
-export { Strategy };

package/src/StrategyHandler.ts

@@ -30,7 +30,7 @@ function toRequest(input: RequestInfo) {
  * and keeps track of when the strategy is "done" (i.e. all added `event.waitUntil()` promises
  * have resolved).
  */
-class StrategyHandler {
+export class StrategyHandler {
   /**
    * The request the strategy is performing (passed to the strategy's
    * `handle()` or `handleAll()` method).
@@ -281,16 +281,6 @@ class StrategyHandler {
           method: effectiveRequest.method,
         });
       }
-
-      // See https://github.com/GoogleChrome/workbox/issues/2818
-      const vary = response.headers.get("Vary");
-      if (vary) {
-        logger.debug(
-          `The response for ${getFriendlyURL(
-            effectiveRequest.url,
-          )} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`,
-        );
-      }
     }
 
     if (!response) {
@@ -315,6 +305,18 @@ class StrategyHandler {
     const { cacheName, matchOptions } = this._strategy;
     const cache = await self.caches.open(cacheName);
 
+    if (process.env.NODE_ENV !== "production") {
+      // See https://github.com/GoogleChrome/workbox/issues/2818
+      const vary = response.headers.get("Vary");
+      if (vary && matchOptions?.ignoreVary !== true) {
+        logger.debug(
+          `The response for ${getFriendlyURL(
+            effectiveRequest.url,
+          )} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`,
+        );
+      }
+    }
+
     const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
     const oldResponse = hasCacheUpdateCallback
       ? await cacheMatchIgnoreParams(
@@ -329,7 +331,7 @@ class StrategyHandler {
       : null;
 
     if (process.env.NODE_ENV !== "production") {
-      logger.debug(`Updating the '${cacheName}' cache with a new Response ` + `for ${getFriendlyURL(effectiveRequest.url)}.`);
+      logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
     }
 
     try {
@@ -379,8 +381,7 @@ class StrategyHandler {
             mode,
             request: effectiveRequest,
             event: this.event,
-            // params has a type any can't change right now.
-            params: this.params, // eslint-disable-line
+            params: this.params,
           }),
         );
       }
@@ -541,5 +542,3 @@ class StrategyHandler {
     return responseToCache;
   }
 }
-
-export { StrategyHandler };