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

package/sw/messageBrowser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Sends a message to the last focused browser window.
+ * @param message
+ */
+function messageBrowser(message, { broadcast = false } = {}) {
+    // @ts-ignore
+    return self.clients.matchAll({ type: 'window' }).then((clients) => {
+        let targetClients = clients;
+        if (!broadcast && clients.length) {
+            // clients array is ordered by last focused
+            targetClients = [clients[0]];
+        }
+        targetClients.forEach(client => client.postMessage(message));
+    });
+}
+exports.default = messageBrowser;

package/sw/prefetch.d.ts

@@ -0,0 +1,9 @@
+import { PrefetchConfiguration, PrefetchAs } from '../window/prefetch';
+/**
+ * Prefetches an asset.
+ * @param url The asset URL
+ * @param as The value for the link 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".
+ */
+export declare function prefetch(url: string, as?: PrefetchAs, options?: PrefetchConfiguration): any;

package/sw/prefetch.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const messageBrowser_1 = __importDefault(require("./messageBrowser"));
+/**
+ * Prefetches an asset.
+ * @param url The asset URL
+ * @param as The value for the link 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".
+ */
+function prefetch(url, as = 'fetch', options = { cors: 'anonymous' }) {
+    return messageBrowser_1.default({ action: 'prefetch', url, as, options });
+}
+exports.prefetch = prefetch;

package/window/InstallOptions.d.ts

@@ -0,0 +1,77 @@
+import PrefetchOptions from './PrefetchOptions';
+export interface PrefetchWatcherConfig {
+    /**
+     * The CSS selector to use when finding elements whose src or href should be deep fetched
+     */
+    selector: string;
+    /**
+     * A callback to allow using attributes of the discovered element to be used to prefetch
+     * resources as needed.
+     */
+    callback: (param: HTMLElement) => void;
+}
+export interface ObserveOptionsConfig {
+    /**
+     * `true` to disable observation of all DOM nodes for prefetching
+     */
+    disabled?: boolean;
+    /**
+     * `true` to observe changes to DOM attributes that may trigger the need to prefetch
+     * resources.
+     */
+    attributes?: boolean;
+}
+/**
+ * Options for the `install` function.
+ */
+export default interface InstallOptions extends PrefetchOptions {
+    /**
+     * Any link whose href matches one of these patterns will have its
+     * href prefetched when the link becomes visible
+     */
+    prefetchPatterns?: RegExp[];
+    /**
+     * URLs to prefetch immediately
+     */
+    prefetchURLs?: string[];
+    /**
+     * The Layer0 hostname from which to prefetch cached content.  This is only used when the origin
+     * site is not served from Layer0.
+     */
+    cacheHost?: string;
+    /**
+     * The URL path on which the service worker is served.
+     */
+    serviceWorkerPath?: string;
+    /**
+     * A list of config objects with selectors to watch for. When elements matching the
+     * selector are found, the specified callback is called.
+     *
+     * **Example**
+     *
+     * install({
+     *   watch: [{
+     *     selector: 'div.product-tile',
+     *     callback: el => {
+     *       const productId = el.getAttribute('data-product-id')
+     *       const catId = document.getElementById('cat-listing').getAttribute('data-category-id')
+     *       prefetch(`/api/${catId}/${productId}`, 'fetch')
+     *     }
+     *   }]
+     * })
+     */
+    watch?: PrefetchWatcherConfig[];
+    /**
+     * The prefetcher observes the DOM for new elements that are added for potential
+     * prefetching. Observations are made to the document's child nodes and subtree.
+     * Attributes changes are not observed by default, but can be enabled with
+     * `ObserveOptionsConfig.attributes`. Additionally, you can disable the observer
+     * by setting `ObserveOptionsConfig.disabled` to `true`.
+     */
+    observe?: ObserveOptionsConfig;
+    /**
+     * The probability that a prefetch request will be relayed to the origin even
+     * if a response is not in the cache.  Defaults to 0. This should be a number between 0 and 1.
+     */
+    forcePrefetchRatio?: number;
+}

package/window/InstallOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/window/PrefetchOptions.d.ts

@@ -0,0 +1,19 @@
+export default interface PrefetchOptions {
+    /**
+     * Set to true to include pages not in the edge cache when prefetching. By default
+     * pages will only be prefetched if they are available in Layer0 edge cache. Warning:
+     * setting this to `true` will cause a significant increase in traffic to the origin server.
+     */
+    includeCacheMisses: boolean;
+    spaRoutes: RegExp[];
+    /**
+     * The Layer0 hostname from which to prefetch cached content.  This is only used when the origin
+     * site is not served from Layer0.
+     */
+    cacheHost?: string;
+    /**
+     * The probability that a prefetch request will be relayed to the origin even
+     * if a response is not in the cache.  Defaults to 0. This should be a number between 0 and 1.
+     */
+    forcePrefetchRatio?: number;
+}

package/window/PrefetchOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/window/entry.d.ts

@@ -0,0 +1 @@
+export {};

package/window/entry.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const install_1 = __importDefault(require("./install"));
+// @ts-ignore prefetchOptions is not a standard property, but one we ask the user to expose
+install_1.default(window.prefetchOptions);

package/window/getHostName.d.ts

@@ -0,0 +1 @@
+export default function getHostName(): string;

package/window/getHostName.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getHostName() {
+    return window.location.hostname;
+}
+exports.default = getHostName;

package/window/getUserAgent.d.ts

@@ -0,0 +1 @@
+export default function getUserAgent(): string;

package/window/getUserAgent.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getUserAgent() {
+    return navigator.userAgent;
+}
+exports.default = getUserAgent;

package/window/index.d.ts

@@ -0,0 +1,3 @@
+export { prefetch } from './prefetch';
+export { default as waitForServiceWorker } from './waitForServiceWorker';
+export { default as install } from './install';

package/window/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var prefetch_1 = require("./prefetch");
+exports.prefetch = prefetch_1.prefetch;
+var waitForServiceWorker_1 = require("./waitForServiceWorker");
+exports.waitForServiceWorker = waitForServiceWorker_1.default;
+var install_1 = require("./install");
+exports.install = install_1.default;

package/window/install.d.ts

@@ -0,0 +1,13 @@
+import InstallOptions from './InstallOptions';
+/**
+ * Installs the service worker, prefetches any URLs specified in `prefetchURLs` and watches
+ * all links whose `href` attribute matches one of the specified `prefetchPatterns`.  When
+ * a matching link is visible in the viewport, the destination URL will be prefetched and
+ * added to the cache.
+ * @param options
+ */
+export default function install(options?: Partial<InstallOptions>): Promise<void>;
+/**
+ * Adds event listener for messages sent by service-worker if it wasn't added already
+ */
+export declare function listenForSwMessages(): void;

package/window/install.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prefetch_1 = require("./prefetch");
+const registerServiceWorker_1 = require("./registerServiceWorker");
+const watchLinks_1 = __importDefault(require("./watchLinks"));
+const loadManifest_1 = __importDefault(require("./loadManifest"));
+const watchElements_1 = __importDefault(require("./watchElements"));
+const CacheManifest_1 = __importDefault(require("@layer0/core/router/CacheManifest"));
+const defaults = {
+    includeCacheMisses: false,
+    cacheHost: undefined,
+    forcePrefetchRatio: 0,
+};
+let swEventListenerAdded = false;
+/**
+ * Installs the service worker, prefetches any URLs specified in `prefetchURLs` and watches
+ * all links whose `href` attribute matches one of the specified `prefetchPatterns`.  When
+ * a matching link is visible in the viewport, the destination URL will be prefetched and
+ * added to the cache.
+ * @param options
+ */
+async function install(options) {
+    options = { ...defaults, ...options };
+    const spaRoutes = [];
+    const { serviceWorker } = navigator;
+    if (typeof serviceWorker === 'undefined') {
+        return;
+    }
+    const { prefetchURLs, watch, serviceWorkerPath = '/service-worker.js', observe } = options;
+    await loadManifest_1.default({ cacheHost: options.cacheHost });
+    const cacheManifest = CacheManifest_1.default.fromEntries(
+    // @ts-ignore
+    window.__LAYER0_CACHE_MANIFEST__ || []);
+    const prefetchPatterns = [...(options.prefetchPatterns || [])].map(routeRegex => ({
+        criteriaPath: routeRegex.source,
+        route: routeRegex.source,
+        cacheOptions: { edge: { maxAgeSeconds: 1 }, browser: { serviceWorkerSeconds: 1 } },
+        returnsResponse: false,
+    }));
+    spaRoutes.push(...cacheManifest.spaRoutes);
+    prefetch_1.configure({ ...options, spaRoutes });
+    // install the service worker
+    registerServiceWorker_1.registerServiceWorker(serviceWorkerPath);
+    // prefetch requested URLs
+    prefetchURLs === null || prefetchURLs === void 0 ? void 0 : prefetchURLs.forEach(url => prefetch_1.prefetch(url));
+    // watch links currently in the DOM as well as any links that are added in the future
+    watchLinks_1.default(cacheManifest, observe); // observer options only needs supplied to the first call since this creates the MutationObserver
+    watchLinks_1.default(CacheManifest_1.default.fromEntries(prefetchPatterns));
+    watchElements_1.default(watch);
+    listenForSwMessages();
+}
+exports.default = install;
+/**
+ * Adds event listener for messages sent by service-worker if it wasn't added already
+ */
+function listenForSwMessages() {
+    const { serviceWorker } = navigator;
+    // In case service-worker was not registered or eventListener for messages was already added, do nothing
+    if (typeof serviceWorker === 'undefined' || swEventListenerAdded) {
+        return;
+    }
+    serviceWorker.addEventListener('message', event => {
+        if (event.data.action === 'prefetch') {
+            prefetch_1.prefetch(event.data.url, event.data.as, event.data.options);
+        }
+    });
+    swEventListenerAdded = true;
+}
+exports.listenForSwMessages = listenForSwMessages;

package/window/isSafari.d.ts

@@ -0,0 +1,6 @@
+export declare function isSafari(): boolean;
+/**
+ * Returns true if this is a private window in safari
+ * From https://stackoverflow.com/questions/12821127/how-to-check-if-ios-is-using-private-browsing/47642304#47642304
+ */
+export declare function isSafariPrivateWindow(): boolean;

package/window/isSafari.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getUserAgent_1 = __importDefault(require("./getUserAgent"));
+let _isSafari = null;
+function isSafari() {
+    if (_isSafari == null) {
+        _isSafari = /^((?!chrome|android).)*safari/i.test(getUserAgent_1.default());
+    }
+    return _isSafari;
+}
+exports.isSafari = isSafari;
+/**
+ * Returns true if this is a private window in safari
+ * From https://stackoverflow.com/questions/12821127/how-to-check-if-ios-is-using-private-browsing/47642304#47642304
+ */
+function isSafariPrivateWindow() {
+    if (!isSafari())
+        return false;
+    try {
+        // @ts-ignore
+        window.openDatabase(null, null, null, null);
+        return false;
+    }
+    catch (_) {
+        return true;
+    }
+}
+exports.isSafariPrivateWindow = isSafariPrivateWindow;

package/window/loadManifest.d.ts

@@ -0,0 +1,3 @@
+export default function loadManifest(options: {
+    cacheHost?: string;
+}): Promise<unknown>;

package/window/loadManifest.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function loadManifest(options) {
+    return new Promise(resolve => {
+        let script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.async = true;
+        script.onload = resolve;
+        let manifestURL = '__layer0__/cache-manifest.js';
+        if (options === null || options === void 0 ? void 0 : options.cacheHost) {
+            manifestURL = new URL(`https://${options.cacheHost}`).toString() + manifestURL;
+            script.src = manifestURL;
+        }
+        else {
+            script.src = '/' + manifestURL;
+        }
+        document.getElementsByTagName('head')[0].appendChild(script);
+    });
+}
+exports.default = loadManifest;

package/window/prefetch.d.ts

@@ -0,0 +1,71 @@
+import PrefetchOptions from './PrefetchOptions';
+import { HTTPMethod } from '@layer0/core/router/CacheOptions';
+/**
+ * Object with configuration for prefetch function
+ */
+export declare type PrefetchConfiguration = {
+    /**
+     * Sets the body of prefetch request.
+     */
+    body?: string;
+    /**
+     * Allows to change default HTTP GET method of prefetch request.
+     */
+    method?: HTTPMethod;
+    /**
+     * Allows to change default CORS policy of prefetch request.
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-crossorigin
+     */
+    cors?: false | 'anonymous' | 'use-credentials';
+    /**
+     * Allows to override the default Prefetch TTL or serviceWorkerSeconds value defined in routes.js.
+     * The number represents the seconds for how long the item will be stored in the browser cache.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * Allows to override the default includeCacheMisses value from install() function.
+     * Set to true to send all requests to origin even when they are not in the Edge cache.
+     */
+    includeCacheMisses?: boolean;
+    /**
+     * Allows to override the default forcePrefetchRatio value from install() function.
+     * The number represents ratio of requests that are sent to origin even when they are not in the Edge cache.
+     * Possible values: Number between 0 and 1. Number 0 is equal to 0% requests and 1 to 100% requests sent to origin.
+     */
+    forcePrefetchRatio?: number;
+};
+/**
+ * Possible values for the "as" param of prefetch function
+ * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+ */
+export declare type PrefetchAs = 'audio' | 'document' | 'embed' | 'fetch' | 'font' | 'image' | 'object' | 'script' | 'style' | 'track' | 'video' | 'worker' | undefined;
+/**
+ * Configures prefetching options
+ * @param opts
+ */
+export declare function configure(opts: Partial<PrefetchOptions>): void;
+/**
+ * Prefetches and caches the specified URL.
+ *
+ * **Example**
+ *
+ * ```js
+ * import { prefetch } from '@layer0/prefetch/window
+ *
+ * // Prefetches the URL with default PrefetchConfiguration
+ * prefetch('/some/url')
+ *
+ * // Prefetches the URL as fetch with custom PrefetchConfiguration
+ * prefetch('/some/url', "fetch", {
+ *     // Overrides the default Prefetch TTL or serviceWorkerSeconds value defined in routes.js
+ *     maxAgeSeconds: 300, // 5 minutes
+ *
+ *     // Allows to override the default forcePrefetchRatio value from install() function
+ *     includeCacheMisses: true
+ * });
+ * ```
+ * @param {String} url The URL to prefetch
+ * @param {String} as Value to use for the "as" attribute of the <link> tag
+ * @param {PrefetchConfiguration} config Options to use for the prefetch
+ */
+export declare function prefetch(url: string, as?: PrefetchAs, config?: PrefetchConfiguration): Promise<void>;

package/window/prefetch.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const waitForServiceWorker_1 = __importDefault(require("./waitForServiceWorker"));
+const constants_1 = require("@layer0/core/constants");
+const getHostName_1 = __importDefault(require("./getHostName"));
+const install_1 = require("./install");
+// According to Fastly, 2^13 (8192) is the max number of bytes allowed for a URL:
+const MAX_URL_BYTES = 2 ** 13;
+const prefetched = new Set();
+const defaults = {
+    includeCacheMisses: false,
+    cacheHost: undefined,
+    spaRoutes: [],
+    forcePrefetchRatio: 0,
+};
+let options = defaults;
+/**
+ * Configures prefetching options
+ * @param opts
+ */
+function configure(opts) {
+    options = { ...defaults, ...opts };
+}
+exports.configure = configure;
+/**
+ * Prefetches and caches the specified URL.
+ *
+ * **Example**
+ *
+ * ```js
+ * import { prefetch } from '@layer0/prefetch/window
+ *
+ * // Prefetches the URL with default PrefetchConfiguration
+ * prefetch('/some/url')
+ *
+ * // Prefetches the URL as fetch with custom PrefetchConfiguration
+ * prefetch('/some/url', "fetch", {
+ *     // Overrides the default Prefetch TTL or serviceWorkerSeconds value defined in routes.js
+ *     maxAgeSeconds: 300, // 5 minutes
+ *
+ *     // Allows to override the default forcePrefetchRatio value from install() function
+ *     includeCacheMisses: true
+ * });
+ * ```
+ * @param {String} url The URL to prefetch
+ * @param {String} as Value to use for the "as" attribute of the <link> tag
+ * @param {PrefetchConfiguration} config Options to use for the prefetch
+ */
+async function prefetch(url, as = 'fetch', config = {
+    cors: 'anonymous',
+    includeCacheMisses: options.includeCacheMisses,
+    forcePrefetchRatio: options.forcePrefetchRatio,
+}) {
+    var _a, _b, _c, _d, _e;
+    // In case service-worker was not registered by our install() function,
+    // this function will add eventListener manually
+    install_1.listenForSwMessages();
+    if (typeof url === 'undefined') {
+        console.error(`prefetch() called with an undefined url`);
+        return;
+    }
+    // Set values from global config if any of config options is missing
+    // Set default value if global config value is undefined
+    config.cors = (_a = config.cors) !== null && _a !== void 0 ? _a : 'anonymous';
+    config.includeCacheMisses = (_c = (_b = config.includeCacheMisses) !== null && _b !== void 0 ? _b : options.includeCacheMisses) !== null && _c !== void 0 ? _c : false;
+    config.forcePrefetchRatio = (_e = (_d = config.forcePrefetchRatio) !== null && _d !== void 0 ? _d : options.forcePrefetchRatio) !== null && _e !== void 0 ? _e : 0;
+    // @ts-ignore
+    if (config.headers) {
+        console.warn('The prefetch `headers` configuration option has been removed as it is not compatible with the service-worker prefetch mechanism. Please set headers in your routes.js file with `setRequestHeader` if required.');
+    }
+    const cacheUrl = modifyUrl(url, config);
+    if (typeof TextEncoder !== 'undefined' &&
+        new TextEncoder().encode(cacheUrl).length > MAX_URL_BYTES) {
+        console.warn(`URL is too many characters to prefetch and cache: ${cacheUrl}`);
+        return;
+    }
+    // This causes all the prefetch request to be called even though they are already cached in SW,
+    // but they should be served from SW cache anyway. The impact to the performance with hmtl DOM changes is minimal,
+    // tested with 1k prefetch calls.
+    if (prefetched.has(cacheUrl)) {
+        let prefetchLink = document.querySelector(`link[href='${cacheUrl}']`);
+        prefetchLink === null || prefetchLink === void 0 ? void 0 : prefetchLink.remove();
+    }
+    prefetched.add(cacheUrl);
+    await waitForServiceWorker_1.default();
+    const link = document.createElement('link');
+    const { relList } = link;
+    link.setAttribute('href', cacheUrl);
+    if (config.cors) {
+        link.setAttribute('crossorigin', config.cors);
+    }
+    link.setAttribute('rel', relList.supports('preload') && /* istanbul ignore next */ !relList.supports('prefetch')
+        ? /* istanbul ignore next */ 'preload'
+        : 'prefetch' // Safari does not support prefetch so we use preload instead
+    );
+    link.setAttribute('as', as);
+    document.head.append(link);
+}
+exports.prefetch = prefetch;
+function modifyUrl(url, config) {
+    const { body, method, maxAgeSeconds } = config;
+    const parsed = new URL(url, window.origin);
+    maybeAddHeadParam(parsed);
+    if (parsed.hostname === getHostName_1.default()) {
+        // If we are prefetching from Layer0 sidecar, rewrite the URL to use the sidecar's domain name
+        if (options.cacheHost) {
+            const cacheHostUrl = new URL(`https://${options.cacheHost}`);
+            parsed.hostname = cacheHostUrl.hostname;
+            parsed.protocol = cacheHostUrl.protocol;
+            parsed.port = cacheHostUrl.port;
+        }
+        appendSearchParam(parsed, constants_1.DEVTOOLS_PREFETCH_QUERY_PARAM, '1');
+        maybeAddThrottleParam(parsed, config);
+    }
+    if (body) {
+        appendSearchParam(parsed, constants_1.POST_BODY_QUERY_PARAM, body);
+    }
+    if (method) {
+        appendSearchParam(parsed, constants_1.METHOD_QUERY_PARAM, method);
+    }
+    if (maxAgeSeconds && maxAgeSeconds > 0) {
+        appendSearchParam(parsed, constants_1.PREFETCH_TTL_PARAM, maxAgeSeconds.toString());
+    }
+    return parsed.toString();
+}
+function appendSearchParam(url, name, value) {
+    const separator = url.search.length ? '&' : '?';
+    url.search += `${separator}${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+}
+/**
+ * Adds the query param that indicates to the service worker that a request may be throttled
+ * @param url
+ * @param config
+ */
+function maybeAddThrottleParam(url, config) {
+    if (!config.includeCacheMisses && shouldAcceptThrottling(config)) {
+        appendSearchParam(url, constants_1.THROTTLED_QUERY_PARAM, '1');
+    }
+}
+/**
+ * Returns true if the next prefetch request should only be served from the edge cache.
+ * This is done by comparing a random number between 0 and 1 to options.forcePrefetchRatio
+ */
+function shouldAcceptThrottling(config) {
+    return !config.forcePrefetchRatio || Math.random() > config.forcePrefetchRatio;
+}
+function maybeAddHeadParam(url) {
+    options.spaRoutes.some(routePattern => {
+        if (routePattern.test(url.pathname)) {
+            appendSearchParam(url, constants_1.HEAD_QUERY_PARAM, '1');
+            return true;
+        }
+    });
+}

package/window/prefetchWhenVisible.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Prefetches a link's href when it is visible in the viewport
+ * @param {HTMLElement} el The link element
+ */
+export default function prefetchWhenVisible(el: HTMLElement): void;

package/window/prefetchWhenVisible.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prefetch_1 = require("./prefetch");
+const runWhenVisible_1 = __importDefault(require("./runWhenVisible"));
+/**
+ * Prefetches a link's href when it is visible in the viewport
+ * @param {HTMLElement} el The link element
+ */
+function prefetchWhenVisible(el) {
+    runWhenVisible_1.default(el, innerEl => {
+        const url = innerEl.getAttribute('href');
+        if (url) {
+            prefetch_1.prefetch(url);
+        }
+    });
+}
+exports.default = prefetchWhenVisible;

package/window/registerServiceWorker.d.ts

@@ -0,0 +1,2 @@
+export declare function registerServiceWorker(serviceWorkerPath: string): void;
+export declare function unregisterServiceWorker(): void;