@bleedingdev/modern-js-runtime 3.5.0-ultramodern.98 → 3.8.1-ultramodern.1

package/dist/cjs/router/cli/code/index.js

@@ -84,8 +84,9 @@ async function generateRoutesForEntry(entrypoint, appContext) {
     }
     return routes;
 }
-const generateCode = async (appContext, config, entrypoints, api)=>{
+const generateCode = async (appContext, config, entrypoints, api, options = {})=>{
     const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
+    const includeRouteServerLoadersInSsrEntry = false !== options.includeRouteServerLoadersInSsrEntry || !(0, utils_namespaceObject.isUseRsc)(config);
     const hooks = api.getHooks();
     const generatedRoutesByEntry = {};
     const eagerRouteComponentFilesByEntry = new Map();
@@ -143,6 +144,7 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                         internalDirectory,
                         splitRouteChunks: config?.output?.splitRouteChunks,
                         isRscClientBundle: (0, utils_namespaceObject.isUseRsc)(config),
+                        hydrateRscClientRoutes: options.hydrateRscClientRoutes,
                         srcDirectory,
                         internalSrcAlias: appContext.internalSrcAlias
                     })
@@ -150,12 +152,14 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                 if (entrypoint.nestedRoutesEntry && ((0, utils_namespaceObject.isUseSSRBundle)(config) || (0, utils_namespaceObject.isUseRsc)(config))) {
                     const routesServerFile = (0, external_utils_js_namespaceObject.getServerLoadersFile)(internalDirectory, entryName);
                     const filtedRoutesForServer = (0, utils_namespaceObject.filterRoutesForServer)(routes);
-                    const routesForServerLoaderMatches = (0, utils_namespaceObject.filterRoutesLoader)(routes);
-                    const code = external_templates_js_namespaceObject.routesForServer({
-                        routesForServerLoaderMatches
-                    });
-                    await utils_namespaceObject.fs.ensureFile(routesServerFile);
-                    await utils_namespaceObject.fs.writeFile(routesServerFile, code);
+                    if (includeRouteServerLoadersInSsrEntry) {
+                        const routesForServerLoaderMatches = (0, utils_namespaceObject.filterRoutesLoader)(routes);
+                        const code = external_templates_js_namespaceObject.routesForServer({
+                            routesForServerLoaderMatches
+                        });
+                        await utils_namespaceObject.fs.ensureFile(routesServerFile);
+                        await utils_namespaceObject.fs.writeFile(routesServerFile, code);
+                    } else await utils_namespaceObject.fs.remove(routesServerFile);
                     const serverRoutesCode = await external_templates_js_namespaceObject.fileSystemRoutes({
                         metaName,
                         routes: filtedRoutesForServer,
@@ -165,12 +169,15 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                         internalDirectory,
                         splitRouteChunks: config?.output?.splitRouteChunks,
                         isRscClientBundle: false,
+                        isolateRouteDataInRscLayer: (0, utils_namespaceObject.isUseRsc)(config) && options.isolateRouteDataInRscLayer,
                         srcDirectory,
                         internalSrcAlias: appContext.internalSrcAlias
                     });
-                    await utils_namespaceObject.fs.outputFile(external_path_default().resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, 'utf8');
+                    await utils_namespaceObject.fs.outputFile(external_path_default().resolve(internalDirectory, `./${entryName}/${options.serverRoutesFileName || 'routes.server.js'}`), serverRoutesCode, 'utf8');
                 }
-                const serverLoaderCombined = external_templates_js_namespaceObject.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                const serverLoaderCombined = external_templates_js_namespaceObject.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext, {
+                    includeRouteServerLoaders: includeRouteServerLoadersInSsrEntry
+                });
                 if (serverLoaderCombined) {
                     const serverLoaderFile = (0, external_utils_js_namespaceObject.getServerCombinedModuleFile)(internalDirectory, entryName);
                     await utils_namespaceObject.fs.outputFile(serverLoaderFile, serverLoaderCombined);

package/dist/cjs/router/cli/code/templates.js

@@ -134,7 +134,7 @@ async function hasUseClientDirective(componentPath, srcDirectory, internalSrcAli
         await fh?.close();
     }
 }
-const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = false, srcDirectory, internalSrcAlias })=>{
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = false, hydrateRscClientRoutes = false, isolateRouteDataInRscLayer = false, srcDirectory, internalSrcAlias })=>{
     const components = [];
     const loadings = [];
     const errors = [];
@@ -206,7 +206,6 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
                     componentPath: route._component,
                     routeId: route.id
                 });
-                rootLayoutCode = `import RootLayout from '${route._component}'`;
                 component = 'RootLayout';
             } else if (splitRouteChunks) {
                 lazyImport = createLazyImport({
@@ -227,8 +226,9 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
             component = `component_${components.length - 1}`;
         }
         const isClientComponent = 'nested' === route.type && Boolean(route._component) && Boolean(srcDirectory) && Boolean(internalSrcAlias) && await hasUseClientDirective(route._component, srcDirectory, internalSrcAlias);
-        const shouldHydrateRscRoute = isRscClientBundle && !isClientComponent && !route.loader && !route.data;
+        const shouldHydrateRscRoute = hydrateRscClientRoutes && isRscClientBundle && !isClientComponent && ('nested' !== route.type || !route.loader && !route.data);
         const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent || shouldHydrateRscRoute;
+        if ('nested' === route.type && route.isRoot && route._component && shouldIncludeClientBundle) rootLayoutCode = `import RootLayout from '${route._component}'`;
         const finalRoute = {
             ...route,
             loading,
@@ -289,32 +289,30 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     const importComponentsCode = components.map((component, index)=>`import component_${index} from '${component}';\n`).join('');
     const importErrorComponentsCode = errors.map((error, index)=>`import error_${index} from '${error}';\n`).join('');
     let importLoadersCode = '';
-    for (const [key, loaderInfo] of Object.entries(loadersMap))if (loaderInfo.inline) {
+    const isolatedRouteDataDirectory = external_path_default().join(internalDirectory, entryName, '__rsc_route_data__');
+    await utils_namespaceObject.fs.remove(isolatedRouteDataDirectory);
+    if (isolateRouteDataInRscLayer) await utils_namespaceObject.fs.ensureDir(isolatedRouteDataDirectory);
+    for (const [key, loaderInfo] of Object.entries(loadersMap)){
         const { route } = loaderInfo;
-        if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+        const loaderRequest = `${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
             loaderId: key,
             clientData: loaderInfo.clientData,
-            action: route.action,
+            action: route.action || false,
             inline: loaderInfo.inline,
             routeId: loaderInfo.routeId,
             inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";\n`;
-        else importLoadersCode += `import { loader as ${key} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
-            loaderId: key,
-            clientData: loaderInfo.clientData,
-            action: false,
-            inline: loaderInfo.inline,
-            routeId: route.id,
-            inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";\n`;
-    } else importLoadersCode += `import ${key} from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
-        loaderId: key,
-        clientData: loaderInfo.clientData,
-        action: false,
-        inline: loaderInfo.inline,
-        routeId: loaderInfo.routeId,
-        inValidSSRRoute: loaderInfo.inValidSSRRoute
-    })}";\n`;
+        })}`;
+        let loaderImport = loaderRequest;
+        if (isolateRouteDataInRscLayer) {
+            const isolatedLoaderFile = external_path_default().join(isolatedRouteDataDirectory, `${key}.js`);
+            const isolatedLoaderCode = loaderInfo.inline ? route.action ? `export { loader, action } from ${JSON.stringify(loaderRequest)};` : `export { loader } from ${JSON.stringify(loaderRequest)};` : `export { default } from ${JSON.stringify(loaderRequest)};`;
+            await utils_namespaceObject.fs.outputFile(isolatedLoaderFile, isolatedLoaderCode, 'utf8');
+            loaderImport = `./__rsc_route_data__/${key}.js`;
+        }
+        if (loaderInfo.inline) if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${loaderImport}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${loaderImport}";\n`;
+        else importLoadersCode += `import ${key} from "${loaderImport}";\n`;
+    }
     let importConfigsCode = '';
     for (const [key, configPath] of Object.entries(configsMap))importConfigsCode += `import * as ${key} from "${(0, utils_namespaceObject.slash)(configPath)}";\n`;
     await utils_namespaceObject.fs.ensureFile(loadersMapFile);
@@ -340,7 +338,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     ${routeComponentsCode}
   `;
 };
-function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext, options = {}) {
     const { entryName, isMainEntry } = entrypoint;
     const { packageName } = appContext;
     const ssr = (0, utils_namespaceObject.getEntryOptions)(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
@@ -348,6 +346,17 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
     if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
         const serverLoaderRuntime = require.resolve('@modern-js/plugin-data-loader/runtime');
         const serverLoadersFile = './route-server-loaders.js';
+        const includeRouteServerLoaders = false !== options.includeRouteServerLoaders;
+        if (!includeRouteServerLoaders) {
+            if (!config.source.enableAsyncEntry) return `export * from "${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"`;
+            return `
+      async function loadModules() {
+        return import("${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}");
+      }
+
+      export { loadModules };
+      `;
+        }
         const combinedModule = `export * from "${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"; export * from "${serverLoadersFile}"`;
         if (!config.source.enableAsyncEntry) return combinedModule;
         return `
@@ -368,7 +377,7 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
     }
     return null;
 }
-const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, basename })=>{
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, routesImportPath = './routes', basename })=>{
     const imports = [
         `import { setGlobalContext } from '@${metaName}/runtime/context';`
     ];
@@ -399,7 +408,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
     const enableRsc = Boolean(rscType);
     if (isClient) return `${imports.join('\n')}
 
-    import { routes } from './routes';
+    import { routes } from '${routesImportPath}';
 
     const entryName = '${entryName}';
     const basename = '${basename || '/'}';
@@ -415,7 +424,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
     `;
     return `${imports.join('\n')}
 
-    import { routes } from './routes';
+    import { routes } from '${routesImportPath}';
 
     const entryName = '${entryName}';
     const basename = '${basename || '/'}';

package/dist/cjs/router/cli/handler.js

@@ -64,7 +64,12 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
     const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.js");
     originEntrypointsByKey.set(entrypointsKey, (0, lodash_namespaceObject.cloneDeep)(entrypoints));
     const enableRsc = resolvedConfig?.server?.rsc;
-    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api);
+    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, {
+        hydrateRscClientRoutes: normalizedOptions.hydrateRscClientRoutes,
+        includeRouteServerLoadersInSsrEntry: normalizedOptions.includeRouteServerLoadersInSsrEntry,
+        isolateRouteDataInRscLayer: normalizedOptions.isolateRouteDataInRscLayer,
+        serverRoutesFileName: normalizedOptions.serverRoutesFileName
+    });
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
@@ -87,6 +92,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
                 internalSrcAlias: appContext.internalSrcAlias,
                 globalApp: entrypoint.fileSystemRoutes?.globalApp,
                 rscType: 'server',
+                routesImportPath: normalizedOptions.serverRoutesFileName ? `./${normalizedOptions.serverRoutesFileName.replace(/\.js$/, '')}` : void 0,
                 basename
             }));
         }

package/dist/cjs/router/runtime/plugin.js

@@ -40,6 +40,7 @@ const url_namespaceObject = require("@modern-js/runtime-utils/url");
 const external_react_namespaceObject = require("react");
 const index_js_namespaceObject = require("../../core/context/index.js");
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_PrefetchLink_js_namespaceObject = require("./PrefetchLink.js");
 const external_provider_js_namespaceObject = require("./provider.js");
 const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
 const external_utils_js_namespaceObject = require("./utils.js");
@@ -73,9 +74,13 @@ const routerPlugin = (userConfig = {})=>({
                     }
                 }
                 context.router = {
+                    Link: external_PrefetchLink_js_namespaceObject.Link,
                     useMatches: router_namespaceObject.useMatches,
                     useLocation: router_namespaceObject.useLocation,
-                    useHref: router_namespaceObject.useHref
+                    useHref: router_namespaceObject.useHref,
+                    useInRouterContext: router_namespaceObject.useInRouterContext,
+                    useNavigate: router_namespaceObject.useNavigate,
+                    useParams: router_namespaceObject.useParams
                 };
                 Object.defineProperty(context, 'routes', {
                     get () {
@@ -99,7 +104,7 @@ const routerPlugin = (userConfig = {})=>({
                 };
                 let cachedRouter = null;
                 const RouterWrapper = (props)=>{
-                    const routerResult = useRouterCreation(process.env.MODERN_ENABLE_RSC ? {
+                    const routerResult = useRouterCreation(("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) ? {
                         ...props,
                         rscPayload: props?.rscPayload
                     } : props, {
@@ -117,18 +122,18 @@ const routerPlugin = (userConfig = {})=>({
                     const { routes } = routerResult;
                     routesContainer.current = routes;
                     beforeCreateRouter = false;
-                    const RouterContent = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
-                            children: [
-                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.RouterProvider, {
-                                    router: router
-                                }),
-                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyComponent, {}),
-                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyComponent, {})
-                            ]
-                        });
+                    const routerContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                        children: [
+                            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.RouterProvider, {
+                                router: router
+                            }),
+                            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyComponent, {}),
+                            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyComponent, {})
+                        ]
+                    });
                     return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
-                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterContent, {})
-                    }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterContent, {});
+                        children: routerContent
+                    }) : routerContent;
                 };
                 return RouterWrapper;
             });
@@ -156,15 +161,15 @@ function useRouterCreation(props, options) {
     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
     const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-    const rscPayload = process.env.MODERN_ENABLE_RSC && props?.rscPayload ? safeUse(props.rscPayload) : null;
-    let hydrationData = process.env.MODERN_ENABLE_RSC ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
+    const rscPayload = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) && props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = "u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA : true === (0, index_js_namespaceObject.getGlobalEnableRsc)() ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
     return (0, external_react_namespaceObject.useMemo)(()=>{
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: (0, external_utils_js_namespaceObject.deserializeErrors)(hydrationData.errors)
         };
         let routes = null;
-        routes = process.env.MODERN_ENABLE_RSC && (0, index_js_namespaceObject.getGlobalIsRscClient)() ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+        routes = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) && (0, index_js_namespaceObject.getGlobalIsRscClient)() ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
             routesConfig: finalRouteConfig
         }) : createRoutes ? createRoutes() : (0, router_namespaceObject.createRoutesFromElements)((0, external_utils_js_namespaceObject.renderRoutes)({
             routesConfig: finalRouteConfig,
@@ -172,7 +177,7 @@ function useRouterCreation(props, options) {
         }));
         if (!routes) routes = [];
         const hooks = api.getHooks();
-        if (process.env.MODERN_ENABLE_RSC && rscPayload) try {
+        if (("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === (0, index_js_namespaceObject.getGlobalEnableRsc)()) && rscPayload) try {
             const router = (0, external_rsc_router_js_namespaceObject.createClientRouterFromPayload)(rscPayload, routes, _basename);
             return {
                 router,

package/dist/cjs/router/runtime/plugin.node.js

@@ -52,6 +52,7 @@ const index_server_js_namespaceObject = require("../../core/context/serverPayloa
 const external_DeferredDataScripts_node_js_namespaceObject = require("./DeferredDataScripts.node.js");
 var external_DeferredDataScripts_node_js_default = /*#__PURE__*/ __webpack_require__.n(external_DeferredDataScripts_node_js_namespaceObject);
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_PrefetchLink_js_namespaceObject = require("./PrefetchLink.js");
 const external_provider_js_namespaceObject = require("./provider.js");
 const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
 const external_utils_js_namespaceObject = require("./utils.js");
@@ -89,6 +90,13 @@ const routerPlugin = (userConfig = {})=>({
         setup: (api)=>{
             let finalRouteConfig = {};
             api.onBeforeRender(async (context, interrupt)=>{
+                context.router = {
+                    Link: external_PrefetchLink_js_namespaceObject.Link,
+                    useInRouterContext: router_namespaceObject.useInRouterContext,
+                    useLocation: router_namespaceObject.useLocation,
+                    useNavigate: router_namespaceObject.useNavigate,
+                    useParams: router_namespaceObject.useParams
+                };
                 const pluginConfig = api.getRuntimeConfig();
                 const { basename = '', routesConfig, createRoutes } = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
                 finalRouteConfig = {
@@ -177,10 +185,8 @@ const routerPlugin = (userConfig = {})=>({
                     const enableRsc = (0, index_js_namespaceObject.getGlobalEnableRsc)();
                     return (props)=>{
                         const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
-                        const { routerContext, ssrContext, routes } = context;
-                        const { nonce, mode, useJsonScript } = ssrContext;
+                        const { routerContext, routes } = context;
                         const { basename } = routerContext;
-                        const remixRouter = (0, router_namespaceObject.createStaticRouter)(routes, routerContext);
                         if (enableRsc) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
                             children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_rsc_router_js_namespaceObject.RSCStaticRouter, {
                                 basename: basename
@@ -189,6 +195,8 @@ const routerPlugin = (userConfig = {})=>({
                             basename: basename
                         });
                         {
+                            const { nonce, mode, useJsonScript } = context.ssrContext;
+                            const remixRouter = (0, router_namespaceObject.createStaticRouter)(routes, routerContext);
                             const routerWrapper = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
                                 children: [
                                     /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.StaticRouterProvider, {

package/dist/cjs/router/runtime/provider.js

@@ -53,7 +53,7 @@ function createRouterProviderRealm(registrations) {
     const providers = new Map();
     let defaultProvider;
     for (const registration of registrations){
-        if (!registration.name) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
+        if (0 === registration.name.length) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
         if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
         if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
         providers.set(registration.name, registration.factory);
@@ -63,7 +63,7 @@ function createRouterProviderRealm(registrations) {
         ...providers.keys()
     ]);
     return Object.freeze({
-        ...defaultProvider ? {
+        ...void 0 !== defaultProvider ? {
             defaultProvider
         } : {},
         get: (name)=>providers.get(name),

package/dist/cjs/router/runtime/redirect.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+const handleRSCRedirect = (headers, basename, status)=>{
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.set('X-Modernjs-BaseUrl', basename);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status,
+        headers: newHeaders
+    });
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    handleRSCRedirect: handleRSCRedirect
+});
+exports.handleRSCRedirect = __webpack_exports__.handleRSCRedirect;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleRSCRedirect"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/routerHelper.js

@@ -31,9 +31,11 @@ __webpack_require__.d(__webpack_exports__, {
     createShouldRevalidate: ()=>createShouldRevalidate,
     handleRouteModule: ()=>handleRouteModule,
     handleRouteModuleError: ()=>handleRouteModuleError,
+    isRouteErrorResponse: ()=>isRouteErrorResponse,
     resolveRouteComponent: ()=>resolveRouteComponent
 });
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const isRouteErrorResponse = (error)=>null !== error && 'object' == typeof error && 'number' == typeof error.status && 'string' == typeof error.statusText && 'boolean' == typeof error.internal && 'data' in error;
 const isObjectLike = (value)=>'object' == typeof value && null !== value || 'function' == typeof value;
 const isRouteComponent = (value)=>'function' == typeof value || isObjectLike(value) && '$$typeof' in value;
 const getRouteModules = ()=>{
@@ -89,11 +91,13 @@ const handleRouteModuleError = (error)=>{
 exports.createShouldRevalidate = __webpack_exports__.createShouldRevalidate;
 exports.handleRouteModule = __webpack_exports__.handleRouteModule;
 exports.handleRouteModuleError = __webpack_exports__.handleRouteModuleError;
+exports.isRouteErrorResponse = __webpack_exports__.isRouteErrorResponse;
 exports.resolveRouteComponent = __webpack_exports__.resolveRouteComponent;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createShouldRevalidate",
     "handleRouteModule",
     "handleRouteModuleError",
+    "isRouteErrorResponse",
     "resolveRouteComponent"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/router/runtime/rsc-router.js

@@ -40,7 +40,7 @@ __webpack_require__.d(__webpack_exports__, {
     RSCStaticRouter: ()=>RSCStaticRouter,
     createClientRouterFromPayload: ()=>createClientRouterFromPayload,
     createServerPayload: ()=>createServerPayload,
-    handleRSCRedirect: ()=>handleRSCRedirect,
+    handleRSCRedirect: ()=>external_redirect_js_namespaceObject.handleRSCRedirect,
     prepareRSCRoutes: ()=>prepareRSCRoutes
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
@@ -49,6 +49,7 @@ const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const external_CSSLinks_js_namespaceObject = require("./CSSLinks.js");
+const external_redirect_js_namespaceObject = require("./redirect.js");
 const safeUse = (value)=>{
     const reactUse = external_react_default().use;
     if ('function' == typeof reactUse) return reactUse(value);
@@ -131,18 +132,6 @@ const createServerPayload = (routerContext, routes)=>{
         })
     };
 };
-const handleRSCRedirect = (headers, basename, status)=>{
-    const newHeaders = new Headers(headers);
-    let redirectUrl = headers.get('Location');
-    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
-    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
-    newHeaders.set('X-Modernjs-BaseUrl', basename);
-    newHeaders.delete('Location');
-    return new Response(null, {
-        status: status,
-        headers: newHeaders
-    });
-};
 const prepareRSCRoutes = async (routes)=>{
     const isLazyComponent = (component)=>null != component && 'object' == typeof component && '_init' in component && '_payload' in component;
     const processRoutes = async (routesList)=>{

package/dist/cjs/router/runtime/utils.js

@@ -55,6 +55,7 @@ var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_
 const external_DefaultNotFound_js_namespaceObject = require("./DefaultNotFound.js");
 const external_DeferredDataScripts_js_namespaceObject = require("./DeferredDataScripts.js");
 var external_DeferredDataScripts_js_default = /*#__PURE__*/ __webpack_require__.n(external_DeferredDataScripts_js_namespaceObject);
+const external_routerHelper_js_namespaceObject = require("./routerHelper.js");
 function getRouteComponents(routes, { globalApp, ssrMode, props }) {
     const Layout = ({ Component, ...props })=>{
         const GlobalLayout = globalApp;
@@ -200,7 +201,7 @@ function serializeErrors(errors) {
     if (!errors) return null;
     const entries = Object.entries(errors);
     const serialized = {};
-    for (const [key, val] of entries)if ((0, router_namespaceObject.isRouteErrorResponse)(val)) serialized[key] = serializeRouteErrorResponse(val);
+    for (const [key, val] of entries)if ((0, external_routerHelper_js_namespaceObject.isRouteErrorResponse)(val)) serialized[key] = serializeRouteErrorResponse(val);
     else if (val instanceof Error) serialized[key] = serializeError(val);
     else serialized[key] = val;
     return serialized;
@@ -221,7 +222,7 @@ function serializeError(error) {
     };
 }
 function serializeRouteErrorResponse(error) {
-    if (!(0, router_namespaceObject.isRouteErrorResponse)(error)) return error;
+    if (!(0, external_routerHelper_js_namespaceObject.isRouteErrorResponse)(error)) return error;
     if (error.status >= 500 && shouldRedactServerError()) return {
         status: error.status,
         statusText: 'Internal Server Error',

package/dist/esm/cli/index.mjs

@@ -1,4 +1,4 @@
-import { cleanRequireCache, isReact18 as utils_isReact18 } from "@modern-js/utils";
+import { cleanRequireCache } from "@modern-js/utils";
 import path_0 from "path";
 import { documentPlugin } from "../document/cli/index.mjs";
 import { getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin, updateNestedRoutesSpec } from "../router/cli/index.mjs";
@@ -54,12 +54,10 @@ const runtimePlugin = (params)=>({
             });
             api.config(()=>{
                 const { appDirectory, metaName } = api.getAppContext();
-                const isReact18 = utils_isReact18(appDirectory);
-                process.env.IS_REACT18 = isReact18.toString();
                 return {
                     source: {
                         globalVars: {
-                            'process.env.IS_REACT18': process.env.IS_REACT18
+                            'process.env.IS_REACT18': 'true'
                         },
                         include: [
                             new RegExp(`[\\\\/]node_modules[\\\\/]@${metaName}[\\\\/]runtime[\\\\/].*[\\\\/]head\\.`)
@@ -68,14 +66,6 @@ const runtimePlugin = (params)=>({
                     tools: {
                         bundlerChain: (chain)=>{
                             chain.module.rule('modern-entry').test(/\.jsx?$/).include.add(path_0.resolve(appDirectory, 'node_modules', `.${metaName}`)).end().sideEffects(true);
-                        },
-                        rspack: (_config, { appendPlugins, rspack })=>{
-                            if (!isReact18) appendPlugins([
-                                new rspack.IgnorePlugin({
-                                    resourceRegExp: /^react-dom\/client$/,
-                                    contextRegExp: /@modern-js\/runtime/
-                                })
-                            ]);
                         }
                     }
                 };

package/dist/esm/cli/ssr/index.mjs

@@ -106,6 +106,7 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                             'process.env.MODERN_SSR_ENV': JSON.stringify(ssrEnv),
                             'process.env.MODERN_ENABLE_HYDRATION': JSON.stringify(isUseSSRBundle(userConfig)),
                             'process.env.MODERN_ENABLE_RSC': JSON.stringify(Boolean(userConfig.server?.rsc)),
+                            __MODERN_ENABLE_RSC__: JSON.stringify(Boolean(userConfig.server?.rsc)),
                             'process.env.MODERN_MF_APP_SSR': JSON.stringify(isModuleFederationAppSSR)
                         }
                     },

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

@@ -5,15 +5,23 @@ import { hydrateRoot } from "react-dom/client";
 import { RenderLevel } from "../constants.mjs";
 import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
 import { WithCallback } from "./withCallback.mjs";
-const isReact18 = ()=>'true' === process.env.IS_REACT18;
 const runtimeProcess = Reflect.get(globalThis, 'process');
+const runtimeEnvironment = null !== runtimeProcess && 'object' == typeof runtimeProcess ? Reflect.get(runtimeProcess, 'env') : void 0;
+const readRuntimeEnvironment = (name)=>{
+    if (null === runtimeEnvironment || 'object' != typeof runtimeEnvironment) return;
+    const value = Reflect.get(runtimeEnvironment, name);
+    return 'string' == typeof value ? value : void 0;
+};
 const loadableReadyOptions = {
-    chunkLoadingGlobal: runtimeProcess?.env?.MODERN_CHUNK_LOADING_GLOBAL || '__LOADABLE_LOADED_CHUNKS__'
+    chunkLoadingGlobal: (()=>{
+        const configured = readRuntimeEnvironment('MODERN_CHUNK_LOADING_GLOBAL');
+        return void 0 === configured || '' === configured ? '__LOADABLE_LOADED_CHUNKS__' : configured;
+    })()
 };
-async function hydrateWithReact(App, rootElement) {
-    return hydrateRoot(rootElement, App, {
+function hydrateWithReact(App, rootElement) {
+    return Promise.resolve(hydrateRoot(rootElement, App, {
         identifierPrefix: SSR_HYDRATION_ID_PREFIX
-    });
+    }));
 }
 function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     const hydrateContext = {
@@ -26,9 +34,9 @@ function hydrate_hydrateRoot(App, context, ModernRender, ModernHydrate) {
     const callback = ()=>{
         delete hydrateContext._hydration;
     };
-    const renderLevel = window?._SSR_DATA?.renderLevel || RenderLevel.CLIENT_RENDER;
-    const renderMode = window?._SSR_DATA?.mode || 'string';
-    if (isReact18() && 'stream' === renderMode) return streamSSRHydrate();
+    const renderLevel = window?._SSR_DATA?.renderLevel ?? RenderLevel.CLIENT_RENDER;
+    const renderMode = window?._SSR_DATA?.mode ?? 'string';
+    if ('stream' === renderMode) return streamSSRHydrate();
     function streamSSRHydrate() {
         if (renderLevel !== RenderLevel.SERVER_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
         {
@@ -42,23 +50,23 @@ 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)=>{
-            isReact18() ? loadableReady(()=>{
+        {
+            if (renderLevel === RenderLevel.SERVER_RENDER) return loadableReady(()=>void 0, loadableReadyOptions).then(()=>{
                 const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
                         callback: callback,
                         children: App
                     });
-                ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext)).then((root)=>{
-                    resolve(root);
-                });
-            }, loadableReadyOptions) : loadableReady(()=>{
-                ModernHydrate(wrapRuntimeContextProvider(App, hydrateContext), callback).then((root)=>{
-                    resolve(root);
-                });
-            }, loadableReadyOptions);
-        });
-        console.warn(`unknow render level: ${renderLevel}, execute render()`);
-        return ModernRender(wrapRuntimeContextProvider(App, context));
+                return ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext));
+            });
+            const runtimeConsole = Reflect.get(globalThis, 'console');
+            if (null !== runtimeConsole && 'object' == typeof runtimeConsole) {
+                const warn = Reflect.get(runtimeConsole, 'warn');
+                if ('function' == typeof warn) Reflect.apply(warn, runtimeConsole, [
+                    `unknow render level: ${renderLevel}, execute render()`
+                ]);
+            }
+            return ModernRender(wrapRuntimeContextProvider(App, context));
+        }
     }
 }
-export { hydrateWithReact, hydrate_hydrateRoot as hydrateRoot, isReact18 };
+export { hydrateWithReact, hydrate_hydrateRoot as hydrateRoot };