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

package/dist/cjs/router/cli/config-routes/converter.js

@@ -0,0 +1,129 @@
+"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__, {
+    normalizeRoutes: ()=>normalizeRoutes,
+    processConfigRoutes: ()=>processConfigRoutes
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const nestedRoutes_js_namespaceObject = require("../code/nestedRoutes.js");
+const utils_js_namespaceObject = require("../code/utils.js");
+async function processConfigRoutes(configRoutes, entryName, isMainEntry, configRoutesDir, alias) {
+    return Promise.all(configRoutes.map((configRoute)=>processConfigRoute(configRoute, entryName, isMainEntry, configRoutesDir, alias)));
+}
+async function processConfigRoute(configRoute, entryName, isMainEntry, configRoutesDir, alias) {
+    if ('config' !== configRoute.origin) {
+        if (configRoute.children && configRoute.children.length > 0) {
+            const processedChildren = await Promise.all(configRoute.children.map((child)=>processConfigRoute(child, entryName, isMainEntry, configRoutesDir, alias)));
+            return {
+                ...configRoute,
+                children: processedChildren
+            };
+        }
+        return configRoute;
+    }
+    const componentPath = configRoute.component;
+    const absoluteComponentPath = componentPath ? external_node_path_default().isAbsolute(componentPath) ? componentPath : external_node_path_default().resolve(configRoutesDir, componentPath) : void 0;
+    const routeId = configRoute.id || (0, nestedRoutes_js_namespaceObject.getRouteId)(componentPath, configRoutesDir, entryName, isMainEntry);
+    const processedRoute = {
+        ...configRoute,
+        id: routeId,
+        path: configRoute.path ?? '',
+        type: 'nested',
+        origin: 'config'
+    };
+    if (absoluteComponentPath) {
+        const componentPathWithAlias = alias ? (0, utils_js_namespaceObject.getPathWithoutExt)((0, utils_js_namespaceObject.replaceWithAlias)(alias.basename, absoluteComponentPath, alias.name)) : (0, utils_js_namespaceObject.getPathWithoutExt)(absoluteComponentPath);
+        processedRoute._component = componentPathWithAlias;
+    }
+    if (configRoute.children && configRoute.children.length > 0) {
+        const processedChildren = await Promise.all(configRoute.children.map((child)=>processConfigRoute(child, entryName, isMainEntry, configRoutesDir, alias)));
+        processedRoute.children = processedChildren;
+    }
+    if ('page' === configRoute.routeType || !configRoute.routeType && !configRoute.children) {
+        const rawPath = configRoute.path;
+        const isIndexPath = '' === rawPath || '/' === rawPath || 'string' == typeof rawPath && '' === rawPath.replace(/^\/+/, '');
+        if (isIndexPath) {
+            processedRoute.index = true;
+            delete processedRoute.path;
+        }
+    }
+    if (absoluteComponentPath) await discoverRelatedFiles(processedRoute, absoluteComponentPath, alias);
+    return processedRoute;
+}
+async function discoverRelatedFiles(nestedRoute, componentPath, alias) {
+    if ('config' !== nestedRoute.origin) return;
+    const componentDir = external_node_path_default().dirname(componentPath);
+    const componentName = external_node_path_default().basename(componentPath, external_node_path_default().extname(componentPath));
+    const relatedFiles = {
+        data: `${componentName}.data.ts`,
+        clientData: `${componentName}.data.client.ts`,
+        error: `${componentName}.error.tsx`,
+        loading: `${componentName}.loading.tsx`,
+        config: `${componentName}.config.ts`
+    };
+    await Promise.all(Object.entries(relatedFiles).map(async ([key, filename])=>{
+        const filePath = external_node_path_default().resolve(componentDir, filename);
+        try {
+            if (await utils_namespaceObject.fs.promises.stat(filePath).then((stat)=>stat.isFile()).catch(()=>false)) {
+                const aliasedPath = alias ? (0, utils_js_namespaceObject.replaceWithAlias)(alias.basename, filePath, alias.name) : filePath;
+                nestedRoute[key] = (0, utils_namespaceObject.normalizeToPosixPath)(aliasedPath);
+            }
+        } catch (e) {}
+    }));
+}
+function normalizeRoutes(generatedRoutes) {
+    return generatedRoutes.map((route)=>normalizeRoute(route));
+}
+function normalizeRoute(route) {
+    const { component, ...rest } = route;
+    const processedRoute = {
+        ...rest,
+        ...route.children && route.children.length > 0 ? {
+            children: route.children.map((child)=>normalizeRoute(child))
+        } : {}
+    };
+    return processedRoute;
+}
+exports.normalizeRoutes = __webpack_exports__.normalizeRoutes;
+exports.processConfigRoutes = __webpack_exports__.processConfigRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeRoutes",
+    "processConfigRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/config-routes/parseRouteConfig.js

@@ -0,0 +1,155 @@
+"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__, {
+    discoverAndParseConfigRoutes: ()=>discoverAndParseConfigRoutes,
+    findConfigRoutesFile: ()=>findConfigRoutesFile,
+    parseConfigRoutesFile: ()=>parseConfigRoutesFile
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+function createRouteFunctions(basePath) {
+    const resolveComponentPath = (component)=>{
+        if (!component) return component;
+        if (external_node_path_default().isAbsolute(component)) return component;
+        if (component.startsWith('./') || component.startsWith('../') || !component.startsWith('@')) return external_node_path_default().resolve(basePath, component);
+        return component;
+    };
+    const createNestedRoute = (component, routePath, children = [], routeType, wildcard = false)=>{
+        if ('string' == typeof component && component.startsWith('@')) throw new Error('component path must be absolute or relative; alias is not allowed');
+        if (void 0 !== routePath && 'string' != typeof routePath) throw new Error('Route path must be a string');
+        const resolvedComponent = resolveComponentPath(component);
+        if ('page' === routeType || wildcard) {
+            if (!component || '' === component.trim()) throw new Error('page route must specify a non-empty component path');
+            if (!utils_namespaceObject.fs.pathExistsSync(resolvedComponent)) throw new Error(`page component not found: ${resolvedComponent}`);
+        }
+        if (wildcard) return {
+            path: routePath || '*',
+            component: resolvedComponent,
+            routeType: 'page',
+            origin: 'config',
+            type: 'nested',
+            children: children.length > 0 ? children : void 0
+        };
+        if (!routeType) throw new Error('createRouteConfig must specify route type');
+        return {
+            path: routePath,
+            component: resolvedComponent,
+            routeType,
+            origin: 'config',
+            type: 'nested',
+            children: children.length > 0 ? children : void 0
+        };
+    };
+    return {
+        route: (component, pathOrChildren, maybeChildren)=>{
+            const path = Array.isArray(pathOrChildren) ? void 0 : pathOrChildren;
+            const children = Array.isArray(pathOrChildren) ? pathOrChildren : maybeChildren ?? [];
+            const routeType = children.length > 0 ? 'layout' : 'page';
+            return createNestedRoute(component, path, children, routeType);
+        },
+        layout: (component, pathOrChildren, maybeChildren)=>{
+            const path = Array.isArray(pathOrChildren) ? void 0 : pathOrChildren;
+            const children = Array.isArray(pathOrChildren) ? pathOrChildren : maybeChildren ?? [];
+            if (0 === children.length) throw new Error('layout route must have children');
+            return createNestedRoute(component, path, children, 'layout');
+        },
+        page: (component, path)=>createNestedRoute(component, path, [], 'page'),
+        $: (component, path)=>createNestedRoute(component, path, [], void 0, true)
+    };
+}
+async function findConfigRoutesFile(entrypoint, appContext) {
+    const { absoluteEntryDir } = entrypoint;
+    if (!absoluteEntryDir) return null;
+    const { metaName } = appContext;
+    const meta = (0, utils_namespaceObject.getMeta)(metaName);
+    const possibleNames = [
+        `${meta}.routes.ts`,
+        `${meta}.routes.mts`,
+        `${meta}.routes.tsx`,
+        `${meta}.routes.js`,
+        `${meta}.routes.mjs`,
+        `${meta}.routes.jsx`
+    ];
+    for (const filename of possibleNames){
+        const filePath = external_node_path_default().resolve(absoluteEntryDir, filename);
+        if (await utils_namespaceObject.fs.pathExists(filePath)) {
+            const stats = await utils_namespaceObject.fs.stat(filePath);
+            if (stats.isFile()) {
+                utils_namespaceObject.logger.debug(`Found config routes file: ${filePath}`);
+                return filePath;
+            }
+        }
+    }
+    return null;
+}
+async function parseConfigRoutesFile(filePath, entrypoint, fileRoutes) {
+    const { loadTypeScriptFile } = await import("@modern-js/plugin/run");
+    const configModule = loadTypeScriptFile(filePath);
+    if (!configModule.default || 'function' != typeof configModule.default) throw new Error(`Config routes file must export a default function. Found: ${typeof configModule.default}`);
+    const routeFunctions = createRouteFunctions(entrypoint.absoluteEntryDir);
+    let routesConfig;
+    if (!fileRoutes) throw new Error("Routes function expects file routes parameter, but none provided");
+    routesConfig = configModule.default(routeFunctions, fileRoutes);
+    if (!Array.isArray(routesConfig)) throw new Error(`Config routes function must return an array of routes. Received: ${typeof routesConfig}`);
+    return {
+        entryName: entrypoint.entryName,
+        filePath,
+        routes: routesConfig,
+        isMainEntry: entrypoint.isMainEntry || false
+    };
+}
+async function discoverAndParseConfigRoutes(entrypoint, appContext, fileRoutes) {
+    const configFilePath = await findConfigRoutesFile(entrypoint, appContext);
+    if (!configFilePath) {
+        utils_namespaceObject.logger.debug(`No config routes file found for entry: ${entrypoint.entryName}`);
+        return null;
+    }
+    const configRouteFile = await parseConfigRoutesFile(configFilePath, entrypoint, fileRoutes);
+    utils_namespaceObject.logger.debug(`Successfully loaded config routes from: ${configFilePath}`);
+    utils_namespaceObject.logger.debug(`Found ${configRouteFile.routes.length} route(s) for entry: ${entrypoint.entryName}`);
+    return configRouteFile;
+}
+exports.discoverAndParseConfigRoutes = __webpack_exports__.discoverAndParseConfigRoutes;
+exports.findConfigRoutesFile = __webpack_exports__.findConfigRoutesFile;
+exports.parseConfigRoutesFile = __webpack_exports__.parseConfigRoutesFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "discoverAndParseConfigRoutes",
+    "findConfigRoutesFile",
+    "parseConfigRoutesFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/constants.js

@@ -0,0 +1,99 @@
+"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__, {
+    ACTION_EXPORT_NAME: ()=>ACTION_EXPORT_NAME,
+    APP_CONFIG_NAME: ()=>APP_CONFIG_NAME,
+    APP_INIT_EXPORTED: ()=>APP_INIT_EXPORTED,
+    FILE_SYSTEM_ROUTES_COMPONENTS_DIR: ()=>FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
+    FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP: ()=>FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
+    FILE_SYSTEM_ROUTES_FILE_NAME: ()=>FILE_SYSTEM_ROUTES_FILE_NAME,
+    FILE_SYSTEM_ROUTES_IGNORED_REGEX: ()=>FILE_SYSTEM_ROUTES_IGNORED_REGEX,
+    FILE_SYSTEM_ROUTES_INDEX: ()=>FILE_SYSTEM_ROUTES_INDEX,
+    LOADER_EXPORT_NAME: ()=>LOADER_EXPORT_NAME,
+    NESTED_ROUTE: ()=>NESTED_ROUTE,
+    NESTED_ROUTES_DIR: ()=>NESTED_ROUTES_DIR,
+    TEMP_LOADERS_DIR: ()=>TEMP_LOADERS_DIR
+});
+const NESTED_ROUTES_DIR = 'routes';
+const FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
+const LOADER_EXPORT_NAME = 'loader';
+const ACTION_EXPORT_NAME = 'action';
+const TEMP_LOADERS_DIR = '__loaders__';
+const FILE_SYSTEM_ROUTES_INDEX = 'index';
+const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = 'internal_components';
+const APP_CONFIG_NAME = 'config';
+const APP_INIT_EXPORTED = 'init';
+const NESTED_ROUTE = {
+    LAYOUT_FILE: 'layout',
+    LAYOUT_CONFIG_FILE: 'layout.config',
+    LAYOUT_LOADER_FILE: 'layout.loader',
+    LAYOUT_DATA_FILE: 'layout.data',
+    LAYOUT_CLIENT_LOADER: 'layout.data.client',
+    PAGE_FILE: 'page',
+    PAGE_CONFIG_FILE: 'page.config',
+    PAGE_LOADER_FILE: 'page.loader',
+    PAGE_DATA_FILE: 'page.data',
+    PAGE_CLIENT_LOADER: 'page.data.client',
+    SPLATE_FILE: '$',
+    SPLATE_CONFIG_FILE: '$.config',
+    SPLATE_LOADER_FILE: '$.loader',
+    SPLATE_DATA_FILE: '$.data',
+    SPLATE_CLIENT_DATA: '$.data.client',
+    LOADING_FILE: 'loading',
+    ERROR_FILE: 'error',
+    LOADER_FILE: 'loader'
+};
+exports.ACTION_EXPORT_NAME = __webpack_exports__.ACTION_EXPORT_NAME;
+exports.APP_CONFIG_NAME = __webpack_exports__.APP_CONFIG_NAME;
+exports.APP_INIT_EXPORTED = __webpack_exports__.APP_INIT_EXPORTED;
+exports.FILE_SYSTEM_ROUTES_COMPONENTS_DIR = __webpack_exports__.FILE_SYSTEM_ROUTES_COMPONENTS_DIR;
+exports.FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = __webpack_exports__.FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP;
+exports.FILE_SYSTEM_ROUTES_FILE_NAME = __webpack_exports__.FILE_SYSTEM_ROUTES_FILE_NAME;
+exports.FILE_SYSTEM_ROUTES_IGNORED_REGEX = __webpack_exports__.FILE_SYSTEM_ROUTES_IGNORED_REGEX;
+exports.FILE_SYSTEM_ROUTES_INDEX = __webpack_exports__.FILE_SYSTEM_ROUTES_INDEX;
+exports.LOADER_EXPORT_NAME = __webpack_exports__.LOADER_EXPORT_NAME;
+exports.NESTED_ROUTE = __webpack_exports__.NESTED_ROUTE;
+exports.NESTED_ROUTES_DIR = __webpack_exports__.NESTED_ROUTES_DIR;
+exports.TEMP_LOADERS_DIR = __webpack_exports__.TEMP_LOADERS_DIR;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ACTION_EXPORT_NAME",
+    "APP_CONFIG_NAME",
+    "APP_INIT_EXPORTED",
+    "FILE_SYSTEM_ROUTES_COMPONENTS_DIR",
+    "FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP",
+    "FILE_SYSTEM_ROUTES_FILE_NAME",
+    "FILE_SYSTEM_ROUTES_IGNORED_REGEX",
+    "FILE_SYSTEM_ROUTES_INDEX",
+    "LOADER_EXPORT_NAME",
+    "NESTED_ROUTE",
+    "NESTED_ROUTES_DIR",
+    "TEMP_LOADERS_DIR"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/entry.js

@@ -0,0 +1,105 @@
+"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__, {
+    BUILT_IN_ROUTES_OWNER: ()=>BUILT_IN_ROUTES_OWNER,
+    ROUTES_DIR_META_KEY: ()=>ROUTES_DIR_META_KEY,
+    ROUTES_OWNER_META_KEY: ()=>ROUTES_OWNER_META_KEY,
+    getEntrypointRoutesDir: ()=>getEntrypointRoutesDir,
+    getEntrypointRoutesOwner: ()=>getEntrypointRoutesOwner,
+    hasNestedRoutes: ()=>hasNestedRoutes,
+    isRouteEntry: ()=>isRouteEntry,
+    modifyEntrypoints: ()=>modifyEntrypoints
+});
+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 entry_js_namespaceObject = require("../../cli/entry.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const ROUTES_DIR_META_KEY = '__modernRoutesDir';
+const ROUTES_OWNER_META_KEY = '__modernRoutesOwner';
+const BUILT_IN_ROUTES_OWNER = '@modern-js/plugin-router';
+const getEntrypointRoutesDir = (entrypoint)=>{
+    if (entrypoint[ROUTES_DIR_META_KEY]) return entrypoint[ROUTES_DIR_META_KEY];
+    if (entrypoint.nestedRoutesEntry) return external_path_default().basename(entrypoint.nestedRoutesEntry);
+    return null;
+};
+const getEntrypointRoutesOwner = (entrypoint)=>entrypoint[ROUTES_OWNER_META_KEY] || null;
+const hasNestedRoutes = (dir, routesDir = external_constants_js_namespaceObject.NESTED_ROUTES_DIR)=>utils_namespaceObject.fs.existsSync(external_path_default().join(dir, routesDir));
+const isRouteEntry = (dir, routesDir = external_constants_js_namespaceObject.NESTED_ROUTES_DIR)=>{
+    if (hasNestedRoutes(dir, routesDir)) return external_path_default().join(dir, routesDir);
+    return false;
+};
+const modifyEntrypoints = (entrypoints, routesDir = external_constants_js_namespaceObject.NESTED_ROUTES_DIR, routesOwner)=>entrypoints.map((entrypoint)=>{
+        const entrypointWithMeta = entrypoint;
+        if (!entrypoint.isAutoMount) return entrypointWithMeta;
+        if (entrypoint?.isCustomSourceEntry) {
+            if (entrypoint.fileSystemRoutes) {
+                entrypointWithMeta.nestedRoutesEntry = entrypoint.absoluteEntryDir || entrypoint.entry;
+                entrypointWithMeta[ROUTES_DIR_META_KEY] = routesDir;
+                if (routesOwner) entrypointWithMeta[ROUTES_OWNER_META_KEY] = routesOwner;
+            }
+            return entrypointWithMeta;
+        }
+        const isHasApp = (0, entry_js_namespaceObject.hasApp)(entrypoint.absoluteEntryDir);
+        if (isHasApp) return entrypointWithMeta;
+        const isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir, routesDir);
+        if (isHasNestedRoutes) {
+            entrypointWithMeta.nestedRoutesEntry = external_path_default().join(entrypoint.absoluteEntryDir, routesDir);
+            entrypointWithMeta[ROUTES_DIR_META_KEY] = routesDir;
+            if (routesOwner) entrypointWithMeta[ROUTES_OWNER_META_KEY] = routesOwner;
+        }
+        return entrypointWithMeta;
+    });
+exports.BUILT_IN_ROUTES_OWNER = __webpack_exports__.BUILT_IN_ROUTES_OWNER;
+exports.ROUTES_DIR_META_KEY = __webpack_exports__.ROUTES_DIR_META_KEY;
+exports.ROUTES_OWNER_META_KEY = __webpack_exports__.ROUTES_OWNER_META_KEY;
+exports.getEntrypointRoutesDir = __webpack_exports__.getEntrypointRoutesDir;
+exports.getEntrypointRoutesOwner = __webpack_exports__.getEntrypointRoutesOwner;
+exports.hasNestedRoutes = __webpack_exports__.hasNestedRoutes;
+exports.isRouteEntry = __webpack_exports__.isRouteEntry;
+exports.modifyEntrypoints = __webpack_exports__.modifyEntrypoints;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BUILT_IN_ROUTES_OWNER",
+    "ROUTES_DIR_META_KEY",
+    "ROUTES_OWNER_META_KEY",
+    "getEntrypointRoutesDir",
+    "getEntrypointRoutesOwner",
+    "hasNestedRoutes",
+    "isRouteEntry",
+    "modifyEntrypoints"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/handler.js

@@ -0,0 +1,131 @@
+"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__, {
+    handleFileChange: ()=>handleFileChange,
+    handleGeneratorEntryCode: ()=>handleGeneratorEntryCode,
+    handleModifyEntrypoints: ()=>handleModifyEntrypoints
+});
+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 templates_js_namespaceObject = require("./code/templates.js");
+const utils_js_namespaceObject = require("./code/utils.js");
+const external_entry_js_namespaceObject = require("./entry.js");
+const DEFAULT_ENTRYPOINTS_KEY = '__default_router_entries__';
+const originEntrypointsByKey = new Map();
+async function handleModifyEntrypoints(entrypoints, routesDir, options = {}) {
+    return (0, external_entry_js_namespaceObject.modifyEntrypoints)(entrypoints, routesDir, options.routesOwner);
+}
+async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
+    const normalizedOptions = 'string' == typeof options ? {
+        entrypointsKey: options
+    } : options;
+    const entrypointsKey = normalizedOptions.entrypointsKey || DEFAULT_ENTRYPOINTS_KEY;
+    const appContext = api.getAppContext();
+    const { internalDirectory } = appContext;
+    const resolvedConfig = api.getNormalizedConfig();
+    const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.js");
+    originEntrypointsByKey.set(entrypointsKey, (0, lodash_namespaceObject.cloneDeep)(entrypoints));
+    const enableRsc = resolvedConfig?.server?.rsc;
+    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, normalizedOptions.generateCodeOptions);
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
+            const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
+            const basename = route?.urlPath || '/';
+            generatorRegisterCode(internalDirectory, entrypoint.entryName, await templates_js_namespaceObject.runtimeGlobalContext({
+                entryName: entrypoint.entryName,
+                metaName: appContext.metaName,
+                srcDirectory: appContext.srcDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                internalSrcAlias: appContext.internalSrcAlias,
+                globalApp: entrypoint.fileSystemRoutes?.globalApp,
+                rscType: enableRsc ? 'client' : void 0,
+                basename
+            }));
+            if (enableRsc) generatorServerRegisterCode(internalDirectory, entrypoint.entryName, await templates_js_namespaceObject.runtimeGlobalContext({
+                entryName: entrypoint.entryName,
+                metaName: appContext.metaName,
+                srcDirectory: appContext.srcDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                internalSrcAlias: appContext.internalSrcAlias,
+                globalApp: entrypoint.fileSystemRoutes?.globalApp,
+                rscType: 'server',
+                basename
+            }));
+        }
+    }));
+    return routesByEntry;
+}
+async function handleFileChange(api, e, options = {}) {
+    const { includeEntry, regenerate, entrypointsKey = DEFAULT_ENTRYPOINTS_KEY } = options;
+    const appContext = api.getAppContext();
+    const { appDirectory, entrypoints } = appContext;
+    const activeEntrypoints = includeEntry ? entrypoints.filter(includeEntry) : entrypoints;
+    const { filename, eventType } = e;
+    const nestedRouteEntries = activeEntrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
+    const pagesDir = activeEntrypoints.map((point)=>point.entry).filter((entry)=>entry && !external_path_default().extname(entry)).concat(nestedRouteEntries);
+    if (0 === pagesDir.length) return;
+    const isPageFile = (name)=>pagesDir.some((pageDir)=>name.includes(pageDir));
+    const absoluteFilePath = external_path_default().resolve(appDirectory, filename);
+    const isRouteComponent = isPageFile(absoluteFilePath) && (0, utils_js_namespaceObject.isPageComponentFile)(absoluteFilePath);
+    const meta = (0, utils_namespaceObject.getMeta)(appContext.metaName);
+    const normalizedFilename = filename.replace(/\\/g, '/');
+    const isConfigRoutesFile = normalizedFilename.includes(`${meta}.routes.`) && /\.(js|ts|jsx|tsx|mjs|mts)$/i.test(external_path_default().extname(filename));
+    if (isRouteComponent && ('add' === eventType || 'unlink' === eventType) || isConfigRoutesFile && ('change' === eventType || 'add' === eventType || 'unlink' === eventType)) {
+        const resolvedConfig = api.getNormalizedConfig();
+        const cachedEntrypoints = originEntrypointsByKey.get(entrypointsKey) || activeEntrypoints;
+        const entrypoints = (0, lodash_namespaceObject.cloneDeep)(cachedEntrypoints).filter((entrypoint)=>includeEntry ? includeEntry(entrypoint) : true);
+        if (regenerate) return void await regenerate({
+            api,
+            appContext,
+            resolvedConfig,
+            entrypoints
+        });
+        const { generateCode } = await import("./code/index.js");
+        await generateCode(appContext, resolvedConfig, entrypoints, api);
+    }
+}
+exports.handleFileChange = __webpack_exports__.handleFileChange;
+exports.handleGeneratorEntryCode = __webpack_exports__.handleGeneratorEntryCode;
+exports.handleModifyEntrypoints = __webpack_exports__.handleModifyEntrypoints;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleFileChange",
+    "handleGeneratorEntryCode",
+    "handleModifyEntrypoints"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});