fastevent 1.0.3 → 1.1.0

package/src/scope.ts

@@ -1,88 +1,89 @@
 import { FastEvent } from "./event";
-import { FastEventListener, FastEventListenOptions, FastEvents, FastEventSubscriber } from "./types";
+import { FastEventListener, FastEventListenOptions, FastEventMessage, FastEvents, FastEventSubscriber } from "./types";
 
 export class FastEventScope<
-    Events extends FastEvents  = FastEvents, 
-    Types extends keyof Events = keyof Events,
-    Meta                       = unknown
->{
-    constructor(public emitter:FastEvent<Events,Types,Meta>,public prefix:string){
-        if(prefix.length>0 && !prefix.endsWith(emitter.options.delimiter!)){
+    Events extends FastEvents = FastEvents,
+    Meta extends Record<string, any> = Record<string, any>,
+    Types extends keyof Events = keyof Events
+> {
+    constructor(public emitter: FastEvent<Events, Meta, Types>, public prefix: string) {
+        if (prefix.length > 0 && !prefix.endsWith(emitter.options.delimiter!)) {
             this.prefix = prefix + emitter.options.delimiter
-        }        
+        }
     }
-    private _getScopeListener(listener:FastEventListener):FastEventListener{
+    private _getScopeListener(listener: FastEventListener): FastEventListener {
         const scopePrefix = this.prefix
-        if(scopePrefix.length===0) return listener
-        const scopeListener = function(payload:any,{type}:{type:string}){
-            if(type.startsWith(scopePrefix)){                
-                type = type.substring(scopePrefix.length)
+        if (scopePrefix.length === 0) return listener
+        const scopeListener = function (message: FastEventMessage) {
+            if (message.type.startsWith(scopePrefix)) {
+                return listener(Object.assign({}, message, {
+                    type: message.type.substring(scopePrefix.length)
+                }))
             }
-            return listener(payload,{type})
-        } 
+        }
         // 当启用scope时对监听器进行包装
         //@ts-ignore
         listener.__wrappedListener = scopeListener
         return listener
     }
-    private _getScopeType(type:string){
-        return type===undefined ? undefined : this.prefix + type
-    }    
-    
-    public on<T extends string>(type: T, listener: FastEventListener<T,Events[T],Meta>, options?:FastEventListenOptions ): FastEventSubscriber    
-    public on<T extends Types=Types>(type: T, listener: FastEventListener<T,Events[T],Meta>, options?:FastEventListenOptions): FastEventSubscriber    
-    public on(type: '**', listener: FastEventListener<any,any,Meta>): FastEventSubscriber
-    public on(): FastEventSubscriber{
-        const args = [...arguments] as [any,any,any]
-        args[0]    = this._getScopeType(args[0])
-        args[1]    = this._getScopeListener(args[1])
+    private _getScopeType(type: string) {
+        return type === undefined ? undefined : this.prefix + type
+    }
+
+    public on<T extends string>(type: T, listener: FastEventListener<T, Events[T], Meta>, options?: FastEventListenOptions): FastEventSubscriber
+    public on<T extends Types = Types>(type: T, listener: FastEventListener<T, Events[T], Meta>, options?: FastEventListenOptions): FastEventSubscriber
+    public on(type: '**', listener: FastEventListener<any, any, Meta>): FastEventSubscriber
+    public on(): FastEventSubscriber {
+        const args = [...arguments] as [any, any, any]
+        args[0] = this._getScopeType(args[0])
+        args[1] = this._getScopeListener(args[1])
         return this.emitter.on(...args)
     }
 
-    public once<T extends string>(type: T, listener: FastEventListener<T,Events[T],Meta>, options?:FastEventListenOptions ): FastEventSubscriber
-    public once<T extends Types = Types>(type: T, listener: FastEventListener<Types,Events[T],Meta>, options?:FastEventListenOptions ): FastEventSubscriber    
-    public once(): FastEventSubscriber{
-        return this.on(arguments[0],arguments[1],Object.assign({},arguments[2],{count:1}))
+    public once<T extends string>(type: T, listener: FastEventListener<T, Events[T], Meta>, options?: FastEventListenOptions): FastEventSubscriber
+    public once<T extends Types = Types>(type: T, listener: FastEventListener<Types, Events[T], Meta>, options?: FastEventListenOptions): FastEventSubscriber
+    public once(): FastEventSubscriber {
+        return this.on(arguments[0], arguments[1], Object.assign({}, arguments[2], { count: 1 }))
     }
 
-    onAny<P=any>(listener: FastEventListener<Types,P,Meta>, options?:FastEventListenOptions): FastEventSubscriber {
+    onAny<P = any>(listener: FastEventListener<Types, P, Meta>, options?: FastEventListenOptions): FastEventSubscriber {
         const type = this.prefix + '**'
-        return this.on(type as any,listener,options)
-    }   
-    offAll(){
+        return this.on(type as any, listener, options)
+    }
+    offAll() {
         this.emitter.offAll(this.prefix)
-    } 
-    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 as unknown as [any,any]
-        if(typeof(args[0])==='string'){
+    }
+    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 as unknown as [any, any]
+        if (typeof (args[0]) === 'string') {
             args[0] = this._getScopeType(args[0])
         }
         this.emitter.off(...args)
-    }    
-    clear(){
+    }
+    clear() {
         this.offAll()
     }
-    public emit<R=any>(type:string,payload?:any,retain?:boolean):R[]
-    public emit<R=any>(type:Types,payload?:Events[Types],retain?:boolean):R[]
-    public emit<R=any>():R[]{
+    public emit<R = any>(type: string, payload?: any, retain?: boolean): R[]
+    public emit<R = any>(type: Types, payload?: Events[Types], retain?: boolean): R[]
+    public emit<R = any>(): R[] {
         const type = arguments[0] as string
-        const payload = arguments[1] 
+        const payload = arguments[1]
         const retain = arguments[2] as boolean
-        return this.emitter.emit(this._getScopeType(type)!,payload,retain)
+        return this.emitter.emit(this._getScopeType(type)!, payload, retain)
     }
-    public waitFor<R=any>(type:string,timeout?:number):Promise<R>
-    public waitFor<R=any>(type:Types,timeout?:number):Promise<R>
-    public waitFor<R=any>():Promise<R>{
+    public waitFor<R = any>(type: string, timeout?: number): Promise<R>
+    public waitFor<R = any>(type: Types, timeout?: number): Promise<R>
+    public waitFor<R = any>(): Promise<R> {
         const type = arguments[0] as string
         const timeout = arguments[1] as number
-        return this.emitter.waitFor(this._getScopeType(type)!,timeout)
+        return this.emitter.waitFor(this._getScopeType(type)!, timeout)
     }
-    public scope(prefix:string){
+    public scope(prefix: string) {
         return this.emitter.scope(this._getScopeType(prefix)!)
     }
 }

package/src/types.ts

@@ -1,57 +1,62 @@
 
-export type FastEventMeta<T=string,M=unknown> = M & {type:T} 
+
+
+export type FastEventMessage<T = string, P = any, M = unknown> = {
+    type: T
+    payload: P
+    meta: M
+}
 
 
 export type FastEventListener<
-    T = string,    
-    P = any,     
+    T = string,
+    P = any,
     M = unknown
-> = ( payload:P, meta:FastEventMeta<T,M> ) => any | Promise<any>
+> = (message: FastEventMessage<T, P, M>) => any | Promise<any>
 
-export type FastListenerNode  = {
-    __listeners: (FastEventListener<any,any,any> | [FastEventListener<any,any>,number])[];  
+export type FastListenerNode = {
+    __listeners: (FastEventListener<any, any, any> | [FastEventListener<any, any>, number])[];
 } & {
-    [key:string]: FastListenerNode
+    [key: string]: FastListenerNode
 }
 
 export type FastEventSubscriber = {
-    off:()=>void
-} 
+    off: () => void
+}
 
-export interface FastEventListenerMeta{
+export interface FastEventListenerMeta {
     emitter?: string
-} 
+}
 
 export type FastListeners = FastListenerNode
 
-export type FastEventOptions<M=unknown> = {
+export type FastEventOptions<M = unknown> = {
     // 事件分隔符
     delimiter?: string
     // 侦听器函数执行上下文
-    context?  : any    
+    context?: any
     // 当执行侦听器函数出错时是否忽略,默认true
-    ignoreErrors?: boolean       
+    ignoreErrors?: boolean
     // 当侦听器函数执行出错时的回调，用于诊断时使用,可以打印错误信息
-    onListenerError?: ((type:string,error:Error)=>void)  
-    // 额外的元数据，当触发事件时传递给侦听器
-    meta?:M
+    onListenerError?: ((type: string, error: Error) => void)
+    // 额外的全局元数据，当触发事件时传递给侦听器
+    meta?: M
     // 当创建新侦听器时回调
-    onAddListener?:(type:string[],listener:FastEventListener)=>void
+    onAddListener?: (type: string[], listener: FastEventListener) => void
     // 当移除侦听器时回调
-    onRemoveListener?:(type:string[],listener:FastEventListener)=>void
-} 
+    onRemoveListener?: (type: string[], listener: FastEventListener) => void
+}
+
+export type FastEvents = Record<string, any>
 
-export type FastEvents = Record<string,any>  
 
 export type ScopeEvents<T extends Record<string, any>, Prefix extends string> = {
     [K in keyof T as K extends `${Prefix}/${infer Rest}` ? Rest : never]: T[K];
-  };
+};
 
- 
-
-export type FastEventListenOptions={
+export type FastEventListenOptions = {
     // 侦听执行次数，当为1时为单次侦听，为0时为永久侦听，其他值为执行次数,每执行一次减一，减到0时移除侦听器
-    count?:number                   
+    count?: number
     // 将侦听器添加到侦听器列表的头部
-    prepend?:boolean
-}
+    prepend?: boolean
+}

package/src/typestest.ts

@@ -1,102 +0,0 @@
-// eslint-disable no-unused-vars
-import type { Equal, Expect, NotAny } from '@type-challenges/utils'
-import { FastEvent } from "./event"
-import { ScopeEvents } from "./types" 
-
-
-
-interface CustomEvents{
-    a        : boolean
-    b        : number
-    c        : string,
-    "x/y/z/a": 1
-    "x/y/z/b": 2
-    "x/y/z/c":3
-}
-
-type  ScopeCustomEvents = ScopeEvents<CustomEvents,'x/y/z'>
-
-type cases = [
-    Expect<Equal<ScopeCustomEvents,{
-        a:1
-        b:2
-        c:3
-    }>>
-]  
-
-
-const emitter = new FastEvent<CustomEvents>() 
-
-emitter.on("a",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"a">>,
-        Expect<Equal<typeof payload,boolean>>
-    ]    
-})
-
-emitter.on("b",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"b">>,
-        Expect<Equal<typeof payload,number>>
-    ]   
-})
-
-emitter.once("a",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"a">>,
-        Expect<Equal<typeof payload,boolean>>
-    ]    
-})
-
-emitter.once("b",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"b">>,
-        Expect<Equal<typeof payload,number>>
-    ]   
-})
-emitter.emit("x/y/z",1)
- 
-
-// ----- scope -----
-
-const scope = emitter.scope("x/y/z")
-
-scope.on("a",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"a">>,
-        Expect<Equal<typeof payload,1>>
-    ]  
-}) 
-
-scope.on("b",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"b">>,
-        Expect<Equal<typeof payload,2>>
-    ]  
-}) 
-
-scope.once("a",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"a">>,
-        Expect<Equal<typeof payload,1>>
-    ]  
-}) 
-
-scope.once("c",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"c">>,
-        Expect<Equal<typeof payload,3>>
-    ]  
-}) 
-emitter.on("x/y/z",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"x/y/z">>,
-        Expect<Equal<typeof payload,unknown>>
-    ]   
-})
-emitter.on("x/y/z/a",(payload,{type})=>{
-    type cases = [
-        Expect<Equal<typeof type,"x/y/z/a">>,
-        Expect<Equal<typeof payload,1>>
-    ]   
-})