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

package/dist/chunks/NetworkOnly.js

@@ -1,193 +0,0 @@
-import { getFriendlyURL, logger, assert, SerwistError, timeout } from '@serwist/core/internal';
-import { S as Strategy } from './Strategy.js';
-
-const cacheOkAndOpaquePlugin = {
-    cacheWillUpdate: async ({ response })=>{
-        if (response.status === 200 || response.status === 0) {
-            return response;
-        }
-        return null;
-    }
-};
-
-const messages = {
-    strategyStart: (strategyName, request)=>`Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,
-    printFinalResponse: (response)=>{
-        if (response) {
-            logger.groupCollapsed("View the final response here.");
-            logger.log(response || "[No response returned]");
-            logger.groupEnd();
-        }
-    }
-};
-
-class NetworkFirst extends Strategy {
-    _networkTimeoutSeconds;
-    constructor(options = {}){
-        super(options);
-        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
-            this.plugins.unshift(cacheOkAndOpaquePlugin);
-        }
-        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
-        if (process.env.NODE_ENV !== "production") {
-            if (this._networkTimeoutSeconds) {
-                assert.isType(this._networkTimeoutSeconds, "number", {
-                    moduleName: "@serwist/strategies",
-                    className: this.constructor.name,
-                    funcName: "constructor",
-                    paramName: "networkTimeoutSeconds"
-                });
-            }
-        }
-    }
-    async _handle(request, handler) {
-        const logs = [];
-        if (process.env.NODE_ENV !== "production") {
-            assert.isInstance(request, Request, {
-                moduleName: "@serwist/strategies",
-                className: this.constructor.name,
-                funcName: "handle",
-                paramName: "makeRequest"
-            });
-        }
-        const promises = [];
-        let timeoutId;
-        if (this._networkTimeoutSeconds) {
-            const { id, promise } = this._getTimeoutPromise({
-                request,
-                logs,
-                handler
-            });
-            timeoutId = id;
-            promises.push(promise);
-        }
-        const networkPromise = this._getNetworkPromise({
-            timeoutId,
-            request,
-            logs,
-            handler
-        });
-        promises.push(networkPromise);
-        const response = await handler.waitUntil((async ()=>{
-            return await handler.waitUntil(Promise.race(promises)) || await networkPromise;
-        })());
-        if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            for (const log of logs){
-                logger.log(log);
-            }
-            messages.printFinalResponse(response);
-            logger.groupEnd();
-        }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url
-            });
-        }
-        return response;
-    }
-    _getTimeoutPromise({ request, logs, handler }) {
-        let timeoutId;
-        const timeoutPromise = new Promise((resolve)=>{
-            const onNetworkTimeout = async ()=>{
-                if (process.env.NODE_ENV !== "production") {
-                    logs.push(`Timing out the network response at ${this._networkTimeoutSeconds} seconds.`);
-                }
-                resolve(await handler.cacheMatch(request));
-            };
-            timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);
-        });
-        return {
-            promise: timeoutPromise,
-            id: timeoutId
-        };
-    }
-    async _getNetworkPromise({ timeoutId, request, logs, handler }) {
-        let error = undefined;
-        let response = undefined;
-        try {
-            response = await handler.fetchAndCachePut(request);
-        } catch (fetchError) {
-            if (fetchError instanceof Error) {
-                error = fetchError;
-            }
-        }
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
-        if (process.env.NODE_ENV !== "production") {
-            if (response) {
-                logs.push("Got response from network.");
-            } else {
-                logs.push("Unable to get a response from the network. Will respond " + "with a cached response.");
-            }
-        }
-        if (error || !response) {
-            response = await handler.cacheMatch(request);
-            if (process.env.NODE_ENV !== "production") {
-                if (response) {
-                    logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
-                } else {
-                    logs.push(`No response found in the '${this.cacheName}' cache.`);
-                }
-            }
-        }
-        return response;
-    }
-}
-
-class NetworkOnly extends Strategy {
-    _networkTimeoutSeconds;
-    constructor(options = {}){
-        super(options);
-        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
-    }
-    async _handle(request, handler) {
-        if (process.env.NODE_ENV !== "production") {
-            assert.isInstance(request, Request, {
-                moduleName: "@serwist/strategies",
-                className: this.constructor.name,
-                funcName: "_handle",
-                paramName: "request"
-            });
-        }
-        let error = undefined;
-        let response;
-        try {
-            const promises = [
-                handler.fetch(request)
-            ];
-            if (this._networkTimeoutSeconds) {
-                const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000);
-                promises.push(timeoutPromise);
-            }
-            response = await Promise.race(promises);
-            if (!response) {
-                throw new Error(`Timed out the network response after ${this._networkTimeoutSeconds} seconds.`);
-            }
-        } catch (err) {
-            if (err instanceof Error) {
-                error = err;
-            }
-        }
-        if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            if (response) {
-                logger.log("Got response from network.");
-            } else {
-                logger.log("Unable to get a response from the network.");
-            }
-            messages.printFinalResponse(response);
-            logger.groupEnd();
-        }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url,
-                error
-            });
-        }
-        return response;
-    }
-}
-
-export { NetworkOnly as N, NetworkFirst as a, cacheOkAndOpaquePlugin as c, messages as m };