fastevent 1.0.4 → 1.1.1

package/src/__tests__/wildcard.test.ts

@@ -2,185 +2,184 @@ 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})=>{
+
+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})=>{
+        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})=>{
+        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"])
+        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})=>{
+    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"]) 
+        }))
+        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})=>{
+    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"]) 
+        }))
+        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})=>{
+    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"]) 
+        }))
+        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})=>{
+    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})=>{
+        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})=>{
+        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"])
+        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})=>{
+    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"]) 
+        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})=>{
+    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"]) 
+        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",()=>{
+    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})=>{
+    })
+    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)
+            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]) 
+        expect(payloads).toEqual([1])
     })
-    test("使用多级路径匹配2",()=>{
-        const emitter = new FastEvent() 
-        const payloads:number[]=[]
-        const events:string[]=[]
-        emitter.on("a/**",(payload,{type})=>{
+    test("使用多级路径匹配2", () => {
+        const emitter = new FastEvent()
+        const payloads: number[] = []
+        const events: string[] = []
+        emitter.on("a/**", ({ payload, type }) => {
             events.push(type)
-            payloads.push(payload)            
+            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]) 
+
+        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})=>{
+    test("使用多级路径匹配3", () => {
+        const emitter = new FastEvent()
+        const payloads: number[] = []
+        const events: string[] = []
+        emitter.on("a/**", ({ payload, type }) => {
             events.push(type)
-            payloads.push(payload)            
+            payloads.push(payload)
         })
-        emitter.on("a/b/*",(payload,{type})=>{
+        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]) 
+            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

@@ -0,0 +1,166 @@
+/**
+ * 
+ *  基于开发工具
+ * 
+ *  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()
+