fastevent 0.0.1 → 1.0.1

package/src/__tests__/once.test.ts

@@ -0,0 +1,71 @@
+import { describe, test, expect } from "vitest"
+import { FastEvent } from "../event" 
+
+describe("只订阅一次的事件的发布与订阅",async ()=>{
+    test("简单发布只订阅一次事件",()=>{
+        const emitter = new FastEvent() 
+        const events:string[] =[]
+        emitter.once("x",(payload,{type})=>{
+            expect(type).toBe("x")
+            expect(payload).toBe(1)            
+            events.push(type)
+        })
+        emitter.emit("x",1)
+        emitter.emit("x",1)
+        emitter.emit("x",1)
+        emitter.emit("x",1)
+        expect(events).toEqual(["x"])
+    })
+    test("简单发布只订阅一次事件后取消",()=>{
+        const emitter = new FastEvent()         
+        const events:string[]=[]
+        const subscriber = emitter.once("x",(payload,{type})=>{
+            expect(type).toBe("x")
+            expect(payload).toBe(1)                    
+            events.push(type)    
+        })
+        subscriber.off()
+        emitter.emit("x",1)
+        emitter.emit("x",1)
+        emitter.emit("x",1)
+        expect(events).toEqual([])
+    })
+    test("简单发布只订阅一次的多级事件",()=>{
+        const emitter = new FastEvent() 
+        const events:string[] =[]
+        emitter.once("a.b.c.d",(payload,{type})=>{
+            expect(type).toBe("a.b.c.d")
+            expect(payload).toBe(1)            
+            events.push(type)
+        })
+        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"])
+    })        
+    test("混合发布只订阅一次的多级事件",()=>{
+        const emitter = new FastEvent() 
+        const events:string[] =[]
+        const values:number[]=[]
+        emitter.once("a.b.c.d",(payload,{type})=>{
+            expect(type).toBe("a.b.c.d")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("a.b.c.d",(payload,{type})=>{
+            expect(type).toBe("a.b.c.d")
+            values.push(payload)
+            events.push(type)
+        })
+        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","a.b.c.d"])
+        expect(values).toEqual([1,1,2,3,4])
+    })
+
+
+})
+ 

package/src/__tests__/retain.test.ts

@@ -0,0 +1,66 @@
+import { describe, test, expect } from "vitest"
+import { FastEvent } from "../event" 
+
+
+
+describe("订阅与发布retain事件",async ()=>{        
+    test("简单发布订阅retain事件",()=>{
+        const emitter = new FastEvent() 
+        emitter.emit("x",1,true)        
+        emitter.on("x",(payload,{type})=>{
+            expect(type).toBe("x")
+            expect(payload).toBe(1)            
+        })
+        emitter.emit("a.b.c1",1,true)        
+        emitter.emit("a.b.c2",2,true)    
+        emitter.on("a.b.c1",(payload,{type})=>{
+            expect(type).toBe("a.b.c1")
+            expect(payload).toBe(1)            
+        })
+        emitter.on("a.b.c2",(payload,{type})=>{
+            expect(type).toBe("a.b.c2")
+            expect(payload).toBe(2)            
+        })
+    })
+    test("不处理通配符的retain事件",()=>{
+        const emitter = new FastEvent()              
+        emitter.emit("a.b.c1",1,true)        
+        emitter.emit("a.b.c2",2,true)     
+        const events:string[] = []
+        // 订阅所有a.b.*事件,由于c1,c2是
+        emitter.on("a.b.*",(payload,{type})=>{
+            events.push(type)
+        })
+        expect(events).toEqual([])
+    })
+    test("简单发布订阅retain事件",()=>{
+        const emitter = new FastEvent()  
+        const events:string[] = []
+        emitter.emit("a",1,true)        
+        emitter.emit("a.b",2,true)    
+        emitter.emit("a.b.c",3,true)    
+        emitter.emit("a.b.c.d",4,true)    
+        
+        emitter.on("a",(payload,{type})=>{
+            expect(type).toBe("a")
+            expect(payload).toBe(1)            
+            events.push(type)
+        })
+        emitter.on("a.b",(payload,{type})=>{
+            expect(type).toBe("a.b")
+            expect(payload).toBe(2)            
+            events.push(type)
+        })
+        emitter.on("a.b.c",(payload,{type})=>{
+            expect(type).toBe("a.b.c")
+            expect(payload).toBe(3)            
+            events.push(type)
+        })
+        emitter.on("a.b.c.d",(payload,{type})=>{
+            expect(type).toBe("a.b.c.d")
+            expect(payload).toBe(4)            
+            events.push(type)
+        })
+        expect(events).toEqual(["a","a.b","a.b.c","a.b.c.d"])            
+    })
+})

package/src/__tests__/scope.test.ts

@@ -0,0 +1,111 @@
+import { describe, test, expect } from "vitest"
+import { FastEvent } from "../event" 
+ 
+
+describe("scope", ()=>{
+    test("scope简单的发布订阅事件",()=>{
+        const emitter = new FastEvent() 
+        const scope = emitter.scope("a/b/c")
+        const events:string[] =[] 
+        scope.on("x", (payload,{type})=>{
+            events.push(type)
+        })
+        emitter.on("a/b/c/x", (payload,{type})=>{
+            events.push(type)
+        })
+        scope.emit("x",1)        
+        expect(events).toEqual(["x","a/b/c/x"])
+    })
+
+    test("scope通过off简单的退订事件",()=>{
+        const emitter = new FastEvent() 
+        const scope = emitter.scope("a/b/c")
+
+        const events:string[] =[] 
+        const subscriber =scope.on("x", (payload,{type})=>{
+            events.push(type)
+        })
+        emitter.on("a/b/c/x", (payload,{type})=>{
+            events.push(type)
+        })
+        scope.emit("x",1)        
+        subscriber.off()
+        scope.emit("x",1)      
+        expect(events).toEqual(["x","a/b/c/x","a/b/c/x"])
+    })
+
+    test("scope off退订事件",()=>{
+        const emitter = new FastEvent() 
+        const scope = emitter.scope("a/b/c")
+
+        const events:string[] =[] 
+        scope.on("x", (payload,{type})=>{
+            events.push(type)
+        })
+        emitter.on("a/b/c/x", (payload,{type})=>{
+            events.push(type)
+        })
+        scope.emit("x",1)        
+        scope.off('x')          // 等效于退订a/b/c/x事件
+        scope.emit("x",1)      
+        expect(events).toEqual(["x","a/b/c/x"])
+    })
+    test("scope once布订阅事件",()=>{
+        const emitter = new FastEvent() 
+        const scope = emitter.scope("a/b/c")
+        const events:string[] =[] 
+        scope.once("x", (payload,{type})=>{
+            events.push(type)
+        })
+        emitter.once("a/b/c/x", (payload,{type})=>{
+            events.push(type)
+        })
+        scope.emit("x",1)        
+        expect(events).toEqual(["x","a/b/c/x"])
+    })
+
+    test('scope waitFor', async () => {
+        const emitter = new FastEvent();
+        const scope = emitter.scope("a/b/c")
+
+        // Arrange
+        const event1Promise = scope.waitFor('x', 500);
+        const event2Promise = scope.waitFor('y', 200);
+        const event3Promise = scope.waitFor('z', 1000);
+
+        // Act
+        setTimeout(() => {
+            scope.emit('x', 'payload1');
+        }, 100);
+
+        setTimeout(() => {
+            scope.emit('y', 'payload2');
+        }, 300);
+
+        // Event2 will timeout before emission
+        setTimeout(() => {
+            scope.emit('z', 'payload3');
+        }, 300);
+
+        // Assert
+        const results = await Promise.allSettled([
+            event1Promise,
+            event2Promise,
+            event3Promise
+        ]);
+
+        expect(results[0].status).toBe('fulfilled');
+        expect(results[0]).toHaveProperty('value', 'payload1');
+        
+        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');
+    });
+
+
+})
+
+ 

package/src/__tests__/waitFor.test.ts

@@ -0,0 +1,109 @@
+import { describe, test, expect  } from "vitest"
+import { FastEvent } from "../event"  
+
+
+
+describe("waitfor",()=>{
+
+    test('should resolve promise when event is emitted immediately', () => {
+        return new Promise<void>((resolve) => {
+            const emitter = new FastEvent();
+            // 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);    
+                resolve()
+            })
+            
+        }) 
+    }); 
+    test('should handle multiple events waiting simultaneously', async () => {
+        return new Promise<void>((resolve) => {
+            const emitter = new FastEvent();
+            // Arrange
+            const event1Promise = emitter.waitFor('event1');
+            const event2Promise = emitter.waitFor('event2');
+            const event3Promise = emitter.waitFor('event3');
+    
+            // Act
+            setTimeout(() => {
+                emitter.emit('event2', 'payload2');
+            }, 100);
+    
+            setTimeout(() => {
+                emitter.emit('event1', 'payload1');
+            }, 200);
+    
+            setTimeout(() => {
+                emitter.emit('event3', 'payload3');
+            }, 300);
+    
+            // Assert
+            Promise.all([
+                event1Promise,
+                event2Promise,
+                event3Promise
+            ]).then(results=>{
+                expect(results).toEqual([
+                    'payload1',
+                    'payload2',
+                    'payload3'
+                ]);
+                resolve()
+            })
+        })
+    });
+
+    test('should handle multiple events with different timeouts', async () => {
+        const emitter = new FastEvent();
+        // Arrange
+        const event1Promise = emitter.waitFor('event1', 500);
+        const event2Promise = emitter.waitFor('event2', 200);
+        const event3Promise = emitter.waitFor('event3', 1000);
+
+        // Act
+        setTimeout(() => {
+            emitter.emit('event1', 'payload1');
+        }, 100);
+
+        setTimeout(() => {
+            emitter.emit('event3', 'payload2');
+        }, 300);
+
+        // Event2 will timeout before emission
+        setTimeout(() => {
+            emitter.emit('event2', 'payload3');
+        }, 300);
+
+        // Assert
+        const results = await Promise.allSettled([
+            event1Promise,
+            event2Promise,
+            event3Promise
+        ]);
+
+        expect(results[0].status).toBe('fulfilled');
+        expect(results[0]).toHaveProperty('value', 'payload1');
+        
+        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');
+    });
+ 
+
+
+})

package/src/__tests__/wildcard.test.ts

@@ -0,0 +1,186 @@
+import { describe, test, expect } from "vitest"
+import { FastEvent } from "../event"
+import { FastEventSubscriber } from "../types"
+
+ 
+describe("基于通配符的发布与订阅",async ()=>{
+        
+    test("使用通配符发布订阅层级事件",()=>{
+        const emitter = new FastEvent() 
+        const events:string[]=[]
+        const subscribers:FastEventSubscriber[]=[]
+        subscribers.push(emitter.on("*/*/*",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        }))
+        subscribers.push(emitter.on("a/*/*",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        }))
+        subscribers.push(emitter.on("a/b/*",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        }))
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c","a/b/c","a/b/c"])
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c","a/b/c","a/b/c","a/b/c","a/b/c","a/b/c"])
+        subscribers.forEach(subscriber=>subscriber.off())
+        expect(events).toEqual(["a/b/c","a/b/c","a/b/c","a/b/c","a/b/c","a/b/c"])
+    })
+
+    test("使用通配符发布订阅层级事件11",()=>{
+        const emitter = new FastEvent() 
+        const events:string[]=[]
+        const subscribers:FastEventSubscriber[]=[]
+        subscribers.push(emitter.on("*/*/*",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        })) 
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c"]) 
+    })
+
+
+    test("使用通配符发布订阅层级事件12",()=>{
+        const emitter = new FastEvent() 
+        const events:string[]=[]
+        const subscribers:FastEventSubscriber[]=[]
+        subscribers.push(emitter.on("a/*/*",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        })) 
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c"]) 
+    })
+    test("使用通配符发布订阅层级事件13",()=>{
+        const emitter = new FastEvent() 
+        const events:string[]=[]
+        const subscribers:FastEventSubscriber[]=[]
+        subscribers.push(emitter.on("a/b/*",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        })) 
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c"]) 
+    })
+
+    test("使用通配符发布订阅层级事件14",()=>{
+        const emitter = new FastEvent() 
+        const events:string[]=[]
+        const subscribers:FastEventSubscriber[]=[]
+        subscribers.push(emitter.on("*/*/*",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        }))
+        subscribers.push(emitter.on("*/*/c",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        }))
+        subscribers.push(emitter.on("*/b/c",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        }))
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c","a/b/c","a/b/c"])
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c","a/b/c","a/b/c","a/b/c","a/b/c","a/b/c"])
+        subscribers.forEach(subscriber=>subscriber.off())
+        expect(events).toEqual(["a/b/c","a/b/c","a/b/c","a/b/c","a/b/c","a/b/c"])
+    })
+    test("使用通配符发布订阅层级事件15",()=>{
+        const emitter = new FastEvent() 
+        const events:string[]=[]
+        const subscribers:FastEventSubscriber[]=[]
+        subscribers.push(emitter.on("*/b/c",(payload,{type})=>{
+            expect(type).toBe("a/b/c")
+            expect(payload).toBe(1)
+            events.push(type)
+        }))
+        emitter.emit("a/b/c",1)
+        expect(events).toEqual(["a/b/c"]) 
+    })
+    test("使用通配符发布订阅层级事件16",()=>{
+        const emitter = new FastEvent() 
+        const events:string[]=[]
+        const subscribers:FastEventSubscriber[]=[]
+        subscribers.push(emitter.on("*/b/*/d/*/f",(payload,{type})=>{
+            events.push(type)
+        }))
+        emitter.emit("1/b/1/d/1/f",1)
+        emitter.emit("2/b/2/d/2/f",1)
+        emitter.emit("3/b/3/d/3/f",1)
+        emitter.emit("4/b/4/d/4/f",1)
+        emitter.emit("5/b/5/d/5/f",1)
+        expect(events).toEqual(["1/b/1/d/1/f","2/b/2/d/2/f","3/b/3/d/3/f","4/b/4/d/4/f","5/b/5/d/5/f"]) 
+    })
+    test("使用通配符发布订阅层级事件17",()=>{
+        return new Promise<void>((resolve) => {
+            const emitter = new FastEvent()
+            emitter.on('a/b/c/*', () => {
+                resolve()
+            })  
+            emitter.emit('a/b/c/x', 1)
+            emitter.emit('a/b/c/x', 1)
+        })
+    }) 
+    test("使用多级路径匹配",()=>{
+        const emitter = new FastEvent() 
+        const payloads:number[]=[]
+        const events:string[]=[]
+        emitter.on("a/**",(payload,{type})=>{
+            events.push(type)
+            payloads.push(payload)            
+        })         
+        emitter.emit("a/b/c/d/e/f",1)
+        expect(events).toEqual(["a/b/c/d/e/f"])
+        expect(payloads).toEqual([1]) 
+    })
+    test("使用多级路径匹配2",()=>{
+        const emitter = new FastEvent() 
+        const payloads:number[]=[]
+        const events:string[]=[]
+        emitter.on("a/**",(payload,{type})=>{
+            events.push(type)
+            payloads.push(payload)            
+        })
+        
+        emitter.emit("a/b",1)        
+        emitter.emit("a/b/c",2)
+        emitter.emit("a/b/c/d",3)
+        emitter.emit("a/b/c/d/e",4)
+        emitter.emit("a/b/c/d/e/f",5)
+        expect(events).toEqual(["a/b","a/b/c","a/b/c/d","a/b/c/d/e","a/b/c/d/e/f"])
+        expect(payloads).toEqual([1,2,3,4,5]) 
+    })
+    test("使用多级路径匹配3",()=>{
+        const emitter = new FastEvent() 
+        const payloads:number[]=[]
+        const events:string[]=[]
+        emitter.on("a/**",(payload,{type})=>{
+            events.push(type)
+            payloads.push(payload)            
+        })
+        emitter.on("a/b/*",(payload,{type})=>{
+            events.push(type)
+            payloads.push(payload)            
+        })       
+        emitter.emit("a/b/c",1)
+        emitter.emit("a/b/c/d",2)
+        emitter.emit("a/b/c/d/e",3)
+        emitter.emit("a/b/c/d/e/f",4)
+        expect(events).toEqual(["a/b/c","a/b/c","a/b/c/d","a/b/c/d/e","a/b/c/d/e/f"])
+        expect(payloads).toEqual([1,1,2,3,4]) 
+    })
+}) 
+ 
+