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

package/src/precaching/createHandlerBoundToURL.ts

@@ -8,7 +8,7 @@
 
 import type { RouteHandlerCallback } from "@serwist/core";
 
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
+import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
 
 /**
  * Helper function that calls `PrecacheController#createHandlerBoundToURL`
@@ -25,6 +25,6 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  * @return
  */
 export const createHandlerBoundToURL = (url: string): RouteHandlerCallback => {
-  const precacheController = getOrCreatePrecacheController();
+  const precacheController = getSingletonPrecacheController();
   return precacheController.createHandlerBoundToURL(url);
 };

package/src/precaching/getCacheKeyForURL.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
+import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
 
 /**
  * Takes in a URL, and returns the corresponding URL that could be used to
@@ -26,7 +26,7 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  * @returns The cache key that corresponds to that URL.
  */
 function getCacheKeyForURL(url: string): string | undefined {
-  const precacheController = getOrCreatePrecacheController();
+  const precacheController = getSingletonPrecacheController();
   return precacheController.getCacheKeyForURL(url);
 }
 

package/src/precaching/matchPrecache.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
+import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
 
 /**
  * Helper function that calls `PrecacheController#matchPrecache`
@@ -21,6 +21,5 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  * @returns
  */
 export const matchPrecache = (request: string | Request): Promise<Response | undefined> => {
-  const precacheController = getOrCreatePrecacheController();
-  return precacheController.matchPrecache(request);
+  return getSingletonPrecacheController().matchPrecache(request);
 };

package/src/precaching/precache.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
+import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
 import type { PrecacheEntry } from "./types.js";
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
 
 /**
  * Adds items to the precache list, removing any duplicates and
@@ -26,6 +26,6 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  * @param entries Array of entries to precache.
  */
 export const precache = (entries: (PrecacheEntry | string)[]): void => {
-  const precacheController = getOrCreatePrecacheController();
+  const precacheController = getSingletonPrecacheController();
   precacheController.precache(entries);
 };

package/src/precaching/singletonPrecacheController.ts

@@ -0,0 +1,57 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { PrecacheController } from "./PrecacheController.js";
+
+let defaultPrecacheController: PrecacheController | undefined = undefined;
+
+/**
+ * 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 const getSingletonPrecacheController = (): PrecacheController => {
+  if (!defaultPrecacheController) {
+    defaultPrecacheController = new PrecacheController();
+  }
+  return defaultPrecacheController;
+};
+
+/**
+ * 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 const setSingletonPrecacheController = (precacheController: PrecacheController): PrecacheController => {
+  defaultPrecacheController = precacheController;
+  return defaultPrecacheController;
+};

package/src/precaching/utils/getCacheKeyForURL.ts

@@ -6,9 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
+import { getSingletonPrecacheController } from "../singletonPrecacheController.js";
 import type { PrecacheRouteOptions } from "../types.js";
 import { generateURLVariations } from "./generateURLVariations.js";
-import { getOrCreatePrecacheController } from "./getOrCreatePrecacheController.js";
 
 /**
  * This function will take the request URL and manipulate it based on the
@@ -22,7 +22,7 @@ import { getOrCreatePrecacheController } from "./getOrCreatePrecacheController.j
  * @private
  */
 export const getCacheKeyForURL = (url: string, options: PrecacheRouteOptions): string | undefined => {
-  const precacheController = getOrCreatePrecacheController();
+  const precacheController = getSingletonPrecacheController();
 
   const urlsToCacheKeys = precacheController.getURLsToCacheKeys();
   for (const possibleURL of generateURLVariations(url, options)) {

package/src/routing/RegExpRoute.ts

@@ -13,10 +13,10 @@ 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 class RegExpRoute extends Route {

package/src/routing/Router.ts

@@ -6,10 +6,11 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { RouteHandler, RouteHandlerCallbackOptions, RouteHandlerObject, RouteMatchCallbackOptions } from "@serwist/core";
+import type { RouteHandler, RouteHandlerCallbackOptions, RouteHandlerObject, RouteMatchCallback, RouteMatchCallbackOptions } from "@serwist/core";
 import { assert, SerwistError, getFriendlyURL, logger } from "@serwist/core/internal";
 
 import type { Route } from "./Route.js";
+import { parseRoute } from "./parseRoute.js";
 import type { HTTPMethod } from "./utils/constants.js";
 import { defaultMethod } from "./utils/constants.js";
 import { normalizeHandler } from "./utils/normalizeHandler.js";
@@ -26,20 +27,21 @@ interface CacheURLsMessageData {
 }
 
 /**
- * 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 class Router {
   private readonly _routes: Map<HTTPMethod, Route[]>;
   private readonly _defaultHandlerMap: Map<HTTPMethod, RouteHandlerObject>;
+  private _fetchListenerHandler: ((ev: FetchEvent) => void) | null = null;
+  private _cacheListenerHandler: ((ev: ExtendableMessageEvent) => void) | null = null;
   private _catchHandler?: RouteHandlerObject;
 
   /**
@@ -51,7 +53,7 @@ export class Router {
   }
 
   /**
-   * @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[]> {
@@ -59,23 +61,40 @@ export class Router {
   }
 
   /**
-   * 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 {
-    self.addEventListener("fetch", (event) => {
-      const { request } = event;
-      const responsePromise = this.handleRequest({ request, event });
-      if (responsePromise) {
-        event.respondWith(responsePromise);
-      }
-    });
+    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);
+    }
+  }
+
+  /**
+   * 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 {
+    if (this._fetchListenerHandler) {
+      self.removeEventListener("fetch", this._fetchListenerHandler);
+      this._fetchListenerHandler = null;
+    }
   }
 
   /**
-   * Adds a message event listener for URLs to cache from the window.
+   * 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
@@ -95,38 +114,52 @@ export class Router {
    * ```
    */
   addCacheListener(): void {
-    self.addEventListener("message", (event) => {
-      if (event.data && event.data.type === "CACHE_URLS") {
-        const { payload }: CacheURLsMessageData = event.data;
+    if (!this._cacheListenerHandler) {
+      this._cacheListenerHandler = (event) => {
+        if (event.data && event.data.type === "CACHE_URLS") {
+          const { payload }: CacheURLsMessageData = event.data;
 
-        if (process.env.NODE_ENV !== "production") {
-          logger.debug("Caching URLs from the window", payload.urlsToCache);
-        }
+          if (process.env.NODE_ENV !== "production") {
+            logger.debug("Caching URLs from the window", payload.urlsToCache);
+          }
 
-        const requestPromises = Promise.all(
-          payload.urlsToCache.map((entry: string | [string, RequestInit?]) => {
-            if (typeof entry === "string") {
-              entry = [entry];
-            }
+          const requestPromises = Promise.all(
+            payload.urlsToCache.map((entry: string | [string, RequestInit?]) => {
+              if (typeof entry === "string") {
+                entry = [entry];
+              }
 
-            const request = new Request(...entry);
-            return this.handleRequest({ request, event });
-          }),
-        );
+              const request = new Request(...entry);
+              return this.handleRequest({ request, event });
+            }),
+          );
 
-        event.waitUntil(requestPromises);
+          event.waitUntil(requestPromises);
 
-        // If a MessageChannel was used, reply to the message on success.
-        if (event.ports?.[0]) {
-          void requestPromises.then(() => event.ports[0].postMessage(true));
+          // If a MessageChannel was used, reply to the message on success.
+          if (event.ports?.[0]) {
+            void requestPromises.then(() => event.ports[0].postMessage(true));
+          }
         }
-      }
-    });
+      };
+      self.addEventListener("message", this._cacheListenerHandler);
+    }
+  }
+
+  /**
+   * 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 {
+    if (this._cacheListenerHandler) {
+      self.removeEventListener("message", this._cacheListenerHandler);
+    }
   }
 
   /**
-   * Apply the routing rules to a FetchEvent object to get a Response from an
-   * appropriate Route's handler.
+   * 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.
@@ -158,7 +191,7 @@ export class Router {
     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'.");
+        logger.debug("Router only supports URLs that start with 'http'.");
       }
       return;
     }
@@ -334,21 +367,21 @@ export 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 = defaultMethod): void {
     this._defaultHandlerMap.set(method, normalizeHandler(handler));
   }
 
   /**
-   * 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
@@ -359,9 +392,25 @@ export class Router {
   }
 
   /**
-   * 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 {
+    const route = parseRoute(capture, handler, method);
+    this.registerRoute(route);
+    return route;
+  }
+
+  /**
+   * Registers a `Route` with the router.
    *
-   * @param route The route to register.
+   * @param route The `Route` to register.
    */
   registerRoute(route: Route): void {
     if (process.env.NODE_ENV !== "production") {
@@ -411,9 +460,9 @@ export class Router {
   }
 
   /**
-   * 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 {
     if (!this._routes.has(route.method)) {

package/src/routing/{utils/parseRoute.ts → parseRoute.ts}

@@ -1,10 +1,21 @@
 import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
 import { SerwistError, logger } from "@serwist/core/internal";
 
-import { RegExpRoute } from "../RegExpRoute.js";
-import { Route } from "../Route.js";
-import type { HTTPMethod } from "./constants.js";
+import { RegExpRoute } from "./RegExpRoute.js";
+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 const parseRoute = (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route => {
   let route: Route;
 

package/src/routing/registerRoute.ts

@@ -9,25 +9,19 @@
 import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
 
 import { Route } from "./Route.js";
+import { getSingletonRouter } from "./singletonRouter.js";
 import type { HTTPMethod } from "./utils/constants.js";
-import { getOrCreateDefaultRouter } from "./utils/getOrCreateDefaultRouter.js";
-import { parseRoute } from "./utils/parseRoute.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 const registerRoute = (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route => {
-  const route = parseRoute(capture, handler, method);
-
-  const defaultRouter = getOrCreateDefaultRouter();
-  defaultRouter.registerRoute(route);
-
-  return route;
+  return getSingletonRouter().registerCapture(capture, handler, method);
 };

package/src/routing/setCatchHandler.ts

@@ -8,15 +8,14 @@
 
 import type { RouteHandler } from "@serwist/core";
 
-import { getOrCreateDefaultRouter } from "./utils/getOrCreateDefaultRouter.js";
+import { getSingletonRouter } from "./singletonRouter.js";
 
 /**
- * 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.
  */
 export const setCatchHandler = (handler: RouteHandler): void => {
-  const defaultRouter = getOrCreateDefaultRouter();
-  defaultRouter.setCatchHandler(handler);
+  getSingletonRouter().setCatchHandler(handler);
 };

package/src/routing/setDefaultHandler.ts

@@ -8,18 +8,17 @@
 
 import type { RouteHandler } from "@serwist/core";
 
-import { getOrCreateDefaultRouter } from "./utils/getOrCreateDefaultRouter.js";
+import { getSingletonRouter } from "./singletonRouter.js";
 
 /**
  * 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.
  */
 export const setDefaultHandler = (handler: RouteHandler): void => {
-  const defaultRouter = getOrCreateDefaultRouter();
-  defaultRouter.setDefaultHandler(handler);
+  getSingletonRouter().setDefaultHandler(handler);
 };

package/src/routing/singletonRouter.ts

@@ -0,0 +1,76 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { Router } from "./Router.js";
+
+let defaultRouter: Router | undefined = undefined;
+
+/**
+ * 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 const getSingletonRouter = (): Router => {
+  if (!defaultRouter) {
+    defaultRouter = new Router();
+
+    // The helpers that use the default Router assume these listeners exist.
+    defaultRouter.addFetchListener();
+    defaultRouter.addCacheListener();
+  }
+  return defaultRouter;
+};
+
+/**
+ * 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 const setSingletonRouter = (router: Router): Router => {
+  if (defaultRouter) {
+    defaultRouter.removeFetchListener();
+    defaultRouter.removeCacheListener();
+  }
+  defaultRouter = router;
+  defaultRouter.addFetchListener();
+  defaultRouter.addCacheListener();
+  return defaultRouter;
+};

package/src/routing/unregisterRoute.ts

@@ -1,12 +1,11 @@
 import type { Route } from "./Route.js";
-import { getOrCreateDefaultRouter } from "./utils/getOrCreateDefaultRouter.js";
+import { getSingletonRouter } from "./singletonRouter.js";
 
 /**
- * Unregisters a route from the singleton Router instance.
+ * Unregisters a route from the singleton `Router` instance.
  *
  * @param route The route to unregister.
  */
 export const unregisterRoute = (route: Route): void => {
-  const defaultRouter = getOrCreateDefaultRouter();
-  defaultRouter.unregisterRoute(route);
+  getSingletonRouter().unregisterRoute(route);
 };

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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/routing/utils/getOrCreateDefaultRouter.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/parseRoute.d.ts

@@ -1,5 +0,0 @@
-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

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