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

package/sw/Prefetcher.d.ts

@@ -0,0 +1,209 @@
+import { WorkboxPlugin } from 'workbox-core/types';
+import { HTTPMethod } from '@layer0/core/router/CacheOptions';
+import { CustomCacheKeyConfig } from '@layer0/core/router/CustomCacheKey';
+export declare class Stats {
+    hits: number;
+    misses: number;
+}
+export interface PrefetcherConfig {
+    /**
+     * Workbox plugins to use when handling a cacheable route.
+     */
+    plugins: WorkboxPlugin[];
+    /**
+     * An optional second domain from which to prefetch instead of the origin domain.
+     */
+    cacheHost?: string;
+    /**
+     * The default time to live for prefetched requests that do not specify a `cache({ browser: { serviceWorkerSeconds }})`
+     * config in the router.
+     */
+    defaultMaxAgeSeconds?: number;
+}
+export declare type RouteConfig = {
+    criteriaPath?: string;
+    pattern: string;
+    edgeMaxAgeSeconds?: number;
+    maxAgeSeconds: number;
+    method?: HTTPMethod;
+    isPartialPathRoute: boolean;
+    key?: CustomCacheKeyConfig[];
+    convertToGet?: boolean;
+    prefetchUpstreamRequests?: boolean;
+};
+export declare type DevtoolsRequestMessage = {
+    type: 'layer0-devtools-request';
+    timestamp: number;
+    request: {
+        method: string;
+        url: string;
+        prefetch: boolean;
+    };
+    response: {
+        ttfb: number;
+        status: number;
+        headers: {
+            [key: string]: string;
+        };
+    };
+    browserCache: string;
+    routeConfig?: RouteConfig;
+};
+export declare type DevtoolsAckMessage = {
+    type: 'layer0-devtools-ack';
+    bufferedDevtoolMessages: DevtoolsRequestMessage[];
+};
+/**
+ * Handles prefetching and caching in the the service worker.  Responses
+ * are cached based on the `browser.serviceWorkerSeconds` cache setting in your routes.
+ *
+ * **Example routes.js**
+ *
+ * ```js
+ *  import { Router } from '@layer0/core/router'
+ *
+ *  module.exports = new Router()
+ *    .match('/some/path', ({ cache }) => {
+ *      cache({
+ *        edge: {
+ *          maxAgeSeconds: 60 * 60 * 24 // one day
+ *        },
+ *        browser: {
+ *          serviceWorkerSeconds: 60 * 60 // one hour
+ *        }
+ *      })
+ *    })
+ * ```
+ *
+ * **Example Service Worker**
+ *
+ * ```js
+ *  import { skipWaiting, clientsClaim } from 'workbox-core'
+ *  import { Prefetcher } from '@layer0/prefetch/sw'
+ *  import { precacheAndRoute } from 'workbox-precaching'
+ *
+ *  skipWaiting()
+ *  clientsClaim()
+ *  precacheAndRoute(self.__WB_MANIFEST || [])
+ *
+ *  new Prefetcher().route()
+ * ```
+ */
+export default class Prefetcher {
+    private readonly cacheableResponsePlugin;
+    private readonly config;
+    private readonly cacheHost?;
+    private readonly cacheOrigins;
+    private readonly stats;
+    private devtoolsEnabled;
+    /**
+     * bufferedDevtoolMessages keeps track of the request received in the last BUFFER_DELAY_MS.
+     */
+    private bufferedDevtoolMessages;
+    private clearDevtoolsRequestMessageTimeout?;
+    constructor(config?: PrefetcherConfig);
+    getRouteConfigsFromManifest(): {
+        criteriaPath: any;
+        pattern: any;
+        method: any;
+        maxAgeSeconds: any;
+        edgeMaxAgeSeconds: any;
+        returnsResponse: any;
+        isPartialPathRoute: boolean;
+        key: any;
+        convertToGet: any;
+        prefetchUpstreamRequests: any;
+    }[];
+    /**
+     * Creates a fallback route that ensures that all non-asset requests are handled by the service worker so that
+     * we properly cache (or not cache) based on x-sw-cache-control, and that all network requests are seen by the
+     * Devtools.
+     */
+    private createFallbackRoute;
+    /**
+     * Adds a fetch event listener that serves content from the browser cache when available.  When
+     * a request is not in the cache, it will be fetched from the network and added to the
+     * cache if the route has `browser.serviceWorkerSeconds` defined in its `cache` setting or if the
+     * request is a prefetch.
+     */
+    route(): this;
+    cache(pattern: RegExp, maxAgeSeconds?: number): this;
+    /**
+     * Starts listening for messages from the browser
+     */
+    private initStats;
+    /**
+     * Here we implement a handshake protocol between the devtool window client and the service worker:
+     * 1. Devtools sends the 'layer0-devtools-syn' event and starts listening for 'layer0-devtools-ack' event
+     * 2. Service worker receives the 'layer0-devtools-syn' event and sends the 'layer0-devtools-ack' event
+     *    along with the buffered messages that were received over the last BUFFER_DELAY_MS.
+     *    This is because the window widget takes time to download, load and to start listening from
+     *    Service worker message, while the latter is already receiving http requests.
+     * 3. Devtools receives the 'layer0-devtools-ack' event, looks for its current page html request,
+     *    which corresponds to that tab very first request, and loads requests past that one.
+     * 4. Devtools starts listening for live 'layer0-devtools-request' events
+     *
+     * Notes:
+     * - there is no 1-1 channel between window client and Service Worker, so all opened tab
+     *   will see the 'layer0-devtools-ack' event. Only the ones in handshake phase will handle it.
+     */
+    private initDevtoolsHandshakeListener;
+    /**
+     * Send a postMessage event to all window client.
+     * Notes:
+     * - When used in multi-tabs, each Devtools will show data from all tabs.
+     *   That's a bit buggy but it's the best we can do as it's very hard to establish 1-1 channels
+     *   on ServiceWorker/Client interface, for example the message event from the window does not
+     *   contain the clientId
+     */
+    private sendToAllClients;
+    /**
+     * Adds a message to this.bufferedDevtoolMessages and manages the buffer so that
+     * we don't keep messages more than BUFFER_DELAY_MS.
+     *
+     * In case of inactivity we clear the whole buffer after BUFFER_DELAY_MS, so technically
+     * a message can stay up to 2 x BUFFER_DELAY_MS in the buffer (a bit less than BUFFER_DELAY_MS old
+     * when the latest message arrives and cleared BUFFER_DELAY_MS later)
+     * @param message
+     */
+    private addDevtoolsRequestMessageToBuffer;
+    /**
+     * Remove message that are too old to stay in devtools message buffer
+     */
+    private trimDevtoolsRequestMessageBuffer;
+    /**
+     * If there's a cacheHost configured check whether the pattern to test
+     * against is a partial pathname pattern. If so, check that the origin is
+     * also correct: service worker's own origin or cacheHost origin
+     * @param pattern A route pattern
+     * @param isPartialPathRoute Set to true if the supplied pattern only matches the path, false if it matches the whole URL.
+     * @param options.skipAssets Set to true to ignore request that are not 'document' or 'empty' (ie: audio, font, image, ...)
+     * @return true if the request should be handled by the service worker.
+     */
+    private shouldIntercept;
+    /**
+     * Creates a DevtoolsPlugin object to be added to a caching strategy instance
+     * @param routeConfig The route config for the given route
+     * @private
+     */
+    private createDevtoolsPlugin;
+    /**
+     * Creates a workbox route.
+     * @param routeConfig The route pattern and caching options specified within the route definition
+     */
+    private createRoute;
+    /**
+     * A Read is considered a Hit until a Write happens meaning it was a miss
+     * This is based on the fragile assumption that a cache read *always* triggers a write
+     * in case of cache miss, which is not true if the backend does not respond for example.
+     *
+     * This could be fixed by checking the presence of `response` in `cachedResponseWillBeUsed``
+     * but that leads to other issues as we cannot discard Prefetch requests at that
+     * stage.
+     * We could implement the same Hack-ish solution as in DevtoolsPlugin to work around that,
+     * but those simple stats are probably going away anyway.
+     */
+    private incrementRead;
+    private incrementWrite;
+    private onResponse;
+}

package/sw/Prefetcher.js

@@ -0,0 +1,367 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workbox_routing_1 = require("workbox-routing");
+const workbox_strategies_1 = require("workbox-strategies");
+const CustomExpirationPlugin_1 = require("./CustomExpirationPlugin");
+const workbox_cacheable_response_1 = require("workbox-cacheable-response");
+const constants_1 = require("../constants");
+const log_1 = __importDefault(require("./log"));
+const PrefetchPlugin_1 = __importDefault(require("./PrefetchPlugin"));
+const DevtoolsPlugin_1 = __importDefault(require("./DevtoolsPlugin"));
+const messageBrowser_1 = __importDefault(require("./messageBrowser"));
+const CustomCacheKeyPlugin_1 = __importDefault(require("./CustomCacheKeyPlugin"));
+const constants_2 = require("../constants");
+class Stats {
+    constructor() {
+        this.hits = 0;
+        this.misses = 0;
+    }
+}
+exports.Stats = Stats;
+const BUFFER_DELAY_MS = 10000;
+/**
+ * Handles prefetching and caching in the the service worker.  Responses
+ * are cached based on the `browser.serviceWorkerSeconds` cache setting in your routes.
+ *
+ * **Example routes.js**
+ *
+ * ```js
+ *  import { Router } from '@layer0/core/router'
+ *
+ *  module.exports = new Router()
+ *    .match('/some/path', ({ cache }) => {
+ *      cache({
+ *        edge: {
+ *          maxAgeSeconds: 60 * 60 * 24 // one day
+ *        },
+ *        browser: {
+ *          serviceWorkerSeconds: 60 * 60 // one hour
+ *        }
+ *      })
+ *    })
+ * ```
+ *
+ * **Example Service Worker**
+ *
+ * ```js
+ *  import { skipWaiting, clientsClaim } from 'workbox-core'
+ *  import { Prefetcher } from '@layer0/prefetch/sw'
+ *  import { precacheAndRoute } from 'workbox-precaching'
+ *
+ *  skipWaiting()
+ *  clientsClaim()
+ *  precacheAndRoute(self.__WB_MANIFEST || [])
+ *
+ *  new Prefetcher().route()
+ * ```
+ */
+class Prefetcher {
+    constructor(config = { plugins: [] }) {
+        // For performance reasons, Devtools plugins are disabled until the first
+        // 'layer0-devtools-syn' message is received (ie: a Devtools client is enabled).
+        // But once enabled, they will remain active until the Service Worker is reinstalled
+        this.devtoolsEnabled = false;
+        /**
+         * bufferedDevtoolMessages keeps track of the request received in the last BUFFER_DELAY_MS.
+         */
+        this.bufferedDevtoolMessages = [];
+        this.config = config;
+        let manifestURL = '__layer0__/cache-manifest.js';
+        this.cacheOrigins = [self.origin];
+        if (config.cacheHost) {
+            this.cacheHost = new URL(`https://${config.cacheHost}`);
+            this.cacheOrigins.push(this.cacheHost.origin);
+            manifestURL = this.cacheHost.toString() + manifestURL;
+        }
+        importScripts(manifestURL);
+        this.cacheableResponsePlugin = new workbox_cacheable_response_1.CacheableResponsePlugin({
+            statuses: [200, 301, 302],
+        });
+        this.stats = new Stats();
+        this.initStats();
+        this.initDevtoolsHandshakeListener();
+    }
+    getRouteConfigsFromManifest() {
+        // @ts-ignore
+        const manifest = self.__LAYER0_CACHE_MANIFEST__;
+        return manifest.map(({ criteriaPath, route, cacheOptions, method, returnsResponse }) => {
+            var _a, _b, _c;
+            const maxAgeSeconds = (_a = cacheOptions.browser) === null || _a === void 0 ? void 0 : _a.serviceWorkerSeconds;
+            const edgeMaxAgeSeconds = (_b = cacheOptions.edge) === null || _b === void 0 ? void 0 : _b.maxAgeSeconds;
+            return {
+                criteriaPath,
+                pattern: route,
+                method,
+                maxAgeSeconds,
+                edgeMaxAgeSeconds,
+                returnsResponse,
+                isPartialPathRoute: true,
+                key: cacheOptions.key,
+                convertToGet: (_c = cacheOptions.browser) === null || _c === void 0 ? void 0 : _c.convertToGet,
+                prefetchUpstreamRequests: cacheOptions.prefetchUpstreamRequests,
+            };
+        });
+    }
+    /**
+     * Creates a fallback route that ensures that all non-asset requests are handled by the service worker so that
+     * we properly cache (or not cache) based on x-sw-cache-control, and that all network requests are seen by the
+     * Devtools.
+     */
+    createFallbackRoute() {
+        this.createRoute({
+            pattern: '^.*$',
+            maxAgeSeconds: 0,
+            isPartialPathRoute: true,
+        }, true);
+    }
+    /**
+     * Adds a fetch event listener that serves content from the browser cache when available.  When
+     * a request is not in the cache, it will be fetched from the network and added to the
+     * cache if the route has `browser.serviceWorkerSeconds` defined in its `cache` setting or if the
+     * request is a prefetch.
+     */
+    route() {
+        for (const routeConfig of this.getRouteConfigsFromManifest()) {
+            const { maxAgeSeconds, prefetchUpstreamRequests } = routeConfig;
+            if (
+            // Only listen for browser cached routes:
+            (maxAgeSeconds && maxAgeSeconds > 0) ||
+                // or for routes that return an x-0-upstream-requests header:
+                prefetchUpstreamRequests) {
+                this.createRoute(routeConfig);
+            }
+        }
+        this.createFallbackRoute();
+        return this;
+    }
+    cache(pattern, maxAgeSeconds = 60 * 60 * 24) {
+        this.createRoute({ pattern: pattern.source, maxAgeSeconds, isPartialPathRoute: false });
+        return this;
+    }
+    /**
+     * Starts listening for messages from the browser
+     */
+    initStats() {
+        self.addEventListener('message', (e) => {
+            if (e.data.action === 'get-stats') {
+                messageBrowser_1.default({
+                    type: 'stats',
+                    stats: this.stats,
+                });
+            }
+        });
+    }
+    /**
+     * Here we implement a handshake protocol between the devtool window client and the service worker:
+     * 1. Devtools sends the 'layer0-devtools-syn' event and starts listening for 'layer0-devtools-ack' event
+     * 2. Service worker receives the 'layer0-devtools-syn' event and sends the 'layer0-devtools-ack' event
+     *    along with the buffered messages that were received over the last BUFFER_DELAY_MS.
+     *    This is because the window widget takes time to download, load and to start listening from
+     *    Service worker message, while the latter is already receiving http requests.
+     * 3. Devtools receives the 'layer0-devtools-ack' event, looks for its current page html request,
+     *    which corresponds to that tab very first request, and loads requests past that one.
+     * 4. Devtools starts listening for live 'layer0-devtools-request' events
+     *
+     * Notes:
+     * - there is no 1-1 channel between window client and Service Worker, so all opened tab
+     *   will see the 'layer0-devtools-ack' event. Only the ones in handshake phase will handle it.
+     */
+    initDevtoolsHandshakeListener() {
+        self.addEventListener('message', async (e) => {
+            if (e.data.action === 'layer0-devtools-install') {
+                if (!this.devtoolsEnabled) {
+                    this.devtoolsEnabled = true;
+                    // Devtools plugin just got initialized so we missed
+                    // a few queries. We send a message so that the browser
+                    // refreshes its page.
+                    this.sendToAllClients({
+                        type: 'layer0-devtools-ack-installed',
+                    });
+                }
+            }
+            if (e.data.action === 'layer0-devtools-syn') {
+                if (this.devtoolsEnabled) {
+                    const ackMessage = {
+                        type: 'layer0-devtools-ack',
+                        bufferedDevtoolMessages: this.bufferedDevtoolMessages,
+                    };
+                    this.sendToAllClients(ackMessage);
+                }
+            }
+            if (e.data.action === 'layer0-devtools-clear-cache') {
+                caches.keys().then(cacheNames => cacheNames.forEach(name => caches.delete(name)));
+            }
+        });
+    }
+    /**
+     * Send a postMessage event to all window client.
+     * Notes:
+     * - When used in multi-tabs, each Devtools will show data from all tabs.
+     *   That's a bit buggy but it's the best we can do as it's very hard to establish 1-1 channels
+     *   on ServiceWorker/Client interface, for example the message event from the window does not
+     *   contain the clientId
+     */
+    async sendToAllClients(data) {
+        messageBrowser_1.default(data, { broadcast: true });
+    }
+    /**
+     * Adds a message to this.bufferedDevtoolMessages and manages the buffer so that
+     * we don't keep messages more than BUFFER_DELAY_MS.
+     *
+     * In case of inactivity we clear the whole buffer after BUFFER_DELAY_MS, so technically
+     * a message can stay up to 2 x BUFFER_DELAY_MS in the buffer (a bit less than BUFFER_DELAY_MS old
+     * when the latest message arrives and cleared BUFFER_DELAY_MS later)
+     * @param message
+     */
+    addDevtoolsRequestMessageToBuffer(message) {
+        this.bufferedDevtoolMessages.push(message);
+        this.trimDevtoolsRequestMessageBuffer();
+        if (this.clearDevtoolsRequestMessageTimeout) {
+            clearTimeout(this.clearDevtoolsRequestMessageTimeout);
+        }
+        // If no additional request for BUFFER_DELAY_MS, we clear the buffer after that
+        this.clearDevtoolsRequestMessageTimeout = setTimeout(() => {
+            this.bufferedDevtoolMessages = [];
+        }, BUFFER_DELAY_MS);
+    }
+    /**
+     * Remove message that are too old to stay in devtools message buffer
+     */
+    trimDevtoolsRequestMessageBuffer() {
+        let sliceIndex = 0;
+        const sliceMinimumTimestamp = Date.now() - BUFFER_DELAY_MS;
+        while (this.bufferedDevtoolMessages[sliceIndex] &&
+            this.bufferedDevtoolMessages[sliceIndex].timestamp < sliceMinimumTimestamp) {
+            sliceIndex++;
+        }
+        this.bufferedDevtoolMessages = this.bufferedDevtoolMessages.slice(sliceIndex);
+    }
+    /**
+     * If there's a cacheHost configured check whether the pattern to test
+     * against is a partial pathname pattern. If so, check that the origin is
+     * also correct: service worker's own origin or cacheHost origin
+     * @param pattern A route pattern
+     * @param isPartialPathRoute Set to true if the supplied pattern only matches the path, false if it matches the whole URL.
+     * @param options.skipAssets Set to true to ignore request that are not 'document' or 'empty' (ie: audio, font, image, ...)
+     * @return true if the request should be handled by the service worker.
+     */
+    shouldIntercept(pattern, isPartialPathRoute, skipAssets) {
+        return ({ url, request }) => {
+            if (skipAssets &&
+                request.destination &&
+                !['document', 'empty'].includes(request.destination)) {
+                return false;
+            }
+            if (isPartialPathRoute) {
+                return this.cacheOrigins.includes(url.origin) && pattern.test(url.pathname);
+            }
+            else {
+                return pattern.test(url.toString());
+            }
+        };
+    }
+    /**
+     * Creates a DevtoolsPlugin object to be added to a caching strategy instance
+     * @param routeConfig The route config for the given route
+     * @private
+     */
+    createDevtoolsPlugin(routeConfig) {
+        return new DevtoolsPlugin_1.default({
+            onResponse: this.onResponse.bind(this),
+            isEnabledFn: () => this.devtoolsEnabled,
+            routeConfig,
+        });
+    }
+    /**
+     * Creates a workbox route.
+     * @param routeConfig The route pattern and caching options specified within the route definition
+     */
+    createRoute(routeConfig, skipAssets = false) {
+        const { pattern, method: optMethod, maxAgeSeconds, isPartialPathRoute, key, convertToGet, prefetchUpstreamRequests, } = routeConfig;
+        const method = (optMethod || 'get').toLowerCase();
+        const patternRegexp = new RegExp(pattern, 'i');
+        log_1.default(`[route] ${method} ${pattern}, maxAgeSeconds: ${maxAgeSeconds}`);
+        // all routes must have a GET route registered, so Workbox can properly look
+        // it up when running workbox-routing/Router#findMatchingRoute:
+        if (method !== 'get') {
+            this.createRoute({ ...routeConfig, method: 'get' }, skipAssets);
+        }
+        const prefetchPlugin = new PrefetchPlugin_1.default({
+            incrementRead: this.incrementRead.bind(this),
+            incrementWrite: this.incrementWrite.bind(this),
+            cacheHost: this.cacheHost,
+            prefetchUpstreamRequests,
+            convertToGet,
+            method,
+        });
+        const ttl = maxAgeSeconds || this.config.defaultMaxAgeSeconds || constants_2.DEFAULT_MAX_AGE_SECONDS;
+        const plugins = [
+            this.cacheableResponsePlugin,
+            new CustomExpirationPlugin_1.CustomExpirationPlugin({ maxAgeSeconds: ttl }),
+            // DevtoolPlugin needs to be injected before PrefetchPlugin as this later
+            // changes request url to normalise the cache key
+            this.createDevtoolsPlugin(routeConfig),
+            prefetchPlugin,
+            ...(this.config.plugins || []),
+        ];
+        if (key) {
+            plugins.push(new CustomCacheKeyPlugin_1.default(patternRegexp, key));
+        }
+        workbox_routing_1.registerRoute(this.shouldIntercept(patternRegexp, isPartialPathRoute, skipAssets), new workbox_strategies_1.CacheFirst({
+            cacheName: constants_1.CACHE_NAME,
+            matchOptions: {
+                ignoreVary: true,
+            },
+            plugins,
+        }), 
+        // @ts-ignore
+        method.toUpperCase() // HTTPMethods map directly from @layer0/core lowercase => @workbox uppercase
+        );
+    }
+    /**
+     * A Read is considered a Hit until a Write happens meaning it was a miss
+     * This is based on the fragile assumption that a cache read *always* triggers a write
+     * in case of cache miss, which is not true if the backend does not respond for example.
+     *
+     * This could be fixed by checking the presence of `response` in `cachedResponseWillBeUsed``
+     * but that leads to other issues as we cannot discard Prefetch requests at that
+     * stage.
+     * We could implement the same Hack-ish solution as in DevtoolsPlugin to work around that,
+     * but those simple stats are probably going away anyway.
+     */
+    incrementRead() {
+        this.stats.hits++;
+    }
+    incrementWrite() {
+        this.stats.misses++;
+        this.stats.hits--;
+    }
+    async onResponse({ request, response, ttfb, prefetch, browserCache, routeConfig, }) {
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        const devToolMessage = {
+            type: 'layer0-devtools-request',
+            timestamp: Date.now(),
+            request: {
+                method: request.method,
+                url: request.url,
+                prefetch,
+            },
+            response: {
+                ttfb,
+                status: response.status,
+                headers,
+            },
+            browserCache,
+            routeConfig,
+        };
+        this.sendToAllClients(devToolMessage);
+        this.addDevtoolsRequestMessageToBuffer(devToolMessage);
+    }
+}
+exports.default = Prefetcher;

package/sw/getServiceWorkerMaxAge.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns the max age in seconds specified in the x-sw-cache-control response header.
+ * If no header or max-age value is present, returns null
+ * @param response
+ * @returns
+ */
+export declare function getServiceWorkerMaxAgeFromHeader(response: Response): number | null;
+/**
+ * Returns the max age in seconds specified in custom query param.
+ * If no custom param is present, returns null
+ * @param response
+ * @returns
+ */
+export declare function getServiceWorkerMaxAgeFromParam(response: Response): number | null;
+/**
+ * Returns the max age in seconds specified in custom query param.
+ * If no custom param is present, returns the max age in seconds specified in the x-sw-cache-control response header.
+ * If no header or max-age value is present, this function returns 0.
+ * @param response
+ * @returns
+ */
+export default function getServiceWorkerMaxAge(response: Response): number;

package/sw/getServiceWorkerMaxAge.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const constants_2 = require("@layer0/core/constants");
+/**
+ * Returns the max age in seconds specified in the x-sw-cache-control response header.
+ * If no header or max-age value is present, returns null
+ * @param response
+ * @returns
+ */
+function getServiceWorkerMaxAgeFromHeader(response) {
+    const header = response.headers.get(constants_1.SERVICE_WORKER_CACHE_CONTROL);
+    if (header) {
+        for (let pair of header.split(',')) {
+            const [key, value] = pair.split('=');
+            if (key === 'max-age') {
+                return parseInt(value);
+            }
+        }
+    }
+    return null;
+}
+exports.getServiceWorkerMaxAgeFromHeader = getServiceWorkerMaxAgeFromHeader;
+/**
+ * Returns the max age in seconds specified in custom query param.
+ * If no custom param is present, returns null
+ * @param response
+ * @returns
+ */
+function getServiceWorkerMaxAgeFromParam(response) {
+    var _a;
+    if (((_a = response === null || response === void 0 ? void 0 : response.url) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        const customMaxAgeSeconds = new URL(response.url).searchParams.get(constants_2.PREFETCH_TTL_PARAM);
+        if (customMaxAgeSeconds) {
+            return parseInt(customMaxAgeSeconds);
+        }
+    }
+    return null;
+}
+exports.getServiceWorkerMaxAgeFromParam = getServiceWorkerMaxAgeFromParam;
+/**
+ * Returns the max age in seconds specified in custom query param.
+ * If no custom param is present, returns the max age in seconds specified in the x-sw-cache-control response header.
+ * If no header or max-age value is present, this function returns 0.
+ * @param response
+ * @returns
+ */
+function getServiceWorkerMaxAge(response) {
+    return (getServiceWorkerMaxAgeFromParam(response) || getServiceWorkerMaxAgeFromHeader(response) || 0);
+}
+exports.default = getServiceWorkerMaxAge;

package/sw/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Prefetcher } from './Prefetcher';
+export { prefetch } from './prefetch';

package/sw/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Prefetcher_1 = require("./Prefetcher");
+exports.Prefetcher = Prefetcher_1.default;
+var prefetch_1 = require("./prefetch");
+exports.prefetch = prefetch_1.prefetch;

package/sw/log.d.ts

@@ -0,0 +1 @@
+export default function log(...message: any[]): void;

package/sw/log.js

@@ -0,0 +1,9 @@
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+function log(...message) {
+    if (process.env.NODE_ENV !== 'production') {
+        console.log('%c@layer0/prefetch', 'background: #43a047; color: #ffffff; font-weight:bold; padding: 3px 5px; border-radius: 5px', ...message);
+    }
+}
+exports.default = log;

package/sw/messageBrowser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sends a message to the last focused browser window.
+ * @param message
+ */
+export default function messageBrowser(message: any, { broadcast }?: {
+    broadcast?: boolean;
+}): any;