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

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

@@ -64,7 +64,7 @@ function createRenderStreaming(createReadableStreamPromise) {
         const end = time();
         const { runtimeContext, config, resource } = options;
         const { onError, onTiming } = options;
-        const { htmlTemplate, entryName, moduleFederationCssAssets } = resource;
+        const { htmlTemplate, entryName } = resource;
         const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
         const StreamServerRootWrapper = ({ children })=>/*#__PURE__*/ jsxs(Fragment, {
                 children: [
@@ -84,7 +84,7 @@ function createRenderStreaming(createReadableStreamPromise) {
             runtimeContext,
             ssrConfig,
             entryName,
-            moduleFederationCssAssets,
+            resource,
             rscClientManifest: options.rscClientManifest,
             rscSSRManifest: options.rscSSRManifest,
             rscServerManifest: options.rscServerManifest,

package/dist/esm-node/core/server/string/index.mjs

@@ -3,17 +3,15 @@ import { time } from "@modern-js/runtime-utils/time";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import server from "react-dom/server";
 import { RenderLevel } from "../../constants.mjs";
-import { getGlobalInternalRuntimeContext } from "../../context/index.mjs";
-import { wrapRuntimeContextProvider } from "../../react/wrapper.mjs";
-import { CHUNK_CSS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
+import { getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "../../context/index.mjs";
+import { wrapRuntimeComponentResolver, wrapRuntimeContextProvider } from "../../react/wrapper.mjs";
+import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
-import { replaceChunkJsPlaceholder } from "../scriptOrder.mjs";
-import { buildHtml } from "../shared.mjs";
+import { buildHtml, createSSRRenderLifecycle, replaceSSRTemplateChunk } from "../shared.mjs";
 import { SSRErrors, SSRTimings } from "../tracer.mjs";
 import { getSSRConfigByEntry, safeReplace } from "../utils.mjs";
 import { LoadableCollector } from "./loadable.mjs";
 import { SSRDataCollector } from "./ssrData.mjs";
-import * as __rspack_external__modern_js_runtime_extensions_ce611631 from "@modern-js/runtime-extensions";
 const renderString = async (request, serverRoot, options)=>{
     const { resource, runtimeContext, config, onError, onTiming } = options;
     const tracer = {
@@ -21,7 +19,7 @@ const renderString = async (request, serverRoot, options)=>{
         onTiming
     };
     const routerContext = runtimeContext.routerContext;
-    const { htmlTemplate, entryName, loadableStats, routeManifest, moduleFederationCssAssets } = resource;
+    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
     const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
     const chunkSet = {
         renderLevel: RenderLevel.CLIENT_RENDER,
@@ -29,83 +27,121 @@ const renderString = async (request, serverRoot, options)=>{
         jsChunk: '',
         cssChunk: ''
     };
-    const collectors = [
-        new LoadableCollector({
-            stats: loadableStats,
-            nonce: config.nonce,
-            routeManifest,
-            runtimeContext,
-            template: htmlTemplate,
-            entryName,
-            moduleFederationCssAssets,
-            chunkSet,
-            config
-        }),
-        new SSRDataCollector({
-            runtimeContext,
-            request,
-            ssrConfig,
-            ssrContext: runtimeContext.ssrContext,
-            chunkSet,
-            routerContext,
-            nonce: config.nonce,
-            useJsonScript: config.useJsonScript
-        })
-    ];
+    const collectors = [];
+    const lifecycle = createSSRRenderLifecycle(collectors);
+    const loadableCollector = new LoadableCollector({
+        stats: loadableStats,
+        nonce: config.nonce,
+        routeManifest,
+        template: htmlTemplate,
+        entryName,
+        chunkSet,
+        config,
+        lifecycle
+    });
+    collectors.push(loadableCollector, new SSRDataCollector({
+        runtimeContext,
+        request,
+        ssrConfig,
+        ssrContext: runtimeContext.ssrContext,
+        chunkSet,
+        routerContext,
+        nonce: config.nonce,
+        useJsonScript: config.useJsonScript,
+        lifecycle
+    }));
     const internalRuntimeContext = getGlobalInternalRuntimeContext();
     const hooks = internalRuntimeContext.hooks;
     const extraCollectors = hooks.extendStringSSRCollectors.call({
-        chunkSet
+        chunkSet,
+        render: {
+            runtimeContext,
+            request,
+            resource,
+            config,
+            platform: 'node',
+            mode: 'string',
+            isRsc: true === getGlobalEnableRsc()
+        }
     });
     for (const c of extraCollectors)if (c) collectors.unshift(c);
-    const rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
+    let rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
         ssr: true
     }));
-    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], runtimeContext, entryName, tracer);
+    if (true === getGlobalEnableRsc() && false === runtimeContext.isBrowser) rootElement = wrapRuntimeComponentResolver(rootElement, hooks);
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], tracer, request.signal, lifecycle, loadableCollector.stylesheetInfo);
     return html;
 };
-async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, runtimeContext, entryName, { onError, onTiming }) {
+async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }, signal, lifecycle, stylesheetInfo) {
     let html = '';
     let helmetData;
-    const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
-    __rspack_external__modern_js_runtime_extensions_ce611631.beginHeadRender(runtimeContext);
     try {
-        const end = time();
-        html = server.renderToString(finalApp, {
-            identifierPrefix: SSR_HYDRATION_ID_PREFIX
+        signal.throwIfAborted();
+        try {
+            const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
+            lifecycle.beforeReact();
+            const end = time();
+            html = server.renderToString(finalApp, {
+                identifierPrefix: SSR_HYDRATION_ID_PREFIX
+            });
+            html = lifecycle.completedBody(html, 'complete');
+            chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
+            helmetData = getHelmetData(collectors);
+            const cost = end();
+            onTiming(SSRTimings.RENDER_HTML, cost);
+        } catch (error) {
+            lifecycle.finish({
+                status: 'fallback',
+                error
+            });
+            html = '';
+            chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+            onError(error, SSRErrors.RENDER_HTML);
+        }
+        await Promise.all(collectors.map((component)=>component.effect()));
+        signal.throwIfAborted();
+        const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+        const finalHtml = await buildHtml(htmlTemplate, [
+            createReplaceHtml(html),
+            (template)=>replaceSSRTemplateChunk({
+                    name: "scripts",
+                    template,
+                    placeholder: CHUNK_JS_PLACEHOLDER,
+                    content: jsChunk
+                }, lifecycle),
+            (template)=>replaceSSRTemplateChunk({
+                    name: 'styles',
+                    template,
+                    placeholder: CHUNK_CSS_PLACEHOLDER,
+                    content: cssChunk,
+                    ...stylesheetInfo
+                }, lifecycle),
+            (template)=>replaceSSRTemplateChunk({
+                    name: 'data',
+                    template,
+                    placeholder: SSR_DATA_PLACEHOLDER,
+                    content: ssrScripts
+                }, lifecycle),
+            createReplaceHelemt(helmetData),
+            ...htmlModifiers
+        ]);
+        signal.throwIfAborted();
+        lifecycle.finish({
+            status: 'complete'
+        });
+        return finalHtml;
+    } catch (error) {
+        lifecycle.finish(signal.aborted ? {
+            status: 'cancelled',
+            reason: signal.reason
+        } : {
+            status: 'error',
+            error
         });
-        html = __rspack_external__modern_js_runtime_extensions_ce611631.completeHeadRender(runtimeContext, html);
-        chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
-        helmetData = getHelmetData(runtimeContext);
-        const cost = end();
-        onTiming(SSRTimings.RENDER_HTML, cost);
-    } catch (e) {
-        __rspack_external__modern_js_runtime_extensions_ce611631.abortHeadRender(runtimeContext);
-        chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
-        onError(e, SSRErrors.RENDER_HTML);
+        throw error;
     }
-    await Promise.all(collectors.map((component)=>component.effect()));
-    const { ssrScripts, cssChunk, jsChunk } = chunkSet;
-    const finalHtml = await buildHtml(htmlTemplate, [
-        createReplaceHtml(html),
-        createReplaceChunkJs(jsChunk, entryName),
-        createReplaceChunkCss(cssChunk),
-        createReplaceSSRDataScript(ssrScripts, entryName),
-        createReplaceHelemt(helmetData),
-        ...htmlModifiers
-    ]);
-    return finalHtml;
 }
 function createReplaceHtml(html) {
     return (template)=>safeReplace(template, HTML_PLACEHOLDER, html);
 }
-function createReplaceSSRDataScript(data, entryName) {
-    return (template)=>replaceChunkJsPlaceholder(template, data, entryName, SSR_DATA_PLACEHOLDER);
-}
-function createReplaceChunkJs(js, entryName) {
-    return (template)=>replaceChunkJsPlaceholder(template, js, entryName);
-}
-function createReplaceChunkCss(css) {
-    return (template)=>safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
-}
 export { renderString };

package/dist/esm-node/core/server/string/loadable.mjs

@@ -1,7 +1,5 @@
 import "node:module";
 import { ChunkExtractor } from "@loadable/server";
-import { createFederatedCssLinks } from "../federatedCss.mjs";
-import { getMatchedRouteChunks, orderHydrationScriptChunks } from "../scriptOrder.mjs";
 import { attributesToString, checkIsNode, hasStylesheetLink } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -11,7 +9,7 @@ const extname = (uri)=>{
     return `.${uri?.split('.').pop()}` || '';
 };
 const generateChunks = (chunks, ext)=>chunks.filter((chunk)=>Boolean(chunk.url)).filter((chunk)=>extname(chunk.url).slice(1) === ext);
-const routeAssetToChunk = (asset)=>({
+const assetToChunk = (asset)=>({
         chunk: asset,
         filename: asset.replace(/^\//, ''),
         linkType: 'preload',
@@ -57,16 +55,32 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = getMatchedRouteChunks(options.runtimeContext, options.routeManifest, routeAssetToChunk);
-        const orderedScriptChunks = orderHydrationScriptChunks({
-            asyncEntryChunks: asyncChunks,
-            collectedChunks,
-            matchedRouteChunks,
-            entryName
-        });
-        const chunks = [].concat(asyncChunks).concat(collectedChunks).concat(matchedRouteChunks);
-        const scriptChunks = generateChunks(orderedScriptChunks, 'js');
-        const styleChunks = generateChunks(chunks, 'css');
+        const groups = [
+            {
+                name: 'async-entry',
+                assets: asyncChunks
+            },
+            {
+                name: 'loadable',
+                assets: collectedChunks
+            }
+        ];
+        const nativeChunks = [
+            ...asyncChunks,
+            ...collectedChunks
+        ];
+        const prepare = (kind)=>options.lifecycle?.transformAssets(groups, {
+                kind,
+                source: 'loadable',
+                template: options.template,
+                createAsset: assetToChunk
+            }) ?? nativeChunks;
+        const scriptChunks = generateChunks([
+            ...prepare("script")
+        ], 'js');
+        const styleChunks = generateChunks([
+            ...prepare('style')
+        ], 'css');
         if (extractor) {
             this.emitLoadableScripts(extractor);
             await this.emitScriptAssets(scriptChunks);
@@ -105,7 +119,7 @@ class LoadableCollector {
         chunkSet.jsChunk += scripts.filter((script)=>Boolean(script)).join('');
     }
     async emitStyleAssets(chunks) {
-        const { template, chunkSet, config, moduleFederationCssAssets } = this.options;
+        const { template, chunkSet, config } = this.options;
         const { inlineStyles } = config;
         const atrributes = attributesToString(this.generateAttributes());
         const emittedAssetUrls = new Set();
@@ -120,11 +134,8 @@ class LoadableCollector {
             return link;
         }));
         chunkSet.cssChunk += css.filter((css)=>Boolean(css)).join('');
-        chunkSet.cssChunk += createFederatedCssLinks(moduleFederationCssAssets, {
-            template,
-            attributes: this.generateAttributes(),
-            existingAssets: emittedChunks.map((chunk)=>chunk.url)
-        });
+        this.stylesheetInfo.emittedAssets = emittedChunks.map((chunk)=>chunk.url);
+        this.stylesheetInfo.attributes = this.generateAttributes();
     }
     generateAttributes(extraAtr = {}) {
         const { config } = this.options;
@@ -137,6 +148,10 @@ class LoadableCollector {
         };
     }
     constructor(options){
+        this.stylesheetInfo = {
+            emittedAssets: [],
+            attributes: {}
+        };
         this.options = options;
     }
 }

package/dist/esm-node/core/server/string/ssrData.mjs

@@ -1,6 +1,5 @@
 import "node:module";
 import { serializeJson } from "@modern-js/runtime-utils/node";
-import { getRouterHydrationScripts, getRouterServerSnapshot } from "../../../router/runtime/lifecycle.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../../constants.mjs";
 import { attributesToString, serializeErrors } from "../utils.mjs";
 function _check_private_redeclaration(obj, privateCollection) {
@@ -89,20 +88,15 @@ function getSSRData() {
     };
 }
 function getRouterData() {
-    const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
-    const snapshotRouterData = getRouterServerSnapshot(runtimeContext)?.routerData;
-    if (snapshotRouterData) return {
-        loaderData: snapshotRouterData.loaderData,
-        errors: serializeErrors(snapshotRouterData.errors || null)
-    };
-    return routerContext ? {
-        loaderData: routerContext.loaderData,
-        errors: serializeErrors(routerContext.errors)
+    const { routerContext, lifecycle } = _class_private_field_get(this, _options);
+    const data = lifecycle?.getRouterData() ?? routerContext;
+    return data ? {
+        loaderData: data.loaderData,
+        errors: serializeErrors(data.errors || null)
     } : void 0;
 }
 function getSSRDataScripts(ssrData, routerData) {
     const { nonce, useJsonScript = false } = _class_private_field_get(this, _options);
-    const hydrationScripts = getRouterHydrationScripts(_class_private_field_get(this, _options).runtimeContext);
     const serializeSSRData = serializeJson(ssrData);
     const attrsStr = attributesToString({
         nonce
@@ -112,7 +106,6 @@ function getSSRDataScripts(ssrData, routerData) {
         const serializedRouterData = serializeJson(routerData);
         ssrDataScripts += useJsonScript ? `\n<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>` : `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>`;
     }
-    if (hydrationScripts.length) ssrDataScripts += `\n${hydrationScripts.join('\n')}`;
     return ssrDataScripts;
 }
 export { SSRDataCollector };

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

@@ -1,8 +1,7 @@
 import "node:module";
-import { escapeHtmlAttribute, isSafeHtmlAttributeName } from "@modern-js/runtime-extensions";
 import { isRouteErrorResponse } from "../../router/runtime/routerHelper.mjs";
 function attributesToString(attributes) {
-    return Object.entries(attributes).reduce((str, [key, value])=>void 0 !== value && isSafeHtmlAttributeName(key) ? `${str} ${key}="${escapeHtmlAttribute(value)}"` : str, '');
+    return Object.entries(attributes).reduce((str, [key, value])=>void 0 !== value && /^[^\u0000-\u0020"'<>/=]+$/u.test(key) ? `${str} ${key}="${String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')}"` : str, '');
 }
 function safeReplace(source, searchValue, replaceValue) {
     return source.replace(searchValue, ()=>replaceValue);

package/dist/esm-node/exports/head.mjs

@@ -2,21 +2,14 @@ import "node:module";
 "use client";
 import react from "react";
 import { Helmet, HelmetData, HelmetProvider } from "react-helmet-async";
-import { InternalRuntimeContext } from "../core/context/index.mjs";
-import { ensureHelmetContext } from "../core/context/helmetContext.mjs";
-import * as __rspack_external__modern_js_runtime_extensions_ce611631 from "@modern-js/runtime-extensions";
-const collectServerHelmet = (runtimeContext, props)=>{
-    const helmetContext = ensureHelmetContext(runtimeContext);
-    const createRecord = ()=>__rspack_external__modern_js_runtime_extensions_ce611631.createHelmetRecord(react, props);
-    const deriveState = (records)=>__rspack_external__modern_js_runtime_extensions_ce611631.deriveHelmetServerState(react, records);
-    const marker = __rspack_external__modern_js_runtime_extensions_ce611631.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
-    if (void 0 !== marker) return marker;
-    helmetContext.helmet = __rspack_external__modern_js_runtime_extensions_ce611631.collectImmediateHelmetState(react, helmetContext, createRecord());
-};
+import { RuntimeComponentResolverContext } from "../core/context/runtime.mjs";
 const head_Helmet = (props)=>{
-    const runtimeContext = react.useContext(InternalRuntimeContext);
-    if (null !== runtimeContext && false === runtimeContext.isBrowser) return __rspack_external__modern_js_runtime_extensions_ce611631.renderHeadMarker(react, collectServerHelmet(runtimeContext, props));
-    return react.createElement(Helmet, props);
+    const resolveComponent = react.useContext(RuntimeComponentResolverContext);
+    const Component = resolveComponent?.(Helmet, {
+        name: 'head.Helmet'
+    }) ?? Helmet;
+    if (Component === head_Helmet) throw new Error('A component resolver cannot resolve head.Helmet to itself.');
+    return react.createElement(Component, props);
 };
 const head = {
     Helmet: head_Helmet,