@serwist/sw 9.0.0-preview.17 → 9.0.0-preview.18

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":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIxD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,QAAS,MAAM,WAAW,oBAAoB,KAAG,MAAM,GAAG,SAYvF,CAAC"}

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

@@ -0,0 +1,7 @@
+import { PrecacheController } from "../PrecacheController.js";
+/**
+ * @returns
+ * @private
+ */
+export declare const getOrCreatePrecacheController: () => PrecacheController;
+//# sourceMappingURL=getOrCreatePrecacheController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getOrCreatePrecacheController.d.ts","sourceRoot":"","sources":["../../../src/precaching/utils/getOrCreatePrecacheController.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAI9D;;;GAGG;AACH,eAAO,MAAM,6BAA6B,QAAO,kBAKhD,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,124 @@
+import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallbackOptions } from "@serwist/core";
+import type { Route } from "./Route.js";
+import type { HTTPMethod } from "./utils/constants.js";
+/**
+ * The Router can be used to process a `FetchEvent` using one or more `@serwist/routing` Route(s),
+ * responding with a `Response` if a matching route exists.
+ *
+ * If no route matches a given a request, the Router will use a "default" handler if one is defined.
+ *
+ * Should the matching Route throw an error, the Router will use a "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 _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.
+     */
+    addFetchListener(): 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.
+     *
+     * 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;
+    /**
+     * 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 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,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAG9H,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAevD;;;;;;;;;;;GAWG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAsC;IACzE,OAAO,CAAC,aAAa,CAAC,CAAqB;IAE3C;;OAEG;;IAMH;;;OAGG;IACH,IAAI,MAAM,IAAI,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC,CAErC;IAED;;;OAGG;IACH,gBAAgB,IAAI,IAAI;IAUxB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBAAgB,IAAI,IAAI;IA8BxB;;;;;;;;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;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IA+CjC;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAcpC"}

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`.
+ */
+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;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIvD;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KAOlI,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,IAGvD,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,IAGzD,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,IAG9C,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/getOrCreateDefaultRouter.d.ts

@@ -0,0 +1,10 @@
+import { Router } from "../Router.js";
+/**
+ * Creates a new, singleton Router instance if one does not exist. If one
+ * does already exist, that instance is returned.
+ *
+ * @private
+ * @returns
+ */
+export declare const getOrCreateDefaultRouter: () => Router;
+//# sourceMappingURL=getOrCreateDefaultRouter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getOrCreateDefaultRouter.d.ts","sourceRoot":"","sources":["../../../src/routing/utils/getOrCreateDefaultRouter.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAItC;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAS3C,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/routing/utils/parseRoute.d.ts

@@ -0,0 +1,5 @@
+import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
+import { Route } from "../Route.js";
+import type { HTTPMethod } from "./constants.js";
+export declare const parseRoute: (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod) => Route;
+//# sourceMappingURL=parseRoute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseRoute.d.ts","sourceRoot":"","sources":["../../../src/routing/utils/parseRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAItE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,eAAO,MAAM,UAAU,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KA2D/H,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"}

package/dist/strategies/NetworkOnly.d.ts

@@ -0,0 +1,32 @@
+import type { StrategyOptions } from "./Strategy.js";
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+export interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" | "matchOptions"> {
+    /**
+     * If set, any network requests that fail to respond within the timeout will result in a network error.
+     */
+    networkTimeoutSeconds?: number;
+}
+/**
+ * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-only)
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any Serwist plugin.
+ *
+ * If the network request fails, this will throw a `SerwistError` exception.
+ */
+export declare class NetworkOnly extends Strategy {
+    private readonly _networkTimeoutSeconds;
+    /**
+     * @param options
+     */
+    constructor(options?: NetworkOnlyOptions);
+    /**
+     * @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=NetworkOnly.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkOnly.d.ts","sourceRoot":"","sources":["../../src/strategies/NetworkOnly.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;AAG5D,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,cAAc,CAAC;IAC7F;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,qBAAa,WAAY,SAAQ,QAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD;;OAEG;gBACS,OAAO,GAAE,kBAAuB;IAM5C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA+C7E"}