serwist 9.0.12 → 10.0.0-preview.1

package/src/controllers/RuntimeCacheController.ts

@@ -0,0 +1,119 @@
+import { parallel } from "@serwist/utils";
+import { PrecacheFallbackPlugin, type PrecacheFallbackEntry } from "../lib/precaching/PrecacheFallbackPlugin.js";
+import { Strategy } from "../lib/strategies/Strategy.js";
+import type { Serwist } from "../Serwist.js";
+import type { Controller, RuntimeCaching } from "../types.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): 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: 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/index.ts

@@ -1,6 +1,8 @@
+import { PrecacheStrategy } from "./controllers/PrecacheController/PrecacheStrategy.js";
+import { PrecacheRoute } from "./controllers/PrecacheController/PrecacheRoute.js";
+import { RuntimeCacheController } from "./controllers/RuntimeCacheController.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";
@@ -36,7 +38,6 @@ 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";
@@ -56,6 +57,8 @@ export {
   isNavigationPreloadSupported,
   registerQuotaErrorCallback,
   setCacheNameDetails,
+  // Controllers
+  RuntimeCacheController,
   // Caching strategies
   CacheFirst,
   CacheOnly,

package/src/lib/backgroundSync/BackgroundSyncPlugin.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { FetchDidFailCallbackParam, SerwistPlugin } from "../../types.js";
+import type { FetchDidFailCallbackParam, StrategyPlugin } from "../../types.js";
 import type { BackgroundSyncQueueOptions } from "./BackgroundSyncQueue.js";
 import { BackgroundSyncQueue } from "./BackgroundSyncQueue.js";
 
@@ -14,7 +14,7 @@ import { BackgroundSyncQueue } from "./BackgroundSyncQueue.js";
  * A class implementing the `fetchDidFail` lifecycle callback. This makes it
  * easier to add failed requests to a {@linkcode BackgroundSyncQueue}.
  */
-export class BackgroundSyncPlugin implements SerwistPlugin {
+export class BackgroundSyncPlugin implements StrategyPlugin {
   private readonly _queue: BackgroundSyncQueue;
 
   /**

package/src/lib/broadcastUpdate/BroadcastUpdatePlugin.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { CacheDidUpdateCallbackParam, SerwistPlugin } from "../../types.js";
+import type { CacheDidUpdateCallbackParam, StrategyPlugin } from "../../types.js";
 import { BroadcastCacheUpdate } from "./BroadcastCacheUpdate.js";
 import type { BroadcastCacheUpdateOptions } from "./types.js";
 
@@ -14,7 +14,7 @@ import type { BroadcastCacheUpdateOptions } from "./types.js";
  * A class implementing the `cacheDidUpdate` lifecycle callback. It will automatically
  * broadcast a message whenever a cached response is updated.
  */
-export class BroadcastUpdatePlugin implements SerwistPlugin {
+export class BroadcastUpdatePlugin implements StrategyPlugin {
   private readonly _broadcastUpdate: BroadcastCacheUpdate;
 
   /**

package/src/lib/cacheableResponse/CacheableResponsePlugin.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin } from "../../types.js";
+import type { StrategyPlugin } from "../../types.js";
 import type { CacheableResponseOptions } from "./CacheableResponse.js";
 import { CacheableResponse } from "./CacheableResponse.js";
 
@@ -15,7 +15,7 @@ import { CacheableResponse } from "./CacheableResponse.js";
  * easier to add in cacheability checks to requests made via Serwist's built-in
  * strategies.
  */
-export class CacheableResponsePlugin implements SerwistPlugin {
+export class CacheableResponsePlugin implements StrategyPlugin {
   private readonly _cacheableResponse: CacheableResponse;
 
   /**
@@ -36,7 +36,7 @@ export class CacheableResponsePlugin implements SerwistPlugin {
    * @returns
    * @private
    */
-  cacheWillUpdate: SerwistPlugin["cacheWillUpdate"] = async ({ response }) => {
+  cacheWillUpdate: StrategyPlugin["cacheWillUpdate"] = async ({ response }) => {
     if (this._cacheableResponse.isResponseCacheable(response)) {
       return response;
     }

package/src/lib/expiration/ExpirationPlugin.ts

@@ -7,7 +7,7 @@
 */
 
 import { registerQuotaErrorCallback } from "../../registerQuotaErrorCallback.js";
-import type { CacheDidUpdateCallbackParam, CachedResponseWillBeUsedCallbackParam, SerwistPlugin } from "../../types.js";
+import type { CacheDidUpdateCallbackParam, CachedResponseWillBeUsedCallbackParam, StrategyPlugin } from "../../types.js";
 import { SerwistError } from "../../utils/SerwistError.js";
 import { assert } from "../../utils/assert.js";
 import { cacheNames as privateCacheNames } from "../../utils/cacheNames.js";
@@ -66,7 +66,7 @@ export interface ExpirationPluginOptions {
  *
  * @see https://serwist.pages.dev/docs/serwist/runtime-caching/plugins/expiration-plugin
  */
-export class ExpirationPlugin implements SerwistPlugin {
+export class ExpirationPlugin implements StrategyPlugin {
   private readonly _config: ExpirationPluginOptions;
   private _cacheExpirations: Map<string, CacheExpiration>;
 

package/src/lib/precaching/PrecacheFallbackPlugin.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { Serwist } from "../../Serwist.js";
-import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "../../types.js";
+import type { PrecacheController } from "../../controllers/PrecacheController/PrecacheController.js";
+import type { HandlerDidErrorCallbackParam, StrategyPlugin } from "../../types.js";
 
 export interface PrecacheFallbackEntry {
   /**
@@ -28,9 +28,9 @@ export interface PrecacheFallbackPluginOptions {
    */
   fallbackUrls: (string | PrecacheFallbackEntry)[];
   /**
-   * A {@linkcode Serwist} instance.
+   * A {@linkcode PrecacheController} instance.
    */
-  serwist: Serwist;
+  precacheController: PrecacheController;
 }
 
 /**
@@ -41,18 +41,18 @@ export interface PrecacheFallbackPluginOptions {
  * and returning a precached response, taking the expected revision parameter
  * into account automatically.
  */
-export class PrecacheFallbackPlugin implements SerwistPlugin {
+export class PrecacheFallbackPlugin implements StrategyPlugin {
   private readonly _fallbackUrls: (string | PrecacheFallbackEntry)[];
-  private readonly _serwist: Serwist;
+  private readonly _precacheController: PrecacheController;
 
   /**
    * Constructs a new instance with the associated `fallbackUrls`.
    *
    * @param config
    */
-  constructor({ fallbackUrls, serwist }: PrecacheFallbackPluginOptions) {
+  constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions) {
     this._fallbackUrls = fallbackUrls;
-    this._serwist = serwist;
+    this._precacheController = precacheController;
   }
 
   /**
@@ -63,12 +63,12 @@ export class PrecacheFallbackPlugin implements SerwistPlugin {
   async handlerDidError(param: HandlerDidErrorCallbackParam) {
     for (const fallback of this._fallbackUrls) {
       if (typeof fallback === "string") {
-        const fallbackResponse = await this._serwist.matchPrecache(fallback);
+        const fallbackResponse = await this._precacheController.matchPrecache(fallback);
         if (fallbackResponse !== undefined) {
           return fallbackResponse;
         }
       } else if (fallback.matcher(param)) {
-        const fallbackResponse = await this._serwist.matchPrecache(fallback.url);
+        const fallbackResponse = await this._precacheController.matchPrecache(fallback.url);
         if (fallbackResponse !== undefined) {
           return fallbackResponse;
         }

package/src/lib/rangeRequests/RangeRequestsPlugin.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin } from "../../types.js";
+import type { StrategyPlugin } from "../../types.js";
 import { createPartialResponse } from "./createPartialResponse.js";
 
 /**
@@ -15,7 +15,7 @@ import { createPartialResponse } from "./createPartialResponse.js";
  * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback
  * and returning the appropriate subset of the cached response body.
  */
-export class RangeRequestsPlugin implements SerwistPlugin {
+export class RangeRequestsPlugin implements StrategyPlugin {
   /**
    * @param options
    * @returns If request contains a `Range` header, then a
@@ -23,7 +23,7 @@ export class RangeRequestsPlugin implements SerwistPlugin {
    * returned. Otherwise, `cachedResponse` is returned as-is.
    * @private
    */
-  cachedResponseWillBeUsed: SerwistPlugin["cachedResponseWillBeUsed"] = async ({ request, cachedResponse }) => {
+  cachedResponseWillBeUsed: StrategyPlugin["cachedResponseWillBeUsed"] = async ({ request, cachedResponse }) => {
     // Only return a sliced response if there's something valid in the cache,
     // and there's a Range: header in the request.
     if (cachedResponse && request.headers.has("range")) {

package/src/lib/strategies/Strategy.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { HandlerCallbackOptions, RouteHandlerObject, SerwistPlugin } from "../../types.js";
+import type { HandlerCallbackOptions, RouteHandlerObject, StrategyPlugin } from "../../types.js";
 import { SerwistError } from "../../utils/SerwistError.js";
 import { cacheNames as privateCacheNames } from "../../utils/cacheNames.js";
 import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
@@ -21,7 +21,7 @@ export interface StrategyOptions {
   /**
    * [Plugins](https://serwist.pages.dev/docs/serwist/runtime-caching/plugins) to use in conjunction with this caching strategy.
    */
-  plugins?: SerwistPlugin[];
+  plugins?: StrategyPlugin[];
   /**
    * Options passed to [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) `fetch()` calls made by
    * this strategy.
@@ -42,7 +42,7 @@ export interface StrategyOptions {
  */
 export abstract class Strategy implements RouteHandlerObject {
   cacheName: string;
-  plugins: SerwistPlugin[];
+  plugins: StrategyPlugin[];
   fetchOptions?: RequestInit;
   matchOptions?: CacheQueryOptions;
 

package/src/lib/strategies/StrategyHandler.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { HandlerCallbackOptions, MapLikeObject, SerwistPlugin, SerwistPluginCallbackParam } from "../../types.js";
+import type { HandlerCallbackOptions, MapLikeObject, StrategyPlugin, StrategyPluginCallbackParam } from "../../types.js";
 import { Deferred } from "../../utils/Deferred.js";
 import { SerwistError } from "../../utils/SerwistError.js";
 import { assert } from "../../utils/assert.js";
@@ -59,8 +59,8 @@ export class StrategyHandler {
   private readonly _strategy: Strategy;
   private readonly _handlerDeferred: Deferred<any>;
   private readonly _extendLifetimePromises: Promise<any>[];
-  private readonly _plugins: SerwistPlugin[];
-  private readonly _pluginStateMap: Map<SerwistPlugin, MapLikeObject>;
+  private readonly _plugins: StrategyPlugin[];
+  private readonly _pluginStateMap: Map<StrategyPlugin, MapLikeObject>;
 
   /**
    * Creates a new instance associated with the passed strategy and event
@@ -405,7 +405,7 @@ export class StrategyHandler {
    * @param name The name of the callback to check for.
    * @returns
    */
-  hasCallback<C extends keyof SerwistPlugin>(name: C): boolean {
+  hasCallback<C extends keyof StrategyPlugin>(name: C): boolean {
     for (const plugin of this._strategy.plugins) {
       if (name in plugin) {
         return true;
@@ -426,10 +426,10 @@ export class StrategyHandler {
    * @param param The object to pass as the first (and only) param when executing each callback. This object will be merged with the
    * current plugin state prior to callback execution.
    */
-  async runCallbacks<C extends keyof NonNullable<SerwistPlugin>>(name: C, param: Omit<SerwistPluginCallbackParam[C], "state">): Promise<void> {
+  async runCallbacks<C extends keyof NonNullable<StrategyPlugin>>(name: C, param: Omit<StrategyPluginCallbackParam[C], "state">): Promise<void> {
     for (const callback of this.iterateCallbacks(name)) {
       // TODO(philipwalton): not sure why `any` is needed. It seems like
-      // this should work with `as SerwistPluginCallbackParam[C]`.
+      // this should work with `as StrategyPluginCallbackParam[C]`.
       await callback(param as any);
     }
   }
@@ -440,18 +440,18 @@ export class StrategyHandler {
    * @param name The name fo the callback to run
    * @returns
    */
-  *iterateCallbacks<C extends keyof SerwistPlugin>(name: C): Generator<NonNullable<SerwistPlugin[C]>> {
+  *iterateCallbacks<C extends keyof StrategyPlugin>(name: C): Generator<NonNullable<StrategyPlugin[C]>> {
     for (const plugin of this._strategy.plugins) {
       if (typeof plugin[name] === "function") {
         const state = this._pluginStateMap.get(plugin);
-        const statefulCallback = (param: Omit<SerwistPluginCallbackParam[C], "state">) => {
+        const statefulCallback = (param: Omit<StrategyPluginCallbackParam[C], "state">) => {
           const statefulParam = { ...param, state };
 
           // TODO(philipwalton): not sure why `any` is needed. It seems like
           // this should work with `as WorkboxPluginCallbackParam[C]`.
           return plugin[name]!(statefulParam as any);
         };
-        yield statefulCallback as NonNullable<SerwistPlugin[C]>;
+        yield statefulCallback as NonNullable<StrategyPlugin[C]>;
       }
     }
   }

package/src/lib/strategies/plugins/cacheOkAndOpaquePlugin.ts

@@ -6,9 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin } from "../../../types.js";
+import type { StrategyPlugin } from "../../../types.js";
 
-export const cacheOkAndOpaquePlugin: SerwistPlugin = {
+export const cacheOkAndOpaquePlugin: StrategyPlugin = {
   /**
    * Returns a valid response (to allow caching) if the status is 200 (OK) or
    * 0 (opaque).

package/src/types.ts

@@ -1,7 +1,8 @@
+import type { Prettify } from "@serwist/utils";
 import type { HTTPMethod } from "./constants.js";
-import type { PrecacheStrategyOptions } from "./lib/strategies/PrecacheStrategy.js";
 import type { Route } from "./Route.js";
 import type { Serwist } from "./Serwist.js";
+import type { PrecacheControllerOptions, PrecacheEntry, PrecacheOptions, PrecacheRouteOptions } from "./controllers/PrecacheController/PrecacheController.js";
 
 export type PromiseOrNot<T> = T | Promise<T>;
 
@@ -15,6 +16,15 @@ export interface MapLikeObject {
  */
 export type PluginState = MapLikeObject;
 
+/**
+ * An object with optional lifecycle callback properties for Serwist's operations.
+ */
+export interface Controller {
+  init?(serwist: Serwist): void;
+  install?(event: ExtendableEvent, serwist: Serwist): Promise<void>;
+  activate?(event: ExtendableEvent, serwist: Serwist): Promise<void>;
+}
+
 /**
  * Options passed to a {@linkcode RouteMatchCallback} function.
  */
@@ -74,7 +84,7 @@ export interface ManualHandlerCallbackOptions {
   params?: never;
 }
 
-export type HandlerCallbackOptions = RouteHandlerCallbackOptions | ManualHandlerCallbackOptions;
+export type HandlerCallbackOptions = Prettify<RouteHandlerCallbackOptions | ManualHandlerCallbackOptions>;
 
 /**
  * The "handler" callback is invoked whenever a request is matched to a
@@ -110,7 +120,7 @@ export interface RouteHandlerObject {
  * Either a {@linkcode RouteHandlerCallback} or a {@linkcode RouteHandlerObject}.
  * Most APIs that accept route handlers take either.
  */
-export type RouteHandler = RouteHandlerCallback | RouteHandlerObject;
+export type RouteHandler = RouteHandlerCallback | Prettify<RouteHandlerObject>;
 
 export interface HandlerWillStartCallbackParam {
   request: Request;
@@ -256,7 +266,7 @@ export type HandlerDidCompleteCallback = (param: HandlerDidCompleteCallbackParam
  * An object with optional lifecycle callback properties for the fetch and
  * cache operations.
  */
-export declare interface SerwistPlugin {
+export interface StrategyPlugin {
   cacheDidUpdate?: CacheDidUpdateCallback;
   cachedResponseWillBeUsed?: CachedResponseWillBeUsedCallback;
   cacheKeyWillBeUsed?: CacheKeyWillBeUsedCallback;
@@ -271,7 +281,7 @@ export declare interface SerwistPlugin {
   requestWillFetch?: RequestWillFetchCallback;
 }
 
-export interface SerwistPluginCallbackParam {
+export interface StrategyPluginCallbackParam {
   cacheDidUpdate: CacheDidUpdateCallbackParam;
   cachedResponseWillBeUsed: CachedResponseWillBeUsedCallbackParam;
   cacheKeyWillBeUsed: CacheKeyWillBeUsedCallbackParam;
@@ -331,66 +341,13 @@ export interface CleanupResult {
   deletedCacheRequests: string[];
 }
 
-export declare 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 PrecacheOptions extends PrecacheStrategyOptions, PrecacheRouteOptions {
-  /**
-   * 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 type UrlManipulation = ({ url }: { url: URL }) => URL[];
+
+export type {
+  StrategyPlugin as SerwistPlugin,
+  StrategyPluginCallbackParam as SerwistPluginCallbackParam,
+  PrecacheEntry,
+  PrecacheRouteOptions,
+  PrecacheControllerOptions,
+  PrecacheOptions,
+};

package/src/utils/pluginUtils.ts

@@ -6,10 +6,10 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin } from "../types.js";
+import type { StrategyPlugin } from "../types.js";
 
 export const pluginUtils = {
-  filter: (plugins: SerwistPlugin[], callbackName: string): SerwistPlugin[] => {
+  filter: (plugins: StrategyPlugin[], callbackName: string): StrategyPlugin[] => {
     return plugins.filter((plugin) => callbackName in plugin);
   },
 };

package/dist/PrecacheRoute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheRoute.d.ts","sourceRoot":"","sources":["../src/PrecacheRoute.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD;;;GAGG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;OAIG;gBACS,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAkB7D"}