@serwist/sw 8.4.4 → 9.0.0-preview.1

package/dist/disableDevLogs.d.ts

@@ -1 +1,2 @@
 export declare const disableDevLogs: () => void;
+//# sourceMappingURL=disableDevLogs.d.ts.map

package/dist/disableDevLogs.d.ts.map

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

package/dist/fallbacks.d.ts

@@ -1,6 +1,6 @@
-import type { RuntimeCaching } from "@serwist/build";
 import type { HandlerDidErrorCallbackParam } from "@serwist/core";
 import type { PrecacheRouteOptions } from "@serwist/precaching";
+import type { RuntimeCaching } from "./types.js";
 export type FallbackMatcher = (_: HandlerDidErrorCallbackParam) => boolean;
 export interface FallbackEntry {
     /**
@@ -30,3 +30,4 @@ export interface FallbacksOptions {
     precacheOptions?: PrecacheRouteOptions;
 }
 export declare const fallbacks: ({ runtimeCaching, entries, precacheOptions }: FallbacksOptions) => RuntimeCaching[];
+//# sourceMappingURL=fallbacks.d.ts.map

package/dist/fallbacks.d.ts.map

@@ -0,0 +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"}

package/dist/handlePrecaching.d.ts

@@ -11,3 +11,4 @@ export type HandlePrecachingOptions = {
     navigateFallback?: never;
 });
 export declare const handlePrecaching: ({ precacheEntries, precacheOptions, cleanupOutdatedCaches: shouldCleanupOutdatedCaches, ...options }: HandlePrecachingOptions) => void;
+//# sourceMappingURL=handlePrecaching.d.ts.map

package/dist/handlePrecaching.d.ts.map

@@ -0,0 +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"}

package/dist/index.d.ts

@@ -1,25 +1,10 @@
-import type { RuntimeCaching } from "@serwist/build";
-import { type GoogleAnalyticsInitializeOptions } from "@serwist/google-analytics/initialize";
 import { disableDevLogs } from "./disableDevLogs.js";
 import type { FallbackEntry, FallbackMatcher, FallbacksOptions } from "./fallbacks.js";
 import { fallbacks } from "./fallbacks.js";
 import { type HandlePrecachingOptions, handlePrecaching } from "./handlePrecaching.js";
+import { type InstallSerwistOptions, installSerwist } from "./installSerwist.js";
 import { registerRuntimeCaching } from "./registerRuntimeCaching.js";
-export type SerwistOptions = HandlePrecachingOptions & {
-    skipWaiting?: boolean;
-    importScripts?: string[];
-    navigationPreload?: boolean;
-    cacheId?: string | undefined;
-    clientsClaim?: boolean;
-    runtimeCaching?: RuntimeCaching[];
-    offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
-    disableDevLogs?: boolean;
-    fallbacks?: Omit<FallbacksOptions, "runtimeCaching">;
-};
-/**
- * A function that abstracts away the core APIs of Serwist.
- * @param options - `installSerwist` options.
- */
-export declare const installSerwist: ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting: shouldSkipWaiting, importScripts: scriptsToImport, navigationPreload, cacheId, clientsClaim: shouldClaimClients, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: shouldDisableDevLogs, fallbacks: fallbacksOptions, ...options }: SerwistOptions) => void;
-export { disableDevLogs, fallbacks, handlePrecaching, registerRuntimeCaching };
-export type { FallbackEntry, FallbackMatcher, FallbacksOptions, HandlePrecachingOptions };
+import type { RuntimeCaching } from "./types.js";
+export { disableDevLogs, fallbacks, handlePrecaching, installSerwist, registerRuntimeCaching };
+export type { FallbackEntry, FallbackMatcher, FallbacksOptions, HandlePrecachingOptions, InstallSerwistOptions as SerwistOptions, RuntimeCaching };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvF,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,KAAK,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAE,KAAK,qBAAqB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,gBAAgB,EAAE,cAAc,EAAE,sBAAsB,EAAE,CAAC;AAC/F,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,qBAAqB,IAAI,cAAc,EAAE,cAAc,EAAE,CAAC"}

package/dist/index.js

@@ -1,8 +1,9 @@
+import { precacheAndRoute, cleanupOutdatedCaches, createHandlerBoundToURL, PrecacheFallbackPlugin } from '@serwist/precaching';
+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 { precacheAndRoute, cleanupOutdatedCaches, createHandlerBoundToURL, PrecacheFallbackPlugin } from '@serwist/precaching';
-import { registerRoute, NavigationRoute } from '@serwist/routing';
 import { BackgroundSyncPlugin } from '@serwist/background-sync';
 import { BroadcastUpdatePlugin } from '@serwist/broadcast-update';
 import { CacheableResponsePlugin } from '@serwist/cacheable-response';
@@ -45,11 +46,7 @@ const fallbacks = ({ runtimeCaching, entries, precacheOptions })=>{
 
 const handlePrecaching = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches: shouldCleanupOutdatedCaches = false, ...options })=>{
     if (!!precacheEntries && precacheEntries.length > 0) {
-        /**
-     * The precacheAndRoute() method efficiently caches and responds to
-     * requests for URLs in the manifest.
-     * See https://goo.gl/S9QRab
-     */ precacheAndRoute(precacheEntries, precacheOptions);
+        precacheAndRoute(precacheEntries, precacheOptions);
     }
     if (shouldCleanupOutdatedCaches) cleanupOutdatedCaches();
     if (options.navigateFallback) {
@@ -70,9 +67,16 @@ const HANDLER_NAME_TO_METHOD = {
     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; // entry.options is always defined when entry.handler is of type '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,
@@ -83,7 +87,6 @@ const registerRuntimeCaching = (...runtimeCachingList)=>{
                     ...plugins ?? [],
                     backgroundSync && new BackgroundSyncPlugin(backgroundSync.name, backgroundSync.options),
                     broadcastUpdate && new BroadcastUpdatePlugin({
-                        // @ts-expect-error weird...
                         channelName: broadcastUpdate.channelName,
                         ...broadcastUpdate.options
                     }),
@@ -99,16 +102,15 @@ const registerRuntimeCaching = (...runtimeCachingList)=>{
     }
 };
 
-/**
- * A function that abstracts away the core APIs of Serwist.
- * @param options - `installSerwist` options.
- */ const installSerwist = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting: shouldSkipWaiting = false, importScripts: scriptsToImport, navigationPreload = false, cacheId, clientsClaim: shouldClaimClients = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: shouldDisableDevLogs, fallbacks: fallbacksOptions, ...options })=>{
-    if (!!scriptsToImport && scriptsToImport.length > 0) self.importScripts(...scriptsToImport);
+const installSerwist = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1, fallbacks: fallbacks$1, ...options })=>{
+    if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
     if (navigationPreload) enable();
-    if (cacheId !== undefined) setCacheNameDetails({
-        prefix: cacheId
-    });
-    if (shouldSkipWaiting) {
+    if (cacheId !== undefined) {
+        setCacheNameDetails({
+            prefix: cacheId
+        });
+    }
+    if (skipWaiting) {
         self.skipWaiting();
     } else {
         self.addEventListener("message", (event)=>{
@@ -117,7 +119,7 @@ const registerRuntimeCaching = (...runtimeCachingList)=>{
             }
         });
     }
-    if (shouldClaimClients) clientsClaim();
+    if (clientsClaim$1) clientsClaim();
     handlePrecaching({
         precacheEntries,
         precacheOptions,
@@ -129,13 +131,20 @@ const registerRuntimeCaching = (...runtimeCachingList)=>{
         }
     });
     if (runtimeCaching !== undefined) {
-        if (fallbacksOptions !== undefined) {
-            runtimeCaching = fallbacks({
-                ...fallbacksOptions,
-                runtimeCaching
-            });
+        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("runtimeCaching and fallbacks are disabled in development mode.");
+        } else {
+            if (fallbacks$1 !== undefined) {
+                runtimeCaching = fallbacks({
+                    ...fallbacks$1,
+                    runtimeCaching
+                });
+            }
+            registerRuntimeCaching(...runtimeCaching);
         }
-        registerRuntimeCaching(...runtimeCaching);
     }
     if (offlineAnalyticsConfig !== undefined) {
         if (typeof offlineAnalyticsConfig === "boolean") {
@@ -144,7 +153,7 @@ const registerRuntimeCaching = (...runtimeCachingList)=>{
             initialize(offlineAnalyticsConfig);
         }
     }
-    if (shouldDisableDevLogs) disableDevLogs();
+    if (disableDevLogs$1) disableDevLogs();
 };
 
 export { disableDevLogs, fallbacks, handlePrecaching, installSerwist, registerRuntimeCaching };

package/dist/installSerwist.d.ts

@@ -0,0 +1,21 @@
+import { type GoogleAnalyticsInitializeOptions } from "@serwist/google-analytics/initialize";
+import type { FallbacksOptions } from "./fallbacks.js";
+import { type HandlePrecachingOptions } from "./handlePrecaching.js";
+import type { RuntimeCaching } from "./types.js";
+export type InstallSerwistOptions = HandlePrecachingOptions & {
+    skipWaiting?: boolean;
+    importScripts?: string[];
+    navigationPreload?: boolean;
+    cacheId?: string | undefined;
+    clientsClaim?: boolean;
+    runtimeCaching?: RuntimeCaching[];
+    offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
+    disableDevLogs?: boolean;
+    fallbacks?: Omit<FallbacksOptions, "runtimeCaching">;
+};
+/**
+ * A function that 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

package/dist/installSerwist.d.ts.map

@@ -0,0 +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"}

package/dist/registerRuntimeCaching.d.ts

@@ -1,2 +1,3 @@
-import type { RuntimeCaching } from "@serwist/build";
+import type { RuntimeCaching } from "./types.js";
 export declare const registerRuntimeCaching: (...runtimeCachingList: RuntimeCaching[]) => void;
+//# sourceMappingURL=registerRuntimeCaching.d.ts.map

package/dist/registerRuntimeCaching.d.ts.map

@@ -0,0 +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"}

package/dist/types.d.ts

@@ -0,0 +1,110 @@
+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 { 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
+     * another type of request.
+     * @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.
+     *
+     * 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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +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"}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@serwist/sw",
-  "version": "8.4.4",
+  "version": "9.0.0-preview.1",
   "type": "module",
   "description": "This module makes it easy to get started with the Serwist service worker libraries.",
   "files": [
-    "dist",
-    "!dist/**/dts"
+    "src",
+    "dist"
   ],
   "keywords": [
     "serwist",
@@ -18,39 +18,41 @@
   "repository": "serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
-  "module": "./dist/index.js",
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/background-sync": "8.4.4",
-    "@serwist/broadcast-update": "8.4.4",
-    "@serwist/cacheable-response": "8.4.4",
-    "@serwist/core": "8.4.4",
-    "@serwist/expiration": "8.4.4",
-    "@serwist/google-analytics": "8.4.4",
-    "@serwist/navigation-preload": "8.4.4",
-    "@serwist/precaching": "8.4.4",
-    "@serwist/range-requests": "8.4.4",
-    "@serwist/routing": "8.4.4",
-    "@serwist/strategies": "8.4.4"
+    "@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"
   },
   "devDependencies": {
-    "rollup": "4.9.1",
-    "@serwist/build": "8.4.4",
-    "@serwist/constants": "8.4.4"
+    "rollup": "4.9.6",
+    "typescript": "5.4.0-dev.20240203",
+    "@serwist/constants": "9.0.0-preview.1",
+    "@serwist/utils": "9.0.0-preview.1"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",

package/src/disableDevLogs.ts

@@ -0,0 +1,7 @@
+declare const self: WorkerGlobalScope & {
+  __WB_DISABLE_DEV_LOGS: boolean;
+};
+
+export const disableDevLogs = () => {
+  self.__WB_DISABLE_DEV_LOGS = true;
+};

package/src/fallbacks.ts

@@ -0,0 +1,66 @@
+import type { HandlerDidErrorCallbackParam } from "@serwist/core";
+import type { PrecacheRouteOptions } from "@serwist/precaching";
+import { precacheAndRoute } 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;
+  /**
+   * The revision used for precaching.
+   */
+  revision: string;
+  /**
+   * How the Response in the cache should be matched.
+   *
+   * @default
+   * { ignoreSearch: true }
+   */
+  cacheMatchOptions?: MultiCacheQueryOptions;
+}
+
+export interface FallbacksOptions {
+  runtimeCaching: RuntimeCaching[];
+  entries: FallbackEntry[];
+  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;
+    }
+
+    if (!cacheEntry.options.plugins) {
+      cacheEntry.options.plugins = [];
+    }
+
+    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;
+};

package/src/handlePrecaching.ts

@@ -0,0 +1,37 @@
+import type { PrecacheEntry, PrecacheRouteOptions } from "@serwist/precaching";
+import { cleanupOutdatedCaches, createHandlerBoundToURL, precacheAndRoute } from "@serwist/precaching";
+import { NavigationRoute, registerRoute } from "@serwist/routing";
+
+export type HandlePrecachingOptions = {
+  precacheEntries?: (PrecacheEntry | string)[];
+  precacheOptions?: PrecacheRouteOptions;
+
+  cleanupOutdatedCaches?: boolean;
+} & ({ navigateFallback: string; navigateFallbackAllowlist?: RegExp[]; navigateFallbackDenylist?: RegExp[] } | { navigateFallback?: never });
+
+export const handlePrecaching = ({
+  precacheEntries,
+  precacheOptions,
+  cleanupOutdatedCaches: shouldCleanupOutdatedCaches = false,
+  ...options
+}: HandlePrecachingOptions) => {
+  if (!!precacheEntries && precacheEntries.length > 0) {
+    /**
+     * The precacheAndRoute() method efficiently caches and responds to
+     * requests for URLs in the manifest.
+     * See https://goo.gl/S9QRab
+     */
+    precacheAndRoute(precacheEntries, precacheOptions);
+  }
+
+  if (shouldCleanupOutdatedCaches) cleanupOutdatedCaches();
+
+  if (options.navigateFallback) {
+    registerRoute(
+      new NavigationRoute(createHandlerBoundToURL(options.navigateFallback), {
+        allowlist: options.navigateFallbackAllowlist,
+        denylist: options.navigateFallbackDenylist,
+      }),
+    );
+  }
+};

package/src/index.ts

@@ -0,0 +1,10 @@
+import { disableDevLogs } from "./disableDevLogs.js";
+import type { FallbackEntry, FallbackMatcher, FallbacksOptions } from "./fallbacks.js";
+import { fallbacks } from "./fallbacks.js";
+import { type HandlePrecachingOptions, handlePrecaching } from "./handlePrecaching.js";
+import { type InstallSerwistOptions, installSerwist } from "./installSerwist.js";
+import { registerRuntimeCaching } from "./registerRuntimeCaching.js";
+import type { RuntimeCaching } from "./types.js";
+
+export { disableDevLogs, fallbacks, handlePrecaching, installSerwist, registerRuntimeCaching };
+export type { FallbackEntry, FallbackMatcher, FallbacksOptions, HandlePrecachingOptions, InstallSerwistOptions as SerwistOptions, RuntimeCaching };

package/src/installSerwist.ts

@@ -0,0 +1,106 @@
+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 { disableDevLogs as disableDevLogsImpl } from "./disableDevLogs.js";
+import type { FallbacksOptions } from "./fallbacks.js";
+import { fallbacks as fallbacksImpl } from "./fallbacks.js";
+import { type HandlePrecachingOptions, handlePrecaching } from "./handlePrecaching.js";
+import { registerRuntimeCaching } from "./registerRuntimeCaching.js";
+import type { RuntimeCaching } from "./types.js";
+
+declare const self: ServiceWorkerGlobalScope;
+
+export type InstallSerwistOptions = HandlePrecachingOptions & {
+  skipWaiting?: boolean;
+  importScripts?: string[];
+  navigationPreload?: boolean;
+  cacheId?: string | undefined;
+  clientsClaim?: boolean;
+  runtimeCaching?: RuntimeCaching[];
+  offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
+  disableDevLogs?: boolean;
+  fallbacks?: Omit<FallbacksOptions, "runtimeCaching">;
+};
+
+/**
+ * A function that abstracts away the core APIs of Serwist.
+ * @param options - `installSerwist` options.
+ */
+export const installSerwist = ({
+  precacheEntries,
+  precacheOptions,
+  cleanupOutdatedCaches,
+
+  skipWaiting = false,
+  importScripts,
+  navigationPreload = false,
+  cacheId,
+  clientsClaim = false,
+  runtimeCaching,
+  offlineAnalyticsConfig,
+  disableDevLogs,
+  fallbacks,
+  ...options
+}: InstallSerwistOptions) => {
+  if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
+
+  if (navigationPreload) enable();
+
+  if (cacheId !== undefined) {
+    setCacheNameDetails({
+      prefix: cacheId,
+    });
+  }
+
+  if (skipWaiting) {
+    self.skipWaiting();
+  } else {
+    self.addEventListener("message", (event) => {
+      if (event.data && event.data.type === "SKIP_WAITING") {
+        self.skipWaiting();
+      }
+    });
+  }
+
+  if (clientsClaim) clientsClaimImpl();
+
+  handlePrecaching({
+    precacheEntries,
+    precacheOptions,
+    cleanupOutdatedCaches,
+    ...(options.navigateFallback && {
+      navigateFallback: options.navigateFallback,
+      navigateFallbackAllowlist: options.navigateFallbackAllowlist,
+      navigateFallbackDenylist: options.navigateFallbackDenylist,
+    }),
+  });
+
+  if (runtimeCaching !== undefined) {
+    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("runtimeCaching and fallbacks are disabled in development mode.");
+    } else {
+      if (fallbacks !== undefined) {
+        runtimeCaching = fallbacksImpl({
+          ...fallbacks,
+          runtimeCaching,
+        });
+      }
+      registerRuntimeCaching(...runtimeCaching);
+    }
+  }
+
+  if (offlineAnalyticsConfig !== undefined) {
+    if (typeof offlineAnalyticsConfig === "boolean") {
+      offlineAnalyticsConfig && initialize();
+    } else {
+      initialize(offlineAnalyticsConfig);
+    }
+  }
+
+  if (disableDevLogs) disableDevLogsImpl();
+};

package/src/registerRuntimeCaching.ts

@@ -0,0 +1,78 @@
+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";
+
+declare const self: ServiceWorkerGlobalScope;
+
+const HANDLER_NAME_TO_METHOD = {
+  CacheFirst,
+  CacheOnly,
+  NetworkFirst,
+  NetworkOnly,
+  StaleWhileRevalidate,
+} satisfies Record<StrategyName, unknown>;
+
+export const registerRuntimeCaching = (...runtimeCachingList: RuntimeCaching[]) => {
+  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);
+    }
+  }
+};

package/src/types.ts

@@ -0,0 +1,113 @@
+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 { 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
+   * another type of request.
+   * @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.
+   *
+   * 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;
+}

package/dist/index.cjs

@@ -1,156 +0,0 @@
-'use strict';
-
-var core = require('@serwist/core');
-var initialize = require('@serwist/google-analytics/initialize');
-var navigationPreload = require('@serwist/navigation-preload');
-var precaching = require('@serwist/precaching');
-var routing = require('@serwist/routing');
-var backgroundSync = require('@serwist/background-sync');
-var broadcastUpdate = require('@serwist/broadcast-update');
-var cacheableResponse = require('@serwist/cacheable-response');
-var expiration = require('@serwist/expiration');
-var rangeRequests = require('@serwist/range-requests');
-var strategies = require('@serwist/strategies');
-
-const disableDevLogs = ()=>{
-    self.__WB_DISABLE_DEV_LOGS = true;
-};
-
-const fallbacks = ({ runtimeCaching, entries, precacheOptions })=>{
-    precaching.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 = [];
-        }
-        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 })=>{
-    if (!!precacheEntries && precacheEntries.length > 0) {
-        /**
-     * The precacheAndRoute() method efficiently caches and responds to
-     * requests for URLs in the manifest.
-     * See https://goo.gl/S9QRab
-     */ precaching.precacheAndRoute(precacheEntries, precacheOptions);
-    }
-    if (shouldCleanupOutdatedCaches) precaching.cleanupOutdatedCaches();
-    if (options.navigateFallback) {
-        routing.registerRoute(new routing.NavigationRoute(precaching.createHandlerBoundToURL(options.navigateFallback), {
-            allowlist: options.navigateFallbackAllowlist,
-            denylist: options.navigateFallbackDenylist
-        }));
-    }
-};
-
-const nonNullable = (value)=>value !== null && value !== undefined;
-
-const HANDLER_NAME_TO_METHOD = {
-    CacheFirst: strategies.CacheFirst,
-    CacheOnly: strategies.CacheOnly,
-    NetworkFirst: strategies.NetworkFirst,
-    NetworkOnly: strategies.NetworkOnly,
-    StaleWhileRevalidate: strategies.StaleWhileRevalidate
-};
-const registerRuntimeCaching = (...runtimeCachingList)=>{
-    for (const rcEntry of runtimeCachingList){
-        if (typeof rcEntry.handler === "string") {
-            const { cacheName, networkTimeoutSeconds, fetchOptions, matchOptions, plugins, backgroundSync: backgroundSync$1, broadcastUpdate: broadcastUpdate$1, cacheableResponse: cacheableResponse$1, expiration: expiration$1, precacheFallback, rangeRequests: rangeRequests$1 } = rcEntry.options; // entry.options is always defined when entry.handler is of type 'string'.
-            const Handler = HANDLER_NAME_TO_METHOD[rcEntry.handler];
-            routing.registerRoute(rcEntry.urlPattern, new Handler({
-                cacheName: cacheName ?? undefined,
-                networkTimeoutSeconds,
-                fetchOptions,
-                matchOptions,
-                plugins: [
-                    ...plugins ?? [],
-                    backgroundSync$1 && new backgroundSync.BackgroundSyncPlugin(backgroundSync$1.name, backgroundSync$1.options),
-                    broadcastUpdate$1 && new broadcastUpdate.BroadcastUpdatePlugin({
-                        // @ts-expect-error weird...
-                        channelName: broadcastUpdate$1.channelName,
-                        ...broadcastUpdate$1.options
-                    }),
-                    cacheableResponse$1 && new cacheableResponse.CacheableResponsePlugin(cacheableResponse$1),
-                    expiration$1 && new expiration.ExpirationPlugin(expiration$1),
-                    precacheFallback && new precaching.PrecacheFallbackPlugin(precacheFallback),
-                    rangeRequests$1 ? new rangeRequests.RangeRequestsPlugin() : undefined
-                ].filter(nonNullable)
-            }), rcEntry.method);
-        } else {
-            routing.registerRoute(rcEntry.urlPattern, rcEntry.handler, rcEntry.method);
-        }
-    }
-};
-
-/**
- * A function that abstracts away the core APIs of Serwist.
- * @param options - `installSerwist` options.
- */ const installSerwist = ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting: shouldSkipWaiting = false, importScripts: scriptsToImport, navigationPreload: navigationPreload$1 = false, cacheId, clientsClaim: shouldClaimClients = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: shouldDisableDevLogs, fallbacks: fallbacksOptions, ...options })=>{
-    if (!!scriptsToImport && scriptsToImport.length > 0) self.importScripts(...scriptsToImport);
-    if (navigationPreload$1) navigationPreload.enable();
-    if (cacheId !== undefined) core.setCacheNameDetails({
-        prefix: cacheId
-    });
-    if (shouldSkipWaiting) {
-        self.skipWaiting();
-    } else {
-        self.addEventListener("message", (event)=>{
-            if (event.data && event.data.type === "SKIP_WAITING") {
-                self.skipWaiting();
-            }
-        });
-    }
-    if (shouldClaimClients) core.clientsClaim();
-    handlePrecaching({
-        precacheEntries,
-        precacheOptions,
-        cleanupOutdatedCaches,
-        ...options.navigateFallback && {
-            navigateFallback: options.navigateFallback,
-            navigateFallbackAllowlist: options.navigateFallbackAllowlist,
-            navigateFallbackDenylist: options.navigateFallbackDenylist
-        }
-    });
-    if (runtimeCaching !== undefined) {
-        if (fallbacksOptions !== undefined) {
-            runtimeCaching = fallbacks({
-                ...fallbacksOptions,
-                runtimeCaching
-            });
-        }
-        registerRuntimeCaching(...runtimeCaching);
-    }
-    if (offlineAnalyticsConfig !== undefined) {
-        if (typeof offlineAnalyticsConfig === "boolean") {
-            offlineAnalyticsConfig && initialize.initialize();
-        } else {
-            initialize.initialize(offlineAnalyticsConfig);
-        }
-    }
-    if (shouldDisableDevLogs) disableDevLogs();
-};
-
-exports.disableDevLogs = disableDevLogs;
-exports.fallbacks = fallbacks;
-exports.handlePrecaching = handlePrecaching;
-exports.installSerwist = installSerwist;
-exports.registerRuntimeCaching = registerRuntimeCaching;

package/dist/index.d.cts

@@ -1,25 +0,0 @@
-import type { RuntimeCaching } from "@serwist/build";
-import { type GoogleAnalyticsInitializeOptions } from "@serwist/google-analytics/initialize";
-import { disableDevLogs } from "./disableDevLogs.js";
-import type { FallbackEntry, FallbackMatcher, FallbacksOptions } from "./fallbacks.js";
-import { fallbacks } from "./fallbacks.js";
-import { type HandlePrecachingOptions, handlePrecaching } from "./handlePrecaching.js";
-import { registerRuntimeCaching } from "./registerRuntimeCaching.js";
-export type SerwistOptions = HandlePrecachingOptions & {
-    skipWaiting?: boolean;
-    importScripts?: string[];
-    navigationPreload?: boolean;
-    cacheId?: string | undefined;
-    clientsClaim?: boolean;
-    runtimeCaching?: RuntimeCaching[];
-    offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
-    disableDevLogs?: boolean;
-    fallbacks?: Omit<FallbacksOptions, "runtimeCaching">;
-};
-/**
- * A function that abstracts away the core APIs of Serwist.
- * @param options - `installSerwist` options.
- */
-export declare const installSerwist: ({ precacheEntries, precacheOptions, cleanupOutdatedCaches, skipWaiting: shouldSkipWaiting, importScripts: scriptsToImport, navigationPreload, cacheId, clientsClaim: shouldClaimClients, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: shouldDisableDevLogs, fallbacks: fallbacksOptions, ...options }: SerwistOptions) => void;
-export { disableDevLogs, fallbacks, handlePrecaching, registerRuntimeCaching };
-export type { FallbackEntry, FallbackMatcher, FallbacksOptions, HandlePrecachingOptions };

package/dist/nonNullable.d.ts

@@ -1 +0,0 @@
-export declare const nonNullable: <T>(value: T) => value is NonNullable<T>;