eddev 2.0.0-beta.99 → 2.1.0

package/dist/app/server/server-context.js

@@ -1,8 +1,12 @@
 import { parseURL, stringifyParsedURL, withQuery, withTrailingSlash } from "ufo";
+import { getCookie, getHeader } from "vinxi/http";
 import { fetchWP } from "../../node/utils/fetch-wp.js";
 import { filterHeader } from "./utils/headers.js";
 import { createUrlReplacer } from "./utils/replace-host.js";
 import { pageCache, queryCache, swr } from "./utils/swr-cache.js";
+import { QueryMonitor } from "../utils/query-monitor.js";
+import chalk from "chalk";
+import { inspect } from "node:util";
 const PROXY_RESPONSE_HEADERS = ["content-type", "set-cookie", /^x-/, "cache-control", /woocommerce/, "location"];
 const PROXY_REQUEST_HEADERS = [
     "content-type",
@@ -23,12 +27,14 @@ export class ServerContext {
     _urlReplacer;
     rpcBases = [];
     config;
+    cacheConfig;
     static main;
     constructor(conf) {
         this.dev = conf.dev;
         this.origin = conf.origin;
         this.rpcBases = conf.rpcBases ?? [];
         this.config = conf.config;
+        this.cacheConfig = conf.cacheConfig;
         if (conf.replaceUrls) {
             this._urlReplacer = createUrlReplacer(conf.replaceUrls);
         }
@@ -55,13 +61,11 @@ export class ServerContext {
     }
     async fetchOrigin(url, opts) {
         url = this.getOriginUrl(url);
+        const fetchOps = { ...opts };
+        delete fetchOps.replaceUrls;
+        delete fetchOps.newOrigin;
         const response = await fetchWP(url, {
-            ...opts,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                ...opts?.headers,
-            },
+            ...fetchOps,
         });
         if (!response.ok) {
             return response;
@@ -82,19 +86,102 @@ export class ServerContext {
             headers,
         });
     }
+    debugLogQueryMonitor(kind, uri, monitor) {
+        if (!QueryMonitor.hasLogEntries(monitor))
+            return;
+        let indentLevel = 2;
+        const finalOutput = [];
+        let label = "";
+        if (kind === "props") {
+            label = "While fetching props for route '" + uri + "'";
+        }
+        else if (kind === "query") {
+            label = "While querying " + uri + " via REST API";
+        }
+        else if (kind === "mutation") {
+            label = "While mutating " + uri + " via REST API";
+        }
+        else if (kind === "app") {
+            label = "While fetching app data";
+        }
+        finalOutput.push(chalk.whiteBright("➜ " + label));
+        function printEntry(entry) {
+            finalOutput.push(indent(indentLevel, chalk.whiteBright("➜ " + entry.file) + " " + chalk.gray(entry.label ? `(${entry.label})` : "")));
+            indentLevel += 2;
+            if (entry.log && entry.log.length) {
+                for (let item of entry.log) {
+                    let output = "";
+                    let prefix = "";
+                    let message = item.message;
+                    let stack = [];
+                    if (item.type === "php_error") {
+                        prefix = chalk.red("PHP Error:");
+                    }
+                    else if (item.type === "php_warning") {
+                        prefix = chalk.yellow("PHP Warning:");
+                    }
+                    else if (item.type === "php_notice") {
+                        prefix = chalk.yellow("PHP Notice:");
+                    }
+                    else if (item.type === "GRAPHQL_DEBUG") {
+                        prefix = chalk.cyan("debug:");
+                    }
+                    else if (item.type === "error" && item.extensions?.category === "user") {
+                        prefix = chalk.red("UserError:");
+                    }
+                    else {
+                        prefix = chalk.gray((item.type || "Log") + ":");
+                    }
+                    if (typeof message !== "string") {
+                        message = inspect(message, { depth: 4 });
+                    }
+                    if (item.debugMessage) {
+                        message += "\n" + chalk.gray(item.debugMessage);
+                    }
+                    output += prefix + " " + message;
+                    if (item.path) {
+                        stack.push(chalk.gray(" at path " + JSON.stringify(item.path)));
+                    }
+                    if (item.file) {
+                        stack.push(chalk.gray(`at ${chalk.white(item.file)} line ${item.line || "??"}`));
+                    }
+                    if (item.stack?.length) {
+                        stack.push(item.stack
+                            .filter((line) => {
+                            return line !== item.file + ":" + item.line;
+                        })
+                            .slice(0, 4)
+                            .map((line) => "  " + chalk.gray(line))
+                            .join("\n"));
+                    }
+                    if (stack.length > 0) {
+                        output += indent(2, "\n" + stack.join("\n"));
+                    }
+                    finalOutput.push(indent(indentLevel, "➜ " + output));
+                }
+            }
+            for (let child of entry.children ?? []) {
+                printEntry(child);
+            }
+            indentLevel -= 2;
+        }
+        for (let entry of monitor) {
+            printEntry(entry);
+        }
+    }
     async fetchRouteData(req) {
         /**
          * Calculcate the cache key.
          * For route data, the cache key is the pathname.
          * TODO: Potential support for Vercel draft mode.
          */
-        let cacheKey = "fetchRouteData:" + req.pathname;
+        let cacheKey = "fetchRouteData:" + withTrailingSlash(req.pathname.toLowerCase());
         const result = await swr({
             key: cacheKey,
             cache: pageCache,
-            forceFresh: this.dev,
+            forceFresh: this.dev || req.bypass,
+            staleWhileRevalidate: 10000,
             getFreshValue: async (ctx) => {
-                ctx.metadata.createdTime;
                 const fetchUrl = withQuery(withTrailingSlash(req.pathname), {
                     _props: "1",
                     _ssr: "1",
@@ -111,30 +198,66 @@ export class ServerContext {
                     redirect: "manual",
                 });
                 const preferredCacheDuration = parseInt(result.headers.get("x-ed-cache-duration") ?? "");
-                if (isFinite(preferredCacheDuration)) {
+                if (this.cacheConfig.serverless.isr) {
+                    ctx.metadata.ttl = 5000;
+                }
+                else if (isFinite(preferredCacheDuration)) {
                     ctx.metadata.ttl = preferredCacheDuration * 1000;
                 }
                 let resultStatus = result.status;
                 let resultHeaders = new Headers(result.headers);
                 let resultData = {};
                 // Special case for redirects
-                if (result.headers.get("location")) {
+                if (result.headers.has("location")) {
                     let location = result.headers.get("location");
                     let status = result.status;
                     if (this.replaceUrls) {
                         location = this.replaceUrls(location);
                     }
-                    resultHeaders.delete("location");
                     return {
                         status: 200,
-                        headers: resultHeaders,
+                        headers: new Headers({
+                            "Content-Type": "application/json",
+                        }),
                         data: JSON.stringify({ redirect: location, status: status }),
                     };
                 }
-                resultData = await result.json();
+                try {
+                    resultData = await result.json();
+                }
+                catch (err) {
+                    console.error(`Invalid JSON response from '${fetchUrl}'. An error page will be displayed.`);
+                    ctx.metadata.ttl = 0;
+                    return {
+                        status: 500,
+                        headers: resultHeaders,
+                        data: JSON.stringify({
+                            view: "_error",
+                            viewData: {
+                                data: {
+                                    statusCode: 500,
+                                    title: "Internal Server Error",
+                                    userMessage: "An internal server error occurred.",
+                                    report: {
+                                        details: "A JSON parsing error occurred while fetching route data.",
+                                        message: err.message,
+                                    },
+                                },
+                            },
+                        }),
+                    };
+                }
                 if (resultData && typeof resultData === "object") {
                     resultData.__generated = new Date().toISOString();
                 }
+                if (resultData.queryMonitor) {
+                    this.debugLogQueryMonitor("props", req.pathname, resultData.queryMonitor);
+                }
+                // if (isFinite(preferredCacheDuration)) {
+                //   const maxAge = isFinite(preferredCacheDuration) ? preferredCacheDuration * 1000 : undefined
+                //   resultHeaders.set("Cache-Control", `max-age=0, s-maxage=${maxAge}, stale-while-revalidate`)
+                // }
+                resultHeaders.set("X-Ed-Fetched-At", new Date().toUTCString());
                 return {
                     status: resultStatus,
                     headers: resultHeaders,
@@ -142,19 +265,25 @@ export class ServerContext {
                 };
             },
         });
+        if (this.cacheConfig.serverless.isr) {
+            result.headers.delete("cache-control");
+        }
         return new Response(result.data, {
             status: result.status,
             headers: result.headers,
         });
     }
-    async fetchAppData() {
+    async fetchAppData(args) {
         const data = await swr({
             key: "fetchAppData",
             cache: pageCache,
+            forceFresh: this.dev || args.bypass,
+            staleWhileRevalidate: 10000,
             getFreshValue: async (ctx) => {
                 const response = await this.fetchOrigin("/_appdata", {
                     cache: "no-cache",
                     replaceUrls: true,
+                    newOrigin: args.newOrigin,
                     headers: {
                         "Content-Type": "application/json",
                         Accept: "application/json",
@@ -165,10 +294,16 @@ export class ServerContext {
                 if (isFinite(preferredCacheDuration)) {
                     ctx.metadata.ttl = preferredCacheDuration * 1000;
                 }
+                // In ISR mode, set a super short TTL to avoid caching, but preventing constant revalidation
+                if (this.cacheConfig.serverless.isr) {
+                    ctx.metadata.ttl = 5000;
+                }
+                if (result.queryMonitor) {
+                    this.debugLogQueryMonitor("app", "", result.queryMonitor);
+                }
                 result.__generated = new Date().toISOString();
                 return result;
             },
-            forceFresh: this.dev,
         });
         return data;
     }
@@ -184,7 +319,7 @@ export class ServerContext {
         return headers;
     }
     async fetchNamedQuery(req) {
-        const url = `/wp-json/ed/v1/query/${req.name}?params=${encodeURIComponent(JSON.stringify(req.params))}`;
+        const url = `/wp-json/ed/v1/query/${req.name.replace(/^\//, "")}?params=${encodeURIComponent(JSON.stringify(req.params))}`;
         const key = `fetchNamedQuery:${req.name}:${JSON.stringify(req.params)}`;
         const fetch = async () => {
             const result = await this.fetchOrigin(url, {
@@ -203,6 +338,10 @@ export class ServerContext {
             if (resultData && typeof resultData === "object") {
                 resultData.__generated = new Date().toISOString();
             }
+            resultHeaders.set("X-Ed-Rendered-At", new Date().toUTCString());
+            if (resultData.queryMonitor) {
+                this.debugLogQueryMonitor("query", req.name, resultData.queryMonitor);
+            }
             return {
                 status: resultStatus,
                 headers: resultHeaders,
@@ -218,21 +357,28 @@ export class ServerContext {
             : await swr({
                 key,
                 cache: queryCache,
-                forceFresh: this.dev,
+                forceFresh: this.dev || req.bypass,
+                staleWhileRevalidate: 10000,
                 getFreshValue: async (ctx) => {
                     const result = await fetch();
                     ctx.metadata.ttl = result.cacheTime;
+                    if (this.cacheConfig.serverless.isr) {
+                        ctx.metadata.ttl = 5000;
+                    }
                     return result;
                 },
             });
+        if (this.cacheConfig.serverless.isr) {
+            result.headers.delete("cache-control");
+        }
         return new Response(result.data, {
             status: result.status,
             headers: result.headers,
         });
     }
     async fetchMutation(req) {
-        const url = `/wp-json/ed/v1/mutation/${req.name}`;
-        return this.fetchOrigin(url, {
+        const url = `/wp-json/ed/v1/mutation/${req.name.replace(/^\//, "")}`;
+        const response = await this.fetchOrigin(url, {
             method: "POST",
             cache: "no-cache",
             replaceUrls: true,
@@ -243,6 +389,16 @@ export class ServerContext {
             },
             body: JSON.stringify(req.body),
         });
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: new Headers({
+                "Content-Type": "application/json",
+                // Do not cache mutation responses
+                "Cache-Control": "max-age=0, max-s-age=0",
+                "X-Ed-Rendered-At": new Date().toUTCString(),
+            }),
+        });
     }
     get allowedCorsOrigins() {
         let result = [];
@@ -252,10 +408,23 @@ export class ServerContext {
             result = result.filter((origin) => origin !== "*");
         }
         if (this.config.serverless.cors?.origins) {
-            result.push(...this.config.serverless.cors.origins);
+            result.push(...this.config.serverless.cors.origins.map((origin) => origin.replace(/(https?:\/\/|\/$)/, "")));
         }
         return result;
     }
+    shouldBypass(event) {
+        const bypassToken = process.env.VERCEL_BYPASS_TOKEN;
+        if (!bypassToken)
+            return false;
+        const cookieName = "__prerender_bypass";
+        if (getCookie(event, cookieName) === bypassToken) {
+            return true;
+        }
+        if (getHeader(event, "x-prerender-revalidate") === bypassToken) {
+            return true;
+        }
+        return false;
+    }
     getCorsOrigin(originHeader) {
         const parsed = parseURL(originHeader);
         if (this.allowedCorsOrigins.includes(parsed.host)) {
@@ -281,3 +450,17 @@ export class ServerContext {
         return {};
     }
 }
+function indent(count, str) {
+    const indent = " ".repeat(count);
+    return str
+        .split("\n")
+        .map((line) => indent + line)
+        .join("\n");
+}
+function indentAllButFirst(count, str) {
+    const indent = " ".repeat(count);
+    return str
+        .split("\n")
+        .map((line, i) => (i === 0 ? line : indent + line))
+        .join("\n");
+}

package/dist/app/server/server-custom-config.d.ts

@@ -0,0 +1,3 @@
+export type ServerConfig = {};
+export declare function defineServerConfig(): void;
+//# sourceMappingURL=server-custom-config.d.ts.map

package/dist/app/server/server-custom-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-custom-config.d.ts","sourceRoot":"","sources":["../../../src/app/server/server-custom-config.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,EAAE,CAAA;AAE7B,wBAAgB,kBAAkB,SAAK"}

package/dist/app/server/server-custom-config.js

@@ -0,0 +1 @@
+export function defineServerConfig() { }

package/dist/app/server/utils/content-security.d.ts

@@ -0,0 +1,26 @@
+import type { EDConfig } from "../../../node/project/config";
+import { RouteMetaTag, TrackerTags } from "../../lib/routing";
+declare const CSP_KEYS: readonly ["childSrc", "connectSrc", "defaultSrc", "fencedFrameSrc", "fontSrc", "frameSrc", "imgSrc", "manifestSrc", "mediaSrc", "objectSrc", "scriptSrc", "scriptSrcElem", "scriptSrcAttr", "styleSrc", "styleSrcElem", "styleSrcAttr", "workerSrc", "baseUri", "formAction", "frameAncestors", "reportTo", "requireTrustedTypesFor", "trustedTypes", "upgradeInsecureRequests"];
+export type CSPKey = (typeof CSP_KEYS)[number];
+export type CSPParams = Record<CSPKey, Set<string>>;
+export type ContentSecurityPolicyRequestContext = {
+    url: string;
+    type: "page";
+    tags: RouteMetaTag[];
+};
+export declare class SecureHeaderBuilder {
+    protected csp: CSPParams;
+    protected headers: Headers;
+    private cspEnabled;
+    private autodetectCspOrigins;
+    private useNonce;
+    private commonCspOrigins;
+    readonly nonce: string | undefined;
+    constructor(config: EDConfig);
+    addTrackingTags(tags: TrackerTags): TrackerTags;
+    addMetaTags(tags: RouteMetaTag[]): RouteMetaTag[];
+    getHeaders(): Headers;
+    getCSPHeaderValue(): string | undefined;
+}
+export {};
+//# sourceMappingURL=content-security.d.ts.map

package/dist/app/server/utils/content-security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-security.d.ts","sourceRoot":"","sources":["../../../../src/app/server/utils/content-security.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAG7D,QAAA,MAAM,QAAQ,kXAyBJ,CAAA;AAEV,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9C,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;AAEnD,MAAM,MAAM,mCAAmC,GAAG;IAChD,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB,CAAA;AAED,qBAAa,mBAAmB;IAC9B,SAAS,CAAC,GAAG,EAAE,SAAS,CAAA;IACxB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAgB;IAE1C,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,oBAAoB,CAAO;IACnC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,gBAAgB,CAAe;IAEvC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;gBAEtB,MAAM,EAAE,QAAQ;IAgC5B,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW;IAkB/C,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE;IAkBhC,UAAU,IAAI,OAAO;IAWrB,iBAAiB,IAAI,MAAM,GAAG,SAAS;CAexC"}

package/dist/app/server/utils/content-security.js

@@ -0,0 +1,124 @@
+import buildCsp from "content-security-policy-builder";
+const CSP_KEYS = [
+    "childSrc",
+    "connectSrc",
+    "defaultSrc",
+    "fencedFrameSrc",
+    "fontSrc",
+    "frameSrc",
+    "imgSrc",
+    "manifestSrc",
+    "mediaSrc",
+    "objectSrc",
+    "scriptSrc",
+    "scriptSrcElem",
+    "scriptSrcAttr",
+    "styleSrc",
+    "styleSrcElem",
+    "styleSrcAttr",
+    "workerSrc",
+    "baseUri",
+    "formAction",
+    "frameAncestors",
+    "reportTo",
+    "requireTrustedTypesFor",
+    "trustedTypes",
+    "upgradeInsecureRequests",
+];
+export class SecureHeaderBuilder {
+    csp;
+    headers = new Headers();
+    cspEnabled = false;
+    autodetectCspOrigins = true;
+    useNonce = false;
+    commonCspOrigins = [];
+    nonce;
+    constructor(config) {
+        this.cspEnabled = config.serverless.csp.enabled;
+        this.autodetectCspOrigins = config.serverless.csp.autoDetect;
+        this.useNonce = config.serverless.csp.nonce;
+        this.commonCspOrigins = config.serverless.csp.commonOrigins ?? [];
+        if (this.useNonce) {
+            this.nonce = crypto.randomUUID();
+        }
+        // Default CSP header parameters
+        this.csp = {};
+        for (let key of CSP_KEYS) {
+            const defaults = [];
+            if (key.match(/Src$/i)) {
+                defaults.push("'self'");
+                if (this.commonCspOrigins.length) {
+                    defaults.push(...this.commonCspOrigins);
+                }
+                if (config.serverless.csp.values) {
+                    const value = config.serverless.csp.values[key];
+                    if (value) {
+                        defaults.push(...value);
+                    }
+                }
+                if (this.useNonce && !defaults.includes("'unsafe-inline'")) {
+                    defaults.push(`'nonce-${this.nonce}'`);
+                }
+            }
+            this.csp[key] = new Set(defaults);
+        }
+    }
+    addTrackingTags(tags) {
+        if (!this.autodetectCspOrigins || !this.cspEnabled)
+            return tags;
+        const handle = (value) => {
+            if (value) {
+                return value.replaceAll(/<(script|style)/g, (tag) => {
+                    return tag + ` nonce="${this.nonce}"`;
+                });
+            }
+        };
+        return {
+            head: handle(tags.head),
+            body: handle(tags.body),
+            footer: handle(tags.footer),
+        };
+    }
+    addMetaTags(tags) {
+        if (!this.autodetectCspOrigins || !this.cspEnabled)
+            return tags;
+        return tags.map((tag) => {
+            if (this.nonce) {
+                if (tag.tagName === "script" || tag.tagName === "style") {
+                    return {
+                        ...tag,
+                        attributes: {
+                            ...tag.attributes,
+                            nonce: this.nonce,
+                        },
+                    };
+                }
+            }
+            return tag;
+        });
+    }
+    getHeaders() {
+        const result = new Headers(this.headers);
+        const cspHeaderValue = this.getCSPHeaderValue();
+        if (cspHeaderValue) {
+            result.set("Content-Security-Policy", cspHeaderValue);
+        }
+        return result;
+    }
+    getCSPHeaderValue() {
+        if (!this.cspEnabled)
+            return undefined;
+        const directives = [];
+        for (let key of CSP_KEYS) {
+            if (this.csp[key].size > 0) {
+                directives.push([key, Array.from(this.csp[key])]);
+            }
+        }
+        if (directives.length) {
+            return buildCsp({
+                directives: Object.fromEntries(directives),
+            });
+        }
+        return undefined;
+    }
+}

package/dist/app/server/utils/headers.d.ts

@@ -3,3 +3,4 @@ export declare const BRANDED_HEADERS: {
     "X-Powered-By": string;
 };
 export declare function extractHeaders(rawHeaders: Headers): Record<string, string>;
+//# sourceMappingURL=headers.d.ts.map

package/dist/app/server/utils/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../../src/app/server/utils/headers.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,WAOrE;AAED,eAAO,MAAM,eAAe;;CAE3B,CAAA;AAYD,wBAAgB,cAAc,CAAC,UAAU,EAAE,OAAO,0BAOjD"}

package/dist/app/server/utils/replace-host.d.ts

@@ -8,3 +8,4 @@ export type UrlReplacerConf = {
     }[];
 };
 export declare function createUrlReplacer(conf: UrlReplacerConf): (text: string, newOrigin?: string) => string;
+//# sourceMappingURL=replace-host.d.ts.map

package/dist/app/server/utils/replace-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-host.d.ts","sourceRoot":"","sources":["../../../../src/app/server/utils/replace-host.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,0FAA0F;IAC1F,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CACjD,CAAA;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,IAI7C,MAAM,MAAM,EAAE,YAAY,MAAM,YAiEzC"}

package/dist/app/server/utils/swr-cache.d.ts

@@ -2,3 +2,4 @@ import { Cache, CachifiedOptions } from "@epic-web/cachified";
 export declare const pageCache: Cache<any>;
 export declare const queryCache: Cache<any>;
 export declare function swr<T>(args: CachifiedOptions<T>): Promise<T>;
+//# sourceMappingURL=swr-cache.d.ts.map

package/dist/app/server/utils/swr-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swr-cache.d.ts","sourceRoot":"","sources":["../../../../src/app/server/utils/swr-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,EAAY,gBAAgB,EAAmB,MAAM,qBAAqB,CAAA;AAuB/G,eAAO,MAAM,SAAS,YAAgB,CAAA;AACtC,eAAO,MAAM,UAAU,YAAgB,CAAA;AAEvC,wBAAgB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,cAO/C"}

package/dist/app/utils/APIProvider.d.ts

@@ -1,2 +1,3 @@
 import { PropsWithChildren } from "react";
 export declare function APIProvider(props: PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=APIProvider.d.ts.map

package/dist/app/utils/APIProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APIProvider.d.ts","sourceRoot":"","sources":["../../../src/app/utils/APIProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAGzC,wBAAgB,WAAW,CAAC,KAAK,EAAE,iBAAiB,CAAC,EAAE,CAAC,2CAEvD"}

package/dist/app/utils/BlockErrorBoundary.d.ts

@@ -17,3 +17,4 @@ export declare class BlockErrorBoundary extends Component<Props, State> {
     render(): ReactNode;
 }
 export {};
+//# sourceMappingURL=BlockErrorBoundary.d.ts.map

package/dist/app/utils/BlockErrorBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockErrorBoundary.d.ts","sourceRoot":"","sources":["../../../src/app/utils/BlockErrorBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEvD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAG5E,UAAU,KAAK;IACb,KAAK,EAAE,YAAY,CAAA;IACnB,YAAY,EAAE,aAAa,CAAA;IAC3B,QAAQ,EAAE,SAAS,CAAA;CACpB;AAED,UAAU,KAAK;IACb,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB;AAED,qBAAa,kBAAmB,SAAQ,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;IACtD,KAAK,EAAE,KAAK,CAElB;WAEa,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAKpD,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS;IAWpD,MAAM;CAmBd"}

package/dist/app/utils/ErrorMessage.d.ts

@@ -3,3 +3,4 @@ type Props = {
 };
 export declare function ErrorMessage({ error }: Props): import("react/jsx-runtime").JSX.Element;
 export {};
+//# sourceMappingURL=ErrorMessage.d.ts.map

package/dist/app/utils/ErrorMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorMessage.d.ts","sourceRoot":"","sources":["../../../src/app/utils/ErrorMessage.tsx"],"names":[],"mappings":"AAAA,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,2CAkB5C"}

package/dist/app/utils/RouteErrorBoundary.d.ts

@@ -3,6 +3,7 @@ import { RouteState } from "../lib/routing/types.js";
 interface Props {
     route: RouteState;
     children: ReactNode;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
 }
 interface State {
     hasError: boolean;
@@ -16,3 +17,4 @@ export declare class RouteErrorBoundary extends Component<Props, State> {
     render(): ReactNode;
 }
 export {};
+//# sourceMappingURL=RouteErrorBoundary.d.ts.map

package/dist/app/utils/RouteErrorBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteErrorBoundary.d.ts","sourceRoot":"","sources":["../../../src/app/utils/RouteErrorBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAMpD,UAAU,KAAK;IACb,KAAK,EAAE,UAAU,CAAA;IACjB,QAAQ,EAAE,SAAS,CAAA;IACnB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,KAAK,IAAI,CAAA;CACvD;AAED,UAAU,KAAK;IACb,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB;AAED,qBAAa,kBAAmB,SAAQ,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;IACtD,KAAK,EAAE,KAAK,CAElB;WAEa,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAKpD,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS;IAcpD,MAAM;CAmBd"}

package/dist/app/utils/RouteErrorBoundary.js

@@ -19,6 +19,9 @@ export class RouteErrorBoundary extends Component {
                 componentStack: errorInfo.componentStack,
             });
         }
+        if (this.props.onError) {
+            this.props.onError(error, errorInfo);
+        }
     }
     render() {
         if (this.state.hasError) {

package/dist/app/utils/asset-capture.d.ts

@@ -1,2 +1,3 @@
 export declare const AssetCaptureContext: import("react").Context<Set<string>>;
 export declare const useAssetCapture: () => Set<string>;
+//# sourceMappingURL=asset-capture.d.ts.map

package/dist/app/utils/asset-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-capture.d.ts","sourceRoot":"","sources":["../../../src/app/utils/asset-capture.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,sCAAwC,CAAA;AAExE,eAAO,MAAM,eAAe,mBAE3B,CAAA"}

package/dist/app/utils/hydration-debugger.d.ts

@@ -11,3 +11,4 @@ export declare const hydrationDebug: {
         info: any;
     }): void;
 };
+//# sourceMappingURL=hydration-debugger.d.ts.map

package/dist/app/utils/hydration-debugger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration-debugger.d.ts","sourceRoot":"","sources":["../../../src/app/utils/hydration-debugger.tsx"],"names":[],"mappings":"AAEA,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,GAAG,CAAA;CACV,CAAA;AAED,eAAO,MAAM,cAAc;;YAEX,sBAAsB,EAAE;cAC5B;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE;CAMrC,CAAA"}

package/dist/app/utils/query-client.d.ts

@@ -2,3 +2,4 @@ import { QueryClient } from "@tanstack/react-query";
 import { PropsWithChildren } from "react";
 export declare function getQueryClient(): QueryClient;
 export declare function QueryProvider(props: PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=query-client.d.ts.map

package/dist/app/utils/query-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-client.d.ts","sourceRoot":"","sources":["../../../src/app/utils/query-client.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAuB,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAGzC,wBAAgB,cAAc,gBAc7B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,CAAC,EAAE,CAAC,2CAEzD"}