coveo.analytics 2.21.27 → 2.22.2

package/dist/react-native.es.js

@@ -1,5 +1,4 @@
-import { fetch } from 'cross-fetch';
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import { fetch as fetch$1 } from 'cross-fetch';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -64,7 +63,7 @@ class AnalyticsFetchClient {
                 body: JSON.stringify(payload),
             };
             const _a = Object.assign(Object.assign({}, defaultOptions), (preprocessRequest ? yield preprocessRequest(defaultOptions, 'analyticsFetch') : {})), { url } = _a, fetchData = __rest(_a, ["url"]);
-            const response = yield fetch(url, fetchData);
+            const response = yield fetch$1(url, fetchData);
             if (response.ok) {
                 const visit = (yield response.json());
                 if (visit.visitorId) {
@@ -87,7 +86,7 @@ class AnalyticsFetchClient {
         return __awaiter(this, void 0, void 0, function* () {
             const { baseUrl } = this.opts;
             const url = `${baseUrl}/analytics/visit`;
-            yield fetch(url, { headers: this.getHeaders(), method: 'DELETE' });
+            yield fetch$1(url, { headers: this.getHeaders(), method: 'DELETE' });
         });
     }
     shouldAppendVisitorId(eventType) {
@@ -106,29 +105,2160 @@ class AnalyticsFetchClient {
     }
 }
 
-class ReactNativeStorage {
+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';
+}
+
+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;
+};
+
+const eventTypesForDefaultValues = [EventType.click, EventType.custom, EventType.search, EventType.view];
+const addDefaultValues = (eventType, payload) => {
+    return eventTypesForDefaultValues.indexOf(eventType) !== -1
+        ? Object.assign({ language: hasDocument() ? document.documentElement.lang : 'unknown', userAgent: hasNavigator() ? navigator.userAgent : 'unknown' }, payload) : 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 = '';
+        }
+        host = location.hostname;
+        if (host.indexOf('.') === -1) {
+            document.cookie = name + '=' + value + expires + '; path=/';
+        }
+        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 });
+            }
+        }
+    }
+    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.indexOf(cookiePrefix) == 0) {
+                return cookie.substring(cookiePrefix.length, cookie.length);
+            }
+        }
+        return null;
+    }
+    static erase(name) {
+        Cookie.set(name, '', -1);
+    }
+}
+function writeCookie(details) {
+    const { name, value, expires, domain } = details;
+    document.cookie = `${name}=${value}${expires}; path=/; domain=${domain}; SameSite=Lax`;
+}
+
+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) {
+        Cookie.set(`${CookieStorage.prefix}${key}`, data);
+    }
+}
+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);
+    }
+}
+class NullStorage {
     getItem(key) {
+        return null;
+    }
+    removeItem(key) {
+    }
+    setItem(key, data) {
+    }
+}
+
+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]);
+        }
+    }
+    addElementAsync(elem) {
         return __awaiter(this, void 0, void 0, function* () {
-            return AsyncStorage.getItem(key);
+            elem.internalTime = new Date().getTime();
+            elem = this.cropQueryElement(this.stripEmptyQuery(elem));
+            let currentHistory = yield this.getHistoryWithInternalTimeAsync();
+            if (currentHistory != null) {
+                if (this.isValidEntry(elem)) {
+                    this.setHistory([elem].concat(currentHistory));
+                }
+            }
+            else {
+                this.setHistory([elem]);
+            }
         });
     }
-    setItem(key, data) {
+    getHistory() {
+        const history = this.getHistoryWithInternalTime();
+        return this.stripEmptyQueries(this.stripInternalTime(history));
+    }
+    getHistoryAsync() {
         return __awaiter(this, void 0, void 0, function* () {
-            return AsyncStorage.setItem(key, data);
+            const history = yield this.getHistoryWithInternalTimeAsync();
+            return this.stripEmptyQueries(this.stripInternalTime(history));
         });
     }
-    removeItem(key) {
+    getHistoryWithInternalTime() {
+        try {
+            const elements = this.store.getItem(STORE_KEY);
+            if (elements && typeof elements === 'string') {
+                return JSON.parse(elements);
+            }
+            else {
+                return [];
+            }
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    getHistoryWithInternalTimeAsync() {
         return __awaiter(this, void 0, void 0, function* () {
-            AsyncStorage.removeItem(key);
+            try {
+                const elements = yield 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 (currentHistory != null) {
+            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) {
+        return history.map((part) => {
+            const { name, time, value } = part;
+            return { name, time, value };
+        });
+    }
+    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));
+    }
 }
 
-class ReactNativeRuntime {
-    constructor(clientOptions) {
-        this.storage = new ReactNativeStorage();
+var history = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    STORE_KEY: STORE_KEY,
+    MAX_NUMBER_OF_HISTORY_ELEMENTS: MAX_NUMBER_OF_HISTORY_ELEMENTS,
+    MIN_THRESHOLD_FOR_DUPLICATE_VALUE: MIN_THRESHOLD_FOR_DUPLICATE_VALUE,
+    MAX_VALUE_SIZE: MAX_VALUE_SIZE,
+    HistoryStore: HistoryStore,
+    'default': HistoryStore
+});
+
+const enhanceViewEvent = (eventType, payload) => __awaiter(void 0, void 0, void 0, function* () {
+    if (eventType === EventType.view) {
+        yield addPageViewToHistory(payload.contentIdValue);
+        return Object.assign({ location: window.location.toString(), referrer: document.referrer, title: document.title }, payload);
+    }
+    return payload;
+});
+const addPageViewToHistory = (pageViewValue) => __awaiter(void 0, void 0, void 0, function* () {
+    const store = new HistoryStore();
+    const historyElement = {
+        name: 'PageView',
+        value: pageViewValue,
+        time: JSON.stringify(new Date()),
+    };
+    yield store.addElementAsync(historyElement);
+});
+
+const keysOf = Object.keys;
+
+const ticketKeysMapping = {
+    id: 'svc_ticket_id',
+    subject: 'svc_ticket_subject',
+    description: 'svc_ticket_description',
+    category: 'svc_ticket_category',
+    productId: 'svc_ticket_product_id',
+    custom: 'svc_ticket_custom',
+};
+const ticketKeysMappingValues = keysOf(ticketKeysMapping).map((key) => ticketKeysMapping[key]);
+const ticketSubKeysMatchGroup = [...ticketKeysMappingValues].join('|');
+const ticketKeyRegex = new RegExp(`^(${ticketSubKeysMatchGroup}$)`);
+const serviceActionsKeysMapping = {
+    svcAction: 'svc_action',
+    svcActionData: 'svc_action_data',
+};
+const convertTicketToMeasurementProtocol = (ticket) => {
+    return keysOf(ticket)
+        .filter((key) => ticket[key] !== undefined)
+        .reduce((mappedTicket, key) => {
+        const newKey = ticketKeysMapping[key] || key;
+        return Object.assign(Object.assign({}, mappedTicket), { [newKey]: ticket[key] });
+    }, {});
+};
+const isTicketKey = (key) => ticketKeyRegex.test(key);
+const isServiceKey = [isTicketKey];
+
+const productKeysMapping = {
+    id: 'id',
+    name: 'nm',
+    brand: 'br',
+    category: 'ca',
+    variant: 'va',
+    price: 'pr',
+    quantity: 'qt',
+    coupon: 'cc',
+    position: 'ps',
+    group: 'group',
+};
+const impressionKeysMapping = {
+    id: 'id',
+    name: 'nm',
+    brand: 'br',
+    category: 'ca',
+    variant: 'va',
+    position: 'ps',
+    price: 'pr',
+    group: 'group',
+};
+const productActionsKeysMapping = {
+    action: 'pa',
+    list: 'pal',
+    listSource: 'pls',
+};
+const transactionActionsKeysMapping = {
+    id: 'ti',
+    revenue: 'tr',
+    tax: 'tt',
+    shipping: 'ts',
+    coupon: 'tcc',
+    affiliation: 'ta',
+    step: 'cos',
+    option: 'col',
+};
+const coveoCommerceExtensionKeys = [
+    'loyaltyCardId',
+    'loyaltyTier',
+    'thirdPartyPersona',
+    'companyName',
+    'favoriteStore',
+    'storeName',
+    'userIndustry',
+    'userRole',
+    'userDepartment',
+    'businessUnit',
+];
+const quoteActionsKeysMapping = {
+    id: 'quoteId',
+    affiliation: 'quoteAffiliation',
+};
+const reviewActionsKeysMapping = {
+    id: 'reviewId',
+    rating: 'reviewRating',
+    comment: 'reviewComment',
+};
+const commerceActionKeysMappingPerAction = {
+    add: productActionsKeysMapping,
+    bookmark_add: productActionsKeysMapping,
+    bookmark_remove: productActionsKeysMapping,
+    click: productActionsKeysMapping,
+    checkout: productActionsKeysMapping,
+    checkout_option: productActionsKeysMapping,
+    detail: productActionsKeysMapping,
+    impression: productActionsKeysMapping,
+    remove: productActionsKeysMapping,
+    refund: Object.assign(Object.assign({}, productActionsKeysMapping), transactionActionsKeysMapping),
+    purchase: Object.assign(Object.assign({}, productActionsKeysMapping), transactionActionsKeysMapping),
+    quickview: productActionsKeysMapping,
+    quote: Object.assign(Object.assign({}, productActionsKeysMapping), quoteActionsKeysMapping),
+    review: Object.assign(Object.assign({}, productActionsKeysMapping), reviewActionsKeysMapping),
+};
+const productKeysMappingValues = keysOf(productKeysMapping).map((key) => productKeysMapping[key]);
+const impressionKeysMappingValues = keysOf(impressionKeysMapping).map((key) => impressionKeysMapping[key]);
+const productActionsKeysMappingValues = keysOf(productActionsKeysMapping).map((key) => productActionsKeysMapping[key]);
+const transactionActionsKeysMappingValues = keysOf(transactionActionsKeysMapping).map((key) => transactionActionsKeysMapping[key]);
+const reviewKeysMappingValues = keysOf(reviewActionsKeysMapping).map((key) => reviewActionsKeysMapping[key]);
+const quoteKeysMappingValues = keysOf(quoteActionsKeysMapping).map((key) => quoteActionsKeysMapping[key]);
+const productSubKeysMatchGroup = [...productKeysMappingValues, 'custom'].join('|');
+const impressionSubKeysMatchGroup = [...impressionKeysMappingValues, 'custom'].join('|');
+const productPrefixMatchGroup = '(pr[0-9]+)';
+const impressionPrefixMatchGroup = '(il[0-9]+pi[0-9]+)';
+const productKeyRegex = new RegExp(`^${productPrefixMatchGroup}(${productSubKeysMatchGroup})$`);
+const impressionKeyRegex = new RegExp(`^(${impressionPrefixMatchGroup}(${impressionSubKeysMatchGroup}))|(il[0-9]+nm)$`);
+const productActionsKeyRegex = new RegExp(`^(${productActionsKeysMappingValues.join('|')})$`);
+const transactionActionsKeyRegex = new RegExp(`^(${transactionActionsKeysMappingValues.join('|')})$`);
+const customProductKeyRegex = new RegExp(`^${productPrefixMatchGroup}custom$`);
+const customImpressionKeyRegex = new RegExp(`^${impressionPrefixMatchGroup}custom$`);
+const coveoCommerceExtensionKeysRegex = new RegExp(`^(${[...coveoCommerceExtensionKeys, ...reviewKeysMappingValues, ...quoteKeysMappingValues].join('|')})$`);
+const isProductKey = (key) => productKeyRegex.test(key);
+const isImpressionKey = (key) => impressionKeyRegex.test(key);
+const isProductActionsKey = (key) => productActionsKeyRegex.test(key);
+const isTransactionActionsKeyRegex = (key) => transactionActionsKeyRegex.test(key);
+const isCoveoCommerceExtensionKey = (key) => coveoCommerceExtensionKeysRegex.test(key);
+const isCommerceKey = [
+    isImpressionKey,
+    isProductKey,
+    isProductActionsKey,
+    isTransactionActionsKeyRegex,
+    isCoveoCommerceExtensionKey,
+];
+const isCustomCommerceKey = [customProductKeyRegex, customImpressionKeyRegex];
+
+const globalParamKeysMapping = {
+    anonymizeIp: 'aip',
+};
+const eventKeysMapping = {
+    eventCategory: 'ec',
+    eventAction: 'ea',
+    eventLabel: 'el',
+    eventValue: 'ev',
+    page: 'dp',
+    visitorId: 'cid',
+    clientId: 'cid',
+    userId: 'uid',
+    currencyCode: 'cu',
+};
+const contextInformationMapping = {
+    hitType: 't',
+    pageViewId: 'pid',
+    encoding: 'de',
+    location: 'dl',
+    referrer: 'dr',
+    screenColor: 'sd',
+    screenResolution: 'sr',
+    title: 'dt',
+    userAgent: 'ua',
+    language: 'ul',
+    eventId: 'z',
+    time: 'tm',
+};
+const coveoExtensionsKeys = [
+    'contentId',
+    'contentIdKey',
+    'contentType',
+    'searchHub',
+    'tab',
+    'searchUid',
+    'permanentId',
+    'contentLocale',
+];
+const baseMeasurementProtocolKeysMapping = Object.assign(Object.assign(Object.assign(Object.assign({}, globalParamKeysMapping), eventKeysMapping), contextInformationMapping), coveoExtensionsKeys.reduce((all, key) => (Object.assign(Object.assign({}, all), { [key]: key })), {}));
+
+const measurementProtocolKeysMapping = Object.assign(Object.assign({}, baseMeasurementProtocolKeysMapping), serviceActionsKeysMapping);
+const convertKeysToMeasurementProtocol = (params) => {
+    const keysMappingForAction = (!!params.action && commerceActionKeysMappingPerAction[params.action]) || {};
+    return keysOf(params).reduce((mappedKeys, key) => {
+        const newKey = keysMappingForAction[key] || measurementProtocolKeysMapping[key] || key;
+        return Object.assign(Object.assign({}, mappedKeys), { [newKey]: params[key] });
+    }, {});
+};
+const measurementProtocolKeysMappingValues = keysOf(measurementProtocolKeysMapping).map((key) => measurementProtocolKeysMapping[key]);
+const isKnownMeasurementProtocolKey = (key) => measurementProtocolKeysMappingValues.indexOf(key) !== -1;
+const isCustomKey = (key) => key === 'custom';
+const isMeasurementProtocolKey = (key) => {
+    return [...isCommerceKey, ...isServiceKey, isKnownMeasurementProtocolKey, isCustomKey].some((test) => test(key));
+};
+const convertCustomMeasurementProtocolKeys = (data) => {
+    return keysOf(data).reduce((all, current) => {
+        const match = getFirstCustomMeasurementProtocolKeyMatch(current);
+        if (match) {
+            return Object.assign(Object.assign({}, all), convertCustomObject(match, data[current]));
+        }
+        else {
+            return Object.assign(Object.assign({}, all), { [current]: data[current] });
+        }
+    }, {});
+};
+const getFirstCustomMeasurementProtocolKeyMatch = (key) => {
+    let matchedKey = undefined;
+    [...isCustomCommerceKey].every((regex) => {
+        var _a;
+        matchedKey = (_a = regex.exec(key)) === null || _a === void 0 ? void 0 : _a[1];
+        return !Boolean(matchedKey);
+    });
+    return matchedKey;
+};
+const convertCustomObject = (prefix, customData) => {
+    return keysOf(customData).reduce((allCustom, currentCustomKey) => (Object.assign(Object.assign({}, allCustom), { [`${prefix}${currentCustomKey}`]: customData[currentCustomKey] })), {});
+};
+
+class AnalyticsBeaconClient {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    sendEvent(eventType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!navigator.sendBeacon) {
+                throw new Error(`navigator.sendBeacon is not supported in this browser. Consider adding a polyfill like "sendbeacon-polyfill".`);
+            }
+            const { baseUrl, preprocessRequest } = this.opts;
+            const parsedRequestData = this.encodeForEventType(eventType, payload);
+            const paramsFragments = yield this.getQueryParamsForEventType(eventType);
+            const defaultOptions = {
+                url: `${baseUrl}/analytics/${eventType}?${paramsFragments}`,
+                body: new Blob([parsedRequestData], {
+                    type: 'application/x-www-form-urlencoded',
+                }),
+            };
+            const { url, body } = Object.assign(Object.assign({}, defaultOptions), (preprocessRequest ? yield preprocessRequest(defaultOptions, 'analyticsBeacon') : {}));
+            console.log(`Sending beacon for "${eventType}" with: `, JSON.stringify(payload));
+            navigator.sendBeacon(url, body);
+            return;
+        });
+    }
+    deleteHttpCookieVisitorId() {
+        return Promise.resolve();
+    }
+    encodeForEventType(eventType, payload) {
+        return this.isEventTypeLegacy(eventType)
+            ? this.encodeForLegacyType(eventType, payload)
+            : this.encodeForFormUrlEncoded(Object.assign({ access_token: this.opts.token }, payload));
+    }
+    getQueryParamsForEventType(eventType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { token, visitorIdProvider } = this.opts;
+            const visitorId = yield visitorIdProvider.getCurrentVisitorId();
+            return [
+                token && this.isEventTypeLegacy(eventType) ? `access_token=${token}` : '',
+                visitorId ? `visitorId=${visitorId}` : '',
+                'discardVisitInfo=true',
+            ]
+                .filter((p) => !!p)
+                .join('&');
+        });
+    }
+    isEventTypeLegacy(eventType) {
+        return [EventType.click, EventType.custom, EventType.search, EventType.view].indexOf(eventType) !== -1;
+    }
+    encodeForLegacyType(eventType, payload) {
+        return `${eventType}Event=${encodeURIComponent(JSON.stringify(payload))}`;
+    }
+    encodeForFormUrlEncoded(payload) {
+        return Object.keys(payload)
+            .filter((key) => !!payload[key])
+            .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(this.encodeValue(payload[key]))}`)
+            .join('&');
+    }
+    encodeValue(value) {
+        return typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean'
+            ? value
+            : JSON.stringify(value);
+    }
+}
+
+class NoopAnalyticsClient {
+    sendEvent(_, __) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve();
+        });
+    }
+    deleteHttpCookieVisitorId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve();
+        });
+    }
+}
+
+class BrowserRuntime {
+    constructor(clientOptions, getUnprocessedRequests) {
+        if (hasLocalStorage() && hasCookieStorage()) {
+            this.storage = new CookieAndLocalStorage();
+        }
+        else if (hasLocalStorage()) {
+            this.storage = localStorage;
+        }
+        else {
+            console.warn('BrowserRuntime detected no valid storage available.', this);
+            this.storage = new NullStorage();
+        }
+        this.client = new AnalyticsFetchClient(clientOptions);
+        this.beaconClient = new AnalyticsBeaconClient(clientOptions);
+        window.addEventListener('beforeunload', () => {
+            const requests = getUnprocessedRequests();
+            for (let { eventType, payload } of requests) {
+                this.beaconClient.sendEvent(eventType, payload);
+            }
+        });
+    }
+}
+class NodeJSRuntime {
+    constructor(clientOptions, storage) {
+        this.storage = storage || new NullStorage();
         this.client = new AnalyticsFetchClient(clientOptions);
     }
+}
+class NoopRuntime {
+    constructor() {
+        this.storage = new NullStorage();
+        this.client = new NoopAnalyticsClient();
+    }
+}
+
+const API_KEY_PREFIX = 'xx';
+const isApiKey = (token) => (token === null || token === void 0 ? void 0 : token.startsWith(API_KEY_PREFIX)) || false;
+
+const ReactNativeRuntimeWarning = `
+        We've detected you're using React Native but have not provided the corresponding runtime, 
+        for an optimal experience please use the "coveo.analytics/react-native" subpackage.
+        Follow the Readme on how to set it up: https://github.com/coveo/coveo.analytics.js#using-react-native
+    `;
+function isReactNative() {
+    return typeof navigator != 'undefined' && navigator.product == 'ReactNative';
+}
+
+const doNotTrackValues = ['1', 1, 'yes', true];
+function doNotTrack() {
+    return (hasNavigator() &&
+        [
+            navigator.globalPrivacyControl,
+            navigator.doNotTrack,
+            navigator.msDoNotTrack,
+            window.doNotTrack,
+        ].some((value) => doNotTrackValues.indexOf(value) !== -1));
+}
+
+const Version = 'v15';
+const Endpoints = {
+    default: 'https://analytics.cloud.coveo.com/rest/ua',
+    production: 'https://analytics.cloud.coveo.com/rest/ua',
+    hipaa: 'https://analyticshipaa.cloud.coveo.com/rest/ua',
+};
+function buildBaseUrl(endpoint = Endpoints.default, apiVersion = Version) {
+    const endpointIsCoveoProxy = endpoint.indexOf('.cloud.coveo.com') !== -1;
+    return `${endpoint}${endpointIsCoveoProxy ? '' : '/rest'}/${apiVersion}`;
+}
+class CoveoAnalyticsClient {
+    constructor(opts) {
+        if (!opts) {
+            throw new Error('You have to pass options to this constructor');
+        }
+        this.options = Object.assign(Object.assign({}, this.defaultOptions), opts);
+        this.visitorId = '';
+        this.bufferedRequests = [];
+        this.beforeSendHooks = [enhanceViewEvent, addDefaultValues].concat(this.options.beforeSendHooks);
+        this.afterSendHooks = this.options.afterSendHooks;
+        this.eventTypeMapping = {};
+        const clientsOptions = {
+            baseUrl: this.baseUrl,
+            token: this.options.token,
+            visitorIdProvider: this,
+            preprocessRequest: this.options.preprocessRequest,
+        };
+        this.runtime = this.options.runtimeEnvironment || this.initRuntime(clientsOptions);
+        if (doNotTrack()) {
+            this.clear();
+            this.runtime.storage = new NullStorage();
+        }
+    }
+    get defaultOptions() {
+        return {
+            endpoint: Endpoints.default,
+            token: '',
+            version: Version,
+            beforeSendHooks: [],
+            afterSendHooks: [],
+        };
+    }
+    initRuntime(clientsOptions) {
+        if (hasWindow() && hasDocument()) {
+            return new BrowserRuntime(clientsOptions, () => {
+                const copy = [...this.bufferedRequests];
+                this.bufferedRequests = [];
+                return copy;
+            });
+        }
+        else if (isReactNative()) {
+            console.warn(ReactNativeRuntimeWarning);
+        }
+        return new NodeJSRuntime(clientsOptions);
+    }
+    get storage() {
+        return this.runtime.storage;
+    }
+    determineVisitorId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (yield this.storage.getItem('visitorId')) || uuidv4();
+            }
+            catch (err) {
+                console.log('Could not get visitor ID from the current runtime environment storage. Using a random ID instead.', err);
+                return uuidv4();
+            }
+        });
+    }
+    getCurrentVisitorId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.visitorId) {
+                const id = yield this.determineVisitorId();
+                yield this.setCurrentVisitorId(id);
+            }
+            return this.visitorId;
+        });
+    }
+    setCurrentVisitorId(visitorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.visitorId = visitorId;
+            yield this.storage.setItem('visitorId', visitorId);
+        });
+    }
+    getParameters(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.resolveParameters(eventType, ...payload);
+        });
+    }
+    getPayload(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parametersToSend = yield this.resolveParameters(eventType, ...payload);
+            return yield this.resolvePayloadForParameters(eventType, parametersToSend);
+        });
+    }
+    get currentVisitorId() {
+        const visitorId = this.visitorId || this.storage.getItem('visitorId');
+        if (typeof visitorId !== 'string') {
+            this.setCurrentVisitorId(uuidv4());
+        }
+        return this.visitorId;
+    }
+    set currentVisitorId(visitorId) {
+        this.visitorId = visitorId;
+        this.storage.setItem('visitorId', visitorId);
+    }
+    resolveParameters(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { variableLengthArgumentsNames = [], addVisitorIdParameter = false, usesMeasurementProtocol = false, addClientIdParameter = false, } = this.eventTypeMapping[eventType] || {};
+            const processVariableArgumentNamesStep = (currentPayload) => variableLengthArgumentsNames.length > 0
+                ? this.parseVariableArgumentsPayload(variableLengthArgumentsNames, currentPayload)
+                : currentPayload[0];
+            const addVisitorIdStep = (currentPayload) => __awaiter(this, void 0, void 0, function* () {
+                return (Object.assign(Object.assign({}, currentPayload), { visitorId: addVisitorIdParameter ? yield this.getCurrentVisitorId() : '' }));
+            });
+            const addClientIdStep = (currentPayload) => __awaiter(this, void 0, void 0, function* () {
+                if (addClientIdParameter) {
+                    return Object.assign(Object.assign({}, currentPayload), { clientId: yield this.getCurrentVisitorId() });
+                }
+                return currentPayload;
+            });
+            const setAnonymousUserStep = (currentPayload) => usesMeasurementProtocol ? this.ensureAnonymousUserWhenUsingApiKey(currentPayload) : currentPayload;
+            const processBeforeSendHooksStep = (currentPayload) => this.beforeSendHooks.reduce((promisePayload, current) => __awaiter(this, void 0, void 0, function* () {
+                const payload = yield promisePayload;
+                return yield current(eventType, payload);
+            }), currentPayload);
+            const parametersToSend = yield [
+                processVariableArgumentNamesStep,
+                addVisitorIdStep,
+                addClientIdStep,
+                setAnonymousUserStep,
+                processBeforeSendHooksStep,
+            ].reduce((payloadPromise, step) => __awaiter(this, void 0, void 0, function* () {
+                const payload = yield payloadPromise;
+                return yield step(payload);
+            }), Promise.resolve(payload));
+            return parametersToSend;
+        });
+    }
+    resolvePayloadForParameters(eventType, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { usesMeasurementProtocol = false } = this.eventTypeMapping[eventType] || {};
+            const cleanPayloadStep = (currentPayload) => this.removeEmptyPayloadValues(currentPayload, eventType);
+            const validateParams = (currentPayload) => this.validateParams(currentPayload);
+            const processMeasurementProtocolConversionStep = (currentPayload) => usesMeasurementProtocol ? convertKeysToMeasurementProtocol(currentPayload) : currentPayload;
+            const removeUnknownParameters = (currentPayload) => usesMeasurementProtocol ? this.removeUnknownParameters(currentPayload) : currentPayload;
+            const processCustomParameters = (currentPayload) => usesMeasurementProtocol ? this.processCustomParameters(currentPayload) : currentPayload;
+            const payloadToSend = yield [
+                cleanPayloadStep,
+                validateParams,
+                processMeasurementProtocolConversionStep,
+                removeUnknownParameters,
+                processCustomParameters,
+            ].reduce((payloadPromise, step) => __awaiter(this, void 0, void 0, function* () {
+                const payload = yield payloadPromise;
+                return yield step(payload);
+            }), Promise.resolve(parameters));
+            return payloadToSend;
+        });
+    }
+    sendEvent(eventType, ...payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { newEventType: eventTypeToSend = eventType } = this.eventTypeMapping[eventType] || {};
+            const parametersToSend = yield this.resolveParameters(eventType, ...payload);
+            const payloadToSend = yield this.resolvePayloadForParameters(eventType, parametersToSend);
+            this.bufferedRequests.push({
+                eventType: eventTypeToSend,
+                payload: payloadToSend,
+            });
+            yield Promise.all(this.afterSendHooks.map((hook) => hook(eventType, parametersToSend)));
+            yield this.deferExecution();
+            return yield this.sendFromBufferWithFetch();
+        });
+    }
+    deferExecution() {
+        return new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    sendFromBufferWithFetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const popped = this.bufferedRequests.shift();
+            if (popped) {
+                const { eventType, payload } = popped;
+                return this.runtime.client.sendEvent(eventType, payload);
+            }
+        });
+    }
+    clear() {
+        this.storage.removeItem('visitorId');
+        const store = new HistoryStore();
+        store.clear();
+    }
+    deleteHttpOnlyVisitorId() {
+        this.runtime.client.deleteHttpCookieVisitorId();
+    }
+    sendSearchEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendEvent(EventType.search, request);
+        });
+    }
+    sendClickEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendEvent(EventType.click, request);
+        });
+    }
+    sendCustomEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendEvent(EventType.custom, request);
+        });
+    }
+    sendViewEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendEvent(EventType.view, request);
+        });
+    }
+    getVisit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${this.baseUrl}/analytics/visit`);
+            const visit = (yield response.json());
+            this.visitorId = visit.visitorId;
+            return visit;
+        });
+    }
+    getHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${this.baseUrl}/analytics/monitoring/health`);
+            return (yield response.json());
+        });
+    }
+    registerBeforeSendEventHook(hook) {
+        this.beforeSendHooks.push(hook);
+    }
+    registerAfterSendEventHook(hook) {
+        this.afterSendHooks.push(hook);
+    }
+    addEventTypeMapping(eventType, eventConfig) {
+        this.eventTypeMapping[eventType] = eventConfig;
+    }
+    parseVariableArgumentsPayload(fieldsOrder, payload) {
+        const parsedArguments = {};
+        for (let i = 0, length = payload.length; i < length; i++) {
+            const currentArgument = payload[i];
+            if (typeof currentArgument === 'string') {
+                parsedArguments[fieldsOrder[i]] = currentArgument;
+            }
+            else if (typeof currentArgument === 'object') {
+                return Object.assign(Object.assign({}, parsedArguments), currentArgument);
+            }
+        }
+        return parsedArguments;
+    }
+    isKeyAllowedEmpty(evtType, key) {
+        const keysThatCanBeEmpty = {
+            [EventType.search]: ['queryText'],
+        };
+        const match = keysThatCanBeEmpty[evtType] || [];
+        return match.indexOf(key) !== -1;
+    }
+    removeEmptyPayloadValues(payload, eventType) {
+        const isNotEmptyValue = (value) => typeof value !== 'undefined' && value !== null && value !== '';
+        return Object.keys(payload)
+            .filter((key) => this.isKeyAllowedEmpty(eventType, key) || isNotEmptyValue(payload[key]))
+            .reduce((newPayload, key) => (Object.assign(Object.assign({}, newPayload), { [key]: payload[key] })), {});
+    }
+    removeUnknownParameters(payload) {
+        const newPayload = Object.keys(payload)
+            .filter((key) => {
+            if (isMeasurementProtocolKey(key)) {
+                return true;
+            }
+            else {
+                console.log(key, 'is not processed by coveoua');
+            }
+        })
+            .reduce((newPayload, key) => (Object.assign(Object.assign({}, newPayload), { [key]: payload[key] })), {});
+        return newPayload;
+    }
+    processCustomParameters(payload) {
+        const { custom } = payload, rest = __rest(payload, ["custom"]);
+        const lowercasedCustom = this.lowercaseKeys(custom);
+        const newPayload = convertCustomMeasurementProtocolKeys(rest);
+        return Object.assign(Object.assign({}, lowercasedCustom), newPayload);
+    }
+    lowercaseKeys(custom) {
+        const keys = Object.keys(custom || {});
+        return keys.reduce((all, key) => (Object.assign(Object.assign({}, all), { [key.toLowerCase()]: custom[key] })), {});
+    }
+    validateParams(payload) {
+        const { anonymizeIp } = payload, rest = __rest(payload, ["anonymizeIp"]);
+        if (anonymizeIp !== undefined) {
+            if (['0', 'false', 'undefined', 'null', '{}', '[]', ''].indexOf(`${anonymizeIp}`.toLowerCase()) == -1) {
+                rest['anonymizeIp'] = 1;
+            }
+        }
+        return rest;
+    }
+    ensureAnonymousUserWhenUsingApiKey(payload) {
+        const { userId } = payload, rest = __rest(payload, ["userId"]);
+        if (isApiKey(this.options.token) && !userId) {
+            rest['userId'] = 'anonymous';
+            return rest;
+        }
+        else {
+            return payload;
+        }
+    }
+    get baseUrl() {
+        return buildBaseUrl(this.options.endpoint, this.options.version);
+    }
+}
+
+class ReactNativeRuntime {
+    constructor(options) {
+        var _a;
+        const visitorIdKey = (_a = options.visitorIdKey) !== null && _a !== void 0 ? _a : 'visitorId';
+        this.storage = options.storage;
+        this.client = new AnalyticsFetchClient({
+            preprocessRequest: options.preprocessRequest,
+            token: options.token,
+            baseUrl: buildBaseUrl(options.endpoint, options.version),
+            visitorIdProvider: {
+                getCurrentVisitorId: () => __awaiter(this, void 0, void 0, function* () { return (yield this.storage.getItem(visitorIdKey)) || uuidv4(); }),
+                setCurrentVisitorId: (visitorId) => this.storage.setItem(visitorIdKey, visitorId),
+            },
+        });
+    }
+}
+
+var InsightEvents;
+(function (InsightEvents) {
+    InsightEvents["contextChanged"] = "contextChanged";
+    InsightEvents["expandToFullUI"] = "expandToFullUI";
+})(InsightEvents || (InsightEvents = {}));
+
+var SearchPageEvents;
+(function (SearchPageEvents) {
+    SearchPageEvents["interfaceLoad"] = "interfaceLoad";
+    SearchPageEvents["interfaceChange"] = "interfaceChange";
+    SearchPageEvents["didyoumeanAutomatic"] = "didyoumeanAutomatic";
+    SearchPageEvents["didyoumeanClick"] = "didyoumeanClick";
+    SearchPageEvents["resultsSort"] = "resultsSort";
+    SearchPageEvents["searchboxSubmit"] = "searchboxSubmit";
+    SearchPageEvents["searchboxClear"] = "searchboxClear";
+    SearchPageEvents["searchboxAsYouType"] = "searchboxAsYouType";
+    SearchPageEvents["breadcrumbFacet"] = "breadcrumbFacet";
+    SearchPageEvents["breadcrumbResetAll"] = "breadcrumbResetAll";
+    SearchPageEvents["documentQuickview"] = "documentQuickview";
+    SearchPageEvents["documentOpen"] = "documentOpen";
+    SearchPageEvents["omniboxAnalytics"] = "omniboxAnalytics";
+    SearchPageEvents["omniboxFromLink"] = "omniboxFromLink";
+    SearchPageEvents["searchFromLink"] = "searchFromLink";
+    SearchPageEvents["triggerNotify"] = "notify";
+    SearchPageEvents["triggerExecute"] = "execute";
+    SearchPageEvents["triggerQuery"] = "query";
+    SearchPageEvents["undoTriggerQuery"] = "undoQuery";
+    SearchPageEvents["triggerRedirect"] = "redirect";
+    SearchPageEvents["pagerResize"] = "pagerResize";
+    SearchPageEvents["pagerNumber"] = "pagerNumber";
+    SearchPageEvents["pagerNext"] = "pagerNext";
+    SearchPageEvents["pagerPrevious"] = "pagerPrevious";
+    SearchPageEvents["pagerScrolling"] = "pagerScrolling";
+    SearchPageEvents["staticFilterClearAll"] = "staticFilterClearAll";
+    SearchPageEvents["staticFilterSelect"] = "staticFilterSelect";
+    SearchPageEvents["staticFilterDeselect"] = "staticFilterDeselect";
+    SearchPageEvents["facetClearAll"] = "facetClearAll";
+    SearchPageEvents["facetSearch"] = "facetSearch";
+    SearchPageEvents["facetSelect"] = "facetSelect";
+    SearchPageEvents["facetSelectAll"] = "facetSelectAll";
+    SearchPageEvents["facetDeselect"] = "facetDeselect";
+    SearchPageEvents["facetExclude"] = "facetExclude";
+    SearchPageEvents["facetUnexclude"] = "facetUnexclude";
+    SearchPageEvents["facetUpdateSort"] = "facetUpdateSort";
+    SearchPageEvents["facetShowMore"] = "showMoreFacetResults";
+    SearchPageEvents["facetShowLess"] = "showLessFacetResults";
+    SearchPageEvents["queryError"] = "query";
+    SearchPageEvents["queryErrorBack"] = "errorBack";
+    SearchPageEvents["queryErrorClear"] = "errorClearQuery";
+    SearchPageEvents["queryErrorRetry"] = "errorRetry";
+    SearchPageEvents["recommendation"] = "recommendation";
+    SearchPageEvents["recommendationInterfaceLoad"] = "recommendationInterfaceLoad";
+    SearchPageEvents["recommendationOpen"] = "recommendationOpen";
+    SearchPageEvents["likeSmartSnippet"] = "likeSmartSnippet";
+    SearchPageEvents["dislikeSmartSnippet"] = "dislikeSmartSnippet";
+    SearchPageEvents["expandSmartSnippet"] = "expandSmartSnippet";
+    SearchPageEvents["collapseSmartSnippet"] = "collapseSmartSnippet";
+    SearchPageEvents["openSmartSnippetFeedbackModal"] = "openSmartSnippetFeedbackModal";
+    SearchPageEvents["closeSmartSnippetFeedbackModal"] = "closeSmartSnippetFeedbackModal";
+    SearchPageEvents["sendSmartSnippetReason"] = "sendSmartSnippetReason";
+    SearchPageEvents["expandSmartSnippetSuggestion"] = "expandSmartSnippetSuggestion";
+    SearchPageEvents["collapseSmartSnippetSuggestion"] = "collapseSmartSnippetSuggestion";
+    SearchPageEvents["showMoreSmartSnippetSuggestion"] = "showMoreSmartSnippetSuggestion";
+    SearchPageEvents["showLessSmartSnippetSuggestion"] = "showLessSmartSnippetSuggestion";
+    SearchPageEvents["openSmartSnippetSource"] = "openSmartSnippetSource";
+    SearchPageEvents["openSmartSnippetSuggestionSource"] = "openSmartSnippetSuggestionSource";
+    SearchPageEvents["openSmartSnippetInlineLink"] = "openSmartSnippetInlineLink";
+    SearchPageEvents["openSmartSnippetSuggestionInlineLink"] = "openSmartSnippetSuggestionInlineLink";
+    SearchPageEvents["recentQueryClick"] = "recentQueriesClick";
+    SearchPageEvents["clearRecentQueries"] = "clearRecentQueries";
+    SearchPageEvents["recentResultClick"] = "recentResultClick";
+    SearchPageEvents["clearRecentResults"] = "clearRecentResults";
+    SearchPageEvents["noResultsBack"] = "noResultsBack";
+    SearchPageEvents["showMoreFoldedResults"] = "showMoreFoldedResults";
+    SearchPageEvents["showLessFoldedResults"] = "showLessFoldedResults";
+})(SearchPageEvents || (SearchPageEvents = {}));
+const CustomEventsTypes = {
+    [SearchPageEvents.triggerNotify]: 'queryPipelineTriggers',
+    [SearchPageEvents.triggerExecute]: 'queryPipelineTriggers',
+    [SearchPageEvents.triggerQuery]: 'queryPipelineTriggers',
+    [SearchPageEvents.triggerRedirect]: 'queryPipelineTriggers',
+    [SearchPageEvents.queryError]: 'errors',
+    [SearchPageEvents.queryErrorBack]: 'errors',
+    [SearchPageEvents.queryErrorClear]: 'errors',
+    [SearchPageEvents.queryErrorRetry]: 'errors',
+    [SearchPageEvents.pagerNext]: 'getMoreResults',
+    [SearchPageEvents.pagerPrevious]: 'getMoreResults',
+    [SearchPageEvents.pagerNumber]: 'getMoreResults',
+    [SearchPageEvents.pagerResize]: 'getMoreResults',
+    [SearchPageEvents.pagerScrolling]: 'getMoreResults',
+    [SearchPageEvents.facetSearch]: 'facet',
+    [SearchPageEvents.facetShowLess]: 'facet',
+    [SearchPageEvents.facetShowMore]: 'facet',
+    [SearchPageEvents.recommendation]: 'recommendation',
+    [SearchPageEvents.likeSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.dislikeSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.expandSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.collapseSmartSnippet]: 'smartSnippet',
+    [SearchPageEvents.openSmartSnippetFeedbackModal]: 'smartSnippet',
+    [SearchPageEvents.closeSmartSnippetFeedbackModal]: 'smartSnippet',
+    [SearchPageEvents.sendSmartSnippetReason]: 'smartSnippet',
+    [SearchPageEvents.expandSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.collapseSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.showMoreSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.showLessSmartSnippetSuggestion]: 'smartSnippetSuggestions',
+    [SearchPageEvents.clearRecentQueries]: 'recentQueries',
+    [SearchPageEvents.recentResultClick]: 'recentlyClickedDocuments',
+    [SearchPageEvents.clearRecentResults]: 'recentlyClickedDocuments',
+    [SearchPageEvents.showLessFoldedResults]: 'folding',
+    [InsightEvents.expandToFullUI]: 'interface',
+};
+
+class NoopAnalytics {
+    constructor() {
+        this.runtime = new NoopRuntime();
+        this.currentVisitorId = '';
+    }
+    getPayload() {
+        return Promise.resolve();
+    }
+    getParameters() {
+        return Promise.resolve();
+    }
+    sendEvent() {
+        return Promise.resolve();
+    }
+    sendSearchEvent() {
+        return Promise.resolve();
+    }
+    sendClickEvent() {
+        return Promise.resolve();
+    }
+    sendCustomEvent() {
+        return Promise.resolve();
+    }
+    sendViewEvent() {
+        return Promise.resolve();
+    }
+    getVisit() {
+        return Promise.resolve({ id: '', visitorId: '' });
+    }
+    getHealth() {
+        return Promise.resolve({ status: '' });
+    }
+    registerBeforeSendEventHook() { }
+    registerAfterSendEventHook() { }
+    addEventTypeMapping() { }
+}
+
+function filterConsecutiveRepeatedValues(rawData) {
+    let prev = '';
+    return rawData.filter((value) => {
+        const isDifferent = value !== prev;
+        prev = value;
+        return isDifferent;
+    });
+}
+function removeSemicolons(rawData) {
+    return rawData.map((value) => {
+        return value.replace(/;/g, '');
+    });
+}
+function getDataString(data) {
+    const ANALYTICS_LENGTH_LIMIT = 256;
+    const formattedData = data.join(';');
+    if (formattedData.length <= ANALYTICS_LENGTH_LIMIT) {
+        return formattedData;
+    }
+    return getDataString(data.slice(1));
+}
+const formatArrayForCoveoCustomData = (rawData) => {
+    const dataWithoutSemicolons = removeSemicolons(rawData);
+    const dataWithoutRepeatedValues = filterConsecutiveRepeatedValues(dataWithoutSemicolons);
+    return getDataString(dataWithoutRepeatedValues);
+};
+
+function formatOmniboxMetadata(meta) {
+    const partialQueries = typeof meta.partialQueries === 'string'
+        ? meta.partialQueries
+        : formatArrayForCoveoCustomData(meta.partialQueries);
+    const suggestions = typeof meta.suggestions === 'string' ? meta.suggestions : formatArrayForCoveoCustomData(meta.suggestions);
+    return Object.assign(Object.assign({}, meta), { partialQueries,
+        suggestions });
+}
+
+class CoveoSearchPageClient {
+    constructor(opts, provider) {
+        this.opts = opts;
+        this.provider = provider;
+        const shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+    }
+    disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+    }
+    enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+    }
+    makeInterfaceLoad() {
+        return this.makeSearchEvent(SearchPageEvents.interfaceLoad);
+    }
+    logInterfaceLoad() {
+        return this.makeInterfaceLoad().log();
+    }
+    makeRecommendationInterfaceLoad() {
+        return this.makeSearchEvent(SearchPageEvents.recommendationInterfaceLoad);
+    }
+    logRecommendationInterfaceLoad() {
+        return this.makeRecommendationInterfaceLoad().log();
+    }
+    makeRecommendation() {
+        return this.makeCustomEvent(SearchPageEvents.recommendation);
+    }
+    logRecommendation() {
+        return this.makeRecommendation().log();
+    }
+    makeRecommendationOpen(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.recommendationOpen, info, identifier);
+    }
+    logRecommendationOpen(info, identifier) {
+        return this.makeRecommendationOpen(info, identifier).log();
+    }
+    makeStaticFilterClearAll(meta) {
+        return this.makeSearchEvent(SearchPageEvents.staticFilterClearAll, meta);
+    }
+    logStaticFilterClearAll(meta) {
+        return this.makeStaticFilterClearAll(meta).log();
+    }
+    makeStaticFilterSelect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.staticFilterSelect, meta);
+    }
+    logStaticFilterSelect(meta) {
+        return this.makeStaticFilterSelect(meta).log();
+    }
+    makeStaticFilterDeselect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.staticFilterDeselect, meta);
+    }
+    logStaticFilterDeselect(meta) {
+        return this.makeStaticFilterDeselect(meta).log();
+    }
+    makeFetchMoreResults() {
+        return this.makeCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+    }
+    logFetchMoreResults() {
+        return this.makeFetchMoreResults().log();
+    }
+    makeInterfaceChange(metadata) {
+        return this.makeSearchEvent(SearchPageEvents.interfaceChange, metadata);
+    }
+    logInterfaceChange(metadata) {
+        return this.makeInterfaceChange(metadata).log();
+    }
+    makeDidYouMeanAutomatic() {
+        return this.makeSearchEvent(SearchPageEvents.didyoumeanAutomatic);
+    }
+    logDidYouMeanAutomatic() {
+        return this.makeDidYouMeanAutomatic().log();
+    }
+    makeDidYouMeanClick() {
+        return this.makeSearchEvent(SearchPageEvents.didyoumeanClick);
+    }
+    logDidYouMeanClick() {
+        return this.makeDidYouMeanClick().log();
+    }
+    makeResultsSort(metadata) {
+        return this.makeSearchEvent(SearchPageEvents.resultsSort, metadata);
+    }
+    logResultsSort(metadata) {
+        return this.makeResultsSort(metadata).log();
+    }
+    makeSearchboxSubmit() {
+        return this.makeSearchEvent(SearchPageEvents.searchboxSubmit);
+    }
+    logSearchboxSubmit() {
+        return this.makeSearchboxSubmit().log();
+    }
+    makeSearchboxClear() {
+        return this.makeSearchEvent(SearchPageEvents.searchboxClear);
+    }
+    logSearchboxClear() {
+        return this.makeSearchboxClear().log();
+    }
+    makeSearchboxAsYouType() {
+        return this.makeSearchEvent(SearchPageEvents.searchboxAsYouType);
+    }
+    logSearchboxAsYouType() {
+        return this.makeSearchboxAsYouType().log();
+    }
+    makeBreadcrumbFacet(metadata) {
+        return this.makeSearchEvent(SearchPageEvents.breadcrumbFacet, metadata);
+    }
+    logBreadcrumbFacet(metadata) {
+        return this.makeBreadcrumbFacet(metadata).log();
+    }
+    makeBreadcrumbResetAll() {
+        return this.makeSearchEvent(SearchPageEvents.breadcrumbResetAll);
+    }
+    logBreadcrumbResetAll() {
+        return this.makeBreadcrumbResetAll().log();
+    }
+    makeDocumentQuickview(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.documentQuickview, info, identifier);
+    }
+    logDocumentQuickview(info, identifier) {
+        return this.makeDocumentQuickview(info, identifier).log();
+    }
+    makeDocumentOpen(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.documentOpen, info, identifier);
+    }
+    logDocumentOpen(info, identifier) {
+        return this.makeDocumentOpen(info, identifier).log();
+    }
+    makeOmniboxAnalytics(meta) {
+        return this.makeSearchEvent(SearchPageEvents.omniboxAnalytics, formatOmniboxMetadata(meta));
+    }
+    logOmniboxAnalytics(meta) {
+        return this.makeOmniboxAnalytics(meta).log();
+    }
+    makeOmniboxFromLink(meta) {
+        return this.makeSearchEvent(SearchPageEvents.omniboxFromLink, formatOmniboxMetadata(meta));
+    }
+    logOmniboxFromLink(meta) {
+        return this.makeOmniboxFromLink(meta).log();
+    }
+    makeSearchFromLink() {
+        return this.makeSearchEvent(SearchPageEvents.searchFromLink);
+    }
+    logSearchFromLink() {
+        return this.makeSearchFromLink().log();
+    }
+    makeTriggerNotify(meta) {
+        return this.makeCustomEvent(SearchPageEvents.triggerNotify, meta);
+    }
+    logTriggerNotify(meta) {
+        return this.makeTriggerNotify(meta).log();
+    }
+    makeTriggerExecute(meta) {
+        return this.makeCustomEvent(SearchPageEvents.triggerExecute, meta);
+    }
+    logTriggerExecute(meta) {
+        return this.makeTriggerExecute(meta).log();
+    }
+    makeTriggerQuery() {
+        return this.makeCustomEvent(SearchPageEvents.triggerQuery, { query: this.provider.getSearchEventRequestPayload().queryText }, 'queryPipelineTriggers');
+    }
+    logTriggerQuery() {
+        return this.makeTriggerQuery().log();
+    }
+    makeUndoTriggerQuery(meta) {
+        return this.makeSearchEvent(SearchPageEvents.undoTriggerQuery, meta);
+    }
+    logUndoTriggerQuery(meta) {
+        return this.makeUndoTriggerQuery(meta).log();
+    }
+    makeTriggerRedirect(meta) {
+        return this.makeCustomEvent(SearchPageEvents.triggerRedirect, Object.assign(Object.assign({}, meta), { query: this.provider.getSearchEventRequestPayload().queryText }));
+    }
+    logTriggerRedirect(meta) {
+        return this.makeTriggerRedirect(meta).log();
+    }
+    makePagerResize(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerResize, meta);
+    }
+    logPagerResize(meta) {
+        return this.makePagerResize(meta).log();
+    }
+    makePagerNumber(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerNumber, meta);
+    }
+    logPagerNumber(meta) {
+        return this.makePagerNumber(meta).log();
+    }
+    makePagerNext(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerNext, meta);
+    }
+    logPagerNext(meta) {
+        return this.makePagerNext(meta).log();
+    }
+    makePagerPrevious(meta) {
+        return this.makeCustomEvent(SearchPageEvents.pagerPrevious, meta);
+    }
+    logPagerPrevious(meta) {
+        return this.makePagerPrevious(meta).log();
+    }
+    makePagerScrolling() {
+        return this.makeCustomEvent(SearchPageEvents.pagerScrolling);
+    }
+    logPagerScrolling() {
+        return this.makePagerScrolling().log();
+    }
+    makeFacetClearAll(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetClearAll, meta);
+    }
+    logFacetClearAll(meta) {
+        return this.makeFacetClearAll(meta).log();
+    }
+    makeFacetSearch(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetSearch, meta);
+    }
+    logFacetSearch(meta) {
+        return this.makeFacetSearch(meta).log();
+    }
+    makeFacetSelect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetSelect, meta);
+    }
+    logFacetSelect(meta) {
+        return this.makeFacetSelect(meta).log();
+    }
+    makeFacetDeselect(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetDeselect, meta);
+    }
+    logFacetDeselect(meta) {
+        return this.makeFacetDeselect(meta).log();
+    }
+    makeFacetExclude(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetExclude, meta);
+    }
+    logFacetExclude(meta) {
+        return this.makeFacetExclude(meta).log();
+    }
+    makeFacetUnexclude(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetUnexclude, meta);
+    }
+    logFacetUnexclude(meta) {
+        return this.makeFacetUnexclude(meta).log();
+    }
+    makeFacetSelectAll(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetSelectAll, meta);
+    }
+    logFacetSelectAll(meta) {
+        return this.makeFacetSelectAll(meta).log();
+    }
+    makeFacetUpdateSort(meta) {
+        return this.makeSearchEvent(SearchPageEvents.facetUpdateSort, meta);
+    }
+    logFacetUpdateSort(meta) {
+        return this.makeFacetUpdateSort(meta).log();
+    }
+    makeFacetShowMore(meta) {
+        return this.makeCustomEvent(SearchPageEvents.facetShowMore, meta);
+    }
+    logFacetShowMore(meta) {
+        return this.makeFacetShowMore(meta).log();
+    }
+    makeFacetShowLess(meta) {
+        return this.makeCustomEvent(SearchPageEvents.facetShowLess, meta);
+    }
+    logFacetShowLess(meta) {
+        return this.makeFacetShowLess(meta).log();
+    }
+    makeQueryError(meta) {
+        return this.makeCustomEvent(SearchPageEvents.queryError, meta);
+    }
+    logQueryError(meta) {
+        return this.makeQueryError(meta).log();
+    }
+    makeQueryErrorBack() {
+        return {
+            description: this.makeDescription(SearchPageEvents.queryErrorBack),
+            log: () => __awaiter(this, void 0, void 0, function* () {
+                yield this.logCustomEvent(SearchPageEvents.queryErrorBack);
+                return this.logSearchEvent(SearchPageEvents.queryErrorBack);
+            }),
+        };
+    }
+    logQueryErrorBack() {
+        return this.makeQueryErrorBack().log();
+    }
+    makeQueryErrorRetry() {
+        return {
+            description: this.makeDescription(SearchPageEvents.queryErrorRetry),
+            log: () => __awaiter(this, void 0, void 0, function* () {
+                yield this.logCustomEvent(SearchPageEvents.queryErrorRetry);
+                return this.logSearchEvent(SearchPageEvents.queryErrorRetry);
+            }),
+        };
+    }
+    logQueryErrorRetry() {
+        return this.makeQueryErrorRetry().log();
+    }
+    makeQueryErrorClear() {
+        return {
+            description: this.makeDescription(SearchPageEvents.queryErrorClear),
+            log: () => __awaiter(this, void 0, void 0, function* () {
+                yield this.logCustomEvent(SearchPageEvents.queryErrorClear);
+                return this.logSearchEvent(SearchPageEvents.queryErrorClear);
+            }),
+        };
+    }
+    logQueryErrorClear() {
+        return this.makeQueryErrorClear().log();
+    }
+    makeLikeSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.likeSmartSnippet);
+    }
+    logLikeSmartSnippet() {
+        return this.makeLikeSmartSnippet().log();
+    }
+    makeDislikeSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.dislikeSmartSnippet);
+    }
+    logDislikeSmartSnippet() {
+        return this.makeDislikeSmartSnippet().log();
+    }
+    makeExpandSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.expandSmartSnippet);
+    }
+    logExpandSmartSnippet() {
+        return this.makeExpandSmartSnippet().log();
+    }
+    makeCollapseSmartSnippet() {
+        return this.makeCustomEvent(SearchPageEvents.collapseSmartSnippet);
+    }
+    logCollapseSmartSnippet() {
+        return this.makeCollapseSmartSnippet().log();
+    }
+    makeOpenSmartSnippetFeedbackModal() {
+        return this.makeCustomEvent(SearchPageEvents.openSmartSnippetFeedbackModal);
+    }
+    logOpenSmartSnippetFeedbackModal() {
+        return this.makeOpenSmartSnippetFeedbackModal().log();
+    }
+    makeCloseSmartSnippetFeedbackModal() {
+        return this.makeCustomEvent(SearchPageEvents.closeSmartSnippetFeedbackModal);
+    }
+    logCloseSmartSnippetFeedbackModal() {
+        return this.makeCloseSmartSnippetFeedbackModal().log();
+    }
+    makeSmartSnippetFeedbackReason(reason, details) {
+        return this.makeCustomEvent(SearchPageEvents.sendSmartSnippetReason, { reason, details });
+    }
+    logSmartSnippetFeedbackReason(reason, details) {
+        return this.makeSmartSnippetFeedbackReason(reason, details).log();
+    }
+    makeExpandSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.expandSmartSnippetSuggestion, 'documentId' in snippet ? snippet : { documentId: snippet });
+    }
+    logExpandSmartSnippetSuggestion(snippet) {
+        return this.makeExpandSmartSnippetSuggestion(snippet).log();
+    }
+    makeCollapseSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.collapseSmartSnippetSuggestion, 'documentId' in snippet ? snippet : { documentId: snippet });
+    }
+    logCollapseSmartSnippetSuggestion(snippet) {
+        return this.makeCollapseSmartSnippetSuggestion(snippet).log();
+    }
+    makeShowMoreSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.showMoreSmartSnippetSuggestion, snippet);
+    }
+    logShowMoreSmartSnippetSuggestion(snippet) {
+        return this.makeShowMoreSmartSnippetSuggestion(snippet).log();
+    }
+    makeShowLessSmartSnippetSuggestion(snippet) {
+        return this.makeCustomEvent(SearchPageEvents.showLessSmartSnippetSuggestion, snippet);
+    }
+    logShowLessSmartSnippetSuggestion(snippet) {
+        return this.makeShowLessSmartSnippetSuggestion(snippet).log();
+    }
+    makeOpenSmartSnippetSource(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetSource, info, identifier);
+    }
+    logOpenSmartSnippetSource(info, identifier) {
+        return this.makeOpenSmartSnippetSource(info, identifier).log();
+    }
+    makeOpenSmartSnippetSuggestionSource(info, snippet) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetSuggestionSource, info, { contentIDKey: snippet.documentId.contentIdKey, contentIDValue: snippet.documentId.contentIdValue }, snippet);
+    }
+    logOpenSmartSnippetSuggestionSource(info, snippet) {
+        return this.makeOpenSmartSnippetSuggestionSource(info, snippet).log();
+    }
+    makeOpenSmartSnippetInlineLink(info, identifierAndLink) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetInlineLink, info, { contentIDKey: identifierAndLink.contentIDKey, contentIDValue: identifierAndLink.contentIDValue }, identifierAndLink);
+    }
+    logOpenSmartSnippetInlineLink(info, identifierAndLink) {
+        return this.makeOpenSmartSnippetInlineLink(info, identifierAndLink).log();
+    }
+    makeOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink) {
+        return this.makeClickEvent(SearchPageEvents.openSmartSnippetSuggestionInlineLink, info, {
+            contentIDKey: snippetAndLink.documentId.contentIdKey,
+            contentIDValue: snippetAndLink.documentId.contentIdValue,
+        }, snippetAndLink);
+    }
+    logOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink) {
+        return this.makeOpenSmartSnippetSuggestionInlineLink(info, snippetAndLink).log();
+    }
+    makeRecentQueryClick() {
+        return this.makeSearchEvent(SearchPageEvents.recentQueryClick);
+    }
+    logRecentQueryClick() {
+        return this.makeRecentQueryClick().log();
+    }
+    makeClearRecentQueries() {
+        return this.makeCustomEvent(SearchPageEvents.clearRecentQueries);
+    }
+    logClearRecentQueries() {
+        return this.makeClearRecentQueries().log();
+    }
+    makeRecentResultClick(info, identifier) {
+        return this.makeCustomEvent(SearchPageEvents.recentResultClick, { info, identifier });
+    }
+    logRecentResultClick(info, identifier) {
+        return this.makeRecentResultClick(info, identifier).log();
+    }
+    makeClearRecentResults() {
+        return this.makeCustomEvent(SearchPageEvents.clearRecentResults);
+    }
+    logClearRecentResults() {
+        return this.makeClearRecentResults().log();
+    }
+    makeNoResultsBack() {
+        return this.makeSearchEvent(SearchPageEvents.noResultsBack);
+    }
+    logNoResultsBack() {
+        return this.makeNoResultsBack().log();
+    }
+    makeShowMoreFoldedResults(info, identifier) {
+        return this.makeClickEvent(SearchPageEvents.showMoreFoldedResults, info, identifier);
+    }
+    logShowMoreFoldedResults(info, identifier) {
+        return this.makeShowMoreFoldedResults(info, identifier).log();
+    }
+    makeShowLessFoldedResults() {
+        return this.makeCustomEvent(SearchPageEvents.showLessFoldedResults);
+    }
+    logShowLessFoldedResults() {
+        return this.makeShowLessFoldedResults().log();
+    }
+    makeCustomEvent(event, metadata, eventType = CustomEventsTypes[event]) {
+        const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+        return {
+            description: this.makeDescription(event, metadata),
+            log: () => __awaiter(this, void 0, void 0, function* () {
+                const payload = Object.assign(Object.assign({}, (yield this.getBaseCustomEventRequest(customData))), { eventType, eventValue: event });
+                return this.coveoAnalyticsClient.sendCustomEvent(payload);
+            }),
+        };
+    }
+    logCustomEvent(event, metadata, eventType = CustomEventsTypes[event]) {
+        return this.makeCustomEvent(event, metadata, eventType).log();
+    }
+    makeCustomEventWithType(eventValue, eventType, metadata) {
+        const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+        return {
+            description: { actionCause: eventValue, customData },
+            log: () => __awaiter(this, void 0, void 0, function* () {
+                const payload = Object.assign(Object.assign({}, (yield this.getBaseCustomEventRequest(customData))), { eventType,
+                    eventValue });
+                return this.coveoAnalyticsClient.sendCustomEvent(payload);
+            }),
+        };
+    }
+    logCustomEventWithType(eventValue, eventType, metadata) {
+        return this.makeCustomEventWithType(eventValue, eventType, metadata).log();
+    }
+    logSearchEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.coveoAnalyticsClient.sendSearchEvent(yield this.getBaseSearchEventRequest(event, metadata));
+        });
+    }
+    makeDescription(actionCause, metadata) {
+        return { actionCause, customData: Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata) };
+    }
+    makeSearchEvent(event, metadata) {
+        return {
+            description: this.makeDescription(event, metadata),
+            log: () => this.logSearchEvent(event, metadata),
+        };
+    }
+    logClickEvent(event, info, identifier, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = Object.assign(Object.assign(Object.assign({}, info), (yield this.getBaseEventRequest(Object.assign(Object.assign({}, identifier), metadata)))), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event });
+            return this.coveoAnalyticsClient.sendClickEvent(payload);
+        });
+    }
+    makeClickEvent(event, info, identifier, metadata) {
+        return {
+            description: this.makeDescription(event, Object.assign(Object.assign({}, identifier), metadata)),
+            log: () => this.logClickEvent(event, info, identifier, metadata),
+        };
+    }
+    getBaseSearchEventRequest(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), this.provider.getSearchEventRequestPayload()), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event });
+        });
+    }
+    getBaseCustomEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), { lastSearchQueryUid: this.provider.getSearchUID() });
+        });
+    }
+    getBaseEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            return Object.assign(Object.assign(Object.assign({}, this.getOrigins()), this.getSplitTestRun()), { customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous(), clientId: yield this.getClientId() });
+        });
+    }
+    getOrigins() {
+        var _a, _b;
+        return {
+            originContext: (_b = (_a = this.provider).getOriginContext) === null || _b === void 0 ? void 0 : _b.call(_a),
+            originLevel1: this.provider.getOriginLevel1(),
+            originLevel2: this.provider.getOriginLevel2(),
+            originLevel3: this.provider.getOriginLevel3(),
+        };
+    }
+    getClientId() {
+        return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+            ? this.coveoAnalyticsClient.getCurrentVisitorId()
+            : undefined;
+    }
+    getSplitTestRun() {
+        const splitTestRunName = this.provider.getSplitTestRunName ? this.provider.getSplitTestRunName() : '';
+        const splitTestRunVersion = this.provider.getSplitTestRunVersion ? this.provider.getSplitTestRunVersion() : '';
+        return Object.assign(Object.assign({}, (splitTestRunName && { splitTestRunName })), (splitTestRunVersion && { splitTestRunVersion }));
+    }
+}
+
+const getFormattedLocation = (location) => `${location.protocol}//${location.hostname}${location.pathname.indexOf('/') === 0 ? location.pathname : `/${location.pathname}`}${location.search}`;
+
+const BasePluginEventTypes = {
+    pageview: 'pageview',
+    event: 'event',
+};
+class BasePlugin {
+    constructor({ client, uuidGenerator = uuidv4 }) {
+        this.actionData = {};
+        this.client = client;
+        this.uuidGenerator = uuidGenerator;
+        this.pageViewId = uuidGenerator();
+        this.nextPageViewId = this.pageViewId;
+        this.currentLocation = getFormattedLocation(window.location);
+        this.lastReferrer = document.referrer;
+        this.addHooks();
+    }
+    setAction(action, options) {
+        this.action = action;
+        this.actionData = options;
+    }
+    clearData() {
+        this.clearPluginData();
+        this.action = undefined;
+        this.actionData = {};
+    }
+    getLocationInformation(eventType, payload) {
+        return Object.assign({ hitType: eventType }, this.getNextValues(eventType, payload));
+    }
+    updateLocationInformation(eventType, payload) {
+        this.updateLocationForNextPageView(eventType, payload);
+    }
+    getDefaultContextInformation(eventType) {
+        const documentContext = {
+            title: document.title,
+            encoding: document.characterSet,
+        };
+        const screenContext = {
+            screenResolution: `${screen.width}x${screen.height}`,
+            screenColor: `${screen.colorDepth}-bit`,
+        };
+        const navigatorContext = {
+            language: navigator.language,
+            userAgent: navigator.userAgent,
+        };
+        const eventContext = {
+            time: Date.now().toString(),
+            eventId: this.uuidGenerator(),
+        };
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, eventContext), screenContext), navigatorContext), documentContext);
+    }
+    updateLocationForNextPageView(eventType, payload) {
+        const { pageViewId, referrer, location } = this.getNextValues(eventType, payload);
+        this.lastReferrer = referrer;
+        this.pageViewId = pageViewId;
+        this.currentLocation = location;
+        if (eventType === BasePluginEventTypes.pageview) {
+            this.nextPageViewId = this.uuidGenerator();
+            this.hasSentFirstPageView = true;
+        }
+    }
+    getNextValues(eventType, payload) {
+        return {
+            pageViewId: eventType === BasePluginEventTypes.pageview ? this.nextPageViewId : this.pageViewId,
+            referrer: eventType === BasePluginEventTypes.pageview && this.hasSentFirstPageView
+                ? this.currentLocation
+                : this.lastReferrer,
+            location: eventType === BasePluginEventTypes.pageview
+                ? this.getCurrentLocationFromPayload(payload)
+                : this.currentLocation,
+        };
+    }
+    getCurrentLocationFromPayload(payload) {
+        if (!!payload.page) {
+            const removeStartingSlash = (page) => page.replace(/^\/?(.*)$/, '/$1');
+            const extractHostnamePart = (location) => location.split('/').slice(0, 3).join('/');
+            return `${extractHostnamePart(this.currentLocation)}${removeStartingSlash(payload.page)}`;
+        }
+        else {
+            return getFormattedLocation(window.location);
+        }
+    }
+}
+
+const SVCPluginEventTypes = Object.assign({}, BasePluginEventTypes);
+const allSVCEventTypes = Object.keys(SVCPluginEventTypes).map((key) => SVCPluginEventTypes[key]);
+class SVCPlugin extends BasePlugin {
+    constructor({ client, uuidGenerator = uuidv4 }) {
+        super({ client, uuidGenerator });
+        this.ticket = {};
+    }
+    addHooks() {
+        this.addHooksForEvent();
+        this.addHooksForPageView();
+        this.addHooksForSVCEvents();
+    }
+    setTicket(ticket) {
+        this.ticket = ticket;
+    }
+    clearPluginData() {
+        this.ticket = {};
+    }
+    addHooksForSVCEvents() {
+        this.client.registerBeforeSendEventHook((eventType, ...[payload]) => {
+            return allSVCEventTypes.indexOf(eventType) !== -1 ? this.addSVCDataToPayload(eventType, payload) : payload;
+        });
+        this.client.registerAfterSendEventHook((eventType, ...[payload]) => {
+            if (allSVCEventTypes.indexOf(eventType) !== -1) {
+                this.updateLocationInformation(eventType, payload);
+            }
+            return payload;
+        });
+    }
+    addHooksForPageView() {
+        this.client.addEventTypeMapping(SVCPluginEventTypes.pageview, {
+            newEventType: EventType.collect,
+            variableLengthArgumentsNames: ['page'],
+            addVisitorIdParameter: true,
+            usesMeasurementProtocol: true,
+        });
+    }
+    addHooksForEvent() {
+        this.client.addEventTypeMapping(SVCPluginEventTypes.event, {
+            newEventType: EventType.collect,
+            variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
+            addVisitorIdParameter: true,
+            usesMeasurementProtocol: true,
+        });
+    }
+    addSVCDataToPayload(eventType, payload) {
+        var _a;
+        const svcPayload = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getLocationInformation(eventType, payload)), this.getDefaultContextInformation(eventType)), (this.action ? { svcAction: this.action } : {})), (Object.keys((_a = this.actionData) !== null && _a !== void 0 ? _a : {}).length > 0 ? { svcActionData: this.actionData } : {}));
+        const ticketPayload = this.getTicketPayload();
+        this.clearData();
+        return Object.assign(Object.assign(Object.assign({}, ticketPayload), svcPayload), payload);
+    }
+    getTicketPayload() {
+        return convertTicketToMeasurementProtocol(this.ticket);
+    }
+}
+SVCPlugin.Id = 'svc';
+
+var CaseAssistEvents;
+(function (CaseAssistEvents) {
+    CaseAssistEvents["click"] = "click";
+    CaseAssistEvents["flowStart"] = "flowStart";
+})(CaseAssistEvents || (CaseAssistEvents = {}));
+var CaseAssistActions;
+(function (CaseAssistActions) {
+    CaseAssistActions["enterInterface"] = "ticket_create_start";
+    CaseAssistActions["fieldUpdate"] = "ticket_field_update";
+    CaseAssistActions["fieldSuggestionClick"] = "ticket_classification_click";
+    CaseAssistActions["suggestionClick"] = "suggestion_click";
+    CaseAssistActions["suggestionRate"] = "suggestion_rate";
+    CaseAssistActions["nextCaseStep"] = "ticket_next_stage";
+    CaseAssistActions["caseCancelled"] = "ticket_cancel";
+    CaseAssistActions["caseSolved"] = "ticket_cancel";
+    CaseAssistActions["caseCreated"] = "ticket_create";
+})(CaseAssistActions || (CaseAssistActions = {}));
+var CaseCancelledReasons;
+(function (CaseCancelledReasons) {
+    CaseCancelledReasons["quit"] = "Quit";
+    CaseCancelledReasons["solved"] = "Solved";
+})(CaseCancelledReasons || (CaseCancelledReasons = {}));
+
+class CaseAssistClient {
+    constructor(options, provider) {
+        var _a;
+        this.options = options;
+        this.provider = provider;
+        const analyticsEnabled = ((_a = options.enableAnalytics) !== null && _a !== void 0 ? _a : true) && !doNotTrack();
+        this.coveoAnalyticsClient = analyticsEnabled ? new CoveoAnalyticsClient(options) : new NoopAnalytics();
+        this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+    }
+    disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+        this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+    }
+    enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.options);
+        this.svc = new SVCPlugin({ client: this.coveoAnalyticsClient });
+    }
+    logEnterInterface(meta) {
+        this.svc.setAction(CaseAssistActions.enterInterface);
+        this.svc.setTicket(meta.ticket);
+        return this.sendFlowStartEvent();
+    }
+    logUpdateCaseField(meta) {
+        this.svc.setAction(CaseAssistActions.fieldUpdate, {
+            fieldName: meta.fieldName,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logSelectFieldSuggestion(meta) {
+        this.svc.setAction(CaseAssistActions.fieldSuggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logSelectDocumentSuggestion(meta) {
+        this.svc.setAction(CaseAssistActions.suggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logRateDocumentSuggestion(meta) {
+        this.svc.setAction(CaseAssistActions.suggestionRate, Object.assign({ rate: meta.rating }, meta.suggestion));
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logMoveToNextCaseStep(meta) {
+        this.svc.setAction(CaseAssistActions.nextCaseStep, {
+            stage: meta === null || meta === void 0 ? void 0 : meta.stage,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logCaseCancelled(meta) {
+        this.svc.setAction(CaseAssistActions.caseCancelled, {
+            reason: CaseCancelledReasons.quit,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logCaseSolved(meta) {
+        this.svc.setAction(CaseAssistActions.caseSolved, {
+            reason: CaseCancelledReasons.solved,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    logCaseCreated(meta) {
+        this.svc.setAction(CaseAssistActions.caseCreated);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+    sendFlowStartEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.flowStart, this.provider
+            ? {
+                searchHub: this.provider.getOriginLevel1(),
+            }
+            : null);
+    }
+    sendClickEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.click, this.provider
+            ? {
+                searchHub: this.provider.getOriginLevel1(),
+            }
+            : null);
+    }
+}
+
+const extractContextFromMetadata = (meta) => {
+    const context = {};
+    if (meta.caseContext) {
+        Object.keys(meta.caseContext).forEach((contextKey) => {
+            var _a;
+            const value = (_a = meta.caseContext) === null || _a === void 0 ? void 0 : _a[contextKey];
+            if (value) {
+                const keyToBeSent = `context_${contextKey}`;
+                context[keyToBeSent] = value;
+            }
+        });
+    }
+    return context;
+};
+const generateMetadataToSend = (metadata, includeContext = true) => {
+    const { caseContext, caseId, caseNumber } = metadata, metadataWithoutContext = __rest(metadata, ["caseContext", "caseId", "caseNumber"]);
+    const context = extractContextFromMetadata(metadata);
+    return Object.assign(Object.assign(Object.assign({ CaseId: caseId, CaseNumber: caseNumber }, metadataWithoutContext), (!!context.context_Case_Subject && { CaseSubject: context.context_Case_Subject })), (includeContext && context));
+};
+class CoveoInsightClient {
+    constructor(opts, provider) {
+        this.opts = opts;
+        this.provider = provider;
+        const shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+    }
+    disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+    }
+    enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+    }
+    logInterfaceLoad(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.interfaceLoad, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.interfaceLoad);
+    }
+    logInterfaceChange(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.interfaceChange, metadataToSend);
+    }
+    logStaticFilterDeselect(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.staticFilterDeselect, metadataToSend);
+    }
+    logFetchMoreResults(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logCustomEvent(SearchPageEvents.pagerScrolling, Object.assign(Object.assign({}, metadataToSend), { type: 'getMoreResults' }));
+        }
+        return this.logCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+    }
+    logBreadcrumbFacet(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.breadcrumbFacet, metadataToSend);
+    }
+    logBreadcrumbResetAll(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll);
+    }
+    logFacetSelect(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetSelect, metadataToSend);
+    }
+    logFacetDeselect(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetDeselect, metadataToSend);
+    }
+    logFacetUpdateSort(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetUpdateSort, metadataToSend);
+    }
+    logFacetClearAll(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetClearAll, metadataToSend);
+    }
+    logFacetShowMore(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.facetShowMore, metadataToSend);
+    }
+    logFacetShowLess(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.facetShowLess, metadataToSend);
+    }
+    logQueryError(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.queryError, metadataToSend);
+    }
+    logPagerNumber(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerNumber, metadataToSend);
+    }
+    logPagerNext(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerNext, metadataToSend);
+    }
+    logPagerPrevious(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerPrevious, metadataToSend);
+    }
+    logDidYouMeanAutomatic(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic);
+    }
+    logDidYouMeanClick(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.didyoumeanClick, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.didyoumeanClick);
+    }
+    logResultsSort(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.resultsSort, metadataToSend);
+    }
+    logSearchboxSubmit(metadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.searchboxSubmit, metadataToSend);
+        }
+        return this.logSearchEvent(SearchPageEvents.searchboxSubmit);
+    }
+    logContextChanged(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(InsightEvents.contextChanged, metadataToSend);
+    }
+    logExpandToFullUI(metadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logCustomEvent(InsightEvents.expandToFullUI, metadataToSend);
+    }
+    logDocumentOpen(info, identifier, metadata) {
+        return this.logClickEvent(SearchPageEvents.documentOpen, info, identifier, metadata ? generateMetadataToSend(metadata, false) : undefined);
+    }
+    logCustomEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            const payload = Object.assign(Object.assign({}, (yield this.getBaseCustomEventRequest(customData))), { eventType: CustomEventsTypes[event], eventValue: event });
+            return this.coveoAnalyticsClient.sendCustomEvent(payload);
+        });
+    }
+    logSearchEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.coveoAnalyticsClient.sendSearchEvent(yield this.getBaseSearchEventRequest(event, metadata));
+        });
+    }
+    logClickEvent(event, info, identifier, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = Object.assign(Object.assign(Object.assign({}, info), (yield this.getBaseEventRequest(Object.assign(Object.assign({}, identifier), metadata)))), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event });
+            return this.coveoAnalyticsClient.sendClickEvent(payload);
+        });
+    }
+    getBaseCustomEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), { lastSearchQueryUid: this.provider.getSearchUID() });
+        });
+    }
+    getBaseSearchEventRequest(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), this.provider.getSearchEventRequestPayload()), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event });
+        });
+    }
+    getBaseEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            return Object.assign(Object.assign({}, this.getOrigins()), { customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous(), clientId: yield this.getClientId() });
+        });
+    }
+    getOrigins() {
+        var _a, _b;
+        return {
+            originContext: (_b = (_a = this.provider).getOriginContext) === null || _b === void 0 ? void 0 : _b.call(_a),
+            originLevel1: this.provider.getOriginLevel1(),
+            originLevel2: this.provider.getOriginLevel2(),
+            originLevel3: this.provider.getOriginLevel3(),
+        };
+    }
+    getClientId() {
+        return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+            ? this.coveoAnalyticsClient.getCurrentVisitorId()
+            : undefined;
+    }
 }
 
-export { ReactNativeRuntime, ReactNativeStorage };
+export { CaseAssistClient, CoveoAnalyticsClient, CoveoInsightClient, CoveoSearchPageClient, ReactNativeRuntime, history };