serwist 9.0.0-preview.24

package/dist/index.strategies.js

@@ -0,0 +1,144 @@
+import { f as finalAssertExports, l as logger, S as SerwistError } from './chunks/timeout.js';
+import { S as Strategy, m as messages, c as cacheOkAndOpaquePlugin } from './chunks/NetworkOnly.js';
+export { a as NetworkFirst, N as NetworkOnly, b as StrategyHandler } from './chunks/NetworkOnly.js';
+
+class CacheFirst extends Strategy {
+    async _handle(request, handler) {
+        const logs = [];
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist/strategies",
+                className: this.constructor.name,
+                funcName: "makeRequest",
+                paramName: "request"
+            });
+        }
+        let response = await handler.cacheMatch(request);
+        let error = undefined;
+        if (!response) {
+            if (process.env.NODE_ENV !== "production") {
+                logs.push(`No response found in the '${this.cacheName}' cache. Will respond with a network request.`);
+            }
+            try {
+                response = await handler.fetchAndCachePut(request);
+            } catch (err) {
+                if (err instanceof Error) {
+                    error = err;
+                }
+            }
+            if (process.env.NODE_ENV !== "production") {
+                if (response) {
+                    logs.push("Got response from network.");
+                } else {
+                    logs.push("Unable to get a response from the network.");
+                }
+            }
+        } else {
+            if (process.env.NODE_ENV !== "production") {
+                logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            for (const log of logs){
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url,
+                error
+            });
+        }
+        return response;
+    }
+}
+
+class CacheOnly extends Strategy {
+    async _handle(request, handler) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist/strategies",
+                className: this.constructor.name,
+                funcName: "makeRequest",
+                paramName: "request"
+            });
+        }
+        const response = await handler.cacheMatch(request);
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            if (response) {
+                logger.log(`Found a cached response in the '${this.cacheName}' cache.`);
+                messages.printFinalResponse(response);
+            } else {
+                logger.log(`No response found in the '${this.cacheName}' cache.`);
+            }
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url
+            });
+        }
+        return response;
+    }
+}
+
+class StaleWhileRevalidate extends Strategy {
+    constructor(options = {}){
+        super(options);
+        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
+            this.plugins.unshift(cacheOkAndOpaquePlugin);
+        }
+    }
+    async _handle(request, handler) {
+        const logs = [];
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist/strategies",
+                className: this.constructor.name,
+                funcName: "handle",
+                paramName: "request"
+            });
+        }
+        const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(()=>{});
+        void handler.waitUntil(fetchAndCachePromise);
+        let response = await handler.cacheMatch(request);
+        let error = undefined;
+        if (response) {
+            if (process.env.NODE_ENV !== "production") {
+                logs.push(`Found a cached response in the '${this.cacheName}' cache. Will update with the network response in the background.`);
+            }
+        } else {
+            if (process.env.NODE_ENV !== "production") {
+                logs.push(`No response found in the '${this.cacheName}' cache. Will wait for the network response.`);
+            }
+            try {
+                response = await fetchAndCachePromise;
+            } catch (err) {
+                if (err instanceof Error) {
+                    error = err;
+                }
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            for (const log of logs){
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url,
+                error
+            });
+        }
+        return response;
+    }
+}
+
+export { CacheFirst, CacheOnly, StaleWhileRevalidate, Strategy };

package/dist/legacy/PrecacheController.d.ts

@@ -0,0 +1,146 @@
+import type { RouteHandlerCallback, SerwistPlugin } from "../types.js";
+import type { Strategy } from "../strategies/Strategy.js";
+import type { CleanupResult, InstallResult, PrecacheEntry } from "../types.js";
+interface PrecacheControllerOptions {
+    /**
+     * The cache to use for precaching.
+     */
+    cacheName?: string;
+    /**
+     * Plugins to use when precaching as well as responding to fetch
+     * events for precached assets.
+     */
+    plugins?: SerwistPlugin[];
+    /**
+     * Whether to attempt to get the response from the network if there's
+     * a precache miss.
+     */
+    fallbackToNetwork?: boolean;
+    /**
+     * The number of precache requests that should be made concurrently.
+     *
+     * @default 1
+     */
+    concurrentPrecaching?: number;
+}
+/**
+ * Performs efficient precaching of assets.
+ * @deprecated
+ */
+export declare class PrecacheController {
+    private _installAndActiveListenersAdded?;
+    private _concurrentPrecaching;
+    private readonly _strategy;
+    private readonly _urlsToCacheKeys;
+    private readonly _urlsToCacheModes;
+    private readonly _cacheKeysToIntegrities;
+    /**
+     * Create a new PrecacheController.
+     *
+     * @param options
+     */
+    constructor({ cacheName, plugins, fallbackToNetwork, concurrentPrecaching }?: PrecacheControllerOptions);
+    /**
+     * The strategy created by this controller and
+     * used to cache assets and respond to fetch events.
+     */
+    get strategy(): Strategy;
+    /**
+     * Adds items to the precache list, removing any duplicates and
+     * stores the files in the precache cache when the service
+     * worker installs.
+     *
+     * This method can be called multiple times.
+     *
+     * @param entries Array of entries to precache.
+     */
+    precache(entries: (PrecacheEntry | string)[]): void;
+    /**
+     * This method will add items to the precache list, removing duplicates
+     * and ensuring the information is valid.
+     *
+     * @param entries Array of entries to precache.
+     */
+    addToCacheList(entries: (PrecacheEntry | string)[]): void;
+    /**
+     * Precaches new and updated assets. Call this method from the service worker
+     * install event.
+     *
+     * Note: this method calls `event.waitUntil()` for you, so you do not need
+     * to call it yourself in your event handlers.
+     *
+     * @param event
+     * @returns
+     */
+    install(event: ExtendableEvent): Promise<InstallResult>;
+    /**
+     * Deletes assets that are no longer present in the current precache manifest.
+     * Call this method from the service worker activate event.
+     *
+     * Note: this method calls `event.waitUntil()` for you, so you do not need
+     * to call it yourself in your event handlers.
+     *
+     * @param event
+     * @returns
+     */
+    activate(event: ExtendableEvent): Promise<CleanupResult>;
+    /**
+     * Returns a mapping of a precached URL to the corresponding cache key, taking
+     * into account the revision information for the URL.
+     *
+     * @returns A URL to cache key mapping.
+     */
+    getURLsToCacheKeys(): Map<string, string>;
+    /**
+     * Returns a list of all the URLs that have been precached by the current
+     * service worker.
+     *
+     * @returns The precached URLs.
+     */
+    getCachedURLs(): string[];
+    /**
+     * Returns the cache key used for storing a given URL. If that URL is
+     * unversioned, like `/index.html', then the cache key will be the original
+     * URL with a search parameter appended to it.
+     *
+     * @param url A URL whose cache key you want to look up.
+     * @returns The versioned URL that corresponds to a cache key
+     * for the original URL, or undefined if that URL isn't precached.
+     */
+    getCacheKeyForURL(url: string): string | undefined;
+    /**
+     * @param url A cache key whose SRI you want to look up.
+     * @returns The subresource integrity associated with the cache key,
+     * or undefined if it's not set.
+     */
+    getIntegrityForCacheKey(cacheKey: string): string | undefined;
+    /**
+     * This acts as a drop-in replacement for
+     * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)
+     * with the following differences:
+     *
+     * - It knows what the name of the precache is, and only checks in that cache.
+     * - It allows you to pass in an "original" URL without versioning parameters,
+     * and it will automatically look up the correct cache key for the currently
+     * active revision of that URL.
+     *
+     * E.g., `matchPrecache('index.html')` will find the correct precached
+     * response for the currently active service worker, even if the actual cache
+     * key is `'/index.html?__WB_REVISION__=1234abcd'`.
+     *
+     * @param request The key (without revisioning parameters)
+     * to look up in the precache.
+     * @returns
+     */
+    matchPrecache(request: string | Request): Promise<Response | undefined>;
+    /**
+     * Returns a function that looks up `url` in the precache (taking into
+     * account revision information), and returns the corresponding `Response`.
+     *
+     * @param url The precached URL which will be used to lookup the response.
+     * @return
+     */
+    createHandlerBoundToURL(url: string): RouteHandlerCallback;
+}
+export {};
+//# sourceMappingURL=PrecacheController.d.ts.map

package/dist/legacy/PrecacheController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheController.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheController.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAQvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAU/E,UAAU,yBAAyB;IACjC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,+BAA+B,CAAC,CAAU;IAClD,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6G;IAC/I,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAkC;IAE1E;;;;OAIG;gBACS,EAAE,SAAS,EAAE,OAAY,EAAE,iBAAwB,EAAE,oBAAwB,EAAE,GAAE,yBAA8B;IAY3H;;;OAGG;IACH,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAUnD;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAwDzD;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAmCvD;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAuBxD;;;;;OAKG;IACH,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC;;;;;OAKG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKlD;;;;OAIG;IACH,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7D;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAU7E;;;;;;OAMG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB;CAY3D"}

package/dist/legacy/PrecacheFallbackPlugin.d.ts

@@ -0,0 +1,62 @@
+import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "../types.js";
+import type { PrecacheController } from "./PrecacheController.js";
+/**
+ * @deprecated
+ */
+export interface PrecacheFallbackEntry {
+    /**
+     * A function that checks whether the fallback entry can be used
+     * for a request.
+     */
+    matcher: (param: HandlerDidErrorCallbackParam) => boolean;
+    /**
+     * A precached URL to be used as a fallback.
+     */
+    url: string;
+}
+/**
+ * @deprecated
+ */
+export interface PrecacheFallbackPluginOptions {
+    /**
+     * Precached URLs to be used as the fallback
+     * if the associated strategy can't generate a response.
+     */
+    fallbackUrls: (string | PrecacheFallbackEntry)[];
+    /**
+     * An optional `PrecacheController` instance. If not provided, the default
+     * `PrecacheController` will be used.
+     */
+    precacheController?: PrecacheController;
+}
+/**
+ * `PrecacheFallbackPlugin` allows you to specify offline fallbacks
+ * to be used when a given strategy is unable to generate a response.
+ *
+ * It does this by intercepting the `handlerDidError` plugin callback
+ * and returning a precached response, taking the expected revision parameter
+ * into account automatically.
+ *
+ * Unless you explicitly pass in a `PrecacheController` instance to the
+ * constructor, the default instance will be used. Generally speaking, most
+ * developers will end up using the default.
+ *
+ * @deprecated
+ */
+export declare class PrecacheFallbackPlugin implements SerwistPlugin {
+    private readonly _fallbackUrls;
+    private readonly _precacheController;
+    /**
+     * Constructs a new `PrecacheFallbackPlugin` with the associated `fallbackUrls`.
+     *
+     * @param config
+     */
+    constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions);
+    /**
+     * @returns The precache response for one of the fallback URLs, or `undefined` if
+     * nothing satisfies the conditions.
+     * @private
+     */
+    handlerDidError(param: HandlerDidErrorCallbackParam): Promise<Response | undefined>;
+}
+//# sourceMappingURL=PrecacheFallbackPlugin.d.ts.map

package/dist/legacy/PrecacheFallbackPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD;;;;OAIG;gBACS,EAAE,YAAY,EAAE,kBAAkB,EAAE,EAAE,6BAA6B;IAK/E;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}

package/dist/legacy/PrecacheRoute.d.ts

@@ -0,0 +1,19 @@
+import { Route } from "../Route.js";
+import type { PrecacheRouteOptions } from "../types.js";
+import type { PrecacheController } from "./PrecacheController.js";
+/**
+ * A subclass of `serwist.Route` that takes a `serwist/legacy.PrecacheController`
+ * instance and uses it to match incoming requests and handle fetching
+ * responses from the precache.
+ * @deprecated
+ */
+export declare class PrecacheRoute extends Route {
+    /**
+     * @param precacheController A `PrecacheController`
+     * instance used to both match requests and respond to fetch events.
+     * @param options Options to control how requests are matched
+     * against the list of precached URLs.
+     */
+    constructor(precacheController: PrecacheController, options?: PrecacheRouteOptions);
+}
+//# sourceMappingURL=PrecacheRoute.d.ts.map

package/dist/legacy/PrecacheRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheRoute.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;;OAKG;gBACS,kBAAkB,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAkBnF"}

package/dist/legacy/Router.d.ts

@@ -0,0 +1,151 @@
+import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
+import type { Route } from "../Route.js";
+import type { HTTPMethod } from "../constants.js";
+/**
+ * `Router` can be used to process a `FetchEvent` using one or more `Route`(s), responding with a `Response`
+ * if a matching route exists.
+ *
+ * If no `Route` matches given a `Request`, the `Router` will use the default handler if one is defined.
+ *
+ * Should the matching Route throw an error, the Router will use the catch handler if one is defined to
+ * gracefully deal with issues and respond with a `Request`.
+ *
+ * If a `Request` matches multiple routes, the earliest registered route will be used to respond to the `Request`.
+ * @deprecated
+ */
+export declare class Router {
+    private readonly _routes;
+    private readonly _defaultHandlerMap;
+    private _fetchListenerHandler;
+    private _cacheListenerHandler;
+    private _catchHandler?;
+    /**
+     * Initializes a new Router.
+     */
+    constructor();
+    /**
+     * @returns routes A `Map` of HTTP method name (`'GET'`, etc.) to an array of all the corresponding `Route`
+     * instances that are registered.
+     */
+    get routes(): Map<HTTPMethod, Route[]>;
+    /**
+     * Adds a `fetch` event listener to respond to events when a `Route` matches
+     * the event's request. Effectively no-op if `addFEtchListener` has been
+     * called, but `removeFetchListener` has not.
+     */
+    addFetchListener(): void;
+    /**
+     * Removes `fetch` event listener added by `addFetchListener`.
+     * Effectively no-op if either `addFetchListener` has not been called or,
+     * if it has, so has `removeFetchListener`.
+     */
+    removeFetchListener(): void;
+    /**
+     * Adds a `message` event listener for URLs to cache from the window.
+     * This is useful to cache resources loaded on the page prior to when the
+     * service worker started controlling it. Effectively no-op if `addCacheListener`
+     * has been called, but `removeCacheListener` hasn't.
+     *
+     * The format of the message data sent from the window should be as follows.
+     * Where the `urlsToCache` array may consist of URL strings or an array of
+     * URL string + `requestInit` object (the same as you'd pass to `fetch()`).
+     *
+     * ```
+     * {
+     *   type: 'CACHE_URLS',
+     *   payload: {
+     *     urlsToCache: [
+     *       './script1.js',
+     *       './script2.js',
+     *       ['./script3.js', {mode: 'no-cors'}],
+     *     ],
+     *   },
+     * }
+     * ```
+     */
+    addCacheListener(): void;
+    /**
+     * Removes the `message` event listener added by `addCacheListener`.
+     * Effectively no-op if either `addCacheListener` has not been called or,
+     * if it has, so has `removeCacheListener`.
+     */
+    removeCacheListener(): void;
+    /**
+     * Apply the routing rules to a `FetchEvent` object to get a `Response` from an
+     * appropriate `Route`'s handler.
+     *
+     * @param options
+     * @returns A promise is returned if a registered route can handle the request.
+     * If there is no matching route and there's no `defaultHandler`, `undefined`
+     * is returned.
+     */
+    handleRequest({ request, event, }: {
+        /**
+         * The request to handle.
+         */
+        request: Request;
+        /**
+         * The event that triggered the request.
+         */
+        event: ExtendableEvent;
+    }): Promise<Response> | undefined;
+    /**
+     * Checks a request and URL (and optionally an event) against the list of
+     * registered routes, and if there's a match, returns the corresponding
+     * route along with any params generated by the match.
+     *
+     * @param options
+     * @returns An object with `route` and `params` properties. They are populated
+     * if a matching route was found or `undefined` otherwise.
+     */
+    findMatchingRoute({ url, sameOrigin, request, event }: RouteMatchCallbackOptions): {
+        route?: Route;
+        params?: RouteHandlerCallbackOptions["params"];
+    };
+    /**
+     * Define a default `handler` that's called when no routes explicitly
+     * match the incoming request.
+     *
+     * Each HTTP method (`'GET'`, `'POST'`, etc.) gets its own default handler.
+     *
+     * Without a default handler, unmatched requests will go against the
+     * network as if there were no service worker present.
+     *
+     * @param handler A callback function that returns a `Promise` resulting in a `Response`.
+     * @param method The HTTP method to associate with this default handler. Each method
+     * has its own default. Defaults to `'GET'`.
+     */
+    setDefaultHandler(handler: RouteHandler, method?: HTTPMethod): void;
+    /**
+     * If a `Route` throws an error while handling a request, this `handler`
+     * will be called and given a chance to provide a response.
+     *
+     * @param handler A callback function that returns a Promise resulting
+     * in a Response.
+     */
+    setCatchHandler(handler: RouteHandler): void;
+    /**
+     * Registers a `RegExp`, string, or function with a caching
+     * strategy to the `Router`.
+     *
+     * @param capture If the capture param is a `Route`, all other arguments will be ignored.
+     * @param handler A callback function that returns a `Promise` resulting in a `Response`.
+     * This parameter is required if `capture` is not a `Route` object.
+     * @param method The HTTP method to match the Route against. Defaults to `'GET'`.
+     * @returns The generated `Route`.
+     */
+    registerCapture(capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route;
+    /**
+     * Registers a `Route` with the router.
+     *
+     * @param route The `Route` to register.
+     */
+    registerRoute(route: Route): void;
+    /**
+     * Unregisters a `Route` with the `Router`.
+     *
+     * @param route The `Route` to unregister.
+     */
+    unregisterRoute(route: Route): void;
+}
+//# sourceMappingURL=Router.d.ts.map

package/dist/legacy/Router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Router.d.ts","sourceRoot":"","sources":["../../src/legacy/Router.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,2BAA2B,EAAsB,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAKhJ,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAgBlD;;;;;;;;;;;GAWG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAsC;IACzE,OAAO,CAAC,qBAAqB,CAA2C;IACxE,OAAO,CAAC,qBAAqB,CAAuD;IACpF,OAAO,CAAC,aAAa,CAAC,CAAqB;IAE3C;;OAEG;;IAMH;;;OAGG;IACH,IAAI,MAAM,IAAI,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC,CAErC;IAED;;;;OAIG;IACH,gBAAgB,IAAI,IAAI;IAaxB;;;;OAIG;IACH,mBAAmB,IAAI,IAAI;IAO3B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAAgB,IAAI,IAAI;IAiCxB;;;;OAIG;IACH,mBAAmB,IAAI,IAAI;IAM3B;;;;;;;;OAQG;IACH,aAAa,CAAC,EACZ,OAAO,EACP,KAAK,GACN,EAAE;QACD;;WAEG;QACH,OAAO,EAAE,OAAO,CAAC;QACjB;;WAEG;QACH,KAAK,EAAE,eAAe,CAAC;KACxB,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS;IA8HjC;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,yBAAyB,GAAG;QACjF,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,MAAM,CAAC,EAAE,2BAA2B,CAAC,QAAQ,CAAC,CAAC;KAChD;IA+CD;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,GAAE,UAA0B,GAAG,IAAI;IAIlF;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI5C;;;;;;;;;OASG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,KAAK;IAM1H;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IA+CjC;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAcpC"}

package/dist/legacy/addPlugins.d.ts

@@ -0,0 +1,9 @@
+import type { SerwistPlugin } from "../types.js";
+/**
+ * Adds plugins to the precaching strategy.
+ *
+ * @param plugins
+ * @deprecated
+ */
+export declare const addPlugins: (plugins: SerwistPlugin[]) => void;
+//# sourceMappingURL=addPlugins.d.ts.map

package/dist/legacy/addPlugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addPlugins.d.ts","sourceRoot":"","sources":["../../src/legacy/addPlugins.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,YAAa,aAAa,EAAE,KAAG,IAGrD,CAAC"}

package/dist/legacy/addRoute.d.ts

@@ -0,0 +1,16 @@
+import type { PrecacheRouteOptions } from "../types.js";
+/**
+ * Add a `fetch` listener to the service worker that will
+ * respond to
+ * [network requests](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests)
+ * with precached assets.
+ *
+ * Requests for assets that aren't precached, the `FetchEvent` will not be
+ * responded to, allowing the event to fall through to other `fetch` event
+ * listeners.
+ *
+ * @param options See `serwist.PrecacheRouteOptions`.
+ * @deprecated
+ */
+export declare const addRoute: (options?: PrecacheRouteOptions) => void;
+//# sourceMappingURL=addRoute.d.ts.map

package/dist/legacy/addRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/addRoute.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAKxD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,aAAc,oBAAoB,KAAG,IAGzD,CAAC"}

package/dist/legacy/createHandlerBoundToURL.d.ts

@@ -0,0 +1,18 @@
+import type { RouteHandlerCallback } from "../types.js";
+/**
+ * Helper function that calls `PrecacheController#createHandlerBoundToURL`
+ * on the default `PrecacheController` instance.
+ *
+ * If you are creating your own `PrecacheController`, then call the
+ * `PrecacheController#createHandlerBoundToURL` on that instance,
+ * instead of using this function.
+ *
+ * @param url The precached URL which will be used to lookup the
+ * `Response`.
+ * @param fallbackToNetwork Whether to attempt to get the
+ * response from the network if there's a precache miss.
+ * @return
+ * @deprecated
+ */
+export declare const createHandlerBoundToURL: (url: string) => RouteHandlerCallback;
+//# sourceMappingURL=createHandlerBoundToURL.d.ts.map

package/dist/legacy/createHandlerBoundToURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHandlerBoundToURL.d.ts","sourceRoot":"","sources":["../../src/legacy/createHandlerBoundToURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,QAAS,MAAM,KAAG,oBAGrD,CAAC"}

package/dist/legacy/fallbacks.d.ts

@@ -0,0 +1,59 @@
+import type { PrecacheRouteOptions, RuntimeCaching } from "../types.js";
+import type { PrecacheController } from "./PrecacheController.js";
+import type { Router } from "./Router.js";
+import type { PrecacheFallbackEntry } from "./PrecacheFallbackPlugin.js";
+export interface FallbackEntry extends PrecacheFallbackEntry {
+    /**
+     * The revision used for precaching.
+     */
+    revision: string;
+}
+export interface FallbacksOptions {
+    /**
+     * A list of fallback entries.
+     */
+    entries: FallbackEntry[];
+    /**
+     * Precache options that will be used for your
+     * fallback entries.
+     */
+    precacheOptions?: PrecacheRouteOptions;
+}
+export interface FallbacksOptions {
+    /**
+     * An optional `PrecacheController` instance. If not provided, the singleton
+     * `PrecacheController` will be used.
+     */
+    precacheController?: PrecacheController;
+    /**
+     * An optional `Router` instance. If not provided, the singleton `Router`
+     * will be used.
+     */
+    router?: Router;
+    /**
+     * Your previous list of caching strategies.
+     */
+    runtimeCaching: RuntimeCaching[];
+    /**
+     * A list of fallback entries.
+     */
+    entries: FallbackEntry[];
+    /**
+     * Precache options that will be used for your
+     * fallback entries.
+     */
+    precacheOptions?: PrecacheRouteOptions;
+}
+/**
+ * Precaches routes so that they can be used as a fallback when
+ * a Strategy fails to generate a response.
+ *
+ * Note: This function mutates `runtimeCaching`. It also precaches the URLs
+ * defined in `entries`, so you must NOT precache any of them beforehand.
+ *
+ * @param options
+ * @returns The modified `runtimeCaching` array.
+ * @deprecated
+ */
+export declare const fallbacks: ({ precacheController, router, runtimeCaching, entries, precacheOptions, }: FallbacksOptions) => RuntimeCaching[];
+//# sourceMappingURL=fallbacks.d.ts.map

package/dist/legacy/fallbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallbacks.d.ts","sourceRoot":"","sources":["../../src/legacy/fallbacks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzE,MAAM,WAAW,aAAc,SAAQ,qBAAqB;IAC1D;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB;;;OAGG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC;;OAEG;IACH,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB;;;OAGG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,8EAMnB,gBAAgB,KAAG,cAAc,EAqBnC,CAAC"}