fastevent 1.1.3 → 2.0.1

package/src/__tests__/waitFor.test.ts

@@ -1,116 +0,0 @@
-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({
-                    type: eventType,
-                    payload: expectedPayload,
-                    meta: undefined
-                });
-                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('event1', 'payload1');
-            }, 100);
-
-            setTimeout(() => {
-                emitter.emit('event2', 'payload2');
-            }, 200);
-
-            setTimeout(() => {
-                emitter.emit('event3', 'payload3');
-            }, 300);
-
-
-            // Assert
-            Promise.all([
-                event1Promise,
-                event2Promise,
-                event3Promise
-            ]).then(results => {
-                expect(results).toEqual([
-                    { type: 'event1', payload: 'payload1', meta: undefined },
-                    { type: 'event2', payload: 'payload2', meta: undefined },
-                    { type: 'event3', payload: 'payload3', meta: undefined }
-                ]);
-                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('event2', 'payload2');
-        }, 300);
-
-        // Event2 will timeout before emission
-        setTimeout(() => {
-            emitter.emit('event3', '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: '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] as any).value).toEqual({ type: 'event3', payload: 'payload3', meta: undefined });
-
-    });
-
-
-
-})

package/src/__tests__/wildcard.test.ts

@@ -1,185 +0,0 @@
-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])
-    })
-})
-

package/src/devTools.ts

@@ -1,166 +0,0 @@
-/**
- * 
- *  基于开发工具
- * 
- *  Redux DevTools 是一个实用工具，用于开发和调试 Redux 应用程序。
- *  FLEXEVENT是基于Redux DevTools 的简单包装，可以让开发者使用Redux DevTools
- *  来查看FLEXEVENT的状态变化 
- * 
- *  import { createStore } from "@FLEXEVENTjs/react"
- *  import { install } from "@FLEXEVENTjs/devtools"
- * 
- *  
- *  const store = createStore({})
- * 
- *  install()
- * 
- */
-
-//@ts-ignore
-import { legacy_createStore as createStore } from "redux"
-import { WeakObjectMap } from "./utils/WeakObjectMap"
-import { FastEvent } from "./event"
-
-const initialState = {
-
-}
-
-
-function getDefaultFastEventState(instance: FastEvent) {
-    return {
-        messageCount: 0,
-        listenerCount: instance.listenerCount,
-        retainMessageCount: instance.retainedMessages.size,
-    }
-}
-
-export class FlexEventDevTools {
-    private reduxStore: any
-    private _installed: boolean = false
-    fastEvents = new WeakObjectMap()
-    constructor() {
-        this.install()
-    }
-    add(instance: FastEvent) {
-        this.fastEvents.set(instance.id, instance)
-
-        instance.options.onAddListener = (type: string[], listener: any) => {
-            this.reduxStore.dispatch({
-                type: "__ADD_LISTENER__",
-                event: type.join("/"),
-                listener,
-                fastEventId: instance.id
-            })
-        }
-        instance.options.onRemoveListener = (type: string[], listener: any) => {
-            this.reduxStore.dispatch({
-                type: "__REMOVE_LISTENER__",
-                event: type.join("/"),
-                listener,
-                fastEventId: instance.id
-            })
-        }
-        instance.options.onClearListeners = () => {
-            this.reduxStore.dispatch({
-                type: "__CLEAR_LISTENERS__",
-                fastEventId: instance.id
-            })
-        }
-        instance.options.onExecuteListener = (message, returns, listeners) => {
-            const results = returns.map(r => r instanceof Error ? `Error(${r.message})` : r)
-            const sresults = listeners.map(listener => (listener as any).name || 'anonymous')
-                .reduce((pre, cur, index) => {
-                    pre[cur] = results[index]
-                    return pre
-                }, {})
-            console.log(`FastEvent<\x1B[31m${message.type}<\x1B[30m> is emit, listeners:`, listeners)
-            this.reduxStore.dispatch({
-                type: message.type,
-                payload: message.payload,
-                meta: message.meta,
-                returns: sresults,
-                fastEventId: instance.id
-            })
-        }
-        this.reduxStore.dispatch({
-            type: "__ADD_FASTEVENT__",
-            fastEventId: instance.id
-        })
-    }
-    remove(instance: FastEvent) {
-        if (this.fastEvents.has(instance.id)) {
-            this.fastEvents.delete(instance.id)
-        }
-    }
-    private reducer(state: any = initialState, action: any) {
-        if (action.type.startsWith("@@")) return state
-        const instance = this.fastEvents.get(action.fastEventId) as FastEvent
-        if (action.type === '__ADD_FASTEVENT__') {
-            return {
-                ...state,
-                [action.fastEventId]: getDefaultFastEventState(instance)
-            }
-        } else if (action.type == '__ADD_LISTENER__') {
-            const eventState = state[action.fastEventId] || getDefaultFastEventState(instance)
-            eventState.listenerCount++
-            return {
-                ...state,
-                [action.fastEventId]: {
-                    ...eventState
-                }
-            }
-        } else if (action.type == '__REMOVE_LISTENER__') {
-            const eventState = state[action.fastEventId]
-            if (!eventState) return state
-            eventState.listenerCount++
-            return {
-                ...state,
-                [action.fastEventId]: {
-                    ...eventState
-                }
-            }
-        } else if (action.type === '__CLEAR_LISTENERS__') {
-            const eventState = state[action.fastEventId]
-            if (!eventState) return state
-            eventState.listenerCount++
-            return {
-                ...state,
-                [action.fastEventId]: getDefaultFastEventState(instance)
-            }
-        } else {
-            const eventState = state[action.fastEventId]
-            if (!eventState) return state
-            eventState.messageCount++
-            eventState.listenerCount = instance.listenerCount
-            eventState.retainMessageCount = instance.retainedMessages.size
-            return {
-                ...state,
-                [action.fastEventId]: { ...eventState }
-            }
-        }
-    }
-    private install() {
-        if (this._installed) return
-        this.reduxStore = createStore(
-            this.reducer.bind(this),
-            // @ts-ignore
-            window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__()
-        );
-        this._installed = true
-        console.info('%c FlexEventDevTools installed. Please open <Redux devtools> to view. %c', "color:red;", '')
-    }
-}
-
-export function install() {
-    // @ts-ignore
-    if (!globalThis.__FLEXEVENT_DEVTOOLS__) globalThis.__FLEXEVENT_DEVTOOLS__ = new FlexEventDevTools()
-}
-
-declare global {
-    // @ts-ignore
-    var __FLEXEVENT_DEVTOOLS__: FlexEventDevTools
-}
-
-
-install()
-