user-analytics-tracker 1.7.0 → 2.1.0

package/dist/index.cjs.js

@@ -553,6 +553,191 @@ function checkAndSetLocationConsent(msisdn) {
     return false;
 }
 
+/**
+ * IP Geolocation Service
+ * Fetches location data (country, region, city) from user's IP address
+ * Uses ipwho.is API (no API key required)
+ *
+ * Stores all keys dynamically from the API response, including nested objects
+ * This ensures we capture all available data and any new fields added by the API
+ */
+/**
+ * Get public IP address using ipwho.is API
+ * No API key required
+ *
+ * @returns Promise<string | null> - The public IP address, or null if unavailable
+ *
+ * @example
+ * ```typescript
+ * const ip = await getPublicIP();
+ * console.log('Your IP:', ip); // e.g., "203.0.113.42"
+ * ```
+ */
+async function getPublicIP() {
+    // Skip if we're in an environment without fetch (SSR)
+    if (typeof fetch === 'undefined') {
+        return null;
+    }
+    try {
+        // Call ipwho.is without IP parameter - it auto-detects user's IP
+        // Using HTTPS endpoint for better security
+        const response = await fetch('https://ipwho.is/', {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+            },
+            // Add timeout to prevent hanging
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        // ipwho.is returns success field
+        if (data.success === false) {
+            return null;
+        }
+        return data.ip || null;
+    }
+    catch (error) {
+        // Silently fail - don't break user experience
+        if (error.name !== 'AbortError') {
+            console.warn('[IP Geolocation] Error fetching public IP:', error.message);
+        }
+        return null;
+    }
+}
+/**
+ * Get location from IP address using ipwho.is API
+ * Free tier: No API key required
+ *
+ * Stores all keys dynamically from the API response, including nested objects
+ * This ensures we capture all available data and any new fields added by the API
+ */
+async function getIPLocation(ip) {
+    // Skip localhost/private IPs (these can't be geolocated)
+    if (!ip ||
+        ip === '0.0.0.0' ||
+        ip === '::1' ||
+        ip.startsWith('127.') ||
+        ip.startsWith('192.168.') ||
+        ip.startsWith('10.') ||
+        ip.startsWith('172.') ||
+        ip.startsWith('::ffff:127.')) {
+        console.log(`[IP Geolocation] Skipping localhost/private IP: ${ip} (geolocation not available for local IPs)`);
+        return null;
+    }
+    try {
+        // Using ipwho.is API (no API key required)
+        const response = await fetch(`https://ipwho.is/${ip}`, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+            },
+            // Add timeout to prevent hanging
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            console.warn(`[IP Geolocation] Failed to fetch location for IP ${ip}: ${response.status}`);
+            return null;
+        }
+        const data = await response.json();
+        // ipwho.is returns success field
+        if (data.success === false) {
+            console.warn(`[IP Geolocation] API error for IP ${ip}: ${data.message || 'Unknown error'}`);
+            return null;
+        }
+        // Store all keys dynamically from the response
+        // This ensures we capture all fields, including nested objects and any new fields
+        const locationData = {
+            ip: data.ip || ip,
+            // Map all fields from the API response dynamically
+            ...Object.keys(data).reduce((acc, key) => {
+                // Store all keys and their values, preserving nested objects
+                acc[key] = data[key];
+                return acc;
+            }, {}),
+        };
+        // Add backward compatibility mappings for existing code
+        if (data.latitude !== undefined) {
+            locationData.lat = data.latitude;
+        }
+        if (data.longitude !== undefined) {
+            locationData.lon = data.longitude;
+        }
+        if (data.country_code !== undefined) {
+            locationData.countryCode = data.country_code;
+        }
+        if (data.region !== undefined) {
+            locationData.regionName = data.region;
+        }
+        if (data.connection?.isp !== undefined) {
+            locationData.isp = data.connection.isp;
+        }
+        if (data.connection?.org !== undefined) {
+            locationData.org = data.connection.org;
+        }
+        if (data.connection?.asn !== undefined) {
+            locationData.as = `AS${data.connection.asn}`;
+        }
+        if (data.timezone?.id !== undefined) {
+            locationData.timezone = data.timezone.id;
+        }
+        locationData.query = data.ip || ip;
+        return locationData;
+    }
+    catch (error) {
+        // Silently fail - don't break user experience
+        if (error.name !== 'AbortError') {
+            console.warn(`[IP Geolocation] Error fetching location for IP ${ip}:`, error.message);
+        }
+        return null;
+    }
+}
+/**
+ * Get IP address from request headers
+ * Handles various proxy headers (x-forwarded-for, x-real-ip, etc.)
+ */
+function getIPFromRequest(req) {
+    // Try various headers that proxies/load balancers use
+    const forwardedFor = req.headers?.get?.('x-forwarded-for') ||
+        req.headers?.['x-forwarded-for'] ||
+        req.headers?.['X-Forwarded-For'];
+    if (forwardedFor) {
+        // x-forwarded-for can contain multiple IPs, take the first one
+        const ips = forwardedFor.split(',').map((ip) => ip.trim());
+        const ip = ips[0];
+        if (ip && ip !== '0.0.0.0') {
+            return ip;
+        }
+    }
+    const realIP = req.headers?.get?.('x-real-ip') ||
+        req.headers?.['x-real-ip'] ||
+        req.headers?.['X-Real-IP'];
+    if (realIP && realIP !== '0.0.0.0') {
+        return realIP.trim();
+    }
+    // Try req.ip (from Express/Next.js)
+    if (req.ip && req.ip !== '0.0.0.0') {
+        return req.ip;
+    }
+    // For localhost, detect if we're running locally
+    if (typeof window === 'undefined') {
+        const hostname = req.headers?.get?.('host') || req.headers?.['host'];
+        if (hostname &&
+            (hostname.includes('localhost') ||
+                hostname.includes('127.0.0.1') ||
+                hostname.startsWith('192.168.'))) {
+            return '127.0.0.1'; // Localhost IP
+        }
+    }
+    // If no IP found and we're in development, return localhost
+    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') {
+        return '127.0.0.1'; // Localhost for development
+    }
+    return '0.0.0.0';
+}
+
 /**
  * Location Detector
  * Detects GPS location with consent management, falls back to IP-based location API
@@ -817,7 +1002,8 @@ class LocationDetector {
     /**
      * Get location from IP-based public API (client-side)
      * Works without user permission, good fallback when GPS is unavailable
-     * Uses ip-api.com free tier (no API key required, 45 requests/minute)
+     * Uses ipwho.is API (no API key required)
+     * Stores all keys dynamically from the API response
      */
     static async getIPBasedLocation() {
         // Return cached IP location if available
@@ -853,51 +1039,47 @@ class LocationDetector {
         }
         this.ipLocationFetchingRef.current = true;
         try {
-            // Call ip-api.com without IP parameter - it auto-detects user's IP
-            // Using HTTPS endpoint for better security
-            const response = await fetch('https://ip-api.com/json/?fields=status,message,country,countryCode,region,regionName,city,lat,lon,timezone,query', {
-                method: 'GET',
-                headers: {
-                    Accept: 'application/json',
-                },
-                // Add timeout to prevent hanging
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}`);
+            // Get public IP first, then get location
+            const publicIP = await getPublicIP();
+            if (!publicIP) {
+                throw new Error('Could not determine public IP address');
             }
-            const data = await response.json();
-            // ip-api.com returns status field
-            if (data.status === 'fail') {
-                console.warn(`[Location] IP API error: ${data.message}`);
-                const fallback = {
-                    source: 'unknown',
-                    permission: 'granted',
-                };
-                this.lastIPLocationRef.current = fallback;
-                return fallback;
+            // Get location from IP using ipwho.is API
+            const ipLocation = await getIPLocation(publicIP);
+            if (!ipLocation) {
+                throw new Error('Could not fetch location data');
             }
             // Convert IP location to LocationInfo format
+            // Map all available fields from the IP location response
+            // Handle timezone which can be either a string or an object
+            const timezoneValue = typeof ipLocation.timezone === 'string'
+                ? ipLocation.timezone
+                : ipLocation.timezone?.id || undefined;
             const locationResult = {
-                lat: data.lat || null,
-                lon: data.lon || null,
+                lat: ipLocation.latitude ?? ipLocation.lat ?? null,
+                lon: ipLocation.longitude ?? ipLocation.lon ?? null,
                 accuracy: null, // IP-based location has no accuracy metric
                 permission: 'granted', // IP location doesn't require permission
                 source: 'ip',
                 ts: new Date().toISOString(),
-                ip: data.query || null, // Public IP address
-                country: data.country || undefined,
-                countryCode: data.countryCode || undefined,
-                city: data.city || undefined,
-                region: data.regionName || data.region || undefined,
-                timezone: data.timezone || undefined,
+                ip: ipLocation.ip || publicIP,
+                country: ipLocation.country || undefined,
+                countryCode: ipLocation.country_code || ipLocation.countryCode || undefined,
+                city: ipLocation.city || undefined,
+                region: ipLocation.region || ipLocation.regionName || undefined,
+                timezone: timezoneValue,
             };
+            // Store the full IP location data in a custom field for access to all keys
+            // This preserves all dynamic keys from the API response
+            locationResult.ipLocationData = ipLocation;
             console.log('[Location] IP-based location obtained:', {
                 ip: locationResult.ip,
                 lat: locationResult.lat,
                 lon: locationResult.lon,
                 city: locationResult.city,
                 country: locationResult.country,
+                continent: ipLocation.continent,
+                timezone: locationResult.timezone,
             });
             this.lastIPLocationRef.current = locationResult;
             return locationResult;
@@ -1017,15 +1199,91 @@ function trackPageVisit() {
     localStorage.setItem('analytics:pageVisits', newCount.toString());
     return newCount;
 }
+const SESSION_STORAGE_KEY = 'analytics:session';
+const DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes
+/**
+ * Get or create a session
+ */
+function getOrCreateSession(timeout = DEFAULT_SESSION_TIMEOUT) {
+    if (typeof window === 'undefined') {
+        return {
+            sessionId: `server-${Date.now()}`,
+            startTime: Date.now(),
+            lastActivity: Date.now(),
+            pageViews: 1,
+        };
+    }
+    const stored = loadJSON(SESSION_STORAGE_KEY);
+    const now = Date.now();
+    // Check if session expired
+    if (stored && now - stored.lastActivity < timeout) {
+        // Update last activity
+        const updated = {
+            ...stored,
+            lastActivity: now,
+            pageViews: stored.pageViews + 1,
+        };
+        saveJSON(SESSION_STORAGE_KEY, updated);
+        return updated;
+    }
+    // Create new session
+    const sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    const newSession = {
+        sessionId,
+        startTime: now,
+        lastActivity: now,
+        pageViews: 1,
+    };
+    saveJSON(SESSION_STORAGE_KEY, newSession);
+    return newSession;
+}
+/**
+ * Update session activity
+ */
+function updateSessionActivity() {
+    if (typeof window === 'undefined')
+        return;
+    const stored = loadJSON(SESSION_STORAGE_KEY);
+    if (stored) {
+        const updated = {
+            ...stored,
+            lastActivity: Date.now(),
+        };
+        saveJSON(SESSION_STORAGE_KEY, updated);
+    }
+}
+/**
+ * Get current session info
+ */
+function getSession() {
+    return loadJSON(SESSION_STORAGE_KEY);
+}
+/**
+ * Clear session
+ */
+function clearSession() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.removeItem(SESSION_STORAGE_KEY);
+    }
+    catch {
+        // Silently fail
+    }
+}
 
 var storage = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    clearSession: clearSession,
+    getOrCreateSession: getOrCreateSession,
     getOrCreateUserId: getOrCreateUserId,
+    getSession: getSession,
     loadJSON: loadJSON,
     loadSessionJSON: loadSessionJSON,
     saveJSON: saveJSON,
     saveSessionJSON: saveSessionJSON,
-    trackPageVisit: trackPageVisit
+    trackPageVisit: trackPageVisit,
+    updateSessionActivity: updateSessionActivity
 });
 
 const UTM_KEYS = [
@@ -1175,95 +1433,765 @@ var attributionDetector = /*#__PURE__*/Object.freeze({
 });
 
 /**
- * Analytics Service
- * Sends analytics events to your backend API
- *
- * Supports both relative paths (e.g., '/api/analytics') and full URLs (e.g., 'https://your-server.com/api/analytics')
+ * Logger utility for analytics tracker
+ * Provides configurable logging levels for development and production
  */
-class AnalyticsService {
+class Logger {
+    constructor() {
+        this.level = 'warn';
+        this.isDevelopment =
+            typeof process !== 'undefined' &&
+                process.env?.NODE_ENV === 'development';
+        // Default to 'info' in development, 'warn' in production
+        if (this.isDevelopment && this.level === 'warn') {
+            this.level = 'info';
+        }
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    getLevel() {
+        return this.level;
+    }
+    shouldLog(level) {
+        const levels = ['silent', 'error', 'warn', 'info', 'debug'];
+        const currentIndex = levels.indexOf(this.level);
+        const messageIndex = levels.indexOf(level);
+        return messageIndex >= 0 && messageIndex <= currentIndex;
+    }
+    error(message, ...args) {
+        if (this.shouldLog('error')) {
+            console.error(`[Analytics] ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.shouldLog('warn')) {
+            console.warn(`[Analytics] ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.shouldLog('info')) {
+            console.log(`[Analytics] ${message}`, ...args);
+        }
+    }
+    debug(message, ...args) {
+        if (this.shouldLog('debug')) {
+            console.log(`[Analytics] [DEBUG] ${message}`, ...args);
+        }
+    }
+}
+const logger = new Logger();
+
+/**
+ * Queue Manager for Analytics Events
+ * Handles batching, persistence, and offline support
+ */
+class QueueManager {
+    constructor(config) {
+        this.queue = [];
+        this.flushTimer = null;
+        this.isFlushing = false;
+        this.flushCallback = null;
+        this.config = config;
+        this.loadFromStorage();
+        this.startAutoFlush();
+        this.setupPageUnloadHandler();
+    }
     /**
-     * Configure the analytics API endpoint
-     *
-     * @param config - Configuration object
-     * @param config.apiEndpoint - Your backend API endpoint URL
-     *   - Relative path: '/api/analytics' (sends to same domain)
-     *   - Full URL: 'https://your-server.com/api/analytics' (sends to your server)
-     *
-     * @example
-     * ```typescript
-     * // Use your own server
-     * AnalyticsService.configure({
-     *   apiEndpoint: 'https://api.yourcompany.com/analytics'
-     * });
-     *
-     * // Or use relative path (same domain)
-     * AnalyticsService.configure({
-     *   apiEndpoint: '/api/analytics'
-     * });
-     * ```
+     * Set the callback function to flush events
      */
-    static configure(config) {
-        this.apiEndpoint = config.apiEndpoint;
+    setFlushCallback(callback) {
+        this.flushCallback = callback;
     }
     /**
-     * Generate a random event ID
+     * Add an event to the queue
      */
-    static generateEventId() {
-        const arr = new Uint32Array(4);
-        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
-            crypto.getRandomValues(arr);
-            return Array.from(arr)
-                .map((n) => n.toString(16))
-                .join('');
+    enqueue(event) {
+        if (this.queue.length >= this.config.maxQueueSize) {
+            logger.warn(`Queue full (${this.config.maxQueueSize} events). Dropping oldest event.`);
+            this.queue.shift(); // Remove oldest event
         }
-        // Fallback for environments without crypto
-        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+        const queuedEvent = {
+            event,
+            retries: 0,
+            timestamp: Date.now(),
+            id: `${Date.now()}-${Math.random().toString(36).substring(7)}`,
+        };
+        this.queue.push(queuedEvent);
+        this.saveToStorage();
+        logger.debug(`Event queued. Queue size: ${this.queue.length}`);
+        // Auto-flush if batch size reached
+        if (this.queue.length >= this.config.batchSize) {
+            this.flush();
+        }
+        return true;
     }
     /**
-     * Track user journey/analytics event
+     * Flush events from the queue
      */
-    static async trackEvent(event) {
-        const payload = {
-            ...event,
-            timestamp: new Date(),
-            eventId: this.generateEventId(),
-        };
+    async flush() {
+        if (this.isFlushing || this.queue.length === 0 || !this.flushCallback) {
+            return;
+        }
+        this.isFlushing = true;
+        const eventsToFlush = this.queue.splice(0, this.config.batchSize);
+        if (eventsToFlush.length === 0) {
+            this.isFlushing = false;
+            return;
+        }
         try {
-            const res = await fetch(this.apiEndpoint, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                keepalive: true, // Allows sending during unload on some browsers
-                body: JSON.stringify(payload),
-            });
-            if (!res.ok) {
-                console.warn('[Analytics] Send failed:', await res.text());
-            }
-            else if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') {
-                console.log('[Analytics] Event sent successfully');
-            }
+            const events = eventsToFlush.map((q) => q.event);
+            await this.flushCallback(events);
+            // Remove successfully flushed events from storage
+            this.saveToStorage();
+            logger.debug(`Flushed ${events.length} events. Queue size: ${this.queue.length}`);
         }
-        catch (err) {
-            // Don't break user experience - silently fail
-            console.warn('[Analytics] Failed to send event:', err);
+        catch (error) {
+            // On failure, put events back in queue (they'll be retried)
+            this.queue.unshift(...eventsToFlush);
+            this.saveToStorage();
+            logger.warn(`Failed to flush events. Re-queued ${eventsToFlush.length} events.`, error);
+            throw error;
+        }
+        finally {
+            this.isFlushing = false;
         }
     }
     /**
-     * Track user journey with full context
+     * Get current queue size
      */
-    static async trackUserJourney({ sessionId, pageUrl, networkInfo, deviceInfo, location, attribution, ipLocation, userId, customData, pageVisits = 1, interactions = 0, }) {
-        await this.trackEvent({
-            sessionId,
-            pageUrl,
-            networkInfo,
-            deviceInfo,
-            location,
-            attribution,
-            ipLocation,
-            userId: userId ?? sessionId,
-            customData: {
-                ...customData,
-                ...(ipLocation && { ipLocation }),
-            },
+    getQueueSize() {
+        return this.queue.length;
+    }
+    /**
+     * Get all queued events (for debugging)
+     */
+    getQueue() {
+        return [...this.queue];
+    }
+    /**
+     * Clear the queue
+     */
+    clear() {
+        this.queue = [];
+        this.saveToStorage();
+        logger.debug('Queue cleared');
+    }
+    /**
+     * Load queue from localStorage
+     */
+    loadFromStorage() {
+        if (typeof window === 'undefined')
+            return;
+        try {
+            const stored = loadJSON(this.config.storageKey);
+            if (stored && Array.isArray(stored)) {
+                // Only load events from last 24 hours to prevent stale data
+                const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+                this.queue = stored.filter((q) => q.timestamp > oneDayAgo);
+                if (this.queue.length > 0) {
+                    logger.debug(`Loaded ${this.queue.length} events from storage`);
+                }
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to load queue from storage', error);
+        }
+    }
+    /**
+     * Save queue to localStorage
+     */
+    saveToStorage() {
+        if (typeof window === 'undefined')
+            return;
+        try {
+            saveJSON(this.config.storageKey, this.queue);
+        }
+        catch (error) {
+            logger.warn('Failed to save queue to storage', error);
+        }
+    }
+    /**
+     * Start auto-flush timer
+     */
+    startAutoFlush() {
+        if (typeof window === 'undefined')
+            return;
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flushTimer = setInterval(() => {
+            if (this.queue.length > 0) {
+                this.flush().catch((error) => {
+                    logger.warn('Auto-flush failed', error);
+                });
+            }
+        }, this.config.batchInterval);
+    }
+    /**
+     * Setup page unload handler to flush events
+     */
+    setupPageUnloadHandler() {
+        if (typeof window === 'undefined')
+            return;
+        // Use sendBeacon for reliable delivery on page unload
+        window.addEventListener('beforeunload', () => {
+            if (this.queue.length > 0 && this.flushCallback) {
+                const events = this.queue.splice(0, this.config.batchSize).map((q) => q.event);
+                // Try to send via sendBeacon (more reliable on unload)
+                if (navigator.sendBeacon) {
+                    try {
+                        const blob = new Blob([JSON.stringify(events)], {
+                            type: 'application/json',
+                        });
+                        navigator.sendBeacon(this.getEndpointFromCallback(), blob);
+                        this.saveToStorage();
+                    }
+                    catch (error) {
+                        // Fallback: put events back in queue
+                        this.queue.unshift(...events.map((e) => ({
+                            event: e,
+                            retries: 0,
+                            timestamp: Date.now(),
+                            id: `${Date.now()}-${Math.random().toString(36).substring(7)}`,
+                        })));
+                    }
+                }
+            }
+        });
+        // Also use visibilitychange for better mobile support
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden' && this.queue.length > 0) {
+                this.flush().catch(() => {
+                    // Silently fail on visibility change
+                });
+            }
+        });
+    }
+    /**
+     * Get endpoint for sendBeacon
+     */
+    getEndpointFromCallback() {
+        // Try to get from window or return default
+        if (typeof window !== 'undefined' && window.__analyticsEndpoint) {
+            return window.__analyticsEndpoint;
+        }
+        return '/api/analytics';
+    }
+    /**
+     * Update storage key (for configuration changes)
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        if (config.batchInterval) {
+            this.startAutoFlush();
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+}
+
+/**
+ * Plugin Manager for Analytics Tracker
+ * Manages plugin registration and execution
+ */
+class PluginManager {
+    constructor() {
+        this.plugins = [];
+    }
+    /**
+     * Register a plugin
+     */
+    register(plugin) {
+        if (!plugin.name) {
+            throw new Error('Plugin must have a name');
+        }
+        this.plugins.push(plugin);
+        logger.debug(`Plugin registered: ${plugin.name}`);
+    }
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginName) {
+        const index = this.plugins.findIndex((p) => p.name === pluginName);
+        if (index !== -1) {
+            this.plugins.splice(index, 1);
+            logger.debug(`Plugin unregistered: ${pluginName}`);
+        }
+    }
+    /**
+     * Get all registered plugins
+     */
+    getPlugins() {
+        return [...this.plugins];
+    }
+    /**
+     * Execute beforeSend hooks for all plugins
+     * Returns the transformed event, or null if filtered out
+     */
+    async executeBeforeSend(event) {
+        let transformedEvent = event;
+        for (const plugin of this.plugins) {
+            if (!plugin.beforeSend)
+                continue;
+            try {
+                const result = await plugin.beforeSend(transformedEvent);
+                // If plugin returns null/undefined, filter out the event
+                if (result === null || result === undefined) {
+                    logger.debug(`Event filtered out by plugin: ${plugin.name}`);
+                    return null;
+                }
+                transformedEvent = result;
+            }
+            catch (error) {
+                logger.warn(`Plugin ${plugin.name} beforeSend hook failed:`, error);
+                // Continue with other plugins even if one fails
+            }
+        }
+        return transformedEvent;
+    }
+    /**
+     * Execute afterSend hooks for all plugins
+     */
+    async executeAfterSend(event) {
+        for (const plugin of this.plugins) {
+            if (!plugin.afterSend)
+                continue;
+            try {
+                await plugin.afterSend(event);
+            }
+            catch (error) {
+                logger.warn(`Plugin ${plugin.name} afterSend hook failed:`, error);
+            }
+        }
+    }
+    /**
+     * Execute onError hooks for all plugins
+     */
+    async executeOnError(event, error) {
+        for (const plugin of this.plugins) {
+            if (!plugin.onError)
+                continue;
+            try {
+                await plugin.onError(event, error);
+            }
+            catch (err) {
+                logger.warn(`Plugin ${plugin.name} onError hook failed:`, err);
+            }
+        }
+    }
+    /**
+     * Clear all plugins
+     */
+    clear() {
+        this.plugins = [];
+        logger.debug('All plugins cleared');
+    }
+}
+// Global plugin manager instance
+const pluginManager = new PluginManager();
+
+/**
+ * Metrics collection for analytics tracker
+ * Tracks performance and usage statistics
+ */
+class MetricsCollector {
+    constructor() {
+        this.metrics = {
+            eventsSent: 0,
+            eventsQueued: 0,
+            eventsFailed: 0,
+            eventsFiltered: 0,
+            averageSendTime: 0,
+            retryCount: 0,
+            queueSize: 0,
+            lastFlushTime: null,
+            errors: [],
+        };
+        this.sendTimes = [];
+        this.maxErrors = 100; // Keep last 100 errors
+    }
+    /**
+     * Record an event being queued
+     */
+    recordQueued() {
+        this.metrics.eventsQueued++;
+    }
+    /**
+     * Record an event being sent
+     */
+    recordSent(sendTime) {
+        this.metrics.eventsSent++;
+        this.sendTimes.push(sendTime);
+        // Keep only last 100 send times for average calculation
+        if (this.sendTimes.length > 100) {
+            this.sendTimes.shift();
+        }
+        // Calculate average
+        const sum = this.sendTimes.reduce((a, b) => a + b, 0);
+        this.metrics.averageSendTime = sum / this.sendTimes.length;
+    }
+    /**
+     * Record a failed event
+     */
+    recordFailed(error) {
+        this.metrics.eventsFailed++;
+        if (error) {
+            this.metrics.errors.push({
+                timestamp: Date.now(),
+                error: error.message || String(error),
+            });
+            // Keep only last N errors
+            if (this.metrics.errors.length > this.maxErrors) {
+                this.metrics.errors.shift();
+            }
+        }
+    }
+    /**
+     * Record a filtered event
+     */
+    recordFiltered() {
+        this.metrics.eventsFiltered++;
+    }
+    /**
+     * Record a retry
+     */
+    recordRetry() {
+        this.metrics.retryCount++;
+    }
+    /**
+     * Update queue size
+     */
+    updateQueueSize(size) {
+        this.metrics.queueSize = size;
+    }
+    /**
+     * Record flush time
+     */
+    recordFlush() {
+        this.metrics.lastFlushTime = Date.now();
+    }
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            errors: [...this.metrics.errors], // Return copy
+        };
+    }
+    /**
+     * Reset metrics
+     */
+    reset() {
+        this.metrics = {
+            eventsSent: 0,
+            eventsQueued: 0,
+            eventsFailed: 0,
+            eventsFiltered: 0,
+            averageSendTime: 0,
+            retryCount: 0,
+            queueSize: 0,
+            lastFlushTime: null,
+            errors: [],
+        };
+        this.sendTimes = [];
+        logger.debug('Metrics reset');
+    }
+    /**
+     * Get metrics summary (for logging)
+     */
+    getSummary() {
+        const m = this.metrics;
+        return `Metrics: ${m.eventsSent} sent, ${m.eventsQueued} queued, ${m.eventsFailed} failed, ${m.eventsFiltered} filtered, ${m.retryCount} retries, avg send time: ${m.averageSendTime.toFixed(2)}ms`;
+    }
+}
+// Global metrics collector instance
+const metricsCollector = new MetricsCollector();
+
+/**
+ * Analytics Service
+ * Sends analytics events to your backend API
+ *
+ * Supports both relative paths (e.g., '/api/analytics') and full URLs (e.g., 'https://your-server.com/api/analytics')
+ *
+ * Features:
+ * - Event batching and queueing
+ * - Automatic retry with exponential backoff
+ * - Offline support with localStorage persistence
+ * - Configurable logging levels
+ */
+class AnalyticsService {
+    /**
+     * Configure the analytics service
+     *
+     * @param config - Configuration object
+     * @param config.apiEndpoint - Your backend API endpoint URL
+     * @param config.batchSize - Events per batch (default: 10)
+     * @param config.batchInterval - Flush interval in ms (default: 5000)
+     * @param config.maxQueueSize - Max queued events (default: 100)
+     * @param config.maxRetries - Max retry attempts (default: 3)
+     * @param config.retryDelay - Initial retry delay in ms (default: 1000)
+     * @param config.logLevel - Logging verbosity (default: 'warn')
+     *
+     * @example
+     * ```typescript
+     * // Basic configuration
+     * AnalyticsService.configure({
+     *   apiEndpoint: 'https://api.yourcompany.com/analytics'
+     * });
+     *
+     * // Advanced configuration
+     * AnalyticsService.configure({
+     *   apiEndpoint: '/api/analytics',
+     *   batchSize: 20,
+     *   batchInterval: 10000,
+     *   maxRetries: 5,
+     *   logLevel: 'info'
+     * });
+     * ```
+     */
+    static configure(config) {
+        this.apiEndpoint = config.apiEndpoint;
+        this.config = {
+            batchSize: 10,
+            batchInterval: 5000,
+            maxQueueSize: 100,
+            maxRetries: 3,
+            retryDelay: 1000,
+            logLevel: 'warn',
+            ...config,
+        };
+        // Set log level
+        if (this.config.logLevel) {
+            logger.setLevel(this.config.logLevel);
+        }
+        // Initialize queue manager
+        this.initializeQueue();
+        // Store endpoint for sendBeacon
+        if (typeof window !== 'undefined') {
+            window.__analyticsEndpoint = this.apiEndpoint;
+        }
+        // Reset metrics if enabled
+        if (this.config.enableMetrics) {
+            metricsCollector.reset();
+        }
+        this.isInitialized = true;
+    }
+    /**
+     * Initialize the queue manager
+     */
+    static initializeQueue() {
+        if (typeof window === 'undefined')
+            return;
+        const batchSize = this.config.batchSize ?? 10;
+        const batchInterval = this.config.batchInterval ?? 5000;
+        const maxQueueSize = this.config.maxQueueSize ?? 100;
+        this.queueManager = new QueueManager({
+            batchSize,
+            batchInterval,
+            maxQueueSize,
+            storageKey: 'analytics:eventQueue',
+        });
+        // Set flush callback
+        this.queueManager.setFlushCallback(async (events) => {
+            await this.sendBatch(events);
+        });
+    }
+    /**
+     * Get queue manager instance
+     */
+    static getQueueManager() {
+        return this.queueManager;
+    }
+    /**
+     * Generate a random event ID
+     */
+    static generateEventId() {
+        const arr = new Uint32Array(4);
+        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+            crypto.getRandomValues(arr);
+            return Array.from(arr)
+                .map((n) => n.toString(16))
+                .join('');
+        }
+        // Fallback for environments without crypto
+        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    }
+    /**
+     * Send a batch of events with retry logic
+     */
+    static async sendBatch(events) {
+        if (events.length === 0)
+            return;
+        // Apply plugin transformations
+        const transformedEvents = [];
+        for (const event of events) {
+            const transformed = await pluginManager.executeBeforeSend(event);
+            if (transformed) {
+                transformedEvents.push(transformed);
+            }
+            else {
+                if (this.config.enableMetrics) {
+                    metricsCollector.recordFiltered();
+                }
+            }
+        }
+        if (transformedEvents.length === 0) {
+            logger.debug('All events filtered out by plugins');
+            return;
+        }
+        const maxRetries = this.config.maxRetries ?? 3;
+        const retryDelay = this.config.retryDelay ?? 1000;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const res = await fetch(this.apiEndpoint, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    keepalive: true,
+                    body: JSON.stringify(transformedEvents),
+                });
+                if (res.ok) {
+                    const sendTime = Date.now(); // Approximate send time
+                    logger.debug(`Successfully sent batch of ${transformedEvents.length} events`);
+                    // Record metrics
+                    if (this.config.enableMetrics) {
+                        for (let i = 0; i < transformedEvents.length; i++) {
+                            metricsCollector.recordSent(sendTime);
+                        }
+                        metricsCollector.recordFlush();
+                    }
+                    // Execute afterSend hooks
+                    for (const event of transformedEvents) {
+                        await pluginManager.executeAfterSend(event);
+                    }
+                    return;
+                }
+                // Don't retry on client errors (4xx)
+                if (res.status >= 400 && res.status < 500) {
+                    const errorText = await res.text().catch(() => 'Unknown error');
+                    logger.warn(`Client error (${res.status}): ${errorText}`);
+                    // Record metrics
+                    if (this.config.enableMetrics) {
+                        const error = new Error(`Client error: ${errorText}`);
+                        for (let i = 0; i < transformedEvents.length; i++) {
+                            metricsCollector.recordFailed(error);
+                        }
+                    }
+                    return;
+                }
+                // Retry on server errors (5xx) or network errors
+                if (attempt < maxRetries) {
+                    const delay = retryDelay * Math.pow(2, attempt); // Exponential backoff
+                    logger.debug(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+                    if (this.config.enableMetrics) {
+                        metricsCollector.recordRetry();
+                    }
+                    await this.sleep(delay);
+                }
+                else {
+                    const errorText = await res.text().catch(() => 'Unknown error');
+                    const error = new Error(`Failed after ${maxRetries} retries: ${errorText}`);
+                    // Record metrics
+                    if (this.config.enableMetrics) {
+                        for (let i = 0; i < transformedEvents.length; i++) {
+                            metricsCollector.recordFailed(error);
+                        }
+                    }
+                    // Execute onError hooks
+                    for (const event of transformedEvents) {
+                        await pluginManager.executeOnError(event, error);
+                    }
+                    throw error;
+                }
+            }
+            catch (err) {
+                // Network error - retry if attempts remaining
+                if (attempt < maxRetries) {
+                    const delay = retryDelay * Math.pow(2, attempt);
+                    logger.debug(`Network error, retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+                    if (this.config.enableMetrics) {
+                        metricsCollector.recordRetry();
+                    }
+                    await this.sleep(delay);
+                }
+                else {
+                    logger.error(`Failed to send batch after ${maxRetries} retries:`, err);
+                    // Record metrics
+                    if (this.config.enableMetrics) {
+                        const error = err instanceof Error ? err : new Error(String(err));
+                        for (let i = 0; i < transformedEvents.length; i++) {
+                            metricsCollector.recordFailed(error);
+                        }
+                    }
+                    // Execute onError hooks
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    for (const event of transformedEvents) {
+                        await pluginManager.executeOnError(event, error);
+                    }
+                    throw err;
+                }
+            }
+        }
+    }
+    /**
+     * Sleep utility for retry delays
+     */
+    static sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Track user journey/analytics event
+     * Events are automatically queued and batched
+     */
+    static async trackEvent(event) {
+        const payload = {
+            ...event,
+            timestamp: new Date(),
+            eventId: this.generateEventId(),
+        };
+        // If queue is available, use it (browser environment)
+        if (this.queueManager && typeof window !== 'undefined') {
+            this.queueManager.enqueue(payload);
+            // Record metrics
+            if (this.config.enableMetrics) {
+                metricsCollector.recordQueued();
+                metricsCollector.updateQueueSize(this.queueManager.getQueueSize());
+            }
+            return;
+        }
+        // Fallback: send immediately (SSR or queue not initialized)
+        try {
+            await this.sendBatch([payload]);
+        }
+        catch (err) {
+            logger.warn('Failed to send event:', err);
+        }
+    }
+    /**
+     * Track user journey with full context
+     */
+    static async trackUserJourney({ sessionId, pageUrl, networkInfo, deviceInfo, location, attribution, ipLocation, userId, customData, pageVisits = 1, interactions = 0, }) {
+        await this.trackEvent({
+            sessionId,
+            pageUrl,
+            networkInfo,
+            deviceInfo,
+            location,
+            attribution,
+            ipLocation,
+            userId: userId ?? sessionId,
+            customData: {
+                ...customData,
+                ...(ipLocation && { ipLocation }),
+            },
             eventName: 'page_view', // Auto-tracked as page view
         });
     }
@@ -1373,8 +2301,123 @@ class AnalyticsService {
             ...parameters,
         });
     }
+    /**
+     * Manually flush the event queue
+     * Useful for ensuring events are sent before page unload
+     */
+    static async flushQueue() {
+        if (this.queueManager) {
+            await this.queueManager.flush();
+        }
+    }
+    /**
+     * Get current queue size
+     */
+    static getQueueSize() {
+        return this.queueManager?.getQueueSize() ?? 0;
+    }
+    /**
+     * Clear the event queue
+     */
+    static clearQueue() {
+        this.queueManager?.clear();
+        if (this.config.enableMetrics) {
+            metricsCollector.updateQueueSize(0);
+        }
+    }
+    /**
+     * Get metrics (if enabled)
+     */
+    static getMetrics() {
+        if (!this.config.enableMetrics) {
+            logger.warn('Metrics collection is not enabled. Set enableMetrics: true in config.');
+            return null;
+        }
+        return metricsCollector.getMetrics();
+    }
 }
 AnalyticsService.apiEndpoint = '/api/analytics';
+AnalyticsService.queueManager = null;
+AnalyticsService.config = {};
+AnalyticsService.isInitialized = false;
+
+/**
+ * Debug utilities for analytics tracker
+ * Provides debugging tools in development mode
+ */
+/**
+ * Initialize debug utilities (only in development)
+ */
+function initDebug() {
+    if (typeof window === 'undefined')
+        return;
+    const isDevelopment = typeof process !== 'undefined' &&
+        process.env?.NODE_ENV === 'development';
+    if (!isDevelopment) {
+        return;
+    }
+    const debug = {
+        /**
+         * Get current queue state
+         */
+        getQueue: () => {
+            const queueManager = AnalyticsService.getQueueManager();
+            if (!queueManager) {
+                logger.warn('Queue manager not initialized');
+                return [];
+            }
+            return queueManager.getQueue();
+        },
+        /**
+         * Get queue size
+         */
+        getQueueSize: () => {
+            return AnalyticsService.getQueueSize();
+        },
+        /**
+         * Manually flush the queue
+         */
+        flushQueue: async () => {
+            logger.info('Manually flushing queue...');
+            await AnalyticsService.flushQueue();
+            logger.info('Queue flushed');
+        },
+        /**
+         * Clear the queue
+         */
+        clearQueue: () => {
+            logger.info('Clearing queue...');
+            AnalyticsService.clearQueue();
+            logger.info('Queue cleared');
+        },
+        /**
+         * Get debug statistics
+         */
+        getStats: () => {
+            const queueManager = AnalyticsService.getQueueManager();
+            const metrics = AnalyticsService.getMetrics();
+            return {
+                queueSize: AnalyticsService.getQueueSize(),
+                queue: queueManager?.getQueue() ?? [],
+                config: {
+                    metrics: metrics,
+                    metricsSummary: metrics ? metricsCollector.getSummary() : 'Metrics disabled',
+                },
+            };
+        },
+        /**
+         * Set log level
+         */
+        setLogLevel: (level) => {
+            logger.setLevel(level);
+            logger.info(`Log level set to: ${level}`);
+        },
+    };
+    // Expose to window for console access
+    window.__analyticsDebug = debug;
+    logger.info('Analytics debug tools available at window.__analyticsDebug');
+    logger.info('Available methods: getQueue(), getQueueSize(), flushQueue(), clearQueue(), getStats(), setLogLevel()');
+}
 
 /**
  * React Hook for Analytics Tracking
@@ -1396,9 +2439,29 @@ function useAnalytics(options = {}) {
     // Configure analytics service if endpoint provided
     react.useEffect(() => {
         if (config?.apiEndpoint) {
-            AnalyticsService.configure({ apiEndpoint: config.apiEndpoint });
+            AnalyticsService.configure({
+                apiEndpoint: config.apiEndpoint,
+                batchSize: config.batchSize,
+                batchInterval: config.batchInterval,
+                maxQueueSize: config.maxQueueSize,
+                maxRetries: config.maxRetries,
+                retryDelay: config.retryDelay,
+                logLevel: config.logLevel,
+                enableMetrics: config.enableMetrics,
+                sessionTimeout: config.sessionTimeout,
+            });
         }
-    }, [config?.apiEndpoint]);
+    }, [
+        config?.apiEndpoint,
+        config?.batchSize,
+        config?.batchInterval,
+        config?.maxQueueSize,
+        config?.maxRetries,
+        config?.retryDelay,
+        config?.logLevel,
+        config?.enableMetrics,
+        config?.sessionTimeout,
+    ]);
     const [networkInfo, setNetworkInfo] = react.useState(null);
     const [deviceInfo, setDeviceInfo] = react.useState(null);
     const [attribution, setAttribution] = react.useState(null);
@@ -1423,6 +2486,10 @@ function useAnalytics(options = {}) {
             };
         }
     }, []);
+    // Initialize debug tools in development
+    react.useEffect(() => {
+        initDebug();
+    }, []);
     const refresh = react.useCallback(async () => {
         const net = NetworkDetector.detect();
         const dev = await DeviceDetector.detect();
@@ -1495,6 +2562,8 @@ function useAnalytics(options = {}) {
             if (autoSend) {
                 // Send after idle to not block paint
                 const send = async () => {
+                    // Extract IP location data if available (stored in ipLocationData field)
+                    const ipLocationData = loc?.ipLocationData;
                     await AnalyticsService.trackUserJourney({
                         sessionId: getOrCreateUserId(),
                         pageUrl: typeof window !== 'undefined' ? window.location.href : '',
@@ -1502,6 +2571,7 @@ function useAnalytics(options = {}) {
                         deviceInfo: dev,
                         location: loc,
                         attribution: attr,
+                        ipLocation: ipLocationData,
                         customData: config?.enableLocation ? { locationEnabled: true } : undefined,
                     });
                 };
@@ -1517,6 +2587,8 @@ function useAnalytics(options = {}) {
     const logEvent = react.useCallback(async (customData) => {
         if (!sessionId || !networkInfo || !deviceInfo)
             return;
+        // Extract IP location data if available (stored in ipLocationData field)
+        const ipLocationData = location ? location?.ipLocationData : undefined;
         await AnalyticsService.trackUserJourney({
             sessionId,
             pageUrl: typeof window !== 'undefined' ? window.location.href : '',
@@ -1524,6 +2596,7 @@ function useAnalytics(options = {}) {
             deviceInfo,
             location: location ?? undefined,
             attribution: attribution ?? undefined,
+            ipLocation: ipLocationData,
             userId: sessionId,
             customData,
         });
@@ -1621,6 +2694,17 @@ function useAnalytics(options = {}) {
     const incrementInteraction = react.useCallback(() => {
         setInteractions((n) => n + 1);
     }, []);
+    // Session management
+    react.useEffect(() => {
+        if (config?.sessionTimeout) {
+            getOrCreateSession(config.sessionTimeout);
+            // Update session activity on user interactions
+            const activityInterval = setInterval(() => {
+                updateSessionActivity();
+            }, 60000); // Update every minute
+            return () => clearInterval(activityInterval);
+        }
+    }, [config?.sessionTimeout]);
     return react.useMemo(() => ({
         sessionId,
         networkInfo,
@@ -1650,186 +2734,32 @@ function useAnalytics(options = {}) {
     ]);
 }
 
-/**
- * IP Geolocation Service
- * Fetches location data (country, region, city) from user's IP address
- * Uses free tier of ip-api.com (no API key required, 45 requests/minute)
- */
-/**
- * Get public IP address using ip-api.com
- * Free tier: 45 requests/minute, no API key required
- *
- * @returns Promise<string | null> - The public IP address, or null if unavailable
- *
- * @example
- * ```typescript
- * const ip = await getPublicIP();
- * console.log('Your IP:', ip); // e.g., "203.0.113.42"
- * ```
- */
-async function getPublicIP() {
-    // Skip if we're in an environment without fetch (SSR)
-    if (typeof fetch === 'undefined') {
-        return null;
-    }
-    try {
-        // Call ip-api.com without IP parameter - it auto-detects user's IP
-        // Using HTTPS endpoint for better security
-        const response = await fetch('https://ip-api.com/json/?fields=status,message,query', {
-            method: 'GET',
-            headers: {
-                Accept: 'application/json',
-            },
-            // Add timeout to prevent hanging
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!response.ok) {
-            return null;
-        }
-        const data = await response.json();
-        // ip-api.com returns status field
-        if (data.status === 'fail') {
-            return null;
-        }
-        return data.query || null;
-    }
-    catch (error) {
-        // Silently fail - don't break user experience
-        if (error.name !== 'AbortError') {
-            console.warn('[IP Geolocation] Error fetching public IP:', error.message);
-        }
-        return null;
-    }
-}
-/**
- * Get location from IP address using ip-api.com
- * Free tier: 45 requests/minute, no API key required
- *
- * Alternative services:
- * - ipapi.co (requires API key for production)
- * - ipgeolocation.io (requires API key)
- * - ip-api.com (free tier available)
- */
-async function getIPLocation(ip) {
-    // Skip localhost/private IPs (these can't be geolocated)
-    if (!ip ||
-        ip === '0.0.0.0' ||
-        ip === '::1' ||
-        ip.startsWith('127.') ||
-        ip.startsWith('192.168.') ||
-        ip.startsWith('10.') ||
-        ip.startsWith('172.') ||
-        ip.startsWith('::ffff:127.')) {
-        console.log(`[IP Geolocation] Skipping localhost/private IP: ${ip} (geolocation not available for local IPs)`);
-        return null;
-    }
-    try {
-        // Using ip-api.com free tier (JSON format)
-        const response = await fetch(`http://ip-api.com/json/${ip}?fields=status,message,country,countryCode,region,regionName,city,lat,lon,timezone,isp,org,as,query`, {
-            method: 'GET',
-            headers: {
-                Accept: 'application/json',
-            },
-            // Add timeout to prevent hanging
-            signal: AbortSignal.timeout(3000),
-        });
-        if (!response.ok) {
-            console.warn(`[IP Geolocation] Failed to fetch location for IP ${ip}: ${response.status}`);
-            return null;
-        }
-        const data = await response.json();
-        // ip-api.com returns status field
-        if (data.status === 'fail') {
-            console.warn(`[IP Geolocation] API error for IP ${ip}: ${data.message}`);
-            return null;
-        }
-        return {
-            ip: data.query || ip,
-            country: data.country || undefined,
-            countryCode: data.countryCode || undefined,
-            region: data.region || undefined,
-            regionName: data.regionName || undefined,
-            city: data.city || undefined,
-            lat: data.lat || undefined,
-            lon: data.lon || undefined,
-            timezone: data.timezone || undefined,
-            isp: data.isp || undefined,
-            org: data.org || undefined,
-            as: data.as || undefined,
-            query: data.query || ip,
-        };
-    }
-    catch (error) {
-        // Silently fail - don't break user experience
-        if (error.name !== 'AbortError') {
-            console.warn(`[IP Geolocation] Error fetching location for IP ${ip}:`, error.message);
-        }
-        return null;
-    }
-}
-/**
- * Get IP address from request headers
- * Handles various proxy headers (x-forwarded-for, x-real-ip, etc.)
- */
-function getIPFromRequest(req) {
-    // Try various headers that proxies/load balancers use
-    const forwardedFor = req.headers?.get?.('x-forwarded-for') ||
-        req.headers?.['x-forwarded-for'] ||
-        req.headers?.['X-Forwarded-For'];
-    if (forwardedFor) {
-        // x-forwarded-for can contain multiple IPs, take the first one
-        const ips = forwardedFor.split(',').map((ip) => ip.trim());
-        const ip = ips[0];
-        if (ip && ip !== '0.0.0.0') {
-            return ip;
-        }
-    }
-    const realIP = req.headers?.get?.('x-real-ip') ||
-        req.headers?.['x-real-ip'] ||
-        req.headers?.['X-Real-IP'];
-    if (realIP && realIP !== '0.0.0.0') {
-        return realIP.trim();
-    }
-    // Try req.ip (from Express/Next.js)
-    if (req.ip && req.ip !== '0.0.0.0') {
-        return req.ip;
-    }
-    // For localhost, detect if we're running locally
-    if (typeof window === 'undefined') {
-        const hostname = req.headers?.get?.('host') || req.headers?.['host'];
-        if (hostname &&
-            (hostname.includes('localhost') ||
-                hostname.includes('127.0.0.1') ||
-                hostname.startsWith('192.168.'))) {
-            return '127.0.0.1'; // Localhost IP
-        }
-    }
-    // If no IP found and we're in development, return localhost
-    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') {
-        return '127.0.0.1'; // Localhost for development
-    }
-    return '0.0.0.0';
-}
-
 exports.AnalyticsService = AnalyticsService;
 exports.AttributionDetector = AttributionDetector;
 exports.DeviceDetector = DeviceDetector;
 exports.LocationDetector = LocationDetector;
 exports.NetworkDetector = NetworkDetector;
+exports.QueueManager = QueueManager;
 exports.checkAndSetLocationConsent = checkAndSetLocationConsent;
 exports.clearLocationConsent = clearLocationConsent;
+exports.clearSession = clearSession;
 exports.default = useAnalytics;
 exports.getIPFromRequest = getIPFromRequest;
 exports.getIPLocation = getIPLocation;
 exports.getLocationConsentTimestamp = getLocationConsentTimestamp;
+exports.getOrCreateSession = getOrCreateSession;
 exports.getOrCreateUserId = getOrCreateUserId;
 exports.getPublicIP = getPublicIP;
+exports.getSession = getSession;
 exports.hasLocationConsent = hasLocationConsent;
+exports.initDebug = initDebug;
 exports.loadJSON = loadJSON;
 exports.loadSessionJSON = loadSessionJSON;
+exports.logger = logger;
 exports.saveJSON = saveJSON;
 exports.saveSessionJSON = saveSessionJSON;
 exports.setLocationConsentGranted = setLocationConsentGranted;
 exports.trackPageVisit = trackPageVisit;
+exports.updateSessionActivity = updateSessionActivity;
 exports.useAnalytics = useAnalytics;
 //# sourceMappingURL=index.cjs.js.map