@serwist/sw 9.0.0-preview.1 → 9.0.0-preview.10

package/dist/disableDevLogs.d.ts

@@ -1,2 +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/disableDevLogs.d.ts.map

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

package/dist/fallbacks.d.ts

@@ -1,33 +1,39 @@
 import type { HandlerDidErrorCallbackParam } from "@serwist/core";
 import type { PrecacheRouteOptions } from "@serwist/precaching";
+import type { PrecacheFallbackEntry } from "@serwist/precaching";
 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 {
+    /**
+     * Your previous `RuntimeCaching` array.
+     */
     runtimeCaching: RuntimeCaching[];
+    /**
+     * A list of fallback entries.
+     */
     entries: FallbackEntry[];
+    /**
+     * Precache options that will be used for your
+     * fallback entries.
+     */
     precacheOptions?: PrecacheRouteOptions;
 }
+/**
+ * Precaches routes so that they can be used as a fallback when
+ * 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 array in `options`.
+ */
 export declare const fallbacks: ({ runtimeCaching, entries, precacheOptions }: FallbacksOptions) => RuntimeCaching[];
 //# sourceMappingURL=fallbacks.d.ts.map

package/dist/fallbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fallbacks.d.ts","sourceRoot":"","sources":["../src/fallbacks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,4BAA4B,KAAK,OAAO,CAAC;AAE3E,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,OAAO,EAAE,eAAe,CAAC;IACzB;;OAEG;IACH,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC;IAClB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;CAC5C;AAED,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAED,eAAO,MAAM,SAAS,iDAAkD,gBAAgB,qBA4BvF,CAAC"}
+{"version":3,"file":"fallbacks.d.ts","sourceRoot":"","sources":["../src/fallbacks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGjE,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

@@ -1,14 +1,43 @@
 import type { PrecacheEntry, PrecacheRouteOptions } from "@serwist/precaching";
 export type HandlePrecachingOptions = {
+    /**
+     * A list of fallback entries.
+     */
     precacheEntries?: (PrecacheEntry | string)[];
+    /**
+     * Precache options for the provided entries.
+     */
     precacheOptions?: PrecacheRouteOptions;
+    /**
+     * Whether outdated caches should be removed.
+     *
+     * @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.
+     */
     navigateFallback: string;
+    /**
+     * URLs that should be allowed to use the `navigateFallback` handler.
+     */
     navigateFallbackAllowlist?: RegExp[];
+    /**
+     * URLs that should not be allowed to use the `navigateFallback` handler. This takes precedence
+     * over `navigateFallbackAllowlist`.
+     */
     navigateFallbackDenylist?: RegExp[];
 } | {
     navigateFallback?: never;
 });
-export declare const handlePrecaching: ({ precacheEntries, precacheOptions, cleanupOutdatedCaches: shouldCleanupOutdatedCaches, ...options }: HandlePrecachingOptions) => void;
+/**
+ * Handles a list of precache entries and cleans up outdated caches.
+ *
+ * @see https://serwist.pages.dev/docs/sw/handlePrecaching
+ * @param options
+ */
+export declare const handlePrecaching: ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, ...options }: HandlePrecachingOptions) => void;
 //# sourceMappingURL=handlePrecaching.d.ts.map

package/dist/handlePrecaching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlePrecaching.d.ts","sourceRoot":"","sources":["../src/handlePrecaching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAI/E,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,CAAC,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC;IAC7C,eAAe,CAAC,EAAE,oBAAoB,CAAC;IAEvC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,GAAG,CAAC;IAAE,gBAAgB,EAAE,MAAM,CAAC;IAAC,yBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG;IAAE,gBAAgB,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAE7I,eAAO,MAAM,gBAAgB,yGAK1B,uBAAuB,SAoBzB,CAAC"}
+{"version":3,"file":"handlePrecaching.d.ts","sourceRoot":"","sources":["../src/handlePrecaching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAI/E,MAAM,MAAM,uBAAuB,GAAG;IACpC;;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;CACjC,GAAG,CACA;IACE;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;OAEG;IACH,yBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC;IACrC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;CACrC,GACD;IAAE,gBAAgB,CAAC,EAAE,KAAK,CAAA;CAAE,CAC/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,4EAAqF,uBAAuB,KAAG,IAoB3I,CAAC"}

package/dist/index.js

@@ -1,54 +1,34 @@
-import { precacheAndRoute, cleanupOutdatedCaches, createHandlerBoundToURL, PrecacheFallbackPlugin } from '@serwist/precaching';
+import { precacheAndRoute, PrecacheFallbackPlugin, cleanupOutdatedCaches, createHandlerBoundToURL } from '@serwist/precaching';
+import { Strategy } from '@serwist/strategies';
 import { registerRoute, NavigationRoute } from '@serwist/routing';
 import { setCacheNameDetails, clientsClaim } from '@serwist/core';
-import { logger } from '@serwist/core/internal';
 import { initialize } from '@serwist/google-analytics/initialize';
 import { enable } from '@serwist/navigation-preload';
-import { BackgroundSyncPlugin } from '@serwist/background-sync';
-import { BroadcastUpdatePlugin } from '@serwist/broadcast-update';
-import { CacheableResponsePlugin } from '@serwist/cacheable-response';
-import { ExpirationPlugin } from '@serwist/expiration';
-import { RangeRequestsPlugin } from '@serwist/range-requests';
-import { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate } from '@serwist/strategies';
+import { logger } from '@serwist/core/internal';
 
 const disableDevLogs = ()=>{
     self.__WB_DISABLE_DEV_LOGS = true;
 };
 
 const fallbacks = ({ runtimeCaching, entries, precacheOptions })=>{
-    precacheAndRoute(entries.map(({ url, revision })=>({
-            url: typeof url === "string" ? url : url.toString(),
-            revision
-        })), precacheOptions);
-    runtimeCaching = runtimeCaching.map((cacheEntry)=>{
-        if (!cacheEntry.options || cacheEntry.options.precacheFallback || cacheEntry.options.plugins?.some((plugin)=>"handlerDidError" in plugin)) {
-            return cacheEntry;
-        }
-        if (!cacheEntry.options.plugins) {
-            cacheEntry.options.plugins = [];
+    precacheAndRoute(entries, precacheOptions);
+    const fallbackPlugin = new PrecacheFallbackPlugin({
+        fallbackUrls: entries
+    });
+    runtimeCaching.forEach((cacheEntry)=>{
+        if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
+            cacheEntry.handler.plugins.push(fallbackPlugin);
         }
-        cacheEntry.options.plugins.push({
-            async handlerDidError (info) {
-                for (const { matcher, url, cacheMatchOptions = {
-                    ignoreSearch: true
-                } } of entries){
-                    if (matcher(info)) {
-                        return caches.match(url, cacheMatchOptions);
-                    }
-                }
-                return Response.error();
-            }
-        });
         return cacheEntry;
     });
     return runtimeCaching;
 };
 
-const handlePrecaching = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches: shouldCleanupOutdatedCaches = false, ...options })=>{
+const handlePrecaching = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches: cleanupOutdatedCaches$1 = false, ...options })=>{
     if (!!precacheEntries && precacheEntries.length > 0) {
         precacheAndRoute(precacheEntries, precacheOptions);
     }
-    if (shouldCleanupOutdatedCaches) cleanupOutdatedCaches();
+    if (cleanupOutdatedCaches$1) cleanupOutdatedCaches();
     if (options.navigateFallback) {
         registerRoute(new NavigationRoute(createHandlerBoundToURL(options.navigateFallback), {
             allowlist: options.navigateFallbackAllowlist,
@@ -57,52 +37,20 @@ const handlePrecaching = ({ precacheEntries, precacheOptions, cleanupOutdatedCac
     }
 };
 
-const nonNullable = (value)=>value !== null && value !== undefined;
-
-const HANDLER_NAME_TO_METHOD = {
-    CacheFirst,
-    CacheOnly,
-    NetworkFirst,
-    NetworkOnly,
-    StaleWhileRevalidate
-};
 const registerRuntimeCaching = (...runtimeCachingList)=>{
     if (!("__WB_FORCE_RUNTIME_CACHING" in globalThis)) {
         self.__WB_FORCE_RUNTIME_CACHING = false;
     }
     if (!self.__WB_FORCE_RUNTIME_CACHING && process.env.NODE_ENV !== "production") {
-        logger.info("registerRuntimeCaching is disabled in development mode.");
-        return;
-    }
-    for (const rcEntry of runtimeCachingList){
-        if (typeof rcEntry.handler === "string") {
-            const { cacheName, networkTimeoutSeconds, fetchOptions, matchOptions, plugins, backgroundSync, broadcastUpdate, cacheableResponse, expiration, precacheFallback, rangeRequests } = rcEntry.options;
-            const Handler = HANDLER_NAME_TO_METHOD[rcEntry.handler];
-            registerRoute(rcEntry.urlPattern, new Handler({
-                cacheName: cacheName ?? undefined,
-                networkTimeoutSeconds,
-                fetchOptions,
-                matchOptions,
-                plugins: [
-                    ...plugins ?? [],
-                    backgroundSync && new BackgroundSyncPlugin(backgroundSync.name, backgroundSync.options),
-                    broadcastUpdate && new BroadcastUpdatePlugin({
-                        channelName: broadcastUpdate.channelName,
-                        ...broadcastUpdate.options
-                    }),
-                    cacheableResponse && new CacheableResponsePlugin(cacheableResponse),
-                    expiration && new ExpirationPlugin(expiration),
-                    precacheFallback && new PrecacheFallbackPlugin(precacheFallback),
-                    rangeRequests ? new RangeRequestsPlugin() : undefined
-                ].filter(nonNullable)
-            }), rcEntry.method);
-        } else {
-            registerRoute(rcEntry.urlPattern, rcEntry.handler, rcEntry.method);
+        logger.log("registerRuntimeCaching is disabled in development mode.");
+    } else {
+        for (const entry of runtimeCachingList){
+            registerRoute(entry.matcher, entry.handler, entry.method);
         }
     }
 };
 
-const installSerwist = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1, fallbacks: fallbacks$1, ...options })=>{
+const installSerwist = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks: fallbacks$1, ...options })=>{
     if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
     if (navigationPreload) enable();
     if (cacheId !== undefined) {
@@ -135,10 +83,10 @@ const installSerwist = ({ precacheEntries, precacheOptions, cleanupOutdatedCache
             self.__WB_FORCE_RUNTIME_CACHING = false;
         }
         if (!self.__WB_FORCE_RUNTIME_CACHING && process.env.NODE_ENV !== "production") {
-            logger.info("runtimeCaching and fallbacks are disabled in development mode.");
+            logger.log("runtimeCaching and fallbacks are disabled in development mode.");
         } else {
             if (fallbacks$1 !== undefined) {
-                runtimeCaching = fallbacks({
+                fallbacks({
                     ...fallbacks$1,
                     runtimeCaching
                 });

package/dist/installSerwist.d.ts

@@ -3,14 +3,61 @@ import type { FallbacksOptions } from "./fallbacks.js";
 import { type HandlePrecachingOptions } from "./handlePrecaching.js";
 import type { RuntimeCaching } from "./types.js";
 export type InstallSerwistOptions = 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 Preload 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/register-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
+     * @see https://serwist.pages.dev/docs/sw/disable-dev-logs
+     */
     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">;
 };
 /**

package/dist/installSerwist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"installSerwist.d.ts","sourceRoot":"","sources":["../src/installSerwist.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gCAAgC,EAAc,MAAM,sCAAsC,CAAC;AAIzG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,KAAK,uBAAuB,EAAoB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,GAAG;IAC5D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC,sBAAsB,CAAC,EAAE,gCAAgC,GAAG,OAAO,CAAC;IACpE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;CACtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,qNAexB,qBAAqB,SA4DvB,CAAC"}
+{"version":3,"file":"installSerwist.d.ts","sourceRoot":"","sources":["../src/installSerwist.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gCAAgC,EAAc,MAAM,sCAAsC,CAAC;AAMzG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,KAAK,uBAAuB,EAAoB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,GAAG;IAC5D;;;;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;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;CACtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,qNAexB,qBAAqB,KAAG,IAyD1B,CAAC"}

package/dist/registerRuntimeCaching.d.ts

@@ -1,3 +1,11 @@
 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
+ * @param runtimeCachingList
+ * @returns
+ */
 export declare const registerRuntimeCaching: (...runtimeCachingList: RuntimeCaching[]) => void;
 //# sourceMappingURL=registerRuntimeCaching.d.ts.map

package/dist/registerRuntimeCaching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerRuntimeCaching.d.ts","sourceRoot":"","sources":["../src/registerRuntimeCaching.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,YAAY,CAAC;AAY/D,eAAO,MAAM,sBAAsB,0BAA2B,cAAc,EAAE,SAsD7E,CAAC"}
+{"version":3,"file":"registerRuntimeCaching.d.ts","sourceRoot":"","sources":["../src/registerRuntimeCaching.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,0BAA2B,cAAc,EAAE,KAAG,IAYhF,CAAC"}

package/dist/types.d.ts

@@ -1,19 +1,6 @@
-import type { QueueOptions } from "@serwist/background-sync";
-import type { BroadcastCacheUpdateOptions } from "@serwist/broadcast-update";
-import type { CacheableResponseOptions } from "@serwist/cacheable-response";
-import type { RouteHandler, RouteMatchCallback, SerwistPlugin } from "@serwist/core";
-import type { ExpirationPluginOptions } from "@serwist/expiration";
+import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
 import type { HTTPMethod } from "@serwist/routing";
-export type StrategyName = "CacheFirst" | "CacheOnly" | "NetworkFirst" | "NetworkOnly" | "StaleWhileRevalidate";
 export interface RuntimeCaching {
-    /**
-     * This determines how the runtime route will generate a response.
-     * To use one of the built-in `@serwist/strategies`, provide its name,
-     * like `'NetworkFirst'`.
-     * Alternatively, this can be a `@serwist/core.RouteHandler` callback
-     * function with custom response logic.
-     */
-    handler: RouteHandler | StrategyName;
     /**
      * The HTTP method to match against. The default value of `'GET'` is normally
      * sufficient, unless you explicitly need to match `'POST'`, `'PUT'`, or
@@ -21,90 +8,22 @@ export interface RuntimeCaching {
      * @default "GET"
      */
     method?: HTTPMethod;
-    options?: {
-        /**
-         * Configuring this will add a
-         * `@serwist/background-sync.BackgroundSyncPlugin` instance to the
-         * `@serwist/strategies` configured in `handler`.
-         */
-        backgroundSync?: {
-            name: string;
-            options?: QueueOptions;
-        };
-        /**
-         * Configuring this will add a
-         * `@serwist/broadcast-update.BroadcastUpdatePlugin` instance to the
-         * `@serwist/strategies` configured in `handler`.
-         */
-        broadcastUpdate?: {
-            channelName?: string;
-            options: BroadcastCacheUpdateOptions;
-        };
-        /**
-         * Configuring this will add a
-         * `@serwist/cacheable-response.CacheableResponsePlugin` instance to
-         * the `@serwist/strategies` configured in `handler`.
-         */
-        cacheableResponse?: CacheableResponseOptions;
-        /**
-         * If provided, this will set the `cacheName` property of the
-         * `@serwist/strategies` configured in `handler`.
-         */
-        cacheName?: string | null;
-        /**
-         * Configuring this will add a
-         * `@serwist/expiration.ExpirationPlugin` instance to
-         * the `@serwist/strategies` configured in `handler`.
-         */
-        expiration?: ExpirationPluginOptions;
-        /**
-         * If provided, this will set the `networkTimeoutSeconds` property of the
-         * `@serwist/strategies` configured in `handler`. Note that only
-         * `'NetworkFirst'` and `'NetworkOnly'` support `networkTimeoutSeconds`.
-         */
-        networkTimeoutSeconds?: number;
-        /**
-         * Configuring this allows the use of one or more Serwist plugins that
-         * don't have "shortcut" options (like `expiration` for
-         * `@serwist/expiration.ExpirationPlugin`). The plugins provided here
-         * will be added to the `@serwist/strategies` configured in `handler`.
-         */
-        plugins?: SerwistPlugin[];
-        /**
-         * Configuring this will add a
-         * `@serwist/precaching.PrecacheFallbackPlugin` instance to
-         * the `@serwist/strategies` configured in `handler`.
-         */
-        precacheFallback?: {
-            fallbackURL: string;
-        };
-        /**
-         * Enabling this will add a
-         * `@serwist/range-requests.RangeRequestsPlugin` instance to
-         * the `@serwist/strategies` configured in `handler`.
-         */
-        rangeRequests?: boolean;
-        /**
-         * Configuring this will pass along the `fetchOptions` value to
-         * the `@serwist/strategies` configured in `handler`.
-         */
-        fetchOptions?: RequestInit;
-        /**
-         * Configuring this will pass along the `matchOptions` value to
-         * the `@serwist/strategies` configured in `handler`.
-         */
-        matchOptions?: CacheQueryOptions;
-    };
     /**
      * 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 `urlPattern` matches will be the one that responds.
+     * 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.
      */
-    urlPattern: RegExp | string | RouteMatchCallback;
+    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/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAC7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,aAAa,GAAG,sBAAsB,CAAC;AAEhH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,OAAO,EAAE,YAAY,GAAG,YAAY,CAAC;IACrC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,OAAO,CAAC,EAAE;QACR;;;;WAIG;QACH,cAAc,CAAC,EAAE;YACf,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,CAAC,EAAE,YAAY,CAAC;SACxB,CAAC;QACF;;;;WAIG;QACH,eAAe,CAAC,EAAE;YAGhB,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,OAAO,EAAE,2BAA2B,CAAC;SACtC,CAAC;QACF;;;;WAIG;QACH,iBAAiB,CAAC,EAAE,wBAAwB,CAAC;QAC7C;;;WAGG;QACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B;;;;WAIG;QACH,UAAU,CAAC,EAAE,uBAAuB,CAAC;QACrC;;;;WAIG;QACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B;;;;;WAKG;QACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;QAC1B;;;;WAIG;QACH,gBAAgB,CAAC,EAAE;YACjB,WAAW,EAAE,MAAM,CAAC;SACrB,CAAC;QACF;;;;WAIG;QACH,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB;;;WAGG;QACH,YAAY,CAAC,EAAE,WAAW,CAAC;QAC3B;;;WAGG;QACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;KAClC,CAAC;IACF;;;;;;;;;OASG;IACH,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,CAAC;CAClD"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/sw",
-  "version": "9.0.0-preview.1",
+  "version": "9.0.0-preview.10",
   "type": "module",
   "description": "This module makes it easy to get started with the Serwist service worker libraries.",
   "files": [
@@ -28,23 +28,23 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/background-sync": "9.0.0-preview.1",
-    "@serwist/broadcast-update": "9.0.0-preview.1",
-    "@serwist/cacheable-response": "9.0.0-preview.1",
-    "@serwist/core": "9.0.0-preview.1",
-    "@serwist/expiration": "9.0.0-preview.1",
-    "@serwist/google-analytics": "9.0.0-preview.1",
-    "@serwist/navigation-preload": "9.0.0-preview.1",
-    "@serwist/precaching": "9.0.0-preview.1",
-    "@serwist/range-requests": "9.0.0-preview.1",
-    "@serwist/routing": "9.0.0-preview.1",
-    "@serwist/strategies": "9.0.0-preview.1"
+    "@serwist/background-sync": "9.0.0-preview.10",
+    "@serwist/broadcast-update": "9.0.0-preview.10",
+    "@serwist/cacheable-response": "9.0.0-preview.10",
+    "@serwist/core": "9.0.0-preview.10",
+    "@serwist/expiration": "9.0.0-preview.10",
+    "@serwist/google-analytics": "9.0.0-preview.10",
+    "@serwist/navigation-preload": "9.0.0-preview.10",
+    "@serwist/precaching": "9.0.0-preview.10",
+    "@serwist/range-requests": "9.0.0-preview.10",
+    "@serwist/routing": "9.0.0-preview.10",
+    "@serwist/strategies": "9.0.0-preview.10"
   },
   "devDependencies": {
     "rollup": "4.9.6",
-    "typescript": "5.4.0-dev.20240203",
-    "@serwist/constants": "9.0.0-preview.1",
-    "@serwist/utils": "9.0.0-preview.1"
+    "typescript": "5.4.0-dev.20240206",
+    "@serwist/constants": "9.0.0-preview.10",
+    "@serwist/utils": "9.0.0-preview.10"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/disableDevLogs.ts

@@ -1,7 +1,10 @@
-declare const self: WorkerGlobalScope & {
-  __WB_DISABLE_DEV_LOGS: boolean;
-};
+declare const self: ServiceWorkerGlobalScope;
 
-export const disableDevLogs = () => {
+/**
+ * Disables Serwist's logging in development mode.
+ *
+ * @see https://serwist.pages.dev/docs/sw/disable-dev-logs
+ */
+export const disableDevLogs = (): void => {
   self.__WB_DISABLE_DEV_LOGS = true;
 };

package/src/fallbacks.ts

@@ -1,66 +1,65 @@
 import type { HandlerDidErrorCallbackParam } from "@serwist/core";
 import type { PrecacheRouteOptions } from "@serwist/precaching";
-import { precacheAndRoute } from "@serwist/precaching";
+import { PrecacheFallbackPlugin, precacheAndRoute } from "@serwist/precaching";
+import type { PrecacheFallbackEntry } from "@serwist/precaching";
 
+import { Strategy } from "@serwist/strategies";
 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 {
+  /**
+   * Your previous `RuntimeCaching` array.
+   */
   runtimeCaching: RuntimeCaching[];
+  /**
+   * A list of fallback entries.
+   */
   entries: FallbackEntry[];
+  /**
+   * Precache options that will be used for your
+   * fallback entries.
+   */
   precacheOptions?: PrecacheRouteOptions;
 }
 
-export const fallbacks = ({ runtimeCaching, entries, precacheOptions }: FallbacksOptions) => {
-  precacheAndRoute(
-    entries.map(({ url, revision }) => ({ url: typeof url === "string" ? url : url.toString(), revision })),
-    precacheOptions,
-  );
-  runtimeCaching = runtimeCaching.map((cacheEntry) => {
-    if (!cacheEntry.options || cacheEntry.options.precacheFallback || cacheEntry.options.plugins?.some((plugin) => "handlerDidError" in plugin)) {
-      return cacheEntry;
-    }
+/**
+ * Precaches routes so that they can be used as a fallback when
+ * 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 array in `options`.
+ */
+export const fallbacks = ({ runtimeCaching, entries, precacheOptions }: FallbacksOptions): RuntimeCaching[] => {
+  precacheAndRoute(entries, precacheOptions);
 
-    if (!cacheEntry.options.plugins) {
-      cacheEntry.options.plugins = [];
-    }
+  const fallbackPlugin = new PrecacheFallbackPlugin({
+    fallbackUrls: entries,
+  });
 
-    cacheEntry.options.plugins.push({
-      async handlerDidError(info) {
-        for (const { matcher, url, cacheMatchOptions = { ignoreSearch: true } } of entries) {
-          if (matcher(info)) {
-            return caches.match(url, cacheMatchOptions);
-          }
-        }
-        return Response.error();
-      },
-    });
+  runtimeCaching.forEach((cacheEntry) => {
+    if (
+      cacheEntry.handler instanceof Strategy &&
+      // PrecacheFallbackPlugin also has `handlerDidError`, so we don't need to check for its instances.
+      !cacheEntry.handler.plugins.some((plugin) => "handlerDidError" in plugin)
+    ) {
+      cacheEntry.handler.plugins.push(fallbackPlugin);
+    }
 
     return cacheEntry;
   });
+
   return runtimeCaching;
 };

package/src/handlePrecaching.ts

@@ -1,20 +1,50 @@
 import type { PrecacheEntry, PrecacheRouteOptions } from "@serwist/precaching";
-import { cleanupOutdatedCaches, createHandlerBoundToURL, precacheAndRoute } from "@serwist/precaching";
+import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl, createHandlerBoundToURL, precacheAndRoute } from "@serwist/precaching";
 import { NavigationRoute, registerRoute } from "@serwist/routing";
 
 export type HandlePrecachingOptions = {
+  /**
+   * A list of fallback entries.
+   */
   precacheEntries?: (PrecacheEntry | string)[];
+  /**
+   * Precache options for the provided entries.
+   */
   precacheOptions?: PrecacheRouteOptions;
-
+  /**
+   * Whether outdated caches should be removed.
+   *
+   * @default false
+   */
   cleanupOutdatedCaches?: boolean;
-} & ({ navigateFallback: string; navigateFallbackAllowlist?: RegExp[]; navigateFallbackDenylist?: RegExp[] } | { navigateFallback?: never });
+} & (
+  | {
+      /**
+       * 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.
+       */
+      navigateFallback: string;
+      /**
+       * URLs that should be allowed to use the `navigateFallback` handler.
+       */
+      navigateFallbackAllowlist?: RegExp[];
+      /**
+       * URLs that should not be allowed to use the `navigateFallback` handler. This takes precedence
+       * over `navigateFallbackAllowlist`.
+       */
+      navigateFallbackDenylist?: RegExp[];
+    }
+  | { navigateFallback?: never }
+);
 
-export const handlePrecaching = ({
-  precacheEntries,
-  precacheOptions,
-  cleanupOutdatedCaches: shouldCleanupOutdatedCaches = false,
-  ...options
-}: HandlePrecachingOptions) => {
+/**
+ * Handles a list of precache entries and cleans up outdated caches.
+ *
+ * @see https://serwist.pages.dev/docs/sw/handlePrecaching
+ * @param options
+ */
+export const handlePrecaching = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches = false, ...options }: HandlePrecachingOptions): void => {
   if (!!precacheEntries && precacheEntries.length > 0) {
     /**
      * The precacheAndRoute() method efficiently caches and responds to
@@ -24,7 +54,7 @@ export const handlePrecaching = ({
     precacheAndRoute(precacheEntries, precacheOptions);
   }
 
-  if (shouldCleanupOutdatedCaches) cleanupOutdatedCaches();
+  if (cleanupOutdatedCaches) cleanupOutdatedCachesImpl();
 
   if (options.navigateFallback) {
     registerRoute(

package/src/installSerwist.ts

@@ -1,11 +1,11 @@
 import { clientsClaim as clientsClaimImpl, setCacheNameDetails } from "@serwist/core";
-import { logger } from "@serwist/core/internal";
 import { type GoogleAnalyticsInitializeOptions, initialize } from "@serwist/google-analytics/initialize";
 import { enable } from "@serwist/navigation-preload";
 
+import { logger } from "@serwist/core/internal";
 import { disableDevLogs as disableDevLogsImpl } from "./disableDevLogs.js";
-import type { FallbacksOptions } from "./fallbacks.js";
 import { fallbacks as fallbacksImpl } from "./fallbacks.js";
+import type { FallbacksOptions } from "./fallbacks.js";
 import { type HandlePrecachingOptions, handlePrecaching } from "./handlePrecaching.js";
 import { registerRuntimeCaching } from "./registerRuntimeCaching.js";
 import type { RuntimeCaching } from "./types.js";
@@ -13,14 +13,61 @@ import type { RuntimeCaching } from "./types.js";
 declare const self: ServiceWorkerGlobalScope;
 
 export type InstallSerwistOptions = 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 Preload 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/register-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
+   * @see https://serwist.pages.dev/docs/sw/disable-dev-logs
+   */
   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">;
 };
 
@@ -40,10 +87,10 @@ export const installSerwist = ({
   clientsClaim = false,
   runtimeCaching,
   offlineAnalyticsConfig,
-  disableDevLogs,
+  disableDevLogs = false,
   fallbacks,
   ...options
-}: InstallSerwistOptions) => {
+}: InstallSerwistOptions): void => {
   if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
 
   if (navigationPreload) enable();
@@ -82,13 +129,10 @@ export const installSerwist = ({
       self.__WB_FORCE_RUNTIME_CACHING = false;
     }
     if (!self.__WB_FORCE_RUNTIME_CACHING && process.env.NODE_ENV !== "production") {
-      logger.info("runtimeCaching and fallbacks are disabled in development mode.");
+      logger.log("runtimeCaching and fallbacks are disabled in development mode.");
     } else {
       if (fallbacks !== undefined) {
-        runtimeCaching = fallbacksImpl({
-          ...fallbacks,
-          runtimeCaching,
-        });
+        fallbacksImpl({ ...fallbacks, runtimeCaching });
       }
       registerRuntimeCaching(...runtimeCaching);
     }

package/src/registerRuntimeCaching.ts

@@ -1,78 +1,28 @@
-import { BackgroundSyncPlugin } from "@serwist/background-sync";
-import { BroadcastUpdatePlugin } from "@serwist/broadcast-update";
-import { CacheableResponsePlugin } from "@serwist/cacheable-response";
 import { logger } from "@serwist/core/internal";
-import { ExpirationPlugin } from "@serwist/expiration";
-import { PrecacheFallbackPlugin } from "@serwist/precaching";
-import { RangeRequestsPlugin } from "@serwist/range-requests";
 import { registerRoute } from "@serwist/routing";
-import { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate } from "@serwist/strategies";
-import { nonNullable } from "@serwist/utils";
 
-import type { RuntimeCaching, StrategyName } from "./types.js";
+import type { RuntimeCaching } from "./types.js";
 
 declare const self: ServiceWorkerGlobalScope;
 
-const HANDLER_NAME_TO_METHOD = {
-  CacheFirst,
-  CacheOnly,
-  NetworkFirst,
-  NetworkOnly,
-  StaleWhileRevalidate,
-} satisfies Record<StrategyName, unknown>;
-
-export const registerRuntimeCaching = (...runtimeCachingList: RuntimeCaching[]) => {
+/**
+ * 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
+ * @param runtimeCachingList
+ * @returns
+ */
+export const registerRuntimeCaching = (...runtimeCachingList: RuntimeCaching[]): void => {
   if (!("__WB_FORCE_RUNTIME_CACHING" in globalThis)) {
     self.__WB_FORCE_RUNTIME_CACHING = false;
   }
 
   if (!self.__WB_FORCE_RUNTIME_CACHING && process.env.NODE_ENV !== "production") {
-    logger.info("registerRuntimeCaching is disabled in development mode.");
-    return;
-  }
-
-  for (const rcEntry of runtimeCachingList) {
-    if (typeof rcEntry.handler === "string") {
-      const {
-        cacheName,
-        networkTimeoutSeconds,
-        fetchOptions,
-        matchOptions,
-        plugins,
-        backgroundSync,
-        broadcastUpdate,
-        cacheableResponse,
-        expiration,
-        precacheFallback,
-        rangeRequests,
-      } = rcEntry.options!; // entry.options is always defined when entry.handler is of type 'string'.
-      const Handler = HANDLER_NAME_TO_METHOD[rcEntry.handler];
-      registerRoute(
-        rcEntry.urlPattern,
-        new Handler({
-          cacheName: cacheName ?? undefined,
-          networkTimeoutSeconds,
-          fetchOptions,
-          matchOptions,
-          plugins: [
-            ...(plugins ?? []),
-            backgroundSync && new BackgroundSyncPlugin(backgroundSync.name, backgroundSync.options),
-            broadcastUpdate &&
-              new BroadcastUpdatePlugin({
-                // @ts-expect-error weird...
-                channelName: broadcastUpdate.channelName,
-                ...broadcastUpdate.options,
-              }),
-            cacheableResponse && new CacheableResponsePlugin(cacheableResponse),
-            expiration && new ExpirationPlugin(expiration),
-            precacheFallback && new PrecacheFallbackPlugin(precacheFallback),
-            rangeRequests ? new RangeRequestsPlugin() : undefined,
-          ].filter(nonNullable),
-        }),
-        rcEntry.method,
-      );
-    } else {
-      registerRoute(rcEntry.urlPattern, rcEntry.handler, rcEntry.method);
+    logger.log("registerRuntimeCaching is disabled in development mode.");
+  } else {
+    for (const entry of runtimeCachingList) {
+      registerRoute(entry.matcher, entry.handler, entry.method);
     }
   }
 };

package/src/types.ts

@@ -1,21 +1,7 @@
-import type { QueueOptions } from "@serwist/background-sync";
-import type { BroadcastCacheUpdateOptions } from "@serwist/broadcast-update";
-import type { CacheableResponseOptions } from "@serwist/cacheable-response";
-import type { RouteHandler, RouteMatchCallback, SerwistPlugin } from "@serwist/core";
-import type { ExpirationPluginOptions } from "@serwist/expiration";
+import type { RouteHandler, RouteMatchCallback } from "@serwist/core";
 import type { HTTPMethod } from "@serwist/routing";
 
-export type StrategyName = "CacheFirst" | "CacheOnly" | "NetworkFirst" | "NetworkOnly" | "StaleWhileRevalidate";
-
 export interface RuntimeCaching {
-  /**
-   * This determines how the runtime route will generate a response.
-   * To use one of the built-in `@serwist/strategies`, provide its name,
-   * like `'NetworkFirst'`.
-   * Alternatively, this can be a `@serwist/core.RouteHandler` callback
-   * function with custom response logic.
-   */
-  handler: RouteHandler | StrategyName;
   /**
    * The HTTP method to match against. The default value of `'GET'` is normally
    * sufficient, unless you explicitly need to match `'POST'`, `'PUT'`, or
@@ -23,91 +9,21 @@ export interface RuntimeCaching {
    * @default "GET"
    */
   method?: HTTPMethod;
-  options?: {
-    /**
-     * Configuring this will add a
-     * `@serwist/background-sync.BackgroundSyncPlugin` instance to the
-     * `@serwist/strategies` configured in `handler`.
-     */
-    backgroundSync?: {
-      name: string;
-      options?: QueueOptions;
-    };
-    /**
-     * Configuring this will add a
-     * `@serwist/broadcast-update.BroadcastUpdatePlugin` instance to the
-     * `@serwist/strategies` configured in `handler`.
-     */
-    broadcastUpdate?: {
-      // TODO: This option is ignored since we switched to using postMessage().
-      // Remove it in the next major release.
-      channelName?: string;
-      options: BroadcastCacheUpdateOptions;
-    };
-    /**
-     * Configuring this will add a
-     * `@serwist/cacheable-response.CacheableResponsePlugin` instance to
-     * the `@serwist/strategies` configured in `handler`.
-     */
-    cacheableResponse?: CacheableResponseOptions;
-    /**
-     * If provided, this will set the `cacheName` property of the
-     * `@serwist/strategies` configured in `handler`.
-     */
-    cacheName?: string | null;
-    /**
-     * Configuring this will add a
-     * `@serwist/expiration.ExpirationPlugin` instance to
-     * the `@serwist/strategies` configured in `handler`.
-     */
-    expiration?: ExpirationPluginOptions;
-    /**
-     * If provided, this will set the `networkTimeoutSeconds` property of the
-     * `@serwist/strategies` configured in `handler`. Note that only
-     * `'NetworkFirst'` and `'NetworkOnly'` support `networkTimeoutSeconds`.
-     */
-    networkTimeoutSeconds?: number;
-    /**
-     * Configuring this allows the use of one or more Serwist plugins that
-     * don't have "shortcut" options (like `expiration` for
-     * `@serwist/expiration.ExpirationPlugin`). The plugins provided here
-     * will be added to the `@serwist/strategies` configured in `handler`.
-     */
-    plugins?: SerwistPlugin[];
-    /**
-     * Configuring this will add a
-     * `@serwist/precaching.PrecacheFallbackPlugin` instance to
-     * the `@serwist/strategies` configured in `handler`.
-     */
-    precacheFallback?: {
-      fallbackURL: string;
-    };
-    /**
-     * Enabling this will add a
-     * `@serwist/range-requests.RangeRequestsPlugin` instance to
-     * the `@serwist/strategies` configured in `handler`.
-     */
-    rangeRequests?: boolean;
-    /**
-     * Configuring this will pass along the `fetchOptions` value to
-     * the `@serwist/strategies` configured in `handler`.
-     */
-    fetchOptions?: RequestInit;
-    /**
-     * Configuring this will pass along the `matchOptions` value to
-     * the `@serwist/strategies` configured in `handler`.
-     */
-    matchOptions?: CacheQueryOptions;
-  };
   /**
    * 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 `urlPattern` matches will be the one that responds.
+   * 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.
    */
-  urlPattern: RegExp | string | RouteMatchCallback;
+  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;
 }