coveo.analytics 2.23.10 → 2.25.1

package/dist/definitions/client/analytics.d.ts

@@ -46,6 +46,7 @@ export interface AnalyticsClient {
     registerAfterSendEventHook(hook: AnalyticsClientSendEventHook): void;
     addEventTypeMapping(eventType: string, eventConfig: EventTypeConfig): void;
     runtime: IRuntimeEnvironment;
+    version: string;
     readonly currentVisitorId: string;
     getCurrentVisitorId?(): Promise<string>;
 }
@@ -57,6 +58,7 @@ export declare function buildBaseUrl(endpoint?: string, apiVersion?: string): st
 export declare class CoveoAnalyticsClient implements AnalyticsClient, VisitorIdProvider {
     private get defaultOptions();
     runtime: IRuntimeEnvironment;
+    get version(): string;
     private visitorId;
     private bufferedRequests;
     private beforeSendHooks;
@@ -69,6 +71,7 @@ export declare class CoveoAnalyticsClient implements AnalyticsClient, VisitorIdP
     private determineVisitorId;
     getCurrentVisitorId(): Promise<string>;
     setCurrentVisitorId(visitorId: string): Promise<void>;
+    setClientId(value: string, namespace?: string): Promise<void>;
     getParameters(eventType: EventType | string, ...payload: VariableArgumentsPayload): Promise<VariableArgumentsPayload>;
     getPayload(eventType: EventType | string, ...payload: VariableArgumentsPayload): Promise<any>;
     get currentVisitorId(): string;

package/dist/definitions/client/noopAnalytics.d.ts

@@ -20,5 +20,6 @@ export declare class NoopAnalytics implements AnalyticsClient {
     registerAfterSendEventHook(): void;
     addEventTypeMapping(): void;
     runtime: NoopRuntime;
+    get version(): string;
     currentVisitorId: string;
 }

package/dist/definitions/cookieutils.d.ts

@@ -1,5 +1,5 @@
 export declare class Cookie {
-    static set(name: string, value: string, expiration?: number): void;
+    static set(name: string, value: string, expire?: number): void;
     static get(name: string): string | null;
     static erase(name: string): void;
 }

package/dist/definitions/coveoua/simpleanalytics.d.ts

@@ -23,6 +23,7 @@ export declare class CoveoUA {
     require(name: string, options: Omit<PluginOptions, 'client'>): void;
     callPlugin(pluginName: string, fn: string, ...args: any): void;
     reset(): void;
+    version(): string;
 }
 export declare const coveoua: CoveoUA;
 export declare const getCurrentClient: () => AnalyticsClient | undefined;

package/dist/definitions/plugins/BasePlugin.d.ts

@@ -1,5 +1,5 @@
 import { AnalyticsClient } from '../client/analytics';
-import { uuidv4 } from '../client/crypto';
+import { v4 as uuidv4 } from 'uuid';
 declare type PluginWithId = {
     readonly Id: string;
 };

package/dist/definitions/src/coveoua/simpleanalytics.d.ts

@@ -23,6 +23,7 @@ export declare class CoveoUA {
     require(name: string, options: Omit<PluginOptions, 'client'>): void;
     callPlugin(pluginName: string, fn: string, ...args: any): void;
     reset(): void;
+    version(): string;
 }
 export declare const coveoua: CoveoUA;
 export declare const getCurrentClient: () => AnalyticsClient | undefined;

package/dist/definitions/storage.d.ts

@@ -9,7 +9,7 @@ export declare class CookieStorage implements WebStorage {
     static prefix: string;
     getItem(key: string): string | null;
     removeItem(key: string): void;
-    setItem(key: string, data: string): void;
+    setItem(key: string, data: string, expire?: number): void;
 }
 export declare class CookieAndLocalStorage implements WebStorage {
     private cookieStorage;

package/dist/definitions/version.d.ts

@@ -0,0 +1 @@
+export declare const libVersion = "2.25.1";

package/dist/library.es.js

@@ -1,4 +1,4 @@
-/*! *****************************************************************************
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -71,12 +71,6 @@ function hasSessionStorage() {
 }
 function hasCookieStorage() {
     return hasNavigator() && navigator.cookieEnabled;
-}
-function hasCrypto() {
-    return typeof crypto !== 'undefined';
-}
-function hasCryptoRandomValues() {
-    return hasCrypto() && typeof crypto.getRandomValues !== 'undefined';
 }
 
 const eventTypesForDefaultValues = [EventType.click, EventType.custom, EventType.search, EventType.view];
@@ -86,29 +80,20 @@ const addDefaultValues = (eventType, payload) => {
 };
 
 class Cookie {
-    static set(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 = '';
+    static set(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, value, expires, domain });
-            if (Cookie.get(name) == null || Cookie.get(name) != value) {
-                domain = '.' + host;
-                writeCookie({ name, value, expires, domain });
-            }
+            domain = domainParts[domainParts.length - 2] + '.' + domainParts[domainParts.length - 1];
+            writeCookie(name, value, expirationDate, domain);
         }
     }
     static get(name) {
@@ -117,7 +102,7 @@ class Cookie {
         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);
             }
         }
@@ -127,9 +112,12 @@ class Cookie {
         Cookie.set(name, '', -1);
     }
 }
-function writeCookie(details) {
-    const { name, value, expires, domain } = details;
-    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';
 }
 
 function getAvailableStorage() {
@@ -151,8 +139,8 @@ class CookieStorage {
     removeItem(key) {
         Cookie.erase(`${CookieStorage.prefix}${key}`);
     }
-    setItem(key, data) {
-        Cookie.set(`${CookieStorage.prefix}${key}`, data);
+    setItem(key, data, expire) {
+        Cookie.set(`${CookieStorage.prefix}${key}`, data, expire);
     }
 }
 CookieStorage.prefix = 'coveo_';
@@ -169,7 +157,7 @@ class CookieAndLocalStorage {
     }
     setItem(key, data) {
         localStorage.setItem(key, data);
-        this.cookieStorage.setItem(key, data);
+        this.cookieStorage.setItem(key, data, 31556926000);
     }
 }
 class NullStorage {
@@ -340,25 +328,273 @@ const addPageViewToHistory = (pageViewValue) => __awaiter(void 0, void 0, void 0
     yield store.addElementAsync(historyElement);
 });
 
-const uuidv4 = (a) => {
-    if (!!a) {
-        return (Number(a) ^ (getRandomValues(new Uint8Array(1))[0] % 16 >> (Number(a) / 4))).toString(16);
-    }
-    return (`${1e7}` + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuidv4);
-};
-const getRandomValues = (rnds) => {
-    if (hasCryptoRandomValues()) {
-        return crypto.getRandomValues(rnds);
-    }
-    for (var i = 0, r = 0; i < rnds.length; i++) {
-        if ((i & 0x03) === 0) {
-            r = Math.random() * 0x100000000;
-        }
-        rnds[i] = (r >>> ((i & 0x03) << 3)) & 0xff;
-    }
-    return rnds;
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+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;
+}
+
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = {
+  randomUUID
 };
 
+function v4(options, buf, offset) {
+  if (native.randomUUID && !buf && !options) {
+    return native.randomUUID();
+  }
+
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return unsafeStringify(rnds);
+}
+
+// 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;
+
+const libVersion = "2.25.1" ;
+
 const keysOf = Object.keys;
 function isObject(o) {
     return o !== null && typeof o === 'object' && !Array.isArray(o);
@@ -779,6 +1015,7 @@ function buildBaseUrl(endpoint = Endpoints.default, apiVersion = Version) {
     const endpointIsCoveoProxy = endpoint.indexOf('.cloud.coveo.com') !== -1;
     return `${endpoint}${endpointIsCoveoProxy ? '' : '/rest'}/${apiVersion}`;
 }
+const COVEO_NAMESPACE = '38824e1f-37f5-42d3-8372-a4b8fa9df946';
 class CoveoAnalyticsClient {
     constructor(opts) {
         if (!opts) {
@@ -811,6 +1048,9 @@ class CoveoAnalyticsClient {
             afterSendHooks: [],
         };
     }
+    get version() {
+        return libVersion;
+    }
     initRuntime(clientsOptions) {
         if (hasWindow() && hasDocument()) {
             return new BrowserRuntime(clientsOptions, () => {
@@ -830,11 +1070,11 @@ class CoveoAnalyticsClient {
     determineVisitorId() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return (yield this.storage.getItem('visitorId')) || uuidv4();
+                return (yield this.storage.getItem('visitorId')) || v4();
             }
             catch (err) {
                 console.log('Could not get visitor ID from the current runtime environment storage. Using a random ID instead.', err);
-                return uuidv4();
+                return v4();
             }
         });
     }
@@ -853,6 +1093,19 @@ class CoveoAnalyticsClient {
             yield this.storage.setItem('visitorId', visitorId);
         });
     }
+    setClientId(value, namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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)));
+            }
+        });
+    }
     getParameters(eventType, ...payload) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.resolveParameters(eventType, ...payload);
@@ -867,7 +1120,7 @@ class CoveoAnalyticsClient {
     get currentVisitorId() {
         const visitorId = this.visitorId || this.storage.getItem('visitorId');
         if (typeof visitorId !== 'string') {
-            this.setCurrentVisitorId(uuidv4());
+            this.setCurrentVisitorId(v4());
         }
         return this.visitorId;
     }
@@ -1308,6 +1561,9 @@ class NoopAnalytics {
     registerBeforeSendEventHook() { }
     registerAfterSendEventHook() { }
     addEventTypeMapping() { }
+    get version() {
+        return libVersion;
+    }
 }
 
 function filterConsecutiveRepeatedValues(rawData) {
@@ -2063,7 +2319,7 @@ const BasePluginEventTypes = {
     event: 'event',
 };
 class BasePlugin {
-    constructor({ client, uuidGenerator = uuidv4 }) {
+    constructor({ client, uuidGenerator = v4 }) {
         this.actionData = {};
         this.client = client;
         this.uuidGenerator = uuidGenerator;
@@ -2143,7 +2399,7 @@ class BasePlugin {
 const SVCPluginEventTypes = Object.assign({}, BasePluginEventTypes);
 const allSVCEventTypes = Object.keys(SVCPluginEventTypes).map((key) => SVCPluginEventTypes[key]);
 class SVCPlugin extends BasePlugin {
-    constructor({ client, uuidGenerator = uuidv4 }) {
+    constructor({ client, uuidGenerator = v4 }) {
         super({ client, uuidGenerator });
         this.ticket = {};
     }