@bleedingdev/modern-js-plugin-data-loader 3.2.0-ultramodern.0

package/dist/esm/runtime/response.mjs

@@ -0,0 +1,42 @@
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { TextEncoder } from "util";
+function isTrackedPromise(value) {
+    return null != value && 'function' == typeof value.then && true === value._tracked;
+}
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = '__deferred_promise:';
+function createDeferredReadableStream(deferredData, signal) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start (controller) {
+            const criticalData = {};
+            const preresolvedKeys = [];
+            for (const [key, value] of Object.entries(deferredData.data))if (isTrackedPromise(value)) {
+                criticalData[key] = `${DEFERRED_VALUE_PLACEHOLDER_PREFIX}${key}`;
+                if (void 0 !== value._data || void 0 !== value._error) preresolvedKeys.push(key);
+            } else criticalData[key] = value;
+            controller.enqueue(encoder.encode(`${JSON.stringify(criticalData)}\n\n`));
+            for (const preresolvedKey of preresolvedKeys)enqueueTrackedPromise(controller, encoder, preresolvedKey, deferredData.data[preresolvedKey]);
+            const unsubscribe = deferredData.subscribe((aborted, settledKey)=>{
+                if (settledKey) enqueueTrackedPromise(controller, encoder, settledKey, deferredData.data[settledKey]);
+            });
+            await deferredData.resolveData(signal);
+            unsubscribe();
+            controller.close();
+        }
+    });
+    return stream;
+}
+function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
+    if ('_error' in promise) {
+        const { _error } = promise;
+        controller.enqueue(encoder.encode(`error:${serializeJson({
+            [settledKey]: {
+                message: _error.message,
+                stack: _error.stack
+            }
+        })}\n\n`));
+    } else controller.enqueue(encoder.encode(`data:${JSON.stringify({
+        [settledKey]: promise._data ?? null
+    })}\n\n`));
+}
+export { createDeferredReadableStream };

package/dist/esm-node/cli/createRequest.mjs

@@ -0,0 +1,94 @@
+import "node:module";
+import { redirect } from "@modern-js/runtime-utils/router";
+import { compile } from "path-to-regexp";
+import { CONTENT_TYPE_DEFERRED, DIRECT_PARAM, LOADER_ID_PARAM } from "../common/constants.mjs";
+import { parseDeferredReadableStream } from "./data.mjs";
+const getRequestUrl = ({ params, request, routeId })=>{
+    const url = new URL(request.url);
+    const toPath = compile(url.pathname, {
+        encode: encodeURIComponent
+    });
+    const newPathName = toPath(params);
+    url.pathname = newPathName;
+    url.searchParams.append(LOADER_ID_PARAM, routeId);
+    url.searchParams.append(DIRECT_PARAM, 'true');
+    return url;
+};
+const handleRedirectResponse = (res)=>{
+    const { headers } = res;
+    const location = headers.get('X-Modernjs-Redirect');
+    if (location) throw redirect(location);
+    return res;
+};
+const isDeferredResponse = (res)=>res.headers.get('Content-Type')?.match(CONTENT_TYPE_DEFERRED) && res.body;
+const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+const isErrorResponse = (res)=>null != res.headers.get('X-Modernjs-Error');
+function isOtherErrorResponse(res) {
+    return res.status >= 400 && null == res.headers.get('X-Modernjs-Error') && null == res.headers.get('X-Modernjs-Catch') && null == res.headers.get('X-Modernjs-Response');
+}
+const isCatchResponse = (res)=>null != res.headers.get('X-Modernjs-Catch');
+const handleErrorResponse = async (res)=>{
+    const data = await res.json();
+    const error = new Error(data.message);
+    error.stack = data.stack;
+    throw error;
+};
+const handleNetworkErrorResponse = async (res)=>{
+    const text = await res.text();
+    const error = new Error(text);
+    error.stack = void 0;
+    throw error;
+};
+const createRequest = (routeId, method = 'get')=>async ({ params, request })=>{
+        const url = getRequestUrl({
+            params,
+            request,
+            routeId
+        });
+        let res;
+        res = await fetch(url, {
+            method,
+            signal: request.signal
+        }).catch((error)=>{
+            throw error;
+        });
+        if (isRedirectResponse(res)) return handleRedirectResponse(res);
+        if (isErrorResponse(res)) return await handleErrorResponse(res);
+        if (isCatchResponse(res)) throw res;
+        if (isDeferredResponse(res)) {
+            const deferredData = await parseDeferredReadableStream(res.body);
+            return deferredData.data;
+        }
+        if (isOtherErrorResponse(res)) return await handleNetworkErrorResponse(res);
+        return res;
+    };
+const createActionRequest = (routeId)=>async ({ params, request })=>{
+        const url = getRequestUrl({
+            params,
+            request,
+            routeId
+        });
+        const init = {
+            signal: request.signal
+        };
+        if ('GET' !== request.method) {
+            init.method = request.method;
+            const contentType = request.headers.get('Content-Type');
+            if (contentType && /\bapplication\/json\b/.test(contentType)) {
+                init.headers = {
+                    'Content-Type': contentType
+                };
+                init.body = JSON.stringify(await request.json());
+            } else if (contentType && /\btext\/plain\b/.test(contentType)) {
+                init.headers = {
+                    'Content-Type': contentType
+                };
+                init.body = await request.text();
+            } else if (contentType && /\bapplication\/x-www-form-urlencoded\b/.test(contentType)) init.body = new URLSearchParams(await request.text());
+            else init.body = await request.formData();
+        }
+        const res = await fetch(url, init);
+        if (!res.ok) throw res;
+        return res;
+    };
+export { createActionRequest, createRequest, getRequestUrl };

package/dist/esm-node/cli/data.mjs

@@ -0,0 +1,112 @@
+import "node:module";
+import { AbortedDeferredError, DeferredData } from "@modern-js/runtime-utils/browser";
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = '__deferred_promise:';
+async function parseDeferredReadableStream(stream) {
+    if (!stream) throw new Error('parseDeferredReadableStream requires stream argument');
+    let deferredData;
+    const deferredResolvers = {};
+    try {
+        const sectionReader = readStreamSections(stream);
+        const initialSectionResult = await sectionReader.next();
+        const initialSection = initialSectionResult.value;
+        if (!initialSection) throw new Error('no critical data');
+        const criticalData = JSON.parse(initialSection);
+        if ('object' == typeof criticalData && null !== criticalData) {
+            for (const [eventKey, value] of Object.entries(criticalData))if ('string' == typeof value && value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
+                deferredData = deferredData || {};
+                deferredData[eventKey] = new Promise((resolve, reject)=>{
+                    deferredResolvers[eventKey] = {
+                        resolve: (value)=>{
+                            resolve(value);
+                            delete deferredResolvers[eventKey];
+                        },
+                        reject: (error)=>{
+                            reject(error);
+                            delete deferredResolvers[eventKey];
+                        }
+                    };
+                });
+            }
+        }
+        (async ()=>{
+            try {
+                for await (const section of sectionReader){
+                    const [event, ...sectionDataStrings] = section.split(':');
+                    const sectionDataString = sectionDataStrings.join(':');
+                    const data = JSON.parse(sectionDataString);
+                    if ('data' === event) {
+                        for (const [key, value] of Object.entries(data))if (deferredResolvers[key]) deferredResolvers[key].resolve(value);
+                    } else if ('error' === event) for (const [key, value] of Object.entries(data)){
+                        const err = new Error(value.message);
+                        err.stack = value.stack;
+                        if (deferredResolvers[key]) deferredResolvers[key].reject(err);
+                    }
+                }
+                for (const [key, resolver] of Object.entries(deferredResolvers))resolver.reject(new AbortedDeferredError(`Deferred ${key} will never resolved`));
+            } catch (error) {
+                for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+            }
+        })();
+        return new DeferredData({
+            ...criticalData,
+            ...deferredData
+        });
+    } catch (error) {
+        for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+        throw error;
+    }
+}
+async function* readStreamSections(stream) {
+    const reader = stream.getReader();
+    let buffer = [];
+    let sections = [];
+    let closed = false;
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const readStreamSection = async ()=>{
+        if (sections.length > 0) return sections.shift();
+        while(!closed && 0 === sections.length){
+            const chunk = await reader.read();
+            if (chunk.done) {
+                closed = true;
+                break;
+            }
+            buffer.push(chunk.value);
+            try {
+                const bufferedString = decoder.decode(mergeArrays(...buffer));
+                const splitSections = bufferedString.split('\n\n');
+                if (splitSections.length >= 2) {
+                    sections.push(...splitSections.slice(0, -1));
+                    buffer = [
+                        encoder.encode(splitSections.slice(-1).join('\n\n'))
+                    ];
+                }
+                if (sections.length > 0) break;
+            } catch  {
+                continue;
+            }
+        }
+        if (sections.length > 0) return sections.shift();
+        if (buffer.length > 0) {
+            const bufferedString = decoder.decode(mergeArrays(...buffer));
+            sections = bufferedString.split('\n\n').filter((s)=>s);
+            buffer = [];
+        }
+        return sections.shift();
+    };
+    let section = await readStreamSection();
+    while(section){
+        yield section;
+        section = await readStreamSection();
+    }
+}
+function mergeArrays(...arrays) {
+    const out = new Uint8Array(arrays.reduce((total, arr)=>total + arr.length, 0));
+    let offset = 0;
+    for (const arr of arrays){
+        out.set(arr, offset);
+        offset += arr.length;
+    }
+    return out;
+}
+export { parseDeferredReadableStream };

package/dist/esm-node/cli/generateClient.mjs

@@ -0,0 +1,26 @@
+import "node:module";
+import path from "path";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var generateClient_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const generateClient = ({ inline, action, routeId })=>{
+    let requestCode = "";
+    const requestCreatorPath = path.join(generateClient_dirname, './createRequest').replace('/cjs/cli/', '/esm/cli/').replace(/\\/g, '/');
+    const importCode = `
+    import { createRequest, createActionRequest } from '${requestCreatorPath}';
+  `;
+    requestCode = inline ? action ? `
+      export const loader = createRequest('${routeId}');
+      export const action = createActionRequest('${routeId}')
+    ` : `
+      export const loader = createRequest('${routeId}');
+    ` : `
+    export default createRequest('${routeId}');
+  `;
+    const generatedCode = `
+    ${importCode}
+    ${requestCode}
+  `;
+    return generatedCode;
+};
+export { generateClient };

package/dist/esm-node/cli/loader.mjs

@@ -0,0 +1,35 @@
+import "node:module";
+import { logger } from "@modern-js/utils";
+import { promisify } from "util";
+import { generateClient } from "./generateClient.mjs";
+async function loader(source) {
+    this.cacheable();
+    const target = this._compiler?.options.target;
+    const shouldSkip = (compileTarget)=>target === compileTarget || Array.isArray(target) && target.includes(compileTarget);
+    if (shouldSkip('node') || shouldSkip('webworker') || shouldSkip('async-node')) return source;
+    const { resourceQuery } = this;
+    const options = resourceQuery.slice(1).split('&').reduce((pre, cur)=>{
+        const [key, value] = cur.split('=');
+        if (key && value) pre[key] = 'true' === value ? true : 'false' === value ? false : value;
+        return pre;
+    }, {});
+    if (!options.loaderId || options.retain) return source;
+    if (options.clientData) {
+        const readFile = promisify(this.fs.readFile);
+        try {
+            const clientDataPath = this.resourcePath.includes('.loader.') ? this.resourcePath.replace('.loader.', '.data.client.') : this.resourcePath.replace('.data.', '.data.client.');
+            this.addDependency(clientDataPath);
+            const clientDataContent = await readFile(clientDataPath);
+            return clientDataContent;
+        } catch (error) {
+            if ('development' === process.env.NODE_ENV) logger.error(`Failed to read the clientData file ${options.clientData}`);
+        }
+    }
+    const code = generateClient({
+        inline: options.inline,
+        action: options.action,
+        routeId: options.routeId
+    });
+    return code;
+}
+export default loader;

package/dist/esm-node/common/constants.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+const LOADER_ID_PARAM = '__loader';
+const DIRECT_PARAM = '__ssrDirect';
+const CONTENT_TYPE_DEFERRED = 'text/modernjs-deferred';
+export { CONTENT_TYPE_DEFERRED, DIRECT_PARAM, LOADER_ID_PARAM };

package/dist/esm-node/runtime/errors.mjs

@@ -0,0 +1,53 @@
+import "node:module";
+import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+function sanitizeError(error) {
+    if (error instanceof Error && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV) {
+        const sanitized = new Error(error.message || 'Unexpected Server Error');
+        sanitized.stack = void 0;
+        return sanitized;
+    }
+    return error;
+}
+function sanitizeErrors(errors) {
+    return Object.entries(errors).reduce((acc, [routeId, error])=>Object.assign(acc, {
+            [routeId]: sanitizeError(error)
+        }), {});
+}
+function serializeError(error) {
+    const sanitized = sanitizeError(error);
+    return {
+        message: sanitized.message,
+        stack: sanitized.stack
+    };
+}
+function serializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = {
+        ...val,
+        __type: 'RouteErrorResponse'
+    };
+    else if (val instanceof Error) {
+        const sanitized = sanitizeError(val);
+        serialized[key] = {
+            message: sanitized.message,
+            stack: sanitized.stack,
+            __type: 'Error',
+            ...'Error' !== sanitized.name ? {
+                __subType: sanitized.name
+            } : {}
+        };
+    } else serialized[key] = val;
+    return serialized;
+}
+function errorResponseToJson(errorResponse) {
+    return Response.json(serializeError(errorResponse.error || new Error('Unexpected Server Error')), {
+        status: errorResponse.status,
+        statusText: errorResponse.statusText,
+        headers: {
+            'X-Modernjs-Error': 'yes'
+        }
+    });
+}
+export { errorResponseToJson, sanitizeError, sanitizeErrors, serializeError, serializeErrors };

package/dist/esm-node/runtime/index.mjs

@@ -0,0 +1,115 @@
+import "node:module";
+import { transformNestedRoutes } from "@modern-js/runtime-utils/browser";
+import { createRequestContext, reporterCtx, storage } from "@modern-js/runtime-utils/node";
+import { DEFERRED_SYMBOL, createStaticHandler, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+import { matchEntry } from "@modern-js/runtime-utils/server";
+import { time } from "@modern-js/runtime-utils/time";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import { isPlainObject } from "@modern-js/utils/lodash";
+import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
+import { CONTENT_TYPE_DEFERRED, LOADER_ID_PARAM } from "../common/constants.mjs";
+import { errorResponseToJson, serializeError } from "./errors.mjs";
+import { createDeferredReadableStream } from "./response.mjs";
+const redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function isRedirectResponse(status) {
+    return redirectStatusCodes.has(status);
+}
+function isResponse(value) {
+    return null != value && 'number' == typeof value.status && 'string' == typeof value.statusText && 'object' == typeof value.headers && void 0 !== value.body;
+}
+function convertModernRedirectResponse(headers, basename) {
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status: 204,
+        headers: newHeaders
+    });
+}
+function hasFileExtension(pathname) {
+    const lastSegment = pathname.split('/').pop() || '';
+    const dotIndex = lastSegment.lastIndexOf('.');
+    if (-1 === dotIndex) return false;
+    const extension = lastSegment.substring(dotIndex).toLowerCase();
+    return '.html' !== extension;
+}
+const handleRequest = async ({ request, serverRoutes, routes: routesConfig, context, onTiming })=>{
+    const url = new URL(request.url);
+    const routeId = url.searchParams.get(LOADER_ID_PARAM);
+    if (hasFileExtension(url.pathname)) return;
+    const entry = matchEntry(url.pathname, serverRoutes);
+    if (!routeId || !entry) return;
+    const basename = entry.urlPath;
+    const end = time();
+    const { reporter, loaderContext, monitors } = context;
+    const headersData = parseHeaders(request);
+    const activeDeferreds = new Map();
+    return storage.run({
+        headers: headersData,
+        monitors,
+        request,
+        activeDeferreds
+    }, async ()=>{
+        const routes = transformNestedRoutes(routesConfig);
+        const { queryRoute } = createStaticHandler(routes, {
+            basename
+        });
+        const requestContext = createRequestContext(loaderContext);
+        requestContext.set(reporterCtx, reporter);
+        let response;
+        try {
+            response = await queryRoute(request, {
+                routeId,
+                requestContext
+            });
+            if (isResponse(response) && isRedirectResponse(response.status)) response = convertModernRedirectResponse(response.headers, basename);
+            else if (isPlainObject(response) && (DEFERRED_SYMBOL in response || activeDeferreds.get(routeId))) {
+                let deferredData;
+                deferredData = DEFERRED_SYMBOL in response ? response[DEFERRED_SYMBOL] : activeDeferreds.get(routeId);
+                const body = createDeferredReadableStream(deferredData, request.signal);
+                const init = deferredData.init || {};
+                if (init.status && isRedirectResponse(init.status)) {
+                    if (!init.headers) throw new Error('redirect response includes no headers');
+                    response = convertModernRedirectResponse(new Headers(init.headers), basename);
+                } else {
+                    const headers = new Headers(init.headers);
+                    headers.set('Content-Type', `${CONTENT_TYPE_DEFERRED}; charset=UTF-8`);
+                    init.headers = headers;
+                    response = new Response(body, init);
+                }
+            } else response = isResponse(response) ? response : new Response(JSON.stringify(response), {
+                headers: {
+                    'Content-Type': 'application/json; charset=utf-8'
+                }
+            });
+            const cost = end();
+            response.headers.set('X-Modernjs-Response', 'yes');
+            onTiming?.(`${LOADER_REPORTER_NAME}-navigation`, cost);
+        } catch (error) {
+            if (isResponse(error)) {
+                error.headers.set('X-Modernjs-Catch', 'yes');
+                response = error;
+            } else if (isRouteErrorResponse(error)) response = errorResponseToJson(error);
+            else {
+                const errorInstance = error instanceof Error || error instanceof DOMException ? error : new Error('Unexpected Server Error');
+                response = new Response(JSON.stringify(serializeError(errorInstance)), {
+                    status: 500,
+                    headers: {
+                        'X-Modernjs-Error': 'yes',
+                        'Content-Type': 'application/json'
+                    }
+                });
+            }
+        }
+        return response;
+    });
+};
+export { handleRequest, hasFileExtension, isRedirectResponse, isResponse };

package/dist/esm-node/runtime/response.mjs

@@ -0,0 +1,43 @@
+import "node:module";
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { TextEncoder } from "util";
+function isTrackedPromise(value) {
+    return null != value && 'function' == typeof value.then && true === value._tracked;
+}
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = '__deferred_promise:';
+function createDeferredReadableStream(deferredData, signal) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start (controller) {
+            const criticalData = {};
+            const preresolvedKeys = [];
+            for (const [key, value] of Object.entries(deferredData.data))if (isTrackedPromise(value)) {
+                criticalData[key] = `${DEFERRED_VALUE_PLACEHOLDER_PREFIX}${key}`;
+                if (void 0 !== value._data || void 0 !== value._error) preresolvedKeys.push(key);
+            } else criticalData[key] = value;
+            controller.enqueue(encoder.encode(`${JSON.stringify(criticalData)}\n\n`));
+            for (const preresolvedKey of preresolvedKeys)enqueueTrackedPromise(controller, encoder, preresolvedKey, deferredData.data[preresolvedKey]);
+            const unsubscribe = deferredData.subscribe((aborted, settledKey)=>{
+                if (settledKey) enqueueTrackedPromise(controller, encoder, settledKey, deferredData.data[settledKey]);
+            });
+            await deferredData.resolveData(signal);
+            unsubscribe();
+            controller.close();
+        }
+    });
+    return stream;
+}
+function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
+    if ('_error' in promise) {
+        const { _error } = promise;
+        controller.enqueue(encoder.encode(`error:${serializeJson({
+            [settledKey]: {
+                message: _error.message,
+                stack: _error.stack
+            }
+        })}\n\n`));
+    } else controller.enqueue(encoder.encode(`data:${JSON.stringify({
+        [settledKey]: promise._data ?? null
+    })}\n\n`));
+}
+export { createDeferredReadableStream };

package/dist/types/cli/createRequest.d.ts

@@ -0,0 +1,13 @@
+export declare const getRequestUrl: ({ params, request, routeId, }: {
+    params: Record<string, string>;
+    request: Request;
+    routeId: string;
+}) => URL;
+export declare const createRequest: (routeId: string, method?: string) => ({ params, request, }: {
+    params: Record<string, string>;
+    request: Request;
+}) => Promise<Record<string, unknown> | Response>;
+export declare const createActionRequest: (routeId: string) => ({ params, request, }: {
+    params: Record<string, string>;
+    request: Request;
+}) => Promise<Response>;

package/dist/types/cli/data.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The following code is modified based on
+ * https://github.com/remix-run/remix/blob/2b5e1a72fc628d0408e27cf4d72e537762f1dc5b/packages/remix-react/data.ts
+ *
+ * MIT Licensed
+ * Author Michael Jackson
+ * Copyright 2021 Remix Software Inc.
+ * https://github.com/remix-run/remix/blob/2b5e1a72fc628d0408e27cf4d72e537762f1dc5b/LICENSE.md
+ */
+import { DeferredData } from '@modern-js/runtime-utils/browser';
+export declare function parseDeferredReadableStream(stream: ReadableStream<Uint8Array>): Promise<DeferredData>;

package/dist/types/cli/generateClient.d.ts

@@ -0,0 +1,5 @@
+export declare const generateClient: ({ inline, action, routeId, }: {
+    inline: boolean;
+    action?: boolean;
+    routeId: string;
+}) => string;

package/dist/types/cli/loader.d.ts

@@ -0,0 +1,12 @@
+import type { Rspack } from '@rsbuild/core';
+type Context = {
+    mapFile: string;
+    loaderId: string;
+    clientData?: boolean;
+    action: boolean;
+    inline: boolean;
+    routeId: string;
+    retain: boolean;
+};
+export default function loader(this: Rspack.LoaderContext<Context>, source: string): Promise<any>;
+export {};

package/dist/types/common/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const LOADER_ID_PARAM = "__loader";
+export declare const DIRECT_PARAM = "__ssrDirect";
+export declare const CONTENT_TYPE_DEFERRED = "text/modernjs-deferred";

package/dist/types/runtime/errors.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The following code is modified based on
+ * https://github.com/remix-run/remix/blob/main/packages/remix-server-runtime/errors.ts
+ *
+ * MIT Licensed
+ * Author Michael Jackson
+ * Copyright 2021 Remix Software Inc.
+ * https://github.com/remix-run/remix/blob/main/LICENSE.md
+ */
+import type { ErrorResponse, StaticHandlerContext } from '@modern-js/runtime-utils/router';
+/**
+ * This thing probably warrants some explanation.
+ *
+ * The whole point here is to emulate componentDidCatch for server rendering and
+ * data loading. It can get tricky. React can do this on component boundaries
+ * but doesn't support it for server rendering or data loading. We know enough
+ * with nested routes to be able to emulate the behavior (because we know them
+ * statically before rendering.)
+ *
+ * Each route can export an `ErrorBoundary`.
+ *
+ * - When rendering throws an error, the nearest error boundary will render
+ *   (normal react componentDidCatch). This will be the route's own boundary, but
+ *   if none is provided, it will bubble up to the parents.
+ * - When data loading throws an error, the nearest error boundary will render
+ * - When performing an action, the nearest error boundary for the action's
+ *   route tree will render (no redirect happens)
+ *
+ * During normal react rendering, we do nothing special, just normal
+ * componentDidCatch.
+ *
+ * For server rendering, we mutate `renderBoundaryRouteId` to know the last
+ * layout that has an error boundary that tried to render. This emulates which
+ * layout would catch a thrown error. If the rendering fails, we catch the error
+ * on the server, and go again a second time with the emulator holding on to the
+ * information it needs to render the same error boundary as a dynamically
+ * thrown render error.
+ *
+ * When data loading, server or client side, we use the emulator to likewise
+ * hang on to the error and re-render at the appropriate layout (where a thrown
+ * error would have been caught by cDC).
+ *
+ * When actions throw, it all works the same. There's an edge case to be aware
+ * of though. Actions normally are required to redirect, but in the case of
+ * errors, we render the action's route with the emulator holding on to the
+ * error. If during this render a parent route/loader throws we ignore that new
+ * error and render the action's original error as deeply as possible. In other
+ * words, we simply ignore the new error and use the action's error in place
+ * because it came first, and that just wouldn't be fair to let errors cut in
+ * line.
+ */
+export declare function sanitizeError<T = unknown>(error: T): Error | T;
+export declare function sanitizeErrors(errors: NonNullable<StaticHandlerContext['errors']>): {};
+export type SerializedError = {
+    message: string;
+    stack?: string;
+};
+export declare function serializeError(error: Error): SerializedError;
+export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
+export declare function errorResponseToJson(errorResponse: ErrorResponse): Response;

package/dist/types/runtime/index.d.ts

@@ -0,0 +1,5 @@
+import type { ServerLoaderBundle } from '@modern-js/server-core';
+export declare function isRedirectResponse(status: number): boolean;
+export declare function isResponse(value: any): value is Response;
+export declare function hasFileExtension(pathname: string): boolean;
+export declare const handleRequest: ServerLoaderBundle['handleRequest'];

package/dist/types/runtime/response.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The following code is modified based on
+ * https://github.com/remix-run/remix/blob/2b5e1a72fc628d0408e27cf4d72e537762f1dc5b/packages/remix-server-runtime/responses.ts
+ *
+ * MIT Licensed
+ * Author Michael Jackson
+ * Copyright 2021 Remix Software Inc.
+ * https://github.com/remix-run/remix/blob/2b5e1a72fc628d0408e27cf4d72e537762f1dc5b/LICENSE.md
+ */
+import type { DeferredData } from '@modern-js/runtime-utils/browser';
+export declare function createDeferredReadableStream(deferredData: DeferredData, signal: AbortSignal): any;