fastevent 2.0.2 → 2.1.1

package/dist/executors/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/executors/first.ts","../../src/executors/last.ts","../../src/executors/race.ts","../../src/executors/random.ts","../../src/executors/balance.ts","../../src/utils/isFunction.ts","../../src/utils/isString.ts","../../src/utils/expandable.ts","../../src/executors/series.ts","../../src/executors/waterfall.ts","../../src/executors/parallel.ts"],"names":["first","__name","listeners","message","args","execute","forEach","listener","last","length","race","winner","abortController","abortSignal","AbortController","signal","Promise","map","resolve","then","result","abort","random","index","Math","floor","balance","count","i","undefined","isFunction","fn","isString","str","series","options","reverse","onNext","onReturns","onError","Object","assign","_","cur","results","stepResult","item","e","behavior","waterfall","previous","payload","parallel"],"mappings":"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","file":"index.mjs","sourcesContent":["import { FastListenerExecutor } from \"./types\"\n\n/**\n * 执行第一个监听器的执行器函数\n * \n * @param listeners - 监听器数组，每个元素是一个包含监听器函数的元组\n * @param message - 要传递给监听器的消息对象\n * @param args - 要传递给监听器的额外参数\n * @param execute - 执行监听器的函数\n * @returns 返回一个数组，包含第一个监听器的执行结果\n */\nexport const first = (): FastListenerExecutor => {\n    return (listeners, message, args, execute) => {\n        listeners.forEach(listener => listener[2]--)\n        listeners[0][2]++\n        return [\n            execute(listeners[0][0], message, args)\n        ]\n    }\n}","import { FastListenerExecutor } from \"./types\"\n\n/**\n * 执行监听器列表中的最后一个监听器\n * @param listeners - 监听器数组\n * @param message - 事件消息\n * @param args - 事件参数\n * @param execute - 执行器函数\n * @returns 返回包含最后一个监听器执行结果的数组\n */\nexport const last = (): FastListenerExecutor => {\n    return (listeners, message, args, execute) => {\n        listeners.forEach(listener => listener[2]--)\n        listeners[listeners.length - 1][2]++\n        return [\n            execute(listeners[listeners.length - 1][0], message, args)\n        ]\n    }\n}","import { FastListenerMeta } from \"../types\"\nimport { FastListenerExecutor } from \"./types\"\n\n/**\n * 竞态执行器 - 同时执行多个监听器,只返回最快完成的结果\n * \n * @param listeners - 监听器元数据列表\n * @param message - 要处理的消息\n * @param args - 执行参数\n * @param execute - 执行函数\n * @returns 包含最快完成监听器结果的数组\n * \n * @description\n * - 只有第一个完成的监听器结果会被返回\n * - 其他未完成的监听器会被中止\n * - 如果没有提供中止信号,会自动创建一个\n * - 胜出的监听器计数会被恢复\n */\nexport const race = (): FastListenerExecutor => {\n    return (listeners, message, args, execute) => {\n        let winner: FastListenerMeta | undefined\n        let abortController: AbortController | undefined\n        if (!args || (args && !args.abortSignal)) {\n            abortController = new AbortController()\n            if (!args) args = {}\n            args.abortSignal = abortController.signal\n        }\n        const result = Promise.race(listeners.map(listener => {\n            listener[2]--\n            return Promise.resolve(execute(listener[0], message, args)).then((result: any) => {\n                if (!winner) {\n                    winner = listener\n                    listener[2]++\n                }\n                abortController?.abort()\n                return result\n            })\n        }))\n        return [\n            result\n        ]\n    }\n}","import { FastListenerExecutor } from \"./types\"\n\n/**\n * 随机执行器 - 从监听器列表中随机选择一个监听器执行\n * \n * @param listeners - 监听器列表，每个元素为 [监听器函数, 优先级, 执行次数] 的元组\n * @param message - 要处理的消息对象\n * @param args - 传递给监听器的额外参数\n * @param execute - 执行监听器的函数\n * @returns 返回包含执行结果的数组\n * \n * @remarks\n * - 随机选择一个监听器执行\n * - 所有监听器的执行次数计数减1\n * - 被选中执行的监听器执行次数加1\n */\nexport const random = (): FastListenerExecutor => {\n    return (listeners, message, args, execute) => {\n        const index = Math.floor(Math.random() * listeners.length)\n        listeners.forEach(listener => listener[2]--)\n        listeners[index][2]++\n        return [\n            execute(listeners[index][0], message, args)\n        ]\n    }\n}","import { FastListenerExecutor } from \"./types\"\n\n/**\n * 负载均衡执行器，用于在多个监听器中选择执行次数最少的进行调用\n * @param listeners 监听器列表\n * @param message 消息对象\n * @param args 参数列表\n * @param execute 执行函数\n * @returns 返回包含单个执行结果的数组\n * \n * 执行策略:\n * 1. 遍历所有监听器,找出执行次数最少的监听器\n * 2. 由于监听器执行后会自动+1,因此先对所有监听器执行次数-1,以抵消后续的+1\n * 3. 只执行选中的监听器,其他监听器不执行\n */\nexport const balance = (): FastListenerExecutor => {\n    return (listeners, message, args, execute) => {\n        // 找出listeners里面所有执行器的执行次数最少的项\n        let count: number\n        let index: number = 0\n        listeners.forEach((listener, i) => {\n            // 为什么所有监听器的执行次数均减1？\n            // 因为监听器执行完毕后会自动+1，但是在balance执行器中，只有一个会监听器会执行，因此在此先减一用来抵消后续的+1\n            listener[2]--\n            if (count === undefined || count > listener[2]) {\n                count = listener[2]\n                index = i\n            }\n        })\n        listeners[index][2]++\n        return [execute(listeners[index][0], message, args)]\n    }\n}","export function isFunction(fn: any): fn is Function {\n    return fn && typeof (fn) == \"function\"\n}","export function isString(str: any): str is string {\n    return str && typeof (str) === \"string\"\n}","/**\n * \n * \n * 用于包括输入值为可展开的对象\n * \n * \n * 用在emit事件\n * \n * emitter1 = new FastEvent()\n * emitter2 = new FastEvent()\n * \n * emitter1.on(\"xxx\",(message)=>{\n *      return emitter2.emit(message)\n * })\n * \n * emitter2.on(\"xxx\",()=>1)\n * emitter2.on(\"xxx\",()=>2)\n * \n * const results = emitter1.emit(\"xxx\")\n * // results == [[1,2]] 而不 [1,2]，因为emitter2.emit返回的是一个[]\n * \n * expandable的作用就是对emit结果进行包括，当isExpandable时，在emit内部进行展开\n * \n * \n * \n * \n * emitter1.on(\"xxx\",(message)=>{\n *      // 告诉emitter2.emit返回的是一个expandable对象\n *      // 然后在内部就展开此对象\n *      return emitter2.emit(message)\n * })\n * \n*  const results = emitter1.emit(\"xxx\")\n * // results ==  [1,2]\n * \n * 为了实现对结果数据的展开处理，在emit内部需要对监听器的执行结果进行依次检查\n * 这多了一个迭代操作，为了不影响性能，可以关闭此特性\n * options.expandEmitResults = false\n * \n * \n */\n\nexport const __expandable__ = Symbol.for('__expandable__')\n\nexport function expandable(value: any) {\n    value[__expandable__] = true\n    return value\n}\n\nexport function isExpandable(value: any) {\n    return value && value[__expandable__]\n}","import { FastEventListener, FastEventListenerArgs, FastEventMessage } from \"../types\"\nimport { isString } from \"../utils\"\nimport { isFunction } from \"../utils/isFunction\"\nimport { FastListenerExecutor } from \"./types\"\n\n\nexport type SeriesExecutorOptions = {\n    reverse?: boolean    // 反向执行监听器\n    /**\n     * 控制监听器如何返回结果\n     * \n     * 提供一个reduce函数对所有监听器返回结果进行reduce操作\n     * series({\n     *    onReturns: (result, cur)=>{\n     *      if(!result) result = []\n     *      return result.push(cur)\n     *    }\n     * })\n     */\n    onReturns?: (results: any, cur: any) => any\n    // 当调用下一个监听器前执行,返回false或触发错误均不再执行后续的监听器\n    // 可以在此修改message\n    onNext?: (index: number, previous: any, message: FastEventMessage, args: FastEventListenerArgs, results: any) => boolean\n    // 当执行监听器出错时的回调，返回false中止后续执行\n    onError?: 'skip' | 'abort' | 'error' | ((e: any, message: FastEventMessage, args: FastEventListenerArgs) => void | 'skip' | 'abort' | 'error')\n}\n\nexport const series = (options?: SeriesExecutorOptions): FastListenerExecutor => {\n    const { reverse, onNext, onReturns, onError } = Object.assign({\n        reverse: false,\n        onError: () => { },\n        onNext: () => true,\n        onReturns: (_: any, cur: any) => cur\n    }, options) as SeriesExecutorOptions\n    return async (listeners, message, args, execute) => {\n        let results: any = undefined\n        let stepResult: any = undefined\n        let index: number = 0\n        // 全部执行次数-1\n        listeners.forEach(listener => listener[2]--)\n        for (let i = 0; i < listeners.length; i++) {\n            const item = listeners[reverse ? listeners.length - 1 - i : i]\n            const listener = item[0] as FastEventListener<any, any, any>\n            try {\n                if (isFunction(onNext) && onNext(++index, stepResult, message, args, results) === false) {\n                    break\n                }\n                stepResult = await execute(listener, message, args, false)\n                if (isFunction(onReturns)) {\n                    results = onReturns(results, stepResult)\n                } else {\n                    results = stepResult\n                }\n                // 实际执行次数+1\n                item[2]++\n            } catch (e: any) {\n                try {\n                    const behavior = isString(onError) ? onError : isFunction(onError) && onError!(e, message, args)\n                    if (behavior === 'skip') {\n                        continue\n                    } else if (behavior === 'error') {\n                        results = e\n                        break\n                    } else if (behavior === 'abort') {\n                        break\n                    }\n                } catch { }\n            }\n        }\n        return results\n    }\n\n}","import { FastEventMessage } from \"../types\"\nimport { series, SeriesExecutorOptions } from \"./series\"\nimport { FastListenerExecutor } from \"./types\"\n\nexport type WaterfallExecutorOptions = Omit<SeriesExecutorOptions, 'onError' | 'onReturns' | 'onStep'>\n\n\n/**\n * 创建一个瀑布流执行器，用于按顺序执行监听器，并将前一个监听器的结果传递给下一个监听器\n * 如果出错就不再执行后续的监听器\n * \n * @param options - 执行器配置选项\n * @returns 返回一个 FastListener 执行器实例\n * \n * @remarks\n * - 当任一监听器执行出错时，会中断后续监听器的执行\n * - 每个监听器的执行结果会作为下一个监听器的 payload 参数\n */\nexport const waterfall = (options?: WaterfallExecutorOptions): FastListenerExecutor => {\n    return series(Object.assign({}, options, {\n        // 出错时不再执行后续的监听器\n        onError: 'abort',\n        // 将结果作为payload传给下一个监听器\n        onNext: (index: number, previous: any, message: FastEventMessage) => {\n            message.payload = previous\n        }\n    }) as unknown as SeriesExecutorOptions)\n}","import { FastListenerExecutor } from \"./types\"\n\n/**\n *  \n */\nexport const parallel = (): FastListenerExecutor => {\n    return (listeners, message, args, execute) => {\n        return listeners.map(listener => execute(listener[0], message, args, true))\n    }\n}"]}

package/dist/index.d.mts

@@ -3,7 +3,6 @@ type FastListenerPipe = (listener: FastEventListener) => FastEventListener;
 interface FaseEventMessageExtends {
 }
 interface FastEventMeta {
-    priority?: number;
 }
 type FastEventMessage<Events extends Record<string, any> = Record<string, any>, M = any> = ({
     [K in keyof Events]: {
@@ -16,7 +15,7 @@ type FastEventEmitMessage<Events extends Record<string, any> = Record<string, an
     [K in keyof Events]: {
         type: Exclude<K, number | symbol>;
         payload?: Events[K];
-        meta?: FastEventMeta & M & Record<string, any>;
+        meta?: Partial<FastEventMeta> & M & Record<string, any>;
     };
 }[Exclude<keyof Events, number | symbol>]) & FaseEventMessageExtends;
 type FastEventListener<T extends string = string, P = any, M = any, C = any> = (this: C, message: FastEventMessage<{
@@ -35,7 +34,7 @@ type FastListenerNode = {
 type FastEventSubscriber = {
     off: () => void;
     /**
-     * 为什么要有一个listener引用? 主要用于移除侦听器时使用
+     * 为什么要有一个listener引用? 主要用于移除监听器时使用
      *
      *  - 正常情况下
      *  const subscriber = emitter.on('event', listener)
@@ -51,11 +50,11 @@ type FastEventSubscriber = {
      *  subscriber.off()        可以正常生效
      *  scope.off('event', listener)    // 无法生效
      *  scope.off(listener) // 无法生效
-     *  因为在scope中，为了让侦听器可以处理scope的逻辑，对listener进行了包装，
-     *  因此在事件注册表中登记的不是listener，而是经过包装的侦听器
+     *  因为在scope中，为了让监听器可以处理scope的逻辑，对listener进行了包装，
+     *  因此在事件注册表中登记的不是listener，而是经过包装的监听器
      *  subscriber.off()        可以正常生效
      *  如果要使用scope.off或emitter.off
-     *  需要使用subscriber.listener， subscriber.listener记录了原始的侦听器引用
+     *  需要使用subscriber.listener， subscriber.listener记录了原始的监听器引用
      *   subscriber.listener===listener
      *
      *  scope.off('event', subscriber.listener)    // 生效
@@ -66,26 +65,24 @@ type FastEventSubscriber = {
 };
 type FastListeners = FastListenerNode;
 type FastEventOptions<Meta = Record<string, any>, Context = any> = {
-    id?: string;
-    debug?: boolean;
-    delimiter?: string;
-    context?: Context;
-    ignoreErrors?: boolean;
-    meta?: Meta;
-    onAddListener?: (type: string[], listener: FastEventListener) => void;
-    onRemoveListener?: (type: string[], listener: FastEventListener) => void;
+    id: string;
+    debug: boolean;
+    delimiter: string;
+    context: Context;
+    ignoreErrors: boolean;
+    meta: Meta;
+    onAddListener?: (type: string, listener: FastEventListener, options: FastEventListenOptions<Record<string, any>, Meta>) => boolean | FastEventSubscriber | void;
+    onRemoveListener?: (type: string, listener: FastEventListener) => void;
     onClearListeners?: () => void;
-    onListenerError?: ((listener: FastEventListener, error: Error, message: FastEventMessage<any, Meta>, args: FastEventListenerArgs<Meta> | undefined) => void);
-    onBeforeExecuteListener?: (message: FastEventMessage<any, Meta>, args: FastEventListenerArgs<Meta>) => boolean | void;
+    onListenerError?: ((error: Error, listener: FastEventListener, message: FastEventMessage<any, Meta>, args: FastEventListenerArgs<Meta> | undefined) => void);
+    onBeforeExecuteListener?: (message: FastEventMessage<any, Meta>, args: FastEventListenerArgs<Meta>) => boolean | void | any[];
     onAfterExecuteListener?: (message: FastEventMessage<any, Meta>, returns: any[], listeners: FastListenerNode[]) => void;
     /**
      * 全局执行器
-     * allSettled: 使用Promise.allSettled()执行所有监听器
-     * race: 使用Promise.race()执行所有监听器，只有第一个执行完成就返回,其他监听器执行结果会被忽略
-     * balance: 尽可能平均执行各个侦听器
-     * sequence: 按照侦听器添加顺序依次执行
      */
-    executor?: FastListenerExecutorArgs;
+    executor?: FastListenerExecutor;
+    onMessage?: FastEventListener;
+    expandEmitResults?: boolean;
 };
 interface FastEvents {
 }
@@ -100,7 +97,6 @@ type FastEventListenOptions<Events extends Record<string, any> = Record<string,
     off?: (message: FastEventMessage<Events, Meta>, args: FastEventListenerArgs<Meta>) => boolean;
     pipes?: FastListenerPipe[];
 };
-type FastListenerExecutorArgs = 'default' | 'allSettled' | 'race' | 'balance' | 'first' | 'last' | 'random' | IFastListenerExecutor;
 type FastEventListenerArgs<M = Record<string, any>> = {
     retain?: boolean;
     meta?: Partial<M> & Record<string, any>;
@@ -109,10 +105,14 @@ type FastEventListenerArgs<M = Record<string, any>> = {
      *
      * allSettled: 使用Promise.allSettled()执行所有监听器
      * race: 使用Promise.race()执行所有监听器，只有第一个执行完成就返回,其他监听器执行结果会被忽略
-     * balance: 尽可能平均执行各个侦听器
-     * sequence: 按照侦听器添加顺序依次执行
+     * balance: 尽可能平均执行各个监听器
+     * sequence: 按照监听器添加顺序依次执行
+     */
+    executor?: FastListenerExecutor;
+    /**
+     * 当emit参数解析完成后的回调，用于修改emit参数
      */
-    executor?: FastListenerExecutorArgs;
+    parseArgs?: (message: FastEventMessage, args: FastEventListenerArgs) => void;
 };
 type Merge<T extends object, U extends object> = {
     [K in keyof T | keyof U]: K extends keyof U ? U[K] : K extends keyof T ? T[K] : never;
@@ -120,26 +120,155 @@ type Merge<T extends object, U extends object> = {
 type RequiredItems<T extends object, Items extends string[]> = Omit<T, Items[number]> & {
     [K in Items[number] & keyof T]-?: Exclude<T[K], undefined>;
 };
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type OptionalItems<T, K extends keyof T> = Expand<Omit<T, K> & {
+    [P in K]?: T[P];
+}>;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
 type Fallback<T, F> = [
     T
 ] extends [never] ? F : T extends undefined ? F : T;
-type IFastListenerExecutor = (listeners: FastListenerMeta[], message: FastEventMessage, args: FastEventListenerArgs | undefined, execute: (listener: FastEventListener, message: FastEventMessage, args?: FastEventListenerArgs) => Promise<any> | any) => Promise<any[]> | any[];
+type ChangeFieldType<Record, Name extends string, Type = any> = Expand<Omit<Record, Name> & {
+    [K in Name]: Type;
+}>;
+type OverrideOptions<T> = ChangeFieldType<Required<T>, 'context', never>;
+type ObjectKeys<T, I = string> = {
+    [P in keyof T]: P extends I ? P : never;
+}[keyof T];
+/**
+ * 从类型数组中移除重复项，返回保留唯一类型的元组
+ * @template T - 输入的任意类型数组（元组）
+ * @template Result - 内部使用的累积结果数组（默认空数组）
+ * @returns {any[]} 去重后的类型元组，保留首次出现的顺序
+ *
+ * @example
+ * type T1 = Unique<[number, string, number]>;  // [number, string]
+ * type T2 = Unique<[1, 2, 2, 3]>;              // [1, 2, 3]
+ * type T3 = Unique<['a', 'b', 'a']>;           // ['a', 'b']
+ */
+type Unique<T extends any[], Result extends any[] = []> = T extends [infer First, ...infer Rest] ? First extends Result[number] ? Unique<Rest, Result> : Unique<Rest, [...Result, First]> : Result;
+type Overloads<T> = Unique<T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+    (...args: infer A8): infer R8;
+} ? [
+    (...args: A1) => R1,
+    ((...args: A2) => R2),
+    ((...args: A3) => R3),
+    ((...args: A4) => R4),
+    ((...args: A5) => R5),
+    ((...args: A6) => R6),
+    ((...args: A7) => R7),
+    ((...args: A8) => R8)
+] : T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+} ? [
+    (...args: A1) => R1,
+    ((...args: A2) => R2),
+    ((...args: A3) => R3),
+    ((...args: A4) => R4),
+    ((...args: A5) => R5),
+    ((...args: A6) => R6),
+    ((...args: A7) => R7)
+] : T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+} ? [
+    (...args: A1) => R1,
+    ((...args: A2) => R2),
+    ((...args: A3) => R3),
+    ((...args: A4) => R4),
+    ((...args: A5) => R5),
+    ((...args: A6) => R6)
+] : T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+} ? [
+    (...args: A1) => R1,
+    ((...args: A2) => R2),
+    ((...args: A3) => R3),
+    ((...args: A4) => R4),
+    ((...args: A5) => R5)
+] : T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+} ? [
+    (...args: A1) => R1,
+    ((...args: A2) => R2),
+    ((...args: A3) => R3),
+    ((...args: A4) => R4)
+] : T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+} ? [
+    ((...args: A1) => R1),
+    ((...args: A2) => R2),
+    ((...args: A3) => R3)
+] : T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+} ? [
+    ((...args: A1) => R1),
+    ((...args: A2) => R2)
+] : T extends {
+    (...args: infer A1): infer R1;
+} ? [
+    (...args: A1) => R1
+] : [
+    T
+]>;
+type Dict<V = any> = Record<Exclude<string, number | symbol>, V>;
+
+type FastListenerExecutor = (listeners: FastListenerMeta[], message: FastEventMessage, args: FastEventListenerArgs, execute: (listener: FastEventListener, message: FastEventMessage, args: FastEventListenerArgs, catchErrors?: boolean) => Promise<any> | any) => Promise<any[]> | any[];
 
-type FastEventScopeOptions<Meta, Context> = {
-    meta?: FastEventMeta & Meta;
-    context?: Context;
-    executor?: FastListenerExecutorArgs;
+type FastEventScopeOptions<Meta = Record<string, any>, Context = any> = {
+    meta: FastEventScopeMeta & FastEventMeta & Meta;
+    context: Context;
+    executor?: FastListenerExecutor;
+    onMessage?: FastEventListener;
 };
 type FastEventScopeMeta = {
     scope: string;
 };
-declare class FastEventScope<Events extends Record<string, any> = Record<string, any>, Meta extends Record<string, any> = Record<string, any>, Context = any, Types extends keyof Events = keyof Events, FinalMeta extends Record<string, any> = Meta & FastEventScopeMeta> {
-    emitter: FastEvent<Events>;
+declare class FastEventScope<Events extends Record<string, any> = Record<string, any>, Meta extends Record<string, any> = Record<string, any>, Context = never, Types extends keyof Events = keyof Events, FinalMeta extends Record<string, any> = FastEventMeta & FastEventScopeMeta & Meta> {
+    __FastEventScope__: boolean;
+    private _options;
+    types: {
+        events: Events;
+        meta: FinalMeta;
+        context: Fallback<Context, typeof this>;
+    };
     prefix: string;
-    options: Required<FastEventScopeOptions<FinalMeta, Context>>;
-    events: Events;
-    constructor(emitter: FastEvent<Events>, prefix: string, options?: FastEventScopeOptions<Meta, Context>);
-    get context(): Context;
+    emitter: FastEvent<Events>;
+    constructor(options?: DeepPartial<FastEventScopeOptions<FinalMeta, Context>>);
+    get context(): Fallback<Context, typeof this>;
+    get options(): FastEventScopeOptions<FinalMeta, Context>;
+    bind(emitter: FastEvent<any>, prefix: string, options?: DeepPartial<FastEventScopeOptions<FinalMeta, Context>>): void;
     /**
      * 获取作用域监听器
      * 当启用作用域时,对原始监听器进行包装,添加作用域前缀处理逻辑
@@ -150,14 +279,20 @@ declare class FastEventScope<Events extends Record<string, any> = Record<string,
     private _getScopeListener;
     private _getScopeType;
     private _fixScopeType;
-    on<T extends Types = Types>(type: T, listener: FastEventListener<Exclude<T, number | symbol>, Events[T], FinalMeta, Context>, options?: FastEventListenOptions): FastEventSubscriber;
-    on<T extends string>(type: T, listener: FastEventListener<string, any, FinalMeta, Context>, options?: FastEventListenOptions): FastEventSubscriber;
-    on(type: '**', listener: FastEventAnyListener<Events, FinalMeta, Context>, options?: FastEventListenOptions): FastEventSubscriber;
-    once<T extends Types = Types>(type: T, listener: FastEventListener<Exclude<T, number | symbol>, Events[T], FinalMeta, Context>, options?: FastEventListenOptions): FastEventSubscriber;
-    once<T extends string>(type: T, listener: FastEventListener<string, any, FinalMeta, Context>, options?: FastEventListenOptions): FastEventSubscriber;
+    on<T extends Types = Types>(type: T, options?: FastEventListenOptions<Events, FinalMeta>): FastEventSubscriber;
+    on<T extends string>(type: T, options?: FastEventListenOptions<Events, FinalMeta>): FastEventSubscriber;
+    on(type: '**', options?: FastEventListenOptions<Events, FinalMeta>): FastEventSubscriber;
+    on<T extends Types = Types>(type: T, listener: FastEventListener<Exclude<T, number | symbol>, Events[T], FinalMeta, Fallback<Context, typeof this>>, options?: FastEventListenOptions): FastEventSubscriber;
+    on<T extends string>(type: T, listener: FastEventListener<string, any, FinalMeta, Fallback<Context, typeof this>>, options?: FastEventListenOptions): FastEventSubscriber;
+    on(type: '**', listener: FastEventAnyListener<Events, FinalMeta, Fallback<Context, typeof this>>, options?: FastEventListenOptions): FastEventSubscriber;
+    once<T extends Types = Types>(type: T, options?: FastEventListenOptions<Events, FinalMeta>): FastEventSubscriber;
+    once<T extends string>(type: T, options?: FastEventListenOptions<Events, FinalMeta>): FastEventSubscriber;
+    once<T extends Types = Types>(type: T, listener: FastEventListener<Exclude<T, number | symbol>, Events[T], FinalMeta, Fallback<Context, typeof this>>, options?: FastEventListenOptions): FastEventSubscriber;
+    once<T extends string>(type: T, listener: FastEventListener<string, any, FinalMeta, Fallback<Context, typeof this>>, options?: FastEventListenOptions): FastEventSubscriber;
+    onAny(options?: Pick<FastEventListenOptions, 'prepend'>): FastEventSubscriber;
     onAny<P = any>(listener: FastEventAnyListener<{
         [K: string]: P;
-    }, FinalMeta, Context>, options?: Pick<FastEventListenOptions, 'prepend'>): FastEventSubscriber;
+    }, FinalMeta, Fallback<Context, typeof this>>, options?: Pick<FastEventListenOptions, 'prepend'>): FastEventSubscriber;
     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;
@@ -165,6 +300,8 @@ declare class FastEventScope<Events extends Record<string, any> = Record<string,
     off(type: Types): void;
     offAll(): void;
     clear(): void;
+    emit(type: Types, directive: symbol): void;
+    emit(type: string, directive: symbol): void;
     emit<R = any>(type: Types, payload?: Events[Types], options?: FastEventListenerArgs<FinalMeta>): R[];
     emit<R = any, T extends string = string>(type: T, payload?: T extends Types ? Events[Types] : any, options?: FastEventListenerArgs<FinalMeta>): R[];
     emit<R = any>(message: FastEventEmitMessage<Events, FinalMeta>, options?: FastEventListenerArgs<FinalMeta>): R[];
@@ -215,7 +352,13 @@ declare class FastEventScope<Events extends Record<string, any> = Record<string,
      * profileScope.emit('update', { name: 'John' });
      * ```
      */
-    scope<E extends Record<string, any> = Record<string, any>, P extends string = string, M extends Record<string, any> = Record<string, any>, C = Context>(prefix: P, options?: FastEventScopeOptions<Partial<FinalMeta> & M, C>): FastEventScope<PickScopeEvents<Events, P> & E, FinalMeta & M, C, keyof PickScopeEvents<Events, P> | keyof E, FinalMeta & M & FastEventScopeMeta>;
+    scope<E extends Record<string, any> = Record<string, any>, P extends string = string, M extends Record<string, any> = Record<string, any>, C = Context>(prefix: P, options?: DeepPartial<FastEventScopeOptions<Partial<FinalMeta> & M, C>>): FastEventScope<ScopeEvents<Events, P> & E, FinalMeta & M, C>;
+    scope<E extends Record<string, any> = Record<string, any>, P extends string = string, M extends Record<string, any> = Record<string, any>, C = Context, ScopeInstance extends FastEventScope<any, any, any> = FastEventScope<ScopeEvents<ScopeEvents<Events, P> & E, P> & E, FinalMeta & M, C>>(prefix: P, scopeObj: ScopeInstance, options?: DeepPartial<FastEventScopeOptions<Partial<FinalMeta> & M, C>>): ScopeInstance;
+    /**
+     * 当on/once/onAny未指定监听器时,此为默认监听器
+     * @param message
+     */
+    onMessage(message: FastEventMessage<Events, FinalMeta>, args: FastEventListenerArgs<FinalMeta>): void;
 }
 
 /**
@@ -225,7 +368,8 @@ declare class FastEventScope<Events extends Record<string, any> = Record<string,
  * @template Meta - 事件元数据类型，默认为任意键值对对象
  * @template Types - 事件类型的键名类型，默认为Events的键名类型
  */
-declare class FastEvent<Events extends Record<string, any> = Record<string, any>, Meta extends Record<string, any> = Record<string, any>, Context = never, AllEvents extends Record<string, any> = Events & FastEvents, Types extends keyof AllEvents = Exclude<keyof (AllEvents), number | symbol>> {
+declare class FastEvent<Events extends Record<string, any> = Record<string, any>, Meta extends Record<string, any> = Record<string, any>, Context = never, AllEvents extends Record<string, any> = Events & FastEvents, Types extends keyof AllEvents = Expand<Exclude<keyof (AllEvents), number | symbol>>> {
+    __FastEvent__: boolean;
     /** 事件监听器树结构，存储所有注册的事件监听器 */
     listeners: FastListeners;
     /** 事件发射器的配置选项 */
@@ -234,11 +378,15 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
     private _delimiter;
     /** 事件监听器执行时的上下文对象 */
     private _context;
-    /** 保留的事件消息映射，用于新订阅者 */
+    /** 保留的事件消息映射，Key是事件名称，Value是保留的事件消息 */
     retainedMessages: Map<string, any>;
     /** 当前注册的监听器总数 */
     listenerCount: number;
-    events: Events;
+    types: {
+        events: AllEvents;
+        meta: Expand<FastEventMeta & Meta & Record<string, any>>;
+        context: Expand<Fallback<Context, typeof this>>;
+    };
     /**
      * 创建FastEvent实例
      * @param options - 事件发射器的配置选项
@@ -250,17 +398,28 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
      * - context: null - 监听器执行上下文
      * - ignoreErrors: true - 是否忽略监听器执行错误
      */
-    constructor(options?: FastEventOptions<Meta, Context>);
+    constructor(options?: Partial<FastEventOptions<Meta, Context>>);
     /** 获取事件发射器的配置选项 */
-    get options(): RequiredItems<FastEventOptions<Meta, Context>, ["meta", "context"]>;
-    get context(): Context;
+    get options(): FastEventOptions<Meta, Context>;
+    get context(): Fallback<Context, typeof this>;
+    get meta(): Meta;
     /** 获取事件发射器的唯一标识符 */
     get id(): string;
+    /**
+     * 添加事件监听器到事件树中
+     * @param parts - 事件路径数组
+     * @param listener - 事件监听器函数
+     * @param options - 监听器配置选项
+     * @param options.count - 监听器触发次数限制
+     * @param options.prepend - 是否将监听器添加到监听器列表开头
+     * @returns [节点, 监听器索引] - 返回监听器所在节点和在节点监听器列表中的索引
+     * @private
+     */
     private _addListener;
     private _enableDevTools;
     /**
      *
-     * 根据parts路径遍历侦听器树，并在最后的节点上执行回调函数
+     * 根据parts路径遍历监听器树，并在最后的节点上执行回调函数
      *
      * @param parts
      * @param callback
@@ -354,7 +513,7 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
      * 此方法供子类继承
      *
      */
-    onMessage(message: FastEventMessage): void;
+    onMessage(message: FastEventMessage<AllEvents, Meta>, args: FastEventListenerArgs<Meta>): void;
     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;
@@ -368,7 +527,7 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
      * - 如果没有提供prefix,则清除所有监听器
      * - 同时会清空保留的事件(_retainedEvents)
      * - 重置监听器对象为空
- 
+     
     * @example
      *
      * ```ts
@@ -386,7 +545,19 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
      */
     private _removeRetainedEvents;
     clear(prefix?: string): void;
-    private _emitForLastEvent;
+    /**
+     * 发送最后一次事件的消息给对应的监听器
+     *
+     * @param type - 事件类型,支持通配符(*)匹配
+     * @private
+     *
+     * 处理流程:
+     * 1. 如果事件类型包含通配符,则遍历所有保留的消息,匹配符合模式的事件
+     * 2. 如果是普通事件类型,则直接获取对应的保留消息
+     * 3. 遍历匹配到的消息,查找对应路径的监听器节点
+     * 4. 执行所有匹配到的监听器
+     */
+    private _emitRetainMessage;
     /**
      * 遍历监听器节点树
      * @param node 当前遍历的监听器节点
@@ -408,6 +579,8 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
      * 执行单个监听器函数
      * @param listener - 要执行的监听器函数或包装过的监听器对象
      * @param message - 事件消息对象，包含type、payload和meta
+     * @param args - 监听器参数
+     * @param catchErrors - 是否捕获并处理执行过程中的错误
      * @returns 监听器的执行结果或错误对象（如果配置了ignoreErrors）
      * @private
      *
@@ -424,23 +597,18 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
     private _executeListener;
     private _getListenerExecutor;
     /**
-     * 触发事件并执行对应的监听器
-     * @param type - 事件类型字符串或包含事件信息的对象
-     * @param payload - 事件携带的数据负载
-        return
-    }
-    /**
-     * 执行监听器节点中的所有监听函数
-     * @param node - FastListenerNode类型的监听器节点
-     * @param payload - 事件携带的数据
-     * @param type - 事件类型
-     * @returns 返回所有监听函数的执行结果数组
+     * 执行监听器节点列表中的所有监听器函数
+     * @param nodes 监听器节点列表
+     * @param message 事件消息对象
+     * @param args 监听器参数
+     * @param args 监听器参数
+     * @returns 所有监听器函数的执行结果数组
      * @private
      *
-     * @description
-     * 遍历执行节点中的所有监听函数:
-     * - 对于普通监听器，直接执行并收集结果
-     * - 对于带次数限制的监听器(数组形式)，执行后递减次数，当次数为0时移除该监听器
+     * 执行流程:
+     * 1. 将所有节点中的监听器函数展平为一维数组
+     * 2. 通过执行器执行所有监听器函数
+     * 3. 更新监听器的执行次数,并移除达到执行次数限制的监听器
      */
     private _executeListeners;
     /**
@@ -495,8 +663,14 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
      *   payload: { userId: 123 },
      *   meta: { time: Date.now() }
      * }, true);
+     *
+     * // 清除保留事件
+     * emitter.emit("user/login")
+     *
      * ```
      */
+    emit<T extends Types = Types>(type: T, directive: symbol): any[];
+    emit(type: string, directive: symbol): any[];
     emit<R = any, T extends Types = Types>(type: T, payload?: AllEvents[T], retain?: boolean): R[];
     emit<R = any, T extends string = string>(type: T, payload?: T extends Types ? AllEvents[Types] : any, retain?: boolean): R[];
     emit<R = any, T extends string = string>(message: FastEventEmitMessage<{
@@ -631,90 +805,27 @@ declare class FastEvent<Events extends Record<string, any> = Record<string, any>
      * userEvents.offAll();  // 清理 'user' 前缀下的所有事件
      * ```
      */
-    scope<E extends Record<string, any> = Record<string, any>, P extends string = string, M extends Record<string, any> = Record<string, any>, C = Context>(prefix: P, options?: FastEventScopeOptions<M, C>): FastEventScope<PickScopeEvents<AllEvents, P> & E, Meta & M, C, keyof PickScopeEvents<AllEvents, P> | keyof E, Meta & M & FastEventScopeMeta>;
-}
-
-interface FastEventListenerDecorators {
-    queue: string;
-}
-type FastQueuePriority = 'none';
-type FastQueueOverflows = "drop" | "expand" | 'slide' | 'throw';
-type QueueListenerPipeOptions = {
-    size?: number;
-    maxExpandSize?: number;
-    expandOverflow?: Omit<FastQueueOverflows, 'expand'>;
-    overflow?: FastQueueOverflows;
-    lifetime?: number;
-    onEnter?: (newMessage: FastEventMessage, messages: [FastEventMessage, number][]) => void;
-    onDrop?: (message: FastEventMessage) => void;
-};
-declare const queue: (options?: QueueListenerPipeOptions) => FastListenerPipe;
-declare const dropping: (size?: number) => FastListenerPipe;
-declare const sliding: (size?: number) => FastListenerPipe;
-declare const expanding: (options?: Omit<QueueListenerPipeOptions, "overflow">) => FastListenerPipe;
-
-interface RetryListenerPipeOptions {
-    interval?: number;
-    drop?: (message: FastEventMessage, error: Error) => void;
-}
-/**
- * 创建一个重试管道，在监听器执行失败时自动重试
- * @param count 最大重试次数
- * @param options 配置选项
- * @returns FastListenerPipe
- */
-declare const retry: (count: number, options?: RetryListenerPipeOptions) => FastListenerPipe;
-
-/**
- * 创建一个超时装饰器，限制监听器函数的执行时间
- * @param ms 超时时间（毫秒）
- * @param defaultValue 可选的默认返回值，如果提供则超时时返回此值，否则抛出TimeoutError
- * @returns 装饰器函数
- */
-declare const timeout: <T = any>(ms: number, defaultValue?: T) => FastListenerPipe;
-
-interface DebounceOptions {
-    /**
-     * 当消息被丢弃时的回调函数
-     */
-    drop?: (message: FastEventMessage) => void;
+    scope<E extends Record<string, any> = Record<string, any>, P extends string = string, M extends Record<string, any> = Record<string, any>, C = Context>(prefix: P, options?: DeepPartial<FastEventScopeOptions<Meta & M, C>>): FastEventScope<ScopeEvents<AllEvents, P> & E, Meta & M, C>;
+    scope<E extends Record<string, any> = Record<string, any>, P extends string = string, M extends Record<string, any> = Record<string, any>, C = Context, ScopeObject extends FastEventScope<any, any, any> = FastEventScope<ScopeEvents<AllEvents, P> & E, Meta & M, C>>(prefix: P, scopeObj: ScopeObject, options?: DeepPartial<FastEventScopeOptions<Meta & M, C>>): ScopeObject;
 }
-/**
- * 创建一个防抖动装饰器，限制监听器函数的执行频率
- * @param ms 防抖动时间（毫秒）
- * @param options 可选的配置项
- * @returns 装饰器函数
- */
-declare const debounce: (ms: number, options?: DebounceOptions) => FastListenerPipe;
-
-interface ThrottleOptions {
-    /**
-     * 当消息被丢弃时的回调函数
-     */
-    drop?: (message: FastEventMessage) => void;
-}
-/**
- * 创建一个节流装饰器，限制监听器函数的执行频率
- * @param interval 节流时间间隔（毫秒）
- * @param options 可选的配置项
- * @returns 装饰器函数
- */
-declare const throttle: (interval: number, options?: ThrottleOptions) => FastListenerPipe;
-
-/**
- * 创建一个memorize pipe，用于缓存上一次的返回值
- * @param predicate 可选的判断函数，用于决定是否使用缓存
- * @returns FastListenerPipe
- */
-declare function memorize(predicate?: (message: FastEventMessage, args: FastEventListenerArgs) => boolean | Promise<boolean>): FastListenerPipe;
 
+declare const __FastEvent__: unique symbol;
+declare const __FastEventScope__: unique symbol;
 declare class FastEventError extends Error {
+    constructor(message?: string);
 }
 declare class TimeoutError extends FastEventError {
 }
+declare class UnboundError extends FastEventError {
+}
 declare class AbortError extends FastEventError {
 }
+declare class CancelError extends FastEventError {
+}
 declare class QueueOverflowError extends FastEventError {
 }
+declare const FastEventDirectives: {
+    clearRetain: symbol;
+};
 
-export { AbortError, type DebounceOptions, type Fallback, type FaseEventMessageExtends, FastEvent, type FastEventAnyListener, type FastEventEmitMessage, FastEventError, type FastEventListenOptions, type FastEventListener, type FastEventListenerArgs, type FastEventListenerDecorators, type FastEventMessage, type FastEventMeta, type FastEventOptions, FastEventScope, type FastEventScopeMeta, type FastEventScopeOptions, type FastEventSubscriber, type FastEvents, type FastListenerExecutorArgs, type FastListenerMeta, type FastListenerNode, type FastListenerPipe, type FastListeners, type FastQueueOverflows, type FastQueuePriority, type IFastListenerExecutor, type Merge, type PickScopeEvents, type QueueListenerPipeOptions, QueueOverflowError, type RequiredItems, type RetryListenerPipeOptions, type ScopeEvents, type ThrottleOptions, TimeoutError, debounce, dropping, expanding, memorize, queue, retry, sliding, throttle, timeout };
+export { AbortError, CancelError, type ChangeFieldType, type DeepPartial, type Dict, type Expand, type Fallback, type FaseEventMessageExtends, FastEvent, type FastEventAnyListener, FastEventDirectives, type FastEventEmitMessage, FastEventError, type FastEventListenOptions, type FastEventListener, type FastEventListenerArgs, type FastEventMessage, type FastEventMeta, type FastEventOptions, FastEventScope, type FastEventScopeMeta, type FastEventScopeOptions, type FastEventSubscriber, type FastEvents, type FastListenerMeta, type FastListenerNode, type FastListeners, type Merge, type ObjectKeys, type OptionalItems, type Overloads, type OverrideOptions, type PickScopeEvents, QueueOverflowError, type RequiredItems, type ScopeEvents, TimeoutError, UnboundError, type Unique, __FastEventScope__, __FastEvent__ };