coveo.analytics 2.32.0 → 2.33.1

package/dist/definitions/version.d.ts

@@ -1 +1 @@
-export declare const libVersion = "2.32.0";
+export declare const libVersion = "2.33.1";

package/dist/esm/cookieutils.d.mts

@@ -0,0 +1 @@
+export * from '../definitions/cookieutils.js';

package/dist/esm/cookieutils.mjs

@@ -0,0 +1,64 @@
+class Cookie {
+    static set(name, value, expire) {
+        let expirationDate;
+        if (expire) {
+            expirationDate = new Date();
+            expirationDate.setTime(expirationDate.getTime() + expire);
+        }
+        writeCookie(name, value, expirationDate, getCookieDomain(window.location.hostname));
+    }
+    static get(name) {
+        var cookiePrefix = name + '=';
+        var cookieArray = document.cookie.split(';');
+        for (var i = 0; i < cookieArray.length; i++) {
+            var cookie = cookieArray[i];
+            cookie = cookie.replace(/^\s+/, '');
+            if (cookie.lastIndexOf(cookiePrefix, 0) === 0) {
+                return cookie.substring(cookiePrefix.length, cookie.length);
+            }
+        }
+        return null;
+    }
+    static erase(name) {
+        Cookie.set(name, '', -1);
+    }
+}
+function getCookieDomain(host) {
+    if (host.indexOf('.') === -1) {
+        return undefined;
+    }
+    const domainParts = host.split('.');
+    for (let domainLength = 2; domainLength <= domainParts.length; domainLength++) {
+        const domain = domainParts.slice(-domainLength).join('.');
+        if (supportsCookieDomain(domain)) {
+            return domain;
+        }
+    }
+    return undefined;
+}
+function supportsCookieDomain(domain) {
+    const name = `__coveo_cookie_domain_test_${Math.random().toString(36).substring(2)}`;
+    try {
+        writeCookie(name, '1', undefined, domain);
+        return Cookie.get(name) === '1';
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            writeCookie(name, '', new Date(0), domain);
+        }
+        catch { }
+    }
+}
+function writeCookie(name, value, expirationDate, domain) {
+    document.cookie =
+        `${name}=${value}` +
+            (expirationDate ? `;expires=${expirationDate.toUTCString()}` : '') +
+            (domain ? `;domain=${domain}` : '') +
+            ';path=/;SameSite=Lax' +
+            (window.location.protocol === 'https:' ? ';Secure' : '');
+}
+
+export { Cookie };

package/dist/esm/detector.d.mts

@@ -0,0 +1 @@
+export * from '../definitions/detector.js';

package/dist/esm/detector.mjs

@@ -0,0 +1,39 @@
+function hasWindow() {
+    return typeof window !== 'undefined';
+}
+function hasNavigator() {
+    return typeof navigator !== 'undefined';
+}
+function hasDocument() {
+    return typeof document !== 'undefined';
+}
+function hasLocalStorage() {
+    try {
+        return typeof localStorage !== 'undefined';
+    }
+    catch (error) {
+        return false;
+    }
+}
+function hasSessionStorage() {
+    try {
+        return typeof sessionStorage !== 'undefined';
+    }
+    catch (error) {
+        return false;
+    }
+}
+function hasCookieStorage() {
+    return hasNavigator() && navigator.cookieEnabled;
+}
+function hasCrypto() {
+    return typeof crypto !== 'undefined';
+}
+function hasCryptoRandomValues() {
+    return hasCrypto() && typeof crypto.getRandomValues !== 'undefined';
+}
+function hasLocation() {
+    return typeof location !== 'undefined';
+}
+
+export { hasCookieStorage, hasCrypto, hasCryptoRandomValues, hasDocument, hasLocalStorage, hasLocation, hasNavigator, hasSessionStorage, hasWindow };

package/dist/esm/history.d.mts

@@ -0,0 +1,2 @@
+export * from '../definitions/history.js';
+export {HistoryStore as default} from '../definitions/history.js';

package/dist/esm/history.mjs

@@ -0,0 +1,134 @@
+import { getAvailableStorage } from './storage.mjs';
+
+const STORE_KEY = '__coveo.analytics.history';
+const MAX_NUMBER_OF_HISTORY_ELEMENTS = 20;
+const MIN_THRESHOLD_FOR_DUPLICATE_VALUE = 1000 * 60;
+const MAX_VALUE_SIZE = 75;
+class HistoryStore {
+    constructor(store) {
+        this.store = store || getAvailableStorage();
+    }
+    addElement(elem) {
+        elem.internalTime = new Date().getTime();
+        elem = this.cropQueryElement(this.stripEmptyQuery(elem));
+        let currentHistory = this.getHistoryWithInternalTime();
+        if (currentHistory != null) {
+            if (this.isValidEntry(elem)) {
+                this.setHistory([elem].concat(currentHistory));
+            }
+        }
+        else {
+            this.setHistory([elem]);
+        }
+    }
+    async addElementAsync(elem) {
+        elem.internalTime = new Date().getTime();
+        elem = this.cropQueryElement(this.stripEmptyQuery(elem));
+        let currentHistory = await this.getHistoryWithInternalTimeAsync();
+        if (currentHistory != null) {
+            if (this.isValidEntry(elem)) {
+                this.setHistory([elem].concat(currentHistory));
+            }
+        }
+        else {
+            this.setHistory([elem]);
+        }
+    }
+    getHistory() {
+        const history = this.getHistoryWithInternalTime();
+        return this.stripEmptyQueries(this.stripInternalTime(history));
+    }
+    async getHistoryAsync() {
+        const history = await this.getHistoryWithInternalTimeAsync();
+        return this.stripEmptyQueries(this.stripInternalTime(history));
+    }
+    getHistoryWithInternalTime() {
+        try {
+            const elements = this.store.getItem(STORE_KEY);
+            if (elements && typeof elements === 'string') {
+                return JSON.parse(elements);
+            }
+            else {
+                return [];
+            }
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    async getHistoryWithInternalTimeAsync() {
+        try {
+            const elements = await this.store.getItem(STORE_KEY);
+            if (elements) {
+                return JSON.parse(elements);
+            }
+            else {
+                return [];
+            }
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    setHistory(history) {
+        try {
+            this.store.setItem(STORE_KEY, JSON.stringify(history.slice(0, MAX_NUMBER_OF_HISTORY_ELEMENTS)));
+        }
+        catch (e) {
+        }
+    }
+    clear() {
+        try {
+            this.store.removeItem(STORE_KEY);
+        }
+        catch (e) {
+        }
+    }
+    getMostRecentElement() {
+        let currentHistory = this.getHistoryWithInternalTime();
+        if (Array.isArray(currentHistory)) {
+            const sorted = currentHistory.sort((first, second) => {
+                return (second.internalTime || 0) - (first.internalTime || 0);
+            });
+            return sorted[0];
+        }
+        return null;
+    }
+    cropQueryElement(part) {
+        if (part.name && part.value && part.name.toLowerCase() === 'query') {
+            part.value = part.value.slice(0, MAX_VALUE_SIZE);
+        }
+        return part;
+    }
+    isValidEntry(elem) {
+        let lastEntry = this.getMostRecentElement();
+        if (lastEntry && lastEntry.value == elem.value) {
+            return ((elem.internalTime || 0) - (lastEntry.internalTime || 0) > MIN_THRESHOLD_FOR_DUPLICATE_VALUE);
+        }
+        return true;
+    }
+    stripInternalTime(history) {
+        if (Array.isArray(history)) {
+            return history.map((part) => {
+                const { name, time, value } = part;
+                return { name, time, value };
+            });
+        }
+        return [];
+    }
+    stripEmptyQuery(part) {
+        const { name, time, value } = part;
+        if (name &&
+            typeof value === 'string' &&
+            name.toLowerCase() === 'query' &&
+            value.trim() === '') {
+            return { name, time };
+        }
+        return part;
+    }
+    stripEmptyQueries(history) {
+        return history.map((part) => this.stripEmptyQuery(part));
+    }
+}
+
+export { HistoryStore, MAX_NUMBER_OF_HISTORY_ELEMENTS, MAX_VALUE_SIZE, MIN_THRESHOLD_FOR_DUPLICATE_VALUE, STORE_KEY, HistoryStore as default };

package/dist/esm/storage.d.mts

@@ -0,0 +1 @@
+export * from '../definitions/storage.js';

package/dist/esm/storage.mjs

@@ -0,0 +1,55 @@
+import { hasLocalStorage, hasCookieStorage, hasSessionStorage } from './detector.mjs';
+import { Cookie } from './cookieutils.mjs';
+
+let preferredStorage = null;
+function getAvailableStorage() {
+    if (hasLocalStorage()) {
+        return localStorage;
+    }
+    if (hasCookieStorage()) {
+        return new CookieStorage();
+    }
+    if (hasSessionStorage()) {
+        return sessionStorage;
+    }
+    return new NullStorage();
+}
+class CookieStorage {
+    getItem(key) {
+        return Cookie.get(`${CookieStorage.prefix}${key}`);
+    }
+    removeItem(key) {
+        Cookie.erase(`${CookieStorage.prefix}${key}`);
+    }
+    setItem(key, data, expire) {
+        Cookie.set(`${CookieStorage.prefix}${key}`, data, expire);
+    }
+}
+CookieStorage.prefix = 'coveo_';
+class CookieAndLocalStorage {
+    constructor() {
+        this.cookieStorage = new CookieStorage();
+    }
+    getItem(key) {
+        return localStorage.getItem(key) || this.cookieStorage.getItem(key);
+    }
+    removeItem(key) {
+        this.cookieStorage.removeItem(key);
+        localStorage.removeItem(key);
+    }
+    setItem(key, data) {
+        localStorage.setItem(key, data);
+        this.cookieStorage.setItem(key, data, 31556926000);
+    }
+}
+class NullStorage {
+    getItem(key) {
+        return null;
+    }
+    removeItem(key) {
+    }
+    setItem(key, data) {
+    }
+}
+
+export { CookieAndLocalStorage, CookieStorage, NullStorage, getAvailableStorage, preferredStorage };