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

package/dist/chunks/singletonRouter.js

@@ -0,0 +1,435 @@
+import { assert, logger, SerwistError, getFriendlyURL } from '@serwist/core/internal';
+
+const defaultMethod = "GET";
+const validMethods = [
+    "DELETE",
+    "GET",
+    "HEAD",
+    "PATCH",
+    "POST",
+    "PUT"
+];
+
+const normalizeHandler = (handler)=>{
+    if (handler && typeof handler === "object") {
+        if (process.env.NODE_ENV !== "production") {
+            assert.hasMethod(handler, "handle", {
+                moduleName: "@serwist/routing",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "handler"
+            });
+        }
+        return handler;
+    }
+    if (process.env.NODE_ENV !== "production") {
+        assert.isType(handler, "function", {
+            moduleName: "@serwist/routing",
+            className: "Route",
+            funcName: "constructor",
+            paramName: "handler"
+        });
+    }
+    return {
+        handle: handler
+    };
+};
+
+class Route {
+    handler;
+    match;
+    method;
+    catchHandler;
+    constructor(match, handler, method = defaultMethod){
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(match, "function", {
+                moduleName: "@serwist/routing",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "match"
+            });
+            if (method) {
+                assert.isOneOf(method, validMethods, {
+                    paramName: "method"
+                });
+            }
+        }
+        this.handler = normalizeHandler(handler);
+        this.match = match;
+        this.method = method;
+    }
+    setCatchHandler(handler) {
+        this.catchHandler = normalizeHandler(handler);
+    }
+}
+
+class RegExpRoute extends Route {
+    constructor(regExp, handler, method){
+        if (process.env.NODE_ENV !== "production") {
+            assert.isInstance(regExp, RegExp, {
+                moduleName: "@serwist/routing",
+                className: "RegExpRoute",
+                funcName: "constructor",
+                paramName: "pattern"
+            });
+        }
+        const match = ({ url })=>{
+            const result = regExp.exec(url.href);
+            if (!result) {
+                return;
+            }
+            if (url.origin !== location.origin && result.index !== 0) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.debug(`The regular expression '${regExp.toString()}' only partially matched against the cross-origin URL '${url.toString()}'. RegExpRoute's will only handle cross-origin requests if they match the entire URL.`);
+                }
+                return;
+            }
+            return result.slice(1);
+        };
+        super(match, handler, method);
+    }
+}
+
+const parseRoute = (capture, handler, method)=>{
+    let route;
+    if (typeof capture === "string") {
+        const captureUrl = new URL(capture, location.href);
+        if (process.env.NODE_ENV !== "production") {
+            if (!(capture.startsWith("/") || capture.startsWith("http"))) {
+                throw new SerwistError("invalid-string", {
+                    moduleName: "@serwist/routing",
+                    funcName: "registerRoute",
+                    paramName: "capture"
+                });
+            }
+            const valueToCheck = capture.startsWith("http") ? captureUrl.pathname : capture;
+            const wildcards = "[*:?+]";
+            if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
+                logger.debug(`The '$capture' parameter contains an Express-style wildcard character (${wildcards}). Strings are now always interpreted as exact matches; use a RegExp for partial or wildcard matches.`);
+            }
+        }
+        const matchCallback = ({ url })=>{
+            if (process.env.NODE_ENV !== "production") {
+                if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
+                    logger.debug(`${capture} only partially matches the cross-origin URL ${url.toString()}. This route will only handle cross-origin requests if they match the entire URL.`);
+                }
+            }
+            return url.href === captureUrl.href;
+        };
+        route = new Route(matchCallback, handler, method);
+    } else if (capture instanceof RegExp) {
+        route = new RegExpRoute(capture, handler, method);
+    } else if (typeof capture === "function") {
+        route = new Route(capture, handler, method);
+    } else if (capture instanceof Route) {
+        route = capture;
+    } else {
+        throw new SerwistError("unsupported-route-type", {
+            moduleName: "@serwist/routing",
+            funcName: "registerRoute",
+            paramName: "capture"
+        });
+    }
+    return route;
+};
+
+class Router {
+    _routes;
+    _defaultHandlerMap;
+    _fetchListenerHandler = null;
+    _cacheListenerHandler = null;
+    _catchHandler;
+    constructor(){
+        this._routes = new Map();
+        this._defaultHandlerMap = new Map();
+    }
+    get routes() {
+        return this._routes;
+    }
+    addFetchListener() {
+        if (!this._fetchListenerHandler) {
+            this._fetchListenerHandler = (event)=>{
+                const { request } = event;
+                const responsePromise = this.handleRequest({
+                    request,
+                    event
+                });
+                if (responsePromise) {
+                    event.respondWith(responsePromise);
+                }
+            };
+            self.addEventListener("fetch", this._fetchListenerHandler);
+        }
+    }
+    removeFetchListener() {
+        if (this._fetchListenerHandler) {
+            self.removeEventListener("fetch", this._fetchListenerHandler);
+            this._fetchListenerHandler = null;
+        }
+    }
+    addCacheListener() {
+        if (!this._cacheListenerHandler) {
+            this._cacheListenerHandler = (event)=>{
+                if (event.data && event.data.type === "CACHE_URLS") {
+                    const { payload } = event.data;
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.debug("Caching URLs from the window", payload.urlsToCache);
+                    }
+                    const requestPromises = Promise.all(payload.urlsToCache.map((entry)=>{
+                        if (typeof entry === "string") {
+                            entry = [
+                                entry
+                            ];
+                        }
+                        const request = new Request(...entry);
+                        return this.handleRequest({
+                            request,
+                            event
+                        });
+                    }));
+                    event.waitUntil(requestPromises);
+                    if (event.ports?.[0]) {
+                        void requestPromises.then(()=>event.ports[0].postMessage(true));
+                    }
+                }
+            };
+            self.addEventListener("message", this._cacheListenerHandler);
+        }
+    }
+    removeCacheListener() {
+        if (this._cacheListenerHandler) {
+            self.removeEventListener("message", this._cacheListenerHandler);
+        }
+    }
+    handleRequest({ request, event }) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isInstance(request, Request, {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "handleRequest",
+                paramName: "options.request"
+            });
+        }
+        const url = new URL(request.url, location.href);
+        if (!url.protocol.startsWith("http")) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug("Router only supports URLs that start with 'http'.");
+            }
+            return;
+        }
+        const sameOrigin = url.origin === location.origin;
+        const { params, route } = this.findMatchingRoute({
+            event,
+            request,
+            sameOrigin,
+            url
+        });
+        let handler = route?.handler;
+        const debugMessages = [];
+        if (process.env.NODE_ENV !== "production") {
+            if (handler) {
+                debugMessages.push([
+                    "Found a route to handle this request:",
+                    route
+                ]);
+                if (params) {
+                    debugMessages.push([
+                        `Passing the following params to the route's handler:`,
+                        params
+                    ]);
+                }
+            }
+        }
+        const method = request.method;
+        if (!handler && this._defaultHandlerMap.has(method)) {
+            if (process.env.NODE_ENV !== "production") {
+                debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
+            }
+            handler = this._defaultHandlerMap.get(method);
+        }
+        if (!handler) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`No route found for: ${getFriendlyURL(url)}`);
+            }
+            return;
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+            for (const msg of debugMessages){
+                if (Array.isArray(msg)) {
+                    logger.log(...msg);
+                } else {
+                    logger.log(msg);
+                }
+            }
+            logger.groupEnd();
+        }
+        let responsePromise;
+        try {
+            responsePromise = handler.handle({
+                url,
+                request,
+                event,
+                params
+            });
+        } catch (err) {
+            responsePromise = Promise.reject(err);
+        }
+        const catchHandler = route?.catchHandler;
+        if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {
+            responsePromise = responsePromise.catch(async (err)=>{
+                if (catchHandler) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
+                        logger.error("Error thrown by:", route);
+                        logger.error(err);
+                        logger.groupEnd();
+                    }
+                    try {
+                        return await catchHandler.handle({
+                            url,
+                            request,
+                            event,
+                            params
+                        });
+                    } catch (catchErr) {
+                        if (catchErr instanceof Error) {
+                            err = catchErr;
+                        }
+                    }
+                }
+                if (this._catchHandler) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
+                        logger.error("Error thrown by:", route);
+                        logger.error(err);
+                        logger.groupEnd();
+                    }
+                    return this._catchHandler.handle({
+                        url,
+                        request,
+                        event
+                    });
+                }
+                throw err;
+            });
+        }
+        return responsePromise;
+    }
+    findMatchingRoute({ url, sameOrigin, request, event }) {
+        const routes = this._routes.get(request.method) || [];
+        for (const route of routes){
+            let params;
+            const matchResult = route.match({
+                url,
+                sameOrigin,
+                request,
+                event
+            });
+            if (matchResult) {
+                if (process.env.NODE_ENV !== "production") {
+                    if (matchResult instanceof Promise) {
+                        logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
+                    }
+                }
+                params = matchResult;
+                if (Array.isArray(params) && params.length === 0) {
+                    params = undefined;
+                } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
+                    params = undefined;
+                } else if (typeof matchResult === "boolean") {
+                    params = undefined;
+                }
+                return {
+                    route,
+                    params
+                };
+            }
+        }
+        return {};
+    }
+    setDefaultHandler(handler, method = defaultMethod) {
+        this._defaultHandlerMap.set(method, normalizeHandler(handler));
+    }
+    setCatchHandler(handler) {
+        this._catchHandler = normalizeHandler(handler);
+    }
+    registerCapture(capture, handler, method) {
+        const route = parseRoute(capture, handler, method);
+        this.registerRoute(route);
+        return route;
+    }
+    registerRoute(route) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(route, "object", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route"
+            });
+            assert.hasMethod(route, "match", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route"
+            });
+            assert.isType(route.handler, "object", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route"
+            });
+            assert.hasMethod(route.handler, "handle", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route.handler"
+            });
+            assert.isType(route.method, "string", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route.method"
+            });
+        }
+        if (!this._routes.has(route.method)) {
+            this._routes.set(route.method, []);
+        }
+        this._routes.get(route.method).push(route);
+    }
+    unregisterRoute(route) {
+        if (!this._routes.has(route.method)) {
+            throw new SerwistError("unregister-route-but-not-found-with-method", {
+                method: route.method
+            });
+        }
+        const routeIndex = this._routes.get(route.method).indexOf(route);
+        if (routeIndex > -1) {
+            this._routes.get(route.method).splice(routeIndex, 1);
+        } else {
+            throw new SerwistError("unregister-route-route-not-registered");
+        }
+    }
+}
+
+let defaultRouter = undefined;
+const getSingletonRouter = ()=>{
+    if (!defaultRouter) {
+        defaultRouter = new Router();
+        defaultRouter.addFetchListener();
+        defaultRouter.addCacheListener();
+    }
+    return defaultRouter;
+};
+const setSingletonRouter = (router)=>{
+    if (defaultRouter) {
+        defaultRouter.removeFetchListener();
+        defaultRouter.removeCacheListener();
+    }
+    defaultRouter = router;
+    defaultRouter.addFetchListener();
+    defaultRouter.addCacheListener();
+    return defaultRouter;
+};
+
+export { Route as R, RegExpRoute as a, Router as b, getSingletonRouter as g, parseRoute as p, setSingletonRouter as s };

package/dist/index.js

@@ -1,11 +1,12 @@
 import { setCacheNameDetails, clientsClaim } from '@serwist/core';
 import { P as PrecacheFallbackPlugin, i as initialize } from './chunks/PrecacheFallbackPlugin.js';
 import { p as precacheAndRoute, P as PrecacheRoute, c as cleanupOutdatedCaches, a as createHandlerBoundToURL } from './chunks/precacheAndRoute.js';
-import { g as getOrCreatePrecacheController } from './chunks/getOrCreatePrecacheController.js';
+import { g as getSingletonPrecacheController } from './chunks/singletonPrecacheController.js';
 import { N as NavigationRoute } from './chunks/NavigationRoute.js';
-import { g as getOrCreateDefaultRouter, p as parseRoute, r as registerRoute } from './chunks/registerRoute.js';
+import { g as getSingletonRouter, p as parseRoute } from './chunks/singletonRouter.js';
 import { S as Strategy } from './chunks/Strategy.js';
 import { logger } from '@serwist/core/internal';
+import { r as registerRoute } from './chunks/registerRoute.js';
 import './chunks/NetworkOnly.js';
 import 'idb';
 
@@ -68,10 +69,10 @@ class Serwist {
     _precacheController;
     _router;
     constructor({ precacheController, router } = {}){
-        this._precacheController = precacheController || getOrCreatePrecacheController();
-        this._router = router || getOrCreateDefaultRouter();
+        this._precacheController = precacheController || getSingletonPrecacheController();
+        this._router = router || getSingletonRouter();
     }
-    install({ precacheEntries, precacheOptions, cleanupOutdatedCaches: cleanupOutdatedCaches$1, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks: fallbacks$1 }) {
+    install({ precacheEntries, precacheOptions, cleanupOutdatedCaches: cleanupOutdatedCaches$1, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks: fallbacks$1 } = {}) {
         if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
         if (navigationPreload) enableNavigationPreload();
         if (cacheId !== undefined) {
@@ -140,8 +141,8 @@ const installSerwist = (options)=>{
         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/dist/index.plugins.js

@@ -2,10 +2,10 @@ export { B as BackgroundSyncPlugin, Q as BackgroundSyncQueue, a as BackgroundSyn
 import { SerwistError, logger, assert, resultingClientExists, timeout, getFriendlyURL, privateCacheNames } from '@serwist/core/internal';
 import { deleteDB, openDB } from 'idb';
 import { registerQuotaErrorCallback } from '@serwist/core';
-import './chunks/registerRoute.js';
+import './chunks/singletonRouter.js';
 import './chunks/NetworkOnly.js';
 import './chunks/Strategy.js';
-import './chunks/getOrCreatePrecacheController.js';
+import './chunks/singletonPrecacheController.js';
 
 const CACHE_UPDATED_MESSAGE_TYPE = "CACHE_UPDATED";
 const CACHE_UPDATED_MESSAGE_META = "serwist-broadcast-update";

package/dist/index.precaching.d.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
  * `@serwist/sw/precaching.precacheAndRoute`
@@ -19,6 +20,6 @@ import { precacheAndRoute } from "./precaching/precacheAndRoute.js";
  * `@serwist/precaching.PrecacheController`
  * interface.
  */
-export { addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute, PrecacheController, PrecacheRoute, PrecacheStrategy, };
+export { addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute, PrecacheController, PrecacheRoute, PrecacheStrategy, getSingletonPrecacheController, setSingletonPrecacheController, };
 export type * from "./precaching/types.js";
 //# sourceMappingURL=index.precaching.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.precaching.d.ts","sourceRoot":"","sources":["../src/index.precaching.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEpE;;;;;;;;;GASG;AAEH,OAAO,EACL,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,aAAa,EACb,gBAAgB,GACjB,CAAC;AAEF,mBAAmB,uBAAuB,CAAC"}
+{"version":3,"file":"index.precaching.d.ts","sourceRoot":"","sources":["../src/index.precaching.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,8BAA8B,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAE7H;;;;;;;;;GASG;AAEH,OAAO,EACL,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,8BAA8B,EAC9B,8BAA8B,GAC/B,CAAC;AAEF,mBAAmB,uBAAuB,CAAC"}

package/dist/index.precaching.js

@@ -1,24 +1,24 @@
-import { g as getOrCreatePrecacheController } from './chunks/getOrCreatePrecacheController.js';
-export { P as PrecacheController, a as PrecacheStrategy } from './chunks/getOrCreatePrecacheController.js';
+import { g as getSingletonPrecacheController } from './chunks/singletonPrecacheController.js';
+export { P as PrecacheController, a as PrecacheStrategy, s as setSingletonPrecacheController } from './chunks/singletonPrecacheController.js';
 export { P as PrecacheRoute, b as addRoute, c as cleanupOutdatedCaches, a as createHandlerBoundToURL, d as precache, p as precacheAndRoute } from './chunks/precacheAndRoute.js';
 import '@serwist/core/internal';
 import '@serwist/core';
 import './chunks/Strategy.js';
 import './chunks/registerRoute.js';
+import './chunks/singletonRouter.js';
 
 const addPlugins = (plugins)=>{
-    const precacheController = getOrCreatePrecacheController();
+    const precacheController = getSingletonPrecacheController();
     precacheController.strategy.plugins.push(...plugins);
 };
 
 function getCacheKeyForURL(url) {
-    const precacheController = getOrCreatePrecacheController();
+    const precacheController = getSingletonPrecacheController();
     return precacheController.getCacheKeyForURL(url);
 }
 
 const matchPrecache = (request)=>{
-    const precacheController = getOrCreatePrecacheController();
-    return precacheController.matchPrecache(request);
+    return getSingletonPrecacheController().matchPrecache(request);
 };
 
-export { addPlugins, getCacheKeyForURL, matchPrecache };
+export { addPlugins, getCacheKeyForURL, getSingletonPrecacheController, matchPrecache };

package/dist/index.routing.d.ts

@@ -3,11 +3,13 @@ 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 };
 //# sourceMappingURL=index.routing.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.routing.d.ts","sourceRoot":"","sources":["../src/index.routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE/D,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAC;AAE3H,YAAY,EAAE,UAAU,EAAE,2BAA2B,EAAE,CAAC"}
+{"version":3,"file":"index.routing.d.ts","sourceRoot":"","sources":["../src/index.routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACtF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE/D,OAAO,EACL,eAAe,EACf,WAAW,EACX,UAAU,EACV,aAAa,EACb,KAAK,EACL,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,GAChB,CAAC;AAEF,YAAY,EAAE,UAAU,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/index.routing.js

@@ -1,21 +1,19 @@
 export { N as NavigationRoute } from './chunks/NavigationRoute.js';
-import { g as getOrCreateDefaultRouter } from './chunks/registerRoute.js';
-export { a as RegExpRoute, R as Route, b as Router, r as registerRoute } from './chunks/registerRoute.js';
+import { g as getSingletonRouter } from './chunks/singletonRouter.js';
+export { a as RegExpRoute, R as Route, b as Router, p as parseRoute, s as setSingletonRouter } from './chunks/singletonRouter.js';
+export { r as registerRoute } from './chunks/registerRoute.js';
 import '@serwist/core/internal';
 
 const setCatchHandler = (handler)=>{
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.setCatchHandler(handler);
+    getSingletonRouter().setCatchHandler(handler);
 };
 
 const setDefaultHandler = (handler)=>{
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.setDefaultHandler(handler);
+    getSingletonRouter().setDefaultHandler(handler);
 };
 
 const unregisterRoute = (route)=>{
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.unregisterRoute(route);
+    getSingletonRouter().unregisterRoute(route);
 };
 
-export { setCatchHandler, setDefaultHandler, unregisterRoute };
+export { getSingletonRouter, setCatchHandler, setDefaultHandler, unregisterRoute };

package/dist/plugins/googleAnalytics/initialize.d.ts

@@ -1,4 +1,10 @@
+import type { Router } from "../../routing/Router.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`.
      */
@@ -20,7 +26,9 @@ export interface GoogleAnalyticsInitializeOptions {
     hitFilter?: (params: URLSearchParams) => void;
 }
 /**
+ * Initialize Serwist's offline Google Analytics v3 support.
+ *
  * @param options
  */
-export declare const initialize: (options?: GoogleAnalyticsInitializeOptions) => void;
+export declare const initialize: ({ cacheName, router, ...options }?: GoogleAnalyticsInitializeOptions) => void;
 //# sourceMappingURL=initialize.d.ts.map

package/dist/plugins/googleAnalytics/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/plugins/googleAnalytics/initialize.ts"],"names":[],"mappings":"AA4BA,MAAM,WAAW,gCAAgC;IAC/C;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACrD;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/C;AAyID;;GAEG;AACH,eAAO,MAAM,UAAU,aAAa,gCAAgC,KAAQ,IAa3E,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/plugins/googleAnalytics/initialize.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAatD,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACrD;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/C;AAyID;;;;GAIG;AACH,eAAO,MAAM,UAAU,uCAA8D,gCAAgC,KAAQ,IAkB5H,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../../src/precaching/addRoute.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,aAAc,oBAAoB,KAAG,IAKzD,CAAC"}
+{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../../src/precaching/addRoute.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,aAAc,oBAAoB,KAAG,IAKzD,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"matchPrecache.d.ts","sourceRoot":"","sources":["../../src/precaching/matchPrecache.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,OAAO,KAAG,QAAQ,QAAQ,GAAG,SAAS,CAGrF,CAAC"}
+{"version":3,"file":"matchPrecache.d.ts","sourceRoot":"","sources":["../../src/precaching/matchPrecache.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,OAAO,KAAG,QAAQ,QAAQ,GAAG,SAAS,CAErF,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"precache.d.ts","sourceRoot":"","sources":["../../src/precaching/precache.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,KAAG,IAG9D,CAAC"}
+{"version":3,"file":"precache.d.ts","sourceRoot":"","sources":["../../src/precaching/precache.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,KAAG,IAG9D,CAAC"}