@selwise/widget 0.0.3 → 1.0.1

package/dist/npm/cjs/core/tracker.js

@@ -1,798 +0,0 @@
-"use strict";
-/**
- * Event Tracker
- * Comprehensive tracking for impressions, clicks, views, and conversions
- *
- * Now with optional EventBatcher for advanced batching capabilities:
- * - Configurable batch size (default: 50 events)
- * - Configurable flush interval (default: 30 seconds)
- * - Page hide/send beacon support
- * - Offline persistence (localStorage)
- * - Event deduplication
- * - Retry logic with exponential backoff
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tracker = void 0;
-const utils_1 = require("../utils");
-const constants_1 = require("../constants");
-const event_batcher_1 = require("./event-batcher");
-const logger_1 = require("../utils/logger");
-class Tracker {
-    constructor(apiUrl = (0, utils_1.resolveApiUrl)(), siteKey = '', batchingConfig) {
-        this.queue = [];
-        this.flushTimeout = null;
-        this.viewObservers = new Map();
-        this.viewedElements = new Set();
-        this.hoverStartTimes = new Map();
-        this.useAdvancedBatching = false;
-        // SPA cleanup flag
-        this.spaCleanupSetup = false;
-        this.apiUrl = apiUrl;
-        this.siteKey = siteKey;
-        this.sessionId = (0, utils_1.getOrCreateSessionId)();
-        this.visitorId = (0, utils_1.getOrCreateVisitorId)();
-        this.siteUserId = (0, utils_1.getStoredSiteUserId)();
-        // Initialize EventBatcher if enabled
-        if (batchingConfig?.enabled !== false && batchingConfig) {
-            this.useAdvancedBatching = true;
-            this.batcher = new event_batcher_1.EventBatcher({
-                ...batchingConfig,
-                apiUrl: this.apiUrl,
-                siteKey: this.siteKey,
-                sessionId: this.sessionId,
-                visitorId: this.visitorId,
-                siteUserId: this.siteUserId,
-            });
-        }
-        // Setup SPA navigation cleanup (lazy - only once)
-        // This is called lazily to avoid overriding history methods before the app is ready
-    }
-    /**
-     * Enable SPA cleanup (call this if your app uses client-side routing)
-     * This should be called once during initialization
-     */
-    enableSPACleanup() {
-        if (!this.spaCleanupSetup) {
-            this.setupSPACleanup();
-            this.spaCleanupSetup = true;
-        }
-    }
-    setSiteKey(siteKey) {
-        this.siteKey = siteKey;
-        if (this.batcher) {
-            this.batcher.setSiteKey(siteKey);
-        }
-    }
-    /**
-     * Configure or enable advanced batching
-     * Can be called to update configuration dynamically after fetching from server
-     */
-    setBatcherConfig(config) {
-        if (config.enabled === false) {
-            // Disable advanced batching
-            this.useAdvancedBatching = false;
-            this.batcher?.destroy();
-            this.batcher = undefined;
-            return;
-        }
-        // Enable advanced batching if not already enabled
-        if (config.enabled === true && !this.useAdvancedBatching) {
-            this.useAdvancedBatching = true;
-        }
-        if (!this.batcher) {
-            // Create new batcher with full config
-            this.batcher = new event_batcher_1.EventBatcher({
-                ...config,
-                apiUrl: this.apiUrl,
-                siteKey: this.siteKey,
-                sessionId: this.sessionId,
-                visitorId: this.visitorId,
-                siteUserId: this.siteUserId,
-            });
-            this.useAdvancedBatching = true;
-        }
-        else {
-            // Update existing batcher configuration
-            this.batcher.updateConfig(config);
-        }
-    }
-    setSiteUserId(siteUserId) {
-        this.siteUserId = siteUserId;
-        (0, utils_1.setSiteUserId)(siteUserId);
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-    getVisitorId() {
-        return this.visitorId;
-    }
-    getSiteUserId() {
-        return this.siteUserId;
-    }
-    /**
-     * Get the current journey ID
-     * Returns the active journey ID or null if no journey is active
-     */
-    getJourneyId() {
-        try {
-            const journeyId = localStorage.getItem(constants_1.STORAGE_KEYS.JOURNEY_ID);
-            const createdStr = localStorage.getItem(constants_1.STORAGE_KEYS.JOURNEY_CREATED);
-            if (journeyId && createdStr) {
-                const created = parseInt(createdStr, 10);
-                const age = Date.now() - created;
-                // Journey is valid for 30 minutes
-                if (age < 30 * 60 * 1000) {
-                    return journeyId;
-                }
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * End the current journey
-     * Clears the journey ID and starts a new one on next event
-     */
-    endJourney() {
-        try {
-            localStorage.removeItem(constants_1.STORAGE_KEYS.JOURNEY_ID);
-            localStorage.removeItem(constants_1.STORAGE_KEYS.JOURNEY_CREATED);
-        }
-        catch {
-            // Ignore storage errors
-        }
-    }
-    /**
-     * Get the journey state for debugging
-     */
-    getJourneyState() {
-        try {
-            const journeyId = localStorage.getItem(constants_1.STORAGE_KEYS.JOURNEY_ID);
-            const createdStr = localStorage.getItem(constants_1.STORAGE_KEYS.JOURNEY_CREATED);
-            if (!journeyId || !createdStr) {
-                return { journeyId: null, age: null, isValid: false };
-            }
-            const created = parseInt(createdStr, 10);
-            const age = Date.now() - created;
-            const isValid = age < 30 * 60 * 1000; // 30 minutes
-            return { journeyId, age, isValid };
-        }
-        catch {
-            return { journeyId: null, age: null, isValid: false };
-        }
-    }
-    /**
-     * Get the internal SiteUser profile ID (UUID) for segment evaluation
-     * This is set after identify() and persists for merged behavior lookup
-     */
-    getSiteUserProfileId() {
-        try {
-            return localStorage.getItem(constants_1.STORAGE_KEYS.SITE_USER_PROFILE_ID) || undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * Identify a user and merge anonymous visitor data
-     * Calls the backend API to perform identity merge
-     */
-    async identify(userId, metadata) {
-        const previousId = this.siteUserId;
-        this.setSiteUserId(userId);
-        // Update batcher with new siteUserId
-        if (this.batcher) {
-            this.batcher.setSessionData(this.sessionId, this.visitorId, userId);
-        }
-        // Try to call backend API for identity merge
-        try {
-            const response = await fetch(`${this.apiUrl}/public/sites/${this.siteKey}/users/identify`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    externalId: userId,
-                    visitorId: this.visitorId,
-                    sessionId: this.sessionId,
-                    traits: metadata,
-                    pageUrl: window.location.href,
-                    userAgent: navigator.userAgent,
-                }),
-                keepalive: true,
-            });
-            if (response.ok) {
-                const result = await response.json();
-                // Track merged visitor IDs for cross-reference
-                if (result.merged || result.aliases) {
-                    this.updateMergedVisitorIds(result.aliases || [this.visitorId]);
-                }
-                // Store the internal SiteUser profile ID (UUID) for segment evaluation
-                // This allows finding merged behaviors even after localStorage is cleared
-                if (result.user?.id) {
-                    try {
-                        localStorage.setItem(constants_1.STORAGE_KEYS.SITE_USER_PROFILE_ID, result.user.id);
-                    }
-                    catch {
-                        // Ignore storage errors
-                    }
-                }
-                // Track identify event after successful merge
-                if (previousId !== userId || result.merged) {
-                    this.track('identify', {
-                        entityType: 'user',
-                        entityId: userId,
-                        metadata: {
-                            ...metadata,
-                            previousId,
-                            visitorId: this.visitorId,
-                            merged: result.merged,
-                        },
-                    });
-                }
-                return { success: true, merged: result.merged };
-            }
-        }
-        catch (error) {
-            // Fallback to local tracking only
-            (0, logger_1.testModeDebug)('Selwise', 'Identity merge API call failed, using local tracking:', error);
-        }
-        // Fallback: track locally if API call fails
-        if (previousId !== userId) {
-            this.track('identify', {
-                entityType: 'user',
-                entityId: userId,
-                metadata: {
-                    ...metadata,
-                    previousId,
-                    visitorId: this.visitorId,
-                    merged: false,
-                },
-            });
-        }
-        return { success: false, merged: false };
-    }
-    /**
-     * Set user traits without changing identity
-     * Calls the backend API to update user attributes
-     */
-    async setTraits(traits) {
-        if (!this.siteKey)
-            return false;
-        // Cache traits locally
-        try {
-            const cached = JSON.parse(localStorage.getItem(constants_1.STORAGE_KEYS.USER_TRAITS) || '{}');
-            // Validate that cached data is an object
-            if (cached && typeof cached === 'object' && !Array.isArray(cached)) {
-                localStorage.setItem(constants_1.STORAGE_KEYS.USER_TRAITS, JSON.stringify({ ...cached, ...traits }));
-            }
-            else {
-                // Data corrupted, start fresh
-                localStorage.setItem(constants_1.STORAGE_KEYS.USER_TRAITS, JSON.stringify(traits));
-            }
-        }
-        catch (e) {
-            (0, logger_1.testModeDebug)('Selwise', 'Failed to cache traits:', e);
-        }
-        // Try to call backend API
-        try {
-            const response = await fetch(`${this.apiUrl}/public/sites/${this.siteKey}/users/traits`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    externalId: this.siteUserId,
-                    visitorId: !this.siteUserId ? this.visitorId : undefined,
-                    traits,
-                }),
-                keepalive: true,
-            });
-            if (response.ok) {
-                const result = await response.json();
-                return result.success === true;
-            }
-        }
-        catch (error) {
-            (0, logger_1.testModeDebug)('Selwise', 'Set traits API call failed:', error);
-        }
-        return false;
-    }
-    /**
-     * Track merged visitor IDs for cross-device reference
-     */
-    updateMergedVisitorIds(visitorIds) {
-        try {
-            const stored = JSON.parse(localStorage.getItem(constants_1.STORAGE_KEYS.MERGED_VISITOR_IDS) || '[]');
-            // Validate that parsed data is an array
-            if (Array.isArray(stored)) {
-                const merged = new Set([...stored, ...visitorIds]);
-                localStorage.setItem(constants_1.STORAGE_KEYS.MERGED_VISITOR_IDS, JSON.stringify([...merged]));
-            }
-            else {
-                // Data corrupted, start fresh
-                const merged = new Set(visitorIds);
-                localStorage.setItem(constants_1.STORAGE_KEYS.MERGED_VISITOR_IDS, JSON.stringify([...merged]));
-            }
-        }
-        catch (e) {
-            (0, logger_1.testModeDebug)('Selwise', 'Failed to update merged visitor IDs:', e);
-        }
-    }
-    /**
-     * Get all merged visitor IDs for this user
-     */
-    getMergedVisitorIds() {
-        try {
-            const parsed = JSON.parse(localStorage.getItem(constants_1.STORAGE_KEYS.MERGED_VISITOR_IDS) || '[]');
-            // Validate that parsed data is an array
-            if (Array.isArray(parsed)) {
-                return parsed;
-            }
-            return [];
-        }
-        catch (e) {
-            (0, logger_1.testModeDebug)('Selwise', 'Failed to get merged visitor IDs:', e);
-            return [];
-        }
-    }
-    track(name, args) {
-        const now = Date.now();
-        const eventId = (0, utils_1.generateEventId)();
-        const metadata = (0, utils_1.sanitizeTrackingMetadata)(args?.metadata);
-        const event = {
-            eventId,
-            eventSchemaVersion: 1,
-            eventTs: now,
-            name,
-            entityType: args?.entityType,
-            entityId: args?.entityId,
-            metadata,
-        };
-        if (name === 'click' && (args?.entityType === 'campaign' || args?.entityType === 'widget')) {
-            try {
-                sessionStorage.setItem(constants_1.STORAGE_KEYS.LAST_TOUCH, JSON.stringify({
-                    ts: Date.now(),
-                    campaignId: args.entityType === 'campaign' ? args.entityId || null : null,
-                    widgetId: args.entityType === 'widget' ? args.entityId || null : null,
-                }));
-            }
-            catch {
-                // ignore
-            }
-        }
-        // Use EventBatcher if enabled
-        if (this.useAdvancedBatching && this.batcher) {
-            this.batcher.add({
-                ...event,
-                timestamp: Date.now(),
-            }); // EventBatch type with timestamp
-        }
-        else {
-            // Local queue batching
-            this.queue.push(event);
-            this.scheduleFlush();
-        }
-    }
-    trackView(element, entityType, entityId, metadata) {
-        const key = `${entityType}_${entityId}`;
-        // Don't track same element twice
-        if (this.viewedElements.has(key))
-            return;
-        let viewStartTime = null;
-        let viewTimer = null;
-        const observer = new IntersectionObserver((entries) => {
-            entries.forEach((entry) => {
-                if (entry.isIntersecting && entry.intersectionRatio >= 0.5) {
-                    // Element is 50%+ visible
-                    if (!viewStartTime) {
-                        viewStartTime = Date.now();
-                        viewTimer = window.setTimeout(() => {
-                            // Element visible for 1+ second
-                            if (!this.viewedElements.has(key)) {
-                                this.viewedElements.add(key);
-                                this.track('view', {
-                                    entityType,
-                                    entityId,
-                                    metadata: {
-                                        ...metadata,
-                                        viewDuration: Date.now() - (viewStartTime || Date.now()),
-                                        scrollDepth: Math.round((window.scrollY / document.body.scrollHeight) * 100),
-                                    },
-                                });
-                            }
-                        }, 1000);
-                    }
-                }
-                else {
-                    // Element no longer visible
-                    if (viewTimer) {
-                        clearTimeout(viewTimer);
-                        viewTimer = null;
-                    }
-                    viewStartTime = null;
-                }
-            });
-        }, { threshold: 0.5 });
-        observer.observe(element);
-        this.viewObservers.set(key, observer);
-    }
-    trackProductImpression(element, widgetId, productItemCode, position) {
-        const key = `product_${widgetId}_${productItemCode}`;
-        if (this.viewedElements.has(key))
-            return;
-        const observer = new IntersectionObserver((entries) => {
-            entries.forEach((entry) => {
-                if (entry.isIntersecting && entry.intersectionRatio >= 0.5) {
-                    if (!this.viewedElements.has(key)) {
-                        this.viewedElements.add(key);
-                        this.track('product_impression', {
-                            entityType: 'recommendation',
-                            entityId: widgetId,
-                            metadata: { productItemCode, position },
-                        });
-                        observer.disconnect();
-                    }
-                }
-            });
-        }, { threshold: 0.5 });
-        observer.observe(element);
-    }
-    trackHoverStart(entityType, entityId) {
-        const key = `${entityType}_${entityId}`;
-        this.hoverStartTimes.set(key, Date.now());
-    }
-    trackHoverEnd(entityType, entityId, metadata) {
-        const key = `${entityType}_${entityId}`;
-        const startTime = this.hoverStartTimes.get(key);
-        if (startTime) {
-            const duration = Date.now() - startTime;
-            this.hoverStartTimes.delete(key);
-            // Only track if hover was longer than 500ms
-            if (duration >= 500) {
-                this.track('hover', {
-                    entityType,
-                    entityId,
-                    metadata: { ...metadata, hoverDuration: duration },
-                });
-            }
-        }
-    }
-    trackScroll(entityType, entityId, scrollPercent) {
-        this.track('scroll', {
-            entityType,
-            entityId,
-            metadata: { scrollPercent },
-        });
-    }
-    trackSliderNavigate(widgetId, direction, fromSlide, toSlide) {
-        this.track('slider_navigate', {
-            entityType: 'recommendation',
-            entityId: widgetId,
-            metadata: { direction, fromSlide, toSlide },
-        });
-    }
-    trackSliderSwipe(widgetId, direction) {
-        this.track('slider_swipe', {
-            entityType: 'recommendation',
-            entityId: widgetId,
-            metadata: { direction },
-        });
-    }
-    // ================================
-    // Search-specific tracking
-    // ================================
-    trackSearchOpen(trigger = 'click') {
-        this.track('search_instant_open', {
-            entityType: 'search',
-            metadata: { trigger },
-        });
-    }
-    trackSearchClose(query, resultCount, dwellTime) {
-        this.track('search_close', {
-            entityType: 'search',
-            metadata: { query, resultCount, dwellTime },
-        });
-    }
-    trackCategoryFilter(categoryName, resultCount) {
-        this.track('category_filter', {
-            entityType: 'search',
-            metadata: { categoryName, resultCount },
-        });
-    }
-    trackRecentSearchClick(query) {
-        this.track('recent_search_click', {
-            entityType: 'search',
-            metadata: { query },
-        });
-    }
-    trackPopularSearchClick(query) {
-        this.track('popular_search_click', {
-            entityType: 'search',
-            metadata: { query },
-        });
-    }
-    trackPopularCategoryClick(categoryName) {
-        this.track('popular_category_click', {
-            entityType: 'search',
-            metadata: { categoryName },
-        });
-    }
-    trackPopularProductClick(productItemCode) {
-        this.track('popular_product_click', {
-            entityType: 'search',
-            metadata: { productItemCode },
-        });
-    }
-    trackZeroResults(query) {
-        this.track('search_zero_results', {
-            entityType: 'search',
-            metadata: { query },
-        });
-    }
-    // ================================
-    // Order/Conversion tracking
-    // ================================
-    async trackOrder(order) {
-        if (!this.siteKey)
-            return;
-        const normalizedOrderId = (order.orderId || '').toString().trim();
-        if (!normalizedOrderId)
-            return;
-        const normalizedOrder = {
-            ...order,
-            orderId: normalizedOrderId,
-        };
-        const lastTouch = (() => {
-            try {
-                const a = JSON.parse(sessionStorage.getItem(constants_1.STORAGE_KEYS.LAST_TOUCH) || 'null');
-                const r = JSON.parse(sessionStorage.getItem(constants_1.STORAGE_KEYS.LAST_TOUCH_RECO) || 'null');
-                const s = JSON.parse(sessionStorage.getItem(constants_1.STORAGE_KEYS.LAST_TOUCH_SEARCH) || 'null');
-                const aTs = a?.ts ? Number(a.ts) : 0;
-                const rTs = r?.ts ? Number(r.ts) : 0;
-                const sTs = s?.ts ? Number(s.ts) : 0;
-                // Find the most recent touch
-                const maxTs = Math.max(aTs, rTs, sTs);
-                if (maxTs === 0)
-                    return {};
-                if (sTs === maxTs) {
-                    return {
-                        source: 'search',
-                        searchProductId: s.productItemCode,
-                        searchQuery: s.query,
-                    };
-                }
-                if (rTs === maxTs) {
-                    return {
-                        source: 'recommendation',
-                        recommendationWidgetId: r.recommendationWidgetId,
-                    };
-                }
-                return {
-                    source: 'campaign',
-                    campaignId: a?.campaignId || undefined,
-                    widgetId: a?.widgetId || undefined,
-                };
-            }
-            catch {
-                return {};
-            }
-        })();
-        // Get experiment assignments from localStorage for conversion tracking
-        const experimentAssignments = (() => {
-            try {
-                const stored = localStorage.getItem(constants_1.STORAGE_KEYS.EXPERIMENTS);
-                if (stored) {
-                    const parsed = JSON.parse(stored);
-                    return parsed;
-                }
-                return {};
-            }
-            catch (e) {
-                return {};
-            }
-        })();
-        try {
-            const response = await fetch(`${this.apiUrl}/public/sites/${this.siteKey}/orders`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    ...normalizedOrder,
-                    sessionId: this.sessionId,
-                    pageUrl: window.location.href,
-                    referrer: document.referrer || undefined,
-                    attribution: lastTouch,
-                    visitorId: normalizedOrder.visitorId || this.visitorId,
-                    siteUserId: normalizedOrder.siteUserId || this.siteUserId,
-                    experimentAssignments, // Include experiment data for revenue tracking
-                }),
-                keepalive: true,
-            });
-            // After successful order tracking, reset correlation for new attribution journey
-            if (response.ok) {
-                (0, utils_1.resetCorrelation)();
-                this.batcher?.resetCorrelation();
-            }
-        }
-        catch (e) { }
-    }
-    // ================================
-    // Internal methods
-    // ================================
-    scheduleFlush() {
-        if (this.flushTimeout) {
-            clearTimeout(this.flushTimeout);
-        }
-        this.flushTimeout = window.setTimeout(() => this.flush(), 1000);
-    }
-    async flush() {
-        if (this.queue.length === 0)
-            return;
-        if (!this.siteKey) {
-            // No siteKey; drop events to avoid poisoning shared endpoints
-            this.queue = [];
-            return;
-        }
-        const events = this.queue.splice(0).map((event) => ({
-            ...event,
-            eventSchemaVersion: event.eventSchemaVersion || 1,
-            eventTs: event.eventTs || Date.now(),
-            metadata: (0, utils_1.sanitizeTrackingMetadata)(event.metadata),
-        }));
-        try {
-            await fetch(`${this.apiUrl}/public/sites/${this.siteKey}/events/batch`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    sessionId: this.sessionId,
-                    visitorId: this.visitorId,
-                    journeyId: (0, utils_1.getOrCreateJourneyId)(),
-                    siteUserId: this.siteUserId,
-                    pageUrl: window.location.href,
-                    referrer: document.referrer || undefined,
-                    events,
-                }),
-                keepalive: true,
-            });
-        }
-        catch (error) {
-            // Fail silently, re-queue for retry
-            this.queue.push(...events);
-        }
-    }
-    cleanup() {
-        // Disconnect all IntersectionObservers
-        this.viewObservers.forEach((observer) => observer.disconnect());
-        this.viewObservers.clear();
-        this.viewedElements.clear();
-        this.hoverStartTimes.clear();
-        // Clear flush timeout to prevent pending callbacks
-        if (this.flushTimeout) {
-            clearTimeout(this.flushTimeout);
-            this.flushTimeout = null;
-        }
-        // Cleanup batcher
-        if (this.batcher) {
-            this.batcher.destroy();
-            this.batcher = undefined;
-        }
-    }
-    /**
-     * Setup SPA navigation cleanup listener
-     * Automatically cleans up observers when page navigation is detected
-     * This prevents memory leaks in single-page applications
-     */
-    setupSPACleanup() {
-        // Listen for navigation events common in SPAs
-        const originalPushState = history.pushState;
-        const originalReplaceState = history.replaceState;
-        // Override pushState
-        history.pushState = (...args) => {
-            originalPushState.apply(history, args);
-            this.scheduleDeferredCleanup();
-        };
-        // Override replaceState
-        history.replaceState = (...args) => {
-            originalReplaceState.apply(history, args);
-            this.scheduleDeferredCleanup();
-        };
-        // Listen for popstate (back/forward navigation)
-        window.addEventListener('popstate', () => {
-            this.scheduleDeferredCleanup();
-        });
-        // Also listen for hash changes
-        window.addEventListener('hashchange', () => {
-            this.scheduleDeferredCleanup();
-        });
-    }
-    /**
-     * Schedule deferred cleanup with a small delay
-     * This allows the new page to settle before cleaning up
-     */
-    scheduleDeferredCleanup() {
-        setTimeout(() => {
-            // Only cleanup if no new observers have been added recently
-            if (this.viewObservers.size > 0 && this.queue.length === 0) {
-                this.cleanup();
-            }
-        }, 1000); // 1 second delay
-    }
-    /**
-     * Manually flush pending events (useful for testing or before page unload)
-     */
-    async flushBatcher() {
-        if (this.batcher) {
-            await this.batcher.flush();
-        }
-        else {
-            await this.flush();
-        }
-    }
-    /**
-     * Get batcher stats (useful for debugging)
-     */
-    getBatcherStats() {
-        return this.batcher
-            ? {
-                queueSize: this.batcher.getQueueSize(),
-                consentQueueSize: this.batcher.getConsentQueueSize(),
-                processedCount: this.batcher.getProcessedCount(),
-                enabled: this.useAdvancedBatching,
-            }
-            : {
-                queueSize: this.queue.length,
-                consentQueueSize: 0,
-                processedCount: 0,
-                enabled: false,
-            };
-    }
-    /**
-     * Initialize the batcher (must be called after construction)
-     * This loads overflow events from IndexedDB and flushes them immediately
-     */
-    async initialize() {
-        if (this.batcher) {
-            await this.batcher.initialize();
-        }
-    }
-    /**
-     * Check if the batcher has been initialized
-     */
-    isReady() {
-        return this.batcher ? this.batcher.isReady() : true;
-    }
-    /**
-     * Flush consent queue - called when user grants consent
-     * Re-evaluates all queued events and sends those that now have consent
-     */
-    flushConsentQueue() {
-        if (this.batcher) {
-            this.batcher.flushConsentQueue();
-        }
-    }
-    /**
-     * Set up the global consent queue flush callback
-     * This allows the cookie consent widget to trigger queue flush when consent is granted
-     */
-    setupConsentCallback() {
-        if (typeof window !== 'undefined') {
-            // Set up global Selwise object if it doesn't exist
-            window.Selwise = window.Selwise || {};
-            // Store reference to this tracker's flush method
-            window.Selwise._flushConsentQueue = () => this.flushConsentQueue();
-            // Also expose getConsentState method for external access
-            window.Selwise.getConsentState = () => {
-                try {
-                    if (!this.siteKey)
-                        return null;
-                    const key = `${constants_1.STORAGE_KEYS.CONSENT}_${this.siteKey}`;
-                    const data = localStorage.getItem(key);
-                    return data ? JSON.parse(data) : null;
-                }
-                catch {
-                    return null;
-                }
-            };
-        }
-    }
-}
-exports.Tracker = Tracker;
-//# sourceMappingURL=tracker.js.map