/**
 * 插件事件总线
 * 用于插件间通信
 */ /**
 * 事件监听器类型
 */ "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 PluginEventBus () {
        return PluginEventBus;
    },
    get pluginEventBus () {
        return pluginEventBus;
    }
});
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;
}
let PluginEventBus = class PluginEventBus {
    /**
   * 订阅事件
   * 
   * @param event - 事件名称
   * @param listener - 事件监听器（可以接收 EventWrapper 或直接数据）
   * @returns 取消订阅函数
   */ on(event, listener) {
        if (!this.listeners.has(event)) {
            this.listeners.set(event, new Set());
        }
        const listeners = this.listeners.get(event);
        listeners.add(listener);
        // 返回取消订阅函数
        return ()=>{
            listeners.delete(listener);
            if (listeners.size === 0) {
                this.listeners.delete(event);
            }
        };
    }
    /**
   * 取消订阅事件
   * 
   * @param event - 事件名称
   * @param listener - 事件监听器
   */ off(event, listener) {
        const listeners = this.listeners.get(event);
        if (listeners) {
            listeners.delete(listener);
            if (listeners.size === 0) {
                this.listeners.delete(event);
            }
        }
    }
    /**
   * 发布事件
   * 
   * @param event - 事件名称
   * @param data - 事件数据
   * @param metadata - 事件元数据（可选）
   */ async emit(event, data, metadata) {
        // 事件验证
        if (this.config.enableValidation && !this.config.validator(event, data)) {
            console.warn(`事件 ${event} 验证失败，已忽略`);
            return;
        }
        // 构建事件元数据
        const eventMetadata = {
            source: metadata?.source,
            timestamp: metadata?.timestamp ?? Date.now(),
            eventId: metadata?.eventId ?? `event_${++this.eventCounter}`,
            priority: metadata?.priority ?? 0
        };
        // 记录事件历史
        if (this.config.enableTracking) {
            this.eventHistory.push({
                event,
                data,
                metadata: eventMetadata
            });
            // 限制历史记录大小
            if (this.eventHistory.length > this.config.maxHistorySize) {
                this.eventHistory.shift();
            }
        }
        const listeners = this.listeners.get(event);
        if (!listeners || listeners.size === 0) {
            return;
        }
        // 创建事件包装器
        const eventWrapper = {
            data: data,
            metadata: eventMetadata
        };
        // 按优先级排序监听器（如果有优先级）
        const sortedListeners = Array.from(listeners);
        // 并行执行所有监听器
        const promises = sortedListeners.map((listener)=>{
            try {
                return Promise.resolve(listener(eventWrapper));
            } catch (error) {
                console.error(`事件 ${event} 的监听器执行失败:`, error);
                return Promise.resolve();
            }
        });
        await Promise.allSettled(promises);
    }
    /**
   * 发布事件（仅数据，向后兼容）
   * 
   * @param event - 事件名称
   * @param data - 事件数据
   */ async emitData(event, data) {
        return this.emit(event, data);
    }
    /**
   * 一次性订阅事件
   * 
   * @param event - 事件名称
   * @param listener - 事件监听器
   */ once(event, listener) {
        const wrappedListener = async (data)=>{
            // 处理 EventWrapper 或直接数据
            const actualData = data.data !== undefined ? data.data : data;
            await listener(actualData);
            this.off(event, wrappedListener);
        };
        this.on(event, wrappedListener);
    }
    /**
   * 清空所有事件监听器
   */ clear() {
        this.listeners.clear();
    }
    /**
   * 获取事件监听器数量
   * 
   * @param event - 事件名称，如果不提供则返回所有事件的监听器总数
   */ listenerCount(event) {
        if (event) {
            return this.listeners.get(event)?.size || 0;
        }
        let count = 0;
        for (const listeners of this.listeners.values()){
            count += listeners.size;
        }
        return count;
    }
    /**
   * 获取所有事件名称
   */ eventNames() {
        return Array.from(this.listeners.keys());
    }
    /**
   * 获取事件历史记录
   * 
   * @param event - 事件名称（可选，如果提供则只返回该事件的历史）
   * @param limit - 限制返回的记录数
   * @returns 事件历史记录
   */ getEventHistory(event, limit) {
        if (!this.config.enableTracking) {
            return [];
        }
        let history = this.eventHistory;
        if (event) {
            history = history.filter((h)=>h.event === event);
        }
        if (limit) {
            history = history.slice(-limit);
        }
        return [
            ...history
        ];
    }
    /**
   * 清空事件历史记录
   */ clearHistory() {
        this.eventHistory = [];
    }
    /**
   * 请求-响应模式：发送请求并等待响应
   * 
   * @param event - 事件名称
   * @param data - 请求数据
   * @param timeout - 超时时间（毫秒）
   * @returns 响应数据
   */ async request(event, data, timeout = 5000) {
        return new Promise((resolve, reject)=>{
            const responseEvent = `${event}:response`;
            const requestId = `req_${Date.now()}_${Math.random()}`;
            // 设置超时
            const timeoutId = setTimeout(()=>{
                this.off(responseEvent, responseHandler);
                reject(new Error(`请求 ${event} 超时`));
            }, timeout);
            // 响应处理器
            const responseHandler = (response)=>{
                // 处理 EventWrapper 或直接数据
                const actualResponse = response.data !== undefined ? response.data : response;
                if (actualResponse.requestId === requestId) {
                    clearTimeout(timeoutId);
                    this.off(responseEvent, responseHandler);
                    resolve(actualResponse.data);
                }
            };
            // 订阅响应事件
            this.on(responseEvent, responseHandler);
            // 发送请求
            this.emit(`${event}:request`, {
                requestId,
                data
            });
        });
    }
    /**
   * 请求-响应模式：注册请求处理器
   * 
   * @param event - 事件名称
   * @param handler - 请求处理器
   * @returns 取消注册函数
   */ onRequest(event, handler) {
        const requestEvent = `${event}:request`;
        const responseEvent = `${event}:response`;
        return this.on(requestEvent, async (wrapper)=>{
            try {
                // 处理 EventWrapper 或直接数据
                const actualWrapper = wrapper.data !== undefined ? wrapper : {
                    data: wrapper,
                    metadata: {
                        timestamp: Date.now()
                    }
                };
                const response = await handler(actualWrapper.data.data, actualWrapper.metadata);
                this.emit(responseEvent, {
                    requestId: actualWrapper.data.requestId,
                    data: response
                });
            } catch (error) {
                const actualWrapper = wrapper.data !== undefined ? wrapper : {
                    data: wrapper
                };
                this.emit(`${responseEvent}:error`, {
                    requestId: actualWrapper.data.requestId,
                    error: error instanceof Error ? error.message : String(error)
                });
            }
        });
    }
    /**
   * 获取配置
   */ getConfig() {
        return {
            ...this.config
        };
    }
    /**
   * 更新配置
   */ updateConfig(config) {
        this.config = {
            ...this.config,
            ...config
        };
    }
    constructor(config = {}){
        _define_property(this, "listeners", new Map());
        _define_property(this, "eventHistory", []);
        _define_property(this, "config", void 0);
        _define_property(this, "eventCounter", 0);
        this.config = {
            enableTracking: config.enableTracking ?? false,
            maxHistorySize: config.maxHistorySize ?? 100,
            enableValidation: config.enableValidation ?? false,
            validator: config.validator ?? (()=>true)
        };
    }
};
const pluginEventBus = new PluginEventBus({
    enableTracking: process.env.NODE_ENV === 'development',
    maxHistorySize: 100,
    enableValidation: false
});

//# sourceMappingURL=PluginEventBus.js.map