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

package/dist/index.plugins.js

@@ -0,0 +1,671 @@
+export { B as BackgroundSyncPlugin, Q as BackgroundSyncQueue, a as BackgroundSyncQueueStore, P as PrecacheFallbackPlugin, S as StorableRequest, i as initializeGoogleAnalytics } from './chunks/PrecacheFallbackPlugin.js';
+import { SerwistError, logger, assert, resultingClientExists, timeout, getFriendlyURL, privateCacheNames } from '@serwist/core/internal';
+import { deleteDB, openDB } from 'idb';
+import { registerQuotaErrorCallback } from '@serwist/core';
+import './chunks/singletonRouter.js';
+import './chunks/NetworkOnly.js';
+import './chunks/Strategy.js';
+import './chunks/singletonPrecacheController.js';
+
+const CACHE_UPDATED_MESSAGE_TYPE = "CACHE_UPDATED";
+const CACHE_UPDATED_MESSAGE_META = "serwist-broadcast-update";
+const defaultNotifyAllClients = true;
+const defaultHeadersToCheck = [
+    "content-length",
+    "etag",
+    "last-modified"
+];
+
+const responsesAreSame = (firstResponse, secondResponse, headersToCheck)=>{
+    if (process.env.NODE_ENV !== "production") {
+        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
+            throw new SerwistError("invalid-responses-are-same-args");
+        }
+    }
+    const atLeastOneHeaderAvailable = headersToCheck.some((header)=>{
+        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
+    });
+    if (!atLeastOneHeaderAvailable) {
+        if (process.env.NODE_ENV !== "production") {
+            logger.warn("Unable to determine where the response has been updated because none of the headers that would be checked are present.");
+            logger.debug("Attempting to compare the following: ", firstResponse, secondResponse, headersToCheck);
+        }
+        return true;
+    }
+    return headersToCheck.every((header)=>{
+        const headerStateComparison = firstResponse.headers.has(header) === secondResponse.headers.has(header);
+        const headerValueComparison = firstResponse.headers.get(header) === secondResponse.headers.get(header);
+        return headerStateComparison && headerValueComparison;
+    });
+};
+
+const isSafari = typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+const defaultPayloadGenerator = (data)=>{
+    return {
+        cacheName: data.cacheName,
+        updatedURL: data.request.url
+    };
+};
+class BroadcastCacheUpdate {
+    _headersToCheck;
+    _generatePayload;
+    _notifyAllClients;
+    constructor({ generatePayload, headersToCheck, notifyAllClients } = {}){
+        this._headersToCheck = headersToCheck || defaultHeadersToCheck;
+        this._generatePayload = generatePayload || defaultPayloadGenerator;
+        this._notifyAllClients = notifyAllClients ?? defaultNotifyAllClients;
+    }
+    async notifyIfUpdated(options) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(options.cacheName, "string", {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "cacheName"
+            });
+            assert.isInstance(options.newResponse, Response, {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "newResponse"
+            });
+            assert.isInstance(options.request, Request, {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "request"
+            });
+        }
+        if (!options.oldResponse) {
+            return;
+        }
+        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.log("Newer response found (and cached) for:", options.request.url);
+            }
+            const messageData = {
+                type: CACHE_UPDATED_MESSAGE_TYPE,
+                meta: CACHE_UPDATED_MESSAGE_META,
+                payload: this._generatePayload(options)
+            };
+            if (options.request.mode === "navigate") {
+                let resultingClientId;
+                if (options.event instanceof FetchEvent) {
+                    resultingClientId = options.event.resultingClientId;
+                }
+                const resultingWin = await resultingClientExists(resultingClientId);
+                if (!resultingWin || isSafari) {
+                    await timeout(3500);
+                }
+            }
+            if (this._notifyAllClients) {
+                const windows = await self.clients.matchAll({
+                    type: "window"
+                });
+                for (const win of windows){
+                    win.postMessage(messageData);
+                }
+            } else {
+                if (options.event instanceof FetchEvent) {
+                    const client = await self.clients.get(options.event.clientId);
+                    client?.postMessage(messageData);
+                }
+            }
+        }
+    }
+}
+
+class BroadcastUpdatePlugin {
+    _broadcastUpdate;
+    constructor(options){
+        this._broadcastUpdate = new BroadcastCacheUpdate(options);
+    }
+    cacheDidUpdate(options) {
+        void this._broadcastUpdate.notifyIfUpdated(options);
+    }
+}
+
+class CacheableResponse {
+    _statuses;
+    _headers;
+    constructor(config = {}){
+        if (process.env.NODE_ENV !== "production") {
+            if (!(config.statuses || config.headers)) {
+                throw new SerwistError("statuses-or-headers-required", {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor"
+                });
+            }
+            if (config.statuses) {
+                assert.isArray(config.statuses, {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.statuses"
+                });
+            }
+            if (config.headers) {
+                assert.isType(config.headers, "object", {
+                    moduleName: "@serwist/cacheable-response",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.headers"
+                });
+            }
+        }
+        this._statuses = config.statuses;
+        if (config.headers) {
+            this._headers = new Headers(config.headers);
+        }
+    }
+    isResponseCacheable(response) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isInstance(response, Response, {
+                moduleName: "@serwist/cacheable-response",
+                className: "CacheableResponse",
+                funcName: "isResponseCacheable",
+                paramName: "response"
+            });
+        }
+        let cacheable = true;
+        if (this._statuses) {
+            cacheable = this._statuses.includes(response.status);
+        }
+        if (this._headers && cacheable) {
+            for (const [headerName, headerValue] of this._headers.entries()){
+                if (response.headers.get(headerName) !== headerValue) {
+                    cacheable = false;
+                    break;
+                }
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            if (!cacheable) {
+                logger.groupCollapsed(`The request for '${getFriendlyURL(response.url)}' returned a response that does not meet the criteria for being cached.`);
+                logger.groupCollapsed("View cacheability criteria here.");
+                logger.log(`Cacheable statuses: ${JSON.stringify(this._statuses)}`);
+                logger.log(`Cacheable headers: ${JSON.stringify(this._headers, null, 2)}`);
+                logger.groupEnd();
+                const logFriendlyHeaders = {};
+                response.headers.forEach((value, key)=>{
+                    logFriendlyHeaders[key] = value;
+                });
+                logger.groupCollapsed("View response status and headers here.");
+                logger.log(`Response status: ${response.status}`);
+                logger.log(`Response headers: ${JSON.stringify(logFriendlyHeaders, null, 2)}`);
+                logger.groupEnd();
+                logger.groupCollapsed("View full response details here.");
+                logger.log(response.headers);
+                logger.log(response);
+                logger.groupEnd();
+                logger.groupEnd();
+            }
+        }
+        return cacheable;
+    }
+}
+
+class CacheableResponsePlugin {
+    _cacheableResponse;
+    constructor(config){
+        this._cacheableResponse = new CacheableResponse(config);
+    }
+    cacheWillUpdate = async ({ response })=>{
+        if (this._cacheableResponse.isResponseCacheable(response)) {
+            return response;
+        }
+        return null;
+    };
+}
+
+const DB_NAME = "serwist-expiration";
+const CACHE_OBJECT_STORE = "cache-entries";
+const normalizeURL = (unNormalizedUrl)=>{
+    const url = new URL(unNormalizedUrl, location.href);
+    url.hash = "";
+    return url.href;
+};
+class CacheTimestampsModel {
+    _cacheName;
+    _db = null;
+    constructor(cacheName){
+        this._cacheName = cacheName;
+    }
+    _getId(url) {
+        return `${this._cacheName}|${normalizeURL(url)}`;
+    }
+    _upgradeDb(db) {
+        const objStore = db.createObjectStore(CACHE_OBJECT_STORE, {
+            keyPath: "id"
+        });
+        objStore.createIndex("cacheName", "cacheName", {
+            unique: false
+        });
+        objStore.createIndex("timestamp", "timestamp", {
+            unique: false
+        });
+    }
+    _upgradeDbAndDeleteOldDbs(db) {
+        this._upgradeDb(db);
+        if (this._cacheName) {
+            void deleteDB(this._cacheName);
+        }
+    }
+    async setTimestamp(url, timestamp) {
+        url = normalizeURL(url);
+        const entry = {
+            id: this._getId(url),
+            cacheName: this._cacheName,
+            url,
+            timestamp
+        };
+        const db = await this.getDb();
+        const tx = db.transaction(CACHE_OBJECT_STORE, "readwrite", {
+            durability: "relaxed"
+        });
+        await tx.store.put(entry);
+        await tx.done;
+    }
+    async getTimestamp(url) {
+        const db = await this.getDb();
+        const entry = await db.get(CACHE_OBJECT_STORE, this._getId(url));
+        return entry?.timestamp;
+    }
+    async expireEntries(minTimestamp, maxCount) {
+        const db = await this.getDb();
+        let cursor = await db.transaction(CACHE_OBJECT_STORE, "readwrite").store.index("timestamp").openCursor(null, "prev");
+        const urlsDeleted = [];
+        let entriesNotDeletedCount = 0;
+        while(cursor){
+            const result = cursor.value;
+            if (result.cacheName === this._cacheName) {
+                if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) {
+                    cursor.delete();
+                    urlsDeleted.push(result.url);
+                } else {
+                    entriesNotDeletedCount++;
+                }
+            }
+            cursor = await cursor.continue();
+        }
+        return urlsDeleted;
+    }
+    async getDb() {
+        if (!this._db) {
+            this._db = await openDB(DB_NAME, 1, {
+                upgrade: this._upgradeDbAndDeleteOldDbs.bind(this)
+            });
+        }
+        return this._db;
+    }
+}
+
+class CacheExpiration {
+    _isRunning = false;
+    _rerunRequested = false;
+    _maxEntries;
+    _maxAgeSeconds;
+    _matchOptions;
+    _cacheName;
+    _timestampModel;
+    constructor(cacheName, config = {}){
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(cacheName, "string", {
+                moduleName: "@serwist/expiration",
+                className: "CacheExpiration",
+                funcName: "constructor",
+                paramName: "cacheName"
+            });
+            if (!(config.maxEntries || config.maxAgeSeconds)) {
+                throw new SerwistError("max-entries-or-age-required", {
+                    moduleName: "@serwist/expiration",
+                    className: "CacheExpiration",
+                    funcName: "constructor"
+                });
+            }
+            if (config.maxEntries) {
+                assert.isType(config.maxEntries, "number", {
+                    moduleName: "@serwist/expiration",
+                    className: "CacheExpiration",
+                    funcName: "constructor",
+                    paramName: "config.maxEntries"
+                });
+            }
+            if (config.maxAgeSeconds) {
+                assert.isType(config.maxAgeSeconds, "number", {
+                    moduleName: "@serwist/expiration",
+                    className: "CacheExpiration",
+                    funcName: "constructor",
+                    paramName: "config.maxAgeSeconds"
+                });
+            }
+        }
+        this._maxEntries = config.maxEntries;
+        this._maxAgeSeconds = config.maxAgeSeconds;
+        this._matchOptions = config.matchOptions;
+        this._cacheName = cacheName;
+        this._timestampModel = new CacheTimestampsModel(cacheName);
+    }
+    async expireEntries() {
+        if (this._isRunning) {
+            this._rerunRequested = true;
+            return;
+        }
+        this._isRunning = true;
+        const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : 0;
+        const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries);
+        const cache = await self.caches.open(this._cacheName);
+        for (const url of urlsExpired){
+            await cache.delete(url, this._matchOptions);
+        }
+        if (process.env.NODE_ENV !== "production") {
+            if (urlsExpired.length > 0) {
+                logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? "entry" : "entries"} and removed ` + `${urlsExpired.length === 1 ? "it" : "them"} from the ` + `'${this._cacheName}' cache.`);
+                logger.log(`Expired the following ${urlsExpired.length === 1 ? "URL" : "URLs"}:`);
+                for (const url of urlsExpired){
+                    logger.log(`    ${url}`);
+                }
+                logger.groupEnd();
+            } else {
+                logger.debug("Cache expiration ran and found no entries to remove.");
+            }
+        }
+        this._isRunning = false;
+        if (this._rerunRequested) {
+            this._rerunRequested = false;
+            void this.expireEntries();
+        }
+    }
+    async updateTimestamp(url) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(url, "string", {
+                moduleName: "@serwist/expiration",
+                className: "CacheExpiration",
+                funcName: "updateTimestamp",
+                paramName: "url"
+            });
+        }
+        await this._timestampModel.setTimestamp(url, Date.now());
+    }
+    async isURLExpired(url) {
+        if (!this._maxAgeSeconds) {
+            if (process.env.NODE_ENV !== "production") {
+                throw new SerwistError("expired-test-without-max-age", {
+                    methodName: "isURLExpired",
+                    paramName: "maxAgeSeconds"
+                });
+            }
+            return false;
+        }
+        const timestamp = await this._timestampModel.getTimestamp(url);
+        const expireOlderThan = Date.now() - this._maxAgeSeconds * 1000;
+        return timestamp !== undefined ? timestamp < expireOlderThan : true;
+    }
+    async delete() {
+        this._rerunRequested = false;
+        await this._timestampModel.expireEntries(Number.POSITIVE_INFINITY);
+    }
+}
+
+class ExpirationPlugin {
+    _config;
+    _cacheExpirations;
+    constructor(config = {}){
+        if (process.env.NODE_ENV !== "production") {
+            if (!(config.maxEntries || config.maxAgeSeconds)) {
+                throw new SerwistError("max-entries-or-age-required", {
+                    moduleName: "@serwist/expiration",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor"
+                });
+            }
+            if (config.maxEntries) {
+                assert.isType(config.maxEntries, "number", {
+                    moduleName: "@serwist/expiration",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor",
+                    paramName: "config.maxEntries"
+                });
+            }
+            if (config.maxAgeSeconds) {
+                assert.isType(config.maxAgeSeconds, "number", {
+                    moduleName: "@serwist/expiration",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor",
+                    paramName: "config.maxAgeSeconds"
+                });
+            }
+            if (config.maxAgeFrom) {
+                assert.isType(config.maxAgeFrom, "string", {
+                    moduleName: "@serwist/expiration",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor",
+                    paramName: "config.maxAgeFrom"
+                });
+            }
+        }
+        this._config = config;
+        this._cacheExpirations = new Map();
+        if (!this._config.maxAgeFrom) {
+            this._config.maxAgeFrom = "last-fetched";
+        }
+        if (this._config.purgeOnQuotaError) {
+            registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata());
+        }
+    }
+    _getCacheExpiration(cacheName) {
+        if (cacheName === privateCacheNames.getRuntimeName()) {
+            throw new SerwistError("expire-custom-caches-only");
+        }
+        let cacheExpiration = this._cacheExpirations.get(cacheName);
+        if (!cacheExpiration) {
+            cacheExpiration = new CacheExpiration(cacheName, this._config);
+            this._cacheExpirations.set(cacheName, cacheExpiration);
+        }
+        return cacheExpiration;
+    }
+    cachedResponseWillBeUsed({ event, cacheName, request, cachedResponse }) {
+        if (!cachedResponse) {
+            return null;
+        }
+        const isFresh = this._isResponseDateFresh(cachedResponse);
+        const cacheExpiration = this._getCacheExpiration(cacheName);
+        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
+        const done = (async ()=>{
+            if (isMaxAgeFromLastUsed) {
+                await cacheExpiration.updateTimestamp(request.url);
+            }
+            await cacheExpiration.expireEntries();
+        })();
+        try {
+            event.waitUntil(done);
+        } catch (error) {
+            if (process.env.NODE_ENV !== "production") {
+                if (event instanceof FetchEvent) {
+                    logger.warn(`Unable to ensure service worker stays alive when updating cache entry for '${getFriendlyURL(event.request.url)}'.`);
+                }
+            }
+        }
+        return isFresh ? cachedResponse : null;
+    }
+    _isResponseDateFresh(cachedResponse) {
+        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
+        if (isMaxAgeFromLastUsed) {
+            return true;
+        }
+        const now = Date.now();
+        if (!this._config.maxAgeSeconds) {
+            return true;
+        }
+        const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
+        if (dateHeaderTimestamp === null) {
+            return true;
+        }
+        return dateHeaderTimestamp >= now - this._config.maxAgeSeconds * 1000;
+    }
+    _getDateHeaderTimestamp(cachedResponse) {
+        if (!cachedResponse.headers.has("date")) {
+            return null;
+        }
+        const dateHeader = cachedResponse.headers.get("date");
+        const parsedDate = new Date(dateHeader);
+        const headerTime = parsedDate.getTime();
+        if (Number.isNaN(headerTime)) {
+            return null;
+        }
+        return headerTime;
+    }
+    async cacheDidUpdate({ cacheName, request }) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(cacheName, "string", {
+                moduleName: "@serwist/expiration",
+                className: "Plugin",
+                funcName: "cacheDidUpdate",
+                paramName: "cacheName"
+            });
+            assert.isInstance(request, Request, {
+                moduleName: "@serwist/expiration",
+                className: "Plugin",
+                funcName: "cacheDidUpdate",
+                paramName: "request"
+            });
+        }
+        const cacheExpiration = this._getCacheExpiration(cacheName);
+        await cacheExpiration.updateTimestamp(request.url);
+        await cacheExpiration.expireEntries();
+    }
+    async deleteCacheAndMetadata() {
+        for (const [cacheName, cacheExpiration] of this._cacheExpirations){
+            await self.caches.delete(cacheName);
+            await cacheExpiration.delete();
+        }
+        this._cacheExpirations = new Map();
+    }
+}
+
+const calculateEffectiveBoundaries = (blob, start, end)=>{
+    if (process.env.NODE_ENV !== "production") {
+        assert.isInstance(blob, Blob, {
+            moduleName: "@serwist/range-requests",
+            funcName: "calculateEffectiveBoundaries",
+            paramName: "blob"
+        });
+    }
+    const blobSize = blob.size;
+    if (end && end > blobSize || start && start < 0) {
+        throw new SerwistError("range-not-satisfiable", {
+            size: blobSize,
+            end,
+            start
+        });
+    }
+    let effectiveStart;
+    let effectiveEnd;
+    if (start !== undefined && end !== undefined) {
+        effectiveStart = start;
+        effectiveEnd = end + 1;
+    } else if (start !== undefined && end === undefined) {
+        effectiveStart = start;
+        effectiveEnd = blobSize;
+    } else if (end !== undefined && start === undefined) {
+        effectiveStart = blobSize - end;
+        effectiveEnd = blobSize;
+    }
+    return {
+        start: effectiveStart,
+        end: effectiveEnd
+    };
+};
+
+const parseRangeHeader = (rangeHeader)=>{
+    if (process.env.NODE_ENV !== "production") {
+        assert.isType(rangeHeader, "string", {
+            moduleName: "@serwist/range-requests",
+            funcName: "parseRangeHeader",
+            paramName: "rangeHeader"
+        });
+    }
+    const normalizedRangeHeader = rangeHeader.trim().toLowerCase();
+    if (!normalizedRangeHeader.startsWith("bytes=")) {
+        throw new SerwistError("unit-must-be-bytes", {
+            normalizedRangeHeader
+        });
+    }
+    if (normalizedRangeHeader.includes(",")) {
+        throw new SerwistError("single-range-only", {
+            normalizedRangeHeader
+        });
+    }
+    const rangeParts = /(\d*)-(\d*)/.exec(normalizedRangeHeader);
+    if (!rangeParts || !(rangeParts[1] || rangeParts[2])) {
+        throw new SerwistError("invalid-range-values", {
+            normalizedRangeHeader
+        });
+    }
+    return {
+        start: rangeParts[1] === "" ? undefined : Number(rangeParts[1]),
+        end: rangeParts[2] === "" ? undefined : Number(rangeParts[2])
+    };
+};
+
+const createPartialResponse = async (request, originalResponse)=>{
+    try {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isInstance(request, Request, {
+                moduleName: "@serwist/range-requests",
+                funcName: "createPartialResponse",
+                paramName: "request"
+            });
+            assert.isInstance(originalResponse, Response, {
+                moduleName: "@serwist/range-requests",
+                funcName: "createPartialResponse",
+                paramName: "originalResponse"
+            });
+        }
+        if (originalResponse.status === 206) {
+            return originalResponse;
+        }
+        const rangeHeader = request.headers.get("range");
+        if (!rangeHeader) {
+            throw new SerwistError("no-range-header");
+        }
+        const boundaries = parseRangeHeader(rangeHeader);
+        const originalBlob = await originalResponse.blob();
+        const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end);
+        const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end);
+        const slicedBlobSize = slicedBlob.size;
+        const slicedResponse = new Response(slicedBlob, {
+            status: 206,
+            statusText: "Partial Content",
+            headers: originalResponse.headers
+        });
+        slicedResponse.headers.set("Content-Length", String(slicedBlobSize));
+        slicedResponse.headers.set("Content-Range", `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` + `${originalBlob.size}`);
+        return slicedResponse;
+    } catch (error) {
+        if (process.env.NODE_ENV !== "production") {
+            logger.warn("Unable to construct a partial response; returning a " + "416 Range Not Satisfiable response instead.");
+            logger.groupCollapsed("View details here.");
+            logger.log(error);
+            logger.log(request);
+            logger.log(originalResponse);
+            logger.groupEnd();
+        }
+        return new Response("", {
+            status: 416,
+            statusText: "Range Not Satisfiable"
+        });
+    }
+};
+
+class RangeRequestsPlugin {
+    cachedResponseWillBeUsed = async ({ request, cachedResponse })=>{
+        if (cachedResponse && request.headers.has("range")) {
+            return await createPartialResponse(request, cachedResponse);
+        }
+        return cachedResponse;
+    };
+}
+
+export { defaultHeadersToCheck as BROADCAST_UPDATE_DEFAULT_HEADERS, CACHE_UPDATED_MESSAGE_META as BROADCAST_UPDATE_MESSAGE_META, CACHE_UPDATED_MESSAGE_TYPE as BROADCAST_UPDATE_MESSAGE_TYPE, BroadcastCacheUpdate, BroadcastUpdatePlugin, CacheExpiration, CacheableResponse, CacheableResponsePlugin, ExpirationPlugin, RangeRequestsPlugin, createPartialResponse, responsesAreSame };

package/dist/index.precaching.d.ts

@@ -0,0 +1,25 @@
+import { PrecacheController } from "./precaching/PrecacheController.js";
+import { PrecacheRoute } from "./precaching/PrecacheRoute.js";
+import { PrecacheStrategy } from "./precaching/PrecacheStrategy.js";
+import { addPlugins } from "./precaching/addPlugins.js";
+import { addRoute } from "./precaching/addRoute.js";
+import { cleanupOutdatedCaches } from "./precaching/cleanupOutdatedCaches.js";
+import { createHandlerBoundToURL } from "./precaching/createHandlerBoundToURL.js";
+import { getCacheKeyForURL } from "./precaching/getCacheKeyForURL.js";
+import { matchPrecache } from "./precaching/matchPrecache.js";
+import { precache } from "./precaching/precache.js";
+import { precacheAndRoute } from "./precaching/precacheAndRoute.js";
+import { getSingletonPrecacheController, setSingletonPrecacheController } from "./precaching/singletonPrecacheController.js";
+/**
+ * Most consumers of this module will want to use the
+ * `@serwist/sw/precaching.precacheAndRoute`
+ * method to add assets to the cache and respond to network requests with these
+ * cached assets.
+ *
+ * If you require more control over caching and routing, you can use the
+ * `@serwist/precaching.PrecacheController`
+ * interface.
+ */
+export { addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute, PrecacheController, PrecacheRoute, PrecacheStrategy, getSingletonPrecacheController, setSingletonPrecacheController, };
+export type * from "./precaching/types.js";
+//# sourceMappingURL=index.precaching.d.ts.map