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";
/**
 * 路由生命周期管理器
 */ export class RouterLifecycleManager {
    /**
   * 注册生命周期钩子
   * 
   * @param hooks - 生命周期钩子配置
   * @returns 取消注册函数
   */ register(hooks) {
        this.hooks.push(hooks);
        logger.debug('路由生命周期钩子已注册');
        // 返回取消注册函数
        return ()=>{
            const index = this.hooks.indexOf(hooks);
            if (index > -1) {
                this.hooks.splice(index, 1);
                logger.debug('路由生命周期钩子已取消注册');
            }
        };
    }
    /**
   * 批量注册生命周期钩子
   * 
   * @param hooksArray - 生命周期钩子配置数组
   */ registerBatch(hooksArray) {
        hooksArray.forEach((hooks)=>this.register(hooks));
    }
    /**
   * 清空所有生命周期钩子
   */ clear() {
        this.hooks = [];
        logger.debug('所有路由生命周期钩子已清空');
    }
    /**
   * 执行路由跳转前钩子
   * 
   * @param to - 目标路由
   * @param from - 来源路由
   * @returns 如果返回字符串，则跳转到该路径；如果返回 false，则阻止跳转；返回 true 或 undefined 则继续跳转
   */ async beforeEach(to, from) {
        // 按注册顺序执行所有 beforeEach 钩子
        for (const hooks of this.hooks){
            if (hooks.beforeEach) {
                try {
                    const result = await hooks.beforeEach(to, from);
                    // 如果返回 false，阻止跳转
                    if (result === false) {
                        logger.debug('路由跳转被阻止: beforeEach 返回 false');
                        return false;
                    }
                    // 如果返回字符串，重定向到该路径
                    if (typeof result === 'string') {
                        logger.debug(`路由跳转重定向: beforeEach 返回 ${result}`);
                        return result;
                    }
                } catch (error) {
                    logger.error('路由生命周期钩子执行失败: beforeEach', error);
                    continue;
                }
            }
        }
        // 所有钩子都通过，允许跳转
        return undefined;
    }
    /**
   * 执行路由跳转后钩子
   * 
   * @param to - 目标路由
   * @param from - 来源路由
   */ async afterEach(to, from) {
        // 按注册顺序执行所有 afterEach 钩子
        for (const hooks of this.hooks){
            if (hooks.afterEach) {
                try {
                    await hooks.afterEach(to, from);
                } catch (error) {
                    logger.error('路由生命周期钩子执行失败: afterEach', error);
                    continue;
                }
            }
        }
    }
    /**
   * 获取所有生命周期钩子
   * 
   * @returns 生命周期钩子配置数组
   */ getAll() {
        return [
            ...this.hooks
        ];
    }
    /**
   * 获取生命周期钩子数量
   * 
   * @returns 生命周期钩子数量
   */ getCount() {
        return this.hooks.length;
    }
    constructor(){
        _define_property(this, "hooks", []);
    }
}
/**
 * 获取路由生命周期管理器单例
 */ let lifecycleManagerInstance = null;
export function getRouterLifecycleManager() {
    if (!lifecycleManagerInstance) {
        lifecycleManagerInstance = new RouterLifecycleManager();
    }
    return lifecycleManagerInstance;
}

//# sourceMappingURL=RouterLifecycleManager.js.map