@serwist/core 8.1.1 → 8.3.0

package/dist/{index.internal.old.cjs → quotaErrorCallbacks.js}

@@ -1,4 +1,83 @@
-'use strict';
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ const _cacheNameDetails = {
+    googleAnalytics: "googleAnalytics",
+    precache: "precache-v2",
+    prefix: "serwist",
+    runtime: "runtime",
+    suffix: typeof registration !== "undefined" ? registration.scope : ""
+};
+const _createCacheName = (cacheName)=>{
+    return [
+        _cacheNameDetails.prefix,
+        cacheName,
+        _cacheNameDetails.suffix
+    ].filter((value)=>value && value.length > 0).join("-");
+};
+const eachCacheNameDetail = (fn)=>{
+    for (const key of Object.keys(_cacheNameDetails)){
+        fn(key);
+    }
+};
+const cacheNames = {
+    updateDetails: (details)=>{
+        eachCacheNameDetail((key)=>{
+            const detail = details[key];
+            if (typeof detail === "string") {
+                _cacheNameDetails[key] = detail;
+            }
+        });
+    },
+    getGoogleAnalyticsName: (userCacheName)=>{
+        return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);
+    },
+    getPrecacheName: (userCacheName)=>{
+        return userCacheName || _createCacheName(_cacheNameDetails.precache);
+    },
+    getPrefix: ()=>{
+        return _cacheNameDetails.prefix;
+    },
+    getRuntimeName: (userCacheName)=>{
+        return userCacheName || _createCacheName(_cacheNameDetails.runtime);
+    },
+    getSuffix: ()=>{
+        return _cacheNameDetails.suffix;
+    }
+};
+
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ let supportStatus;
+/**
+ * A utility function that determines whether the current browser supports
+ * constructing a new `Response` from a `response.body` stream.
+ *
+ * @returns `true`, if the current browser can successfully construct
+ * a `Response` from a `response.body` stream, `false` otherwise.
+ * @private
+ */ function canConstructResponseFromBodyStream() {
+    if (supportStatus === undefined) {
+        const testResponse = new Response("");
+        if ("body" in testResponse) {
+            try {
+                new Response(testResponse.body);
+                supportStatus = true;
+            } catch (error) {
+                supportStatus = false;
+            }
+        }
+        supportStatus = false;
+    }
+    return supportStatus;
+}
 
 /*
   Copyright 2018 Google LLC
@@ -268,202 +347,6 @@ const finalAssertExports = process.env.NODE_ENV === "production" ? null : {
     isArrayOfClass
 };
 
-/*
-  Copyright 2020 Google LLC
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ function stripParams(fullURL, ignoreParams) {
-    const strippedURL = new URL(fullURL);
-    for (const param of ignoreParams){
-        strippedURL.searchParams.delete(param);
-    }
-    return strippedURL.href;
-}
-/**
- * Matches an item in the cache, ignoring specific URL params. This is similar
- * to the `ignoreSearch` option, but it allows you to ignore just specific
- * params (while continuing to match on the others).
- *
- * @private
- * @param cache
- * @param request
- * @param matchOptions
- * @param ignoreParams
- * @returns
- */ async function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) {
-    const strippedRequestURL = stripParams(request.url, ignoreParams);
-    // If the request doesn't include any ignored params, match as normal.
-    if (request.url === strippedRequestURL) {
-        return cache.match(request, matchOptions);
-    }
-    // Otherwise, match by comparing keys
-    const keysOptions = {
-        ...matchOptions,
-        ignoreSearch: true
-    };
-    const cacheKeys = await cache.keys(request, keysOptions);
-    for (const cacheKey of cacheKeys){
-        const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams);
-        if (strippedRequestURL === strippedCacheKeyURL) {
-            return cache.match(cacheKey, matchOptions);
-        }
-    }
-    return;
-}
-
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ const _cacheNameDetails = {
-    googleAnalytics: "googleAnalytics",
-    precache: "precache-v2",
-    prefix: "serwist",
-    runtime: "runtime",
-    suffix: typeof registration !== "undefined" ? registration.scope : ""
-};
-const _createCacheName = (cacheName)=>{
-    return [
-        _cacheNameDetails.prefix,
-        cacheName,
-        _cacheNameDetails.suffix
-    ].filter((value)=>value && value.length > 0).join("-");
-};
-const eachCacheNameDetail = (fn)=>{
-    for (const key of Object.keys(_cacheNameDetails)){
-        fn(key);
-    }
-};
-const cacheNames = {
-    updateDetails: (details)=>{
-        eachCacheNameDetail((key)=>{
-            const detail = details[key];
-            if (typeof detail === "string") {
-                _cacheNameDetails[key] = detail;
-            }
-        });
-    },
-    getGoogleAnalyticsName: (userCacheName)=>{
-        return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);
-    },
-    getPrecacheName: (userCacheName)=>{
-        return userCacheName || _createCacheName(_cacheNameDetails.precache);
-    },
-    getPrefix: ()=>{
-        return _cacheNameDetails.prefix;
-    },
-    getRuntimeName: (userCacheName)=>{
-        return userCacheName || _createCacheName(_cacheNameDetails.runtime);
-    },
-    getSuffix: ()=>{
-        return _cacheNameDetails.suffix;
-    }
-};
-
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ let supportStatus$1;
-/**
- * A utility function that determines whether the current browser supports
- * constructing a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
- * object.
- *
- * @returns `true`, if the current browser can successfully construct a `ReadableStream`, `false` otherwise.
- *
- * @private
- */ function canConstructReadableStream() {
-    if (supportStatus$1 === undefined) {
-        // See https://github.com/GoogleChrome/workbox/issues/1473
-        try {
-            new ReadableStream({
-                start () {}
-            });
-            supportStatus$1 = true;
-        } catch (error) {
-            supportStatus$1 = false;
-        }
-    }
-    return supportStatus$1;
-}
-
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ let supportStatus;
-/**
- * A utility function that determines whether the current browser supports
- * constructing a new `Response` from a `response.body` stream.
- *
- * @returns `true`, if the current browser can successfully construct
- * a `Response` from a `response.body` stream, `false` otherwise.
- * @private
- */ function canConstructResponseFromBodyStream() {
-    if (supportStatus === undefined) {
-        const testResponse = new Response("");
-        if ("body" in testResponse) {
-            try {
-                new Response(testResponse.body);
-                supportStatus = true;
-            } catch (error) {
-                supportStatus = false;
-            }
-        }
-        supportStatus = false;
-    }
-    return supportStatus;
-}
-
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * The Deferred class composes Promises in a way that allows for them to be
- * resolved or rejected from outside the constructor. In most cases promises
- * should be used directly, but Deferreds can be necessary when the logic to
- * resolve a promise must be separate.
- *
- * @private
- */ class Deferred {
-    promise;
-    resolve;
-    reject;
-    /**
-   * Creates a promise and exposes its resolve and reject functions as methods.
-   */ constructor(){
-        this.promise = new Promise((resolve, reject)=>{
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-    }
-}
-
-/*
-  Copyright 2019 Google LLC
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * A helper function that prevents a promise from being flagged as unused.
- *
- * @private
- **/ function dontWaitFor(promise) {
-    // Effective no-op.
-    void promise.then(()=>{});
-}
-
 /*
   Copyright 2019 Google LLC
   Use of this source code is governed by an MIT-style
@@ -540,128 +423,4 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
 // eslint-disable-next-line @typescript-eslint/ban-types
 const quotaErrorCallbacks = new Set();
 
-/**
- * Runs all of the callback functions, one at a time sequentially, in the order
- * in which they were registered.
- *
- * @private
- */ async function executeQuotaErrorCallbacks() {
-    if (process.env.NODE_ENV !== "production") {
-        logger.log(`About to run ${quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`);
-    }
-    for (const callback of quotaErrorCallbacks){
-        await callback();
-        if (process.env.NODE_ENV !== "production") {
-            logger.log(callback, "is complete.");
-        }
-    }
-    if (process.env.NODE_ENV !== "production") {
-        logger.log("Finished running callbacks.");
-    }
-}
-
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ const getFriendlyURL = (url)=>{
-    const urlObj = new URL(String(url), location.href);
-    // See https://github.com/GoogleChrome/workbox/issues/2323
-    // We want to include everything, except for the origin if it's same-origin.
-    return urlObj.href.replace(new RegExp(`^${location.origin}`), "");
-};
-
-/*
-  Copyright 2019 Google LLC
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * Returns a promise that resolves and the passed number of milliseconds.
- * This utility is an async/await-friendly version of `setTimeout`.
- *
- * @param ms
- * @returns
- * @private
- */ function timeout(ms) {
-    return new Promise((resolve)=>setTimeout(resolve, ms));
-}
-
-const MAX_RETRY_TIME = 2000;
-/**
- * Returns a promise that resolves to a window client matching the passed
- * `resultingClientId`. For browsers that don't support `resultingClientId`
- * or if waiting for the resulting client to apper takes too long, resolve to
- * `undefined`.
- *
- * @param resultingClientId
- * @returns
- * @private
- */ async function resultingClientExists(resultingClientId) {
-    if (!resultingClientId) {
-        return;
-    }
-    let existingWindows = await self.clients.matchAll({
-        type: "window"
-    });
-    const existingWindowIds = new Set(existingWindows.map((w)=>w.id));
-    let resultingWindow;
-    const startTime = performance.now();
-    // Only wait up to `MAX_RETRY_TIME` to find a matching client.
-    while(performance.now() - startTime < MAX_RETRY_TIME){
-        existingWindows = await self.clients.matchAll({
-            type: "window"
-        });
-        resultingWindow = existingWindows.find((w)=>{
-            if (resultingClientId) {
-                // If we have a `resultingClientId`, we can match on that.
-                return w.id === resultingClientId;
-            } else {
-                // Otherwise match on finding a window not in `existingWindowIds`.
-                return !existingWindowIds.has(w.id);
-            }
-        });
-        if (resultingWindow) {
-            break;
-        }
-        // Sleep for 100ms and retry.
-        await timeout(100);
-    }
-    return resultingWindow;
-}
-
-/*
-  Copyright 2020 Google LLC
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * A utility method that makes it easier to use `event.waitUntil` with
- * async functions and return the result.
- *
- * @param event
- * @param asyncFn
- * @returns
- * @private
- */ function waitUntil(event, asyncFn) {
-    const returnPromise = asyncFn();
-    event.waitUntil(returnPromise);
-    return returnPromise;
-}
-
-exports.Deferred = Deferred;
-exports.SerwistError = SerwistError;
-exports.assert = finalAssertExports;
-exports.cacheMatchIgnoreParams = cacheMatchIgnoreParams;
-exports.canConstructReadableStream = canConstructReadableStream;
-exports.canConstructResponseFromBodyStream = canConstructResponseFromBodyStream;
-exports.dontWaitFor = dontWaitFor;
-exports.executeQuotaErrorCallbacks = executeQuotaErrorCallbacks;
-exports.getFriendlyURL = getFriendlyURL;
-exports.logger = logger;
-exports.privateCacheNames = cacheNames;
-exports.resultingClientExists = resultingClientExists;
-exports.timeout = timeout;
-exports.waitUntil = waitUntil;
+export { SerwistError as S, canConstructResponseFromBodyStream as a, cacheNames as c, finalAssertExports as f, logger as l, quotaErrorCallbacks as q };

package/dist/types.d.cts

@@ -0,0 +1,272 @@
+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 interface RouteMatchCallback {
+    (options: RouteMatchCallbackOptions): any;
+}
+/**
+ * Options passed to a `RouteHandlerCallback` function.
+ */
+export declare interface RouteHandlerCallbackOptions {
+    /**
+     * The event associated with the request.
+     */
+    event: ExtendableEvent;
+    /**
+     * A request to run this strategy for.
+     */
+    request: Request;
+    url: URL;
+    /**
+     * The return value from `@serwist/routing`'s `matchCallback` (if applicable).
+     */
+    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;
+}
+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 interface 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 interface 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 in `@serwist/routing` that accept route handlers take either.
+ */
+export type RouteHandler = RouteHandlerCallback | RouteHandlerObject;
+export interface HandlerWillStartCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export interface HandlerWillStartCallback {
+    (param: HandlerWillStartCallbackParam): Promise<void | null | undefined>;
+}
+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 interface CacheDidUpdateCallback {
+    (param: CacheDidUpdateCallbackParam): Promise<void | null | undefined>;
+}
+export interface CacheKeyWillBeUsedCallbackParam {
+    mode: string;
+    request: Request;
+    event: ExtendableEvent;
+    params?: any;
+    state?: PluginState;
+}
+export interface CacheKeyWillBeUsedCallback {
+    (param: CacheKeyWillBeUsedCallbackParam): Promise<Request | string>;
+}
+export interface CacheWillUpdateCallbackParam {
+    request: Request;
+    response: Response;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export interface CacheWillUpdateCallback {
+    (param: CacheWillUpdateCallbackParam): Promise<Response | void | null | undefined>;
+}
+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 interface CachedResponseWillBeUsedCallback {
+    (param: CachedResponseWillBeUsedCallbackParam): Promise<Response | void | null | undefined>;
+}
+export interface FetchDidFailCallbackParam {
+    error: Error;
+    originalRequest: Request;
+    request: Request;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export interface FetchDidFailCallback {
+    (param: FetchDidFailCallbackParam): Promise<void | null | undefined>;
+}
+export interface FetchDidSucceedCallbackParam {
+    request: Request;
+    response: Response;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export interface FetchDidSucceedCallback {
+    (param: FetchDidSucceedCallbackParam): Promise<Response>;
+}
+export interface RequestWillFetchCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export interface RequestWillFetchCallback {
+    (param: RequestWillFetchCallbackParam): Promise<Request>;
+}
+export interface HandlerWillRespondCallbackParam {
+    request: Request;
+    response: Response;
+    event: ExtendableEvent;
+    state?: PluginState;
+}
+export interface HandlerWillRespondCallback {
+    (param: HandlerWillRespondCallbackParam): Promise<Response>;
+}
+export interface HandlerDidErrorCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    error: Error;
+    state?: PluginState;
+}
+export interface HandlerDidErrorCallback {
+    (param: HandlerDidErrorCallbackParam): Promise<Response | undefined>;
+}
+export interface HandlerDidRespondCallbackParam {
+    request: Request;
+    event: ExtendableEvent;
+    response?: Response;
+    state?: PluginState;
+}
+export interface HandlerDidRespondCallback {
+    (param: HandlerDidRespondCallbackParam): Promise<void | null | undefined>;
+}
+export interface HandlerDidCompleteCallbackParam {
+    request: Request;
+    error?: Error;
+    event: ExtendableEvent;
+    response?: Response;
+    state?: PluginState;
+}
+export interface HandlerDidCompleteCallback {
+    (param: HandlerDidCompleteCallbackParam): Promise<void | null | undefined>;
+}
+/**
+ * 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;
+}

package/dist/utils/pluginUtils.d.cts

@@ -0,0 +1,4 @@
+import type { SerwistPlugin } from "../types.js";
+export declare const pluginUtils: {
+    filter: (plugins: SerwistPlugin[], callbackName: string) => SerwistPlugin[];
+};

package/dist/utils/welcome.d.cts

@@ -0,0 +1 @@
+export {};