@vlian/framework 1.2.57 → 1.2.59

package/dist/core/router/utils/transform.js

@@ -1,791 +1 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { logger } from "@vlian/logger";
-import { SecurityUtils, SecurityError, ValidationError } from "@vlian/utils";
-/**
- * LRU 缓存实现
- */ let LRUCache = class LRUCache {
-    get(key) {
-        const item = this.cache.get(key);
-        if (item) {
-            // 更新访问时间
-            item.accessTime = Date.now();
-            // 移动到末尾（最近使用）
-            this.cache.delete(key);
-            this.cache.set(key, item);
-        }
-        return item;
-    }
-    set(key, value) {
-        // 如果已存在，先删除
-        if (this.cache.has(key)) {
-            this.cache.delete(key);
-        } else if (this.cache.size >= this.maxSize) {
-            // 如果达到最大大小，删除最久未使用的项（第一个）
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey) {
-                this.cache.delete(firstKey);
-            }
-        }
-        value.accessTime = Date.now();
-        this.cache.set(key, value);
-    }
-    delete(key) {
-        return this.cache.delete(key);
-    }
-    clear() {
-        this.cache.clear();
-    }
-    size() {
-        return this.cache.size;
-    }
-    cleanupExpired(cacheTTL) {
-        const now = Date.now();
-        for (const [key, item] of this.cache.entries()){
-            if (now - item.timestamp > cacheTTL) {
-                this.cache.delete(key);
-            }
-        }
-    }
-    constructor(maxSize = 50){
-        _define_property(this, "cache", new Map());
-        _define_property(this, "maxSize", void 0);
-        this.maxSize = maxSize;
-    }
-};
-/**
- * 转换缓存（使用 LRU 缓存）
- */ let transformCache = null;
-/**
- * 默认配置
- */ const DEFAULT_OPTIONS = {
-    pathValidation: {
-        enablePathValidation: true,
-        // 默认仅允许常见本地模块路径，生产环境建议进一步收紧。
-        allowedPathPrefixes: [
-            '@/',
-            './',
-            '../'
-        ],
-        maxPathLength: 500,
-        allowAbsolutePaths: false
-    },
-    performance: {
-        enableCache: true,
-        cacheTTL: 5 * 60 * 1000,
-        maxCacheSize: 50,
-        maxRecursionDepth: 100,
-        enableParallelProcessing: true,
-        parallelBatchSize: 10
-    },
-    enableDebugLog: false
-};
-/**
- * 优化的字符串哈希函数（用于缓存键）
- * 使用更高效的哈希算法，支持大字符串
- */ function optimizedHash(str) {
-    // 对于小字符串，使用快速哈希
-    if (str.length < 100) {
-        let hash = 0;
-        for(let i = 0; i < str.length; i++){
-            const char = str.charCodeAt(i);
-            hash = (hash << 5) - hash + char;
-            hash = hash & hash; // 转换为 32 位整数
-        }
-        return Math.abs(hash).toString(36);
-    }
-    // 对于大字符串，使用分段哈希
-    let hash = 0;
-    const step = Math.max(1, Math.floor(str.length / 100));
-    for(let i = 0; i < str.length; i += step){
-        const char = str.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash;
-    }
-    return Math.abs(hash).toString(36);
-}
-/**
- * 使用 crypto API 的哈希函数（如果可用）
- * 保留此函数供未来使用（异步哈希场景）
- */ // async function cryptoHash(str: string): Promise<string> {
-//   // 检查是否支持 crypto API
-//   if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.digest) {
-//     try {
-//       const encoder = new TextEncoder();
-//       const data = encoder.encode(str);
-//       const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-//       const hashArray = Array.from(new Uint8Array(hashBuffer));
-//       return hashArray.map(b => b.toString(16).padStart(2, '0')).join('').substring(0, 16);
-//     } catch {
-//       // 如果 crypto API 失败，回退到优化哈希
-//       return optimizedHash(str);
-//     }
-//   }
-//   return optimizedHash(str);
-// }
-/**
- * 同步哈希函数（用于同步场景）
- */ function simpleHash(str) {
-    return optimizedHash(str);
-}
-function serializeComponentRef(value) {
-    if (typeof value === 'string') {
-        return {
-            str: value
-        };
-    }
-    if (typeof value === 'function') {
-        // 函数引用无法稳定序列化源码，使用名称和长度参与哈希，避免同名不同体完全碰撞。
-        const fnText = String(value);
-        return {
-            fn: `${value.name || 'anonymous'}:${fnText.length}`
-        };
-    }
-    return {};
-}
-function serializeRouteConfig(route) {
-    const page = serializeComponentRef(route.page);
-    const layout = serializeComponentRef(route.layout);
-    const routeError = serializeComponentRef(route.error ?? route.errors);
-    const loading = serializeComponentRef(route.loading);
-    return {
-        name: route.name,
-        path: route.path,
-        page: page.str,
-        pageFn: page.fn,
-        layout: layout.str,
-        layoutFn: layout.fn,
-        error: routeError.str,
-        errorFn: routeError.fn,
-        loading: loading.str,
-        loadingFn: loading.fn,
-        isGroup: route.isGroup,
-        enableRedirection: route.enableRedirection,
-        handle: route.handle ? {
-            title: route.handle.title,
-            order: route.handle.order,
-            needLogin: route.handle.needLogin,
-            roles: Array.isArray(route.handle.roles) ? [
-                ...route.handle.roles
-            ] : undefined
-        } : undefined,
-        children: route.children?.map((child)=>serializeRouteConfig(child))
-    };
-}
-/**
- * 生成配置哈希（用于缓存键）
- * 优化：缓存序列化结果，避免重复序列化
- */ function generateConfigHash(routes) {
-    try {
-        if (routes.length === 0) {
-            return 'empty';
-        }
-        const serializedRoutes = routes.map((route)=>serializeRouteConfig(route));
-        const configStr = JSON.stringify(serializedRoutes);
-        return simpleHash(configStr);
-    } catch  {
-        return '';
-    }
-}
-/**
- * 路径验证缓存（已验证的路径）
- */ const validatedPathCache = new Set();
-/**
- * 预编译的正则表达式（用于路径验证）
- */ const PATH_TRAVERSAL_REGEX = /\.\.(\/|\\)|\.\.%2[Ff]|\.\.%5[Cc]|%2[Ee]%2[Ee]%2[Ff]|%2[Ee]%2[Ee]%5[Cc]/i;
-const ABSOLUTE_PATH_REGEX = /^\/|^[A-Za-z]:\\/;
-const CONTROL_CHAR_REGEX = /[\x00-\x1f\x7f]/;
-const NULL_BYTE_REGEX = /%00|\\0|\x00/;
-const URL_SCHEME_REGEX = /^[A-Za-z][A-Za-z0-9+.-]*:/;
-// 保留供未来使用（命令注入检测）
-// const COMMAND_INJECTION_REGEX = /[;|&$`]/;
-// const ALLOWED_CHARS_REGEX = /^[a-zA-Z0-9\/\-_.@]+$/;
-/**
- * 验证路径是否安全
- * 优化：添加验证缓存、预编译正则、早期返回
- */ function validatePath(path, config) {
-    // 早期返回：检查缓存
-    if (validatedPathCache.has(path)) {
-        return {
-            valid: true
-        };
-    }
-    // 早期返回：检查路径长度（最快检查）
-    if (path.length > config.maxPathLength) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? `路径长度超过最大限制 ${config.maxPathLength} 字符` : '路径验证失败'
-        };
-    }
-    // 早期返回：检查空字符串
-    if (path.length === 0) {
-        return {
-            valid: false,
-            error: '路径不能为空'
-        };
-    }
-    // 检查路径遍历攻击（使用预编译正则）
-    if (PATH_TRAVERSAL_REGEX.test(path)) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? '路径包含路径遍历字符（../），可能存在安全风险' : '路径验证失败'
-        };
-    }
-    // 检查空字节注入
-    if (NULL_BYTE_REGEX.test(path)) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? '路径包含空字节，可能存在安全风险' : '路径验证失败'
-        };
-    }
-    // 检查控制字符
-    if (CONTROL_CHAR_REGEX.test(path)) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? '路径包含控制字符，可能存在安全风险' : '路径验证失败'
-        };
-    }
-    // 检查命令注入字符（可选，根据需求决定是否启用）
-    // if (COMMAND_INJECTION_REGEX.test(path)) {
-    //   return {
-    //     valid: false,
-    //     error: process.env.NODE_ENV === 'development'
-    //       ? '路径包含潜在的命令注入字符'
-    //       : '路径验证失败',
-    //   };
-    // }
-    // 禁止 URL scheme 导入（如 http:, https:, data:, javascript:）
-    if (URL_SCHEME_REGEX.test(path)) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? '不允许使用带协议的路径' : '路径验证失败'
-        };
-    }
-    // 检查绝对路径（使用预编译正则）
-    if (!config.allowAbsolutePaths && ABSOLUTE_PATH_REGEX.test(path)) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? '不允许使用绝对路径' : '路径验证失败'
-        };
-    }
-    // 默认仅允许相对路径和别名路径，避免把第三方包名作为动态入口。
-    if (!path.startsWith('@/') && !path.startsWith('./') && !path.startsWith('../')) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? '仅允许使用 @/、./、../ 开头的模块路径' : '路径验证失败'
-        };
-    }
-    // 检查路径前缀白名单（优化：使用 Set 提高查找速度）
-    if (config.allowedPathPrefixes.length > 0) {
-        const prefixSet = new Set(config.allowedPathPrefixes);
-        const isAllowed = Array.from(prefixSet).some((prefix)=>path.startsWith(prefix));
-        if (!isAllowed) {
-            return {
-                valid: false,
-                error: process.env.NODE_ENV === 'development' ? `路径不在允许的前缀列表中: ${config.allowedPathPrefixes.join(', ')}` : '路径验证失败'
-            };
-        }
-    }
-    // 使用 SecurityUtils 验证输入（最后检查，因为可能较慢）
-    const validation = SecurityUtils.validateInput(path);
-    if (!validation.safe) {
-        return {
-            valid: false,
-            error: process.env.NODE_ENV === 'development' ? validation.reason || '路径包含潜在的危险内容' : '路径验证失败'
-        };
-    }
-    // 验证通过，添加到缓存（限制缓存大小）
-    if (validatedPathCache.size < 1000) {
-        validatedPathCache.add(path);
-    }
-    return {
-        valid: true
-    };
-}
-/**
- * 预编译的正则表达式（用于路径规范化）
- */ const NORMALIZE_REGEX = {
-    multipleSlashes: /\/+/g,
-    dotSlash: /\/\.\//g,
-    trailingDot: /\/\.$/
-};
-/**
- * 规范化路径
- * 优化：合并正则表达式，减少替换次数
- */ function normalizePath(path) {
-    // 合并多个替换操作，减少字符串遍历次数
-    return path.replace(NORMALIZE_REGEX.multipleSlashes, '/').replace(NORMALIZE_REGEX.dotSlash, '/').replace(NORMALIZE_REGEX.trailingDot, '').trim();
-}
-/**
- * 类型守卫：检查是否为有效路径字符串
- */ function isValidPathString(path) {
-    return typeof path === 'string' && path.length > 0;
-}
-/**
- * 类型守卫：检查是否为动态导入函数
- */ function isComponentImport(path) {
-    return typeof path === 'function';
-}
-/**
- * 创建动态导入函数
- * 
- * 将组件路径字符串转换为动态导入函数，用于代码分割和懒加载
- * 
- * @param path - 组件路径字符串，支持相对路径和别名路径（如 '@/pages/home.tsx'）
- * @returns 返回动态导入函数，调用后会返回 Promise，resolve 后的值为组件模块对象
- * 
- * @remarks
- * - 使用 `@vite-ignore` 注释告诉 Vite 忽略此动态导入的静态分析
- * - 使用类型断言 `as any` 是因为 TypeScript 的 `import()` 需要静态字符串字面量
- * - 在运行时，我们可以使用动态路径进行导入
- * - 组件必须使用默认导出（export default）
- * 
- * @example
- * ```typescript
- * const importFn = createDynamicImport('@/pages/home.tsx');
- * const module = await importFn();
- * const HomePage = module.default;
- * ```
- */ function createDynamicImport(path) {
-    // 使用类型断言，因为 TypeScript 的 import() 需要静态字符串
-    // 但在运行时，我们可以使用动态路径
-    return ()=>import(/* @vite-ignore */ path);
-}
-/**
- * 提取并验证组件路径到 Map 中
- * 
- * 如果路径有效且 Map 中不存在，则创建动态导入函数并存储到 Map 中
- * 这样可以避免重复创建相同路径的动态导入函数，提高性能
- * 
- * @param path - 组件路径，可能是字符串、动态导入函数、null 或 undefined
- * @param map - 目标 Map，用于存储路径到动态导入函数的映射
- * @param config - 路径验证配置
- * @param options - 转换选项
- * @returns 如果成功提取，返回动态导入函数；否则返回 null
- * 
- * @remarks
- * - 如果 path 是函数，直接返回，不添加到 Map（函数本身就可以直接使用）
- * - 只有当路径是有效的非空字符串时才会处理并添加到 Map
- * - 如果 Map 中已存在该路径，则直接返回已有的导入函数
- * - 优化：使用 `get()` 一次获取，判断是否为 undefined，减少函数调用
- * - 会进行路径验证和清理
- * 
- * @example
- * ```typescript
- * const pages = new Map<string, () => Promise<any>>();
- * const importFn1 = extractAndValidatePath('@/pages/home.tsx', pages, config, options);
- * const importFn2 = extractAndValidatePath(() => import('@/pages/home.tsx'), pages, config, options);
- * ```
- */ function extractAndValidatePath(path, map, config, options) {
-    // 早期返回：如果是函数，直接返回，不添加到 Map
-    if (isComponentImport(path)) {
-        return path;
-    }
-    // 早期返回：检查是否为有效路径字符串
-    if (!isValidPathString(path)) {
-        return null;
-    }
-    // 规范化路径
-    const normalizedPath = normalizePath(path);
-    // 优化：先检查 Map 中是否已存在（避免不必要的验证）
-    const existingImport = map.get(normalizedPath);
-    if (existingImport !== undefined) {
-        return existingImport;
-    }
-    // 路径验证（仅在 Map 中不存在时进行）
-    if (config.enablePathValidation) {
-        const validation = validatePath(normalizedPath, config);
-        if (!validation.valid) {
-            // 生产环境错误信息脱敏
-            const errorMessage = process.env.NODE_ENV === 'development' ? `路径验证失败: ${validation.error}` : '路径验证失败';
-            const error = new SecurityError(errorMessage, undefined, process.env.NODE_ENV === 'development' ? {
-                path: normalizedPath
-            } : {});
-            if (options.enableDebugLog) {
-                logger.error('路径验证失败:', error);
-            }
-            // 开发环境抛出错误，生产环境记录警告并跳过
-            if (process.env.NODE_ENV === 'development') {
-                throw error;
-            } else {
-                // 生产环境日志脱敏
-                logger.warn('路径验证失败，已跳过');
-                return null;
-            }
-        }
-    }
-    // 创建动态导入函数并存储
-    const importFn = createDynamicImport(normalizedPath);
-    map.set(normalizedPath, importFn);
-    if (options.enableDebugLog) {
-        logger.debug('提取路径:', normalizedPath);
-    }
-    return importFn;
-}
-/**
- * 对象池：复用栈节点对象，减少 GC 压力
- */ let StackNodePool = class StackNodePool {
-    acquire(route, depth) {
-        if (this.pool.length > 0) {
-            const node = this.pool.pop();
-            node.route = route;
-            node.depth = depth;
-            return node;
-        }
-        return {
-            route,
-            depth
-        };
-    }
-    release(node) {
-        if (this.pool.length < this.maxPoolSize) {
-            this.pool.push(node);
-        }
-    }
-    constructor(){
-        _define_property(this, "pool", []);
-        _define_property(this, "maxPoolSize", 100);
-    }
-};
-const stackNodePool = new StackNodePool();
-/**
- * 只提取组件路径到 Map 中，不转换路由配置
- * 
- * 使用迭代方式遍历所有路由（包括子路由），提取组件路径到对应的 Map 中
- * 这种设计可以确保：
- * - 相同的组件路径只会创建一个动态导入函数
- * - 使用迭代而非递归，避免栈溢出
- * - 优化：支持并行处理、使用对象池、预分配数组
- * 
- * @param routes - 原始路由配置列表
- * @param result - 结果对象，用于累积收集的组件路径
- * @param config - 路径验证配置
- * @param options - 转换选项
- * @param maxDepth - 最大递归深度
- */ async function extractPathsOnly(routes, result, config, options, maxDepth) {
-    const enableParallel = options.performance?.enableParallelProcessing ?? true;
-    const batchSize = options.performance?.parallelBatchSize ?? 10;
-    // 如果启用并行处理且路由数量较多，使用并行处理
-    if (enableParallel && routes.length > batchSize) {
-        // 收集所有需要处理的路径（只收集字符串类型，函数类型不需要处理）
-        const pathsToProcess = [];
-        // 遍历所有路由，收集路径
-        const stack = [];
-        for(let i = routes.length - 1; i >= 0; i--){
-            stack.push({
-                route: routes[i],
-                depth: 0
-            });
-        }
-        while(stack.length > 0){
-            const { route, depth } = stack.pop();
-            if (depth > maxDepth) {
-                logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`, route.name);
-                continue;
-            }
-            // 收集路径（只收集字符串类型，函数类型不需要处理，会直接使用）
-            if (route.page && typeof route.page === 'string') {
-                pathsToProcess.push({
-                    path: route.page,
-                    map: result.pages
-                });
-            }
-            if (route.layout && typeof route.layout === 'string') {
-                pathsToProcess.push({
-                    path: route.layout,
-                    map: result.layouts
-                });
-            }
-            const routeError = route.error ?? route.errors;
-            if (routeError && typeof routeError === 'string') {
-                pathsToProcess.push({
-                    path: routeError,
-                    map: result.errors
-                });
-            }
-            if (route.loading && typeof route.loading === 'string') {
-                pathsToProcess.push({
-                    path: route.loading,
-                    map: result.loadings
-                });
-            }
-            // 处理子路由
-            if (route.children && Array.isArray(route.children) && route.children.length > 0) {
-                for(let i = route.children.length - 1; i >= 0; i--){
-                    stack.push({
-                        route: route.children[i],
-                        depth: depth + 1
-                    });
-                }
-            }
-        }
-        // 并行处理路径（分批处理）
-        for(let i = 0; i < pathsToProcess.length; i += batchSize){
-            const batch = pathsToProcess.slice(i, i + batchSize);
-            await Promise.all(batch.map(({ path, map })=>Promise.resolve(extractAndValidatePath(path, map, config, options))));
-        }
-    } else {
-        // 串行处理（原有逻辑，优化：使用对象池）
-        const stack = [];
-        // 初始化栈：将所有路由推入栈中
-        for(let i = routes.length - 1; i >= 0; i--){
-            stack.push(stackNodePool.acquire(routes[i], 0));
-        }
-        // 迭代处理栈中的路由
-        while(stack.length > 0){
-            const node = stack.pop();
-            const { route, depth } = node;
-            // 检查递归深度
-            if (depth > maxDepth) {
-                logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`, route.name);
-                stackNodePool.release(node);
-                continue;
-            }
-            // 提取组件路径到 Map 中（同时进行验证）
-            extractAndValidatePath(route.page, result.pages, config, options);
-            extractAndValidatePath(route.layout, result.layouts, config, options);
-            extractAndValidatePath(route.error ?? route.errors, result.errors, config, options);
-            extractAndValidatePath(route.loading, result.loadings, config, options);
-            // 处理子路由
-            if (route.children && Array.isArray(route.children) && route.children.length > 0) {
-                // 将子路由推入栈中（逆序推入，保证处理顺序正确）
-                for(let i = route.children.length - 1; i >= 0; i--){
-                    stack.push(stackNodePool.acquire(route.children[i], depth + 1));
-                }
-            }
-            // 释放节点到对象池
-            stackNodePool.release(node);
-        }
-    }
-}
-/**
- * 清理过期缓存
- * 优化：使用 LRU 缓存的清理方法
- */ function cleanupExpiredCache(cacheTTL) {
-    if (transformCache) {
-        transformCache.cleanupExpired(cacheTTL);
-    }
-}
-/**
- * 转换路由配置：提取组件路径到 Map 中，返回原始路由配置
- * 
- * 此函数是路由转换的核心函数，主要完成以下任务：
- * 1. 递归提取路由配置中的所有组件路径（page、layout、errors、loading）
- * 2. 将组件路径字符串转换为动态导入函数
- * 3. 将动态导入函数存储在对应的 Map 中，key 为路径字符串，确保不重复
- * 4. 返回原始路由配置列表，不进行转换
- * 
- * @param routes - 路由配置列表，可以是：
- *   - 路由配置数组（RouteConfig[]）
- *   - 返回路由配置数组的函数（支持同步或异步：() => RouteConfig[] | Promise<RouteConfig[]>）
- *   支持异步函数是为了支持动态加载路由配置（如从服务器获取）
- * @param options - 转换配置选项
- * @returns 包含以下内容的结果对象：
- *   - `pages`: 页面组件路径到动态导入函数的 Map
- *   - `layouts`: 布局组件路径到动态导入函数的 Map
- *   - `errors`: 错误组件路径到动态导入函数的 Map
- *   - `loadings`: 加载组件路径到动态导入函数的 Map
- *   - `routes`: 原始路由配置列表，不进行转换
- * 
- * @remarks
- * - 如果 `routes` 为 null、undefined 或空数组，返回空结果对象
- * - 如果 `routes` 是函数但返回的不是数组，返回空结果对象
- * - 相同的组件路径只会创建一个动态导入函数，存储在 Map 中复用
- * - 路由配置保持原始格式，组件路径仍为字符串
- * - 支持嵌套路由，会递归处理所有层级的子路由
- * - 支持缓存，相同配置会直接返回缓存结果
- * 
- * @example
- * ```typescript
- * // 示例 1: 使用数组配置
- * const result = await transformRoutes([
- *   {
- *     name: 'home',
- *     path: '/',
- *     page: '@/pages/home.tsx',
- *     errors: '@/pages/error.tsx',
- *     handle: { title: '首页', order: 1 },
- *   },
- * ]);
- * 
- * // 示例 2: 使用异步函数配置
- * const result = await transformRoutes(async () => {
- *   const response = await fetch('/api/routes');
- *   return response.json();
- * });
- * 
- * // 示例 3: 使用配置选项
- * const result = await transformRoutes(routes, {
- *   pathValidation: {
- *     enablePathValidation: true,
- *     allowedPathPrefixes: ['@/pages', '@/components'],
- *   },
- *   performance: {
- *     enableCache: true,
- *     cacheTTL: 10 * 60 * 1000, // 10 分钟
- *   },
- * });
- * ```
- */ export async function transformRoutes(routes, options = {}) {
-    const startTime = performance.now();
-    const mergedOptions = {
-        pathValidation: {
-            ...DEFAULT_OPTIONS.pathValidation,
-            ...options.pathValidation
-        },
-        performance: {
-            ...DEFAULT_OPTIONS.performance,
-            ...options.performance
-        },
-        enableDebugLog: options.enableDebugLog ?? DEFAULT_OPTIONS.enableDebugLog
-    };
-    // 早期返回：如果 routes 为空或未定义，直接返回空结果
-    if (!routes) {
-        if (mergedOptions.enableDebugLog) {
-            logger.debug('路由配置为空，返回空结果');
-        }
-        return {
-            pages: new Map(),
-            layouts: new Map(),
-            errors: new Map(),
-            loadings: new Map(),
-            routes: []
-        };
-    }
-    // 处理 routes 可能是函数的情况
-    let routesArray;
-    try {
-        routesArray = typeof routes === 'function' ? await routes() : routes;
-    } catch (error) {
-        const err = error instanceof Error ? error : new Error('路由配置加载失败');
-        logger.error('路由配置加载失败:', err);
-        throw new ValidationError('路由配置加载失败', {
-            originalError: err
-        });
-    }
-    // 早期返回：如果 routesArray 不是数组，直接返回空结果
-    if (!Array.isArray(routesArray) || routesArray.length === 0) {
-        if (mergedOptions.enableDebugLog) {
-            logger.debug('路由配置不是数组或为空，返回空结果');
-        }
-        return {
-            pages: new Map(),
-            layouts: new Map(),
-            errors: new Map(),
-            loadings: new Map(),
-            routes: []
-        };
-    }
-    // 检查缓存
-    const cacheTTL = mergedOptions.performance.cacheTTL ?? DEFAULT_OPTIONS.performance.cacheTTL;
-    const maxCacheSize = mergedOptions.performance.maxCacheSize ?? DEFAULT_OPTIONS.performance.maxCacheSize;
-    if (mergedOptions.performance.enableCache) {
-        // 初始化 LRU 缓存（如果尚未初始化或大小发生变化）
-        if (!transformCache || transformCache.size() !== maxCacheSize) {
-            transformCache = new LRUCache(maxCacheSize);
-        }
-        const configHash = generateConfigHash(routesArray);
-        if (configHash) {
-            const cached = transformCache.get(configHash);
-            if (cached && Date.now() - cached.timestamp < cacheTTL) {
-                if (mergedOptions.enableDebugLog) {
-                    logger.debug('使用缓存结果');
-                }
-                // 直接返回缓存结果（LRU 缓存已处理访问时间更新）
-                return cached.result;
-            }
-        }
-        // 清理过期缓存
-        cleanupExpiredCache(cacheTTL);
-    }
-    // 初始化结果对象
-    const result = {
-        pages: new Map(),
-        layouts: new Map(),
-        errors: new Map(),
-        loadings: new Map(),
-        routes: []
-    };
-    try {
-        // 性能监控：记录各阶段耗时
-        const extractStartTime = performance.now();
-        // 提取组件路径到 Map 中（不转换路由配置）
-        const pathValidation = {
-            enablePathValidation: mergedOptions.pathValidation.enablePathValidation ?? DEFAULT_OPTIONS.pathValidation.enablePathValidation,
-            allowedPathPrefixes: mergedOptions.pathValidation.allowedPathPrefixes ?? DEFAULT_OPTIONS.pathValidation.allowedPathPrefixes,
-            maxPathLength: mergedOptions.pathValidation.maxPathLength ?? DEFAULT_OPTIONS.pathValidation.maxPathLength,
-            allowAbsolutePaths: mergedOptions.pathValidation.allowAbsolutePaths ?? DEFAULT_OPTIONS.pathValidation.allowAbsolutePaths
-        };
-        const maxRecursionDepth = mergedOptions.performance.maxRecursionDepth ?? DEFAULT_OPTIONS.performance.maxRecursionDepth;
-        // 异步提取路径（支持并行处理）
-        await extractPathsOnly(routesArray, result, pathValidation, mergedOptions, maxRecursionDepth);
-        const extractEndTime = performance.now();
-        const extractDuration = extractEndTime - extractStartTime;
-        // 直接使用原始路由配置，不进行转换
-        result.routes = routesArray;
-        // 缓存结果
-        const cacheStartTime = performance.now();
-        if (mergedOptions.performance.enableCache && transformCache) {
-            const configHash = generateConfigHash(routesArray);
-            if (configHash) {
-                // 注意：Map 中包含函数值，structuredClone 会失败；统一使用手动克隆。
-                const cachedResult = {
-                    pages: new Map(result.pages),
-                    layouts: new Map(result.layouts),
-                    errors: new Map(result.errors),
-                    loadings: new Map(result.loadings),
-                    routes: JSON.parse(JSON.stringify(result.routes))
-                };
-                transformCache.set(configHash, {
-                    result: cachedResult,
-                    timestamp: Date.now(),
-                    hash: configHash,
-                    accessTime: Date.now()
-                });
-            }
-        }
-        const cacheEndTime = performance.now();
-        const cacheDuration = cacheEndTime - cacheStartTime;
-        const endTime = performance.now();
-        const totalDuration = endTime - startTime;
-        if (mergedOptions.enableDebugLog) {
-            // 详细的性能报告
-            logger.debug(`路由转换完成，总耗时: ${totalDuration.toFixed(2)}ms`, {
-                routeCount: result.routes.length,
-                pageCount: result.pages.size,
-                layoutCount: result.layouts.size,
-                errorCount: result.errors.size,
-                loadingCount: result.loadings.size,
-                performance: {
-                    extractDuration: `${extractDuration.toFixed(2)}ms`,
-                    cacheDuration: `${cacheDuration.toFixed(2)}ms`,
-                    totalDuration: `${totalDuration.toFixed(2)}ms`
-                },
-                cache: {
-                    hit: transformCache ? 'miss' : 'disabled',
-                    size: transformCache?.size() ?? 0
-                }
-            });
-        }
-        return result;
-    } catch (error) {
-        const err = error instanceof Error ? error : new Error('路由转换失败');
-        logger.error('路由转换失败:', err);
-        throw new ValidationError('路由转换失败', {
-            originalError: err
-        });
-    }
-}
-
-//# sourceMappingURL=transform.js.map
+function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}import{logger}from"@vlian/logger";import{SecurityUtils,SecurityError,ValidationError}from"@vlian/utils";let LRUCache=class LRUCache{get(key){const item=this.cache.get(key);if(item){item.accessTime=Date.now();this.cache.delete(key);this.cache.set(key,item)}return item}set(key,value){if(this.cache.has(key)){this.cache.delete(key)}else if(this.cache.size>=this.maxSize){const firstKey=this.cache.keys().next().value;if(firstKey){this.cache.delete(firstKey)}}value.accessTime=Date.now();this.cache.set(key,value)}delete(key){return this.cache.delete(key)}clear(){this.cache.clear()}size(){return this.cache.size}cleanupExpired(cacheTTL){const now=Date.now();for(const[key,item]of this.cache.entries()){if(now-item.timestamp>cacheTTL){this.cache.delete(key)}}}constructor(maxSize=50){_define_property(this,"cache",new Map);_define_property(this,"maxSize",void 0);this.maxSize=maxSize}};let transformCache=null;const DEFAULT_OPTIONS={pathValidation:{enablePathValidation:true,allowedPathPrefixes:["@/","./","../"],maxPathLength:500,allowAbsolutePaths:false},performance:{enableCache:true,cacheTTL:5*60*1e3,maxCacheSize:50,maxRecursionDepth:100,enableParallelProcessing:true,parallelBatchSize:10},enableDebugLog:false};function optimizedHash(str){if(str.length<100){let hash=0;for(let i=0;i<str.length;i++){const char=str.charCodeAt(i);hash=(hash<<5)-hash+char;hash=hash&hash}return Math.abs(hash).toString(36)}let hash=0;const step=Math.max(1,Math.floor(str.length/100));for(let i=0;i<str.length;i+=step){const char=str.charCodeAt(i);hash=(hash<<5)-hash+char;hash=hash&hash}return Math.abs(hash).toString(36)}function simpleHash(str){return optimizedHash(str)}function serializeComponentRef(value){if(typeof value==="string"){return{str:value}}if(typeof value==="function"){const fnText=String(value);return{fn:`${value.name||"anonymous"}:${fnText.length}`}}return{}}function serializeRouteConfig(route){const page=serializeComponentRef(route.page);const layout=serializeComponentRef(route.layout);const routeError=serializeComponentRef(route.error??route.errors);const loading=serializeComponentRef(route.loading);return{name:route.name,path:route.path,page:page.str,pageFn:page.fn,layout:layout.str,layoutFn:layout.fn,error:routeError.str,errorFn:routeError.fn,loading:loading.str,loadingFn:loading.fn,isGroup:route.isGroup,enableRedirection:route.enableRedirection,handle:route.handle?{title:route.handle.title,order:route.handle.order,needLogin:route.handle.needLogin,roles:Array.isArray(route.handle.roles)?[...route.handle.roles]:undefined}:undefined,children:route.children?.map(child=>serializeRouteConfig(child))}}function generateConfigHash(routes){try{if(routes.length===0){return"empty"}const serializedRoutes=routes.map(route=>serializeRouteConfig(route));const configStr=JSON.stringify(serializedRoutes);return simpleHash(configStr)}catch{return""}}const validatedPathCache=new Set;const PATH_TRAVERSAL_REGEX=/\.\.(\/|\\)|\.\.%2[Ff]|\.\.%5[Cc]|%2[Ee]%2[Ee]%2[Ff]|%2[Ee]%2[Ee]%5[Cc]/i;const ABSOLUTE_PATH_REGEX=/^\/|^[A-Za-z]:\\/;const CONTROL_CHAR_REGEX=/[\x00-\x1f\x7f]/;const NULL_BYTE_REGEX=/%00|\\0|\x00/;const URL_SCHEME_REGEX=/^[A-Za-z][A-Za-z0-9+.-]*:/;function validatePath(path,config){if(validatedPathCache.has(path)){return{valid:true}}if(path.length>config.maxPathLength){return{valid:false,error:process.env.NODE_ENV==="development"?`路径长度超过最大限制 ${config.maxPathLength} 字符`:"路径验证失败"}}if(path.length===0){return{valid:false,error:"路径不能为空"}}if(PATH_TRAVERSAL_REGEX.test(path)){return{valid:false,error:process.env.NODE_ENV==="development"?"路径包含路径遍历字符（../），可能存在安全风险":"路径验证失败"}}if(NULL_BYTE_REGEX.test(path)){return{valid:false,error:process.env.NODE_ENV==="development"?"路径包含空字节，可能存在安全风险":"路径验证失败"}}if(CONTROL_CHAR_REGEX.test(path)){return{valid:false,error:process.env.NODE_ENV==="development"?"路径包含控制字符，可能存在安全风险":"路径验证失败"}}if(URL_SCHEME_REGEX.test(path)){return{valid:false,error:process.env.NODE_ENV==="development"?"不允许使用带协议的路径":"路径验证失败"}}if(!config.allowAbsolutePaths&&ABSOLUTE_PATH_REGEX.test(path)){return{valid:false,error:process.env.NODE_ENV==="development"?"不允许使用绝对路径":"路径验证失败"}}if(!path.startsWith("@/")&&!path.startsWith("./")&&!path.startsWith("../")){return{valid:false,error:process.env.NODE_ENV==="development"?"仅允许使用 @/、./、../ 开头的模块路径":"路径验证失败"}}if(config.allowedPathPrefixes.length>0){const prefixSet=new Set(config.allowedPathPrefixes);const isAllowed=Array.from(prefixSet).some(prefix=>path.startsWith(prefix));if(!isAllowed){return{valid:false,error:process.env.NODE_ENV==="development"?`路径不在允许的前缀列表中: ${config.allowedPathPrefixes.join(", ")}`:"路径验证失败"}}}const validation=SecurityUtils.validateInput(path);if(!validation.safe){return{valid:false,error:process.env.NODE_ENV==="development"?validation.reason||"路径包含潜在的危险内容":"路径验证失败"}}if(validatedPathCache.size<1e3){validatedPathCache.add(path)}return{valid:true}}const NORMALIZE_REGEX={multipleSlashes:/\/+/g,dotSlash:/\/\.\//g,trailingDot:/\/\.$/};function normalizePath(path){return path.replace(NORMALIZE_REGEX.multipleSlashes,"/").replace(NORMALIZE_REGEX.dotSlash,"/").replace(NORMALIZE_REGEX.trailingDot,"").trim()}function isValidPathString(path){return typeof path==="string"&&path.length>0}function isComponentImport(path){return typeof path==="function"}function createDynamicImport(path){return()=>import(path)}function extractAndValidatePath(path,map,config,options){if(isComponentImport(path)){return path}if(!isValidPathString(path)){return null}const normalizedPath=normalizePath(path);const existingImport=map.get(normalizedPath);if(existingImport!==undefined){return existingImport}if(config.enablePathValidation){const validation=validatePath(normalizedPath,config);if(!validation.valid){const errorMessage=process.env.NODE_ENV==="development"?`路径验证失败: ${validation.error}`:"路径验证失败";const error=new SecurityError(errorMessage,undefined,process.env.NODE_ENV==="development"?{path:normalizedPath}:{});if(options.enableDebugLog){logger.error("路径验证失败:",error)}if(process.env.NODE_ENV==="development"){throw error}else{logger.warn("路径验证失败，已跳过");return null}}}const importFn=createDynamicImport(normalizedPath);map.set(normalizedPath,importFn);if(options.enableDebugLog){logger.debug("提取路径:",normalizedPath)}return importFn}let StackNodePool=class StackNodePool{acquire(route,depth){if(this.pool.length>0){const node=this.pool.pop();node.route=route;node.depth=depth;return node}return{route,depth}}release(node){if(this.pool.length<this.maxPoolSize){this.pool.push(node)}}constructor(){_define_property(this,"pool",[]);_define_property(this,"maxPoolSize",100)}};const stackNodePool=new StackNodePool;async function extractPathsOnly(routes,result,config,options,maxDepth){const enableParallel=options.performance?.enableParallelProcessing??true;const batchSize=options.performance?.parallelBatchSize??10;if(enableParallel&&routes.length>batchSize){const pathsToProcess=[];const stack=[];for(let i=routes.length-1;i>=0;i--){stack.push({route:routes[i],depth:0})}while(stack.length>0){const{route,depth}=stack.pop();if(depth>maxDepth){logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`,route.name);continue}if(route.page&&typeof route.page==="string"){pathsToProcess.push({path:route.page,map:result.pages})}if(route.layout&&typeof route.layout==="string"){pathsToProcess.push({path:route.layout,map:result.layouts})}const routeError=route.error??route.errors;if(routeError&&typeof routeError==="string"){pathsToProcess.push({path:routeError,map:result.errors})}if(route.loading&&typeof route.loading==="string"){pathsToProcess.push({path:route.loading,map:result.loadings})}if(route.children&&Array.isArray(route.children)&&route.children.length>0){for(let i=route.children.length-1;i>=0;i--){stack.push({route:route.children[i],depth:depth+1})}}}for(let i=0;i<pathsToProcess.length;i+=batchSize){const batch=pathsToProcess.slice(i,i+batchSize);await Promise.all(batch.map(({path,map})=>Promise.resolve(extractAndValidatePath(path,map,config,options))))}}else{const stack=[];for(let i=routes.length-1;i>=0;i--){stack.push(stackNodePool.acquire(routes[i],0))}while(stack.length>0){const node=stack.pop();const{route,depth}=node;if(depth>maxDepth){logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`,route.name);stackNodePool.release(node);continue}extractAndValidatePath(route.page,result.pages,config,options);extractAndValidatePath(route.layout,result.layouts,config,options);extractAndValidatePath(route.error??route.errors,result.errors,config,options);extractAndValidatePath(route.loading,result.loadings,config,options);if(route.children&&Array.isArray(route.children)&&route.children.length>0){for(let i=route.children.length-1;i>=0;i--){stack.push(stackNodePool.acquire(route.children[i],depth+1))}}stackNodePool.release(node)}}}function cleanupExpiredCache(cacheTTL){if(transformCache){transformCache.cleanupExpired(cacheTTL)}}export async function transformRoutes(routes,options={}){const startTime=performance.now();const mergedOptions={pathValidation:{...DEFAULT_OPTIONS.pathValidation,...options.pathValidation},performance:{...DEFAULT_OPTIONS.performance,...options.performance},enableDebugLog:options.enableDebugLog??DEFAULT_OPTIONS.enableDebugLog};if(!routes){if(mergedOptions.enableDebugLog){logger.debug("路由配置为空，返回空结果")}return{pages:new Map,layouts:new Map,errors:new Map,loadings:new Map,routes:[]}}let routesArray;try{routesArray=typeof routes==="function"?await routes():routes}catch(error){const err=error instanceof Error?error:new Error("路由配置加载失败");logger.error("路由配置加载失败:",err);throw new ValidationError("路由配置加载失败",{originalError:err})}if(!Array.isArray(routesArray)||routesArray.length===0){if(mergedOptions.enableDebugLog){logger.debug("路由配置不是数组或为空，返回空结果")}return{pages:new Map,layouts:new Map,errors:new Map,loadings:new Map,routes:[]}}const cacheTTL=mergedOptions.performance.cacheTTL??DEFAULT_OPTIONS.performance.cacheTTL;const maxCacheSize=mergedOptions.performance.maxCacheSize??DEFAULT_OPTIONS.performance.maxCacheSize;if(mergedOptions.performance.enableCache){if(!transformCache||transformCache.size()!==maxCacheSize){transformCache=new LRUCache(maxCacheSize)}const configHash=generateConfigHash(routesArray);if(configHash){const cached=transformCache.get(configHash);if(cached&&Date.now()-cached.timestamp<cacheTTL){if(mergedOptions.enableDebugLog){logger.debug("使用缓存结果")}return cached.result}}cleanupExpiredCache(cacheTTL)}const result={pages:new Map,layouts:new Map,errors:new Map,loadings:new Map,routes:[]};try{const extractStartTime=performance.now();const pathValidation={enablePathValidation:mergedOptions.pathValidation.enablePathValidation??DEFAULT_OPTIONS.pathValidation.enablePathValidation,allowedPathPrefixes:mergedOptions.pathValidation.allowedPathPrefixes??DEFAULT_OPTIONS.pathValidation.allowedPathPrefixes,maxPathLength:mergedOptions.pathValidation.maxPathLength??DEFAULT_OPTIONS.pathValidation.maxPathLength,allowAbsolutePaths:mergedOptions.pathValidation.allowAbsolutePaths??DEFAULT_OPTIONS.pathValidation.allowAbsolutePaths};const maxRecursionDepth=mergedOptions.performance.maxRecursionDepth??DEFAULT_OPTIONS.performance.maxRecursionDepth;await extractPathsOnly(routesArray,result,pathValidation,mergedOptions,maxRecursionDepth);const extractEndTime=performance.now();const extractDuration=extractEndTime-extractStartTime;result.routes=routesArray;const cacheStartTime=performance.now();if(mergedOptions.performance.enableCache&&transformCache){const configHash=generateConfigHash(routesArray);if(configHash){const cachedResult={pages:new Map(result.pages),layouts:new Map(result.layouts),errors:new Map(result.errors),loadings:new Map(result.loadings),routes:JSON.parse(JSON.stringify(result.routes))};transformCache.set(configHash,{result:cachedResult,timestamp:Date.now(),hash:configHash,accessTime:Date.now()})}}const cacheEndTime=performance.now();const cacheDuration=cacheEndTime-cacheStartTime;const endTime=performance.now();const totalDuration=endTime-startTime;if(mergedOptions.enableDebugLog){logger.debug(`路由转换完成，总耗时: ${totalDuration.toFixed(2)}ms`,{routeCount:result.routes.length,pageCount:result.pages.size,layoutCount:result.layouts.size,errorCount:result.errors.size,loadingCount:result.loadings.size,performance:{extractDuration:`${extractDuration.toFixed(2)}ms`,cacheDuration:`${cacheDuration.toFixed(2)}ms`,totalDuration:`${totalDuration.toFixed(2)}ms`},cache:{hit:transformCache?"miss":"disabled",size:transformCache?.size()??0}})}return result}catch(error){const err=error instanceof Error?error:new Error("路由转换失败");logger.error("路由转换失败:",err);throw new ValidationError("路由转换失败",{originalError:err})}}