@serwist/sw 9.0.0-preview.2 → 9.0.0-preview.20

package/dist/precaching/utils/getCacheKeyForURL.d.ts

@@ -0,0 +1,14 @@
+import type { PrecacheRouteOptions } from "../types.js";
+/**
+ * This function will take the request URL and manipulate it based on the
+ * configuration options.
+ *
+ * @param url
+ * @param options
+ * @returns Returns the URL in the cache that matches the request,
+ * if possible.
+ *
+ * @private
+ */
+export declare const getCacheKeyForURL: (url: string, options: PrecacheRouteOptions) => string | undefined;
+//# sourceMappingURL=getCacheKeyForURL.d.ts.map

package/dist/precaching/utils/getCacheKeyForURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCacheKeyForURL.d.ts","sourceRoot":"","sources":["../../../src/precaching/utils/getCacheKeyForURL.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,QAAS,MAAM,WAAW,oBAAoB,KAAG,MAAM,GAAG,SAYvF,CAAC"}

package/dist/precaching/utils/printCleanupDetails.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param deletedURLs
+ * @private
+ */
+export declare function printCleanupDetails(deletedURLs: string[]): void;
+//# sourceMappingURL=printCleanupDetails.d.ts.map

package/dist/precaching/utils/printCleanupDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printCleanupDetails.d.ts","sourceRoot":"","sources":["../../../src/precaching/utils/printCleanupDetails.ts"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,IAAI,CAO/D"}

package/dist/precaching/utils/printInstallDetails.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param urlsToPrecache
+ * @param  urlsAlreadyPrecached
+ * @private
+ */
+export declare function printInstallDetails(urlsToPrecache: string[], urlsAlreadyPrecached: string[]): void;
+//# sourceMappingURL=printInstallDetails.d.ts.map

package/dist/precaching/utils/printInstallDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printInstallDetails.d.ts","sourceRoot":"","sources":["../../../src/precaching/utils/printInstallDetails.ts"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,EAAE,EAAE,oBAAoB,EAAE,MAAM,EAAE,GAAG,IAAI,CAiBlG"}

package/dist/precaching/utils/removeIgnoredSearchParams.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Removes any URL search parameters that should be ignored.
+ *
+ * @param urlObject The original URL.
+ * @param ignoreURLParametersMatching RegExps to test against
+ * each search parameter name. Matches mean that the search parameter should be
+ * ignored.
+ * @returns The URL with any ignored search parameters removed.
+ * @private
+ */
+export declare function removeIgnoredSearchParams(urlObject: URL, ignoreURLParametersMatching?: RegExp[]): URL;
+//# sourceMappingURL=removeIgnoredSearchParams.d.ts.map

package/dist/precaching/utils/removeIgnoredSearchParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeIgnoredSearchParams.d.ts","sourceRoot":"","sources":["../../../src/precaching/utils/removeIgnoredSearchParams.ts"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,GAAG,EAAE,2BAA2B,GAAE,MAAM,EAAO,GAAG,GAAG,CAUzG"}

package/dist/routing/NavigationRoute.d.ts

@@ -0,0 +1,57 @@
+import type { RouteHandler } from "@serwist/core";
+import { Route } from "./Route.js";
+export interface NavigationRouteMatchOptions {
+    /**
+     * If any of these patterns
+     * match the URL's pathname and search parameter, the route will handle the
+     * request (assuming the denylist doesn't match).
+     *
+     * @default [/./]
+     */
+    allowlist?: RegExp[];
+    /**
+     * If any of these patterns match, the route will not handle the request (even if a allowlist RegExp matches).
+     */
+    denylist?: RegExp[];
+}
+/**
+ * NavigationRoute makes it easy to create a `@serwist/routing` Route that matches for browser
+ * [navigation requests](https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_navigation_requests).
+ *
+ * It will only match incoming Requests whose [mode](https://fetch.spec.whatwg.org/#concept-request-mode) is set to `navigate`.
+ *
+ * You can optionally only apply this route to a subset of navigation requests
+ * by using one or both of the `denylist` and `allowlist` parameters.
+ */
+export declare class NavigationRoute extends Route {
+    private readonly _allowlist;
+    private readonly _denylist;
+    /**
+     * If both `denylist` and `allowlist` are provided, the `denylist` will
+     * take precedence and the request will not match this route.
+     *
+     * The regular expressions in `allowlist` and `denylist`
+     * are matched against the concatenated
+     * [`pathname`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname)
+     * and [`search`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search)
+     * portions of the requested URL.
+     *
+     * *Note*: These RegExps may be evaluated against every destination URL during
+     * a navigation. Avoid using
+     * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077),
+     * or else your users may see delays when navigating your site.
+     *
+     * @param handler A callback function that returns a Promise resulting in a Response.
+     * @param options
+     */
+    constructor(handler: RouteHandler, { allowlist, denylist }?: NavigationRouteMatchOptions);
+    /**
+     * Routes match handler.
+     *
+     * @param options
+     * @returns
+     * @private
+     */
+    private _match;
+}
+//# sourceMappingURL=NavigationRoute.d.ts.map

package/dist/routing/NavigationRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationRoute.d.ts","sourceRoot":"","sources":["../../src/routing/NavigationRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAA6B,MAAM,eAAe,CAAC;AAG7E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,MAAM,WAAW,2BAA2B;IAC1C;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAW;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IAErC;;;;;;;;;;;;;;;;;OAiBG;gBACS,OAAO,EAAE,YAAY,EAAE,EAAE,SAAiB,EAAE,QAAa,EAAE,GAAE,2BAAgC;IAsBzG;;;;;;OAMG;IACH,OAAO,CAAC,MAAM;CA8Bf"}

package/dist/routing/RegExpRoute.d.ts

@@ -0,0 +1,24 @@
+import type { RouteHandler } from "@serwist/core";
+import { Route } from "./Route.js";
+import type { HTTPMethod } from "./utils/constants.js";
+/**
+ * `RegExpRoute` makes it easy to create a regular expression based on a `@serwist/routing` Route.
+ *
+ * For same-origin requests the `RegExp` only needs to match part of the URL. For
+ * requests against third-party servers, you must define a `RegExp` that matches
+ * the start of the URL.
+ */
+export declare class RegExpRoute extends Route {
+    /**
+     * If the regular expression contains
+     * [capture groups](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references),
+     * the captured values will be passed to the `params` argument.
+     *
+     * @param regExp The regular expression to match against URLs.
+     * @param handler A callback function that returns a Promise resulting in a Response.
+     * @param method The HTTP method to match the Route, defaults to GET.
+     * against.
+     */
+    constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod);
+}
+//# sourceMappingURL=RegExpRoute.d.ts.map

package/dist/routing/RegExpRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegExpRoute.d.ts","sourceRoot":"","sources":["../../src/routing/RegExpRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAiD,MAAM,eAAe,CAAC;AAGjG,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC;;;;;;;;;OASG;gBACS,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,UAAU;CAyCvE"}

package/dist/routing/Route.d.ts

@@ -0,0 +1,33 @@
+import type { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "@serwist/core";
+import type { HTTPMethod } from "./utils/constants.js";
+/**
+ * A `Route` consists of a pair of callback functions, "match" and "handler".
+ * The "match" callback determine if a route should be used to "handle" a
+ * request by returning a non-falsy value if it can. The "handler" callback
+ * is called when there is a match and should return a Promise that resolves
+ * to a `Response`.
+ */
+export declare class Route {
+    handler: RouteHandlerObject;
+    match: RouteMatchCallback;
+    method: HTTPMethod;
+    catchHandler?: RouteHandlerObject;
+    /**
+     * Constructor for Route class.
+     *
+     * @param match A callback function that determines whether the
+     * route matches a given `fetch` event by returning a non-falsy value.
+     * @param handler A callback function that returns a Promise resolving
+     * to a Response.
+     * @param method The HTTP method to match the Route against. Defaults
+     * to GET.
+     */
+    constructor(match: RouteMatchCallback, handler: RouteHandler, method?: HTTPMethod);
+    /**
+     *
+     * @param handler A callback function that returns a Promise resolving
+     * to a Response.
+     */
+    setCatchHandler(handler: RouteHandler): void;
+}
+//# sourceMappingURL=Route.d.ts.map

package/dist/routing/Route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Route.d.ts","sourceRoot":"","sources":["../../src/routing/Route.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAG1F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIvD;;;;;;GAMG;AACH,qBAAa,KAAK;IAChB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAElC;;;;;;;;;OASG;gBACS,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAE,UAA0B;IAqBhG;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;CAG7C"}

package/dist/routing/Router.d.ts

@@ -0,0 +1,150 @@
+import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallback, RouteMatchCallbackOptions } from "@serwist/core";
+import type { Route } from "./Route.js";
+import type { HTTPMethod } from "./utils/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`.
+ */
+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/routing/Router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Router.d.ts","sourceRoot":"","sources":["../../src/routing/Router.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,2BAA2B,EAAsB,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAGlJ,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAevD;;;;;;;;;;GAUG;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/routing/parseRoute.d.ts

@@ -0,0 +1,16 @@
+import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
+import { Route } from "./Route.js";
+import type { HTTPMethod } from "./utils/constants.js";
+/**
+ * Parses a `RegExp`, string, or function with a caching strategy into a `Route`. This is for
+ * when you want to create a `Route`, but you don't want to register it just yet: sometimes
+ * you want to call `setCatchHandler` first, for example.
+ *
+ * @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`.
+ */
+export declare const parseRoute: (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod) => Route;
+//# sourceMappingURL=parseRoute.d.ts.map

package/dist/routing/parseRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRoute.d.ts","sourceRoot":"","sources":["../../src/routing/parseRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAItE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KA2D/H,CAAC"}

package/dist/routing/registerRoute.d.ts

@@ -0,0 +1,15 @@
+import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
+import { Route } from "./Route.js";
+import type { HTTPMethod } from "./utils/constants.js";
+/**
+ * Registers a `RegExp`, string, or function with a caching
+ * strategy to a singleton `Router` instance.
+ *
+ * @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`, which can then be provided to `unregisterRoute` if needed.
+ */
+export declare const registerRoute: (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod) => Route;
+//# sourceMappingURL=registerRoute.d.ts.map

package/dist/routing/registerRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../src/routing/registerRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEtE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KAElI,CAAC"}

package/dist/routing/setCatchHandler.d.ts

@@ -0,0 +1,9 @@
+import type { RouteHandler } from "@serwist/core";
+/**
+ * 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.
+ */
+export declare const setCatchHandler: (handler: RouteHandler) => void;
+//# sourceMappingURL=setCatchHandler.d.ts.map

package/dist/routing/setCatchHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setCatchHandler.d.ts","sourceRoot":"","sources":["../../src/routing/setCatchHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAIlD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,YAAa,YAAY,KAAG,IAEvD,CAAC"}

package/dist/routing/setDefaultHandler.d.ts

@@ -0,0 +1,12 @@
+import type { RouteHandler } from "@serwist/core";
+/**
+ * Defines a default `handler` that's called when no routes explicitly
+ * match the incoming request.
+ *
+ * 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.
+ */
+export declare const setDefaultHandler: (handler: RouteHandler) => void;
+//# sourceMappingURL=setDefaultHandler.d.ts.map

package/dist/routing/setDefaultHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setDefaultHandler.d.ts","sourceRoot":"","sources":["../../src/routing/setDefaultHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAIlD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,YAAa,YAAY,KAAG,IAEzD,CAAC"}

package/dist/routing/singletonRouter.d.ts

@@ -0,0 +1,47 @@
+import { Router } from "./Router.js";
+/**
+ * Creates a new, singleton `Router` if one does not exist. If one does
+ * already exist, that instance is returned. This instance is used by
+ * Serwist's `Router`-dependent functions and classes unless you provide
+ * a different `Router` to them.
+ *
+ * @returns The singleton `Router`.
+ */
+export declare const getSingletonRouter: () => Router;
+/**
+ * Changes the singleton `Router` to a different instance. This is meant for when you do not
+ * want to pass your own `Router` to every one of Serwist's `Router`-dependent functions and classes.
+ * If this or `getSingletonRouter` has been called before, it removes the listeners of the
+ * previous singleton `Router`. It also adds those of the new one, so you need not do that yourself.
+ *
+ * It is highly recommended that you call this before anything else, if you plan on doing so.
+ *
+ * @example
+ * ```js
+ * import { Router, setSingletonRouter } from "@serwist/sw/routing";
+ *
+ * const router = new Router();
+ *
+ * setSingletonRouter(router);
+ *
+ * router.registerRoute(
+ *   new Route(
+ *     /\/api\/.*\/*.json/,
+ *     new NetworkOnly({
+ *       plugins: [backgroundSync],
+ *     }),
+ *     "POST",
+ *   ),
+ * );
+ *
+ * // This class now automatically picks up your `Router`! Without `setSingletonRouter`, you'd need to
+ * // write this instead: `new Serwist({ router })`
+ * const serwist = new Serwist();
+ *
+ * serwist.install();
+ * ```
+ * @param router
+ * @returns The new singleton `Router`.
+ */
+export declare const setSingletonRouter: (router: Router) => Router;
+//# sourceMappingURL=singletonRouter.d.ts.map

package/dist/routing/singletonRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonRouter.d.ts","sourceRoot":"","sources":["../../src/routing/singletonRouter.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIrC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,QAAO,MASrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,kBAAkB,WAAY,MAAM,KAAG,MASnD,CAAC"}

package/dist/routing/unregisterRoute.d.ts

@@ -0,0 +1,8 @@
+import type { Route } from "./Route.js";
+/**
+ * Unregisters a route from the singleton `Router` instance.
+ *
+ * @param route The route to unregister.
+ */
+export declare const unregisterRoute: (route: Route) => void;
+//# sourceMappingURL=unregisterRoute.d.ts.map

package/dist/routing/unregisterRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unregisterRoute.d.ts","sourceRoot":"","sources":["../../src/routing/unregisterRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC;;;;GAIG;AACH,eAAO,MAAM,eAAe,UAAW,KAAK,KAAG,IAE9C,CAAC"}

package/dist/routing/utils/constants.d.ts

@@ -0,0 +1,15 @@
+export type HTTPMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+/**
+ * The default HTTP method, 'GET', used when there's no specific method
+ * configured for a route.
+ *
+ * @private
+ */
+export declare const defaultMethod = "GET";
+/**
+ * The list of valid HTTP methods associated with requests that could be routed.
+ *
+ * @private
+ */
+export declare const validMethods: ("GET" | "DELETE" | "HEAD" | "PATCH" | "POST" | "PUT")[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/routing/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/routing/utils/constants.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAA6B,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,YAAY,0DAA2E,CAAC"}

package/dist/routing/utils/normalizeHandler.d.ts

@@ -0,0 +1,10 @@
+import type { RouteHandler, RouteHandlerObject } from "@serwist/core";
+/**
+ * @param handler Either a function, or an object with a
+ * 'handle' method.
+ * @returns An object with a handle method.
+ *
+ * @private
+ */
+export declare const normalizeHandler: (handler: RouteHandler) => RouteHandlerObject;
+//# sourceMappingURL=normalizeHandler.d.ts.map

package/dist/routing/utils/normalizeHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeHandler.d.ts","sourceRoot":"","sources":["../../../src/routing/utils/normalizeHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGtE;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,YAAa,YAAY,KAAG,kBAqBxD,CAAC"}

package/dist/strategies/CacheFirst.d.ts

@@ -0,0 +1,23 @@
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+/**
+ * An implementation of the [cache first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache_first_falling_back_to_network)
+ * request strategy.
+ *
+ * A cache first strategy is useful for assets that have been revisioned,
+ * such as URLs like `/styles/example.a8f5f1.css`, since they
+ * can be cached for long periods of time.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `SerwistError` exception.
+ */
+export declare class CacheFirst extends Strategy {
+    /**
+     * @private
+     * @param request A request to run this strategy for.
+     * @param handler The event that triggered the request.
+     * @returns
+     */
+    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
+}
+//# sourceMappingURL=CacheFirst.d.ts.map

package/dist/strategies/CacheFirst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheFirst.d.ts","sourceRoot":"","sources":["../../src/strategies/CacheFirst.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,QAAQ;IACtC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CAsD7E"}

package/dist/strategies/CacheOnly.d.ts

@@ -0,0 +1,20 @@
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+/**
+ * An implementation of the [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only)
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any Serwist plugin.
+ *
+ * If there is no cache match, this will throw a `SerwistError` exception.
+ */
+export declare class CacheOnly extends Strategy {
+    /**
+     * @private
+     * @param request A request to run this strategy for.
+     * @param handler The event that triggered the request.
+     * @returns
+     */
+    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
+}
+//# sourceMappingURL=CacheOnly.d.ts.map

package/dist/strategies/CacheOnly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheOnly.d.ts","sourceRoot":"","sources":["../../src/strategies/CacheOnly.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,QAAQ;IACrC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA4B7E"}

package/dist/strategies/NetworkFirst.d.ts

@@ -0,0 +1,61 @@
+import type { StrategyOptions } from "./Strategy.js";
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+export interface NetworkFirstOptions extends StrategyOptions {
+    /**
+     * If set, any network requests that fail to respond within the timeout will fallback to the cache.
+     */
+    networkTimeoutSeconds?: number;
+}
+/**
+ * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache)
+ * request strategy.
+ *
+ * By default, this strategy will cache responses with a 200 status code as
+ * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
+ * Opaque responses are are cross-origin requests where the response doesn't
+ * support [CORS](https://enable-cors.org/).
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `SerwistError` exception.
+ */
+export declare class NetworkFirst extends Strategy {
+    private readonly _networkTimeoutSeconds;
+    /**
+     * @param options
+     * This option can be used to combat
+     * "[lie-fi](https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi)"
+     * scenarios.
+     */
+    constructor(options?: NetworkFirstOptions);
+    /**
+     * @private
+     * @param request A request to run this strategy for.
+     * @param handler The event that triggered the request.
+     * @returns
+     */
+    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
+    /**
+     * @param options
+     * @returns
+     * @private
+     */
+    private _getTimeoutPromise;
+    /**
+     * @param options
+     * @param options.timeoutId
+     * @param options.request
+     * @param options.logs A reference to the logs Array.
+     * @param options.event
+     * @returns
+     *
+     * @private
+     */
+    _getNetworkPromise({ timeoutId, request, logs, handler, }: {
+        request: Request;
+        logs: any[];
+        timeoutId?: number;
+        handler: StrategyHandler;
+    }): Promise<Response | undefined>;
+}
+//# sourceMappingURL=NetworkFirst.d.ts.map

package/dist/strategies/NetworkFirst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkFirst.d.ts","sourceRoot":"","sources":["../../src/strategies/NetworkFirst.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI5D,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD;;;;;OAKG;gBACS,OAAO,GAAE,mBAAwB;IAsB7C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgE5E;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;;;;;;;;OASG;IACG,kBAAkB,CAAC,EACvB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAO,GACR,EAAE;QACD,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,EAAE,GAAG,EAAE,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,eAAe,CAAC;KAC1B,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAqClC"}