coveo.analytics 2.23.10 → 2.24.1

package/dist/coveoua.debug.js

@@ -4,7 +4,7 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.coveoua = factory());
 })(this, (function () { 'use strict';
 
-    /*! *****************************************************************************
+    /******************************************************************************
     Copyright (c) Microsoft Corporation.
 
     Permission to use, copy, modify, and/or distribute this software for any
@@ -28,6 +28,8 @@
     };
 
     function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
         extendStatics(d, b);
         function __() { this.constructor = d; }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
@@ -94,6 +96,7 @@
         }
     }
 
+    /** @deprecated */
     function __spreadArrays() {
         for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
         for (var r = Array(s), k = 0, i = 0; i < il; i++)
@@ -155,29 +158,20 @@
     var Cookie = (function () {
         function Cookie() {
         }
-        Cookie.set = function (name, value, expiration) {
-            var domain, domainParts, date, expires, host;
-            if (expiration) {
-                date = new Date();
-                date.setTime(date.getTime() + expiration);
-                expires = '; expires=' + date.toGMTString();
-            }
-            else {
-                expires = '';
+        Cookie.set = function (name, value, expire) {
+            var domain, expirationDate, domainParts, host;
+            if (expire) {
+                expirationDate = new Date();
+                expirationDate.setTime(expirationDate.getTime() + expire);
             }
             host = window.location.hostname;
             if (host.indexOf('.') === -1) {
-                document.cookie = name + '=' + value + expires + '; path=/';
+                writeCookie(name, value, expirationDate);
             }
             else {
                 domainParts = host.split('.');
-                domainParts.shift();
-                domain = '.' + domainParts.join('.');
-                writeCookie({ name: name, value: value, expires: expires, domain: domain });
-                if (Cookie.get(name) == null || Cookie.get(name) != value) {
-                    domain = '.' + host;
-                    writeCookie({ name: name, value: value, expires: expires, domain: domain });
-                }
+                domain = domainParts[domainParts.length - 2] + '.' + domainParts[domainParts.length - 1];
+                writeCookie(name, value, expirationDate, domain);
             }
         };
         Cookie.get = function (name) {
@@ -186,7 +180,7 @@
             for (var i = 0; i < cookieArray.length; i++) {
                 var cookie = cookieArray[i];
                 cookie = cookie.replace(/^\s+/, '');
-                if (cookie.indexOf(cookiePrefix) == 0) {
+                if (cookie.lastIndexOf(cookiePrefix, 0) === 0) {
                     return cookie.substring(cookiePrefix.length, cookie.length);
                 }
             }
@@ -197,9 +191,12 @@
         };
         return Cookie;
     }());
-    function writeCookie(details) {
-        var name = details.name, value = details.value, expires = details.expires, domain = details.domain;
-        document.cookie = name + "=" + value + expires + "; path=/; domain=" + domain + "; SameSite=Lax";
+    function writeCookie(name, value, expirationDate, domain) {
+        document.cookie =
+            name + "=" + value +
+                (expirationDate ? ";expires=" + expirationDate.toUTCString() : '') +
+                (domain ? ";domain=" + domain : '') +
+                ';SameSite=Lax';
     }
 
     var preferredStorage = null;
@@ -224,8 +221,8 @@
         CookieStorage.prototype.removeItem = function (key) {
             Cookie.erase("" + CookieStorage.prefix + key);
         };
-        CookieStorage.prototype.setItem = function (key, data) {
-            Cookie.set("" + CookieStorage.prefix + key, data);
+        CookieStorage.prototype.setItem = function (key, data, expire) {
+            Cookie.set("" + CookieStorage.prefix + key, data, expire);
         };
         CookieStorage.prefix = 'coveo_';
         return CookieStorage;
@@ -243,7 +240,7 @@
         };
         CookieAndLocalStorage.prototype.setItem = function (key, data) {
             localStorage.setItem(key, data);
-            this.cookieStorage.setItem(key, data);
+            this.cookieStorage.setItem(key, data, 31556926000);
         };
         return CookieAndLocalStorage;
     }());
@@ -487,6 +484,225 @@
         return rnds;
     };
 
+    var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+    function validate(uuid) {
+      return typeof uuid === 'string' && REGEX.test(uuid);
+    }
+
+    /**
+     * Convert array of 16 byte values to UUID string format of the form:
+     * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+     */
+
+    const byteToHex = [];
+
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 0x100).toString(16).slice(1));
+    }
+
+    function unsafeStringify(arr, offset = 0) {
+      // Note: Be careful editing this code!  It's been tuned for performance
+      // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+      return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+    }
+
+    function parse(uuid) {
+      if (!validate(uuid)) {
+        throw TypeError('Invalid UUID');
+      }
+
+      let v;
+      const arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+      arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+      arr[1] = v >>> 16 & 0xff;
+      arr[2] = v >>> 8 & 0xff;
+      arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+      arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+      arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+      arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+      arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+      arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+      arr[9] = v & 0xff; // Parse ........-....-....-....-############
+      // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+      arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+      arr[11] = v / 0x100000000 & 0xff;
+      arr[12] = v >>> 24 & 0xff;
+      arr[13] = v >>> 16 & 0xff;
+      arr[14] = v >>> 8 & 0xff;
+      arr[15] = v & 0xff;
+      return arr;
+    }
+
+    function stringToBytes(str) {
+      str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+      const bytes = [];
+
+      for (let i = 0; i < str.length; ++i) {
+        bytes.push(str.charCodeAt(i));
+      }
+
+      return bytes;
+    }
+
+    const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+    const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+    function v35(name, version, hashfunc) {
+      function generateUUID(value, namespace, buf, offset) {
+        var _namespace;
+
+        if (typeof value === 'string') {
+          value = stringToBytes(value);
+        }
+
+        if (typeof namespace === 'string') {
+          namespace = parse(namespace);
+        }
+
+        if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
+          throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+        } // Compute hash of namespace and value, Per 4.3
+        // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+        // hashfunc([...namespace, ... value])`
+
+
+        let bytes = new Uint8Array(16 + value.length);
+        bytes.set(namespace);
+        bytes.set(value, namespace.length);
+        bytes = hashfunc(bytes);
+        bytes[6] = bytes[6] & 0x0f | version;
+        bytes[8] = bytes[8] & 0x3f | 0x80;
+
+        if (buf) {
+          offset = offset || 0;
+
+          for (let i = 0; i < 16; ++i) {
+            buf[offset + i] = bytes[i];
+          }
+
+          return buf;
+        }
+
+        return unsafeStringify(bytes);
+      } // Function#name is not settable on some platforms (#270)
+
+
+      try {
+        generateUUID.name = name; // eslint-disable-next-line no-empty
+      } catch (err) {} // For CommonJS default export support
+
+
+      generateUUID.DNS = DNS;
+      generateUUID.URL = URL;
+      return generateUUID;
+    }
+
+    // Adapted from Chris Veness' SHA1 code at
+    // http://www.movable-type.co.uk/scripts/sha1.html
+    function f(s, x, y, z) {
+      switch (s) {
+        case 0:
+          return x & y ^ ~x & z;
+
+        case 1:
+          return x ^ y ^ z;
+
+        case 2:
+          return x & y ^ x & z ^ y & z;
+
+        case 3:
+          return x ^ y ^ z;
+      }
+    }
+
+    function ROTL(x, n) {
+      return x << n | x >>> 32 - n;
+    }
+
+    function sha1(bytes) {
+      const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+      const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+
+      if (typeof bytes === 'string') {
+        const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+        bytes = [];
+
+        for (let i = 0; i < msg.length; ++i) {
+          bytes.push(msg.charCodeAt(i));
+        }
+      } else if (!Array.isArray(bytes)) {
+        // Convert Array-like to Array
+        bytes = Array.prototype.slice.call(bytes);
+      }
+
+      bytes.push(0x80);
+      const l = bytes.length / 4 + 2;
+      const N = Math.ceil(l / 16);
+      const M = new Array(N);
+
+      for (let i = 0; i < N; ++i) {
+        const arr = new Uint32Array(16);
+
+        for (let j = 0; j < 16; ++j) {
+          arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3];
+        }
+
+        M[i] = arr;
+      }
+
+      M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
+      M[N - 1][14] = Math.floor(M[N - 1][14]);
+      M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
+
+      for (let i = 0; i < N; ++i) {
+        const W = new Uint32Array(80);
+
+        for (let t = 0; t < 16; ++t) {
+          W[t] = M[i][t];
+        }
+
+        for (let t = 16; t < 80; ++t) {
+          W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
+        }
+
+        let a = H[0];
+        let b = H[1];
+        let c = H[2];
+        let d = H[3];
+        let e = H[4];
+
+        for (let t = 0; t < 80; ++t) {
+          const s = Math.floor(t / 20);
+          const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0;
+          e = d;
+          d = c;
+          c = ROTL(b, 30) >>> 0;
+          b = a;
+          a = T;
+        }
+
+        H[0] = H[0] + a >>> 0;
+        H[1] = H[1] + b >>> 0;
+        H[2] = H[2] + c >>> 0;
+        H[3] = H[3] + d >>> 0;
+        H[4] = H[4] + e >>> 0;
+      }
+
+      return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+    }
+
+    const v5 = v35('v5', 0x50, sha1);
+    var uuidv5 = v5;
+
+    var libVersion = "2.24.1" ;
+
     var keysOf = Object.keys;
     function isObject(o) {
         return o !== null && typeof o === 'object' && !Array.isArray(o);
@@ -1029,6 +1245,7 @@
         var endpointIsCoveoProxy = endpoint.indexOf('.cloud.coveo.com') !== -1;
         return "" + endpoint + (endpointIsCoveoProxy ? '' : '/rest') + "/" + apiVersion;
     }
+    var COVEO_NAMESPACE = '38824e1f-37f5-42d3-8372-a4b8fa9df946';
     var CoveoAnalyticsClient = (function () {
         function CoveoAnalyticsClient(opts) {
             if (!opts) {
@@ -1065,6 +1282,13 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(CoveoAnalyticsClient.prototype, "version", {
+            get: function () {
+                return libVersion;
+            },
+            enumerable: false,
+            configurable: true
+        });
         CoveoAnalyticsClient.prototype.initRuntime = function (clientsOptions) {
             var _this = this;
             if (hasWindow() && hasDocument()) {
@@ -1137,6 +1361,22 @@
                 });
             });
         };
+        CoveoAnalyticsClient.prototype.setClientId = function (value, namespace) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (validate(value)) {
+                        this.setCurrentVisitorId(value);
+                    }
+                    else {
+                        if (!namespace) {
+                            throw Error('Cannot generate uuid client id without a specific namespace string.');
+                        }
+                        this.setCurrentVisitorId(uuidv5(value, uuidv5(namespace, COVEO_NAMESPACE)));
+                    }
+                    return [2];
+                });
+            });
+        };
         CoveoAnalyticsClient.prototype.getParameters = function (eventType) {
             var payload = [];
             for (var _i = 1; _i < arguments.length; _i++) {
@@ -2079,6 +2319,9 @@
             this.plugins = new Plugins();
             this.params = {};
         };
+        CoveoUA.prototype.version = function () {
+            return libVersion;
+        };
         return CoveoUA;
     }());
     var coveoua$1 = new CoveoUA();
@@ -2106,6 +2349,7 @@
                 'reset',
                 'require',
                 'provide',
+                'version',
             ];
             throw new Error("The action \"" + command + "\" does not exist. Available actions: " + actions.join(', ') + ".");
         }
@@ -2297,6 +2541,13 @@
         NoopAnalytics.prototype.registerBeforeSendEventHook = function () { };
         NoopAnalytics.prototype.registerAfterSendEventHook = function () { };
         NoopAnalytics.prototype.addEventTypeMapping = function () { };
+        Object.defineProperty(NoopAnalytics.prototype, "version", {
+            get: function () {
+                return libVersion;
+            },
+            enumerable: false,
+            configurable: true
+        });
         return NoopAnalytics;
     }());
 
@@ -3943,11 +4194,11 @@
     });
 
     var promise = window['Promise'];
-    if (!(promise instanceof Function)) {
+    if (!(promise instanceof Function) && !global) {
         console.error("This script uses window.Promise which is not supported in your browser. Consider adding a polyfill like \"es6-promise\".");
     }
     var fetch$1 = window['fetch'];
-    if (!(fetch$1 instanceof Function)) {
+    if (!(fetch$1 instanceof Function) && !global) {
         console.error("This script uses window.fetch which is not supported in your browser. Consider adding a polyfill like \"fetch\".");
     }
     var coveoua = self.coveoua || handleOneAnalyticsEvent;