@selwise/widget 0.0.3 → 1.0.1

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

@@ -1,973 +0,0 @@
-/**
- * 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