@selwise/widget 0.0.1

package/dist/npm/esm/core/event-batcher.js

@@ -0,0 +1,973 @@
+/**
+ * Event Batcher
+ * Advanced event batching with offline support and retry logic
+ * Now with consent-based event filtering
+ */
+import { generateEventId, resolveApiUrl, sanitizeTrackingMetadata } from '../utils/index.js';
+import { CONSENT_EVENT_CATEGORIES, STORAGE_KEYS } from '../constants.js';
+import { getOrCreateJourneyId, getOrCreateCorrelationId, isJourneyExpired } from '../utils/storage.js';
+import { getIndexedDBQueue } from './indexeddb-queue.js';
+import { testModeLog, testModeWarn, testModeError } from '../utils/logger.js';
+const STORAGE_KEY = 'selwise_event_queue';
+const STORAGE_VERSION = 2;
+export class EventBatcher {
+    constructor(config = {}) {
+        this.queue = [];
+        this.consentQueue = []; // Events waiting for consent
+        this.flushTimeout = null;
+        this.pageHideHandler = null;
+        this.isFlushing = false;
+        // Consent state tracking
+        this.consentChecked = false;
+        this.consentGranted = false;
+        // Enable IndexedDB for consent queue persistence
+        this.useIndexedDBForConsent = true;
+        // Extended config options
+        this.maxRetries = 3;
+        this.maxQueueSize = 100;
+        this.maxStorageEvents = 50;
+        this.debugMode = false;
+        // Deduplication
+        this.processedEvents = new Set();
+        // Correlation tracking for attribution
+        this.lastEventId = null;
+        // Journey sequence counter - tracks position within journey
+        this.journeyEventCount = 0;
+        // Metrics tracking for monitoring
+        this.metrics = {
+            eventsDropped: 0,
+            batchesFailed: 0,
+            sendBeaconFailed: 0,
+            overflowStored: 0,
+        };
+        // Track whether initialization is complete
+        this.initialized = false;
+        this.config = {
+            apiUrl: resolveApiUrl(config.apiUrl),
+            siteKey: config.siteKey || '',
+            batchSize: config.batchSize ?? 50,
+            flushInterval: config.flushInterval ?? 30000, // 30 seconds
+            enablePersistence: config.enablePersistence ?? true,
+            enableSendBeacon: config.enableSendBeacon ?? true,
+        };
+        // Extended config options
+        this.maxRetries = config.maxRetries ?? 3;
+        this.maxQueueSize = config.maxQueueSize ?? 100;
+        this.maxStorageEvents = config.maxStorageEvents ?? 50;
+        this.debugMode = config.debugMode ?? false;
+        // Initialize overflow storage
+        this.overflowStorage = getIndexedDBQueue();
+        // Generate tab-specific correlation ID (prevents multi-tab collisions)
+        this.tabCorrelationId = this.generateTabCorrelationId();
+        this.sessionData = {
+            sessionId: config.sessionId || this.generateSessionId(),
+            visitorId: config.visitorId || this.generateVisitorId(),
+            siteUserId: config.siteUserId,
+        };
+        // Load persisted events from localStorage
+        if (this.config.enablePersistence) {
+            this.loadFromStorage();
+        }
+        // NOTE: loadFromOverflowStorage() is NOT called in constructor
+        // Call initialize() after construction to recover overflow events
+        // Setup page hide handler for send beacon
+        if (this.config.enableSendBeacon) {
+            this.setupPageHideHandler();
+        }
+        // Start periodic cleanup of processed events
+        this.startCleanupInterval();
+        if (this.debugMode) {
+            testModeLog('EventBatcher', 'Initialized with config:', {
+                ...this.config,
+                maxRetries: this.maxRetries,
+                maxQueueSize: this.maxQueueSize,
+                maxStorageEvents: this.maxStorageEvents,
+            });
+        }
+    }
+    /**
+     * Asynchronous initialization - must be called after constructor
+     * This loads events from IndexedDB overflow storage and immediately flushes them
+     *
+     * IMPORTANT: Call this after creating EventBatcher instance
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            // Load overflow events and immediately flush them
+            await this.loadFromOverflowStorage();
+            if (this.queue.length > 0) {
+                if (this.debugMode) {
+                    testModeLog('EventBatcher', 'Flushing', this.queue.length, 'recovered events');
+                }
+                // Trigger immediate flush for recovered events
+                await this.flush();
+            }
+        }
+        catch (error) {
+            if (this.debugMode) {
+                testModeError('EventBatcher', 'Initialization error:', error);
+            }
+        }
+        finally {
+            this.initialized = true;
+        }
+    }
+    /**
+     * Check if the batcher has been initialized
+     */
+    isReady() {
+        return this.initialized;
+    }
+    setSessionData(sessionId, visitorId, siteUserId) {
+        this.sessionData = { sessionId, visitorId, siteUserId };
+    }
+    setSiteKey(siteKey) {
+        this.config.siteKey = siteKey;
+    }
+    /**
+     * Update configuration dynamically (e.g., after fetching from server)
+     */
+    updateConfig(config) {
+        if (config.batchSize !== undefined) {
+            this.config.batchSize = config.batchSize;
+            if (this.debugMode)
+                testModeLog('EventBatcher', 'batchSize updated:', config.batchSize);
+        }
+        if (config.flushInterval !== undefined) {
+            this.config.flushInterval = config.flushInterval;
+            if (this.debugMode)
+                testModeLog('EventBatcher', 'flushInterval updated:', config.flushInterval);
+        }
+        if (config.enablePersistence !== undefined) {
+            this.config.enablePersistence = config.enablePersistence;
+            if (this.debugMode)
+                testModeLog('EventBatcher', 'enablePersistence updated:', config.enablePersistence);
+        }
+        if (config.enableSendBeacon !== undefined) {
+            this.config.enableSendBeacon = config.enableSendBeacon;
+            if (this.debugMode)
+                testModeLog('EventBatcher', 'enableSendBeacon updated:', config.enableSendBeacon);
+        }
+        if (config.maxRetries !== undefined) {
+            this.maxRetries = config.maxRetries;
+            if (this.debugMode)
+                testModeLog('EventBatcher', 'maxRetries updated:', config.maxRetries);
+        }
+        if (config.maxQueueSize !== undefined) {
+            this.maxQueueSize = config.maxQueueSize;
+            if (this.debugMode)
+                testModeLog('EventBatcher', 'maxQueueSize updated:', config.maxQueueSize);
+        }
+        if (config.maxStorageEvents !== undefined) {
+            this.maxStorageEvents = config.maxStorageEvents;
+            if (this.debugMode)
+                testModeLog('EventBatcher', 'maxStorageEvents updated:', config.maxStorageEvents);
+        }
+        if (config.debugMode !== undefined) {
+            this.debugMode = config.debugMode;
+            testModeLog('EventBatcher', 'debugMode updated:', config.debugMode);
+        }
+    }
+    /**
+     * Add an event to the batch queue
+     * Checks consent before adding - queues events if consent pending
+     * Populates correlation fields for attribution tracking
+     */
+    add(event) {
+        const queuedEvent = {
+            ...event,
+            metadata: sanitizeTrackingMetadata(event.metadata),
+        };
+        // Ensure eventId exists for deduplication and parent-child linking
+        if (!queuedEvent.eventId) {
+            queuedEvent.eventId = generateEventId();
+        }
+        // Deduplication check
+        if (this.processedEvents.has(queuedEvent.eventId)) {
+            return; // Skip duplicate
+        }
+        // Add timestamp and retry count
+        queuedEvent.timestamp = queuedEvent.timestamp || Date.now();
+        queuedEvent.eventTs = queuedEvent.eventTs || queuedEvent.timestamp;
+        queuedEvent.eventSchemaVersion = queuedEvent.eventSchemaVersion || 1;
+        queuedEvent.retryCount = queuedEvent.retryCount || 0;
+        // Populate attribution fields with tab-specific correlation
+        // Combine global correlation with tab-specific ID to prevent multi-tab collisions
+        const globalCorrelation = getOrCreateCorrelationId();
+        queuedEvent.correlationId = `${globalCorrelation}_${this.tabCorrelationId}`;
+        queuedEvent.parentEventId = this.lastEventId ?? undefined; // Link to previous event for chain tracking
+        queuedEvent.journeyId = getOrCreateJourneyId();
+        // Store current event as parent for next event
+        this.lastEventId = queuedEvent.eventId;
+        // Check consent if siteKey is available
+        if (this.config.siteKey) {
+            const canSend = this.checkConsentForEvent(queuedEvent);
+            if (!canSend) {
+                // Event requires consent and not yet granted - queue for later
+                this.consentQueue.push(queuedEvent);
+                if (this.debugMode) {
+                    testModeLog('EventBatcher', 'Event queued pending consent:', queuedEvent.name);
+                }
+                return;
+            }
+        }
+        // Check if queue is at capacity - use overflow storage instead of dropping
+        if (this.queue.length >= this.maxQueueSize) {
+            this.storeInOverflow([queuedEvent]);
+            return;
+        }
+        // Consent granted or event is necessary - add to main queue
+        this.queue.push(queuedEvent);
+        this.processedEvents.add(queuedEvent.eventId);
+        // Persist to localStorage
+        if (this.config.enablePersistence) {
+            this.saveToStorage();
+        }
+        // Check if we should flush
+        if (this.queue.length >= this.config.batchSize) {
+            this.flush();
+        }
+        else {
+            this.scheduleFlush();
+        }
+    }
+    /**
+     * Check if an event can be sent based on current consent state
+     */
+    checkConsentForEvent(event) {
+        const eventName = event.name;
+        // Find which category this event belongs to
+        // Check each category individually
+        const categories = Object.keys(CONSENT_EVENT_CATEGORIES);
+        for (const category of categories) {
+            const events = CONSENT_EVENT_CATEGORIES[category];
+            if (events.indexOf(eventName) >= 0) {
+                // Found the category - check consent
+                try {
+                    const key = `${STORAGE_KEYS.CONSENT}_${this.config.siteKey}`;
+                    const data = localStorage.getItem(key);
+                    if (data) {
+                        const state = JSON.parse(data);
+                        // Check if consent was granted for this category
+                        return state.categories?.[category] ?? false;
+                    }
+                }
+                catch { }
+                // No consent given yet - queue the event
+                return false;
+            }
+        }
+        // Event not in any category - considered necessary (always allowed)
+        return true;
+    }
+    /**
+     * Schedule a flush after the configured interval
+     */
+    scheduleFlush() {
+        if (this.flushTimeout) {
+            clearTimeout(this.flushTimeout);
+        }
+        this.flushTimeout = window.setTimeout(() => {
+            this.flush();
+        }, this.config.flushInterval);
+    }
+    /**
+     * Flush all queued events to the server
+     */
+    async flush() {
+        if (this.isFlushing || this.queue.length === 0) {
+            return;
+        }
+        if (!this.config.siteKey) {
+            // No siteKey configured; drop events
+            this.queue = [];
+            this.saveToStorage();
+            return;
+        }
+        this.isFlushing = true;
+        const events = this.queue.splice(0);
+        try {
+            const success = await this.sendBatch(events);
+            if (success) {
+                // Clear processed events cache for sent events
+                events.forEach(e => this.processedEvents.delete(e.eventId));
+            }
+            else {
+                // Re-queue with retry logic
+                this.requeueEvents(events);
+            }
+        }
+        catch (error) {
+            // Re-queue on error
+            this.requeueEvents(events);
+        }
+        finally {
+            this.isFlushing = false;
+            this.saveToStorage();
+        }
+    }
+    /**
+     * Send batch to server
+     * Returns true if successful, false otherwise
+     * Only increments journey counter on confirmed success
+     */
+    async sendBatch(events) {
+        // Check if journey has expired - reset counter if so
+        if (isJourneyExpired()) {
+            this.journeyEventCount = 0;
+        }
+        // Calculate sequence numbers BEFORE sending (assign temporarily)
+        // These will only be committed if the send succeeds
+        const sequences = events.map((_, index) => this.journeyEventCount + index + 1);
+        // Add journey sequence to each event
+        const eventsWithSequence = events.map((event, index) => ({
+            ...event,
+            eventSchemaVersion: event.eventSchemaVersion || 1,
+            eventTs: event.eventTs || event.timestamp || Date.now(),
+            metadata: sanitizeTrackingMetadata(event.metadata),
+            journeySequence: sequences[index],
+        }));
+        const payload = {
+            sessionId: this.sessionData.sessionId,
+            visitorId: this.sessionData.visitorId,
+            journeyId: getOrCreateJourneyId(),
+            siteUserId: this.sessionData.siteUserId,
+            pageUrl: window.location.href,
+            referrer: document.referrer || undefined,
+            events: eventsWithSequence,
+        };
+        try {
+            const response = await fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/events/batch`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                keepalive: true,
+            });
+            const success = response.ok;
+            // Only update counter AFTER confirmed success
+            if (success) {
+                this.journeyEventCount += events.length;
+            }
+            else {
+                this.metrics.batchesFailed++;
+                this.reportMetric('batch_failure', 1);
+            }
+            return success;
+        }
+        catch (error) {
+            this.metrics.batchesFailed++;
+            this.reportMetric('batch_failure', 1);
+            return false;
+        }
+    }
+    /**
+     * Re-queue events with exponential backoff
+     * Uses overflow storage instead of dropping events when queue is full
+     */
+    requeueEvents(events) {
+        for (const event of events) {
+            event.retryCount = (event.retryCount || 0) + 1;
+            // Use configured max retry count
+            if (event.retryCount <= this.maxRetries) {
+                // Check if queue has space
+                if (this.queue.length < this.maxQueueSize) {
+                    this.queue.push(event);
+                }
+                else {
+                    // Store in overflow instead of dropping
+                    this.storeInOverflow([event]);
+                }
+            }
+            else {
+                // Events exceeding max retries
+                if (this.debugMode) {
+                    testModeLog('EventBatcher', 'Dropped event after', this.maxRetries, 'retries:', event.eventId);
+                }
+                this.metrics.eventsDropped++;
+            }
+        }
+        // Sort by timestamp and retry count (oldest, least retried first)
+        this.queue.sort((a, b) => {
+            const aRetryCount = a.retryCount || 0;
+            const bRetryCount = b.retryCount || 0;
+            if (aRetryCount !== bRetryCount) {
+                return aRetryCount - bRetryCount;
+            }
+            return a.timestamp - b.timestamp;
+        });
+    }
+    /**
+     * Setup page hide handler for send beacon
+     *
+     * KNOWN LIMITATION: sendBeacon doesn't provide success/failure feedback.
+     * - The browser returns true if it accepted the payload, NOT if server received it
+     * - Network failures after browser acceptance are undetectable
+     * - Journey sequence counter is NOT incremented (see persistPendingJourneyIncrement)
+     * - Sequence numbers from sendBeacon may not match actual server-side sequences
+     *
+     * This is a fundamental limitation of the sendBeacon API with no workaround.
+     */
+    setupPageHideHandler() {
+        this.pageHideHandler = () => {
+            if (this.queue.length === 0 || !this.config.siteKey) {
+                return;
+            }
+            const events = this.queue.splice(0);
+            // Calculate sequence numbers
+            const sequences = events.map((_, index) => this.journeyEventCount + index + 1);
+            // Add journey sequence to each event
+            const eventsWithSequence = events.map((event, index) => ({
+                ...event,
+                eventSchemaVersion: event.eventSchemaVersion || 1,
+                eventTs: event.eventTs || event.timestamp || Date.now(),
+                metadata: sanitizeTrackingMetadata(event.metadata),
+                journeySequence: sequences[index],
+            }));
+            const payload = {
+                sessionId: this.sessionData.sessionId,
+                visitorId: this.sessionData.visitorId,
+                journeyId: getOrCreateJourneyId(),
+                siteUserId: this.sessionData.siteUserId,
+                pageUrl: window.location.href,
+                referrer: document.referrer || undefined,
+                events: eventsWithSequence,
+            };
+            // Use sendBeacon for reliable delivery on page unload
+            const data = new Blob([JSON.stringify(payload)], { type: 'application/json' });
+            if (navigator.sendBeacon) {
+                const sent = navigator.sendBeacon(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/events/batch`, data);
+                if (sent) {
+                    // sendBeacon accepted the payload (browser will queue it)
+                    // Persist the counter state to localStorage for recovery
+                    // The actual increment will happen when we can verify
+                    this.persistPendingJourneyIncrement(events.length);
+                }
+                else {
+                    // sendBeacon rejected (queue full, etc.)
+                    this.metrics.sendBeaconFailed++;
+                    this.reportMetric('sendBeacon_failure', 1);
+                    // Re-queue events
+                    this.queue.push(...events);
+                }
+            }
+            else {
+                // sendBeacon not available, re-queue
+                this.queue.push(...events);
+            }
+        };
+        // Listen for page hide events
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                this.pageHideHandler?.();
+            }
+        });
+        // Also listen for beforeunload
+        window.addEventListener('beforeunload', () => {
+            this.pageHideHandler?.();
+        });
+    }
+    /**
+     * Persist pending journey counter increment to localStorage
+     *
+     * KNOWN LIMITATION: sendBeacon doesn't provide success/failure feedback.
+     * The browser queues the request but we can't know if it reached the server.
+     *
+     * We do NOT increment the journey counter here because:
+     * 1. sendBeacon may fail silently (network, server error, queue full)
+     * 2. Counter increment would cause permanent gaps in sequence numbers
+     * 3. There's no server validation endpoint to confirm receipt
+     *
+     * Consequence: On page hide, journey sequence numbers may not match
+     * server-side sequences. This is accepted as a known limitation of
+     * the sendBeacon API.
+     */
+    persistPendingJourneyIncrement(count) {
+        try {
+            const state = {
+                count,
+                timestamp: Date.now(),
+                journeyId: getOrCreateJourneyId(),
+            };
+            localStorage.setItem('selwise_pending_journey_increment', JSON.stringify(state));
+            // NOTE: We do NOT increment journeyEventCount here
+            // The counter is only incremented after confirmed success in sendBatch()
+            // This means sendBeacon events will have sequence numbers that don't
+            // match the actual counter, but this is unavoidable without server validation
+        }
+        catch {
+            // Silently fail
+        }
+    }
+    /**
+     * Check and recover pending journey increment on initialization
+     * If server confirmed receipt, the increment is valid
+     * Otherwise we need to roll back
+     */
+    async recoverPendingJourneyIncrement() {
+        try {
+            const stored = localStorage.getItem('selwise_pending_journey_increment');
+            if (!stored) {
+                return;
+            }
+            const state = JSON.parse(stored);
+            const age = Date.now() - state.timestamp;
+            // If older than 5 minutes, assume it was processed or is stale
+            if (age > 5 * 60 * 1000) {
+                localStorage.removeItem('selwise_pending_journey_increment');
+                return;
+            }
+            // Check with server if these events were received
+            // For now, we'll just clear it after 5 minutes
+            // In a production system, you'd have an endpoint to validate
+            localStorage.removeItem('selwise_pending_journey_increment');
+        }
+        catch {
+            localStorage.removeItem('selwise_pending_journey_increment');
+        }
+    }
+    /**
+     * Save queue to localStorage for offline persistence
+     * Includes quota checking to prevent quota exhaustion DoS
+     */
+    saveToStorage() {
+        if (!this.config.enablePersistence)
+            return;
+        try {
+            // Check storage quota before saving to prevent quota exhaustion
+            if (!this.checkStorageQuota()) {
+                if (this.debugMode) {
+                    testModeLog('EventBatcher', 'Storage quota exceeded, skipping save');
+                }
+                return;
+            }
+            const stored = {
+                version: STORAGE_VERSION,
+                queue: this.queue.slice(0, this.maxStorageEvents),
+                timestamp: Date.now(),
+            };
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+            if (this.debugMode) {
+                testModeLog('EventBatcher', 'Saved', stored.queue.length, 'events to storage');
+            }
+        }
+        catch (e) {
+            if (this.debugMode) {
+                testModeLog('EventBatcher', 'Failed to save to storage:', e);
+            }
+        }
+    }
+    /**
+     * Check if we have enough storage quota for Selwise data
+     * Returns false if quota would be exceeded (prevents DoS via quota exhaustion)
+     */
+    checkStorageQuota() {
+        try {
+            // Maximum storage quota for Selwise (2MB)
+            const SELWISE_QUOTA = 2 * 1024 * 1024;
+            // Calculate current Selwise storage usage
+            let totalUsage = 0;
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key && key.startsWith('selwise_')) {
+                    const value = localStorage.getItem(key);
+                    if (value) {
+                        totalUsage += key.length + value.length;
+                    }
+                }
+            }
+            // Estimate the size of data we're about to save
+            const estimatedSize = JSON.stringify({
+                version: STORAGE_VERSION,
+                queue: this.queue.slice(0, this.maxStorageEvents),
+                timestamp: Date.now(),
+            }).length;
+            // Check if we'd exceed quota
+            if (totalUsage + estimatedSize > SELWISE_QUOTA) {
+                // Try cleanup first
+                this.cleanupOldStorage();
+                // Recalculate after cleanup
+                let newUsage = 0;
+                for (let i = 0; i < localStorage.length; i++) {
+                    const key = localStorage.key(i);
+                    if (key && key.startsWith('selwise_')) {
+                        const value = localStorage.getItem(key);
+                        if (value) {
+                            newUsage += key.length + value.length;
+                        }
+                    }
+                }
+                return (newUsage + estimatedSize) <= SELWISE_QUOTA;
+            }
+            return true;
+        }
+        catch {
+            // If we can't check, assume OK
+            return true;
+        }
+    }
+    /**
+     * Cleanup old Selwise storage items to free up quota
+     */
+    cleanupOldStorage() {
+        try {
+            // Clean up expired journey state
+            const journeyKey = 'selwise_journey_state';
+            const journeyData = localStorage.getItem(journeyKey);
+            if (journeyData) {
+                try {
+                    const journey = JSON.parse(journeyData);
+                    const JOURNEY_TIMEOUT = 30 * 60 * 1000; // 30 minutes
+                    if (journey.lastEventTime && (Date.now() - journey.lastEventTime) > JOURNEY_TIMEOUT) {
+                        localStorage.removeItem(journeyKey);
+                        if (this.debugMode) {
+                            testModeLog('EventBatcher', 'Cleaned up expired journey state');
+                        }
+                    }
+                }
+                catch {
+                    localStorage.removeItem(journeyKey);
+                }
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    /**
+     * Load queue from localStorage
+     */
+    loadFromStorage() {
+        try {
+            const stored = localStorage.getItem(STORAGE_KEY);
+            if (!stored)
+                return;
+            const parsed = JSON.parse(stored);
+            // Check version compatibility
+            if (parsed.version === STORAGE_VERSION && Array.isArray(parsed.queue)) {
+                // Filter out events older than 24 hours
+                const cutoffTime = Date.now() - (24 * 60 * 60 * 1000);
+                this.queue = parsed.queue
+                    .filter(e => e.timestamp > cutoffTime)
+                    .map((event) => ({
+                    ...event,
+                    metadata: sanitizeTrackingMetadata(event.metadata),
+                }));
+            }
+            // Clear storage after loading
+            localStorage.removeItem(STORAGE_KEY);
+        }
+        catch {
+            // Invalid storage, clear it
+            localStorage.removeItem(STORAGE_KEY);
+        }
+    }
+    /**
+     * Get queue size
+     */
+    getQueueSize() {
+        return this.queue.length;
+    }
+    /**
+     * Get processed events count
+     */
+    getProcessedCount() {
+        return this.processedEvents.size;
+    }
+    /**
+     * Clear all queued events
+     */
+    clear() {
+        this.queue = [];
+        this.consentQueue = []; // Also clear consent queue
+        this.processedEvents.clear();
+        if (this.flushTimeout) {
+            clearTimeout(this.flushTimeout);
+            this.flushTimeout = null;
+        }
+        if (this.config.enablePersistence) {
+            localStorage.removeItem(STORAGE_KEY);
+        }
+    }
+    /**
+     * Reset correlation tracking for new attribution journey
+     * Call this after a conversion event to start fresh attribution
+     */
+    resetCorrelation() {
+        this.lastEventId = null;
+        if (this.debugMode) {
+            testModeLog('EventBatcher', 'Correlation tracking reset');
+        }
+    }
+    /**
+     * Get consent queue size
+     */
+    getConsentQueueSize() {
+        return this.consentQueue.length;
+    }
+    /**
+     * Flush consent queue - called when user grants consent
+     * Re-evaluates each queued event and adds to main queue if consented
+     */
+    flushConsentQueue() {
+        if (this.consentQueue.length === 0) {
+            return;
+        }
+        if (this.debugMode) {
+            testModeLog('EventBatcher', 'Flushing consent queue:', this.consentQueue.length, 'events');
+        }
+        // Process each queued event
+        const eventsToFlush = this.consentQueue.splice(0);
+        for (const event of eventsToFlush) {
+            // Re-check consent for each event
+            const canSend = this.checkConsentForEvent(event);
+            if (canSend) {
+                // Add to main queue for sending
+                this.queue.push(event);
+                this.processedEvents.add(event.eventId);
+            }
+            else {
+                // Still no consent for this category - keep in consent queue
+                this.consentQueue.push(event);
+            }
+        }
+        // Save state and schedule flush if events were added
+        if (this.queue.length > 0) {
+            if (this.config.enablePersistence) {
+                this.saveToStorage();
+            }
+            // Check if we should flush immediately
+            if (this.queue.length >= this.config.batchSize) {
+                this.flush();
+            }
+            else {
+                this.scheduleFlush();
+            }
+        }
+        if (this.debugMode) {
+            testModeLog('EventBatcher', 'Consent queue flushed. Main queue:', this.queue.length, 'Remaining consent queue:', this.consentQueue.length);
+        }
+    }
+    /**
+     * Cleanup
+     */
+    destroy() {
+        this.clear();
+        // Clear cleanup interval
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        if (this.pageHideHandler) {
+            document.removeEventListener('visibilitychange', this.pageHideHandler);
+            window.removeEventListener('beforeunload', this.pageHideHandler);
+            this.pageHideHandler = null;
+        }
+    }
+    /**
+     * Start periodic cleanup of processed events set
+     */
+    startCleanupInterval() {
+        // Cleanup every 5 minutes to prevent memory growth
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupProcessedEvents();
+        }, 5 * 60 * 1000);
+        if (this.debugMode) {
+            testModeLog('EventBatcher', 'Cleanup interval started');
+        }
+    }
+    /**
+     * Cleanup old processed event IDs to prevent memory growth
+     *
+     * NOTE: After 10000 events, old event IDs can be re-sent and may create duplicates.
+     * This is a known limitation - the deduplication Set is kept to a reasonable size
+     * to prevent memory issues while still providing good duplicate detection for
+     * typical user sessions.
+     *
+     * Server-side deduplication cache provides additional protection.
+     */
+    cleanupProcessedEvents() {
+        // More aggressive cleanup - keep only last 5000 event IDs (reduced from 10000)
+        // This provides better memory management for long-running sessions
+        if (this.processedEvents.size > 5000) {
+            const entries = Array.from(this.processedEvents);
+            this.processedEvents = new Set(entries.slice(-5000));
+            if (this.debugMode) {
+                testModeLog('EventBatcher', 'Cleaned up processed events, kept last 5000');
+            }
+        }
+        // Also cleanup consent queue if it gets too large
+        if (this.consentQueue.length > 100) {
+            // Remove oldest consent-pending events (they likely expired)
+            this.consentQueue = this.consentQueue.slice(-50);
+            if (this.debugMode) {
+                testModeLog('EventBatcher', 'Cleaned up consent queue, kept last 50');
+            }
+        }
+    }
+    generateSessionId() {
+        return `sess_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+    }
+    generateVisitorId() {
+        let visitorId = null;
+        try {
+            visitorId = localStorage.getItem('selwise_visitor_id');
+            if (!visitorId) {
+                visitorId = `vis_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+                localStorage.setItem('selwise_visitor_id', visitorId);
+            }
+        }
+        catch {
+            visitorId = `vis_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+        }
+        return visitorId;
+    }
+    /**
+     * Generate tab-specific correlation ID
+     * This prevents correlation ID collisions between multiple tabs
+     */
+    generateTabCorrelationId() {
+        // Use a random string for tab identification
+        return `tab_${Math.random().toString(36).substring(2, 11)}`;
+    }
+    /**
+     * Store events in IndexedDB overflow storage
+     * Non-blocking - errors are logged but don't throw
+     */
+    storeInOverflow(events) {
+        this.overflowStorage.store(events).then(() => {
+            this.metrics.overflowStored += events.length;
+            if (this.debugMode) {
+                testModeLog('EventBatcher', 'Stored', events.length, 'events in overflow storage');
+            }
+        }).catch(() => {
+            // Silently fail - overflow storage is best-effort
+            this.metrics.eventsDropped += events.length;
+            if (this.debugMode) {
+                testModeWarn('EventBatcher', 'Overflow storage unavailable, dropped', events.length, 'events');
+            }
+        });
+    }
+    /**
+     * Load events from IndexedDB overflow storage
+     * Called during initialization to recover persisted events
+     */
+    async loadFromOverflowStorage() {
+        if (!this.overflowStorage.isAvailable()) {
+            return;
+        }
+        try {
+            const events = await this.overflowStorage.retrieve(this.maxQueueSize);
+            if (events.length > 0) {
+                if (this.debugMode) {
+                    testModeLog('EventBatcher', 'Loaded', events.length, 'events from overflow storage');
+                }
+                // Add events to queue (up to max queue size)
+                for (const event of events) {
+                    if (this.queue.length < this.maxQueueSize) {
+                        // Re-assign journey sequence on recovery
+                        this.queue.push({
+                            ...event,
+                            metadata: sanitizeTrackingMetadata(event.metadata),
+                        });
+                    }
+                    else {
+                        // Queue full, remaining events stay in overflow
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (this.debugMode) {
+                testModeError('EventBatcher', 'Failed to load overflow storage:', error);
+            }
+        }
+    }
+    /**
+     * Get metrics for monitoring
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            queueSize: this.queue.length,
+            processedCount: this.processedEvents.size,
+            consentQueueSize: this.consentQueue.length,
+            overflowStats: {
+                count: 0, // Will be populated asynchronously
+                oldestTimestamp: null,
+            },
+        };
+    }
+    /**
+     * Get overflow storage stats (async)
+     */
+    async getOverflowStats() {
+        return this.overflowStorage.getStats();
+    }
+    /**
+     * Report metric to monitoring endpoint
+     * Non-blocking - failures are ignored
+     */
+    reportMetric(name, value) {
+        if (!this.config.siteKey) {
+            return;
+        }
+        const url = `${this.config.apiUrl}/public/sites/${this.config.siteKey}/metrics`;
+        // Use sendBeacon if available for non-blocking delivery
+        if (navigator.sendBeacon) {
+            const data = new Blob([JSON.stringify({ name, value, timestamp: Date.now() })], { type: 'application/json' });
+            navigator.sendBeacon(url, data);
+        }
+        else {
+            // Fallback to fetch with keepalive
+            fetch(url, {
+                method: 'POST',
+                body: JSON.stringify({ name, value, timestamp: Date.now() }),
+                keepalive: true,
+            }).catch(() => {
+                // Ignore failures
+            });
+        }
+    }
+    /**
+     * Send all accumulated metrics to monitoring endpoint
+     */
+    async flushMetrics() {
+        if (!this.config.siteKey) {
+            return;
+        }
+        const metrics = await this.getOverflowStats();
+        const payload = {
+            metrics: {
+                eventsDropped: this.metrics.eventsDropped,
+                batchesFailed: this.metrics.batchesFailed,
+                sendBeaconFailed: this.metrics.sendBeaconFailed,
+                overflowStored: this.metrics.overflowStored,
+                overflowCount: metrics.count,
+            },
+            timestamp: Date.now(),
+        };
+        try {
+            await fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/metrics`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                keepalive: true,
+            });
+            // Reset metrics after successful send
+            this.metrics = {
+                eventsDropped: 0,
+                batchesFailed: 0,
+                sendBeaconFailed: 0,
+                overflowStored: 0,
+            };
+        }
+        catch {
+            // Silently fail - metrics are best-effort
+        }
+    }
+}
+//# sourceMappingURL=event-batcher.js.map