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

package/dist/chunks/Strategy.js

@@ -1,410 +0,0 @@
-import { assert, Deferred, logger, getFriendlyURL, SerwistError, timeout, cacheMatchIgnoreParams, executeQuotaErrorCallbacks, privateCacheNames } from '@serwist/core/internal';
-
-function toRequest(input) {
-    return typeof input === "string" ? new Request(input) : input;
-}
-class StrategyHandler {
-    event;
-    request;
-    url;
-    params;
-    _cacheKeys = {};
-    _strategy;
-    _handlerDeferred;
-    _extendLifetimePromises;
-    _plugins;
-    _pluginStateMap;
-    constructor(strategy, options){
-        if (process.env.NODE_ENV !== "production") {
-            assert.isInstance(options.event, ExtendableEvent, {
-                moduleName: "@serwist/strategies",
-                className: "StrategyHandler",
-                funcName: "constructor",
-                paramName: "options.event"
-            });
-            assert.isInstance(options.request, Request, {
-                moduleName: "@serwist/strategies",
-                className: "StrategyHandler",
-                funcName: "constructor",
-                paramName: "options.request"
-            });
-        }
-        this.event = options.event;
-        this.request = options.request;
-        if (options.url) {
-            this.url = options.url;
-            this.params = options.params;
-        }
-        this._strategy = strategy;
-        this._handlerDeferred = new Deferred();
-        this._extendLifetimePromises = [];
-        this._plugins = [
-            ...strategy.plugins
-        ];
-        this._pluginStateMap = new Map();
-        for (const plugin of this._plugins){
-            this._pluginStateMap.set(plugin, {});
-        }
-        this.event.waitUntil(this._handlerDeferred.promise);
-    }
-    async fetch(input) {
-        const { event } = this;
-        let request = toRequest(input);
-        if (request.mode === "navigate" && event instanceof FetchEvent && event.preloadResponse) {
-            const possiblePreloadResponse = await event.preloadResponse;
-            if (possiblePreloadResponse) {
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log(`Using a preloaded navigation response for '${getFriendlyURL(request.url)}'`);
-                }
-                return possiblePreloadResponse;
-            }
-        }
-        const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
-        try {
-            for (const cb of this.iterateCallbacks("requestWillFetch")){
-                request = await cb({
-                    request: request.clone(),
-                    event
-                });
-            }
-        } catch (err) {
-            if (err instanceof Error) {
-                throw new SerwistError("plugin-error-request-will-fetch", {
-                    thrownErrorMessage: err.message
-                });
-            }
-        }
-        const pluginFilteredRequest = request.clone();
-        try {
-            let fetchResponse;
-            fetchResponse = await fetch(request, request.mode === "navigate" ? undefined : this._strategy.fetchOptions);
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`Network request for '${getFriendlyURL(request.url)}' returned a response with status '${fetchResponse.status}'.`);
-            }
-            for (const callback of this.iterateCallbacks("fetchDidSucceed")){
-                fetchResponse = await callback({
-                    event,
-                    request: pluginFilteredRequest,
-                    response: fetchResponse
-                });
-            }
-            return fetchResponse;
-        } catch (error) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.log(`Network request for '${getFriendlyURL(request.url)}' threw an error.`, error);
-            }
-            if (originalRequest) {
-                await this.runCallbacks("fetchDidFail", {
-                    error: error,
-                    event,
-                    originalRequest: originalRequest.clone(),
-                    request: pluginFilteredRequest.clone()
-                });
-            }
-            throw error;
-        }
-    }
-    async fetchAndCachePut(input) {
-        const response = await this.fetch(input);
-        const responseClone = response.clone();
-        void this.waitUntil(this.cachePut(input, responseClone));
-        return response;
-    }
-    async cacheMatch(key) {
-        const request = toRequest(key);
-        let cachedResponse;
-        const { cacheName, matchOptions } = this._strategy;
-        const effectiveRequest = await this.getCacheKey(request, "read");
-        const multiMatchOptions = {
-            ...matchOptions,
-            ...{
-                cacheName
-            }
-        };
-        cachedResponse = await caches.match(effectiveRequest, multiMatchOptions);
-        if (process.env.NODE_ENV !== "production") {
-            if (cachedResponse) {
-                logger.debug(`Found a cached response in '${cacheName}'.`);
-            } else {
-                logger.debug(`No cached response found in '${cacheName}'.`);
-            }
-        }
-        for (const callback of this.iterateCallbacks("cachedResponseWillBeUsed")){
-            cachedResponse = await callback({
-                cacheName,
-                matchOptions,
-                cachedResponse,
-                request: effectiveRequest,
-                event: this.event
-            }) || undefined;
-        }
-        return cachedResponse;
-    }
-    async cachePut(key, response) {
-        const request = toRequest(key);
-        await timeout(0);
-        const effectiveRequest = await this.getCacheKey(request, "write");
-        if (process.env.NODE_ENV !== "production") {
-            if (effectiveRequest.method && effectiveRequest.method !== "GET") {
-                throw new SerwistError("attempt-to-cache-non-get-request", {
-                    url: getFriendlyURL(effectiveRequest.url),
-                    method: effectiveRequest.method
-                });
-            }
-        }
-        if (!response) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.error(`Cannot cache non-existent response for '${getFriendlyURL(effectiveRequest.url)}'.`);
-            }
-            throw new SerwistError("cache-put-with-no-response", {
-                url: getFriendlyURL(effectiveRequest.url)
-            });
-        }
-        const responseToCache = await this._ensureResponseSafeToCache(response);
-        if (!responseToCache) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will not be cached.`, responseToCache);
-            }
-            return false;
-        }
-        const { cacheName, matchOptions } = this._strategy;
-        const cache = await self.caches.open(cacheName);
-        if (process.env.NODE_ENV !== "production") {
-            const vary = response.headers.get("Vary");
-            if (vary && matchOptions?.ignoreVary !== true) {
-                logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`);
-            }
-        }
-        const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
-        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(cache, effectiveRequest.clone(), [
-            "__WB_REVISION__"
-        ], matchOptions) : null;
-        if (process.env.NODE_ENV !== "production") {
-            logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
-        }
-        try {
-            await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);
-        } catch (error) {
-            if (error instanceof Error) {
-                if (error.name === "QuotaExceededError") {
-                    await executeQuotaErrorCallbacks();
-                }
-                throw error;
-            }
-        }
-        for (const callback of this.iterateCallbacks("cacheDidUpdate")){
-            await callback({
-                cacheName,
-                oldResponse,
-                newResponse: responseToCache.clone(),
-                request: effectiveRequest,
-                event: this.event
-            });
-        }
-        return true;
-    }
-    async getCacheKey(request, mode) {
-        const key = `${request.url} | ${mode}`;
-        if (!this._cacheKeys[key]) {
-            let effectiveRequest = request;
-            for (const callback of this.iterateCallbacks("cacheKeyWillBeUsed")){
-                effectiveRequest = toRequest(await callback({
-                    mode,
-                    request: effectiveRequest,
-                    event: this.event,
-                    params: this.params
-                }));
-            }
-            this._cacheKeys[key] = effectiveRequest;
-        }
-        return this._cacheKeys[key];
-    }
-    hasCallback(name) {
-        for (const plugin of this._strategy.plugins){
-            if (name in plugin) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async runCallbacks(name, param) {
-        for (const callback of this.iterateCallbacks(name)){
-            await callback(param);
-        }
-    }
-    *iterateCallbacks(name) {
-        for (const plugin of this._strategy.plugins){
-            if (typeof plugin[name] === "function") {
-                const state = this._pluginStateMap.get(plugin);
-                const statefulCallback = (param)=>{
-                    const statefulParam = {
-                        ...param,
-                        state
-                    };
-                    return plugin[name](statefulParam);
-                };
-                yield statefulCallback;
-            }
-        }
-    }
-    waitUntil(promise) {
-        this._extendLifetimePromises.push(promise);
-        return promise;
-    }
-    async doneWaiting() {
-        let promise = undefined;
-        while(promise = this._extendLifetimePromises.shift()){
-            await promise;
-        }
-    }
-    destroy() {
-        this._handlerDeferred.resolve(null);
-    }
-    async _ensureResponseSafeToCache(response) {
-        let responseToCache = response;
-        let pluginsUsed = false;
-        for (const callback of this.iterateCallbacks("cacheWillUpdate")){
-            responseToCache = await callback({
-                request: this.request,
-                response: responseToCache,
-                event: this.event
-            }) || undefined;
-            pluginsUsed = true;
-            if (!responseToCache) {
-                break;
-            }
-        }
-        if (!pluginsUsed) {
-            if (responseToCache && responseToCache.status !== 200) {
-                responseToCache = undefined;
-            }
-            if (process.env.NODE_ENV !== "production") {
-                if (responseToCache) {
-                    if (responseToCache.status !== 200) {
-                        if (responseToCache.status === 0) {
-                            logger.warn(`The response for '${this.request.url}' is an opaque response. The caching strategy that you're using will not cache opaque responses by default.`);
-                        } else {
-                            logger.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
-                        }
-                    }
-                }
-            }
-        }
-        return responseToCache;
-    }
-}
-
-class Strategy {
-    cacheName;
-    plugins;
-    fetchOptions;
-    matchOptions;
-    constructor(options = {}){
-        this.cacheName = privateCacheNames.getRuntimeName(options.cacheName);
-        this.plugins = options.plugins || [];
-        this.fetchOptions = options.fetchOptions;
-        this.matchOptions = options.matchOptions;
-    }
-    handle(options) {
-        const [responseDone] = this.handleAll(options);
-        return responseDone;
-    }
-    handleAll(options) {
-        if (options instanceof FetchEvent) {
-            options = {
-                event: options,
-                request: options.request
-            };
-        }
-        const event = options.event;
-        const request = typeof options.request === "string" ? new Request(options.request) : options.request;
-        const handler = new StrategyHandler(this, options.url ? {
-            event,
-            request,
-            url: options.url,
-            params: options.params
-        } : {
-            event,
-            request
-        });
-        const responseDone = this._getResponse(handler, request, event);
-        const handlerDone = this._awaitComplete(responseDone, handler, request, event);
-        return [
-            responseDone,
-            handlerDone
-        ];
-    }
-    async _getResponse(handler, request, event) {
-        await handler.runCallbacks("handlerWillStart", {
-            event,
-            request
-        });
-        let response = undefined;
-        try {
-            response = await this._handle(request, handler);
-            if (response === undefined || response.type === "error") {
-                throw new SerwistError("no-response", {
-                    url: request.url
-                });
-            }
-        } catch (error) {
-            if (error instanceof Error) {
-                for (const callback of handler.iterateCallbacks("handlerDidError")){
-                    response = await callback({
-                        error,
-                        event,
-                        request
-                    });
-                    if (response !== undefined) {
-                        break;
-                    }
-                }
-            }
-            if (!response) {
-                throw error;
-            }
-            if (process.env.NODE_ENV !== "production") {
-                throw logger.log(`While responding to '${getFriendlyURL(request.url)}', an ${error instanceof Error ? error.toString() : ""} error occurred. Using a fallback response provided by a handlerDidError plugin.`);
-            }
-        }
-        for (const callback of handler.iterateCallbacks("handlerWillRespond")){
-            response = await callback({
-                event,
-                request,
-                response
-            });
-        }
-        return response;
-    }
-    async _awaitComplete(responseDone, handler, request, event) {
-        let response = undefined;
-        let error = undefined;
-        try {
-            response = await responseDone;
-        } catch (error) {}
-        try {
-            await handler.runCallbacks("handlerDidRespond", {
-                event,
-                request,
-                response
-            });
-            await handler.doneWaiting();
-        } catch (waitUntilError) {
-            if (waitUntilError instanceof Error) {
-                error = waitUntilError;
-            }
-        }
-        await handler.runCallbacks("handlerDidComplete", {
-            event,
-            request,
-            response,
-            error
-        });
-        handler.destroy();
-        if (error) {
-            throw error;
-        }
-    }
-}
-
-export { Strategy as S, StrategyHandler as a };

package/dist/chunks/precacheAndRoute.js

@@ -1,113 +0,0 @@
-import { logger, getFriendlyURL, privateCacheNames } from '@serwist/core/internal';
-import { g as getSingletonPrecacheController } from './singletonPrecacheController.js';
-import { r as registerRoute } from './registerRoute.js';
-import { R as Route } from './singletonRouter.js';
-
-function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {
-    for (const paramName of [
-        ...urlObject.searchParams.keys()
-    ]){
-        if (ignoreURLParametersMatching.some((regExp)=>regExp.test(paramName))) {
-            urlObject.searchParams.delete(paramName);
-        }
-    }
-    return urlObject;
-}
-
-function* generateURLVariations(url, { ignoreURLParametersMatching = [
-    /^utm_/,
-    /^fbclid$/
-], directoryIndex = "index.html", cleanURLs = true, urlManipulation } = {}) {
-    const urlObject = new URL(url, location.href);
-    urlObject.hash = "";
-    yield urlObject.href;
-    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);
-    yield urlWithoutIgnoredParams.href;
-    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith("/")) {
-        const directoryURL = new URL(urlWithoutIgnoredParams.href);
-        directoryURL.pathname += directoryIndex;
-        yield directoryURL.href;
-    }
-    if (cleanURLs) {
-        const cleanURL = new URL(urlWithoutIgnoredParams.href);
-        cleanURL.pathname += ".html";
-        yield cleanURL.href;
-    }
-    if (urlManipulation) {
-        const additionalURLs = urlManipulation({
-            url: urlObject
-        });
-        for (const urlToAttempt of additionalURLs){
-            yield urlToAttempt.href;
-        }
-    }
-}
-
-class PrecacheRoute extends Route {
-    constructor(precacheController, options){
-        const match = ({ request })=>{
-            const urlsToCacheKeys = precacheController.getURLsToCacheKeys();
-            for (const possibleURL of generateURLVariations(request.url, options)){
-                const cacheKey = urlsToCacheKeys.get(possibleURL);
-                if (cacheKey) {
-                    const integrity = precacheController.getIntegrityForCacheKey(cacheKey);
-                    return {
-                        cacheKey,
-                        integrity
-                    };
-                }
-            }
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}`);
-            }
-            return;
-        };
-        super(match, precacheController.strategy);
-    }
-}
-
-const SUBSTRING_TO_FIND = "-precache-";
-const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND)=>{
-    const cacheNames = await self.caches.keys();
-    const cacheNamesToDelete = cacheNames.filter((cacheName)=>{
-        return cacheName.includes(substringToFind) && cacheName.includes(self.registration.scope) && cacheName !== currentPrecacheName;
-    });
-    await Promise.all(cacheNamesToDelete.map((cacheName)=>self.caches.delete(cacheName)));
-    return cacheNamesToDelete;
-};
-
-const cleanupOutdatedCaches = ()=>{
-    self.addEventListener("activate", (event)=>{
-        const cacheName = privateCacheNames.getPrecacheName();
-        event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted)=>{
-            if (process.env.NODE_ENV !== "production") {
-                if (cachesDeleted.length > 0) {
-                    logger.log("The following out-of-date precaches were cleaned up automatically:", cachesDeleted);
-                }
-            }
-        }));
-    });
-};
-
-const createHandlerBoundToURL = (url)=>{
-    const precacheController = getSingletonPrecacheController();
-    return precacheController.createHandlerBoundToURL(url);
-};
-
-const addRoute = (options)=>{
-    const precacheController = getSingletonPrecacheController();
-    const precacheRoute = new PrecacheRoute(precacheController, options);
-    registerRoute(precacheRoute);
-};
-
-const precache = (entries)=>{
-    const precacheController = getSingletonPrecacheController();
-    precacheController.precache(entries);
-};
-
-const precacheAndRoute = (entries, options)=>{
-    precache(entries);
-    addRoute(options);
-};
-
-export { PrecacheRoute as P, createHandlerBoundToURL as a, addRoute as b, cleanupOutdatedCaches as c, precache as d, precacheAndRoute as p };

package/dist/chunks/registerRoute.js

@@ -1,7 +0,0 @@
-import { g as getSingletonRouter } from './singletonRouter.js';
-
-const registerRoute = (capture, handler, method)=>{
-    return getSingletonRouter().registerCapture(capture, handler, method);
-};
-
-export { registerRoute as r };