vlibras-player-webjs/dist/esm/infrastructure/events/VLibrasEvents.js

Biblioteca JavaScript moderna para integração do VLibras Player com React, Vue, Angular e vanilla JS

/**
 * Sistema de eventos padronizado e type-safe para VLibras Player
 * Fornece eventos detalhados sobre o ciclo de vida do player
 */
/**
 * Event Emitter type-safe para VLibras
 */
export class VLibrasEventEmitter {
    constructor() {
        this.listeners = new Map();
        this.onceListeners = new Map();
    }
    /**
     * Adiciona um listener para um evento específico
     */
    on(event, listener) {
        if (!this.listeners.has(event)) {
            this.listeners.set(event, []);
        }
        this.listeners.get(event).push(listener);
        // Retorna função para remover o listener
        return () => this.off(event, listener);
    }
    /**
     * Adiciona um listener que será executado apenas uma vez
     */
    once(event, listener) {
        if (!this.onceListeners.has(event)) {
            this.onceListeners.set(event, []);
        }
        this.onceListeners.get(event).push(listener);
        return () => this.off(event, listener);
    }
    /**
     * Remove um listener específico
     */
    off(event, listener) {
        // Remove from regular listeners
        const regularListeners = this.listeners.get(event);
        if (regularListeners) {
            const index = regularListeners.indexOf(listener);
            if (index !== -1) {
                regularListeners.splice(index, 1);
            }
        }
        // Remove from once listeners
        const onceListeners = this.onceListeners.get(event);
        if (onceListeners) {
            const index = onceListeners.indexOf(listener);
            if (index !== -1) {
                onceListeners.splice(index, 1);
            }
        }
    }
    /**
     * Emite um evento para todos os listeners
     */
    emit(event, data) {
        // Emit to regular listeners
        const regularListeners = this.listeners.get(event);
        if (regularListeners) {
            regularListeners.forEach(listener => {
                try {
                    listener(data);
                }
                catch (error) {
                    console.error(`Erro no listener do evento ${event}:`, error);
                }
            });
        }
        // Emit to once listeners and remove them
        const onceListeners = this.onceListeners.get(event);
        if (onceListeners) {
            onceListeners.forEach(listener => {
                try {
                    listener(data);
                }
                catch (error) {
                    console.error(`Erro no listener once do evento ${event}:`, error);
                }
            });
            this.onceListeners.set(event, []); // Clear once listeners
        }
    }
    /**
     * Remove todos os listeners de um evento ou de todos os eventos
     */
    removeAllListeners(event) {
        if (event) {
            this.listeners.delete(event);
            this.onceListeners.delete(event);
        }
        else {
            this.listeners.clear();
            this.onceListeners.clear();
        }
    }
    /**
     * Retorna o número de listeners para um evento
     */
    listenerCount(event) {
        const regular = this.listeners.get(event)?.length || 0;
        const once = this.onceListeners.get(event)?.length || 0;
        return regular + once;
    }
    /**
     * Retorna todos os eventos que têm listeners
     */
    eventNames() {
        const events = new Set();
        for (const event of this.listeners.keys()) {
            events.add(event);
        }
        for (const event of this.onceListeners.keys()) {
            events.add(event);
        }
        return Array.from(events);
    }
}
/**
 * Utilitários para eventos
 */
export class VLibrasEventUtils {
    /**
     * Cria um timestamp padronizado
     */
    static createTimestamp() {
        return Date.now();
    }
    /**
     * Aguarda por um evento específico
     */
    static waitForEvent(emitter, event, timeout = 5000) {
        return new Promise((resolve, reject) => {
            const timer = setTimeout(() => {
                reject(new Error(`Timeout aguardando evento ${event}`));
            }, timeout);
            const cleanup = emitter.once(event, (data) => {
                clearTimeout(timer);
                resolve(data);
            });
            // Se o timeout acontecer, remove o listener
            setTimeout(() => {
                if (timer) {
                    cleanup();
                }
            }, timeout);
        });
    }
    /**
     * Debounce para eventos frequentes
     */
    static debounceEvent(emitter, event, callback, delay = 300) {
        let timeoutId = null;
        let lastData = null;
        const cleanup = emitter.on(event, (data) => {
            lastData = data;
            if (timeoutId) {
                clearTimeout(timeoutId);
            }
            timeoutId = setTimeout(() => {
                if (lastData) {
                    callback(lastData);
                    lastData = null;
                }
            }, delay);
        });
        return () => {
            if (timeoutId) {
                clearTimeout(timeoutId);
            }
            cleanup();
        };
    }
}
// Instância global de eventos
export const globalEventEmitter = new VLibrasEventEmitter();
//# sourceMappingURL=VLibrasEvents.js.map