eddev 2.0.0-beta.6 → 2.0.0-beta.61

package/dist/app/lib/routing/hooks/useRouteTransition.js

@@ -1,5 +1,5 @@
 import { useEffect, useRef } from "react";
-import { useRouter } from "./useRouter";
+import { useRouter } from "./useRouter.js";
 export function useRouteTransition(func) {
     const subscribe = useRouter((r) => r.subscribe);
     const handler = useRef(func);

package/dist/app/lib/routing/hooks/useRouter.d.ts

@@ -1,2 +1,2 @@
-import { RouterAPI } from "../types";
+import { RouterAPI } from "../types.js";
 export declare function useRouter<T = RouterAPI>(selector?: (r: RouterAPI) => T): T;

package/dist/app/lib/routing/hooks/useRouter.js

@@ -1,5 +1,5 @@
 import { useContext } from "react";
-import { RouterContext } from "../context";
+import { RouterContext } from "../context.js";
 export function useRouter(selector) {
     const router = useContext(RouterContext);
     if (selector) {

package/dist/app/lib/routing/hooks/useRouterEvents.d.ts

@@ -1,2 +1,2 @@
-import type { RouterEvent } from "../types";
+import type { RouterEvent } from "../types.js";
 export declare function useRouterEvents(handler: (event: RouterEvent) => void): void;

package/dist/app/lib/routing/hooks/useRouterEvents.js

@@ -1,5 +1,5 @@
 import { useEffect, useRef } from "react";
-import { useRouter } from "./useRouter";
+import { useRouter } from "./useRouter.js";
 export function useRouterEvents(handler) {
     const subscribe = useRouter((r) => r.subscribe);
     const ref = useRef(handler);

package/dist/app/lib/routing/hooks/useRouterState.d.ts

@@ -1,2 +1,2 @@
-import { RouterAPIState } from "../types";
+import { RouterAPIState } from "../types.js";
 export declare function useRouterState<T = RouterAPIState>(selector?: (state: RouterAPIState) => T): T;

package/dist/app/lib/routing/hooks/useRouterState.js

@@ -1,5 +1,5 @@
 import { useContext } from "react";
-import { RouterStateContext } from "../context";
+import { RouterStateContext } from "../context.js";
 export function useRouterState(selector) {
     const ctx = useContext(RouterStateContext);
     if (selector)

package/dist/app/lib/routing/hooks/useSearchParams.js

@@ -1,6 +1,6 @@
 import { useMemo } from "react";
-import { useRoute } from "./useRoute";
-import { useRouter } from "./useRouter";
+import { useRoute } from "./useRoute.js";
+import { useRouter } from "./useRouter.js";
 export function useSearchParams(defaultValue) {
     const route = useRoute();
     const replaceQuery = useRouter((r) => r.replaceQuery);

package/dist/app/lib/routing/index.d.ts

@@ -1,13 +1,14 @@
-export * from "./types";
-export * from "./components/Link";
-export * from "./components/ScrollRestoration";
-export * from "./components/RouteRenderer";
-export * from "./components/ClientOnly";
-export * from "./hooks/useRoute";
-export * from "./hooks/useRouteTransition";
-export * from "./hooks/useRouter";
-export * from "./hooks/useRouterEvents";
-export * from "./hooks/useRouterState";
-export * from "./hooks/useRestorableState";
-export * from "./hooks/useIsSSR";
-export * from "./hooks/useSearchParams";
+export * from "./types.js";
+export * from "./components/Link.js";
+export * from "./components/ScrollRestoration.js";
+export * from "./components/RouteRenderer.js";
+export * from "./components/ClientOnly.js";
+export * from "./components/BackButton.js";
+export * from "./hooks/useRoute.js";
+export * from "./hooks/useRouteTransition.js";
+export * from "./hooks/useRouter.js";
+export * from "./hooks/useRouterEvents.js";
+export * from "./hooks/useRouterState.js";
+export * from "./hooks/useRestorableState.js";
+export * from "./hooks/useIsSSR.js";
+export * from "./hooks/useSearchParams.js";

package/dist/app/lib/routing/index.js

@@ -1,13 +1,14 @@
-export * from "./types";
-export * from "./components/Link";
-export * from "./components/ScrollRestoration";
-export * from "./components/RouteRenderer";
-export * from "./components/ClientOnly";
-export * from "./hooks/useRoute";
-export * from "./hooks/useRouteTransition";
-export * from "./hooks/useRouter";
-export * from "./hooks/useRouterEvents";
-export * from "./hooks/useRouterState";
-export * from "./hooks/useRestorableState";
-export * from "./hooks/useIsSSR";
-export * from "./hooks/useSearchParams";
+export * from "./types.js";
+export * from "./components/Link.js";
+export * from "./components/ScrollRestoration.js";
+export * from "./components/RouteRenderer.js";
+export * from "./components/ClientOnly.js";
+export * from "./components/BackButton.js";
+export * from "./hooks/useRoute.js";
+export * from "./hooks/useRouteTransition.js";
+export * from "./hooks/useRouter.js";
+export * from "./hooks/useRouterEvents.js";
+export * from "./hooks/useRouterState.js";
+export * from "./hooks/useRestorableState.js";
+export * from "./hooks/useIsSSR.js";
+export * from "./hooks/useSearchParams.js";

package/dist/app/lib/routing/loader.d.ts

@@ -1,6 +1,6 @@
 import { FunctionComponent, PropsWithChildren } from "react";
-import { DynamicComponent } from "../dynamic/dynamic";
-import { RouteData } from "./types";
+import { DynamicComponent } from "../dynamic/dynamic.js";
+import { RouteData } from "./types.js";
 export type RouteCacheEntry = {
     data: RouteData;
     component: FunctionComponent;

package/dist/app/lib/routing/loader.js

@@ -1,5 +1,5 @@
 import { parseURL, stringifyParsedURL, stringifyQuery, withTrailingSlash } from "ufo";
-import { viewManifestReader } from "../internal";
+import { viewManifestReader } from "../internal/read-view-manifest.js";
 export class RouteError extends Error {
     message;
     statusCode;
@@ -31,10 +31,12 @@ export class RouteLoader {
         const origin = parseURL(sampleUrl);
         let propsPath = withTrailingSlash(pathname);
         let query = {};
-        if (opts.serverless) {
-            query["_debug"] = opts.debug ? "1" : "0";
-            query["_props"] = opts.appData ? "all" : "1";
-            query["_ssr"] = "1";
+        if (env.serverless && env.client) {
+            propsPath = "/_data/route" + propsPath;
+            query = {};
+            // query["_debug"] = opts.debug ? "1" : "0"
+            // query["_props"] = opts.appData ? "all" : "1"
+            // query["_ssr"] = "1"
         }
         else {
             query["_debug"] = opts.debug ? "1" : "0";

package/dist/app/lib/routing/types.d.ts

@@ -1,9 +1,16 @@
 import { FunctionComponent } from "react";
-import type { RouteLoader } from "./loader";
-import { LinkHandlerMode, PointerOrMouseEvent } from "./utils";
-export type ParsedRouteTags = Record<"title" | "meta" | "script" | "style" | "link", {
-    [key: string]: string;
-}[]>;
+import type { RouteLoader } from "./loader.js";
+import { LinkHandlerMode, PointerOrMouseEvent } from "./utils.js";
+export type RouteMetaTag = {
+    tagName: string;
+    attributes: Record<string, string>;
+    inner?: string;
+};
+export type TrackerTags = {
+    head?: RouteMetaTag[];
+    body?: RouteMetaTag[];
+    footer?: RouteMetaTag[];
+};
 export interface RouteData {
     view: string;
     editLink?: string;
@@ -13,10 +20,13 @@ export interface RouteData {
     redirect?: string;
     canonical?: string;
     meta?: {
-        head: ParsedRouteTags;
-        footer: ParsedRouteTags;
+        head: RouteMetaTag[];
+        footer: RouteMetaTag[];
     };
 }
+export interface RouteDataWithTrackers extends RouteData {
+    trackers?: TrackerTags;
+}
 export type RouteReturnState<T = {}> = {
     scrollTop: number;
     scrollLeft: number;
@@ -99,14 +109,24 @@ export type RouterAPI = {
     replaceQuery: (search: Record<string, string | string[]>) => void;
     /** Replace the hash */
     replaceHash: (hash: string) => void;
-    /** Handle link clicking events */
-    handleClickEvent(e: PointerOrMouseEvent, href?: string): void;
+    /**
+     * Handle a click event, potentially triggering a route change.
+     *
+     * @param e A pointer or mouse event.
+     * @param href An optional URL. This must be provided if no `href` property exists on the clicked element
+     * @param preferBack If set, clicking this link will send the user 'back', when clicking a link to the previous history item.
+     */
+    handleClickEvent(e: PointerOrMouseEvent, href?: string, preferBack?: boolean | "exact"): void;
     /** A reference to the route loader (mostly for internal use) */
     loader: RouteLoader;
     /** Subscribe to events */
     subscribe: (subscribe: RouterSubscriber) => () => void;
     /** This function is used by the routing system automatically */
     emitEvent: (event: RouterEvent) => void;
+    /** Returns the current RouterAPIState */
+    getState: () => RouterAPIState | null;
+    /** Go back to a previous route in the history stack, or push it onto the stack if it isn't currently on the stack. */
+    restoreRoute: (route: RouteState) => void;
 };
 export type TypedRouteState<T, TProps> = {
     /** A unique ID, representing this history item. */
@@ -131,6 +151,12 @@ export type TypedRouteState<T, TProps> = {
     component: FunctionComponent<TProps>;
     /** The props for this route, to be passed to the component. */
     props: TProps;
+    /** Loaded metadata for this route */
+    meta: RouteMeta;
+};
+export type RouteMeta = {
+    title?: string;
+    tags?: RouteMetaTag[];
 };
 export type RouteState = {
     [K in keyof ViewProps]: TypedRouteState<K, ViewProps[K]>;

package/dist/app/lib/routing/utils.d.ts

@@ -1,6 +1,7 @@
 import { MouseEvent as ReactMouseEvent, PointerEvent as ReactPointerEvent } from "react";
-import { RouteLink, RouteState } from "./types";
+import { RouteData, RouteLink, RouteMeta, RouteState } from "./types.js";
 export declare function isSameOrigin(url: string): boolean;
+export declare function isSamePathname(a: string, b: string): boolean;
 export type PointerOrMouseEvent = MouseEvent | PointerEvent | ReactMouseEvent | ReactPointerEvent;
 export type LinkHandlerMode = {
     mode: "ignore" | "navigate" | "native";
@@ -12,4 +13,5 @@ export declare function normalizeRoute(route: Partialize<RouteState, "uri" | "re
 export declare function stringifyRouteLink(route: RouteLink): string;
 export declare function parseQuery(query: string): Record<string, string | string[]>;
 export declare function stringifyQuery(query: any): string;
+export declare function getRouteMeta(data: RouteData): RouteMeta;
 export {};

package/dist/app/lib/routing/utils.js

@@ -1,5 +1,5 @@
+import { parse as qsParse, stringify as qsStringify } from "qs";
 import { parseURL, resolveURL, stringifyParsedURL, withoutTrailingSlash } from "ufo";
-import { stringify as qsStringify, parse as qsParse } from "qs";
 export function isSameOrigin(url) {
     if (typeof document === "undefined") {
         return url.startsWith("/");
@@ -10,6 +10,11 @@ export function isSameOrigin(url) {
         return parsed.protocol === document.location.protocol && parsed.host === document.location.host;
     }
 }
+export function isSamePathname(a, b) {
+    const left = parseURL(a).pathname.replace(/\/$/, "").toLocaleLowerCase();
+    const right = parseURL(b).pathname.replace(/\/$/, "").toLocaleLowerCase();
+    return left === right;
+}
 export function getLinkHandlerMode(e, href) {
     try {
         // Attempt to get the link element, if there is one
@@ -92,3 +97,9 @@ export function stringifyQuery(query) {
         arrayFormat: "brackets",
     });
 }
+export function getRouteMeta(data) {
+    return {
+        title: data.meta?.head.find((tag) => tag.tagName === "title")?.inner,
+        tags: data.meta?.head ?? [],
+    };
+}

package/dist/app/lib/{hooks → runtime}/apiConfig.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Configuration options for manipulating how the client interacts with the GraphQL API
+ */
 export type APIConfigStore = {
     /**
      * Any value, which will be used as part of the cache key for each query.
@@ -11,8 +14,9 @@ export type APIConfigStore = {
      */
     customQueryFetchOptions?: (type: "query" | "mutation", queryName: string, queryArgs: any, url: string, opts: RequestInit) => RequestInit | Promise<RequestInit>;
     /**
-     * Update aspects of the API client
+     * Allows you to hook into the response of a query or mutation.
      */
+    onResponse?: (response: Response, type: "query" | "mutation", queryName: string, queryArgs: any, url: string, opts: RequestInit) => void;
     set: (config: Partial<APIConfigStore>) => void;
 };
-export declare const useAPIConfig: import("zustand").UseBoundStore<import("zustand").StoreApi<APIConfigStore>>;
+export declare const apiConfig: APIConfigStore;

package/dist/app/lib/runtime/apiConfig.js

@@ -0,0 +1,6 @@
+import { proxy } from "valtio";
+export const apiConfig = proxy({
+    set: (config) => {
+        Object.assign(apiConfig, config);
+    },
+});

package/dist/app/lib/runtime/errorHandling.d.ts

@@ -0,0 +1,39 @@
+import { ContentBlock } from "../blocks";
+import { ReactNode } from "react";
+import { RouteState } from "../routing";
+export type ErrorEvent = {
+    /** The runtime error that occurred */
+    error: Error;
+    /** The Component stack (not available in renderBlockError) */
+    componentStack?: string;
+} & ({
+    type: "block";
+    /** The block which had an error, including it's type information, props, content and children */
+    block: ContentBlock;
+} | {
+    type: "route";
+    /** The route which had an error */
+    route: RouteState;
+});
+/**
+ * Configuration options for manipulating how the client interacts with the GraphQL API
+ */
+export type ErrorHandlingConfig = {
+    /**
+     * Triggered when a runtime error occurs in a block
+     * @param event The error event, containing the error and block information
+     **/
+    onReactError?(event: ErrorEvent): void;
+    /**
+     * Triggered when a React rendering error occurs, and allows you to return some JSX to render as a fallback.
+     * If not provided, the block will be hidden from the user.
+     * @param error The error event, containing the error and contextual information
+     * @param defaultDisplay The default display for the block — in development, this will display the error message. In production, this will be `null`.
+     */
+    renderFallback?(event: ErrorEvent, defaultDisplay: ReactNode): ReactNode;
+    /**
+     * Update the error handling configuration all at once
+     */
+    set: (config: Partial<ErrorHandlingConfig>) => void;
+};
+export declare const errorHandling: ErrorHandlingConfig;

package/dist/app/lib/runtime/errorHandling.js

@@ -0,0 +1,6 @@
+import { proxy } from "valtio";
+export const errorHandling = proxy({
+    set: (config) => {
+        Object.assign(errorHandling, config);
+    },
+});

package/dist/app/lib/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./apiConfig";
+export * from "./errorHandling";

package/dist/app/lib/runtime/index.js

@@ -0,0 +1,2 @@
+export * from "./apiConfig";
+export * from "./errorHandling";

package/dist/app/lib/views/index.d.ts

@@ -1 +1 @@
-export * from "./defineView";
+export * from "./defineView.js";

package/dist/app/lib/views/index.js

@@ -1 +1 @@
-export * from "./defineView";
+export * from "./defineView.js";

package/dist/app/server/defineRouter.d.ts

@@ -0,0 +1,2 @@
+import { Hono } from "hono";
+export declare function defineRouter(): Hono;

package/dist/app/server/defineRouter.js

@@ -0,0 +1,4 @@
+import { Hono } from "hono";
+export function defineRouter() {
+    return new Hono();
+}

package/dist/app/server/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./render-ssr-page.js";
+export * from "./server-context.js";
+export * from "./proxy-wp-admin.js";
+export * from "./defineRouter.js";
+export * from "./rpc.js";

package/dist/app/server/index.js

@@ -0,0 +1,5 @@
+export * from "./render-ssr-page.js";
+export * from "./server-context.js";
+export * from "./proxy-wp-admin.js";
+export * from "./defineRouter.js";
+export * from "./rpc.js";

package/dist/app/server/proxy-wp-admin.d.ts

@@ -0,0 +1,2 @@
+import { EventHandlerRequest, H3Event } from "vinxi/http";
+export declare function proxyWpAdmin(event: H3Event<EventHandlerRequest>): Promise<Response>;

package/dist/app/server/proxy-wp-admin.js

@@ -0,0 +1,112 @@
+/// <reference types="vinxi/types/server" />
+import { splitSetCookieString } from "cookie-es";
+import { getProxyRequestHeaders, getRequestURL, getWebRequest } from "vinxi/http";
+import { ServerContext } from "./server-context.js";
+export async function proxyWpAdmin(event) {
+    const serverContext = ServerContext.main;
+    const replaceUrls = serverContext.replaceUrls;
+    const req = getWebRequest(event);
+    const proxyUrl = serverContext.getOriginUrl(getRequestURL(event).href);
+    // Prepare request headers to be sent to the origin server
+    const proxyHeaders = getProxyRequestHeaders(event);
+    proxyHeaders["X-ED-Dev-Proxy"] = "true";
+    // Forward the request to the origin server
+    const response = await fetch(proxyUrl, {
+        method: req.method,
+        referrer: req.referrer,
+        referrerPolicy: req.referrerPolicy,
+        headers: proxyHeaders,
+        body: req.method.match(/get|head|options/i) ? undefined : await req.blob(),
+        redirect: "manual",
+        cache: "no-cache",
+    });
+    const contentType = response.headers.get("content-type");
+    let body;
+    let res = { status: response.status, statusText: response.statusText, headers: new Headers() };
+    const cookies = [];
+    response.headers.forEach((value, key) => {
+        if (key === "content-encoding" || key === "content-length" || key === "transfer-encoding") {
+            return;
+        }
+        if (key === "set-cookie") {
+            cookies.push(...splitSetCookieString(value));
+            return;
+        }
+        if (key === "location" && replaceUrls) {
+            value = replaceUrls(value);
+        }
+        res.headers.set(key, value);
+    });
+    // Set cookies in the response headers
+    // TODO: May need to rewrite cookie domain here before setting.
+    if (cookies.length > 0) {
+        for (const cookie of cookies) {
+            res.headers.append("set-cookie", cookie);
+        }
+    }
+    // Replace URLs pointing to the origin server from the response itself
+    // This is only done for text-based content types, like application/json, text/plain, text/html etc
+    if (contentType?.match(/(application|text)\//)) {
+        if (replaceUrls) {
+            body = replaceUrls((await response.text()) ?? "");
+        }
+        // If the content type is text/html, inject the Vite assets into the response — assuming the placeholder comments are found
+        if (contentType.startsWith("text/html")) {
+            const clientManifest = serverContext.runtime.getManifest("admin");
+            const assets = await clientManifest.inputs[clientManifest.handler].assets();
+            const getViteHeader = () => assets.map((asset) => renderAsset(asset)).join("\n");
+            const getViteFooter = () => renderAsset({
+                tag: "script",
+                attrs: {
+                    type: "module",
+                    src: clientManifest.inputs[clientManifest.handler].output.path,
+                },
+                children: "",
+            });
+            const encodeForJSON = (str) => JSON.stringify(str).slice(1, -1).replace(/\"/g, "'");
+            body = body.replace(/<!---VITE_HEADER--->/g, getViteHeader);
+            body = body.replace(/<!---VITE_FOOTER--->/g, getViteFooter);
+            body = body.replace(/<!---VITE_HEADER_ENCODED--->/g, encodeForJSON(getViteHeader()));
+            body = body.replace(/<!---VITE_FOOTER_ENCODED--->/g, encodeForJSON(getViteFooter()));
+        }
+    }
+    else {
+        // Otherwise just stream the response as is
+        body = response.body;
+    }
+    return new Response(body, res);
+}
+function printElement(element, props, innerText) {
+    if (typeof innerText === "string") {
+        return `<${element}${Object.entries(props)
+            .map(([key, value]) => ` ${key}="${value}"`)
+            .join("")}>${innerText}</${element}>`;
+    }
+    else {
+        return `<${element}${Object.entries(props)
+            .map(([key, value]) => ` ${key}="${value}"`)
+            .join("")} />`;
+    }
+}
+function renderAsset({ tag, attrs: { key, ...attrs } = {}, children, }) {
+    switch (tag) {
+        case "script":
+            if (attrs.src) {
+                return printElement("script", { ...attrs, key: attrs.src }, "");
+            }
+            else {
+                return printElement("script", {
+                    ...attrs,
+                    key: key,
+                }, children ?? "");
+            }
+        case "link":
+            return printElement("link", { ...attrs, key: key });
+        case "style":
+            return printElement("style", {
+                ...attrs,
+                key: key,
+            }, children ?? "");
+    }
+    return "";
+}

package/dist/app/server/render-ssr-page.d.ts

@@ -0,0 +1,11 @@
+import type { RouteDataWithTrackers } from "../lib/routing/types.js";
+type SSRArgs = {
+    pathname: string;
+    initialData: RouteDataWithTrackers;
+};
+export declare function getSsrStream(args: SSRArgs): Promise<ReadableStream<Uint8Array>>;
+type RenderArgs = {
+    pathname: string;
+};
+export declare function renderPage(args: RenderArgs): Promise<Response>;
+export {};

package/dist/app/server/render-ssr-page.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderAsset } from "@vinxi/react";
+import { Suspense } from "react";
+import { renderToPipeableStream } from "react-dom/server";
+import { SSRRoot } from "../entry/ssr-root.js";
+import { RouteLoader } from "../lib/routing/loader.js";
+import { ServerContext } from "./server-context.js";
+import { Writable } from "stream";
+export async function getSsrStream(args) {
+    const clientManifest = ServerContext.main.runtime.getManifest("client");
+    const assets = await clientManifest.inputs[clientManifest.handler].assets();
+    const jsx = (_jsx(SSRRoot, { assets: _jsx(Suspense, { children: assets.map((m) => renderAsset(m)) }), metaTags: args.initialData?.meta?.head || [], pathname: args.pathname, initialData: args.initialData, loader: new RouteLoader() }));
+    const stream = await new Promise(async (resolve, reject) => {
+        // console.log("Rendering to pipable")
+        const stream = renderToPipeableStream(jsx, {
+            onShellReady() {
+                // console.log("Shell ready")
+                resolve(stream);
+            },
+            onShellError(err) {
+                console.log("onShellError", err);
+                reject(err);
+            },
+            onError(err, errInfo) {
+                console.log("Error occurred after shell ready", err, errInfo);
+                console.error(err);
+            },
+            bootstrapModules: [clientManifest.inputs[clientManifest.handler].output.path],
+            bootstrapScriptContent: `window.manifest = ${JSON.stringify(await clientManifest.json())};\nwindow._PAGE_DATA = ${JSON.stringify(args.initialData)};\nwindow._TRACKERS = ${JSON.stringify(args.initialData.trackers)}`,
+        });
+    });
+    return new ReadableStream({
+        async start(controller) {
+            const writableStream = new Writable({
+                emitClose: true,
+                write(chunk, encoding, callback) {
+                    controller.enqueue(chunk);
+                    callback();
+                },
+                final(callback) {
+                    controller.close();
+                    callback();
+                },
+            });
+            stream.pipe(writableStream);
+        },
+    });
+}
+export async function renderPage(args) {
+    const serverContext = ServerContext.main;
+    let headers = new Headers();
+    let responseInit = {
+        headers,
+    };
+    try {
+        const [{ appData, trackers }, response] = await Promise.all([
+            serverContext.fetchAppData(),
+            serverContext.fetchRouteData({
+                pathname: args.pathname,
+                withAppData: false,
+                headers: {},
+                query: {},
+            }),
+        ]);
+        let data;
+        try {
+            data = await response.json();
+            data.appData = appData;
+            data.trackers = trackers;
+        }
+        catch (err) {
+            data = {
+                view: "_error",
+                viewType: "react",
+                viewData: {},
+                appData: appData,
+            };
+            console.error(err);
+            responseInit.status = 500;
+        }
+        headers.set("Content-Type", "text/html; charset=utf-8");
+        const stream = await getSsrStream({
+            ...args,
+            initialData: data,
+        });
+        return new Response(stream, responseInit);
+    }
+    catch (err) {
+        console.error(err);
+        return new Response('<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1>500 Internal Server Error</h1><p>"' +
+            String(err) +
+            '"</p></body></html>', {
+            status: 500,
+            statusText: "Internal Server Error",
+            headers: {
+                "Content-Type": "text/html; charset=utf-8",
+            },
+        });
+    }
+}