@serwist/sw 9.0.0-preview.17 → 9.0.0-preview.19

package/dist/chunks/registerRoute.js

@@ -0,0 +1,408 @@
+import { assert, logger, getFriendlyURL, SerwistError } from '@serwist/core/internal';
+
+const defaultMethod = "GET";
+const validMethods = [
+    "DELETE",
+    "GET",
+    "HEAD",
+    "PATCH",
+    "POST",
+    "PUT"
+];
+
+const normalizeHandler = (handler)=>{
+    if (handler && typeof handler === "object") {
+        if (process.env.NODE_ENV !== "production") {
+            assert.hasMethod(handler, "handle", {
+                moduleName: "@serwist/routing",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "handler"
+            });
+        }
+        return handler;
+    }
+    if (process.env.NODE_ENV !== "production") {
+        assert.isType(handler, "function", {
+            moduleName: "@serwist/routing",
+            className: "Route",
+            funcName: "constructor",
+            paramName: "handler"
+        });
+    }
+    return {
+        handle: handler
+    };
+};
+
+class Route {
+    handler;
+    match;
+    method;
+    catchHandler;
+    constructor(match, handler, method = defaultMethod){
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(match, "function", {
+                moduleName: "@serwist/routing",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "match"
+            });
+            if (method) {
+                assert.isOneOf(method, validMethods, {
+                    paramName: "method"
+                });
+            }
+        }
+        this.handler = normalizeHandler(handler);
+        this.match = match;
+        this.method = method;
+    }
+    setCatchHandler(handler) {
+        this.catchHandler = normalizeHandler(handler);
+    }
+}
+
+class Router {
+    _routes;
+    _defaultHandlerMap;
+    _catchHandler;
+    constructor(){
+        this._routes = new Map();
+        this._defaultHandlerMap = new Map();
+    }
+    get routes() {
+        return this._routes;
+    }
+    addFetchListener() {
+        self.addEventListener("fetch", (event)=>{
+            const { request } = event;
+            const responsePromise = this.handleRequest({
+                request,
+                event
+            });
+            if (responsePromise) {
+                event.respondWith(responsePromise);
+            }
+        });
+    }
+    addCacheListener() {
+        self.addEventListener("message", (event)=>{
+            if (event.data && event.data.type === "CACHE_URLS") {
+                const { payload } = event.data;
+                if (process.env.NODE_ENV !== "production") {
+                    logger.debug("Caching URLs from the window", payload.urlsToCache);
+                }
+                const requestPromises = Promise.all(payload.urlsToCache.map((entry)=>{
+                    if (typeof entry === "string") {
+                        entry = [
+                            entry
+                        ];
+                    }
+                    const request = new Request(...entry);
+                    return this.handleRequest({
+                        request,
+                        event
+                    });
+                }));
+                event.waitUntil(requestPromises);
+                if (event.ports?.[0]) {
+                    void requestPromises.then(()=>event.ports[0].postMessage(true));
+                }
+            }
+        });
+    }
+    handleRequest({ request, event }) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isInstance(request, Request, {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "handleRequest",
+                paramName: "options.request"
+            });
+        }
+        const url = new URL(request.url, location.href);
+        if (!url.protocol.startsWith("http")) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug("The Serwist router only supports URLs that start with 'http'.");
+            }
+            return;
+        }
+        const sameOrigin = url.origin === location.origin;
+        const { params, route } = this.findMatchingRoute({
+            event,
+            request,
+            sameOrigin,
+            url
+        });
+        let handler = route?.handler;
+        const debugMessages = [];
+        if (process.env.NODE_ENV !== "production") {
+            if (handler) {
+                debugMessages.push([
+                    "Found a route to handle this request:",
+                    route
+                ]);
+                if (params) {
+                    debugMessages.push([
+                        `Passing the following params to the route's handler:`,
+                        params
+                    ]);
+                }
+            }
+        }
+        const method = request.method;
+        if (!handler && this._defaultHandlerMap.has(method)) {
+            if (process.env.NODE_ENV !== "production") {
+                debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
+            }
+            handler = this._defaultHandlerMap.get(method);
+        }
+        if (!handler) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`No route found for: ${getFriendlyURL(url)}`);
+            }
+            return;
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+            for (const msg of debugMessages){
+                if (Array.isArray(msg)) {
+                    logger.log(...msg);
+                } else {
+                    logger.log(msg);
+                }
+            }
+            logger.groupEnd();
+        }
+        let responsePromise;
+        try {
+            responsePromise = handler.handle({
+                url,
+                request,
+                event,
+                params
+            });
+        } catch (err) {
+            responsePromise = Promise.reject(err);
+        }
+        const catchHandler = route?.catchHandler;
+        if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {
+            responsePromise = responsePromise.catch(async (err)=>{
+                if (catchHandler) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
+                        logger.error("Error thrown by:", route);
+                        logger.error(err);
+                        logger.groupEnd();
+                    }
+                    try {
+                        return await catchHandler.handle({
+                            url,
+                            request,
+                            event,
+                            params
+                        });
+                    } catch (catchErr) {
+                        if (catchErr instanceof Error) {
+                            err = catchErr;
+                        }
+                    }
+                }
+                if (this._catchHandler) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
+                        logger.error("Error thrown by:", route);
+                        logger.error(err);
+                        logger.groupEnd();
+                    }
+                    return this._catchHandler.handle({
+                        url,
+                        request,
+                        event
+                    });
+                }
+                throw err;
+            });
+        }
+        return responsePromise;
+    }
+    findMatchingRoute({ url, sameOrigin, request, event }) {
+        const routes = this._routes.get(request.method) || [];
+        for (const route of routes){
+            let params;
+            const matchResult = route.match({
+                url,
+                sameOrigin,
+                request,
+                event
+            });
+            if (matchResult) {
+                if (process.env.NODE_ENV !== "production") {
+                    if (matchResult instanceof Promise) {
+                        logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
+                    }
+                }
+                params = matchResult;
+                if (Array.isArray(params) && params.length === 0) {
+                    params = undefined;
+                } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
+                    params = undefined;
+                } else if (typeof matchResult === "boolean") {
+                    params = undefined;
+                }
+                return {
+                    route,
+                    params
+                };
+            }
+        }
+        return {};
+    }
+    setDefaultHandler(handler, method = defaultMethod) {
+        this._defaultHandlerMap.set(method, normalizeHandler(handler));
+    }
+    setCatchHandler(handler) {
+        this._catchHandler = normalizeHandler(handler);
+    }
+    registerRoute(route) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(route, "object", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route"
+            });
+            assert.hasMethod(route, "match", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route"
+            });
+            assert.isType(route.handler, "object", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route"
+            });
+            assert.hasMethod(route.handler, "handle", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route.handler"
+            });
+            assert.isType(route.method, "string", {
+                moduleName: "@serwist/routing",
+                className: "Router",
+                funcName: "registerRoute",
+                paramName: "route.method"
+            });
+        }
+        if (!this._routes.has(route.method)) {
+            this._routes.set(route.method, []);
+        }
+        this._routes.get(route.method).push(route);
+    }
+    unregisterRoute(route) {
+        if (!this._routes.has(route.method)) {
+            throw new SerwistError("unregister-route-but-not-found-with-method", {
+                method: route.method
+            });
+        }
+        const routeIndex = this._routes.get(route.method).indexOf(route);
+        if (routeIndex > -1) {
+            this._routes.get(route.method).splice(routeIndex, 1);
+        } else {
+            throw new SerwistError("unregister-route-route-not-registered");
+        }
+    }
+}
+
+let defaultRouter;
+const getOrCreateDefaultRouter = ()=>{
+    if (!defaultRouter) {
+        defaultRouter = new Router();
+        defaultRouter.addFetchListener();
+        defaultRouter.addCacheListener();
+    }
+    return defaultRouter;
+};
+
+class RegExpRoute extends Route {
+    constructor(regExp, handler, method){
+        if (process.env.NODE_ENV !== "production") {
+            assert.isInstance(regExp, RegExp, {
+                moduleName: "@serwist/routing",
+                className: "RegExpRoute",
+                funcName: "constructor",
+                paramName: "pattern"
+            });
+        }
+        const match = ({ url })=>{
+            const result = regExp.exec(url.href);
+            if (!result) {
+                return;
+            }
+            if (url.origin !== location.origin && result.index !== 0) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.debug(`The regular expression '${regExp.toString()}' only partially matched against the cross-origin URL '${url.toString()}'. RegExpRoute's will only handle cross-origin requests if they match the entire URL.`);
+                }
+                return;
+            }
+            return result.slice(1);
+        };
+        super(match, handler, method);
+    }
+}
+
+const parseRoute = (capture, handler, method)=>{
+    let route;
+    if (typeof capture === "string") {
+        const captureUrl = new URL(capture, location.href);
+        if (process.env.NODE_ENV !== "production") {
+            if (!(capture.startsWith("/") || capture.startsWith("http"))) {
+                throw new SerwistError("invalid-string", {
+                    moduleName: "@serwist/routing",
+                    funcName: "registerRoute",
+                    paramName: "capture"
+                });
+            }
+            const valueToCheck = capture.startsWith("http") ? captureUrl.pathname : capture;
+            const wildcards = "[*:?+]";
+            if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
+                logger.debug(`The '$capture' parameter contains an Express-style wildcard character (${wildcards}). Strings are now always interpreted as exact matches; use a RegExp for partial or wildcard matches.`);
+            }
+        }
+        const matchCallback = ({ url })=>{
+            if (process.env.NODE_ENV !== "production") {
+                if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
+                    logger.debug(`${capture} only partially matches the cross-origin URL ${url.toString()}. This route will only handle cross-origin requests if they match the entire URL.`);
+                }
+            }
+            return url.href === captureUrl.href;
+        };
+        route = new Route(matchCallback, handler, method);
+    } else if (capture instanceof RegExp) {
+        route = new RegExpRoute(capture, handler, method);
+    } else if (typeof capture === "function") {
+        route = new Route(capture, handler, method);
+    } else if (capture instanceof Route) {
+        route = capture;
+    } else {
+        throw new SerwistError("unsupported-route-type", {
+            moduleName: "@serwist/routing",
+            funcName: "registerRoute",
+            paramName: "capture"
+        });
+    }
+    return route;
+};
+
+const registerRoute = (capture, handler, method)=>{
+    const route = parseRoute(capture, handler, method);
+    const defaultRouter = getOrCreateDefaultRouter();
+    defaultRouter.registerRoute(route);
+    return route;
+};
+
+export { Route as R, RegExpRoute as a, Router as b, getOrCreateDefaultRouter as g, parseRoute as p, registerRoute as r };

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-import { Serwist, type SerwistOptions, type SerwistInstallOptions } from "./Serwist.js";
-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, Serwist, registerRuntimeCaching };
+import { Serwist, type SerwistInstallOptions, type SerwistOptions } from "./abstractions/Serwist.js";
+import { disableDevLogs } from "./abstractions/disableDevLogs.js";
+import type { FallbackEntry, FallbackMatcher, FallbacksOptions } from "./abstractions/fallbacks.js";
+import { fallbacks } from "./abstractions/fallbacks.js";
+import { type HandlePrecachingOptions, handlePrecaching } from "./abstractions/handlePrecaching.js";
+import { type InstallSerwistOptions, installSerwist } from "./abstractions/installSerwist.js";
+import { disableNavigationPreload, enableNavigationPreload, isNavigationPreloadSupported } from "./abstractions/navigationPreload.js";
+import { registerRuntimeCaching } from "./abstractions/registerRuntimeCaching.js";
+import type { RuntimeCaching } from "./abstractions/types.js";
+export { disableDevLogs, fallbacks, handlePrecaching, installSerwist, Serwist, registerRuntimeCaching, disableNavigationPreload, enableNavigationPreload, isNavigationPreloadSupported, };
 export type { FallbackEntry, FallbackMatcher, FallbacksOptions, HandlePrecachingOptions, InstallSerwistOptions, SerwistOptions, SerwistInstallOptions, RuntimeCaching, };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACxF,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,OAAO,EAAE,sBAAsB,EAAE,CAAC;AACxG,YAAY,EACV,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACd,qBAAqB,EACrB,cAAc,GACf,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AACrG,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpG,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,KAAK,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACpG,OAAO,EAAE,KAAK,qBAAqB,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAC9F,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AACtI,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EACL,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,OAAO,EACP,sBAAsB,EAEtB,wBAAwB,EACxB,uBAAuB,EACvB,4BAA4B,GAC7B,CAAC;AACF,YAAY,EACV,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACd,qBAAqB,EACrB,cAAc,GACf,CAAC"}

package/dist/index.js

@@ -1,12 +1,13 @@
 import { setCacheNameDetails, clientsClaim } from '@serwist/core';
-import { initialize } from '@serwist/google-analytics/initialize';
-import { enable } from '@serwist/navigation-preload';
-import { precacheAndRoute, PrecacheFallbackPlugin, PrecacheController, PrecacheRoute, cleanupOutdatedCaches, createHandlerBoundToURL } from '@serwist/precaching';
-import { Router, NavigationRoute, registerRoute } from '@serwist/routing';
-import { parseRoute, getOrCreateDefaultRouter } from '@serwist/routing/internal';
-import { Strategy } from '@serwist/strategies';
+import { P as PrecacheFallbackPlugin, i as initialize } from './chunks/PrecacheFallbackPlugin.js';
+import { p as precacheAndRoute, P as PrecacheRoute, c as cleanupOutdatedCaches, a as createHandlerBoundToURL } from './chunks/precacheAndRoute.js';
+import { g as getOrCreatePrecacheController } from './chunks/getOrCreatePrecacheController.js';
+import { N as NavigationRoute } from './chunks/NavigationRoute.js';
+import { g as getOrCreateDefaultRouter, p as parseRoute, r as registerRoute } from './chunks/registerRoute.js';
+import { S as Strategy } from './chunks/Strategy.js';
 import { logger } from '@serwist/core/internal';
-import { getOrCreatePrecacheController } from '@serwist/precaching/internal';
+import './chunks/NetworkOnly.js';
+import 'idb';
 
 const disableDevLogs = ()=>{
     self.__WB_DISABLE_DEV_LOGS = true;
@@ -26,16 +27,53 @@ const fallbacks = ({ runtimeCaching, entries, precacheOptions })=>{
     return runtimeCaching;
 };
 
+const isNavigationPreloadSupported = ()=>{
+    return Boolean(self.registration?.navigationPreload);
+};
+const enableNavigationPreload = (headerValue)=>{
+    if (isNavigationPreloadSupported()) {
+        self.addEventListener("activate", (event)=>{
+            event.waitUntil(self.registration.navigationPreload.enable().then(()=>{
+                if (headerValue) {
+                    void self.registration.navigationPreload.setHeaderValue(headerValue);
+                }
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log("Navigation preloading is enabled.");
+                }
+            }));
+        });
+    } else {
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("Navigation preloading is not supported in this browser.");
+        }
+    }
+};
+const disableNavigationPreload = ()=>{
+    if (isNavigationPreloadSupported()) {
+        self.addEventListener("activate", (event)=>{
+            event.waitUntil(self.registration.navigationPreload.disable().then(()=>{
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log("Navigation preloading is disabled.");
+                }
+            }));
+        });
+    } else {
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("Navigation preloading is not supported in this browser.");
+        }
+    }
+};
+
 class Serwist {
     _precacheController;
     _router;
-    constructor({ precacheController = new PrecacheController(), router = new Router() } = {}){
-        this._precacheController = precacheController;
-        this._router = router;
+    constructor({ precacheController, router } = {}){
+        this._precacheController = precacheController || getOrCreatePrecacheController();
+        this._router = router || getOrCreateDefaultRouter();
     }
     install({ precacheEntries, precacheOptions, cleanupOutdatedCaches: cleanupOutdatedCaches$1, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks: fallbacks$1 }) {
         if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
-        if (navigationPreload) enable();
+        if (navigationPreload) enableNavigationPreload();
         if (cacheId !== undefined) {
             setCacheNameDetails({
                 prefix: cacheId
@@ -114,4 +152,4 @@ const registerRuntimeCaching = (...runtimeCachingList)=>{
     }
 };
 
-export { Serwist, disableDevLogs, fallbacks, handlePrecaching, installSerwist, registerRuntimeCaching };
+export { Serwist, disableDevLogs, disableNavigationPreload, enableNavigationPreload, fallbacks, handlePrecaching, installSerwist, isNavigationPreloadSupported, registerRuntimeCaching };

package/dist/index.plugins.d.ts

@@ -1,12 +1,41 @@
-import type { QueueEntry, QueueOptions } from "@serwist/background-sync";
-import { BackgroundSyncPlugin, Queue, QueueStore, StorableRequest } from "@serwist/background-sync";
-import type { BroadcastCacheUpdateOptions, BroadcastMessage, BroadcastPayload, BroadcastPayloadGenerator } from "@serwist/broadcast-update";
-import { BroadcastCacheUpdate, BroadcastUpdatePlugin, CACHE_UPDATED_MESSAGE_META as BROADCAST_UPDATE_MESSAGE_META, CACHE_UPDATED_MESSAGE_TYPE as BROADCAST_UPDATE_MESSAGE_TYPE, defaultHeadersToCheck as BROADCAST_UPDATE_DEFAULT_HEADERS, responsesAreSame } from "@serwist/broadcast-update";
-import type { CacheableResponseOptions } from "@serwist/cacheable-response";
-import { CacheableResponse, CacheableResponsePlugin } from "@serwist/cacheable-response";
-import type { ExpirationPluginOptions } from "@serwist/expiration";
-import { CacheExpiration, ExpirationPlugin } from "@serwist/expiration";
-import { RangeRequestsPlugin, createPartialResponse } from "@serwist/range-requests";
-export { BackgroundSyncPlugin, Queue as BackgroundSyncQueue, QueueStore as BackgroundSyncQueueStore, StorableRequest, BroadcastCacheUpdate, BroadcastUpdatePlugin, responsesAreSame, BROADCAST_UPDATE_MESSAGE_META, BROADCAST_UPDATE_MESSAGE_TYPE, BROADCAST_UPDATE_DEFAULT_HEADERS, CacheableResponse, CacheableResponsePlugin, CacheExpiration, ExpirationPlugin, createPartialResponse, RangeRequestsPlugin, };
-export type { QueueOptions as BackgroundSyncQueueOptions, QueueEntry as BackgroundSyncQueueEntry, BroadcastCacheUpdateOptions, BroadcastPayload, BroadcastPayloadGenerator, BroadcastMessage, CacheableResponseOptions, ExpirationPluginOptions, };
+import { BackgroundSyncPlugin } from "./plugins/backgroundSync/BackgroundSyncPlugin.js";
+import type { QueueEntry as BackgroundSyncQueueEntry, QueueOptions as BackgroundSyncQueueOptions } from "./plugins/backgroundSync/Queue.js";
+import { Queue as BackgroundSyncQueue } from "./plugins/backgroundSync/Queue.js";
+import { QueueStore as BackgroundSyncQueueStore } from "./plugins/backgroundSync/QueueStore.js";
+import { StorableRequest } from "./plugins/backgroundSync/StorableRequest.js";
+import { BroadcastCacheUpdate } from "./plugins/broadcastUpdate/BroadcastCacheUpdate.js";
+import { BroadcastUpdatePlugin } from "./plugins/broadcastUpdate/BroadcastUpdatePlugin.js";
+import { CACHE_UPDATED_MESSAGE_META as BROADCAST_UPDATE_MESSAGE_META, CACHE_UPDATED_MESSAGE_TYPE as BROADCAST_UPDATE_MESSAGE_TYPE, defaultHeadersToCheck as BROADCAST_UPDATE_DEFAULT_HEADERS } from "./plugins/broadcastUpdate/constants.js";
+import { responsesAreSame } from "./plugins/broadcastUpdate/responsesAreSame.js";
+import type { BroadcastCacheUpdateOptions, BroadcastMessage, BroadcastPayload, BroadcastPayloadGenerator } from "./plugins/broadcastUpdate/types.js";
+import type { CacheableResponseOptions } from "./plugins/cacheableResponse/CacheableResponse.js";
+import { CacheableResponse } from "./plugins/cacheableResponse/CacheableResponse.js";
+import { CacheableResponsePlugin } from "./plugins/cacheableResponse/CacheableResponsePlugin.js";
+import { CacheExpiration } from "./plugins/expiration/CacheExpiration.js";
+import type { ExpirationPluginOptions } from "./plugins/expiration/ExpirationPlugin.js";
+import { ExpirationPlugin } from "./plugins/expiration/ExpirationPlugin.js";
+import type { GoogleAnalyticsInitializeOptions } from "./plugins/googleAnalytics/initialize.js";
+import { initialize as initializeGoogleAnalytics } from "./plugins/googleAnalytics/initialize.js";
+import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./plugins/precaching/PrecacheFallbackPlugin.js";
+import { PrecacheFallbackPlugin } from "./plugins/precaching/PrecacheFallbackPlugin.js";
+import { RangeRequestsPlugin } from "./plugins/rangeRequests/RangeRequestsPlugin.js";
+import { createPartialResponse } from "./plugins/rangeRequests/createPartialResponse.js";
+interface SyncManager {
+    getTags(): Promise<string[]>;
+    register(tag: string): Promise<void>;
+}
+declare global {
+    interface ServiceWorkerRegistration {
+        readonly sync: SyncManager;
+    }
+    interface SyncEvent extends ExtendableEvent {
+        readonly lastChance: boolean;
+        readonly tag: string;
+    }
+    interface ServiceWorkerGlobalScopeEventMap {
+        sync: SyncEvent;
+    }
+}
+export { BackgroundSyncPlugin, BackgroundSyncQueue, BackgroundSyncQueueStore, StorableRequest, BroadcastCacheUpdate, BroadcastUpdatePlugin, responsesAreSame, BROADCAST_UPDATE_MESSAGE_META, BROADCAST_UPDATE_MESSAGE_TYPE, BROADCAST_UPDATE_DEFAULT_HEADERS, CacheableResponse, CacheableResponsePlugin, CacheExpiration, ExpirationPlugin, PrecacheFallbackPlugin, createPartialResponse, RangeRequestsPlugin, initializeGoogleAnalytics, };
+export type { BackgroundSyncQueueOptions, BackgroundSyncQueueEntry, BroadcastCacheUpdateOptions, BroadcastPayload, BroadcastPayloadGenerator, BroadcastMessage, CacheableResponseOptions, ExpirationPluginOptions, PrecacheFallbackEntry, PrecacheFallbackPluginOptions, GoogleAnalyticsInitializeOptions, };
 //# sourceMappingURL=index.plugins.d.ts.map

package/dist/index.plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.plugins.d.ts","sourceRoot":"","sources":["../src/index.plugins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACpG,OAAO,KAAK,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC5I,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,0BAA0B,IAAI,6BAA6B,EAC3D,0BAA0B,IAAI,6BAA6B,EAC3D,qBAAqB,IAAI,gCAAgC,EACzD,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACzF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErF,OAAO,EACL,oBAAoB,EACpB,KAAK,IAAI,mBAAmB,EAC5B,UAAU,IAAI,wBAAwB,EACtC,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,6BAA6B,EAC7B,6BAA6B,EAC7B,gCAAgC,EAChC,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,mBAAmB,GACpB,CAAC;AAEF,YAAY,EACV,YAAY,IAAI,0BAA0B,EAC1C,UAAU,IAAI,wBAAwB,EACtC,2BAA2B,EAC3B,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,GACxB,CAAC"}
+{"version":3,"file":"index.plugins.d.ts","sourceRoot":"","sources":["../src/index.plugins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kDAAkD,CAAC;AACxF,OAAO,KAAK,EAAE,UAAU,IAAI,wBAAwB,EAAE,YAAY,IAAI,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC5I,OAAO,EAAE,KAAK,IAAI,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,EAAE,UAAU,IAAI,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAC;AAC3F,OAAO,EACL,0BAA0B,IAAI,6BAA6B,EAC3D,0BAA0B,IAAI,6BAA6B,EAC3D,qBAAqB,IAAI,gCAAgC,EAC1D,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,KAAK,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AACrJ,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AACjG,OAAO,EAAE,iBAAiB,EAAE,MAAM,kDAAkD,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,wDAAwD,CAAC;AACjG,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,UAAU,IAAI,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAClG,OAAO,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,gDAAgD,CAAC;AAC3H,OAAO,EAAE,sBAAsB,EAAE,MAAM,gDAAgD,CAAC;AACxF,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kDAAkD,CAAC;AAGzF,UAAU,WAAW;IACnB,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,yBAAyB;QACjC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;KAC5B;IAED,UAAU,SAAU,SAAQ,eAAe;QACzC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;QAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;KACtB;IAED,UAAU,gCAAgC;QACxC,IAAI,EAAE,SAAS,CAAC;KACjB;CACF;AAED,OAAO,EAEL,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,eAAe,EAEf,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,6BAA6B,EAC7B,6BAA6B,EAC7B,gCAAgC,EAEhC,iBAAiB,EACjB,uBAAuB,EAEvB,eAAe,EACf,gBAAgB,EAEhB,sBAAsB,EAEtB,qBAAqB,EACrB,mBAAmB,EAEnB,yBAAyB,GAC1B,CAAC;AAEF,YAAY,EAEV,0BAA0B,EAC1B,wBAAwB,EAExB,2BAA2B,EAC3B,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,EAEhB,wBAAwB,EAExB,uBAAuB,EAEvB,qBAAqB,EACrB,6BAA6B,EAE7B,gCAAgC,GACjC,CAAC"}