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 "../../../utils";
import { getRouterManager } from "../RouterManager";
import { transformRoutes } from "../utils/transform";
import { RouterError, RouterErrorCode } from "../errors";
/**
 * 动态路由注册管理器
 */ export class DynamicRouteManager {
    /**
   * 注册路由
   * 
   * @param routes - 要注册的路由配置
   * @param namespace - 路由命名空间（可选，用于分组管理）
   * @returns 取消注册函数
   */ async register(routes, namespace) {
        const ns = namespace || 'default';
        // 验证路由配置
        if (!Array.isArray(routes) || routes.length === 0) {
            throw new RouterError('路由配置必须是非空数组', RouterErrorCode.ROUTER_CONFIG_ERROR);
        }
        // 检查路由名称是否冲突
        const existingRoutes = this.registeredRoutes.get(ns) || [];
        const existingNames = new Set(existingRoutes.map((r)=>r.name));
        const newNames = routes.map((r)=>r.name);
        const conflicts = newNames.filter((name)=>existingNames.has(name));
        if (conflicts.length > 0) {
            throw new RouterError(`路由名称冲突: ${conflicts.join(', ')}`, RouterErrorCode.ROUTER_CONFIG_ERROR, undefined, undefined, {
                conflicts,
                namespace: ns
            });
        }
        // 添加到注册表
        const currentRoutes = this.registeredRoutes.get(ns) || [];
        this.registeredRoutes.set(ns, [
            ...currentRoutes,
            ...routes
        ]);
        // 更新版本号
        this.routeVersion++;
        logger.info(`路由已注册: ${routes.length} 个路由到命名空间 "${ns}"`);
        // 返回取消注册函数
        return async ()=>{
            await this.unregister(routes.map((r)=>r.name), ns);
        };
    }
    /**
   * 取消注册路由
   * 
   * @param routeNames - 要取消注册的路由名称数组
   * @param namespace - 路由命名空间（可选）
   */ async unregister(routeNames, namespace) {
        const ns = namespace || 'default';
        const routes = this.registeredRoutes.get(ns) || [];
        // 过滤掉要取消注册的路由
        const filteredRoutes = routes.filter((r)=>!routeNames.includes(r.name));
        if (filteredRoutes.length === routes.length) {
            logger.warn(`未找到要取消注册的路由: ${routeNames.join(', ')}`);
            return;
        }
        // 更新注册表
        if (filteredRoutes.length === 0) {
            this.registeredRoutes.delete(ns);
        } else {
            this.registeredRoutes.set(ns, filteredRoutes);
        }
        // 更新版本号
        this.routeVersion++;
        logger.info(`路由已取消注册: ${routeNames.length} 个路由从命名空间 "${ns}"`);
    }
    /**
   * 获取指定命名空间的路由
   * 
   * @param namespace - 路由命名空间（可选）
   * @returns 路由配置数组
   */ getRoutes(namespace) {
        const ns = namespace || 'default';
        return [
            ...this.registeredRoutes.get(ns) || []
        ];
    }
    /**
   * 获取所有路由
   * 
   * @returns 所有命名空间的路由配置
   */ getAllRoutes() {
        return new Map(this.registeredRoutes);
    }
    /**
   * 清空指定命名空间的路由
   * 
   * @param namespace - 路由命名空间（可选）
   */ clear(namespace) {
        const ns = namespace || 'default';
        this.registeredRoutes.delete(ns);
        this.routeVersion++;
        logger.info(`路由命名空间已清空: "${ns}"`);
    }
    /**
   * 清空所有路由
   */ clearAll() {
        this.registeredRoutes.clear();
        this.routeVersion++;
        logger.info('所有路由已清空');
    }
    /**
   * 获取路由版本号
   * 
   * @returns 路由版本号
   */ getVersion() {
        return this.routeVersion;
    }
    /**
   * 检查路由是否已注册
   * 
   * @param routeName - 路由名称
   * @param namespace - 路由命名空间（可选）
   * @returns 如果已注册返回 true，否则返回 false
   */ isRegistered(routeName, namespace) {
        const ns = namespace || 'default';
        const routes = this.registeredRoutes.get(ns) || [];
        return routes.some((r)=>r.name === routeName);
    }
    /**
   * 重新加载路由
   * 
   * 注意：此方法会重新初始化路由管理器，需要谨慎使用
   */ async reload() {
        const routerManager = getRouterManager();
        if (!routerManager.isInitialized()) {
            throw new RouterError('路由管理器未初始化', RouterErrorCode.ROUTER_NOT_INITIALIZED);
        }
        // 获取所有路由
        const allRoutes = [];
        this.registeredRoutes.forEach((routes)=>{
            allRoutes.push(...routes);
        });
        if (allRoutes.length === 0) {
            logger.warn('没有已注册的路由，无法重新加载');
            return;
        }
        // 转换路由
        await transformRoutes(allRoutes);
        // const reactRoutes = await transformRoutesToReactRoutes(result.routes, result);
        // 重新创建路由实例
        // 注意：这里需要获取原始配置的模式和选项
        // 由于当前架构限制，这里只是示例实现
        logger.info('路由重新加载完成');
    }
    constructor(){
        _define_property(this, "registeredRoutes", new Map());
        _define_property(this, "routeVersion", 0);
    }
}
/**
 * 获取动态路由管理器单例
 */ let dynamicRouteManagerInstance = null;
export function getDynamicRouteManager() {
    if (!dynamicRouteManagerInstance) {
        dynamicRouteManagerInstance = new DynamicRouteManager();
    }
    return dynamicRouteManagerInstance;
}

//# sourceMappingURL=DynamicRouteManager.js.map