@eventmsg/core/dist/event-msg.d.cts

EventMsgV3 TypeScript library - Core protocol implementation with transport abstraction

import { Transport } from "./types/transport.cjs";
import { EventMsgConfig } from "./types/config.cjs";
import { MessageMetadata, MessageResult, SendOptions, WaitForOptions } from "./types/message.cjs";
import { Protocol } from "./protocol.cjs";
import { ConnectionStats, MessageHandler } from "./types/events.cjs";
import { EventEmitter } from "eventemitter3";

//#region src/event-msg.d.ts

/**
* EventMsg - Main class for EventMsgV3 protocol communication
*
* Provides type-safe messaging with per-method generics, async event handling,
* and transport abstraction.
*/
declare class EventMsg<TDevice = unknown> extends EventEmitter {
  private readonly transport;
  protocol: Protocol;
  private readonly logger;
  messageCounter: number;
  private readonly config;
  private connectionState;
  private connectTime;
  private readonly pendingWaits;
  private readonly stats;
  private readonly messageHandlers;
  constructor(config: EventMsgConfig<TDevice>);
  /**
  * Connect to the transport layer
  */
  connect(): Promise<void>;
  /**
  * Disconnect from the transport layer
  */
  disconnect(): Promise<void>;
  /**
  * Check if currently connected
  */
  isConnected(): boolean;
  /**
  * Send a message with explicit receiver targeting
  */
  send<TData = unknown>(event: string, data: TData, options: SendOptions): Promise<void>;
  /**
  * Send binary data with explicit receiver targeting
  */
  sendBinary(event: string, data: Uint8Array, options: SendOptions): Promise<void>;
  /**
  * Register a type-safe event handler
  */
  on<TData = unknown>(event: string | symbol, handler: MessageHandler<TData>): this;
  /**
  * Register a one-time type-safe event handler
  */
  once<TData = unknown>(event: string | symbol, handler: MessageHandler<TData>): this;
  /**
  * Remove a type-safe event handler
  */
  off<TData = unknown>(event: string | symbol, handler?: MessageHandler<TData>): this;
  /**
  * Register a handler for all incoming user messages
  * @param handler - Function called for every incoming message
  * @returns Unsubscribe function to remove this specific handler
  * @example
  * ```typescript
  * const unsubscribe = eventMsg.onMessage((eventName, data, metadata) => {
  *   console.log(`Received ${eventName} from device ${metadata.senderId}`);
  * });
  * // Later: unsubscribe();
  * ```
  */
  onMessage(handler: (eventName: string, data: unknown, metadata: MessageMetadata) => void): () => void;
  /**
  * Register a handler for a specific message event type
  * @param eventName - The specific event name to listen for
  * @param handler - Function called when the specific event is received
  * @returns Unsubscribe function to remove this specific handler
  * @example
  * ```typescript
  * const unsubscribe = eventMsg.onMessage('ping', (data, metadata) => {
  *   console.log(`Ping from device ${metadata.senderId}: ${data}`);
  * });
  * // Later: unsubscribe();
  * ```
  */
  onMessage<TData = unknown>(eventName: string, handler: (data: TData, metadata: MessageMetadata) => void): () => void;
  /**
  * Remove message handlers
  * @param eventName - The event name to stop listening for
  * @returns this instance for chaining
  * @warning When called without arguments, removes ALL message handlers from ALL events.
  * Prefer using the unsubscribe function returned by onMessage() for targeted cleanup.
  * @example
  * ```typescript
  * // Preferred: use unsubscribe function from onMessage()
  * const unsubscribe = eventMsg.onMessage('ping', handler);
  * unsubscribe(); // Removes only this handler
  *
  * // Remove all handlers for a specific event
  * eventMsg.offMessage('ping');
  *
  * // Remove ALL message handlers (use with caution)
  * eventMsg.offMessage();
  * ```
  */
  offMessage(eventName?: string): this;
  /**
  * Track message handlers for proper cleanup
  */
  private trackMessageHandler;
  /**
  * Wait for a single event occurrence with timeout
  */
  waitFor<TData = unknown>(event: string, options?: WaitForOptions): Promise<MessageResult<TData>>;
  /**
  * Get local device address from transport
  */
  getLocalAddress(): number;
  /**
  * Get local group address from transport
  */
  getGroupAddress(): number;
  /**
  * Get connection statistics
  */
  getStats(): ConnectionStats;
  /**
  * Get the underlying transport instance
  */
  getTransport(): Transport<TDevice>;
  /**
  * Get the connected device from transport
  */
  getDevice(): TDevice | null;
  /**
  * Create message header from send options
  */
  private createHeader;
  /**
  * Validate send options
  */
  private validateSendOptions;
  /**
  * Setup transport event handlers
  */
  private setupTransportHandlers;
  /**
  * Handle incoming transport data
  */
  private handleIncomingData;
  /**
  * Handle transport errors
  */
  private handleTransportError;
  /**
  * Handle transport disconnection
  */
  private handleTransportDisconnect;
  /**
  * Add a pending wait for an event
  */
  private addPendingWait;
  /**
  * Remove a pending wait
  */
  private removePendingWait;
  /**
  * Resolve pending waits for an event
  */
  private resolvePendingWaits;
  /**
  * Clear all pending waits (on disconnect)
  */
  private clearAllPendingWaits;
}
//#endregion
export { EventMsg };
//# sourceMappingURL=event-msg.d.cts.map