fastevent 1.1.3 → 2.0.1

package/src/event.ts

@@ -1,741 +0,0 @@
-import { FastEventScope } from './scope';
-import {
-    FastEventListener,
-    FastEventOptions,
-    FastEvents,
-    FastListeners,
-    FastListenerNode,
-    FastEventSubscriber,
-    ScopeEvents,
-    FastEventListenOptions,
-    FastEventMessage
-} from './types';
-import { isPathMatched } from './utils/isPathMatched';
-import { removeItem } from './utils/removeItem';
-
-/**
- * FastEvent 事件发射器类
- * 
- * @template Events - 事件类型定义，继承自FastEvents接口
- * @template Meta - 事件元数据类型，默认为任意键值对对象
- * @template Types - 事件类型的键名类型，默认为Events的键名类型
- */
-export class FastEvent<
-    Events extends FastEvents = FastEvents,
-    Meta extends Record<string, any> = Record<string, any>,
-    Context = any,
-    Types extends keyof Events = keyof Events
-> {
-    /** 事件监听器树结构，存储所有注册的事件监听器 */
-    public listeners: FastListeners = { __listeners: [] } as unknown as FastListeners
-
-    /** 事件发射器的配置选项 */
-    private _options: FastEventOptions
-
-    /** 事件名称的分隔符，默认为'/' */
-    private _delimiter: string = '/'
-
-    /** 事件监听器执行时的上下文对象 */
-    private _context: Context
-
-    /** 保留的事件消息映射，用于新订阅者 */
-    retainedMessages: Map<string, any> = new Map<string, any>()
-
-    /** 当前注册的监听器总数 */
-    listenerCount: number = 0
-    /**
-     * 创建FastEvent实例
-     * @param options - 事件发射器的配置选项
-     * 
-     * 默认配置：
-     * - debug: false - 是否启用调试模式
-     * - id: 随机字符串 - 实例唯一标识符
-     * - delimiter: '/' - 事件名称分隔符
-     * - context: null - 监听器执行上下文
-     * - ignoreErrors: true - 是否忽略监听器执行错误
-     */
-    constructor(options?: FastEventOptions<Meta>) {
-        this._options = Object.assign({
-            debug: false,
-            id: Math.random().toString(36).substring(2),
-            delimiter: '/',
-            context: null,
-            ignoreErrors: true
-        }, options)
-        this._delimiter = this._options.delimiter!
-        this._context = this._options.context || this
-        this._enableDevTools()
-    }
-
-    /** 获取事件发射器的配置选项 */
-    get options() { return this._options }
-
-    /** 获取事件发射器的唯一标识符 */
-    get id() { return this._options.id! }
-    private _addListener(parts: string[], listener: FastEventListener<any, any>, options: Required<FastEventListenOptions>): FastListenerNode | undefined {
-        const { count, prepend } = options
-        return this._forEachNodes(parts, (node) => {
-            const newListener = count > 0 ? [listener, count] : listener as any
-            if (prepend) {
-                node.__listeners.splice(0, 0, newListener)
-            } else {
-                node.__listeners.push(newListener)
-            }
-            if (typeof (this._options.onAddListener) === 'function') {
-                this.listenerCount++
-                this._options.onAddListener(parts, listener)
-            }
-        })
-    }
-    private _enableDevTools() {
-        if (this.options.debug) {
-            // @ts-ignore
-            globalThis.__FLEXEVENT_DEVTOOLS__.add(this)
-        }
-    }
-    /**
-     * 
-     * 根据parts路径遍历侦听器树，并在最后的节点上执行回调函数
-     * 
-     * @param parts 
-     * @param callback 
-     * @returns 
-     */
-    private _forEachNodes(parts: string[], callback: (node: FastListenerNode, parent: FastListenerNode) => void): FastListenerNode | undefined {
-        if (parts.length === 0) return
-        let current = this.listeners
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i]
-            if (!(part in current)) {
-                current[part] = {
-                    __listeners: []
-                } as unknown as FastListeners
-            }
-            if (i === parts.length - 1) {
-                const node = current[part]
-                callback(node, current)
-                return node
-            } else {
-                current = current[part]
-            }
-        }
-        return undefined
-    }
-
-
-    /**
-     * 从监听器节点中移除指定的事件监听器
-     * @private
-     * @param node - 监听器节点
-     * @param listener - 需要移除的事件监听器
-     * @description 遍历节点的监听器列表,移除所有匹配的监听器。支持移除普通函数和数组形式的监听器
-     */
-    private _removeListener(node: FastListenerNode, path: string[], listener: FastEventListener<any, any, any>): void {
-        if (!listener) return
-        removeItem(node.__listeners, (item: any) => {
-            item = Array.isArray(item) ? item[0] : item
-            const isRemove = item === listener
-            if (isRemove && typeof (this._options.onRemoveListener) === 'function') {
-                this.listenerCount--
-                this._options.onRemoveListener(path, listener)
-            }
-            return isRemove
-        })
-    }
-    /**
-     * 注册事件监听器
-     * @param type - 事件类型，支持以下格式：
-     *   - 普通字符串：'user/login'
-     *   - 通配符：'user/*'（匹配单层）或'user/**'（匹配多层）
-     *   - 全局监听：'**'（监听所有事件）
-     * @param listener - 事件监听器函数
-     * @param options - 监听器配置选项：
-     *   - count: 触发次数限制，0表示无限制
-     *   - prepend: 是否将监听器添加到监听器队列开头
-     * @returns 返回订阅者对象，包含off方法用于取消监听
-     * 
-     * @example
-     * ```ts
-     * // 监听特定事件
-     * emitter.on('user/login', (data) => console.log(data));
-     * 
-     * // 使用通配符
-     * emitter.on('user/*', (data) => console.log(data));
-     * 
-     * // 限制触发次数
-     * emitter.on('event', handler, { count: 3 });
-     * ```
-     */
-    public on<T extends string>(type: T, listener: FastEventListener<T, Events[T], Meta, Context>, options?: FastEventListenOptions): FastEventSubscriber
-    public on<T extends Types = Types>(type: T, listener: FastEventListener<Types, Events[T], Meta, Context>, options?: FastEventListenOptions): FastEventSubscriber
-    public on<P = any>(type: '**', listener: FastEventListener<Types, P, Meta, Context>): FastEventSubscriber
-    public on(): FastEventSubscriber {
-        const type = arguments[0] as string
-        const listener = arguments[1] as FastEventListener
-        const options = Object.assign({
-            count: 0,
-            prepend: false
-        }, arguments[2]) as Required<FastEventListenOptions>
-
-        if (type.length === 0) throw new Error('event type cannot be empty')
-
-        if (type === '**') {
-            return this.onAny(listener)
-        }
-
-        const parts = type.split(this._delimiter);
-        const node = this._addListener(parts, listener, options)
-
-        // Retain不支持通配符
-        if (node && !type.includes('*')) this._emitForLastEvent(type)
-
-        return {
-            off: () => node && this._removeListener(node, parts, listener)
-        }
-    }
-
-
-    /**
-     * 注册一次性事件监听器
-     * @param type - 事件类型，支持与on方法相同的格式：
-     *   - 普通字符串：'user/login'
-     *   - 通配符：'user/*'（匹配单层）或'user/**'（匹配多层）
-     * @param listener - 事件监听器函数
-     * @returns 返回订阅者对象，包含off方法用于取消监听
-     * 
-     * @description
-     * 监听器只会在事件首次触发时被调用一次，之后会自动解除注册。
-     * 这是on方法的特例，相当于设置options.count = 1。
-     * 如果事件有保留消息，新注册的监听器会立即收到最近一次的保留消息并解除注册。
-     * 
-     * @example
-     * ```ts
-     * // 只监听一次登录事件
-     * emitter.once('user/login', (data) => {
-     *   console.log('用户登录:', data);
-     * });
-     * ```
-     */
-    public once<T extends Types = Types>(type: T, listener: FastEventListener<T, Events[T], Meta, Context>): FastEventSubscriber
-    public once<T extends string>(type: T, listener: FastEventListener<T, Events[T], Meta, Context>): FastEventSubscriber
-    public once(): FastEventSubscriber {
-        return this.on(arguments[0], arguments[1], { count: 1 })
-    }
-
-    /**
-     * 注册一个监听器，用于监听所有事件
-     * @param listener 事件监听器函数，可以接收任意类型的事件数据
-     * @returns {FastEventSubscriber} 返回一个订阅者对象，包含 off 方法用于取消监听
-     * @example
-     * ```ts
-     * const subscriber = emitter.onAny((eventName, data) => {
-     *   console.log(eventName, data);
-     * });
-     * 
-     * // 取消监听
-     * subscriber.off();
-     * ```
-     */
-    onAny<P = any>(listener: FastEventListener<string, P, Meta, Context>, options?: Pick<FastEventListenOptions, 'prepend'>): FastEventSubscriber {
-        const listeners = this.listeners.__listeners
-        if (options && options.prepend) {
-            listeners.splice(0, 0, listener)
-        } else {
-            listeners.push(listener)
-        }
-        return {
-            off: () => this._removeListener(this.listeners, [], listener)
-        }
-    }
-
-    off(listener: FastEventListener<any, any, any>): void
-    off(type: string, listener: FastEventListener<any, any, any>): void
-    off(type: Types, listener: FastEventListener<any, any, any>): void
-    off(type: string): void
-    off(type: Types): void
-    off() {
-        const args = arguments
-        const type = typeof (args[0]) === 'function' ? undefined : args[0]
-        const listener = typeof (args[0]) === 'function' ? args[0] : args[1]
-        const parts = type ? type.split(this._delimiter) : []
-        const hasWildcard = type ? type.includes('*') : false
-        if (type && !hasWildcard) {
-            this._traverseToPath(this.listeners, parts, (node) => {
-                if (listener) { // 只删除指定的监听器
-                    this._removeListener(node, parts, listener)
-                } else if (type) {
-                    node.__listeners = []
-                }
-            })
-        } else { // 仅删除指定的侦听器
-            const entryParts: string[] = hasWildcard ? [] : parts
-            this._traverseListeners(this.listeners, entryParts, (path, node) => {
-                if (listener !== undefined || (hasWildcard && isPathMatched(path, parts))) {
-                    if (listener) {
-                        this._removeListener(node, parts, listener)
-                    } else {
-                        node.__listeners = []
-                    }
-                }
-            })
-        }
-    }
-
-    /**
-     * 移除所有事件监听器
-     * @param entry - 可选的事件前缀,如果提供则只移除指定前缀下的的监听器
-     * @description 
-     * - 如果提供了prefix参数,则只清除该前缀下的所有监听器
-     * - 如果没有提供prefix,则清除所有监听器
-     * - 同时会清空保留的事件(_retainedEvents)
-     * - 重置监听器对象为空
-
-    * @example
-     * 
-     * ```ts
-     * emitter.offAll();    // 清除所有监听器
-     * emitter.offAll('a/b'); // 清除a/b下的所有监听器
-     * 
-     */
-    offAll(entry?: string) {
-        if (entry) {
-            const entryNode = this._getListenerNode(entry.split(this._delimiter))
-            if (entryNode) entryNode.__listeners = []
-            this._removeRetainedEvents(entry)
-        } else {
-            this.retainedMessages.clear()
-            this.listeners = { __listeners: [] } as unknown as FastListeners
-        }
-        if (typeof (this._options.onClearListeners) === 'function') this._options.onClearListeners.call(this)
-    }
-
-    private _getListenerNode(parts: string[]): FastListenerNode | undefined {
-        let entryNode: FastListenerNode | undefined
-        this._forEachNodes(parts, (node) => {
-            entryNode = node
-        })
-        return entryNode
-    }
-    /**
-     * 移除保留的事件
-     * @param prefix - 事件前缀。如果不提供，将清除所有保留的事件。
-     *                如果提供前缀，将删除所有以该前缀开头的事件。
-     *                如果前缀不以分隔符结尾，会自动添加分隔符。
-     * @private
-     */
-    private _removeRetainedEvents(prefix?: string) {
-        if (!prefix) this.retainedMessages.clear()
-        if (prefix?.endsWith(this._delimiter)) {
-            prefix += this._delimiter
-        }
-        this.retainedMessages.delete(prefix!)
-        for (let key of this.retainedMessages.keys()) {
-            if (key.startsWith(prefix!)) {
-                this.retainedMessages.delete(key)
-            }
-        }
-    }
-    clear() {
-        this.offAll()
-    }
-
-    private _createMeta(extra: Record<string, any> | undefined) {
-        if (!this._options.meta) return extra
-        return Object.assign({}, this._options.meta, extra)
-    }
-
-
-    private _emitForLastEvent(type: string) {
-        if (this.retainedMessages.has(type)) {
-            const message = this.retainedMessages.get(type)
-            const parts = type.split(this._delimiter);
-            this._traverseToPath(this.listeners, parts, (node) => {
-                this._executeListeners(node, message)
-            })
-            // onAny侦听器保存在根节点中，所以需要执行
-            this._executeListeners(this.listeners, message)
-        }
-    }
-
-    /**
-     * 遍历监听器节点树
-     * @param node 当前遍历的监听器节点
-     * @param parts 事件名称按'.'分割的部分数组
-     * @param callback 遍历到目标节点时的回调函数
-     * @param index 当前遍历的parts数组索引,默认为0
-     * @param lastFollowing  当命中**时该值为true, 注意**只能作在路径的最后面，如a.**有效，而a.**.b无效
-     * @private
-     * 
-     * 支持三种匹配模式:
-     * - 精确匹配: 'a.b.c'
-     * - 单层通配: 'a.*.c' 
-     * - 多层通配: 'a.**'
-     */
-    private _traverseToPath(node: FastListenerNode, parts: string[], callback: (node: FastListenerNode) => void, index: number = 0, lastFollowing?: boolean): void {
-
-        if (index >= parts.length) {
-            callback(node)
-            return
-        }
-        const part = parts[index]
-
-        if (lastFollowing === true) {
-            this._traverseToPath(node, parts, callback, index + 1, true)
-            return
-        }
-
-        if ('*' in node) {
-            this._traverseToPath(node['*'], parts, callback, index + 1)
-        }
-        // 
-        if ('**' in node) {
-            this._traverseToPath(node['**'], parts, callback, index + 1, true)
-        }
-
-        if (part in node) {
-            this._traverseToPath(node[part], parts, callback, index + 1)
-        }
-    }
-
-    private _traverseListeners(node: FastListenerNode, entry: string[], callback: (path: string[], node: FastListenerNode) => void): void {
-        let entryNode: FastListenerNode = node
-        // 如果指定了entry路径，则按照路径遍历
-        if (entry && entry.length > 0) {
-            this._traverseToPath(node, entry, (node) => {
-                entryNode = node
-            });
-        }
-        const traverseNodes = (node: FastListenerNode, callback: (path: string[], node: FastListenerNode) => void, parentPath: string[]) => {
-            callback(parentPath, node);
-            for (let [key, childNode] of Object.entries(node)) {
-                if (key.startsWith("__")) continue
-                if (childNode) {
-                    traverseNodes(childNode as FastListenerNode, callback, [...parentPath, key]);
-                }
-            }
-        }
-        // 如果没有指定entry或entry为空数组，则递归遍历所有节点
-        traverseNodes(entryNode, callback, []);
-    }
-
-    /**
-     * 执行单个监听器函数
-     * @param listener - 要执行的监听器函数或包装过的监听器对象
-     * @param message - 事件消息对象，包含type、payload和meta
-     * @returns 监听器的执行结果或错误对象（如果配置了ignoreErrors）
-     * @private
-     * 
-     * @description
-     * 执行单个监听器函数，处理以下情况：
-     * - 如果监听器是包装过的（有__wrappedListener属性），调用包装的函数
-     * - 否则直接调用监听器函数
-     * - 使用配置的上下文（_context）作为this
-     * - 捕获并处理执行过程中的错误：
-     *   - 如果有onListenerError回调，调用它
-     *   - 如果配置了ignoreErrors，返回错误对象
-     *   - 否则抛出错误
-     */
-    private _executeListener(listener: any, message: FastEventMessage): any {
-        try {
-            if (typeof (listener.__wrappedListener) === 'function') {
-                return listener.__wrappedListener.call(this._context, message)
-            } else {
-                return listener.call(this._context, message)
-            }
-        } catch (e: any) {
-            e._emitter = message.type
-            if (typeof (this._options.onListenerError) === 'function') {
-                this._options.onListenerError.call(this, message.type, e)
-            }
-            // 如果忽略错误，则返回错误对象
-            if (this._options.ignoreErrors) {
-                return e
-            } else {
-                throw e
-            }
-        }
-    }
-
-    /**
-     * 执行监听器节点中的所有监听函数
-     * @param node - FastListenerNode类型的监听器节点
-     * @param payload - 事件携带的数据
-     * @param type - 事件类型
-     * @returns 返回所有监听函数的执行结果数组
-     * @private
-     * 
-     * @description
-     * 遍历执行节点中的所有监听函数:
-     * - 对于普通监听器，直接执行并收集结果
-     * - 对于带次数限制的监听器(数组形式)，执行后递减次数，当次数为0时移除该监听器
-     */
-    private _executeListeners(node: FastListenerNode, message: FastEventMessage): any[] {
-        if (!node || !node.__listeners) return []
-        let i = 0
-        const listeners = node.__listeners
-        let result: any[] = []
-        while (i < listeners.length) {
-            const listener = listeners[i]
-            if (Array.isArray(listener)) {
-                result.push(this._executeListener(listener[0], message))
-                listener[1]--
-                if (listener[1] === 0) {
-                    listeners.splice(i, 1)
-                    i-- // 抵消后面的i++
-                }
-            } else {
-                result.push(this._executeListener(listener, message))
-            }
-            i++
-        }
-        return result
-    }
-    /**
-     * 触发事件并执行对应的监听器
-     * 
-     * @param type - 事件类型字符串或包含事件信息的对象
-     * @param payload - 事件携带的数据负载
-     * @param retain - 是否保留该事件(用于新订阅者)
-     * @param meta - 事件元数据
-     * @returns 所有监听器的执行结果数组
-     * 
-     * @example
-     * // 方式1: 参数形式
-     * emit('user.login', { id: 1 }, true)
-     * 
-     * // 方式2: 对象形式
-     * emit({ type: 'user.login', payload: { id: 1 } ,meta:{...}}}, true)
-     */
-    /**
-     * 同步触发事件
-     * @param type - 事件类型，可以是字符串或预定义的事件类型
-     * @param payload - 事件数据负载
-     * @param retain - 是否保留该事件，用于后续新的订阅者
-     * @param meta - 事件元数据
-     * @returns 所有监听器的执行结果数组
-     * 
-     * @description
-     * 同步触发指定类型的事件，支持两种调用方式：
-     * 1. 参数形式：emit(type, payload, retain, meta)
-     * 2. 对象形式：emit({ type, payload, meta }, retain)
-     * 
-     * 特性：
-     * - 支持通配符匹配，一个事件可能触发多个监听器
-     * - 如果设置了retain为true，会保存最后一次的事件数据
-     * - 按照注册顺序同步调用所有匹配的监听器
-     * - 如果配置了ignoreErrors，监听器抛出的错误会被捕获并返回
-     * 
-     * @example
-     * ```ts
-     * // 简单事件触发
-     * emitter.emit('user/login', { userId: 123 });
-     * 
-     * // 带保留的事件触发
-     * emitter.emit('status/change', { online: true }, true);
-     * 
-     * // 带元数据的事件触发
-     * emitter.emit('data/update', newData, false, { timestamp: Date.now() });
-     * 
-     * // 使用对象形式触发
-     * emitter.emit({
-     *   type: 'user/login',
-     *   payload: { userId: 123 },
-     *   meta: { time: Date.now() }
-     * }, true);
-     * ```
-     */
-    public emit<R = any>(type: string, payload?: any, retain?: boolean, meta?: Meta): R[]
-    public emit<R = any>(type: Types, payload?: Events[Types], retain?: boolean, meta?: Meta): R[]
-    public emit<R = any>(message: FastEventMessage<Types, Events[Types], Meta>, retain?: boolean): R[]
-    public emit<R = any>(message: FastEventMessage<string, any, Meta>, retain?: boolean): R[]
-    public emit<R = any>(): R[] {
-        let type: string, payload: any, retain: boolean, meta: any
-        if (typeof (arguments[0]) === 'object') {
-            type = arguments[0].type as string
-            payload = arguments[0].payload as any
-            meta = this._createMeta(arguments[0].meta) as Meta
-            retain = arguments[1] as boolean
-        } else {
-            type = arguments[0] as string
-            payload = arguments[1] as any
-            retain = arguments[2] as boolean
-            meta = this._createMeta(arguments[3])
-        }
-        const message: FastEventMessage = {
-            type,
-            payload,
-            meta
-        }
-        const parts = type.split(this._delimiter);
-        if (retain) {
-            this.retainedMessages.set(type, message)
-        }
-        const results: any[] = []
-        // onAny侦听器保存在根节点中，所以需要执行 
-        results.push(...this._executeListeners(this.listeners, message))
-        this._traverseToPath(this.listeners, parts, (node) => {
-            results.push(...this._executeListeners(node, message))
-            // 用于调试时使用
-            if (this._options.debug && typeof (this._options.onExecuteListener) === 'function') {
-                if (retain) {
-                    if (!message.meta) message.meta = { retain: true }
-                }
-                this._options.onExecuteListener.call(this, message, results, [...this.listeners.__listeners, ...node.__listeners])
-            }
-        })
-
-        return results
-    }
-
-    /**
-     * 异步触发事件
-     * @param type - 事件类型，可以是字符串或预定义的事件类型
-     * @param payload - 事件数据负载
-     * @param retain - 是否保留该事件，用于后续新的订阅者
-     * @param meta - 事件元数据
-     * @returns Promise，解析为所有监听器的执行结果数组
-     * 
-     * @description
-     * 异步触发指定类型的事件，与emit方法类似，但有以下区别：
-     * - 返回Promise，等待所有异步监听器执行完成
-     * - 使用Promise.allSettled处理监听器的执行结果
-     * - 即使某些监听器失败，也会等待所有监听器执行完成
-     * - 返回结果包含成功值或错误信息
-     * 
-     * @example
-     * ```ts
-     * // 异步事件处理
-     * const results = await emitter.emitAsync('data/process', rawData);
-     * 
-     * // 处理结果包含成功和失败的情况
-     * results.forEach(result => {
-     *   if (result instanceof Error) {
-     *     console.error('处理失败:', result);
-     *   } else {
-     *     console.log('处理成功:', result);
-     *   }
-     * });
-     * 
-     * // 带元数据的异步事件
-     * await emitter.emitAsync('batch/process', items, false, {
-     *   batchId: 'batch-001',
-     *   timestamp: Date.now()
-     * });
-     * ```
-     */
-    public async emitAsync<R = any>(type: string, payload?: any, retain?: boolean, meta?: Meta): Promise<[R | Error][]>
-    public async emitAsync<R = any>(type: Types, payload?: Events[Types], retain?: boolean, meta?: Meta): Promise<[R | Error][]>
-    public async emitAsync<P = any>(): Promise<[P | Error][]> {
-        const type = arguments[0] as string
-        const payload = arguments[1] as any
-        const retain = arguments[2] as boolean
-        const meta = this._createMeta((arguments[3])) as Meta
-        const message = {
-            type,
-            payload,
-            meta
-        }
-        const results = await Promise.allSettled(this.emit<P>(message, retain))
-        return results.map((result) => {
-            if (result.status === 'fulfilled') {
-                return result.value
-            } else {
-                return result.reason
-            }
-        })
-    }
-
-    /**
-     * 等待指定事件发生，返回一个Promise
-     * @param type - 要等待的事件类型
-     * @param timeout - 超时时间（毫秒），默认为0表示永不超时
-     * @returns Promise，解析为事件消息对象，包含type、payload和meta
-     * 
-     * @description
-     * 创建一个Promise，在指定事件发生时解析。
-     * - 当事件触发时，Promise会解析为事件消息对象
-     * - 如果设置了timeout且超时，Promise会被拒绝
-     * - 一旦事件发生或超时，会自动取消事件监听
-     * 
-     * @example
-     * ```ts
-     * try {
-     *   // 等待登录事件，最多等待5秒
-     *   const event = await emitter.waitFor('user/login', 5000);
-     *   console.log('用户登录成功:', event.payload);
-     * } catch (error) {
-     *   console.error('等待登录超时');
-     * }
-     * 
-     * // 无限等待事件
-     * const event = await emitter.waitFor('server/ready');
-     * console.log('服务器就绪');
-     * ```
-     */
-    public waitFor<T extends Types, P = Events[T], M = Meta>(type: T, timeout?: number): Promise<FastEventMessage<T, P, M>>
-    public waitFor<T extends string, P = Events[T], M = Meta>(type: string, timeout?: number): Promise<FastEventMessage<T, P, M>>
-    public waitFor<T extends string, P = Events[T], M = Meta>(): Promise<FastEventMessage<T, P, M>> {
-        const type = arguments[0] as any
-        const timeout = arguments[1] as number
-        return new Promise<FastEventMessage<T, P, M>>((resolve, reject) => {
-            let tid: any
-            let subscriber: FastEventSubscriber
-            const listener = (message: FastEventMessage<T, P, M>) => {
-                clearTimeout(tid)
-                subscriber.off()
-                resolve(message)
-            }
-            if (timeout && timeout > 0) {
-                tid = setTimeout(() => {
-                    subscriber && subscriber.off()
-                    reject(new Error('wait for event<' + type + '> is timeout'))
-                }, timeout)
-            }
-            subscriber = this.on(type, listener as any)
-        })
-    }
-
-    /**
-     * 创建一个新的事件作用域
-     * @param prefix - 作用域前缀，将自动添加到该作用域下所有事件名称前
-     * @returns 新的FastEventScope实例
-     * 
-     * @description
-     * 创建一个新的事件作用域，用于在特定命名空间下管理事件。
-     * 
-     * 重要特性：
-     * - 作用域与父事件发射器共享同一个监听器表
-     * - 作用域中的事件会自动添加前缀
-     * - 作用域的所有操作都会映射到父事件发射器上
-     * - 作用域不是完全隔离的，只是提供了事件名称的命名空间
-     * 
-     * @example
-     * ```ts
-     * const emitter = new FastEvent();
-     * 
-     * // 创建用户相关事件的作用域
-     * const userEvents = emitter.scope('user');
-     * 
-     * // 在作用域中监听事件
-     * userEvents.on('login', (data) => {
-     *   // 实际监听的是 'user/login'
-     *   console.log('用户登录:', data);
-     * });
-     * 
-     * // 在作用域中触发事件
-     * userEvents.emit('login', { userId: 123 });
-     * // 等同于 emitter.emit('user/login', { userId: 123 })
-     * 
-     * // 创建嵌套作用域
-     * const profileEvents = userEvents.scope('profile');
-     * profileEvents.emit('update', { name: 'John' });
-     * // 等同于 emitter.emit('user/profile/update', { name: 'John' })
-     * 
-     * // 清理作用域
-     * userEvents.offAll();  // 清理 'user' 前缀下的所有事件
-     * ```
-     */
-    scope<T extends string>(prefix: T) {
-        return new FastEventScope<ScopeEvents<Events, T>>(this as unknown as FastEvent<ScopeEvents<Events, T>>, prefix)
-    }
-}