@vlian/framework 1.2.62 → 2.0.1

package/dist/core-bak/router/utils/transform.d.ts

@@ -1,348 +0,0 @@
-import type { RouterConfig, RouteConfig } from '../types';
-/**
- * 路径验证配置
- */
-export interface PathValidationConfig {
-    /**
-     * 是否启用路径验证（默认 true）
-     */
-    enablePathValidation?: boolean;
-    /**
-     * 允许的路径前缀列表
-     * 例如：['@/pages', '@/components', './pages']
-     */
-    allowedPathPrefixes?: string[];
-    /**
-     * 最大路径长度（默认 500）
-     */
-    maxPathLength?: number;
-    /**
-     * 是否允许绝对路径（默认 false）
-     */
-    allowAbsolutePaths?: boolean;
-}
-/**
- * 转换性能配置
- */
-export interface TransformPerformanceConfig {
-    /**
-     * 是否启用缓存（默认 true）
-     */
-    enableCache?: boolean;
-    /**
-     * 缓存过期时间（毫秒，默认 5 分钟）
-     */
-    cacheTTL?: number;
-    /**
-     * 最大缓存数量（默认 50，LRU 缓存）
-     */
-    maxCacheSize?: number;
-    /**
-     * 最大递归深度（默认 100）
-     */
-    maxRecursionDepth?: number;
-    /**
-     * 是否启用并行处理（默认 true）
-     */
-    enableParallelProcessing?: boolean;
-    /**
-     * 并行处理批次大小（默认 10）
-     */
-    parallelBatchSize?: number;
-}
-/**
- * 转换配置选项
- */
-export interface TransformOptions {
-    /**
-     * 路径验证配置
-     */
-    pathValidation?: PathValidationConfig;
-    /**
-     * 性能配置
-     */
-    performance?: TransformPerformanceConfig;
-    /**
-     * 是否启用调试日志（默认 false）
-     */
-    enableDebugLog?: boolean;
-}
-/**
- * 转换后的路由项
- *
- * 与 RouteConfig 的区别：
- * - `page`、`layout`、`errors`、`loading` 字段的值是对应 Map 中的动态导入函数，而不是路径字符串
- * - 这些字段可以直接用于动态加载组件，无需再次查找 Map
- * - 所有组件路径字符串都已转换为对应的动态导入函数
- *
- * @example
- * ```typescript
- * const transformedRoute: TransformedRoute = {
- *   name: 'home',
- *   path: '/',
- *   page: () => import('@/pages/home.tsx'),  // 动态导入函数
- *   handle: { title: '首页', order: 1 },
- * };
- *
- * // 使用动态导入函数加载组件
- * if (transformedRoute.page) {
- *   const pageModule = await transformedRoute.page();
- *   const PageComponent = pageModule?.default;
- * }
- * ```
- */
-export interface TransformedRoute {
-    /**
-     * 页面组件的动态导入函数
-     *
-     * 如果路由配置中指定了 `page` 路径，则此字段为对应的动态导入函数
-     * 如果未指定或为 null，则此字段为 null
-     *
-     * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象
-     * 组件必须使用默认导出（export default）
-     */
-    page?: (() => Promise<any>) | null;
-    /**
-     * 布局组件的动态导入函数
-     *
-     * 如果路由配置中指定了 `layout` 路径，则此字段为对应的动态导入函数
-     * 如果未指定或为 null，则此字段为 null
-     *
-     * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象
-     * 组件必须使用默认导出（export default）
-     */
-    layout?: (() => Promise<any>) | null;
-    /**
-     * 错误组件的动态导入函数
-     *
-     * 如果路由配置中指定了 `errors` 路径，则此字段为对应的动态导入函数
-     * 如果未指定或为 null，则此字段为 null
-     *
-     * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象
-     * 组件必须使用默认导出（export default）
-     */
-    errors?: (() => Promise<any>) | null;
-    /**
-     * 加载组件的动态导入函数
-     *
-     * 如果路由配置中指定了 `loading` 路径，则此字段为对应的动态导入函数
-     * 如果未指定或为 null，则此字段为 null
-     *
-     * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象
-     * 组件必须使用默认导出（export default）
-     */
-    loading?: (() => Promise<any>) | null;
-    /**
-     * 路由名称（唯一标识）
-     *
-     * 用于标识路由的唯一名称，通常用于路由导航和权限控制
-     */
-    name: string;
-    /**
-     * 路由路径
-     *
-     * URL 路径，例如：'/'、'/about'、'/user/:id'
-     * 如果路由是路由组（isGroup: true），则可能为 undefined
-     */
-    path: string | undefined;
-    /**
-     * 是否为路由组
-     *
-     * 路由组用于组织子路由，本身不匹配任何路径
-     * 路由组的 path 通常为 undefined
-     */
-    isGroup?: boolean;
-    /**
-     * 是否启用重定向
-     *
-     * 如果为 true，表示此路由用于重定向到其他路由
-     */
-    enableRedirection?: boolean;
-    /**
-     * 路由元数据
-     *
-     * 包含路由的标题、图标、排序、权限等信息
-     * 用于菜单生成、权限控制、SEO 等场景
-     */
-    handle: {
-        /**
-         * 路由标题
-         */
-        title: string;
-        /**
-         * 国际化键名
-         * 如果提供，会使用 i18n 系统进行翻译
-         */
-        i18nKey?: string;
-        /**
-         * 排序值
-         * 用于菜单排序，数值越小越靠前
-         */
-        order: number;
-        /**
-         * 图标名称或路径
-         */
-        icon?: string;
-        /**
-         * 是否在菜单中隐藏
-         */
-        hideInMenu?: boolean;
-        /**
-         * 是否隐藏页脚
-         */
-        hideFooter?: boolean;
-        /**
-         * 是否启用 KeepAlive 缓存
-         */
-        keepAlive?: boolean;
-        /**
-         * 是否需要登录
-         */
-        needLogin?: boolean;
-        /**
-         * 允许访问的角色列表
-         */
-        roles?: Array<string>;
-        /**
-         * 路由名称（与 name 字段相同，用于兼容）
-         */
-        name?: string;
-        /**
-         * 其他自定义元数据
-         */
-        [key: string]: unknown;
-    };
-    /**
-     * 子路由配置
-     *
-     * 如果路由有子路由，则此字段包含转换后的子路由列表
-     * 子路由会继承父路由的某些配置（如 layout）
-     */
-    children?: TransformedRoute[];
-}
-/**
- * 路由转换结果
- *
- * 包含所有提取的组件路径 Map 和原始路由配置列表
- *
- * @example
- * ```typescript
- * const result: TransformRoutesResult = {
- *   pages: new Map([
- *     ['@/pages/home.tsx', () => import('@/pages/home.tsx')],
- *     ['@/pages/about.tsx', () => import('@/pages/about.tsx')],
- *   ]),
- *   layouts: new Map([
- *     ['@/layouts/MainLayout.tsx', () => import('@/layouts/MainLayout.tsx')],
- *   ]),
- *   errors: new Map(),
- *   loadings: new Map(),
- *   routes: [], // 原始路由配置列表
- * };
- * ```
- */
-export interface TransformRoutesResult {
-    /**
-     * 页面组件路径 Map
-     *
-     * key: 组件路径字符串（如 '@/pages/home.tsx'）
-     * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象
-     *
-     * 用于存储所有路由配置中出现的页面组件路径
-     * 相同的路径只会存储一次，避免重复创建动态导入函数
-     */
-    pages: Map<string, () => Promise<any>>;
-    /**
-     * 布局组件路径 Map
-     *
-     * key: 组件路径字符串（如 '@/layouts/MainLayout.tsx'）
-     * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象
-     *
-     * 用于存储所有路由配置中出现的布局组件路径
-     * 相同的路径只会存储一次，避免重复创建动态导入函数
-     */
-    layouts: Map<string, () => Promise<any>>;
-    /**
-     * 错误组件路径 Map
-     *
-     * key: 组件路径字符串（如 '@/components/ErrorBoundary.tsx'）
-     * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象
-     *
-     * 用于存储所有路由配置中出现的错误组件路径
-     * 相同的路径只会存储一次，避免重复创建动态导入函数
-     */
-    errors: Map<string, () => Promise<any>>;
-    /**
-     * 加载组件路径 Map
-     *
-     * key: 组件路径字符串（如 '@/components/Loading.tsx'）
-     * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象
-     *
-     * 用于存储所有路由配置中出现的加载组件路径
-     * 相同的路径只会存储一次，避免重复创建动态导入函数
-     */
-    loadings: Map<string, () => Promise<any>>;
-    routes: RouteConfig[];
-}
-/**
- * 转换路由配置：提取组件路径到 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 declare function transformRoutes(routes: RouterConfig['routes'], options?: TransformOptions): Promise<TransformRoutesResult>;

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

@@ -1 +0,0 @@
-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})}}

package/dist/core-bak/router/validation/RouterConfigValidator.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"RouterConfigValidator",{enumerable:true,get:function(){return RouterConfigValidator}});const _ConfigValidator=require("../../config/ConfigValidator");const _logger=require("@vlian/logger");const _schema=require("./schema");let RouterConfigValidator=class RouterConfigValidator{static validate(config){const result=(0,_schema.safeValidateRouterConfig)(config);if(!result.success){const errorMessages=result.error.issues.map(issue=>{const path=issue.path.length>0?issue.path.join("."):"root";return`路由配置项 "${path}": ${issue.message}`});const friendlyMessage=`路由配置验证失败:
-${errorMessages.join("\n")}`;_logger.logger.error("路由配置验证失败",{errors:result.error.issues,config});throw new _ConfigValidator.ConfigValidationError(friendlyMessage,result.error)}return result.data}static safeValidate(config){return(0,_schema.safeValidateRouterConfig)(config)}static validateWithSuggestions(config){const result=(0,_schema.safeValidateRouterConfig)(config);if(!result.success){const suggestions=[];result.error.issues.forEach(issue=>{const path=issue.path.join(".");if(issue.code==="invalid_type"){const invalidTypeIssue=issue;suggestions.push(`配置项 "${path}" 类型错误: 期望 ${invalidTypeIssue.expected}，实际 ${invalidTypeIssue.received}`)}else if(issue.code==="too_small"){suggestions.push(`配置项 "${path}" 值太小: ${issue.message}`)}else if(issue.code==="too_big"){suggestions.push(`配置项 "${path}" 值太大: ${issue.message}`)}else{suggestions.push(`配置项 "${path}": ${issue.message}`)}});return{success:false,errors:result.error.issues,suggestions}}return{success:true,data:result.data}}};

package/dist/core-bak/router/validation/RouterConfigValidator.d.ts

@@ -1,121 +0,0 @@
-/**
- * 路由配置验证器
- * 使用 Zod 进行配置验证，并提供友好的错误信息
- */
-import { z } from 'zod';
-/**
- * 路由配置验证器
- */
-export declare class RouterConfigValidator {
-    /**
-     * 验证路由配置
-     *
-     * @param config - 要验证的路由配置
-     * @returns 验证后的路由配置
-     * @throws ConfigValidationError 如果配置验证失败
-     */
-    static validate(config: unknown): {
-        enabled?: boolean | "disabled" | undefined;
-        routes?: any[] | z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
-        mode?: "hash" | "browser" | "memory" | undefined;
-        options?: {
-            [x: string]: unknown;
-            basename?: string | undefined;
-            future?: Record<string, string | number | boolean> | undefined;
-            hydrationData?: unknown;
-            window?: unknown;
-            initialEntries?: string[] | undefined;
-            initialIndex?: number | undefined;
-        } | undefined;
-        pathResolve?: {
-            basePath?: string | undefined;
-            pathAliases?: Record<string, string> | undefined;
-        } | undefined;
-        transformOptions?: {
-            [x: string]: unknown;
-            pathValidation?: {
-                enablePathValidation?: boolean | undefined;
-                allowedPathPrefixes?: string[] | undefined;
-                maxPathLength?: number | undefined;
-                allowAbsolutePaths?: boolean | undefined;
-            } | undefined;
-            performance?: {
-                enableCache?: boolean | undefined;
-                cacheTTL?: number | undefined;
-                maxCacheSize?: number | undefined;
-                maxRecursionDepth?: number | undefined;
-                enableParallelProcessing?: boolean | undefined;
-                parallelBatchSize?: number | undefined;
-            } | undefined;
-            enableDebugLog?: boolean | undefined;
-        } | undefined;
-        preload?: {
-            strategy?: "all" | "none" | "visible" | "next-level" | undefined;
-            delay?: number | undefined;
-            priorityThreshold?: number | undefined;
-            timeout?: number | undefined;
-        } | undefined;
-        enableHydrateFallback?: boolean | undefined;
-    };
-    /**
-     * 安全验证路由配置（不抛出异常）
-     *
-     * @param config - 要验证的路由配置
-     * @returns 验证结果
-     */
-    static safeValidate(config: unknown): z.ZodSafeParseResult<{
-        enabled?: boolean | "disabled" | undefined;
-        routes?: any[] | z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
-        mode?: "hash" | "browser" | "memory" | undefined;
-        options?: {
-            [x: string]: unknown;
-            basename?: string | undefined;
-            future?: Record<string, string | number | boolean> | undefined;
-            hydrationData?: unknown;
-            window?: unknown;
-            initialEntries?: string[] | undefined;
-            initialIndex?: number | undefined;
-        } | undefined;
-        pathResolve?: {
-            basePath?: string | undefined;
-            pathAliases?: Record<string, string> | undefined;
-        } | undefined;
-        transformOptions?: {
-            [x: string]: unknown;
-            pathValidation?: {
-                enablePathValidation?: boolean | undefined;
-                allowedPathPrefixes?: string[] | undefined;
-                maxPathLength?: number | undefined;
-                allowAbsolutePaths?: boolean | undefined;
-            } | undefined;
-            performance?: {
-                enableCache?: boolean | undefined;
-                cacheTTL?: number | undefined;
-                maxCacheSize?: number | undefined;
-                maxRecursionDepth?: number | undefined;
-                enableParallelProcessing?: boolean | undefined;
-                parallelBatchSize?: number | undefined;
-            } | undefined;
-            enableDebugLog?: boolean | undefined;
-        } | undefined;
-        preload?: {
-            strategy?: "all" | "none" | "visible" | "next-level" | undefined;
-            delay?: number | undefined;
-            priorityThreshold?: number | undefined;
-            timeout?: number | undefined;
-        } | undefined;
-        enableHydrateFallback?: boolean | undefined;
-    }>;
-    /**
-     * 验证路由配置并提供修复建议
-     *
-     * @param config - 要验证的路由配置
-     * @returns 验证结果和修复建议
-     */
-    static validateWithSuggestions(config: unknown): {
-        success: boolean;
-        data?: unknown;
-        errors?: z.ZodIssue[];
-        suggestions?: string[];
-    };
-}

package/dist/core-bak/router/validation/RouterConfigValidator.js

@@ -1,2 +0,0 @@
-import{ConfigValidationError}from"../../config/ConfigValidator";import{logger}from"@vlian/logger";import{safeValidateRouterConfig}from"./schema";export class RouterConfigValidator{static validate(config){const result=safeValidateRouterConfig(config);if(!result.success){const errorMessages=result.error.issues.map(issue=>{const path=issue.path.length>0?issue.path.join("."):"root";return`路由配置项 "${path}": ${issue.message}`});const friendlyMessage=`路由配置验证失败:
-${errorMessages.join("\n")}`;logger.error("路由配置验证失败",{errors:result.error.issues,config});throw new ConfigValidationError(friendlyMessage,result.error)}return result.data}static safeValidate(config){return safeValidateRouterConfig(config)}static validateWithSuggestions(config){const result=safeValidateRouterConfig(config);if(!result.success){const suggestions=[];result.error.issues.forEach(issue=>{const path=issue.path.join(".");if(issue.code==="invalid_type"){const invalidTypeIssue=issue;suggestions.push(`配置项 "${path}" 类型错误: 期望 ${invalidTypeIssue.expected}，实际 ${invalidTypeIssue.received}`)}else if(issue.code==="too_small"){suggestions.push(`配置项 "${path}" 值太小: ${issue.message}`)}else if(issue.code==="too_big"){suggestions.push(`配置项 "${path}" 值太大: ${issue.message}`)}else{suggestions.push(`配置项 "${path}": ${issue.message}`)}});return{success:false,errors:result.error.issues,suggestions}}return{success:true,data:result.data}}}

package/dist/core-bak/router/validation/index.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});_export_star(require("./schema"),exports);_export_star(require("./RouterConfigValidator"),exports);function _export_star(from,to){Object.keys(from).forEach(function(k){if(k!=="default"&&!Object.prototype.hasOwnProperty.call(to,k)){Object.defineProperty(to,k,{enumerable:true,get:function(){return from[k]}})}});return from}

package/dist/core-bak/router/validation/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * 路由配置验证模块入口
- */
-export * from './schema';
-export * from './RouterConfigValidator';

package/dist/core-bak/router/validation/index.js

@@ -1 +0,0 @@
-export*from"./schema";export*from"./RouterConfigValidator";

package/dist/core-bak/router/validation/schema.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get componentImportSchema(){return componentImportSchema},get routeConfigSchema(){return routeConfigSchema},get routeItemHandleSchema(){return routeItemHandleSchema},get routerConfigSchema(){return routerConfigSchema},get safeValidateRouterConfig(){return safeValidateRouterConfig},get validateRouterConfig(){return validateRouterConfig}});const _zod=require("zod");const routeItemHandleSchema=_zod.z.object({title:_zod.z.string().min(1,"路由标题不能为空"),i18nKey:_zod.z.string().optional(),order:_zod.z.number().int("排序值必须是整数"),icon:_zod.z.string().optional(),hideInMenu:_zod.z.boolean().optional(),hideFooter:_zod.z.boolean().optional(),keepAlive:_zod.z.boolean().optional(),needLogin:_zod.z.boolean().optional(),roles:_zod.z.array(_zod.z.string()).optional(),name:_zod.z.string().optional()}).passthrough();const componentImportSchema=_zod.z.union([_zod.z.string().min(1,"组件路径不能为空"),_zod.z.function(),_zod.z.null()]);const routerOptionsSchema=_zod.z.object({basename:_zod.z.string().optional(),future:_zod.z.record(_zod.z.string(),_zod.z.union([_zod.z.boolean(),_zod.z.string(),_zod.z.number()])).optional(),hydrationData:_zod.z.unknown().optional(),window:_zod.z.unknown().optional(),initialEntries:_zod.z.array(_zod.z.string()).optional(),initialIndex:_zod.z.number().int().nonnegative().optional()}).passthrough();const transformOptionsSchema=_zod.z.object({pathValidation:_zod.z.object({enablePathValidation:_zod.z.boolean().optional(),allowedPathPrefixes:_zod.z.array(_zod.z.string().min(1)).optional(),maxPathLength:_zod.z.number().int().positive().optional(),allowAbsolutePaths:_zod.z.boolean().optional()}).optional(),performance:_zod.z.object({enableCache:_zod.z.boolean().optional(),cacheTTL:_zod.z.number().int().positive().optional(),maxCacheSize:_zod.z.number().int().positive().optional(),maxRecursionDepth:_zod.z.number().int().positive().optional(),enableParallelProcessing:_zod.z.boolean().optional(),parallelBatchSize:_zod.z.number().int().positive().optional()}).optional(),enableDebugLog:_zod.z.boolean().optional()}).passthrough();const routeConfigSchema=_zod.z.lazy(()=>_zod.z.object({layout:componentImportSchema.optional().nullable(),page:componentImportSchema.optional().nullable(),loading:componentImportSchema.optional().nullable(),error:componentImportSchema.optional().nullable(),errors:componentImportSchema.optional().nullable(),name:_zod.z.string().min(1,"路由名称不能为空"),path:_zod.z.string().optional(),isGroup:_zod.z.boolean().optional(),enableRedirection:_zod.z.boolean().optional(),handle:routeItemHandleSchema,children:_zod.z.array(routeConfigSchema).optional()}));const routerConfigSchema=_zod.z.object({enabled:_zod.z.union([_zod.z.boolean(),_zod.z.literal("disabled")]).optional(),routes:_zod.z.union([_zod.z.array(routeConfigSchema),_zod.z.function()]).optional(),mode:_zod.z.enum(["browser","hash","memory"]).optional(),options:routerOptionsSchema.optional(),pathResolve:_zod.z.object({basePath:_zod.z.string().optional(),pathAliases:_zod.z.record(_zod.z.string(),_zod.z.string()).optional()}).optional(),transformOptions:transformOptionsSchema.optional(),preload:_zod.z.object({strategy:_zod.z.enum(["none","next-level","all","visible"]).optional(),delay:_zod.z.number().int().positive().optional(),priorityThreshold:_zod.z.number().int().nonnegative().optional(),timeout:_zod.z.number().int().positive().optional()}).optional(),enableHydrateFallback:_zod.z.boolean().optional()}).superRefine((config,ctx)=>{if(!Array.isArray(config.routes)){return}const routeNameMap=new Map;const walk=(routes,parentPath)=>{routes.forEach((route,index)=>{const currentPath=`${parentPath}[${index}]`;const existingPath=routeNameMap.get(route.name);if(existingPath){ctx.addIssue({code:_zod.z.ZodIssueCode.custom,path:["routes",index,"name"],message:`路由名称重复: "${route.name}"，首次定义位置 ${existingPath}`})}else{routeNameMap.set(route.name,currentPath)}if(Array.isArray(route.children)&&route.children.length>0){walk(route.children,`${currentPath}.children`)}})};walk(config.routes,"routes")});function validateRouterConfig(config){return routerConfigSchema.parse(config)}function safeValidateRouterConfig(config){return routerConfigSchema.safeParse(config)}