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

package/dist/precaching/singletonPrecacheController.d.ts

@@ -0,0 +1,38 @@
+import { PrecacheController } from "./PrecacheController.js";
+/**
+ * Creates a new, singleton `PrecacheController` if one does not exist. If one does
+ * already exist, that instance is returned. This instance is used by Serwist's
+ * `PrecacheController`-dependent functions and classes unless you provide a different
+ * `Router` to them.
+ *
+ * @returns The singleton `PrecacheController`.
+ */
+export declare const getSingletonPrecacheController: () => PrecacheController;
+/**
+ * Changes the singleton `PrecacheController` to a different instance. This is meant for when you do not
+ * want to pass your own `PrecacheController` to every one of Serwist's `PrecacheController`-dependent
+ * functions and classes.
+ *
+ * It is highly recommended that you call this before anything else, if you plan on doing so.
+ *
+ * @example
+ * ```js
+ * import { PrecacheController, setSingletonPrecacheController } from "@serwist/sw/precaching";
+ *
+ * const controller = new PrecacheController();
+ *
+ * setSingletonPrecacheController(controller);
+ *
+ * // Do something with your controller...
+ *
+ * // This class now automatically picks up your `PrecacheController`! Without `setSingletonPrecacheController`,
+ * // you'd need to write this instead: `new Serwist({ controller })`
+ * const serwist = new Serwist();
+ *
+ * serwist.install();
+ * ```
+ * @param router
+ * @returns The new singleton `PrecacheController`.
+ */
+export declare const setSingletonPrecacheController: (precacheController: PrecacheController) => PrecacheController;
+//# sourceMappingURL=singletonPrecacheController.d.ts.map

package/dist/precaching/singletonPrecacheController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonPrecacheController.d.ts","sourceRoot":"","sources":["../../src/precaching/singletonPrecacheController.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAI7D;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,QAAO,kBAKjD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,8BAA8B,uBAAwB,kBAAkB,KAAG,kBAGvF,CAAC"}

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

@@ -1 +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"}
+{"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/routing/RegExpRoute.d.ts

@@ -2,10 +2,10 @@ 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.
+ * `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
+ * 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 {

package/dist/routing/Router.d.ts

@@ -1,40 +1,49 @@
-import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallbackOptions } from "@serwist/core";
+import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallback, 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.
+ * `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 a given a request, the Router will use a "default" handler if one is defined.
+ * 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 a "catch" handler if one is defined to
- * gracefully deal with issues and respond with a Request.
+ * 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.
+ * 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`
+     * @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.
+     * 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;
     /**
-     * Adds a message event listener for URLs to cache from the window.
+     * 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.
+     * 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
@@ -55,8 +64,14 @@ export declare class Router {
      */
     addCacheListener(): void;
     /**
-     * Apply the routing rules to a FetchEvent object to get a Response from an
-     * appropriate Route's handler.
+     * 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.
@@ -90,18 +105,18 @@ export declare class Router {
      * 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.
+     * 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 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.
+     * 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`
+     * 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
@@ -109,15 +124,26 @@ export declare class Router {
      */
     setCatchHandler(handler: RouteHandler): void;
     /**
-     * Registers a route with the router.
+     * 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.
+     * @param route The `Route` to register.
      */
     registerRoute(route: Route): void;
     /**
-     * Unregisters a route with the router.
+     * Unregisters a `Route` with the `Router`.
      *
-     * @param route The route to unregister.
+     * @param route The `Route` to unregister.
      */
     unregisterRoute(route: Route): void;
 }

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

@@ -1 +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"}
+{"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

@@ -2,14 +2,14 @@ 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.
+ * 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.
+ * @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`.
+ * @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

@@ -1 +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"}
+{"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

@@ -1,6 +1,6 @@
 import type { RouteHandler } from "@serwist/core";
 /**
- * If a Route throws an error while handling a request, this `handler`
+ * 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.

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

@@ -1 +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"}
+{"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

@@ -3,7 +3,7 @@ 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
+ * 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.

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

@@ -1 +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"}
+{"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

@@ -1,6 +1,6 @@
 import type { Route } from "./Route.js";
 /**
- * Unregisters a route from the singleton Router instance.
+ * Unregisters a route from the singleton `Router` instance.
  *
  * @param route The route to unregister.
  */

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

@@ -1 +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"}
+{"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/sw",
-  "version": "9.0.0-preview.19",
+  "version": "9.0.0-preview.20",
   "type": "module",
   "description": "A service worker helper module.",
   "files": [
@@ -61,13 +61,13 @@
   },
   "dependencies": {
     "idb": "8.0.0",
-    "@serwist/core": "9.0.0-preview.19"
+    "@serwist/core": "9.0.0-preview.20"
   },
   "devDependencies": {
     "rollup": "4.13.0",
     "typescript": "5.5.0-dev.20240323",
-    "@serwist/constants": "9.0.0-preview.19",
-    "@serwist/utils": "9.0.0-preview.19"
+    "@serwist/constants": "9.0.0-preview.20",
+    "@serwist/utils": "9.0.0-preview.20"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/abstractions/Serwist.ts

@@ -4,11 +4,11 @@ import { PrecacheController } from "../precaching/PrecacheController.js";
 import { PrecacheRoute } from "../precaching/PrecacheRoute.js";
 import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "../precaching/cleanupOutdatedCaches.js";
 import { createHandlerBoundToURL } from "../precaching/createHandlerBoundToURL.js";
-import { getOrCreatePrecacheController } from "../precaching/utils/getOrCreatePrecacheController.js";
+import { getSingletonPrecacheController } from "../precaching/singletonPrecacheController.js";
 import { NavigationRoute } from "../routing/NavigationRoute.js";
 import { Router } from "../routing/Router.js";
-import { getOrCreateDefaultRouter } from "../routing/utils/getOrCreateDefaultRouter.js";
-import { parseRoute } from "../routing/utils/parseRoute.js";
+import { parseRoute } from "../routing/parseRoute.js";
+import { getSingletonRouter } from "../routing/singletonRouter.js";
 import { disableDevLogs as disableDevLogsImpl } from "./disableDevLogs.js";
 import { fallbacks as fallbacksImpl } from "./fallbacks.js";
 import type { FallbacksOptions } from "./fallbacks.js";
@@ -20,15 +20,13 @@ declare const self: ServiceWorkerGlobalScope;
 
 export interface SerwistOptions {
   /**
-   * The precache controller that will be used to perform efficient
-   * precaching of assets.
-   * @see https://serwist.pages.dev/docs/sw/precaching
+   * An optional `PrecacheController` instance. If not provided, the singleton
+   * `PrecacheController` will be used.
    */
   precacheController?: PrecacheController;
   /**
-   * The router that will be used to process a `FetchEvent`, responding
-   * with a `Response` if a matching route exists.
-   * @see https://serwist.pages.dev/docs/sw/routing
+   * An optional `Router` instance. If not provided, the singleton `Router`
+   * will be used.
    */
   router?: Router;
 }
@@ -95,8 +93,8 @@ export class Serwist {
   private _precacheController: PrecacheController;
   private _router: Router;
   constructor({ precacheController, router }: SerwistOptions = {}) {
-    this._precacheController = precacheController || getOrCreatePrecacheController();
-    this._router = router || getOrCreateDefaultRouter();
+    this._precacheController = precacheController || getSingletonPrecacheController();
+    this._router = router || getSingletonRouter();
   }
   install({
     precacheEntries,
@@ -114,7 +112,7 @@ export class Serwist {
     offlineAnalyticsConfig,
     disableDevLogs = false,
     fallbacks,
-  }: SerwistInstallOptions) {
+  }: SerwistInstallOptions = {}) {
     if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
 
     if (navigationPreload) enableNavigationPreload();

package/src/abstractions/installSerwist.ts

@@ -1,6 +1,6 @@
 import { logger } from "@serwist/core/internal";
-import { getOrCreatePrecacheController } from "../precaching/utils/getOrCreatePrecacheController.js";
-import { getOrCreateDefaultRouter } from "../routing/utils/getOrCreateDefaultRouter.js";
+import { getSingletonPrecacheController } from "../precaching/singletonPrecacheController.js";
+import { getSingletonRouter } from "../routing/singletonRouter.js";
 import { Serwist, type SerwistInstallOptions } from "./Serwist.js";
 
 /**
@@ -21,8 +21,8 @@ export const installSerwist = (options: InstallSerwistOptions): void => {
     logger.warn("'installSerwist' has been deprecated. Please migrate to 'new Serwist().install()'.");
   }
   const serwist = new Serwist({
-    precacheController: getOrCreatePrecacheController(),
-    router: getOrCreateDefaultRouter(),
+    precacheController: getSingletonPrecacheController(),
+    router: getSingletonRouter(),
   });
   serwist.install(options);
 };

package/src/index.precaching.ts

@@ -9,6 +9,7 @@ import { getCacheKeyForURL } from "./precaching/getCacheKeyForURL.js";
 import { matchPrecache } from "./precaching/matchPrecache.js";
 import { precache } from "./precaching/precache.js";
 import { precacheAndRoute } from "./precaching/precacheAndRoute.js";
+import { getSingletonPrecacheController, setSingletonPrecacheController } from "./precaching/singletonPrecacheController.js";
 
 /**
  * Most consumers of this module will want to use the
@@ -33,6 +34,8 @@ export {
   PrecacheController,
   PrecacheRoute,
   PrecacheStrategy,
+  getSingletonPrecacheController,
+  setSingletonPrecacheController,
 };
 
 export type * from "./precaching/types.js";

package/src/index.routing.ts

@@ -3,12 +3,26 @@ import { NavigationRoute } from "./routing/NavigationRoute.js";
 import { RegExpRoute } from "./routing/RegExpRoute.js";
 import { Route } from "./routing/Route.js";
 import { Router } from "./routing/Router.js";
+import { parseRoute } from "./routing/parseRoute.js";
 import { registerRoute } from "./routing/registerRoute.js";
 import { setCatchHandler } from "./routing/setCatchHandler.js";
 import { setDefaultHandler } from "./routing/setDefaultHandler.js";
+import { getSingletonRouter, setSingletonRouter } from "./routing/singletonRouter.js";
 import { unregisterRoute } from "./routing/unregisterRoute.js";
 import type { HTTPMethod } from "./routing/utils/constants.js";
 
-export { NavigationRoute, RegExpRoute, registerRoute, Route, Router, setCatchHandler, setDefaultHandler, unregisterRoute };
+export {
+  NavigationRoute,
+  RegExpRoute,
+  parseRoute,
+  registerRoute,
+  Route,
+  Router,
+  setCatchHandler,
+  setDefaultHandler,
+  getSingletonRouter,
+  setSingletonRouter,
+  unregisterRoute,
+};
 
 export type { HTTPMethod, NavigationRouteMatchOptions };

package/src/plugins/googleAnalytics/initialize.ts

@@ -9,12 +9,13 @@
 import type { RouteMatchCallbackOptions } from "@serwist/core";
 import { getFriendlyURL, logger, privateCacheNames } from "@serwist/core/internal";
 import { Route } from "../../routing/Route.js";
-import { registerRoute } from "../../routing/registerRoute.js";
 import { NetworkFirst } from "../../strategies/NetworkFirst.js";
 import { NetworkOnly } from "../../strategies/NetworkOnly.js";
 import { BackgroundSyncPlugin } from "../backgroundSync/BackgroundSyncPlugin.js";
 import type { Queue, QueueEntry } from "../backgroundSync/Queue.js";
 
+import type { Router } from "../../routing/Router.js";
+import { getSingletonRouter } from "../../routing/singletonRouter.js";
 import {
   ANALYTICS_JS_PATH,
   COLLECT_PATHS_REGEX,
@@ -27,6 +28,11 @@ import {
 } from "./constants.js";
 
 export interface GoogleAnalyticsInitializeOptions {
+  /**
+   * An optional `Router` instance. If not provided, the singleton `Router`
+   * will be used.
+   */
+  router?: Router;
   /**
    * The cache name to store and retrieve analytics.js. Defaults to the cache names provided by `@serwist/core`.
    */
@@ -56,7 +62,7 @@ export interface GoogleAnalyticsInitializeOptions {
  * @returns The requestWillDequeue callback function.
  * @private
  */
-const createOnSyncCallback = (config: GoogleAnalyticsInitializeOptions) => {
+const createOnSyncCallback = (config: Pick<GoogleAnalyticsInitializeOptions, "parameterOverrides" | "hitFilter">) => {
   return async ({ queue }: { queue: Queue }) => {
     let entry: QueueEntry | undefined = undefined;
     while ((entry = await queue.shiftRequest())) {
@@ -182,19 +188,26 @@ const createGtmJsRoute = (cacheName: string) => {
 };
 
 /**
+ * Initialize Serwist's offline Google Analytics v3 support.
+ *
  * @param options
  */
-export const initialize = (options: GoogleAnalyticsInitializeOptions = {}): void => {
-  const cacheName = privateCacheNames.getGoogleAnalyticsName(options.cacheName);
+export const initialize = ({ cacheName, router = getSingletonRouter(), ...options }: GoogleAnalyticsInitializeOptions = {}): void => {
+  const resolvedCacheName = privateCacheNames.getGoogleAnalyticsName(cacheName);
 
   const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
     maxRetentionTime: MAX_RETENTION_TIME,
     onSync: createOnSyncCallback(options),
   });
 
-  const routes = [createGtmJsRoute(cacheName), createAnalyticsJsRoute(cacheName), createGtagJsRoute(cacheName), ...createCollectRoutes(bgSyncPlugin)];
+  const routes = [
+    createGtmJsRoute(resolvedCacheName),
+    createAnalyticsJsRoute(resolvedCacheName),
+    createGtagJsRoute(resolvedCacheName),
+    ...createCollectRoutes(bgSyncPlugin),
+  ];
 
   for (const route of routes) {
-    registerRoute(route);
+    router.registerRoute(route);
   }
 };

package/src/plugins/precaching/PrecacheFallbackPlugin.ts

@@ -9,7 +9,7 @@
 import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "@serwist/core";
 
 import type { PrecacheController } from "../../precaching/PrecacheController.js";
-import { getOrCreatePrecacheController } from "../../precaching/utils/getOrCreatePrecacheController.js";
+import { getSingletonPrecacheController } from "../../precaching/singletonPrecacheController.js";
 
 export interface PrecacheFallbackEntry {
   /**
@@ -59,7 +59,7 @@ export class PrecacheFallbackPlugin implements SerwistPlugin {
    */
   constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions) {
     this._fallbackUrls = fallbackUrls;
-    this._precacheController = precacheController || getOrCreatePrecacheController();
+    this._precacheController = precacheController || getSingletonPrecacheController();
   }
 
   /**

package/src/precaching/addPlugins.ts

@@ -8,7 +8,7 @@
 
 import type { SerwistPlugin } from "@serwist/core";
 
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
+import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
 
 /**
  * Adds plugins to the precaching strategy.
@@ -16,6 +16,6 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  * @param plugins
  */
 export const addPlugins = (plugins: SerwistPlugin[]): void => {
-  const precacheController = getOrCreatePrecacheController();
+  const precacheController = getSingletonPrecacheController();
   precacheController.strategy.plugins.push(...plugins);
 };

package/src/precaching/addRoute.ts

@@ -7,8 +7,8 @@
 
 import { registerRoute } from "../routing/registerRoute.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
+import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
 import type { PrecacheRouteOptions } from "./types.js";
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
 
 /**
  * Add a `fetch` listener to the service worker that will
@@ -23,7 +23,7 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  * @param options See the `@serwist/precaching.PrecacheRoute` options.
  */
 export const addRoute = (options?: PrecacheRouteOptions): void => {
-  const precacheController = getOrCreatePrecacheController();
+  const precacheController = getSingletonPrecacheController();
 
   const precacheRoute = new PrecacheRoute(precacheController, options);
   registerRoute(precacheRoute);