@zaplier/sdk 1.1.2 → 1.1.4

package/dist/index.cjs

@@ -5694,156 +5694,51 @@ async function collectFingerprint(options = {}) {
             timezone: browser?.timezone || "unknown",
             // PRIORITY 3: Primary language only (most stable language preference)
             // Remove secondary languages as they can change more frequently
-            primaryLanguage: Array.isArray(browser?.languages) &&
-                browser.languages.length > 0 &&
-                browser.languages[0]
-                ? browser.languages[0].toLowerCase().split("-")[0] // Only language code (en, pt, fr), not region
-                : "unknown",
+            primaryLanguage: (() => {
+                try {
+                    const languages = browser?.languages;
+                    if (Array.isArray(languages) && languages.length > 0 && languages[0]) {
+                        return languages[0].toLowerCase().split("-")[0]; // Only language code (en, pt, fr), not region
+                    }
+                    // Fallback to navigator.language if browser.languages is not available
+                    if (typeof navigator !== 'undefined' && navigator.language) {
+                        return navigator.language.toLowerCase().split("-")[0];
+                    }
+                    return "unknown";
+                }
+                catch {
+                    return "unknown";
+                }
+            })(),
             // PRIORITY 4: Platform (ultra-stable - OS doesn't change)
             platform: (browser?.platform || "unknown").toLowerCase(),
             // PRIORITY 5: Device type (critical for differentiation, ultra-stable)
             deviceType,
-            // PRIORITY 6: Enhanced screen resolution - ONLY for mobile/tablet
-            // CRITICAL: Desktop screen detection is UNSTABLE with DevTools (viewport changes)
-            // For desktop, we rely on hardware + display + platform for differentiation
-            // For mobile/tablet, screen is STABLE (no DevTools viewport issues)
-            screen: screen && (deviceType === "mobile" || deviceType === "tablet")
-                ? (() => {
-                    // Use enhanced screen buckets for modern display landscape
-                    const dims = [screen.width, screen.height].sort((a, b) => b - a);
-                    const w = dims[0];
-                    const h = dims[1];
-                    // Enhanced screen bucketing based on 2024 display standards
-                    const getScreenBucket = (width, height) => {
-                        // Ultra-high resolution displays (2024: 8K, 5K, etc.)
-                        if (width >= 7680)
-                            return "8k"; // 8K displays
-                        if (width >= 5120)
-                            return "5k"; // 5K displays (iMac, etc.)
-                        if (width >= 4096)
-                            return "4k_cinema"; // Cinema 4K
-                        if (width >= 3840)
-                            return "4k_uhd"; // 4K UHD standard
-                        if (width >= 3440)
-                            return "ultrawide"; // Ultrawide QHD
-                        if (width >= 2880)
-                            return "retina_4k"; // Retina 4K/5K scaled
-                        if (width >= 2560)
-                            return "qhd"; // QHD/WQHD
-                        // Standard high-resolution displays
-                        if (width >= 2048)
-                            return "qxga"; // QXGA
-                        if (width >= 1920)
-                            return "fhd"; // Full HD 1080p
-                        if (width >= 1680)
-                            return "wsxga+"; // WSXGA+
-                        if (width >= 1600)
-                            return "uxga"; // UXGA
-                        if (width >= 1440)
-                            return "wxga++"; // WXGA++
-                        if (width >= 1366)
-                            return "hd"; // HD 720p
-                        if (width >= 1280)
-                            return "sxga"; // SXGA
-                        // Tablet and mobile displays
-                        if (width >= 1024)
-                            return "xga"; // XGA (tablets)
-                        if (width >= 768)
-                            return "svga"; // SVGA (small tablets)
-                        if (width >= 640)
-                            return "vga"; // VGA (phones)
-                        if (width >= 480)
-                            return "hvga"; // HVGA (older phones)
-                        if (width >= 320)
-                            return "qvga"; // QVGA (legacy phones)
-                        return "minimal"; // Sub-QVGA
-                    };
-                    // Enhanced aspect ratio classification for device type hints
-                    const getAspectRatioClass = (width, height) => {
-                        if (height === 0)
-                            return "unknown";
-                        const ratio = width / height;
-                        // Ultra-wide displays (gaming, productivity)
-                        if (ratio >= 3.0)
-                            return "super_ultrawide"; // 32:9+
-                        if (ratio >= 2.3)
-                            return "ultrawide"; // 21:9
-                        if (ratio >= 2.0)
-                            return "wide"; // 18:9
-                        // Standard desktop ratios
-                        if (ratio >= 1.7 && ratio <= 1.8)
-                            return "standard"; // 16:9
-                        if (ratio >= 1.6 && ratio <= 1.67)
-                            return "classic"; // 16:10, 5:3
-                        if (ratio >= 1.3 && ratio <= 1.35)
-                            return "traditional"; // 4:3
-                        // Mobile/portrait ratios
-                        if (ratio >= 0.5 && ratio <= 0.8)
-                            return "mobile_portrait"; // Phones in portrait
-                        if (ratio >= 0.4 && ratio <= 0.5)
-                            return "tall_mobile"; // Modern tall phones
-                        return "custom"; // Non-standard ratio
-                    };
-                    // Ensure w and h are valid numbers
-                    const width = w || 0;
-                    const height = h || 0;
-                    // Screen density class based on common DPR patterns
-                    const getDensityClass = (pixelRatio) => {
-                        if (!pixelRatio)
-                            return "standard";
-                        if (pixelRatio >= 3.0)
-                            return "ultra_high"; // iPhone Plus, high-end Android
-                        if (pixelRatio >= 2.0)
-                            return "high"; // Retina, standard high-DPI
-                        if (pixelRatio >= 1.5)
-                            return "medium"; // Mid-range displays
-                        if (pixelRatio >= 1.25)
-                            return "enhanced"; // Slightly enhanced DPI
-                        return "standard"; // Standard 1x displays
-                    };
-                    // CRITICAL: Do NOT include exact dimensions in stableCoreVector for mobile!
-                    // Reason: Screen dimensions change when:
-                    // - Chrome address bar appears/disappears (scroll behavior)
-                    // - Virtual keyboard opens/closes
-                    // - Screen rotates (portrait ↔ landscape)
-                    // - Browser zoom changes
-                    // These changes would cause stableCoreHash to change, breaking visitor identification
-                    //
-                    // INSTEAD: Use ONLY stable screen characteristics (bucket, aspect, density)
-                    // For device differentiation (S22 vs A54), use:
-                    // - screenFrame (bezel measurements)
-                    // - Combination of bucket + hardware + display
-                    // - Vector similarity in IdentityResolver
-                    return {
-                        bucket: getScreenBucket(width),
-                        aspectClass: getAspectRatioClass(width, height),
-                        densityClass: getDensityClass(screen.pixelRatio || window.devicePixelRatio),
-                        // Simplified ratio for matching (rounded to prevent micro-variations)
-                        ratio: height > 0 ? Math.round((width / height) * 100) / 100 : 0,
-                        // Size category for general device classification
-                        sizeCategory: width >= 2560
-                            ? "large"
-                            : width >= 1920
-                                ? "desktop"
-                                : width >= 1024
-                                    ? "laptop"
-                                    : width >= 768
-                                        ? "tablet"
-                                        : "mobile",
-                        // ❌ REMOVED: exact dimensions (causes instability on mobile)
-                        // Device differentiation is now handled by:
-                        // 1. screenFrame (bezel measurements - stable)
-                        // 2. hardware + display combination
-                        // 3. Vector similarity in IdentityResolver
-                    };
-                })()
-                : {
-                    bucket: "unknown",
-                    aspectClass: "unknown",
-                    densityClass: "unknown",
-                    ratio: 0,
-                    sizeCategory: "unknown",
-                },
+            // ❌ PRIORITY 6: Screen - REMOVED FROM stableCoreVector
+            // REASON: Screen properties are UNSTABLE across all device types:
+            //
+            // Desktop:
+            // - DevTools changes viewport (lateral vs bottom)
+            // - Browser zoom changes dimensions
+            // - Window resize changes available space
+            //
+            // Mobile:
+            // - Address bar appears/disappears on scroll
+            // - Virtual keyboard opens/closes
+            // - Screen rotation (portrait ↔ landscape)
+            // - Pull-to-refresh changes viewport
+            //
+            // RESULT: Even "bucket" detection is unreliable due to viewport changes
+            //
+            // SOLUTION: Device differentiation now relies ONLY on:
+            // 1. screenFrame (bezel measurements - MORE stable)
+            // 2. hardware (cores, memory, arch - STABLE)
+            // 3. display (color depth, gamut - STABLE)
+            // 4. platform + deviceType + ua (ULTRA-STABLE)
+            // 5. timezone + primaryLanguage (USER-STABLE)
+            //
+            // Note: screen is still collected in full fingerprint for analytics,
+            // but excluded from stableCoreHash to ensure visitor identification stability
             // CRITICAL: Do NOT include availability flags (canvas/webgl/audio) in stableCoreVector
             // These flags can change between requests due to timeouts, permissions, or hardware issues
             // and would cause the stableCoreHash to change, breaking visitor identification
@@ -6034,12 +5929,13 @@ async function collectFingerprint(options = {}) {
         };
         // ADDITIONAL ENTROPY: Add a deterministic but unique component based on ultra-stable signals
         // This helps prevent collisions while maintaining deterministic behavior
+        // Note: screen removed as it's unstable (viewport changes)
         const entropyComponents = [
             coreVector.ua || "",
             coreVector.platform || "",
             coreVector.deviceType || "",
-            coreVector.screen?.bucket || "",
             coreVector.timezone || "",
+            coreVector.primaryLanguage || "",
         ].filter(Boolean);
         if (entropyComponents.length >= 3) {
             // Create a stable entropy string from the most stable components
@@ -6064,15 +5960,18 @@ async function collectFingerprint(options = {}) {
         // - Screen frame (can vary slightly)
         // - Vendor flavors (can change)
         // - Exact hardware values (use buckets)
-        // DEBUG: Log coreVector components to identify DevTools instability
+        // DEBUG: Log coreVector components for monitoring
         if (opts.debug ||
             (typeof window !== "undefined" && window._rabbitTrackerDebug)) {
             console.log("[RabbitTracker DEBUG] coreVector components:", {
                 ua: coreVector.ua,
                 platform: coreVector.platform,
                 deviceType: coreVector.deviceType,
-                screenBucket: coreVector.screen?.bucket,
                 timezone: coreVector.timezone,
+                primaryLanguage: coreVector.primaryLanguage,
+                hasHardware: !!coreVector.hardware,
+                hasDisplay: !!coreVector.display,
+                hasScreenFrame: !!coreVector.screenFrame,
                 _entropy: coreVector._entropy,
             });
         }
@@ -6118,7 +6017,10 @@ async function collectFingerprint(options = {}) {
                 ua: coreVector.ua,
                 deviceType: coreVector.deviceType,
                 platform: coreVector.platform,
-                screenBucket: coreVector.screen?.bucket,
+                timezone: coreVector.timezone,
+                hasScreenFrame: !!coreVector.screenFrame,
+                hardwareClass: coreVector.hardware?.class,
+                displayClass: coreVector.display?.class,
                 totalComponentsInHash: Object.keys(enhancedComponentValues).length,
             });
         }