fastevent 1.1.3 → 2.0.1

package/src/__tests__/emit.test.ts

@@ -1,106 +0,0 @@
-import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event"
-
-describe("简单发布与订阅", async () => {
-    test("简单发布订阅事件", () => {
-        const emitter = new FastEvent()
-        emitter.on("x", ({ type, payload }) => {
-            expect(type).toBe("x")
-            expect(payload).toBe(1)
-        })
-        emitter.emit("x", 1)
-    })
-    test("简单发布订阅事件后取消", () => {
-        const emitter = new FastEvent()
-        const events: string[] = []
-        const subscriber = emitter.on("x", ({ type, payload }) => {
-            expect(type).toBe("x")
-            expect(payload).toBe(1)
-            events.push(type)
-        })
-        emitter.emit("x", 1)
-        expect(events).toEqual(["x"])
-        subscriber.off()
-        emitter.emit("x", 1)
-        emitter.emit("x", 1)
-        emitter.emit("x", 1)
-        expect(events).toEqual(["x"])
-    })
-    test("发布订阅层级事件", () => {
-        const emitter = new FastEvent()
-        const events: string[] = []
-        emitter.on("a.b.c", ({ type, payload }) => {
-            expect(type).toBe("a.b.c")
-            expect(payload).toBe(1)
-            events.push(type)
-        })
-        emitter.emit("a", 1)
-        emitter.emit("a.b", 1)
-        emitter.emit("a.b.c", 1)
-        expect(events).toEqual(["a.b.c"])
-    })
-    test("返回事件执行结果", () => {
-        const emitter = new FastEvent()
-        for (let i = 1; i <= 10; i++) {
-            emitter.on("x", () => {
-                return i
-            })
-        }
-        const results = emitter.emit("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", () => {
-                if (i % 2 == 0) throw new Error("custom")
-                return i
-            })
-        }
-        const results = emitter.emit("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)
-        }
-    })
-    test("侦听器执行出错时emit出错", async () => {
-        const emitter = new FastEvent({ ignoreErrors: false })
-        const err = new Error("custom")
-        for (let i = 1; i <= 10; i++) {
-            emitter.on("x", () => {
-                if (i % 2 == 0) throw err
-                return i
-            })
-        }
-        expect(() => emitter.emit("x", 1)).toThrow(err);
-        // @ts-ignore,  当执行侦听器出错时会在错误对象上挂载一个_listener属性代表当前执行的侦听器路径
-        expect(err._emitter).toBe("x")
-
-    })
-    test("添加侦听器时指定顺序", async () => {
-        const emitter = new FastEvent()
-        const types: number[] = []
-        emitter.on("x", () => {
-            types.push(1)
-        })
-
-        emitter.on("x", () => {
-            types.push(2)
-        }, { prepend: true })
-        emitter.emit("x")
-        expect(types).toEqual([2, 1])
-    })
-    test("简单发布订阅message事件", () => {
-        const emitter = new FastEvent()
-        emitter.on("x", ({ type, payload, meta }) => {
-            expect(type).toBe("x")
-            expect(meta.a).toBe(1)
-            expect(payload).toBe(1)
-        })
-        emitter.emit({
-            type: "x",
-            payload: 1,
-            meta: { a: 1 }
-        })
-    })
-})

package/src/__tests__/emitAsync.test.ts

@@ -1,64 +0,0 @@
-import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event"
-
-describe("异步发布与订阅", async () => {
-    test("异步发布订阅事件", async () => {
-        const emitter = new FastEvent()
-        const events: any[] = []
-        emitter.on("x", async ({ payload, type }) => {
-            events.push({ type, payload })
-        })
-        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 ({ type }) => {
-            events.push(type)
-        })
-        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)
-        expect(events).toEqual(["x"])
-    })
-    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)
-        expect(events).toEqual(["a.b.c"])
-    })
-    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])
-    })
-    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)
-        }
-    })
-})

package/src/__tests__/isPathMatched.test.ts

@@ -1,205 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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, meta }) => {
-            expect(type).toBe("x")
-            expect(payload).toBe(1)
-            expect(meta.a).toBe(1)
-        })
-        emitter.emit("x", 1)
-    })
-    test("emit时传递meta数据", () => {
-        const emitter = new FastEvent({
-            meta: { a: 1, b: 2 }
-        })
-        emitter.on("x", ({ payload, type, meta }) => {
-            expect(type).toBe("x")
-            expect(payload).toBe(1)
-            expect(meta.a).toBe(10)
-            expect(meta.b).toBe(20)
-        })
-        emitter.emit("x", 1, false, { a: 10, b: 20 })
-    })
-}) 

package/src/__tests__/off.test.ts

@@ -1,214 +0,0 @@
-import { describe, test, expect } from "vitest"
-import { FastEvent } from "../event"
-import { FastEventListener } from '../types';
-
-
-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: FastEventListener<string, number> = (({ payload, type }) => {
-            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: FastEventListener<string, number> = (({ payload, type }) => {
-            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: FastEventListener<string, number> = ({ payload, type }) => {
-            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: FastEventListener<string, number> = ({ payload, type }) => {
-            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: 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"])
-    })
-    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.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: 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.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: 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.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: 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.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"])
-    })
-})
-