@serwist/cacheable-response 8.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,10 @@
+
+> @serwist/cacheable-response@8.0.0 build /home/runner/work/serwist/serwist/packages/cacheable-response
+> cross-env NODE_ENV=production rollup --waitForBundleInput --config rollup.config.js
+
+(node:2290) ExperimentalWarning: Import assertions are not a stable feature of the JavaScript language. Avoid relying on their current behavior and syntax as those might change in a future version of Node.js.
+(Use `node --trace-warnings ...` to show where the warning was created)
+(node:2290) ExperimentalWarning: Importing JSON modules is an experimental feature and might change at any time
+
+src/index.ts → dist/index.old.cjs, dist/index.js...
+created dist/index.old.cjs, dist/index.js in 7.6s

package/.turbo/turbo-lint.log

@@ -0,0 +1,4 @@
+
+> @serwist/cacheable-response@8.0.0 lint /home/runner/work/serwist/serwist/packages/cacheable-response
+> eslint src --ext ts,tsx,js,jsx,cjs,mjs
+

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,4 @@
+
+> @serwist/cacheable-response@8.0.0 typecheck /home/runner/work/serwist/serwist/packages/cacheable-response
+> tsc
+

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# @serwist/cacheable-response
+
+## 8.0.0
+
+### Major Changes
+
+- [`e0313f0`](https://github.com/serwist/serwist/commit/e0313f02f661a07ccbe9edc64e44e1af6136c73e) Thanks [@DuCanhGH](https://github.com/DuCanhGH)! - chore: initial release
+
+  - Reimagined `@serwist/next`.
+    - Removed various options.
+      - Removed `aggressiveFrontEndNavCaching` to reassess its usefulness.
+      - Removed `browserslist`. Use `swcEnvTargets` instead (TODO: add this option).
+      - Custom workers have been removed. You should use `swSrc`.
+      - Removed `extendDefaultRuntimeCaching`. Use the spread syntax instead (use `import { defaultCache } from "@serwist/next/browser"` to import the default runtimeCaching array).
+      - Temporarily removed `fallbacks` to investigate module-friendly alternatives.
+      - Removed `swcMinify`.
+      - Removed `watchWorkersInDev`.
+      - Removed `cacheStartUrl`, `dynamicStartUrl`, and `dynamicStartUrl`. These shall be re-added only when their use cases are made more clear to me.
+    - Merged `workboxOptions` with the plugin's options.
+    - Removed `swc-loader`, `terser-minify`, `webpack-builders`,... (we now leverage `ChildCompilationPlugin` to compile workers - this change will be backported to `@ducanh2912/next-pwa@10`)
+    - Removed the ability to use GenerateSW. `@serwist/sw.installSerwist` is provided as a replacement.
+    - `swSrc` is now a required property.
+    - Moved minimum support Next.js version from `11.0.0` to `14.0.0`.
+  - Removed GenerateSW (replaced by `@serwist/sw.installSerwist`).
+    - See `examples/next-basic/app/sw.ts` to see how `installSerwist` should be used.
+  - Repurposed `@serwist/sw`.
+    - The old package might be reintroduced if there's demand.
+  - **Note:** This is just the initial release, and there is still a lot of ground to cover (a lot of legacy code to be removed, a lot of features to be reintroduced,...). Here's to a bright future for the project :\_)
+
+### Patch Changes
+
+- Updated dependencies [[`e0313f0`](https://github.com/serwist/serwist/commit/e0313f02f661a07ccbe9edc64e44e1af6136c73e)]:
+  - @serwist/core@8.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-cacheable-response

package/dist/CacheableResponse.d.ts

@@ -0,0 +1,45 @@
+export interface CacheableResponseOptions {
+    /**
+     * One or more status codes that a `Response` can have to be considered cacheable.
+     */
+    statuses?: number[];
+    /**
+     * A mapping of header names and expected values that a `Response` can have and be
+     * considered cacheable. If multiple headers are provided, only one needs to be present.
+     */
+    headers?: {
+        [headerName: string]: string;
+    };
+}
+/**
+ * This class allows you to set up rules determining what
+ * status codes and/or headers need to be present in order for a
+ * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * to be considered cacheable.
+ */
+declare class CacheableResponse {
+    private readonly _statuses?;
+    private readonly _headers?;
+    /**
+     * To construct a new CacheableResponse instance you must provide at least
+     * one of the `config` properties.
+     *
+     * If both `statuses` and `headers` are specified, then both conditions must
+     * be met for the `Response` to be considered cacheable.
+     *
+     * @param config
+     */
+    constructor(config?: CacheableResponseOptions);
+    /**
+     * Checks a response to see whether it's cacheable or not, based on this
+     * object's configuration.
+     *
+     * @param response The response whose cacheability is being
+     * checked.
+     * @returns `true` if the `Response` is cacheable, and `false`
+     * otherwise.
+     */
+    isResponseCacheable(response: Response): boolean;
+}
+export { CacheableResponse };
+//# sourceMappingURL=CacheableResponse.d.ts.map

package/dist/CacheableResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheableResponse.d.ts","sourceRoot":"","sources":["../src/CacheableResponse.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE;QAAE,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC5C;AAED;;;;;GAKG;AACH,cAAM,iBAAiB;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAuC;IAClE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAsC;IAEhE;;;;;;;;OAQG;gBACS,MAAM,GAAE,wBAA6B;IAiCjD;;;;;;;;OAQG;IACH,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;CAsDjD;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/CacheableResponsePlugin.d.ts

@@ -0,0 +1,28 @@
+import type { SerwistPlugin } from "@serwist/core";
+import type { CacheableResponseOptions } from "./CacheableResponse.js";
+/**
+ * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it
+ * easier to add in cacheability checks to requests made via Serwist's built-in
+ * strategies.
+ */
+declare class CacheableResponsePlugin implements SerwistPlugin {
+    private readonly _cacheableResponse;
+    /**
+     * To construct a new CacheableResponsePlugin instance you must provide at
+     * least one of the `config` properties.
+     *
+     * If both `statuses` and `headers` are specified, then both conditions must
+     * be met for the `Response` to be considered cacheable.
+     *
+     * @param config
+     */
+    constructor(config: CacheableResponseOptions);
+    /**
+     * @param options
+     * @returns
+     * @private
+     */
+    cacheWillUpdate: SerwistPlugin["cacheWillUpdate"];
+}
+export { CacheableResponsePlugin };
+//# sourceMappingURL=CacheableResponsePlugin.d.ts.map

package/dist/CacheableResponsePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheableResponsePlugin.d.ts","sourceRoot":"","sources":["../src/CacheableResponsePlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAGvE;;;;GAIG;AACH,cAAM,uBAAwB,YAAW,aAAa;IACpD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IAEvD;;;;;;;;OAQG;gBACS,MAAM,EAAE,wBAAwB;IAI5C;;;;OAIG;IACH,eAAe,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAK/C;CACH;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { CacheableResponseOptions } from "./CacheableResponse.js";
+import { CacheableResponse } from "./CacheableResponse.js";
+import { CacheableResponsePlugin } from "./CacheableResponsePlugin.js";
+export { CacheableResponse, CacheableResponsePlugin };
+export type { CacheableResponseOptions };
+//# 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,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,CAAC;AAEtD,YAAY,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,129 @@
+import { SerwistError, assert, logger, getFriendlyURL } from '@serwist/core/internal';
+
+/**
+ * This class allows you to set up rules determining what
+ * status codes and/or headers need to be present in order for a
+ * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * to be considered cacheable.
+ */ class CacheableResponse {
+    _statuses;
+    _headers;
+    /**
+   * To construct a new CacheableResponse instance you must provide at least
+   * one of the `config` properties.
+   *
+   * If both `statuses` and `headers` are specified, then both conditions must
+   * be met for the `Response` to be considered cacheable.
+   *
+   * @param config
+   */ constructor(config = {}){
+        if (process.env.NODE_ENV !== "production") {
+            if (!(config.statuses || config.headers)) {
+                throw new SerwistError("statuses-or-headers-required", {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor"
+                });
+            }
+            if (config.statuses) {
+                assert.isArray(config.statuses, {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.statuses"
+                });
+            }
+            if (config.headers) {
+                assert.isType(config.headers, "object", {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.headers"
+                });
+            }
+        }
+        this._statuses = config.statuses;
+        this._headers = config.headers;
+    }
+    /**
+   * Checks a response to see whether it's cacheable or not, based on this
+   * object's configuration.
+   *
+   * @param response The response whose cacheability is being
+   * checked.
+   * @returns `true` if the `Response` is cacheable, and `false`
+   * otherwise.
+   */ isResponseCacheable(response) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isInstance(response, Response, {
+                moduleName: "@serwist/cacheable-response",
+                className: "CacheableResponse",
+                funcName: "isResponseCacheable",
+                paramName: "response"
+            });
+        }
+        let cacheable = true;
+        if (this._statuses) {
+            cacheable = this._statuses.includes(response.status);
+        }
+        if (this._headers && cacheable) {
+            cacheable = Object.keys(this._headers).some((headerName)=>{
+                return response.headers.get(headerName) === this._headers[headerName];
+            });
+        }
+        if (process.env.NODE_ENV !== "production") {
+            if (!cacheable) {
+                logger.groupCollapsed(`The request for ` + `'${getFriendlyURL(response.url)}' returned a response that does ` + `not meet the criteria for being cached.`);
+                logger.groupCollapsed(`View cacheability criteria here.`);
+                logger.log(`Cacheable statuses: ` + JSON.stringify(this._statuses));
+                logger.log(`Cacheable headers: ` + JSON.stringify(this._headers, null, 2));
+                logger.groupEnd();
+                const logFriendlyHeaders = {};
+                response.headers.forEach((value, key)=>{
+                    logFriendlyHeaders[key] = value;
+                });
+                logger.groupCollapsed(`View response status and headers here.`);
+                logger.log(`Response status: ${response.status}`);
+                logger.log(`Response headers: ` + JSON.stringify(logFriendlyHeaders, null, 2));
+                logger.groupEnd();
+                logger.groupCollapsed(`View full response details here.`);
+                logger.log(response.headers);
+                logger.log(response);
+                logger.groupEnd();
+                logger.groupEnd();
+            }
+        }
+        return cacheable;
+    }
+}
+
+/**
+ * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it
+ * easier to add in cacheability checks to requests made via Serwist's built-in
+ * strategies.
+ */ class CacheableResponsePlugin {
+    _cacheableResponse;
+    /**
+   * To construct a new CacheableResponsePlugin instance you must provide at
+   * least one of the `config` properties.
+   *
+   * If both `statuses` and `headers` are specified, then both conditions must
+   * be met for the `Response` to be considered cacheable.
+   *
+   * @param config
+   */ constructor(config){
+        this._cacheableResponse = new CacheableResponse(config);
+    }
+    /**
+   * @param options
+   * @returns
+   * @private
+   */ cacheWillUpdate = async ({ response })=>{
+        if (this._cacheableResponse.isResponseCacheable(response)) {
+            return response;
+        }
+        return null;
+    };
+}
+
+export { CacheableResponse, CacheableResponsePlugin };

package/dist/index.old.cjs

@@ -0,0 +1,132 @@
+'use strict';
+
+var internal = require('@serwist/core/internal');
+
+/**
+ * This class allows you to set up rules determining what
+ * status codes and/or headers need to be present in order for a
+ * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * to be considered cacheable.
+ */ class CacheableResponse {
+    _statuses;
+    _headers;
+    /**
+   * To construct a new CacheableResponse instance you must provide at least
+   * one of the `config` properties.
+   *
+   * If both `statuses` and `headers` are specified, then both conditions must
+   * be met for the `Response` to be considered cacheable.
+   *
+   * @param config
+   */ constructor(config = {}){
+        if (process.env.NODE_ENV !== "production") {
+            if (!(config.statuses || config.headers)) {
+                throw new internal.SerwistError("statuses-or-headers-required", {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor"
+                });
+            }
+            if (config.statuses) {
+                internal.assert.isArray(config.statuses, {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.statuses"
+                });
+            }
+            if (config.headers) {
+                internal.assert.isType(config.headers, "object", {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.headers"
+                });
+            }
+        }
+        this._statuses = config.statuses;
+        this._headers = config.headers;
+    }
+    /**
+   * Checks a response to see whether it's cacheable or not, based on this
+   * object's configuration.
+   *
+   * @param response The response whose cacheability is being
+   * checked.
+   * @returns `true` if the `Response` is cacheable, and `false`
+   * otherwise.
+   */ isResponseCacheable(response) {
+        if (process.env.NODE_ENV !== "production") {
+            internal.assert.isInstance(response, Response, {
+                moduleName: "@serwist/cacheable-response",
+                className: "CacheableResponse",
+                funcName: "isResponseCacheable",
+                paramName: "response"
+            });
+        }
+        let cacheable = true;
+        if (this._statuses) {
+            cacheable = this._statuses.includes(response.status);
+        }
+        if (this._headers && cacheable) {
+            cacheable = Object.keys(this._headers).some((headerName)=>{
+                return response.headers.get(headerName) === this._headers[headerName];
+            });
+        }
+        if (process.env.NODE_ENV !== "production") {
+            if (!cacheable) {
+                internal.logger.groupCollapsed(`The request for ` + `'${internal.getFriendlyURL(response.url)}' returned a response that does ` + `not meet the criteria for being cached.`);
+                internal.logger.groupCollapsed(`View cacheability criteria here.`);
+                internal.logger.log(`Cacheable statuses: ` + JSON.stringify(this._statuses));
+                internal.logger.log(`Cacheable headers: ` + JSON.stringify(this._headers, null, 2));
+                internal.logger.groupEnd();
+                const logFriendlyHeaders = {};
+                response.headers.forEach((value, key)=>{
+                    logFriendlyHeaders[key] = value;
+                });
+                internal.logger.groupCollapsed(`View response status and headers here.`);
+                internal.logger.log(`Response status: ${response.status}`);
+                internal.logger.log(`Response headers: ` + JSON.stringify(logFriendlyHeaders, null, 2));
+                internal.logger.groupEnd();
+                internal.logger.groupCollapsed(`View full response details here.`);
+                internal.logger.log(response.headers);
+                internal.logger.log(response);
+                internal.logger.groupEnd();
+                internal.logger.groupEnd();
+            }
+        }
+        return cacheable;
+    }
+}
+
+/**
+ * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it
+ * easier to add in cacheability checks to requests made via Serwist's built-in
+ * strategies.
+ */ class CacheableResponsePlugin {
+    _cacheableResponse;
+    /**
+   * To construct a new CacheableResponsePlugin instance you must provide at
+   * least one of the `config` properties.
+   *
+   * If both `statuses` and `headers` are specified, then both conditions must
+   * be met for the `Response` to be considered cacheable.
+   *
+   * @param config
+   */ constructor(config){
+        this._cacheableResponse = new CacheableResponse(config);
+    }
+    /**
+   * @param options
+   * @returns
+   * @private
+   */ cacheWillUpdate = async ({ response })=>{
+        if (this._cacheableResponse.isResponseCacheable(response)) {
+            return response;
+        }
+        return null;
+    };
+}
+
+exports.CacheableResponse = CacheableResponse;
+exports.CacheableResponsePlugin = CacheableResponsePlugin;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@serwist/cacheable-response",
+  "version": "8.0.0",
+  "type": "module",
+  "license": "MIT",
+  "author": "Google's Web DevRel Team, Serwist's Team",
+  "description": "This library takes a Response object and determines whether it's cacheable based on a specific configuration.",
+  "repository": "serwist/serwist",
+  "bugs": "https://github.com/serwist/serwist/issues",
+  "homepage": "https://ducanh-next-pwa.vercel.app",
+  "keywords": [
+    "serwist",
+    "serwistjs",
+    "service worker",
+    "sw",
+    "serwist-plugin"
+  ],
+  "module": "./dist/index.js",
+  "main": "./dist/index.old.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.old.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@serwist/core": "8.0.0"
+  },
+  "devDependencies": {
+    "rollup": "3.28.1",
+    "@serwist/constants": "8.0.0"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production rollup --waitForBundleInput --config rollup.config.js",
+    "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
+    "typecheck": "tsc"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,27 @@
+// @ts-check
+import { getRollupOptions } from "@serwist/constants/rollup";
+
+import packageJson from "./package.json" assert { type: "json" };
+
+const isDev = process.env.NODE_ENV === "development";
+
+export default getRollupOptions({
+  packageJson,
+  jsFiles: [
+    {
+      input: "src/index.ts",
+      output: [
+        {
+          file: "dist/index.old.cjs",
+          format: "cjs",
+          exports: "named",
+        },
+        {
+          file: "dist/index.js",
+          format: "esm",
+        },
+      ],
+    },
+  ],
+  shouldEmitDeclaration: !isDev,
+});

package/src/CacheableResponse.ts

@@ -0,0 +1,140 @@
+/*
+  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, getFriendlyURL, logger, SerwistError } from "@serwist/core/internal";
+
+export interface CacheableResponseOptions {
+  /**
+   * One or more status codes that a `Response` can have to be considered cacheable.
+   */
+  statuses?: number[];
+  /**
+   * A mapping of header names and expected values that a `Response` can have and be
+   * considered cacheable. If multiple headers are provided, only one needs to be present.
+   */
+  headers?: { [headerName: string]: string };
+}
+
+/**
+ * This class allows you to set up rules determining what
+ * status codes and/or headers need to be present in order for a
+ * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * to be considered cacheable.
+ */
+class CacheableResponse {
+  private readonly _statuses?: CacheableResponseOptions["statuses"];
+  private readonly _headers?: CacheableResponseOptions["headers"];
+
+  /**
+   * To construct a new CacheableResponse instance you must provide at least
+   * one of the `config` properties.
+   *
+   * If both `statuses` and `headers` are specified, then both conditions must
+   * be met for the `Response` to be considered cacheable.
+   *
+   * @param config
+   */
+  constructor(config: CacheableResponseOptions = {}) {
+    if (process.env.NODE_ENV !== "production") {
+      if (!(config.statuses || config.headers)) {
+        throw new SerwistError("statuses-or-headers-required", {
+          moduleName: "@serwist/cacheable-response",
+          className: "CacheableResponse",
+          funcName: "constructor",
+        });
+      }
+
+      if (config.statuses) {
+        assert!.isArray(config.statuses, {
+          moduleName: "@serwist/cacheable-response",
+          className: "CacheableResponse",
+          funcName: "constructor",
+          paramName: "config.statuses",
+        });
+      }
+
+      if (config.headers) {
+        assert!.isType(config.headers, "object", {
+          moduleName: "@serwist/cacheable-response",
+          className: "CacheableResponse",
+          funcName: "constructor",
+          paramName: "config.headers",
+        });
+      }
+    }
+
+    this._statuses = config.statuses;
+    this._headers = config.headers;
+  }
+
+  /**
+   * Checks a response to see whether it's cacheable or not, based on this
+   * object's configuration.
+   *
+   * @param response The response whose cacheability is being
+   * checked.
+   * @returns `true` if the `Response` is cacheable, and `false`
+   * otherwise.
+   */
+  isResponseCacheable(response: Response): boolean {
+    if (process.env.NODE_ENV !== "production") {
+      assert!.isInstance(response, Response, {
+        moduleName: "@serwist/cacheable-response",
+        className: "CacheableResponse",
+        funcName: "isResponseCacheable",
+        paramName: "response",
+      });
+    }
+
+    let cacheable = true;
+
+    if (this._statuses) {
+      cacheable = this._statuses.includes(response.status);
+    }
+
+    if (this._headers && cacheable) {
+      cacheable = Object.keys(this._headers).some((headerName) => {
+        return response.headers.get(headerName) === this._headers![headerName];
+      });
+    }
+
+    if (process.env.NODE_ENV !== "production") {
+      if (!cacheable) {
+        logger.groupCollapsed(
+          `The request for ` + `'${getFriendlyURL(response.url)}' returned a response that does ` + `not meet the criteria for being cached.`
+        );
+
+        logger.groupCollapsed(`View cacheability criteria here.`);
+        logger.log(`Cacheable statuses: ` + JSON.stringify(this._statuses));
+        logger.log(`Cacheable headers: ` + JSON.stringify(this._headers, null, 2));
+        logger.groupEnd();
+
+        const logFriendlyHeaders: { [key: string]: string } = {};
+        response.headers.forEach((value, key) => {
+          logFriendlyHeaders[key] = value;
+        });
+
+        logger.groupCollapsed(`View response status and headers here.`);
+        logger.log(`Response status: ${response.status}`);
+        logger.log(`Response headers: ` + JSON.stringify(logFriendlyHeaders, null, 2));
+        logger.groupEnd();
+
+        logger.groupCollapsed(`View full response details here.`);
+        logger.log(response.headers);
+        logger.log(response);
+        logger.groupEnd();
+
+        logger.groupEnd();
+      }
+    }
+
+    return cacheable;
+  }
+}
+
+export { CacheableResponse };

package/src/CacheableResponsePlugin.ts

@@ -0,0 +1,48 @@
+/*
+  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 type { SerwistPlugin } from "@serwist/core";
+
+import type { CacheableResponseOptions } from "./CacheableResponse.js";
+import { CacheableResponse } from "./CacheableResponse.js";
+
+/**
+ * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it
+ * easier to add in cacheability checks to requests made via Serwist's built-in
+ * strategies.
+ */
+class CacheableResponsePlugin implements SerwistPlugin {
+  private readonly _cacheableResponse: CacheableResponse;
+
+  /**
+   * To construct a new CacheableResponsePlugin instance you must provide at
+   * least one of the `config` properties.
+   *
+   * If both `statuses` and `headers` are specified, then both conditions must
+   * be met for the `Response` to be considered cacheable.
+   *
+   * @param config
+   */
+  constructor(config: CacheableResponseOptions) {
+    this._cacheableResponse = new CacheableResponse(config);
+  }
+
+  /**
+   * @param options
+   * @returns
+   * @private
+   */
+  cacheWillUpdate: SerwistPlugin["cacheWillUpdate"] = async ({ response }) => {
+    if (this._cacheableResponse.isResponseCacheable(response)) {
+      return response;
+    }
+    return null;
+  };
+}
+
+export { CacheableResponsePlugin };

package/src/index.ts

@@ -0,0 +1,15 @@
+/*
+  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 type { CacheableResponseOptions } from "./CacheableResponse.js";
+import { CacheableResponse } from "./CacheableResponse.js";
+import { CacheableResponsePlugin } from "./CacheableResponsePlugin.js";
+
+export { CacheableResponse, CacheableResponsePlugin };
+
+export type { CacheableResponseOptions };

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "NodeNext"
+  },
+  "include": ["src/**/*.ts", "rollup.config.js"]
+}