@modern-js/runtime 3.1.0 → 3.1.2

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

@@ -117,4 +117,4 @@ const DeferredDataScripts = (props)=>{
     });
 };
 const DeferredDataScripts_node = DeferredDataScripts;
-export { DeferredDataScripts_node as default };
+export default DeferredDataScripts_node;

package/dist/esm/router/runtime/PrefetchLink.mjs

@@ -3,10 +3,6 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
 import react, { useContext, useMemo } from "react";
 import { InternalRuntimeContext } from "../../core/context/index.mjs";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.e = ()=>Promise.resolve();
-})();
 function composeEventHandlers(theirHandler, ourHandler) {
     return (event)=>{
         theirHandler?.(event);
@@ -145,7 +141,7 @@ const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetc
                     ...props,
                     ...prefetchHandlers
                 }),
-                shouldPrefetch && __webpack_require__.e && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
+                shouldPrefetch && __webpack_chunk_load__ && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
                     path: resolvedPath
                 }) : null
             ]

package/dist/esm/router/runtime/index.mjs

@@ -1,9 +1,9 @@
 import { useRouteLoaderData } from "@modern-js/runtime-utils/router";
-import { Link, NavLink } from "./PrefetchLink.mjs";
 export * from "@modern-js/runtime-utils/router";
 export * from "./withRouter.mjs";
 const runtime_useRouteLoaderData = (routeId)=>{
     const realRouteId = routeId.replace(/\[(.*?)\]/g, '($1)');
     return useRouteLoaderData(realRouteId);
 };
-export { Link, NavLink, runtime_useRouteLoaderData as useRouteLoaderData };
+export { Link, NavLink } from "./PrefetchLink.mjs";
+export { runtime_useRouteLoaderData as useRouteLoaderData };

package/dist/esm/router/runtime/internal.mjs

@@ -1,4 +1,5 @@
 import { modifyRoutes, routerPlugin } from "./plugin.mjs";
-import { renderRoutes } from "./utils.mjs";
 const internal = routerPlugin;
-export { internal as default, modifyRoutes, renderRoutes, routerPlugin };
+export { renderRoutes } from "./utils.mjs";
+export default internal;
+export { modifyRoutes, routerPlugin };

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

@@ -2,11 +2,11 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useLocation, useMatches } from "@modern-js/runtime-utils/router";
 import { normalizePathname } from "@modern-js/runtime-utils/url";
+import * as __rspack_external_react from "react";
 import { InternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { modifyRoutes, onBeforeCreateRoutes } from "./hooks.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils.mjs";
-import * as __rspack_external_react from "react";
 let finalRouteConfig = {
     routes: []
 };

package/dist/esm-node/cli/code.mjs

@@ -3,8 +3,8 @@ import path from "path";
 import { fs } from "@modern-js/utils";
 import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME } from "./constants.mjs";
 import { resolveSSRMode } from "./ssr/mode.mjs";
-import { AppProxyForRSC, entryForCSRWithRSC, index, register, runtimeGlobalContext, runtimeGlobalContextForRSCClient, runtimeGlobalContextForRSCServer, runtimeRegister } from "./template.mjs";
-import { entryForCSRWithRSC as external_template_server_mjs_entryForCSRWithRSC, serverIndex } from "./template.server.mjs";
+import * as __rspack_external__template_mjs_d6ab8956 from "./template.mjs";
+import * as __rspack_external__template_server_mjs_38d6edb1 from "./template.server.mjs";
 const generateCode = async (entrypoints, appContext, config, hooks)=>{
     const { mountId } = config.html;
     const { enableAsyncEntry } = config.source;
@@ -22,13 +22,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 nestedRoutesEntry
             });
             let indexCode = '';
-            indexCode = !ssrMode && config.server.rsc ? entryForCSRWithRSC({
-                metaName,
-                entryName,
-                mountId,
-                urlPath: serverRoutes.find((route)=>route.entryName === entryName)?.urlPath,
-                isNestedRouter: entrypoint.nestedRoutesEntry
-            }) : index({
+            indexCode = ssrMode || !config.server.rsc || customEntry ? __rspack_external__template_mjs_d6ab8956.index({
                 srcDirectory,
                 internalSrcAlias,
                 metaName,
@@ -38,6 +32,12 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 mountId,
                 enableRsc: config.server.rsc,
                 isNestedRouter: !!entrypoint.nestedRoutesEntry
+            }) : __rspack_external__template_mjs_d6ab8956.entryForCSRWithRSC({
+                metaName,
+                entryName,
+                mountId,
+                urlPath: serverRoutes.find((route)=>route.entryName === entryName)?.urlPath,
+                isNestedRouter: entrypoint.nestedRoutesEntry
             });
             const indexFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
             await fs.outputFile(indexFile, indexCode, 'utf8');
@@ -48,7 +48,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
             }
             if (ssrMode) {
-                const indexServerCode = serverIndex({
+                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.serverIndex({
                     entry,
                     entryName,
                     internalSrcAlias,
@@ -62,16 +62,16 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
             } else if (config.server.rsc) {
                 const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
-                const indexServerCode = external_template_server_mjs_entryForCSRWithRSC({
+                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.entryForCSRWithRSC({
                     entryName,
                     metaName
                 });
                 await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
             }
-            const registerCode = register();
+            const registerCode = __rspack_external__template_mjs_d6ab8956.register();
             const registerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_REGISTER_FILE_NAME}`);
             await fs.outputFile(registerFile, registerCode, 'utf8');
-            const registerRuntimeCode = runtimeRegister({
+            const registerRuntimeCode = __rspack_external__template_mjs_d6ab8956.runtimeRegister({
                 entryName,
                 srcDirectory,
                 internalSrcAlias,
@@ -85,7 +85,7 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
             if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
                 const route = serverRoutes.find((r)=>r.entryName === entryName);
                 const basename = route?.urlPath || '/';
-                contextCode = runtimeGlobalContext({
+                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContext({
                     entryName,
                     srcDirectory,
                     internalSrcAlias,
@@ -96,17 +96,18 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 });
             } else {
                 const AppProxyPath = path.join(internalDirectory, entryName, './AppProxy.jsx');
-                const appProxyCode = AppProxyForRSC({
+                const appProxyCode = __rspack_external__template_mjs_d6ab8956.AppProxyForRSC({
                     srcDirectory,
                     internalSrcAlias,
                     entry,
                     customEntry
                 });
                 await fs.outputFile(AppProxyPath, appProxyCode);
-                contextCode = runtimeGlobalContextForRSCClient({
-                    metaName
+                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCClient({
+                    metaName,
+                    customEntry
                 });
-                const contextServerCode = runtimeGlobalContextForRSCServer({
+                const contextServerCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCServer({
                     metaName
                 });
                 const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`);

package/dist/esm-node/cli/index.mjs

@@ -91,4 +91,5 @@ const runtimePlugin = (params)=>({
         }
     });
 const cli = runtimePlugin;
-export { cli as default, documentPlugin, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };
+export default cli;
+export { documentPlugin, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };

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

@@ -107,4 +107,5 @@ const ssrPlugin = ()=>({
         }
     });
 const cli_ssr = ssrPlugin;
-export { cli_ssr as default, ssrPlugin };
+export default cli_ssr;
+export { ssrPlugin };

package/dist/esm-node/cli/ssr/loadable-bundler-plugin.mjs

@@ -74,4 +74,4 @@ class LoadablePlugin {
     }
 }
 const loadable_bundler_plugin = LoadablePlugin;
-export { loadable_bundler_plugin as default };
+export default loadable_bundler_plugin;

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

@@ -153,16 +153,54 @@ const runtimeGlobalContextForRSCServer = ({ metaName })=>`
     App: DefaultRoot,
     RSCRoot: AppProxy,
   });`;
-const runtimeGlobalContextForRSCClient = ({ metaName })=>`
-  import { createElement, Fragment } from 'react';
-  import { setGlobalContext } from '@${metaName}/runtime/context';
-
-  const DefaultRoot = ({ children }: { children?: ReactNode }) =>
-    createElement(Fragment, null, children);
-
-  setGlobalContext({
-    App: DefaultRoot
-  });`;
+const runtimeGlobalContextForRSCClient = ({ metaName, customEntry })=>`
+   ${customEntry ? `import {
+     RscClientRoot,
+     createFromFetch,
+     createFromReadableStream,
+     isRedirectResponse,
+     rscStream,
+     callServer,
+     setServerCallback,
+   } from '@${metaName}/runtime/rsc/client';` : ''}
+   import { createElement, Fragment } from 'react';
+   import { setGlobalContext } from '@${metaName}/runtime/context';
+
+   ${customEntry ? 'setServerCallback(callServer);' : ''}
+
+   ${customEntry ? `const handleRedirectResponse = (res: Response) => {
+     const { headers } = res;
+     const location = headers.get('X-Modernjs-Redirect');
+     const baseUrl = headers.get('X-Modernjs-BaseUrl');
+     if (location) {
+       if (baseUrl && baseUrl !== '/') {
+         window.location.replace(baseUrl + location);
+       } else {
+         window.location.replace(location);
+       }
+       return res;
+     }
+     return res;
+   };
+
+   const data = ${process.env.MODERN_DISABLE_INJECT_RSC_DATA ? `createFromFetch(
+     fetch(location.pathname, {
+       headers: {
+         'x-rsc-tree': 'true',
+       },
+     }).then(handleRedirectResponse),
+   )` : `createFromReadableStream(rscStream, {
+     callServer: callServer,
+   })`};` : ''}
+
+   const DefaultRoot = ({ children }: { children?: ReactNode }) =>
+     createElement(Fragment, null, children);
+
+   ${customEntry ? 'const RSCRoot = () => createElement(RscClientRoot, { rscPayload: data });' : ''}
+
+   setGlobalContext({
+     App: ${customEntry ? 'RSCRoot' : 'DefaultRoot'}
+   });`;
 const AppProxyForRSC = ({ srcDirectory, internalSrcAlias, entry, customEntry })=>`
   import App from '${formatImportPath(customEntry ? entry.replace(/entry\.[tj]sx/, 'App').replace(srcDirectory, internalSrcAlias) : entry.replace(srcDirectory, internalSrcAlias).replace('.tsx', ''))}';
   import React from 'react';

package/dist/esm-node/core/constants.mjs

@@ -6,4 +6,4 @@ var constants_RenderLevel = /*#__PURE__*/ function(RenderLevel) {
 }({});
 const SSR_DATA_JSON_ID = '__MODERN_SSR_DATA__';
 const ROUTER_DATA_JSON_ID = '__MODERN_ROUTER_DATA__';
-export { ROUTER_DATA_JSON_ID, constants_RenderLevel as RenderLevel, SSR_DATA_JSON_ID };
+export { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID, constants_RenderLevel as RenderLevel };

package/dist/esm-node/core/context/index.mjs

@@ -1,6 +1,4 @@
 import "node:module";
-import { InternalRuntimeContext, RuntimeContext, getInitialContext } from "./runtime.mjs";
-import { getServerPayload, setServerPayload } from "./serverPayload/index.mjs";
 const globalContext = {};
 function getGlobalIsRscClient() {
     return globalContext.isRscClient;
@@ -43,4 +41,6 @@ function getGlobalLayoutApp() {
 function getGlobalBasename() {
     return globalContext.basename;
 }
-export { InternalRuntimeContext, RuntimeContext, getCurrentEntryName, getGlobalApp, getGlobalBasename, getGlobalEnableRsc, getGlobalInternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRSCRoot, getGlobalRoutes, getInitialContext, getServerPayload, setGlobalContext, setGlobalInternalRuntimeContext, setServerPayload };
+export { InternalRuntimeContext, RuntimeContext, getInitialContext } from "./runtime.mjs";
+export { getServerPayload, setServerPayload } from "./serverPayload/index.mjs";
+export { getCurrentEntryName, getGlobalApp, getGlobalBasename, getGlobalEnableRsc, getGlobalInternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRSCRoot, getGlobalRoutes, setGlobalContext, setGlobalInternalRuntimeContext };

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

@@ -1,4 +1,3 @@
 import "node:module";
-import { defineRuntimeConfig } from "./config.mjs";
-import { RuntimeContext, useRuntimeContext } from "./context/runtime.mjs";
-export { RuntimeContext, defineRuntimeConfig, useRuntimeContext };
+export { defineRuntimeConfig } from "./config.mjs";
+export { RuntimeContext, useRuntimeContext } from "./context/runtime.mjs";

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

@@ -1,8 +1,9 @@
 import "node:module";
-import { NoSSR, NoSSRCache } from "./react/index.mjs";
 const ssr = (_config)=>({
         name: '@modern-js/plugin-ssr',
         setup: (_api)=>{}
     });
 const server = ssr;
-export { NoSSR, NoSSRCache, server as default, ssr };
+export { NoSSR, NoSSRCache } from "./react/index.mjs";
+export default server;
+export { ssr };

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

@@ -1,4 +1,3 @@
 import "node:module";
-import { NoSSR } from "./nossr/index.mjs";
-import { NoSSRCache } from "./no-ssr-cache/index.mjs";
-export { NoSSR, NoSSRCache };
+export { NoSSR } from "./nossr/index.mjs";
+export { NoSSRCache } from "./no-ssr-cache/index.mjs";

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

@@ -1,5 +1,4 @@
 import "node:module";
-import { renderString } from "./string/index.mjs";
-import { renderStreaming } from "./stream/index.mjs";
-import { createRequestHandler } from "./requestHandler.mjs";
-export { createRequestHandler, renderStreaming, renderString };
+export { renderString } from "./string/index.mjs";
+export { renderStreaming } from "./stream/index.mjs";
+export { createRequestHandler } from "./requestHandler.mjs";

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

@@ -1,12 +1,12 @@
 import "node:module";
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-import { dirname as __rspack_dirname } from "node:path";
 import { matchRoutes } from "@modern-js/runtime-utils/router";
 import react_helmet from "react-helmet";
 import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
 import { createReplaceHelemt } from "../helmet.mjs";
 import { buildHtml } from "../shared.mjs";
 import { checkIsNode, safeReplace } from "../utils.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
 var beforeTemplate_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const readAsset = async (chunk)=>{
     const fs = await import("fs/promises");

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

@@ -106,4 +106,4 @@ function createRenderStreaming(createReadableStreamPromise) {
         return stream;
     };
 }
-export { shared_ShellChunkStatus as ShellChunkStatus, createRenderStreaming, encodeForWebStream, getReadableStreamFromString, resolveStreamingMode };
+export { createRenderStreaming, encodeForWebStream, getReadableStreamFromString, resolveStreamingMode, shared_ShellChunkStatus as ShellChunkStatus };

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

@@ -1,8 +1,8 @@
 import "node:module";
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-import { dirname as __rspack_dirname } from "node:path";
 import { ChunkExtractor } from "@loadable/server";
 import { attributesToString, checkIsNode } from "../utils.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
 var loadable_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const extname = (uri)=>{
     if ('string' != typeof uri || !uri.includes('.')) return '';

package/dist/esm-node/document/Html.mjs

@@ -4,12 +4,22 @@ import "react";
 import { Body } from "./Body.mjs";
 import { DocumentStructureContext } from "./DocumentStructureContext.mjs";
 import { Head } from "./Head.mjs";
+import { Root } from "./Root.mjs";
 function findTargetChildByName(tag, children) {
     return children.find((item)=>getEleType(item) === tag);
 }
 function findTargetChildByComponent(component, children) {
     return children.find((item)=>item?.type === component);
 }
+function findTargetElementByComponent(component, children) {
+    if (0 === children.length) return null;
+    let nextChildren = [];
+    for (const item of children){
+        if (item?.type === component) return item;
+        if (item?.props?.children) nextChildren = nextChildren.concat(item.props.children);
+    }
+    return findTargetElementByComponent(component, nextChildren);
+}
 function getEleType(ele) {
     return 'function' == typeof ele?.type ? ele.type.name : ele?.type;
 }
@@ -28,7 +38,7 @@ function Html(props) {
     const hasSetScripts = Boolean(findTargetElement('Scripts', children));
     const hasSetLinks = Boolean(findTargetElement('Links', children));
     const hasSetBody = Boolean(findTargetChildByComponent(Body, children) || findTargetChildByName('Body', children));
-    const hasSetRoot = Boolean(findTargetElement('Root', children));
+    const hasSetRoot = Boolean(findTargetElementByComponent(Root, children) || findTargetChildByName('Root', children));
     const hasSetTitle = Boolean(findTargetElement('title', children));
     const notMissMustChild = [
         hasSetHead,

package/dist/esm-node/document/cli/index.mjs

@@ -349,4 +349,5 @@ const documentPlugin = ()=>({
         }
     });
 const cli = documentPlugin;
-export { cli as default, documentPlugin, getDocumentByEntryName };
+export default cli;
+export { documentPlugin, getDocumentByEntryName };

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

@@ -2,4 +2,5 @@ import "node:module";
 "use client";
 import react_helmet, { Helmet } from "react-helmet";
 const head = react_helmet;
-export { Helmet, head as default };
+export default head;
+export { Helmet };

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

@@ -2,4 +2,4 @@ import "node:module";
 import component from "@loadable/component";
 export * from "@loadable/component";
 const loadable = component;
-export { loadable as default };
+export default loadable;

package/dist/esm-node/index.mjs

@@ -1,7 +1,6 @@
 import "node:module";
-import { isBrowser } from "./common.mjs";
-import { getMonitors } from "./core/context/monitors/index.mjs";
-import { getRequest } from "./core/context/request/index.mjs";
-import { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";
-import { RuntimeContext, defineRuntimeConfig, useRuntimeContext } from "./core/index.mjs";
-export { RuntimeContext, defineRuntimeConfig, getMonitors, getRequest, isBrowser, redirect, setHeaders, setStatus, useRuntimeContext };
+export { isBrowser } from "./common.mjs";
+export { getMonitors } from "./core/context/monitors/index.mjs";
+export { getRequest } from "./core/context/request/index.mjs";
+export { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";
+export { RuntimeContext, defineRuntimeConfig, useRuntimeContext } from "./core/index.mjs";

package/dist/esm-node/internal.mjs

@@ -1,3 +1,2 @@
 import "node:module";
-import { InternalRuntimeContext } from "./core/context/runtime.mjs";
-export { InternalRuntimeContext };
+export { InternalRuntimeContext } from "./core/context/runtime.mjs";

package/dist/esm-node/react-server.mjs

@@ -1,5 +1,4 @@
 import "node:module";
-import { getRequest } from "./core/context/request/index.mjs";
-import { getMonitors } from "./core/context/monitors/index.mjs";
-import { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";
-export { getMonitors, getRequest, redirect, setHeaders, setStatus };
+export { getRequest } from "./core/context/request/index.mjs";
+export { getMonitors } from "./core/context/monitors/index.mjs";
+export { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";

package/dist/esm-node/router/cli/code/getClientRoutes/index.mjs

@@ -1,3 +1,2 @@
 import "node:module";
-import { getClientRoutes } from "./getRoutes.mjs";
-export { getClientRoutes };
+export { getClientRoutes } from "./getRoutes.mjs";

package/dist/esm-node/router/cli/code/index.mjs

@@ -6,8 +6,8 @@ import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME } from "../../../cli/const
 import { resolveSSRMode } from "../../../cli/ssr/mode.mjs";
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "../constants.mjs";
 import { walk } from "./nestedRoutes.mjs";
-import { fileSystemRoutes, routesForServer, ssrLoaderCombinedModule } from "./templates.mjs";
 import { getServerCombinedModuleFile, getServerLoadersFile } from "./utils.mjs";
+import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
 async function generateRoutesForEntry(entrypoint, appContext) {
     const routes = [];
     if (entrypoint.nestedRoutesEntry) {
@@ -82,7 +82,7 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                 }
                 const { code } = await hooks.onBeforeGenerateRoutes.call({
                     entrypoint,
-                    code: await fileSystemRoutes({
+                    code: await __rspack_external__templates_mjs_4da4c6c8.fileSystemRoutes({
                         metaName,
                         routes: routes,
                         ssrMode: isUseRsc(config) ? 'stream' : ssrMode,
@@ -99,12 +99,12 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                     const routesServerFile = getServerLoadersFile(internalDirectory, entryName);
                     const filtedRoutesForServer = filterRoutesForServer(routes);
                     const routesForServerLoaderMatches = filterRoutesLoader(routes);
-                    const code = routesForServer({
+                    const code = __rspack_external__templates_mjs_4da4c6c8.routesForServer({
                         routesForServerLoaderMatches
                     });
                     await fs.ensureFile(routesServerFile);
                     await fs.writeFile(routesServerFile, code);
-                    const serverRoutesCode = await fileSystemRoutes({
+                    const serverRoutesCode = await __rspack_external__templates_mjs_4da4c6c8.fileSystemRoutes({
                         metaName,
                         routes: filtedRoutesForServer,
                         ssrMode,
@@ -118,7 +118,7 @@ const generateCode = async (appContext, config, entrypoints, api)=>{
                     });
                     await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, 'utf8');
                 }
-                const serverLoaderCombined = ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                const serverLoaderCombined = __rspack_external__templates_mjs_4da4c6c8.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
                 if (serverLoaderCombined) {
                     const serverLoaderFile = getServerCombinedModuleFile(internalDirectory, entryName);
                     await fs.outputFile(serverLoaderFile, serverLoaderCombined);

package/dist/esm-node/router/cli/code/nestedRoutes.mjs

@@ -1,12 +1,12 @@
 import "node:module";
-import { extname as external_path_extname, join, relative, sep } from "path";
 import { JS_EXTENSIONS, fs, normalizeToPosixPath } from "@modern-js/utils";
 import { NESTED_ROUTE } from "../constants.mjs";
 import { getPathWithoutExt, hasAction, replaceWithAlias } from "./utils.mjs";
+import * as __rspack_external_path from "path";
 const conventionNames = Object.values(NESTED_ROUTE);
 const replaceDynamicPath = (routePath)=>routePath.replace(/\[(.*?)\]/g, ':$1');
 const getRouteId = (componentPath, routesDir, entryName, isMainEntry)=>{
-    const relativePath = normalizeToPosixPath(relative(routesDir, componentPath));
+    const relativePath = normalizeToPosixPath(__rspack_external_path.relative(routesDir, componentPath));
     const pathWithoutExt = getPathWithoutExt(relativePath);
     let id = "";
     id = isMainEntry ? pathWithoutExt : `${entryName}_${pathWithoutExt}`;
@@ -65,8 +65,8 @@ const walk = async (options)=>{
     if (!await fs.pathExists(dirname)) return null;
     const isDirectory = (await fs.stat(dirname)).isDirectory();
     if (!isDirectory) return null;
-    const relativeDir = relative(rootDir, dirname);
-    const pathSegments = relativeDir.split(sep);
+    const relativeDir = __rspack_external_path.relative(rootDir, dirname);
+    const pathSegments = relativeDir.split(__rspack_external_path.sep);
     const lastSegment = pathSegments[pathSegments.length - 1];
     const isRoot = '' === lastSegment;
     const isPathlessLayout = lastSegment.startsWith('__');
@@ -94,9 +94,9 @@ const walk = async (options)=>{
     let splatAction = '';
     const items = await fs.readdir(dirname);
     for (const item of items){
-        const itemPath = join(dirname, item);
+        const itemPath = __rspack_external_path.join(dirname, item);
         const itemPathWithAlias = alias ? getPathWithoutExt(replaceWithAlias(alias.basename, itemPath, alias.name)) : getPathWithoutExt(itemPath);
-        const extname = external_path_extname(item);
+        const extname = __rspack_external_path.extname(item);
         const itemWithoutExt = item.slice(0, -extname.length);
         const isDirectory = (await fs.stat(itemPath)).isDirectory();
         if (isDirectory) {
@@ -169,7 +169,7 @@ const walk = async (options)=>{
     let finalRoute = createRoute({
         ...route,
         origin: 'file-system'
-    }, rootDir, join(dirname, `${NESTED_ROUTE.LAYOUT_FILE}.ts`), entryName, isMainEntry);
+    }, rootDir, __rspack_external_path.join(dirname, `${NESTED_ROUTE.LAYOUT_FILE}.ts`), entryName, isMainEntry);
     if (isPathlessLayout) delete finalRoute.path;
     const childRoutes = finalRoute.children = finalRoute.children?.filter((childRoute)=>childRoute);
     if (childRoutes && 0 === childRoutes.length && !finalRoute.index && !finalRoute._component) return null;

package/dist/esm-node/router/cli/handler.mjs

@@ -2,9 +2,9 @@ import "node:module";
 import path from "path";
 import { getMeta } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
-import { runtimeGlobalContext } from "./code/templates.mjs";
 import { isPageComponentFile } from "./code/utils.mjs";
 import { modifyEntrypoints } from "./entry.mjs";
+import * as __rspack_external__code_templates_mjs_5e908598 from "./code/templates.mjs";
 let originEntrypoints = [];
 async function handleModifyEntrypoints(entrypoints) {
     return modifyEntrypoints(entrypoints);
@@ -21,7 +21,7 @@ async function handleGeneratorEntryCode(api, entrypoints) {
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
             const basename = route?.urlPath || '/';
-            generatorRegisterCode(internalDirectory, entrypoint.entryName, await runtimeGlobalContext({
+            generatorRegisterCode(internalDirectory, entrypoint.entryName, await __rspack_external__code_templates_mjs_5e908598.runtimeGlobalContext({
                 entryName: entrypoint.entryName,
                 metaName: appContext.metaName,
                 srcDirectory: appContext.srcDirectory,
@@ -31,7 +31,7 @@ async function handleGeneratorEntryCode(api, entrypoints) {
                 rscType: enableRsc ? 'client' : void 0,
                 basename
             }));
-            if (enableRsc) generatorServerRegisterCode(internalDirectory, entrypoint.entryName, await runtimeGlobalContext({
+            if (enableRsc) generatorServerRegisterCode(internalDirectory, entrypoint.entryName, await __rspack_external__code_templates_mjs_5e908598.runtimeGlobalContext({
                 entryName: entrypoint.entryName,
                 metaName: appContext.metaName,
                 srcDirectory: appContext.srcDirectory,

package/dist/esm-node/router/cli/index.mjs

@@ -1,10 +1,10 @@
 import "node:module";
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-import { dirname as __rspack_dirname } from "node:path";
 import node_path from "node:path";
 import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
 import { isRouteEntry } from "./entry.mjs";
 import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
 var cli_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const routerPlugin = ()=>({
         name: '@modern-js/plugin-router',
@@ -81,4 +81,5 @@ const routerPlugin = ()=>({
         }
     });
 const cli = routerPlugin;
-export { cli as default, handleFileChange, handleModifyEntrypoints, isRouteEntry, routerPlugin };
+export default cli;
+export { handleFileChange, handleModifyEntrypoints, isRouteEntry, routerPlugin };

package/dist/esm-node/router/internal.mjs

@@ -1,4 +1,3 @@
 import "node:module";
-import { routerPlugin } from "./runtime/internal.mjs";
 export * from "./runtime/internal.mjs";
-export { routerPlugin as default };
+export { routerPlugin as default } from "./runtime/internal.mjs";

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

@@ -1,3 +1,3 @@
 import "node:module";
 const DeferredDataScripts = ()=>null;
-export { DeferredDataScripts as default };
+export default DeferredDataScripts;

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

@@ -118,4 +118,4 @@ const DeferredDataScripts = (props)=>{
     });
 };
 const DeferredDataScripts_node = DeferredDataScripts;
-export { DeferredDataScripts_node as default };
+export default DeferredDataScripts_node;

package/dist/esm-node/router/runtime/PrefetchLink.mjs

@@ -4,10 +4,6 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
 import react, { useContext, useMemo } from "react";
 import { InternalRuntimeContext } from "../../core/context/index.mjs";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.e = ()=>Promise.resolve();
-})();
 function composeEventHandlers(theirHandler, ourHandler) {
     return (event)=>{
         theirHandler?.(event);
@@ -146,7 +142,7 @@ const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetc
                     ...props,
                     ...prefetchHandlers
                 }),
-                shouldPrefetch && __webpack_require__.e && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
+                shouldPrefetch && __webpack_chunk_load__ && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
                     path: resolvedPath
                 }) : null
             ]