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

package/dist/chunks/singletonRouter.js

@@ -0,0 +1,435 @@
+import { assert, logger, SerwistError, getFriendlyURL } 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 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;
+};
+
+class Router {
+    _routes;
+    _defaultHandlerMap;
+    _fetchListenerHandler = null;
+    _cacheListenerHandler = null;
+    _catchHandler;
+    constructor(){
+        this._routes = new Map();
+        this._defaultHandlerMap = new Map();
+    }
+    get routes() {
+        return this._routes;
+    }
+    addFetchListener() {
+        if (!this._fetchListenerHandler) {
+            this._fetchListenerHandler = (event)=>{
+                const { request } = event;
+                const responsePromise = this.handleRequest({
+                    request,
+                    event
+                });
+                if (responsePromise) {
+                    event.respondWith(responsePromise);
+                }
+            };
+            self.addEventListener("fetch", this._fetchListenerHandler);
+        }
+    }
+    removeFetchListener() {
+        if (this._fetchListenerHandler) {
+            self.removeEventListener("fetch", this._fetchListenerHandler);
+            this._fetchListenerHandler = null;
+        }
+    }
+    addCacheListener() {
+        if (!this._cacheListenerHandler) {
+            this._cacheListenerHandler = (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));
+                    }
+                }
+            };
+            self.addEventListener("message", this._cacheListenerHandler);
+        }
+    }
+    removeCacheListener() {
+        if (this._cacheListenerHandler) {
+            self.removeEventListener("message", this._cacheListenerHandler);
+        }
+    }
+    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("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);
+    }
+    registerCapture(capture, handler, method) {
+        const route = parseRoute(capture, handler, method);
+        this.registerRoute(route);
+        return route;
+    }
+    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 = undefined;
+const getSingletonRouter = ()=>{
+    if (!defaultRouter) {
+        defaultRouter = new Router();
+        defaultRouter.addFetchListener();
+        defaultRouter.addCacheListener();
+    }
+    return defaultRouter;
+};
+const setSingletonRouter = (router)=>{
+    if (defaultRouter) {
+        defaultRouter.removeFetchListener();
+        defaultRouter.removeCacheListener();
+    }
+    defaultRouter = router;
+    defaultRouter.addFetchListener();
+    defaultRouter.addCacheListener();
+    return defaultRouter;
+};
+
+export { Route as R, RegExpRoute as a, Router as b, getSingletonRouter as g, parseRoute as p, setSingletonRouter as s };

package/dist/index.d.ts

@@ -1,10 +1,12 @@
-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 };
+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,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"}
+{"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"}