serwist 9.0.0-preview.24 → 9.0.0-preview.25

package/src/PrecacheRoute.ts

@@ -6,13 +6,13 @@
   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 { Serwist } from "./Serwist.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";
 
 /**
  * A subclass of `Route` that takes a `serwist.Serwist` instance and uses it to match

package/src/RegExpRoute.ts

@@ -6,11 +6,11 @@
   https://opensource.org/licenses/MIT.
 */
 
+import { Route } from "./Route.js";
+import type { HTTPMethod } from "./constants.js";
 import type { RouteHandler, RouteMatchCallback, RouteMatchCallbackOptions } from "./types.js";
 import { assert } from "./utils/assert.js";
 import { logger } from "./utils/logger.js";
-import { Route } from "./Route.js";
-import type { HTTPMethod } from "./constants.js";
 
 /**
  * `RegExpRoute` makes it easy to create a regular expression based on a `Route`.

package/src/Route.ts

@@ -6,10 +6,10 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "./types.js";
-import { assert } from "./utils/assert.js";
 import type { HTTPMethod } from "./constants.js";
 import { defaultMethod, validMethods } from "./constants.js";
+import type { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "./types.js";
+import { assert } from "./utils/assert.js";
 import { normalizeHandler } from "./utils/normalizeHandler.js";
 
 /**

package/src/Serwist.ts

@@ -1,41 +1,41 @@
-import type {
-  RouteHandler,
-  RouteHandlerCallback,
-  RouteHandlerCallbackOptions,
-  RouteHandlerObject,
-  RouteMatchCallback,
-  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 { clientsClaim as clientsClaimImpl } from "./clientsClaim.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 { PrecacheOnly } from "./lib/strategies/PrecacheOnly.js";
+import { Strategy } from "./lib/strategies/Strategy.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 { setCacheNameDetails } from "./setCacheNameDetails.js";
+import type {
+  RouteHandler,
+  RouteHandlerCallback,
+  RouteHandlerCallbackOptions,
+  RouteHandlerObject,
+  RouteMatchCallback,
+  RouteMatchCallbackOptions,
+  SerwistPlugin,
+} from "./types.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 { createCacheKey } from "./utils/createCacheKey.js";
+import { getFriendlyURL } from "./utils/getFriendlyURL.js";
+import { logger } from "./utils/logger.js";
 import { normalizeHandler } from "./utils/normalizeHandler.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._precacheStrategy = new PrecacheStrategy({
+    this._concurrentPrecaching = precacheOptions?.concurrency ?? 10;
+    this._precacheStrategy = new PrecacheOnly({
       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`.
@@ -602,7 +591,7 @@ export class Serwist {
   }
 
   /**
-   * Unregisters a `Route` with the `Router`.
+   * Unregisters a `Route` with the router.
    *
    * @param route The `Route` to unregister.
    */
@@ -643,7 +632,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 +702,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/cleanupOutdatedCaches.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { logger } from "./utils/logger.js";
 import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
+import { logger } from "./utils/logger.js";
 
 import { deleteOutdatedCaches } from "./utils/deleteOutdatedCaches.js";
 

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.legacy.ts

@@ -1,5 +1,4 @@
 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";
@@ -15,6 +14,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,6 +27,7 @@ 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 {
@@ -33,7 +35,7 @@ export {
   // can re-export them without having to import both the normal and legacy
   // import paths.
   NavigationRoute,
-  PrecacheStrategy,
+  PrecacheOnly,
   RegExpRoute,
   Route,
   cleanupOutdatedCaches,
@@ -42,8 +44,10 @@ export {
   addPlugins,
   addRoute,
   createHandlerBoundToURL,
-  getCacheKeyForURL,
   fallbacks,
+  getCacheKeyForURL,
+  initializeGoogleAnalytics,
+  installSerwist,
   matchPrecache,
   precache,
   precacheAndRoute,
@@ -53,7 +57,6 @@ export {
   getSingletonPrecacheController,
   setSingletonPrecacheController,
   handlePrecaching,
-  installSerwist,
   registerRuntimeCaching,
   registerRoute,
   Router,
@@ -63,4 +66,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,23 +1,56 @@
-import type { HTTPMethod } from "./constants.js";
+import type { NavigationRouteMatchOptions } from "./NavigationRoute.js";
+import { NavigationRoute } from "./NavigationRoute.js";
+import { PrecacheRoute } from "./PrecacheRoute.js";
+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";
+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 { PrecacheOnly } from "./lib/strategies/PrecacheOnly.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 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 { setCacheNameDetails } from "./setCacheNameDetails.js";
 
 export {
-  NavigationRoute,
+  // Core
+  Serwist,
   cacheNames,
   cleanupOutdatedCaches,
   clientsClaim,
@@ -26,14 +59,74 @@ export {
   disableNavigationPreload,
   enableNavigationPreload,
   isNavigationPreloadSupported,
-  parseRoute,
+  // Caching strategies
+  CacheFirst,
+  CacheOnly,
+  NetworkFirst,
+  NetworkOnly,
+  PrecacheOnly,
+  StaleWhileRevalidate,
+  Strategy,
+  StrategyHandler,
+  // Routing
+  NavigationRoute,
   PrecacheRoute,
-  PrecacheStrategy,
   RegExpRoute,
-  registerQuotaErrorCallback,
   Route,
-  Serwist,
+  parseRoute,
+  // 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,
+  // Misc
+  registerQuotaErrorCallback,
   setCacheNameDetails,
 };
-export type { HTTPMethod, NavigationRouteMatchOptions, SerwistOptions };
+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 * 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 { PrecacheOnly } from "../lib/strategies/PrecacheOnly.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.
@@ -67,7 +67,7 @@ export class PrecacheController {
    */
   constructor({ cacheName, plugins = [], fallbackToNetwork = true, concurrentPrecaching = 1 }: PrecacheControllerOptions = {}) {
     this._concurrentPrecaching = concurrentPrecaching;
-    this._strategy = new PrecacheStrategy({
+    this._strategy = new PrecacheOnly({
       cacheName: privateCacheNames.getPrecacheName(cacheName),
       plugins: [...plugins, new PrecacheCacheKeyPlugin({ precacheController: this })],
       fallbackToNetwork,

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";
 
 /**