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

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

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

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

@@ -0,0 +1,82 @@
+import { JS_EXTENSIONS, fs, normalizeToPosixPath } from "@modern-js/utils";
+import { parse } from "es-module-lexer";
+import { transform } from "esbuild";
+import fs_0 from "fs";
+import path from "path";
+import { ACTION_EXPORT_NAME, LOADER_EXPORT_NAME } from "../constants.mjs";
+const walkDirectory = (dir)=>fs_0.readdirSync(dir).reduce((previous, filename)=>{
+        const filePath = path.join(dir, filename);
+        if (fs_0.statSync(filePath).isDirectory()) return [
+            ...previous,
+            ...walkDirectory(filePath)
+        ];
+        return [
+            ...previous,
+            filePath
+        ];
+    }, []);
+const isPageComponentFile = (filePath)=>{
+    if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) return false;
+    if ([
+        '.js',
+        '.jsx',
+        '.ts',
+        '.tsx'
+    ].includes(path.extname(filePath))) return true;
+    return false;
+};
+const replaceWithAlias = (base, filePath, alias)=>{
+    if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+    return filePath;
+};
+const parseModule = async ({ source, filename })=>{
+    let content = source;
+    if (JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const ext = path.extname(filename);
+        const loader = '.tsx' === ext ? 'tsx' : '.ts' === ext ? 'ts' : '.jsx' === ext ? 'jsx' : 'js';
+        const result = await transform(content, {
+            sourcefile: filename,
+            loader,
+            format: 'esm',
+            target: 'es2022',
+            tsconfigRaw: {
+                compilerOptions: {
+                    experimentalDecorators: true
+                }
+            }
+        });
+        content = result.code;
+    }
+    return parse(content);
+};
+const hasLoader = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === LOADER_EXPORT_NAME);
+    }
+    return false;
+};
+const hasAction = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === ACTION_EXPORT_NAME);
+    }
+    return false;
+};
+const getServerLoadersFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'route-server-loaders.js');
+const getServerCombinedModuleFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
+const getPathWithoutExt = (filename)=>{
+    const extname = path.extname(filename);
+    return extname ? filename.slice(0, -extname.length) : filename;
+};
+export { getPathWithoutExt, getServerCombinedModuleFile, getServerLoadersFile, hasAction, hasLoader, isPageComponentFile, parseModule, replaceWithAlias, walkDirectory };

package/dist/esm/router/cli/config-routes/converter.mjs

@@ -0,0 +1,82 @@
+import node_path from "node:path";
+import { fs, normalizeToPosixPath } from "@modern-js/utils";
+import { getRouteId } from "../code/nestedRoutes.mjs";
+import { getPathWithoutExt, replaceWithAlias } from "../code/utils.mjs";
+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 ? node_path.isAbsolute(componentPath) ? componentPath : node_path.resolve(configRoutesDir, componentPath) : void 0;
+    const routeId = configRoute.id || getRouteId(componentPath, configRoutesDir, entryName, isMainEntry);
+    const processedRoute = {
+        ...configRoute,
+        id: routeId,
+        path: configRoute.path ?? '',
+        type: 'nested',
+        origin: 'config'
+    };
+    if (absoluteComponentPath) {
+        const componentPathWithAlias = alias ? getPathWithoutExt(replaceWithAlias(alias.basename, absoluteComponentPath, alias.name)) : 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 = node_path.dirname(componentPath);
+    const componentName = node_path.basename(componentPath, node_path.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 = node_path.resolve(componentDir, filename);
+        try {
+            if (await fs.promises.stat(filePath).then((stat)=>stat.isFile()).catch(()=>false)) {
+                const aliasedPath = alias ? replaceWithAlias(alias.basename, filePath, alias.name) : filePath;
+                nestedRoute[key] = 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;
+}
+export { normalizeRoutes, processConfigRoutes };

package/dist/esm/router/cli/config-routes/parseRouteConfig.mjs

@@ -0,0 +1,105 @@
+import node_path from "node:path";
+import { fs, getMeta, logger } from "@modern-js/utils";
+function createRouteFunctions(basePath) {
+    const resolveComponentPath = (component)=>{
+        if (!component) return component;
+        if (node_path.isAbsolute(component)) return component;
+        if (component.startsWith('./') || component.startsWith('../') || !component.startsWith('@')) return node_path.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 (!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 = 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 = node_path.resolve(absoluteEntryDir, filename);
+        if (await fs.pathExists(filePath)) {
+            const stats = await fs.stat(filePath);
+            if (stats.isFile()) {
+                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) {
+        logger.debug(`No config routes file found for entry: ${entrypoint.entryName}`);
+        return null;
+    }
+    const configRouteFile = await parseConfigRoutesFile(configFilePath, entrypoint, fileRoutes);
+    logger.debug(`Successfully loaded config routes from: ${configFilePath}`);
+    logger.debug(`Found ${configRouteFile.routes.length} route(s) for entry: ${entrypoint.entryName}`);
+    return configRouteFile;
+}
+export { discoverAndParseConfigRoutes, findConfigRoutesFile, parseConfigRoutesFile };