@serwist/strategies 8.4.3 → 9.0.0-preview.0

package/dist/CacheFirst.d.ts

@@ -21,3 +21,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

@@ -0,0 +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"}

package/dist/CacheOnly.d.ts

@@ -18,3 +18,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

@@ -0,0 +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"}

package/dist/NetworkFirst.d.ts

@@ -59,3 +59,4 @@ declare class NetworkFirst extends Strategy {
     }): Promise<Response | undefined>;
 }
 export { NetworkFirst };
+//# sourceMappingURL=NetworkFirst.d.ts.map

package/dist/NetworkFirst.d.ts.map

@@ -0,0 +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"}

package/dist/NetworkOnly.d.ts

@@ -31,3 +31,4 @@ declare class NetworkOnly extends Strategy {
 }
 export { NetworkOnly };
 export type { NetworkOnlyOptions };
+//# sourceMappingURL=NetworkOnly.d.ts.map

package/dist/NetworkOnly.d.ts.map

@@ -0,0 +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"}

package/dist/StaleWhileRevalidate.d.ts

@@ -33,3 +33,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

@@ -0,0 +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"}

package/dist/Strategy.d.ts

@@ -81,3 +81,4 @@ declare abstract class Strategy implements RouteHandlerObject {
     _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

@@ -0,0 +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"}

package/dist/StrategyHandler.d.ts

@@ -185,3 +185,4 @@ declare class StrategyHandler {
     _ensureResponseSafeToCache(response: Response): Promise<Response | undefined>;
 }
 export { StrategyHandler };
+//# sourceMappingURL=StrategyHandler.d.ts.map

package/dist/StrategyHandler.d.ts.map

@@ -0,0 +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"}

package/dist/index.d.ts

@@ -19,3 +19,4 @@ declare global {
  */
 export { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate, Strategy, StrategyHandler };
 export type { NetworkFirstOptions, NetworkOnlyOptions, StrategyOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAElB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;KACxC;CACF;AAED;;;GAGG;AACH,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,oBAAoB,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC;AAE7G,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,eAAe,EAAE,CAAC"}

package/dist/plugins/cacheOkAndOpaquePlugin.d.ts

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

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

@@ -0,0 +1 @@
+{"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

@@ -2,3 +2,4 @@ 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

@@ -0,0 +1 @@
+{"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/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@serwist/strategies",
-  "version": "8.4.3",
+  "version": "9.0.0-preview.0",
   "type": "module",
   "description": "A service worker helper library implementing common caching strategies.",
   "files": [
-    "dist",
-    "!dist/**/dts"
+    "src",
+    "dist"
   ],
   "keywords": [
     "serwist",
@@ -20,28 +20,30 @@
   "repository": "serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
-  "module": "./dist/index.js",
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/core": "8.4.3"
+    "@serwist/core": "9.0.0-preview.0"
   },
   "devDependencies": {
-    "rollup": "4.9.1",
-    "@serwist/constants": "8.4.3"
+    "rollup": "4.9.6",
+    "typescript": "5.4.0-dev.20240203",
+    "@serwist/constants": "9.0.0-preview.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",

package/src/CacheFirst.ts

@@ -0,0 +1,89 @@
+/*
+  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 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: 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;
+  }
+}
+
+export { CacheFirst };

package/src/CacheOnly.ts

@@ -0,0 +1,60 @@
+/*
+  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 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: Request, handler: StrategyHandler): Promise<Response> {
+    if (process.env.NODE_ENV !== "production") {
+      assert!.isInstance(request, Request, {
+        moduleName: "@serwist/strategies",
+        className: this.constructor.name,
+        funcName: "makeRequest",
+        paramName: "request",
+      });
+    }
+
+    const response = await handler.cacheMatch(request);
+
+    if (process.env.NODE_ENV !== "production") {
+      logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+      if (response) {
+        logger.log(`Found a cached response in the '${this.cacheName}' cache.`);
+        messages.printFinalResponse(response);
+      } else {
+        logger.log(`No response found in the '${this.cacheName}' cache.`);
+      }
+      logger.groupEnd();
+    }
+
+    if (!response) {
+      throw new SerwistError("no-response", { url: request.url });
+    }
+    return response;
+  }
+}
+
+export { CacheOnly };

package/src/NetworkFirst.ts

@@ -0,0 +1,231 @@
+/*
+  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 type { StrategyOptions } from "./Strategy.js";
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+import { cacheOkAndOpaquePlugin } from "./plugins/cacheOkAndOpaquePlugin.js";
+import { messages } from "./utils/messages.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;
+}
+
+/**
+ * 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 {
+  private readonly _networkTimeoutSeconds: number;
+
+  /**
+   * @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 = {}) {
+    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);
+    }
+
+    this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
+    if (process.env.NODE_ENV !== "production") {
+      if (this._networkTimeoutSeconds) {
+        assert!.isType(this._networkTimeoutSeconds, "number", {
+          moduleName: "@serwist/strategies",
+          className: this.constructor.name,
+          funcName: "constructor",
+          paramName: "networkTimeoutSeconds",
+        });
+      }
+    }
+  }
+
+  /**
+   * @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: any[] = [];
+
+    if (process.env.NODE_ENV !== "production") {
+      assert!.isInstance(request, Request, {
+        moduleName: "@serwist/strategies",
+        className: this.constructor.name,
+        funcName: "handle",
+        paramName: "makeRequest",
+      });
+    }
+
+    const promises: Promise<Response | undefined>[] = [];
+    let timeoutId: number | undefined;
+
+    if (this._networkTimeoutSeconds) {
+      const { id, promise } = this._getTimeoutPromise({
+        request,
+        logs,
+        handler,
+      });
+      timeoutId = id;
+      promises.push(promise);
+    }
+
+    const networkPromise = this._getNetworkPromise({
+      timeoutId,
+      request,
+      logs,
+      handler,
+    });
+
+    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)
+        );
+      })(),
+    );
+
+    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 });
+    }
+    return response;
+  }
+
+  /**
+   * @param options
+   * @returns
+   * @private
+   */
+  private _getTimeoutPromise({
+    request,
+    logs,
+    handler,
+  }: {
+    request: Request;
+    /**
+     * A reference to the logs array.
+     */
+    logs: any[];
+    handler: StrategyHandler;
+  }): { promise: Promise<Response | undefined>; id?: number } {
+    // biome-ignore lint/suspicious/noImplicitAnyLet: setTimeout is typed with Node.js's typings, so we can't use number | undefined here.
+    let timeoutId;
+    const timeoutPromise: Promise<Response | undefined> = new Promise((resolve) => {
+      const onNetworkTimeout = async () => {
+        if (process.env.NODE_ENV !== "production") {
+          logs.push(`Timing out the network response at ${this._networkTimeoutSeconds} seconds.`);
+        }
+        resolve(await handler.cacheMatch(request));
+      };
+      timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);
+    });
+
+    return {
+      promise: timeoutPromise,
+      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,
+  }: {
+    request: Request;
+    logs: any[];
+    timeoutId?: number;
+    handler: StrategyHandler;
+  }): Promise<Response | undefined> {
+    let error: Error | undefined = undefined;
+    let response: Response | undefined = undefined;
+    try {
+      response = await handler.fetchAndCachePut(request);
+    } catch (fetchError) {
+      if (fetchError instanceof Error) {
+        error = fetchError;
+      }
+    }
+
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    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. Will respond " + "with a cached response.");
+      }
+    }
+
+    if (error || !response) {
+      response = await handler.cacheMatch(request);
+
+      if (process.env.NODE_ENV !== "production") {
+        if (response) {
+          logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
+        } else {
+          logs.push(`No response found in the '${this.cacheName}' cache.`);
+        }
+      }
+    }
+
+    return response;
+  }
+}
+
+export { NetworkFirst };

package/src/NetworkOnly.ts

@@ -0,0 +1,99 @@
+/*
+  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, timeout } from "@serwist/core/internal";
+
+import type { StrategyOptions } from "./Strategy.js";
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+import { messages } from "./utils/messages.js";
+
+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 {
+  private readonly _networkTimeoutSeconds: number;
+
+  /**
+   * @param options
+   */
+  constructor(options: NetworkOnlyOptions = {}) {
+    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: Request, handler: StrategyHandler): Promise<Response> {
+    if (process.env.NODE_ENV !== "production") {
+      assert!.isInstance(request, Request, {
+        moduleName: "@serwist/strategies",
+        className: this.constructor.name,
+        funcName: "_handle",
+        paramName: "request",
+      });
+    }
+
+    let error: Error | undefined = undefined;
+    let response: Response | undefined;
+
+    try {
+      const promises: Promise<Response | undefined>[] = [handler.fetch(request)];
+
+      if (this._networkTimeoutSeconds) {
+        const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000) as Promise<undefined>;
+        promises.push(timeoutPromise);
+      }
+
+      response = await Promise.race(promises);
+      if (!response) {
+        throw new Error(`Timed out the network response after ${this._networkTimeoutSeconds} seconds.`);
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        error = err;
+      }
+    }
+
+    if (process.env.NODE_ENV !== "production") {
+      logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+      if (response) {
+        logger.log("Got response from network.");
+      } else {
+        logger.log("Unable to get a response from the network.");
+      }
+      messages.printFinalResponse(response);
+      logger.groupEnd();
+    }
+
+    if (!response) {
+      throw new SerwistError("no-response", { url: request.url, error });
+    }
+    return response;
+  }
+}
+
+export { NetworkOnly };
+export type { NetworkOnlyOptions };