@netlify/cache 1.7.0 → 1.8.0

package/dist/bootstrap/main.cjs

@@ -78,17 +78,15 @@ var allowedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
 var discardedHeaders = /* @__PURE__ */ new Set(["cookie", "content-encoding", "content-length"]);
 var getInternalHeaders = Symbol("getInternalHeaders");
 var serializeResourceHeaders = Symbol("serializeResourceHeaders");
-var _base64Encode, _getContext, _logger, _name, _userAgent;
+var _base64Encode, _getContext, _name, _userAgent;
 var NetlifyCache = class {
-  constructor({ base64Encode, getContext, logger, name, userAgent }) {
+  constructor({ base64Encode, getContext, name, userAgent }) {
     __privateAdd(this, _base64Encode, void 0);
     __privateAdd(this, _getContext, void 0);
-    __privateAdd(this, _logger, void 0);
     __privateAdd(this, _name, void 0);
     __privateAdd(this, _userAgent, void 0);
     __privateSet(this, _base64Encode, base64Encode);
     __privateSet(this, _getContext, getContext);
-    __privateSet(this, _logger, logger);
     __privateSet(this, _name, name);
     __privateSet(this, _userAgent, userAgent);
   }
@@ -171,7 +169,6 @@ var NetlifyCache = class {
     return res ? [res] : [];
   }
   async put(request, response) {
-    var _a;
     if (!response.ok) {
       throw new TypeError(`Cannot cache response with status ${response.status}.`);
     }
@@ -203,13 +200,12 @@ var NetlifyCache = class {
     if (!cacheResponse.ok) {
       const errorDetail = cacheResponse.headers.get(ErrorDetail) ?? "";
       const errorMessage = ERROR_CODES[errorDetail] || GENERIC_ERROR;
-      (_a = __privateGet(this, _logger)) == null ? void 0 : _a.call(this, `Failed to write to the cache: ${errorMessage}`);
+      context.logger?.(`Failed to write to the cache: ${errorMessage}`);
     }
   }
 };
 _base64Encode = new WeakMap();
 _getContext = new WeakMap();
-_logger = new WeakMap();
 _name = new WeakMap();
 _userAgent = new WeakMap();
 var extractAndValidateURL = (input) => {

package/dist/bootstrap/main.d.cts

@@ -1,5 +1,5 @@
-import { E as EnvironmentOptions } from '../cache-089d07a0.js';
-export { B as Base64Encoder, N as NetlifyCache, O as Operation, R as RequestContextFactory } from '../cache-089d07a0.js';
+import { E as EnvironmentOptions } from '../cache-7af07baa.js';
+export { B as Base64Encoder, N as NetlifyCache, O as Operation, R as RequestContextFactory } from '../cache-7af07baa.js';
 
 declare class NetlifyCacheStorage {
     #private;

package/dist/bootstrap/main.d.ts

@@ -1,5 +1,5 @@
-import { E as EnvironmentOptions } from '../cache-089d07a0.js';
-export { B as Base64Encoder, N as NetlifyCache, O as Operation, R as RequestContextFactory } from '../cache-089d07a0.js';
+import { E as EnvironmentOptions } from '../cache-7af07baa.js';
+export { B as Base64Encoder, N as NetlifyCache, O as Operation, R as RequestContextFactory } from '../cache-7af07baa.js';
 
 declare class NetlifyCacheStorage {
     #private;

package/dist/bootstrap/main.js

@@ -51,17 +51,15 @@ var allowedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
 var discardedHeaders = /* @__PURE__ */ new Set(["cookie", "content-encoding", "content-length"]);
 var getInternalHeaders = Symbol("getInternalHeaders");
 var serializeResourceHeaders = Symbol("serializeResourceHeaders");
-var _base64Encode, _getContext, _logger, _name, _userAgent;
+var _base64Encode, _getContext, _name, _userAgent;
 var NetlifyCache = class {
-  constructor({ base64Encode, getContext, logger, name, userAgent }) {
+  constructor({ base64Encode, getContext, name, userAgent }) {
     __privateAdd(this, _base64Encode, void 0);
     __privateAdd(this, _getContext, void 0);
-    __privateAdd(this, _logger, void 0);
     __privateAdd(this, _name, void 0);
     __privateAdd(this, _userAgent, void 0);
     __privateSet(this, _base64Encode, base64Encode);
     __privateSet(this, _getContext, getContext);
-    __privateSet(this, _logger, logger);
     __privateSet(this, _name, name);
     __privateSet(this, _userAgent, userAgent);
   }
@@ -144,7 +142,6 @@ var NetlifyCache = class {
     return res ? [res] : [];
   }
   async put(request, response) {
-    var _a;
     if (!response.ok) {
       throw new TypeError(`Cannot cache response with status ${response.status}.`);
     }
@@ -176,13 +173,12 @@ var NetlifyCache = class {
     if (!cacheResponse.ok) {
       const errorDetail = cacheResponse.headers.get(ErrorDetail) ?? "";
       const errorMessage = ERROR_CODES[errorDetail] || GENERIC_ERROR;
-      (_a = __privateGet(this, _logger)) == null ? void 0 : _a.call(this, `Failed to write to the cache: ${errorMessage}`);
+      context.logger?.(`Failed to write to the cache: ${errorMessage}`);
     }
   }
 };
 _base64Encode = new WeakMap();
 _getContext = new WeakMap();
-_logger = new WeakMap();
 _name = new WeakMap();
 _userAgent = new WeakMap();
 var extractAndValidateURL = (input) => {

package/dist/{cache-089d07a0.d.ts → cache-7af07baa.d.ts}

@@ -3,7 +3,6 @@ type Logger = (...args: any[]) => void;
 interface EnvironmentOptions {
     base64Encode: Base64Encoder;
     getContext: RequestContextFactory;
-    logger?: Logger;
     userAgent?: string;
 }
 declare enum Operation {
@@ -16,6 +15,7 @@ type RequestContextFactory = (options: {
 }) => RequestContext | null;
 interface RequestContext {
     host: string;
+    logger?: Logger;
     token: string;
     url: string;
 }
@@ -27,7 +27,7 @@ declare const getInternalHeaders: unique symbol;
 declare const serializeResourceHeaders: unique symbol;
 declare class NetlifyCache implements Cache {
     #private;
-    constructor({ base64Encode, getContext, logger, name, userAgent }: NetlifyCacheOptions);
+    constructor({ base64Encode, getContext, name, userAgent }: NetlifyCacheOptions);
     private [getInternalHeaders];
     private [serializeResourceHeaders];
     add(request: RequestInfo): Promise<void>;

package/dist/main.cjs

@@ -16,6 +16,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
 
 // src/main.ts
 var main_exports = {};
@@ -25,18 +43,245 @@ __export(main_exports, {
   MINUTE: () => MINUTE,
   WEEK: () => WEEK,
   YEAR: () => YEAR,
+  caches: () => caches,
   fetchWithCache: () => fetchWithCache,
   getCacheStatus: () => getCacheStatus,
   setCacheHeaders: () => setCacheHeaders
 });
 module.exports = __toCommonJS(main_exports);
 
+// src/bootstrap/errors.ts
+var ERROR_CODES = {
+  invalid_vary: "Responses must not use unsupported directives of the `Netlify-Vary` header (https://ntl.fyi/cache_api_invalid_vary).",
+  no_cache: "Responses must not set cache control headers with the `private`, `no-cache` or `no-store` directives (https://ntl.fyi/cache_api_no_cache).",
+  low_ttl: "Responses must have a cache control header with a `max-age` or `s-maxage` directive (https://ntl.fyi/cache_api_low_ttl).",
+  no_directive: "Responses must have a cache control header with caching directives (https://ntl.fyi/cache_api_no_directive).",
+  no_ttl: "Responses must have a cache control header with a `max-age` or `s-maxage` directive (https://ntl.fyi/cache_api_no_ttl).",
+  no_status: "Responses must specify a status code (https://ntl.fyi/cache_api_no_status).",
+  invalid_directive: "Responses must have a cache control header with caching directives (https://ntl.fyi/cache_api_invalid_directive).",
+  status: "Responses must have a status code between 200 and 299 (https://ntl.fyi/cache_api_status)."
+};
+var GENERIC_ERROR = "The server has returned an unexpected error (https://ntl.fyi/cache_api_error).";
+
 // src/headers.ts
 var CacheStatus = "cache-status";
 var NetlifyCacheId = "netlify-cache-id";
 var NetlifyCacheTag = "netlify-cache-tag";
 var NetlifyCdnCacheControl = "netlify-cdn-cache-control";
 var NetlifyVary = "netlify-vary";
+var ErrorDetail = "netlify-programmable-error";
+var ResourceHeaders = "netlify-programmable-headers";
+var ResourceStatus = "netlify-programmable-status";
+var ResourceStore = "netlify-programmable-store";
+var NetlifyForwardedHost = "netlify-forwarded-host";
+var UserAgent = "user-agent";
+
+// src/bootstrap/cache.ts
+var allowedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
+var discardedHeaders = /* @__PURE__ */ new Set(["cookie", "content-encoding", "content-length"]);
+var getInternalHeaders = Symbol("getInternalHeaders");
+var serializeResourceHeaders = Symbol("serializeResourceHeaders");
+var _base64Encode, _getContext, _name, _userAgent;
+var NetlifyCache = class {
+  constructor({ base64Encode, getContext, name, userAgent }) {
+    __privateAdd(this, _base64Encode, void 0);
+    __privateAdd(this, _getContext, void 0);
+    __privateAdd(this, _name, void 0);
+    __privateAdd(this, _userAgent, void 0);
+    __privateSet(this, _base64Encode, base64Encode);
+    __privateSet(this, _getContext, getContext);
+    __privateSet(this, _name, name);
+    __privateSet(this, _userAgent, userAgent);
+  }
+  [getInternalHeaders](requestContext) {
+    const { host, token } = requestContext;
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      [ResourceStore]: __privateGet(this, _name)
+    };
+    if (host) {
+      headers[NetlifyForwardedHost] = host;
+    }
+    if (__privateGet(this, _userAgent)) {
+      headers[UserAgent] = __privateGet(this, _userAgent);
+    }
+    return headers;
+  }
+  [serializeResourceHeaders](headers) {
+    const headersMap = {};
+    headers.forEach((value, key) => {
+      if (discardedHeaders.has(key)) {
+        return;
+      }
+      if (key === "set-cookie") {
+        headersMap[key] = headersMap[key] || [];
+        headersMap[key].push(value);
+      } else {
+        headersMap[key] = value.split(",");
+      }
+    });
+    return __privateGet(this, _base64Encode).call(this, JSON.stringify(headersMap));
+  }
+  async add(request) {
+    await this.put(new Request(request), await fetch(request));
+  }
+  async addAll(requests) {
+    await Promise.allSettled(requests.map((request) => this.add(request)));
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async delete(request) {
+    const context = __privateGet(this, _getContext).call(this, { operation: "delete" /* Delete */ });
+    if (context) {
+      const resourceURL = extractAndValidateURL(request);
+      await fetch(`${context.url}/${toCacheKey(resourceURL)}`, {
+        headers: this[getInternalHeaders](context),
+        method: "DELETE"
+      });
+    }
+    return true;
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async keys(_request) {
+    return [];
+  }
+  async match(request) {
+    try {
+      const context = __privateGet(this, _getContext).call(this, { operation: "read" /* Read */ });
+      if (!context) {
+        return;
+      }
+      const resourceURL = extractAndValidateURL(request);
+      const cacheURL = `${context.url}/${toCacheKey(resourceURL)}`;
+      const response = await fetch(cacheURL, {
+        headers: this[getInternalHeaders](context),
+        method: "GET"
+      });
+      if (!response.ok) {
+        return;
+      }
+      return response;
+    } catch {
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async matchAll(request, _options) {
+    if (!request) {
+      return [];
+    }
+    const res = await this.match(request);
+    return res ? [res] : [];
+  }
+  async put(request, response) {
+    if (!response.ok) {
+      throw new TypeError(`Cannot cache response with status ${response.status}.`);
+    }
+    if (request instanceof Request && request.method !== "GET") {
+      throw new TypeError(`Cannot cache response to ${request.method} request.`);
+    }
+    if (response.status === 206) {
+      throw new TypeError("Cannot cache response to a range request (206 Partial Content).");
+    }
+    if (response.headers.get("vary")?.includes("*")) {
+      throw new TypeError("Cannot cache response with 'Vary: *' header.");
+    }
+    const context = __privateGet(this, _getContext).call(this, { operation: "write" /* Write */ });
+    if (!context) {
+      return;
+    }
+    const resourceURL = extractAndValidateURL(request);
+    const cacheResponse = await fetch(`${context.url}/${toCacheKey(resourceURL)}`, {
+      body: response.body,
+      headers: {
+        ...this[getInternalHeaders](context),
+        [ResourceHeaders]: this[serializeResourceHeaders](response.headers),
+        [ResourceStatus]: response.status.toString()
+      },
+      // @ts-expect-error https://github.com/whatwg/fetch/pull/1457
+      duplex: "half",
+      method: "POST"
+    });
+    if (!cacheResponse.ok) {
+      const errorDetail = cacheResponse.headers.get(ErrorDetail) ?? "";
+      const errorMessage = ERROR_CODES[errorDetail] || GENERIC_ERROR;
+      context.logger?.(`Failed to write to the cache: ${errorMessage}`);
+    }
+  }
+};
+_base64Encode = new WeakMap();
+_getContext = new WeakMap();
+_name = new WeakMap();
+_userAgent = new WeakMap();
+var extractAndValidateURL = (input) => {
+  let url;
+  if (input instanceof Request) {
+    url = new URL(input.url);
+  } else {
+    try {
+      url = new URL(String(input));
+    } catch {
+      throw new TypeError(`${input} is not a valid URL.`);
+    }
+  }
+  if (!allowedProtocols.has(url.protocol)) {
+    throw new TypeError(
+      `Cannot cache response for URL with unsupported protocol (${url.protocol}). Supported protocols are ${[
+        ...allowedProtocols
+      ].join(", ")}.`
+    );
+  }
+  return url;
+};
+var toCacheKey = (url) => encodeURIComponent(url.toString());
+
+// src/bootstrap/cachestorage.ts
+var _environmentOptions, _stores;
+var NetlifyCacheStorage = class {
+  constructor(environmentOptions) {
+    __privateAdd(this, _environmentOptions, void 0);
+    __privateAdd(this, _stores, void 0);
+    __privateSet(this, _environmentOptions, environmentOptions);
+    __privateSet(this, _stores, /* @__PURE__ */ new Map());
+  }
+  open(name) {
+    let store = __privateGet(this, _stores).get(name);
+    if (!store) {
+      store = new NetlifyCache({
+        ...__privateGet(this, _environmentOptions),
+        name
+      });
+      __privateGet(this, _stores).set(name, store);
+    }
+    return Promise.resolve(store);
+  }
+  has(name) {
+    return Promise.resolve(__privateGet(this, _stores).has(name));
+  }
+  delete(name) {
+    return Promise.resolve(__privateGet(this, _stores).delete(name));
+  }
+  keys() {
+    return Promise.resolve([...__privateGet(this, _stores).keys()]);
+  }
+  async match(request, options) {
+    if (options?.cacheName) {
+      return __privateGet(this, _stores).get(options.cacheName)?.match(request);
+    }
+    for (const store of __privateGet(this, _stores).values()) {
+      const response = await store.match(request);
+      if (response === void 0) {
+        return;
+      }
+    }
+  }
+};
+_environmentOptions = new WeakMap();
+_stores = new WeakMap();
+
+// src/polyfill.ts
+var caches = globalThis.caches ?? new NetlifyCacheStorage({
+  base64Encode: () => "",
+  getContext: () => null
+});
 
 // src/cache-headers/validation.ts
 var ensureArray = (value) => Array.isArray(value) ? value : [value];
@@ -309,6 +554,7 @@ var YEAR = 365 * DAY;
   MINUTE,
   WEEK,
   YEAR,
+  caches,
   fetchWithCache,
   getCacheStatus,
   setCacheHeaders

package/dist/main.d.cts

@@ -1,4 +1,11 @@
-import { N as NetlifyCache } from './cache-089d07a0.js';
+import { N as NetlifyCache } from './cache-7af07baa.js';
+
+/**
+ * Polyfill for local development environments where `globalThis.caches` is not
+ * available. This is a no-op cache, which will automatically work with the
+ * real one in production.
+ */
+declare const caches: CacheStorage;
 
 interface CacheSettings {
     /**
@@ -174,4 +181,4 @@ declare const WEEK: number;
  */
 declare const YEAR: number;
 
-export { DAY, HOUR, MINUTE, WEEK, YEAR, fetchWithCache, getCacheStatus, setCacheHeaders };
+export { DAY, HOUR, MINUTE, WEEK, YEAR, caches, fetchWithCache, getCacheStatus, setCacheHeaders };

package/dist/main.d.ts

@@ -1,4 +1,11 @@
-import { N as NetlifyCache } from './cache-089d07a0.js';
+import { N as NetlifyCache } from './cache-7af07baa.js';
+
+/**
+ * Polyfill for local development environments where `globalThis.caches` is not
+ * available. This is a no-op cache, which will automatically work with the
+ * real one in production.
+ */
+declare const caches: CacheStorage;
 
 interface CacheSettings {
     /**
@@ -174,4 +181,4 @@ declare const WEEK: number;
  */
 declare const YEAR: number;
 
-export { DAY, HOUR, MINUTE, WEEK, YEAR, fetchWithCache, getCacheStatus, setCacheHeaders };
+export { DAY, HOUR, MINUTE, WEEK, YEAR, caches, fetchWithCache, getCacheStatus, setCacheHeaders };

package/dist/main.js

@@ -1,9 +1,254 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/bootstrap/errors.ts
+var ERROR_CODES = {
+  invalid_vary: "Responses must not use unsupported directives of the `Netlify-Vary` header (https://ntl.fyi/cache_api_invalid_vary).",
+  no_cache: "Responses must not set cache control headers with the `private`, `no-cache` or `no-store` directives (https://ntl.fyi/cache_api_no_cache).",
+  low_ttl: "Responses must have a cache control header with a `max-age` or `s-maxage` directive (https://ntl.fyi/cache_api_low_ttl).",
+  no_directive: "Responses must have a cache control header with caching directives (https://ntl.fyi/cache_api_no_directive).",
+  no_ttl: "Responses must have a cache control header with a `max-age` or `s-maxage` directive (https://ntl.fyi/cache_api_no_ttl).",
+  no_status: "Responses must specify a status code (https://ntl.fyi/cache_api_no_status).",
+  invalid_directive: "Responses must have a cache control header with caching directives (https://ntl.fyi/cache_api_invalid_directive).",
+  status: "Responses must have a status code between 200 and 299 (https://ntl.fyi/cache_api_status)."
+};
+var GENERIC_ERROR = "The server has returned an unexpected error (https://ntl.fyi/cache_api_error).";
+
 // src/headers.ts
 var CacheStatus = "cache-status";
 var NetlifyCacheId = "netlify-cache-id";
 var NetlifyCacheTag = "netlify-cache-tag";
 var NetlifyCdnCacheControl = "netlify-cdn-cache-control";
 var NetlifyVary = "netlify-vary";
+var ErrorDetail = "netlify-programmable-error";
+var ResourceHeaders = "netlify-programmable-headers";
+var ResourceStatus = "netlify-programmable-status";
+var ResourceStore = "netlify-programmable-store";
+var NetlifyForwardedHost = "netlify-forwarded-host";
+var UserAgent = "user-agent";
+
+// src/bootstrap/cache.ts
+var allowedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
+var discardedHeaders = /* @__PURE__ */ new Set(["cookie", "content-encoding", "content-length"]);
+var getInternalHeaders = Symbol("getInternalHeaders");
+var serializeResourceHeaders = Symbol("serializeResourceHeaders");
+var _base64Encode, _getContext, _name, _userAgent;
+var NetlifyCache = class {
+  constructor({ base64Encode, getContext, name, userAgent }) {
+    __privateAdd(this, _base64Encode, void 0);
+    __privateAdd(this, _getContext, void 0);
+    __privateAdd(this, _name, void 0);
+    __privateAdd(this, _userAgent, void 0);
+    __privateSet(this, _base64Encode, base64Encode);
+    __privateSet(this, _getContext, getContext);
+    __privateSet(this, _name, name);
+    __privateSet(this, _userAgent, userAgent);
+  }
+  [getInternalHeaders](requestContext) {
+    const { host, token } = requestContext;
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      [ResourceStore]: __privateGet(this, _name)
+    };
+    if (host) {
+      headers[NetlifyForwardedHost] = host;
+    }
+    if (__privateGet(this, _userAgent)) {
+      headers[UserAgent] = __privateGet(this, _userAgent);
+    }
+    return headers;
+  }
+  [serializeResourceHeaders](headers) {
+    const headersMap = {};
+    headers.forEach((value, key) => {
+      if (discardedHeaders.has(key)) {
+        return;
+      }
+      if (key === "set-cookie") {
+        headersMap[key] = headersMap[key] || [];
+        headersMap[key].push(value);
+      } else {
+        headersMap[key] = value.split(",");
+      }
+    });
+    return __privateGet(this, _base64Encode).call(this, JSON.stringify(headersMap));
+  }
+  async add(request) {
+    await this.put(new Request(request), await fetch(request));
+  }
+  async addAll(requests) {
+    await Promise.allSettled(requests.map((request) => this.add(request)));
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async delete(request) {
+    const context = __privateGet(this, _getContext).call(this, { operation: "delete" /* Delete */ });
+    if (context) {
+      const resourceURL = extractAndValidateURL(request);
+      await fetch(`${context.url}/${toCacheKey(resourceURL)}`, {
+        headers: this[getInternalHeaders](context),
+        method: "DELETE"
+      });
+    }
+    return true;
+  }
+  // eslint-disable-next-line class-methods-use-this, require-await, @typescript-eslint/no-unused-vars
+  async keys(_request) {
+    return [];
+  }
+  async match(request) {
+    try {
+      const context = __privateGet(this, _getContext).call(this, { operation: "read" /* Read */ });
+      if (!context) {
+        return;
+      }
+      const resourceURL = extractAndValidateURL(request);
+      const cacheURL = `${context.url}/${toCacheKey(resourceURL)}`;
+      const response = await fetch(cacheURL, {
+        headers: this[getInternalHeaders](context),
+        method: "GET"
+      });
+      if (!response.ok) {
+        return;
+      }
+      return response;
+    } catch {
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async matchAll(request, _options) {
+    if (!request) {
+      return [];
+    }
+    const res = await this.match(request);
+    return res ? [res] : [];
+  }
+  async put(request, response) {
+    if (!response.ok) {
+      throw new TypeError(`Cannot cache response with status ${response.status}.`);
+    }
+    if (request instanceof Request && request.method !== "GET") {
+      throw new TypeError(`Cannot cache response to ${request.method} request.`);
+    }
+    if (response.status === 206) {
+      throw new TypeError("Cannot cache response to a range request (206 Partial Content).");
+    }
+    if (response.headers.get("vary")?.includes("*")) {
+      throw new TypeError("Cannot cache response with 'Vary: *' header.");
+    }
+    const context = __privateGet(this, _getContext).call(this, { operation: "write" /* Write */ });
+    if (!context) {
+      return;
+    }
+    const resourceURL = extractAndValidateURL(request);
+    const cacheResponse = await fetch(`${context.url}/${toCacheKey(resourceURL)}`, {
+      body: response.body,
+      headers: {
+        ...this[getInternalHeaders](context),
+        [ResourceHeaders]: this[serializeResourceHeaders](response.headers),
+        [ResourceStatus]: response.status.toString()
+      },
+      // @ts-expect-error https://github.com/whatwg/fetch/pull/1457
+      duplex: "half",
+      method: "POST"
+    });
+    if (!cacheResponse.ok) {
+      const errorDetail = cacheResponse.headers.get(ErrorDetail) ?? "";
+      const errorMessage = ERROR_CODES[errorDetail] || GENERIC_ERROR;
+      context.logger?.(`Failed to write to the cache: ${errorMessage}`);
+    }
+  }
+};
+_base64Encode = new WeakMap();
+_getContext = new WeakMap();
+_name = new WeakMap();
+_userAgent = new WeakMap();
+var extractAndValidateURL = (input) => {
+  let url;
+  if (input instanceof Request) {
+    url = new URL(input.url);
+  } else {
+    try {
+      url = new URL(String(input));
+    } catch {
+      throw new TypeError(`${input} is not a valid URL.`);
+    }
+  }
+  if (!allowedProtocols.has(url.protocol)) {
+    throw new TypeError(
+      `Cannot cache response for URL with unsupported protocol (${url.protocol}). Supported protocols are ${[
+        ...allowedProtocols
+      ].join(", ")}.`
+    );
+  }
+  return url;
+};
+var toCacheKey = (url) => encodeURIComponent(url.toString());
+
+// src/bootstrap/cachestorage.ts
+var _environmentOptions, _stores;
+var NetlifyCacheStorage = class {
+  constructor(environmentOptions) {
+    __privateAdd(this, _environmentOptions, void 0);
+    __privateAdd(this, _stores, void 0);
+    __privateSet(this, _environmentOptions, environmentOptions);
+    __privateSet(this, _stores, /* @__PURE__ */ new Map());
+  }
+  open(name) {
+    let store = __privateGet(this, _stores).get(name);
+    if (!store) {
+      store = new NetlifyCache({
+        ...__privateGet(this, _environmentOptions),
+        name
+      });
+      __privateGet(this, _stores).set(name, store);
+    }
+    return Promise.resolve(store);
+  }
+  has(name) {
+    return Promise.resolve(__privateGet(this, _stores).has(name));
+  }
+  delete(name) {
+    return Promise.resolve(__privateGet(this, _stores).delete(name));
+  }
+  keys() {
+    return Promise.resolve([...__privateGet(this, _stores).keys()]);
+  }
+  async match(request, options) {
+    if (options?.cacheName) {
+      return __privateGet(this, _stores).get(options.cacheName)?.match(request);
+    }
+    for (const store of __privateGet(this, _stores).values()) {
+      const response = await store.match(request);
+      if (response === void 0) {
+        return;
+      }
+    }
+  }
+};
+_environmentOptions = new WeakMap();
+_stores = new WeakMap();
+
+// src/polyfill.ts
+var caches = globalThis.caches ?? new NetlifyCacheStorage({
+  base64Encode: () => "",
+  getContext: () => null
+});
 
 // src/cache-headers/validation.ts
 var ensureArray = (value) => Array.isArray(value) ? value : [value];
@@ -275,6 +520,7 @@ export {
   MINUTE,
   WEEK,
   YEAR,
+  caches,
   fetchWithCache,
   getCacheStatus,
   setCacheHeaders

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/cache",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "TypeScript utilities for interacting with the Netlify cache",
   "type": "module",
   "engines": {