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

package/dist/abstractions/Serwist.d.ts

@@ -0,0 +1,82 @@
+import { type GoogleAnalyticsInitializeOptions } from "../plugins/googleAnalytics/initialize.js";
+import { PrecacheController } from "../precaching/PrecacheController.js";
+import { Router } from "../routing/Router.js";
+import type { FallbacksOptions } from "./fallbacks.js";
+import { type HandlePrecachingOptions } from "./handlePrecaching.js";
+import type { RuntimeCaching } from "./types.js";
+export interface SerwistOptions {
+    /**
+     * An optional `PrecacheController` instance. If not provided, the singleton
+     * `PrecacheController` will be used.
+     */
+    precacheController?: PrecacheController;
+    /**
+     * An optional `Router` instance. If not provided, the singleton `Router`
+     * will be used.
+     */
+    router?: Router;
+}
+export interface SerwistInstallOptions extends HandlePrecachingOptions {
+    /**
+     * Forces the waiting service worker to become the active one.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting
+     */
+    skipWaiting?: boolean;
+    /**
+     * Imports external scripts. They are executed in the order they
+     * are passed.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/importScripts
+     */
+    importScripts?: string[];
+    /**
+     * Enables navigation preloading if it is supported.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/navigationPreload
+     */
+    navigationPreload?: boolean;
+    /**
+     * Modifies the prefix of the default cache names used by Serwist packages.
+     */
+    cacheId?: string | undefined;
+    /**
+     * Claims any currently available clients once the service worker
+     * becomes active. This is normally used in conjunction with `skipWaiting()`.
+     *
+     * @default false
+     */
+    clientsClaim?: boolean;
+    /**
+     * A list of caching strategies.
+     *
+     * @see https://serwist.pages.dev/docs/sw/runtime-caching
+     */
+    runtimeCaching?: RuntimeCaching[];
+    /**
+     * Your configuration for `@serwist/google-analytics`. This plugin is
+     * only initialized when this option is not `undefined` or `false`.
+     */
+    offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
+    /**
+     * Disables Serwist's logging in development mode.
+     *
+     * @default false
+     */
+    disableDevLogs?: boolean;
+    /**
+     * Precaches routes so that they can be used as a fallback when
+     * a Strategy fails to generate a response.
+     * Note: This option mutates `runtimeCaching`!
+     *
+     * @see https://serwist.pages.dev/docs/sw/fallbacks
+     */
+    fallbacks?: Omit<FallbacksOptions, "runtimeCaching">;
+}
+export declare class Serwist {
+    private _precacheController;
+    private _router;
+    constructor({ precacheController, router }?: SerwistOptions);
+    install({ precacheEntries, precacheOptions, cleanupOutdatedCaches, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, skipWaiting, importScripts, navigationPreload, cacheId, clientsClaim, runtimeCaching, offlineAnalyticsConfig, disableDevLogs, fallbacks, }?: SerwistInstallOptions): void;
+}
+//# sourceMappingURL=Serwist.d.ts.map

package/dist/abstractions/Serwist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serwist.d.ts","sourceRoot":"","sources":["../../src/abstractions/Serwist.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gCAAgC,EAAc,MAAM,0CAA0C,CAAC;AAC7G,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAMzE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAK9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAsB,SAAQ,uBAAuB;IACpE;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,gCAAgC,GAAG,OAAO,CAAC;IACpE;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;CACtD;AAED,qBAAa,OAAO;IAClB,OAAO,CAAC,mBAAmB,CAAqB;IAChD,OAAO,CAAC,OAAO,CAAS;gBACZ,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAE,cAAmB;IAI/D,OAAO,CAAC,EACN,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,wBAAwB,EACxB,WAAmB,EACnB,aAAa,EACb,iBAAyB,EACzB,OAAO,EACP,YAAoB,EACpB,cAAc,EACd,sBAAsB,EACtB,cAAsB,EACtB,SAAS,GACV,GAAE,qBAA0B;CA8D9B"}

package/dist/{disableDevLogs.d.ts → abstractions/disableDevLogs.d.ts}

@@ -1,5 +1,7 @@
 /**
  * Disables Serwist's logging in development mode.
+ *
+ * @see https://serwist.pages.dev/docs/sw/disable-dev-logs
  */
 export declare const disableDevLogs: () => void;
 //# sourceMappingURL=disableDevLogs.d.ts.map

package/dist/abstractions/disableDevLogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disableDevLogs.d.ts","sourceRoot":"","sources":["../../src/abstractions/disableDevLogs.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAO,IAEjC,CAAC"}

package/dist/{fallbacks.d.ts → abstractions/fallbacks.d.ts}

@@ -1,28 +1,13 @@
 import type { HandlerDidErrorCallbackParam } from "@serwist/core";
-import type { PrecacheRouteOptions } from "@serwist/precaching";
+import type { PrecacheFallbackEntry } from "../plugins/precaching/PrecacheFallbackPlugin.js";
+import type { PrecacheRouteOptions } from "../precaching/types.js";
 import type { RuntimeCaching } from "./types.js";
 export type FallbackMatcher = (_: HandlerDidErrorCallbackParam) => boolean;
-export interface FallbackEntry {
-    /**
-     * The matcher, which checks whether the fallback entry can be used
-     * for a Request.
-     */
-    matcher: FallbackMatcher;
-    /**
-     * The fallback URL.
-     */
-    url: URL | string;
+export interface FallbackEntry extends PrecacheFallbackEntry {
     /**
      * The revision used for precaching.
      */
     revision: string;
-    /**
-     * How the Response in the cache should be matched.
-     *
-     * @default
-     * { ignoreSearch: true }
-     */
-    cacheMatchOptions?: MultiCacheQueryOptions;
 }
 export interface FallbacksOptions {
     /**
@@ -41,10 +26,14 @@ export interface FallbacksOptions {
 }
 /**
  * Precaches routes so that they can be used as a fallback when
- * a `RuntimeCaching` handler fails.
+ * a Strategy fails to generate a response.
+ *
+ * Note: This function mutates `runtimeCaching`!
+ *
+ * @see https://serwist.pages.dev/docs/sw/fallbacks
  * @param options
  * @returns The modified `RuntimeCaching` array. Using this value
- * is not needed, as it is simply the provided array.
+ * is not needed, as it is simply the array in `options`.
  */
 export declare const fallbacks: ({ runtimeCaching, entries, precacheOptions }: FallbacksOptions) => RuntimeCaching[];
 //# sourceMappingURL=fallbacks.d.ts.map

package/dist/abstractions/fallbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallbacks.d.ts","sourceRoot":"","sources":["../../src/abstractions/fallbacks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAElE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAE7F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,4BAA4B,KAAK,OAAO,CAAC;AAE3E,MAAM,WAAW,aAAc,SAAQ,qBAAqB;IAC1D;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC;;OAEG;IACH,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB;;;OAGG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,iDAAkD,gBAAgB,KAAG,cAAc,EAoBxG,CAAC"}

package/dist/{handlePrecaching.d.ts → abstractions/handlePrecaching.d.ts}

@@ -1,5 +1,5 @@
-import type { PrecacheEntry, PrecacheRouteOptions } from "@serwist/precaching";
-export type HandlePrecachingOptions = {
+import type { PrecacheEntry, PrecacheRouteOptions } from "../precaching/types.js";
+export interface HandlePrecachingOptions {
     /**
      * A list of fallback entries.
      */
@@ -14,13 +14,11 @@ export type HandlePrecachingOptions = {
      * @default false
      */
     cleanupOutdatedCaches?: boolean;
-} & ({
     /**
-     * An URL that should point to a HTML
-     * file with which navigation requests for URLs that aren't precached will be fulfilled.
-     * For more complex cases, consider `@serwist/sw.fallbacks`instead.
+     * An URL that should point to a HTML file with which navigation requests for URLs that aren't
+     * precached will be fulfilled.
      */
-    navigateFallback: string;
+    navigateFallback?: string;
     /**
      * URLs that should be allowed to use the `navigateFallback` handler.
      */
@@ -30,11 +28,11 @@ export type HandlePrecachingOptions = {
      * over `navigateFallbackAllowlist`.
      */
     navigateFallbackDenylist?: RegExp[];
-} | {
-    navigateFallback?: never;
-});
+}
 /**
  * Handles a list of precache entries and cleans up outdated caches.
+ *
+ * @see https://serwist.pages.dev/docs/sw/handle-precaching
  * @param options
  */
 export declare const handlePrecaching: ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, ...options }: HandlePrecachingOptions) => void;

package/dist/abstractions/handlePrecaching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlePrecaching.d.ts","sourceRoot":"","sources":["../../src/abstractions/handlePrecaching.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAIlF,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,eAAe,CAAC,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC;IAC7C;;OAEG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;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;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,4EAAqF,uBAAuB,KAAG,IAoB3I,CAAC"}

package/dist/abstractions/installSerwist.d.ts

@@ -0,0 +1,15 @@
+import { type SerwistInstallOptions } from "./Serwist.js";
+/**
+ * Options for `installSerwist`.
+ *
+ * @deprecated
+ */
+export type InstallSerwistOptions = SerwistInstallOptions;
+/**
+ * Abstracts away the core APIs of Serwist.
+ *
+ * @param options - `installSerwist` options.
+ * @deprecated
+ */
+export declare const installSerwist: (options: InstallSerwistOptions) => void;
+//# sourceMappingURL=installSerwist.d.ts.map

package/dist/abstractions/installSerwist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installSerwist.d.ts","sourceRoot":"","sources":["../../src/abstractions/installSerwist.ts"],"names":[],"mappings":"AAGA,OAAO,EAAW,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,qBAAqB,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,cAAc,YAAa,qBAAqB,KAAG,IAS/D,CAAC"}

package/dist/abstractions/navigationPreload.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks whether the current browser supports
+ * navigation preloading.
+ *
+ * @returns
+ */
+export declare const isNavigationPreloadSupported: () => boolean;
+/**
+ * If the browser supports navigation preloading, then this will enable it.
+ *
+ * @param headerValue Optional. Allows developers to override the value of
+ * the `Service-Worker-Navigation-Preload` header which will be sent to the
+ * server when making the navigation request.
+ */
+export declare const enableNavigationPreload: (headerValue?: string) => void;
+/**
+ * If the browser supports navigation preloading, then this will disable it.
+ */
+export declare const disableNavigationPreload: () => void;
+//# sourceMappingURL=navigationPreload.d.ts.map

package/dist/abstractions/navigationPreload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigationPreload.d.ts","sourceRoot":"","sources":["../../src/abstractions/navigationPreload.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,QAAO,OAE/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,iBAAkB,MAAM,KAAG,IAqB9D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,QAAO,IAgB3C,CAAC"}

package/dist/{registerRuntimeCaching.d.ts → abstractions/registerRuntimeCaching.d.ts}

@@ -2,6 +2,8 @@ import type { RuntimeCaching } from "./types.js";
 /**
  * Registers caching strategies to a singleton Router instance. It is a simple
  * syntatic sugar for `@serwist/routing.registerRoute`.
+ *
+ * @see https://serwist.pages.dev/docs/sw/register-runtime-caching
  * @param runtimeCachingList
  * @returns
  */

package/dist/abstractions/registerRuntimeCaching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerRuntimeCaching.d.ts","sourceRoot":"","sources":["../../src/abstractions/registerRuntimeCaching.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,0BAA2B,cAAc,EAAE,KAAG,IAIhF,CAAC"}

package/dist/abstractions/types.d.ts

@@ -0,0 +1,29 @@
+import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
+import type { HTTPMethod } from "../routing/utils/constants.js";
+export interface RuntimeCaching {
+    /**
+     * The HTTP method to match against. The default value of `'GET'` is normally
+     * sufficient, unless you explicitly need to match `'POST'`, `'PUT'`, or
+     * another type of request.
+     * @default "GET"
+     */
+    method?: HTTPMethod;
+    /**
+     * This match criteria determines whether the configured handler will
+     * generate a response for any requests that don't match one of the precached
+     * URLs. If multiple `RuntimeCaching` routes are defined, then the first one
+     * whose `matcher` matches will be the one that responds.
+     *
+     * This value directly maps to the first parameter passed to
+     * `@serwist/routing.registerRoute`. It's recommended to use a
+     * `@serwist/core.RouteMatchCallback` function for greatest flexibility.
+     */
+    matcher: RegExp | string | RouteMatchCallback;
+    /**
+     * This determines how the runtime route will generate a response. It
+     * can be a `@serwist/core.RouteHandler` callback function with custom
+     * response logic.
+     */
+    handler: RouteHandler;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/abstractions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/abstractions/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;;;;;;;OASG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,CAAC;IAC9C;;;;OAIG;IACH,OAAO,EAAE,YAAY,CAAC;CACvB"}

package/dist/chunks/NavigationRoute.js

@@ -0,0 +1,54 @@
+import { assert, logger } from '@serwist/core/internal';
+import { R as Route } from './singletonRouter.js';
+
+class NavigationRoute extends Route {
+    _allowlist;
+    _denylist;
+    constructor(handler, { allowlist = [
+        /./
+    ], denylist = [] } = {}){
+        if (process.env.NODE_ENV !== "production") {
+            assert.isArrayOfClass(allowlist, RegExp, {
+                moduleName: "@serwist/routing",
+                className: "NavigationRoute",
+                funcName: "constructor",
+                paramName: "options.allowlist"
+            });
+            assert.isArrayOfClass(denylist, RegExp, {
+                moduleName: "@serwist/routing",
+                className: "NavigationRoute",
+                funcName: "constructor",
+                paramName: "options.denylist"
+            });
+        }
+        super((options)=>this._match(options), handler);
+        this._allowlist = allowlist;
+        this._denylist = denylist;
+    }
+    _match({ url, request }) {
+        if (request && request.mode !== "navigate") {
+            return false;
+        }
+        const pathnameAndSearch = url.pathname + url.search;
+        for (const regExp of this._denylist){
+            if (regExp.test(pathnameAndSearch)) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL matches this denylist pattern: ${regExp.toString()}`);
+                }
+                return false;
+            }
+        }
+        if (this._allowlist.some((regExp)=>regExp.test(pathnameAndSearch))) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`The navigation route ${pathnameAndSearch} is being used.`);
+            }
+            return true;
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL being navigated to doesn't match the allowlist.`);
+        }
+        return false;
+    }
+}
+
+export { NavigationRoute as N };

package/dist/chunks/NetworkOnly.js

@@ -0,0 +1,193 @@
+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 };