fastevent 1.0.3 → 1.1.0

package/src/__tests__/emitAsync.test.ts

@@ -1,65 +1,64 @@
 import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event" 
+import { FastEvent } from "../event"
 
-describe("异步发布与订阅",async ()=>{
-    test("异步发布订阅事件",async ()=>{
-        const emitter = new FastEvent() 
+describe("异步发布与订阅", async () => {
+    test("异步发布订阅事件", async () => {
+        const emitter = new FastEvent()
         const events: any[] = []
-        emitter.on("x",async (payload,{type})=>{
-            events.push({type, payload})           
+        emitter.on("x", async ({ payload, type }) => {
+            events.push({ type, payload })
         })
-        await emitter.emitAsync("x",1)
+        await emitter.emitAsync("x", 1)
         expect(events[0].type).toBe("x")
         expect(events[0].payload).toBe(1)
     })
-    test("异步发布订阅事件后取消",async ()=>{
-        const emitter = new FastEvent()         
-        const events:string[]=[]
-        const subscriber = emitter.on("x",async (payload,{type})=>{
-            events.push(type)    
+    test("异步发布订阅事件后取消", async () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const subscriber = emitter.on("x", async ({ type }) => {
+            events.push(type)
         })
-        await emitter.emitAsync("x",1)
+        await emitter.emitAsync("x", 1)
         expect(events).toEqual(["x"])
         subscriber.off()
-        await emitter.emitAsync("x",1)
-        await emitter.emitAsync("x",1)
-        await emitter.emitAsync("x",1)
+        await emitter.emitAsync("x", 1)
+        await emitter.emitAsync("x", 1)
+        await emitter.emitAsync("x", 1)
         expect(events).toEqual(["x"])
-    }) 
-    test("发布订阅层级事件",async ()=>{
-        const emitter = new FastEvent() 
-        const events:string[]=[]
-        emitter.on("a.b.c",async (payload,{type})=>{
-            events.push(type)       
+    })
+    test("发布订阅层级事件", async () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        emitter.on("a.b.c", async ({ type }) => {
+            events.push(type)
         })
-        await emitter.emitAsync("a",1)
-        await emitter.emitAsync("a.b",1)
-        await emitter.emitAsync("a.b.c",1)
+        await emitter.emitAsync("a", 1)
+        await emitter.emitAsync("a.b", 1)
+        await emitter.emitAsync("a.b.c", 1)
         expect(events).toEqual(["a.b.c"])
     })
-    test("返回事件执行结果",async ()=>{
-        const emitter = new FastEvent() 
-        for(let i=1;i<=10;i++){
-            emitter.on("x",async ()=>{
+    test("返回事件执行结果", async () => {
+        const emitter = new FastEvent()
+        for (let i = 1; i <= 10; i++) {
+            emitter.on("x", async () => {
                 return i
             })
         }
-        const results = await emitter.emitAsync("x",1)
-        expect(results).toEqual([1,2,3,4,5,6,7,8,9,10])
+        const results = await emitter.emitAsync("x", 1)
+        expect(results).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
     })
-    test("异步侦听器执行出错返回事件执行结果",async ()=>{
-        const emitter = new FastEvent() 
-        for(let i=1;i<=10;i++){
-            emitter.on("x",async ()=>{
-                if(i % 2 ==0) throw new Error("custom")
+    test("异步侦听器执行出错返回事件执行结果", async () => {
+        const emitter = new FastEvent()
+        for (let i = 1; i <= 10; i++) {
+            emitter.on("x", async () => {
+                if (i % 2 == 0) throw new Error("custom")
                 return i
             })
         }
-        const results = await emitter.emitAsync("x",1)
-        for(let i=1;i<=10;i++){
-            if(i % 2 ==0) expect(results[i-1]).toBeInstanceOf(Error)
-            else expect(results[i-1]).toBe(i)    
+        const results = await emitter.emitAsync("x", 1)
+        for (let i = 1; i <= 10; i++) {
+            if (i % 2 == 0) expect(results[i - 1]).toBeInstanceOf(Error)
+            else expect(results[i - 1]).toBe(i)
         }
     })
-}) 
- 
+})

package/src/__tests__/many.test.ts

@@ -1,23 +1,22 @@
 import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event" 
+import { FastEvent } from "../event"
 
-describe("指定次数事件的发布与订阅",async ()=>{
-    test("简单发布只订阅一次事件",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        emitter.on("x",(payload,{type})=>{
+describe("指定次数事件的发布与订阅", async () => {
+    test("简单发布只订阅一次事件", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        emitter.on("x", ({ payload, type }) => {
             expect(type).toBe("x")
-            expect(payload).toBe(1)            
+            expect(payload).toBe(1)
             events.push(type)
-        },{count:2})
-        emitter.emit("x",1)
-        emitter.emit("x",1)
-        emitter.emit("x",1)
-        emitter.emit("x",1)
-        emitter.emit("x",1)
-        expect(events).toEqual(["x","x"])
-        
+        }, { count: 2 })
+        emitter.emit("x", 1)
+        emitter.emit("x", 1)
+        emitter.emit("x", 1)
+        emitter.emit("x", 1)
+        emitter.emit("x", 1)
+        expect(events).toEqual(["x", "x"])
+
     })
 
 })
- 

package/src/__tests__/meta.test.ts

@@ -1,29 +1,28 @@
 import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event" 
+import { FastEvent } from "../event"
 
-describe("传递Meta数据",async ()=>{
-    test("全局meta数据",()=>{
+describe("传递Meta数据", async () => {
+    test("全局meta数据", () => {
         const emitter = new FastEvent({
-            meta:{ a:1 }
-        }) 
-        emitter.on("x",(payload,{type,a})=>{
+            meta: { a: 1 }
+        })
+        emitter.on("x", ({ payload, type, meta }) => {
             expect(type).toBe("x")
-            expect(payload).toBe(1)    
-            expect(a).toBe(1)        
+            expect(payload).toBe(1)
+            expect(meta.a).toBe(1)
         })
-        emitter.emit("x",1)
-    }) 
-    test("emit时传递meta数据",()=>{
+        emitter.emit("x", 1)
+    })
+    test("emit时传递meta数据", () => {
         const emitter = new FastEvent({
-            meta:{ a:1,b: 2 }
-        }) 
-        emitter.on("x",(payload,{type,a,b})=>{
+            meta: { a: 1, b: 2 }
+        })
+        emitter.on("x", ({ payload, type, meta }) => {
             expect(type).toBe("x")
-            expect(payload).toBe(1)    
-            expect(a).toBe(10)        
-            expect(b).toBe(20)        
+            expect(payload).toBe(1)
+            expect(meta.a).toBe(10)
+            expect(meta.b).toBe(20)
         })
-        emitter.emit("x",1,false,{a:10,b:20})
-    })  
-}) 
- 
+        emitter.emit("x", 1, false, { a: 10, b: 20 })
+    })
+}) 

package/src/__tests__/off.test.ts

@@ -1,214 +1,214 @@
 import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event" 
- 
+import { FastEvent } from "../event"
+import { FastEventListener } from '../types';
 
-describe("退订事件", ()=>{
-    test("基本退订事件",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const subscriber  = emitter.on("x",(payload,{type})=>{
+
+describe("退订事件", () => {
+    test("基本退订事件", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const subscriber = emitter.on("x", ({ payload, type }) => {
             expect(type).toBe("x")
-            expect(payload).toBe(1)            
+            expect(payload).toBe(1)
             events.push(type)
         })
-        emitter.emit("x",1)
+        emitter.emit("x", 1)
         subscriber.off()
-        emitter.emit("x",1)
+        emitter.emit("x", 1)
         expect(events).toEqual(["x"])
     })
-    test("根据事件类型和侦听器进行退订",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =(payload:any,{type}:{type:string})=>{
+    test("根据事件类型和侦听器进行退订", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = (({ payload, type }) => {
             expect(type).toBe("x")
-            expect(payload).toBe(1)            
+            expect(payload).toBe(1)
             events.push(type)
-        }
-        emitter.on("x",listener)
-        emitter.emit("x",1)
-        emitter.off("x",listener)
-        emitter.emit("x",1)
+        })
+        emitter.on("x", listener)
+        emitter.emit("x", 1)
+        emitter.off("x", listener)
+        emitter.emit("x", 1)
         expect(events).toEqual(["x"])
     })
-    test("多级事件根据事件类型和侦听器进行退订",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =(payload:any,{type}:{type:string})=>{
+    test("多级事件根据事件类型和侦听器进行退订", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = (({ payload, type }) => {
             expect(type).toBe("a/b/c/d")
-            expect(payload).toBe(1)            
+            expect(payload).toBe(1)
             events.push(type)
-        }
-        emitter.on("a/b/c/d",listener)
-        emitter.emit("a/b/c/d",1)
-        emitter.off("a/b/c/d",listener) //
-        emitter.emit("a/b/c/d",1)
-        emitter.emit("a/b/c/d",2)
-        emitter.emit("a/b/c/d",3)
+        })
+        emitter.on("a/b/c/d", listener)
+        emitter.emit("a/b/c/d", 1)
+        emitter.off("a/b/c/d", listener) //
+        emitter.emit("a/b/c/d", 1)
+        emitter.emit("a/b/c/d", 2)
+        emitter.emit("a/b/c/d", 3)
         expect(events).toEqual(["a/b/c/d"])
     })
 
-    test("通配符事件退订",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =(payload:any,{type}:{type:string})=>{
+    test("通配符事件退订", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = ({ payload, type }) => {
             expect(type).toBe("a/b/c/d")
-            expect(payload).toBe(1)            
+            expect(payload).toBe(1)
             events.push(type)
         }
-        emitter.on("a/b/c/*",listener)
-        emitter.emit("a/b/c/d",1)
-        emitter.off("a/b/c/*",listener) //
-        emitter.emit("a/b/c/d",1)
-        emitter.emit("a/b/c/d",2)
-        emitter.emit("a/b/c/d",3)
+        emitter.on("a/b/c/*", listener)
+        emitter.emit("a/b/c/d", 1)
+        emitter.off("a/b/c/*", listener) //
+        emitter.emit("a/b/c/d", 1)
+        emitter.emit("a/b/c/d", 2)
+        emitter.emit("a/b/c/d", 3)
         expect(events).toEqual(["a/b/c/d"])
     })
 
-    test("退订指定的侦听器",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =( payload:any,{type}:{type:string} )=>{
+    test("退订指定的侦听器", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = ({ payload, type }) => {
             expect(type).toBe("a/b/c/d")
-            expect(payload).toBe(1)            
+            expect(payload).toBe(1)
             events.push(type)
         }
-        emitter.on("a/b/c/*",listener)
-        emitter.on("a/b/*/*",listener)
-        emitter.on("a/*/*/*",listener)
-        emitter.on("*/*/*/*",listener)
-        emitter.emit("a/b/c/d",1)
-        emitter.off(listener) 
-        emitter.emit("a/b/c/d",1)
-        emitter.emit("a/b/c/d",2)
-        emitter.emit("a/b/c/d",3)
-        emitter.emit("a/b/c/d",4)
-        expect(events).toEqual(["a/b/c/d","a/b/c/d","a/b/c/d","a/b/c/d"])
+        emitter.on("a/b/c/*", listener)
+        emitter.on("a/b/*/*", listener)
+        emitter.on("a/*/*/*", listener)
+        emitter.on("*/*/*/*", listener)
+        emitter.emit("a/b/c/d", 1)
+        emitter.off(listener)
+        emitter.emit("a/b/c/d", 1)
+        emitter.emit("a/b/c/d", 2)
+        emitter.emit("a/b/c/d", 3)
+        emitter.emit("a/b/c/d", 4)
+        expect(events).toEqual(["a/b/c/d", "a/b/c/d", "a/b/c/d", "a/b/c/d"])
     })
-    test("退订指定的事件时不指定侦听器",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =( payload:any,{type}:{type:string} )=>{
+    test("退订指定的事件时不指定侦听器", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = ({ payload, type }) => {
             events.push(type)
         }
-        emitter.on("a",listener)
-        emitter.on("b",listener)
-        emitter.on("c",listener)
-        emitter.on("d",listener)
-        emitter.emit("a",1)
-        emitter.emit("a",1)
-        emitter.off("a") 
-        emitter.emit("a",1)
-        emitter.emit("a",1)
-        emitter.emit("a",1)
-        emitter.emit("b",2)
-        emitter.emit("c",3)
-        emitter.emit("d",4)
-        expect(events).toEqual(["a","a","b","c","d"])
+        emitter.on("a", listener)
+        emitter.on("b", listener)
+        emitter.on("c", listener)
+        emitter.on("d", listener)
+        emitter.emit("a", 1)
+        emitter.emit("a", 1)
+        emitter.off("a")
+        emitter.emit("a", 1)
+        emitter.emit("a", 1)
+        emitter.emit("a", 1)
+        emitter.emit("b", 2)
+        emitter.emit("c", 3)
+        emitter.emit("d", 4)
+        expect(events).toEqual(["a", "a", "b", "c", "d"])
     })
-    test("退订所有侦听器",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =( payload:any,{type}:{type:string} )=>{
+    test("退订所有侦听器", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = ({ payload, type }) => {
             events.push(type)
         }
-        emitter.on("a",listener)
-        emitter.on("b",listener)
-        emitter.on("c",listener)
-        emitter.on("d",listener)
-        emitter.emit("a",1)
-        emitter.emit("b",1)
-        emitter.emit("c",1)
-        emitter.emit("d",1)
+        emitter.on("a", listener)
+        emitter.on("b", listener)
+        emitter.on("c", listener)
+        emitter.on("d", listener)
+        emitter.emit("a", 1)
+        emitter.emit("b", 1)
+        emitter.emit("c", 1)
+        emitter.emit("d", 1)
         emitter.offAll()
-        emitter.emit("a",1)
-        emitter.emit("a",1)
-        emitter.emit("b",1)
-        emitter.emit("b",1)
-        emitter.emit("c",1)
-        emitter.emit("c",1)
-        emitter.emit("d",1)
-        emitter.emit("d",1)
-        expect(events).toEqual(["a","b","c","d"])
+        emitter.emit("a", 1)
+        emitter.emit("a", 1)
+        emitter.emit("b", 1)
+        emitter.emit("b", 1)
+        emitter.emit("c", 1)
+        emitter.emit("c", 1)
+        emitter.emit("d", 1)
+        emitter.emit("d", 1)
+        expect(events).toEqual(["a", "b", "c", "d"])
     })
-    test("退订含通配符的事件",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =( payload:any,{type}:{type:string} )=>{
+    test("退订含通配符的事件", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = ({ payload, type }) => {
             events.push(type)
         }
-        emitter.on("a",listener)
-        emitter.on("b",listener)
-        emitter.on("c",listener)
-        emitter.on("d",listener)
-        emitter.emit("a",1)
-        emitter.emit("b",1)
-        emitter.emit("c",1)
-        emitter.emit("d",1)
+        emitter.on("a", listener)
+        emitter.on("b", listener)
+        emitter.on("c", listener)
+        emitter.on("d", listener)
+        emitter.emit("a", 1)
+        emitter.emit("b", 1)
+        emitter.emit("c", 1)
+        emitter.emit("d", 1)
         emitter.off("*")
-        emitter.emit("a",1)
-        emitter.emit("a",1)
-        emitter.emit("b",1)
-        emitter.emit("b",1)
-        emitter.emit("c",1)
-        emitter.emit("c",1)
-        emitter.emit("d",1)
-        emitter.emit("d",1)
-        expect(events).toEqual(["a","b","c","d"])
+        emitter.emit("a", 1)
+        emitter.emit("a", 1)
+        emitter.emit("b", 1)
+        emitter.emit("b", 1)
+        emitter.emit("c", 1)
+        emitter.emit("c", 1)
+        emitter.emit("d", 1)
+        emitter.emit("d", 1)
+        expect(events).toEqual(["a", "b", "c", "d"])
     })
-    test("退订含通配符的事件",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =( payload:any,{type}:{type:string} )=>{
+    test("退订含通配符的事件", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = ({ payload, type }) => {
             events.push(type)
         }
-        emitter.on("a/*",listener)
-        emitter.on("b/*",listener)
-        emitter.on("c/*",listener)
-        emitter.on("d/*",listener)
-        emitter.emit("a/1",1)
-        emitter.emit("b/2",1)
-        emitter.emit("c/3",1)
-        emitter.emit("d/4",1)
+        emitter.on("a/*", listener)
+        emitter.on("b/*", listener)
+        emitter.on("c/*", listener)
+        emitter.on("d/*", listener)
+        emitter.emit("a/1", 1)
+        emitter.emit("b/2", 1)
+        emitter.emit("c/3", 1)
+        emitter.emit("d/4", 1)
         emitter.off("a/*")
         emitter.off("b/*")
-        emitter.emit("a/1",2)
-        emitter.emit("b/2",2)
-        emitter.emit("c/3",2)
-        emitter.emit("d/4",2)
-        expect(events).toEqual(["a/1","b/2","c/3","d/4","c/3","d/4"])
+        emitter.emit("a/1", 2)
+        emitter.emit("b/2", 2)
+        emitter.emit("c/3", 2)
+        emitter.emit("d/4", 2)
+        expect(events).toEqual(["a/1", "b/2", "c/3", "d/4", "c/3", "d/4"])
     })
-    test("退订多层含通配符的事件",()=>{
-        const emitter = new FastEvent() 
-        const events:string[] =[]
-        const listener =( payload:any,{type}:{type:string} )=>{
+    test("退订多层含通配符的事件", () => {
+        const emitter = new FastEvent()
+        const events: string[] = []
+        const listener: FastEventListener<string, number> = ({ payload, type }) => {
             events.push(type)
         }
-        emitter.on("a/*",listener)
-        emitter.on("a/b/*",listener)
-        emitter.on("a/b/c/*",listener)
-        emitter.on("a/b/c/d/*",listener)
-        emitter.on("a/b/c/d/e/*",listener)
+        emitter.on("a/*", listener)
+        emitter.on("a/b/*", listener)
+        emitter.on("a/b/c/*", listener)
+        emitter.on("a/b/c/d/*", listener)
+        emitter.on("a/b/c/d/e/*", listener)
 
-        emitter.emit("a/1",1)
-        emitter.emit("a/b/2",1)
-        emitter.emit("a/b/c/3",1)
-        emitter.emit("a/b/c/d/4",1)
-        emitter.emit("a/b/c/d/e/5",1)
+        emitter.emit("a/1", 1)
+        emitter.emit("a/b/2", 1)
+        emitter.emit("a/b/c/3", 1)
+        emitter.emit("a/b/c/d/4", 1)
+        emitter.emit("a/b/c/d/e/5", 1)
 
         emitter.off("a/**")
-        emitter.emit("a/1",1)
-        emitter.emit("a/b/2",1)
-        emitter.emit("a/b/c/3",1)
-        emitter.emit("a/b/c/d/4",1)
-        emitter.emit("a/b/c/d/e/5",1)
-        emitter.emit("a/1",1)
-        emitter.emit("a/b/2",1)
-        emitter.emit("a/b/c/3",1)
-        emitter.emit("a/b/c/d/4",1)
-        emitter.emit("a/b/c/d/e/5",1)
+        emitter.emit("a/1", 1)
+        emitter.emit("a/b/2", 1)
+        emitter.emit("a/b/c/3", 1)
+        emitter.emit("a/b/c/d/4", 1)
+        emitter.emit("a/b/c/d/e/5", 1)
+        emitter.emit("a/1", 1)
+        emitter.emit("a/b/2", 1)
+        emitter.emit("a/b/c/3", 1)
+        emitter.emit("a/b/c/d/4", 1)
+        emitter.emit("a/b/c/d/e/5", 1)
 
-        expect(events).toEqual(["a/1","a/b/2","a/b/c/3","a/b/c/d/4","a/b/c/d/e/5"])
+        expect(events).toEqual(["a/1", "a/b/2", "a/b/c/3", "a/b/c/d/4", "a/b/c/d/e/5"])
     })
 })
 
-