typescript-event-emitter/dist/GlobalEventBus.js

Versatile and feature-rich TypeScript library for event management, providing a solid foundation for building event-driven applications in TypeScript.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.globalEventBus = void 0;
const EventEmitter_1 = require("./EventEmitter");
class GlobalEventBus {
    constructor() {
        this.emitter = new EventEmitter_1.EventEmitter();
    }
    /**
     * Gets the singleton instance of the GlobalEventBus.
     * @returns The singleton instance of the GlobalEventBus.
     */
    static getInstance() {
        if (!GlobalEventBus.instance) {
            GlobalEventBus.instance = new GlobalEventBus();
        }
        return GlobalEventBus.instance;
    }
    /**
     * Sets global options for the EventEmitter.
     * @param options - Global options, such as the separator.
     */
    setGlobalOptions(options) {
        this.emitter.setGlobalOptions(options);
    }
    /**
     * Adds a listener for the specified event through the GlobalEventBus, with optional filtering, throttling, debouncing, and priority.
     * @param event - The event name to listen for.
     * @param listener - The listener function to be called when the event is emitted.
     * @param options - An optional object containing properties like `filter`, `throttle`, `debounce`, and `priority`.
     * @param options.filter - A filter function to determine whether to emit the event.
     * @param options.throttle - The time delay (in milliseconds) between allowed invocations of the listener.
     * @param options.debounce - The time delay (in milliseconds) before the listener is called after the last invocation.
     * @param options.priority - The priority of the listener, higher values execute first (default is 0).
     * @param options.separator - Separator used for parsing the event (if applicable, default is '.').
     */
    on(event, listener, { filter, throttle, debounce, priority, separator } = {}) {
        this.emitter.on(event, listener, { filter, throttle, debounce, priority, separator });
    }
    /**
     * Removes a previously added listener for the specified event through the GlobalEventBus.
     * @param event - The event name from which to remove the listener.
     * @param listener - The listener function to be removed.
     */
    off(event, listener) {
        this.emitter.off(event, listener);
    }
    /**
     * Emits the specified event through the GlobalEventBus, calling all associated listeners.
     * @param event - The event name to be emitted.
     * @param args - Additional arguments to be passed to the listeners.
     * @returns A promise that resolves when all listeners have been executed.
     */
    emit(event, ...args) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                yield this.emitter.emit(event, ...args);
            }
            catch (error) {
                this.handleEventBusError(event, error);
            }
        });
    }
    /**
     * Handles errors that occur during the event emission process in the GlobalEventBus.
     * @param event - The name of the event that encountered an error during emission.
     * @param error - The error object representing the encountered error.
     */
    handleEventBusError(event, error) {
        console.error(`Error in GlobalEventBus while emitting event ${event}:`, error);
        console.error(error.stack);
    }
}
exports.globalEventBus = GlobalEventBus.getInstance();