serwist 9.0.0-preview.24 → 9.0.0-preview.26

package/src/{strategies → lib/strategies}/NetworkFirst.ts

@@ -6,9 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { assert } from "../utils/assert.js";
-import { SerwistError } from "../utils/SerwistError.js";
-import { logger } from "../utils/logger.js";
+import { SerwistError } from "../../utils/SerwistError.js";
+import { assert } from "../../utils/assert.js";
+import { logger } from "../../utils/logger.js";
 import type { StrategyOptions } from "./Strategy.js";
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
@@ -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/).
  *
@@ -55,7 +55,7 @@ export class NetworkFirst extends Strategy {
     if (process.env.NODE_ENV !== "production") {
       if (this._networkTimeoutSeconds) {
         assert!.isType(this._networkTimeoutSeconds, "number", {
-          moduleName: "serwist/strategies",
+          moduleName: "serwist",
           className: this.constructor.name,
           funcName: "constructor",
           paramName: "networkTimeoutSeconds",
@@ -75,7 +75,7 @@ export class NetworkFirst extends Strategy {
 
     if (process.env.NODE_ENV !== "production") {
       assert!.isInstance(request, Request, {
-        moduleName: "serwist/strategies",
+        moduleName: "serwist",
         className: this.constructor.name,
         funcName: "handle",
         paramName: "makeRequest",

package/src/{strategies → lib/strategies}/NetworkOnly.ts

@@ -6,10 +6,10 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { assert } from "../utils/assert.js";
-import { SerwistError } from "../utils/SerwistError.js";
-import { logger } from "../utils/logger.js";
-import { timeout } from "../utils/timeout.js";
+import { SerwistError } from "../../utils/SerwistError.js";
+import { assert } from "../../utils/assert.js";
+import { logger } from "../../utils/logger.js";
+import { timeout } from "../../utils/timeout.js";
 import type { StrategyOptions } from "./Strategy.js";
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
@@ -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.
  */
@@ -51,7 +51,7 @@ export class NetworkOnly extends Strategy {
   async _handle(request: Request, handler: StrategyHandler): Promise<Response> {
     if (process.env.NODE_ENV !== "production") {
       assert!.isInstance(request, Request, {
-        moduleName: "serwist/strategies",
+        moduleName: "serwist",
         className: this.constructor.name,
         funcName: "_handle",
         paramName: "request",

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

@@ -6,15 +6,15 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin } from "./types.js";
-import { copyResponse } from "./copyResponse.js";
-import { SerwistError } from "./utils/SerwistError.js";
-import { getFriendlyURL } from "./utils/getFriendlyURL.js";
-import { logger } from "./utils/logger.js";
-import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
-import type { StrategyOptions } from "./strategies/Strategy.js";
-import { Strategy } from "./strategies/Strategy.js";
-import type { StrategyHandler } from "./strategies/StrategyHandler.js";
+import { copyResponse } from "../../copyResponse.js";
+import type { SerwistPlugin } from "../../types.js";
+import { SerwistError } from "../../utils/SerwistError.js";
+import { cacheNames as privateCacheNames } from "../../utils/cacheNames.js";
+import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
+import { logger } from "../../utils/logger.js";
+import type { StrategyOptions } from "./Strategy.js";
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
 
 interface PrecacheStrategyOptions extends StrategyOptions {
   /**
@@ -29,7 +29,7 @@ interface PrecacheStrategyOptions extends StrategyOptions {
  * specifically designed to both cache and fetch precached assets.
  *
  * Note: an instance of this class is created automatically when creating a
- * `PrecacheController`; it's generally not necessary to create this yourself.
+ * `Serwist` instance; it's generally not necessary to create this yourself.
  */
 export class PrecacheStrategy extends Strategy {
   private readonly _fallbackToNetwork: boolean;
@@ -55,6 +55,7 @@ export class PrecacheStrategy extends Strategy {
    */
   constructor(options: PrecacheStrategyOptions = {}) {
     options.cacheName = privateCacheNames.getPrecacheName(options.cacheName);
+
     super(options);
 
     this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true;
@@ -74,6 +75,7 @@ export class PrecacheStrategy extends Strategy {
    */
   async _handle(request: Request, handler: StrategyHandler): Promise<Response> {
     const response = await handler.cacheMatch(request);
+
     if (response) {
       return response;
     }
@@ -91,6 +93,7 @@ export class PrecacheStrategy extends Strategy {
 
   async _handleFetch(request: Request, handler: StrategyHandler): Promise<Response> {
     let response: Response | undefined = undefined;
+
     const params = (handler.params || {}) as {
       cacheKey?: string;
       integrity?: string;
@@ -169,6 +172,7 @@ export class PrecacheStrategy extends Strategy {
     // Make sure we defer cachePut() until after we know the response
     // should be cached; see https://github.com/GoogleChrome/workbox/issues/2737
     const wasCached = await handler.cachePut(request, response.clone());
+
     if (!wasCached) {
       // Throwing here will lead to the `install` handler failing, which
       // we want to do if *any* of the responses aren't safe to cache.

package/src/{strategies → lib/strategies}/StaleWhileRevalidate.ts

@@ -6,9 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { assert } from "../utils/assert.js";
-import { SerwistError } from "../utils/SerwistError.js";
-import { logger } from "../utils/logger.js";
+import { SerwistError } from "../../utils/SerwistError.js";
+import { assert } from "../../utils/assert.js";
+import { logger } from "../../utils/logger.js";
 import type { StrategyOptions } from "./Strategy.js";
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
@@ -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.
@@ -58,7 +58,7 @@ export class StaleWhileRevalidate extends Strategy {
 
     if (process.env.NODE_ENV !== "production") {
       assert!.isInstance(request, Request, {
-        moduleName: "serwist/strategies",
+        moduleName: "serwist",
         className: this.constructor.name,
         funcName: "handle",
         paramName: "request",

package/src/{strategies → lib/strategies}/Strategy.ts

@@ -6,11 +6,11 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { HandlerCallbackOptions, RouteHandlerObject, SerwistPlugin } from "../types.js";
-import { SerwistError } from "../utils/SerwistError.js";
-import { getFriendlyURL } from "../utils/getFriendlyURL.js";
-import { logger } from "../utils/logger.js";
-import { cacheNames as privateCacheNames } from "../utils/cacheNames.js";
+import type { HandlerCallbackOptions, RouteHandlerObject, SerwistPlugin } from "../../types.js";
+import { SerwistError } from "../../utils/SerwistError.js";
+import { cacheNames as privateCacheNames } from "../../utils/cacheNames.js";
+import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
+import { logger } from "../../utils/logger.js";
 import { StrategyHandler } from "./StrategyHandler.js";
 
 export interface StrategyOptions {
@@ -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/{strategies → lib/strategies}/StrategyHandler.ts

@@ -6,15 +6,15 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { HandlerCallbackOptions, MapLikeObject, SerwistPlugin, SerwistPluginCallbackParam } from "../types.js";
-import { assert } from "../utils/assert.js";
-import { Deferred } from "../utils/Deferred.js";
-import { SerwistError } from "../utils/SerwistError.js";
-import { cacheMatchIgnoreParams } from "../utils/cacheMatchIgnoreParams.js";
-import { executeQuotaErrorCallbacks } from "../utils/executeQuotaErrorCallbacks.js";
-import { getFriendlyURL } from "../utils/getFriendlyURL.js";
-import { logger } from "../utils/logger.js";
-import { timeout } from "../utils/timeout.js";
+import type { HandlerCallbackOptions, MapLikeObject, SerwistPlugin, SerwistPluginCallbackParam } from "../../types.js";
+import { Deferred } from "../../utils/Deferred.js";
+import { SerwistError } from "../../utils/SerwistError.js";
+import { assert } from "../../utils/assert.js";
+import { cacheMatchIgnoreParams } from "../../utils/cacheMatchIgnoreParams.js";
+import { executeQuotaErrorCallbacks } from "../../utils/executeQuotaErrorCallbacks.js";
+import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
+import { logger } from "../../utils/logger.js";
+import { timeout } from "../../utils/timeout.js";
 import type { Strategy } from "./Strategy.js";
 
 function toRequest(input: RequestInfo) {
@@ -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;
 
@@ -78,13 +78,13 @@ export class StrategyHandler {
   ) {
     if (process.env.NODE_ENV !== "production") {
       assert!.isInstance(options.event, ExtendableEvent, {
-        moduleName: "serwist/strategies",
+        moduleName: "serwist",
         className: "StrategyHandler",
         funcName: "constructor",
         paramName: "options.event",
       });
       assert!.isInstance(options.request, Request, {
-        moduleName: "serwist/strategies",
+        moduleName: "serwist",
         className: "StrategyHandler",
         funcName: "constructor",
         paramName: "options.request",
@@ -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/{strategies → lib/strategies}/plugins/cacheOkAndOpaquePlugin.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin } from "../../types.js";
+import type { SerwistPlugin } from "../../../types.js";
 
 export const cacheOkAndOpaquePlugin: SerwistPlugin = {
   /**

package/src/{strategies → lib/strategies}/utils/messages.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
-import { logger } from "../../utils/logger.js";
+import { getFriendlyURL } from "../../../utils/getFriendlyURL.js";
+import { logger } from "../../../utils/logger.js";
 
 export const messages = {
   strategyStart: (strategyName: string, request: Request): string => `Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,

package/src/models/messages/messages.ts

@@ -112,7 +112,7 @@ export const messages = {
   },
 
   "duplicate-queue-name": ({ name }) => {
-    return `The Queue name '${name}' is already being used. All instances of backgroundSync.Queue must be given unique names.`;
+    return `The queue name '${name}' is already being used. All instances of 'serwist.BackgroundSyncQueue' must be given unique names.`;
   },
 
   "expired-test-without-max-age": ({ methodName, paramName }) => {

package/src/navigationPreload.ts

@@ -7,7 +7,7 @@ declare const self: ServiceWorkerGlobalScope;
  * navigation preloading.
  *
  * @returns
- * @see https://serwist.pages.dev/docs/sw/navigation-preloading/is-navigation-preload-supported
+ * @see https://serwist.pages.dev/docs/serwist/core/is-navigation-preload-supported
  */
 export const isNavigationPreloadSupported = (): boolean => {
   return Boolean(self.registration?.navigationPreload);
@@ -19,7 +19,7 @@ export const isNavigationPreloadSupported = (): boolean => {
  * @param headerValue Optional. Allows developers to override the value of
  * the `Service-Worker-Navigation-Preload` header which will be sent to the
  * server when making the navigation request.
- * @see https://serwist.pages.dev/docs/sw/navigation-preloading/enable-navigation-preload
+ * @see https://serwist.pages.dev/docs/serwist/core/enable-navigation-preload
  */
 export const enableNavigationPreload = (headerValue?: string): void => {
   if (isNavigationPreloadSupported()) {
@@ -47,7 +47,7 @@ export const enableNavigationPreload = (headerValue?: string): void => {
 /**
  * If the browser supports navigation preloading, then this will disable it.
  *
- * @see https://serwist.pages.dev/docs/sw/navigation-preloading/disable-navigation-preload
+ * @see https://serwist.pages.dev/docs/serwist/core/disable-navigation-preload
  */
 export const disableNavigationPreload = (): void => {
   if (isNavigationPreloadSupported()) {

package/src/registerQuotaErrorCallback.ts

@@ -6,9 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
+import { quotaErrorCallbacks } from "./models/quotaErrorCallbacks.js";
 import { assert } from "./utils/assert.js";
 import { logger } from "./utils/logger.js";
-import { quotaErrorCallbacks } from "./models/quotaErrorCallbacks.js";
 
 /**
  * Adds a function to the set of quotaErrorCallbacks that will be executed if

package/src/types.ts

@@ -335,22 +335,27 @@ export declare interface PrecacheEntry {
 
 export interface PrecacheRouteOptions {
   /**
-   * The `directoryIndex` will check cache entries for a URL ending with '/'
-   * to see if there is a hit when appending the `directoryIndex` value.
+   * Tells Serwist to check the precache for an entry whose URL is the request URL appended
+   * with the specified value. Only applies if the request URL ends with "/".
+   *
+   * @default "index.html"
    */
   directoryIndex?: string | null;
   /**
-   * An array of RegExp's to remove search params when looking for a cache match.
+   * An array of `RegExp` objects matching search params that should be removed when looking
+   * for a precache match.
    */
   ignoreURLParametersMatching?: RegExp[];
   /**
-   * The `cleanURLs` option will check the cache for the URL with a `.html` added
-   * to the end of the end.
+   * Tells Serwist to check the precache for an entry whose URL is the request URL appended
+   * with ".html".
+   *
+   * @default true
    */
   cleanURLs?: boolean;
   /**
-   * This is a function that should take a URL and return an array of
-   * alternative URLs that should be checked for precache matches.
+   * A function that should take a URL and return an array of alternative URLs that should
+   * be checked for precache matches.
    */
   urlManipulation?: UrlManipulation;
 }

package/src/utils/PrecacheCacheKeyPlugin.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin, SerwistPluginCallbackParam } from "../types.js";
 import type { Serwist } from "../Serwist.js";
+import type { SerwistPlugin, SerwistPluginCallbackParam } from "../types.js";
 
 /**
  * A plugin, designed to be used with PrecacheController, to translate URLs into

package/src/utils/assert.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { SerwistError } from "./SerwistError.js";
 import type { MapLikeObject } from "../types.js";
+import { SerwistError } from "./SerwistError.js";
 
 /*
  * This method throws if the supplied value is not an array.

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

@@ -6,10 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { logger } from "./utils/logger.js";
-import { cacheNames as privateCacheNames } from "./utils/cacheNames.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/utils/executeQuotaErrorCallbacks.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { logger } from "./logger.js";
 import { quotaErrorCallbacks } from "../models/quotaErrorCallbacks.js";
+import { logger } from "./logger.js";
 
 /**
  * Runs all of the callback functions, one at a time sequentially, in the order