@modern-js/runtime 2.69.7 → 3.0.0-alpha.1

package/dist/esm/router/cli/code/inspect.mjs

@@ -0,0 +1,95 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { modifyEntrypoints } from "../entry";
+import { generateRoutesForEntry } from "./index";
+function convertRouteToInspectFormat(route) {
+    const inspectRoute = {
+        path: route.path ?? void 0,
+        component: route._component || ''
+    };
+    if (route.path?.includes(':')) {
+        const params = route.path.match(/:[^\/]+/g)?.map((param)=>param.slice(1)) || [];
+        inspectRoute.params = params;
+    }
+    if (route.data) inspectRoute.data = route.data;
+    if (route.clientData) inspectRoute.clientData = route.clientData;
+    if (route.error) inspectRoute.error = route.error;
+    if (route.loading) inspectRoute.loading = route.loading;
+    if (route.config) inspectRoute.config = 'string' == typeof route.config ? route.config : String(route.config);
+    if ('children' in route && route.children && route.children.length > 0) inspectRoute.children = route.children.filter((child)=>{
+        const hasComponent = Boolean(child._component);
+        const hasChildren = 'children' in child && child.children && child.children.length > 0;
+        const hasPath = void 0 !== child.path;
+        return hasComponent || hasChildren || hasPath;
+    }).map((child)=>convertRouteToInspectFormat(child));
+    return inspectRoute;
+}
+async function generateInspectReportForEntry(entrypoint, appContext, config, api) {
+    const { entryName } = entrypoint;
+    console.log(`🔍 Analyzing routes for entry "${entryName}"...`);
+    const routes = await generateRoutesForEntry(entrypoint, appContext);
+    if (0 === routes.length) {
+        console.log(`⚠️  No routes found for entry "${entryName}"`);
+        return {
+            entryName,
+            routes: []
+        };
+    }
+    const hooks = api.getHooks();
+    const clonedRoutes = cloneDeep(routes);
+    const { routes: finalRoutes } = await hooks.modifyFileSystemRoutes.call({
+        entrypoint,
+        routes: clonedRoutes
+    });
+    const inspectRoutes = finalRoutes.filter((route)=>{
+        const hasComponent = Boolean(route._component);
+        const hasChildren = 'children' in route && route.children && route.children.length > 0;
+        const hasPath = void 0 !== route.path;
+        return hasComponent || hasChildren || hasPath;
+    }).map((route)=>convertRouteToInspectFormat(route));
+    console.log(`✅ Found ${inspectRoutes.length} routes for entry "${entryName}"`);
+    return {
+        entryName,
+        routes: inspectRoutes
+    };
+}
+async function generateRoutesInspectReport(api) {
+    try {
+        console.log('🚀 Start generating route inspection report...\n');
+        const appContext = api.getAppContext();
+        const config = api.getNormalizedConfig();
+        const { entrypoints, distDirectory } = appContext;
+        const modifiedEntrypoints = modifyEntrypoints(entrypoints);
+        const routesEntrypoints = modifiedEntrypoints.filter((entrypoint)=>entrypoint.isAutoMount);
+        if (0 === routesEntrypoints.length) return void console.log('⚠️  No entrypoints with routes (file-system or config-based) were found');
+        console.log(`📁 Found ${routesEntrypoints.length} entrypoints with routes`);
+        const reports = [];
+        for (const entrypoint of routesEntrypoints)if (entrypoint.nestedRoutesEntry) {
+            const report = await generateInspectReportForEntry(entrypoint, appContext, config, api);
+            reports.push(report);
+        }
+        let finalReport;
+        if (1 === reports.length) finalReport = {
+            routes: reports[0].routes
+        };
+        else {
+            finalReport = {};
+            for (const report of reports)finalReport[report.entryName] = {
+                routes: report.routes
+            };
+        }
+        await fs.ensureDir(distDirectory);
+        const reportPath = path.join(distDirectory, 'routes-inspect.json');
+        await fs.writeJSON(reportPath, finalReport, {
+            spaces: 2
+        });
+        console.log(`\n✨ Route inspection report has been generated: ${reportPath}`);
+        const totalRoutes = reports.reduce((sum, report)=>sum + report.routes.length, 0);
+        console.log(`📊 Found a total of ${totalRoutes} routes across ${reports.length} entrypoints`);
+    } catch (error) {
+        console.error('❌ Failed to generate route inspection report:', error);
+        process.exit(1);
+    }
+}
+export { generateRoutesInspectReport };

package/dist/esm/router/cli/code/makeLegalIdentifier.mjs

@@ -0,0 +1,9 @@
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbidList = new Set(`${reservedWords} ${builtins}`.split(' '));
+function makeLegalIdentifier(str) {
+    const identifier = str.replace(/-(\w)/g, (_, letter)=>letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbidList.has(identifier)) return `_${identifier}`;
+    return identifier || '_';
+}
+export { makeLegalIdentifier };

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

@@ -0,0 +1,193 @@
+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";
+import { getPathWithoutExt, hasAction, replaceWithAlias } from "./utils";
+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 pathWithoutExt = getPathWithoutExt(relativePath);
+    let id = "";
+    id = isMainEntry ? pathWithoutExt : `${entryName}_${pathWithoutExt}`;
+    return id.replace(/\[(.*?)\]/g, '($1)');
+};
+const createIndexRoute = (routeInfo, rootDir, filename, entryName, isMainEntry)=>createRoute({
+        ...routeInfo,
+        index: true,
+        children: void 0,
+        routeType: 'page'
+    }, rootDir, filename, entryName, isMainEntry);
+const createRoute = (routeInfo, rootDir, filename, entryName, isMainEntry)=>{
+    const id = getRouteId(filename, rootDir, entryName, isMainEntry);
+    const hasChildren = routeInfo.children && routeInfo.children.length > 0;
+    return {
+        ...routeInfo,
+        id,
+        type: 'nested',
+        routeType: hasChildren ? 'layout' : 'page',
+        origin: 'file-system',
+        component: routeInfo._component ? filename : void 0
+    };
+};
+const optimizeRoute = (routeTree)=>{
+    if (!routeTree.children || 0 === routeTree.children.length) return [
+        routeTree
+    ];
+    const { children } = routeTree;
+    if (routeTree._component || routeTree.error || routeTree.loading || routeTree.config || routeTree.clientData) {
+        const optimizedChildren = routeTree.children.flatMap(optimizeRoute);
+        return [
+            {
+                ...routeTree,
+                children: optimizedChildren
+            }
+        ];
+    }
+    {
+        const newRoutes = children.map((child)=>{
+            const routePath = routeTree.path ? `${routeTree.path}${child.path ? `/${child.path}` : ''}` : child.path || '';
+            const newRoute = {
+                ...child,
+                path: routePath.replace(/\/\//g, '/'),
+                component: child.component || void 0,
+                origin: 'file-system'
+            };
+            if (routePath.length > 0) delete newRoute.index;
+            else delete newRoute.path;
+            return newRoute;
+        });
+        return Array.from(new Set(newRoutes)).flatMap(optimizeRoute);
+    }
+};
+const walk = async (options)=>{
+    const { dirname, rootDir, alias, entryName, isMainEntry } = 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 lastSegment = pathSegments[pathSegments.length - 1];
+    const isRoot = '' === lastSegment;
+    const isPathlessLayout = lastSegment.startsWith('__');
+    const isWithoutLayoutPath = lastSegment.includes('.');
+    let routePath = isRoot || isPathlessLayout ? '/' : `${lastSegment}`;
+    if (isWithoutLayoutPath) routePath = lastSegment.split('.').join('/');
+    routePath = replaceDynamicPath(routePath);
+    const route = {
+        path: routePath?.replace(/\$$/, '?'),
+        children: [],
+        isRoot,
+        origin: 'file-system'
+    };
+    let pageLoaderFile = '';
+    let pageRoute = null;
+    let pageConfigFile = '';
+    let pageClientData = '';
+    let pageData = '';
+    let pageAction = '';
+    let splatLoaderFile = '';
+    let splatRoute = null;
+    let splatConfigFile = '';
+    let splatClientData = '';
+    let splatData = '';
+    let splatAction = '';
+    const items = await fs.readdir(dirname);
+    for (const item of items){
+        const itemPath = join(dirname, item);
+        const itemPathWithAlias = alias ? getPathWithoutExt(replaceWithAlias(alias.basename, itemPath, alias.name)) : getPathWithoutExt(itemPath);
+        const extname = external_path_extname(item);
+        const itemWithoutExt = item.slice(0, -extname.length);
+        const isDirectory = (await fs.stat(itemPath)).isDirectory();
+        if (isDirectory) {
+            const childRoute = await walk({
+                dirname: itemPath,
+                rootDir,
+                alias,
+                entryName,
+                isMainEntry
+            });
+            if (childRoute && !Array.isArray(childRoute)) route.children?.push(childRoute);
+        }
+        if (!extname || JS_EXTENSIONS.includes(extname) && conventionNames.includes(itemWithoutExt)) {
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_LOADER_FILE) {
+                if (!route.loader) route.loader = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_CLIENT_LOADER) route.clientData = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_DATA_FILE) {
+                route.data = itemPathWithAlias;
+                if (await hasAction(itemPath)) route.action = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_CONFIG_FILE) {
+                if (!route.config) route.config = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_FILE) route._component = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_LOADER_FILE) pageLoaderFile = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_CLIENT_LOADER) pageClientData = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_DATA_FILE) {
+                pageData = itemPathWithAlias;
+                if (await hasAction(itemPath)) pageAction = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_CONFIG_FILE) pageConfigFile = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_FILE) {
+                pageRoute = createIndexRoute({
+                    _component: itemPathWithAlias
+                }, rootDir, itemPath, entryName, isMainEntry);
+                if (pageLoaderFile) pageRoute.loader = pageLoaderFile;
+                if (pageConfigFile) pageRoute.config = pageConfigFile;
+                if (pageData) pageRoute.data = pageData;
+                if (pageClientData) pageRoute.clientData = pageClientData;
+                if (pageAction) pageRoute.action = pageAction;
+                route.children?.unshift(pageRoute);
+            }
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_LOADER_FILE) splatLoaderFile = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_CLIENT_DATA) splatClientData = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_CONFIG_FILE) {
+                if (!route.config) splatConfigFile = alias ? replaceWithAlias(alias.basename, itemPath, alias.name) : getPathWithoutExt(itemPath);
+            }
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_DATA_FILE) {
+                splatData = itemPathWithAlias;
+                if (await hasAction(itemPath)) splatAction = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_FILE) {
+                splatRoute = createRoute({
+                    _component: itemPathWithAlias,
+                    path: '*',
+                    origin: 'file-system'
+                }, rootDir, itemPath, entryName, isMainEntry);
+                if (splatLoaderFile) splatRoute.loader = splatLoaderFile;
+                if (splatClientData) splatRoute.clientData = splatClientData;
+                if (splatData) splatRoute.data = splatData;
+                if (splatConfigFile) splatRoute.config = splatConfigFile;
+                if (splatAction) splatRoute.action = splatAction;
+                route.children?.push(splatRoute);
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LOADING_FILE) route.loading = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.ERROR_FILE) route.error = itemPathWithAlias;
+        }
+    }
+    let finalRoute = createRoute({
+        ...route,
+        origin: 'file-system'
+    }, rootDir, 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;
+    if (childRoutes && 1 === childRoutes.length && !finalRoute._component) {
+        const childRoute = childRoutes[0];
+        if ('*' === childRoute.path) {
+            const path = `${finalRoute.path || ''}/${childRoute.path || ''}`;
+            finalRoute = {
+                ...childRoute,
+                path,
+                component: childRoute.component || void 0
+            };
+        }
+    }
+    if (isRoot && !finalRoute._component) throw new Error('The root layout component is required, make sure the routes/layout.tsx file exists.');
+    if (isRoot) {
+        const optimizedRoutes = optimizeRoute(finalRoute);
+        return optimizedRoutes;
+    }
+    return finalRoute;
+};
+export { getRouteId, optimizeRoute, walk };

package/dist/esm/router/cli/code/templates.mjs

@@ -0,0 +1,365 @@
+import path from "path";
+import { findExists, formatImportPath, fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
+import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
+import { APP_INIT_EXPORTED, TEMP_LOADERS_DIR } from "../constants";
+import { getPathWithoutExt, getServerLoadersFile, parseModule, replaceWithAlias } from "./utils";
+const routesForServer = ({ routesForServerLoaderMatches })=>{
+    const loaders = [];
+    const actions = [];
+    const loadersMap = {};
+    const traverseRouteTree = (route)=>{
+        let children;
+        if ('children' in route && route.children) children = route?.children?.map(traverseRouteTree);
+        let loader;
+        let action;
+        if ('nested' === route.type) {
+            if (route.loader || route.data) {
+                loaders.push(route.loader);
+                const loaderId = loaders.length - 1;
+                loader = `loader_${loaderId}`;
+                const inline = Boolean(route.data);
+                loadersMap[loader] = {
+                    loaderId,
+                    routeId: route.id,
+                    filePath: route.data || route.loader,
+                    clientData: Boolean(route.clientData),
+                    route,
+                    inline
+                };
+                if (route.action) {
+                    actions.push(route.action);
+                    action = `action_${loaders.length - 1}`;
+                }
+            }
+        }
+        const finalRoute = {
+            ...route,
+            loader,
+            action,
+            children
+        };
+        return finalRoute;
+    };
+    let routesCode = `
+  export const routes = [
+  `;
+    for(let i = 0; i < routesForServerLoaderMatches.length; i++){
+        const route = routesForServerLoaderMatches[i];
+        if ('type' in route) {
+            const keywords = [
+                'loader',
+                'action'
+            ];
+            const regs = keywords.map(createMatchReg);
+            const newRoute = traverseRouteTree(route);
+            const routeStr = JSON.stringify(newRoute, null, 2);
+            routesCode += regs.reduce((acc, reg)=>acc.replace(reg, '$1$2'), routeStr).replace(/\\"/g, '"');
+        } else routesCode += `${JSON.stringify(route, null, 2)}`;
+        if (i < routesForServerLoaderMatches.length - 1) routesCode += ',';
+    }
+    routesCode += `\n];`;
+    let importLoadersCode = '';
+    for (const [key, loaderInfo] of Object.entries(loadersMap))if (loaderInfo.inline) {
+        const { route } = loaderInfo;
+        if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${slash(loaderInfo.filePath)}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${slash(loaderInfo.filePath)}";\n`;
+    } else importLoadersCode += `import ${key} from "${slash(loaderInfo.filePath)}";\n`;
+    return `
+    ${importLoadersCode}
+    ${routesCode}
+  `;
+};
+const createMatchReg = (keyword)=>new RegExp(`("${keyword}":\\s)"([^\n]+)"`, 'g');
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClient = false })=>{
+    const components = [];
+    const loadings = [];
+    const errors = [];
+    const loaders = [];
+    const loadersMap = {};
+    const configs = [];
+    const configsMap = {};
+    const loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'map.json');
+    const importLazyCode = `
+    import { lazy } from "react";
+    import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
+  `;
+    let rootLayoutCode = "";
+    const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute })=>{
+        if (!ssrMode) return '';
+        const clientDataStr = clientData ? `&clientData=${clientData}` : '';
+        const retain = inValidSSRRoute ?? false;
+        if (nestedRoutesEntry) return `?loaderId=${loaderId}${clientDataStr}&action=${action ? slash(action) : action}&inline=${inline}&routeId=${routeId}&retain=${retain}`;
+        return '';
+    };
+    const createLazyImport = ({ componentPath, routeId, webpackChunkName, eager })=>{
+        const importOptions = webpackChunkName ? `/* webpackChunkName: "${routeId}" */  ` : eager ? '/* webpackMode: "eager" */  ' : '';
+        return `() => import(${importOptions}'${componentPath}').then(routeModule => handleRouteModule(routeModule, "${routeId}")).catch(handleRouteModuleError)`;
+    };
+    const traverseRouteTree = (route, isRscClient)=>{
+        let children;
+        if ('children' in route && route.children) children = route?.children?.map((child)=>traverseRouteTree(child, isRscClient));
+        let loading;
+        let error;
+        let loader;
+        let action;
+        let config;
+        let component = '';
+        let lazyImport = null;
+        if ('nested' === route.type) {
+            if (route.loading) {
+                loadings.push(route.loading);
+                loading = `loading_${loadings.length - 1}`;
+            }
+            if (route.error) {
+                errors.push(route.error);
+                error = `error_${errors.length - 1}`;
+            }
+            if (route.loader || route.data) {
+                loaders.push(route.loader);
+                const loaderId = loaders.length - 1;
+                loader = `loader_${loaderId}`;
+                const inline = Boolean(route.data);
+                loadersMap[loader] = {
+                    loaderId,
+                    routeId: route.id,
+                    inValidSSRRoute: route.inValidSSRRoute,
+                    filePath: route.data || route.loader,
+                    clientData: Boolean(route.clientData),
+                    route,
+                    inline
+                };
+                loader = `loader_${loaderId}`;
+                if (route.action) action = `action_${loaderId}`;
+            }
+            if ('string' == typeof route.config) {
+                configs.push(route.config);
+                const configId = configs.length - 1;
+                config = `config_${configId}`;
+                configsMap[config] = route.config;
+            }
+            if (route._component) if (route.isRoot) {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id
+                });
+                rootLayoutCode = `import RootLayout from '${route._component}'`;
+                component = 'RootLayout';
+            } else if (splitRouteChunks) {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id,
+                    webpackChunkName: true
+                });
+                component = 'string' === ssrMode ? `loadable(${lazyImport})` : `lazy(${lazyImport})`;
+            } else if ('string' === ssrMode) {
+                components.push(route._component);
+                component = `component_${components.length - 1}`;
+            } else {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id,
+                    eager: true
+                });
+                component = `lazy(${lazyImport})`;
+            }
+        } else if (route._component) if (splitRouteChunks) {
+            lazyImport = `() => import('${route._component}')`;
+            component = `loadable(${lazyImport})`;
+        } else {
+            components.push(route._component);
+            component = `component_${components.length - 1}`;
+        }
+        const finalRoute = {
+            ...route,
+            loading,
+            loader,
+            action,
+            config,
+            error,
+            children
+        };
+        if (!isRscClient) finalRoute.lazyImport = lazyImport;
+        if (route._component && !isRscClient) finalRoute.component = component;
+        if ('nested' === route.type && route._component && (route.loader || route.data)) finalRoute.shouldRevalidate = `createShouldRevalidate("${route.id}")`;
+        return finalRoute;
+    };
+    let routeComponentsCode = `
+    export const routes = [
+  `;
+    for (const route of routes)if ('type' in route) {
+        const newRoute = traverseRouteTree(route, isRscClient);
+        const routeStr = JSON.stringify(newRoute, null, 2);
+        const keywords = [
+            'component',
+            'lazyImport',
+            'shouldRevalidate',
+            'loader',
+            'action',
+            'loading',
+            'error',
+            'config'
+        ];
+        const regs = keywords.map(createMatchReg);
+        const newRouteStr = regs.reduce((acc, reg)=>acc.replace(reg, '$1$2'), routeStr).replace(/"(RootLayout)"/g, '$1').replace(/\\"/g, '"');
+        routeComponentsCode += `${newRouteStr},`;
+    } else {
+        const component = `loadable(() => import('${route._component}'))`;
+        const finalRoute = {
+            ...route,
+            component
+        };
+        const keywords = [
+            'component',
+            'lazyImport'
+        ];
+        const routeStr = JSON.stringify(finalRoute, null, 2);
+        const regs = keywords.map(createMatchReg);
+        const newRouteStr = regs.reduce((acc, reg)=>acc.replace(reg, '$1$2'), routeStr).replace(/\\"/g, '"');
+        routeComponentsCode += `${newRouteStr},`;
+    }
+    routeComponentsCode += `\n];`;
+    const importLoadingCode = loadings.map((loading, index)=>`import loading_${index} from '${loading}';\n`).join('');
+    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 { route } = loaderInfo;
+        if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
+            loaderId: key,
+            clientData: loaderInfo.clientData,
+            action: route.action,
+            inline: loaderInfo.inline,
+            routeId: loaderInfo.routeId,
+            inValidSSRRoute: loaderInfo.inValidSSRRoute
+        })}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${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 "${slash(loaderInfo.filePath)}${getDataLoaderPath({
+        loaderId: key,
+        clientData: loaderInfo.clientData,
+        action: false,
+        inline: loaderInfo.inline,
+        routeId: loaderInfo.routeId,
+        inValidSSRRoute: loaderInfo.inValidSSRRoute
+    })}";\n`;
+    let importConfigsCode = '';
+    for (const [key, configPath] of Object.entries(configsMap))importConfigsCode += `import * as ${key} from "${slash(configPath)}";\n`;
+    await fs.ensureFile(loadersMapFile);
+    await fs.writeJSON(loadersMapFile, loadersMap);
+    const importRuntimeRouterCode = `
+    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@${metaName}/runtime/routerHelper';
+  `;
+    const routeModulesCode = `
+    if(typeof document !== 'undefined'){
+      window.${ROUTE_MODULES} = {}
+    }
+  `;
+    return `
+    ${importLazyCode}
+    ${!isRscClient ? importComponentsCode : ''}
+    ${importRuntimeRouterCode}
+    ${!isRscClient ? rootLayoutCode : ''}
+    ${importLoadingCode}
+    ${importErrorComponentsCode}
+    ${importLoadersCode}
+    ${importConfigsCode}
+    ${routeModulesCode}
+    ${routeComponentsCode}
+  `;
+};
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+    const { entryName, isMainEntry } = entrypoint;
+    const { packageName, internalDirectory } = appContext;
+    const ssr = getEntryOptions(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
+    const ssg = isSSGEntry(config, entryName, entrypoints);
+    if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
+        const serverLoaderRuntime = require.resolve('@modern-js/plugin-data-loader/runtime');
+        const serverLoadersFile = getServerLoadersFile(internalDirectory, entryName);
+        const combinedModule = `export * from "${slash(serverLoaderRuntime)}"; export * from "${slash(serverLoadersFile)}"`;
+        if (!config.source.enableAsyncEntry) return combinedModule;
+        return `
+    async function loadModules() {
+      const [moduleA, moduleB] = await Promise.all([
+        import("${slash(serverLoaderRuntime)}"),
+        import("${slash(serverLoadersFile)}")
+      ]);
+
+      return {
+        ...moduleA,
+        ...moduleB
+      };
+    }
+
+    export { loadModules };
+    `;
+    }
+    return null;
+}
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, basename })=>{
+    const imports = [
+        `import { setGlobalContext } from '@${metaName}/runtime/context';`
+    ];
+    if (nestedRoutesEntry) {
+        const rootLayoutPath = path.join(nestedRoutesEntry, 'layout');
+        const rootLayoutFile = findExists([
+            '.js',
+            '.ts',
+            '.jsx',
+            '.tsx'
+        ].map((ext)=>`${rootLayoutPath}${ext}`));
+        if (rootLayoutFile) {
+            const rootLayoutBuffer = await fs.readFile(rootLayoutFile);
+            const rootLayout = rootLayoutBuffer.toString();
+            const [, moduleExports] = await parseModule({
+                source: rootLayout.toString(),
+                filename: rootLayoutFile
+            });
+            const hasAppInit = moduleExports.some((e)=>e.n === APP_INIT_EXPORTED);
+            const layoutPath = formatImportPath(getPathWithoutExt(replaceWithAlias(srcDirectory, rootLayoutFile, internalSrcAlias)));
+            if (hasAppInit) imports.push(`import { init as appInit } from '${layoutPath}';`);
+            else imports.push("let appInit;");
+        } else imports.push("let appInit;");
+    } else imports.push("let appInit;");
+    if (globalApp) imports.push(`import layoutApp from '${formatImportPath(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
+    else imports.push("let layoutApp;");
+    const isClient = 'client' === rscType;
+    const enableRsc = Boolean(rscType);
+    if (isClient) return `${imports.join('\n')}
+
+    import { routes } from './routes';
+
+    const entryName = '${entryName}';
+    const basename = '${basename || '/'}';
+      setGlobalContext({
+        entryName,
+        layoutApp,
+        routes,
+        appInit,
+        basename,
+        isRscClient: true,
+        enableRsc: true,
+      });
+    `;
+    return `${imports.join('\n')}
+
+    import { routes } from './routes';
+
+    const entryName = '${entryName}';
+    const basename = '${basename || '/'}';
+      setGlobalContext({
+        entryName,
+        layoutApp,
+        routes,
+        appInit,
+        basename,
+        enableRsc: ${enableRsc},
+      });
+    `;
+};
+export { fileSystemRoutes, routesForServer, runtimeGlobalContext, ssrLoaderCombinedModule };