@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

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

@@ -0,0 +1,116 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+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 "node:module";
+export { getClientRoutes } from "./getRoutes.mjs";

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

@@ -0,0 +1,13 @@
+import "node:module";
+import { JS_EXTENSIONS, createDebugger, fs } from "@modern-js/utils";
+import path from "path";
+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,186 @@
+import "node:module";
+import { filterRoutesForServer, filterRoutesLoader, fs, getEntryOptions, isUseRsc, isUseSSRBundle, logger, markRoutes } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import path from "path";
+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 { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled } from "./tanstackTypes.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) {
+        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, options)=>{
+    const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
+    const hooks = api.getHooks();
+    const enableTanstackTypes = options?.enableTanstackTypes ?? await isTanstackRouterFrameworkEnabled(appContext);
+    const generatedRoutesByEntry = {};
+    await Promise.all(entrypoints.map(generateEntryCode));
+    if (enableTanstackTypes) {
+        const allEntries = Array.from(new Set(entrypoints.map((e)=>e.entryName).filter(Boolean)));
+        const mainEntry = entrypoints.find((e)=>e.isMainEntry)?.entryName;
+        const registerEntries = allEntries.sort((a, b)=>{
+            if (mainEntry && a === mainEntry) return -1;
+            if (mainEntry && b === mainEntry) return 1;
+            return a.localeCompare(b);
+        });
+        if (registerEntries.length > 0) {
+            const registerDtsPath = path.join(srcDirectory, 'modern-tanstack', 'register.gen.d.ts');
+            const importStatements = registerEntries.map((entryName, index)=>`import type { router as router${index} } from './${entryName}/router.gen';`).join('\n');
+            const routerUnionType = registerEntries.map((_, index)=>`typeof router${index}`).join(' | ');
+            const registerContent = `// This file is auto-generated by Modern.js. Do not edit manually.
+
+${importStatements}
+
+declare module '@modern-js/runtime/tanstack-router' {
+  interface Register {
+    router: ${routerUnionType};
+  }
+}
+`;
+            try {
+                const prev = await fs.pathExists(registerDtsPath) ? await fs.readFile(registerDtsPath, 'utf-8') : null;
+                if (prev !== registerContent) await fs.outputFile(registerDtsPath, registerContent, 'utf-8');
+            } catch  {
+                await fs.outputFile(registerDtsPath, registerContent, 'utf-8');
+            }
+        }
+    }
+    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
+                });
+                generatedRoutesByEntry[entryName] = routes;
+                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 __rspack_external__templates_mjs_4da4c6c8.fileSystemRoutes({
+                        metaName,
+                        routes: routes,
+                        ssrMode: isUseRsc(config) ? 'stream' : ssrMode,
+                        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                        entryName: entrypoint.entryName,
+                        internalDirectory,
+                        splitRouteChunks: config?.output?.splitRouteChunks,
+                        isRscClientBundle: isUseRsc(config),
+                        srcDirectory,
+                        internalSrcAlias: appContext.internalSrcAlias
+                    })
+                });
+                if (entrypoint.nestedRoutesEntry && (isUseSSRBundle(config) || isUseRsc(config))) {
+                    const routesServerFile = getServerLoadersFile(internalDirectory, entryName);
+                    const filtedRoutesForServer = filterRoutesForServer(routes);
+                    const routesForServerLoaderMatches = filterRoutesLoader(routes);
+                    const code = __rspack_external__templates_mjs_4da4c6c8.routesForServer({
+                        routesForServerLoaderMatches
+                    });
+                    await fs.ensureFile(routesServerFile);
+                    await fs.writeFile(routesServerFile, code);
+                    const serverRoutesCode = await __rspack_external__templates_mjs_4da4c6c8.fileSystemRoutes({
+                        metaName,
+                        routes: filtedRoutesForServer,
+                        ssrMode,
+                        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                        entryName: entrypoint.entryName,
+                        internalDirectory,
+                        splitRouteChunks: config?.output?.splitRouteChunks,
+                        isRscClientBundle: false,
+                        srcDirectory,
+                        internalSrcAlias: appContext.internalSrcAlias
+                    });
+                    await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, 'utf8');
+                }
+                const serverLoaderCombined = __rspack_external__templates_mjs_4da4c6c8.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                if (serverLoaderCombined) {
+                    const serverLoaderFile = getServerCombinedModuleFile(internalDirectory, entryName);
+                    await fs.outputFile(serverLoaderFile, serverLoaderCombined);
+                }
+                await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
+                if (enableTanstackTypes) {
+                    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+                        appContext,
+                        entryName,
+                        routes: routes
+                    });
+                    const outPath = path.join(srcDirectory, 'modern-tanstack', entryName, 'router.gen.ts');
+                    try {
+                        const prev = await fs.pathExists(outPath) ? await fs.readFile(outPath, 'utf-8') : null;
+                        if (prev !== routerGenTs) await fs.outputFile(outPath, routerGenTs, 'utf-8');
+                    } catch  {
+                        await fs.outputFile(outPath, routerGenTs, 'utf-8');
+                    }
+                }
+            }
+        }
+    }
+    return generatedRoutesByEntry;
+};
+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,96 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import path from "path";
+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.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+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-node/router/cli/code/nestedRoutes.mjs

@@ -0,0 +1,194 @@
+import "node:module";
+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(__rspack_external_path.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 = __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('__');
+    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 = __rspack_external_path.join(dirname, item);
+        const itemPathWithAlias = alias ? getPathWithoutExt(replaceWithAlias(alias.basename, itemPath, alias.name)) : getPathWithoutExt(itemPath);
+        const extname = __rspack_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, __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;
+    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 };