@serwist/sw 9.0.0-preview.20 → 9.0.0-preview.24

package/dist/strategies/NetworkFirst.d.ts

@@ -1,61 +0,0 @@
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-export interface NetworkFirstOptions extends StrategyOptions {
-    /**
-     * If set, any network requests that fail to respond within the timeout will fallback to the cache.
-     */
-    networkTimeoutSeconds?: number;
-}
-/**
- * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache)
- * request strategy.
- *
- * By default, this strategy will cache responses with a 200 status code as
- * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
- * Opaque responses are are cross-origin requests where the response doesn't
- * support [CORS](https://enable-cors.org/).
- *
- * If the network request fails, and there is no cache match, this will throw
- * a `SerwistError` exception.
- */
-export declare class NetworkFirst extends Strategy {
-    private readonly _networkTimeoutSeconds;
-    /**
-     * @param options
-     * This option can be used to combat
-     * "[lie-fi](https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi)"
-     * scenarios.
-     */
-    constructor(options?: NetworkFirstOptions);
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-    /**
-     * @param options
-     * @returns
-     * @private
-     */
-    private _getTimeoutPromise;
-    /**
-     * @param options
-     * @param options.timeoutId
-     * @param options.request
-     * @param options.logs A reference to the logs Array.
-     * @param options.event
-     * @returns
-     *
-     * @private
-     */
-    _getNetworkPromise({ timeoutId, request, logs, handler, }: {
-        request: Request;
-        logs: any[];
-        timeoutId?: number;
-        handler: StrategyHandler;
-    }): Promise<Response | undefined>;
-}
-//# sourceMappingURL=NetworkFirst.d.ts.map

package/dist/strategies/NetworkFirst.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NetworkFirst.d.ts","sourceRoot":"","sources":["../../src/strategies/NetworkFirst.ts"],"names":[],"mappings":"AAUA,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;AAI5D,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD;;;;;OAKG;gBACS,OAAO,GAAE,mBAAwB;IAsB7C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgE5E;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;;;;;;;;OASG;IACG,kBAAkB,CAAC,EACvB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAO,GACR,EAAE;QACD,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,EAAE,GAAG,EAAE,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,eAAe,CAAC;KAC1B,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAqClC"}

package/dist/strategies/NetworkOnly.d.ts

@@ -1,32 +0,0 @@
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-export interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" | "matchOptions"> {
-    /**
-     * If set, any network requests that fail to respond within the timeout will result in a network error.
-     */
-    networkTimeoutSeconds?: number;
-}
-/**
- * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-only)
- * request strategy.
- *
- * This class is useful if you want to take advantage of any Serwist plugin.
- *
- * If the network request fails, this will throw a `SerwistError` exception.
- */
-export declare class NetworkOnly extends Strategy {
-    private readonly _networkTimeoutSeconds;
-    /**
-     * @param options
-     */
-    constructor(options?: NetworkOnlyOptions);
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-}
-//# sourceMappingURL=NetworkOnly.d.ts.map

package/dist/strategies/NetworkOnly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NetworkOnly.d.ts","sourceRoot":"","sources":["../../src/strategies/NetworkOnly.ts"],"names":[],"mappings":"AAUA,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;AAG5D,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,cAAc,CAAC;IAC7F;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,qBAAa,WAAY,SAAQ,QAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD;;OAEG;gBACS,OAAO,GAAE,kBAAuB;IAM5C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA+C7E"}

package/dist/strategies/StaleWhileRevalidate.d.ts

@@ -1,35 +0,0 @@
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./StrategyHandler.js";
-/**
- * An implementation of the
- * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#stale-while-revalidate)
- * request strategy.
- *
- * Resources are requested from both the cache and the network in parallel.
- * The strategy will respond with the cached version if available, otherwise
- * wait for the network response. The cache is updated with the network response
- * with each successful request.
- *
- * By default, this strategy will cache responses with a 200 status code as
- * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
- * Opaque responses are cross-origin requests where the response doesn't
- * support [CORS](https://enable-cors.org/).
- *
- * If the network request fails, and there is no cache match, this will throw
- * a `SerwistError` exception.
- */
-export declare class StaleWhileRevalidate extends Strategy {
-    /**
-     * @param options
-     */
-    constructor(options?: StrategyOptions);
-    /**
-     * @private
-     * @param request A request to run this strategy for.
-     * @param handler The event that triggered the request.
-     * @returns
-     */
-    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
-}
-//# sourceMappingURL=StaleWhileRevalidate.d.ts.map

package/dist/strategies/StaleWhileRevalidate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StaleWhileRevalidate.d.ts","sourceRoot":"","sources":["../../src/strategies/StaleWhileRevalidate.ts"],"names":[],"mappings":"AAUA,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;AAI5D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAqB,SAAQ,QAAQ;IAChD;;OAEG;gBACS,OAAO,GAAE,eAAoB;IAUzC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CAsD7E"}

package/dist/strategies/Strategy.d.ts

@@ -1,83 +0,0 @@
-import type { HandlerCallbackOptions, RouteHandlerObject, SerwistPlugin } from "@serwist/core";
-import { StrategyHandler } from "./StrategyHandler.js";
-export interface StrategyOptions {
-    /**
-     * Cache name to store and retrieve requests. Defaults to cache names provided by `@serwist/core`.
-     */
-    cacheName?: string;
-    /**
-     * [Plugins](https://developer.chrome.com/docs/workbox/using-plugins)
-     * to use in conjunction with this caching strategy.
-     */
-    plugins?: SerwistPlugin[];
-    /**
-     * Values passed along to the [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
-     * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) `fetch()` requests made by this strategy.
-     */
-    fetchOptions?: RequestInit;
-    /**
-     * The [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
-     * for any `cache.match()` or `cache.put()` calls made by this strategy.
-     */
-    matchOptions?: CacheQueryOptions;
-}
-/**
- * Classes extending the `Strategy` based class should implement this method,
- * and leverage `@serwist/strategies`'s `StrategyHandler` arg to perform all
- * fetching and cache logic, which will ensure all relevant cache, cache options,
- * fetch options and plugins are used (per the current strategy instance).
- */
-export declare abstract class Strategy implements RouteHandlerObject {
-    cacheName: string;
-    plugins: SerwistPlugin[];
-    fetchOptions?: RequestInit;
-    matchOptions?: CacheQueryOptions;
-    protected abstract _handle(request: Request, handler: StrategyHandler): Promise<Response | undefined>;
-    /**
-     * Creates a new instance of the strategy and sets all documented option
-     * properties as public instance properties.
-     *
-     * Note: if a custom strategy class extends the base Strategy class and does
-     * not need more than these properties, it does not need to define its own
-     * constructor.
-     *
-     * @param options
-     */
-    constructor(options?: StrategyOptions);
-    /**
-     * Perform a request strategy and returns a `Promise` that will resolve with
-     * a `Response`, invoking all relevant plugin callbacks.
-     *
-     * When a strategy instance is registered with a `@serwist/routing` Route, this method is automatically
-     * called when the route matches.
-     *
-     * Alternatively, this method can be used in a standalone `FetchEvent`
-     * listener by passing it to `event.respondWith()`.
-     *
-     * @param options A `FetchEvent` or an object with the properties listed below.
-     * @param options.request A request to run this strategy for.
-     * @param options.event The event associated with the request.
-     * @param options.url
-     * @param options.params
-     */
-    handle(options: FetchEvent | HandlerCallbackOptions): Promise<Response>;
-    /**
-     * Similar to `@serwist/strategies`'s `Strategy.handle`, but
-     * instead of just returning a `Promise` that resolves to a `Response` it
-     * it will return an tuple of `[response, done]` promises, where the former
-     * (`response`) is equivalent to what `handle()` returns, and the latter is a
-     * Promise that will resolve once any promises that were added to
-     * `event.waitUntil()` as part of performing the strategy have completed.
-     *
-     * You can await the `done` promise to ensure any extra work performed by
-     * the strategy (usually caching responses) completes successfully.
-     *
-     * @param options A `FetchEvent` or `HandlerCallbackOptions` object.
-     * @returns A tuple of [response, done] promises that can be used to determine when the response resolves as
-     * well as when the handler has completed all its work.
-     */
-    handleAll(options: FetchEvent | HandlerCallbackOptions): [Promise<Response>, Promise<void>];
-    _getResponse(handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<Response>;
-    _awaitComplete(responseDone: Promise<Response>, handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<void>;
-}
-//# sourceMappingURL=Strategy.d.ts.map

package/dist/strategies/Strategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Strategy.d.ts","sourceRoot":"","sources":["../../src/strategies/Strategy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG/F,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED;;;;;GAKG;AACH,8BAAsB,QAAS,YAAW,kBAAkB;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,YAAY,CAAC,EAAE,iBAAiB,CAAC;IAEjC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAErG;;;;;;;;;OASG;gBACS,OAAO,GAAE,eAAoB;IAOzC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKvE;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAqBrF,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyCnG,cAAc,CAAC,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CAqCzI"}

package/dist/strategies/StrategyHandler.d.ts

@@ -1,189 +0,0 @@
-import type { HandlerCallbackOptions, MapLikeObject, SerwistPlugin, SerwistPluginCallbackParam } from "@serwist/core";
-import type { Strategy } from "./Strategy.js";
-/**
- * A class created every time a Strategy instance instance calls `Strategy.handle` or
- * `Strategy.handleAll` that wraps all fetch and cache actions around plugin callbacks
- * and keeps track of when the strategy is "done" (i.e. all added `event.waitUntil()` promises
- * have resolved).
- */
-export declare class StrategyHandler {
-    /**
-     * The event associated with this request.
-     */
-    event: ExtendableEvent;
-    /**
-     * The request the strategy is performing (passed to the strategy's
-     * `handle()` or `handleAll()` method).
-     */
-    request: Request;
-    /**
-     * A `URL` instance of `request.url` (if passed to the strategy's
-     * `handle()` or `handleAll()` method).
-     * Note: the `url` param will be present if the strategy was invoked
-     * from a `@serwist/routing.Route` object.
-     */
-    url?: URL;
-    /**
-     * A `param` value (if passed to the strategy's
-     * `handle()` or `handleAll()` method).
-     * Note: the `param` param will be present if the strategy was invoked
-     * from a `@serwist/routing.Route` object and the `@serwist/strategies.matchCallback`
-     * returned a truthy value (it will be that value).
-     */
-    params?: string[] | MapLikeObject;
-    private _cacheKeys;
-    private readonly _strategy;
-    private readonly _handlerDeferred;
-    private readonly _extendLifetimePromises;
-    private readonly _plugins;
-    private readonly _pluginStateMap;
-    /**
-     * Creates a new instance associated with the passed strategy and event
-     * that's handling the request.
-     *
-     * The constructor also initializes the state that will be passed to each of
-     * the plugins handling this request.
-     *
-     * @param strategy
-     * @param options
-     */
-    constructor(strategy: Strategy, options: HandlerCallbackOptions & {
-        request: HandlerCallbackOptions["request"] & Request;
-    });
-    /**
-     * Fetches a given request (and invokes any applicable plugin callback
-     * methods) using the `fetchOptions` (for non-navigation requests) and
-     * `plugins` defined on the `Strategy` object.
-     *
-     * The following plugin lifecycle methods are invoked when using this method:
-     * - `requestWillFetch()`
-     * - `fetchDidSucceed()`
-     * - `fetchDidFail()`
-     *
-     * @param input The URL or request to fetch.
-     * @returns
-     */
-    fetch(input: RequestInfo): Promise<Response>;
-    /**
-     * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on
-     * the response generated by `this.fetch()`.
-     *
-     * The call to `this.cachePut()` automatically invokes `this.waitUntil()`,
-     * so you do not have to manually call `waitUntil()` on the event.
-     *
-     * @param input The request or URL to fetch and cache.
-     * @returns
-     */
-    fetchAndCachePut(input: RequestInfo): Promise<Response>;
-    /**
-     * Matches a request from the cache (and invokes any applicable plugin
-     * callback methods) using the `cacheName`, `matchOptions`, and `plugins`
-     * defined on the strategy object.
-     *
-     * The following plugin lifecycle methods are invoked when using this method:
-     * - cacheKeyWillByUsed()
-     * - cachedResponseWillByUsed()
-     *
-     * @param key The Request or URL to use as the cache key.
-     * @returns A matching response, if found.
-     */
-    cacheMatch(key: RequestInfo): Promise<Response | undefined>;
-    /**
-     * Puts a request/response pair in the cache (and invokes any applicable
-     * plugin callback methods) using the `cacheName` and `plugins` defined on
-     * the strategy object.
-     *
-     * The following plugin lifecycle methods are invoked when using this method:
-     * - cacheKeyWillByUsed()
-     * - cacheWillUpdate()
-     * - cacheDidUpdate()
-     *
-     * @param key The request or URL to use as the cache key.
-     * @param response The response to cache.
-     * @returns `false` if a cacheWillUpdate caused the response
-     * not be cached, and `true` otherwise.
-     */
-    cachePut(key: RequestInfo, response: Response): Promise<boolean>;
-    /**
-     * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and
-     * executes any of those callbacks found in sequence. The final `Request`
-     * object returned by the last plugin is treated as the cache key for cache
-     * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have
-     * been registered, the passed request is returned unmodified
-     *
-     * @param request
-     * @param mode
-     * @returns
-     */
-    getCacheKey(request: Request, mode: "read" | "write"): Promise<Request>;
-    /**
-     * Returns true if the strategy has at least one plugin with the given
-     * callback.
-     *
-     * @param name The name of the callback to check for.
-     * @returns
-     */
-    hasCallback<C extends keyof SerwistPlugin>(name: C): boolean;
-    /**
-     * Runs all plugin callbacks matching the given name, in order, passing the
-     * given param object (merged ith the current plugin state) as the only
-     * argument.
-     *
-     * Note: since this method runs all plugins, it's not suitable for cases
-     * where the return value of a callback needs to be applied prior to calling
-     * the next callback. See `@serwist/strategies.iterateCallbacks` for how to handle that case.
-     *
-     * @param name The name of the callback to run within each plugin.
-     * @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.
-     */
-    runCallbacks<C extends keyof NonNullable<SerwistPlugin>>(name: C, param: Omit<SerwistPluginCallbackParam[C], "state">): Promise<void>;
-    /**
-     * Accepts a callback and returns an iterable of matching plugin callbacks,
-     * where each callback is wrapped with the current handler state (i.e. when
-     * you call each callback, whatever object parameter you pass it will
-     * be merged with the plugin's current state).
-     *
-     * @param name The name fo the callback to run
-     * @returns
-     */
-    iterateCallbacks<C extends keyof SerwistPlugin>(name: C): Generator<NonNullable<SerwistPlugin[C]>>;
-    /**
-     * Adds a promise to the
-     * [extend lifetime promises](https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises)
-     * of the event event associated with the request being handled (usually a `FetchEvent`).
-     *
-     * Note: you can await
-     * `@serwist/strategies.StrategyHandler.doneWaiting`
-     * to know when all added promises have settled.
-     *
-     * @param promise A promise to add to the extend lifetime promises of
-     * the event that triggered the request.
-     */
-    waitUntil<T>(promise: Promise<T>): Promise<T>;
-    /**
-     * Returns a promise that resolves once all promises passed to
-     * `@serwist/strategies.StrategyHandler.waitUntil` have settled.
-     *
-     * Note: any work done after `doneWaiting()` settles should be manually
-     * passed to an event's `waitUntil()` method (not this handler's
-     * `waitUntil()` method), otherwise the service worker thread my be killed
-     * prior to your work completing.
-     */
-    doneWaiting(): Promise<void>;
-    /**
-     * Stops running the strategy and immediately resolves any pending
-     * `waitUntil()` promises.
-     */
-    destroy(): void;
-    /**
-     * This method will call `cacheWillUpdate` on the available plugins (or use
-     * status === 200) to determine if the response is safe and valid to cache.
-     *
-     * @param response
-     * @returns
-     * @private
-     */
-    _ensureResponseSafeToCache(response: Response): Promise<Response | undefined>;
-}
-//# sourceMappingURL=StrategyHandler.d.ts.map

package/dist/strategies/StrategyHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StrategyHandler.d.ts","sourceRoot":"","sources":["../../src/strategies/StrategyHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAYtH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAM9C;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACI,KAAK,EAAE,eAAe,CAAC;IAC9B;;;OAGG;IACI,OAAO,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACI,GAAG,CAAC,EAAE,GAAG,CAAC;IACjB;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC;IAEzC,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgB;IACjD,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAiB;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IAEpE;;;;;;;;;OASG;gBAED,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,sBAAsB,GAAG;QAChC,OAAO,EAAE,sBAAsB,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;KACtD;IAsCH;;;;;;;;;;;;OAYG;IACG,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyElD;;;;;;;;;OASG;IACG,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAS7D;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IA+BjE;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IA8FtE;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB7E;;;;;;OAMG;IACH,WAAW,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO;IAS5D;;;;;;;;;;;;OAYG;IACG,YAAY,CAAC,CAAC,SAAS,MAAM,WAAW,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3I;;;;;;;;OAQG;IACF,gBAAgB,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAgBnG;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK7C;;;;;;;;OAQG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAOlC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAIf;;;;;;;OAOG;IACG,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAuCpF"}

package/dist/strategies/plugins/cacheOkAndOpaquePlugin.d.ts

@@ -1,3 +0,0 @@
-import type { SerwistPlugin } from "@serwist/core";
-export declare const cacheOkAndOpaquePlugin: SerwistPlugin;
-//# sourceMappingURL=cacheOkAndOpaquePlugin.d.ts.map

package/dist/strategies/plugins/cacheOkAndOpaquePlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cacheOkAndOpaquePlugin.d.ts","sourceRoot":"","sources":["../../../src/strategies/plugins/cacheOkAndOpaquePlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,eAAO,MAAM,sBAAsB,EAAE,aAepC,CAAC"}

package/dist/strategies/utils/messages.d.ts

@@ -1,5 +0,0 @@
-export declare const messages: {
-    strategyStart: (strategyName: string, request: Request) => string;
-    printFinalResponse: (response?: Response) => void;
-};
-//# sourceMappingURL=messages.d.ts.map

package/dist/strategies/utils/messages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/strategies/utils/messages.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,QAAQ;kCACW,MAAM,WAAW,OAAO,KAAG,MAAM;oCAC/B,QAAQ,KAAG,IAAI;CAOhD,CAAC"}

package/src/abstractions/Serwist.ts

@@ -1,177 +0,0 @@
-import { clientsClaim as clientsClaimImpl, setCacheNameDetails } from "@serwist/core";
-import { type GoogleAnalyticsInitializeOptions, initialize } from "../plugins/googleAnalytics/initialize.js";
-import { PrecacheController } from "../precaching/PrecacheController.js";
-import { PrecacheRoute } from "../precaching/PrecacheRoute.js";
-import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "../precaching/cleanupOutdatedCaches.js";
-import { createHandlerBoundToURL } from "../precaching/createHandlerBoundToURL.js";
-import { getSingletonPrecacheController } from "../precaching/singletonPrecacheController.js";
-import { NavigationRoute } from "../routing/NavigationRoute.js";
-import { Router } from "../routing/Router.js";
-import { parseRoute } from "../routing/parseRoute.js";
-import { getSingletonRouter } from "../routing/singletonRouter.js";
-import { disableDevLogs as disableDevLogsImpl } from "./disableDevLogs.js";
-import { fallbacks as fallbacksImpl } from "./fallbacks.js";
-import type { FallbacksOptions } from "./fallbacks.js";
-import { type HandlePrecachingOptions } from "./handlePrecaching.js";
-import { enableNavigationPreload } from "./navigationPreload.js";
-import type { RuntimeCaching } from "./types.js";
-
-declare const self: ServiceWorkerGlobalScope;
-
-export interface SerwistOptions {
-  /**
-   * An optional `PrecacheController` instance. If not provided, the singleton
-   * `PrecacheController` will be used.
-   */
-  precacheController?: PrecacheController;
-  /**
-   * An optional `Router` instance. If not provided, the singleton `Router`
-   * will be used.
-   */
-  router?: Router;
-}
-
-export interface SerwistInstallOptions extends HandlePrecachingOptions {
-  /**
-   * 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;
-  /**
-   * A list of caching strategies.
-   *
-   * @see https://serwist.pages.dev/docs/sw/runtime-caching
-   */
-  runtimeCaching?: RuntimeCaching[];
-  /**
-   * Your configuration for `@serwist/google-analytics`. This plugin is
-   * only initialized when this option is not `undefined` or `false`.
-   */
-  offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
-  /**
-   * Disables Serwist's logging in development mode.
-   *
-   * @default false
-   */
-  disableDevLogs?: boolean;
-  /**
-   * Precaches routes so that they can be used as a fallback when
-   * a Strategy fails to generate a response.
-   * Note: This option mutates `runtimeCaching`!
-   *
-   * @see https://serwist.pages.dev/docs/sw/fallbacks
-   */
-  fallbacks?: Omit<FallbacksOptions, "runtimeCaching">;
-}
-
-export class Serwist {
-  private _precacheController: PrecacheController;
-  private _router: Router;
-  constructor({ precacheController, router }: SerwistOptions = {}) {
-    this._precacheController = precacheController || getSingletonPrecacheController();
-    this._router = router || getSingletonRouter();
-  }
-  install({
-    precacheEntries,
-    precacheOptions,
-    cleanupOutdatedCaches,
-    navigateFallback,
-    navigateFallbackAllowlist,
-    navigateFallbackDenylist,
-    skipWaiting = false,
-    importScripts,
-    navigationPreload = false,
-    cacheId,
-    clientsClaim = false,
-    runtimeCaching,
-    offlineAnalyticsConfig,
-    disableDevLogs = false,
-    fallbacks,
-  }: SerwistInstallOptions = {}) {
-    if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
-
-    if (navigationPreload) enableNavigationPreload();
-
-    if (cacheId !== undefined) {
-      setCacheNameDetails({
-        prefix: cacheId,
-      });
-    }
-
-    if (skipWaiting) {
-      self.skipWaiting();
-    } else {
-      self.addEventListener("message", (event) => {
-        if (event.data && event.data.type === "SKIP_WAITING") {
-          self.skipWaiting();
-        }
-      });
-    }
-
-    if (clientsClaim) clientsClaimImpl();
-
-    if (!!precacheEntries && precacheEntries.length > 0) {
-      /**
-       * The precacheAndRoute() method efficiently caches and responds to
-       * requests for URLs in the manifest.
-       * See https://goo.gl/S9QRab
-       */
-      this._precacheController.precache(precacheEntries);
-      this._router.registerRoute(new PrecacheRoute(this._precacheController, precacheOptions));
-
-      if (cleanupOutdatedCaches) cleanupOutdatedCachesImpl();
-
-      if (navigateFallback) {
-        this._router.registerRoute(
-          new NavigationRoute(createHandlerBoundToURL(navigateFallback), {
-            allowlist: navigateFallbackAllowlist,
-            denylist: navigateFallbackDenylist,
-          }),
-        );
-      }
-    }
-
-    if (offlineAnalyticsConfig !== undefined) {
-      if (typeof offlineAnalyticsConfig === "boolean") {
-        offlineAnalyticsConfig && initialize();
-      } else {
-        initialize(offlineAnalyticsConfig);
-      }
-    }
-    if (runtimeCaching !== undefined) {
-      if (fallbacks !== undefined) {
-        fallbacksImpl({ ...fallbacks, runtimeCaching });
-      }
-      for (const entry of runtimeCaching) {
-        this._router.registerRoute(parseRoute(entry.matcher, entry.handler, entry.method));
-      }
-    }
-
-    if (disableDevLogs) disableDevLogsImpl();
-  }
-}

package/src/abstractions/disableDevLogs.ts

@@ -1,10 +0,0 @@
-declare const self: ServiceWorkerGlobalScope;
-
-/**
- * Disables Serwist's logging in development mode.
- *
- * @see https://serwist.pages.dev/docs/sw/disable-dev-logs
- */
-export const disableDevLogs = (): void => {
-  self.__WB_DISABLE_DEV_LOGS = true;
-};