serwist 9.0.12 → 10.0.0-preview.1

package/dist/legacy/precacheAndRoute.d.ts

@@ -1,14 +0,0 @@
-import type { PrecacheEntry, PrecacheRouteOptions } from "../types.js";
-/**
- * This method will add entries to the precache list and add a route to
- * respond to `fetch` events.
- *
- * This is a convenience method that will call
- * {@linkcode precache} and {@linkcode addRoute} in a single call.
- *
- * @param entries Array of entries to precache.
- * @param options See the {@linkcode PrecacheRouteOptions} options.
- * @deprecated
- */
-export declare const precacheAndRoute: (entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions) => void;
-//# sourceMappingURL=precacheAndRoute.d.ts.map

package/dist/legacy/precacheAndRoute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"precacheAndRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/precacheAndRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIvE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,YAAY,oBAAoB,KAAG,IAGtG,CAAC"}

package/dist/legacy/registerRoute.d.ts

@@ -1,16 +0,0 @@
-import type { Route } from "../Route.js";
-import type { HTTPMethod } from "../constants.js";
-import type { RouteHandler, RouteMatchCallback } from "../types.js";
-/**
- * Registers a `RegExp`, string, or function with a caching
- * strategy to a singleton {@linkcode Router} instance.
- *
- * @param capture If the capture param is a {@linkcode Route}, all other arguments will be ignored.
- * @param handler A callback function that returns a promise resulting in a response.
- * This parameter is required if `capture` is not a {@linkcode Route} object.
- * @param method The HTTP method to match the route against. Defaults to `'GET'`.
- * @returns The generated {@linkcode Route} object, which can then be provided to {@linkcode unregisterRoute} if needed.
- * @deprecated
- */
-export declare const registerRoute: (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod) => Route;
-//# sourceMappingURL=registerRoute.d.ts.map

package/dist/legacy/registerRoute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/registerRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIpE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KAElI,CAAC"}

package/dist/legacy/registerRuntimeCaching.d.ts

@@ -1,11 +0,0 @@
-import type { RuntimeCaching } from "../types.js";
-/**
- * Registers caching strategies to a singleton Router instance. It is a simple
- * syntatic sugar for {@linkcode registerRoute}.
- *
- * @param runtimeCachingList
- * @returns
- * @deprecated
- */
-export declare const registerRuntimeCaching: (...runtimeCachingList: RuntimeCaching[]) => void;
-//# sourceMappingURL=registerRuntimeCaching.d.ts.map

package/dist/legacy/registerRuntimeCaching.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerRuntimeCaching.d.ts","sourceRoot":"","sources":["../../src/legacy/registerRuntimeCaching.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,0BAA2B,cAAc,EAAE,KAAG,IAIhF,CAAC"}

package/dist/legacy/setCatchHandler.d.ts

@@ -1,10 +0,0 @@
-import type { RouteHandler } from "../types.js";
-/**
- * If a route throws an error while handling a request, this handler
- * will be called and given a chance to provide a response.
- *
- * @param handler A callback function that returns a promise resulting in a response.
- * @deprecated
- */
-export declare const setCatchHandler: (handler: RouteHandler) => void;
-//# sourceMappingURL=setCatchHandler.d.ts.map

package/dist/legacy/setCatchHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setCatchHandler.d.ts","sourceRoot":"","sources":["../../src/legacy/setCatchHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,YAAa,YAAY,KAAG,IAEvD,CAAC"}

package/dist/legacy/setDefaultHandler.d.ts

@@ -1,13 +0,0 @@
-import type { RouteHandler } from "../types.js";
-/**
- * Defines a default handler that's called when no routes explicitly
- * match the incoming request.
- *
- * Without a default handler, unmatched requests will go against the
- * network as if there were no service worker present.
- *
- * @param handler A callback function that returns a promise resulting in a response.
- * @deprecated
- */
-export declare const setDefaultHandler: (handler: RouteHandler) => void;
-//# sourceMappingURL=setDefaultHandler.d.ts.map

package/dist/legacy/setDefaultHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setDefaultHandler.d.ts","sourceRoot":"","sources":["../../src/legacy/setDefaultHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,YAAa,YAAY,KAAG,IAEzD,CAAC"}

package/dist/legacy/singletonPrecacheController.d.ts

@@ -1,34 +0,0 @@
-import { PrecacheController } from "./PrecacheController.js";
-/**
- * Creates a new, singleton {@linkcode PrecacheController} if one does not exist. If one does
- * already exist, that instance is returned. This instance is used by Serwist's
- * {@linkcode PrecacheController}-dependent functions and classes unless you provide a different
- * {@linkcode PrecacheController} to them.
- *
- * @returns The singleton {@linkcode PrecacheController}.
- * @deprecated
- */
-export declare const getSingletonPrecacheController: () => PrecacheController;
-/**
- * Changes the singleton {@linkcode PrecacheController} to a different instance. This is meant for when you do not
- * want to pass your own {@linkcode PrecacheController} to every one of Serwist's {@linkcode PrecacheController}-dependent
- * functions and classes.
- *
- * It is highly recommended that you call this before anything else, if you plan on doing so.
- *
- * @example
- * ```js
- * import { PrecacheController, setSingletonPrecacheController } from "serwist/legacy";
- *
- * const controller = new PrecacheController();
- *
- * setSingletonPrecacheController(controller);
- *
- * // Do something with your controller...
- * ```
- * @param router
- * @returns The new singleton {@linkcode PrecacheController}.
- * @deprecated
- */
-export declare const setSingletonPrecacheController: (precacheController: PrecacheController) => PrecacheController;
-//# sourceMappingURL=singletonPrecacheController.d.ts.map

package/dist/legacy/singletonPrecacheController.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"singletonPrecacheController.d.ts","sourceRoot":"","sources":["../../src/legacy/singletonPrecacheController.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAI7D;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,QAAO,kBAKjD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,8BAA8B,uBAAwB,kBAAkB,KAAG,kBAGvF,CAAC"}

package/dist/legacy/singletonRouter.d.ts

@@ -1,41 +0,0 @@
-import { Router } from "./Router.js";
-/**
- * Creates a new, singleton {@linkcode Router} if one does not exist. If one does
- * already exist, that instance is returned. This instance is used by
- * Serwist's {@linkcode Router}-dependent functions and classes unless you provide
- * a different {@linkcode Router} to them.
- *
- * @returns The singleton {@linkcode Router}.
- * @deprecated
- */
-export declare const getSingletonRouter: () => Router;
-/**
- * Changes the singleton {@linkcode Router} to a different instance. This is meant for when you do not
- * want to pass your own {@linkcode Router} to every one of Serwist's {@linkcode Router}-dependent functions and classes.
- * If this or {@linkcode getSingletonRouter} has been called before, it removes the listeners of the
- * previous singleton {@linkcode Router}. It also adds those of the new one, so you need not do that yourself.
- *
- * It is highly recommended that you call this before anything else, if you plan on doing so.
- *
- * @example
- * ```js
- * import { Router, setSingletonRouter } from "serwist/legacy";
- *
- * const router = new Router();
- *
- * setSingletonRouter(router);
- *
- * router.registerRoute(
- *   new Route(
- *     /\/api\/.*\/*.json/,
- *     new NetworkOnly(),
- *     "POST",
- *   ),
- * );
- * ```
- * @param router
- * @returns The new singleton {@linkcode Router}.
- * @deprecated
- */
-export declare const setSingletonRouter: (router: Router) => Router;
-//# sourceMappingURL=singletonRouter.d.ts.map

package/dist/legacy/singletonRouter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"singletonRouter.d.ts","sourceRoot":"","sources":["../../src/legacy/singletonRouter.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIrC;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,QAAO,MASrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,WAAY,MAAM,KAAG,MASnD,CAAC"}

package/dist/legacy/unregisterRoute.d.ts

@@ -1,9 +0,0 @@
-import type { Route } from "../Route.js";
-/**
- * Unregisters a route from the singleton {@linkcode Router} instance.
- *
- * @param route The route to unregister.
- * @deprecated
- */
-export declare const unregisterRoute: (route: Route) => void;
-//# sourceMappingURL=unregisterRoute.d.ts.map

package/dist/legacy/unregisterRoute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unregisterRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/unregisterRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIzC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,UAAW,KAAK,KAAG,IAE9C,CAAC"}

package/dist/legacy/utils/PrecacheCacheKeyPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheCacheKeyPlugin.d.ts","sourceRoot":"","sources":["../../../src/legacy/utils/PrecacheCacheKeyPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAA8B,MAAM,gBAAgB,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;GAKG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;gBAE7C,EAAE,kBAAkB,EAAE,EAAE;QAAE,kBAAkB,EAAE,kBAAkB,CAAA;KAAE;IAI9E,kBAAkB,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAOrD;CACH"}

package/dist/legacy/utils/getCacheKeyForURL.d.ts

@@ -1,14 +0,0 @@
-import type { PrecacheRouteOptions } from "../../types.js";
-/**
- * This function will take the request URL and manipulate it based on the
- * configuration options.
- *
- * @param url
- * @param options
- * @returns Returns the URL in the cache that matches the request,
- * if possible.
- *
- * @private
- */
-export declare const getCacheKeyForURL: (url: string, options: PrecacheRouteOptions) => string | undefined;
-//# sourceMappingURL=getCacheKeyForURL.d.ts.map

package/dist/legacy/utils/getCacheKeyForURL.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCacheKeyForURL.d.ts","sourceRoot":"","sources":["../../../src/legacy/utils/getCacheKeyForURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAI3D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,QAAS,MAAM,WAAW,oBAAoB,KAAG,MAAM,GAAG,SAYvF,CAAC"}

package/dist/lib/strategies/PrecacheStrategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheStrategy.d.ts","sourceRoot":"","sources":["../../../src/lib/strategies/PrecacheStrategy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAMpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC9D;;OAEG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;IACrC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAU;IAE7C,MAAM,CAAC,QAAQ,CAAC,iCAAiC,EAAE,aAAa,CAQ9D;IAEF,MAAM,CAAC,QAAQ,CAAC,sCAAsC,EAAE,aAAa,CAInE;IAEF;;OAEG;gBACS,OAAO,GAAE,uBAA4B;IAcjD;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAwBtE,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyE3E,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAqBnF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,qCAAqC,IAAI,IAAI;CA4B9C"}

package/dist/utils/PrecacheCacheKeyPlugin.d.ts

@@ -1,16 +0,0 @@
-import type { Serwist } from "../Serwist.js";
-import type { SerwistPlugin } from "../types.js";
-/**
- * A plugin, designed to be used with PrecacheController, to translate URLs into
- * the corresponding cache key, based on the current revision info.
- *
- * @private
- */
-export declare class PrecacheCacheKeyPlugin implements SerwistPlugin {
-    private readonly _precacheController;
-    constructor({ precacheController }: {
-        precacheController: Serwist;
-    });
-    cacheKeyWillBeUsed: SerwistPlugin["cacheKeyWillBeUsed"];
-}
-//# sourceMappingURL=PrecacheCacheKeyPlugin.d.ts.map

package/dist/utils/PrecacheCacheKeyPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheCacheKeyPlugin.d.ts","sourceRoot":"","sources":["../../src/utils/PrecacheCacheKeyPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,aAAa,EAA8B,MAAM,aAAa,CAAC;AAE7E;;;;;GAKG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAU;gBAElC,EAAE,kBAAkB,EAAE,EAAE;QAAE,kBAAkB,EAAE,OAAO,CAAA;KAAE;IAInE,kBAAkB,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAOrD;CACH"}

package/dist/utils/PrecacheInstallReportPlugin.d.ts

@@ -1,14 +0,0 @@
-import type { SerwistPlugin } from "../types.js";
-/**
- * A plugin designed to determine the number of assets that were updated (or not updated)
- * during the `install` event.
- *
- * @private
- */
-export declare class PrecacheInstallReportPlugin implements SerwistPlugin {
-    updatedURLs: string[];
-    notUpdatedURLs: string[];
-    handlerWillStart: SerwistPlugin["handlerWillStart"];
-    cachedResponseWillBeUsed: SerwistPlugin["cachedResponseWillBeUsed"];
-}
-//# sourceMappingURL=PrecacheInstallReportPlugin.d.ts.map

package/dist/utils/PrecacheInstallReportPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheInstallReportPlugin.d.ts","sourceRoot":"","sources":["../../src/utils/PrecacheInstallReportPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAA8B,MAAM,aAAa,CAAC;AAE7E;;;;;GAKG;AACH,qBAAa,2BAA4B,YAAW,aAAa;IAC/D,WAAW,EAAE,MAAM,EAAE,CAAM;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAM;IAE9B,gBAAgB,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAKjD;IAEF,wBAAwB,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAkBjE;CACH"}

package/dist/utils/parsePrecacheOptions.d.ts

@@ -1,26 +0,0 @@
-import type { Serwist } from "../Serwist.js";
-import type { PrecacheOptions } from "../types.js";
-import { PrecacheCacheKeyPlugin } from "./PrecacheCacheKeyPlugin.js";
-export declare const parsePrecacheOptions: (serwist: Serwist, precacheOptions?: PrecacheOptions) => {
-    precacheStrategyOptions: {
-        cacheName: string;
-        plugins: (import("../types.js").SerwistPlugin | PrecacheCacheKeyPlugin)[];
-        fetchOptions: RequestInit | undefined;
-        matchOptions: CacheQueryOptions | undefined;
-        fallbackToNetwork: boolean | undefined;
-    };
-    precacheRouteOptions: {
-        directoryIndex: string | null | undefined;
-        ignoreURLParametersMatching: RegExp[] | undefined;
-        cleanURLs: boolean | undefined;
-        urlManipulation: import("../types.js").UrlManipulation | undefined;
-    };
-    precacheMiscOptions: {
-        cleanupOutdatedCaches: boolean | undefined;
-        concurrency: number;
-        navigateFallback: string | undefined;
-        navigateFallbackAllowlist: RegExp[] | undefined;
-        navigateFallbackDenylist: RegExp[] | undefined;
-    };
-};
-//# sourceMappingURL=parsePrecacheOptions.d.ts.map

package/dist/utils/parsePrecacheOptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parsePrecacheOptions.d.ts","sourceRoot":"","sources":["../../src/utils/parsePrecacheOptions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE,eAAO,MAAM,oBAAoB,YAAa,OAAO,oBAAmB,eAAe;;;;;;;;;;;;;;;;;;;;;CAwCtF,CAAC"}

package/src/index.legacy.ts

@@ -1,62 +0,0 @@
-import { PrecacheController } from "./legacy/PrecacheController.js";
-import { PrecacheFallbackPlugin } from "./legacy/PrecacheFallbackPlugin.js";
-import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./legacy/PrecacheFallbackPlugin.js";
-import { PrecacheRoute } from "./legacy/PrecacheRoute.js";
-import { Router } from "./legacy/Router.js";
-import { addPlugins } from "./legacy/addPlugins.js";
-import { addRoute } from "./legacy/addRoute.js";
-import { createHandlerBoundToURL } from "./legacy/createHandlerBoundToURL.js";
-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";
-import { precacheAndRoute } from "./legacy/precacheAndRoute.js";
-import { registerRoute } from "./legacy/registerRoute.js";
-import { registerRuntimeCaching } from "./legacy/registerRuntimeCaching.js";
-import { setCatchHandler } from "./legacy/setCatchHandler.js";
-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";
-
-export {
-  // Actual deprecated modules start here
-  addPlugins,
-  addRoute,
-  createHandlerBoundToURL,
-  fallbacks,
-  getCacheKeyForURL,
-  initializeGoogleAnalytics,
-  installSerwist,
-  matchPrecache,
-  precache,
-  precacheAndRoute,
-  PrecacheController,
-  PrecacheFallbackPlugin,
-  PrecacheRoute,
-  getSingletonPrecacheController,
-  setSingletonPrecacheController,
-  handlePrecaching,
-  registerRuntimeCaching,
-  registerRoute,
-  Router,
-  setCatchHandler,
-  setDefaultHandler,
-  getSingletonRouter,
-  setSingletonRouter,
-  unregisterRoute,
-};
-export type {
-  HandlePrecachingOptions,
-  GoogleAnalyticsInitializeOptions,
-  InstallSerwistOptions,
-  FallbackEntry,
-  FallbacksOptions,
-  PrecacheFallbackEntry,
-  PrecacheFallbackPluginOptions,
-};

package/src/legacy/PrecacheFallbackPlugin.ts

@@ -1,92 +0,0 @@
-/*
-  Copyright 2020 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 type { HandlerDidErrorCallbackParam, SerwistPlugin } from "../types.js";
-import type { PrecacheController } from "./PrecacheController.js";
-import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
-
-/**
- * @deprecated
- */
-export interface PrecacheFallbackEntry {
-  /**
-   * A function that checks whether the fallback entry can be used
-   * for a request.
-   */
-  matcher: (param: HandlerDidErrorCallbackParam) => boolean;
-  /**
-   * A precached URL to be used as a fallback.
-   */
-  url: string;
-}
-
-/**
- * @deprecated
- */
-export interface PrecacheFallbackPluginOptions {
-  /**
-   * Precached URLs to be used as the fallback
-   * if the associated strategy can't generate a response.
-   */
-  fallbackUrls: (string | PrecacheFallbackEntry)[];
-  /**
-   * An optional {@linkcode PrecacheController} instance. If not provided,
-   * the default {@linkcode PrecacheController} will be used.
-   */
-  precacheController?: PrecacheController;
-}
-
-/**
- * A class that allows you to specify offline fallbacks
- * to be used when a given strategy is unable to generate a response.
- *
- * It does this by intercepting the `handlerDidError` plugin callback
- * and returning a precached response, taking the expected revision parameter
- * into account automatically.
- *
- * Unless you explicitly pass in a {@linkcode PrecacheController} instance to the
- * constructor, the default instance will be used.
- *
- * @deprecated
- */
-export class PrecacheFallbackPlugin implements SerwistPlugin {
-  private readonly _fallbackUrls: (string | PrecacheFallbackEntry)[];
-  private readonly _precacheController: PrecacheController;
-
-  /**
-   * Constructs a new instance with the associated `fallbackUrls`.
-   *
-   * @param config
-   */
-  constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions) {
-    this._fallbackUrls = fallbackUrls;
-    this._precacheController = precacheController || getSingletonPrecacheController();
-  }
-
-  /**
-   * @returns The precache response for one of the fallback URLs, or `undefined` if
-   * nothing satisfies the conditions.
-   * @private
-   */
-  async handlerDidError(param: HandlerDidErrorCallbackParam) {
-    for (const fallback of this._fallbackUrls) {
-      if (typeof fallback === "string") {
-        const fallbackResponse = await this._precacheController.matchPrecache(fallback);
-        if (fallbackResponse !== undefined) {
-          return fallbackResponse;
-        }
-      } else if (fallback.matcher(param)) {
-        const fallbackResponse = await this._precacheController.matchPrecache(fallback.url);
-        if (fallbackResponse !== undefined) {
-          return fallbackResponse;
-        }
-      }
-    }
-    return undefined;
-  }
-}

package/src/legacy/PrecacheRoute.ts

@@ -1,48 +0,0 @@
-/*
-  Copyright 2020 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 { 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";
-
-/**
- * A subclass of {@linkcode Route} that takes a {@linkcode PrecacheController}
- * instance and uses it to match incoming requests and handle fetching
- * responses from the precache.
- * @deprecated
- */
-export class PrecacheRoute extends Route {
-  /**
-   * @param precacheController A {@linkcode PrecacheController}
-   * instance used to both match requests and respond to `fetch` events.
-   * @param options Options to control how requests are matched
-   * against the list of precached URLs.
-   */
-  constructor(precacheController: PrecacheController, options?: PrecacheRouteOptions) {
-    const match: RouteMatchCallback = ({ request }: RouteMatchCallbackOptions) => {
-      const urlsToCacheKeys = precacheController.getURLsToCacheKeys();
-      for (const possibleURL of generateURLVariations(request.url, options)) {
-        const cacheKey = urlsToCacheKeys.get(possibleURL);
-        if (cacheKey) {
-          const integrity = precacheController.getIntegrityForCacheKey(cacheKey);
-          return { cacheKey, integrity };
-        }
-      }
-      if (process.env.NODE_ENV !== "production") {
-        logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}`);
-      }
-      return;
-    };
-
-    super(match, precacheController.strategy);
-  }
-}