@serwist/core 8.0.0

package/dist/index.old.cjs

@@ -0,0 +1,577 @@
+'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$1 = {
+    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;
+    }
+};
+
+/**
+ * Get the current cache names and prefix/suffix used by Workbox.
+ *
+ * `cacheNames.precache` is used for precached assets,
+ * `cacheNames.googleAnalytics` is used by `@serwist/google-analytics` to
+ * store `analytics.js`, and `cacheNames.runtime` is used for everything else.
+ *
+ * `cacheNames.prefix` can be used to retrieve just the current prefix value.
+ * `cacheNames.suffix` can be used to retrieve just the current suffix value.
+ *
+ * @returns An object with `precache`, `runtime`, `prefix`, and `googleAnalytics` properties.
+ */ const cacheNames = {
+    get googleAnalytics () {
+        return cacheNames$1.getGoogleAnalyticsName();
+    },
+    get precache () {
+        return cacheNames$1.getPrecacheName();
+    },
+    get prefix () {
+        return cacheNames$1.getPrefix();
+    },
+    get runtime () {
+        return cacheNames$1.getRuntimeName();
+    },
+    get suffix () {
+        return cacheNames$1.getSuffix();
+    }
+};
+
+/*
+  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.
+*/ // Give TypeScript the correct global.
+/**
+ * Claim any currently available clients once the service worker
+ * becomes active. This is normally used in conjunction with `skipWaiting()`.
+ */ function clientsClaim() {
+    self.addEventListener("activate", ()=>self.clients.claim());
+}
+
+/*
+  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.
+*/ 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/precaching.PrecacheController.addToCacheList()' 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/precaching.PrecacheController.addToCacheList()' 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 plugins '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 backgroundSync.Queue 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/precaching.PrecacheController.addToCacheList()' 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;
+
+/**
+ * Serwist errors should be thrown with this class.
+ * This allows use to ensure the type easily in tests,
+ * helps developers identify errors from Serwist
+ * easily and allows use to optimise error
+ * messages correctly.
+ *
+ * @private
+ */ class SerwistError extends Error {
+    details;
+    /**
+   *
+   * @param errorCode The error code that
+   * identifies this particular error.
+   * @param details Any relevant arguments
+   * that will help developers identify issues should
+   * be added as a key on the context object.
+   */ constructor(errorCode, details){
+        const message = messageGenerator(errorCode, details);
+        super(message);
+        this.name = errorCode;
+        this.details = details;
+    }
+}
+
+/**
+ * Allows developers to copy a response and modify its `headers`, `status`,
+ * or `statusText` values (the values settable via a
+ * [`ResponseInit`](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax)
+ * object in the constructor).
+ * To modify these values, pass a function as the second argument. That
+ * function will be invoked with a single object with the response properties
+ * `{headers, status, statusText}`. The return value of this function will
+ * be used as the `ResponseInit` for the new `Response`. To change the values
+ * either modify the passed parameter(s) and return it, or return a totally
+ * new object.
+ *
+ * This method is intentionally limited to same-origin responses, regardless of
+ * whether CORS was used or not.
+ *
+ * @param response
+ * @param modifier
+ */ async function copyResponse(response, modifier) {
+    let origin = null;
+    // If response.url isn't set, assume it's cross-origin and keep origin null.
+    if (response.url) {
+        const responseURL = new URL(response.url);
+        origin = responseURL.origin;
+    }
+    if (origin !== self.location.origin) {
+        throw new SerwistError("cross-origin-copy-response", {
+            origin
+        });
+    }
+    const clonedResponse = response.clone();
+    // Create a fresh `ResponseInit` object by cloning the headers.
+    const responseInit = {
+        headers: new Headers(clonedResponse.headers),
+        status: clonedResponse.status,
+        statusText: clonedResponse.statusText
+    };
+    // Apply any user modifications.
+    const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;
+    // Create the new response from the body stream and `ResponseInit`
+    // modifications. Note: not all browsers support the Response.body stream,
+    // so fall back to reading the entire body into memory as a blob.
+    const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob();
+    return new Response(body, modifiedResponseInit);
+}
+
+/*
+ * This method throws if the supplied value is not an array.
+ * The destructed values are required to produce a meaningful error for users.
+ * The destructed and restructured object is so it's clear what is
+ * needed.
+ */ 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, // Need the general type to do the check later.
+// eslint-disable-next-line @typescript-eslint/ban-types
+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, // Need general type to do check later.
+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
+};
+
+/*
+  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.
+*/ // logger is used inside of both service workers and the window global scope.
+const logger = process.env.NODE_ENV === "production" ? null : (()=>{
+    // Don't overwrite this value if it's already set.
+    // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923
+    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 = function(method, args) {
+        if (self.__WB_DISABLE_DEV_LOGS) {
+            return;
+        }
+        if (method === "groupCollapsed") {
+            // Safari doesn't print all console.groupCollapsed() arguments:
+            // https://bugs.webkit.org/show_bug.cgi?id=182754
+            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`
+        ];
+        // When in a group, the serwist prefix is not displayed.
+        const logPrefix = inGroup ? [] : [
+            "%cserwist",
+            styles.join(";")
+        ];
+        console[method](...logPrefix, ...args);
+        if (method === "groupCollapsed") {
+            inGroup = true;
+        }
+        if (method === "groupEnd") {
+            inGroup = false;
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    const api = {};
+    const loggerMethods = Object.keys(methodToColorMap);
+    for (const key of loggerMethods){
+        const method = key;
+        api[method] = (...args)=>{
+            print(method, args);
+        };
+    }
+    return api;
+})();
+
+/*
+  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.
+*/ // Callbacks to be executed whenever there's a quota error.
+// Can't change Function type right now.
+// eslint-disable-next-line @typescript-eslint/ban-types
+const quotaErrorCallbacks = new Set();
+
+/**
+ * Adds a function to the set of quotaErrorCallbacks that will be executed if
+ * there's a quota error.
+ *
+ * @param callback
+ */ // Can't change Function type
+// eslint-disable-next-line @typescript-eslint/ban-types
+function registerQuotaErrorCallback(callback) {
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(callback, "function", {
+            moduleName: "@serwist/core",
+            funcName: "register",
+            paramName: "callback"
+        });
+    }
+    quotaErrorCallbacks.add(callback);
+    if (process.env.NODE_ENV !== "production") {
+        logger.log("Registered a callback to respond to quota errors.", callback);
+    }
+}
+
+/**
+ * Modifies the default cache names used by the Serwist packages.
+ * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
+ *
+ * @param details
+ */ function setCacheNameDetails(details) {
+    if (process.env.NODE_ENV !== "production") {
+        Object.keys(details).forEach((key)=>{
+            finalAssertExports.isType(details[key], "string", {
+                moduleName: "@serwist/core",
+                funcName: "setCacheNameDetails",
+                paramName: `details.${key}`
+            });
+        });
+        if (details["precache"]?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "precache",
+                value: details["precache"]
+            });
+        }
+        if (details["runtime"]?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "runtime",
+                value: details["runtime"]
+            });
+        }
+        if (details["googleAnalytics"]?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "googleAnalytics",
+                value: details["googleAnalytics"]
+            });
+        }
+    }
+    cacheNames$1.updateDetails(details);
+}
+
+exports.cacheNames = cacheNames;
+exports.clientsClaim = clientsClaim;
+exports.copyResponse = copyResponse;
+exports.registerQuotaErrorCallback = registerQuotaErrorCallback;
+exports.setCacheNameDetails = setCacheNameDetails;

package/dist/models/messages/messageGenerator.d.ts

@@ -0,0 +1,2 @@
+export declare const messageGenerator: ((code: string, ...args: any[]) => string) | ((code: string, details?: {}) => string);
+//# sourceMappingURL=messageGenerator.d.ts.map

package/dist/models/messages/messageGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageGenerator.d.ts","sourceRoot":"","sources":["../../../src/models/messages/messageGenerator.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,gBAAgB,UAjBL,MAAM,WAAW,GAAG,EAAE,uBAQb,MAAM,0BAS6D,CAAC"}

package/dist/models/messages/messages.d.ts

@@ -0,0 +1,9 @@
+interface LoggableObject {
+    [key: string]: string | number;
+}
+interface MessageMap {
+    [messageID: string]: (param: LoggableObject) => string;
+}
+export declare const messages: MessageMap;
+export {};
+//# sourceMappingURL=messages.d.ts.map

package/dist/models/messages/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/models/messages/messages.ts"],"names":[],"mappings":"AAQA,UAAU,cAAc;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CAChC;AACD,UAAU,UAAU;IAClB,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,MAAM,CAAC;CACxD;AAED,eAAO,MAAM,QAAQ,EAAE,UA2PtB,CAAC"}

package/dist/models/pluginEvents.d.ts

@@ -0,0 +1,10 @@
+export declare const enum pluginEvents {
+    CACHE_DID_UPDATE = "cacheDidUpdate",
+    CACHE_KEY_WILL_BE_USED = "cacheKeyWillBeUsed",
+    CACHE_WILL_UPDATE = "cacheWillUpdate",
+    CACHED_RESPONSE_WILL_BE_USED = "cachedResponseWillBeUsed",
+    FETCH_DID_FAIL = "fetchDidFail",
+    FETCH_DID_SUCCEED = "fetchDidSucceed",
+    REQUEST_WILL_FETCH = "requestWillFetch"
+}
+//# sourceMappingURL=pluginEvents.d.ts.map

package/dist/models/pluginEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluginEvents.d.ts","sourceRoot":"","sources":["../../src/models/pluginEvents.ts"],"names":[],"mappings":"AAQA,0BAAkB,YAAY;IAC5B,gBAAgB,mBAAmB;IACnC,sBAAsB,uBAAuB;IAC7C,iBAAiB,oBAAoB;IACrC,4BAA4B,6BAA6B;IACzD,cAAc,iBAAiB;IAC/B,iBAAiB,oBAAoB;IACrC,kBAAkB,qBAAqB;CACxC"}

package/dist/models/quotaErrorCallbacks.d.ts

@@ -0,0 +1,3 @@
+declare const quotaErrorCallbacks: Set<Function>;
+export { quotaErrorCallbacks };
+//# sourceMappingURL=quotaErrorCallbacks.d.ts.map

package/dist/models/quotaErrorCallbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quotaErrorCallbacks.d.ts","sourceRoot":"","sources":["../../src/models/quotaErrorCallbacks.ts"],"names":[],"mappings":"AAWA,QAAA,MAAM,mBAAmB,EAAE,GAAG,CAAC,QAAQ,CAAa,CAAC;AAErD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/registerQuotaErrorCallback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Adds a function to the set of quotaErrorCallbacks that will be executed if
+ * there's a quota error.
+ *
+ * @param callback
+ */
+declare function registerQuotaErrorCallback(callback: Function): void;
+export { registerQuotaErrorCallback };
+//# sourceMappingURL=registerQuotaErrorCallback.d.ts.map

package/dist/registerQuotaErrorCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerQuotaErrorCallback.d.ts","sourceRoot":"","sources":["../src/registerQuotaErrorCallback.ts"],"names":[],"mappings":"AAYA;;;;;GAKG;AAGH,iBAAS,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAc5D;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/setCacheNameDetails.d.ts

@@ -0,0 +1,10 @@
+import type { PartialCacheNameDetails } from "./_private/cacheNames.js";
+/**
+ * Modifies the default cache names used by the Serwist packages.
+ * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
+ *
+ * @param details
+ */
+declare function setCacheNameDetails(details: PartialCacheNameDetails): void;
+export { setCacheNameDetails };
+//# sourceMappingURL=setCacheNameDetails.d.ts.map

package/dist/setCacheNameDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setCacheNameDetails.d.ts","sourceRoot":"","sources":["../src/setCacheNameDetails.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAIxE;;;;;GAKG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAiCnE;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}