countly-sdk-web 26.1.0 → 26.1.2

package/lib/countly.js

@@ -350,7 +350,7 @@
         backoffCount: "cly_hc_backoff_count",
         consecutiveBackoffCount: "cly_hc_consecutive_backoff_count"
     });
-    var SDK_VERSION = "26.1.0";
+    var SDK_VERSION = "26.1.2";
     var SDK_NAME = "javascript_native_web";
 
     // Using this on document.referrer would return an array with 17 elements in it. The 12th element (array[11]) would be the path we are looking for. Others would be things like password and such (use https://regex101.com/ to check more)
@@ -759,6 +759,109 @@
         return ua;
     }
 
+    /**
+     * Parse Windows version from UA-CH platformVersion
+     * Chromium based browsers use platformVersion major >= 13 for Windows 11 and lower values for Windows 10.
+     *
+     * @param {string} platformVersion - platformVersion value from userAgentData.getHighEntropyValues
+     * @returns {string|null} "11", "10" or null if not parsable
+     */
+    function parseWindowsVersionFromPlatformVersion(platformVersion) {
+        if (typeof platformVersion !== "string" || !platformVersion) {
+            return null;
+        }
+        var major = parseInt(platformVersion.split(".")[0], 10);
+        if (isNaN(major)) {
+            return null;
+        }
+        return major >= 13 ? "11" : "10";
+    }
+
+    /**
+     * Retrieve User-Agent Client Hints (high entropy values) when available.
+     *
+     * @param {Object} uaDataOverride - optional userAgentData override for testing
+     * @returns {Promise<Object|null>} resolved hints object or null
+     */
+    function getUserAgentClientHintsInternal(uaData) {
+        if (!uaData || typeof uaData.getHighEntropyValues !== "function") {
+            return Promise.resolve(null);
+        }
+        return uaData.getHighEntropyValues(["platform", "platformVersion", "architecture", "bitness", "model", "uaFullVersion", "fullVersionList"]).then(function (values) {
+            if (!values || _typeof(values) !== "object") {
+                return null;
+            }
+            var browserName = null;
+            var browserVersion = null;
+            var versionList = Array.isArray(values.fullVersionList) ? values.fullVersionList : [];
+            var fallbackList = Array.isArray(uaData.brands) ? uaData.brands : [];
+            var normalizeBrand = function normalizeBrand(brand) {
+                return typeof brand === "string" ? brand.toLowerCase().replace(/[^a-z0-9]/g, "") : "";
+            };
+            var isGreaseBrand = function isGreaseBrand(brand) {
+                var normalized = normalizeBrand(brand);
+                return normalized === "notabrand" || normalized === "notabrand99" || normalized.indexOf("notabrand") === 0;
+            };
+            var isChromiumBrand = function isChromiumBrand(brand) {
+                return normalizeBrand(brand) === "chromium";
+            };
+            var pickEntry = function pickEntry(list, allowChromiumFallback) {
+                return list.find(function (entry) {
+                    if (!entry || !entry.brand) {
+                        return false;
+                    }
+                    if (isGreaseBrand(entry.brand)) {
+                        return false;
+                    }
+                    if (!allowChromiumFallback && isChromiumBrand(entry.brand)) {
+                        return false;
+                    }
+                    return true;
+                });
+            };
+            var browserEntry = pickEntry(versionList, false) || pickEntry(fallbackList, false) || pickEntry(versionList, true) || pickEntry(fallbackList, true);
+            if (browserEntry) {
+                browserName = browserEntry.brand || null;
+                browserVersion = browserEntry.version || null;
+            }
+            var parsed = {
+                platform: values.platform || uaData.platform || null,
+                platformVersion: values.platformVersion || null,
+                architecture: values.architecture || null,
+                bitness: values.bitness || null,
+                model: values.model || null,
+                uaFullVersion: values.uaFullVersion || null,
+                fullVersionList: values.fullVersionList || null,
+                browserName: browserName,
+                browserVersion: browserVersion,
+                windowsVersion: null
+            };
+            if (parsed.platform && parsed.platform.toLowerCase() === "windows") {
+                parsed.windowsVersion = parseWindowsVersionFromPlatformVersion(parsed.platformVersion);
+            }
+            return parsed;
+        })["catch"](function () {
+            return null;
+        });
+    }
+    var prefetchedUserAgentClientHintsPromise = null;
+    if (isBrowser && typeof navigator !== "undefined" && navigator.userAgentData && typeof navigator.userAgentData.getHighEntropyValues === "function") {
+        prefetchedUserAgentClientHintsPromise = getUserAgentClientHintsInternal(navigator.userAgentData);
+    }
+    function getUserAgentClientHints(uaDataOverride) {
+        if (uaDataOverride) {
+            return getUserAgentClientHintsInternal(uaDataOverride);
+        }
+        if (prefetchedUserAgentClientHintsPromise) {
+            return prefetchedUserAgentClientHintsPromise;
+        }
+        if (isBrowser && typeof navigator !== "undefined" && navigator.userAgentData && typeof navigator.userAgentData.getHighEntropyValues === "function") {
+            prefetchedUserAgentClientHintsPromise = getUserAgentClientHintsInternal(navigator.userAgentData);
+            return prefetchedUserAgentClientHintsPromise;
+        }
+        return Promise.resolve(null);
+    }
+
     /**
      *  Returns device type information according to user agent string
      *  @memberof Countly._internals
@@ -1092,6 +1195,14 @@
     var _journeyTriggerPending = /*#__PURE__*/new WeakMap();
     var _journeyPendingEventIds = /*#__PURE__*/new WeakMap();
     var _fakeRequestHandler = /*#__PURE__*/new WeakMap();
+    var _uaClientHints = /*#__PURE__*/new WeakMap();
+    var _uaClientHintsStatus = /*#__PURE__*/new WeakMap();
+    var _clientHintsPromise = /*#__PURE__*/new WeakMap();
+    var _pendingRequestBuffer = /*#__PURE__*/new WeakMap();
+    var _clientHintsBufferTimeoutId = /*#__PURE__*/new WeakMap();
+    var _changeIdRemoteConfigTimeoutId = /*#__PURE__*/new WeakMap();
+    var _initializeClientHints = /*#__PURE__*/new WeakMap();
+    var _flushPendingRequestBuffer = /*#__PURE__*/new WeakMap();
     var _getAndSetServerConfig = /*#__PURE__*/new WeakMap();
     var _populateServerConfig = /*#__PURE__*/new WeakMap();
     var _initialize = /*#__PURE__*/new WeakMap();
@@ -1141,6 +1252,7 @@
     var _getStoredIdOrGenerateId = /*#__PURE__*/new WeakMap();
     var _isUUID = /*#__PURE__*/new WeakMap();
     var _getUA = /*#__PURE__*/new WeakMap();
+    var _getBrowserInfoFromUA = /*#__PURE__*/new WeakMap();
     var _getMetrics = /*#__PURE__*/new WeakMap();
     var _getResolution = /*#__PURE__*/new WeakMap();
     var _isReferrerUsable = /*#__PURE__*/new WeakMap();
@@ -1280,6 +1392,90 @@
         _classPrivateFieldInitSpec(this, _journeyTriggerPending, void 0);
         _classPrivateFieldInitSpec(this, _journeyPendingEventIds, void 0);
         _classPrivateFieldInitSpec(this, _fakeRequestHandler, void 0);
+        _classPrivateFieldInitSpec(this, _uaClientHints, void 0);
+        _classPrivateFieldInitSpec(this, _uaClientHintsStatus, void 0);
+        _classPrivateFieldInitSpec(this, _clientHintsPromise, void 0);
+        _classPrivateFieldInitSpec(this, _pendingRequestBuffer, void 0);
+        _classPrivateFieldInitSpec(this, _clientHintsBufferTimeoutId, void 0);
+        _classPrivateFieldInitSpec(this, _changeIdRemoteConfigTimeoutId, void 0);
+        /**
+         * Fetch User-Agent Client Hints and cache values for metrics enrichment.
+         * @private
+         */
+        _classPrivateFieldInitSpec(this, _initializeClientHints, function () {
+            if (!isBrowser) {
+                _classPrivateFieldSet2(_uaClientHintsStatus, _this, "unavailable");
+                _classPrivateFieldSet2(_pendingRequestBuffer, _this, null); // no buffering needed
+                return;
+            }
+            var uaRaw = currentUserAgentString();
+            var uaDataAvailable = typeof navigator !== "undefined" && !!navigator.userAgentData;
+            var getHighEntropyValuesAvailable = uaDataAvailable && typeof navigator.userAgentData.getHighEntropyValues === "function";
+            var uaDataPlatform = uaDataAvailable ? navigator.userAgentData.platform : undefined;
+            var uaDataBrands = uaDataAvailable ? navigator.userAgentData.brands : undefined;
+            _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, raw ua string:[" + uaRaw + "]");
+            _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, userAgentData available:[" + uaDataAvailable + "], getHighEntropyValues available:[" + getHighEntropyValuesAvailable + "]");
+            _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, userAgentData low-entropy platform:[" + uaDataPlatform + "], brands:[" + JSON.stringify(uaDataBrands) + "]");
+            _classPrivateFieldSet2(_uaClientHintsStatus, _this, "pending");
+            _classPrivateFieldSet2(_pendingRequestBuffer, _this, []); // enable request buffering until hints resolve
+
+            // Safety timeout: flush buffer even if hints never resolve (e.g. API blocked)
+            _classPrivateFieldSet2(_clientHintsBufferTimeoutId, _this, setTimeout(function () {
+                if (_classPrivateFieldGet2(_pendingRequestBuffer, _this) !== null) {
+                    _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.WARNING, "ua_logic, client hints resolution timed out after 5s, flushing pending requests with available metrics");
+                    _classPrivateFieldGet2(_flushPendingRequestBuffer, _this).call(_this);
+                }
+            }, 1000));
+            _classPrivateFieldSet2(_clientHintsPromise, _this, getUserAgentClientHints().then(function (clientHints) {
+                if (clientHints && _typeof(clientHints) === "object") {
+                    _classPrivateFieldSet2(_uaClientHints, _this, clientHints);
+                    _classPrivateFieldSet2(_uaClientHintsStatus, _this, "resolved");
+                    _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, high-entropy hints resolved:[" + JSON.stringify(clientHints) + "]");
+                } else {
+                    _classPrivateFieldSet2(_uaClientHintsStatus, _this, "unavailable");
+                    _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, high-entropy hints unavailable or not returned");
+                }
+            })["catch"](function (err) {
+                _classPrivateFieldSet2(_uaClientHints, _this, null);
+                _classPrivateFieldSet2(_uaClientHintsStatus, _this, "failed");
+                _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, high-entropy hints fetch failed:[" + err + "]");
+            })["finally"](function () {
+                _classPrivateFieldGet2(_flushPendingRequestBuffer, _this).call(_this);
+            }));
+        });
+        /**
+         * Flush pending request buffer after client hints resolution.
+         * Re-computes metrics for any buffered begin_session request so that
+         * high-entropy Client Hints values are included. All other buffered
+         * requests are pushed to the queue unchanged, preserving order.
+         * @private
+         */
+        _classPrivateFieldInitSpec(this, _flushPendingRequestBuffer, function () {
+            // Clear safety timeout
+            if (_classPrivateFieldGet2(_clientHintsBufferTimeoutId, _this)) {
+                clearTimeout(_classPrivateFieldGet2(_clientHintsBufferTimeoutId, _this));
+                _classPrivateFieldSet2(_clientHintsBufferTimeoutId, _this, null);
+            }
+            var buffer = _classPrivateFieldGet2(_pendingRequestBuffer, _this);
+            _classPrivateFieldSet2(_pendingRequestBuffer, _this, null); // disable buffering — subsequent calls go directly to queue
+
+            if (!buffer || buffer.length === 0) {
+                return;
+            }
+            _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, flushing [" + buffer.length + "] pending request(s) after client hints resolution");
+            for (var i = 0; i < buffer.length; i++) {
+                var request = buffer[i];
+                // Re-compute metrics for begin_session requests with now-resolved hints
+                if (request.begin_session) {
+                    request.metrics = JSON.stringify(_classPrivateFieldGet2(_getMetrics, _this).call(_this));
+                }
+                if (_classPrivateFieldGet2(_requestQueue, _this).length > _classPrivateFieldGet2(_SCSizeReqQueue, _this)) {
+                    _classPrivateFieldGet2(_requestQueue, _this).shift();
+                }
+                _classPrivateFieldGet2(_requestQueue, _this).push(request);
+            }
+            _classPrivateFieldGet2(_setValueInStorage, _this).call(_this, "cly_queue", _classPrivateFieldGet2(_requestQueue, _this), true);
+        });
         /**
          * Fetch and set server configuration
          * Retrieves server-side settings and behavior configurations
@@ -2003,6 +2199,18 @@
             _classPrivateFieldSet2(_journeyTriggerInProgress, _this, undefined);
             _classPrivateFieldSet2(_journeyTriggerPending, _this, undefined);
             _classPrivateFieldSet2(_journeyPendingEventIds, _this, undefined);
+            if (_classPrivateFieldGet2(_clientHintsBufferTimeoutId, _this)) {
+                clearTimeout(_classPrivateFieldGet2(_clientHintsBufferTimeoutId, _this));
+                _classPrivateFieldSet2(_clientHintsBufferTimeoutId, _this, null);
+            }
+            if (_classPrivateFieldGet2(_changeIdRemoteConfigTimeoutId, _this)) {
+                clearTimeout(_classPrivateFieldGet2(_changeIdRemoteConfigTimeoutId, _this));
+                _classPrivateFieldSet2(_changeIdRemoteConfigTimeoutId, _this, null);
+            }
+            _classPrivateFieldSet2(_pendingRequestBuffer, _this, null);
+            _classPrivateFieldSet2(_clientHintsPromise, _this, null);
+            _classPrivateFieldSet2(_uaClientHints, _this, null);
+            _classPrivateFieldSet2(_uaClientHintsStatus, _this, "not_started");
         });
         /**
          * Returns the SDK version string currently in use
@@ -2433,7 +2641,17 @@
             if (_this.remote_config) {
                 _classPrivateFieldSet2(_remoteConfigs, _this, {});
                 _classPrivateFieldGet2(_setValueInStorage, _this).call(_this, "cly_remote_configs", _classPrivateFieldGet2(_remoteConfigs, _this));
-                _this.fetch_remote_config(_this.remote_config);
+                if (merge) {
+                    if (_classPrivateFieldGet2(_changeIdRemoteConfigTimeoutId, _this)) {
+                        clearTimeout(_classPrivateFieldGet2(_changeIdRemoteConfigTimeoutId, _this));
+                    }
+                    _classPrivateFieldSet2(_changeIdRemoteConfigTimeoutId, _this, setTimeout(function () {
+                        _classPrivateFieldSet2(_changeIdRemoteConfigTimeoutId, _this, null);
+                        _this.fetch_remote_config(_this.remote_config);
+                    }, 1000));
+                } else {
+                    _this.fetch_remote_config(_this.remote_config);
+                }
             }
         });
         /**
@@ -2731,6 +2949,11 @@
             return _regenerator().w(function (_context2) {
                 while (1) switch (_context2.n) {
                     case 0:
+                        // Flush any buffered requests (e.g. held while client hints were resolving)
+                        // into the real request queue so they can be sent before the content request.
+                        if (_classPrivateFieldGet2(_pendingRequestBuffer, _this) !== null) {
+                            _classPrivateFieldGet2(_flushPendingRequestBuffer, _this).call(_this);
+                        }
                         initialQueueLength = _classPrivateFieldGet2(_requestQueue, _this).length;
                         if (!(initialQueueLength === 0)) {
                             _context2.n = 1;
@@ -5836,6 +6059,12 @@
                 return;
             }
             _classPrivateFieldGet2(_prepareRequest, _this).call(_this, request);
+
+            // Buffer requests while client hints are still resolving
+            if (_classPrivateFieldGet2(_pendingRequestBuffer, _this) !== null) {
+                _classPrivateFieldGet2(_pendingRequestBuffer, _this).push(request);
+                return;
+            }
             if (_classPrivateFieldGet2(_requestQueue, _this).length > _classPrivateFieldGet2(_SCSizeReqQueue, _this)) {
                 _classPrivateFieldGet2(_requestQueue, _this).shift();
             }
@@ -6089,6 +6318,49 @@
             }
             return currentUserAgentString();
         });
+        /**
+         * Basic browser name/version parsing fallback from UA string.
+         * @private
+         * @param {string} ua - raw user agent string
+         * @returns {{name: string|null, version: string|null}}
+         */
+        _classPrivateFieldInitSpec(this, _getBrowserInfoFromUA, function (ua) {
+            if (!ua || typeof ua !== "string") {
+                return {
+                    name: null,
+                    version: null
+                };
+            }
+            var patterns = [{
+                name: "Edge",
+                regex: /Edg\/([\d\.]+)/
+            }, {
+                name: "Opera",
+                regex: /OPR\/([\d\.]+)/
+            }, {
+                name: "Chrome",
+                regex: /Chrome\/([\d\.]+)/
+            }, {
+                name: "Firefox",
+                regex: /Firefox\/([\d\.]+)/
+            }, {
+                name: "Safari",
+                regex: /Version\/([\d\.]+).*Safari/
+            }];
+            for (var i = 0; i < patterns.length; i++) {
+                var match = ua.match(patterns[i].regex);
+                if (match && match[1]) {
+                    return {
+                        name: patterns[i].name,
+                        version: match[1]
+                    };
+                }
+            }
+            return {
+                name: null,
+                version: null
+            };
+        });
         /**
          *  Get metrics of the browser or config object
          *  @memberof Countly._internals
@@ -6118,6 +6390,55 @@
             if (typeof locale !== "undefined") {
                 metrics._locale = metrics._locale || locale;
             }
+            if (isBrowser && navigator.userAgentData && navigator.userAgentData.platform) {
+                metrics._os = metrics._os || navigator.userAgentData.platform;
+            }
+            var detectedDeviceType = userAgentDeviceDetection();
+            if (detectedDeviceType === "phone") {
+                detectedDeviceType = "mobile";
+            }
+            metrics._device_type = metrics._device_type || detectedDeviceType;
+            if (_classPrivateFieldGet2(_uaClientHints, _this) && _typeof(_classPrivateFieldGet2(_uaClientHints, _this)) === "object") {
+                if (_classPrivateFieldGet2(_uaClientHints, _this).platform) {
+                    metrics._os = metrics._os || _classPrivateFieldGet2(_uaClientHints, _this).platform;
+                }
+                var osVersionFromHints = _classPrivateFieldGet2(_uaClientHints, _this).windowsVersion || _classPrivateFieldGet2(_uaClientHints, _this).platformVersion;
+                if (osVersionFromHints) {
+                    metrics._os_version = metrics._os_version || osVersionFromHints;
+                }
+                if (_classPrivateFieldGet2(_uaClientHints, _this).model) {
+                    metrics._device = metrics._device || _classPrivateFieldGet2(_uaClientHints, _this).model;
+                }
+                if (_classPrivateFieldGet2(_uaClientHints, _this).browserName) {
+                    metrics._browser = metrics._browser || _classPrivateFieldGet2(_uaClientHints, _this).browserName;
+                }
+                if (_classPrivateFieldGet2(_uaClientHints, _this).browserVersion) {
+                    metrics._browser_version = metrics._browser_version || _classPrivateFieldGet2(_uaClientHints, _this).browserVersion;
+                }
+                if (_classPrivateFieldGet2(_uaClientHints, _this).windowsVersion) {
+                    metrics._os = metrics._os || "Windows";
+                    metrics._os_version = metrics._os_version || _classPrivateFieldGet2(_uaClientHints, _this).windowsVersion;
+                }
+                _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, metrics enriched from hints:[" + JSON.stringify({
+                    _os: metrics._os,
+                    _os_version: metrics._os_version,
+                    _device: metrics._device,
+                    _device_type: metrics._device_type,
+                    _browser: metrics._browser,
+                    _browser_version: metrics._browser_version
+                }) + "]");
+            } else {
+                if (_classPrivateFieldGet2(_uaClientHintsStatus, _this) === "pending") {
+                    _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, high-entropy hints are still pending, using fallback metrics for now");
+                } else {
+                    _classPrivateFieldGet2(_log, _this).call(_this, logLevelEnums.DEBUG, "ua_logic, no high-entropy hints available, using UA fallback parsing");
+                }
+            }
+            if (!metrics._browser || !metrics._browser_version) {
+                var browserInfo = _classPrivateFieldGet2(_getBrowserInfoFromUA, _this).call(_this, metrics._ua);
+                metrics._browser = metrics._browser || browserInfo.name;
+                metrics._browser_version = metrics._browser_version || browserInfo.version;
+            }
             if (_classPrivateFieldGet2(_isReferrerUsable, _this).call(_this)) {
                 metrics._store = metrics._store || document.referrer;
             }
@@ -7332,6 +7653,12 @@
         _classPrivateFieldSet2(_journeyTriggerPending, this, false);
         _classPrivateFieldSet2(_journeyPendingEventIds, this, new Set());
         _classPrivateFieldSet2(_fakeRequestHandler, this, getConfig("fake_request_handler", _ob, null));
+        _classPrivateFieldSet2(_uaClientHints, this, null);
+        _classPrivateFieldSet2(_uaClientHintsStatus, this, "not_started");
+        _classPrivateFieldSet2(_clientHintsPromise, this, null);
+        _classPrivateFieldSet2(_pendingRequestBuffer, this, null);
+        _classPrivateFieldSet2(_clientHintsBufferTimeoutId, this, null);
+        _classPrivateFieldSet2(_changeIdRemoteConfigTimeoutId, this, null);
         this.app_key = getConfig("app_key", _ob, null);
         this.url = stripTrailingSlash(getConfig("url", _ob, ""));
         this.serialize = getConfig("serialize", _ob, Countly.serialize);
@@ -7359,6 +7686,7 @@
         for (var it = 0; it < Countly.features.length; it++) {
             _classPrivateFieldGet2(_consents, this)[Countly.features[it]] = {};
         }
+        _classPrivateFieldGet2(_initializeClientHints, this).call(this);
         _classPrivateFieldGet2(_initialize, this).call(this, _ob);
 
         // start SDK