@infectedbyjs/emitts/dist/EmitTS.d.ts

A type-safe event emitter for TypeScript with priority-based listeners, sequential/parallel execution strategies, and memory leak detection

import type { CleanUpFn, DebugLog, EmitOptions, EventCallback, EventMap, IEmitTS } from "./types";
/**
 * A type-safe event emitter with priority-based event handling.
 *
 * Features:
 * - Priority-based listeners (higher numbers execute first)
 * - Sequential or parallel execution strategies
 * - Debugging capabilities with custom loggers
 * - Memory leak detection with maxListeners warning
 *
 * @template Events A map of event names to their payload types
 */
export declare class EmitTS<Events extends EventMap = EventMap> implements IEmitTS<Events> {
    private subscriptions;
    private maxListeners;
    private logger;
    /**
     * Creates a new event emitter instance.
     *
     * @param options Configuration options
     * @param options.debug Whether to enable debug logging (defaults to false)
     * @param options.logger Custom debug logger (defaults to internal logger)
     * @param options.maxListeners Maximum listeners per event before warning (defaults to 10)
     */
    constructor(options?: {
        debug?: boolean;
        logger?: DebugLog;
        maxListeners?: number;
    });
    /**
     * Checks whether the emitter has listeners for the given event.
     * @param event Event name
     * @returns `true` if any listeners are registered
     */
    has(event: keyof Events): boolean;
    /**
     * Returns the number of listeners for the given event.
     * @param event Event name
     * @returns The number of listeners
     */
    listenersCount(event: keyof Events): number;
    /**
     * Returns a list of all currently registered event names.
     */
    get eventNames(): (keyof Events)[];
    /**
     * Checks whether the emitter has no listeners at all.
     */
    isEmpty(): boolean;
    /**
     * Removes all listeners for all events.
     */
    clear(): void;
    /**
     * Subscribes a callback function to an event with optional priority.
     * Higher priority listeners are called first.
     */
    on<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>, priority?: number): CleanUpFn;
    /**
     * Subscribes a one-time callback function that automatically unsubscribes after execution.
     */
    once<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>, priority?: number): void;
    /**
     * Removes listeners from an event. If no callback is provided, removes all listeners.
     * If no event is provided, clears all listeners from all events.
     */
    off<E extends keyof Events>(event?: E, callback?: EventCallback<Events[E]>): void;
    /**
     * Triggers an event with payload data and executes all listeners.
     * Supports both parallel (default) and sequential execution strategies.
     * Handles errors to prevent one listener from breaking others.
     */
    emit<E extends keyof Events>(event: E, data: Events[E], options?: EmitOptions): Promise<void>;
    /**
     * Returns a promise that resolves when the given event is emitted.
     *
     * @param event Event name
     * @returns Promise that resolves with the event payload
     */
    toPromise<E extends keyof Events>(event: E): Promise<Events[E]>;
}