@xyo-network/module-events 2.52.1 → 2.53.0

package/src/Events/Events.ts

@@ -35,12 +35,15 @@ export type Options<TEventData extends EventData> = {
 
 const resolvedPromise = Promise.resolve()
 
-const listenerAdded = 'listenerAdded'
-const listenerRemoved = 'listenerRemoved'
-
 export type MetaEventData<TEventData extends EventData> = {
-  listenerAdded: { eventName?: keyof TEventData; listener: EventListener<TEventData> }
-  listenerRemoved: { eventName?: keyof TEventData; listener: EventListener<TEventData> }
+  listenerAdded: {
+    eventName?: keyof TEventData
+    listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>
+  }
+  listenerRemoved: {
+    eventName?: keyof TEventData
+    listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>
+  }
 }
 
 let canEmitMetaEvents = false
@@ -58,18 +61,21 @@ function assertListener(listener: object) {
   }
 }
 
-const isMetaEvent = (eventName: EventName) => eventName === listenerAdded || eventName === listenerRemoved
+const isMetaEvent = (eventName: EventName) => eventName === 'listenerAdded' || eventName === 'listenerRemoved'
 
-export class Events<TEventData extends EventData> implements EventFunctions<TEventData> {
-  static anyMap = new WeakMap<object, Set<EventAnyListener<any>>>()
-  static eventsMap = new WeakMap<object, Map<keyof EventData, Set<EventListener<any>>>>()
+export class Events<TEventData extends EventData = EventData> implements EventFunctions<TEventData> {
+  static anyMap = new WeakMap<object, Set<EventAnyListener>>()
+  static eventsMap = new WeakMap<object, Map<EventName, Set<EventListener>>>()
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   debug?: DebugOptions<any>
 
+  //this is here to be able to query the type, not use
+  eventData = {} as TEventData
+
   constructor(options: Options<TEventData> = {}) {
-    Events.anyMap.set(this, new Set<EventAnyListener<TEventData>>())
-    Events.eventsMap.set(this, new Map<keyof TEventData, Set<EventListener<TEventData>>>())
+    Events.anyMap.set(this, new Set<EventAnyListener>())
+    Events.eventsMap.set(this, new Map<keyof TEventData, Set<EventListener>>())
 
     this.debug = options.debug
 
@@ -139,58 +145,29 @@ export class Events<TEventData extends EventData> implements EventFunctions<TEve
     }
   }
 
-  async emit(eventName: keyof TEventData, eventData?: TEventData[keyof TEventData]) {
-    await this.emitInternal(eventName, eventData)
-  }
-
-  async emitInternal<TEventName extends EventName, TEventArgs extends EventArgs>(eventName: TEventName, eventArgs?: TEventArgs) {
-    assertEventName(eventName)
-
-    if (isMetaEvent(eventName) && !canEmitMetaEvents) {
-      throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`')
-    }
-
-    this.logIfDebugEnabled('emit', eventName, eventArgs)
-
-    const listeners = this.getListeners(eventName) ?? new Set()
-    const anyListeners = assertEx(Events.anyMap.get(this))
-    const staticListeners = [...listeners]
-    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners]
-
-    await resolvedPromise
-    await Promise.all([
-      ...staticListeners.map(async (listener) => {
-        if (listeners.has(listener)) {
-          return await listener(eventArgs)
-        }
-      }),
-      ...staticAnyListeners.map(async (listener) => {
-        if (anyListeners.has(listener)) {
-          return await listener(eventName, eventArgs)
-        }
-      }),
-    ])
+  async emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]) {
+    await this.emitInternal(eventName, eventArgs)
   }
 
-  async emitMetaEvent<TEventName extends EventName, TEventArgs extends EventArgs>(eventName: TEventName, eventArgs: TEventArgs) {
+  async emitMetaEvent<TEventName extends keyof MetaEventData<TEventData>>(eventName: TEventName, eventArgs: MetaEventData<TEventData>[TEventName]) {
     if (isMetaEvent(eventName)) {
       try {
         canEmitMetaEvents = true
-        await this.emitInternal(eventName, eventArgs)
+        await this.emitMetaEventInternal(eventName, eventArgs)
       } finally {
         canEmitMetaEvents = false
       }
     }
   }
 
-  async emitSerial(eventName: keyof TEventData, eventData: TEventData[keyof TEventData]) {
+  async emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]) {
     assertEventName(eventName)
 
     if (isMetaEvent(eventName) && !canEmitMetaEvents) {
       throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`')
     }
 
-    this.logIfDebugEnabled('emitSerial', eventName, eventData)
+    this.logIfDebugEnabled('emitSerial', eventName, eventArgs)
 
     const listeners = this.getListeners(eventName) ?? new Set()
     const anyListeners = assertEx(Events.anyMap.get(this))
@@ -201,13 +178,13 @@ export class Events<TEventData extends EventData> implements EventFunctions<TEve
 
     for (const listener of staticListeners) {
       if (listeners.has(listener)) {
-        await listener(eventData)
+        await listener(eventArgs)
       }
     }
 
     for (const listener of staticAnyListeners) {
       if (anyListeners.has(listener)) {
-        await listener(eventName, eventData)
+        await listener(eventName, eventArgs)
       }
     }
   }
@@ -252,13 +229,13 @@ export class Events<TEventData extends EventData> implements EventFunctions<TEve
     }
   }
 
-  off(eventNames: keyof TEventData | (keyof TEventData)[], listener: EventListener<TEventData>) {
+  off<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>) {
     assertListener(listener)
 
     const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]
     for (const eventName of eventNamesArray) {
       assertEventName(eventName)
-      const set = this.getListeners(eventName)
+      const set = this.getListeners(eventName) as Set<EventListener<TEventData[TEventName]>>
       if (set) {
         set.delete(listener)
         if (set.size === 0) {
@@ -270,21 +247,22 @@ export class Events<TEventData extends EventData> implements EventFunctions<TEve
       this.logIfDebugEnabled('unsubscribe', eventName, undefined)
 
       if (!isMetaEvent(eventName)) {
-        forget(this.emitMetaEvent(listenerRemoved, { eventName, listener }))
+        forget(this.emitMetaEvent('listenerRemoved', { eventName, listener: listener as EventListener }))
       }
     }
   }
 
-  offAny(listener: EventAnyListener<TEventData>) {
+  offAny(listener: EventAnyListener) {
     assertListener(listener)
 
     this.logIfDebugEnabled('unsubscribeAny', undefined, undefined)
 
-    Events.anyMap.get(this)?.delete(listener)
-    forget(this.emitMetaEvent(listenerRemoved, { listener }))
+    const typedMap = Events.anyMap.get(this) as Set<EventAnyListener<TEventData[keyof TEventData]>>
+    typedMap?.delete(listener)
+    forget(this.emitMetaEvent('listenerRemoved', { listener: listener as EventAnyListener }))
   }
 
-  on(eventNames: keyof TEventData | (keyof TEventData)[], listener: EventListener<TEventData>) {
+  on<TEventName extends keyof TEventData = keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>) {
     assertListener(listener)
 
     const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]
@@ -297,34 +275,98 @@ export class Events<TEventData extends EventData> implements EventFunctions<TEve
         events?.set(eventName, set)
       }
 
-      set.add(listener)
+      set.add(listener as EventListener)
 
       this.logIfDebugEnabled('subscribe', eventName, undefined)
 
       if (!isMetaEvent(eventName)) {
-        forget(this.emitMetaEvent(listenerAdded, { eventName, listener }))
+        forget(this.emitMetaEvent('listenerAdded', { eventName, listener: listener as EventListener }))
       }
     }
 
-    return this.off.bind(this, eventNames, listener)
+    return this.off.bind(this, eventNames, listener as EventListener)
   }
 
-  onAny(listener: EventAnyListener<TEventData>) {
+  onAny(listener: EventAnyListener) {
     assertListener(listener)
 
     this.logIfDebugEnabled('subscribeAny', undefined, undefined)
 
-    Events.anyMap.get(this)?.add(listener)
-    forget(this.emitMetaEvent(listenerAdded, { listener }))
-    return this.offAny.bind(this, listener)
+    Events.anyMap.get(this)?.add(listener as EventAnyListener)
+    forget(this.emitMetaEvent('listenerAdded', { listener: listener as EventAnyListener }))
+    return this.offAny.bind(this, listener as EventAnyListener)
   }
 
-  once(eventNames: keyof TEventData | (keyof TEventData)[], listener: EventListener<TEventData>) {
-    const subListener = async (args?: TEventData[keyof TEventData]) => {
-      this.off(eventNames, subListener)
+  once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>) {
+    const subListener = async (args: TEventData[TEventName]) => {
+      this.off(eventName, subListener)
       await listener(args)
     }
-    this.on(eventNames, subListener)
-    return this.off.bind(this, eventNames, subListener)
+    this.on(eventName, subListener)
+    return this.off.bind(this, eventName, subListener as EventListener)
+  }
+
+  private async emitInternal<TEventName extends keyof TEventData, TEventArgs extends TEventData[TEventName]>(
+    eventName: TEventName,
+    eventArgs: TEventArgs,
+  ) {
+    assertEventName(eventName)
+
+    if (isMetaEvent(eventName) && !canEmitMetaEvents) {
+      throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`')
+    }
+
+    this.logIfDebugEnabled('emit', eventName, eventArgs)
+
+    const listeners = this.getListeners(eventName) ?? new Set()
+    const anyListeners = assertEx(Events.anyMap.get(this))
+    const staticListeners = [...listeners]
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners]
+
+    await resolvedPromise
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        if (listeners.has(listener)) {
+          return await listener(eventArgs)
+        }
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          return await listener(eventName, eventArgs)
+        }
+      }),
+    ])
+  }
+
+  private async emitMetaEventInternal<TEventName extends keyof MetaEventData<TEventData>>(
+    eventName: TEventName,
+    eventArgs: MetaEventData<TEventData>[TEventName],
+  ) {
+    assertEventName(eventName)
+
+    if (isMetaEvent(eventName) && !canEmitMetaEvents) {
+      throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`')
+    }
+
+    this.logIfDebugEnabled('emit', eventName, eventArgs)
+
+    const listeners = this.getListeners(eventName) ?? new Set()
+    const anyListeners = assertEx(Events.anyMap.get(this))
+    const staticListeners = [...listeners]
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners]
+
+    await resolvedPromise
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        if (listeners.has(listener)) {
+          return await listener(eventArgs)
+        }
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          return await listener(eventName, eventArgs)
+        }
+      }),
+    ])
   }
 }

package/src/model/Event.ts

@@ -1,33 +1,24 @@
-import { BaseParams } from '@xyo-network/core'
 import { Promisable } from '@xyo-network/promise'
 
 export type EventName = PropertyKey
 export type EventArgs = string | number | object
 export type EventData = { [key: EventName]: EventArgs }
 export type EventUnsubscribeFunction = () => void
-export type EventAnyListener<TEventData extends EventData = EventData> = (
-  eventName: keyof TEventData,
-  eventData?: TEventData[keyof TEventData],
-) => Promisable<void>
-export type EventListener<TEventData extends EventData = EventData> = (eventData?: TEventData[keyof TEventData]) => Promisable<void>
-
-export type OncePromise<T> = {
-  off(): void
-} & Promise<T>
+export type EventAnyListener<TEventArgs extends EventArgs = EventArgs> = (eventName: EventName, eventData: TEventArgs) => Promisable<void>
+export type EventListener<TEventArgs extends EventArgs = EventArgs> = (eventData: TEventArgs) => Promisable<void>
 
 export interface EventFunctions<TEventData extends EventData> {
+  eventData: TEventData
   clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]): void
-  emit(eventName: keyof TEventData, eventData: TEventData[keyof TEventData]): Promise<void>
-  emitSerial(eventName: keyof TEventData, eventData: TEventData[keyof TEventData]): Promise<void>
+  emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>
+  emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>
   listenerCount(eventNames: keyof TEventData | (keyof TEventData)[]): number
-  off(eventName: keyof TEventData | (keyof TEventData)[], listener: EventListener<TEventData>): void
-  offAny(listener: EventAnyListener<TEventData> | Promise<void>): void
-  on(eventName: keyof TEventData | (keyof TEventData)[], listener: EventListener<TEventData>): EventUnsubscribeFunction
-  onAny(listener: EventAnyListener<TEventData>): EventUnsubscribeFunction
-  once(eventName: keyof TEventData | (keyof TEventData)[], listener: EventListener<TEventData>): EventUnsubscribeFunction
-}
-
-export type EventDataParams<TEventData extends EventData | undefined = undefined, TParams extends BaseParams = BaseParams> = TParams & {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  eventData?: TEventData extends EventData ? TEventData | any : any
+  off<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): void
+  offAny(listener: EventAnyListener | Promise<void>): void
+  on<TEventName extends keyof TEventData>(
+    eventNames: TEventName | TEventName[],
+    listener: EventListener<TEventData[TEventName]>,
+  ): EventUnsubscribeFunction
+  onAny(listener: EventAnyListener): EventUnsubscribeFunction
+  once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>): EventUnsubscribeFunction
 }