serwist 9.1.0-preview.0 → 10.0.0-preview.2

package/src/lib/controllers/PrecacheController/PrecacheController.ts

@@ -0,0 +1,328 @@
+import { SerwistError } from "#utils/SerwistError.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 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";
+
+export interface PrecacheEntry {
+  integrity?: string;
+  url: string;
+  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 {
+  /**
+   * The cache to use for precaching.
+   */
+  cacheName?: string;
+  /**
+   * Whether outdated caches should be removed.
+   *
+   * @default false
+   */
+  cleanupOutdatedCaches?: boolean;
+  /**
+   * The number of precache requests that should be made concurrently.
+   *
+   * @default 10
+   */
+  concurrency?: number;
+  /**
+   * An URL that should point to a HTML file with which navigation requests for URLs that aren't
+   * precached will be fulfilled.
+   */
+  navigateFallback?: string;
+  /**
+   * URLs that should be allowed to use the `navigateFallback` handler.
+   */
+  navigateFallbackAllowlist?: RegExp[];
+  /**
+   * URLs that should not be allowed to use the `navigateFallback` handler. This takes precedence
+   * over `navigateFallbackAllowlist`.
+   */
+  navigateFallbackDenylist?: RegExp[];
+}
+
+export interface PrecacheOptions extends PrecacheStrategyOptions, PrecacheRouteOptions, PrecacheControllerOptions {}
+
+export class PrecacheController implements Controller {
+  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 _routeOptions: PrecacheRouteOptions;
+
+  /**
+   * Create a new PrecacheController.
+   *
+   * @param options
+   */
+  constructor(entries: (PrecacheEntry | string)[], precacheOptions?: PrecacheOptions) {
+    const { strategyOptions, routeOptions, controllerOptions } = parsePrecacheOptions(this, precacheOptions);
+    this.addToCacheList(entries);
+    this._strategy = new PrecacheStrategy(strategyOptions);
+    this._options = controllerOptions;
+    this._routeOptions = routeOptions;
+  }
+
+  /**
+   * The strategy created by this controller and
+   * used to cache assets and respond to `fetch` events.
+   */
+  get strategy(): Strategy {
+    return this._strategy;
+  }
+
+  /**
+   * Adds items to the cache list, removing duplicates and ensuring the information is valid.
+   *
+   * @param entries Array of entries to precache.
+   */
+  addToCacheList(entries: (PrecacheEntry | string)[]): void {
+    if (process.env.NODE_ENV !== "production") {
+      assert!.isArray(entries, {
+        moduleName: "serwist",
+        className: "PrecacheController",
+        funcName: "addEntries",
+        paramName: "entries",
+      });
+    }
+
+    const urlsToWarnAbout: string[] = [];
+    for (const entry of entries) {
+      // See https://github.com/GoogleChrome/workbox/issues/2259
+      if (typeof entry === "string") {
+        urlsToWarnAbout.push(entry);
+      } else if (entry && !entry.integrity && entry.revision === undefined) {
+        urlsToWarnAbout.push(entry.url);
+      }
+
+      const { cacheKey, url } = createCacheKey(entry);
+      const cacheMode = typeof entry !== "string" && entry.revision ? "reload" : "default";
+
+      if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) {
+        throw new SerwistError("add-to-cache-list-conflicting-entries", {
+          firstEntry: this._urlsToCacheKeys.get(url),
+          secondEntry: cacheKey,
+        });
+      }
+
+      if (typeof entry !== "string" && entry.integrity) {
+        if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {
+          throw new SerwistError("add-to-cache-list-conflicting-integrities", {
+            url,
+          });
+        }
+        this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);
+      }
+
+      this._urlsToCacheKeys.set(url, cacheKey);
+      this._urlsToCacheModes.set(url, cacheMode);
+
+      if (urlsToWarnAbout.length > 0) {
+        const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(
+          ", ",
+        )}\nThis is generally NOT safe, as you risk serving outdated assets.`;
+        if (process.env.NODE_ENV === "production") {
+          // Use console directly to display this warning without bloating
+          // bundle sizes by pulling in all of the logger codebase in prod.
+          console.warn(warningMessage);
+        } else {
+          logger.warn(warningMessage);
+        }
+      }
+    }
+  }
+
+  init({ serwist }: { serwist: Serwist }): void {
+    serwist.registerRoute(new PrecacheRoute(this, this._routeOptions));
+
+    if (this._options.navigateFallback) {
+      serwist.registerRoute(
+        new NavigationRoute(this.createHandlerBoundToUrl(this._options.navigateFallback), {
+          allowlist: this._options.navigateFallbackAllowlist,
+          denylist: this._options.navigateFallbackDenylist,
+        }),
+      );
+    }
+  }
+
+  async install({ event }: { event: ExtendableEvent }): Promise<void> {
+    const installReportPlugin = new PrecacheInstallReportPlugin();
+    this._strategy.plugins.push(installReportPlugin);
+    await parallel(this._options.concurrency!, Array.from(this._urlsToCacheKeys.entries()), async ([url, cacheKey]): Promise<void> => {
+      const integrity = this._cacheKeysToIntegrities.get(cacheKey);
+      const cacheMode = this._urlsToCacheModes.get(url);
+
+      const request = new Request(url, {
+        integrity,
+        cache: cacheMode,
+        credentials: "same-origin",
+      });
+
+      await Promise.all(
+        this._strategy.handleAll({
+          event,
+          request,
+          url: new URL(request.url),
+          params: { cacheKey },
+        }),
+      );
+    });
+
+    const { updatedURLs, notUpdatedURLs } = installReportPlugin;
+
+    if (process.env.NODE_ENV !== "production") {
+      printInstallDetails(updatedURLs, notUpdatedURLs);
+    }
+  }
+
+  async activate(): Promise<void> {
+    const cache = await self.caches.open(this._strategy.cacheName);
+    const currentlyCachedRequests = await cache.keys();
+    const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
+
+    const deletedCacheRequests: string[] = [];
+
+    for (const request of currentlyCachedRequests) {
+      if (!expectedCacheKeys.has(request.url)) {
+        await cache.delete(request);
+        deletedCacheRequests.push(request.url);
+      }
+    }
+
+    if (process.env.NODE_ENV !== "production") {
+      printCleanupDetails(deletedCacheRequests);
+    }
+  }
+
+  /**
+   * Returns a mapping of a precached URL to the corresponding cache key, taking
+   * into account the revision information for the URL.
+   *
+   * @returns A URL to cache key mapping.
+   */
+  getUrlsToPrecacheKeys(): Map<string, string> {
+    return this._urlsToCacheKeys;
+  }
+
+  /**
+   * Returns a list of all the URLs that have been precached by the current
+   * service worker.
+   *
+   * @returns The precached URLs.
+   */
+  getPrecachedUrls(): string[] {
+    return [...this._urlsToCacheKeys.keys()];
+  }
+
+  /**
+   * 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
+   * URL with a search parameter appended to it.
+   *
+   * @param url A URL whose cache key you want to look up.
+   * @returns The versioned URL that corresponds to a cache key
+   * for the original URL, or undefined if that URL isn't precached.
+   */
+  getPrecacheKeyForUrl(url: string): string | undefined {
+    const urlObject = new URL(url, location.href);
+    return this._urlsToCacheKeys.get(urlObject.href);
+  }
+
+  /**
+   * @param url A cache key whose SRI you want to look up.
+   * @returns The subresource integrity associated with the cache key,
+   * or undefined if it's not set.
+   */
+  getIntegrityForPrecacheKey(cacheKey: string): string | undefined {
+    return this._cacheKeysToIntegrities.get(cacheKey);
+  }
+
+  /**
+   * This acts as a drop-in replacement for
+   * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)
+   * with the following differences:
+   *
+   * - It knows what the name of the precache is, and only checks in that cache.
+   * - It allows you to pass in an "original" URL without versioning parameters,
+   * and it will automatically look up the correct cache key for the currently
+   * active revision of that URL.
+   *
+   * E.g., `matchPrecache('index.html')` will find the correct precached
+   * response for the currently active service worker, even if the actual cache
+   * key is `'/index.html?__WB_REVISION__=1234abcd'`.
+   *
+   * @param request The key (without revisioning parameters)
+   * to look up in the precache.
+   * @returns
+   */
+  async matchPrecache(request: string | Request): Promise<Response | undefined> {
+    const url = request instanceof Request ? request.url : request;
+    const cacheKey = this.getPrecacheKeyForUrl(url);
+    if (cacheKey) {
+      const cache = await self.caches.open(this._strategy.cacheName);
+      return cache.match(cacheKey);
+    }
+    return undefined;
+  }
+
+  /**
+   * Returns a function that looks up `url` in the precache (taking into
+   * account revision information), and returns the corresponding `Response`.
+   *
+   * @param url The precached URL which will be used to lookup the response.
+   * @return
+   */
+  createHandlerBoundToUrl(url: string): RouteHandlerCallback {
+    const cacheKey = this.getPrecacheKeyForUrl(url);
+    if (!cacheKey) {
+      throw new SerwistError("non-precached-url", { url });
+    }
+    return (options) => {
+      options.request = new Request(url);
+      options.params = { cacheKey, ...options.params };
+
+      return this._strategy.handle(options);
+    };
+  }
+}

package/src/{utils → lib/controllers/PrecacheController}/PrecacheInstallReportPlugin.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin, SerwistPluginCallbackParam } from "../types.js";
+import type { StrategyPlugin, StrategyPluginCallbackParam } from "../../../types.js";
 
 /**
  * A plugin designed to determine the number of assets that were updated (or not updated)
@@ -14,22 +14,22 @@ import type { SerwistPlugin, SerwistPluginCallbackParam } from "../types.js";
  *
  * @private
  */
-export class PrecacheInstallReportPlugin implements SerwistPlugin {
+export class PrecacheInstallReportPlugin implements StrategyPlugin {
   updatedURLs: string[] = [];
   notUpdatedURLs: string[] = [];
 
-  handlerWillStart: SerwistPlugin["handlerWillStart"] = async ({ request, state }: SerwistPluginCallbackParam["handlerWillStart"]) => {
+  handlerWillStart: StrategyPlugin["handlerWillStart"] = async ({ request, state }: StrategyPluginCallbackParam["handlerWillStart"]) => {
     // TODO: `state` should never be undefined...
     if (state) {
       state.originalRequest = request;
     }
   };
 
-  cachedResponseWillBeUsed: SerwistPlugin["cachedResponseWillBeUsed"] = async ({
+  cachedResponseWillBeUsed: StrategyPlugin["cachedResponseWillBeUsed"] = async ({
     event,
     state,
     cachedResponse,
-  }: SerwistPluginCallbackParam["cachedResponseWillBeUsed"]) => {
+  }: StrategyPluginCallbackParam["cachedResponseWillBeUsed"]) => {
     if (event.type === "install") {
       if (state?.originalRequest && state.originalRequest instanceof Request) {
         // TODO: `state` should never be undefined...

package/src/{PrecacheRoute.ts → lib/controllers/PrecacheController/PrecacheRoute.ts}

@@ -6,13 +6,12 @@
   https://opensource.org/licenses/MIT.
 */
 
-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";
+import { generateURLVariations } from "#utils/generateURLVariations.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 { PrecacheController, PrecacheRouteOptions } from "./PrecacheController.js";
 
 /**
  * A subclass of {@linkcode Route} that takes a {@linkcode Serwist} instance and uses it to match
@@ -20,17 +19,17 @@ import { logger } from "./utils/logger.js";
  */
 export class PrecacheRoute extends Route {
   /**
-   * @param serwist A {@linkcode Serwist} instance.
+   * @param controller A {@linkcode PrecacheController} instance.
    * @param options Options to control how requests are matched
    * against the list of precached URLs.
    */
-  constructor(serwist: Serwist, options?: PrecacheRouteOptions) {
+  constructor(controller: PrecacheController, options?: PrecacheRouteOptions) {
     const match: RouteMatchCallback = ({ request }: RouteMatchCallbackOptions) => {
-      const urlsToCacheKeys = serwist.getUrlsToPrecacheKeys();
+      const urlsToCacheKeys = controller.getUrlsToPrecacheKeys();
       for (const possibleURL of generateURLVariations(request.url, options)) {
         const cacheKey = urlsToCacheKeys.get(possibleURL);
         if (cacheKey) {
-          const integrity = serwist.getIntegrityForPrecacheKey(cacheKey);
+          const integrity = controller.getIntegrityForPrecacheKey(cacheKey);
           return { cacheKey, integrity };
         }
       }
@@ -40,6 +39,6 @@ export class PrecacheRoute extends Route {
       return;
     };
 
-    super(match, serwist.precacheStrategy);
+    super(match, controller.strategy);
   }
 }

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

@@ -6,16 +6,16 @@
   https://opensource.org/licenses/MIT.
 */
 
-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 { Serwist } from "../../Serwist.js";
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.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 { Serwist } from "../../../Serwist.js";
+import { copyResponse } from "../../../copyResponse.js";
+import type { StrategyPlugin } from "../../../types.js";
+import type { StrategyOptions } from "../../strategies/Strategy.js";
+import { Strategy } from "../../strategies/Strategy.js";
+import type { StrategyHandler } from "../../strategies/StrategyHandler.js";
 
 export interface PrecacheStrategyOptions extends StrategyOptions {
   /**
@@ -39,7 +39,7 @@ export interface PrecacheStrategyOptions extends StrategyOptions {
 export class PrecacheStrategy extends Strategy {
   private readonly _fallbackToNetwork: boolean;
 
-  static readonly defaultPrecacheCacheabilityPlugin: SerwistPlugin = {
+  static readonly defaultPrecacheCacheabilityPlugin: StrategyPlugin = {
     async cacheWillUpdate({ response }) {
       if (!response || response.status >= 400) {
         return null;
@@ -49,7 +49,7 @@ export class PrecacheStrategy extends Strategy {
     },
   };
 
-  static readonly copyRedirectedCacheableResponsesPlugin: SerwistPlugin = {
+  static readonly copyRedirectedCacheableResponsesPlugin: StrategyPlugin = {
     async cacheWillUpdate({ response }) {
       return response.redirected ? await copyResponse(response) : response;
     },
@@ -63,7 +63,7 @@ export class PrecacheStrategy extends Strategy {
 
     super(options);
 
-    this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true;
+    this._fallbackToNetwork = options.fallbackToNetwork !== false;
 
     // Redirected responses cannot be used to satisfy a navigation request, so
     // any redirected response must be "copied" rather than cloned, so the new

package/src/lib/controllers/PrecacheController/parsePrecacheOptions.ts

@@ -0,0 +1,46 @@
+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";
+
+export const parsePrecacheOptions = (
+  controller: PrecacheController,
+  {
+    cacheName,
+    plugins,
+    fetchOptions,
+    matchOptions,
+    fallbackToNetwork,
+    directoryIndex,
+    ignoreURLParametersMatching,
+    cleanURLs,
+    urlManipulation,
+    cleanupOutdatedCaches,
+    concurrency,
+    navigateFallback,
+    navigateFallbackAllowlist,
+    navigateFallbackDenylist,
+  }: PrecacheOptions = {},
+) => ({
+  strategyOptions: {
+    cacheName: privateCacheNames.getPrecacheName(cacheName),
+    plugins: [...(plugins ?? []), new PrecacheCacheKeyPlugin({ precacheController: controller })],
+    fetchOptions,
+    matchOptions,
+    fallbackToNetwork,
+  } satisfies Require<PrecacheStrategyOptions, "cacheName" | "plugins">,
+  routeOptions: {
+    directoryIndex,
+    ignoreURLParametersMatching,
+    cleanURLs,
+    urlManipulation,
+  } satisfies PrecacheRouteOptions,
+  controllerOptions: {
+    cleanupOutdatedCaches,
+    concurrency: concurrency ?? 10,
+    navigateFallback,
+    navigateFallbackAllowlist,
+    navigateFallbackDenylist,
+  } satisfies Require<PrecacheControllerOptions, "concurrency">,
+});

package/src/lib/controllers/RuntimeCacheController.ts

@@ -0,0 +1,119 @@
+import { parallel } from "@serwist/utils";
+import type { Serwist } from "../../Serwist.js";
+import type { Controller, RuntimeCaching } from "../../types.js";
+import { type PrecacheFallbackEntry, PrecacheFallbackPlugin } from "../precaching/PrecacheFallbackPlugin.js";
+import { Strategy } from "../strategies/Strategy.js";
+
+export interface WarmRuntimeCacheEntry {
+  integrity?: string;
+  url: string;
+}
+
+export interface WarmRuntimeCacheOptions {
+  concurrency?: number;
+}
+
+export interface FallbackEntry extends PrecacheFallbackEntry {}
+
+export interface FallbacksOptions {
+  /**
+   * A list of fallback entries.
+   */
+  entries: FallbackEntry[];
+}
+
+export interface RuntimeCacheControllerOptions {
+  /**
+   * URLs that should be cached as the service worker is installed.
+   */
+  warmEntries?: (WarmRuntimeCacheEntry | string | Request)[];
+  /**
+   * Options for `warmEntries`.
+   */
+  warmOptions?: WarmRuntimeCacheOptions;
+  /**
+   * Precaches routes so that they can be used as a fallback when
+   * a {@linkcode Strategy} fails to generate a response.
+   *
+   * Note: This option mutates `runtimeCaching`. It also expects the URLs
+   * defined in `entries` to have been precached beforehand.
+   */
+  fallbacks?: FallbacksOptions;
+}
+
+export class RuntimeCacheController implements Controller {
+  _entries: RuntimeCaching[];
+  _options: RuntimeCacheControllerOptions;
+  constructor(entries: RuntimeCaching[], options: RuntimeCacheControllerOptions = {}) {
+    this._entries = entries;
+    this._options = options;
+    this.init = this.init.bind(this);
+    this.install = this.install.bind(this);
+  }
+
+  init({ serwist }: { serwist: Serwist }): void {
+    if (this._options.fallbacks !== undefined) {
+      const fallbackPlugin = new PrecacheFallbackPlugin({
+        fallbackUrls: this._options.fallbacks.entries,
+        precacheController: serwist.precache,
+      });
+
+      this._entries.forEach((cacheEntry) => {
+        if (
+          cacheEntry.handler instanceof Strategy &&
+          // This also filters entries with `PrecacheFallbackPlugin` as it also has `handlerDidError`.
+          !cacheEntry.handler.plugins.some((plugin) => "handlerDidError" in plugin)
+        ) {
+          cacheEntry.handler.plugins.push(fallbackPlugin);
+        }
+      });
+    }
+    for (const entry of this._entries) {
+      serwist.registerCapture(entry.matcher, entry.handler, entry.method);
+    }
+  }
+
+  async install({ event, serwist }: { event: ExtendableEvent; serwist: Serwist }) {
+    const concurrency = this._options.warmOptions?.concurrency ?? 10;
+    if (this._options.warmEntries) {
+      await parallel(concurrency, this._options.warmEntries, async (entry) => {
+        const request =
+          entry instanceof Request
+            ? entry
+            : new Request(typeof entry === "string" ? entry : entry.url, {
+                integrity: typeof entry !== "string" ? entry.integrity : undefined,
+                credentials: "same-origin",
+              });
+        await serwist.handleRequest({
+          request,
+          event,
+        });
+      });
+    }
+  }
+
+  /**
+   * Any assets you wish to cache ahead of time which can't be revisioned
+   * should be cached with this method. All assets are cached on install
+   * regardless of whether an older version of the request is in the cache.
+   *
+   * The input can be a string or a [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request).
+   *
+   * @example
+   * ```js
+   * // For unrevisioned assets that should always be downloaded
+   * // with every service worker update, use this method.
+   * serwist.warmRuntimeCache([
+   *   "/scripts/main.js',
+   *   "/images/default-avater.png",
+   *   new Request("/images/logo.png"),
+   *   new Request("/api/data.json"),
+   * ]);
+   * ```
+   * @param entries A set of urls to cache when the service worker is installed.
+   */
+  warmRuntimeCache(entries: (WarmRuntimeCacheEntry | string | Request)[]): void {
+    if (!this._options.warmEntries) this._options.warmEntries = [];
+    this._options.warmEntries.push(...entries);
+  }
+}

package/src/lib/controllers/index.ts

@@ -0,0 +1,3 @@
+export { PrecacheStrategy } from "./PrecacheController/PrecacheStrategy.js";
+export { PrecacheRoute } from "./PrecacheController/PrecacheRoute.js";
+export { RuntimeCacheController } from "./RuntimeCacheController.js";

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 { assert } from "#utils/assert.js";
+import { logger } from "#utils/logger.js";
 import { CacheTimestampsModel } from "./models/CacheTimestampsModel.js";
 
 interface CacheExpirationConfig {