user-analytics-tracker 1.2.0

package/dist/index.cjs.js

@@ -0,0 +1,1835 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('react');
+
+/**
+ * Network Type Detector
+ * Detects WiFi, Mobile Data (Cellular), Hotspot, Ethernet, or Unknown
+ */
+class NetworkDetector {
+    static detect() {
+        if (typeof navigator === 'undefined') {
+            return { type: 'unknown' };
+        }
+        const c = navigator.connection ||
+            navigator.mozConnection ||
+            navigator.webkitConnection;
+        if (!c) {
+            // Fallback: guess based on user agent
+            const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+            return { type: isMobile ? 'cellular' : 'wifi' };
+        }
+        let type = 'unknown';
+        // Method 1: Direct type property (most reliable)
+        if (c.type) {
+            const connectionType = c.type.toLowerCase();
+            switch (connectionType) {
+                case 'wifi':
+                case 'wlan':
+                    type = 'wifi';
+                    break;
+                case 'cellular':
+                case '2g':
+                case '3g':
+                case '4g':
+                case '5g':
+                    type = 'cellular';
+                    break;
+                case 'ethernet':
+                    type = 'ethernet';
+                    break;
+                case 'none':
+                    type = 'unknown';
+                    break;
+                default:
+                    type = connectionType;
+            }
+        }
+        // Method 2: Heuristic-based detection using multiple signals
+        // Note: effectiveType indicates speed/quality, NOT connection type
+        // A WiFi connection can have effectiveType "4g" if it's fast
+        else {
+            const downlink = c.downlink || 0;
+            const rtt = c.rtt || 0;
+            const saveData = c.saveData || false;
+            c.effectiveType?.toLowerCase() || '';
+            const isMobileDevice = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
+            const isDesktop = !isMobileDevice;
+            // Data saver mode strongly suggests cellular
+            if (saveData) {
+                type = 'cellular';
+            }
+            // Desktop/laptop devices are almost always WiFi or Ethernet (not cellular)
+            else if (isDesktop) {
+                // Very high speeds (>50 Mbps) are likely Ethernet
+                // Medium-high speeds (10-50 Mbps) are likely WiFi
+                // Lower speeds could be WiFi or Ethernet depending on connection quality
+                if (downlink > 50) {
+                    type = 'ethernet';
+                }
+                else if (downlink > 5) {
+                    type = 'wifi';
+                }
+                else {
+                    // Low speed on desktop - likely poor WiFi, but still WiFi
+                    type = 'wifi';
+                }
+            }
+            // Mobile device: need to distinguish between WiFi, cellular, and hotspot
+            else {
+                // Very fast connection (>20 Mbps) on mobile = almost certainly WiFi
+                if (downlink > 20) {
+                    type = 'wifi';
+                }
+                // Fast connection (10-20 Mbps) = likely WiFi (even with moderate RTT)
+                // WiFi can have RTT up to ~150ms depending on router/network quality
+                else if (downlink >= 10) {
+                    type = 'wifi';
+                }
+                // Medium-fast connection (5-10 Mbps) with reasonable latency = likely WiFi
+                else if (downlink >= 5 && rtt < 150) {
+                    type = 'wifi';
+                }
+                // Medium speed (1-5 Mbps) with low latency = likely WiFi
+                else if (downlink >= 1 && rtt < 100) {
+                    type = 'wifi';
+                }
+                // Very slow connection with high latency = likely hotspot
+                else if (downlink > 0 && downlink < 1 && rtt > 300) {
+                    type = 'hotspot';
+                }
+                // Medium speed with high latency = likely hotspot
+                else if (downlink >= 1 && downlink < 5 && rtt > 200) {
+                    type = 'hotspot';
+                }
+                // Low speed with very high latency = likely hotspot
+                else if (downlink >= 1 && downlink < 3 && rtt > 250) {
+                    type = 'hotspot';
+                }
+                // Otherwise, default to cellular for mobile devices
+                // But prefer WiFi if we have decent speed indicators
+                else if (downlink >= 3) {
+                    type = 'wifi';
+                }
+                else {
+                    type = 'cellular';
+                }
+            }
+        }
+        // Additional hotspot detection: Check for tethering indicators
+        // Some browsers expose this via connection.type = 'wifi' but with mobile-like characteristics
+        // Only override if we're very confident it's a hotspot (very slow + high latency)
+        if (type === 'wifi' && c.downlink && c.downlink < 2 && c.rtt && c.rtt > 250) {
+            const isMobileUA = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
+            if (isMobileUA) {
+                // Mobile device with wifi but very slow connection + high latency = likely hotspot
+                type = 'hotspot';
+            }
+        }
+        return {
+            type,
+            effectiveType: c?.effectiveType,
+            downlink: c?.downlink,
+            rtt: c?.rtt,
+            saveData: c?.saveData,
+            connectionType: c?.type,
+        };
+    }
+}
+
+var networkDetector = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    NetworkDetector: NetworkDetector
+});
+
+/**
+ * Device Information Detector
+ * Detects device type, OS, browser, and hardware specs
+ */
+class DeviceDetector {
+    static async getRealDeviceInfo() {
+        const nau = navigator.userAgentData;
+        if (nau?.getHighEntropyValues) {
+            try {
+                const v = await nau.getHighEntropyValues([
+                    'platform',
+                    'platformVersion',
+                    'model',
+                    'uaFullVersion',
+                    'brands',
+                ]);
+                return {
+                    platform: v.platform || 'Unknown',
+                    platformVersion: v.platformVersion || 'Unknown',
+                    model: v.model || 'Unknown',
+                    fullVersion: v.uaFullVersion || 'Unknown',
+                    brands: v.brands || [],
+                };
+            }
+            catch {
+                // Fallback to UA parsing
+            }
+        }
+        const ua = navigator.userAgent;
+        let platform = 'Unknown', platformVersion = 'Unknown', model = 'Unknown';
+        if (/Android/i.test(ua)) {
+            platform = 'Android';
+            platformVersion = ua.match(/Android\s([\d.]+)/)?.[1] || 'Unknown';
+            const androidModelMatch = ua.match(/;\s*([^;)]+)\s*\)/);
+            if (androidModelMatch) {
+                const deviceStr = androidModelMatch[1];
+                if (deviceStr && deviceStr.length < 50) {
+                    model = deviceStr.trim();
+                }
+            }
+            if (model === 'Unknown') {
+                const buildMatch = ua.match(/Build\/([A-Z0-9_-]+)/);
+                if (buildMatch) {
+                    const codename = buildMatch[1].split('_')[0];
+                    if (codename && codename.length > 2 && codename.length < 20) {
+                        model = codename;
+                    }
+                }
+            }
+        }
+        else if (/iPhone|iPad|iPod/i.test(ua)) {
+            platform = 'iOS';
+            const m = ua.match(/OS\s(\d+[._]\d+(?:[._]\d+)?)/);
+            platformVersion = m ? m[1].replace(/_/g, '.') : 'Unknown';
+            if (/iPad/i.test(ua)) {
+                if (/iPad13/i.test(ua))
+                    model = 'iPad Pro 12.9" (5th gen)';
+                else if (/iPad14/i.test(ua))
+                    model = 'iPad Pro 11" (3rd gen)';
+                else if (/iPad11/i.test(ua))
+                    model = 'iPad (9th gen)';
+                else if (/iPad12/i.test(ua))
+                    model = 'iPad mini (6th gen)';
+                else
+                    model = 'iPad';
+            }
+            else if (/iPhone/i.test(ua)) {
+                if (/iPhone15/i.test(ua))
+                    model = 'iPhone 15';
+                else if (/iPhone14/i.test(ua))
+                    model = 'iPhone 14';
+                else if (/iPhone13/i.test(ua))
+                    model = 'iPhone 13';
+                else if (/iPhone12/i.test(ua))
+                    model = 'iPhone 12';
+                else if (/iPhone11/i.test(ua))
+                    model = 'iPhone 11';
+                else {
+                    const modelMatch = ua.match(/iPhone\s*OS\s+\d+[._]\d+[^;]*;\s*([^)]+)/);
+                    model = modelMatch ? modelMatch[1].trim() : 'iPhone';
+                }
+            }
+            else {
+                model = 'iOS Device';
+            }
+        }
+        else if (/Mac OS X/i.test(ua)) {
+            platform = 'macOS';
+            const m = ua.match(/Mac OS X\s(\d+[._]\d+(?:[._]\d+)?)/);
+            platformVersion = m ? m[1].replace(/_/g, '.') : 'Unknown';
+            model = 'Mac';
+        }
+        else if (/Windows NT/i.test(ua)) {
+            platform = 'Windows';
+            if (/Windows NT 10\.0/i.test(ua))
+                platformVersion = '10/11';
+            else if (/Windows NT 6\.3/i.test(ua))
+                platformVersion = '8.1';
+            else if (/Windows NT 6\.2/i.test(ua))
+                platformVersion = '8';
+            else if (/Windows NT 6\.1/i.test(ua))
+                platformVersion = '7';
+        }
+        else if (/CrOS/i.test(ua)) {
+            platform = 'Chrome OS';
+            const versionMatch = ua.match(/CrOS\s+[^\s]+\s+(\d+\.\d+\.\d+)/);
+            platformVersion = versionMatch ? versionMatch[1] : 'Unknown';
+        }
+        else if (/Linux/i.test(ua)) {
+            platform = 'Linux';
+            if (/Ubuntu/i.test(ua)) {
+                platform = 'Ubuntu';
+                const ubuntuMatch = ua.match(/Ubuntu[/\s](\d+\.\d+)/);
+                platformVersion = ubuntuMatch ? ubuntuMatch[1] : 'Unknown';
+            }
+        }
+        return { platform, platformVersion, model, fullVersion: 'Unknown' };
+    }
+    static detectBrowser(ua) {
+        if (/Chrome/i.test(ua) && !/Edg|OPR/i.test(ua))
+            return {
+                browser: 'Chrome',
+                version: ua.match(/Chrome\/(\d+\.\d+)/)?.[1] || 'Unknown',
+            };
+        if (/Firefox/i.test(ua))
+            return {
+                browser: 'Firefox',
+                version: ua.match(/Firefox\/(\d+\.\d+)/)?.[1] || 'Unknown',
+            };
+        if (/Safari/i.test(ua) && !/Chrome/i.test(ua))
+            return {
+                browser: 'Safari',
+                version: ua.match(/Version\/(\d+\.\d+)/)?.[1] || 'Unknown',
+            };
+        if (/Edg/i.test(ua))
+            return {
+                browser: 'Edge',
+                version: ua.match(/Edg\/(\d+\.\d+)/)?.[1] || 'Unknown',
+            };
+        if (/OPR/i.test(ua))
+            return {
+                browser: 'Opera',
+                version: ua.match(/OPR\/(\d+\.\d+)/)?.[1] || 'Unknown',
+            };
+        return { browser: 'Unknown', version: 'Unknown' };
+    }
+    static async detect() {
+        if (typeof navigator === 'undefined') {
+            return this.getDefaultDeviceInfo();
+        }
+        const ua = navigator.userAgent;
+        const real = await this.getRealDeviceInfo();
+        // OS detection
+        let os = real.platform || 'Unknown';
+        let osVersion = real.platformVersion || 'Unknown';
+        if (/Android/i.test(ua)) {
+            os = 'Android';
+            osVersion =
+                real.platformVersion !== 'Unknown'
+                    ? real.platformVersion
+                    : ua.match(/Android\s([\d.]+)/)?.[1] || 'Unknown';
+        }
+        else if (/iPhone|iPad|iPod/i.test(ua)) {
+            os = 'iOS';
+            osVersion =
+                ua.match(/OS\s(\d+[._]\d+(?:[._]\d+)?)/)?.[1]?.replace(/_/g, '.') || 'Unknown';
+        }
+        else if (/Mac OS X/i.test(ua)) {
+            os = 'macOS';
+            osVersion =
+                real.platformVersion !== 'Unknown'
+                    ? real.platformVersion
+                    : ua.match(/Mac OS X\s(\d+[._]\d+(?:[._]\d+)?)/)?.[1]?.replace(/_/g, '.') ||
+                        'Unknown';
+        }
+        else if (/Windows NT 10/i.test(ua)) {
+            os = 'Windows';
+            osVersion = '10/11';
+        }
+        else if (/CrOS/i.test(ua)) {
+            os = 'Chrome OS';
+        }
+        else if (/Linux/i.test(ua)) {
+            os = 'Linux';
+        }
+        // Device type
+        const type = /Android|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i.test(ua)
+            ? 'mobile'
+            : /iPad|Tablet|PlayBook|Silk/i.test(ua)
+                ? 'tablet'
+                : 'desktop';
+        // Brand detection
+        const brand = this.detectBrand(ua);
+        // Browser detection
+        const { browser, version: browserVersion } = this.detectBrowser(ua);
+        // Model detection
+        let deviceModel = real.model !== 'Unknown' ? real.model : 'Unknown';
+        if (deviceModel === 'Unknown' || deviceModel === brand) {
+            if (/Android/i.test(ua)) {
+                const buildMatch = ua.match(/Build\/([A-Z0-9_-]+)/);
+                if (buildMatch) {
+                    const codename = buildMatch[1].split('_')[0];
+                    if (codename && codename.length > 2 && codename.length < 20) {
+                        deviceModel = codename;
+                    }
+                }
+                if (deviceModel === 'Unknown' || deviceModel === brand) {
+                    const deviceMatch = ua.match(/;\s*([^;)]+)\s*\)/);
+                    if (deviceMatch) {
+                        const cleaned = deviceMatch[1]
+                            .replace(/^Linux\s+/, '')
+                            .replace(/^Android\s+/, '')
+                            .replace(/\s+Build\/.*$/, '')
+                            .trim();
+                        if (cleaned && cleaned.length < 50) {
+                            deviceModel = cleaned;
+                        }
+                    }
+                }
+            }
+            if ((deviceModel === 'Unknown' || deviceModel === brand) && /iPhone|iPad|iPod/i.test(ua)) {
+                const iosModelMatch = ua.match(/(iPhone|iPad|iPod)[\s\d,]+/);
+                if (iosModelMatch) {
+                    deviceModel = iosModelMatch[0].trim();
+                }
+            }
+        }
+        if (deviceModel === 'Unknown') {
+            deviceModel = brand;
+        }
+        // CPU architecture
+        const cpuArchitecture = /ARM|ARM64|aarch64/i.test(ua)
+            ? 'ARM'
+            : /x64|WOW64|Win64|x86_64/i.test(ua)
+                ? 'x64'
+                : 'x86';
+        return {
+            type,
+            os,
+            osVersion,
+            browser,
+            browserVersion,
+            screenResolution: `${window.screen.width}x${window.screen.height}`,
+            deviceModel,
+            deviceBrand: brand,
+            language: navigator.language,
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            userAgent: ua,
+            deviceMemory: navigator.deviceMemory,
+            hardwareConcurrency: navigator.hardwareConcurrency || 0,
+            touchSupport: 'ontouchstart' in window || navigator.maxTouchPoints > 0,
+            pixelRatio: window.devicePixelRatio || 1,
+            colorDepth: window.screen.colorDepth,
+            orientation: window.screen.orientation ? window.screen.orientation.type : 'unknown',
+            cpuArchitecture,
+        };
+    }
+    static detectBrand(ua) {
+        return /iPhone|iPad|iPod|Macintosh|Mac OS X/i.test(ua)
+            ? 'Apple'
+            : /Samsung|SM-|GT-|SCH-|SGH-|SHV-|SHM-|Galaxy|Note|S[0-9]+|A[0-9]+|J[0-9]+|M[0-9]+|F[0-9]+/i.test(ua)
+                ? 'Samsung'
+                : /Pixel|Nexus|Google|Chrome|Chromebook/i.test(ua)
+                    ? 'Google'
+                    : /OnePlus|ONEPLUS|OP[A-Z0-9]+/i.test(ua)
+                        ? 'OnePlus'
+                        : /Mi\s|Redmi|Xiaomi|POCO|MI\s|HM\s|M[0-9]+[A-Z]/i.test(ua)
+                            ? 'Xiaomi'
+                            : /Huawei|HWI-|HUAWEI|Honor|HONOR|ELE-|VOG-|LIO-|ANA-/i.test(ua)
+                                ? 'Huawei'
+                                : /Oppo|OPPO|CPH|OPD|OP[A-Z0-9]+|Reno|Find/i.test(ua)
+                                    ? 'Oppo'
+                                    : /Vivo|VIVO|V[0-9]+|Y[0-9]+|X[0-9]+/i.test(ua)
+                                        ? 'Vivo'
+                                        : /Motorola|Moto|XT[0-9]+|Moto\s/i.test(ua)
+                                            ? 'Motorola'
+                                            : /LG|LGE|LM-|LG-[A-Z0-9]+/i.test(ua)
+                                                ? 'LG'
+                                                : /Sony|Xperia|SO-|SOV|XQ-[A-Z0-9]+/i.test(ua)
+                                                    ? 'Sony'
+                                                    : /Nokia|TA-[0-9]+|Nokia\s/i.test(ua)
+                                                        ? 'Nokia'
+                                                        : /Realme|RMX|RM[A-Z0-9]+/i.test(ua)
+                                                            ? 'Realme'
+                                                            : /Infinix|Infinix\s|X[0-9]+/i.test(ua)
+                                                                ? 'Infinix'
+                                                                : /Tecno|TECNO|TECNO\s|T[A-Z0-9]+/i.test(ua)
+                                                                    ? 'Tecno'
+                                                                    : /Asus|ASUS|ZenFone|ROG/i.test(ua)
+                                                                        ? 'Asus'
+                                                                        : /Lenovo|ThinkPad|IdeaPad/i.test(ua)
+                                                                            ? 'Lenovo'
+                                                                            : /HP|Hewlett-Packard/i.test(ua)
+                                                                                ? 'HP'
+                                                                                : /Dell/i.test(ua)
+                                                                                    ? 'Dell'
+                                                                                    : /Acer/i.test(ua)
+                                                                                        ? 'Acer'
+                                                                                        : /Microsoft|Surface/i.test(ua)
+                                                                                            ? 'Microsoft'
+                                                                                            : 'Unknown';
+    }
+    static getDefaultDeviceInfo() {
+        return {
+            type: 'desktop',
+            os: 'Unknown',
+            osVersion: 'Unknown',
+            browser: 'Unknown',
+            browserVersion: 'Unknown',
+            screenResolution: 'Unknown',
+            deviceModel: 'Unknown',
+            deviceBrand: 'Unknown',
+            language: 'en-US',
+            timezone: 'UTC',
+            userAgent: 'Server',
+            touchSupport: false,
+            pixelRatio: 1,
+            colorDepth: 24,
+            orientation: 'unknown',
+            cpuArchitecture: 'x86',
+            hardwareConcurrency: 0,
+        };
+    }
+}
+
+var deviceDetector = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DeviceDetector: DeviceDetector
+});
+
+/**
+ * Location Consent Manager
+ * When user enters MSISDN, they implicitly consent to location tracking
+ * This utility manages the consent state and prevents unnecessary permission prompts
+ */
+const LOCATION_CONSENT_KEY = 'analytics:locationConsent';
+const LOCATION_CONSENT_TIMESTAMP_KEY = 'analytics:locationConsentTimestamp';
+/**
+ * Set location consent as granted (when MSISDN is provided)
+ */
+function setLocationConsentGranted() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const timestamp = new Date().toISOString();
+        localStorage.setItem(LOCATION_CONSENT_KEY, 'granted');
+        localStorage.setItem(LOCATION_CONSENT_TIMESTAMP_KEY, timestamp);
+        console.log('[Location Consent] Granted at:', timestamp);
+    }
+    catch (error) {
+        console.warn('[Location Consent] Failed to save consent:', error);
+    }
+}
+/**
+ * Check if location consent has been granted
+ */
+function hasLocationConsent() {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        const consent = localStorage.getItem(LOCATION_CONSENT_KEY);
+        return consent === 'granted';
+    }
+    catch (error) {
+        console.warn('[Location Consent] Failed to check consent:', error);
+        return false;
+    }
+}
+/**
+ * Get location consent timestamp
+ */
+function getLocationConsentTimestamp() {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        return localStorage.getItem(LOCATION_CONSENT_TIMESTAMP_KEY);
+    }
+    catch (_error) {
+        return null;
+    }
+}
+/**
+ * Clear location consent (for testing or user revocation)
+ */
+function clearLocationConsent() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.removeItem(LOCATION_CONSENT_KEY);
+        localStorage.removeItem(LOCATION_CONSENT_TIMESTAMP_KEY);
+        console.log('[Location Consent] Cleared');
+    }
+    catch (error) {
+        console.warn('[Location Consent] Failed to clear consent:', error);
+    }
+}
+/**
+ * Check if MSISDN is provided and set consent accordingly
+ * Call this whenever MSISDN is detected
+ */
+function checkAndSetLocationConsent(msisdn) {
+    if (msisdn && typeof msisdn === 'string' && msisdn.trim().length > 0) {
+        // User has provided MSISDN, which means they consent to location tracking
+        setLocationConsentGranted();
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Location Detector
+ * Detects GPS location with consent management, falls back to IP-based location API
+ * IP-based location works automatically without user permission
+ */
+class LocationDetector {
+    /**
+     * Detect location using IP-based API only (no GPS, no permission needed)
+     * Fast and automatic - works immediately without user interaction
+     */
+    static async detectIPOnly() {
+        // Return cached IP location if available
+        if (this.lastIPLocationRef.current) {
+            return this.lastIPLocationRef.current;
+        }
+        // Get IP-based location (no permission required)
+        const ipLocation = await this.getIPBasedLocation();
+        this.lastLocationRef.current = ipLocation;
+        return ipLocation;
+    }
+    /**
+     * Detect location with automatic consent granted
+     * Tries GPS first (if available), then falls back to IP-based location
+     * Automatically sets location consent to bypass permission checks
+     */
+    static async detectWithAutoConsent() {
+        // Automatically grant location consent
+        setLocationConsentGranted();
+        // Clear cache to force fresh detection
+        this.lastLocationRef.current = null;
+        // Now detect with consent granted
+        return this.detect();
+    }
+    /**
+     * Get browser GPS location
+     * Respects location consent (set via MSISDN entry)
+     * Falls back to IP-based location automatically if GPS fails
+     */
+    static async detect() {
+        // Check if user has granted location consent via MSISDN entry
+        const userHasConsent = hasLocationConsent();
+        if (this.lastLocationRef.current &&
+            userHasConsent &&
+            this.lastLocationRef.current.permission !== 'granted') {
+            // Consent was granted but cached location has wrong permission - clear cache
+            console.log('[Location] Consent detected but cache has wrong permission - clearing cache');
+            this.lastLocationRef.current = null;
+        }
+        // Return cached location if available and permission matches consent status
+        if (this.lastLocationRef.current) {
+            // If we have consent, ensure cached location reflects it
+            if (userHasConsent && this.lastLocationRef.current.permission !== 'granted') {
+                // Update cached location to reflect consent
+                this.lastLocationRef.current = {
+                    ...this.lastLocationRef.current,
+                    permission: 'granted',
+                };
+            }
+            return this.lastLocationRef.current;
+        }
+        // Prevent multiple simultaneous location requests
+        if (this.locationFetchingRef.current) {
+            // Return a default promise that will resolve when current fetch completes
+            return new Promise((resolve) => {
+                const checkInterval = setInterval(() => {
+                    if (this.lastLocationRef.current) {
+                        clearInterval(checkInterval);
+                        resolve(this.lastLocationRef.current);
+                    }
+                    else if (!this.locationFetchingRef.current) {
+                        clearInterval(checkInterval);
+                        resolve({
+                            source: 'unknown',
+                            permission: userHasConsent ? 'granted' : 'prompt',
+                        });
+                    }
+                }, 50);
+            });
+        }
+        if (typeof navigator === 'undefined' || !('geolocation' in navigator)) {
+            // GPS not supported, try IP-based location as fallback
+            console.log('[Location] GPS not supported, using IP-based location API...');
+            try {
+                const ipLocation = await this.getIPBasedLocation();
+                this.lastLocationRef.current = ipLocation;
+                return ipLocation;
+            }
+            catch (_ipError) {
+                const unsupportedResult = {
+                    source: 'unknown',
+                    permission: 'unsupported',
+                };
+                this.lastLocationRef.current = unsupportedResult;
+                return unsupportedResult;
+            }
+        }
+        // Helper with timeout so we never block forever
+        // Reduced timeout to 2 seconds for faster fallback to IP
+        const withTimeout = (p, ms = 2000) => new Promise((resolve) => {
+            let settled = false;
+            const t = setTimeout(async () => {
+                if (!settled) {
+                    settled = true;
+                    // If GPS times out, fallback to IP-based location immediately
+                    console.log('[Location] GPS timeout, falling back to IP-based location API...');
+                    try {
+                        const ipLocation = await this.getIPBasedLocation();
+                        resolve(ipLocation);
+                    }
+                    catch (_ipError) {
+                        resolve({ source: 'unknown', permission: userHasConsent ? 'granted' : 'prompt' });
+                    }
+                }
+            }, ms);
+            p.then((v) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(t);
+                    resolve(v);
+                }
+            }).catch(async () => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(t);
+                    // If GPS fails, fallback to IP-based location
+                    try {
+                        const ipLocation = await this.getIPBasedLocation();
+                        resolve(ipLocation);
+                    }
+                    catch (_ipError) {
+                        resolve({ source: 'unknown', permission: userHasConsent ? 'granted' : 'prompt' });
+                    }
+                }
+            });
+        });
+        const ask = new Promise((resolve) => {
+            // If user has consented (via MSISDN entry), treat as granted
+            if (userHasConsent) {
+                // Only log once to prevent console spam
+                if (!this.locationConsentLoggedRef.current) {
+                    this.locationConsentLoggedRef.current = true;
+                    console.log('[Location] Consent granted via MSISDN entry, requesting location...');
+                }
+                this.locationFetchingRef.current = true;
+                navigator.geolocation.getCurrentPosition((pos) => {
+                    this.locationFetchingRef.current = false;
+                    const locationResult = {
+                        lat: pos.coords.latitude,
+                        lon: pos.coords.longitude,
+                        accuracy: isFinite(pos.coords.accuracy) ? pos.coords.accuracy : null,
+                        permission: 'granted',
+                        source: 'gps',
+                        ts: new Date(pos.timestamp || Date.now()).toISOString(),
+                    };
+                    console.log('[Location] GPS coordinates obtained:', {
+                        lat: locationResult.lat,
+                        lon: locationResult.lon,
+                    });
+                    this.lastLocationRef.current = locationResult;
+                    resolve(locationResult);
+                }, (error) => {
+                    this.locationFetchingRef.current = false;
+                    // Log the error to understand why GPS failed
+                    console.warn('[Location] GPS failed:', {
+                        code: error.code,
+                        message: error.message,
+                        codeMeaning: error.code === 1
+                            ? 'PERMISSION_DENIED'
+                            : error.code === 2
+                                ? 'POSITION_UNAVAILABLE'
+                                : error.code === 3
+                                    ? 'TIMEOUT'
+                                    : 'UNKNOWN',
+                    });
+                    // Fallback to IP-based location when GPS fails
+                    console.log('[Location] Falling back to IP-based location API...');
+                    this.getIPBasedLocation()
+                        .then((ipLocation) => {
+                        this.lastLocationRef.current = ipLocation;
+                        resolve(ipLocation);
+                    })
+                        .catch((_ipError) => {
+                        // Even if IP location fails, we still have consent
+                        const locationResult = {
+                            permission: 'granted',
+                            source: 'unknown',
+                            ts: new Date().toISOString(),
+                        };
+                        this.lastLocationRef.current = locationResult;
+                        resolve(locationResult);
+                    });
+                }, {
+                    enableHighAccuracy: false,
+                    timeout: 2000, // Reduced to 2 seconds for faster fallback to IP
+                    maximumAge: 60000, // Cache for 60 seconds
+                });
+                return;
+            }
+            // No consent yet - use IP-based location as primary (no permission needed)
+            // This provides automatic location without user interaction
+            console.log('[Location] No consent granted, using IP-based location (automatic, no permission needed)...');
+            this.locationFetchingRef.current = true;
+            // Use IP-based location (no permission needed, works automatically)
+            this.getIPBasedLocation()
+                .then((ipLocation) => {
+                this.locationFetchingRef.current = false;
+                this.lastLocationRef.current = ipLocation;
+                resolve(ipLocation);
+            })
+                .catch((_ipError) => {
+                this.locationFetchingRef.current = false;
+                // If IP fails, try GPS as last resort (but it will likely prompt)
+                navigator.permissions?.query({ name: 'geolocation' })
+                    .then((perm) => {
+                    const base = {
+                        permission: perm?.state || 'prompt',
+                    };
+                    navigator.geolocation.getCurrentPosition((pos) => {
+                        this.locationFetchingRef.current = false;
+                        const locationResult = {
+                            lat: pos.coords.latitude,
+                            lon: pos.coords.longitude,
+                            accuracy: isFinite(pos.coords.accuracy) ? pos.coords.accuracy : null,
+                            permission: 'granted',
+                            source: 'gps',
+                            ts: new Date(pos.timestamp || Date.now()).toISOString(),
+                        };
+                        this.lastLocationRef.current = locationResult;
+                        resolve(locationResult);
+                    }, () => {
+                        this.locationFetchingRef.current = false;
+                        // Both IP and GPS failed
+                        const locationResult = {
+                            ...base,
+                            source: 'unknown',
+                            ts: new Date().toISOString(),
+                        };
+                        this.lastLocationRef.current = locationResult;
+                        resolve(locationResult);
+                    }, {
+                        enableHighAccuracy: false,
+                        timeout: 2000,
+                        maximumAge: 60000,
+                    });
+                })
+                    .catch(() => {
+                    // Permissions API not available; GPS failed, return unknown
+                    this.locationFetchingRef.current = false;
+                    const locationResult = {
+                        source: 'unknown',
+                        permission: 'prompt',
+                        ts: new Date().toISOString(),
+                    };
+                    this.lastLocationRef.current = locationResult;
+                    resolve(locationResult);
+                });
+            });
+        });
+        // Reduced overall timeout to 2 seconds for faster IP fallback
+        return withTimeout(ask, 2000);
+    }
+    /**
+     * 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)
+     */
+    static async getIPBasedLocation() {
+        // Return cached IP location if available
+        if (this.lastIPLocationRef.current) {
+            return this.lastIPLocationRef.current;
+        }
+        // Prevent multiple simultaneous requests
+        if (this.ipLocationFetchingRef.current) {
+            return new Promise((resolve) => {
+                const checkInterval = setInterval(() => {
+                    if (this.lastIPLocationRef.current) {
+                        clearInterval(checkInterval);
+                        resolve(this.lastIPLocationRef.current);
+                    }
+                    else if (!this.ipLocationFetchingRef.current) {
+                        clearInterval(checkInterval);
+                        resolve({
+                            source: 'unknown',
+                            permission: 'granted',
+                        });
+                    }
+                }, 50);
+            });
+        }
+        // Skip if we're in an environment without fetch (SSR)
+        if (typeof fetch === 'undefined') {
+            const fallback = {
+                source: 'unknown',
+                permission: 'unsupported',
+            };
+            this.lastIPLocationRef.current = fallback;
+            return fallback;
+        }
+        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}`);
+            }
+            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;
+            }
+            // Convert IP location to LocationInfo format
+            const locationResult = {
+                lat: data.lat || null,
+                lon: data.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,
+            };
+            console.log('[Location] IP-based location obtained:', {
+                ip: locationResult.ip,
+                lat: locationResult.lat,
+                lon: locationResult.lon,
+                city: locationResult.city,
+                country: locationResult.country,
+            });
+            this.lastIPLocationRef.current = locationResult;
+            return locationResult;
+        }
+        catch (error) {
+            // Silently fail - don't break user experience
+            if (error.name !== 'AbortError') {
+                console.warn('[Location] IP-based location fetch failed:', error.message);
+            }
+            const fallback = {
+                source: 'unknown',
+                permission: 'granted',
+            };
+            this.lastIPLocationRef.current = fallback;
+            return fallback;
+        }
+        finally {
+            this.ipLocationFetchingRef.current = false;
+        }
+    }
+    /**
+     * Clear location cache (useful when consent is granted)
+     */
+    static clearCache() {
+        this.lastLocationRef.current = null;
+        this.lastIPLocationRef.current = null;
+        this.locationFetchingRef.current = false;
+        this.ipLocationFetchingRef.current = false;
+        this.locationConsentLoggedRef.current = false;
+        console.log('[Location] Cache cleared - will re-fetch with consent');
+    }
+}
+LocationDetector.locationFetchingRef = { current: false };
+LocationDetector.lastLocationRef = { current: null };
+LocationDetector.locationConsentLoggedRef = { current: false };
+LocationDetector.ipLocationFetchingRef = { current: false };
+LocationDetector.lastIPLocationRef = { current: null };
+
+var locationDetector = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LocationDetector: LocationDetector
+});
+
+/**
+ * Storage utilities for analytics tracking
+ */
+const loadJSON = (key) => {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const s = localStorage.getItem(key);
+        return s ? JSON.parse(s) : null;
+    }
+    catch {
+        return null;
+    }
+};
+const saveJSON = (key, obj) => {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(key, JSON.stringify(obj));
+    }
+    catch {
+        // Silently fail if storage is unavailable
+    }
+};
+const loadSessionJSON = (key) => {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const s = sessionStorage.getItem(key);
+        return s ? JSON.parse(s) : null;
+    }
+    catch {
+        return null;
+    }
+};
+const saveSessionJSON = (key, obj) => {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        sessionStorage.setItem(key, JSON.stringify(obj));
+    }
+    catch {
+        // Silently fail if storage is unavailable
+    }
+};
+/**
+ * Generate or retrieve a user ID from localStorage
+ */
+function getOrCreateUserId(length = 8) {
+    if (typeof window === 'undefined') {
+        return `server-${Date.now()}`;
+    }
+    const storageKey = 'analytics:userId';
+    let userId = localStorage.getItem(storageKey);
+    if (!userId) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        userId = result;
+        localStorage.setItem(storageKey, userId);
+    }
+    return userId;
+}
+/**
+ * Track page visits with localStorage
+ */
+function trackPageVisit() {
+    if (typeof window === 'undefined')
+        return 1;
+    const storedCount = localStorage.getItem('analytics:pageVisits');
+    const newCount = storedCount ? parseInt(storedCount, 10) + 1 : 1;
+    localStorage.setItem('analytics:pageVisits', newCount.toString());
+    return newCount;
+}
+
+var storage = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getOrCreateUserId: getOrCreateUserId,
+    loadJSON: loadJSON,
+    loadSessionJSON: loadSessionJSON,
+    saveJSON: saveJSON,
+    saveSessionJSON: saveSessionJSON,
+    trackPageVisit: trackPageVisit
+});
+
+const UTM_KEYS = [
+    'utm_source',
+    'utm_medium',
+    'utm_campaign',
+    'utm_term',
+    'utm_content',
+    'gclid',
+    'fbclid',
+    'ttclid',
+    'msclkid',
+    'dmclid',
+];
+const FIRST_TOUCH_KEY = 'analytics:firstTouch';
+const LAST_TOUCH_KEY = 'analytics:lastTouch';
+const SESSION_START_KEY = 'analytics:sessionStart';
+function pickUtm(url) {
+    const out = {
+        utm_source: null,
+        utm_medium: null,
+        utm_campaign: null,
+        utm_term: null,
+        utm_content: null,
+        gclid: null,
+        fbclid: null,
+        ttclid: null,
+        msclkid: null,
+        dmclid: null,
+    };
+    UTM_KEYS.forEach((k) => {
+        const v = url.searchParams.get(k);
+        if (v)
+            out[k] = v;
+    });
+    return out;
+}
+function anyCampaignParams(utm) {
+    return UTM_KEYS.some((k) => !!utm[k]);
+}
+function getReferrerDomain(ref) {
+    if (!ref)
+        return null;
+    try {
+        return new URL(ref).hostname;
+    }
+    catch {
+        return null;
+    }
+}
+function getNavigationType() {
+    if (typeof window === 'undefined' || typeof performance === 'undefined') {
+        return { type: 'unknown', isReload: false, isBackForward: false };
+    }
+    const entries = performance.getEntriesByType('navigation');
+    const navType = entries?.[0]?.type || 'navigate';
+    const typeMap = {
+        navigate: 'navigate',
+        reload: 'reload',
+        back_forward: 'back_forward',
+        prerender: 'prerender',
+    };
+    const type = typeMap[navType] ?? 'unknown';
+    return {
+        type,
+        isReload: type === 'reload',
+        isBackForward: type === 'back_forward',
+    };
+}
+/**
+ * Attribution Detector
+ * Detects UTM parameters, referrer, navigation type, and tracks first/last touch
+ */
+class AttributionDetector {
+    static detect() {
+        if (typeof window === 'undefined') {
+            return this.getDefaultAttribution();
+        }
+        const landingUrl = window.location.href;
+        const url = new URL(landingUrl);
+        const { type, isReload, isBackForward } = getNavigationType();
+        const referrerUrl = document.referrer || null;
+        const referrerDomain = getReferrerDomain(referrerUrl);
+        const utm = pickUtm(url);
+        // Per-tab session start
+        const sessionStart = loadSessionJSON(SESSION_START_KEY) ||
+            (() => {
+                const ts = new Date().toISOString();
+                saveSessionJSON(SESSION_START_KEY, ts);
+                return ts;
+            })();
+        // First/last touch tracking
+        const existingFirst = loadJSON(FIRST_TOUCH_KEY);
+        if (!existingFirst && anyCampaignParams(utm)) {
+            saveJSON(FIRST_TOUCH_KEY, { ...utm, referrerDomain, ts: new Date().toISOString() });
+        }
+        if (anyCampaignParams(utm)) {
+            saveJSON(LAST_TOUCH_KEY, { ...utm, referrerDomain, ts: new Date().toISOString() });
+        }
+        const firstTouch = loadJSON(FIRST_TOUCH_KEY);
+        const lastTouch = loadJSON(LAST_TOUCH_KEY);
+        return {
+            landingUrl,
+            path: url.pathname + url.search,
+            hostname: url.hostname,
+            referrerUrl,
+            referrerDomain,
+            navigationType: type,
+            isReload,
+            isBackForward,
+            ...utm,
+            firstTouch,
+            lastTouch,
+            sessionStart,
+        };
+    }
+    static getDefaultAttribution() {
+        return {
+            landingUrl: '',
+            path: '',
+            hostname: '',
+            referrerUrl: null,
+            referrerDomain: null,
+            navigationType: 'unknown',
+            isReload: false,
+            isBackForward: false,
+            utm_source: null,
+            utm_medium: null,
+            utm_campaign: null,
+            utm_term: null,
+            utm_content: null,
+            gclid: null,
+            fbclid: null,
+            ttclid: null,
+            msclkid: null,
+            dmclid: null,
+            firstTouch: null,
+            lastTouch: null,
+            sessionStart: null,
+        };
+    }
+}
+
+var attributionDetector = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AttributionDetector: AttributionDetector
+});
+
+/**
+ * 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')
+ */
+class AnalyticsService {
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    static configure(config) {
+        this.apiEndpoint = config.apiEndpoint;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Track user journey/analytics event
+     */
+    static async trackEvent(event) {
+        const payload = {
+            ...event,
+            timestamp: new Date(),
+            eventId: this.generateEventId(),
+        };
+        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');
+            }
+        }
+        catch (err) {
+            // Don't break user experience - silently fail
+            console.warn('[Analytics] 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
+        });
+    }
+    /**
+     * Track a custom event (Firebase/GA-style)
+     * Automatically collects device, network, location context if available
+     *
+     * @param eventName - Name of the event (e.g., 'button_click', 'purchase', 'sign_up')
+     * @param parameters - Event-specific parameters (optional)
+     * @param context - Optional context override (auto-collected if not provided)
+     *
+     * @example
+     * ```typescript
+     * // Simple event tracking
+     * AnalyticsService.logEvent('button_click', {
+     *   button_name: 'signup',
+     *   button_location: 'header'
+     * });
+     *
+     * // Purchase event
+     * AnalyticsService.logEvent('purchase', {
+     *   transaction_id: 'T12345',
+     *   value: 29.99,
+     *   currency: 'USD',
+     *   items: [{ id: 'item1', name: 'Product 1', price: 29.99 }]
+     * });
+     * ```
+     */
+    static async logEvent(eventName, parameters, context) {
+        // Auto-collect context if not provided (requires dynamic imports)
+        let autoContext = null;
+        if (!context) {
+            // Try to auto-collect context from window/global if available
+            if (typeof window !== 'undefined') {
+                try {
+                    // Import dynamically to avoid circular dependencies
+                    const { getOrCreateUserId } = await Promise.resolve().then(function () { return storage; });
+                    const { NetworkDetector } = await Promise.resolve().then(function () { return networkDetector; });
+                    const { DeviceDetector } = await Promise.resolve().then(function () { return deviceDetector; });
+                    const { LocationDetector } = await Promise.resolve().then(function () { return locationDetector; });
+                    const { AttributionDetector } = await Promise.resolve().then(function () { return attributionDetector; });
+                    autoContext = {
+                        sessionId: getOrCreateUserId(),
+                        pageUrl: window.location.href,
+                        networkInfo: NetworkDetector.detect(),
+                        deviceInfo: await DeviceDetector.detect(),
+                        location: await LocationDetector.detect().catch(() => undefined),
+                        attribution: AttributionDetector.detect(),
+                    };
+                }
+                catch (error) {
+                    // If auto-collection fails, use minimal context
+                    const { getOrCreateUserId } = await Promise.resolve().then(function () { return storage; });
+                    autoContext = {
+                        sessionId: getOrCreateUserId(),
+                        pageUrl: typeof window !== 'undefined' ? window.location.href : '',
+                    };
+                }
+            }
+            else {
+                // SSR environment - use minimal context
+                autoContext = {
+                    sessionId: 'unknown',
+                    pageUrl: '',
+                };
+            }
+        }
+        const finalSessionId = context?.sessionId || autoContext?.sessionId || 'unknown';
+        const finalPageUrl = context?.pageUrl || autoContext?.pageUrl || '';
+        await this.trackEvent({
+            sessionId: finalSessionId,
+            pageUrl: finalPageUrl,
+            networkInfo: context?.networkInfo || autoContext?.networkInfo,
+            deviceInfo: context?.deviceInfo || autoContext?.deviceInfo,
+            location: context?.location || autoContext?.location,
+            attribution: context?.attribution || autoContext?.attribution,
+            userId: context?.userId || finalSessionId,
+            eventName,
+            eventParameters: parameters || {},
+            customData: parameters || {},
+        });
+    }
+    /**
+     * Track a page view event (Firebase/GA-style)
+     * Automatically collects device, network, location context
+     *
+     * @param pageName - Optional page name (defaults to current URL pathname)
+     * @param parameters - Optional page view parameters
+     *
+     * @example
+     * ```typescript
+     * // Track current page view
+     * AnalyticsService.trackPageView();
+     *
+     * // Track with custom page name
+     * AnalyticsService.trackPageView('/dashboard', {
+     *   page_title: 'Dashboard',
+     *   user_type: 'premium'
+     * });
+     * ```
+     */
+    static async trackPageView(pageName, parameters) {
+        const page = pageName || (typeof window !== 'undefined' ? window.location.pathname : '');
+        await this.logEvent('page_view', {
+            page_name: page,
+            page_title: typeof document !== 'undefined' ? document.title : undefined,
+            ...parameters,
+        });
+    }
+}
+AnalyticsService.apiEndpoint = '/api/analytics';
+
+/**
+ * React Hook for Analytics Tracking
+ * Provides device, network, location, and attribution data
+ */
+/**
+ * React hook for analytics tracking
+ *
+ * @example
+ * ```tsx
+ * const { sessionId, networkInfo, deviceInfo, logEvent } = useAnalytics({
+ *   autoSend: true,
+ *   config: { apiEndpoint: '/api/analytics' }
+ * });
+ * ```
+ */
+function useAnalytics(options = {}) {
+    const { autoSend = true, config, onReady } = options;
+    // Configure analytics service if endpoint provided
+    react.useEffect(() => {
+        if (config?.apiEndpoint) {
+            AnalyticsService.configure({ apiEndpoint: config.apiEndpoint });
+        }
+    }, [config?.apiEndpoint]);
+    const [networkInfo, setNetworkInfo] = react.useState(null);
+    const [deviceInfo, setDeviceInfo] = react.useState(null);
+    const [attribution, setAttribution] = react.useState(null);
+    const [sessionId, setSessionId] = react.useState(null);
+    const [pageVisits, setPageVisits] = react.useState(1);
+    const [interactions, setInteractions] = react.useState(0);
+    const [location, setLocation] = react.useState(null);
+    // Guards to prevent infinite loops
+    const didInit = react.useRef(false);
+    const sessionLoggedRef = react.useRef(false);
+    const locationFetchingRef = react.useRef(false);
+    const lastLocationRef = react.useRef(null);
+    const locationConsentLoggedRef = react.useRef(false);
+    // Expose function to clear location cache (for when consent is granted)
+    react.useEffect(() => {
+        if (typeof window !== 'undefined') {
+            window.__clearLocationCache = () => {
+                LocationDetector.clearCache();
+                lastLocationRef.current = null;
+                locationFetchingRef.current = false;
+                locationConsentLoggedRef.current = false;
+            };
+        }
+    }, []);
+    const refresh = react.useCallback(async () => {
+        const net = NetworkDetector.detect();
+        const dev = await DeviceDetector.detect();
+        const attr = AttributionDetector.detect();
+        const uid = getOrCreateUserId();
+        const pv = trackPageVisit();
+        // Check consent status - if consent exists but cached location doesn't reflect it, re-fetch
+        const hasConsent = hasLocationConsent();
+        const shouldRefetchLocation = !lastLocationRef.current ||
+            (hasConsent && lastLocationRef.current.permission !== 'granted');
+        // Fetch location if needed
+        let loc;
+        if (!locationFetchingRef.current && shouldRefetchLocation) {
+            locationFetchingRef.current = true;
+            try {
+                loc = await LocationDetector.detect();
+                lastLocationRef.current = loc;
+                // If we have consent, ensure location reflects it
+                if (hasConsent && loc.permission !== 'granted') {
+                    loc = {
+                        ...loc,
+                        permission: 'granted',
+                    };
+                    lastLocationRef.current = loc;
+                }
+            }
+            finally {
+                locationFetchingRef.current = false;
+            }
+        }
+        else {
+            // Use cached location, but update permission if consent exists
+            loc =
+                lastLocationRef.current ||
+                    { source: 'unknown', permission: hasConsent ? 'granted' : 'prompt' };
+            // If we have consent but cached location doesn't reflect it, update it
+            if (hasConsent && loc.permission !== 'granted') {
+                loc = {
+                    ...loc,
+                    permission: 'granted',
+                };
+                lastLocationRef.current = loc;
+            }
+        }
+        setNetworkInfo(net);
+        setDeviceInfo(dev);
+        setAttribution(attr);
+        setSessionId(uid);
+        setPageVisits(pv);
+        setLocation(loc);
+        // Call onReady callback if provided
+        if (onReady && !sessionLoggedRef.current) {
+            onReady({
+                sessionId: uid,
+                networkInfo: net,
+                deviceInfo: dev,
+                location: loc,
+                attribution: attr,
+            });
+        }
+        return { net, dev, attr, loc };
+    }, [onReady]);
+    // Initialize on mount
+    react.useEffect(() => {
+        if (didInit.current)
+            return;
+        didInit.current = true;
+        (async () => {
+            const { net, dev, attr, loc } = await refresh();
+            if (autoSend) {
+                // Send after idle to not block paint
+                const send = async () => {
+                    await AnalyticsService.trackUserJourney({
+                        sessionId: getOrCreateUserId(),
+                        pageUrl: typeof window !== 'undefined' ? window.location.href : '',
+                        networkInfo: net,
+                        deviceInfo: dev,
+                        location: loc,
+                        attribution: attr,
+                        customData: config?.enableLocation ? { locationEnabled: true } : undefined,
+                    });
+                };
+                if (typeof window !== 'undefined' && window.requestIdleCallback) {
+                    window.requestIdleCallback(send);
+                }
+                else {
+                    setTimeout(send, 0);
+                }
+            }
+        })();
+    }, [autoSend, refresh, config?.enableLocation]);
+    const logEvent = react.useCallback(async (customData) => {
+        if (!sessionId || !networkInfo || !deviceInfo)
+            return;
+        await AnalyticsService.trackUserJourney({
+            sessionId,
+            pageUrl: typeof window !== 'undefined' ? window.location.href : '',
+            networkInfo,
+            deviceInfo,
+            location: location ?? undefined,
+            attribution: attribution ?? undefined,
+            userId: sessionId,
+            customData,
+        });
+        setInteractions((prev) => prev + 1);
+    }, [sessionId, networkInfo, deviceInfo, location, attribution]);
+    /**
+     * Track a custom event (Firebase/GA-style)
+     * Automatically uses current session context
+     *
+     * @param eventName - Name of the event (e.g., 'button_click', 'purchase')
+     * @param parameters - Event-specific parameters (optional)
+     *
+     * @example
+     * ```tsx
+     * const { trackEvent } = useAnalytics();
+     *
+     * // Track button click
+     * trackEvent('button_click', {
+     *   button_name: 'signup',
+     *   button_location: 'header'
+     * });
+     *
+     * // Track purchase
+     * trackEvent('purchase', {
+     *   transaction_id: 'T12345',
+     *   value: 29.99,
+     *   currency: 'USD'
+     * });
+     * ```
+     */
+    const trackEvent = react.useCallback(async (eventName, parameters) => {
+        // Wait for context to be available
+        if (!sessionId || !networkInfo || !deviceInfo) {
+            // If context not ready, still track but with auto-collected context
+            await AnalyticsService.logEvent(eventName, parameters);
+            return;
+        }
+        // Use hook context for more accurate tracking
+        await AnalyticsService.logEvent(eventName, parameters, {
+            sessionId,
+            pageUrl: typeof window !== 'undefined' ? window.location.href : '',
+            networkInfo,
+            deviceInfo,
+            location: location ?? undefined,
+            attribution: attribution ?? undefined,
+            userId: sessionId,
+        });
+        setInteractions((prev) => prev + 1);
+    }, [sessionId, networkInfo, deviceInfo, location, attribution]);
+    /**
+     * Track a page view event (Firebase/GA-style)
+     * Automatically uses current session context
+     *
+     * @param pageName - Optional page name (defaults to current pathname)
+     * @param parameters - Optional page view parameters
+     *
+     * @example
+     * ```tsx
+     * const { trackPageView } = useAnalytics();
+     *
+     * // Track current page
+     * trackPageView();
+     *
+     * // Track with custom name
+     * trackPageView('/dashboard', {
+     *   page_title: 'Dashboard',
+     *   user_type: 'premium'
+     * });
+     * ```
+     */
+    const trackPageView = react.useCallback(async (pageName, parameters) => {
+        // Wait for context to be available
+        if (!sessionId || !networkInfo || !deviceInfo) {
+            // If context not ready, still track but with auto-collected context
+            await AnalyticsService.trackPageView(pageName, parameters);
+            return;
+        }
+        // Use hook context for more accurate tracking
+        const page = pageName || (typeof window !== 'undefined' ? window.location.pathname : '');
+        await AnalyticsService.logEvent('page_view', {
+            page_name: page,
+            page_title: typeof document !== 'undefined' ? document.title : undefined,
+            ...parameters,
+        }, {
+            sessionId,
+            pageUrl: typeof window !== 'undefined' ? window.location.href : '',
+            networkInfo,
+            deviceInfo,
+            location: location ?? undefined,
+            attribution: attribution ?? undefined,
+            userId: sessionId,
+        });
+        setInteractions((prev) => prev + 1);
+    }, [sessionId, networkInfo, deviceInfo, location, attribution]);
+    const incrementInteraction = react.useCallback(() => {
+        setInteractions((n) => n + 1);
+    }, []);
+    return react.useMemo(() => ({
+        sessionId,
+        networkInfo,
+        deviceInfo,
+        location,
+        attribution,
+        pageVisits, // Used in return
+        interactions, // Used in return
+        logEvent,
+        trackEvent,
+        trackPageView,
+        incrementInteraction,
+        refresh,
+    }), [
+        sessionId,
+        networkInfo,
+        deviceInfo,
+        location,
+        attribution,
+        pageVisits,
+        interactions,
+        logEvent,
+        trackEvent,
+        trackPageView,
+        incrementInteraction,
+        refresh,
+    ]);
+}
+
+/**
+ * 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.checkAndSetLocationConsent = checkAndSetLocationConsent;
+exports.clearLocationConsent = clearLocationConsent;
+exports.default = useAnalytics;
+exports.getIPFromRequest = getIPFromRequest;
+exports.getIPLocation = getIPLocation;
+exports.getLocationConsentTimestamp = getLocationConsentTimestamp;
+exports.getOrCreateUserId = getOrCreateUserId;
+exports.getPublicIP = getPublicIP;
+exports.hasLocationConsent = hasLocationConsent;
+exports.loadJSON = loadJSON;
+exports.loadSessionJSON = loadSessionJSON;
+exports.saveJSON = saveJSON;
+exports.saveSessionJSON = saveSessionJSON;
+exports.setLocationConsentGranted = setLocationConsentGranted;
+exports.trackPageVisit = trackPageVisit;
+exports.useAnalytics = useAnalytics;
+//# sourceMappingURL=index.cjs.js.map