@bleedingdev/modern-js-runtime 3.2.0-ultramodern.1 → 3.2.0-ultramodern.100

package/dist/cjs/boundary-debugger/index.js

@@ -0,0 +1,299 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>boundary_debugger,
+    ultramodernBoundaryDebuggerPlugin: ()=>ultramodernBoundaryDebuggerPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const defaultStorageKey = 'modernjs:boundary-debugger:enabled';
+const queryParamName = 'modern-boundaries';
+const boundarySelector = '[data-modern-boundary-id]';
+const defaultLabels = {
+    cs: {
+        toggle: 'zobrazit hranice týmů'
+    },
+    en: {
+        toggle: 'show team boundaries'
+    }
+};
+const palette = [
+    '#ff5a5f',
+    '#30e27a',
+    '#f6cf45',
+    '#7c8cff',
+    '#29b6f6'
+];
+const readStoredEnabled = (storageKey, fallback)=>{
+    if ("u" < typeof window) return fallback;
+    try {
+        const stored = window.localStorage.getItem(storageKey);
+        return null === stored ? fallback : 'true' === stored;
+    } catch  {
+        return fallback;
+    }
+};
+const writeStoredEnabled = (storageKey, enabled)=>{
+    if ("u" < typeof window) return;
+    try {
+        window.localStorage.setItem(storageKey, String(enabled));
+    } catch  {}
+};
+const parseEnabledOverride = (value)=>{
+    if (null === value) return;
+    const normalized = value.toLowerCase();
+    if ('1' === normalized || 'true' === normalized) return true;
+    if ('0' === normalized || 'false' === normalized) return false;
+};
+const readQueryEnabledOverride = ()=>{
+    if ("u" < typeof window) return;
+    try {
+        return parseEnabledOverride(new URLSearchParams(window.location.search).get(queryParamName));
+    } catch  {
+        return;
+    }
+};
+const detectLanguage = ()=>{
+    if ("u" < typeof document) return 'en';
+    const htmlLanguage = document.documentElement.lang;
+    if (htmlLanguage) return htmlLanguage.split('-')[0] || 'en';
+    if ("u" < typeof window) return 'en';
+    return window.location.pathname.split('/').filter(Boolean)[0] || 'en';
+};
+const hashBoundaryId = (id)=>{
+    let hash = 0;
+    for(let index = 0; index < id.length; index++)hash = 31 * hash + id.charCodeAt(index) >>> 0;
+    return hash;
+};
+const formatRectKey = (rect)=>[
+        Math.round(100 * rect.left) / 100,
+        Math.round(100 * rect.top) / 100,
+        Math.round(100 * rect.width) / 100,
+        Math.round(100 * rect.height) / 100
+    ].join(':');
+const getBoundaryId = (element)=>element.dataset.modernBoundaryId ?? element.dataset.mfRemote ?? element.getAttribute('data-mf-remote') ?? void 0;
+const collectBoundaryElements = (legacySelector)=>{
+    const elements = new Set();
+    for (const element of document.querySelectorAll(boundarySelector))elements.add(element);
+    if (!legacySelector) return Array.from(elements);
+    try {
+        for (const element of document.querySelectorAll(legacySelector))elements.add(element);
+    } catch  {}
+    return Array.from(elements);
+};
+function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, labels = defaultLabels, legacySelector, metadata, storageKey = defaultStorageKey }) {
+    const [mounted, setMounted] = (0, external_react_namespaceObject.useState)(false);
+    const [enabled, setEnabled] = (0, external_react_namespaceObject.useState)(false);
+    const [boxes, setBoxes] = (0, external_react_namespaceObject.useState)([]);
+    const boundaries = (0, external_react_namespaceObject.useMemo)(()=>new Map(metadata.boundaries.map((entry, index)=>[
+                entry.mfName,
+                {
+                    ...entry,
+                    color: entry.color ?? palette[index % palette.length],
+                    label: entry.label ?? entry.appId
+                }
+            ])), [
+        metadata
+    ]);
+    const language = mounted ? detectLanguage() : 'en';
+    const toggleLabel = labels[language]?.toggle ?? labels.en?.toggle ?? defaultLabels.en?.toggle ?? 'show team boundaries';
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        setMounted(true);
+        const queryOverride = readQueryEnabledOverride();
+        setEnabled(queryOverride ?? readStoredEnabled(storageKey, enabledByDefault));
+    }, [
+        enabledByDefault,
+        storageKey
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!mounted) return;
+        writeStoredEnabled(storageKey, enabled);
+    }, [
+        enabled,
+        mounted,
+        storageKey
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled) return void setBoxes([]);
+        const readBoxes = ()=>{
+            const seenBoxes = new Set();
+            const nextBoxes = collectBoundaryElements(legacySelector).map((element)=>{
+                const boundaryId = getBoundaryId(element);
+                if (!boundaryId) return;
+                const rect = element.getBoundingClientRect();
+                if (rect.width <= 0 || rect.height <= 0) return;
+                const rectKey = formatRectKey(rect);
+                const boxKey = `${boundaryId}:${rectKey}`;
+                if (seenBoxes.has(boxKey)) return;
+                seenBoxes.add(boxKey);
+                const boundary = boundaries.get(boundaryId);
+                const color = boundary?.color ?? palette[hashBoundaryId(boundaryId) % palette.length];
+                const label = boundary?.label ?? boundary?.appId ?? boundaryId;
+                const expose = element.dataset.modernMfExpose;
+                const detail = expose && expose !== label && expose !== boundaryId ? expose : void 0;
+                const box = {
+                    color,
+                    height: rect.height,
+                    id: boxKey,
+                    label,
+                    left: rect.left,
+                    top: rect.top,
+                    width: rect.width
+                };
+                if (detail) box.detail = detail;
+                return box;
+            }).filter((box)=>void 0 !== box);
+            setBoxes(nextBoxes);
+        };
+        readBoxes();
+        const resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver(readBoxes);
+        for (const element of collectBoundaryElements(legacySelector))resizeObserver?.observe(element);
+        const mutationObserver = new MutationObserver(readBoxes);
+        mutationObserver.observe(document.body, {
+            childList: true,
+            subtree: true
+        });
+        window.addEventListener('resize', readBoxes);
+        window.addEventListener('scroll', readBoxes, true);
+        return ()=>{
+            mutationObserver.disconnect();
+            resizeObserver?.disconnect();
+            window.removeEventListener('resize', readBoxes);
+            window.removeEventListener('scroll', readBoxes, true);
+        };
+    }, [
+        boundaries,
+        enabled,
+        legacySelector
+    ]);
+    if (!mounted) return null;
+    const shouldRenderToggle = 'visible' === controlMode || 'hidden-when-off' === controlMode && enabled;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            shouldRenderToggle ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("label", {
+                style: {
+                    alignItems: 'center',
+                    background: 'rgba(255, 255, 255, 0.96)',
+                    border: '1px solid rgba(0, 0, 0, 0.1)',
+                    borderRadius: 10,
+                    boxShadow: '0 10px 28px rgba(0, 0, 0, 0.14)',
+                    color: '#111827',
+                    display: 'flex',
+                    font: '600 13px/1.2 system-ui, sans-serif',
+                    gap: 8,
+                    left: 'max(12px, env(safe-area-inset-left))',
+                    maxWidth: 'calc(100vw - 24px)',
+                    padding: '9px 11px',
+                    position: 'fixed',
+                    top: 'max(12px, env(safe-area-inset-top))',
+                    zIndex: 2147483000
+                },
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("input", {
+                        checked: enabled,
+                        onChange: (event)=>setEnabled(event.currentTarget.checked),
+                        type: "checkbox"
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                        children: toggleLabel
+                    })
+                ]
+            }) : null,
+            enabled ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                "aria-hidden": "true",
+                children: boxes.map((box)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                        style: {
+                            border: `2px solid ${box.color}`,
+                            borderRadius: 8,
+                            boxShadow: `0 0 0 1px rgba(255,255,255,.72), 0 6px 20px color-mix(in srgb, ${box.color} 20%, transparent)`,
+                            height: box.height,
+                            left: box.left,
+                            pointerEvents: 'none',
+                            position: 'fixed',
+                            top: box.top,
+                            width: box.width,
+                            zIndex: 2147482999
+                        },
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("span", {
+                            style: {
+                                background: box.color,
+                                borderRadius: 999,
+                                color: '#111827',
+                                display: 'grid',
+                                font: '800 11px/1.1 system-ui, sans-serif',
+                                gap: 3,
+                                maxWidth: 'min(280px, calc(100vw - 24px))',
+                                padding: '5px 8px',
+                                position: 'absolute',
+                                right: 4,
+                                top: 4,
+                                whiteSpace: 'nowrap'
+                            },
+                            children: [
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                                    children: box.label
+                                }),
+                                box.detail ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                                    style: {
+                                        font: '700 10px/1.1 system-ui, sans-serif',
+                                        opacity: 0.82,
+                                        overflow: 'hidden',
+                                        textOverflow: 'ellipsis'
+                                    },
+                                    children: box.detail
+                                }) : null
+                            ]
+                        })
+                    }, box.id))
+            }) : null
+        ]
+    });
+}
+const ultramodernBoundaryDebuggerPlugin = (options)=>({
+        name: '@modern-js/runtime/boundary-debugger',
+        setup: (api)=>{
+            api.wrapRoot((App)=>(props)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                        children: [
+                            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                                ...props
+                            }),
+                            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(BoundaryDebugger, {
+                                ...options
+                            })
+                        ]
+                    }));
+        }
+    });
+const boundary_debugger = ultramodernBoundaryDebuggerPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.ultramodernBoundaryDebuggerPlugin = __webpack_exports__.ultramodernBoundaryDebuggerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "ultramodernBoundaryDebuggerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/ssr/index.js

@@ -125,30 +125,20 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                 const hasServerRendering = hasServerRenderingConfig(userConfig);
                 const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
                 const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
+                const isCloudflareWorkerSSR = 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare';
                 const requireExplicitMfSsrFlag = 'true' === process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT;
                 if (hasServerRendering && hasModuleFederationRuntimeMarker && !hasExplicitMfSsrFlag) {
                     const warningMessage = '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
                     if (requireExplicitMfSsrFlag) throw new Error(`${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`);
                     console.warn(warningMessage);
                 }
-                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
-                const useModuleFederationNodeOutput = hasServerRendering && isModuleFederationAppSSR && isNodeEnvironmentTarget(config.output.target);
+                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag && !isCloudflareWorkerSSR;
                 const ssrEnv = userConfig.deploy?.worker?.ssr || userConfig.server?.rsc ? 'edge' : 'node';
                 const appContext = modernAPI.getAppContext();
                 const { appDirectory, entrypoints } = appContext;
-                const serverBundlerChain = useModuleFederationNodeOutput ? (chain)=>{
-                    chain.target('async-node');
-                    chain.output.module(false);
-                    chain.output.chunkFormat('commonjs');
-                    chain.output.chunkLoading('async-node');
-                    chain.output.library({
-                        ...chain.output.get('library') || {},
-                        type: 'commonjs-module'
-                    });
-                } : void 0;
                 const useLoadablePlugin = (0, utils_namespaceObject.isUseSSRBundle)(userConfig) && !isServerEnvironment && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 const outputConfig = {
-                    module: isServerEnvironment && !useModuleFederationNodeOutput && outputModule
+                    module: isServerEnvironment && (outputModule || 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare')
                 };
                 const useLoadableComponents = (0, utils_namespaceObject.isUseSSRBundle)(userConfig) && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 return mergeEnvironmentConfig(config, {
@@ -161,13 +151,13 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                     },
                     output: outputConfig,
                     tools: {
-                        bundlerChain: serverBundlerChain || (useLoadablePlugin ? (chain)=>{
+                        bundlerChain: useLoadablePlugin ? (chain)=>{
                             chain.plugin('loadable').use(external_loadable_bundler_plugin_js_default(), [
                                 {
                                     filename: utils_namespaceObject.LOADABLE_STATS_FILE
                                 }
                             ]);
-                        } : void 0),
+                        } : void 0,
                         swc: useLoadableComponents ? {
                             jsc: {
                                 experimental: {

package/dist/cjs/cli/template.server.js

@@ -64,6 +64,7 @@ const handleRequest = async (request, ServerRoot, options) => {
     </ServerRoot>,
     {
       ...options,
+      rscManifest: __rspack_rsc_manifest__,
       rscRoot: options.rscRoot,
     },
   );

package/dist/cjs/core/context/serverPayload/index.js

@@ -27,7 +27,7 @@ __webpack_require__.d(__webpack_exports__, {
     getServerPayload: ()=>getServerPayload,
     setServerPayload: ()=>setServerPayload
 });
-const getServerPayload = ()=>{};
+const getServerPayload = ()=>void 0;
 const setServerPayload = (payload)=>{};
 exports.getServerPayload = __webpack_exports__.getServerPayload;
 exports.setServerPayload = __webpack_exports__.setServerPayload;

package/dist/cjs/core/plugin/index.js

@@ -45,8 +45,9 @@ function registerPlugin(internalPlugins, runtimeConfig) {
         config: runtimeConfig || {},
         handleSetupResult: hooks_js_namespaceObject.handleSetupResult
     });
-    (0, external_context_index_js_namespaceObject.setGlobalInternalRuntimeContext)(runtimeContext);
-    return runtimeContext;
+    const internalRuntimeContext = runtimeContext;
+    (0, external_context_index_js_namespaceObject.setGlobalInternalRuntimeContext)(internalRuntimeContext);
+    return internalRuntimeContext;
 }
 function mergeConfig(config, ...otherConfig) {
     return (0, merge_namespaceObject.merge)({}, config, ...otherConfig);

package/dist/cjs/core/react/wrapper.js

@@ -27,9 +27,12 @@ __webpack_require__.d(__webpack_exports__, {
     wrapRuntimeContextProvider: ()=>wrapRuntimeContextProvider
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_helmet_async_namespaceObject = require("react-helmet-async");
 const index_js_namespaceObject = require("../context/index.js");
 function wrapRuntimeContextProvider(App, contextValue) {
-    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
+    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, _helmetContext, ...rest } = contextValue;
+    const internalContextValue = contextValue;
+    internalContextValue._helmetContext ??= {};
     const runtimeContextValue = {
         isBrowser,
         initialData,
@@ -39,10 +42,13 @@ function wrapRuntimeContextProvider(App, contextValue) {
         ...rest
     };
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.InternalRuntimeContext.Provider, {
-        value: contextValue,
+        value: internalContextValue,
         children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.RuntimeContext.Provider, {
             value: runtimeContextValue,
-            children: App
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_helmet_async_namespaceObject.HelmetProvider, {
+                context: internalContextValue._helmetContext,
+                children: App
+            })
         })
     });
 }

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

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createFederatedCssLinks: ()=>createFederatedCssLinks
+});
+const external_utils_js_namespaceObject = require("./utils.js");
+const createFederatedCssLinks = (assets, options)=>{
+    if (!assets?.length) return '';
+    const seen = new Set(options.existingAssets || []);
+    const attributes = (0, external_utils_js_namespaceObject.attributesToString)(options.attributes || {});
+    const links = [];
+    for (const asset of assets)if (!(!asset || seen.has(asset) || options.template.includes(asset))) {
+        seen.add(asset);
+        links.push(`<link${attributes} href="${asset}" rel="stylesheet" />`);
+    }
+    return links.join('');
+};
+exports.createFederatedCssLinks = __webpack_exports__.createFederatedCssLinks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createFederatedCssLinks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -25,15 +25,19 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createReplaceHelemt: ()=>createReplaceHelemt,
+    getHelmetData: ()=>getHelmetData,
     helmetReplace: ()=>helmetReplace
 });
-const external_os_namespaceObject = require("os");
 const external_utils_js_namespaceObject = require("./utils.js");
+const EOL = '\n';
 const RE_HTML_ATTR = /<html[^>]*>/;
 const RE_BODY_ATTR = /<body[^>]*>/;
 const RE_LAST_IN_HEAD = /<\/head>/;
 const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
 const TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/;
+function getHelmetData(runtimeContext) {
+    return runtimeContext._helmetContext?.helmet ?? void 0;
+}
 function createReplaceHelemt(helmetData) {
     return helmetData ? (template)=>helmetReplace(template, helmetData) : (tempalte)=>tempalte;
 }
@@ -61,13 +65,15 @@ function helmetReplace(content, helmetData) {
         script,
         style,
         !existTitleTag ? title : ''
-    ].reduce((pre, cur)=>pre + (cur.length > 0 ? `  ${cur}${external_os_namespaceObject.EOL}` : ''), '');
+    ].reduce((pre, cur)=>pre + (cur.length > 0 ? `  ${cur}${EOL}` : ''), '');
     return (0, external_utils_js_namespaceObject.safeReplace)(result, RE_LAST_IN_HEAD, `${helmetStr}</head>`);
 }
 exports.createReplaceHelemt = __webpack_exports__.createReplaceHelemt;
+exports.getHelmetData = __webpack_exports__.getHelmetData;
 exports.helmetReplace = __webpack_exports__.helmetReplace;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createReplaceHelemt",
+    "getHelmetData",
     "helmetReplace"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -0,0 +1,59 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    injectBeforeHydrationEntryScript: ()=>injectBeforeHydrationEntryScript
+});
+function getScriptTags(template) {
+    const scriptRegExp = /<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*><\/script>/g;
+    return Array.from(template.matchAll(scriptRegExp)).map((match)=>({
+            index: match.index ?? 0,
+            tag: match[0],
+            src: match[2]
+        }));
+}
+function getAssetBasename(src) {
+    const withoutQuery = src.split(/[?#]/)[0];
+    return withoutQuery.split('/').pop() || withoutQuery;
+}
+function isEntryScript(src, entryName, asyncEntry) {
+    const basename = getAssetBasename(src);
+    const prefix = asyncEntry ? `async-${entryName}` : entryName;
+    return basename === `${prefix}.js` || basename.startsWith(`${prefix}.`) || basename.startsWith(`${prefix}-`);
+}
+function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index') {
+    if (!scripts) return template;
+    const scriptTags = getScriptTags(template);
+    const target = scriptTags.find((match)=>isEntryScript(match.src, entryName, false)) ?? scriptTags.find((match)=>isEntryScript(match.src, entryName, true));
+    if (!target) return template;
+    return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
+}
+exports.injectBeforeHydrationEntryScript = __webpack_exports__.injectBeforeHydrationEntryScript;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "injectBeforeHydrationEntryScript"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -30,6 +30,7 @@ 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_constants_js_namespaceObject_1 = require("../constants.js");
+const external_scriptOrder_js_namespaceObject = require("../scriptOrder.js");
 const external_shared_js_namespaceObject = require("../shared.js");
 const external_utils_js_namespaceObject = require("../utils.js");
 function buildShellAfterTemplate(afterAppTemplate, options) {
@@ -50,11 +51,18 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
         if (!routeManifest) return template;
         const { routeAssets } = routeManifest;
         if (!routeAssets) return template;
-        const asyncEntry = routeAssets[`async-${entryName}`];
-        if (asyncEntry) {
-            const { assets } = asyncEntry;
-            const jsChunkStr = assets?.filter((asset)=>asset.endsWith('.js'))?.map((asset)=>`<script src=${asset} nonce="${nonce}"></script>`).join(' ');
-            if (jsChunkStr) return (0, external_utils_js_namespaceObject.safeReplace)(template, '<!--<?- chunksMap.js ?>-->', jsChunkStr);
+        const matchedRouteIds = (0, lifecycle_js_namespaceObject.getRouterMatchedRouteIds)(runtimeContext) ?? [];
+        const assetEntries = [
+            ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
+            routeAssets[`async-${entryName}`]
+        ].filter(Boolean);
+        const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
+        const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
+        const jsChunkStr = jsAssets.filter((asset)=>!template.includes(asset)).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
+        if (jsChunkStr) {
+            const withoutPlaceholder = (0, external_utils_js_namespaceObject.safeReplace)(template, '<!--<?- chunksMap.js ?>-->', '');
+            const withEarlyScripts = (0, external_scriptOrder_js_namespaceObject.injectBeforeHydrationEntryScript)(withoutPlaceholder, jsChunkStr, entryName);
+            return withEarlyScripts !== withoutPlaceholder ? withEarlyScripts : (0, external_utils_js_namespaceObject.safeReplace)(template, '<!--<?- chunksMap.js ?>-->', jsChunkStr);
         }
         return template;
     }