fastevent 1.1.3 → 2.0.1

package/src/__tests__/onany.test.ts

@@ -1,212 +0,0 @@
-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])
-    })
-    test("通过onAny订阅所有简单事件", () => {
-        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])
-
-    })
-})
-

package/src/__tests__/once.test.ts

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

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

@@ -1,110 +0,0 @@
-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", ({ type }) => {
-            events.push(type)
-        })
-        emitter.on("a/b/c/x", ({ 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", ({ type }) => {
-            events.push(type)
-        })
-        emitter.on("a/b/c/x", ({ 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", ({ type }) => {
-            events.push(type)
-        })
-        emitter.on("a/b/c/x", ({ 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", ({ type }) => {
-            events.push(type)
-        })
-        emitter.once("a/b/c/x", ({ 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] 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] as any).value).toEqual({ type: 'z', payload: 'payload3', meta: undefined });
-    });
-
-
-})
-

package/src/__tests__/types.test.ts

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