fastevent 1.0.4 → 1.1.1

package/src/__tests__/scope.test.ts

@@ -1,67 +1,67 @@
 import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event" 
- 
+import { FastEvent } from "../event"
 
-describe("scope", ()=>{
-    test("scope简单的发布订阅事件",()=>{
-        const emitter = new FastEvent() 
+
+describe("scope", () => {
+    test("scope简单的发布订阅事件", () => {
+        const emitter = new FastEvent()
         const scope = emitter.scope("a/b/c")
-        const events:string[] =[] 
-        scope.on("x", (payload,{type})=>{
+        const events: string[] = []
+        scope.on("x", ({ type }) => {
             events.push(type)
         })
-        emitter.on("a/b/c/x", (payload,{type})=>{
+        emitter.on("a/b/c/x", ({ type }) => {
             events.push(type)
         })
-        scope.emit("x",1)        
-        expect(events).toEqual(["x","a/b/c/x"])
+        scope.emit("x", 1)
+        expect(events).toEqual(["x", "a/b/c/x"])
     })
 
-    test("scope通过off简单的退订事件",()=>{
-        const emitter = new FastEvent() 
+    test("scope通过off简单的退订事件", () => {
+        const emitter = new FastEvent()
         const scope = emitter.scope("a/b/c")
 
-        const events:string[] =[] 
-        const subscriber =scope.on("x", (payload,{type})=>{
+        const events: string[] = []
+        const subscriber = scope.on("x", ({ type }) => {
             events.push(type)
         })
-        emitter.on("a/b/c/x", (payload,{type})=>{
+        emitter.on("a/b/c/x", ({ type }) => {
             events.push(type)
         })
-        scope.emit("x",1)        
+        scope.emit("x", 1)
         subscriber.off()
-        scope.emit("x",1)      
-        expect(events).toEqual(["x","a/b/c/x","a/b/c/x"])
+        scope.emit("x", 1)
+        expect(events).toEqual(["x", "a/b/c/x", "a/b/c/x"])
     })
 
-    test("scope off退订事件",()=>{
-        const emitter = new FastEvent() 
+    test("scope off退订事件", () => {
+        const emitter = new FastEvent()
         const scope = emitter.scope("a/b/c")
 
-        const events:string[] =[] 
-        scope.on("x", (payload,{type})=>{
+        const events: string[] = []
+        scope.on("x", ({ type }) => {
             events.push(type)
         })
-        emitter.on("a/b/c/x", (payload,{type})=>{
+        emitter.on("a/b/c/x", ({ type }) => {
             events.push(type)
         })
-        scope.emit("x",1)        
+        scope.emit("x", 1)
         scope.off('x')          // 等效于退订a/b/c/x事件
-        scope.emit("x",1)      
-        expect(events).toEqual(["x","a/b/c/x"])
+        scope.emit("x", 1)
+        expect(events).toEqual(["x", "a/b/c/x"])
     })
-    test("scope once布订阅事件",()=>{
-        const emitter = new FastEvent() 
+    test("scope once布订阅事件", () => {
+        const emitter = new FastEvent()
         const scope = emitter.scope("a/b/c")
-        const events:string[] =[] 
-        scope.once("x", (payload,{type})=>{
+        const events: string[] = []
+        scope.once("x", ({ type }) => {
             events.push(type)
         })
-        emitter.once("a/b/c/x", (payload,{type})=>{
+        emitter.once("a/b/c/x", ({ type }) => {
             events.push(type)
         })
-        scope.emit("x",1)        
-        expect(events).toEqual(["x","a/b/c/x"])
+        scope.emit("x", 1)
+        expect(events).toEqual(["x", "a/b/c/x"])
     })
 
     test('scope waitFor', async () => {
@@ -95,17 +95,16 @@ describe("scope", ()=>{
         ]);
 
         expect(results[0].status).toBe('fulfilled');
-        expect(results[0]).toHaveProperty('value', 'payload1');
-        
-        expect(results[1].status).toBe('rejected'); 
+        expect((results[0] as any).value).toEqual({ type: 'x', payload: 'payload1', meta: undefined });
+
+        expect(results[1].status).toBe('rejected');
         //@ts-ignore
         expect(results[1].reason).toBeInstanceOf(Error);
-        
+
         expect(results[2].status).toBe('fulfilled');
-        expect(results[2]).toHaveProperty('value', 'payload3');
+        expect((results[2] as any).value).toEqual({ type: 'z', payload: 'payload3', meta: undefined });
     });
 
 
 })
 
- 

package/src/__tests__/types.test.ts

@@ -2,127 +2,144 @@
 import { describe, test, expect } from "vitest"
 import type { Equal, Expect, NotAny } from '@type-challenges/utils'
 import { FastEvent } from "../event"
-import { ScopeEvents } from "../types" 
+import { ScopeEvents } from "../types"
 
 
-describe("Types",()=>{
-    test("Types tests",()=>{
-        interface CustomEvents{
-            a        : boolean
-            b        : number
-            c        : string,
+describe("Types", () => {
+    test("Types tests", () => {
+        interface CustomEvents {
+            a: boolean
+            b: number
+            c: string,
             "x/y/z/a": 1
             "x/y/z/b": 2
-            "x/y/z/c":3
+            "x/y/z/c": 3
         }
 
-        type  ScopeCustomEvents = ScopeEvents<CustomEvents,'x/y/z'>
+        type ScopeCustomEvents = ScopeEvents<CustomEvents, 'x/y/z'>
 
         type cases = [
-            Expect<Equal<ScopeCustomEvents,{
-                a:1
-                b:2
-                c:3
+            Expect<Equal<ScopeCustomEvents, {
+                a: 1
+                b: 2
+                c: 3
             }>>
-        ]  
+        ]
 
-        interface CustomMeta{
-            a        : number
-            b        : string
-            c        : boolean
+        interface CustomMeta {
+            a: number
+            b: string
+            c: boolean
         }
 
-        const emitter = new FastEvent<CustomEvents,CustomMeta>() 
+        const emitter = new FastEvent<CustomEvents, CustomMeta>()
 
-        emitter.on("a",(payload,meta)=>{
+        emitter.on("a", (message) => {
+            message.meta
             type cases = [
-                Expect<Equal<typeof meta,CustomMeta & {
-                    type:'a'
-                }>>,
-            ]    
-            meta.a
-            meta.b
+                Expect<Equal<typeof message.meta, CustomMeta>>
+            ]
         })
 
-        emitter.on("a",(payload,{type})=>{
+        emitter.on("a", (message) => {
             type cases = [
-                Expect<Equal<typeof type,"a">>,
-                Expect<Equal<typeof payload,boolean>>
-            ]    
+                Expect<Equal<typeof message.type, "a">>,
+                Expect<Equal<typeof message.payload, boolean>>
+            ]
         })
 
-        emitter.onAny((payload,{type})=>{
+        emitter.onAny((message) => {
             type cases = [
-                Expect<Equal<typeof type,string>>,
-                Expect<Equal<typeof payload,any>>
-            ]    
+                Expect<Equal<typeof message.type, string>>,
+                Expect<Equal<typeof message.payload, any>>
+            ]
         })
 
-        emitter.on("b",(payload,{type})=>{
+        emitter.onAny<number>((message) => {
             type cases = [
-                Expect<Equal<typeof type,"b">>,
-                Expect<Equal<typeof payload,number>>
-            ]   
+                Expect<Equal<typeof message.type, string>>,
+                Expect<Equal<typeof message.payload, number>>
+            ]
         })
 
-        emitter.once("a",(payload,{type})=>{
+
+        emitter.on("b", (message) => {
+            type cases = [
+                Expect<Equal<typeof message.type, "b">>,
+                Expect<Equal<typeof message.payload, number>>
+            ]
+        })
+
+        emitter.once("a", (message) => {
             type cases = [
-                Expect<Equal<typeof type,"a">>,
-                Expect<Equal<typeof payload,boolean>>
-            ]    
+                Expect<Equal<typeof message.type, "a">>,
+                Expect<Equal<typeof message.payload, boolean>>
+            ]
         })
 
-        emitter.once("b",(payload,{type})=>{
+        emitter.once("b", (message) => {
+            type cases = [
+                Expect<Equal<typeof message.type, "b">>,
+                Expect<Equal<typeof message.payload, number>>
+            ]
+        })
+        emitter.emit("x/y/z", 1)
+
+        emitter.on("x/y/z", (message) => {
+            type cases = [
+                Expect<Equal<typeof message.type, "x/y/z">>,
+                Expect<Equal<typeof message.payload, unknown>>
+            ]
+        })
+
+        emitter.on("x/y/z/a", (message) => {
+            type cases = [
+                Expect<Equal<typeof message.type, "x/y/z/a">>,
+                Expect<Equal<typeof message.payload, 1>>
+            ]
+        })
+        emitter.waitFor("x/y/z/a").then((message) => {
             type cases = [
-                Expect<Equal<typeof type,"b">>,
-                Expect<Equal<typeof payload,number>>
-            ]   
+                Expect<Equal<typeof message.type, "x/y/z/a">>,
+                Expect<Equal<typeof message.payload, 1>>
+            ]
         })
-        emitter.emit("x/y/z",1)        
+
+
 
         // ----- scope -----
 
         const scope = emitter.scope("x/y/z")
 
-        scope.on("a",(payload,{type})=>{
+        scope.on("a", (message) => {
             type cases = [
-                Expect<Equal<typeof type,"a">>,
-                Expect<Equal<typeof payload,1>>
-            ]  
-        }) 
+                Expect<Equal<typeof message.type, "a">>,
+                Expect<Equal<typeof message.payload, 1>>
+            ]
+        })
 
-        scope.on("b",(payload,{type})=>{
+        scope.on("b", (message) => {
             type cases = [
-                Expect<Equal<typeof type,"b">>,
-                Expect<Equal<typeof payload,2>>
-            ]  
-        }) 
+                Expect<Equal<typeof message.type, "b">>,
+                Expect<Equal<typeof message.payload, 2>>
+            ]
+        })
 
-        scope.once("a",(payload,{type})=>{
+        scope.once("a", (message) => {
             type cases = [
-                Expect<Equal<typeof type,"a">>,
-                Expect<Equal<typeof payload,1>>
-            ]  
-        }) 
+                Expect<Equal<typeof message.type, "a">>,
+                Expect<Equal<typeof message.payload, 1>>
+            ]
+        })
 
-        scope.once("c",(payload,{type})=>{
+        scope.once("c", (message) => {
             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>>
-            ]   
+                Expect<Equal<typeof message.type, "c">>,
+                Expect<Equal<typeof message.payload, 3>>
+            ]
         })
-        emitter.on("x/y/z/a",(payload,{type})=>{
-            type cases = [
-                Expect<Equal<typeof type,"x/y/z/a">>,
-                Expect<Equal<typeof payload,1>>
-            ]   
-        }) 
-        
-    })   
+
+
+
+    })
 })

package/src/__tests__/waitFor.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect  } from "vitest"
-import { FastEvent } from "../event"  
+import { describe, test, expect } from "vitest"
+import { FastEvent } from "../event"
 
 
 
-describe("waitfor",()=>{
+describe("waitfor", () => {
 
     test('should resolve promise when event is emitted immediately', () => {
         return new Promise<void>((resolve) => {
@@ -11,23 +11,27 @@ describe("waitfor",()=>{
             // Arrange
             const eventType = 'test-event';
             const expectedPayload = { data: 'test data' };
-            
+
             // Act
             // Create a promise for waitFor and store it
             const waitPromise = emitter.waitFor(eventType);
-            
+
             // Emit the event immediately after calling waitFor
             emitter.emit(eventType, expectedPayload);
-    
+
             // Assert
             // Wait for the promise to resolve and check the result
-            waitPromise.then(result=>{
-                expect(result).toEqual(expectedPayload);    
+            waitPromise.then(result => {
+                expect(result).toEqual({
+                    type: eventType,
+                    payload: expectedPayload,
+                    meta: undefined
+                });
                 resolve()
             })
-            
-        }) 
-    }); 
+
+        })
+    });
     test('should handle multiple events waiting simultaneously', async () => {
         return new Promise<void>((resolve) => {
             const emitter = new FastEvent();
@@ -35,30 +39,31 @@ describe("waitfor",()=>{
             const event1Promise = emitter.waitFor('event1');
             const event2Promise = emitter.waitFor('event2');
             const event3Promise = emitter.waitFor('event3');
-    
+
             // Act
             setTimeout(() => {
-                emitter.emit('event2', 'payload2');
+                emitter.emit('event1', 'payload1');
             }, 100);
-    
+
             setTimeout(() => {
-                emitter.emit('event1', 'payload1');
+                emitter.emit('event2', 'payload2');
             }, 200);
-    
+
             setTimeout(() => {
                 emitter.emit('event3', 'payload3');
             }, 300);
-    
+
+
             // Assert
             Promise.all([
                 event1Promise,
                 event2Promise,
                 event3Promise
-            ]).then(results=>{
+            ]).then(results => {
                 expect(results).toEqual([
-                    'payload1',
-                    'payload2',
-                    'payload3'
+                    { type: 'event1', payload: 'payload1', meta: undefined },
+                    { type: 'event2', payload: 'payload2', meta: undefined },
+                    { type: 'event3', payload: 'payload3', meta: undefined }
                 ]);
                 resolve()
             })
@@ -78,12 +83,12 @@ describe("waitfor",()=>{
         }, 100);
 
         setTimeout(() => {
-            emitter.emit('event3', 'payload2');
+            emitter.emit('event2', 'payload2');
         }, 300);
 
         // Event2 will timeout before emission
         setTimeout(() => {
-            emitter.emit('event2', 'payload3');
+            emitter.emit('event3', 'payload3');
         }, 300);
 
         // Assert
@@ -94,16 +99,18 @@ describe("waitfor",()=>{
         ]);
 
         expect(results[0].status).toBe('fulfilled');
-        expect(results[0]).toHaveProperty('value', 'payload1');
-        
-        expect(results[1].status).toBe('rejected'); 
+        expect((results[0] as any).value).toEqual({ type: 'event1', payload: 'payload1', meta: undefined });
+
+
+        expect(results[1].status).toBe('rejected');
         //@ts-ignore
         expect(results[1].reason).toBeInstanceOf(Error);
-        
+
         expect(results[2].status).toBe('fulfilled');
-        expect(results[2]).toHaveProperty('value', 'payload2');
+        expect((results[2] as any).value).toEqual({ type: 'event3', payload: 'payload3', meta: undefined });
+
     });
- 
+
 
 
 })