@serwist/sw 9.0.0-preview.2 → 9.0.0-preview.21

package/dist/plugins/backgroundSync/StorableRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorableRequest.d.ts","sourceRoot":"","sources":["../../../src/plugins/backgroundSync/StorableRequest.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAiBnD,MAAM,WAAW,WAAY,SAAQ,aAAa;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;GAMG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C;;;;;;OAMG;WACU,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC;IA6BpE;;;;;;OAMG;gBACS,WAAW,EAAE,WAAW;IAyBpC;;;;OAIG;IACH,QAAQ,IAAI,WAAW;IAUvB;;;;OAIG;IACH,SAAS,IAAI,OAAO;IAIpB;;;;OAIG;IACH,KAAK,IAAI,eAAe;CAGzB"}

package/dist/plugins/broadcastUpdate/BroadcastCacheUpdate.d.ts

@@ -0,0 +1,45 @@
+import type { CacheDidUpdateCallbackParam } from "@serwist/core";
+import type { BroadcastCacheUpdateOptions } from "./types.js";
+/**
+ * A class that uses the `postMessage()` API to inform any open windows/tabs when
+ * a cached response has been updated.
+ *
+ * For efficiency's sake, the underlying response bodies are not compared;
+ * only specific response headers are checked.
+ */
+export declare class BroadcastCacheUpdate {
+    private readonly _headersToCheck;
+    private readonly _generatePayload;
+    private readonly _notifyAllClients;
+    /**
+     * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+     * broadcast messages on
+     *
+     * @param options
+     */
+    constructor({ generatePayload, headersToCheck, notifyAllClients }?: BroadcastCacheUpdateOptions);
+    /**
+     * Compares two responses and sends a message (via `postMessage()`) to all window clients if the
+     * responses differ. Neither of the Responses can be opaque.
+     *
+     * The message that's posted has the following format (where `payload` can
+     * be customized via the `generatePayload` option the instance is created
+     * with):
+     *
+     * ```
+     * {
+     *   type: 'CACHE_UPDATED',
+     *   meta: 'workbox-broadcast-update',
+     *   payload: {
+     *     cacheName: 'the-cache-name',
+     *     updatedURL: 'https://example.com/'
+     *   }
+     * }
+     * ```
+     *
+     * @param options
+     * @returns Resolves once the update is sent.
+     */
+    notifyIfUpdated(options: CacheDidUpdateCallbackParam): Promise<void>;
+}
+//# sourceMappingURL=BroadcastCacheUpdate.d.ts.map

package/dist/plugins/broadcastUpdate/BroadcastCacheUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadcastCacheUpdate.d.ts","sourceRoot":"","sources":["../../../src/plugins/broadcastUpdate/BroadcastCacheUpdate.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAKjE,OAAO,KAAK,EAAE,2BAA2B,EAAiE,MAAM,YAAY,CAAC;AAuB7H;;;;;;GAMG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAW;IAC3C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4B;IAC7D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;IAE5C;;;;;OAKG;gBACS,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,GAAE,2BAAgC;IAMnG;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,eAAe,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;CA4E3E"}

package/dist/plugins/broadcastUpdate/BroadcastUpdatePlugin.d.ts

@@ -0,0 +1,27 @@
+import type { CacheDidUpdateCallbackParam, SerwistPlugin } from "@serwist/core";
+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 declare class BroadcastUpdatePlugin implements SerwistPlugin {
+    private readonly _broadcastUpdate;
+    /**
+     * Construct a `@serwist/broadcast-update.BroadcastCacheUpdate` instance with
+     * the passed options and calls its `notifyIfUpdated` method whenever the
+     * plugin's `cacheDidUpdate` callback is invoked.
+     *
+     * @param options
+     */
+    constructor(options?: BroadcastCacheUpdateOptions);
+    /**
+     * A "lifecycle" callback that will be triggered automatically by
+     * `@serwist/build.RuntimeCaching` handlers when an entry is
+     * added to a cache.
+     *
+     * @private
+     * @param options The input object to this function.
+     */
+    cacheDidUpdate(options: CacheDidUpdateCallbackParam): void;
+}
+//# sourceMappingURL=BroadcastUpdatePlugin.d.ts.map

package/dist/plugins/broadcastUpdate/BroadcastUpdatePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadcastUpdatePlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/broadcastUpdate/BroadcastUpdatePlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGhF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAE9D;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACzD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAuB;IAExD;;;;;;OAMG;gBACS,OAAO,CAAC,EAAE,2BAA2B;IAIjD;;;;;;;OAOG;IACH,cAAc,CAAC,OAAO,EAAE,2BAA2B;CAGpD"}

package/dist/plugins/broadcastUpdate/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const CACHE_UPDATED_MESSAGE_TYPE = "CACHE_UPDATED";
+export declare const CACHE_UPDATED_MESSAGE_META = "serwist-broadcast-update";
+export declare const defaultNotifyAllClients = true;
+export declare const defaultHeadersToCheck: string[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/plugins/broadcastUpdate/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/plugins/broadcastUpdate/constants.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,0BAA0B,kBAAkB,CAAC;AAC1D,eAAO,MAAM,0BAA0B,6BAA6B,CAAC;AACrE,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAC5C,eAAO,MAAM,qBAAqB,UAA8C,CAAC"}

package/dist/plugins/broadcastUpdate/responsesAreSame.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Given two responses, compares several header values to see if they are
+ * the same or not.
+ *
+ * @param firstResponse The first response.
+ * @param secondResponse The second response.
+ * @param headersToCheck A list of headers to check.
+ * @returns
+ */
+export declare const responsesAreSame: (firstResponse: Response, secondResponse: Response, headersToCheck: string[]) => boolean;
+//# sourceMappingURL=responsesAreSame.d.ts.map

package/dist/plugins/broadcastUpdate/responsesAreSame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responsesAreSame.d.ts","sourceRoot":"","sources":["../../../src/plugins/broadcastUpdate/responsesAreSame.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,kBAAmB,QAAQ,kBAAkB,QAAQ,kBAAkB,MAAM,EAAE,KAAG,OA4B9G,CAAC"}

package/dist/plugins/broadcastUpdate/types.d.ts

@@ -0,0 +1,34 @@
+import type { CacheDidUpdateCallbackParam } from "@serwist/core";
+import type { CACHE_UPDATED_MESSAGE_META, CACHE_UPDATED_MESSAGE_TYPE } from "./constants.js";
+export interface BroadcastCacheUpdateOptions {
+    /**
+     * A list of headers that will be used to determine whether the responses
+     * differ.
+     *
+     * @default ['content-length', 'etag', 'last-modified']
+     */
+    headersToCheck?: string[];
+    /**
+     * A function whose return value
+     * will be used as the `payload` field in any cache update messages sent
+     * to the window clients.
+     * @param options
+     * @returns
+     */
+    generatePayload?: (options: CacheDidUpdateCallbackParam) => Record<string, any>;
+    /**
+     * If `true` (the default) then all open clients will receive a message. If `false`,
+     * then only the client that make the original request will be notified of the update.
+     *
+     * @default true
+     */
+    notifyAllClients?: boolean;
+}
+export type BroadcastPayload = Record<string, any>;
+export type BroadcastPayloadGenerator = (options: CacheDidUpdateCallbackParam) => BroadcastPayload;
+export interface BroadcastMessage {
+    type: typeof CACHE_UPDATED_MESSAGE_TYPE;
+    meta: typeof CACHE_UPDATED_MESSAGE_META;
+    payload: BroadcastPayload;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/broadcastUpdate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/plugins/broadcastUpdate/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,KAAK,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAE7F,MAAM,WAAW,2BAA2B;IAC1C;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,2BAA2B,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAChF;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEnD,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,EAAE,2BAA2B,KAAK,gBAAgB,CAAC;AAEnG,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,0BAA0B,CAAC;IACxC,IAAI,EAAE,OAAO,0BAA0B,CAAC;IACxC,OAAO,EAAE,gBAAgB,CAAC;CAC3B"}

package/dist/plugins/cacheableResponse/CacheableResponse.d.ts

@@ -0,0 +1,40 @@
+export interface CacheableResponseOptions {
+    /**
+     * One or more status codes that a `Response` can have to be considered cacheable.
+     */
+    statuses?: number[];
+    /**
+     * A mapping of header names and expected values that a `Response` can have and be
+     * considered cacheable. If multiple headers are provided, only one needs to be present.
+     */
+    headers?: HeadersInit;
+}
+/**
+ * Allows you to set up rules determining what status codes and/or headers need
+ * to be present in order for a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * to be considered cacheable.
+ */
+export declare class CacheableResponse {
+    private readonly _statuses?;
+    private readonly _headers?;
+    /**
+     * To construct a new CacheableResponse instance you must provide at least
+     * one of the `config` properties.
+     *
+     * If both `statuses` and `headers` are specified, then both conditions must
+     * be met for the `Response` to be considered cacheable.
+     *
+     * @param config
+     */
+    constructor(config?: CacheableResponseOptions);
+    /**
+     * Checks a response to see whether it's cacheable or not.
+     *
+     * @param response The response whose cacheability is being
+     * checked.
+     * @returns `true` if the `Response` is cacheable, and `false`
+     * otherwise.
+     */
+    isResponseCacheable(response: Response): boolean;
+}
+//# sourceMappingURL=CacheableResponse.d.ts.map

package/dist/plugins/cacheableResponse/CacheableResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheableResponse.d.ts","sourceRoot":"","sources":["../../../src/plugins/cacheableResponse/CacheableResponse.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAuC;IAClE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAU;IAEpC;;;;;;;;OAQG;gBACS,MAAM,GAAE,wBAA6B;IAmCjD;;;;;;;OAOG;IACH,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;CAyDjD"}

package/dist/plugins/cacheableResponse/CacheableResponsePlugin.d.ts

@@ -0,0 +1,27 @@
+import type { SerwistPlugin } from "@serwist/core";
+import type { CacheableResponseOptions } from "./CacheableResponse.js";
+/**
+ * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it
+ * easier to add in cacheability checks to requests made via Serwist's built-in
+ * strategies.
+ */
+export declare class CacheableResponsePlugin implements SerwistPlugin {
+    private readonly _cacheableResponse;
+    /**
+     * To construct a new CacheableResponsePlugin instance you must provide at
+     * least one of the `config` properties.
+     *
+     * If both `statuses` and `headers` are specified, then both conditions must
+     * be met for the `Response` to be considered cacheable.
+     *
+     * @param config
+     */
+    constructor(config: CacheableResponseOptions);
+    /**
+     * @param options
+     * @returns
+     * @private
+     */
+    cacheWillUpdate: SerwistPlugin["cacheWillUpdate"];
+}
+//# sourceMappingURL=CacheableResponsePlugin.d.ts.map

package/dist/plugins/cacheableResponse/CacheableResponsePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheableResponsePlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/cacheableResponse/CacheableResponsePlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAGvE;;;;GAIG;AACH,qBAAa,uBAAwB,YAAW,aAAa;IAC3D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IAEvD;;;;;;;;OAQG;gBACS,MAAM,EAAE,wBAAwB;IAI5C;;;;OAIG;IACH,eAAe,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAK/C;CACH"}

package/dist/plugins/expiration/CacheExpiration.d.ts

@@ -0,0 +1,66 @@
+interface CacheExpirationConfig {
+    /**
+     * The maximum number of entries to cache. Entries used the least will
+     * be removed as the maximum is reached.
+     */
+    maxEntries?: number;
+    /**
+     * The maximum age of an entry before it's treated as stale and removed.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters)
+     * that will be used when calling `delete()` on the cache.
+     */
+    matchOptions?: CacheQueryOptions;
+}
+/**
+ * Allows you to expires cached responses based on age or maximum number of entries.
+ * @see https://serwist.pages.dev/docs/expiration/cache-expiration
+ */
+export declare class CacheExpiration {
+    private _isRunning;
+    private _rerunRequested;
+    private readonly _maxEntries?;
+    private readonly _maxAgeSeconds?;
+    private readonly _matchOptions?;
+    private readonly _cacheName;
+    private readonly _timestampModel;
+    /**
+     * To construct a new CacheExpiration instance you must provide at least
+     * one of the `config` properties.
+     *
+     * @param cacheName Name of the cache to apply restrictions to.
+     * @param config
+     */
+    constructor(cacheName: string, config?: CacheExpirationConfig);
+    /**
+     * Expires entries for the given cache and given criteria.
+     */
+    expireEntries(): Promise<void>;
+    /**
+     * Updates the timestamp for the given URL, allowing it to be correctly
+     * tracked by the class.
+     *
+     * @param url
+     */
+    updateTimestamp(url: string): Promise<void>;
+    /**
+     * Checks if a URL has expired or not before it's used.
+     *
+     * This looks the timestamp up in IndexedDB and can be slow.
+     *
+     * Note: This method does not remove an expired entry, call
+     * `expireEntries()` to remove such entries instead.
+     *
+     * @param url
+     * @returns
+     */
+    isURLExpired(url: string): Promise<boolean>;
+    /**
+     * Removes the IndexedDB used to keep track of cache expiration metadata.
+     */
+    delete(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=CacheExpiration.d.ts.map

package/dist/plugins/expiration/CacheExpiration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheExpiration.d.ts","sourceRoot":"","sources":["../../../src/plugins/expiration/CacheExpiration.ts"],"names":[],"mappings":"AAYA,UAAU,qBAAqB;IAC7B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAoB;IACnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuB;IAEvD;;;;;;OAMG;gBACS,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,qBAA0B;IA2CjE;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CpC;;;;;OAKG;IACG,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAajD;;;;;;;;;;OAUG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAejD;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAM9B"}

package/dist/plugins/expiration/ExpirationPlugin.d.ts

@@ -0,0 +1,116 @@
+import type { CacheDidUpdateCallbackParam, CachedResponseWillBeUsedCallbackParam, SerwistPlugin } from "@serwist/core";
+export interface ExpirationPluginOptions {
+    /**
+     * The maximum number of entries to cache. Entries used the least will be removed
+     * as the maximum is reached.
+     */
+    maxEntries?: number;
+    /**
+     * The maximum number of seconds before an entry is treated as stale and removed.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * Determines whether `maxAgeSeconds` should be calculated from when an
+     * entry was last fetched or when it was last used.
+     *
+     * @default "last-fetched"
+     */
+    maxAgeFrom?: "last-fetched" | "last-used";
+    /**
+     * The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters)
+     * that will be used when calling `delete()` on the cache.
+     */
+    matchOptions?: CacheQueryOptions;
+    /**
+     * Whether to opt this cache into automatic deletion if the available storage quota has been exceeded.
+     */
+    purgeOnQuotaError?: boolean;
+}
+/**
+ * This plugin can be used in a `@serwist/strategies` Strategy to regularly enforce a
+ * limit on the age and/or the number of cached requests.
+ *
+ * It can only be used with Strategy instances that have a custom `cacheName` property set.
+ * In other words, it can't be used to expire entries in strategies that use the default runtime
+ * cache name.
+ *
+ * Whenever a cached response is used or updated, this plugin will look
+ * at the associated cache and remove any old or extra responses.
+ *
+ * When using `maxAgeSeconds`, responses may be used *once* after expiring
+ * because the expiration clean up will not have occurred until *after* the
+ * cached response has been used. If the response has a "Date" header, then a lightweight expiration
+ * check is performed, and the response will not be used immediately.
+ *
+ * When using `maxEntries`, the least recently requested entry will be removed
+ * from the cache.
+ *
+ * @see https://serwist.pages.dev/docs/expiration/expiration-plugin
+ */
+export declare class ExpirationPlugin implements SerwistPlugin {
+    private readonly _config;
+    private _cacheExpirations;
+    /**
+     * @param config
+     */
+    constructor(config?: ExpirationPluginOptions);
+    /**
+     * A simple helper method to return a CacheExpiration instance for a given
+     * cache name.
+     *
+     * @param cacheName
+     * @returns
+     * @private
+     */
+    private _getCacheExpiration;
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `@serwist/strategies` handlers when a `Response` is about to be returned
+     * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
+     * the handler. It allows the `Response` to be inspected for freshness and
+     * prevents it from being used if the `Response`'s `Date` header value is
+     * older than the configured `maxAgeSeconds`.
+     *
+     * @param options
+     * @returns `cachedResponse` if it is fresh and `null` if it is stale or
+     * not available.
+     * @private
+     */
+    cachedResponseWillBeUsed({ event, cacheName, request, cachedResponse }: CachedResponseWillBeUsedCallbackParam): Response | null;
+    /**
+     * @param cachedResponse
+     * @returns
+     * @private
+     */
+    private _isResponseDateFresh;
+    /**
+     * Extracts the `Date` header and parse it into an useful value.
+     *
+     * @param cachedResponse
+     * @returns
+     * @private
+     */
+    private _getDateHeaderTimestamp;
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `@serwist/strategies` handlers when an entry is added to a cache.
+     *
+     * @param options
+     * @private
+     */
+    cacheDidUpdate({ cacheName, request }: CacheDidUpdateCallbackParam): Promise<void>;
+    /**
+     * Deletes the underlying `Cache` instance associated with this instance and the metadata
+     * from IndexedDB used to keep track of expiration details for each `Cache` instance.
+     *
+     * When using cache expiration, calling this method is preferable to calling
+     * `caches.delete()` directly, since this will ensure that the IndexedDB
+     * metadata is also cleanly removed and that open IndexedDB instances are deleted.
+     *
+     * Note that if you're *not* using cache expiration for a given cache, calling
+     * `caches.delete()` and passing in the cache's name should be sufficient.
+     * There is no Serwist-specific method needed for cleanup in that case.
+     */
+    deleteCacheAndMetadata(): Promise<void>;
+}
+//# sourceMappingURL=ExpirationPlugin.d.ts.map

package/dist/plugins/expiration/ExpirationPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpirationPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/expiration/ExpirationPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,qCAAqC,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAMvH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,cAAc,GAAG,WAAW,CAAC;IAC1C;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,iBAAiB,CAA+B;IAExD;;OAEG;gBACS,MAAM,GAAE,uBAA4B;IAkDhD;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAa3B;;;;;;;;;;;;OAYG;IACH,wBAAwB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,qCAAqC;IAqC7G;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAwB5B;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAkB/B;;;;;;OAMG;IACG,cAAc,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,2BAA2B;IAqBxE;;;;;;;;;;;OAWG;IACG,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;CAW9C"}

package/dist/plugins/expiration/models/CacheTimestampsModel.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Returns the timestamp model.
+ *
+ * @private
+ */
+export declare class CacheTimestampsModel {
+    private readonly _cacheName;
+    private _db;
+    /**
+     *
+     * @param cacheName
+     *
+     * @private
+     */
+    constructor(cacheName: string);
+    /**
+     * Takes a URL and returns an ID that will be unique in the object store.
+     *
+     * @param url
+     * @returns
+     * @private
+     */
+    private _getId;
+    /**
+     * Performs an upgrade of indexedDB.
+     *
+     * @param db
+     *
+     * @private
+     */
+    private _upgradeDb;
+    /**
+     * Performs an upgrade of indexedDB and deletes deprecated DBs.
+     *
+     * @param db
+     *
+     * @private
+     */
+    private _upgradeDbAndDeleteOldDbs;
+    /**
+     * @param url
+     * @param timestamp
+     *
+     * @private
+     */
+    setTimestamp(url: string, timestamp: number): Promise<void>;
+    /**
+     * Returns the timestamp stored for a given URL.
+     *
+     * @param url
+     * @returns
+     * @private
+     */
+    getTimestamp(url: string): Promise<number | undefined>;
+    /**
+     * Iterates through all the entries in the object store (from newest to
+     * oldest) and removes entries once either `maxCount` is reached or the
+     * entry's timestamp is less than `minTimestamp`.
+     *
+     * @param minTimestamp
+     * @param maxCount
+     * @returns
+     * @private
+     */
+    expireEntries(minTimestamp: number, maxCount?: number): Promise<string[]>;
+    /**
+     * Returns an open connection to the database.
+     *
+     * @private
+     */
+    private getDb;
+}
+//# sourceMappingURL=CacheTimestampsModel.d.ts.map

package/dist/plugins/expiration/models/CacheTimestampsModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheTimestampsModel.d.ts","sourceRoot":"","sources":["../../../../src/plugins/expiration/models/CacheTimestampsModel.ts"],"names":[],"mappings":"AAoCA;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,GAAG,CAA4C;IAEvD;;;;;OAKG;gBACS,SAAS,EAAE,MAAM;IAI7B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM;IAId;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAYlB;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IAOjC;;;;;OAKG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjE;;;;;;OAMG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAM5D;;;;;;;;;OASG;IACG,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAyB/E;;;;OAIG;YACW,KAAK;CAQpB"}

package/dist/plugins/googleAnalytics/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const QUEUE_NAME = "serwist-google-analytics";
+export declare const MAX_RETENTION_TIME: number;
+export declare const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+export declare const GTM_HOST = "www.googletagmanager.com";
+export declare const ANALYTICS_JS_PATH = "/analytics.js";
+export declare const GTAG_JS_PATH = "/gtag/js";
+export declare const GTM_JS_PATH = "/gtm.js";
+export declare const COLLECT_DEFAULT_PATH = "/collect";
+export declare const COLLECT_PATHS_REGEX: RegExp;
+//# sourceMappingURL=constants.d.ts.map

package/dist/plugins/googleAnalytics/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/plugins/googleAnalytics/constants.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,UAAU,6BAA6B,CAAC;AACrD,eAAO,MAAM,kBAAkB,QAAU,CAAC;AAC1C,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAChE,eAAO,MAAM,QAAQ,6BAA6B,CAAC;AACnD,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AACjD,eAAO,MAAM,YAAY,aAAa,CAAC;AACvC,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAM/C,eAAO,MAAM,mBAAmB,QAAuB,CAAC"}

package/dist/plugins/googleAnalytics/initialize.d.ts

@@ -0,0 +1,34 @@
+import type { Router } from "../../routing/Router.js";
+export interface GoogleAnalyticsInitializeOptions {
+    /**
+     * An optional `Router` instance. If not provided, the singleton `Router`
+     * will be used.
+     */
+    router?: Router;
+    /**
+     * The cache name to store and retrieve analytics.js. Defaults to the cache names provided by `@serwist/core`.
+     */
+    cacheName?: string;
+    /**
+     * [Measurement Protocol parameters](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters),
+     * expressed as key/value pairs, to be added to replayed Google Analytics
+     * requests. This can be used to, e.g., set a custom dimension indicating
+     * that the request was replayed.
+     */
+    parameterOverrides?: {
+        [paramName: string]: string;
+    };
+    /**
+     * A function that allows you to modify the hit parameters prior to replaying
+     * the hit. The function is invoked with the original hit's URLSearchParams
+     * object as its only argument.
+     */
+    hitFilter?: (params: URLSearchParams) => void;
+}
+/**
+ * Initialize Serwist's offline Google Analytics v3 support.
+ *
+ * @param options
+ */
+export declare const initialize: ({ cacheName, router, ...options }?: GoogleAnalyticsInitializeOptions) => void;
+//# sourceMappingURL=initialize.d.ts.map

package/dist/plugins/googleAnalytics/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/plugins/googleAnalytics/initialize.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAatD,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACrD;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/C;AAyID;;;;GAIG;AACH,eAAO,MAAM,UAAU,uCAA8D,gCAAgC,KAAQ,IAkB5H,CAAC"}

package/dist/plugins/precaching/PrecacheFallbackPlugin.d.ts

@@ -0,0 +1,54 @@
+import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "@serwist/core";
+import type { PrecacheController } from "../../precaching/PrecacheController.js";
+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;
+}
+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 `PrecacheController` instance. If not provided, the default
+     * `PrecacheController` will be used.
+     */
+    precacheController?: PrecacheController;
+}
+/**
+ * `PrecacheFallbackPlugin` 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 `PrecacheController` instance to the
+ * constructor, the default instance will be used. Generally speaking, most
+ * developers will end up using the default.
+ */
+export declare class PrecacheFallbackPlugin implements SerwistPlugin {
+    private readonly _fallbackUrls;
+    private readonly _precacheController;
+    /**
+     * Constructs a new `PrecacheFallbackPlugin` with the associated `fallbackUrls`.
+     *
+     * @param config
+     */
+    constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions);
+    /**
+     * @returns The precache response for one of the fallback URLs, or `undefined` if
+     * nothing satisfies the conditions.
+     * @private
+     */
+    handlerDidError(param: HandlerDidErrorCallbackParam): Promise<Response | undefined>;
+}
+//# sourceMappingURL=PrecacheFallbackPlugin.d.ts.map

package/dist/plugins/precaching/PrecacheFallbackPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/precaching/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAGjF,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD;;;;OAIG;gBACS,EAAE,YAAY,EAAE,kBAAkB,EAAE,EAAE,6BAA6B;IAK/E;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}

package/dist/plugins/rangeRequests/RangeRequestsPlugin.d.ts

@@ -0,0 +1,19 @@
+import type { SerwistPlugin } from "@serwist/core";
+/**
+ * The range request plugin makes it easy for a request with a 'Range' header to
+ * be fulfilled by a cached response.
+ *
+ * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback
+ * and returning the appropriate subset of the cached response body.
+ */
+export declare class RangeRequestsPlugin implements SerwistPlugin {
+    /**
+     * @param options
+     * @returns If request contains a 'Range' header, then a
+     * new response with status 206 whose body is a subset of `cachedResponse` is
+     * returned. Otherwise, `cachedResponse` is returned as-is.
+     * @private
+     */
+    cachedResponseWillBeUsed: SerwistPlugin["cachedResponseWillBeUsed"];
+}
+//# sourceMappingURL=RangeRequestsPlugin.d.ts.map

package/dist/plugins/rangeRequests/RangeRequestsPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RangeRequestsPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/rangeRequests/RangeRequestsPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAInD;;;;;;GAMG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IACvD;;;;;;OAMG;IACH,wBAAwB,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAUjE;CACH"}

package/dist/plugins/rangeRequests/createPartialResponse.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Given a `Request` and `Response` objects as input, this will return a
+ * promise for a new `Response`.
+ *
+ * If the original `Response` already contains partial content (i.e. it has
+ * a status of 206), then this assumes it already fulfills the `Range:`
+ * requirements, and will return it as-is.
+ *
+ * @param request A request, which should contain a Range:
+ * header.
+ * @param originalResponse A response.
+ * @returns Either a `206 Partial Content` response, with
+ * the response body set to the slice of content specified by the request's
+ * `Range:` header, or a `416 Range Not Satisfiable` response if the
+ * conditions of the `Range:` header can't be met.
+ */
+export declare const createPartialResponse: (request: Request, originalResponse: Response) => Promise<Response>;
+//# sourceMappingURL=createPartialResponse.d.ts.map