fastevent 0.0.1 → 1.0.1

package/src/__tests__/isPathMatched.test.ts

@@ -0,0 +1,205 @@
+import { describe, test, expect } from "vitest"
+import { isPathMatched } from "../utils/isPathMatched";
+ 
+
+describe("isPathMatched", ()=>{
+    test('Empty Path and Pattern Match', () => {
+        // Arrange
+        const path: string[] = [];
+        const pattern: string[] = [];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+    test('should match single element arrays with same value', () => {
+        // Arrange
+        const path = ["a"];
+        const pattern = ["a"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+    test('should match wildcards', () => {
+        // Arrange
+        const path = ["*"];
+        const pattern = ["*"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should match single wildcard pattern correctly', () => {
+        // Arrange
+        const path = ["anything"];
+        const pattern = ["*"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should match multiple elements with exact values', () => {
+        // Arrange
+        const path = ["a", "b", "c"];
+        const pattern = ["a", "b", "c"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should match path with multiple wildcards in pattern', () => {
+        // Arrange
+        const path = ["a", "b", "c"];
+        const pattern = ["*", "b", "*"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should match path when pattern ends with double star', () => {
+        // Arrange
+        const path = ["a", "b", "c", "d"];
+        const pattern = ["a", "b", "**"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should return false when arrays have different lengths without double star pattern', () => {
+        // Arrange
+        const path = ['a', 'b'];
+        const pattern = ['a'];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(false);
+    });
+
+    test('Double Star with Empty Remaining Path', () => {
+        // Arrange
+        const path = ["a", "b"];
+        const pattern = ["a", "b", "**"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should match pattern with mixed * and ** wildcards', () => {
+        // Arrange
+        const path = ["a", "b", "c", "d"];
+        const pattern = ["*", "b", "**"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should match path partially when pattern ends with double star', () => {
+        // Arrange
+        const path = ["x", "y"];
+        const pattern = ["x", "**"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should match single element path with double star pattern', () => {
+        // Arrange
+        const path = ["x"];
+        const pattern = ["**"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+
+    test('should return false when pattern length exceeds path length', () => {
+        // Arrange
+        const path = ["a"];
+        const pattern = ["a", "b"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(false);
+    });
+
+    test('should match path with special characters', () => {
+        // Arrange
+        const path = ['$', '#', '@'];
+        const pattern = ['$', '*', '@'];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test('should return false when double star pattern is in middle of pattern array', () => {
+        // Arrange
+        const path = ["a", "b", "c"];
+        const pattern = ["a", "**", "c"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(false);
+    });
+
+    test('should match path with consecutive wildcards in pattern', () => {
+        // Arrange
+        const path = ["a", "b", "c"];
+        const pattern = ["*", "*", "c"];
+
+        // Act
+        const result = isPathMatched(path, pattern);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    test("多路匹配路径",()=>{
+        expect(isPathMatched(["a","b","c","d","e"],["**"])).toBeTruthy() 
+        expect(isPathMatched(["a","b","c","d","e"],["a","**"]) ).toBeTruthy() 
+        expect(isPathMatched(["a","b","c","d","e"],["a","b","**"]) ).toBeTruthy() 
+        expect(isPathMatched(["a","b","c","d","e"],["a","b","c","**"])).toBeTruthy() 
+        expect(isPathMatched(["a","b","c","d","e"],["a","b","c","d","**"])).toBeTruthy() 
+    })
+
+})

package/src/__tests__/many.test.ts

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

package/src/__tests__/meta.test.ts

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

package/src/__tests__/off.test.ts

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

package/src/__tests__/onany.test.ts

@@ -0,0 +1,173 @@
+import { describe, test, expect } from "vitest"
+import { FastEvent } from "../event" 
+ 
+
+describe("订阅所有事件", ()=>{
+    test("订阅所有简单事件",()=>{
+        const emitter = new FastEvent() 
+        const allEvents:string[] =[]
+        const allValues:number[]=[]
+        const events:string[] =[]
+        const values:number[]=[]
+        emitter.onAny((payload,{type})=>{                
+            allEvents.push(type)
+            allValues.push(payload)
+        })
+        emitter.on("a",(payload,{type})=>{
+            expect(type).toBe("a")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("b",(payload,{type})=>{
+            expect(type).toBe("b")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("c",(payload,{type})=>{
+            expect(type).toBe("c")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("d",(payload,{type})=>{
+            expect(type).toBe("d")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.emit("a",1)        
+        emitter.emit("b",2)
+        emitter.emit("c",3)
+        emitter.emit("d",4)
+
+        expect(events).toEqual(["a","b","c","d"])
+        expect(values).toEqual([1,2,3,4])
+        expect(allEvents).toEqual(["a","b","c","d"])
+        expect(allValues).toEqual([1,2,3,4]) 
+
+    })
+    test("通过on订阅所有简单事件",()=>{
+        const emitter = new FastEvent() 
+        const allEvents:string[] =[]
+        const allValues:number[]=[]
+        const events:string[] =[]
+        const values:number[]=[]
+        emitter.on("**",(payload,{type})=>{                
+            allEvents.push(type)
+            allValues.push(payload)
+        })
+        emitter.on("a",(payload,{type})=>{
+            expect(type).toBe("a")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("b",(payload,{type})=>{
+            expect(type).toBe("b")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("c",(payload,{type})=>{
+            expect(type).toBe("c")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("d",(payload,{type})=>{
+            expect(type).toBe("d")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.emit("a",1)        
+        emitter.emit("b",2)
+        emitter.emit("c",3)
+        emitter.emit("d",4)
+
+        expect(events).toEqual(["a","b","c","d"])
+        expect(values).toEqual([1,2,3,4])
+        expect(allEvents).toEqual(["a","b","c","d"])
+        expect(allValues).toEqual([1,2,3,4]) 
+
+    })
+    test("订阅所有简单事件",()=>{
+        const emitter = new FastEvent() 
+        const allEvents:string[] =[]
+        const allValues:number[]=[]
+        const events:string[] =[]
+        const values:number[]=[]
+        emitter.onAny((payload,{type})=>{                
+            allEvents.push(type)
+            allValues.push(payload)
+        })
+        emitter.on("a.x.y",(payload,{type})=>{
+            expect(type).toBe("a.x.y")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("b.m.n",(payload,{type})=>{
+            expect(type).toBe("b.m.n")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("c.o.p",(payload,{type})=>{
+            expect(type).toBe("c.o.p")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("d.q.r",(payload,{type})=>{
+            expect(type).toBe("d.q.r")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.emit("a.x.y",1)        
+        emitter.emit("b.m.n",2)
+        emitter.emit("c.o.p",3)
+        emitter.emit("d.q.r",4)
+
+        expect(events).toEqual(["a.x.y","b.m.n","c.o.p","d.q.r"])
+        expect(values).toEqual([1,2,3,4])
+        expect(allEvents).toEqual(["a.x.y","b.m.n","c.o.p","d.q.r"])
+        expect(allValues).toEqual([1,2,3,4])
+
+    })
+    test("取消订阅所有简单事件",()=>{
+        const emitter = new FastEvent() 
+        const allEvents:string[] =[]
+        const allValues:number[]=[]
+        const events:string[] =[]
+        const values:number[]=[]
+        const subscriber = emitter.onAny((payload,{type})=>{                
+            allEvents.push(type)
+            allValues.push(payload)
+        })
+        emitter.on("a",(payload,{type})=>{
+            expect(type).toBe("a")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("b",(payload,{type})=>{
+            expect(type).toBe("b")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("c",(payload,{type})=>{
+            expect(type).toBe("c")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.on("d",(payload,{type})=>{
+            expect(type).toBe("d")
+            values.push(payload)
+            events.push(type)
+        })
+        emitter.emit("a",1)        
+        subscriber.off()
+        emitter.emit("b",2)
+        emitter.emit("c",3)
+        emitter.emit("d",4)
+
+        expect(events).toEqual(["a","b","c","d"])
+        expect(values).toEqual([1,2,3,4])
+        expect(allEvents).toEqual(["a"])
+        expect(allValues).toEqual([1])  
+    })
+
+})
+
+