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

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

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

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

@@ -0,0 +1,95 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { modifyEntrypoints } from "../entry";
+import { generateRoutesForEntry } from "./index";
+function convertRouteToInspectFormat(route) {
+    const inspectRoute = {
+        path: route.path ?? void 0,
+        component: route._component || ''
+    };
+    if (route.path?.includes(':')) {
+        const params = route.path.match(/:[^\/]+/g)?.map((param)=>param.slice(1)) || [];
+        inspectRoute.params = params;
+    }
+    if (route.data) inspectRoute.data = route.data;
+    if (route.clientData) inspectRoute.clientData = route.clientData;
+    if (route.error) inspectRoute.error = route.error;
+    if (route.loading) inspectRoute.loading = route.loading;
+    if (route.config) inspectRoute.config = 'string' == typeof route.config ? route.config : String(route.config);
+    if ('children' in route && route.children && route.children.length > 0) inspectRoute.children = route.children.filter((child)=>{
+        const hasComponent = Boolean(child._component);
+        const hasChildren = 'children' in child && child.children && child.children.length > 0;
+        const hasPath = void 0 !== child.path;
+        return hasComponent || hasChildren || hasPath;
+    }).map((child)=>convertRouteToInspectFormat(child));
+    return inspectRoute;
+}
+async function generateInspectReportForEntry(entrypoint, appContext, config, api) {
+    const { entryName } = entrypoint;
+    console.log(`🔍 Analyzing routes for entry "${entryName}"...`);
+    const routes = await generateRoutesForEntry(entrypoint, appContext);
+    if (0 === routes.length) {
+        console.log(`⚠️  No routes found for entry "${entryName}"`);
+        return {
+            entryName,
+            routes: []
+        };
+    }
+    const hooks = api.getHooks();
+    const clonedRoutes = cloneDeep(routes);
+    const { routes: finalRoutes } = await hooks.modifyFileSystemRoutes.call({
+        entrypoint,
+        routes: clonedRoutes
+    });
+    const inspectRoutes = finalRoutes.filter((route)=>{
+        const hasComponent = Boolean(route._component);
+        const hasChildren = 'children' in route && route.children && route.children.length > 0;
+        const hasPath = void 0 !== route.path;
+        return hasComponent || hasChildren || hasPath;
+    }).map((route)=>convertRouteToInspectFormat(route));
+    console.log(`✅ Found ${inspectRoutes.length} routes for entry "${entryName}"`);
+    return {
+        entryName,
+        routes: inspectRoutes
+    };
+}
+async function generateRoutesInspectReport(api) {
+    try {
+        console.log('🚀 Start generating route inspection report...\n');
+        const appContext = api.getAppContext();
+        const config = api.getNormalizedConfig();
+        const { entrypoints, distDirectory } = appContext;
+        const modifiedEntrypoints = modifyEntrypoints(entrypoints);
+        const routesEntrypoints = modifiedEntrypoints.filter((entrypoint)=>entrypoint.isAutoMount);
+        if (0 === routesEntrypoints.length) return void console.log('⚠️  No entrypoints with routes (file-system or config-based) were found');
+        console.log(`📁 Found ${routesEntrypoints.length} entrypoints with routes`);
+        const reports = [];
+        for (const entrypoint of routesEntrypoints)if (entrypoint.nestedRoutesEntry) {
+            const report = await generateInspectReportForEntry(entrypoint, appContext, config, api);
+            reports.push(report);
+        }
+        let finalReport;
+        if (1 === reports.length) finalReport = {
+            routes: reports[0].routes
+        };
+        else {
+            finalReport = {};
+            for (const report of reports)finalReport[report.entryName] = {
+                routes: report.routes
+            };
+        }
+        await fs.ensureDir(distDirectory);
+        const reportPath = path.join(distDirectory, 'routes-inspect.json');
+        await fs.writeJSON(reportPath, finalReport, {
+            spaces: 2
+        });
+        console.log(`\n✨ Route inspection report has been generated: ${reportPath}`);
+        const totalRoutes = reports.reduce((sum, report)=>sum + report.routes.length, 0);
+        console.log(`📊 Found a total of ${totalRoutes} routes across ${reports.length} entrypoints`);
+    } catch (error) {
+        console.error('❌ Failed to generate route inspection report:', error);
+        process.exit(1);
+    }
+}
+export { generateRoutesInspectReport };

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

@@ -0,0 +1,9 @@
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbidList = new Set(`${reservedWords} ${builtins}`.split(' '));
+function makeLegalIdentifier(str) {
+    const identifier = str.replace(/-(\w)/g, (_, letter)=>letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbidList.has(identifier)) return `_${identifier}`;
+    return identifier || '_';
+}
+export { makeLegalIdentifier };

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

@@ -0,0 +1,193 @@
+import { extname as external_path_extname, join, relative, sep } from "path";
+import { JS_EXTENSIONS, fs, normalizeToPosixPath } from "@modern-js/utils";
+import { NESTED_ROUTE } from "../constants";
+import { getPathWithoutExt, hasAction, replaceWithAlias } from "./utils";
+const conventionNames = Object.values(NESTED_ROUTE);
+const replaceDynamicPath = (routePath)=>routePath.replace(/\[(.*?)\]/g, ':$1');
+const getRouteId = (componentPath, routesDir, entryName, isMainEntry)=>{
+    const relativePath = normalizeToPosixPath(relative(routesDir, componentPath));
+    const pathWithoutExt = getPathWithoutExt(relativePath);
+    let id = "";
+    id = isMainEntry ? pathWithoutExt : `${entryName}_${pathWithoutExt}`;
+    return id.replace(/\[(.*?)\]/g, '($1)');
+};
+const createIndexRoute = (routeInfo, rootDir, filename, entryName, isMainEntry)=>createRoute({
+        ...routeInfo,
+        index: true,
+        children: void 0,
+        routeType: 'page'
+    }, rootDir, filename, entryName, isMainEntry);
+const createRoute = (routeInfo, rootDir, filename, entryName, isMainEntry)=>{
+    const id = getRouteId(filename, rootDir, entryName, isMainEntry);
+    const hasChildren = routeInfo.children && routeInfo.children.length > 0;
+    return {
+        ...routeInfo,
+        id,
+        type: 'nested',
+        routeType: hasChildren ? 'layout' : 'page',
+        origin: 'file-system',
+        component: routeInfo._component ? filename : void 0
+    };
+};
+const optimizeRoute = (routeTree)=>{
+    if (!routeTree.children || 0 === routeTree.children.length) return [
+        routeTree
+    ];
+    const { children } = routeTree;
+    if (routeTree._component || routeTree.error || routeTree.loading || routeTree.config || routeTree.clientData) {
+        const optimizedChildren = routeTree.children.flatMap(optimizeRoute);
+        return [
+            {
+                ...routeTree,
+                children: optimizedChildren
+            }
+        ];
+    }
+    {
+        const newRoutes = children.map((child)=>{
+            const routePath = routeTree.path ? `${routeTree.path}${child.path ? `/${child.path}` : ''}` : child.path || '';
+            const newRoute = {
+                ...child,
+                path: routePath.replace(/\/\//g, '/'),
+                component: child.component || void 0,
+                origin: 'file-system'
+            };
+            if (routePath.length > 0) delete newRoute.index;
+            else delete newRoute.path;
+            return newRoute;
+        });
+        return Array.from(new Set(newRoutes)).flatMap(optimizeRoute);
+    }
+};
+const walk = async (options)=>{
+    const { dirname, rootDir, alias, entryName, isMainEntry } = options;
+    if (!await fs.pathExists(dirname)) return null;
+    const isDirectory = (await fs.stat(dirname)).isDirectory();
+    if (!isDirectory) return null;
+    const relativeDir = relative(rootDir, dirname);
+    const pathSegments = relativeDir.split(sep);
+    const lastSegment = pathSegments[pathSegments.length - 1];
+    const isRoot = '' === lastSegment;
+    const isPathlessLayout = lastSegment.startsWith('__');
+    const isWithoutLayoutPath = lastSegment.includes('.');
+    let routePath = isRoot || isPathlessLayout ? '/' : `${lastSegment}`;
+    if (isWithoutLayoutPath) routePath = lastSegment.split('.').join('/');
+    routePath = replaceDynamicPath(routePath);
+    const route = {
+        path: routePath?.replace(/\$$/, '?'),
+        children: [],
+        isRoot,
+        origin: 'file-system'
+    };
+    let pageLoaderFile = '';
+    let pageRoute = null;
+    let pageConfigFile = '';
+    let pageClientData = '';
+    let pageData = '';
+    let pageAction = '';
+    let splatLoaderFile = '';
+    let splatRoute = null;
+    let splatConfigFile = '';
+    let splatClientData = '';
+    let splatData = '';
+    let splatAction = '';
+    const items = await fs.readdir(dirname);
+    for (const item of items){
+        const itemPath = join(dirname, item);
+        const itemPathWithAlias = alias ? getPathWithoutExt(replaceWithAlias(alias.basename, itemPath, alias.name)) : getPathWithoutExt(itemPath);
+        const extname = external_path_extname(item);
+        const itemWithoutExt = item.slice(0, -extname.length);
+        const isDirectory = (await fs.stat(itemPath)).isDirectory();
+        if (isDirectory) {
+            const childRoute = await walk({
+                dirname: itemPath,
+                rootDir,
+                alias,
+                entryName,
+                isMainEntry
+            });
+            if (childRoute && !Array.isArray(childRoute)) route.children?.push(childRoute);
+        }
+        if (!extname || JS_EXTENSIONS.includes(extname) && conventionNames.includes(itemWithoutExt)) {
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_LOADER_FILE) {
+                if (!route.loader) route.loader = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_CLIENT_LOADER) route.clientData = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_DATA_FILE) {
+                route.data = itemPathWithAlias;
+                if (await hasAction(itemPath)) route.action = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_CONFIG_FILE) {
+                if (!route.config) route.config = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LAYOUT_FILE) route._component = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_LOADER_FILE) pageLoaderFile = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_CLIENT_LOADER) pageClientData = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_DATA_FILE) {
+                pageData = itemPathWithAlias;
+                if (await hasAction(itemPath)) pageAction = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_CONFIG_FILE) pageConfigFile = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.PAGE_FILE) {
+                pageRoute = createIndexRoute({
+                    _component: itemPathWithAlias
+                }, rootDir, itemPath, entryName, isMainEntry);
+                if (pageLoaderFile) pageRoute.loader = pageLoaderFile;
+                if (pageConfigFile) pageRoute.config = pageConfigFile;
+                if (pageData) pageRoute.data = pageData;
+                if (pageClientData) pageRoute.clientData = pageClientData;
+                if (pageAction) pageRoute.action = pageAction;
+                route.children?.unshift(pageRoute);
+            }
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_LOADER_FILE) splatLoaderFile = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_CLIENT_DATA) splatClientData = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_CONFIG_FILE) {
+                if (!route.config) splatConfigFile = alias ? replaceWithAlias(alias.basename, itemPath, alias.name) : getPathWithoutExt(itemPath);
+            }
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_DATA_FILE) {
+                splatData = itemPathWithAlias;
+                if (await hasAction(itemPath)) splatAction = itemPathWithAlias;
+            }
+            if (itemWithoutExt === NESTED_ROUTE.SPLATE_FILE) {
+                splatRoute = createRoute({
+                    _component: itemPathWithAlias,
+                    path: '*',
+                    origin: 'file-system'
+                }, rootDir, itemPath, entryName, isMainEntry);
+                if (splatLoaderFile) splatRoute.loader = splatLoaderFile;
+                if (splatClientData) splatRoute.clientData = splatClientData;
+                if (splatData) splatRoute.data = splatData;
+                if (splatConfigFile) splatRoute.config = splatConfigFile;
+                if (splatAction) splatRoute.action = splatAction;
+                route.children?.push(splatRoute);
+            }
+            if (itemWithoutExt === NESTED_ROUTE.LOADING_FILE) route.loading = itemPathWithAlias;
+            if (itemWithoutExt === NESTED_ROUTE.ERROR_FILE) route.error = itemPathWithAlias;
+        }
+    }
+    let finalRoute = createRoute({
+        ...route,
+        origin: 'file-system'
+    }, rootDir, join(dirname, `${NESTED_ROUTE.LAYOUT_FILE}.ts`), entryName, isMainEntry);
+    if (isPathlessLayout) delete finalRoute.path;
+    const childRoutes = finalRoute.children = finalRoute.children?.filter((childRoute)=>childRoute);
+    if (childRoutes && 0 === childRoutes.length && !finalRoute.index && !finalRoute._component) return null;
+    if (childRoutes && 1 === childRoutes.length && !finalRoute._component) {
+        const childRoute = childRoutes[0];
+        if ('*' === childRoute.path) {
+            const path = `${finalRoute.path || ''}/${childRoute.path || ''}`;
+            finalRoute = {
+                ...childRoute,
+                path,
+                component: childRoute.component || void 0
+            };
+        }
+    }
+    if (isRoot && !finalRoute._component) throw new Error('The root layout component is required, make sure the routes/layout.tsx file exists.');
+    if (isRoot) {
+        const optimizedRoutes = optimizeRoute(finalRoute);
+        return optimizedRoutes;
+    }
+    return finalRoute;
+};
+export { getRouteId, optimizeRoute, walk };