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

package/src/Serwist.ts

@@ -1,3 +1,15 @@
+import { parallel } from "@serwist/utils";
+import { NavigationRoute } from "./NavigationRoute.js";
+import { PrecacheRoute } from "./PrecacheRoute.js";
+import type { Route } from "./Route.js";
+import { type HTTPMethod, defaultMethod } from "./constants.js";
+import { disableDevLogs as disableDevLogsImpl } from "./disableDevLogs.js";
+import { type GoogleAnalyticsInitializeOptions, initializeGoogleAnalytics } from "./lib/googleAnalytics/initializeGoogleAnalytics.js";
+import { type PrecacheFallbackEntry, PrecacheFallbackPlugin } from "./lib/precaching/PrecacheFallbackPlugin.js";
+import { PrecacheStrategy } from "./lib/strategies/PrecacheStrategy.js";
+import { Strategy } from "./lib/strategies/Strategy.js";
+import { enableNavigationPreload } from "./navigationPreload.js";
+import { setCacheNameDetails } from "./setCacheNameDetails.js";
 import type {
   RouteHandler,
   RouteHandlerCallback,
@@ -7,35 +19,23 @@ import type {
   RouteMatchCallbackOptions,
   SerwistPlugin,
 } from "./types.js";
-import { clientsClaim as clientsClaimImpl } from "./clientsClaim.js";
-import { setCacheNameDetails } from "./setCacheNameDetails.js";
-import { assert } from "./utils/assert.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 { waitUntil } from "./utils/waitUntil.js";
-import { parallel } from "@serwist/utils";
-import { NavigationRoute } from "./NavigationRoute.js";
-import { PrecacheRoute } from "./PrecacheRoute.js";
-import { PrecacheStrategy } from "./PrecacheStrategy.js";
-import type { Route } from "./Route.js";
-import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "./cleanupOutdatedCaches.js";
-import { type HTTPMethod, defaultMethod } from "./constants.js";
-import { disableDevLogs as disableDevLogsImpl } from "./disableDevLogs.js";
-import { enableNavigationPreload } from "./navigationPreload.js";
-import { parseRoute } from "./parseRoute.js";
-import { type GoogleAnalyticsInitializeOptions, initialize } from "./plugins/googleAnalytics/initialize.js";
-import { type PrecacheFallbackEntry, PrecacheFallbackPlugin } from "./plugins/precaching/PrecacheFallbackPlugin.js";
-import { Strategy } from "./strategies/Strategy.js";
 import type { PrecacheRouteOptions, RuntimeCaching } from "./types.js";
 import type { CleanupResult, InstallResult, PrecacheEntry } from "./types.js";
 import { PrecacheCacheKeyPlugin } from "./utils/PrecacheCacheKeyPlugin.js";
 import { PrecacheInstallReportPlugin } from "./utils/PrecacheInstallReportPlugin.js";
+import { SerwistError } from "./utils/SerwistError.js";
+import { assert } from "./utils/assert.js";
+import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
+import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "./utils/cleanupOutdatedCaches.js";
+import { clientsClaim as clientsClaimImpl } from "./utils/clientsClaim.js";
 import { createCacheKey } from "./utils/createCacheKey.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";
 import { printCleanupDetails } from "./utils/printCleanupDetails.js";
 import { printInstallDetails } from "./utils/printInstallDetails.js";
+import { waitUntil } from "./utils/waitUntil.js";
 
 declare const self: ServiceWorkerGlobalScope;
 
@@ -50,26 +50,26 @@ export interface FallbacksOptions {
 
 export interface PrecacheOptions extends PrecacheRouteOptions {
   /**
-   * The cache to use for precaching.
+   * The cache used for precaching.
    */
   cacheName?: string;
-}
-
-export interface SerwistOptions {
-  /**
-   * A list of URLs that should be cached.
-   */
-  precacheEntries?: (PrecacheEntry | string)[];
-  /**
-   * Options to customize how Serwist precaches the URLs in the precache list.
-   */
-  precacheOptions?: PrecacheOptions;
   /**
    * Whether outdated caches should be removed.
    *
    * @default false
    */
   cleanupOutdatedCaches?: boolean;
+  /**
+   * The number of precache requests that should be made concurrently.
+   *
+   * @default 10
+   */
+  concurrency?: number;
+  /**
+   * Whether to attempt to get the response from the network if there's
+   * a precache miss.
+   */
+  fallbackToNetwork?: boolean;
   /**
    * An URL that should point to a HTML file with which navigation requests for URLs that aren't
    * precached will be fulfilled.
@@ -89,17 +89,17 @@ export interface SerwistOptions {
    * events for precached assets.
    */
   plugins?: SerwistPlugin[];
+}
+
+export interface SerwistOptions {
   /**
-   * Whether to attempt to get the response from the network if there's
-   * a precache miss.
+   * A list of URLs that should be cached.
    */
-  fallbackToNetwork?: boolean;
+  precacheEntries?: (PrecacheEntry | string)[];
   /**
-   * The number of precache requests that should be made concurrently.
-   *
-   * @default 1
+   * Options to customize how Serwist precaches the URLs in the precache list.
    */
-  concurrentPrecaching?: number;
+  precacheOptions?: PrecacheOptions;
   /**
    * Forces the waiting service worker to become the active one.
    *
@@ -132,12 +132,10 @@ export interface SerwistOptions {
   clientsClaim?: boolean;
   /**
    * A list of caching strategies.
-   *
-   * @see https://serwist.pages.dev/docs/sw/runtime-caching
    */
   runtimeCaching?: RuntimeCaching[];
   /**
-   * Your configuration for `@serwist/google-analytics`. This plugin is
+   * Your configuration for `initializeGoogleAnalytics`. This plugin is
    * only initialized when this option is not `undefined` or `false`.
    */
   offlineAnalyticsConfig?: Omit<GoogleAnalyticsInitializeOptions, "serwist"> | boolean;
@@ -149,12 +147,10 @@ export interface SerwistOptions {
   disableDevLogs?: boolean;
   /**
    * Precaches routes so that they can be used as a fallback when
-   * a Strategy fails to generate a response.
+   * a `Strategy` fails to generate a response.
    *
-   * Note: This option mutates `runtimeCaching`. It also precaches the URLs
-   * defined in `entries`, so you must NOT precache any of them beforehand.
-   *
-   * @see https://serwist.pages.dev/docs/sw/abstractions/fallbacks
+   * Note: This option mutates `runtimeCaching`. It also expects the URLs
+   * defined in `entries` to have been precached beforehand.
    */
   fallbacks?: FallbacksOptions;
 }
@@ -170,6 +166,8 @@ interface CacheURLsMessageData {
 
 /**
  * A class that helps bootstrap the service worker.
+ *
+ * @see https://serwist.pages.dev/docs/serwist/core/serwist
  */
 export class Serwist {
   private readonly _urlsToCacheKeys: Map<string, string> = new Map();
@@ -184,13 +182,6 @@ export class Serwist {
   constructor({
     precacheEntries,
     precacheOptions,
-    cleanupOutdatedCaches,
-    navigateFallback,
-    navigateFallbackAllowlist,
-    navigateFallbackDenylist,
-    plugins = [],
-    fallbackToNetwork = true,
-    concurrentPrecaching = 1,
     skipWaiting = false,
     importScripts,
     navigationPreload = false,
@@ -201,11 +192,11 @@ export class Serwist {
     disableDevLogs = false,
     fallbacks,
   }: SerwistOptions = {}) {
-    this._concurrentPrecaching = concurrentPrecaching;
+    this._concurrentPrecaching = precacheOptions?.concurrency ?? 10;
     this._precacheStrategy = new PrecacheStrategy({
       cacheName: privateCacheNames.getPrecacheName(precacheOptions?.cacheName),
-      plugins: [...plugins, new PrecacheCacheKeyPlugin({ precacheController: this })],
-      fallbackToNetwork,
+      plugins: [...(precacheOptions?.plugins ?? []), new PrecacheCacheKeyPlugin({ precacheController: this })],
+      fallbackToNetwork: precacheOptions?.fallbackToNetwork,
     });
     this._routes = new Map();
     this._defaultHandlerMap = new Map();
@@ -237,35 +228,36 @@ export class Serwist {
 
     if (clientsClaim) clientsClaimImpl();
 
-    this.registerRoute(new PrecacheRoute(this, precacheOptions));
-
     if (!!precacheEntries && precacheEntries.length > 0) {
       this.addToPrecacheList(precacheEntries);
     }
 
-    if (cleanupOutdatedCaches) {
+    if (precacheOptions?.cleanupOutdatedCaches) {
       cleanupOutdatedCachesImpl(precacheOptions?.cacheName);
     }
 
-    if (navigateFallback) {
+    this.registerRoute(new PrecacheRoute(this, precacheOptions));
+
+    if (precacheOptions?.navigateFallback) {
       this.registerRoute(
-        new NavigationRoute(this.createHandlerBoundToUrl(navigateFallback), {
-          allowlist: navigateFallbackAllowlist,
-          denylist: navigateFallbackDenylist,
+        new NavigationRoute(this.createHandlerBoundToUrl(precacheOptions?.navigateFallback), {
+          allowlist: precacheOptions?.navigateFallbackAllowlist,
+          denylist: precacheOptions?.navigateFallbackDenylist,
         }),
       );
     }
 
     if (offlineAnalyticsConfig !== undefined) {
       if (typeof offlineAnalyticsConfig === "boolean") {
-        offlineAnalyticsConfig && initialize({ serwist: this });
+        offlineAnalyticsConfig && initializeGoogleAnalytics({ serwist: this });
       } else {
-        initialize({
+        initializeGoogleAnalytics({
           ...offlineAnalyticsConfig,
           serwist: this,
         });
       }
     }
+
     if (runtimeCaching !== undefined) {
       if (fallbacks !== undefined) {
         const fallbackPlugin = new PrecacheFallbackPlugin({
@@ -292,23 +284,21 @@ export class Serwist {
   }
 
   /**
-   * The strategy created by this controller and
-   * used to cache assets and respond to fetch events.
+   * The strategy used to precache assets and respond to fetch events.
    */
   get precacheStrategy(): Strategy {
     return this._precacheStrategy;
   }
   /**
-   * A `Map` of HTTP method name (`'GET'`, etc.) to an array of all the corresponding `Route`
-   * instances that are registered.
+   * A `Map` of HTTP method name (`'GET'`, etc.) to an array of all corresponding registered `Route`
+   * instances.
    */
   get routes(): Map<HTTPMethod, Route[]> {
     return this._routes;
   }
 
   /**
-   * This function adds Serwist's event listeners for you. Before calling it, add your own listeners
-   * should you need to.
+   * Adds Serwist's event listeners for you. Before calling it, add your own listeners should you need to.
    */
   addEventListeners() {
     self.addEventListener("install", this.handleInstall);
@@ -318,8 +308,7 @@ export class Serwist {
   }
 
   /**
-   * This method will add items to the precache list, removing duplicates
-   * and ensuring the information is valid.
+   * Adds items to the precache list, removing duplicates and ensuring the information is valid.
    *
    * @param entries Array of entries to precache.
    */
@@ -535,7 +524,7 @@ export class Serwist {
 
   /**
    * Registers a `RegExp`, string, or function with a caching
-   * strategy to the `Router`.
+   * 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`.
@@ -543,7 +532,11 @@ export class Serwist {
    * @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 {
+  registerCapture<T extends RegExp | string | RouteMatchCallback | Route>(
+    capture: T,
+    handler?: T extends Route ? never : RouteHandler,
+    method?: T extends Route ? never : HTTPMethod,
+  ): Route {
     const route = parseRoute(capture, handler, method);
     this.registerRoute(route);
     return route;
@@ -602,7 +595,7 @@ export class Serwist {
   }
 
   /**
-   * Unregisters a `Route` with the `Router`.
+   * Unregisters a `Route` with the router.
    *
    * @param route The `Route` to unregister.
    */
@@ -643,7 +636,7 @@ export class Serwist {
 
   /**
    * Returns the cache key used for storing a given URL. If that URL is
-   * unversioned, like `/index.html', then the cache key will be the original
+   * unversioned, like "/index.html", then the cache key will be the original
    * URL with a search parameter appended to it.
    *
    * @param url A URL whose cache key you want to look up.
@@ -713,7 +706,7 @@ export class Serwist {
   }
 
   /**
-   * Apply the routing rules to a `FetchEvent` object to get a `Response` from an
+   * Applies the routing rules to a `FetchEvent` object to get a `Response` from an
    * appropriate `Route`'s handler.
    *
    * @param options

package/src/copyResponse.ts

@@ -11,21 +11,19 @@ import { canConstructResponseFromBodyStream } from "./utils/canConstructResponse
 
 /**
  * Allows developers to copy a response and modify its `headers`, `status`,
- * or `statusText` values (the values settable via a
- * [`ResponseInit`](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax)
- * object in the constructor).
+ * or `statusText` values (the [valid options](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#options)
+ * when constructing a `Response` object).
  * To modify these values, pass a function as the second argument. That
- * function will be invoked with a single object with the response properties
- * `{headers, status, statusText}`. The return value of this function will
- * be used as the `ResponseInit` for the new `Response`. To change the values
- * either modify the passed parameter(s) and return it, or return a totally
+ * function will be invoked with the options of the initial `Response` object.
+ * The return value of this function will be used as the options for the new `Response` object.
+ * To change the values either modify the passed parameter(s) and return it or return a totally
  * new object.
  *
  * This method is intentionally limited to same-origin responses, regardless of
  * whether CORS was used or not.
  *
- * @param response
- * @param modifier
+ * @param response The initial response.
+ * @param modifier The function used to modify the options of the `Response` object.
  */
 export const copyResponse = async (response: Response, modifier?: (responseInit: ResponseInit) => ResponseInit): Promise<Response> => {
   let origin = null;

package/src/disableDevLogs.ts

@@ -3,7 +3,7 @@ declare const self: ServiceWorkerGlobalScope;
 /**
  * Disables Serwist's logging in development mode.
  *
- * @see https://serwist.pages.dev/docs/sw/abstractions/disable-dev-logs
+ * @see https://serwist.pages.dev/docs/serwist/core/disable-dev-logs
  */
 export const disableDevLogs = (): void => {
   self.__WB_DISABLE_DEV_LOGS = true;

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,8 +1,3 @@
-import { NavigationRoute } from "./NavigationRoute.js";
-import { PrecacheStrategy } from "./PrecacheStrategy.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";
@@ -15,6 +10,8 @@ import type { FallbackEntry, FallbacksOptions } from "./legacy/fallbacks.js";
 import { fallbacks } from "./legacy/fallbacks.js";
 import { getCacheKeyForURL } from "./legacy/getCacheKeyForURL.js";
 import { type HandlePrecachingOptions, handlePrecaching } from "./legacy/handlePrecaching.js";
+import type { GoogleAnalyticsInitializeOptions } from "./legacy/initializeGoogleAnalytics.js";
+import { initializeGoogleAnalytics } from "./legacy/initializeGoogleAnalytics.js";
 import { type InstallSerwistOptions, installSerwist } from "./legacy/installSerwist.js";
 import { matchPrecache } from "./legacy/matchPrecache.js";
 import { precache } from "./legacy/precache.js";
@@ -26,24 +23,16 @@ 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 { 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,
-  PrecacheStrategy,
-  RegExpRoute,
-  Route,
-  cleanupOutdatedCaches,
-  parseRoute,
   // Actual deprecated modules start here
   addPlugins,
   addRoute,
   createHandlerBoundToURL,
-  getCacheKeyForURL,
   fallbacks,
+  getCacheKeyForURL,
+  initializeGoogleAnalytics,
+  installSerwist,
   matchPrecache,
   precache,
   precacheAndRoute,
@@ -53,7 +42,6 @@ export {
   getSingletonPrecacheController,
   setSingletonPrecacheController,
   handlePrecaching,
-  installSerwist,
   registerRuntimeCaching,
   registerRoute,
   Router,
@@ -63,4 +51,12 @@ export {
   setSingletonRouter,
   unregisterRoute,
 };
-export type { HandlePrecachingOptions, InstallSerwistOptions, FallbackEntry, FallbacksOptions, PrecacheFallbackEntry, PrecacheFallbackPluginOptions };
+export type {
+  HandlePrecachingOptions,
+  GoogleAnalyticsInitializeOptions,
+  InstallSerwistOptions,
+  FallbackEntry,
+  FallbacksOptions,
+  PrecacheFallbackEntry,
+  PrecacheFallbackPluginOptions,
+};

package/src/index.ts

@@ -1,39 +1,125 @@
-import type { HTTPMethod } from "./constants.js";
-import { cacheNames } from "./cacheNames.js";
-import { cleanupOutdatedCaches } from "./cleanupOutdatedCaches.js";
-import { clientsClaim } from "./clientsClaim.js";
-import { copyResponse } from "./copyResponse.js";
-import { disableDevLogs } from "./disableDevLogs.js";
-import { disableNavigationPreload, enableNavigationPreload, isNavigationPreloadSupported } from "./navigationPreload.js";
 import type { NavigationRouteMatchOptions } from "./NavigationRoute.js";
 import { NavigationRoute } from "./NavigationRoute.js";
-import { parseRoute } from "./parseRoute.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
-import { PrecacheStrategy } from "./PrecacheStrategy.js";
 import { RegExpRoute } from "./RegExpRoute.js";
-import { registerQuotaErrorCallback } from "./registerQuotaErrorCallback.js";
 import { Route } from "./Route.js";
 import { Serwist, type SerwistOptions } from "./Serwist.js";
+import { cacheNames } from "./cacheNames.js";
+import type { HTTPMethod } from "./constants.js";
+import { copyResponse } from "./copyResponse.js";
+import { disableDevLogs } from "./disableDevLogs.js";
+import { BackgroundSyncPlugin } from "./lib/backgroundSync/BackgroundSyncPlugin.js";
+import type { BackgroundSyncQueueEntry, BackgroundSyncQueueOptions } from "./lib/backgroundSync/BackgroundSyncQueue.js";
+import { BackgroundSyncQueue } from "./lib/backgroundSync/BackgroundSyncQueue.js";
+import { BackgroundSyncQueueStore } from "./lib/backgroundSync/BackgroundSyncQueueStore.js";
+import { StorableRequest } from "./lib/backgroundSync/StorableRequest.js";
+import { BroadcastCacheUpdate } from "./lib/broadcastUpdate/BroadcastCacheUpdate.js";
+import { BroadcastUpdatePlugin } from "./lib/broadcastUpdate/BroadcastUpdatePlugin.js";
+import { BROADCAST_UPDATE_DEFAULT_HEADERS } from "./lib/broadcastUpdate/constants.js";
+import { responsesAreSame } from "./lib/broadcastUpdate/responsesAreSame.js";
+import type { BroadcastCacheUpdateOptions, BroadcastMessage, BroadcastPayload, BroadcastPayloadGenerator } from "./lib/broadcastUpdate/types.js";
+import { CacheableResponse } from "./lib/cacheableResponse/CacheableResponse.js";
+import type { CacheableResponseOptions } from "./lib/cacheableResponse/CacheableResponse.js";
+import { CacheableResponsePlugin } from "./lib/cacheableResponse/CacheableResponsePlugin.js";
+import { CacheExpiration } from "./lib/expiration/CacheExpiration.js";
+import type { ExpirationPluginOptions } from "./lib/expiration/ExpirationPlugin.js";
+import { ExpirationPlugin } from "./lib/expiration/ExpirationPlugin.js";
+import { initializeGoogleAnalytics } from "./lib/googleAnalytics/initializeGoogleAnalytics.js";
+import type { GoogleAnalyticsInitializeOptions } from "./lib/googleAnalytics/initializeGoogleAnalytics.js";
+import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./lib/precaching/PrecacheFallbackPlugin.js";
+import { PrecacheFallbackPlugin } from "./lib/precaching/PrecacheFallbackPlugin.js";
+import { RangeRequestsPlugin } from "./lib/rangeRequests/RangeRequestsPlugin.js";
+import { createPartialResponse } from "./lib/rangeRequests/createPartialResponse.js";
+import { CacheFirst } from "./lib/strategies/CacheFirst.js";
+import { CacheOnly } from "./lib/strategies/CacheOnly.js";
+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 { 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 { registerQuotaErrorCallback } from "./registerQuotaErrorCallback.js";
 import { setCacheNameDetails } from "./setCacheNameDetails.js";
 
 export {
-  NavigationRoute,
+  // Core
+  Serwist,
   cacheNames,
-  cleanupOutdatedCaches,
-  clientsClaim,
   copyResponse,
   disableDevLogs,
   disableNavigationPreload,
   enableNavigationPreload,
   isNavigationPreloadSupported,
-  parseRoute,
-  PrecacheRoute,
+  registerQuotaErrorCallback,
+  setCacheNameDetails,
+  // Caching strategies
+  CacheFirst,
+  CacheOnly,
+  NetworkFirst,
+  NetworkOnly,
   PrecacheStrategy,
+  StaleWhileRevalidate,
+  Strategy,
+  StrategyHandler,
+  // Routing
+  NavigationRoute,
+  PrecacheRoute,
   RegExpRoute,
-  registerQuotaErrorCallback,
   Route,
-  Serwist,
-  setCacheNameDetails,
+  // Background synchronizing
+  BackgroundSyncPlugin,
+  BackgroundSyncQueue,
+  BackgroundSyncQueueStore,
+  StorableRequest,
+  // Broadcasting updates
+  BroadcastCacheUpdate,
+  BroadcastUpdatePlugin,
+  BROADCAST_UPDATE_DEFAULT_HEADERS,
+  responsesAreSame,
+  // Setting cacheability criteria
+  CacheableResponse,
+  CacheableResponsePlugin,
+  // Expiring outdated responses
+  CacheExpiration,
+  ExpirationPlugin,
+  // Precaching
+  PrecacheFallbackPlugin,
+  // Google Analytics
+  initializeGoogleAnalytics,
+  // Handling range requests
+  createPartialResponse,
+  RangeRequestsPlugin,
+};
+export type {
+  // Core
+  HTTPMethod,
+  SerwistOptions,
+  // Caching strategies
+  NetworkFirstOptions,
+  NetworkOnlyOptions,
+  StrategyOptions,
+  // Routing
+  NavigationRouteMatchOptions,
+  // Background synchronizing
+  BackgroundSyncQueueOptions,
+  BackgroundSyncQueueEntry,
+  // Broadcasting updates
+  BroadcastCacheUpdateOptions,
+  BroadcastPayload,
+  BroadcastPayloadGenerator,
+  BroadcastMessage,
+  // Setting cacheability criteria
+  CacheableResponseOptions,
+  // Expiring outdated responses
+  ExpirationPluginOptions,
+  // Precaching
+  PrecacheFallbackEntry,
+  PrecacheFallbackPluginOptions,
+  // Google Analytics
+  GoogleAnalyticsInitializeOptions,
 };
-export type { HTTPMethod, NavigationRouteMatchOptions, SerwistOptions };
 export type * from "./types.js";

package/src/legacy/PrecacheController.ts

@@ -6,20 +6,20 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { RouteHandlerCallback, SerwistPlugin } from "../types.js";
-import { assert } from "../utils/assert.js";
-import { SerwistError } from "../utils/SerwistError.js";
-import { logger } from "../utils/logger.js";
-import { cacheNames as privateCacheNames } from "../utils/cacheNames.js";
-import { waitUntil } from "../utils/waitUntil.js";
 import { parallel } from "@serwist/utils";
-import { PrecacheStrategy } from "../PrecacheStrategy.js";
-import type { Strategy } from "../strategies/Strategy.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";
 import { PrecacheInstallReportPlugin } from "../utils/PrecacheInstallReportPlugin.js";
+import { SerwistError } from "../utils/SerwistError.js";
+import { assert } from "../utils/assert.js";
+import { cacheNames as privateCacheNames } from "../utils/cacheNames.js";
 import { createCacheKey } from "../utils/createCacheKey.js";
+import { logger } from "../utils/logger.js";
 import { printCleanupDetails } from "../utils/printCleanupDetails.js";
 import { printInstallDetails } from "../utils/printInstallDetails.js";
+import { waitUntil } from "../utils/waitUntil.js";
 import { PrecacheCacheKeyPlugin } from "./utils/PrecacheCacheKeyPlugin.js";
 
 // Give TypeScript the correct global.

package/src/legacy/PrecacheFallbackPlugin.ts

@@ -52,7 +52,7 @@ export interface PrecacheFallbackPluginOptions {
  * 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.
- * 
+ *
  * @deprecated
  */
 export class PrecacheFallbackPlugin implements SerwistPlugin {

package/src/legacy/PrecacheRoute.ts

@@ -6,12 +6,12 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
-import { getFriendlyURL } from "../utils/getFriendlyURL.js";
-import { logger } from "../utils/logger.js";
 import { Route } from "../Route.js";
+import type { RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
 import type { PrecacheRouteOptions } from "../types.js";
 import { generateURLVariations } from "../utils/generateURLVariations.js";
+import { getFriendlyURL } from "../utils/getFriendlyURL.js";
+import { logger } from "../utils/logger.js";
 import type { PrecacheController } from "./PrecacheController.js";
 
 /**