@grainql/analytics-web 2.1.3 → 2.2.1

package/dist/react/index.mjs

@@ -1,1490 +1,44 @@
 /**
- * Grain Analytics Web SDK
- * A lightweight, dependency-free TypeScript SDK for sending analytics events to Grain's REST API
+ * Grain Analytics React Hooks
+ *
+ * React integration for @grainql/analytics-web
+ *
+ * @example
+ * ```tsx
+ * import { GrainProvider, useConfig, useTrack } from '@grainql/analytics-web/react';
+ *
+ * // Pattern 1: Provider-managed client
+ * <GrainProvider config={{ tenantId: 'xxx' }}>
+ *   <App />
+ * </GrainProvider>
+ *
+ * // Pattern 2: External client
+ * const grain = new GrainAnalytics({ tenantId: 'xxx' });
+ * <GrainProvider client={grain}>
+ *   <App />
+ * </GrainProvider>
+ *
+ * // Use hooks in components
+ * function MyComponent() {
+ *   const { value } = useConfig('hero_variant');
+ *   const track = useTrack();
+ *
+ *   return <button onClick={() => track('clicked')}>Click</button>;
+ * }
+ * ```
  */
-import { ConsentManager } from './consent';
-import { setCookie, getCookie, areCookiesEnabled } from './cookies';
-import { ActivityDetector } from './activity';
-import { HeartbeatManager } from './heartbeat';
-import { PageTrackingManager } from './page-tracking';
-export class GrainAnalytics {
-    constructor(config) {
-        this.eventQueue = [];
-        this.waitingForConsentQueue = [];
-        this.flushTimer = null;
-        this.isDestroyed = false;
-        this.globalUserId = null;
-        this.persistentAnonymousUserId = null;
-        // Remote Config properties
-        this.configCache = null;
-        this.configRefreshTimer = null;
-        this.configChangeListeners = [];
-        this.configFetchPromise = null;
-        this.cookiesEnabled = false;
-        // Automatic Tracking properties
-        this.activityDetector = null;
-        this.heartbeatManager = null;
-        this.pageTrackingManager = null;
-        this.ephemeralSessionId = null;
-        this.eventCountSinceLastHeartbeat = 0;
-        this.config = {
-            apiUrl: 'https://api.grainql.com',
-            authStrategy: 'NONE',
-            batchSize: 50,
-            flushInterval: 5000, // 5 seconds
-            retryAttempts: 3,
-            retryDelay: 1000, // 1 second
-            maxEventsPerRequest: 160, // Maximum events per API request
-            debug: false,
-            // Remote Config defaults
-            defaultConfigurations: {},
-            configCacheKey: 'grain_config',
-            configRefreshInterval: 300000, // 5 minutes
-            enableConfigCache: true,
-            // Privacy defaults
-            consentMode: 'opt-out',
-            waitForConsent: false,
-            enableCookies: false,
-            anonymizeIP: false,
-            disableAutoProperties: false,
-            // Automatic Tracking defaults
-            enableHeartbeat: true,
-            heartbeatActiveInterval: 120000, // 2 minutes
-            heartbeatInactiveInterval: 300000, // 5 minutes
-            enableAutoPageView: true,
-            stripQueryParams: true,
-            ...config,
-            tenantId: config.tenantId,
-        };
-        // Initialize consent manager
-        this.consentManager = new ConsentManager(this.config.tenantId, this.config.consentMode);
-        // Check if cookies are enabled
-        if (this.config.enableCookies) {
-            this.cookiesEnabled = areCookiesEnabled();
-            if (!this.cookiesEnabled && this.config.debug) {
-                console.warn('[Grain Analytics] Cookies are not available, falling back to localStorage');
-            }
-        }
-        // Set global userId if provided in config
-        if (config.userId) {
-            this.globalUserId = config.userId;
-        }
-        this.validateConfig();
-        this.initializePersistentAnonymousUserId();
-        this.setupBeforeUnload();
-        this.startFlushTimer();
-        this.initializeConfigCache();
-        // Initialize ephemeral session ID (memory-only, not persisted)
-        this.ephemeralSessionId = this.generateUUID();
-        // Initialize automatic tracking (browser only)
-        if (typeof window !== 'undefined') {
-            this.initializeAutomaticTracking();
-        }
-        // Set up consent change listener to flush waiting events and handle consent upgrade
-        this.consentManager.addListener((state) => {
-            if (state.granted) {
-                this.handleConsentGranted();
-            }
-        });
-    }
-    validateConfig() {
-        if (!this.config.tenantId) {
-            throw new Error('Grain Analytics: tenantId is required');
-        }
-        if (this.config.authStrategy === 'SERVER_SIDE' && !this.config.secretKey) {
-            throw new Error('Grain Analytics: secretKey is required for SERVER_SIDE auth strategy');
-        }
-        if (this.config.authStrategy === 'JWT' && !this.config.authProvider) {
-            throw new Error('Grain Analytics: authProvider is required for JWT auth strategy');
-        }
-    }
-    /**
-     * Generate a UUID v4 string
-     */
-    generateUUID() {
-        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-            return crypto.randomUUID();
-        }
-        // Fallback for environments without crypto.randomUUID
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            const r = Math.random() * 16 | 0;
-            const v = c === 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-    /**
-     * Generate a proper UUIDv4 identifier for anonymous user ID
-     */
-    generateAnonymousUserId() {
-        return this.generateUUID();
-    }
-    /**
-     * Initialize persistent anonymous user ID from cookies or localStorage
-     * Priority: Cookie → localStorage → generate new
-     */
-    initializePersistentAnonymousUserId() {
-        if (typeof window === 'undefined')
-            return;
-        const storageKey = `grain_anonymous_user_id_${this.config.tenantId}`;
-        const cookieName = '_grain_uid';
-        try {
-            // Try to load from cookie first if enabled
-            if (this.cookiesEnabled) {
-                const cookieValue = getCookie(cookieName);
-                if (cookieValue) {
-                    this.persistentAnonymousUserId = cookieValue;
-                    this.log('Loaded persistent anonymous user ID from cookie:', this.persistentAnonymousUserId);
-                    return;
-                }
-            }
-            // Fallback to localStorage
-            const stored = localStorage.getItem(storageKey);
-            if (stored) {
-                this.persistentAnonymousUserId = stored;
-                this.log('Loaded persistent anonymous user ID from localStorage:', this.persistentAnonymousUserId);
-                // Migrate to cookie if enabled
-                if (this.cookiesEnabled) {
-                    this.savePersistentAnonymousUserId(stored);
-                }
-            }
-            else {
-                // Generate new UUIDv4 anonymous user ID
-                this.persistentAnonymousUserId = this.generateAnonymousUserId();
-                this.savePersistentAnonymousUserId(this.persistentAnonymousUserId);
-                this.log('Generated new persistent anonymous user ID:', this.persistentAnonymousUserId);
-            }
-        }
-        catch (error) {
-            this.log('Failed to initialize persistent anonymous user ID:', error);
-            // Fallback: generate temporary ID without persistence
-            this.persistentAnonymousUserId = this.generateAnonymousUserId();
-        }
-    }
-    /**
-     * Save persistent anonymous user ID to cookie and/or localStorage
-     */
-    savePersistentAnonymousUserId(userId) {
-        if (typeof window === 'undefined')
-            return;
-        const storageKey = `grain_anonymous_user_id_${this.config.tenantId}`;
-        const cookieName = '_grain_uid';
-        try {
-            // Save to cookie if enabled
-            if (this.cookiesEnabled) {
-                const cookieOptions = {
-                    maxAge: 365 * 24 * 60 * 60, // 365 days
-                    sameSite: 'lax',
-                    secure: typeof window !== 'undefined' && window.location.protocol === 'https:',
-                    ...this.config.cookieOptions,
-                };
-                setCookie(cookieName, userId, cookieOptions);
-            }
-            // Always save to localStorage as fallback
-            localStorage.setItem(storageKey, userId);
-        }
-        catch (error) {
-            this.log('Failed to save persistent anonymous user ID:', error);
-        }
-    }
-    /**
-     * Get the effective user ID (global userId or persistent anonymous ID)
-     */
-    getEffectiveUserIdInternal() {
-        if (this.globalUserId) {
-            return this.globalUserId;
-        }
-        if (this.persistentAnonymousUserId) {
-            return this.persistentAnonymousUserId;
-        }
-        // Generate a new UUIDv4 identifier as fallback
-        this.persistentAnonymousUserId = this.generateAnonymousUserId();
-        // Try to persist it
-        if (typeof window !== 'undefined') {
-            try {
-                const storageKey = `grain_anonymous_user_id_${this.config.tenantId}`;
-                localStorage.setItem(storageKey, this.persistentAnonymousUserId);
-            }
-            catch (error) {
-                this.log('Failed to persist generated anonymous user ID:', error);
-            }
-        }
-        return this.persistentAnonymousUserId;
-    }
-    log(...args) {
-        if (this.config.debug) {
-            console.log('[Grain Analytics]', ...args);
-        }
-    }
-    /**
-     * Create error digest from events
-     */
-    createErrorDigest(events) {
-        const eventNames = [...new Set(events.map(e => e.eventName))];
-        const userIds = [...new Set(events.map(e => e.userId))];
-        let totalProperties = 0;
-        let totalSize = 0;
-        events.forEach(event => {
-            const properties = event.properties || {};
-            totalProperties += Object.keys(properties).length;
-            totalSize += JSON.stringify(event).length;
-        });
-        return {
-            eventCount: events.length,
-            totalProperties,
-            totalSize,
-            eventNames,
-            userIds,
-        };
-    }
-    /**
-     * Format error with beautiful structure
-     */
-    formatError(error, context, events) {
-        const digest = events ? this.createErrorDigest(events) : {
-            eventCount: 0,
-            totalProperties: 0,
-            totalSize: 0,
-            eventNames: [],
-            userIds: [],
-        };
-        let code = 'UNKNOWN_ERROR';
-        let message = 'An unknown error occurred';
-        if (error instanceof Error) {
-            message = error.message;
-            // Determine error code based on error type and message
-            if (message.includes('fetch failed') || message.includes('network error')) {
-                code = 'NETWORK_ERROR';
-            }
-            else if (message.includes('timeout')) {
-                code = 'TIMEOUT_ERROR';
-            }
-            else if (message.includes('HTTP 4')) {
-                code = 'CLIENT_ERROR';
-            }
-            else if (message.includes('HTTP 5')) {
-                code = 'SERVER_ERROR';
-            }
-            else if (message.includes('JSON')) {
-                code = 'PARSE_ERROR';
-            }
-            else if (message.includes('auth') || message.includes('unauthorized')) {
-                code = 'AUTH_ERROR';
-            }
-            else if (message.includes('rate limit') || message.includes('429')) {
-                code = 'RATE_LIMIT_ERROR';
-            }
-            else {
-                code = 'GENERAL_ERROR';
-            }
-        }
-        else if (typeof error === 'string') {
-            message = error;
-            code = 'STRING_ERROR';
-        }
-        else if (error && typeof error === 'object' && 'status' in error) {
-            const status = error.status;
-            code = `HTTP_${status}`;
-            message = `HTTP ${status} error`;
-        }
-        return {
-            code,
-            message,
-            digest,
-            timestamp: new Date().toISOString(),
-            context,
-            originalError: error,
-        };
-    }
-    /**
-     * Log formatted error gracefully
-     */
-    logError(formattedError) {
-        const { code, message, digest, timestamp, context } = formattedError;
-        const errorOutput = {
-            '🚨 Grain Analytics Error': {
-                'Error Code': code,
-                'Message': message,
-                'Context': context,
-                'Timestamp': timestamp,
-                'Event Digest': {
-                    'Events': digest.eventCount,
-                    'Properties': digest.totalProperties,
-                    'Size (bytes)': digest.totalSize,
-                    'Event Names': digest.eventNames.length > 0 ? digest.eventNames.join(', ') : 'None',
-                    'User IDs': digest.userIds.length > 0 ? digest.userIds.slice(0, 3).join(', ') + (digest.userIds.length > 3 ? '...' : '') : 'None',
-                }
-            }
-        };
-        console.error('🚨 Grain Analytics Error:', errorOutput);
-        // Also log in a more compact format for debugging
-        if (this.config.debug) {
-            console.error(`[Grain Analytics] ${code}: ${message} (${context}) - Events: ${digest.eventCount}, Props: ${digest.totalProperties}, Size: ${digest.totalSize}B`);
-        }
-    }
-    /**
-     * Safely execute a function with error handling
-     */
-    async safeExecute(fn, context, events) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, context, events);
-            this.logError(formattedError);
-            return null;
-        }
-    }
-    formatEvent(event) {
-        return {
-            eventName: event.eventName,
-            userId: event.userId || this.getEffectiveUserIdInternal(),
-            properties: event.properties || {},
-        };
-    }
-    async getAuthHeaders() {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        switch (this.config.authStrategy) {
-            case 'NONE':
-                break;
-            case 'SERVER_SIDE':
-                headers['Authorization'] = `Chase ${this.config.secretKey}`;
-                break;
-            case 'JWT':
-                if (this.config.authProvider) {
-                    const token = await this.config.authProvider.getToken();
-                    headers['Authorization'] = `Bearer ${token}`;
-                }
-                break;
-        }
-        return headers;
-    }
-    async delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    isRetriableError(error) {
-        if (error instanceof Error) {
-            // Check for specific network or fetch errors
-            const message = error.message.toLowerCase();
-            if (message.includes('fetch failed'))
-                return true;
-            if (message === 'network error')
-                return true; // Exact match to avoid "Non-network error"
-            if (message.includes('timeout'))
-                return true;
-            if (message.includes('connection'))
-                return true;
-        }
-        // Check for HTTP status codes that are retriable
-        if (typeof error === 'object' && error !== null && 'status' in error) {
-            const status = error.status;
-            return status >= 500 || status === 429; // Server errors or rate limiting
-        }
-        return false;
-    }
-    async sendEvents(events) {
-        if (events.length === 0)
-            return;
-        let lastError;
-        for (let attempt = 0; attempt <= this.config.retryAttempts; attempt++) {
-            try {
-                const headers = await this.getAuthHeaders();
-                const url = `${this.config.apiUrl}/v1/events/${encodeURIComponent(this.config.tenantId)}/multi`;
-                this.log(`Sending ${events.length} events to ${url} (attempt ${attempt + 1})`);
-                const response = await fetch(url, {
-                    method: 'POST',
-                    headers,
-                    body: JSON.stringify(events),
-                });
-                if (!response.ok) {
-                    let errorMessage = `HTTP ${response.status}`;
-                    try {
-                        const errorBody = await response.json();
-                        if (errorBody?.message) {
-                            errorMessage = errorBody.message;
-                        }
-                    }
-                    catch {
-                        const errorText = await response.text();
-                        if (errorText) {
-                            errorMessage = errorText;
-                        }
-                    }
-                    const error = new Error(`Failed to send events: ${errorMessage}`);
-                    error.status = response.status;
-                    throw error;
-                }
-                this.log(`Successfully sent ${events.length} events`);
-                return; // Success, exit retry loop
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt === this.config.retryAttempts) {
-                    // Last attempt, don't retry - log error gracefully
-                    const formattedError = this.formatError(error, `sendEvents (attempt ${attempt + 1}/${this.config.retryAttempts + 1})`, events);
-                    this.logError(formattedError);
-                    return; // Don't throw, just return gracefully
-                }
-                if (!this.isRetriableError(error)) {
-                    // Non-retriable error, don't retry - log error gracefully
-                    const formattedError = this.formatError(error, `sendEvents (non-retriable error)`, events);
-                    this.logError(formattedError);
-                    return; // Don't throw, just return gracefully
-                }
-                const delayMs = this.config.retryDelay * Math.pow(2, attempt); // Exponential backoff
-                this.log(`Retrying in ${delayMs}ms after error:`, error);
-                await this.delay(delayMs);
-            }
-        }
-    }
-    async sendEventsWithBeacon(events) {
-        if (events.length === 0)
-            return;
-        try {
-            const headers = await this.getAuthHeaders();
-            const url = `${this.config.apiUrl}/v1/events/${encodeURIComponent(this.config.tenantId)}/multi`;
-            const body = JSON.stringify({ events });
-            // Try beacon API first (more reliable for page unload)
-            if (typeof navigator !== 'undefined' && 'sendBeacon' in navigator) {
-                const blob = new Blob([body], { type: 'application/json' });
-                const success = navigator.sendBeacon(url, blob);
-                if (success) {
-                    this.log(`Successfully sent ${events.length} events via beacon`);
-                    return;
-                }
-            }
-            // Fallback to fetch with keepalive
-            await fetch(url, {
-                method: 'POST',
-                headers,
-                body,
-                keepalive: true,
-            });
-            this.log(`Successfully sent ${events.length} events via fetch (keepalive)`);
-        }
-        catch (error) {
-            // Log error gracefully for beacon failures (page unload scenarios)
-            const formattedError = this.formatError(error, 'sendEventsWithBeacon', events);
-            this.logError(formattedError);
-        }
-    }
-    startFlushTimer() {
-        if (typeof window === 'undefined')
-            return;
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-        }
-        this.flushTimer = window.setInterval(() => {
-            if (this.eventQueue.length > 0) {
-                this.flush().catch((error) => {
-                    const formattedError = this.formatError(error, 'auto-flush');
-                    this.logError(formattedError);
-                });
-            }
-        }, this.config.flushInterval);
-    }
-    setupBeforeUnload() {
-        if (typeof window === 'undefined')
-            return;
-        const handleBeforeUnload = () => {
-            if (this.eventQueue.length > 0) {
-                // Use beacon API for reliable delivery during page unload
-                const eventsToSend = [...this.eventQueue];
-                this.eventQueue = [];
-                const chunks = this.chunkEvents(eventsToSend, this.config.maxEventsPerRequest);
-                // Send first chunk with beacon (most important for page unload)
-                if (chunks.length > 0) {
-                    this.sendEventsWithBeacon(chunks[0]).catch(() => {
-                        // Silently fail - page is unloading
-                    });
-                }
-            }
-        };
-        // Handle page unload
-        window.addEventListener('beforeunload', handleBeforeUnload);
-        window.addEventListener('pagehide', handleBeforeUnload);
-        // Handle visibility change (page hidden)
-        document.addEventListener('visibilitychange', () => {
-            if (document.visibilityState === 'hidden' && this.eventQueue.length > 0) {
-                const eventsToSend = [...this.eventQueue];
-                this.eventQueue = [];
-                const chunks = this.chunkEvents(eventsToSend, this.config.maxEventsPerRequest);
-                // Send first chunk with beacon (most important for page hidden)
-                if (chunks.length > 0) {
-                    this.sendEventsWithBeacon(chunks[0]).catch(() => {
-                        // Silently fail
-                    });
-                }
-            }
-        });
-    }
-    /**
-     * Initialize automatic tracking (heartbeat and page views)
-     */
-    initializeAutomaticTracking() {
-        if (this.config.enableHeartbeat) {
-            try {
-                this.activityDetector = new ActivityDetector();
-                this.heartbeatManager = new HeartbeatManager(this, this.activityDetector, {
-                    activeInterval: this.config.heartbeatActiveInterval,
-                    inactiveInterval: this.config.heartbeatInactiveInterval,
-                    debug: this.config.debug,
-                });
-                this.log('Heartbeat tracking initialized');
-            }
-            catch (error) {
-                this.log('Failed to initialize heartbeat tracking:', error);
-            }
-        }
-        if (this.config.enableAutoPageView) {
-            try {
-                this.pageTrackingManager = new PageTrackingManager(this, {
-                    stripQueryParams: this.config.stripQueryParams,
-                    debug: this.config.debug,
-                });
-                this.log('Auto page view tracking initialized');
-            }
-            catch (error) {
-                this.log('Failed to initialize page view tracking:', error);
-            }
-        }
-    }
-    /**
-     * Handle consent granted - upgrade ephemeral session to persistent user
-     */
-    handleConsentGranted() {
-        this.flushWaitingForConsentQueue();
-        // Track consent granted event with mapping
-        if (this.ephemeralSessionId) {
-            this.trackSystemEvent('_grain_consent_granted', {
-                previous_session_id: this.ephemeralSessionId,
-                new_user_id: this.getEffectiveUserId(),
-                timestamp: Date.now(),
-            });
-        }
-    }
-    /**
-     * Track system events that bypass consent checks (for necessary/functional tracking)
-     */
-    trackSystemEvent(eventName, properties) {
-        if (this.isDestroyed)
-            return;
-        const hasConsent = this.consentManager.hasConsent('analytics');
-        // Create event with appropriate user ID
-        const event = {
-            eventName,
-            userId: hasConsent ? this.getEffectiveUserId() : this.getEphemeralSessionId(),
-            properties: {
-                ...properties,
-                _minimal: !hasConsent, // Flag to indicate minimal tracking
-                _consent_status: hasConsent ? 'granted' : 'pending',
-            },
-        };
-        // Bypass consent check for necessary system events
-        this.eventQueue.push(event);
-        this.eventCountSinceLastHeartbeat++;
-        this.log(`Queued system event: ${eventName}`, properties);
-        // Consider flushing
-        if (this.eventQueue.length >= this.config.batchSize) {
-            this.flush().catch((error) => {
-                const formattedError = this.formatError(error, 'flush system event');
-                this.logError(formattedError);
-            });
-        }
-    }
-    /**
-     * Get ephemeral session ID (memory-only, not persisted)
-     */
-    getEphemeralSessionId() {
-        if (!this.ephemeralSessionId) {
-            this.ephemeralSessionId = this.generateUUID();
-        }
-        return this.ephemeralSessionId;
-    }
-    /**
-     * Get the current page path from page tracker
-     */
-    getCurrentPage() {
-        return this.pageTrackingManager?.getCurrentPage() || null;
-    }
-    /**
-     * Get event count since last heartbeat
-     */
-    getEventCountSinceLastHeartbeat() {
-        return this.eventCountSinceLastHeartbeat;
-    }
-    /**
-     * Reset event count since last heartbeat
-     */
-    resetEventCountSinceLastHeartbeat() {
-        this.eventCountSinceLastHeartbeat = 0;
-    }
-    /**
-     * Get the effective user ID (public method)
-     */
-    getEffectiveUserId() {
-        return this.getEffectiveUserIdInternal();
-    }
-    /**
-     * Get the session ID (ephemeral or persistent based on consent)
-     */
-    getSessionId() {
-        const hasConsent = this.consentManager.hasConsent('analytics');
-        return hasConsent ? this.getEffectiveUserId() : this.getEphemeralSessionId();
-    }
-    async track(eventOrName, propertiesOrOptions, options) {
-        try {
-            if (this.isDestroyed) {
-                const error = new Error('Grain Analytics: Client has been destroyed');
-                const formattedError = this.formatError(error, 'track (client destroyed)');
-                this.logError(formattedError);
-                return;
-            }
-            let event;
-            let opts = {};
-            if (typeof eventOrName === 'string') {
-                event = {
-                    eventName: eventOrName,
-                    properties: propertiesOrOptions,
-                };
-                opts = options || {};
-            }
-            else {
-                event = eventOrName;
-                opts = propertiesOrOptions || {};
-            }
-            // Filter properties if whitelist is enabled
-            if (this.config.allowedProperties && event.properties) {
-                const filtered = {};
-                for (const key of this.config.allowedProperties) {
-                    if (key in event.properties) {
-                        filtered[key] = event.properties[key];
-                    }
-                }
-                event.properties = filtered;
-            }
-            const formattedEvent = this.formatEvent(event);
-            // Check consent before tracking
-            if (this.consentManager.shouldWaitForConsent() && this.config.waitForConsent) {
-                // Queue event until consent is granted
-                this.waitingForConsentQueue.push(formattedEvent);
-                this.log(`Event waiting for consent: ${event.eventName}`, event.properties);
-                return;
-            }
-            if (!this.consentManager.hasConsent('analytics')) {
-                this.log(`Event blocked by consent: ${event.eventName}`);
-                return;
-            }
-            this.eventQueue.push(formattedEvent);
-            this.eventCountSinceLastHeartbeat++;
-            this.log(`Queued event: ${event.eventName}`, event.properties);
-            // Check if we should flush immediately
-            if (opts.flush || this.eventQueue.length >= this.config.batchSize) {
-                await this.flush();
-            }
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'track');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Flush events that were waiting for consent
-     */
-    flushWaitingForConsentQueue() {
-        if (this.waitingForConsentQueue.length === 0)
-            return;
-        this.log(`Flushing ${this.waitingForConsentQueue.length} events waiting for consent`);
-        // Move waiting events to main queue
-        this.eventQueue.push(...this.waitingForConsentQueue);
-        this.waitingForConsentQueue = [];
-        // Flush immediately
-        this.flush().catch((error) => {
-            const formattedError = this.formatError(error, 'flush waiting for consent queue');
-            this.logError(formattedError);
-        });
-    }
-    /**
-     * Identify a user (sets userId for subsequent events)
-     */
-    identify(userId) {
-        this.log(`Identified user: ${userId}`);
-        this.globalUserId = userId;
-        // Clear persistent anonymous user ID since we now have a real user ID
-        this.persistentAnonymousUserId = null;
-    }
-    /**
-     * Set global user ID for all subsequent events
-     */
-    setUserId(userId) {
-        this.log(`Set global user ID: ${userId}`);
-        this.globalUserId = userId;
-        if (userId) {
-            // Clear persistent anonymous user ID if setting a real user ID
-            this.persistentAnonymousUserId = null;
-        }
-        else {
-            // If clearing user ID, ensure we have a UUIDv4 identifier
-            if (!this.persistentAnonymousUserId) {
-                this.persistentAnonymousUserId = this.generateAnonymousUserId();
-                // Try to persist the new anonymous ID
-                if (typeof window !== 'undefined') {
-                    try {
-                        const storageKey = `grain_anonymous_user_id_${this.config.tenantId}`;
-                        localStorage.setItem(storageKey, this.persistentAnonymousUserId);
-                    }
-                    catch (error) {
-                        this.log('Failed to persist new anonymous user ID:', error);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Get current global user ID
-     */
-    getUserId() {
-        return this.globalUserId;
-    }
-    /**
-     * Get current effective user ID (global userId or persistent anonymous ID)
-     */
-    getEffectiveUserIdPublic() {
-        return this.getEffectiveUserIdInternal();
-    }
-    /**
-     * Login with auth token or userId on the fly
-     *
-     * @example
-     * // Login with userId only
-     * client.login({ userId: 'user123' });
-     *
-     * // Login with auth token (automatically sets authStrategy to JWT)
-     * client.login({ authToken: 'jwt-token-here' });
-     *
-     * // Login with both userId and auth token
-     * client.login({ userId: 'user123', authToken: 'jwt-token-here' });
-     *
-     * // Override auth strategy
-     * client.login({ userId: 'user123', authStrategy: 'SERVER_SIDE' });
-     */
-    login(options) {
-        try {
-            if (this.isDestroyed) {
-                const error = new Error('Grain Analytics: Client has been destroyed');
-                const formattedError = this.formatError(error, 'login (client destroyed)');
-                this.logError(formattedError);
-                return;
-            }
-            // Set userId if provided
-            if (options.userId) {
-                this.log(`Login: Setting user ID to ${options.userId}`);
-                this.globalUserId = options.userId;
-                // Clear persistent anonymous user ID since we now have a real user ID
-                this.persistentAnonymousUserId = null;
-            }
-            // Handle auth token if provided
-            if (options.authToken) {
-                this.log('Login: Setting auth token');
-                // Update auth strategy to JWT if not already set
-                if (this.config.authStrategy === 'NONE') {
-                    this.config.authStrategy = 'JWT';
-                }
-                // Create a simple auth provider that returns the provided token
-                this.config.authProvider = {
-                    getToken: () => options.authToken
-                };
-            }
-            // Override auth strategy if provided
-            if (options.authStrategy) {
-                this.log(`Login: Setting auth strategy to ${options.authStrategy}`);
-                this.config.authStrategy = options.authStrategy;
-            }
-            this.log(`Login successful. Effective user ID: ${this.getEffectiveUserIdInternal()}`);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'login');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Logout and clear user session, fall back to UUIDv4 identifier
-     *
-     * @example
-     * // Logout user and return to anonymous mode
-     * client.logout();
-     *
-     * // After logout, events will use the persistent UUIDv4 identifier
-     * client.track('page_view', { page: 'home' });
-     */
-    logout() {
-        try {
-            if (this.isDestroyed) {
-                const error = new Error('Grain Analytics: Client has been destroyed');
-                const formattedError = this.formatError(error, 'logout (client destroyed)');
-                this.logError(formattedError);
-                return;
-            }
-            this.log('Logout: Clearing user session');
-            // Clear global user ID
-            this.globalUserId = null;
-            // Reset auth strategy to NONE
-            this.config.authStrategy = 'NONE';
-            this.config.authProvider = undefined;
-            // Generate new UUIDv4 identifier if we don't have one
-            if (!this.persistentAnonymousUserId) {
-                this.persistentAnonymousUserId = this.generateAnonymousUserId();
-                // Try to persist the new anonymous ID
-                if (typeof window !== 'undefined') {
-                    try {
-                        const storageKey = `grain_anonymous_user_id_${this.config.tenantId}`;
-                        localStorage.setItem(storageKey, this.persistentAnonymousUserId);
-                    }
-                    catch (error) {
-                        this.log('Failed to persist new anonymous user ID after logout:', error);
-                    }
-                }
-            }
-            this.log(`Logout successful. Effective user ID: ${this.getEffectiveUserIdInternal()}`);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'logout');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Set user properties
-     */
-    async setProperty(properties, options) {
-        try {
-            if (this.isDestroyed) {
-                const error = new Error('Grain Analytics: Client has been destroyed');
-                const formattedError = this.formatError(error, 'setProperty (client destroyed)');
-                this.logError(formattedError);
-                return;
-            }
-            const userId = options?.userId || this.getEffectiveUserIdInternal();
-            // Validate property count (max 4 properties)
-            const propertyKeys = Object.keys(properties);
-            if (propertyKeys.length > 4) {
-                const error = new Error('Grain Analytics: Maximum 4 properties allowed per request');
-                const formattedError = this.formatError(error, 'setProperty (validation)');
-                this.logError(formattedError);
-                return;
-            }
-            if (propertyKeys.length === 0) {
-                const error = new Error('Grain Analytics: At least one property is required');
-                const formattedError = this.formatError(error, 'setProperty (validation)');
-                this.logError(formattedError);
-                return;
-            }
-            // Serialize all values to strings
-            const serializedProperties = {};
-            for (const [key, value] of Object.entries(properties)) {
-                if (value === null || value === undefined) {
-                    serializedProperties[key] = '';
-                }
-                else if (typeof value === 'string') {
-                    serializedProperties[key] = value;
-                }
-                else {
-                    serializedProperties[key] = JSON.stringify(value);
-                }
-            }
-            const payload = {
-                userId,
-                ...serializedProperties,
-            };
-            await this.sendProperties(payload);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'setProperty');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Send properties to the API
-     */
-    async sendProperties(payload) {
-        let lastError;
-        for (let attempt = 0; attempt <= this.config.retryAttempts; attempt++) {
-            try {
-                const headers = await this.getAuthHeaders();
-                const url = `${this.config.apiUrl}/v1/events/${encodeURIComponent(this.config.tenantId)}/properties`;
-                this.log(`Setting properties for user ${payload.userId} (attempt ${attempt + 1})`);
-                const response = await fetch(url, {
-                    method: 'POST',
-                    headers,
-                    body: JSON.stringify(payload),
-                });
-                if (!response.ok) {
-                    let errorMessage = `HTTP ${response.status}`;
-                    try {
-                        const errorBody = await response.json();
-                        if (errorBody?.message) {
-                            errorMessage = errorBody.message;
-                        }
-                    }
-                    catch {
-                        const errorText = await response.text();
-                        if (errorText) {
-                            errorMessage = errorText;
-                        }
-                    }
-                    const error = new Error(`Failed to set properties: ${errorMessage}`);
-                    error.status = response.status;
-                    throw error;
-                }
-                this.log(`Successfully set properties for user ${payload.userId}`);
-                return; // Success, exit retry loop
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt === this.config.retryAttempts) {
-                    // Last attempt, don't retry - log error gracefully
-                    const formattedError = this.formatError(error, `sendProperties (attempt ${attempt + 1}/${this.config.retryAttempts + 1})`);
-                    this.logError(formattedError);
-                    return; // Don't throw, just return gracefully
-                }
-                if (!this.isRetriableError(error)) {
-                    // Non-retriable error, don't retry - log error gracefully
-                    const formattedError = this.formatError(error, 'sendProperties (non-retriable error)');
-                    this.logError(formattedError);
-                    return; // Don't throw, just return gracefully
-                }
-                const delayMs = this.config.retryDelay * Math.pow(2, attempt); // Exponential backoff
-                this.log(`Retrying in ${delayMs}ms after error:`, error);
-                await this.delay(delayMs);
-            }
-        }
-    }
-    // Template event methods
-    /**
-     * Track user login event
-     */
-    async trackLogin(properties, options) {
-        try {
-            return await this.track('login', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackLogin');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Track user signup event
-     */
-    async trackSignup(properties, options) {
-        try {
-            return await this.track('signup', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackSignup');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Track checkout event
-     */
-    async trackCheckout(properties, options) {
-        try {
-            return await this.track('checkout', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackCheckout');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Track page view event
-     */
-    async trackPageView(properties, options) {
-        try {
-            return await this.track('page_view', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackPageView');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Track purchase event
-     */
-    async trackPurchase(properties, options) {
-        try {
-            return await this.track('purchase', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackPurchase');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Track search event
-     */
-    async trackSearch(properties, options) {
-        try {
-            return await this.track('search', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackSearch');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Track add to cart event
-     */
-    async trackAddToCart(properties, options) {
-        try {
-            return await this.track('add_to_cart', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackAddToCart');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Track remove from cart event
-     */
-    async trackRemoveFromCart(properties, options) {
-        try {
-            return await this.track('remove_from_cart', properties, options);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'trackRemoveFromCart');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Manually flush all queued events
-     */
-    async flush() {
-        try {
-            if (this.eventQueue.length === 0)
-                return;
-            const eventsToSend = [...this.eventQueue];
-            this.eventQueue = [];
-            // Split events into chunks to respect maxEventsPerRequest limit
-            const chunks = this.chunkEvents(eventsToSend, this.config.maxEventsPerRequest);
-            // Send all chunks sequentially to maintain order
-            for (const chunk of chunks) {
-                await this.sendEvents(chunk);
-            }
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'flush');
-            this.logError(formattedError);
-        }
-    }
-    // Remote Config Methods
-    /**
-     * Initialize configuration cache from localStorage
-     */
-    initializeConfigCache() {
-        if (!this.config.enableConfigCache || typeof window === 'undefined')
-            return;
-        try {
-            const cached = localStorage.getItem(this.config.configCacheKey);
-            if (cached) {
-                this.configCache = JSON.parse(cached);
-                this.log('Loaded configuration from cache:', this.configCache);
-            }
-        }
-        catch (error) {
-            this.log('Failed to load configuration cache:', error);
-        }
-    }
-    /**
-     * Save configuration cache to localStorage
-     */
-    saveConfigCache(cache) {
-        if (!this.config.enableConfigCache || typeof window === 'undefined')
-            return;
-        try {
-            localStorage.setItem(this.config.configCacheKey, JSON.stringify(cache));
-            this.log('Saved configuration to cache:', cache);
-        }
-        catch (error) {
-            this.log('Failed to save configuration cache:', error);
-        }
-    }
-    /**
-     * Get configuration value with fallback to defaults
-     */
-    getConfig(key) {
-        // First check cache
-        if (this.configCache?.configurations?.[key]) {
-            return this.configCache.configurations[key];
-        }
-        // Then check defaults
-        if (this.config.defaultConfigurations?.[key]) {
-            return this.config.defaultConfigurations[key];
-        }
-        return undefined;
-    }
-    /**
-     * Get all configurations with fallback to defaults
-     */
-    getAllConfigs() {
-        const configs = { ...this.config.defaultConfigurations };
-        if (this.configCache?.configurations) {
-            Object.assign(configs, this.configCache.configurations);
-        }
-        return configs;
-    }
-    /**
-     * Fetch configurations from API
-     */
-    async fetchConfig(options = {}) {
-        try {
-            if (this.isDestroyed) {
-                const error = new Error('Grain Analytics: Client has been destroyed');
-                const formattedError = this.formatError(error, 'fetchConfig (client destroyed)');
-                this.logError(formattedError);
-                return null;
-            }
-            const userId = options.userId || this.getEffectiveUserIdInternal();
-            const immediateKeys = options.immediateKeys || [];
-            const properties = options.properties || {};
-            const request = {
-                userId,
-                immediateKeys,
-                properties,
-            };
-            let lastError;
-            for (let attempt = 0; attempt <= this.config.retryAttempts; attempt++) {
-                try {
-                    const headers = await this.getAuthHeaders();
-                    const url = `${this.config.apiUrl}/v1/client/${encodeURIComponent(this.config.tenantId)}/config/configurations`;
-                    this.log(`Fetching configurations for user ${userId} (attempt ${attempt + 1})`);
-                    const response = await fetch(url, {
-                        method: 'POST',
-                        headers,
-                        body: JSON.stringify(request),
-                    });
-                    if (!response.ok) {
-                        let errorMessage = `HTTP ${response.status}`;
-                        try {
-                            const errorBody = await response.json();
-                            if (errorBody?.message) {
-                                errorMessage = errorBody.message;
-                            }
-                        }
-                        catch {
-                            const errorText = await response.text();
-                            if (errorText) {
-                                errorMessage = errorText;
-                            }
-                        }
-                        const error = new Error(`Failed to fetch configurations: ${errorMessage}`);
-                        error.status = response.status;
-                        throw error;
-                    }
-                    const configResponse = await response.json();
-                    // Update cache if successful
-                    if (configResponse.configurations) {
-                        this.updateConfigCache(configResponse, userId);
-                    }
-                    this.log(`Successfully fetched configurations for user ${userId}:`, configResponse);
-                    return configResponse;
-                }
-                catch (error) {
-                    lastError = error;
-                    if (attempt === this.config.retryAttempts) {
-                        // Last attempt, don't retry - log error gracefully
-                        const formattedError = this.formatError(error, `fetchConfig (attempt ${attempt + 1}/${this.config.retryAttempts + 1})`);
-                        this.logError(formattedError);
-                        return null;
-                    }
-                    if (!this.isRetriableError(error)) {
-                        // Non-retriable error, don't retry - log error gracefully
-                        const formattedError = this.formatError(error, 'fetchConfig (non-retriable error)');
-                        this.logError(formattedError);
-                        return null;
-                    }
-                    const delayMs = this.config.retryDelay * Math.pow(2, attempt);
-                    this.log(`Retrying config fetch in ${delayMs}ms after error:`, error);
-                    await this.delay(delayMs);
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'fetchConfig');
-            this.logError(formattedError);
-            return null;
-        }
-    }
-    /**
-     * Get configuration asynchronously (cache-first with fallback to API)
-     */
-    async getConfigAsync(key, options = {}) {
-        try {
-            // Return immediately if we have it in cache and not forcing refresh
-            if (!options.forceRefresh && this.configCache?.configurations?.[key]) {
-                return this.configCache.configurations[key];
-            }
-            // Return default if available and not forcing refresh
-            if (!options.forceRefresh && this.config.defaultConfigurations?.[key]) {
-                return this.config.defaultConfigurations[key];
-            }
-            // Fetch from API
-            const response = await this.fetchConfig(options);
-            if (response) {
-                return response.configurations[key];
-            }
-            // Return default as fallback
-            return this.config.defaultConfigurations?.[key];
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'getConfigAsync');
-            this.logError(formattedError);
-            // Return default as fallback
-            return this.config.defaultConfigurations?.[key];
-        }
-    }
-    /**
-     * Get all configurations asynchronously (cache-first with fallback to API)
-     */
-    async getAllConfigsAsync(options = {}) {
-        try {
-            // Return cache if available and not forcing refresh
-            if (!options.forceRefresh && this.configCache?.configurations) {
-                return { ...this.config.defaultConfigurations, ...this.configCache.configurations };
-            }
-            // Fetch from API
-            const response = await this.fetchConfig(options);
-            if (response) {
-                return { ...this.config.defaultConfigurations, ...response.configurations };
-            }
-            // Return defaults as fallback
-            return { ...this.config.defaultConfigurations };
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'getAllConfigsAsync');
-            this.logError(formattedError);
-            // Return defaults as fallback
-            return { ...this.config.defaultConfigurations };
-        }
-    }
-    /**
-     * Update configuration cache and notify listeners
-     */
-    updateConfigCache(response, userId) {
-        const newCache = {
-            configurations: response.configurations,
-            snapshotId: response.snapshotId,
-            timestamp: response.timestamp,
-            userId,
-        };
-        const oldConfigs = this.configCache?.configurations || {};
-        this.configCache = newCache;
-        this.saveConfigCache(newCache);
-        // Notify listeners if configurations changed
-        if (JSON.stringify(oldConfigs) !== JSON.stringify(response.configurations)) {
-            this.notifyConfigChangeListeners(response.configurations);
-        }
-    }
-    /**
-     * Add configuration change listener
-     */
-    addConfigChangeListener(listener) {
-        this.configChangeListeners.push(listener);
-    }
-    /**
-     * Remove configuration change listener
-     */
-    removeConfigChangeListener(listener) {
-        const index = this.configChangeListeners.indexOf(listener);
-        if (index > -1) {
-            this.configChangeListeners.splice(index, 1);
-        }
-    }
-    /**
-     * Notify all configuration change listeners
-     */
-    notifyConfigChangeListeners(configurations) {
-        this.configChangeListeners.forEach(listener => {
-            try {
-                listener(configurations);
-            }
-            catch (error) {
-                console.error('[Grain Analytics] Config change listener error:', error);
-            }
-        });
-    }
-    /**
-     * Start automatic configuration refresh timer
-     */
-    startConfigRefreshTimer() {
-        if (typeof window === 'undefined')
-            return;
-        if (this.configRefreshTimer) {
-            clearInterval(this.configRefreshTimer);
-        }
-        this.configRefreshTimer = window.setInterval(() => {
-            if (!this.isDestroyed) {
-                // Use effective userId (will be generated if not set)
-                this.fetchConfig().catch((error) => {
-                    const formattedError = this.formatError(error, 'auto-config refresh');
-                    this.logError(formattedError);
-                });
-            }
-        }, this.config.configRefreshInterval);
-    }
-    /**
-     * Stop automatic configuration refresh timer
-     */
-    stopConfigRefreshTimer() {
-        if (this.configRefreshTimer) {
-            clearInterval(this.configRefreshTimer);
-            this.configRefreshTimer = null;
-        }
-    }
-    /**
-     * Preload configurations for immediate access
-     */
-    async preloadConfig(immediateKeys = [], properties) {
-        try {
-            // Use effective userId (will be generated if not set)
-            const effectiveUserId = this.getEffectiveUserIdInternal();
-            this.log(`Preloading config for user: ${effectiveUserId}`);
-            const response = await this.fetchConfig({ immediateKeys, properties });
-            if (response) {
-                this.startConfigRefreshTimer();
-            }
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'preloadConfig');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Split events array into chunks of specified size
-     */
-    chunkEvents(events, chunkSize) {
-        const chunks = [];
-        for (let i = 0; i < events.length; i += chunkSize) {
-            chunks.push(events.slice(i, i + chunkSize));
-        }
-        return chunks;
-    }
-    // Privacy & Consent Methods
-    /**
-     * Grant consent for tracking
-     * @param categories - Optional array of consent categories (e.g., ['analytics', 'functional'])
-     */
-    grantConsent(categories) {
-        try {
-            this.consentManager.grantConsent(categories);
-            this.log('Consent granted', categories);
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'grantConsent');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Revoke consent for tracking (opt-out)
-     * @param categories - Optional array of categories to revoke (if not provided, revokes all)
-     */
-    revokeConsent(categories) {
-        try {
-            this.consentManager.revokeConsent(categories);
-            this.log('Consent revoked', categories);
-            // Clear queued events when consent is revoked
-            this.eventQueue = [];
-            this.waitingForConsentQueue = [];
-        }
-        catch (error) {
-            const formattedError = this.formatError(error, 'revokeConsent');
-            this.logError(formattedError);
-        }
-    }
-    /**
-     * Get current consent state
-     */
-    getConsentState() {
-        return this.consentManager.getConsentState();
-    }
-    /**
-     * Check if user has granted consent
-     * @param category - Optional category to check (if not provided, checks general consent)
-     */
-    hasConsent(category) {
-        return this.consentManager.hasConsent(category);
-    }
-    /**
-     * Add listener for consent state changes
-     */
-    onConsentChange(listener) {
-        this.consentManager.addListener(listener);
-    }
-    /**
-     * Remove consent change listener
-     */
-    offConsentChange(listener) {
-        this.consentManager.removeListener(listener);
-    }
-    /**
-     * Destroy the client and clean up resources
-     */
-    destroy() {
-        this.isDestroyed = true;
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-            this.flushTimer = null;
-        }
-        // Stop config refresh timer
-        this.stopConfigRefreshTimer();
-        // Clear config change listeners
-        this.configChangeListeners = [];
-        // Destroy automatic tracking managers
-        if (this.heartbeatManager) {
-            this.heartbeatManager.destroy();
-            this.heartbeatManager = null;
-        }
-        if (this.pageTrackingManager) {
-            this.pageTrackingManager.destroy();
-            this.pageTrackingManager = null;
-        }
-        if (this.activityDetector) {
-            this.activityDetector.destroy();
-            this.activityDetector = null;
-        }
-        // Send any remaining events (in chunks if necessary)
-        if (this.eventQueue.length > 0) {
-            const eventsToSend = [...this.eventQueue];
-            this.eventQueue = [];
-            const chunks = this.chunkEvents(eventsToSend, this.config.maxEventsPerRequest);
-            // Send first chunk with beacon (most important for page unload)
-            if (chunks.length > 0) {
-                this.sendEventsWithBeacon(chunks[0]).catch(() => {
-                    // Silently fail during cleanup
-                });
-                // If there are more chunks, try to send them with regular fetch
-                for (let i = 1; i < chunks.length; i++) {
-                    this.sendEventsWithBeacon(chunks[i]).catch(() => {
-                        // Silently fail during cleanup
-                    });
-                }
-            }
-        }
-    }
-}
-/**
- * Create a new Grain Analytics client
- */
-export function createGrainAnalytics(config) {
-    return new GrainAnalytics(config);
-}
-// Default export for convenience
-export default GrainAnalytics;
-// Auto-setup for IIFE build
-if (typeof window !== 'undefined') {
-    window.Grain = {
-        GrainAnalytics,
-        createGrainAnalytics,
-    };
-}
+// Provider
+export { GrainProvider } from './GrainProvider';
+// Hooks
+export { useGrainAnalytics } from './hooks/useGrainAnalytics';
+export { useConfig } from './hooks/useConfig';
+export { useAllConfigs } from './hooks/useAllConfigs';
+export { useTrack } from './hooks/useTrack';
+// Privacy hooks
+export { useConsent } from './hooks/useConsent';
+export { usePrivacyPreferences } from './hooks/usePrivacyPreferences';
+export { useDataDeletion } from './hooks/useDataDeletion';
+// Privacy components
+export { ConsentBanner } from './components/ConsentBanner';
+export { PrivacyPreferenceCenter } from './components/PrivacyPreferenceCenter';
+export { CookieNotice } from './components/CookieNotice';