xypriss-security/dist/cjs/components/secure-object/events/event-manager.js

XyPriss Security is an advanced JavaScript security library designed for enterprise applications. It provides military-grade encryption, secure data structures, quantum-resistant cryptography, and comprehensive security utilities for modern web applicatio

'use strict';

/**
 * Event Manager Module
 * Handles event system for SecureObject
 */
/**
 * Manages events for SecureObject instances
 */
class EventManager {
    constructor() {
        this.eventListeners = new Map();
    }
    /**
     * Adds an event listener
     */
    addEventListener(event, listener) {
        if (!this.eventListeners.has(event)) {
            this.eventListeners.set(event, new Set());
        }
        this.eventListeners.get(event).add(listener);
    }
    /**
     * Removes an event listener
     */
    removeEventListener(event, listener) {
        const listeners = this.eventListeners.get(event);
        if (listeners) {
            listeners.delete(listener);
            // Clean up empty sets
            if (listeners.size === 0) {
                this.eventListeners.delete(event);
            }
        }
    }
    /**
     * Removes all listeners for a specific event
     */
    removeAllListeners(event) {
        if (event) {
            this.eventListeners.delete(event);
        }
        else {
            this.eventListeners.clear();
        }
    }
    /**
     * Emits an event to all registered listeners
     */
    emit(event, key, value) {
        const listeners = this.eventListeners.get(event);
        if (listeners) {
            for (const listener of listeners) {
                try {
                    listener(event, key, value);
                }
                catch (error) {
                    console.error(`Error in SecureObject event listener:`, error);
                }
            }
        }
    }
    /**
     * Gets the number of listeners for an event
     */
    getListenerCount(event) {
        const listeners = this.eventListeners.get(event);
        return listeners ? listeners.size : 0;
    }
    /**
     * Gets all registered event types
     */
    getRegisteredEvents() {
        return Array.from(this.eventListeners.keys());
    }
    /**
     * Gets total number of listeners across all events
     */
    getTotalListenerCount() {
        let total = 0;
        for (const listeners of this.eventListeners.values()) {
            total += listeners.size;
        }
        return total;
    }
    /**
     * Checks if there are any listeners for an event
     */
    hasListeners(event) {
        const listeners = this.eventListeners.get(event);
        return listeners ? listeners.size > 0 : false;
    }
    /**
     * Checks if there are any listeners at all
     */
    hasAnyListeners() {
        return this.eventListeners.size > 0;
    }
    /**
     * Gets a copy of all listeners for an event
     */
    getListeners(event) {
        const listeners = this.eventListeners.get(event);
        return listeners ? Array.from(listeners) : [];
    }
    /**
     * Creates a one-time event listener that removes itself after first execution
     */
    once(event, listener) {
        const onceListener = (evt, key, value) => {
            this.removeEventListener(event, onceListener);
            listener(evt, key, value);
        };
        this.addEventListener(event, onceListener);
    }
    /**
     * Creates a promise that resolves when a specific event is emitted
     */
    waitFor(event, timeout) {
        return new Promise((resolve, reject) => {
            let timeoutId;
            const listener = (_evt, key, value) => {
                if (timeoutId) {
                    clearTimeout(timeoutId);
                }
                this.removeEventListener(event, listener);
                resolve({ key, value });
            };
            this.addEventListener(event, listener);
            if (timeout) {
                timeoutId = setTimeout(() => {
                    this.removeEventListener(event, listener);
                    reject(new Error(`Event '${event}' timeout after ${timeout}ms`));
                }, timeout);
            }
        });
    }
    /**
     * Emits an event and waits for all listeners to complete (if they return promises)
     */
    async emitAsync(event, key, value) {
        const listeners = this.eventListeners.get(event);
        if (listeners) {
            const promises = [];
            for (const listener of listeners) {
                try {
                    const result = listener(event, key, value);
                    if (result &&
                        typeof result === "object" &&
                        "then" in result) {
                        promises.push(result);
                    }
                }
                catch (error) {
                    console.error(`Error in SecureObject event listener:`, error);
                }
            }
            if (promises.length > 0) {
                await Promise.allSettled(promises);
            }
        }
    }
    /**
     * Creates a filtered event listener that only triggers for specific keys
     */
    addKeyFilteredListener(event, keys, listener) {
        const filteredListener = (evt, key, value) => {
            if (!key || keys.includes(key)) {
                listener(evt, key, value);
            }
        };
        this.addEventListener(event, filteredListener);
    }
    /**
     * Clears all event listeners (used during destruction)
     */
    clear() {
        this.eventListeners.clear();
    }
    /**
     * Gets debug information about the event system
     */
    getDebugInfo() {
        const eventBreakdown = {};
        for (const [event, listeners] of this.eventListeners.entries()) {
            eventBreakdown[event] = listeners.size;
        }
        return {
            totalEvents: this.eventListeners.size,
            totalListeners: this.getTotalListenerCount(),
            eventBreakdown: eventBreakdown,
        };
    }
}

exports.EventManager = EventManager;
//# sourceMappingURL=event-manager.js.map