@ohos-ports/layer0-prefetch 4.20.0-beta.0

package/README.md

@@ -0,0 +1,7 @@
+# Layer0 Prefetch
+
+Prefetching library for the [Layer0](https://docs.layer0.co), infrastructure to run your big, dynamic website frontend and make it load in less than one second.
+
+The `@layer0/prefetch` package makes it easy to prefetch dynamic content cached at the network edge and store it in the browser's service worker cache.
+
+You can read more about it in our [prefetching guide](https://docs.layer0.co/guides/prefetching)

package/constants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The name of the prefetch cache.
+ *
+ * Defaults to `prefetch`.
+ */
+export declare const CACHE_NAME: string;
+/**
+ * The header that lists the urls that were fetched from backends during server side rendering
+ */
+export declare const BACKEND_REQUESTS_RESPONSE_HEADER_NAME = "x-0-upstream-requests";
+/**
+ * The value of the prefetch header. Defaults to `1`.
+ */
+export declare const PREFETCH_HEADER_VALUE: string;
+/**
+ * The header used to determine if a response should be cached by the service worker.
+ */
+export declare const SERVICE_WORKER_CACHE_CONTROL = "x-sw-cache-control";
+/**
+ * The amount of time prefetch requests are cached for when no explicit TTL is set in the route definition or
+ * query param.
+ */
+export declare const DEFAULT_MAX_AGE_SECONDS: number;

package/constants.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The name of the prefetch cache.
+ *
+ * Defaults to `prefetch`.
+ */
+exports.CACHE_NAME = process.env.LAYER0_PREFETCH_CACHE_NAME || 'prefetch';
+/**
+ * The header that lists the urls that were fetched from backends during server side rendering
+ */
+exports.BACKEND_REQUESTS_RESPONSE_HEADER_NAME = 'x-0-upstream-requests';
+/**
+ * The value of the prefetch header. Defaults to `1`.
+ */
+exports.PREFETCH_HEADER_VALUE = process.env.LAYER0_PREFETCH_HEADER_VALUE || '1';
+/**
+ * The header used to determine if a response should be cached by the service worker.
+ */
+exports.SERVICE_WORKER_CACHE_CONTROL = 'x-sw-cache-control';
+/**
+ * The amount of time prefetch requests are cached for when no explicit TTL is set in the route definition or
+ * query param.
+ */
+exports.DEFAULT_MAX_AGE_SECONDS = 60 * 2; // 2 minutes

package/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Main entry for @layer0/prefetch.
+ *
+ * The published npm tarball for 4.20.0 is missing this file even though
+ * package.json declares `"main": "index.js"` (upstream packaging defect).
+ * It re-exports the browser/window API as the package's top-level entry,
+ * along with the shared prefetch constants.
+ */
+// Re-export the window (browser) API: prefetch, install, waitForServiceWorker
+const window_1 = require("./window");
+Object.keys(window_1).forEach(function (key) {
+    if (key !== 'default' && !(key in exports)) {
+        exports[key] = window_1[key];
+    }
+});
+// Re-export the shared constants: CACHE_NAME, PREFETCH_HEADER_VALUE, etc.
+const constants_1 = require("./constants");
+Object.keys(constants_1).forEach(function (key) {
+    if (key !== 'default' && !(key in exports)) {
+        exports[key] = constants_1[key];
+    }
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@ohos-ports/layer0-prefetch",
+  "version": "4.20.0-beta.0",
+  "description": "Enables prefetching and caching of pages using Layer0 and Workbox.",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "@layer0/core": "^4.20.0",
+    "cheerio": "^1.0.0-rc.3",
+    "json-query": "^2.2.2",
+    "workbox-cacheable-response": "^5.1.2",
+    "workbox-core": "^5.1.4",
+    "workbox-expiration": "^5.1.2",
+    "workbox-precaching": "^5.1.4",
+    "workbox-routing": "^5.1.2",
+    "workbox-strategies": "^5.1.2"
+  },
+  "devDependencies": {
+    "@types/cheerio": "0.22.18",
+    "@types/jest": "^25.2.1",
+    "@types/json-query": "^2.2.0",
+    "@types/node": "^13.11.1",
+    "node-fetch": "^2.6.0"
+  },
+  "peerDependencies": {
+    "@layer0/devtools": "^4.0.0"
+  },
+  "scripts": {},
+  "keywords": [],
+  "author": "Layer0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/@layer0/prefetch/4.20.0"
+  },
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "files": [
+    "index.js",
+    "constants.js",
+    "constants.d.ts",
+    "sw/",
+    "window/",
+    "README.md"
+  ]
+}

package/sw/CustomCacheKeyPlugin.d.ts

@@ -0,0 +1,10 @@
+import { CacheKeyWillBeUsedCallbackParam, WorkboxPlugin } from 'workbox-core/types';
+import { CustomCacheKeyConfig } from '@layer0/core/router/CustomCacheKey';
+export default class CustomCacheKeyPlugin implements WorkboxPlugin {
+    route: RegExp;
+    config: CustomCacheKeyConfig[];
+    constructor(urls: RegExp, config: CustomCacheKeyConfig[]);
+    urlMatches(url: string): boolean;
+    cacheKeyWillBeUsed({ request }: CacheKeyWillBeUsedCallbackParam): Promise<string | Request>;
+    private handleKeyConfig;
+}

package/sw/CustomCacheKeyPlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CustomCacheKey_1 = require("@layer0/core/router/CustomCacheKey");
+const constants_1 = require("@layer0/core/constants");
+class CustomCacheKeyPlugin {
+    constructor(urls, config) {
+        this.route = urls;
+        this.config = config;
+    }
+    urlMatches(url) {
+        return this.route.test(url);
+    }
+    async cacheKeyWillBeUsed({ request }) {
+        const url = new URL(request.url);
+        if (this.urlMatches(url.pathname)) {
+            const url = new URL(request.url);
+            this.config.forEach(conf => this.handleKeyConfig(url, conf));
+            return url.toString();
+        }
+        return request;
+    }
+    handleKeyConfig(url, config) {
+        const deleteKeys = [];
+        switch (config.action) {
+            case CustomCacheKey_1.CUSTOM_CACHE_KEY_ACTIONS.blacklistAll:
+                url.searchParams.forEach((value, key) => {
+                    deleteKeys.push(key);
+                });
+                break;
+            case CustomCacheKey_1.CUSTOM_CACHE_KEY_ACTIONS.blacklistSome:
+                url.searchParams.forEach((value, key) => {
+                    if (config.names && config.names.includes(key)) {
+                        deleteKeys.push(key);
+                    }
+                });
+                break;
+            case CustomCacheKey_1.CUSTOM_CACHE_KEY_ACTIONS.whitelistSome:
+                url.searchParams.forEach((value, key) => {
+                    if (config.names && !config.names.includes(key)) {
+                        deleteKeys.push(key);
+                    }
+                });
+                break;
+            case CustomCacheKey_1.CUSTOM_CACHE_KEY_ACTIONS.removeBody:
+                url.searchParams.delete(constants_1.POST_BODY_QUERY_PARAM);
+                break;
+            case CustomCacheKey_1.CUSTOM_CACHE_KEY_ACTIONS.removeMethod:
+                url.searchParams.delete(constants_1.METHOD_QUERY_PARAM);
+                break;
+        }
+        deleteKeys.forEach(key => url.searchParams.delete(key));
+    }
+}
+exports.default = CustomCacheKeyPlugin;

package/sw/CustomExpirationPlugin.d.ts

@@ -0,0 +1,122 @@
+import { WorkboxPlugin } from 'workbox-core/types';
+export interface ExpirationPluginOptions {
+    maxEntries?: number;
+    maxAgeSeconds?: number;
+    matchOptions?: CacheQueryOptions;
+    purgeOnQuotaError?: boolean;
+}
+/**
+ * This plugin can be used in a `workbox-strategy` to regularly enforce a
+ * limit on the age and / or the number of cached requests.
+ *
+ * It can only be used with `workbox-strategy` instances that have a
+ * [custom `cacheName` property set](/web/tools/workbox/guides/configure-workbox#custom_cache_names_in_strategies).
+ * In other words, it can't be used to expire entries in strategy that uses the
+ * default runtime cache name.
+ *
+ * Whenever a cached response is used or updated, this plugin will look
+ * at the associated cache and remove any old or extra responses.
+ *
+ * When using `maxAgeSeconds`, responses may be used *once* after expiring
+ * because the expiration clean up will not have occurred until *after* the
+ * cached response has been used. If the response has a "Date" header, then
+ * a light weight expiration check is performed and the response will not be
+ * used immediately.
+ *
+ * When using `maxEntries`, the entry least-recently requested will be removed
+ * from the cache first.
+ *
+ * @memberof workbox-expiration
+ */
+declare class CustomExpirationPlugin implements WorkboxPlugin {
+    private readonly _config;
+    private readonly _maxAgeSeconds?;
+    private _cacheExpirations;
+    /**
+     * @param {ExpirationPluginOptions} config
+     * @param {number} [config.maxEntries] The maximum number of entries to cache.
+     * Entries used the least will be removed as the maximum is reached.
+     * @param {number} [config.maxAgeSeconds] The maximum age of an entry before
+     * it's treated as stale and removed.
+     * @param {Object} [config.matchOptions] The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters)
+     * that will be used when calling `delete()` on the cache.
+     * @param {boolean} [config.purgeOnQuotaError] Whether to opt this cache in to
+     * automatic deletion if the available storage quota has been exceeded.
+     */
+    constructor(config?: ExpirationPluginOptions);
+    /**
+     * A simple helper method to return a CacheExpiration instance for a given
+     * cache name.
+     *
+     * @param {string} cacheName
+     * @return {CacheExpiration}
+     *
+     * @private
+     */
+    private _getCacheExpiration;
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `workbox-strategies` handlers when a `Response` is about to be returned
+     * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
+     * the handler. It allows the `Response` to be inspected for freshness and
+     * prevents it from being used if the `Response`'s `Date` header value is
+     * older than the configured `maxAgeSeconds`.
+     *
+     * @param {Object} options
+     * @param {string} options.cacheName Name of the cache the response is in.
+     * @param {Response} options.cachedResponse The `Response` object that's been
+     *     read from a cache and whose freshness should be checked.
+     * @return {Response} Either the `cachedResponse`, if it's
+     *     fresh, or `null` if the `Response` is older than `maxAgeSeconds`.
+     *
+     * @private
+     */
+    cachedResponseWillBeUsed: WorkboxPlugin['cachedResponseWillBeUsed'];
+    /**
+     * @param {Response} cachedResponse
+     * @param {number|null} maxAgeSeconds
+     * @return {boolean}
+     *
+     * @private
+     */
+    private _isResponseDateFresh;
+    /**
+     * This method will extract the data header and parse it into a useful
+     * value.
+     *
+     * @param {Response} cachedResponse
+     * @return {number|null}
+     *
+     * @private
+     */
+    private _getDateHeaderTimestamp;
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `workbox-strategies` handlers when an entry is added to a cache.
+     *
+     * @param {Object} options
+     * @param {string} options.cacheName Name of the cache that was updated.
+     * @param {string} options.request The Request for the cached entry.
+     *
+     * @private
+     */
+    cacheDidUpdate: WorkboxPlugin['cacheDidUpdate'];
+    /**
+     * This is a helper method that performs two operations:
+     *
+     * - Deletes *all* the underlying Cache instances associated with this plugin
+     * instance, by calling caches.delete() on your behalf.
+     * - Deletes the metadata from IndexedDB used to keep track of expiration
+     * details for each Cache instance.
+     *
+     * When using cache expiration, calling this method is preferable to calling
+     * `caches.delete()` directly, since this will ensure that the IndexedDB
+     * metadata is also cleanly removed and open IndexedDB instances are deleted.
+     *
+     * Note that if you're *not* using cache expiration for a given cache, calling
+     * `caches.delete()` and passing in the cache's name should be sufficient.
+     * There is no Workbox-specific method needed for cleanup in that case.
+     */
+    deleteCacheAndMetadata(): Promise<void>;
+}
+export { CustomExpirationPlugin };

package/sw/CustomExpirationPlugin.js

@@ -0,0 +1,280 @@
+"use strict";
+/*
+  Modified version of ExpirationPlugin from 'workbox-expiration'
+  with layer0 custom TTL support
+
+  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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("workbox-core/_private/assert");
+const cacheNames_1 = require("workbox-core/_private/cacheNames");
+const dontWaitFor_1 = require("workbox-core/_private/dontWaitFor");
+const getFriendlyURL_1 = require("workbox-core/_private/getFriendlyURL");
+const logger_1 = require("workbox-core/_private/logger");
+const registerQuotaErrorCallback_1 = require("workbox-core/registerQuotaErrorCallback");
+const WorkboxError_1 = require("workbox-core/_private/WorkboxError");
+const workbox_expiration_1 = require("workbox-expiration");
+const getServiceWorkerMaxAge_1 = __importDefault(require("./getServiceWorkerMaxAge"));
+const log_1 = __importDefault(require("./log"));
+/**
+ * This plugin can be used in a `workbox-strategy` to regularly enforce a
+ * limit on the age and / or the number of cached requests.
+ *
+ * It can only be used with `workbox-strategy` instances that have a
+ * [custom `cacheName` property set](/web/tools/workbox/guides/configure-workbox#custom_cache_names_in_strategies).
+ * In other words, it can't be used to expire entries in strategy that uses the
+ * default runtime cache name.
+ *
+ * Whenever a cached response is used or updated, this plugin will look
+ * at the associated cache and remove any old or extra responses.
+ *
+ * When using `maxAgeSeconds`, responses may be used *once* after expiring
+ * because the expiration clean up will not have occurred until *after* the
+ * cached response has been used. If the response has a "Date" header, then
+ * a light weight expiration check is performed and the response will not be
+ * used immediately.
+ *
+ * When using `maxEntries`, the entry least-recently requested will be removed
+ * from the cache first.
+ *
+ * @memberof workbox-expiration
+ */
+class CustomExpirationPlugin {
+    /**
+     * @param {ExpirationPluginOptions} config
+     * @param {number} [config.maxEntries] The maximum number of entries to cache.
+     * Entries used the least will be removed as the maximum is reached.
+     * @param {number} [config.maxAgeSeconds] The maximum age of an entry before
+     * it's treated as stale and removed.
+     * @param {Object} [config.matchOptions] The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters)
+     * that will be used when calling `delete()` on the cache.
+     * @param {boolean} [config.purgeOnQuotaError] Whether to opt this cache in to
+     * automatic deletion if the available storage quota has been exceeded.
+     */
+    constructor(config = {}) {
+        /**
+         * A "lifecycle" callback that will be triggered automatically by the
+         * `workbox-strategies` handlers when a `Response` is about to be returned
+         * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
+         * the handler. It allows the `Response` to be inspected for freshness and
+         * prevents it from being used if the `Response`'s `Date` header value is
+         * older than the configured `maxAgeSeconds`.
+         *
+         * @param {Object} options
+         * @param {string} options.cacheName Name of the cache the response is in.
+         * @param {Response} options.cachedResponse The `Response` object that's been
+         *     read from a cache and whose freshness should be checked.
+         * @return {Response} Either the `cachedResponse`, if it's
+         *     fresh, or `null` if the `Response` is older than `maxAgeSeconds`.
+         *
+         * @private
+         */
+        this.cachedResponseWillBeUsed = async ({ event, request, cacheName, cachedResponse, }) => {
+            if (!cachedResponse) {
+                return null;
+            }
+            const isFresh = this._isResponseDateFresh(cachedResponse);
+            // Expire entries to ensure that even if the expiration date has
+            // expired, it'll only be used once.
+            const cacheExpiration = this._getCacheExpiration(cacheName);
+            dontWaitFor_1.dontWaitFor(cacheExpiration.expireEntries());
+            // Update the metadata for the request URL to the current timestamp,
+            // but don't `await` it as we don't want to block the response.
+            const updateTimestampDone = cacheExpiration.updateTimestamp(request.url);
+            if (event) {
+                try {
+                    event.waitUntil(updateTimestampDone);
+                }
+                catch (error) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        // The event may not be a fetch event; only log the URL if it is.
+                        if ('request' in event) {
+                            logger_1.logger.warn(`Unable to ensure service worker stays alive when ` +
+                                `updating cache entry for ` +
+                                `'${getFriendlyURL_1.getFriendlyURL(event.request.url)}'.`);
+                        }
+                    }
+                }
+            }
+            return isFresh ? cachedResponse : null;
+        };
+        /**
+         * A "lifecycle" callback that will be triggered automatically by the
+         * `workbox-strategies` handlers when an entry is added to a cache.
+         *
+         * @param {Object} options
+         * @param {string} options.cacheName Name of the cache that was updated.
+         * @param {string} options.request The Request for the cached entry.
+         *
+         * @private
+         */
+        this.cacheDidUpdate = async ({ cacheName, request }) => {
+            if (process.env.NODE_ENV !== 'production') {
+                assert_1.assert.isType(cacheName, 'string', {
+                    moduleName: 'workbox-expiration',
+                    className: 'Plugin',
+                    funcName: 'cacheDidUpdate',
+                    paramName: 'cacheName',
+                });
+                assert_1.assert.isInstance(request, Request, {
+                    moduleName: 'workbox-expiration',
+                    className: 'Plugin',
+                    funcName: 'cacheDidUpdate',
+                    paramName: 'request',
+                });
+            }
+            const cacheExpiration = this._getCacheExpiration(cacheName);
+            await cacheExpiration.updateTimestamp(request.url);
+            await cacheExpiration.expireEntries();
+        };
+        if (process.env.NODE_ENV !== 'production') {
+            if (!(config.maxEntries || config.maxAgeSeconds)) {
+                throw new WorkboxError_1.WorkboxError('max-entries-or-age-required', {
+                    moduleName: 'workbox-expiration',
+                    className: 'Plugin',
+                    funcName: 'constructor',
+                });
+            }
+            if (config.maxEntries) {
+                assert_1.assert.isType(config.maxEntries, 'number', {
+                    moduleName: 'workbox-expiration',
+                    className: 'Plugin',
+                    funcName: 'constructor',
+                    paramName: 'config.maxEntries',
+                });
+            }
+            if (config.maxAgeSeconds) {
+                assert_1.assert.isType(config.maxAgeSeconds, 'number', {
+                    moduleName: 'workbox-expiration',
+                    className: 'Plugin',
+                    funcName: 'constructor',
+                    paramName: 'config.maxAgeSeconds',
+                });
+            }
+        }
+        this._config = config;
+        this._maxAgeSeconds = config.maxAgeSeconds;
+        this._cacheExpirations = new Map();
+        if (config.purgeOnQuotaError) {
+            registerQuotaErrorCallback_1.registerQuotaErrorCallback(() => this.deleteCacheAndMetadata());
+        }
+    }
+    /**
+     * A simple helper method to return a CacheExpiration instance for a given
+     * cache name.
+     *
+     * @param {string} cacheName
+     * @return {CacheExpiration}
+     *
+     * @private
+     */
+    _getCacheExpiration(cacheName) {
+        if (cacheName === cacheNames_1.cacheNames.getRuntimeName()) {
+            throw new WorkboxError_1.WorkboxError('expire-custom-caches-only');
+        }
+        let cacheExpiration = this._cacheExpirations.get(cacheName);
+        if (!cacheExpiration) {
+            cacheExpiration = new workbox_expiration_1.CacheExpiration(cacheName, this._config);
+            this._cacheExpirations.set(cacheName, cacheExpiration);
+        }
+        return cacheExpiration;
+    }
+    // THIS PART OF CODE WAS MODIFIED BY US
+    // The optional maxAgeSeconds param was added and the maxAgeSeconds use changed to this param
+    /**
+     * @param {Response} cachedResponse
+     * @param {number|null} maxAgeSeconds
+     * @return {boolean}
+     *
+     * @private
+     */
+    _isResponseDateFresh(cachedResponse) {
+        // BEGIN EDGIO CHANGES
+        // Get maxAgeSeconds config from SW header
+        let maxAgeSeconds = getServiceWorkerMaxAge_1.default(cachedResponse) || this._maxAgeSeconds;
+        // END EDGIO CHANGES
+        if (!maxAgeSeconds) {
+            // We aren't expiring by age, so return true, it's fresh
+            return true;
+        }
+        // Check if the 'date' header will suffice a quick expiration check.
+        // See https://github.com/GoogleChromeLabs/sw-toolbox/issues/164 for
+        // discussion.
+        const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
+        if (dateHeaderTimestamp === null) {
+            // Unable to parse date, so assume it's fresh.
+            return true;
+        }
+        // If we have a valid headerTime, then our response is fresh iff the
+        // headerTime plus maxAgeSeconds is greater than the current time.
+        const now = Date.now();
+        // BEGIN EDGIO CHANGES
+        // Here we change the logging output to include the remaining fresh time to make things easier to debug
+        const expiresAtTimestamp = now - maxAgeSeconds * 1000;
+        const remaingFreshTime = dateHeaderTimestamp - expiresAtTimestamp;
+        if (remaingFreshTime > 0) {
+            log_1.default(`The cached response is still fresh for ${remaingFreshTime / 1000} seconds`);
+            return true;
+        }
+        else {
+            log_1.default(`The cached response is stale and will not be used`);
+            return false;
+        }
+        // END EDGIO CHANGES
+    }
+    /**
+     * This method will extract the data header and parse it into a useful
+     * value.
+     *
+     * @param {Response} cachedResponse
+     * @return {number|null}
+     *
+     * @private
+     */
+    _getDateHeaderTimestamp(cachedResponse) {
+        if (!cachedResponse.headers.has('date')) {
+            return null;
+        }
+        const dateHeader = cachedResponse.headers.get('date');
+        const parsedDate = new Date(dateHeader);
+        const headerTime = parsedDate.getTime();
+        // If the Date header was invalid for some reason, parsedDate.getTime()
+        // will return NaN.
+        if (isNaN(headerTime)) {
+            return null;
+        }
+        return headerTime;
+    }
+    /**
+     * This is a helper method that performs two operations:
+     *
+     * - Deletes *all* the underlying Cache instances associated with this plugin
+     * instance, by calling caches.delete() on your behalf.
+     * - Deletes the metadata from IndexedDB used to keep track of expiration
+     * details for each Cache instance.
+     *
+     * When using cache expiration, calling this method is preferable to calling
+     * `caches.delete()` directly, since this will ensure that the IndexedDB
+     * metadata is also cleanly removed and open IndexedDB instances are deleted.
+     *
+     * Note that if you're *not* using cache expiration for a given cache, calling
+     * `caches.delete()` and passing in the cache's name should be sufficient.
+     * There is no Workbox-specific method needed for cleanup in that case.
+     */
+    async deleteCacheAndMetadata() {
+        // Do this one at a time instead of all at once via `Promise.all()` to
+        // reduce the chance of inconsistency if a promise rejects.
+        for (const [cacheName, cacheExpiration] of this._cacheExpirations) {
+            await self.caches.delete(cacheName);
+            await cacheExpiration.delete();
+        }
+        // Reset this._cacheExpirations to its initial state.
+        this._cacheExpirations = new Map();
+    }
+}
+exports.CustomExpirationPlugin = CustomExpirationPlugin;