@vlian/framework 1.0.0

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

@@ -0,0 +1,772 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformRoutes", {
+    enumerable: true,
+    get: function() {
+        return transformRoutes;
+    }
+});
+const _utils = require("../../../utils");
+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;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/**
+ * 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);
+}
+/**
+ * 配置序列化缓存（避免重复序列化）
+ */ const configStringCache = new Map();
+/**
+ * 生成配置哈希（用于缓存键）
+ * 优化：缓存序列化结果，避免重复序列化
+ */ function generateConfigHash(routes) {
+    try {
+        // 快速检查：如果路由数量为 0，直接返回
+        if (routes.length === 0) {
+            return 'empty';
+        }
+        // 使用路由数量作为快速键的一部分
+        const quickKey = `${routes.length}_${routes[0]?.name || ''}_${routes[routes.length - 1]?.name || ''}`;
+        // 检查序列化缓存
+        if (configStringCache.has(quickKey)) {
+            const cachedStr = configStringCache.get(quickKey);
+            // 验证缓存是否仍然有效（简单检查）
+            const currentStr = JSON.stringify(routes, null, 0).substring(0, 100);
+            if (cachedStr.startsWith(currentStr.substring(0, 50))) {
+                return simpleHash(cachedStr);
+            }
+        }
+        // 使用 JSON.stringify 生成配置的字符串表示
+        // 只包含影响转换结果的字段
+        const configStr = JSON.stringify(routes, (key, value)=>{
+            // 只序列化相关字段
+            if ([
+                'name',
+                'path',
+                'page',
+                'layout',
+                'errors',
+                'loading',
+                'isGroup',
+                'enableRedirection',
+                'children'
+            ].includes(key)) {
+                return value;
+            }
+            if (key === 'handle' && value && typeof value === 'object') {
+                // 只序列化 handle 的基本字段
+                return {
+                    title: value.title,
+                    order: value.order
+                };
+            }
+            return undefined;
+        });
+        // 缓存序列化结果（限制缓存大小）
+        if (configStringCache.size < 20) {
+            configStringCache.set(quickKey, configStr);
+        }
+        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 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'
+    //       ? '路径包含潜在的命令注入字符'
+    //       : '路径验证失败',
+    //   };
+    // }
+    // 检查绝对路径（使用预编译正则）
+    if (!config.allowAbsolutePaths && ABSOLUTE_PATH_REGEX.test(path)) {
+        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 = _utils.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 ()=>Promise.resolve(path).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
+}
+/**
+ * 提取并验证组件路径到 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 _utils.SecurityError(errorMessage, undefined, process.env.NODE_ENV === 'development' ? {
+                path: normalizedPath
+            } : {});
+            if (options.enableDebugLog) {
+                _utils.logger.error('路径验证失败:', error);
+            }
+            // 开发环境抛出错误，生产环境记录警告并跳过
+            if (process.env.NODE_ENV === 'development') {
+                throw error;
+            } else {
+                // 生产环境日志脱敏
+                _utils.logger.warn('路径验证失败，已跳过');
+                return null;
+            }
+        }
+    }
+    // 创建动态导入函数并存储
+    const importFn = createDynamicImport(normalizedPath);
+    map.set(normalizedPath, importFn);
+    if (options.enableDebugLog) {
+        _utils.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) {
+                _utils.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
+                });
+            }
+            if (route.errors && typeof route.errors === 'string') {
+                pathsToProcess.push({
+                    path: route.errors,
+                    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) {
+                _utils.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.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);
+    }
+}
+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) {
+            _utils.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('路由配置加载失败');
+        _utils.logger.error('路由配置加载失败:', err);
+        throw new _utils.ValidationError('路由配置加载失败', {
+            originalError: err
+        });
+    }
+    // 早期返回：如果 routesArray 不是数组，直接返回空结果
+    if (!Array.isArray(routesArray) || routesArray.length === 0) {
+        if (mergedOptions.enableDebugLog) {
+            _utils.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) {
+                    _utils.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) {
+                // 使用结构化克隆（如果可用）或浅拷贝 + 深拷贝 routes
+                let cachedResult;
+                if (typeof structuredClone !== 'undefined') {
+                    // 使用结构化克隆（更快且更安全）
+                    cachedResult = structuredClone(result);
+                    // Map 需要手动克隆（structuredClone 可能不支持 Map）
+                    cachedResult.pages = new Map(result.pages);
+                    cachedResult.layouts = new Map(result.layouts);
+                    cachedResult.errors = new Map(result.errors);
+                    cachedResult.loadings = new Map(result.loadings);
+                } else {
+                    // 回退到手动深拷贝
+                    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) {
+            // 详细的性能报告
+            _utils.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('路由转换失败');
+        _utils.logger.error('路由转换失败:', err);
+        throw new _utils.ValidationError('路由转换失败', {
+            originalError: err
+        });
+    }
+}
+
+//# sourceMappingURL=transform.js.map