serwist 9.0.0-preview.25 → 9.0.0

package/src/index.internal.ts

@@ -5,6 +5,8 @@ import { cacheMatchIgnoreParams } from "./utils/cacheMatchIgnoreParams.js";
 import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
 import { canConstructReadableStream } from "./utils/canConstructReadableStream.js";
 import { canConstructResponseFromBodyStream } from "./utils/canConstructResponseFromBodyStream.js";
+import { cleanupOutdatedCaches } from "./utils/cleanupOutdatedCaches.js";
+import { clientsClaim } from "./utils/clientsClaim.js";
 import { dontWaitFor } from "./utils/dontWaitFor.js";
 import { executeQuotaErrorCallbacks } from "./utils/executeQuotaErrorCallbacks.js";
 import { getFriendlyURL } from "./utils/getFriendlyURL.js";
@@ -19,6 +21,8 @@ export {
   Deferred,
   SerwistError,
   assert,
+  cleanupOutdatedCaches,
+  clientsClaim,
   cacheMatchIgnoreParams,
   privateCacheNames,
   canConstructReadableStream,

package/src/index.legacy.ts

@@ -1,7 +1,3 @@
-import { NavigationRoute } from "./NavigationRoute.js";
-import { RegExpRoute } from "./RegExpRoute.js";
-import { Route } from "./Route.js";
-import { cleanupOutdatedCaches } from "./cleanupOutdatedCaches.js";
 import { PrecacheController } from "./legacy/PrecacheController.js";
 import { PrecacheFallbackPlugin } from "./legacy/PrecacheFallbackPlugin.js";
 import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./legacy/PrecacheFallbackPlugin.js";
@@ -27,19 +23,8 @@ import { setDefaultHandler } from "./legacy/setDefaultHandler.js";
 import { getSingletonPrecacheController, setSingletonPrecacheController } from "./legacy/singletonPrecacheController.js";
 import { getSingletonRouter, setSingletonRouter } from "./legacy/singletonRouter.js";
 import { unregisterRoute } from "./legacy/unregisterRoute.js";
-import { PrecacheOnly } from "./lib/strategies/PrecacheOnly.js";
-import { parseRoute } from "./parseRoute.js";
 
 export {
-  // These are not deprecated, but we export them so legacy packages
-  // can re-export them without having to import both the normal and legacy
-  // import paths.
-  NavigationRoute,
-  PrecacheOnly,
-  RegExpRoute,
-  Route,
-  cleanupOutdatedCaches,
-  parseRoute,
   // Actual deprecated modules start here
   addPlugins,
   addRoute,

package/src/index.ts

@@ -5,8 +5,6 @@ import { RegExpRoute } from "./RegExpRoute.js";
 import { Route } from "./Route.js";
 import { Serwist, type SerwistOptions } from "./Serwist.js";
 import { cacheNames } from "./cacheNames.js";
-import { cleanupOutdatedCaches } from "./cleanupOutdatedCaches.js";
-import { clientsClaim } from "./clientsClaim.js";
 import type { HTTPMethod } from "./constants.js";
 import { copyResponse } from "./copyResponse.js";
 import { disableDevLogs } from "./disableDevLogs.js";
@@ -38,13 +36,12 @@ import type { NetworkFirstOptions } from "./lib/strategies/NetworkFirst.js";
 import { NetworkFirst } from "./lib/strategies/NetworkFirst.js";
 import type { NetworkOnlyOptions } from "./lib/strategies/NetworkOnly.js";
 import { NetworkOnly } from "./lib/strategies/NetworkOnly.js";
-import { PrecacheOnly } from "./lib/strategies/PrecacheOnly.js";
+import { PrecacheStrategy } from "./lib/strategies/PrecacheStrategy.js";
 import { StaleWhileRevalidate } from "./lib/strategies/StaleWhileRevalidate.js";
 import type { StrategyOptions } from "./lib/strategies/Strategy.js";
 import { Strategy } from "./lib/strategies/Strategy.js";
 import { StrategyHandler } from "./lib/strategies/StrategyHandler.js";
 import { disableNavigationPreload, enableNavigationPreload, isNavigationPreloadSupported } from "./navigationPreload.js";
-import { parseRoute } from "./parseRoute.js";
 import { registerQuotaErrorCallback } from "./registerQuotaErrorCallback.js";
 import { setCacheNameDetails } from "./setCacheNameDetails.js";
 
@@ -52,19 +49,19 @@ export {
   // Core
   Serwist,
   cacheNames,
-  cleanupOutdatedCaches,
-  clientsClaim,
   copyResponse,
   disableDevLogs,
   disableNavigationPreload,
   enableNavigationPreload,
   isNavigationPreloadSupported,
+  registerQuotaErrorCallback,
+  setCacheNameDetails,
   // Caching strategies
   CacheFirst,
   CacheOnly,
   NetworkFirst,
   NetworkOnly,
-  PrecacheOnly,
+  PrecacheStrategy,
   StaleWhileRevalidate,
   Strategy,
   StrategyHandler,
@@ -73,7 +70,6 @@ export {
   PrecacheRoute,
   RegExpRoute,
   Route,
-  parseRoute,
   // Background synchronizing
   BackgroundSyncPlugin,
   BackgroundSyncQueue,
@@ -97,9 +93,6 @@ export {
   // Handling range requests
   createPartialResponse,
   RangeRequestsPlugin,
-  // Misc
-  registerQuotaErrorCallback,
-  setCacheNameDetails,
 };
 export type {
   // Core

package/src/legacy/PrecacheController.ts

@@ -7,7 +7,7 @@
 */
 
 import { parallel } from "@serwist/utils";
-import { PrecacheOnly } from "../lib/strategies/PrecacheOnly.js";
+import { PrecacheStrategy } from "../lib/strategies/PrecacheStrategy.js";
 import type { Strategy } from "../lib/strategies/Strategy.js";
 import type { RouteHandlerCallback, SerwistPlugin } from "../types.js";
 import type { CleanupResult, InstallResult, PrecacheEntry } from "../types.js";
@@ -67,7 +67,7 @@ export class PrecacheController {
    */
   constructor({ cacheName, plugins = [], fallbackToNetwork = true, concurrentPrecaching = 1 }: PrecacheControllerOptions = {}) {
     this._concurrentPrecaching = concurrentPrecaching;
-    this._strategy = new PrecacheOnly({
+    this._strategy = new PrecacheStrategy({
       cacheName: privateCacheNames.getPrecacheName(cacheName),
       plugins: [...plugins, new PrecacheCacheKeyPlugin({ precacheController: this })],
       fallbackToNetwork,

package/src/legacy/Router.ts

@@ -9,13 +9,13 @@
 import type { Route } from "../Route.js";
 import type { HTTPMethod } from "../constants.js";
 import { defaultMethod } from "../constants.js";
-import { parseRoute } from "../parseRoute.js";
 import type { RouteHandler, RouteHandlerCallbackOptions, RouteHandlerObject, RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
 import { SerwistError } from "../utils/SerwistError.js";
 import { assert } from "../utils/assert.js";
 import { getFriendlyURL } from "../utils/getFriendlyURL.js";
 import { logger } from "../utils/logger.js";
 import { normalizeHandler } from "../utils/normalizeHandler.js";
+import { parseRoute } from "../utils/parseRoute.js";
 
 declare const self: ServiceWorkerGlobalScope;
 

package/src/legacy/handlePrecaching.ts

@@ -1,6 +1,6 @@
 import { NavigationRoute } from "../NavigationRoute.js";
-import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "../cleanupOutdatedCaches.js";
 import type { PrecacheEntry, PrecacheRouteOptions } from "../types.js";
+import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "../utils/cleanupOutdatedCaches.js";
 import type { PrecacheController } from "./PrecacheController.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
 import type { Router } from "./Router.js";

package/src/legacy/installSerwist.ts

@@ -1,8 +1,8 @@
-import { clientsClaim as clientsClaimImpl } from "../clientsClaim.js";
 import { disableDevLogs as disableDevLogsImpl } from "../disableDevLogs.js";
 import { enableNavigationPreload } from "../navigationPreload.js";
 import { setCacheNameDetails } from "../setCacheNameDetails.js";
 import type { RuntimeCaching } from "../types.js";
+import { clientsClaim as clientsClaimImpl } from "../utils/clientsClaim.js";
 import type { PrecacheController } from "./PrecacheController.js";
 import type { Router } from "./Router.js";
 import type { FallbacksOptions } from "./fallbacks.js";

package/src/lib/backgroundSync/StorableRequest.ts

@@ -41,7 +41,7 @@ export class StorableRequest {
 
   /**
    * Converts a Request object to a plain object that can be structured
-   * cloned or JSON-stringified.
+   * cloned or stringified to JSON.
    *
    * @param request
    * @returns
@@ -79,8 +79,8 @@ export class StorableRequest {
    * Accepts an object of request data that can be used to construct a
    * `Request` but can also be stored in IndexedDB.
    *
-   * @param requestData An object of request data that includes the `url` plus any relevant properties of
-   * [requestInit](https://fetch.spec.whatwg.org/#requestinit).
+   * @param requestData An object of request data that includes the `url` plus any relevant property of
+   * [`requestInit`](https://fetch.spec.whatwg.org/#requestinit).
    */
   constructor(requestData: RequestData) {
     if (process.env.NODE_ENV !== "production") {
@@ -108,7 +108,7 @@ export class StorableRequest {
   }
 
   /**
-   * Returns a deep clone of the instances `_requestData` object.
+   * Returns a deep clone of the instance's `requestData` object.
    *
    * @returns
    */

package/src/lib/expiration/ExpirationPlugin.ts

@@ -62,7 +62,7 @@ export interface ExpirationPluginOptions {
  * When using `maxEntries`, the least recently requested entry will be removed
  * from the cache.
  *
- * @see https://serwist.pages.dev/docs/serwist/plugins/expiration-plugin
+ * @see https://serwist.pages.dev/docs/serwist/runtime-caching/plugins/expiration-plugin
  */
 export class ExpirationPlugin implements SerwistPlugin {
   private readonly _config: ExpirationPluginOptions;

package/src/lib/precaching/PrecacheFallbackPlugin.ts

@@ -40,10 +40,6 @@ export interface PrecacheFallbackPluginOptions {
  * It does this by intercepting the `handlerDidError` plugin callback
  * and returning a precached response, taking the expected revision parameter
  * into account automatically.
- *
- * Unless you explicitly pass in a `PrecacheController` instance to the
- * constructor, the default instance will be used. Generally speaking, most
- * developers will end up using the default.
  */
 export class PrecacheFallbackPlugin implements SerwistPlugin {
   private readonly _fallbackUrls: (string | PrecacheFallbackEntry)[];

package/src/lib/strategies/CacheFirst.ts

@@ -18,7 +18,7 @@ import { messages } from "./utils/messages.js";
  * request strategy.
  *
  * A cache first strategy is useful for assets that have been revisioned,
- * such as URLs like `/styles/example.a8f5f1.css`, since they
+ * such as URLs like "/styles/example.a8f5f1.css", since they
  * can be cached for long periods of time.
  *
  * If the network request fails, and there is no cache match, this will throw

package/src/lib/strategies/CacheOnly.ts

@@ -14,10 +14,10 @@ import type { StrategyHandler } from "./StrategyHandler.js";
 import { messages } from "./utils/messages.js";
 
 /**
- * An implementation of the [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only)
+ * An implementation of the [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache_only)
  * request strategy.
  *
- * This class is useful if you want to take advantage of any Serwist plugin.
+ * This class is useful if you already have your own precaching step.
  *
  * If there is no cache match, this will throw a `SerwistError` exception.
  */

package/src/lib/strategies/NetworkFirst.ts

@@ -23,11 +23,11 @@ export interface NetworkFirstOptions extends StrategyOptions {
 }
 
 /**
- * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache)
+ * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network_first_falling_back_to_cache)
  * request strategy.
  *
  * By default, this strategy will cache responses with a 200 status code as
- * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
+ * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque_responses).
  * Opaque responses are are cross-origin requests where the response doesn't
  * support [CORS](https://enable-cors.org/).
  *

package/src/lib/strategies/NetworkOnly.ts

@@ -23,10 +23,10 @@ export interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" |
 }
 
 /**
- * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-only)
+ * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network_only)
  * request strategy.
  *
- * This class is useful if you want to take advantage of any Serwist plugin.
+ * This class is useful if you require specific requests to only be fulfilled from the network.
  *
  * If the network request fails, this will throw a `SerwistError` exception.
  */

package/src/lib/strategies/{PrecacheOnly.ts → PrecacheStrategy.ts}

@@ -31,7 +31,7 @@ interface PrecacheStrategyOptions extends StrategyOptions {
  * Note: an instance of this class is created automatically when creating a
  * `Serwist` instance; it's generally not necessary to create this yourself.
  */
-export class PrecacheOnly extends Strategy {
+export class PrecacheStrategy extends Strategy {
   private readonly _fallbackToNetwork: boolean;
 
   static readonly defaultPrecacheCacheabilityPlugin: SerwistPlugin = {
@@ -64,7 +64,7 @@ export class PrecacheOnly extends Strategy {
     // any redirected response must be "copied" rather than cloned, so the new
     // response doesn't contain the `redirected` flag. See:
     // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1
-    this.plugins.push(PrecacheOnly.copyRedirectedCacheableResponsesPlugin);
+    this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
   }
 
   /**
@@ -218,12 +218,12 @@ export class PrecacheOnly extends Strategy {
 
     for (const [index, plugin] of this.plugins.entries()) {
       // Ignore the copy redirected plugin when determining what to do.
-      if (plugin === PrecacheOnly.copyRedirectedCacheableResponsesPlugin) {
+      if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
         continue;
       }
 
       // Save the default plugin's index, in case it needs to be removed.
-      if (plugin === PrecacheOnly.defaultPrecacheCacheabilityPlugin) {
+      if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
         defaultPluginIndex = index;
       }
 
@@ -233,7 +233,7 @@ export class PrecacheOnly extends Strategy {
     }
 
     if (cacheWillUpdatePluginCount === 0) {
-      this.plugins.push(PrecacheOnly.defaultPrecacheCacheabilityPlugin);
+      this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
     } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
       // Only remove the default plugin; multiple custom plugins are allowed.
       this.plugins.splice(defaultPluginIndex, 1);

package/src/lib/strategies/StaleWhileRevalidate.ts

@@ -17,7 +17,7 @@ import { messages } from "./utils/messages.js";
 
 /**
  * An implementation of the
- * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#stale-while-revalidate)
+ * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#stale_while_revalidate)
  * request strategy.
  *
  * Resources are requested from both the cache and the network in parallel.

package/src/lib/strategies/Strategy.ts

@@ -19,27 +19,26 @@ export interface StrategyOptions {
    */
   cacheName?: string;
   /**
-   * [Plugins](https://developer.chrome.com/docs/workbox/using-plugins)
-   * to use in conjunction with this caching strategy.
+   * [Plugins](https://serwist.pages.dev/docs/serwist/runtime-caching/plugins) to use in conjunction with this caching strategy.
    */
   plugins?: SerwistPlugin[];
   /**
-   * Values passed along to the [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
-   * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) `fetch()` requests made by this strategy.
+   * Options passed to [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) `fetch()` calls made by
+   * this strategy.
    */
   fetchOptions?: RequestInit;
   /**
    * The [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
-   * for any `cache.match()` or `cache.put()` calls made by this strategy.
+   * passed to any `cache.match()` or `cache.put()` call made by this strategy.
    */
   matchOptions?: CacheQueryOptions;
 }
 
 /**
- * Classes extending the `Strategy` based class should implement this method,
- * and leverage `serwist/strategies`'s `StrategyHandler` arg to perform all
- * fetching and cache logic, which will ensure all relevant cache, cache options,
- * fetch options and plugins are used (per the current strategy instance).
+ * Abstract class for implementing runtime caching strategies.
+ *
+ * Custom strategies should extend this class and leverage `StrategyHandler`, which will ensure all relevant cache options,
+ * fetch options, and plugins are used (per the current strategy instance), to perform all fetching and caching logic.
  */
 export abstract class Strategy implements RouteHandlerObject {
   cacheName: string;
@@ -67,7 +66,7 @@ export abstract class Strategy implements RouteHandlerObject {
   }
 
   /**
-   * Perform a request strategy and returns a `Promise` that will resolve with
+   * Performs a request strategy and returns a `Promise` that will resolve with
    * a `Response`, invoking all relevant plugin callbacks.
    *
    * When a strategy instance is registered with a `Route`, this method is automatically
@@ -88,12 +87,11 @@ export abstract class Strategy implements RouteHandlerObject {
   }
 
   /**
-   * Similar to `serwist/strategies`'s `Strategy.handle`, but
-   * instead of just returning a `Promise` that resolves to a `Response` it
-   * it will return an tuple of `[response, done]` promises, where the former
-   * (`response`) is equivalent to what `handle()` returns, and the latter is a
-   * Promise that will resolve once any promises that were added to
-   * `event.waitUntil()` as part of performing the strategy have completed.
+   * Similar to `handle()`, but instead of just returning a `Promise` that
+   * resolves to a `Response`, it will return an tuple of `[response, done]` promises,
+   * where `response` is equivalent to what `handle()` returns, and `done` is a
+   * `Promise` that will resolve once all promises added to `event.waitUntil()` as a part
+   * of performing the strategy have completed.
    *
    * You can await the `done` promise to ensure any extra work performed by
    * the strategy (usually caching responses) completes successfully.

package/src/lib/strategies/StrategyHandler.ts

@@ -22,9 +22,9 @@ function toRequest(input: RequestInfo) {
 }
 
 /**
- * A class created every time a Strategy instance instance calls `Strategy.handle` or
+ * A class created every time a `Strategy` instance calls `Strategy.handle` or
  * `Strategy.handleAll` that wraps all fetch and cache actions around plugin callbacks
- * and keeps track of when the strategy is "done" (i.e. all added `event.waitUntil()` promises
+ * and keeps track of when the strategy is "done" (i.e. when all added `event.waitUntil()` promises
  * have resolved).
  */
 export class StrategyHandler {
@@ -33,23 +33,23 @@ export class StrategyHandler {
    */
   public event: ExtendableEvent;
   /**
-   * The request the strategy is performing (passed to the strategy's
+   * The request the strategy is processing (passed to the strategy's
    * `handle()` or `handleAll()` method).
    */
   public request: Request;
   /**
    * A `URL` instance of `request.url` (if passed to the strategy's
    * `handle()` or `handleAll()` method).
-   * Note: the `url` param will be present if the strategy was invoked
+   * Note: the `url` param will be present if the strategy is invoked
    * from a `Route` object.
    */
   public url?: URL;
   /**
-   * A `param` value (if passed to the strategy's
+   * Some additional params (if passed to the strategy's
    * `handle()` or `handleAll()` method).
-   * Note: the `param` param will be present if the strategy was invoked
-   * from a `Route` object and the `serwist/strategies.matchCallback`
-   * returned a truthy value (it will be that value).
+   * Note: the `params` param will be present if the strategy is invoked
+   * from a `Route` object and that route's matcher returned a truthy value
+   * (it will be that value).
    */
   public params?: string[] | MapLikeObject;
 
@@ -114,8 +114,8 @@ export class StrategyHandler {
 
   /**
    * Fetches a given request (and invokes any applicable plugin callback
-   * methods) using the `fetchOptions` (for non-navigation requests) and
-   * `plugins` defined on the `Strategy` object.
+   * methods), taking the `fetchOptions` (for non-navigation requests) and
+   * `plugins` provided to the `Strategy` object into account.
    *
    * The following plugin lifecycle methods are invoked when using this method:
    * - `requestWillFetch()`
@@ -199,11 +199,10 @@ export class StrategyHandler {
   }
 
   /**
-   * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on
-   * the response generated by `this.fetch()`.
+   * Calls `this.fetch()` and (in the background) caches the generated response.
    *
    * The call to `this.cachePut()` automatically invokes `this.waitUntil()`,
-   * so you do not have to manually call `waitUntil()` on the event.
+   * so you do not have to call `waitUntil()` yourself.
    *
    * @param input The request or URL to fetch and cache.
    * @returns
@@ -219,14 +218,14 @@ export class StrategyHandler {
 
   /**
    * Matches a request from the cache (and invokes any applicable plugin
-   * callback methods) using the `cacheName`, `matchOptions`, and `plugins`
-   * defined on the strategy object.
+   * callback method) using the `cacheName`, `matchOptions`, and `plugins`
+   * provided to the `Strategy` object.
    *
-   * The following plugin lifecycle methods are invoked when using this method:
-   * - cacheKeyWillByUsed()
-   * - cachedResponseWillByUsed()
+   * The following lifecycle methods are invoked when using this method:
+   * - `cacheKeyWillByUsed`
+   * - `cachedResponseWillByUsed`
    *
-   * @param key The Request or URL to use as the cache key.
+   * @param key The `Request` or `URL` object to use as the cache key.
    * @returns A matching response, if found.
    */
   async cacheMatch(key: RequestInfo): Promise<Response | undefined> {
@@ -261,14 +260,14 @@ export class StrategyHandler {
   }
 
   /**
-   * Puts a request/response pair in the cache (and invokes any applicable
-   * plugin callback methods) using the `cacheName` and `plugins` defined on
-   * the strategy object.
+   * Puts a request/response pair into the cache (and invokes any applicable
+   * plugin callback method) using the `cacheName` and `plugins` provided to
+   * the `Strategy` object.
    *
    * The following plugin lifecycle methods are invoked when using this method:
-   * - cacheKeyWillByUsed()
-   * - cacheWillUpdate()
-   * - cacheDidUpdate()
+   * - `cacheKeyWillByUsed`
+   * - `cacheWillUpdate`
+   * - `cacheDidUpdate`
    *
    * @param key The request or URL to use as the cache key.
    * @param response The response to cache.
@@ -370,11 +369,11 @@ export class StrategyHandler {
   }
 
   /**
-   * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and
-   * executes any of those callbacks found in sequence. The final `Request`
+   * Checks the `plugins` provided to the `Strategy` object for `cacheKeyWillBeUsed`
+   * callbacks and executes found callbacks in sequence. The final `Request`
    * object returned by the last plugin is treated as the cache key for cache
    * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have
-   * been registered, the passed request is returned unmodified
+   * been registered, the passed request is returned unmodified.
    *
    * @param request
    * @param mode
@@ -402,7 +401,7 @@ export class StrategyHandler {
   }
 
   /**
-   * Returns true if the strategy has at least one plugin with the given
+   * Returns `true` if the strategy has at least one plugin with the given
    * callback.
    *
    * @param name The name of the callback to check for.
@@ -419,8 +418,7 @@ export class StrategyHandler {
 
   /**
    * Runs all plugin callbacks matching the given name, in order, passing the
-   * given param object (merged ith the current plugin state) as the only
-   * argument.
+   * given param object as the only argument.
    *
    * Note: since this method runs all plugins, it's not suitable for cases
    * where the return value of a callback needs to be applied prior to calling
@@ -439,10 +437,7 @@ export class StrategyHandler {
   }
 
   /**
-   * Accepts a callback and returns an iterable of matching plugin callbacks,
-   * where each callback is wrapped with the current handler state (i.e. when
-   * you call each callback, whatever object parameter you pass it will
-   * be merged with the plugin's current state).
+   * Accepts a callback name and returns an iterable of matching plugin callbacks.
    *
    * @param name The name fo the callback to run
    * @returns
@@ -482,12 +477,11 @@ export class StrategyHandler {
 
   /**
    * Returns a promise that resolves once all promises passed to
-   * `serwist/strategies.StrategyHandler.waitUntil` have settled.
+   * `this.waitUntil()` have settled.
    *
    * Note: any work done after `doneWaiting()` settles should be manually
-   * passed to an event's `waitUntil()` method (not this handler's
-   * `waitUntil()` method), otherwise the service worker thread my be killed
-   * prior to your work completing.
+   * passed to an event's `waitUntil()` method (not `this.waitUntil()`), otherwise
+   * the service worker thread may be killed prior to your work completing.
    */
   async doneWaiting(): Promise<void> {
     let promise: Promise<any> | undefined = undefined;
@@ -498,7 +492,7 @@ export class StrategyHandler {
 
   /**
    * Stops running the strategy and immediately resolves any pending
-   * `waitUntil()` promises.
+   * `waitUntil()` promise.
    */
   destroy(): void {
     this._handlerDeferred.resolve(null);

package/src/{cleanupOutdatedCaches.ts → utils/cleanupOutdatedCaches.ts}

@@ -6,10 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
-import { logger } from "./utils/logger.js";
-
-import { deleteOutdatedCaches } from "./utils/deleteOutdatedCaches.js";
+import { cacheNames as privateCacheNames } from "./cacheNames.js";
+import { deleteOutdatedCaches } from "./deleteOutdatedCaches.js";
+import { logger } from "./logger.js";
 
 declare const self: ServiceWorkerGlobalScope;
 

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

@@ -1,9 +1,9 @@
-import { RegExpRoute } from "./RegExpRoute.js";
-import { Route } from "./Route.js";
-import type { HTTPMethod } from "./constants.js";
-import type { RouteHandler, RouteMatchCallback } from "./types.js";
-import { SerwistError } from "./utils/SerwistError.js";
-import { logger } from "./utils/logger.js";
+import { RegExpRoute } from "../RegExpRoute.js";
+import { Route } from "../Route.js";
+import type { HTTPMethod } from "../constants.js";
+import type { RouteHandler, RouteMatchCallback } from "../types.js";
+import { SerwistError } from "./SerwistError.js";
+import { logger } from "./logger.js";
 
 /**
  * Parses a `RegExp`, string, or function with a caching strategy into a `Route`. This is for
@@ -17,8 +17,6 @@ import { logger } from "./utils/logger.js";
  * @returns The generated `Route`.
  */
 export const parseRoute = (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route => {
-  let route: Route;
-
   if (typeof capture === "string") {
     const captureUrl = new URL(capture, location.href);
 
@@ -57,22 +55,22 @@ export const parseRoute = (capture: RegExp | string | RouteMatchCallback | Route
     };
 
     // If `capture` is a string then `handler` and `method` must be present.
-    route = new Route(matchCallback, handler!, method);
-  } else if (capture instanceof RegExp) {
+    return new Route(matchCallback, handler!, method);
+  }
+  if (capture instanceof RegExp) {
     // If `capture` is a `RegExp` then `handler` and `method` must be present.
-    route = new RegExpRoute(capture, handler!, method);
-  } else if (typeof capture === "function") {
+    return new RegExpRoute(capture, handler!, method);
+  }
+  if (typeof capture === "function") {
     // If `capture` is a function then `handler` and `method` must be present.
-    route = new Route(capture, handler!, method);
-  } else if (capture instanceof Route) {
-    route = capture;
-  } else {
-    throw new SerwistError("unsupported-route-type", {
-      moduleName: "serwist",
-      funcName: "parseRoute",
-      paramName: "capture",
-    });
+    return new Route(capture, handler!, method);
   }
-
-  return route;
+  if (capture instanceof Route) {
+    return capture;
+  }
+  throw new SerwistError("unsupported-route-type", {
+    moduleName: "serwist",
+    funcName: "parseRoute",
+    paramName: "capture",
+  });
 };

package/dist/cleanupOutdatedCaches.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cleanupOutdatedCaches.d.ts","sourceRoot":"","sources":["../src/cleanupOutdatedCaches.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,eAAO,MAAM,qBAAqB,eAAgB,MAAM,KAAG,IAY1D,CAAC"}