@serwist/sw 9.0.0-preview.16 → 9.0.0-preview.18

package/dist/{installSerwist.d.ts → abstractions/Serwist.d.ts}

@@ -1,8 +1,24 @@
-import { type GoogleAnalyticsInitializeOptions } from "@serwist/google-analytics/initialize";
+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 type InstallSerwistOptions = HandlePrecachingOptions & {
+export interface SerwistOptions {
+    /**
+     * The precache controller that will be used to perform efficient
+     * precaching of assets.
+     * @see https://serwist.pages.dev/docs/sw/precaching
+     */
+    precacheController?: PrecacheController;
+    /**
+     * The router that will be used to process a `FetchEvent`, responding
+     * with a `Response` if a matching route exists.
+     * @see https://serwist.pages.dev/docs/sw/routing
+     */
+    router?: Router;
+}
+export interface SerwistInstallOptions extends HandlePrecachingOptions {
     /**
      * Forces the waiting service worker to become the active one.
      *
@@ -36,7 +52,7 @@ export type InstallSerwistOptions = HandlePrecachingOptions & {
     /**
      * A list of caching strategies.
      *
-     * @see https://serwist.pages.dev/docs/sw/register-runtime-caching
+     * @see https://serwist.pages.dev/docs/sw/runtime-caching
      */
     runtimeCaching?: RuntimeCaching[];
     /**
@@ -48,7 +64,6 @@ export type InstallSerwistOptions = HandlePrecachingOptions & {
      * Disables Serwist's logging in development mode.
      *
      * @default false
-     * @see https://serwist.pages.dev/docs/sw/disable-dev-logs
      */
     disableDevLogs?: boolean;
     /**
@@ -59,10 +74,11 @@ export type InstallSerwistOptions = HandlePrecachingOptions & {
      * @see https://serwist.pages.dev/docs/sw/fallbacks
      */
     fallbacks?: Omit<FallbacksOptions, "runtimeCaching">;
-};
-/**
- * Abstracts away the core APIs of Serwist.
- * @param options - `installSerwist` options.
- */
-export declare const installSerwist: ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting, importScripts, navigationPreload, cacheId, clientsClaim, runtimeCaching, offlineAnalyticsConfig, disableDevLogs, fallbacks, ...options }: InstallSerwistOptions) => void;
-//# sourceMappingURL=installSerwist.d.ts.map
+}
+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":"AAEA,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;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;;OAIG;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,EAAE,qBAAqB;CA8DzB"}

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,6 +1,6 @@
 import type { HandlerDidErrorCallbackParam } from "@serwist/core";
-import type { PrecacheRouteOptions } from "@serwist/precaching";
-import type { PrecacheFallbackEntry } 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 extends PrecacheFallbackEntry {

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,12 +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.
      */
-    navigateFallback: string;
+    navigateFallback?: string;
     /**
      * URLs that should be allowed to use the `navigateFallback` handler.
      */
@@ -29,13 +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/handlePrecaching
+ * @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/{registerRuntimeCaching.d.ts → abstractions/registerRuntimeCaching.d.ts}

@@ -3,7 +3,7 @@ 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/registerRuntimeCaching
+ * @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/{types.d.ts → abstractions/types.d.ts}

@@ -1,5 +1,5 @@
 import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
-import type { HTTPMethod } from "@serwist/routing";
+import type { HTTPMethod } from "../routing/utils/constants.js";
 export interface RuntimeCaching {
     /**
      * The HTTP method to match against. The default value of `'GET'` is normally

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 './registerRoute.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 };