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

package/dist/abstractions/Serwist.d.ts

@@ -6,15 +6,13 @@ import { type HandlePrecachingOptions } from "./handlePrecaching.js";
 import type { RuntimeCaching } from "./types.js";
 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;
 }
@@ -79,6 +77,6 @@ export declare class Serwist {
     private _precacheController;
     private _router;
     constructor({ precacheController, router }?: SerwistOptions);
-    install({ precacheEntries, precacheOptions, cleanupOutdatedCaches, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, skipWaiting, importScripts, navigationPreload, cacheId, clientsClaim, runtimeCaching, offlineAnalyticsConfig, disableDevLogs, fallbacks, }: SerwistInstallOptions): void;
+    install({ precacheEntries, precacheOptions, cleanupOutdatedCaches, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, skipWaiting, importScripts, navigationPreload, cacheId, clientsClaim, runtimeCaching, offlineAnalyticsConfig, disableDevLogs, fallbacks, }?: SerwistInstallOptions): void;
 }
 //# sourceMappingURL=Serwist.d.ts.map

package/dist/abstractions/Serwist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Serwist.d.ts","sourceRoot":"","sources":["../../src/abstractions/Serwist.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gCAAgC,EAAc,MAAM,0CAA0C,CAAC;AAC7G,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAMzE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAK9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAsB,SAAQ,uBAAuB;IACpE;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,gCAAgC,GAAG,OAAO,CAAC;IACpE;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;CACtD;AAED,qBAAa,OAAO;IAClB,OAAO,CAAC,mBAAmB,CAAqB;IAChD,OAAO,CAAC,OAAO,CAAS;gBACZ,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAE,cAAmB;IAI/D,OAAO,CAAC,EACN,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,wBAAwB,EACxB,WAAmB,EACnB,aAAa,EACb,iBAAyB,EACzB,OAAO,EACP,YAAoB,EACpB,cAAc,EACd,sBAAsB,EACtB,cAAsB,EACtB,SAAS,GACV,EAAE,qBAAqB;CA8DzB"}
+{"version":3,"file":"Serwist.d.ts","sourceRoot":"","sources":["../../src/abstractions/Serwist.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gCAAgC,EAAc,MAAM,0CAA0C,CAAC;AAC7G,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAMzE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAK9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAsB,SAAQ,uBAAuB;IACpE;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,gCAAgC,GAAG,OAAO,CAAC;IACpE;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;CACtD;AAED,qBAAa,OAAO;IAClB,OAAO,CAAC,mBAAmB,CAAqB;IAChD,OAAO,CAAC,OAAO,CAAS;gBACZ,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAE,cAAmB;IAI/D,OAAO,CAAC,EACN,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,wBAAwB,EACxB,WAAmB,EACnB,aAAa,EACb,iBAAyB,EACzB,OAAO,EACP,YAAoB,EACpB,cAAc,EACd,sBAAsB,EACtB,cAAsB,EACtB,SAAS,GACV,GAAE,qBAA0B;CA8D9B"}

package/dist/chunks/NavigationRoute.js

@@ -1,5 +1,5 @@
 import { assert, logger } from '@serwist/core/internal';
-import { R as Route } from './registerRoute.js';
+import { R as Route } from './singletonRouter.js';
 
 class NavigationRoute extends Route {
     _allowlist;

package/dist/chunks/PrecacheFallbackPlugin.js

@@ -1,8 +1,8 @@
 import { assert, SerwistError, logger, getFriendlyURL, privateCacheNames } from '@serwist/core/internal';
-import { r as registerRoute, R as Route } from './registerRoute.js';
+import { g as getSingletonRouter, R as Route } from './singletonRouter.js';
 import { N as NetworkOnly, a as NetworkFirst } from './NetworkOnly.js';
 import { openDB } from 'idb';
-import { g as getOrCreatePrecacheController } from './getOrCreatePrecacheController.js';
+import { g as getSingletonPrecacheController } from './singletonPrecacheController.js';
 
 const DB_VERSION = 3;
 const DB_NAME = "serwist-background-sync";
@@ -528,20 +528,20 @@ const createGtmJsRoute = (cacheName)=>{
     });
     return new Route(match, handler, "GET");
 };
-const initialize = (options = {})=>{
-    const cacheName = privateCacheNames.getGoogleAnalyticsName(options.cacheName);
+const initialize = ({ cacheName, router = getSingletonRouter(), ...options } = {})=>{
+    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),
+        createGtmJsRoute(resolvedCacheName),
+        createAnalyticsJsRoute(resolvedCacheName),
+        createGtagJsRoute(resolvedCacheName),
         ...createCollectRoutes(bgSyncPlugin)
     ];
     for (const route of routes){
-        registerRoute(route);
+        router.registerRoute(route);
     }
 };
 
@@ -550,7 +550,7 @@ class PrecacheFallbackPlugin {
     _precacheController;
     constructor({ fallbackUrls, precacheController }){
         this._fallbackUrls = fallbackUrls;
-        this._precacheController = precacheController || getOrCreatePrecacheController();
+        this._precacheController = precacheController || getSingletonPrecacheController();
     }
     async handlerDidError(param) {
         for (const fallback of this._fallbackUrls){

package/dist/chunks/precacheAndRoute.js

@@ -1,6 +1,7 @@
 import { logger, getFriendlyURL, privateCacheNames } from '@serwist/core/internal';
-import { g as getOrCreatePrecacheController } from './getOrCreatePrecacheController.js';
-import { R as Route, r as registerRoute } from './registerRoute.js';
+import { g as getSingletonPrecacheController } from './singletonPrecacheController.js';
+import { r as registerRoute } from './registerRoute.js';
+import { R as Route } from './singletonRouter.js';
 
 function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {
     for (const paramName of [
@@ -89,18 +90,18 @@ const cleanupOutdatedCaches = ()=>{
 };
 
 const createHandlerBoundToURL = (url)=>{
-    const precacheController = getOrCreatePrecacheController();
+    const precacheController = getSingletonPrecacheController();
     return precacheController.createHandlerBoundToURL(url);
 };
 
 const addRoute = (options)=>{
-    const precacheController = getOrCreatePrecacheController();
+    const precacheController = getSingletonPrecacheController();
     const precacheRoute = new PrecacheRoute(precacheController, options);
     registerRoute(precacheRoute);
 };
 
 const precache = (entries)=>{
-    const precacheController = getOrCreatePrecacheController();
+    const precacheController = getSingletonPrecacheController();
     precacheController.precache(entries);
 };
 

package/dist/chunks/registerRoute.js

@@ -1,408 +1,7 @@
-import { assert, logger, getFriendlyURL, SerwistError } 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 Router {
-    _routes;
-    _defaultHandlerMap;
-    _catchHandler;
-    constructor(){
-        this._routes = new Map();
-        this._defaultHandlerMap = new Map();
-    }
-    get routes() {
-        return this._routes;
-    }
-    addFetchListener() {
-        self.addEventListener("fetch", (event)=>{
-            const { request } = event;
-            const responsePromise = this.handleRequest({
-                request,
-                event
-            });
-            if (responsePromise) {
-                event.respondWith(responsePromise);
-            }
-        });
-    }
-    addCacheListener() {
-        self.addEventListener("message", (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));
-                }
-            }
-        });
-    }
-    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("The Serwist 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);
-    }
-    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;
-const getOrCreateDefaultRouter = ()=>{
-    if (!defaultRouter) {
-        defaultRouter = new Router();
-        defaultRouter.addFetchListener();
-        defaultRouter.addCacheListener();
-    }
-    return defaultRouter;
-};
-
-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;
-};
+import { g as getSingletonRouter } from './singletonRouter.js';
 
 const registerRoute = (capture, handler, method)=>{
-    const route = parseRoute(capture, handler, method);
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.registerRoute(route);
-    return route;
+    return getSingletonRouter().registerCapture(capture, handler, method);
 };
 
-export { Route as R, RegExpRoute as a, Router as b, getOrCreateDefaultRouter as g, parseRoute as p, registerRoute as r };
+export { registerRoute as r };

package/dist/chunks/{getOrCreatePrecacheController.js → singletonPrecacheController.js}

@@ -418,12 +418,16 @@ class PrecacheController {
     }
 }
 
-let precacheController;
-const getOrCreatePrecacheController = ()=>{
-    if (!precacheController) {
-        precacheController = new PrecacheController();
+let defaultPrecacheController = undefined;
+const getSingletonPrecacheController = ()=>{
+    if (!defaultPrecacheController) {
+        defaultPrecacheController = new PrecacheController();
     }
-    return precacheController;
+    return defaultPrecacheController;
+};
+const setSingletonPrecacheController = (precacheController)=>{
+    defaultPrecacheController = precacheController;
+    return defaultPrecacheController;
 };
 
-export { PrecacheController as P, PrecacheStrategy as a, getOrCreatePrecacheController as g };
+export { PrecacheController as P, PrecacheStrategy as a, getSingletonPrecacheController as g, setSingletonPrecacheController as s };