serwist 9.0.0-preview.24

package/dist/strategies/StaleWhileRevalidate.d.ts

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1 @@
+{"version":3,"file":"StaleWhileRevalidate.d.ts","sourceRoot":"","sources":["../../src/strategies/StaleWhileRevalidate.ts"],"names":[],"mappings":"AAWA,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

@@ -0,0 +1,83 @@
+import type { HandlerCallbackOptions, RouteHandlerObject, SerwistPlugin } from "../types.js";
+import { StrategyHandler } from "./StrategyHandler.js";
+export interface StrategyOptions {
+    /**
+     * Cache name to store and retrieve requests. Defaults to Serwist's default cache names.
+     */
+    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 `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

@@ -0,0 +1 @@
+{"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,aAAa,CAAC;AAK7F,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

@@ -0,0 +1,189 @@
+import type { HandlerCallbackOptions, MapLikeObject, SerwistPlugin, SerwistPluginCallbackParam } from "../types.js";
+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 `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 `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

@@ -0,0 +1 @@
+{"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,aAAa,CAAC;AASpH,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

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

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

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

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

@@ -0,0 +1,5 @@
+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

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

package/dist/types.d.ts

@@ -0,0 +1,317 @@
+import type { HTTPMethod } from "./constants.js";
+export type PromiseOrNot<T> = T | Promise<T>;
+export interface MapLikeObject {
+    [key: string]: any;
+}
+/**
+ * Using a plain `MapLikeObject` for now, but could extend/restrict this
+ * in the future.
+ */
+export type PluginState = MapLikeObject;
+/**
+ * Options passed to a `RouteMatchCallback` function.
+ */
+export interface RouteMatchCallbackOptions {
+    event: ExtendableEvent;
+    request: Request;
+    sameOrigin: boolean;
+    url: URL;
+}
+/**
+ * The "match" callback is used to determine if a `Route` should apply for a
+ * particular URL and request. When matching occurs in response to a fetch
+ * event from the client, the `event` object is also supplied. However, since
+ * the match callback can be invoked outside of a fetch event, matching logic
+ * should not assume the `event` object will always be available.
+ * If the match callback returns a truthy value, the matching route's
+ * `RouteHandlerCallback` will be invoked immediately. If the value returned
+ * is a non-empty array or object, that value will be set on the handler's
+ * `options.params` argument.
+ */
+export type RouteMatchCallback = (options: RouteMatchCallbackOptions) => any;
+/**
+ * Options passed to a `RouteHandlerCallback` function.
+ */
+export interface RouteHandlerCallbackOptions {
+    /**
+     * The event associated with the request.
+     */
+    event: ExtendableEvent;
+    /**
+     * A request to run this strategy for.
+     */
+    request: Request;
+    url: URL;
+    params?: string[] | MapLikeObject;
+}
+/**
+ * Options passed to a `ManualHandlerCallback` function.
+ */
+export interface ManualHandlerCallbackOptions {
+    /**
+     * The event associated with the request.
+     */
+    event: ExtendableEvent;
+    /**
+     * A request to run this strategy for.
+     */
+    request: Request | string;
+    url?: never;
+    /**
+     * The return value from `serwist.matchCallback` (if applicable).
+     */
+    params?: never;
+}
+export type HandlerCallbackOptions = RouteHandlerCallbackOptions | ManualHandlerCallbackOptions;
+/**
+ * The "handler" callback is invoked whenever a `Router` matches a URL/Request
+ * to a `Route` via its `RouteMatchCallback`. This handler callback should
+ * return a `Promise` that resolves with a `Response`.
+ *
+ * If a non-empty array or object is returned by the `RouteMatchCallback` it
+ * will be passed in as this handler's `options.params` argument.
+ */
+export type RouteHandlerCallback = (options: RouteHandlerCallbackOptions) => Promise<Response>;
+/**
+ * The "handler" callback is invoked whenever a `Router` matches a URL/Request
+ * to a `Route` via its `RouteMatchCallback`. This handler callback should
+ * return a `Promise` that resolves with a `Response`.
+ *
+ * If a non-empty array or object is returned by the `RouteMatchCallback` it
+ * will be passed in as this handler's `options.params` argument.
+ */
+export type ManualHandlerCallback = (options: ManualHandlerCallbackOptions) => Promise<Response>;
+/**
+ * An object with a `handle` method of type `RouteHandlerCallback`.
+ *
+ * A `Route` object can be created with either an `RouteHandlerCallback`
+ * function or this `RouteHandler` object. The benefit of the `RouteHandler`
+ * is it can be extended (as is done by the `serwist/strategies` package).
+ */
+export interface RouteHandlerObject {
+    handle: RouteHandlerCallback;
+}
+/**
+ * Either a `RouteHandlerCallback` or a `RouteHandlerObject`.
+ * Most APIs that accept route handlers take either.
+ */
+export type RouteHandler = RouteHandlerCallback | RouteHandlerObject;
+export interface HandlerWillStartCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export type HandlerWillStartCallback = (param: HandlerWillStartCallbackParam) => Promise<any>;
+export interface CacheDidUpdateCallbackParam {
+    /**
+     * Name of the cache the responses belong to. This is included in the
+     * broadcast message.
+     */
+    cacheName: string;
+    /**
+     * Possibly updated response to compare.
+     */
+    newResponse: Response;
+    /**
+     * The `Request` object for the cached entry.
+     */
+    request: Request;
+    /**
+     * The event that triggered this possible cache update.
+     */
+    event: ExtendableEvent;
+    /**
+     * Cached response to compare.
+     */
+    oldResponse?: Response | null;
+    state?: PluginState;
+}
+export type CacheDidUpdateCallback = (param: CacheDidUpdateCallbackParam) => PromiseOrNot<any>;
+export interface CacheKeyWillBeUsedCallbackParam {
+    mode: string;
+    request: Request;
+    event: ExtendableEvent;
+    params?: any;
+    state?: PluginState;
+}
+export type CacheKeyWillBeUsedCallback = (param: CacheKeyWillBeUsedCallbackParam) => PromiseOrNot<Request | string>;
+export interface CacheWillUpdateCallbackParam {
+    request: Request;
+    response: Response;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export type CacheWillUpdateCallback = (param: CacheWillUpdateCallbackParam) => PromiseOrNot<any>;
+export interface CachedResponseWillBeUsedCallbackParam {
+    /**
+     * Name of the cache the response is in.
+     */
+    cacheName: string;
+    /**
+     * The original request, which may or may not
+     * contain a Range: header.
+     */
+    request: Request;
+    /**
+     * The complete cached `Response` object that's been read
+     * from a cache and whose freshness should be checked.
+     */
+    cachedResponse?: Response;
+    event: ExtendableEvent;
+    matchOptions?: CacheQueryOptions;
+    state?: PluginState;
+}
+export type CachedResponseWillBeUsedCallback = (param: CachedResponseWillBeUsedCallbackParam) => PromiseOrNot<any>;
+export interface FetchDidFailCallbackParam {
+    error: Error;
+    originalRequest: Request;
+    request: Request;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export type FetchDidFailCallback = (param: FetchDidFailCallbackParam) => PromiseOrNot<any>;
+export interface FetchDidSucceedCallbackParam {
+    request: Request;
+    response: Response;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export type FetchDidSucceedCallback = (param: FetchDidSucceedCallbackParam) => PromiseOrNot<Response>;
+export interface RequestWillFetchCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export type RequestWillFetchCallback = (param: RequestWillFetchCallbackParam) => PromiseOrNot<Request>;
+export interface HandlerWillRespondCallbackParam {
+    request: Request;
+    response: Response;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export type HandlerWillRespondCallback = (param: HandlerWillRespondCallbackParam) => PromiseOrNot<Response>;
+export interface HandlerDidErrorCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    error: Error;
+    state?: PluginState;
+}
+export type HandlerDidErrorCallback = (param: HandlerDidErrorCallbackParam) => PromiseOrNot<Response | undefined>;
+export interface HandlerDidRespondCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    response?: Response;
+    state?: PluginState;
+}
+export type HandlerDidRespondCallback = (param: HandlerDidRespondCallbackParam) => PromiseOrNot<any>;
+export interface HandlerDidCompleteCallbackParam {
+    request: Request;
+    error?: Error;
+    event: ExtendableEvent;
+    response?: Response;
+    state?: PluginState;
+}
+export type HandlerDidCompleteCallback = (param: HandlerDidCompleteCallbackParam) => PromiseOrNot<any>;
+/**
+ * An object with optional lifecycle callback properties for the fetch and
+ * cache operations.
+ */
+export declare interface SerwistPlugin {
+    cacheDidUpdate?: CacheDidUpdateCallback;
+    cachedResponseWillBeUsed?: CachedResponseWillBeUsedCallback;
+    cacheKeyWillBeUsed?: CacheKeyWillBeUsedCallback;
+    cacheWillUpdate?: CacheWillUpdateCallback;
+    fetchDidFail?: FetchDidFailCallback;
+    fetchDidSucceed?: FetchDidSucceedCallback;
+    handlerDidComplete?: HandlerDidCompleteCallback;
+    handlerDidError?: HandlerDidErrorCallback;
+    handlerDidRespond?: HandlerDidRespondCallback;
+    handlerWillRespond?: HandlerWillRespondCallback;
+    handlerWillStart?: HandlerWillStartCallback;
+    requestWillFetch?: RequestWillFetchCallback;
+}
+export interface SerwistPluginCallbackParam {
+    cacheDidUpdate: CacheDidUpdateCallbackParam;
+    cachedResponseWillBeUsed: CachedResponseWillBeUsedCallbackParam;
+    cacheKeyWillBeUsed: CacheKeyWillBeUsedCallbackParam;
+    cacheWillUpdate: CacheWillUpdateCallbackParam;
+    fetchDidFail: FetchDidFailCallbackParam;
+    fetchDidSucceed: FetchDidSucceedCallbackParam;
+    handlerDidComplete: HandlerDidCompleteCallbackParam;
+    handlerDidError: HandlerDidErrorCallbackParam;
+    handlerDidRespond: HandlerDidRespondCallbackParam;
+    handlerWillRespond: HandlerWillRespondCallbackParam;
+    handlerWillStart: HandlerWillStartCallbackParam;
+    requestWillFetch: RequestWillFetchCallbackParam;
+}
+export interface SerwistGlobalConfig {
+    /**
+     * Whether Serwist should disable development logging.
+     *
+     * @default false
+     */
+    __WB_DISABLE_DEV_LOGS: boolean;
+}
+export interface RuntimeCaching {
+    /**
+     * The HTTP method to match against. The default value of `'GET'` is normally
+     * sufficient, unless you explicitly need to match `'POST'`, `'PUT'`, or
+     * another type of request.
+     * @default "GET"
+     */
+    method?: HTTPMethod;
+    /**
+     * This match criteria determines whether the configured handler will
+     * generate a response for any requests that don't match one of the precached
+     * URLs. If multiple `RuntimeCaching` routes are defined, then the first one
+     * whose `matcher` matches will be the one that responds.
+     *
+     * This value directly maps to the first parameter passed to
+     * `Serwist.registerRoute`. It's recommended to use a
+     * `serwist.RouteMatchCallback` function for greatest flexibility.
+     */
+    matcher: RegExp | string | RouteMatchCallback;
+    /**
+     * This determines how the runtime route will generate a response. It
+     * can be a `serwist.RouteHandler` callback function with custom
+     * response logic.
+     */
+    handler: RouteHandler;
+}
+export interface InstallResult {
+    updatedURLs: string[];
+    notUpdatedURLs: string[];
+}
+export interface CleanupResult {
+    deletedCacheRequests: string[];
+}
+export declare interface PrecacheEntry {
+    integrity?: string;
+    url: string;
+    revision?: string | null;
+}
+export interface PrecacheRouteOptions {
+    /**
+     * The `directoryIndex` will check cache entries for a URL ending with '/'
+     * to see if there is a hit when appending the `directoryIndex` value.
+     */
+    directoryIndex?: string | null;
+    /**
+     * An array of RegExp's to remove search params when looking for a cache match.
+     */
+    ignoreURLParametersMatching?: RegExp[];
+    /**
+     * The `cleanURLs` option will check the cache for the URL with a `.html` added
+     * to the end of the end.
+     */
+    cleanURLs?: boolean;
+    /**
+     * This is a function that should take a URL and return an array of
+     * alternative URLs that should be checked for precache matches.
+     */
+    urlManipulation?: UrlManipulation;
+}
+export type UrlManipulation = ({ url }: {
+    url: URL;
+}) => URL[];
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}