serwist 10.0.0-preview.7 → 10.0.0-preview.9

package/src/lib/{broadcastUpdate → broadcast-update}/types.ts

@@ -1,4 +1,4 @@
-import type { CacheDidUpdateCallbackParam } from "../../types.js";
+import type { CacheDidUpdateCallbackParam } from "#lib/types.js";
 import type { BROADCAST_UPDATE_MESSAGE_META, BROADCAST_UPDATE_MESSAGE_TYPE } from "./constants.js";
 
 export interface BroadcastCacheUpdateOptions {

package/src/lib/{cacheableResponse → cacheable-response}/CacheableResponsePlugin.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { StrategyPlugin } from "../../types.js";
+import type { StrategyPlugin } from "#lib/types.js";
 import type { CacheableResponseOptions } from "./CacheableResponse.js";
 import { CacheableResponse } from "./CacheableResponse.js";
 

package/src/lib/core.ts

@@ -0,0 +1,128 @@
+import { clientsClaim as clientsClaimImpl } from "#utils/clientsClaim.js";
+import type { HTTPMethod } from "./constants.js";
+import type { Extension } from "./extension.js";
+import { Precache } from "./extensions/index.js";
+import { iterateExtensions } from "./functions/handlers.js";
+import { enableNavigationPreload } from "./navigation-preload.js";
+import type { Route } from "./route.js";
+import type { PrecacheEntry, PrecacheOptions, RouteHandlerObject } from "./types.js";
+import { disableDevLogs as disableDevLogsImpl, setCacheNameDetails } from "./utils.js";
+
+export interface Serwist {
+  readonly routes: Map<HTTPMethod, Route[]>;
+  readonly defaultHandlerMap: Map<HTTPMethod, RouteHandlerObject>;
+  readonly precache: Precache;
+  readonly extensions: Extension[];
+  catchHandler?: RouteHandlerObject;
+}
+
+export interface SerwistOptions {
+  /**
+   * Options to customize precaching.
+   */
+  precache?: PrecacheOptions & {
+    entries: (PrecacheEntry | string)[] | undefined;
+  };
+  /**
+   * Forces the waiting service worker to become the active one.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting
+   */
+  skipWaiting?: boolean;
+  /**
+   * Imports external scripts. They are executed in the order they
+   * are passed.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/importScripts
+   */
+  importScripts?: string[];
+  /**
+   * Enables navigation preloading if it is supported.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/navigationPreload
+   */
+  navigationPreload?: boolean;
+  /**
+   * Modifies the prefix of the default cache names used by Serwist packages.
+   */
+  cacheId?: string | undefined;
+  /**
+   * Claims any currently available clients once the service worker
+   * becomes active. This is normally used in conjunction with `skipWaiting()`.
+   *
+   * @default false
+   */
+  clientsClaim?: boolean;
+  /**
+   * Disables Serwist's logging in development mode.
+   *
+   * @default false
+   */
+  disableDevLogs?: boolean;
+  /**
+   * A list of extensions.
+   */
+  extensions?: Extension[];
+}
+
+declare const self: ServiceWorkerGlobalScope;
+
+export const createSerwist = ({
+  precache,
+  skipWaiting = false,
+  importScripts,
+  navigationPreload = false,
+  cacheId,
+  clientsClaim = false,
+  disableDevLogs = false,
+  extensions = [],
+}: SerwistOptions = {}): Serwist => {
+  if (importScripts?.length) self.importScripts(...importScripts);
+
+  if (navigationPreload) enableNavigationPreload();
+
+  if (cacheId) setCacheNameDetails({ prefix: cacheId });
+
+  if (skipWaiting) {
+    self.skipWaiting();
+  } else {
+    self.addEventListener("message", (event) => {
+      if (event.data?.type === "SKIP_WAITING") {
+        self.skipWaiting();
+      }
+    });
+  }
+
+  if (clientsClaim) clientsClaimImpl();
+
+  const precacheExtension = new Precache(precache ?? { entries: [] });
+
+  const routes = new Map<HTTPMethod, Route[]>();
+
+  const defaultHandlerMap = new Map<HTTPMethod, RouteHandlerObject>();
+
+  const exts = [precacheExtension, ...extensions];
+
+  const state: Serwist = {
+    get routes() {
+      return routes;
+    },
+    get defaultHandlerMap() {
+      return defaultHandlerMap;
+    },
+    get precache() {
+      return precacheExtension;
+    },
+    get extensions() {
+      return exts;
+    },
+  };
+
+  for (const callback of iterateExtensions(state, "init")) {
+    callback({ serwist: state });
+  }
+
+  if (disableDevLogs) disableDevLogsImpl();
+
+  return state;
+};

package/src/lib/expiration/CacheExpiration.ts

@@ -6,9 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { SerwistError } from "#utils/SerwistError.js";
 import { assert } from "#utils/assert.js";
 import { logger } from "#utils/logger.js";
+import { SerwistError } from "#utils/SerwistError.js";
 import { CacheTimestampsModel } from "./models/CacheTimestampsModel.js";
 
 interface CacheExpirationConfig {

package/src/lib/expiration/ExpirationPlugin.ts

@@ -5,14 +5,13 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
-
-import { SerwistError } from "#utils/SerwistError.js";
+import type { CacheDidUpdateCallbackParam, CachedResponseWillBeUsedCallbackParam, StrategyPlugin } from "#lib/types.js";
+import { registerQuotaErrorCallback } from "#lib/utils.js";
 import { assert } from "#utils/assert.js";
 import { cacheNames as privateCacheNames } from "#utils/cacheNames.js";
 import { getFriendlyURL } from "#utils/getFriendlyURL.js";
 import { logger } from "#utils/logger.js";
-import { registerQuotaErrorCallback } from "../../registerQuotaErrorCallback.js";
-import type { CacheDidUpdateCallbackParam, CachedResponseWillBeUsedCallbackParam, StrategyPlugin } from "../../types.js";
+import { SerwistError } from "#utils/SerwistError.js";
 import type { Strategy } from "../strategies/Strategy.js";
 import { CacheExpiration } from "./CacheExpiration.js";
 
@@ -182,7 +181,7 @@ export class ExpirationPlugin implements StrategyPlugin {
     })();
     try {
       event.waitUntil(done);
-    } catch (error) {
+    } catch {
       if (process.env.NODE_ENV !== "production") {
         if (event instanceof FetchEvent) {
           logger.warn(`Unable to ensure service worker stays alive when updating cache entry for '${getFriendlyURL(event.request.url)}'.`);

package/src/lib/extension.ts

@@ -0,0 +1,37 @@
+import type { MaybePromise } from "@serwist/utils";
+import type { Serwist } from "./core.js";
+
+export interface InitCallbackParam {
+  serwist: Serwist;
+}
+
+export type InitCallback = (param: InitCallbackParam) => MaybePromise<void>;
+
+export interface InstallCallbackParam {
+  event: ExtendableEvent;
+  serwist: Serwist;
+}
+
+export type InstallCallback = (param: InstallCallbackParam) => MaybePromise<void>;
+
+export interface ActivateCallbackParam {
+  event: ExtendableEvent;
+  serwist: Serwist;
+}
+
+export type ActivateCallback = (param: ActivateCallbackParam) => MaybePromise<void>;
+
+/**
+ * An object with optional lifecycle callback properties for Serwist's operations.
+ */
+export interface Extension {
+  init?: InitCallback;
+  install?: InstallCallback;
+  activate?: ActivateCallback;
+}
+
+export interface ExtensionParam {
+  init: InitCallbackParam;
+  install: InstallCallbackParam;
+  activate: ActivateCallbackParam;
+}

package/src/lib/{googleAnalytics/initializeGoogleAnalytics.ts → extensions/google-analytics/extension.ts}

@@ -1,21 +1,15 @@
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
+import { BackgroundSyncPlugin } from "#lib/background-sync/BackgroundSyncPlugin.js";
+import type { BackgroundSyncQueue, BackgroundSyncQueueEntry } from "#lib/background-sync/BackgroundSyncQueue.js";
+import type { Serwist } from "#lib/core.js";
+import type { Extension } from "#lib/extension.js";
+import { registerRoute } from "#lib/functions/router.js";
+import { Route } from "#lib/route.js";
+import { NetworkFirst } from "#lib/strategies/NetworkFirst.js";
+import { NetworkOnly } from "#lib/strategies/NetworkOnly.js";
+import type { RouteMatchCallbackOptions } from "#lib/types.js";
 import { cacheNames as privateCacheNames } from "#utils/cacheNames.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 { RouteMatchCallbackOptions } from "../../types.js";
-import { BackgroundSyncPlugin } from "../backgroundSync/BackgroundSyncPlugin.js";
-import type { BackgroundSyncQueue, BackgroundSyncQueueEntry } from "../backgroundSync/BackgroundSyncQueue.js";
-import { NetworkFirst } from "../strategies/NetworkFirst.js";
-import { NetworkOnly } from "../strategies/NetworkOnly.js";
 import {
   ANALYTICS_JS_PATH,
   COLLECT_PATHS_REGEX,
@@ -27,8 +21,7 @@ import {
   QUEUE_NAME,
 } from "./constants.js";
 
-export interface GoogleAnalyticsInitializeOptions {
-  serwist: Serwist;
+export interface GoogleAnalyticsOptions {
   /**
    * The cache name to store and retrieve analytics.js. Defaults to Serwist's default cache names.
    */
@@ -58,9 +51,9 @@ export interface GoogleAnalyticsInitializeOptions {
  * @returns The requestWillDequeue callback function.
  * @private
  */
-const createOnSyncCallback = (config: Pick<GoogleAnalyticsInitializeOptions, "parameterOverrides" | "hitFilter">) => {
+export const createOnSyncCallback = (config: Pick<GoogleAnalyticsOptions, "parameterOverrides" | "hitFilter">) => {
   return async ({ queue }: { queue: BackgroundSyncQueue }) => {
-    let entry: BackgroundSyncQueueEntry | undefined = undefined;
+    let entry: BackgroundSyncQueueEntry | undefined;
     while ((entry = await queue.shiftRequest())) {
       const { request, timestamp } = entry;
       const url = new URL(request.url);
@@ -128,7 +121,7 @@ const createOnSyncCallback = (config: Pick<GoogleAnalyticsInitializeOptions, "pa
  * @returns The created routes.
  * @private
  */
-const createCollectRoutes = (bgSyncPlugin: BackgroundSyncPlugin) => {
+export const createCollectRoutes = (bgSyncPlugin: BackgroundSyncPlugin) => {
   const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
 
   const handler = new NetworkOnly({
@@ -145,7 +138,7 @@ const createCollectRoutes = (bgSyncPlugin: BackgroundSyncPlugin) => {
  * @returns The created route.
  * @private
  */
-const createAnalyticsJsRoute = (cacheName: string) => {
+export const createAnalyticsJsRoute = (cacheName: string) => {
   const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
 
   const handler = new NetworkFirst({ cacheName });
@@ -160,7 +153,7 @@ const createAnalyticsJsRoute = (cacheName: string) => {
  * @returns The created route.
  * @private
  */
-const createGtagJsRoute = (cacheName: string) => {
+export const createGtagJsRoute = (cacheName: string) => {
   const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
 
   const handler = new NetworkFirst({ cacheName });
@@ -175,7 +168,7 @@ const createGtagJsRoute = (cacheName: string) => {
  * @returns The created route.
  * @private
  */
-const createGtmJsRoute = (cacheName: string) => {
+export const createGtmJsRoute = (cacheName: string) => {
   const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
 
   const handler = new NetworkFirst({ cacheName });
@@ -183,27 +176,28 @@ const createGtmJsRoute = (cacheName: string) => {
   return new Route(match, handler, "GET");
 };
 
-/**
- * Initialize Serwist's offline Google Analytics v3 support.
- *
- * @param options
- */
-export const initializeGoogleAnalytics = ({ serwist, cacheName, ...options }: GoogleAnalyticsInitializeOptions): void => {
-  const resolvedCacheName = privateCacheNames.getGoogleAnalyticsName(cacheName);
-
-  const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
-    maxRetentionTime: MAX_RETENTION_TIME,
-    onSync: createOnSyncCallback(options),
-  });
-
-  const routes = [
-    createGtmJsRoute(resolvedCacheName),
-    createAnalyticsJsRoute(resolvedCacheName),
-    createGtagJsRoute(resolvedCacheName),
-    ...createCollectRoutes(bgSyncPlugin),
-  ];
-
-  for (const route of routes) {
-    serwist.registerRoute(route);
+export class GoogleAnalytics implements Extension {
+  private _options: GoogleAnalyticsOptions;
+  constructor(options: GoogleAnalyticsOptions = {}) {
+    this._options = options;
   }
-};
+  init({ serwist }: { serwist: Serwist }) {
+    const resolvedCacheName = privateCacheNames.getGoogleAnalyticsName(this._options.cacheName);
+
+    const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+      maxRetentionTime: MAX_RETENTION_TIME,
+      onSync: createOnSyncCallback(this._options),
+    });
+
+    const routes = [
+      createGtmJsRoute(resolvedCacheName),
+      createAnalyticsJsRoute(resolvedCacheName),
+      createGtagJsRoute(resolvedCacheName),
+      ...createCollectRoutes(bgSyncPlugin),
+    ];
+
+    for (const route of routes) {
+      registerRoute(serwist, route);
+    }
+  }
+}

package/src/lib/extensions/google-analytics/initialize.ts

@@ -0,0 +1,48 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import { BackgroundSyncPlugin } from "#lib/background-sync/BackgroundSyncPlugin.js";
+import type { Serwist } from "#lib/serwist.js";
+import { cacheNames as privateCacheNames } from "#utils/cacheNames.js";
+import { MAX_RETENTION_TIME, QUEUE_NAME } from "./constants.js";
+import {
+  createAnalyticsJsRoute,
+  createCollectRoutes,
+  createGtagJsRoute,
+  createGtmJsRoute,
+  createOnSyncCallback,
+  type GoogleAnalyticsOptions,
+} from "./extension.js";
+
+export interface GoogleAnalyticsInitializeOptions extends GoogleAnalyticsOptions {
+  serwist: Serwist;
+}
+
+/**
+ * Initialize Serwist's offline Google Analytics v3 support.
+ *
+ * @param options
+ */
+export const initializeGoogleAnalytics = ({ serwist, cacheName, ...options }: GoogleAnalyticsInitializeOptions): void => {
+  const resolvedCacheName = privateCacheNames.getGoogleAnalyticsName(cacheName);
+
+  const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+    maxRetentionTime: MAX_RETENTION_TIME,
+    onSync: createOnSyncCallback(options),
+  });
+
+  const routes = [
+    createGtmJsRoute(resolvedCacheName),
+    createAnalyticsJsRoute(resolvedCacheName),
+    createGtagJsRoute(resolvedCacheName),
+    ...createCollectRoutes(bgSyncPlugin),
+  ];
+
+  for (const route of routes) {
+    serwist.registerRoute(route);
+  }
+};

package/src/lib/extensions/index.ts

@@ -0,0 +1,13 @@
+export type { GoogleAnalyticsOptions } from "./google-analytics/extension.js";
+export { GoogleAnalytics } from "./google-analytics/extension.js";
+export type { GoogleAnalyticsInitializeOptions } from "./google-analytics/initialize.js";
+export { initializeGoogleAnalytics } from "./google-analytics/initialize.js";
+export type { PrecacheEntry, PrecacheExtensionOptions, PrecacheOptions } from "./precache/extension.js";
+export { Precache } from "./precache/extension.js";
+export type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./precache/plugin-fallback.js";
+export { PrecacheFallbackPlugin } from "./precache/plugin-fallback.js";
+export type { PrecacheRouteOptions } from "./precache/route.js";
+export { PrecacheRoute } from "./precache/route.js";
+export type { PrecacheStrategyOptions } from "./precache/strategy.js";
+export { PrecacheStrategy } from "./precache/strategy.js";
+export { RuntimeCache, type RuntimeCacheOptions } from "./runtime-cache.js";

package/src/lib/{controllers/PrecacheController/PrecacheController.ts → extensions/precache/extension.ts}

@@ -1,19 +1,21 @@
-import { SerwistError } from "#utils/SerwistError.js";
+import { parallel } from "@serwist/utils";
+import type { Serwist } from "#lib/core.js";
+import type { Extension } from "#lib/extension.js";
+import { registerRoute } from "#lib/functions/router.js";
 import { assert } from "#utils/assert.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 { parallel } from "@serwist/utils";
-import { NavigationRoute } from "../../../NavigationRoute.js";
-import type { Serwist } from "../../../Serwist.js";
-import type { Controller, RouteHandlerCallback, UrlManipulation } from "../../../types.js";
+import { SerwistError } from "#utils/SerwistError.js";
+import { NavigationRoute } from "../../route.js";
 import type { Strategy } from "../../strategies/Strategy.js";
-import { PrecacheInstallReportPlugin } from "./PrecacheInstallReportPlugin.js";
-import { PrecacheRoute } from "./PrecacheRoute.js";
-import { PrecacheStrategy } from "./PrecacheStrategy.js";
-import type { PrecacheStrategyOptions } from "./PrecacheStrategy.js";
-import { parsePrecacheOptions } from "./parsePrecacheOptions.js";
+import type { RouteHandlerCallback } from "../../types.js";
+import { parsePrecacheOptions } from "./options.js";
+import { PrecacheInstallReportPlugin } from "./plugin-install-report.js";
+import { PrecacheRoute, type PrecacheRouteOptions } from "./route.js";
+import type { PrecacheStrategyOptions } from "./strategy.js";
+import { PrecacheStrategy } from "./strategy.js";
 
 export interface PrecacheEntry {
   integrity?: string;
@@ -21,34 +23,7 @@ export interface PrecacheEntry {
   revision?: string | null;
 }
 
-export interface PrecacheRouteOptions {
-  /**
-   * 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` objects matching search params that should be removed when looking
-   * for a precache match.
-   */
-  ignoreURLParametersMatching?: RegExp[];
-  /**
-   * Tells Serwist to check the precache for an entry whose URL is the request URL appended
-   * with ".html".
-   *
-   * @default true
-   */
-  cleanURLs?: boolean;
-  /**
-   * A function that should take a URL and return an array of alternative URLs that should
-   * be checked for precache matches.
-   */
-  urlManipulation?: UrlManipulation;
-}
-
-export interface PrecacheControllerOptions {
+export interface PrecacheExtensionOptions {
   /**
    * The cache to use for precaching.
    */
@@ -81,14 +56,16 @@ export interface PrecacheControllerOptions {
   navigateFallbackDenylist?: RegExp[];
 }
 
-export interface PrecacheOptions extends PrecacheStrategyOptions, PrecacheRouteOptions, PrecacheControllerOptions {}
+export interface PrecacheOptions extends PrecacheStrategyOptions, PrecacheRouteOptions, PrecacheExtensionOptions {
+  entries: (PrecacheEntry | string)[] | undefined;
+}
 
-export class PrecacheController implements Controller {
+export class Precache implements Extension {
   private readonly _urlsToCacheKeys: Map<string, string> = new Map();
   private readonly _urlsToCacheModes: Map<string, "reload" | "default" | "no-store" | "no-cache" | "force-cache" | "only-if-cached"> = new Map();
   private readonly _cacheKeysToIntegrities: Map<string, string> = new Map();
   private readonly _strategy: Strategy;
-  private _options: PrecacheControllerOptions;
+  private _options: PrecacheExtensionOptions;
   private _routeOptions: PrecacheRouteOptions;
 
   /**
@@ -96,8 +73,8 @@ export class PrecacheController implements Controller {
    *
    * @param options
    */
-  constructor(entries: (PrecacheEntry | string)[], precacheOptions?: PrecacheOptions) {
-    const { strategyOptions, routeOptions, controllerOptions } = parsePrecacheOptions(this, precacheOptions);
+  constructor(precacheOptions: PrecacheOptions) {
+    const { entries, strategyOptions, routeOptions, extensionOptions: controllerOptions } = parsePrecacheOptions(this, precacheOptions);
     this.addToCacheList(entries);
     this._strategy = new PrecacheStrategy(strategyOptions);
     this._options = controllerOptions;
@@ -174,10 +151,11 @@ export class PrecacheController implements Controller {
   }
 
   init({ serwist }: { serwist: Serwist }): void {
-    serwist.registerRoute(new PrecacheRoute(this, this._routeOptions));
+    registerRoute(serwist, new PrecacheRoute(this, this._routeOptions));
 
     if (this._options.navigateFallback) {
-      serwist.registerRoute(
+      registerRoute(
+        serwist,
         new NavigationRoute(this.createHandlerBoundToUrl(this._options.navigateFallback), {
           allowlist: this._options.navigateFallbackAllowlist,
           denylist: this._options.navigateFallbackDenylist,

package/src/lib/{controllers/PrecacheController/parsePrecacheOptions.ts → extensions/precache/options.ts}

@@ -1,12 +1,14 @@
-import { privateCacheNames } from "#index.internal";
 import type { Require } from "@serwist/utils";
-import { PrecacheCacheKeyPlugin } from "./PrecacheCacheKeyPlugin.js";
-import type { PrecacheController, PrecacheControllerOptions, PrecacheOptions, PrecacheRouteOptions } from "./PrecacheController.js";
-import type { PrecacheStrategyOptions } from "./PrecacheStrategy.js";
+import { privateCacheNames } from "#index.internal";
+import type { Precache, PrecacheExtensionOptions, PrecacheOptions } from "./extension.js";
+import { PrecacheCacheKeyPlugin } from "./plugin-cache-key.js";
+import type { PrecacheRouteOptions } from "./route.js";
+import type { PrecacheStrategyOptions } from "./strategy.js";
 
 export const parsePrecacheOptions = (
-  controller: PrecacheController,
+  controller: Precache,
   {
+    entries,
     cacheName,
     plugins,
     fetchOptions,
@@ -21,8 +23,9 @@ export const parsePrecacheOptions = (
     navigateFallback,
     navigateFallbackAllowlist,
     navigateFallbackDenylist,
-  }: PrecacheOptions = {},
+  }: PrecacheOptions,
 ) => ({
+  entries: entries ?? [],
   strategyOptions: {
     cacheName: privateCacheNames.getPrecacheName(cacheName),
     plugins: [...(plugins ?? []), new PrecacheCacheKeyPlugin({ precacheController: controller })],
@@ -36,11 +39,11 @@ export const parsePrecacheOptions = (
     cleanURLs,
     urlManipulation,
   } satisfies PrecacheRouteOptions,
-  controllerOptions: {
+  extensionOptions: {
     cleanupOutdatedCaches,
     concurrency: concurrency ?? 10,
     navigateFallback,
     navigateFallbackAllowlist,
     navigateFallbackDenylist,
-  } satisfies Require<PrecacheControllerOptions, "concurrency">,
+  } satisfies Require<PrecacheExtensionOptions, "concurrency">,
 });

package/src/lib/{controllers/PrecacheController/PrecacheCacheKeyPlugin.ts → extensions/precache/plugin-cache-key.ts}

@@ -5,8 +5,8 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
-import type { StrategyPlugin, StrategyPluginCallbackParam } from "../../../types.js";
-import type { PrecacheController } from "./PrecacheController.js";
+import type { StrategyPlugin, StrategyPluginCallbackParam } from "#lib/types.js";
+import type { Precache } from "./extension.js";
 
 /**
  * A plugin, designed to be used with PrecacheController, to translate URLs into
@@ -15,9 +15,9 @@ import type { PrecacheController } from "./PrecacheController.js";
  * @private
  */
 export class PrecacheCacheKeyPlugin implements StrategyPlugin {
-  private readonly _precacheController: PrecacheController;
+  private readonly _precacheController: Precache;
 
-  constructor({ precacheController }: { precacheController: PrecacheController }) {
+  constructor({ precacheController }: { precacheController: Precache }) {
     this._precacheController = precacheController;
   }