@modern-js/runtime 3.9.1 → 3.9.3

package/dist/esm/router/runtime/DeferredDataScripts.node.mjs

@@ -13,7 +13,8 @@ const DeferredDataScripts = (props)=>{
     }, []);
     const deferredScripts = useMemo(()=>{
         if (!staticContext) return null;
-        const activeDeferreds = storage.useContext().activeDeferreds;
+        const requestStorage = storage.useContext();
+        const activeDeferreds = requestStorage.activeDeferreds;
         const _ROUTER_DATA = {
             loaderData: staticContext.loaderData,
             errors: serializeErrors(staticContext.errors)
@@ -26,6 +27,7 @@ const DeferredDataScripts = (props)=>{
         const deferredDataScripts = [];
         const initialScripts = Array.from(activeDeferreds.entries()).map(([routeId, deferredData])=>{
             const pendingKeys = new Set(deferredData.pendingKeys);
+            requestStorage.deferredScriptKeys?.set(routeId, Array.from(pendingKeys));
             const { deferredKeys } = deferredData;
             const deferredKeyPromiseManifests = deferredKeys.map((key)=>{
                 if (pendingKeys.has(key)) return {
@@ -36,7 +38,7 @@ const DeferredDataScripts = (props)=>{
                         serializeJson(key)
                     ]
                 };
-                {
+                else {
                     const trackedPromise = deferredData.data[key];
                     if (void 0 !== trackedPromise._error) {
                         const error = {
@@ -51,15 +53,16 @@ const DeferredDataScripts = (props)=>{
                                 serializeJson(error)
                             ]
                         };
+                    } else {
+                        if (void 0 === trackedPromise._data) throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
+                        return {
+                            key,
+                            routerDataFnName: 'p',
+                            routerDataFnArgs: [
+                                serializeJson(trackedPromise._data)
+                            ]
+                        };
                     }
-                    if (void 0 === trackedPromise._data) throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
-                    return {
-                        key,
-                        routerDataFnName: 'p',
-                        routerDataFnArgs: [
-                            serializeJson(trackedPromise._data)
-                        ]
-                    };
                 }
             });
             return {

package/dist/esm/router/runtime/plugin.node.mjs

@@ -106,7 +106,7 @@ const routerPlugin = (userConfig = {})=>({
                         }) : /*#__PURE__*/ jsx(RSCStaticRouter, {
                             basename: basename
                         });
-                        {
+                        else {
                             const routerWrapper = /*#__PURE__*/ jsxs(Fragment, {
                                 children: [
                                     /*#__PURE__*/ jsx(StaticRouterProvider, {

package/dist/esm-node/cli/template.server.mjs

@@ -109,8 +109,7 @@ function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, inter
         return `
       export * from '${realEntryPath}';
       export { default as requestHandler } from '${realEntryPath}'`;
-    }
-    {
+    } else {
         const entrySource = enableRsc ? SERVER_ENTRY_RSC : SERVER_ENTRY;
         const serverEntry = transformServerEntry(entrySource, {
             metaName: metaName || 'modern-js',

package/dist/esm-node/core/browser/hydrate.mjs

@@ -27,7 +27,7 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     if ('stream' === renderMode) return streamSSRHydrate();
     function streamSSRHydrate() {
         if (renderLevel !== RenderLevel.SERVER_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
-        {
+        else {
             const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
                     callback: callback,
                     children: App
@@ -38,19 +38,21 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     return stringSSRHydrate();
     function stringSSRHydrate() {
         if (renderLevel === RenderLevel.CLIENT_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
-        if (renderLevel === RenderLevel.SERVER_RENDER) return new Promise((resolve)=>{
-            loadableReady(()=>{
-                const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
-                        callback: callback,
-                        children: App
+        else {
+            if (renderLevel === RenderLevel.SERVER_RENDER) return new Promise((resolve)=>{
+                loadableReady(()=>{
+                    const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
+                            callback: callback,
+                            children: App
+                        });
+                    ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext)).then((root)=>{
+                        resolve(root);
                     });
-                ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext)).then((root)=>{
-                    resolve(root);
                 });
             });
-        });
-        console.warn(`unknow render level: ${renderLevel}, execute render()`);
-        return ModernRender(wrapRuntimeContextProvider(App, context));
+            console.warn(`unknow render level: ${renderLevel}, execute render()`);
+            return ModernRender(wrapRuntimeContextProvider(App, context));
+        }
     }
 }
 export { hydrateWithReact, hydrate_hydrateRoot as hydrateRoot };

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

@@ -102,12 +102,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();

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

@@ -16,8 +16,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 } = options;
@@ -58,7 +58,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-node/core/server/stream/createReadableStream.mjs

@@ -1,5 +1,6 @@
 import "node:module";
 import { PassThrough, Readable, Transform } from "stream";
+import { StringDecoder } from "string_decoder";
 import { storage } from "@modern-js/runtime-utils/node";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
@@ -7,6 +8,7 @@ import { RenderLevel } from "../../constants.mjs";
 import { getGlobalInternalRuntimeContext } from "../../context/index.mjs";
 import { getMonitors } from "../../context/monitors/index.mjs";
 import { enqueueFromEntries } from "./deferredScript.mjs";
+import { DeferredScriptOutputCoordinator } from "./deferredScriptOutputCoordinator.mjs";
 import { ShellChunkStatus, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
 const defaultExtender = {
@@ -55,7 +57,14 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     entryName,
                     styledComponentsStyleTags
                 }).then(({ shellAfter, shellBefore })=>{
+                    const decoder = new StringDecoder('utf8');
                     const pendingScripts = [];
+                    const outputState = {};
+                    let deferredResolversComplete = Promise.resolve();
+                    const writeReact = (content)=>{
+                        if (!outputState.coordinator) throw new Error("Deferred script coordinator is not ready");
+                        outputState.coordinator.writeReact(content);
+                    };
                     const body = new Transform({
                         transform (chunk, _encoding, callback) {
                             try {
@@ -67,17 +76,49 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                                         const beforeMark = concatedChunk.slice(0, markerIndex);
                                         const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
                                         shellChunkStatus = ShellChunkStatus.FINISH;
-                                        this.push(`${shellBefore}${beforeMark}${shellAfter}`);
-                                        if (afterMark) this.push(afterMark);
-                                        if (pendingScripts.length > 0) for (const s of pendingScripts)this.push(s);
+                                        writeReact(`${shellBefore}${beforeMark}${shellAfter}`);
+                                        if (afterMark) writeReact(afterMark);
+                                        if (outputState.coordinator) {
+                                            outputState.coordinator.markShellFinished();
+                                            for (const script of pendingScripts)outputState.coordinator.enqueueResolver(script);
+                                            pendingScripts.length = 0;
+                                        }
                                     }
-                                } else this.push(chunk);
+                                } else {
+                                    const decodedChunk = decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                                    writeReact(decodedChunk);
+                                }
                                 callback();
                             } catch (e) {
                                 e instanceof Error ? callback(e) : callback(new Error('Received unknown error when streaming'));
                             }
+                        },
+                        flush (callback) {
+                            try {
+                                writeReact(decoder.end());
+                            } catch (error) {
+                                callback(error instanceof Error ? error : new Error('Received unknown error when streaming'));
+                                return;
+                            }
+                            deferredResolversComplete.then(()=>{
+                                try {
+                                    outputState.coordinator?.finish();
+                                    callback();
+                                } catch (error) {
+                                    callback(error instanceof Error ? error : new Error('Received unknown error when streaming'));
+                                }
+                            }, (error)=>{
+                                callback(error instanceof Error ? error : new Error('Received unknown error when streaming'));
+                            });
                         }
                     });
+                    const coordinator = new DeferredScriptOutputCoordinator((content)=>{
+                        body.push(content);
+                    });
+                    outputState.coordinator = coordinator;
+                    body.once('close', ()=>{
+                        coordinator.abort();
+                    });
                     const passThrough = new PassThrough();
                     const stream = Readable.toWeb(body);
                     resolve(stream);
@@ -85,23 +126,25 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     extenders.forEach((extender)=>{
                         if (extender.processStream) processedStream = extender.processStream(processedStream);
                     });
-                    reactStreamingPipe(passThrough);
-                    processedStream.pipe(body);
                     try {
                         const storageContext = storage.useContext?.();
                         const activeDeferreds = storageContext?.activeDeferreds;
+                        const deferredScriptKeys = storageContext?.deferredScriptKeys;
                         const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
                         if (entries.length > 0) {
                             const enqueueScript = (s)=>{
-                                if (shellChunkStatus === ShellChunkStatus.FINISH) body.write(s);
+                                if (!outputState.coordinator) throw new Error("Deferred script coordinator is not ready");
+                                if (shellChunkStatus === ShellChunkStatus.FINISH) outputState.coordinator.enqueueResolver(s);
                                 else pendingScripts.push(s);
                             };
-                            enqueueFromEntries(entries, config.nonce, (s)=>enqueueScript(s));
+                            deferredResolversComplete = enqueueFromEntries(entries, deferredScriptKeys, config.nonce, enqueueScript);
                         }
                     } catch (err) {
                         const monitors = getMonitors();
                         monitors.error("cannot inject router data script", err);
                     }
+                    reactStreamingPipe(passThrough);
+                    processedStream.pipe(body);
                 });
             },
             onShellError (error) {

package/dist/esm-node/core/server/stream/createReadableStream.worker.mjs

@@ -4,6 +4,7 @@ import { storage } from "@modern-js/runtime-utils/node";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common.mjs";
 import { RenderLevel } from "../../constants.mjs";
 import { enqueueFromEntries } from "./deferredScript.mjs";
+import { DeferredScriptOutputCoordinator } from "./deferredScriptOutputCoordinator.mjs";
 import { ShellChunkStatus, encodeForWebStream, getReadableStreamFromString, resolveStreamingMode } from "./shared.mjs";
 import { getTemplates } from "./template.mjs";
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
@@ -36,10 +37,13 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         const { waitForAllReady } = resolveStreamingMode(request, forceStreamToString);
         if (waitForAllReady) await readableOriginal.allReady;
         const reader = readableOriginal.getReader();
+        let coordinator;
         const stream = new ReadableStream({
             start (controller) {
+                const decoder = new TextDecoder();
                 const pendingScripts = [];
                 let isClosed = false;
+                let deferredResolversComplete = Promise.resolve();
                 const safeEnqueue = (chunk)=>{
                     if (isClosed) return;
                     try {
@@ -56,38 +60,55 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                         } catch  {}
                     }
                 };
-                const flushPendingScripts = ()=>{
-                    for (const s of pendingScripts)safeEnqueue(encodeForWebStream(s));
-                    pendingScripts.length = 0;
-                };
-                const enqueueScript = (script)=>{
-                    if (shellChunkStatus === ShellChunkStatus.FINISH) safeEnqueue(encodeForWebStream(script));
-                    else pendingScripts.push(script);
-                };
+                coordinator = new DeferredScriptOutputCoordinator((content)=>{
+                    safeEnqueue(encodeForWebStream(content));
+                });
                 const storageContext = storage.useContext?.();
                 const activeDeferreds = storageContext?.activeDeferreds;
+                const deferredScriptKeys = storageContext?.deferredScriptKeys;
                 const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-                if (entries.length > 0) enqueueFromEntries(entries, config.nonce, enqueueScript);
+                if (entries.length > 0) deferredResolversComplete = enqueueFromEntries(entries, deferredScriptKeys, config.nonce, (script)=>{
+                    if (!coordinator) throw new Error("Deferred script coordinator is not ready");
+                    if (shellChunkStatus === ShellChunkStatus.FINISH) coordinator.enqueueResolver(script);
+                    else pendingScripts.push(script);
+                });
                 async function push() {
                     try {
                         const { done, value } = await reader.read();
-                        if (done) return void closeController();
+                        if (done) {
+                            const trailingText = decoder.decode();
+                            if (trailingText) coordinator?.writeReact(trailingText);
+                            await deferredResolversComplete;
+                            coordinator?.finish();
+                            closeController();
+                            return;
+                        }
                         if (isClosed) return;
                         if (shellChunkStatus !== ShellChunkStatus.FINISH) {
-                            chunkVec.push(new TextDecoder().decode(value));
+                            chunkVec.push(decoder.decode(value, {
+                                stream: true
+                            }));
                             const concatedChunk = chunkVec.join('');
                             const markerIndex = concatedChunk.indexOf(ESCAPED_SHELL_STREAM_END_MARK);
                             if (-1 !== markerIndex) {
                                 const beforeMark = concatedChunk.slice(0, markerIndex);
                                 const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
                                 shellChunkStatus = ShellChunkStatus.FINISH;
-                                safeEnqueue(encodeForWebStream(`${shellBefore}${beforeMark}${shellAfter}`));
-                                if (afterMark) safeEnqueue(encodeForWebStream(afterMark));
-                                flushPendingScripts();
+                                coordinator?.writeReact(`${shellBefore}${beforeMark}${shellAfter}`);
+                                if (afterMark) coordinator?.writeReact(afterMark);
+                                coordinator?.markShellFinished();
+                                for (const script of pendingScripts)coordinator?.enqueueResolver(script);
+                                pendingScripts.length = 0;
                             }
-                        } else safeEnqueue(value);
+                        } else {
+                            const decodedChunk = decoder.decode(value, {
+                                stream: true
+                            });
+                            if (decodedChunk) coordinator?.writeReact(decodedChunk);
+                        }
                         if (!isClosed) push();
                     } catch (error) {
+                        coordinator?.abort();
                         if (!isClosed) {
                             isClosed = true;
                             try {
@@ -99,6 +120,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                 push();
             },
             cancel (reason) {
+                coordinator?.abort();
                 reader.cancel(reason).catch(()=>{});
             }
         });

package/dist/esm-node/core/server/stream/deferredScript.mjs

@@ -41,23 +41,29 @@ function buildDeferredDataScript(nonce, args) {
     const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
     return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${runRouterDataFnStr}</script>`;
 }
-function enqueueFromEntries(entries, nonce, emit) {
+function enqueueFromEntries(entries, deferredScriptKeys, nonce, emit) {
+    const pendingResolvers = [];
     entries.forEach(([routeId, value])=>{
         if (!isDeferredDataLike(value)) return;
-        const pendingKeys = new Set(value.pendingKeys ?? []);
-        pendingKeys.forEach((key)=>{
+        const serializedKeys = deferredScriptKeys ? deferredScriptKeys.get(routeId) ?? [] : value.pendingKeys ?? [];
+        serializedKeys.forEach((key)=>{
             const tracked = value.data?.[key];
-            if (isPromiseLike(tracked)) tracked.then((val)=>emit(buildDeferredDataScript(nonce, [
+            if (isPromiseLike(tracked)) pendingResolvers.push(Promise.resolve(tracked).then((val)=>{
+                emit(buildDeferredDataScript(nonce, [
                     routeId,
                     key,
                     val
-                ])), (err)=>emit(buildDeferredDataScript(nonce, [
+                ]));
+            }, (err)=>{
+                emit(buildDeferredDataScript(nonce, [
                     routeId,
                     key,
                     void 0,
                     toErrorInfo(err)
-                ])));
+                ]));
+            }));
         });
     });
+    return Promise.all(pendingResolvers).then(()=>void 0);
 }
 export { buildDeferredDataScript, enqueueFromEntries, escapeAttr, isDeferredDataLike, isPromiseLike, isRecord, toErrorInfo };