@serwist/cacheable-response 8.4.3 → 9.0.0-preview.0

package/dist/CacheableResponse.d.ts

@@ -17,7 +17,7 @@ export interface CacheableResponseOptions {
  * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
  * to be considered cacheable.
  */
-declare class CacheableResponse {
+export declare class CacheableResponse {
     private readonly _statuses?;
     private readonly _headers?;
     /**
@@ -41,4 +41,4 @@ declare class CacheableResponse {
      */
     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,qBAAa,iBAAiB;IAC5B,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"}

package/dist/CacheableResponsePlugin.d.ts

@@ -5,7 +5,7 @@ import type { CacheableResponseOptions } from "./CacheableResponse.js";
  * easier to add in cacheability checks to requests made via Serwist's built-in
  * strategies.
  */
-declare class CacheableResponsePlugin implements SerwistPlugin {
+export declare class CacheableResponsePlugin implements SerwistPlugin {
     private readonly _cacheableResponse;
     /**
      * To construct a new CacheableResponsePlugin instance you must provide at
@@ -24,4 +24,4 @@ declare class CacheableResponsePlugin implements SerwistPlugin {
      */
     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,qBAAa,uBAAwB,YAAW,aAAa;IAC3D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IAEvD;;;;;;;;OAQG;gBACS,MAAM,EAAE,wBAAwB;IAI5C;;;;OAIG;IACH,eAAe,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAK/C;CACH"}

package/dist/index.d.ts

@@ -3,3 +3,4 @@ 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/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@serwist/cacheable-response",
-  "version": "8.4.3",
+  "version": "9.0.0-preview.0",
   "type": "module",
   "description": "This library takes a Response object and determines whether it's cacheable based on a specific configuration.",
   "files": [
-    "dist",
-    "!dist/**/dts"
+    "src",
+    "dist"
   ],
   "keywords": [
     "serwist",
@@ -19,31 +19,33 @@
   "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": "cross-env NODE_ENV=production rollup --waitForBundleInput --config rollup.config.js",
+    "build": "cross-env NODE_ENV=production rollup --config rollup.config.js",
     "dev": "rollup --config rollup.config.js --watch",
     "lint": "biome lint ./src",
     "typecheck": "tsc"

package/src/CacheableResponse.ts

@@ -0,0 +1,138 @@
+/*
+  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, getFriendlyURL, logger } 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.
+ */
+export 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;
+  }
+}

package/src/CacheableResponsePlugin.ts

@@ -0,0 +1,46 @@
+/*
+  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.
+ */
+export 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;
+  };
+}

package/{dist/index.d.cts → src/index.ts}

@@ -1,5 +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/dist/index.cjs

@@ -1,132 +0,0 @@
-'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;