serwist 9.0.12 → 10.0.0-preview.1

package/dist/chunks/resultingClientExists.js

@@ -1,4 +1,428 @@
-import { t as timeout } from './waitUntil.js';
+const messages = {
+    "invalid-value": ({ paramName, validValueDescription, value })=>{
+        if (!paramName || !validValueDescription) {
+            throw new Error(`Unexpected input to 'invalid-value' error.`);
+        }
+        return `The '${paramName}' parameter was given a value with an ` + `unexpected value. ${validValueDescription} Received a value of ` + `${JSON.stringify(value)}.`;
+    },
+    "not-an-array": ({ moduleName, className, funcName, paramName })=>{
+        if (!moduleName || !className || !funcName || !paramName) {
+            throw new Error(`Unexpected input to 'not-an-array' error.`);
+        }
+        return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`;
+    },
+    "incorrect-type": ({ expectedType, paramName, moduleName, className, funcName })=>{
+        if (!expectedType || !paramName || !moduleName || !funcName) {
+            throw new Error(`Unexpected input to 'incorrect-type' error.`);
+        }
+        const classNameStr = className ? `${className}.` : "";
+        return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}` + `${funcName}()' must be of type ${expectedType}.`;
+    },
+    "incorrect-class": ({ expectedClassName, paramName, moduleName, className, funcName, isReturnValueProblem })=>{
+        if (!expectedClassName || !moduleName || !funcName) {
+            throw new Error(`Unexpected input to 'incorrect-class' error.`);
+        }
+        const classNameStr = className ? `${className}.` : "";
+        if (isReturnValueProblem) {
+            return `The return value from '${moduleName}.${classNameStr}${funcName}()' must be an instance of class ${expectedClassName}.`;
+        }
+        return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`;
+    },
+    "missing-a-method": ({ expectedMethod, paramName, moduleName, className, funcName })=>{
+        if (!expectedMethod || !paramName || !moduleName || !className || !funcName) {
+            throw new Error(`Unexpected input to 'missing-a-method' error.`);
+        }
+        return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
+    },
+    "add-to-cache-list-unexpected-type": ({ entry })=>{
+        return `An unexpected entry was passed to 'serwist.Serwist.addToPrecacheList()' The entry '${JSON.stringify(entry)}' isn't supported. You must supply an array of strings with one or more characters, objects with a url property or Request objects.`;
+    },
+    "add-to-cache-list-conflicting-entries": ({ firstEntry, secondEntry })=>{
+        if (!firstEntry || !secondEntry) {
+            throw new Error("Unexpected input to " + `'add-to-cache-list-duplicate-entries' error.`);
+        }
+        return `Two of the entries passed to 'serwist.Serwist.addToPrecacheList()' had the URL ${firstEntry} but different revision details. Serwist is unable to cache and version the asset correctly. Please remove one of the entries.`;
+    },
+    "plugin-error-request-will-fetch": ({ thrownErrorMessage })=>{
+        if (!thrownErrorMessage) {
+            throw new Error("Unexpected input to " + `'plugin-error-request-will-fetch', error.`);
+        }
+        return `An error was thrown by a plugin's 'requestWillFetch()' method. The thrown error message was: '${thrownErrorMessage}'.`;
+    },
+    "invalid-cache-name": ({ cacheNameId, value })=>{
+        if (!cacheNameId) {
+            throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);
+        }
+        return `You must provide a name containing at least one character for setCacheDetails({${cacheNameId}: '...'}). Received a value of '${JSON.stringify(value)}'`;
+    },
+    "unregister-route-but-not-found-with-method": ({ method })=>{
+        if (!method) {
+            throw new Error("Unexpected input to " + `'unregister-route-but-not-found-with-method' error.`);
+        }
+        return `The route you're trying to unregister was not  previously registered for the method type '${method}'.`;
+    },
+    "unregister-route-route-not-registered": ()=>{
+        return `The route you're trying to unregister was not previously ` + "registered.";
+    },
+    "queue-replay-failed": ({ name })=>{
+        return `Replaying the background sync queue '${name}' failed.`;
+    },
+    "duplicate-queue-name": ({ name })=>{
+        return `The queue name '${name}' is already being used. All instances of 'serwist.BackgroundSyncQueue' must be given unique names.`;
+    },
+    "expired-test-without-max-age": ({ methodName, paramName })=>{
+        return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`;
+    },
+    "unsupported-route-type": ({ moduleName, className, funcName, paramName })=>{
+        return `The supplied '${paramName}' parameter was an unsupported type. Please check the docs for ${moduleName}.${className}.${funcName} for valid input types.`;
+    },
+    "not-array-of-class": ({ value, expectedClass, moduleName, className, funcName, paramName })=>{
+        return `The supplied '${paramName}' parameter must be an array of '${expectedClass}' objects. Received '${JSON.stringify(value)},'. Please check the call to ${moduleName}.${className}.${funcName}() to fix the issue.`;
+    },
+    "max-entries-or-age-required": ({ moduleName, className, funcName })=>{
+        return `You must define either 'config.maxEntries' or 'config.maxAgeSeconds' in '${moduleName}.${className}.${funcName}'`;
+    },
+    "statuses-or-headers-required": ({ moduleName, className, funcName })=>{
+        return `You must define either 'config.statuses' or 'config.headers' in '${moduleName}.${className}.${funcName}'`;
+    },
+    "invalid-string": ({ moduleName, funcName, paramName })=>{
+        if (!paramName || !moduleName || !funcName) {
+            throw new Error(`Unexpected input to 'invalid-string' error.`);
+        }
+        return `When using strings, the '${paramName}' parameter must start with 'http' (for cross-origin matches) or '/' (for same-origin matches). Please see the docs for ${moduleName}.${funcName}() for more info.`;
+    },
+    "channel-name-required": ()=>{
+        return "You must provide a channelName to construct a " + "BroadcastCacheUpdate instance.";
+    },
+    "invalid-responses-are-same-args": ()=>{
+        return "The arguments passed into responsesAreSame() appear to be " + "invalid. Please ensure valid Responses are used.";
+    },
+    "expire-custom-caches-only": ()=>{
+        return `You must provide a 'cacheName' property when using the ` + "expiration plugin with a runtime caching strategy.";
+    },
+    "unit-must-be-bytes": ({ normalizedRangeHeader })=>{
+        if (!normalizedRangeHeader) {
+            throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
+        }
+        return `The 'unit' portion of the Range header must be set to 'bytes'. The Range header provided was "${normalizedRangeHeader}"`;
+    },
+    "single-range-only": ({ normalizedRangeHeader })=>{
+        if (!normalizedRangeHeader) {
+            throw new Error(`Unexpected input to 'single-range-only' error.`);
+        }
+        return `Multiple ranges are not supported. Please use a  single start value, and optional end value. The Range header provided was "${normalizedRangeHeader}"`;
+    },
+    "invalid-range-values": ({ normalizedRangeHeader })=>{
+        if (!normalizedRangeHeader) {
+            throw new Error(`Unexpected input to 'invalid-range-values' error.`);
+        }
+        return `The Range header is missing both start and end values. At least one of those values is needed. The Range header provided was "${normalizedRangeHeader}"`;
+    },
+    "no-range-header": ()=>{
+        return "No Range header was found in the Request provided.";
+    },
+    "range-not-satisfiable": ({ size, start, end })=>{
+        return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`;
+    },
+    "attempt-to-cache-non-get-request": ({ url, method })=>{
+        return `Unable to cache '${url}' because it is a '${method}' request and only 'GET' requests can be cached.`;
+    },
+    "cache-put-with-no-response": ({ url })=>{
+        return `There was an attempt to cache '${url}' but the response was not defined.`;
+    },
+    "no-response": ({ url, error })=>{
+        let message = `The strategy could not generate a response for '${url}'.`;
+        if (error) {
+            message += ` The underlying error is ${error}.`;
+        }
+        return message;
+    },
+    "bad-precaching-response": ({ url, status })=>{
+        return `The precaching request for '${url}' failed${status ? ` with an HTTP status of ${status}.` : "."}`;
+    },
+    "non-precached-url": ({ url })=>{
+        return `'createHandlerBoundToURL("${url}")' was called, but that URL is not precached. Please pass in a URL that is precached instead.`;
+    },
+    "add-to-cache-list-conflicting-integrities": ({ url })=>{
+        return `Two of the entries passed to 'serwist.Serwist.addToPrecacheList()' had the URL ${url} with different integrity values. Please remove one of them.`;
+    },
+    "missing-precache-entry": ({ cacheName, url })=>{
+        return `Unable to find a precached response in ${cacheName} for ${url}.`;
+    },
+    "cross-origin-copy-response": ({ origin })=>{
+        return `'@serwist/core.copyResponse()' can only be used with same-origin responses. It was passed a response with origin ${origin}.`;
+    },
+    "opaque-streams-source": ({ type })=>{
+        const message = `One of the '@serwist/streams' sources resulted in an '${type}' response.`;
+        if (type === "opaqueredirect") {
+            return `${message} Please do not use a navigation request that results in a redirect as a source.`;
+        }
+        return `${message} Please ensure your sources are CORS-enabled.`;
+    }
+};
+
+const fallback = (code, ...args)=>{
+    let msg = code;
+    if (args.length > 0) {
+        msg += ` :: ${JSON.stringify(args)}`;
+    }
+    return msg;
+};
+const generatorFunction = (code, details = {})=>{
+    const message = messages[code];
+    if (!message) {
+        throw new Error(`Unable to find message for code '${code}'.`);
+    }
+    return message(details);
+};
+const messageGenerator = process.env.NODE_ENV === "production" ? fallback : generatorFunction;
+
+class SerwistError extends Error {
+    details;
+    constructor(errorCode, details){
+        const message = messageGenerator(errorCode, details);
+        super(message);
+        this.name = errorCode;
+        this.details = details;
+    }
+}
+
+let supportStatus;
+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;
+}
+
+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;
+    }
+};
+
+const getFriendlyURL = (url)=>{
+    const urlObj = new URL(String(url), location.href);
+    return urlObj.href.replace(new RegExp(`^${location.origin}`), "");
+};
+
+const logger = process.env.NODE_ENV === "production" ? null : (()=>{
+    if (!("__WB_DISABLE_DEV_LOGS" in globalThis)) {
+        self.__WB_DISABLE_DEV_LOGS = false;
+    }
+    let inGroup = false;
+    const methodToColorMap = {
+        debug: "#7f8c8d",
+        log: "#2ecc71",
+        warn: "#f39c12",
+        error: "#c0392b",
+        groupCollapsed: "#3498db",
+        groupEnd: null
+    };
+    const print = (method, args)=>{
+        if (self.__WB_DISABLE_DEV_LOGS) {
+            return;
+        }
+        if (method === "groupCollapsed") {
+            if (typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+                console[method](...args);
+                return;
+            }
+        }
+        const styles = [
+            `background: ${methodToColorMap[method]}`,
+            "border-radius: 0.5em",
+            "color: white",
+            "font-weight: bold",
+            "padding: 2px 0.5em"
+        ];
+        const logPrefix = inGroup ? [] : [
+            "%cserwist",
+            styles.join(";")
+        ];
+        console[method](...logPrefix, ...args);
+        if (method === "groupCollapsed") {
+            inGroup = true;
+        }
+        if (method === "groupEnd") {
+            inGroup = false;
+        }
+    };
+    const loggerMethods = Object.keys(methodToColorMap);
+    return loggerMethods.reduce((api, method)=>{
+        api[method] = (...args)=>{
+            print(method, args);
+        };
+        return api;
+    }, {});
+})();
+
+class Deferred {
+    promise;
+    resolve;
+    reject;
+    constructor(){
+        this.promise = new Promise((resolve, reject)=>{
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+
+const isArray = (value, details)=>{
+    if (!Array.isArray(value)) {
+        throw new SerwistError("not-an-array", details);
+    }
+};
+const hasMethod = (object, expectedMethod, details)=>{
+    const type = typeof object[expectedMethod];
+    if (type !== "function") {
+        details.expectedMethod = expectedMethod;
+        throw new SerwistError("missing-a-method", details);
+    }
+};
+const isType = (object, expectedType, details)=>{
+    if (typeof object !== expectedType) {
+        details.expectedType = expectedType;
+        throw new SerwistError("incorrect-type", details);
+    }
+};
+const isInstance = (object, expectedClass, details)=>{
+    if (!(object instanceof expectedClass)) {
+        details.expectedClassName = expectedClass.name;
+        throw new SerwistError("incorrect-class", details);
+    }
+};
+const isOneOf = (value, validValues, details)=>{
+    if (!validValues.includes(value)) {
+        details.validValueDescription = `Valid values are ${JSON.stringify(validValues)}.`;
+        throw new SerwistError("invalid-value", details);
+    }
+};
+const isArrayOfClass = (value, expectedClass, details)=>{
+    const error = new SerwistError("not-array-of-class", details);
+    if (!Array.isArray(value)) {
+        throw error;
+    }
+    for (const item of value){
+        if (!(item instanceof expectedClass)) {
+            throw error;
+        }
+    }
+};
+const finalAssertExports = process.env.NODE_ENV === "production" ? null : {
+    hasMethod,
+    isArray,
+    isInstance,
+    isOneOf,
+    isType,
+    isArrayOfClass
+};
+
+function stripParams(fullURL, ignoreParams) {
+    const strippedURL = new URL(fullURL);
+    for (const param of ignoreParams){
+        strippedURL.searchParams.delete(param);
+    }
+    return strippedURL.href;
+}
+async function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) {
+    const strippedRequestURL = stripParams(request.url, ignoreParams);
+    if (request.url === strippedRequestURL) {
+        return cache.match(request, matchOptions);
+    }
+    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;
+}
+
+const quotaErrorCallbacks = new Set();
+
+const executeQuotaErrorCallbacks = async ()=>{
+    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.");
+    }
+};
+
+function timeout(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+
+const clientsClaim = ()=>{
+    self.addEventListener("activate", ()=>self.clients.claim());
+};
+
+const waitUntil = (event, asyncFn)=>{
+    const returnPromise = asyncFn();
+    event.waitUntil(returnPromise);
+    return returnPromise;
+};
 
 const MAX_RETRY_TIME = 2000;
 async function resultingClientExists(resultingClientId) {
@@ -29,4 +453,4 @@ async function resultingClientExists(resultingClientId) {
     return resultingWindow;
 }
 
-export { resultingClientExists as r };
+export { Deferred as D, SerwistError as S, cacheMatchIgnoreParams as a, cacheNames as b, canConstructResponseFromBodyStream as c, clientsClaim as d, executeQuotaErrorCallbacks as e, finalAssertExports as f, getFriendlyURL as g, logger as l, quotaErrorCallbacks as q, resultingClientExists as r, timeout as t, waitUntil as w };

package/dist/{legacy/utils → controllers/PrecacheController}/PrecacheCacheKeyPlugin.d.ts

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

package/dist/controllers/PrecacheController/PrecacheCacheKeyPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheCacheKeyPlugin.d.ts","sourceRoot":"","sources":["../../../src/controllers/PrecacheController/PrecacheCacheKeyPlugin.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAA+B,MAAM,gBAAgB,CAAC;AAElF;;;;;GAKG;AACH,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;gBAE7C,EAAE,kBAAkB,EAAE,EAAE;QAAE,kBAAkB,EAAE,kBAAkB,CAAA;KAAE;IAI9E,kBAAkB,EAAE,cAAc,CAAC,oBAAoB,CAAC,CAOtD;CACH"}

package/dist/{legacy → controllers/PrecacheController}/PrecacheController.d.ts

@@ -1,119 +1,129 @@
-import type { Strategy } from "../lib/strategies/Strategy.js";
-import type { RouteHandlerCallback, SerwistPlugin } from "../types.js";
-import type { CleanupResult, InstallResult, PrecacheEntry } from "../types.js";
-interface PrecacheControllerOptions {
+import type { Strategy } from "../../lib/strategies/Strategy.js";
+import type { Controller, RouteHandlerCallback, UrlManipulation } from "../../types.js";
+import type { Serwist } from "../../Serwist.js";
+import type { PrecacheStrategyOptions } from "./PrecacheStrategy.js";
+export interface PrecacheEntry {
+    integrity?: string;
+    url: string;
+    revision?: string | null;
+}
+export interface PrecacheRouteOptions {
     /**
-     * The cache to use for precaching.
+     * Tells Serwist to check the precache for an entry whose URL is the request URL appended
+     * with the specified value. Only applies if the request URL ends with "/".
+     *
+     * @default "index.html"
      */
-    cacheName?: string;
+    directoryIndex?: string | null;
+    /**
+     * An array of `RegExp` objects matching search params that should be removed when looking
+     * for a precache match.
+     */
+    ignoreURLParametersMatching?: RegExp[];
+    /**
+     * Tells Serwist to check the precache for an entry whose URL is the request URL appended
+     * with ".html".
+     *
+     * @default true
+     */
+    cleanURLs?: boolean;
+    /**
+     * A function that should take a URL and return an array of alternative URLs that should
+     * be checked for precache matches.
+     */
+    urlManipulation?: UrlManipulation;
+}
+export interface PrecacheControllerOptions {
     /**
-     * Plugins to use when precaching as well as responding to fetch
-     * events for precached assets.
+     * The cache to use for precaching.
      */
-    plugins?: SerwistPlugin[];
+    cacheName?: string;
     /**
-     * Whether to attempt to get the response from the network if there's
-     * a precache miss.
+     * Whether outdated caches should be removed.
+     *
+     * @default false
      */
-    fallbackToNetwork?: boolean;
+    cleanupOutdatedCaches?: boolean;
     /**
      * The number of precache requests that should be made concurrently.
      *
-     * @default 1
+     * @default 10
      */
-    concurrentPrecaching?: number;
+    concurrency?: number;
+    /**
+     * An URL that should point to a HTML file with which navigation requests for URLs that aren't
+     * precached will be fulfilled.
+     */
+    navigateFallback?: string;
+    /**
+     * URLs that should be allowed to use the `navigateFallback` handler.
+     */
+    navigateFallbackAllowlist?: RegExp[];
+    /**
+     * URLs that should not be allowed to use the `navigateFallback` handler. This takes precedence
+     * over `navigateFallbackAllowlist`.
+     */
+    navigateFallbackDenylist?: RegExp[];
 }
-/**
- * Performs efficient precaching of assets.
- * @deprecated
- */
-export declare class PrecacheController {
-    private _installAndActiveListenersAdded?;
-    private _concurrentPrecaching;
-    private readonly _strategy;
+export interface PrecacheOptions extends PrecacheStrategyOptions, PrecacheRouteOptions, PrecacheControllerOptions {
+}
+export declare class PrecacheController implements Controller {
     private readonly _urlsToCacheKeys;
     private readonly _urlsToCacheModes;
     private readonly _cacheKeysToIntegrities;
+    private readonly _strategy;
+    private _options;
+    private _routeOptions;
     /**
      * Create a new PrecacheController.
      *
      * @param options
      */
-    constructor({ cacheName, plugins, fallbackToNetwork, concurrentPrecaching }?: PrecacheControllerOptions);
+    constructor(entries: (PrecacheEntry | string)[], precacheOptions?: PrecacheOptions);
     /**
      * The strategy created by this controller and
      * used to cache assets and respond to `fetch` events.
      */
     get strategy(): Strategy;
     /**
-     * Adds items to the precache list, removing any duplicates and
-     * stores the files in the precache cache when the service
-     * worker installs.
-     *
-     * This method can be called multiple times.
-     *
-     * @param entries Array of entries to precache.
-     */
-    precache(entries: (PrecacheEntry | string)[]): void;
-    /**
-     * This method will add items to the precache list, removing duplicates
-     * and ensuring the information is valid.
+     * Adds items to the cache list, removing duplicates and ensuring the information is valid.
      *
      * @param entries Array of entries to precache.
      */
     addToCacheList(entries: (PrecacheEntry | string)[]): void;
-    /**
-     * Precaches new and updated assets. Call this method from the service worker
-     * install event.
-     *
-     * Note: this method calls `event.waitUntil()` for you, so you do not need
-     * to call it yourself in your event handlers.
-     *
-     * @param event
-     * @returns
-     */
-    install(event: ExtendableEvent): Promise<InstallResult>;
-    /**
-     * Deletes assets that are no longer present in the current precache manifest.
-     * Call this method from the service worker activate event.
-     *
-     * Note: this method calls `event.waitUntil()` for you, so you do not need
-     * to call it yourself in your event handlers.
-     *
-     * @param event
-     * @returns
-     */
-    activate(event: ExtendableEvent): Promise<CleanupResult>;
+    init(serwist: Serwist): void;
+    install(event: ExtendableEvent): Promise<void>;
+    activate(): Promise<void>;
     /**
      * Returns a mapping of a precached URL to the corresponding cache key, taking
      * into account the revision information for the URL.
      *
      * @returns A URL to cache key mapping.
      */
-    getURLsToCacheKeys(): Map<string, string>;
+    getUrlsToPrecacheKeys(): Map<string, string>;
     /**
      * Returns a list of all the URLs that have been precached by the current
      * service worker.
      *
      * @returns The precached URLs.
      */
-    getCachedURLs(): string[];
+    getPrecachedUrls(): string[];
     /**
      * Returns the cache key used for storing a given URL. If that URL is
-     * unversioned, like `/index.html', then the cache key will be the original
+     * unversioned, like "/index.html", then the cache key will be the original
      * URL with a search parameter appended to it.
      *
      * @param url A URL whose cache key you want to look up.
      * @returns The versioned URL that corresponds to a cache key
      * for the original URL, or undefined if that URL isn't precached.
      */
-    getCacheKeyForURL(url: string): string | undefined;
+    getPrecacheKeyForUrl(url: string): string | undefined;
     /**
      * @param url A cache key whose SRI you want to look up.
      * @returns The subresource integrity associated with the cache key,
      * or undefined if it's not set.
      */
-    getIntegrityForCacheKey(cacheKey: string): string | undefined;
+    getIntegrityForPrecacheKey(cacheKey: string): string | undefined;
     /**
      * This acts as a drop-in replacement for
      * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)
@@ -140,7 +150,6 @@ export declare class PrecacheController {
      * @param url The precached URL which will be used to lookup the response.
      * @return
      */
-    createHandlerBoundToURL(url: string): RouteHandlerCallback;
+    createHandlerBoundToUrl(url: string): RouteHandlerCallback;
 }
-export {};
 //# sourceMappingURL=PrecacheController.d.ts.map

package/dist/controllers/PrecacheController/PrecacheController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheController.d.ts","sourceRoot":"","sources":["../../../src/controllers/PrecacheController/PrecacheController.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAUxF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAGrE,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,2BAA2B,CAAC,EAAE,MAAM,EAAE,CAAC;IACvC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAED,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;OAEG;IACH,yBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC;IACrC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,eAAgB,SAAQ,uBAAuB,EAAE,oBAAoB,EAAE,yBAAyB;CAAG;AAEpH,qBAAa,kBAAmB,YAAW,UAAU;IACnD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6G;IAC/I,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAkC;IAC1E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,aAAa,CAAuB;IAC5C;;;;OAIG;gBACS,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,EAAE,eAAe;IAUlF;;;OAGG;IACH,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IACD;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAuDzD,IAAI,CAAC,OAAO,EAAE,OAAO;IAYf,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B9C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB/B;;;;;OAKG;IACH,qBAAqB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI5C;;;;;OAKG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAI5B;;;;;;;;OAQG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKrD;;;;OAIG;IACH,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIhE;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAU7E;;;;;;OAMG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB;CAY3D"}

package/dist/controllers/PrecacheController/PrecacheInstallReportPlugin.d.ts

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