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

package/dist/cjs/router/cli/code/getClientRoutes/getRoutes.js

@@ -0,0 +1,159 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getClientRoutes: ()=>getClientRoutes
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("../../constants.js");
+const external_makeLegalIdentifier_js_namespaceObject = require("../makeLegalIdentifier.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const external_utils_js_namespaceObject_1 = require("./utils.js");
+const compName = (srcDirectory, filePath)=>{
+    const legalCompName = (0, external_makeLegalIdentifier_js_namespaceObject.makeLegalIdentifier)(external_path_default().relative(srcDirectory, filePath));
+    return `Comp_${legalCompName}`;
+};
+const layoutNameAbbr = (filePath)=>{
+    const prefix = 'L_';
+    const dirName = external_path_default().dirname(filePath).split('/').pop() || '';
+    return `${prefix}${(0, external_makeLegalIdentifier_js_namespaceObject.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 utils_namespaceObject.fs.readdirSync(dir)){
+        const filePath = external_path_default().join(dir, relative);
+        if (!(0, external_utils_js_namespaceObject_1.shouldSkip)(filePath)) {
+            const filename = external_path_default().basename(filePath, external_path_default().extname(filePath));
+            const alias = (0, external_utils_js_namespaceObject.replaceWithAlias)(srcDirectory, filePath, srcAlias);
+            const componentName = compName(srcDirectory, filePath);
+            const dynamicRouteMatched = external_constants_js_namespaceObject.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 (utils_namespaceObject.fs.statSync(filePath).isDirectory()) {
+                recursiveReadDir({
+                    dir: filePath,
+                    routes,
+                    basePath: `${route.path}/`,
+                    srcDirectory,
+                    srcAlias
+                });
+                continue;
+            }
+            if (filename === external_constants_js_namespaceObject.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 = external_path_default().resolve(internalComponentsDir, `${lastComponent}.jsx`);
+        utils_namespaceObject.fs.outputFileSync(file, `${imports.join('\n')}\n${codes.join('\n')}\nexport default ${lastComponent}`);
+        return {
+            component: lastComponent,
+            _component: (0, external_utils_js_namespaceObject.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 (!utils_namespaceObject.fs.existsSync(pageRoutesEntry)) throw new Error(`generate file system routes error, ${pageRoutesEntry} directory not found.`);
+    if (!(utils_namespaceObject.fs.existsSync(pageRoutesEntry) && utils_namespaceObject.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 = external_path_default().resolve(internalDirectory, `${entryName}/${external_constants_js_namespaceObject.FILE_SYSTEM_ROUTES_COMPONENTS_DIR}`);
+    utils_namespaceObject.fs.emptyDirSync(internalComponentsDir);
+    routes = normalizeNestedRoutes(routes, internalComponentsDir, internalDirectory, internalDirAlias);
+    parents.length = 0;
+    routes.sort((a, b)=>{
+        const delta = (0, external_utils_js_namespaceObject_1.getRouteWeight)(a.path) - (0, external_utils_js_namespaceObject_1.getRouteWeight)(b.path);
+        if (0 === delta) return a.path.length - b.path.length;
+        return delta;
+    });
+    (0, external_utils_js_namespaceObject_1.debug)("fileSystem routes: %o", routes);
+    return routes;
+};
+exports.getClientRoutes = __webpack_exports__.getClientRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getClientRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getClientRoutes: ()=>external_getRoutes_js_namespaceObject.getClientRoutes
+});
+const external_getRoutes_js_namespaceObject = require("./getRoutes.js");
+exports.getClientRoutes = __webpack_exports__.getClientRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getClientRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/code/getClientRoutes/utils.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    debug: ()=>debug,
+    getRouteWeight: ()=>getRouteWeight,
+    shouldSkip: ()=>shouldSkip
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("../../constants.js");
+const debug = (0, utils_namespaceObject.createDebugger)('get-client-routes');
+const getRouteWeight = (route)=>'*' === route ? 999 : route.split(':').length - 1;
+const shouldSkip = (file)=>{
+    if (utils_namespaceObject.fs.statSync(file).isDirectory()) return false;
+    const ext = external_path_default().extname(file);
+    if (external_constants_js_namespaceObject.FILE_SYSTEM_ROUTES_IGNORED_REGEX.test(file) || !utils_namespaceObject.JS_EXTENSIONS.includes(ext)) return true;
+    return false;
+};
+exports.debug = __webpack_exports__.debug;
+exports.getRouteWeight = __webpack_exports__.getRouteWeight;
+exports.shouldSkip = __webpack_exports__.shouldSkip;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "debug",
+    "getRouteWeight",
+    "shouldSkip"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,238 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    generateCode: ()=>generateCode,
+    generateRoutesForEntry: ()=>generateRoutesForEntry,
+    generatorRegisterCode: ()=>generatorRegisterCode,
+    generatorServerRegisterCode: ()=>generatorServerRegisterCode
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const constants_js_namespaceObject = require("../../../cli/constants.js");
+const mode_js_namespaceObject = require("../../../cli/ssr/mode.js");
+const external_constants_js_namespaceObject = require("../constants.js");
+const external_nestedRoutes_js_namespaceObject = require("./nestedRoutes.js");
+const external_tanstackTypes_js_namespaceObject = require("./tanstackTypes.js");
+const external_templates_js_namespaceObject = require("./templates.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+async function generateRoutesForEntry(entrypoint, appContext) {
+    const routes = [];
+    if (entrypoint.nestedRoutesEntry) {
+        const nestedRoutes = await (0, external_nestedRoutes_js_namespaceObject.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.js");
+    const configRoutesData = await discoverAndParseConfigRoutes(entrypoint, appContext, fileRoutes);
+    if (configRoutesData) {
+        const { processConfigRoutes } = await import("../config-routes/converter.js");
+        const processedConfigRoutes = await processConfigRoutes(configRoutesData.routes, entrypoint.entryName, entrypoint.isMainEntry || false, external_path_default().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 (0, external_tanstackTypes_js_namespaceObject.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 = external_path_default().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 utils_namespaceObject.fs.pathExists(registerDtsPath) ? await utils_namespaceObject.fs.readFile(registerDtsPath, 'utf-8') : null;
+                if (prev !== registerContent) await utils_namespaceObject.fs.outputFile(registerDtsPath, registerContent, 'utf-8');
+            } catch  {
+                await utils_namespaceObject.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();
+            (0, utils_namespaceObject.getEntryOptions)(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
+            const ssrMode = (0, mode_js_namespaceObject.resolveSSRMode)({
+                entry: entrypoint.entryName,
+                config,
+                appDirectory: appContext.appDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry
+            });
+            if (!nestedRoutesEntry && ssrMode && 'string' !== ssrMode && !(0, utils_namespaceObject.isUseRsc)(config)) {
+                utils_namespaceObject.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.js");
+                const normalizedRoutes = removeComponentFields(generatedRoutes);
+                for (const route of normalizedRoutes)initialRoutes.unshift(route);
+                const ssrByRouteIds = config.server.ssrByRouteIds || [];
+                const clonedRoutes = (0, lodash_namespaceObject.cloneDeep)(initialRoutes);
+                const markedRoutes = ssrByRouteIds.length > 0 ? (0, utils_namespaceObject.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) {
+                        utils_namespaceObject.logger.error('Streaming ssr is not supported when pages dir exists');
+                        process.exit(1);
+                    }
+                }
+                const { code } = await hooks.onBeforeGenerateRoutes.call({
+                    entrypoint,
+                    code: await external_templates_js_namespaceObject.fileSystemRoutes({
+                        metaName,
+                        routes: routes,
+                        ssrMode: (0, utils_namespaceObject.isUseRsc)(config) ? 'stream' : ssrMode,
+                        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                        entryName: entrypoint.entryName,
+                        internalDirectory,
+                        splitRouteChunks: config?.output?.splitRouteChunks,
+                        isRscClientBundle: (0, utils_namespaceObject.isUseRsc)(config),
+                        srcDirectory,
+                        internalSrcAlias: appContext.internalSrcAlias
+                    })
+                });
+                if (entrypoint.nestedRoutesEntry && ((0, utils_namespaceObject.isUseSSRBundle)(config) || (0, utils_namespaceObject.isUseRsc)(config))) {
+                    const routesServerFile = (0, external_utils_js_namespaceObject.getServerLoadersFile)(internalDirectory, entryName);
+                    const filtedRoutesForServer = (0, utils_namespaceObject.filterRoutesForServer)(routes);
+                    const routesForServerLoaderMatches = (0, utils_namespaceObject.filterRoutesLoader)(routes);
+                    const code = external_templates_js_namespaceObject.routesForServer({
+                        routesForServerLoaderMatches
+                    });
+                    await utils_namespaceObject.fs.ensureFile(routesServerFile);
+                    await utils_namespaceObject.fs.writeFile(routesServerFile, code);
+                    const serverRoutesCode = await external_templates_js_namespaceObject.fileSystemRoutes({
+                        metaName,
+                        routes: filtedRoutesForServer,
+                        ssrMode,
+                        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                        entryName: entrypoint.entryName,
+                        internalDirectory,
+                        splitRouteChunks: config?.output?.splitRouteChunks,
+                        isRscClientBundle: false,
+                        srcDirectory,
+                        internalSrcAlias: appContext.internalSrcAlias
+                    });
+                    await utils_namespaceObject.fs.outputFile(external_path_default().resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, 'utf8');
+                }
+                const serverLoaderCombined = external_templates_js_namespaceObject.ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext);
+                if (serverLoaderCombined) {
+                    const serverLoaderFile = (0, external_utils_js_namespaceObject.getServerCombinedModuleFile)(internalDirectory, entryName);
+                    await utils_namespaceObject.fs.outputFile(serverLoaderFile, serverLoaderCombined);
+                }
+                await utils_namespaceObject.fs.outputFile(external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
+                if (enableTanstackTypes) {
+                    const { routerGenTs } = await (0, external_tanstackTypes_js_namespaceObject.generateTanstackRouterTypesSourceForEntry)({
+                        appContext,
+                        entryName,
+                        routes: routes
+                    });
+                    const outPath = external_path_default().join(srcDirectory, 'modern-tanstack', entryName, 'router.gen.ts');
+                    try {
+                        const prev = await utils_namespaceObject.fs.pathExists(outPath) ? await utils_namespaceObject.fs.readFile(outPath, 'utf-8') : null;
+                        if (prev !== routerGenTs) await utils_namespaceObject.fs.outputFile(outPath, routerGenTs, 'utf-8');
+                    } catch  {
+                        await utils_namespaceObject.fs.outputFile(outPath, routerGenTs, 'utf-8');
+                    }
+                }
+            }
+        }
+    }
+    return generatedRoutesByEntry;
+};
+function generatorRegisterCode(internalDirectory, entryName, code) {
+    utils_namespaceObject.fs.outputFileSync(external_path_default().resolve(internalDirectory, `./${entryName}/${constants_js_namespaceObject.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`), code, 'utf8');
+}
+function generatorServerRegisterCode(internalDirectory, entryName, code) {
+    utils_namespaceObject.fs.outputFileSync(external_path_default().resolve(internalDirectory, `./${entryName}/${constants_js_namespaceObject.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`), code, 'utf8');
+}
+exports.generateCode = __webpack_exports__.generateCode;
+exports.generateRoutesForEntry = __webpack_exports__.generateRoutesForEntry;
+exports.generatorRegisterCode = __webpack_exports__.generatorRegisterCode;
+exports.generatorServerRegisterCode = __webpack_exports__.generatorServerRegisterCode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateCode",
+    "generateRoutesForEntry",
+    "generatorRegisterCode",
+    "generatorServerRegisterCode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,139 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    generateRoutesInspectReport: ()=>generateRoutesInspectReport
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_entry_js_namespaceObject = require("../entry.js");
+const external_index_js_namespaceObject = require("./index.js");
+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 (0, external_index_js_namespaceObject.generateRoutesForEntry)(entrypoint, appContext);
+    if (0 === routes.length) {
+        console.log(`⚠️  No routes found for entry "${entryName}"`);
+        return {
+            entryName,
+            routes: []
+        };
+    }
+    const hooks = api.getHooks();
+    const clonedRoutes = (0, lodash_namespaceObject.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 = (0, external_entry_js_namespaceObject.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 utils_namespaceObject.fs.ensureDir(distDirectory);
+        const reportPath = external_path_default().join(distDirectory, 'routes-inspect.json');
+        await utils_namespaceObject.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);
+    }
+}
+exports.generateRoutesInspectReport = __webpack_exports__.generateRoutesInspectReport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateRoutesInspectReport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});