@bleedingdev/modern-js-runtime 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/dist/cjs/core/server/stream/deferredScript.js

@@ -58,13 +58,13 @@ function isDeferredDataLike(v) {
     return hasPending && hasData;
 }
 function isPromiseLike(value) {
-    return !!value && 'function' == typeof value.then;
+    return Boolean(value) && 'function' == typeof value.then;
 }
 function toErrorInfo(error) {
     if ((0, external_utils_js_namespaceObject.shouldRedactServerError)()) return {
         message: 'Unexpected Server Error'
     };
-    if (error && 'object' == typeof error) {
+    if (null !== error && 'object' == typeof error) {
         const maybeMsg = error.message;
         const maybeStack = error.stack;
         return {
@@ -79,7 +79,7 @@ function toErrorInfo(error) {
 function buildDeferredDataScript(nonce, args) {
     const payload = JSON.stringify(args);
     const escaped = escapeAttr(payload);
-    const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
+    const nonceAttr = void 0 !== nonce && '' !== nonce ? ` nonce="${nonce}"` : '';
     return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${constants_js_namespaceObject.runRouterDataFnStr}</script>`;
 }
 function enqueueFromEntries(entries, nonce, emit) {

package/dist/cjs/core/server/stream/shared.js

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

package/dist/cjs/core/server/string/index.js

@@ -39,7 +39,6 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     renderString: ()=>renderString
 });
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const time_namespaceObject = require("@modern-js/runtime-utils/time");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const server_namespaceObject = require("react-dom/server");
@@ -49,7 +48,6 @@ const index_js_namespaceObject = require("../../context/index.js");
 const wrapper_js_namespaceObject = require("../../react/wrapper.js");
 const external_constants_js_namespaceObject_1 = require("../constants.js");
 const external_helmet_js_namespaceObject = require("../helmet.js");
-const external_scriptOrder_js_namespaceObject = require("../scriptOrder.js");
 const external_shared_js_namespaceObject = require("../shared.js");
 const external_tracer_js_namespaceObject = require("../tracer.js");
 const external_utils_js_namespaceObject = require("../utils.js");
@@ -62,7 +60,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 = (0, external_utils_js_namespaceObject.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
     const chunkSet = {
         renderLevel: external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER,
@@ -70,85 +68,123 @@ const renderString = async (request, serverRoot, options)=>{
         jsChunk: '',
         cssChunk: ''
     };
-    const collectors = [
-        new external_loadable_js_namespaceObject.LoadableCollector({
-            stats: loadableStats,
-            nonce: config.nonce,
-            routeManifest,
-            runtimeContext,
-            template: htmlTemplate,
-            entryName,
-            moduleFederationCssAssets,
-            chunkSet,
-            config
-        }),
-        new external_ssrData_js_namespaceObject.SSRDataCollector({
-            runtimeContext,
-            request,
-            ssrConfig,
-            ssrContext: runtimeContext.ssrContext,
-            chunkSet,
-            routerContext,
-            nonce: config.nonce,
-            useJsonScript: config.useJsonScript
-        })
-    ];
+    const collectors = [];
+    const lifecycle = (0, external_shared_js_namespaceObject.createSSRRenderLifecycle)(collectors);
+    const loadableCollector = new external_loadable_js_namespaceObject.LoadableCollector({
+        stats: loadableStats,
+        nonce: config.nonce,
+        routeManifest,
+        template: htmlTemplate,
+        entryName,
+        chunkSet,
+        config,
+        lifecycle
+    });
+    collectors.push(loadableCollector, new external_ssrData_js_namespaceObject.SSRDataCollector({
+        runtimeContext,
+        request,
+        ssrConfig,
+        ssrContext: runtimeContext.ssrContext,
+        chunkSet,
+        routerContext,
+        nonce: config.nonce,
+        useJsonScript: config.useJsonScript,
+        lifecycle
+    }));
     const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
     const hooks = internalRuntimeContext.hooks;
     const extraCollectors = hooks.extendStringSSRCollectors.call({
-        chunkSet
+        chunkSet,
+        render: {
+            runtimeContext,
+            request,
+            resource,
+            config,
+            platform: 'node',
+            mode: 'string',
+            isRsc: true === (0, index_js_namespaceObject.getGlobalEnableRsc)()
+        }
     });
     for (const c of extraCollectors)if (c) collectors.unshift(c);
-    const rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
+    let rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
         ssr: true
     }));
-    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], runtimeContext, entryName, tracer);
+    if (true === (0, index_js_namespaceObject.getGlobalEnableRsc)() && false === runtimeContext.isBrowser) rootElement = (0, wrapper_js_namespaceObject.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);
-    runtime_extensions_namespaceObject.beginHeadRender(runtimeContext);
     try {
-        const end = (0, time_namespaceObject.time)();
-        html = server_default().renderToString(finalApp, {
-            identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
+        signal.throwIfAborted();
+        try {
+            const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
+            lifecycle.beforeReact();
+            const end = (0, time_namespaceObject.time)();
+            html = server_default().renderToString(finalApp, {
+                identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
+            });
+            html = lifecycle.completedBody(html, 'complete');
+            chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
+            helmetData = (0, external_helmet_js_namespaceObject.getHelmetData)(collectors);
+            const cost = end();
+            onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
+        } catch (error) {
+            lifecycle.finish({
+                status: 'fallback',
+                error
+            });
+            html = '';
+            chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+            onError(error, external_tracer_js_namespaceObject.SSRErrors.RENDER_HTML);
+        }
+        await Promise.all(collectors.map((component)=>component.effect()));
+        signal.throwIfAborted();
+        const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+        const finalHtml = await (0, external_shared_js_namespaceObject.buildHtml)(htmlTemplate, [
+            createReplaceHtml(html),
+            (template)=>(0, external_shared_js_namespaceObject.replaceSSRTemplateChunk)({
+                    name: "scripts",
+                    template,
+                    placeholder: external_constants_js_namespaceObject_1.CHUNK_JS_PLACEHOLDER,
+                    content: jsChunk
+                }, lifecycle),
+            (template)=>(0, external_shared_js_namespaceObject.replaceSSRTemplateChunk)({
+                    name: 'styles',
+                    template,
+                    placeholder: external_constants_js_namespaceObject_1.CHUNK_CSS_PLACEHOLDER,
+                    content: cssChunk,
+                    ...stylesheetInfo
+                }, lifecycle),
+            (template)=>(0, external_shared_js_namespaceObject.replaceSSRTemplateChunk)({
+                    name: 'data',
+                    template,
+                    placeholder: external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER,
+                    content: ssrScripts
+                }, lifecycle),
+            (0, external_helmet_js_namespaceObject.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 = runtime_extensions_namespaceObject.completeHeadRender(runtimeContext, html);
-        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
-        helmetData = (0, external_helmet_js_namespaceObject.getHelmetData)(runtimeContext);
-        const cost = end();
-        onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
-    } catch (e) {
-        runtime_extensions_namespaceObject.abortHeadRender(runtimeContext);
-        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
-        onError(e, external_tracer_js_namespaceObject.SSRErrors.RENDER_HTML);
+        throw error;
     }
-    await Promise.all(collectors.map((component)=>component.effect()));
-    const { ssrScripts, cssChunk, jsChunk } = chunkSet;
-    const finalHtml = await (0, external_shared_js_namespaceObject.buildHtml)(htmlTemplate, [
-        createReplaceHtml(html),
-        createReplaceChunkJs(jsChunk, entryName),
-        createReplaceChunkCss(cssChunk),
-        createReplaceSSRDataScript(ssrScripts, entryName),
-        (0, external_helmet_js_namespaceObject.createReplaceHelemt)(helmetData),
-        ...htmlModifiers
-    ]);
-    return finalHtml;
 }
 function createReplaceHtml(html) {
     return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.HTML_PLACEHOLDER, html);
 }
-function createReplaceSSRDataScript(data, entryName) {
-    return (template)=>(0, external_scriptOrder_js_namespaceObject.replaceChunkJsPlaceholder)(template, data, entryName, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER);
-}
-function createReplaceChunkJs(js, entryName) {
-    return (template)=>(0, external_scriptOrder_js_namespaceObject.replaceChunkJsPlaceholder)(template, js, entryName);
-}
-function createReplaceChunkCss(css) {
-    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.CHUNK_CSS_PLACEHOLDER, css);
-}
 exports.renderString = __webpack_exports__.renderString;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "renderString"

package/dist/cjs/core/server/string/loadable.js

@@ -31,15 +31,13 @@ __webpack_require__.d(__webpack_exports__, {
     LoadableCollector: ()=>LoadableCollector
 });
 const server_namespaceObject = require("@loadable/server");
-const external_federatedCss_js_namespaceObject = require("../federatedCss.js");
-const external_scriptOrder_js_namespaceObject = require("../scriptOrder.js");
 const external_utils_js_namespaceObject = require("../utils.js");
 const extname = (uri)=>{
     if ('string' != typeof uri || !uri.includes('.')) return '';
     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',
@@ -85,16 +83,32 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = (0, external_scriptOrder_js_namespaceObject.getMatchedRouteChunks)(options.runtimeContext, options.routeManifest, routeAssetToChunk);
-        const orderedScriptChunks = (0, external_scriptOrder_js_namespaceObject.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);
@@ -133,7 +147,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 = (0, external_utils_js_namespaceObject.attributesToString)(this.generateAttributes());
         const emittedAssetUrls = new Set();
@@ -148,11 +162,8 @@ class LoadableCollector {
             return link;
         }));
         chunkSet.cssChunk += css.filter((css)=>Boolean(css)).join('');
-        chunkSet.cssChunk += (0, external_federatedCss_js_namespaceObject.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;
@@ -165,6 +176,10 @@ class LoadableCollector {
         };
     }
     constructor(options){
+        this.stylesheetInfo = {
+            emittedAssets: [],
+            attributes: {}
+        };
         this.options = options;
     }
 }

package/dist/cjs/core/server/string/ssrData.js

@@ -31,7 +31,6 @@ __webpack_require__.d(__webpack_exports__, {
     SSRDataCollector: ()=>SSRDataCollector
 });
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
-const lifecycle_js_namespaceObject = require("../../../router/runtime/lifecycle.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
 const external_utils_js_namespaceObject = require("../utils.js");
 function _check_private_redeclaration(obj, privateCollection) {
@@ -120,20 +119,15 @@ function getSSRData() {
     };
 }
 function getRouterData() {
-    const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
-    const snapshotRouterData = (0, lifecycle_js_namespaceObject.getRouterServerSnapshot)(runtimeContext)?.routerData;
-    if (snapshotRouterData) return {
-        loaderData: snapshotRouterData.loaderData,
-        errors: (0, external_utils_js_namespaceObject.serializeErrors)(snapshotRouterData.errors || null)
-    };
-    return routerContext ? {
-        loaderData: routerContext.loaderData,
-        errors: (0, external_utils_js_namespaceObject.serializeErrors)(routerContext.errors)
+    const { routerContext, lifecycle } = _class_private_field_get(this, _options);
+    const data = lifecycle?.getRouterData() ?? routerContext;
+    return data ? {
+        loaderData: data.loaderData,
+        errors: (0, external_utils_js_namespaceObject.serializeErrors)(data.errors || null)
     } : void 0;
 }
 function getSSRDataScripts(ssrData, routerData) {
     const { nonce, useJsonScript = false } = _class_private_field_get(this, _options);
-    const hydrationScripts = (0, lifecycle_js_namespaceObject.getRouterHydrationScripts)(_class_private_field_get(this, _options).runtimeContext);
     const serializeSSRData = (0, node_namespaceObject.serializeJson)(ssrData);
     const attrsStr = (0, external_utils_js_namespaceObject.attributesToString)({
         nonce
@@ -143,7 +137,6 @@ function getSSRDataScripts(ssrData, routerData) {
         const serializedRouterData = (0, node_namespaceObject.serializeJson)(routerData);
         ssrDataScripts += useJsonScript ? `\n<script type="application/json" id="${external_constants_js_namespaceObject.ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>` : `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>`;
     }
-    if (hydrationScripts.length) ssrDataScripts += `\n${hydrationScripts.join('\n')}`;
     return ssrDataScripts;
 }
 exports.SSRDataCollector = __webpack_exports__.SSRDataCollector;

package/dist/cjs/core/server/utils.js

@@ -37,10 +37,9 @@ __webpack_require__.d(__webpack_exports__, {
     serializeErrors: ()=>serializeErrors,
     shouldRedactServerError: ()=>shouldRedactServerError
 });
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const routerHelper_js_namespaceObject = require("../../router/runtime/routerHelper.js");
 function attributesToString(attributes) {
-    return Object.entries(attributes).reduce((str, [key, value])=>void 0 !== value && (0, runtime_extensions_namespaceObject.isSafeHtmlAttributeName)(key) ? `${str} ${key}="${(0, runtime_extensions_namespaceObject.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/cjs/exports/head.js

@@ -41,24 +41,17 @@ __webpack_require__.d(__webpack_exports__, {
     Helmet: ()=>Helmet,
     default: ()=>exports_head
 });
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const external_react_helmet_async_namespaceObject = require("react-helmet-async");
-const index_js_namespaceObject = require("../core/context/index.js");
-const helmetContext_js_namespaceObject = require("../core/context/helmetContext.js");
-const collectServerHelmet = (runtimeContext, props)=>{
-    const helmetContext = (0, helmetContext_js_namespaceObject.ensureHelmetContext)(runtimeContext);
-    const createRecord = ()=>runtime_extensions_namespaceObject.createHelmetRecord(external_react_default(), props);
-    const deriveState = (records)=>runtime_extensions_namespaceObject.deriveHelmetServerState(external_react_default(), records);
-    const marker = runtime_extensions_namespaceObject.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
-    if (void 0 !== marker) return marker;
-    helmetContext.helmet = runtime_extensions_namespaceObject.collectImmediateHelmetState(external_react_default(), helmetContext, createRecord());
-};
+const runtime_js_namespaceObject = require("../core/context/runtime.js");
 const Helmet = (props)=>{
-    const runtimeContext = external_react_default().useContext(index_js_namespaceObject.InternalRuntimeContext);
-    if (null !== runtimeContext && false === runtimeContext.isBrowser) return runtime_extensions_namespaceObject.renderHeadMarker(external_react_default(), collectServerHelmet(runtimeContext, props));
-    return external_react_default().createElement(external_react_helmet_async_namespaceObject.Helmet, props);
+    const resolveComponent = external_react_default().useContext(runtime_js_namespaceObject.RuntimeComponentResolverContext);
+    const Component = resolveComponent?.(external_react_helmet_async_namespaceObject.Helmet, {
+        name: 'head.Helmet'
+    }) ?? external_react_helmet_async_namespaceObject.Helmet;
+    if (Component === Helmet) throw new Error('A component resolver cannot resolve head.Helmet to itself.');
+    return external_react_default().createElement(Component, props);
 };
 const head = {
     Helmet,