vitarx-router 4.0.0-beta.2 → 4.0.0-beta.21

package/dist/file-router/scanner/routeTreeBuilder.js

@@ -1,312 +0,0 @@
-/**
- * 分组布局文件和普通页面
- *
- * @param pages - 页面列表
- * @returns 分组结果
- */
-function groupPagesByType(pages) {
-    const layoutFiles = new Map();
-    const normalPages = [];
-    // 遍历所有页面，根据 isLayoutFile 标记进行分组
-    for (const page of pages) {
-        if (page.isLayoutFile) {
-            layoutFiles.set(page.path, { ...page, children: [] });
-        }
-        else {
-            normalPages.push({ ...page, children: [] });
-        }
-    }
-    return { layoutFiles, normalPages };
-}
-/**
- * 按目录分组页面
- *
- * @param normalPages - 普通页面列表
- * @param layoutFiles - 布局文件映射
- * @returns 按目录分组的结果
- */
-function groupPagesByDirectory(normalPages, layoutFiles) {
-    const pagesByDir = new Map();
-    // 为每个页面确定其所属的目录路径
-    for (const page of normalPages) {
-        const dirPath = determineDirectoryPath(page);
-        if (!pagesByDir.has(dirPath)) {
-            pagesByDir.set(dirPath, []);
-        }
-        pagesByDir.get(dirPath).push(page);
-    }
-    // 确定需要创建的目录路由
-    const routesToCreate = determineDirectoryRoutes(pagesByDir, layoutFiles);
-    return { map: pagesByDir, routesToCreate };
-}
-/**
- * 确定页面所属的目录路径
- *
- * @param page - 页面信息
- * @returns 目录路径
- */
-function determineDirectoryPath(page) {
-    const pathParts = page.path.split('/').filter(Boolean);
-    // 索引页面的目录路径就是其自身路径
-    if (page.isIndex) {
-        return page.path;
-    }
-    // 根目录下的页面，目录路径为 /
-    if (page.parentPath === '' || page.parentPath === '/') {
-        return '/';
-    }
-    // 只有一级路径的页面，目录路径为 /
-    if (pathParts.length <= 1) {
-        return '/';
-    }
-    // 多级路径的页面，目录路径为去掉最后一级的路径
-    return '/' + pathParts.slice(0, -1).join('/');
-}
-/**
- * 确定需要创建的目录路由
- *
- * @param pagesByDir - 按目录分组的页面
- * @param layoutFiles - 布局文件映射
- * @returns 需要创建的目录路由路径集合
- */
-function determineDirectoryRoutes(pagesByDir, layoutFiles) {
-    const routesToCreate = new Set();
-    for (const [dirPath, dirPages] of pagesByDir) {
-        // 跳过根目录
-        if (dirPath === '/')
-            continue;
-        // 目录下有多个页面，需要创建目录路由
-        if (dirPages.length > 1) {
-            routesToCreate.add(dirPath);
-        }
-        // 目录下只有一个页面但存在布局文件，也需要创建目录路由
-        else if (dirPages.length === 1 && layoutFiles.has(dirPath)) {
-            routesToCreate.add(dirPath);
-        }
-    }
-    return routesToCreate;
-}
-/**
- * 收集所有需要处理的目录路径
- *
- * @param routesToCreate - 需要创建的目录路由
- * @returns 所有目录路径集合
- */
-function collectAllDirectoryPaths(routesToCreate) {
-    const allDirPaths = new Set();
-    for (const dirPath of routesToCreate) {
-        allDirPaths.add(dirPath);
-        const pathParts = dirPath.split('/').filter(Boolean);
-        // 收集所有父级目录路径
-        for (let i = 1; i < pathParts.length; i++) {
-            const parentPath = '/' + pathParts.slice(0, i).join('/');
-            if (routesToCreate.has(parentPath)) {
-                allDirPaths.add(parentPath);
-            }
-        }
-    }
-    return allDirPaths;
-}
-/**
- * 构建目录路由
- *
- * @param allDirPaths - 所有目录路径
- * @param pagesByDir - 按目录分组的页面
- * @param layoutFiles - 布局文件映射
- * @returns 目录路由映射
- */
-function buildDirectoryRoutes(allDirPaths, pagesByDir, layoutFiles) {
-    const dirRoutes = new Map();
-    for (const dirPath of allDirPaths) {
-        const pathParts = dirPath.split('/').filter(Boolean);
-        const dirName = pathParts[pathParts.length - 1] || '';
-        // 检查是否存在对应的布局文件
-        const layoutFile = layoutFiles.get(dirPath);
-        const dirPages = pagesByDir.get(dirPath) || [];
-        // 创建目录路由配置
-        const dirRoute = layoutFile
-            ? { ...layoutFile, children: [] }
-            : {
-                path: dirPath,
-                name: dirName,
-                filePath: '',
-                params: [],
-                isIndex: false,
-                isDynamic: false,
-                children: [],
-                parentPath: pathParts.length > 1 ? '/' + pathParts.slice(0, -1).join('/') : ''
-            };
-        // 添加子路由
-        for (const page of dirPages) {
-            dirRoute.children.push(createChildRoute(page));
-        }
-        dirRoutes.set(dirPath, dirRoute);
-    }
-    return dirRoutes;
-}
-/**
- * 创建子路由
- *
- * @param page - 页面信息
- * @returns 子路由配置
- */
-function createChildRoute(page) {
-    const pathParts = page.path.split('/').filter(Boolean);
-    const relativePath = pathParts[pathParts.length - 1] || '';
-    // 创建子路由配置，使用相对路径
-    const childRoute = {
-        ...page,
-        path: page.isIndex ? '' : relativePath,
-        children: []
-    };
-    // 为索引路由添加特殊的名称后缀
-    if (page.isIndex && page.name) {
-        childRoute.name = `${page.name}-index`;
-    }
-    return childRoute;
-}
-/**
- * 组装最终路由树
- *
- * @param pagesByDir - 按目录分组的页面
- * @param dirRoutes - 目录路由映射
- * @param routesToCreate - 需要创建的目录路由
- * @param layoutFiles - 布局文件映射
- * @returns 路由树根节点列表
- */
-function assembleRouteTree(pagesByDir, dirRoutes, routesToCreate, layoutFiles) {
-    const root = [];
-    // 添加根目录下的页面
-    const rootPages = pagesByDir.get('/') || [];
-    for (const page of rootPages) {
-        root.push({ ...page, children: [] });
-    }
-    // 添加不需要创建目录路由的页面
-    for (const [dirPath, dirPages] of pagesByDir) {
-        if (dirPath === '/')
-            continue;
-        if (routesToCreate.has(dirPath))
-            continue;
-        if (dirPages.length === 1) {
-            const page = dirPages[0];
-            root.push({ ...page, children: [] });
-        }
-    }
-    // 组装目录路由
-    for (const [dirPath, dirRoute] of dirRoutes) {
-        const pathParts = dirPath.split('/').filter(Boolean);
-        // 一级目录路由直接添加到根
-        if (pathParts.length === 1) {
-            root.push(dirRoute);
-        }
-        else {
-            // 多级目录路由添加到父级路由
-            const parentDirPath = '/' + pathParts.slice(0, -1).join('/');
-            const parentRoute = dirRoutes.get(parentDirPath);
-            if (parentRoute) {
-                const relativePath = pathParts[pathParts.length - 1];
-                parentRoute.children.push({
-                    ...dirRoute,
-                    path: relativePath
-                });
-            }
-            else {
-                // 如果父级路由不存在，直接添加到根
-                root.push(dirRoute);
-            }
-        }
-    }
-    // 添加未被处理的布局文件
-    for (const layoutFile of layoutFiles.values()) {
-        if (!dirRoutes.has(layoutFile.path)) {
-            root.push(layoutFile);
-        }
-    }
-    return root;
-}
-/**
- * 处理路由的子路由
- *
- * @param routes - 路由列表
- * @returns 处理后的路由列表
- */
-function processRouteChildren(routes) {
-    // 先排序路由，然后处理子路由
-    return sortRoutes(routes).map(route => {
-        const processed = { ...route, children: [] };
-        if (route.children.length > 0) {
-            processed.children = route.children.map(child => {
-                const newChild = {
-                    ...child,
-                    children: []
-                };
-                // 递归处理子路由
-                if (child.children.length > 0) {
-                    newChild.children = processRouteChildren(child.children);
-                }
-                return newChild;
-            });
-        }
-        return processed;
-    });
-}
-/**
- * 排序路由
- *
- * 排序规则：
- * 1. 索引路由优先
- * 2. 静态路由优先于动态路由
- * 3. 按路径字母顺序排序
- *
- * @param routes - 路由列表
- * @returns 排序后的路由列表
- */
-function sortRoutes(routes) {
-    return routes
-        .sort((a, b) => {
-        // 索引路由优先
-        if (a.isIndex && !b.isIndex)
-            return -1;
-        if (!a.isIndex && b.isIndex)
-            return 1;
-        // 静态路由优先于动态路由
-        if (a.isDynamic && !b.isDynamic)
-            return 1;
-        if (!a.isDynamic && b.isDynamic)
-            return -1;
-        // 按路径字母顺序排序
-        return a.path.localeCompare(b.path);
-    })
-        .map(route => ({
-        ...route,
-        // 递归排序子路由
-        children: sortRoutes(route.children)
-    }));
-}
-/**
- * 构建路由树
- *
- * 核心规则：
- * 1. 同名文件+目录组合：文件作为布局组件，目录内文件作为子路由
- * 2. 目录下的所有文件（包括 index）都作为子路由
- * 3. 子路由使用相对路径
- * 4. 有 index 子路由时自动添加 redirect
- * 5. 只有 index 文件的目录不创建目录路由
- *
- * @param pages - 解析后的页面列表
- * @returns 路由树根节点列表
- */
-export function buildRouteTree(pages) {
-    // 1. 分组布局文件和普通页面
-    const { layoutFiles, normalPages } = groupPagesByType(pages);
-    // 2. 按目录分组页面并确定需要创建的目录路由
-    const { map: pagesByDir, routesToCreate } = groupPagesByDirectory(normalPages, layoutFiles);
-    // 3. 收集所有需要处理的目录路径
-    const allDirPaths = collectAllDirectoryPaths(routesToCreate);
-    // 4. 构建目录路由
-    const dirRoutes = buildDirectoryRoutes(allDirPaths, pagesByDir, layoutFiles);
-    // 5. 组装最终路由树
-    const root = assembleRouteTree(pagesByDir, dirRoutes, routesToCreate, layoutFiles);
-    // 6. 处理子路由并排序
-    return processRouteChildren(root);
-}

package/dist/file-router/scanner/scanPages.d.ts

@@ -1,48 +0,0 @@
-import type { ResolvedPageConfig } from '../config/index.js';
-import type { NamingStrategy, ParsedPage } from '../types.js';
-/**
- * 页面扫描选项
- *
- * 配置 scanPages 函数的扫描行为。
- */
-export interface ScanOptions {
-    /**
-     * 页面配置
-     */
-    page: ResolvedPageConfig;
-    /** 要处理的文件扩展名列表 */
-    extensions: string[];
-    /**
-     * 路由命名策略
-     * - `kebab`: 将驼峰命名转换为 kebab-case（默认）
-     * - `lowercase`: 简单转换为小写
-     * - `none`: 保持原始命名
-     * @default 'kebab'
-     */
-    namingStrategy: NamingStrategy;
-}
-/**
- * 多目录扫描选项
- *
- * 用于扫描多个页面目录，每个目录可以有独立的包含/排除规则。
- */
-export interface MultiScanOptions {
-    /** 页面目录配置列表 */
-    pages: ResolvedPageConfig[];
-    /** 要处理的文件扩展名列表 */
-    extensions: string[];
-    /**
-     * 路由命名策略
-     * - `kebab`: 将驼峰命名转换为 kebab-case（默认）
-     * - `lowercase`: 简单转换为小写
-     * - `none`: 保持原始命名
-     */
-    namingStrategy: NamingStrategy;
-}
-/**
- * 扫描多个页面目录
- *
- * @param options - 多目录扫描选项
- * @returns 合并后的页面列表
- */
-export declare function scanMultiplePages(options: MultiScanOptions): ParsedPage[];

package/dist/file-router/scanner/scanPages.js

@@ -1,174 +0,0 @@
-/**
- * @fileoverview 页面扫描模块
- *
- * 负责扫描指定目录下的页面文件，并构建路由树结构。
- * 支持同名文件+目录组合（布局路由）、嵌套路由、glob 包含/排除规则。
- * 与构建工具无关，可在任何 Node.js 环境中使用。
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { parsePageFile } from '../parser/index.js';
-import { warn } from '../utils/logger.js';
-import { shouldProcessFile } from './filterUtils.js';
-/**
- * 聚合命名视图
- *
- * 将同一路径下的命名视图文件合并到主页面配置中。
- *
- * @param pages - 页面列表
- * @returns 聚合后的页面列表
- */
-function aggregateNamedViews(pages) {
-    // 按路径分组页面
-    const pagesByPath = new Map();
-    for (const page of pages) {
-        if (!pagesByPath.has(page.path)) {
-            pagesByPath.set(page.path, []);
-        }
-        pagesByPath.get(page.path).push(page);
-    }
-    const aggregatedPages = [];
-    for (const [path, pathPages] of pagesByPath) {
-        // 分离默认视图和命名视图
-        const defaultPages = pathPages.filter(p => p.viewName === null || p.viewName === 'default');
-        const namedViews = pathPages.filter(p => p.viewName !== null && p.viewName !== 'default');
-        // 检查是否只有命名视图而没有默认视图
-        if (defaultPages.length === 0 && namedViews.length > 0) {
-            const namedViewFiles = namedViews.map(p => p.filePath).join(', ');
-            const firstNamedView = namedViews[0];
-            const baseName = firstNamedView.filePath.split('/').pop()?.split('@')[0].split('.')[0] || 'index';
-            throw new Error(`[file-router] 命名视图错误: 路径 "${path}" 只有命名视图文件 (${namedViewFiles})，` +
-                `缺少默认视图文件 (${baseName}.tsx 或 ${baseName}@default.tsx)。\n` +
-                `修复方案: 添加 ${baseName}.tsx 或 ${baseName}@default.tsx 文件。`);
-        }
-        // 如果没有命名视图，直接添加所有页面
-        if (namedViews.length === 0) {
-            aggregatedPages.push(...pathPages);
-            continue;
-        }
-        // 以第一个默认视图为基础，添加命名视图
-        const basePage = { ...defaultPages[0], children: defaultPages[0].children || [] };
-        basePage.namedViews = {};
-        namedViews.forEach(page => {
-            basePage.namedViews[page.viewName] = page.filePath;
-        });
-        aggregatedPages.push(basePage);
-    }
-    return aggregatedPages;
-}
-/**
- * 扫描单个目录
- *
- * @param dir - 目录路径
- * @param pageDir - 页面根目录
- * @param parentPath - 父级路径
- * @param extensions - 文件扩展名
- * @param include - 包含模式
- * @param exclude - 排除模式
- * @param namingStrategy - 命名策略
- * @param pathPrefix - 路径前缀
- * @param pages - 页面收集器
- */
-function scanDirectory(dir, pageDir, parentPath, extensions, include, exclude, namingStrategy, pathPrefix, pages) {
-    // 读取目录内容
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const directories = [];
-    const files = [];
-    // 分类目录和文件
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        const isDir = entry.isDirectory();
-        // 检查是否应该处理该文件/目录
-        if (!shouldProcessFile(fullPath, pageDir, include, exclude, isDir)) {
-            continue;
-        }
-        if (isDir) {
-            directories.push(entry);
-        }
-        else if (entry.isFile()) {
-            files.push(entry);
-        }
-    }
-    // 收集目录名和文件名（用于检测布局路由）
-    const dirNames = new Set(directories.map(d => d.name));
-    const fileBaseNames = new Map();
-    // 处理文件，检查扩展名和同名冲突
-    for (const file of files) {
-        const ext = path.extname(file.name);
-        if (!extensions.includes(ext))
-            continue;
-        const baseName = path.basename(file.name, ext);
-        const existing = fileBaseNames.get(baseName);
-        // 处理同名文件冲突（不同扩展名）
-        if (existing) {
-            warn(`同名文件冲突: "${baseName}"`, `存在多个扩展名版本 (${existing.ext} 和 ${ext})，将忽略 "${file.name}"`);
-            continue;
-        }
-        fileBaseNames.set(baseName, { entry: file, ext });
-    }
-    // 解析文件并检查布局路由
-    for (const [baseName, { entry }] of fileBaseNames) {
-        const filePath = path.join(dir, entry.name);
-        // 检查是否存在同名目录（布局路由）
-        const hasSameNameDir = dirNames.has(baseName);
-        // 解析页面文件
-        const parsed = parsePageFile(filePath, pageDir, parentPath, namingStrategy, pathPrefix);
-        if (parsed) {
-            // 如果存在同名目录，标记为布局文件
-            if (hasSameNameDir) {
-                parsed.isLayoutFile = true;
-            }
-            pages.push(parsed);
-        }
-    }
-    // 递归扫描子目录
-    for (const directory of directories) {
-        const dirPath = path.join(dir, directory.name);
-        const newParentPath = parentPath ? `${parentPath}/${directory.name}` : directory.name;
-        scanDirectory(dirPath, pageDir, newParentPath, extensions, include, exclude, namingStrategy, pathPrefix, pages);
-    }
-}
-/**
- * 扫描页面目录
- *
- * 核心流程：
- * 1. 递归扫描目录，收集文件和子目录
- * 2. 检测同名文件+目录组合（布局路由）
- * 3. 解析每个文件为 ParsedPage
- * 4. 聚合命名视图
- *
- * @param options - 扫描选项
- * @returns - 解析后的页面列表
- */
-function scanPages(options) {
-    // 检查目录是否存在
-    if (!fs.existsSync(options.page.dir))
-        return [];
-    const { extensions, namingStrategy, page } = options;
-    const { include, exclude, prefix, dir } = page;
-    const pages = [];
-    // 扫描目录并收集页面
-    scanDirectory(dir, dir, '', extensions, include, exclude || [], namingStrategy, prefix, pages);
-    // 聚合命名视图
-    return aggregateNamedViews(pages);
-}
-/**
- * 扫描多个页面目录
- *
- * @param options - 多目录扫描选项
- * @returns 合并后的页面列表
- */
-export function scanMultiplePages(options) {
-    const { pages, extensions, namingStrategy = 'kebab' } = options;
-    const allPages = [];
-    // 扫描每个页面目录
-    for (const dirConfig of pages) {
-        const pages = scanPages({
-            page: dirConfig,
-            extensions,
-            namingStrategy
-        });
-        allPages.push(...pages);
-    }
-    return allPages;
-}