@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

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

@@ -0,0 +1,115 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_INDEX } from "../../constants.mjs";
+import { makeLegalIdentifier } from "../makeLegalIdentifier.mjs";
+import { replaceWithAlias } from "../utils.mjs";
+import { debug, getRouteWeight, shouldSkip } from "./utils.mjs";
+const compName = (srcDirectory, filePath)=>{
+    const legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+    return `Comp_${legalCompName}`;
+};
+const layoutNameAbbr = (filePath)=>{
+    const prefix = 'L_';
+    const dirName = path.dirname(filePath).split('/').pop() || '';
+    return `${prefix}${makeLegalIdentifier(dirName)}`;
+};
+const parents = [];
+const recursiveReadDir = ({ dir, routes, basePath = '/', srcDirectory, srcAlias })=>{
+    let hasDynamicRoute = false;
+    const resetParent = false;
+    const parent = parents[parents.length - 1];
+    for (const relative of fs.readdirSync(dir)){
+        const filePath = path.join(dir, relative);
+        if (!shouldSkip(filePath)) {
+            const filename = path.basename(filePath, path.extname(filePath));
+            const alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+            const componentName = compName(srcDirectory, filePath);
+            const dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+            if (dynamicRouteMatched) if (hasDynamicRoute) throw new Error(`Can't set two dynamic route in one directory: ${dir}`);
+            else hasDynamicRoute = true;
+            const route = {
+                path: `${basePath}${dynamicRouteMatched ? `:${dynamicRouteMatched[1].replace(/\$$/, '?')}${dynamicRouteMatched[2]}` : filename}`,
+                _component: alias,
+                component: componentName,
+                parent,
+                type: 'page'
+            };
+            if (fs.statSync(filePath).isDirectory()) {
+                recursiveReadDir({
+                    dir: filePath,
+                    routes,
+                    basePath: `${route.path}/`,
+                    srcDirectory,
+                    srcAlias
+                });
+                continue;
+            }
+            if (filename === FILE_SYSTEM_ROUTES_INDEX) route.path = '/' === basePath ? basePath : `${basePath.substring(0, basePath.length - 1)}`;
+            if ('404' === filename && '/' === basePath) route.path = '*';
+            routes.push(route);
+        }
+    }
+    if (resetParent) parents.pop();
+};
+const normalizeNestedRoutes = (nested, internalComponentsDir, internalDirectory, internalDirAlias)=>{
+    const flat = (routes)=>routes.reduce((memo, route)=>memo.concat(Array.isArray(route.children) ? flat(route.children) : [
+                route
+            ]), []);
+    const generate = (route)=>{
+        const codes = [];
+        let lastComponent = route.component;
+        const imports = [
+            "import React from 'react';",
+            `import ${lastComponent} from '${route._component}'`
+        ];
+        while(route = route.parent){
+            const layoutComponent = route.component;
+            const layoutComponentAbbr = layoutNameAbbr(route._component);
+            imports.push(`import ${layoutComponent} from '${route._component}';`);
+            const currentComponent = `${layoutComponentAbbr}_${lastComponent}`;
+            codes.push(`const ${currentComponent} = props => <${layoutComponent} Component={${lastComponent}} {...props} />;`);
+            lastComponent = currentComponent;
+        }
+        const file = path.resolve(internalComponentsDir, `${lastComponent}.jsx`);
+        fs.outputFileSync(file, `${imports.join('\n')}\n${codes.join('\n')}\nexport default ${lastComponent}`);
+        return {
+            component: lastComponent,
+            _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+        };
+    };
+    const normalized = flat(nested).map((route)=>route.parent ? {
+            ...route,
+            ...generate(route),
+            parent: void 0
+        } : {
+            ...route,
+            parent: void 0
+        });
+    return normalized;
+};
+const getClientRoutes = ({ entrypoint, srcDirectory, srcAlias, internalDirectory, internalDirAlias })=>{
+    const { entryName, pageRoutesEntry } = entrypoint;
+    if (!pageRoutesEntry) return [];
+    if (!fs.existsSync(pageRoutesEntry)) throw new Error(`generate file system routes error, ${pageRoutesEntry} directory not found.`);
+    if (!(fs.existsSync(pageRoutesEntry) && fs.statSync(pageRoutesEntry).isDirectory())) throw new Error(`generate file system routes error, ${pageRoutesEntry} should be directory.`);
+    let routes = [];
+    recursiveReadDir({
+        dir: pageRoutesEntry,
+        routes,
+        basePath: '/',
+        srcDirectory,
+        srcAlias
+    });
+    const internalComponentsDir = path.resolve(internalDirectory, `${entryName}/${FILE_SYSTEM_ROUTES_COMPONENTS_DIR}`);
+    fs.emptyDirSync(internalComponentsDir);
+    routes = normalizeNestedRoutes(routes, internalComponentsDir, internalDirectory, internalDirAlias);
+    parents.length = 0;
+    routes.sort((a, b)=>{
+        const delta = getRouteWeight(a.path) - getRouteWeight(b.path);
+        if (0 === delta) return a.path.length - b.path.length;
+        return delta;
+    });
+    debug("fileSystem routes: %o", routes);
+    return routes;
+};
+export { getClientRoutes };

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

@@ -0,0 +1,2 @@
+import { getClientRoutes } from "./getRoutes.mjs";
+export { getClientRoutes };

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

@@ -0,0 +1,12 @@
+import path from "path";
+import { JS_EXTENSIONS, createDebugger, fs } from "@modern-js/utils";
+import { FILE_SYSTEM_ROUTES_IGNORED_REGEX } from "../../constants.mjs";
+const debug = createDebugger('get-client-routes');
+const getRouteWeight = (route)=>'*' === route ? 999 : route.split(':').length - 1;
+const shouldSkip = (file)=>{
+    if (fs.statSync(file).isDirectory()) return false;
+    const ext = path.extname(file);
+    if (FILE_SYSTEM_ROUTES_IGNORED_REGEX.test(file) || !JS_EXTENSIONS.includes(ext)) return true;
+    return false;
+};
+export { debug, getRouteWeight, shouldSkip };

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

@@ -0,0 +1,132 @@
+import path from "path";
+import { filterRoutesForServer, filterRoutesLoader, fs, getEntryOptions, isUseRsc, isUseSSRBundle, logger, markRoutes } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME } from "../../../cli/constants.mjs";
+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 { getServerCombinedModueFile, getServerLoadersFile } from "./utils.mjs";
+async function generateRoutesForEntry(entrypoint, appContext) {
+    const routes = [];
+    if (entrypoint.nestedRoutesEntry) {
+        const nestedRoutes = await walk({
+            dirname: entrypoint.nestedRoutesEntry,
+            rootDir: entrypoint.nestedRoutesEntry,
+            alias: {
+                name: appContext.internalSrcAlias,
+                basename: appContext.srcDirectory
+            },
+            entryName: entrypoint.entryName,
+            isMainEntry: entrypoint.isMainEntry
+        });
+        if (nestedRoutes) if (Array.isArray(nestedRoutes)) routes.push(...nestedRoutes);
+        else routes.push(nestedRoutes);
+    }
+    const fileRoutes = routes.length > 0 ? Array.isArray(routes) ? routes : [
+        routes
+    ] : [];
+    const { discoverAndParseConfigRoutes } = await import("../config-routes/parseRouteConfig.mjs");
+    const configRoutesData = await discoverAndParseConfigRoutes(entrypoint, appContext, fileRoutes);
+    if (configRoutesData) {
+        const { processConfigRoutes } = await import("../config-routes/converter.mjs");
+        const processedConfigRoutes = await processConfigRoutes(configRoutesData.routes, entrypoint.entryName, entrypoint.isMainEntry || false, path.dirname(configRoutesData.filePath), {
+            name: appContext.internalSrcAlias,
+            basename: appContext.srcDirectory
+        });
+        routes.length = 0;
+        routes.push(...processedConfigRoutes);
+    }
+    return routes;
+}
+const generateCode = async (appContext, config, entrypoints, api)=>{
+    const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
+    const hooks = api.getHooks();
+    await Promise.all(entrypoints.map(generateEntryCode));
+    async function generateEntryCode(entrypoint) {
+        const { entryName, isMainEntry, isAutoMount, pageRoutesEntry, nestedRoutesEntry } = entrypoint;
+        const { metaName } = api.getAppContext();
+        if (isAutoMount) {
+            const config = api.getNormalizedConfig();
+            getEntryOptions(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
+            const ssrMode = resolveSSRMode({
+                entry: entrypoint.entryName,
+                config,
+                appDirectory: appContext.appDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry
+            });
+            if (!nestedRoutesEntry && ssrMode && 'string' !== ssrMode && !isUseRsc(config)) {
+                logger.error('Streaming SSR is only supported for convention-based routing (nested routes). Please set `server.ssr.mode` to `"string"` for non-convention-based routing projects.');
+                process.exit(1);
+            }
+            if (pageRoutesEntry || nestedRoutesEntry) {
+                const initialRoutes = [];
+                const generatedRoutes = await generateRoutesForEntry(entrypoint, appContext);
+                const { normalizeRoutes: removeComponentFields } = await import("../config-routes/converter.mjs");
+                const normalizedRoutes = removeComponentFields(generatedRoutes);
+                for (const route of normalizedRoutes)initialRoutes.unshift(route);
+                const ssrByRouteIds = config.server.ssrByRouteIds || [];
+                const clonedRoutes = cloneDeep(initialRoutes);
+                const markedRoutes = ssrByRouteIds.length > 0 ? markRoutes(clonedRoutes, ssrByRouteIds) : initialRoutes;
+                const { routes } = await hooks.modifyFileSystemRoutes.call({
+                    entrypoint,
+                    routes: markedRoutes
+                });
+                if ('stream' === ssrMode) {
+                    const hasPageRoute = routes.some((route)=>'type' in route && 'page' === route.type);
+                    if (hasPageRoute) {
+                        logger.error('Streaming ssr is not supported when pages dir exists');
+                        process.exit(1);
+                    }
+                }
+                const { code } = await hooks.onBeforeGenerateRoutes.call({
+                    entrypoint,
+                    code: await fileSystemRoutes({
+                        metaName,
+                        routes: routes,
+                        ssrMode: isUseRsc(config) ? 'stream' : ssrMode,
+                        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                        entryName: entrypoint.entryName,
+                        internalDirectory,
+                        splitRouteChunks: config?.output?.splitRouteChunks,
+                        isRscClient: isUseRsc(config)
+                    })
+                });
+                if (entrypoint.nestedRoutesEntry && (isUseSSRBundle(config) || isUseRsc(config))) {
+                    const routesServerFile = getServerLoadersFile(internalDirectory, entryName);
+                    const filtedRoutesForServer = filterRoutesForServer(routes);
+                    const routesForServerLoaderMatches = filterRoutesLoader(routes);
+                    const code = routesForServer({
+                        routesForServerLoaderMatches
+                    });
+                    await fs.ensureFile(routesServerFile);
+                    await fs.writeFile(routesServerFile, code);
+                    const serverRoutesCode = await fileSystemRoutes({
+                        metaName,
+                        routes: filtedRoutesForServer,
+                        ssrMode,
+                        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                        entryName: entrypoint.entryName,
+                        internalDirectory,
+                        splitRouteChunks: config?.output?.splitRouteChunks,
+                        isRscClient: false
+                    });
+                    await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, 'utf8');
+                }
+                const serverLoaderCombined = ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                if (serverLoaderCombined) {
+                    const serverLoaderFile = getServerCombinedModueFile(internalDirectory, entryName);
+                    await fs.outputFile(serverLoaderFile, serverLoaderCombined);
+                }
+                await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
+            }
+        }
+    }
+};
+function generatorRegisterCode(internalDirectory, entryName, code) {
+    fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`), code, 'utf8');
+}
+function generatorServerRegisterCode(internalDirectory, entryName, code) {
+    fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`), code, 'utf8');
+}
+export { generateCode, generateRoutesForEntry, generatorRegisterCode, generatorServerRegisterCode };

package/dist/esm-node/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.mjs";
+import { generateRoutesForEntry } from "./index.mjs";
+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-node/router/cli/code/{makeLegalIdentifier.js → makeLegalIdentifier.mjs}

@@ -1,13 +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(" "));
+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 || "_";
+    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
-};
+export { makeLegalIdentifier };

package/dist/esm-node/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.mjs";
+import { getPathWithoutExt, hasAction, replaceWithAlias } from "./utils.mjs";
+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 };