coveo.analytics 2.30.56 → 2.32.0

package/src/client/analyticsFetchClient.ts

@@ -1,78 +1,94 @@
-import {AnalyticsRequestClient, IAnalyticsRequestOptions, IAnalyticsClientOptions} from './analyticsRequestClient';
+import {
+  AnalyticsRequestClient,
+  IAnalyticsRequestOptions,
+  IAnalyticsClientOptions,
+} from './analyticsRequestClient';
 import {AnyEventResponse, EventType, IRequestPayload} from '../events';
 import {fetch} from 'cross-fetch';
 
 export class AnalyticsFetchClient implements AnalyticsRequestClient {
-    constructor(private opts: IAnalyticsClientOptions) {}
+  constructor(private opts: IAnalyticsClientOptions) {}
 
-    public async sendEvent(eventType: EventType, payload: IRequestPayload): Promise<AnyEventResponse | void> {
-        const {baseUrl, visitorIdProvider, preprocessRequest} = this.opts;
+  public async sendEvent(
+    eventType: EventType,
+    payload: IRequestPayload
+  ): Promise<AnyEventResponse | void> {
+    const {baseUrl, visitorIdProvider, preprocessRequest} = this.opts;
 
-        const visitorIdParam = this.shouldAppendVisitorId(eventType) ? await this.getVisitorIdParam() : '';
-        const defaultOptions: IAnalyticsRequestOptions = {
-            url: `${baseUrl}/analytics/${eventType}${visitorIdParam}`,
-            credentials: 'include',
-            mode: 'cors',
-            headers: this.getHeaders(),
-            method: 'POST',
-            body: JSON.stringify(payload),
-        };
-        const {url, ...fetchData}: IAnalyticsRequestOptions = {
-            ...defaultOptions,
-            ...(preprocessRequest ? await preprocessRequest(defaultOptions, 'analyticsFetch') : {}),
-        };
+    const visitorIdParam = this.shouldAppendVisitorId(eventType)
+      ? await this.getVisitorIdParam()
+      : '';
+    const defaultOptions: IAnalyticsRequestOptions = {
+      url: `${baseUrl}/analytics/${eventType}${visitorIdParam}`,
+      credentials: 'include',
+      mode: 'cors',
+      headers: this.getHeaders(),
+      method: 'POST',
+      body: JSON.stringify(payload),
+    };
+    const {url, ...fetchData}: IAnalyticsRequestOptions = {
+      ...defaultOptions,
+      ...(preprocessRequest ? await preprocessRequest(defaultOptions, 'analyticsFetch') : {}),
+    };
 
-        let response: Response;
+    let response: Response;
 
-        try {
-            response = await fetch(url, fetchData);
-        } catch (error) {
-            console.error('An error has occured when sending the event.', error);
-            return;
-        }
+    try {
+      response = await fetch(url, fetchData);
+    } catch (error) {
+      console.error('An error has occurred when sending the event.', error);
+      return;
+    }
 
-        if (response.ok) {
-            const visit = (await response.json()) as AnyEventResponse;
+    if (response.ok) {
+      const visit = (await response.json()) as AnyEventResponse;
 
-            if (visit.visitorId) {
-                visitorIdProvider.setCurrentVisitorId(visit.visitorId);
-            }
+      if (visit.visitorId) {
+        visitorIdProvider.setCurrentVisitorId(visit.visitorId);
+      }
 
-            return visit;
-        } else {
-            try {
-                response.json();
-            } catch {
-                /* If you don't parse the response, it won't appear in the network tab. */
-            }
-            console.error(`An error has occured when sending the "${eventType}" event.`, response, payload);
-            throw new Error(
-                `An error has occurred when sending the "${eventType}" event. Check the console logs for more details.`,
-            );
-        }
+      return visit;
+    } else {
+      try {
+        response.json();
+      } catch {
+        /* If you don't parse the response, it won't appear in the network tab. */
+      }
+      console.error(
+        `An error has occurred when sending the "${eventType}" event.`,
+        response,
+        payload
+      );
+      throw new Error(
+        `An error has occurred when sending the "${eventType}" event. Check the console logs for more details.`
+      );
     }
+  }
 
-    public async deleteHttpCookieVisitorId() {
-        const {baseUrl} = this.opts;
-        const url = `${baseUrl}/analytics/visit`;
-        await fetch(url, {headers: this.getHeaders(), method: 'DELETE'});
-    }
+  public async deleteHttpCookieVisitorId() {
+    const {baseUrl} = this.opts;
+    const url = `${baseUrl}/analytics/visit`;
+    await fetch(url, {headers: this.getHeaders(), method: 'DELETE'});
+  }
 
-    private shouldAppendVisitorId(eventType: EventType) {
-        return [EventType.click, EventType.custom, EventType.search, EventType.view].indexOf(eventType) !== -1;
-    }
+  private shouldAppendVisitorId(eventType: EventType) {
+    return (
+      [EventType.click, EventType.custom, EventType.search, EventType.view].indexOf(eventType) !==
+      -1
+    );
+  }
 
-    private async getVisitorIdParam() {
-        const {visitorIdProvider} = this.opts;
-        const visitorId = await visitorIdProvider.getCurrentVisitorId();
-        return visitorId ? `?visitor=${visitorId}` : '';
-    }
+  private async getVisitorIdParam() {
+    const {visitorIdProvider} = this.opts;
+    const visitorId = await visitorIdProvider.getCurrentVisitorId();
+    return visitorId ? `?visitor=${visitorId}` : '';
+  }
 
-    private getHeaders(): Record<string, string> {
-        const {token} = this.opts;
-        return {
-            ...(token ? {Authorization: `Bearer ${token}`} : {}),
-            'Content-Type': `application/json`,
-        };
-    }
+  private getHeaders(): Record<string, string> {
+    const {token} = this.opts;
+    return {
+      ...(token ? {Authorization: `Bearer ${token}`} : {}),
+      'Content-Type': `application/json`,
+    };
+  }
 }

package/src/client/analyticsRequestClient.ts

@@ -1,39 +1,39 @@
 import {AnyEventResponse, EventType, IRequestPayload} from '../events';
 
 export interface VisitorIdProvider {
-    getCurrentVisitorId: () => Promise<string>;
-    setCurrentVisitorId: (visitorId: string) => void;
+  getCurrentVisitorId: () => Promise<string>;
+  setCurrentVisitorId: (visitorId: string) => void;
 }
 
 export interface AnalyticsRequestClient {
-    sendEvent(eventType: string, payload: IRequestPayload): Promise<AnyEventResponse | void>;
-    deleteHttpCookieVisitorId: () => Promise<void>;
+  sendEvent(eventType: string, payload: IRequestPayload): Promise<AnyEventResponse | void>;
+  deleteHttpCookieVisitorId: () => Promise<void>;
 }
 
 export interface IAnalyticsClientOptions {
-    baseUrl: string;
-    token?: string;
-    visitorIdProvider: VisitorIdProvider;
-    preprocessRequest?: PreprocessAnalyticsRequest;
+  baseUrl: string;
+  token?: string;
+  visitorIdProvider: VisitorIdProvider;
+  preprocessRequest?: PreprocessAnalyticsRequest;
 }
 
 export type AnalyticsClientOrigin = 'analyticsFetch' | 'analyticsBeacon';
 
 export type PreprocessAnalyticsRequest = (
-    request: IAnalyticsRequestOptions,
-    clientOrigin: AnalyticsClientOrigin,
+  request: IAnalyticsRequestOptions,
+  clientOrigin: AnalyticsClientOrigin
 ) => IAnalyticsRequestOptions | Promise<IAnalyticsRequestOptions>;
 
 export interface IAnalyticsRequestOptions extends RequestInit {
-    url: string;
+  url: string;
 }
 
 export class NoopAnalyticsClient implements AnalyticsRequestClient {
-    public async sendEvent(_: EventType, __: IRequestPayload): Promise<void> {
-        return Promise.resolve();
-    }
+  public async sendEvent(_: EventType, __: IRequestPayload): Promise<void> {
+    return Promise.resolve();
+  }
 
-    public async deleteHttpCookieVisitorId() {
-        return Promise.resolve();
-    }
+  public async deleteHttpCookieVisitorId() {
+    return Promise.resolve();
+  }
 }

package/src/client/location.ts

@@ -1,4 +1,4 @@
 export const getFormattedLocation = (location: Location) =>
-    `${location.protocol}//${location.hostname}${
-        location.pathname.indexOf('/') === 0 ? location.pathname : `/${location.pathname}`
-    }${location.search}`;
+  `${location.protocol}//${location.hostname}${
+    location.pathname.indexOf('/') === 0 ? location.pathname : `/${location.pathname}`
+  }${location.search}`;

package/src/client/measurementProtocolMapper.ts

@@ -1,71 +1,80 @@
-import {isServiceKey, serviceActionsKeysMapping} from './measurementProtocolMapping/serviceMeasurementProtocolMapper';
 import {
-    commerceActionKeysMappingPerAction,
-    isCommerceKey,
-    isCustomCommerceKey,
+  isServiceKey,
+  serviceActionsKeysMapping,
+} from './measurementProtocolMapping/serviceMeasurementProtocolMapper';
+import {
+  commerceActionKeysMappingPerAction,
+  isCommerceKey,
+  isCustomCommerceKey,
 } from './measurementProtocolMapping/commerceMeasurementProtocolMapper';
 import {keysOf} from './utils';
 import {baseMeasurementProtocolKeysMapping} from './measurementProtocolMapping/baseMeasurementProtocolMapper';
 
 const measurementProtocolKeysMapping: {[name: string]: string} = {
-    ...baseMeasurementProtocolKeysMapping,
-    ...serviceActionsKeysMapping,
+  ...baseMeasurementProtocolKeysMapping,
+  ...serviceActionsKeysMapping,
 };
 
 export const convertKeysToMeasurementProtocol = (params: any) => {
-    const keysMappingForAction = (!!params.action && commerceActionKeysMappingPerAction[params.action]) || {};
-    return keysOf(params).reduce((mappedKeys, key) => {
-        const newKey = keysMappingForAction[key] || measurementProtocolKeysMapping[key] || key;
-        return {
-            ...mappedKeys,
-            [newKey]: params[key],
-        };
-    }, {});
+  const keysMappingForAction =
+    (!!params.action && commerceActionKeysMappingPerAction[params.action]) || {};
+  return keysOf(params).reduce((mappedKeys, key) => {
+    const newKey = keysMappingForAction[key] || measurementProtocolKeysMapping[key] || key;
+    return {
+      ...mappedKeys,
+      [newKey]: params[key],
+    };
+  }, {});
 };
 
 const measurementProtocolKeysMappingValues = keysOf(measurementProtocolKeysMapping).map(
-    (key) => measurementProtocolKeysMapping[key],
+  (key) => measurementProtocolKeysMapping[key]
 );
 
-const isKnownMeasurementProtocolKey = (key: string) => measurementProtocolKeysMappingValues.indexOf(key) !== -1;
+const isKnownMeasurementProtocolKey = (key: string) =>
+  measurementProtocolKeysMappingValues.indexOf(key) !== -1;
 const isCustomKey = (key: string) => key === 'custom';
 
 export const isMeasurementProtocolKey = (key: string): boolean => {
-    return [...isCommerceKey, ...isServiceKey, isKnownMeasurementProtocolKey, isCustomKey].some((test) => test(key));
+  return [...isCommerceKey, ...isServiceKey, isKnownMeasurementProtocolKey, isCustomKey].some(
+    (test) => test(key)
+  );
 };
 
-export const convertCustomMeasurementProtocolKeys = (data: {[name: string]: string | {[name: string]: string}}) => {
-    return keysOf(data).reduce((all, current) => {
-        const match = getFirstCustomMeasurementProtocolKeyMatch(current);
-        if (match) {
-            return {
-                ...all,
-                ...convertCustomObject(match, data[current] as {[name: string]: string}),
-            };
-        } else {
-            return {
-                ...all,
-                [current]: data[current],
-            };
-        }
-    }, {});
+export const convertCustomMeasurementProtocolKeys = (data: {
+  [name: string]: string | {[name: string]: string};
+}) => {
+  return keysOf(data).reduce((all, current) => {
+    const match = getFirstCustomMeasurementProtocolKeyMatch(current);
+    if (match) {
+      return {
+        ...all,
+        ...convertCustomObject(match, data[current] as {[name: string]: string}),
+      };
+    } else {
+      return {
+        ...all,
+        [current]: data[current],
+      };
+    }
+  }, {});
 };
 
 const getFirstCustomMeasurementProtocolKeyMatch = (key: string): string | undefined => {
-    let matchedKey: string | undefined = undefined;
-    [...isCustomCommerceKey].every((regex) => {
-        matchedKey = regex.exec(key)?.[1];
-        return !Boolean(matchedKey);
-    });
-    return matchedKey;
+  let matchedKey: string | undefined = undefined;
+  [...isCustomCommerceKey].every((regex) => {
+    matchedKey = regex.exec(key)?.[1];
+    return !matchedKey;
+  });
+  return matchedKey;
 };
 
 const convertCustomObject = (prefix: string, customData: {[name: string]: string}) => {
-    return keysOf(customData).reduce(
-        (allCustom, currentCustomKey) => ({
-            ...allCustom,
-            [`${prefix}${currentCustomKey}`]: customData[currentCustomKey],
-        }),
-        {},
-    );
+  return keysOf(customData).reduce(
+    (allCustom, currentCustomKey) => ({
+      ...allCustom,
+      [`${prefix}${currentCustomKey}`]: customData[currentCustomKey],
+    }),
+    {}
+  );
 };

package/src/client/measurementProtocolMapping/baseMeasurementProtocolMapper.ts

@@ -1,61 +1,65 @@
 import {BasePlugin} from '../../plugins/BasePlugin';
 
-type DefaultContextInformation = ReturnType<typeof BasePlugin.prototype.getDefaultContextInformation> &
-    ReturnType<typeof BasePlugin.prototype.getLocationInformation>;
+type DefaultContextInformation = ReturnType<
+  typeof BasePlugin.prototype.getDefaultContextInformation
+> &
+  ReturnType<typeof BasePlugin.prototype.getLocationInformation>;
 
 const globalParamKeysMapping: {[name: string]: string} = {
-    anonymizeIp: 'aip',
+  anonymizeIp: 'aip',
 };
 
 const eventKeysMapping: {[name: string]: string} = {
-    eventCategory: 'ec',
-    eventAction: 'ea',
-    eventLabel: 'el',
-    eventValue: 'ev',
-    page: 'dp',
-    visitorId: 'cid',
-    clientId: 'cid',
-    userId: 'uid',
-    currencyCode: 'cu',
+  eventCategory: 'ec',
+  eventAction: 'ea',
+  eventLabel: 'el',
+  eventValue: 'ev',
+  page: 'dp',
+  visitorId: 'cid',
+  clientId: 'cid',
+  userId: 'uid',
+  currencyCode: 'cu',
 };
 
-const contextInformationMapping: {[key in keyof DefaultContextInformation]: string} = {
-    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 contextInformationMapping: {
+  [key in keyof DefaultContextInformation]: string;
+} = {
+  hitType: 't',
+  pageViewId: 'pid',
+  encoding: 'de',
+  location: 'dl',
+  referrer: 'dr',
+  screenColor: 'sd',
+  screenResolution: 'sr',
+  title: 'dt',
+  userAgent: 'ua',
+  language: 'ul',
+  eventId: 'z',
+  time: 'tm',
 };
 
 /* Those are extension keys that are supported by the Coveo collect protocol (but not Google's protocol). They will be forwarded as-is. */
 const coveoExtensionsKeys = [
-    'contentId',
-    'contentIdKey',
-    'contentType',
-    'searchHub',
-    'tab',
-    'searchUid',
-    'permanentId',
-    'contentLocale',
-    'trackingId',
+  'contentId',
+  'contentIdKey',
+  'contentType',
+  'searchHub',
+  'tab',
+  'searchUid',
+  'permanentId',
+  'contentLocale',
+  'trackingId',
 ];
 
 export const baseMeasurementProtocolKeysMapping: {[name: string]: string} = {
-    ...globalParamKeysMapping,
-    ...eventKeysMapping,
-    ...contextInformationMapping,
-    ...coveoExtensionsKeys.reduce(
-        (all, key) => ({
-            ...all,
-            [key]: key,
-        }),
-        {},
-    ),
+  ...globalParamKeysMapping,
+  ...eventKeysMapping,
+  ...contextInformationMapping,
+  ...coveoExtensionsKeys.reduce(
+    (all, key) => ({
+      ...all,
+      [key]: key,
+    }),
+    {}
+  ),
 };