@bleedingdev/modern-js-runtime 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/esm/core/context/runtime.mjs

@@ -1,14 +1,8 @@
 import { createContext, useContext } from "react";
 const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
-function getRuntimeReactContext(kind, create) {
-    const key = Symbol.for(`@modern-js/runtime:react-context:v1:${kind}`);
-    const contexts = globalThis;
-    contexts[key] ??= create();
-    return contexts[key];
-}
-const InternalRuntimeContext = getRuntimeReactContext('internal', ()=>createContext({}));
-const RuntimeContext = getRuntimeReactContext('public', ()=>createContext({}));
-const RuntimeComponentResolverContext = getRuntimeReactContext('component-resolver', ()=>createContext(void 0));
+const InternalRuntimeContext = createContext({});
+const RuntimeContext = createContext({});
+const RuntimeComponentResolverContext = createContext(void 0);
 const ReactRuntimeContext = RuntimeContext;
 const useRuntimeContext = ()=>useContext(RuntimeContext);
 const getInitialContext = (isBrowser = true, routeManifest)=>{

package/dist/esm/core/index.mjs

@@ -1,2 +1,2 @@
+export { RuntimeContext, useRuntimeContext } from "@modern-js/runtime/context";
 export { defineRuntimeConfig } from "./config.mjs";
-export { RuntimeContext, useRuntimeContext } from "./context/runtime.mjs";

package/dist/esm/core/plugin/index.mjs

@@ -1,9 +1,9 @@
 import { runtime } from "@modern-js/plugin/runtime";
+import { setGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { compatPlugin } from "../compat/index.mjs";
 import { handleSetupResult } from "../compat/hooks.mjs";
 import { requestContextPlugin } from "../compat/requestContext.mjs";
-import { setGlobalInternalRuntimeContext } from "../context/index.mjs";
 function registerPlugin(internalPlugins, runtimeConfig) {
     const { plugins = [] } = runtimeConfig || {};
     const { runtimeContext } = runtime.run({

package/dist/esm/core/react/index.mjs

@@ -1,7 +1,7 @@
+import { getGlobalApp, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
 import { isBrowser } from "../../common.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants.mjs";
-import { getGlobalApp, getGlobalInternalRuntimeContext } from "../context/index.mjs";
 function createRoot(UserApp) {
     const App = UserApp || getGlobalApp();
     if (isBrowser()) {

package/dist/esm/core/react/wrapper.mjs

@@ -1,6 +1,5 @@
 import { jsx } from "react/jsx-runtime";
-import { InternalRuntimeContext, RuntimeContext, getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "../context/index.mjs";
-import { RuntimeComponentResolverContext } from "../context/runtime.mjs";
+import { InternalRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 function wrapRuntimeComponentResolver(root, hooks = getGlobalInternalRuntimeContext()?.hooks) {
     return /*#__PURE__*/ jsx(RuntimeComponentResolverContext.Provider, {
         value: hooks?.resolveComponent?.call,

package/dist/esm/core/server/requestHandler.mjs

@@ -1,15 +1,195 @@
 import { jsx } from "react/jsx-runtime";
+import { getGlobalInternalRuntimeContext, getGlobalRSCRoot, getInitialContext } from "@modern-js/runtime/context";
 import { storage } from "@modern-js/runtime-utils/node";
 import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
 import react, { Fragment } from "react";
-import { getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context/index.mjs";
-import { getInitialContext } from "../context/runtime.mjs";
+import { handleRSCRedirect } from "../../router/runtime/redirect.mjs";
 import { getServerPayload } from "../context/serverPayload/index.mjs";
 import { createRoot } from "../react/index.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "./constants.mjs";
-import { applyRouterSnapshotResult, createLoaderRedirectResponse, finalizeRenderResponse } from "./requestResponse.mjs";
-import { createRouterCleanup, finishWithRouterCleanup, runWithRouterCleanupOnError } from "./routerCleanup.mjs";
+import { SSRErrors } from "./tracer.mjs";
 import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
+const REQUEST_END_ERROR = 'An error occurs during request lifecycle completion';
+const RESPONSE_BODY_CANCEL_ERROR = 'An error occurs while cancelling a discarded response body';
+async function runWithRequestLifecycleOnError(lifecycle, callback) {
+    try {
+        return await callback();
+    } catch (error) {
+        await lifecycle.run({
+            status: 'error',
+            error
+        });
+        throw error;
+    }
+}
+async function finishWithRequestLifecycle(lifecycle, callback) {
+    try {
+        return await callback();
+    } catch (error) {
+        if (!lifecycle.deferred) await lifecycle.run({
+            status: 'error',
+            error
+        });
+        throw error;
+    } finally{
+        if (!lifecycle.deferred) await lifecycle.run();
+    }
+}
+function createRequestLifecycle(onEnd, onError) {
+    let deferred = false;
+    let finished;
+    const run = (terminal = {
+        status: 'complete'
+    })=>{
+        finished ??= Promise.resolve().then(()=>onEnd(terminal)).catch((error)=>{
+            onError(error, REQUEST_END_ERROR);
+        });
+        return finished;
+    };
+    const deferUntilBodyDone = (response)=>{
+        const { body } = response;
+        if (!body) return response;
+        deferred = true;
+        if (body.locked) throw new TypeError('Cannot observe a locked response body before request completion');
+        let cancelled = false;
+        const reader = body.getReader();
+        const wrappedBody = new ReadableStream({
+            async pull (controller) {
+                let result;
+                try {
+                    result = await reader.read();
+                } catch (error) {
+                    if (!cancelled) {
+                        await run({
+                            status: 'error',
+                            error
+                        });
+                        controller.error(error);
+                    }
+                    return;
+                }
+                if (cancelled) return;
+                if (result.done) {
+                    await run();
+                    if (!cancelled) controller.close();
+                    return;
+                }
+                controller.enqueue(result.value);
+            },
+            async cancel (reason) {
+                cancelled = true;
+                try {
+                    await reader.cancel(reason);
+                } catch  {}
+                await run({
+                    status: 'cancelled',
+                    reason
+                });
+            }
+        });
+        return new Response(wrappedBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+    };
+    const discardBody = async (response, terminal = {
+        status: 'discarded'
+    })=>{
+        const { body } = response;
+        if (!body) return void await run(terminal);
+        deferred = true;
+        if (body.locked) throw new TypeError('Cannot discard a locked response body before request completion');
+        try {
+            await body.cancel('Response body discarded during finalization');
+        } catch (error) {
+            await run('error' === terminal.status ? terminal : {
+                status: 'error',
+                error
+            });
+            if ('error' === terminal.status) onError(error, RESPONSE_BODY_CANCEL_ERROR);
+            throw error;
+        }
+        await run(terminal);
+    };
+    return {
+        get deferred () {
+            return deferred;
+        },
+        run,
+        deferUntilBodyDone,
+        discardBody
+    };
+}
+const isRedirectStatus = (status)=>301 === status || 302 === status || 303 === status || 307 === status || 308 === status;
+const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
+const getRedirectLocation = (headers)=>{
+    const location = headers.get('Location');
+    return null !== location && '' !== location && URL.canParse(location, 'http://localhost') ? location : void 0;
+};
+const processRedirect = (headers, status, ctx)=>{
+    headers.delete('content-length');
+    headers.delete('transfer-encoding');
+    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        headers
+    });
+};
+const applyRouterResult = (context, routerResult, onError)=>{
+    const routerStatusCode = routerResult?.statusCode;
+    if (void 0 !== routerStatusCode && 0 !== routerStatusCode && !Number.isNaN(routerStatusCode) && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
+    const errors = Object.values(routerResult?.errors || {});
+    if (errors.length > 0) onError(errors[0], SSRErrors.LOADER_ERROR);
+};
+const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
+    if (void 0 === beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
+    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+    const redirectUrl = getRedirectLocation(beforeRenderResult.headers);
+    if (void 0 === redirectUrl) return;
+    return processRedirect(new Headers(beforeRenderResult.headers), beforeRenderResult.status, redirectCtx);
+};
+const finalizeRenderResponse = async (response, responseProxy, redirectCtx, lifecycle)=>{
+    try {
+        const proxyHeaders = new Headers(responseProxy.headers);
+        if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && void 0 !== getRedirectLocation(proxyHeaders)) {
+            await lifecycle.discardBody(response);
+            return processRedirect(proxyHeaders, responseProxy.status, redirectCtx);
+        }
+        const headers = new Headers(response.headers);
+        Object.entries(responseProxy.headers).forEach(([key, value])=>{
+            headers.set(key, value);
+        });
+        if (-1 !== responseProxy.status) {
+            if (isNullBodyStatus(responseProxy.status)) {
+                await lifecycle.discardBody(response);
+                headers.delete('content-length');
+                headers.delete('transfer-encoding');
+                return new Response(null, {
+                    status: responseProxy.status,
+                    headers
+                });
+            }
+            if (response.body?.locked) lifecycle.deferUntilBodyDone(response);
+            return lifecycle.deferUntilBodyDone(new Response(response.body, {
+                status: responseProxy.status,
+                headers
+            }));
+        }
+        Object.entries(responseProxy.headers).forEach(([key, value])=>{
+            response.headers.set(key, value);
+        });
+        return lifecycle.deferUntilBodyDone(response);
+    } catch (error) {
+        if (!lifecycle.deferred) try {
+            await lifecycle.discardBody(response, {
+                status: 'error',
+                error
+            });
+        } catch  {}
+        throw error;
+    }
+};
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
     const serverPayload = getServerPayload();
     if (void 0 !== serverPayload) return await handleRequest(request, Root, {
@@ -100,12 +280,14 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
             status: -1
         };
         const activeDeferreds = new Map();
+        const deferredScriptKeys = new Map();
         return storage.run({
             headers: headersData,
             request,
             monitors: options.monitors,
             responseProxy,
             activeDeferreds,
+            deferredScriptKeys,
             serverPayload: void 0
         }, async ()=>{
             const Root = createRoot();
@@ -130,28 +312,50 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            const routerCleanup = createRouterCleanup(context, options.onError);
-            const beforeRenderResult = await runWithRouterCleanupOnError(routerCleanup, ()=>runBeforeRender(context));
-            await runWithRouterCleanupOnError(routerCleanup, ()=>{
-                applyRouterSnapshotResult(context, options.onError);
-            });
-            if ("u" > typeof Response) {
-                const redirectResponse = await runWithRouterCleanupOnError(routerCleanup, ()=>createLoaderRedirectResponse(beforeRenderResult, redirectCtx));
-                if (redirectResponse) {
-                    await routerCleanup.run();
-                    return redirectResponse;
-                }
+            const lifecycle = createRequestLifecycle(async (terminal)=>{
+                await hooks.onRequestEnd?.call({
+                    runtimeContext: context,
+                    terminal
+                });
+            }, options.onError);
+            const beforeRenderResult = await runWithRequestLifecycleOnError(lifecycle, ()=>runBeforeRender(context));
+            let redirectResponse;
+            try {
+                const prepared = {
+                    runtimeContext: context,
+                    routerResult: context.routerContext
+                };
+                const result = await hooks.onRenderPrepared?.call(prepared) ?? prepared;
+                applyRouterResult(context, result.routerResult, options.onError);
+                if ("u" > typeof Response) redirectResponse = createLoaderRedirectResponse(beforeRenderResult, redirectCtx);
+            } catch (error) {
+                if (beforeRenderResult) try {
+                    await lifecycle.discardBody(beforeRenderResult, {
+                        status: 'error',
+                        error
+                    });
+                } catch  {}
+                else await lifecycle.run({
+                    status: 'error',
+                    error
+                });
+                throw error;
+            }
+            if (redirectResponse) {
+                const response = redirectResponse;
+                if (beforeRenderResult?.body && response !== beforeRenderResult) await lifecycle.discardBody(beforeRenderResult);
+                return finishWithRequestLifecycle(lifecycle, ()=>lifecycle.deferUntilBodyDone(response));
             }
-            await runWithRouterCleanupOnError(routerCleanup, ()=>{
+            await runWithRequestLifecycleOnError(lifecycle, ()=>{
                 if (!createRequestOptions?.enableRsc) {
                     const { htmlTemplate } = options.resource;
                     options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${CHUNK_CSS_PLACEHOLDER}</head>`);
                 }
             });
-            const response = await runWithRouterCleanupOnError(routerCleanup, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
-            return finishWithRouterCleanup(routerCleanup, ()=>finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup));
+            const response = await runWithRequestLifecycleOnError(lifecycle, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
+            return finishWithRequestLifecycle(lifecycle, ()=>finalizeRenderResponse(response, responseProxy, redirectCtx, lifecycle));
         });
     };
     return requestHandler;
 };
-export { createRequestHandler };
+export { REQUEST_END_ERROR, RESPONSE_BODY_CANCEL_ERROR, applyRouterResult, createLoaderRedirectResponse, createRequestHandler, createRequestLifecycle, finalizeRenderResponse, finishWithRequestLifecycle, runWithRequestLifecycleOnError };

package/dist/esm/core/server/stream/beforeTemplate.mjs

@@ -11,8 +11,8 @@ const readAsset = async (chunk)=>{
 };
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
-    if (enableInline instanceof RegExp) return enableInline.test(chunk);
-    return Boolean(enableInline);
+    else if (enableInline instanceof RegExp) return enableInline.test(chunk);
+    else return Boolean(enableInline);
 };
 async function buildShellBeforeTemplate(beforeAppTemplate, options) {
     const { config, runtimeContext, styledComponentsStyleTags, entryName, lifecycle, helmetData } = options;
@@ -70,7 +70,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
             const styles = await Promise.all(cssChunks.map(async (chunk)=>{
                 const link = `<link href="${chunk}" rel="stylesheet" />`;
                 if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
-                return link;
+                else return link;
             }));
             return `${styles.join('')}`;
         }

package/dist/esm/core/server/stream/beforeTemplate.worker.mjs

@@ -4,8 +4,8 @@ import { buildHtml, replaceSSRTemplateChunk } from "../shared.mjs";
 import { hasStylesheetLink } from "../utils.mjs";
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
-    if (enableInline instanceof RegExp) return enableInline.test(chunk);
-    return Boolean(enableInline);
+    else if (enableInline instanceof RegExp) return enableInline.test(chunk);
+    else return Boolean(enableInline);
 };
 async function buildShellBeforeTemplate(beforeAppTemplate, options) {
     const { config, runtimeContext, styledComponentsStyleTags, entryName, lifecycle, helmetData } = options;

package/dist/esm/core/server/stream/createReadableStream.mjs

@@ -1,15 +1,17 @@
+import { getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { storage } from "@modern-js/runtime-utils/node";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import { PassThrough, Readable, Transform, finished, pipeline } from "stream";
+import { StringDecoder } from "string_decoder";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
 import { RenderLevel } from "../../constants.mjs";
-import { getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "../../context/index.mjs";
 import { getMonitors } from "../../context/monitors/index.mjs";
 import { wrapRuntimeComponentResolver } from "../../react/wrapper.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
 import { createSSRRenderLifecycle, createSSRStreamErrorReporter, observeSSRStream, orderSSRStreamTransforms } from "../shared.mjs";
 import { enqueueFromEntries } from "./deferredScript.mjs";
-import { ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
+import { DeferredScriptOutputCoordinator } from "./deferredScriptOutputCoordinator.mjs";
+import { SHELL_PROGRESSIVE_CHUNK_SIZE, ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     const { renderToPipeableStream } = await import("react-dom/server");
@@ -23,6 +25,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         config,
         platform: 'node',
         mode: 'stream',
+        monitors: getMonitors(),
         isRsc,
         terminalMarker: ESCAPED_SHELL_STREAM_END_MARK
     }) || [];
@@ -121,29 +124,42 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             });
             if (failed) return;
             const chunks = [];
+            let bufferedLength = 0;
             const marker = Buffer.from(ESCAPED_SHELL_STREAM_END_MARK);
+            let markerTail = Buffer.alloc(0);
+            const decoder = new StringDecoder('utf8');
             const pendingScripts = [];
+            let deferredResolversComplete = Promise.resolve();
             let shellChunkStatus = ShellChunkStatus.START;
-            const emitShell = (destination, buffered, markerIndex)=>{
+            const emitShell = (buffered, markerIndex)=>{
                 const beforeMark = lifecycle.completedBody(buffered.subarray(0, markerIndex).toString('utf8'), 'shell');
                 const completedShellBefore = createReplaceHelemt(getHelmetData(extenders))(shellBefore);
                 shellChunkStatus = ShellChunkStatus.FINISH;
                 chunks.length = 0;
-                destination.push(`${completedShellBefore}${beforeMark}${shellAfter}`);
+                bufferedLength = 0;
+                coordinator.writeReact(`${completedShellBefore}${beforeMark}${shellAfter}`);
                 const afterMark = buffered.subarray(markerIndex + marker.length);
-                if (afterMark.length > 0) destination.push(afterMark);
-                for (const script of pendingScripts)destination.push(script);
+                if (afterMark.length > 0) coordinator.writeReact(decoder.write(afterMark));
+                coordinator.markShellFinished();
+                for (const script of pendingScripts)coordinator.enqueueResolver(script);
                 pendingScripts.length = 0;
             };
             const body = new Transform({
                 transform (chunk, _encoding, callback) {
                     try {
-                        if (shellChunkStatus === ShellChunkStatus.FINISH) this.push(chunk);
+                        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                        if (shellChunkStatus === ShellChunkStatus.FINISH) coordinator.writeReact(decoder.write(bytes));
                         else {
-                            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                            const buffered = Buffer.concat(chunks);
-                            const markerIndex = buffered.indexOf(marker);
-                            if (-1 !== markerIndex) emitShell(this, buffered, markerIndex);
+                            const window = Buffer.concat([
+                                markerTail,
+                                bytes
+                            ]);
+                            const windowIndex = window.indexOf(marker);
+                            const windowStart = bufferedLength - markerTail.length;
+                            chunks.push(bytes);
+                            bufferedLength += bytes.length;
+                            if (-1 === windowIndex) markerTail = window.subarray(Math.max(0, window.length - marker.length + 1));
+                            else emitShell(Buffer.concat(chunks, bufferedLength), windowStart + windowIndex);
                         }
                         callback();
                     } catch (error) {
@@ -154,14 +170,27 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     try {
                         if (shellChunkStatus !== ShellChunkStatus.FINISH) {
                             const buffered = Buffer.concat(chunks);
-                            emitShell(this, buffered, buffered.length);
+                            emitShell(buffered, buffered.length);
                         }
-                        callback();
+                        const trailing = decoder.end();
+                        if (trailing) coordinator.writeReact(trailing);
+                        deferredResolversComplete.then(()=>{
+                            try {
+                                coordinator.finish();
+                                callback();
+                            } catch (error) {
+                                callback(error instanceof Error ? error : new Error(String(error)));
+                            }
+                        }, (error)=>callback(error instanceof Error ? error : new Error(String(error))));
                     } catch (error) {
                         callback(error instanceof Error ? error : new Error(String(error)));
                     }
                 }
             });
+            const coordinator = new DeferredScriptOutputCoordinator((content)=>{
+                body.push(content);
+            });
+            body.once('close', ()=>coordinator.abort());
             own(body);
             const passThrough = new PassThrough();
             let processedStream = own(passThrough);
@@ -172,11 +201,13 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             deliver(Readable.toWeb(body));
             reactStream.pipe(passThrough);
             try {
-                const activeDeferreds = storage.useContext?.()?.activeDeferreds;
+                const storageContext = storage.useContext?.();
+                const activeDeferreds = storageContext?.activeDeferreds;
+                const deferredScriptKeys = storageContext?.deferredScriptKeys;
                 const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-                enqueueFromEntries(entries, config.nonce, (script)=>{
+                if (entries.length > 0) deferredResolversComplete = enqueueFromEntries(entries, deferredScriptKeys, config.nonce, (script)=>{
                     if (failed || body.destroyed || body.writableEnded) return;
-                    if (shellChunkStatus === ShellChunkStatus.FINISH) body.write(script);
+                    if (shellChunkStatus === ShellChunkStatus.FINISH) coordinator.enqueueResolver(script);
                     else pendingScripts.push(script);
                 });
             } catch (error) {
@@ -213,6 +244,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             reactStream = renderToPipeableStream(processedRootElement, {
                 nonce: config.nonce,
                 identifierPrefix: SSR_HYDRATION_ID_PREFIX,
+                progressiveChunkSize: SHELL_PROGRESSIVE_CHUNK_SIZE,
                 [onReady] () {
                     startOutput().catch(fail);
                 },