@nmtjs/client 0.15.2 → 0.16.0-beta.1

package/src/events.ts

@@ -2,6 +2,16 @@ import type { Callback } from '@nmtjs/common'
 
 export type EventMap = { [K: string]: any[] }
 
+type ListenerRegistration = {
+  abortHandler?: () => void
+  capture: boolean
+  disposed: boolean
+  event: string
+  listener: Callback
+  signal?: AbortSignal
+  wrapper: EventListener
+}
+
 // TODO: add errors and promise rejections handling
 /**
  * Thin node-like event emitter wrapper around EventTarget
@@ -13,25 +23,101 @@ export class EventEmitter<
     string
   >,
 > {
-  static once<
-    T extends EventEmitter,
-    E extends T extends EventEmitter<any, infer Event> ? Event : never,
-  >(ee: T, event: E) {
-    return new Promise((resolve) => ee.once(event, resolve))
+  #target = new EventTarget()
+  #listeners = new Map<string, Map<Callback, Set<ListenerRegistration>>>()
+
+  #addRegistration(registration: ListenerRegistration) {
+    const events =
+      this.#listeners.get(registration.event) ??
+      new Map<Callback, Set<ListenerRegistration>>()
+
+    if (!this.#listeners.has(registration.event)) {
+      this.#listeners.set(registration.event, events)
+    }
+
+    const registrations =
+      events.get(registration.listener) ?? new Set<ListenerRegistration>()
+
+    if (!events.has(registration.listener)) {
+      events.set(registration.listener, registrations)
+    }
+
+    registrations.add(registration)
   }
 
-  #target = new EventTarget()
-  #listeners = new Map<Callback, Callback>()
+  #removeRegistration(registration: ListenerRegistration) {
+    if (registration.disposed) return
+
+    registration.disposed = true
+    this.#target.removeEventListener(
+      registration.event,
+      registration.wrapper,
+      registration.capture,
+    )
+
+    if (registration.signal && registration.abortHandler) {
+      registration.signal.removeEventListener(
+        'abort',
+        registration.abortHandler,
+      )
+    }
+
+    const events = this.#listeners.get(registration.event)
+    const registrations = events?.get(registration.listener)
+
+    registrations?.delete(registration)
+
+    if (registrations?.size === 0) {
+      events?.delete(registration.listener)
+    }
+
+    if (events?.size === 0) {
+      this.#listeners.delete(registration.event)
+    }
+  }
 
   on<E extends EventName>(
     event: E | (Object & string),
     listener: (...args: Events[E]) => void,
     options?: AddEventListenerOptions,
   ) {
-    const wrapper = (event) => listener(...event.detail)
-    this.#listeners.set(listener, wrapper)
-    this.#target.addEventListener(event, wrapper, { ...options, once: false })
-    return () => this.#target.removeEventListener(event, wrapper)
+    const cleanup = () => {
+      this.#removeRegistration(registration)
+    }
+
+    const registration: ListenerRegistration = {
+      capture: !!options?.capture,
+      disposed: false,
+      event,
+      listener,
+      wrapper: (rawEvent) => {
+        try {
+          listener(...(rawEvent as CustomEvent<Events[E]>).detail)
+        } finally {
+          if (options?.once) {
+            cleanup()
+          }
+        }
+      },
+    }
+
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        return cleanup
+      }
+
+      registration.signal = options.signal
+      registration.abortHandler = cleanup
+      options.signal.addEventListener('abort', cleanup, { once: true })
+    }
+
+    this.#addRegistration(registration)
+    this.#target.addEventListener(registration.event, registration.wrapper, {
+      capture: options?.capture,
+      passive: options?.passive,
+    })
+
+    return cleanup
   }
 
   once<E extends EventName>(
@@ -43,8 +129,15 @@ export class EventEmitter<
   }
 
   off(event: EventName | (Object & string), listener: Callback) {
-    const wrapper = this.#listeners.get(listener)
-    if (wrapper) this.#target.removeEventListener(event, wrapper)
+    const registration = this.#listeners
+      .get(event)
+      ?.get(listener)
+      ?.values()
+      .next().value
+
+    if (registration) {
+      this.#removeRegistration(registration)
+    }
   }
 
   emit<E extends EventName | (Object & string)>(
@@ -65,6 +158,12 @@ export const once = <
   signal?: AbortSignal,
 ) => {
   return new Promise<EventMap[EventName]>((resolve) => {
-    ee.once(event, resolve, { signal })
+    ee.once(
+      event,
+      ((...args: EventMap[EventName]) => {
+        resolve(args)
+      }) as (...args: any[]) => void,
+      { signal },
+    )
   })
 }

package/src/index.ts

@@ -1,6 +1,10 @@
+export * from './client.ts'
+export * from './clients/runtime.ts'
+export * from './clients/static.ts'
 export * from './core.ts'
 export * from './events.ts'
 export * from './plugins/index.ts'
+export * from './streams.ts'
 export * from './transformers.ts'
 export * from './transport.ts'
 export * from './types.ts'

package/src/layers/ping.ts

@@ -0,0 +1,99 @@
+import type { Future } from '@nmtjs/common'
+import { createFuture, MAX_UINT32, withTimeout } from '@nmtjs/common'
+import {
+  ClientMessageType,
+  ConnectionType,
+  ServerMessageType,
+} from '@nmtjs/protocol'
+
+import type { ClientCore } from '../core.ts'
+
+export interface PingLayerApi {
+  ping(timeout: number, signal?: AbortSignal): Promise<void>
+  stopAll(reason?: unknown): void
+}
+
+export const createPingLayer = (core: ClientCore): PingLayerApi => {
+  let pingNonce = 0
+  const pendingPings = new Map<number, Future<void>>()
+
+  const nextPingNonce = () => {
+    if (pingNonce >= MAX_UINT32) {
+      pingNonce = 0
+    }
+
+    return pingNonce++
+  }
+
+  const stopAll = (reason?: unknown) => {
+    if (!pendingPings.size) return
+
+    const error = new Error('Heartbeat stopped', { cause: reason })
+    for (const pending of pendingPings.values()) {
+      pending.reject(error)
+    }
+    pendingPings.clear()
+  }
+
+  core.on('message', (message: any) => {
+    switch (message.type) {
+      case ServerMessageType.Pong: {
+        const pending = pendingPings.get(message.nonce)
+        if (!pending) return
+
+        pendingPings.delete(message.nonce)
+        pending.resolve()
+        core.emit('pong', message.nonce)
+        break
+      }
+      case ServerMessageType.Ping: {
+        if (!core.messageContext) return
+
+        const buffer = core.protocol.encodeMessage(
+          core.messageContext,
+          ClientMessageType.Pong,
+          { nonce: message.nonce },
+        )
+
+        core.send(buffer).catch(() => {})
+        break
+      }
+    }
+  })
+
+  core.on('disconnected', (reason) => {
+    stopAll(reason)
+  })
+
+  return {
+    ping(timeout: number, signal?: AbortSignal) {
+      if (
+        core.transportType !== ConnectionType.Bidirectional ||
+        core.state !== 'connected' ||
+        !core.messageContext
+      ) {
+        return Promise.reject(new Error('Client is not connected'))
+      }
+
+      const nonce = nextPingNonce()
+      const future = createFuture<void>()
+      pendingPings.set(nonce, future)
+
+      const buffer = core.protocol.encodeMessage(
+        core.messageContext,
+        ClientMessageType.Ping,
+        { nonce },
+      )
+
+      return core
+        .send(buffer, signal)
+        .then(() =>
+          withTimeout(future.promise, timeout, new Error('Heartbeat timeout')),
+        )
+        .finally(() => {
+          pendingPings.delete(nonce)
+        })
+    },
+    stopAll,
+  }
+}