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

package/sw/DeepFetchPlugin.d.ts

@@ -0,0 +1,108 @@
+/// <reference types="cheerio" />
+import { WorkboxPlugin, FetchDidSucceedCallbackParam } from 'workbox-core/types';
+import { Options } from 'json-query';
+export interface DeepFetchCallbackParam {
+    /**
+     * The matching element, wrapped in a cheerio instance
+     */
+    $el: Cheerio;
+    /**
+     * The matching element
+     */
+    el: CheerioElement;
+    /**
+     * The cheerio static instance
+     */
+    $: CheerioStatic;
+    /**
+     * The URL of the page that was prefetched
+     */
+    srcURL: string;
+}
+interface DeepFetchBaseConfig {
+    /**
+     * The max number of matching elements to prefetch per page
+     */
+    maxMatches?: number;
+    /**
+     * The value for the `<link rel="prefetch|preload">` element's `as` attribute.
+     * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link.  Use "fetch" for html pages as Safari doesn't support "document".
+     */
+    as: 'image' | 'script' | 'style' | 'font' | 'fetch' | 'video';
+    /**
+     * The value of the `crossorigin` attribute of the prefetch link. Defaults to 'anonymous'. Setting this to `false`
+     * makes it so the `crossorigin` attribute is omitted, i.e. no CORS is used.
+     */
+    cors?: false | 'anonymous' | 'use-credentials';
+}
+interface DeepFetchHtmlConfig extends DeepFetchBaseConfig {
+    /**
+     * The CSS selector to use when finding elements whose src or href should be deep fetched
+     */
+    selector: string;
+    /**
+     * The attribute whose value should be prefetched. Defaults to `src`.
+     */
+    attribute: string;
+    /**
+     * A callback to override the default prefetching logic. Will be called for each matching element,
+     * or if `maxMatches` is provided, the first n elements.
+     */
+    callback?: (param: DeepFetchCallbackParam) => void;
+}
+interface DeepFetchJsonConfig extends DeepFetchBaseConfig {
+    /**
+     * A json query to use when finding data within a JSON response that should be deep
+     * fetched.
+     * Queries are made using the [json-query](https://github.com/auditassistant/json-query)
+     * library. Properties returned by the query are expected to be strings; any non-string
+     * results are ignored.
+     */
+    jsonQuery: string;
+    /**
+     * Options that can be passed to [json-query](https://github.com/auditassistant/json-query#options).
+     */
+    jsonQueryOptions?: Options;
+}
+declare type DeepFetchConfig = DeepFetchHtmlConfig | DeepFetchJsonConfig;
+/**
+ * This plugin deep fetches resources during prefetching based on CSS selectors.
+ *
+ * ** Example **
+ *
+ * ```js
+ *  import DeepFetchPlugin from '@layer0/prefetch/sw/DeepFetchPlugin'
+ *  import { Prefetcher } from '@layer0/prefetch/sw'
+ *
+ *  new Prefetcher({
+ *    plugins: [
+ *      new DeepFetchPlugin([
+ *        {
+ *          selector: 'img.product-main-image,
+ *          maxMatches: 1,
+ *          as: 'image',
+ *          attribute: 'src'
+ *        }
+ *      ])
+ *    ]
+ *  })
+ * ```
+ */
+export default class DeepFetchPlugin implements WorkboxPlugin {
+    config: DeepFetchConfig[];
+    constructor(config: DeepFetchConfig[]);
+    get htmlConfigs(): DeepFetchHtmlConfig[];
+    get jsonConfigs(): DeepFetchJsonConfig[];
+    /**
+     * WorkboxPlugin method called every time a fetch succeeds.
+     */
+    fetchDidSucceed({ request, response }: FetchDidSucceedCallbackParam): Promise<Response>;
+    /**
+     * Deep fetches elements that match the selectors provided by the user.
+     * @param html The document to search
+     * @param srcURL URL of the source document
+     */
+    private deepFetchHtml;
+    private deepFetchJson;
+}
+export {};

package/sw/DeepFetchPlugin.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cheerio_1 = __importDefault(require("cheerio"));
+const prefetch_1 = require("./prefetch");
+const log_1 = __importDefault(require("./log"));
+const json_query_1 = __importDefault(require("json-query"));
+function isHtmlConfig(config) {
+    return config.selector !== undefined;
+}
+function isJsonConfig(config) {
+    return config.jsonQuery !== undefined;
+}
+/**
+ * This plugin deep fetches resources during prefetching based on CSS selectors.
+ *
+ * ** Example **
+ *
+ * ```js
+ *  import DeepFetchPlugin from '@layer0/prefetch/sw/DeepFetchPlugin'
+ *  import { Prefetcher } from '@layer0/prefetch/sw'
+ *
+ *  new Prefetcher({
+ *    plugins: [
+ *      new DeepFetchPlugin([
+ *        {
+ *          selector: 'img.product-main-image,
+ *          maxMatches: 1,
+ *          as: 'image',
+ *          attribute: 'src'
+ *        }
+ *      ])
+ *    ]
+ *  })
+ * ```
+ */
+class DeepFetchPlugin {
+    constructor(config) {
+        this.config = config;
+    }
+    get htmlConfigs() {
+        return this.config.filter(isHtmlConfig);
+    }
+    get jsonConfigs() {
+        return this.config.filter(isJsonConfig);
+    }
+    /**
+     * WorkboxPlugin method called every time a fetch succeeds.
+     */
+    async fetchDidSucceed({ request, response }) {
+        try {
+            const contentType = response.headers.get('content-type');
+            if (contentType && contentType.toLowerCase().includes('text/html')) {
+                response
+                    .clone()
+                    .text()
+                    .then(html => this.deepFetchHtml(html, request.url));
+            }
+            else if (contentType && contentType.toLowerCase().includes('application/json')) {
+                response
+                    .clone()
+                    .json()
+                    .then(obj => this.deepFetchJson(obj, request.url));
+            }
+        }
+        finally {
+            // need to always return the response here, even if there is an error, or the browser will never get a response from the network
+            // eslint-disable-next-line no-unsafe-finally
+            return response;
+        }
+    }
+    /**
+     * Deep fetches elements that match the selectors provided by the user.
+     * @param html The document to search
+     * @param srcURL URL of the source document
+     */
+    async deepFetchHtml(html, srcURL) {
+        // cheerio >= 1.0.0 compiles its CJS build with __esModule = true and exports `load`
+        // as a named export, so `cheerio_1.default` may be undefined. Resolve `load` from
+        // either the default export or the module itself to support both module shapes
+        // (cheerio 1.0.0-rc.x CJS default export and cheerio >= 1.0.0 named exports).
+        const $ = (cheerio_1.default || cheerio_1).load(html);
+        for (let { selector, maxMatches, callback, as, attribute = 'src', cors = 'anonymous' } of this
+            .htmlConfigs) {
+            let matchCount = 0;
+            $(selector).each(function () {
+                if (maxMatches != null && matchCount >= maxMatches)
+                    return;
+                if (this.tagName.toLowerCase() === 'a') {
+                    log_1.default('warning', 'Deep fetching of html links is not supported.');
+                    return;
+                }
+                const $el = $(this);
+                if (callback) {
+                    matchCount++;
+                    callback({ $el, el: this, $, srcURL });
+                }
+                else {
+                    const url = $el.attr(attribute);
+                    if (url) {
+                        matchCount++;
+                        prefetch_1.prefetch(url, as, { cors });
+                    }
+                    else {
+                        log_1.default(`warning: DeepFetchPlugin found an element matching selector ${selector} which did not have a ${attribute} attribute.`);
+                    }
+                }
+            });
+        }
+    }
+    async deepFetchJson(jsonObj, srcURL) {
+        for (let { jsonQuery: query, jsonQueryOptions, maxMatches, as, cors = 'anonymous' } of this
+            .jsonConfigs) {
+            let matchCount = 0;
+            const maybeDeepFetchJsonResult = (result) => {
+                if (maxMatches != null && matchCount >= maxMatches)
+                    return;
+                if (typeof result === 'string') {
+                    matchCount++;
+                    prefetch_1.prefetch(result, as, { cors });
+                }
+                else {
+                    console.warn(`Unable to deep fetch result: ${result} is not a valid URL string`);
+                    return;
+                }
+            };
+            const { value: results } = json_query_1.default(query, {
+                data: jsonObj,
+                ...jsonQueryOptions,
+            });
+            if (Array.isArray(results)) {
+                results.forEach(result => {
+                    maybeDeepFetchJsonResult(result);
+                });
+            }
+            else {
+                maybeDeepFetchJsonResult(results);
+            }
+        }
+    }
+}
+exports.default = DeepFetchPlugin;

package/sw/DevtoolsPlugin.d.ts

@@ -0,0 +1,64 @@
+import { WorkboxPlugin, CachedResponseWillBeUsedCallbackParam, RequestWillFetchCallbackParam, FetchDidSucceedCallbackParam, CacheKeyWillBeUsedCallbackParam } from 'workbox-core/types';
+import { RouteConfig } from './Prefetcher';
+declare type CurrentRequestMetadata = {
+    isPrefetch?: boolean;
+    requestStart?: number;
+};
+export default class DevtoolsPlugin implements WorkboxPlugin {
+    private onResponse;
+    private isEnabledFn;
+    private routeConfig?;
+    private currentRequests;
+    constructor({ onResponse, routeConfig, isEnabledFn, }: {
+        onResponse: Function;
+        isEnabledFn: Function;
+        routeConfig?: RouteConfig;
+    });
+    /**
+     * Stores information about a request to be used by subsequent plugin steps
+     *
+     * IMPORTANT We do **not** use a custom header to store the metadata: a custom header leads
+     * to CORS pre-flight requests when using cache on a different origin, and those would likely
+     * reject our header.
+     * (more info https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#Preflighted_requests)
+     *
+     * Unfortunately, there does not seem to be another way to (or if there is, feel free to fix this):
+     * - store information on the request instance that we be passed along to subsequent steps
+     * - identify a request uniquely with some sort of internal id
+     *
+     * For now, the solution is to use the normalized cache key to identify each request "uniquely",
+     * although that would lead to inconsistent results if a same request happens multiple time concurrently.
+     * It also adds overhead, especially for POST graphql query which serializes the body.
+     *
+     * After CURRENT_REQUEST_MAP_CLEANUP_DELAY, the metadata is cleared to avoid a memory leak.
+     * We don't clear explicitly from cachedResponseWillBeUsed/fetchDidSucceed, as it very complex (impossible?) to do it right:
+     * - we would need a counter on the current requests to be sure to not clear the metadata from concurrent equivalent request
+     * - incrementing/decrementing because we don't know in advance through which
+     *   plugin functions the request will go through, which is the first and which
+     *   is the last. We could make assumptions but that would lead to fragility.
+     */
+    saveRequestMetadata(request: Request, metadata: CurrentRequestMetadata): Promise<void>;
+    getRequestMetadata(request: Request): Promise<CurrentRequestMetadata>;
+    /**
+     * Notes:
+     * - It seems that we cannot add arbitrary attributes to the request object
+     *   so the best we can do is to store request info in a memory hash-map
+     */
+    requestWillFetch({ request }: RequestWillFetchCallbackParam): Promise<Request>;
+    /**
+     * Called when an object is read from or written to the cache.
+     *
+     * Notes:
+     * - It seems that we cannot add arbitrary attributes to the request object
+     *   so the best we can do is to store request info in a memory hash-map
+     *
+     * - In case of cache 'read', we keep track of prefetch request so that we can identify them later
+     *   in `cachedResponseWillBeUsed`, which is called for both hit or miss.
+     *   Why here and not on response? Because in `cachedResponseWillBeUsed` we only get the cache-normalized request
+     *   where layer0_dt_pf query string got removed
+     */
+    cacheKeyWillBeUsed({ request, mode }: CacheKeyWillBeUsedCallbackParam): Promise<Request>;
+    cachedResponseWillBeUsed({ request, cachedResponse: response, }: CachedResponseWillBeUsedCallbackParam): Promise<Response | undefined>;
+    fetchDidSucceed({ request, response }: FetchDidSucceedCallbackParam): Promise<Response>;
+}
+export {};

package/sw/DevtoolsPlugin.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PrefetchPlugin_1 = require("./PrefetchPlugin");
+/**
+ * Time after which we clear a given request metadata from memory.
+ * This must be above usual http timeouts to be sure the request is completed.
+ */
+const CURRENT_REQUEST_MAP_CLEANUP_DELAY = 120000;
+class DevtoolsPlugin {
+    constructor({ onResponse, routeConfig, isEnabledFn, }) {
+        this.currentRequests = {};
+        this.onResponse = onResponse;
+        this.routeConfig = routeConfig;
+        this.isEnabledFn = isEnabledFn;
+    }
+    /**
+     * Stores information about a request to be used by subsequent plugin steps
+     *
+     * IMPORTANT We do **not** use a custom header to store the metadata: a custom header leads
+     * to CORS pre-flight requests when using cache on a different origin, and those would likely
+     * reject our header.
+     * (more info https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#Preflighted_requests)
+     *
+     * Unfortunately, there does not seem to be another way to (or if there is, feel free to fix this):
+     * - store information on the request instance that we be passed along to subsequent steps
+     * - identify a request uniquely with some sort of internal id
+     *
+     * For now, the solution is to use the normalized cache key to identify each request "uniquely",
+     * although that would lead to inconsistent results if a same request happens multiple time concurrently.
+     * It also adds overhead, especially for POST graphql query which serializes the body.
+     *
+     * After CURRENT_REQUEST_MAP_CLEANUP_DELAY, the metadata is cleared to avoid a memory leak.
+     * We don't clear explicitly from cachedResponseWillBeUsed/fetchDidSucceed, as it very complex (impossible?) to do it right:
+     * - we would need a counter on the current requests to be sure to not clear the metadata from concurrent equivalent request
+     * - incrementing/decrementing because we don't know in advance through which
+     *   plugin functions the request will go through, which is the first and which
+     *   is the last. We could make assumptions but that would lead to fragility.
+     */
+    async saveRequestMetadata(request, metadata) {
+        var _a, _b;
+        const normalizedUrl = await PrefetchPlugin_1.normalizeRequestUrlForCache(request);
+        if ((_a = this.currentRequests[normalizedUrl]) === null || _a === void 0 ? void 0 : _a.cleanupTimeout) {
+            clearTimeout(this.currentRequests[normalizedUrl].cleanupTimeout);
+        }
+        this.currentRequests[normalizedUrl] = {
+            metadata: {
+                ...(_b = this.currentRequests[normalizedUrl]) === null || _b === void 0 ? void 0 : _b.metadata,
+                ...metadata,
+            },
+            cleanupTimeout: setTimeout(() => {
+                delete this.currentRequests[normalizedUrl];
+            }, CURRENT_REQUEST_MAP_CLEANUP_DELAY),
+        };
+    }
+    async getRequestMetadata(request) {
+        var _a;
+        const normalizedUrl = await PrefetchPlugin_1.normalizeRequestUrlForCache(request);
+        return ((_a = this.currentRequests[normalizedUrl]) === null || _a === void 0 ? void 0 : _a.metadata) || {};
+    }
+    /**
+     * Notes:
+     * - It seems that we cannot add arbitrary attributes to the request object
+     *   so the best we can do is to store request info in a memory hash-map
+     */
+    async requestWillFetch({ request }) {
+        if (!this.isEnabledFn()) {
+            return request;
+        }
+        await this.saveRequestMetadata(request, { requestStart: Date.now() });
+        return request;
+    }
+    /**
+     * Called when an object is read from or written to the cache.
+     *
+     * Notes:
+     * - It seems that we cannot add arbitrary attributes to the request object
+     *   so the best we can do is to store request info in a memory hash-map
+     *
+     * - In case of cache 'read', we keep track of prefetch request so that we can identify them later
+     *   in `cachedResponseWillBeUsed`, which is called for both hit or miss.
+     *   Why here and not on response? Because in `cachedResponseWillBeUsed` we only get the cache-normalized request
+     *   where layer0_dt_pf query string got removed
+     */
+    async cacheKeyWillBeUsed({ request, mode }) {
+        if (!this.isEnabledFn()) {
+            return request;
+        }
+        if (mode === 'read') {
+            await this.saveRequestMetadata(request, {
+                isPrefetch: PrefetchPlugin_1.isPrefetchRequest(request),
+            });
+        }
+        return request;
+    }
+    async cachedResponseWillBeUsed({ request, cachedResponse: response, }) {
+        if (!this.isEnabledFn()) {
+            return response;
+        }
+        // In case of cache miss
+        if (!response)
+            return response;
+        const { isPrefetch } = await this.getRequestMetadata(request);
+        // TTFB is hard-coded to 0 for cached response
+        this.onResponse({
+            browserCache: 'hit',
+            ttfb: 0,
+            prefetch: isPrefetch,
+            request,
+            response,
+            routeConfig: this.routeConfig,
+        });
+        return response;
+    }
+    async fetchDidSucceed({ request, response }) {
+        if (!this.isEnabledFn()) {
+            return response;
+        }
+        const { requestStart } = await this.getRequestMetadata(request);
+        const ttfb = requestStart && Date.now() - requestStart;
+        this.onResponse({
+            browserCache: 'miss',
+            ttfb,
+            prefetch: PrefetchPlugin_1.isPrefetchRequest(request),
+            request,
+            response,
+            routeConfig: this.routeConfig,
+        });
+        return response;
+    }
+}
+exports.default = DevtoolsPlugin;

package/sw/PrefetchPlugin.d.ts

@@ -0,0 +1,32 @@
+import { WorkboxPlugin, CacheKeyWillBeUsedCallbackParam, CacheWillUpdateCallbackParamParam, RequestWillFetchCallbackParam } from 'workbox-core/types';
+export declare function isPrefetchRequest(request: Request): boolean;
+export declare function normalizeRequestUrlForCache(request: Request, { cacheHost }?: {
+    cacheHost?: URL;
+}): Promise<string>;
+export default class PrefetchPlugin implements WorkboxPlugin {
+    private incrementRead;
+    private incrementWrite;
+    private cacheHost?;
+    private prefetchUpstreamRequests?;
+    private convertToGet?;
+    private method;
+    constructor({ incrementRead, incrementWrite, cacheHost, prefetchUpstreamRequests, convertToGet, method, }: {
+        incrementRead: Function;
+        incrementWrite: Function;
+        cacheHost?: URL;
+        prefetchUpstreamRequests?: boolean;
+        convertToGet?: boolean;
+        method: string;
+    });
+    requestWillFetch({ request }: RequestWillFetchCallbackParam): Promise<Request>;
+    /**
+     * Called when an object is read from or written to the cache.  Here we
+     * compute cache stats and ensure that ?layer0_prefetch is removed from the cache key so
+     * that future requests for prefetched resources will match.
+     */
+    cacheKeyWillBeUsed({ request, mode }: CacheKeyWillBeUsedCallbackParam): Promise<string>;
+    /**
+     * Called when a response is about to be written to the cache.
+     */
+    cacheWillUpdate({ response, request, event }: CacheWillUpdateCallbackParamParam): Promise<Response | null>;
+}

package/sw/PrefetchPlugin.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@layer0/core/constants");
+const constants_2 = require("../constants");
+const constants_3 = require("../constants");
+const log_1 = __importDefault(require("./log"));
+const prefetch_1 = require("./prefetch");
+const getServiceWorkerMaxAge_1 = __importDefault(require("./getServiceWorkerMaxAge"));
+const origin = new URL(self.origin);
+function isPrefetchRequest(request) {
+    return new URL(request.url).searchParams.has(constants_1.DEVTOOLS_PREFETCH_QUERY_PARAM);
+}
+exports.isPrefetchRequest = isPrefetchRequest;
+async function normalizeRequestUrlForCache(request, { cacheHost } = {}) {
+    request = request.clone();
+    const url = new URL(request.url);
+    // When reading/writing cacheHost URLs convert them back to origin
+    if (cacheHost && url.hostname == cacheHost.hostname) {
+        url.host = origin.host;
+        url.protocol = origin.protocol;
+    }
+    const method = request.method.toLowerCase();
+    // For non-GET requests, we need to add the request body to the cache key by appending in to the URL query string
+    if (method !== 'get') {
+        let body = await request.text();
+        const bodyParam = url.searchParams.get(constants_1.POST_BODY_QUERY_PARAM);
+        if (!bodyParam && body) {
+            url.searchParams.set(constants_1.POST_BODY_QUERY_PARAM, encodeURIComponent(body));
+        }
+        // add method to the cache key so that we can cache requests to the same path with different methods
+        url.searchParams.set(constants_1.METHOD_QUERY_PARAM, request.method.toLowerCase());
+    }
+    // remove layer0_prefetch, layer0_dt_pf and layer0_prefetch_ttl query params so that prefetches and real requests
+    // return from the same cache space
+    url.searchParams.delete(constants_1.THROTTLED_QUERY_PARAM);
+    url.searchParams.delete(constants_1.DEVTOOLS_PREFETCH_QUERY_PARAM);
+    url.searchParams.delete(constants_1.PREFETCH_TTL_PARAM);
+    // Decode query parameters both when writing to cache and when reading
+    // from cache. This ensures the cache is used no matter whether the URL
+    // is encoded in either step.
+    decodeQueryParams(url);
+    return url.toString();
+}
+exports.normalizeRequestUrlForCache = normalizeRequestUrlForCache;
+class PrefetchPlugin {
+    constructor({ incrementRead, incrementWrite, cacheHost, prefetchUpstreamRequests, convertToGet, method, }) {
+        this.incrementRead = incrementRead;
+        this.incrementWrite = incrementWrite;
+        this.cacheHost = cacheHost;
+        this.prefetchUpstreamRequests = prefetchUpstreamRequests;
+        this.convertToGet = convertToGet;
+        this.method = method;
+    }
+    async requestWillFetch({ request }) {
+        if (this.convertToGet && this.method !== 'get') {
+            const url = new URL(request.url);
+            // if the request is not a GET, then it's ok to modify the request and bump
+            // the priority since this means it is the real (non-prefetch) request (a
+            // prefetch request will not come in as anything but a GET)
+            const headers = new Headers(request.headers);
+            let body = await request.clone().text();
+            url.searchParams.set(constants_1.POST_BODY_QUERY_PARAM, body);
+            return new Request(url.toString(), {
+                method: 'get',
+                headers,
+                redirect: request.redirect,
+            });
+        }
+        else {
+            // We need to send a clone of the request so that we can read the request body and use
+            // it in the cache key in the write phase of the cacheKeyWillBeUsed method.
+            return request.clone();
+        }
+    }
+    /**
+     * Called when an object is read from or written to the cache.  Here we
+     * compute cache stats and ensure that ?layer0_prefetch is removed from the cache key so
+     * that future requests for prefetched resources will match.
+     */
+    async cacheKeyWillBeUsed({ request, mode }) {
+        if (!isPrefetchRequest(request)) {
+            if (mode === 'read') {
+                this.incrementRead();
+            }
+            else {
+                this.incrementWrite();
+            }
+        }
+        return normalizeRequestUrlForCache(request, { cacheHost: this.cacheHost });
+    }
+    /**
+     * Called when a response is about to be written to the cache.
+     */
+    async cacheWillUpdate({ response, request, event }) {
+        // If prefetchUpstreamRequests is set, we only prefetch the html pages in SPA mode
+        // (e.g Angular) to get the upstream requests response header.  We don't actually want
+        // to serve the html from the cache, so this returns null:
+        if (this.prefetchUpstreamRequests) {
+            const backendRequests = response.headers.get(constants_3.BACKEND_REQUESTS_RESPONSE_HEADER_NAME);
+            if (backendRequests) {
+                const urlsToPrefetch = backendRequests.split(';');
+                urlsToPrefetch.forEach(url => {
+                    if (url)
+                        prefetch_1.prefetch(url);
+                });
+            }
+            return null;
+        }
+        // Get the maxage for storing in the service worker cache from x-sw-cache-control
+        // Only responses from routes with cache({ browser: { serviceWorkerSeconds: (value) }}) will have this.
+        // We should only cache non-prefetch requests if they have browser.serviceWorkerSeconds explicitly set in the router.
+        const maxAge = getServiceWorkerMaxAge_1.default(response);
+        // Service workers do not handle redirects well. If a redirected response is put in the cache,
+        // you'll see this error: "a ServiceWorker passed a redirected Response to FetchEvent.respondWith()
+        // while RedirectMode is not ‘follow"
+        // Returning null here prevents the response from being cached
+        if (response.redirected) {
+            log_1.default(`${response.url} was not added to the cache because it was a redirect.`);
+            return null;
+            // @ts-ignore
+        }
+        else if (isPrefetchRequest(event.request) || maxAge > 0) {
+            log_1.default(`${response.url} was added to the cache with key ${request.url} for ${maxAge || constants_2.DEFAULT_MAX_AGE_SECONDS} seconds.`);
+            const headers = new Headers(response.headers);
+            headers.set('date', new Date().toUTCString());
+            // Change max-age in SW header to custom value from query param
+            // If no param is presented the value will be the same
+            // This value is read by CustomExpirationPlugin to determinate if the response is still "fresh"
+            let swHeaderContent = headers.get(constants_2.SERVICE_WORKER_CACHE_CONTROL);
+            swHeaderContent = swHeaderContent
+                ? swHeaderContent.replace(/max-age=\d+/, `max-age=${maxAge}`)
+                : `max-age=${maxAge}`;
+            headers.set(constants_2.SERVICE_WORKER_CACHE_CONTROL, swHeaderContent);
+            return new Response(response.body, { ...response, headers });
+        }
+        else {
+            // For routes without an explicit serviceWorkerSeconds cache config, we only cache the
+            // response if the request was a prefetch. So in other words, we always write prefetches
+            // to the cache.
+            log_1.default(`${response.url} was not cached because it was not a prefetch.`);
+            return null;
+        }
+    }
+}
+exports.default = PrefetchPlugin;
+/**
+ * Mutates the searchParams object, ensuring that each value is decoded.
+ * @param {URL} url The URL whose params should be decoded
+ */
+function decodeQueryParams(url) {
+    const maybeDecode = (val) => {
+        try {
+            return decodeURIComponent(val);
+        }
+        catch (e) {
+            // it will fail if the string has a % in it that isn't a URL-decoded entity,
+            // so that means the string is already decoded so we can just return the value:
+            return val;
+        }
+    };
+    url.searchParams.forEach((param, key) => {
+        url.searchParams.set(maybeDecode(key), maybeDecode(param));
+    });
+}