coveo.analytics 2.30.56 → 2.32.0

package/src/client/measurementProtocolMapping/commerceMeasurementProtocolMapper.ts

@@ -3,170 +3,182 @@ import {keysOf} from '../utils';
 
 // Based off: https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#enhanced-ecomm
 const productKeysMapping: {[key in keyof Product]: string} = {
-    id: 'id',
-    name: 'nm',
-    brand: 'br',
-    category: 'ca',
-    variant: 'va',
-    price: 'pr',
-    quantity: 'qt',
-    coupon: 'cc',
-    position: 'ps',
-    // Below are keys that were extended for Coveo
-    group: 'group',
+  id: 'id',
+  name: 'nm',
+  brand: 'br',
+  category: 'ca',
+  variant: 'va',
+  price: 'pr',
+  quantity: 'qt',
+  coupon: 'cc',
+  position: 'ps',
+  // Below are keys that were extended for Coveo
+  group: 'group',
 };
 
 const impressionKeysMapping: {[key in keyof BaseImpression]: string} = {
-    id: 'id',
-    name: 'nm',
-    brand: 'br',
-    category: 'ca',
-    variant: 'va',
-    position: 'ps',
-    price: 'pr',
-    // Below are keys that were extended for Coveo
-    group: 'group',
+  id: 'id',
+  name: 'nm',
+  brand: 'br',
+  category: 'ca',
+  variant: 'va',
+  position: 'ps',
+  price: 'pr',
+  // Below are keys that were extended for Coveo
+  group: 'group',
 };
 
 const productActionsKeysMapping: {[name: string]: string} = {
-    action: 'pa',
-    list: 'pal',
-    listSource: 'pls',
+  action: 'pa',
+  list: 'pal',
+  listSource: 'pls',
 };
 
 const transactionActionsKeysMapping: {[name: string]: string} = {
-    id: 'ti',
-    revenue: 'tr',
-    tax: 'tt',
-    shipping: 'ts',
-    coupon: 'tcc',
-    affiliation: 'ta',
-    step: 'cos',
-    option: 'col',
+  id: 'ti',
+  revenue: 'tr',
+  tax: 'tt',
+  shipping: 'ts',
+  coupon: 'tcc',
+  affiliation: 'ta',
+  step: 'cos',
+  option: 'col',
 };
 
 // These extension keys do not have direct mappings, we are sending them as-is, thus only requiring an array.
 const coveoCommerceExtensionKeys: string[] = [
-    'loyaltyCardId',
-    'loyaltyTier',
-    'thirdPartyPersona',
-    'companyName',
-    'favoriteStore',
-    'storeName',
-    'userIndustry',
-    'userRole',
-    'userDepartment',
-    'businessUnit',
+  'loyaltyCardId',
+  'loyaltyTier',
+  'thirdPartyPersona',
+  'companyName',
+  'favoriteStore',
+  'storeName',
+  'userIndustry',
+  'userRole',
+  'userDepartment',
+  'businessUnit',
 ];
 
 const quoteActionsKeysMapping: {[name: string]: string} = {
-    id: 'quoteId',
-    affiliation: 'quoteAffiliation',
+  id: 'quoteId',
+  affiliation: 'quoteAffiliation',
 };
 
 const reviewActionsKeysMapping: {[name: string]: string} = {
-    id: 'reviewId',
-    rating: 'reviewRating',
-    comment: 'reviewComment',
+  id: 'reviewId',
+  rating: 'reviewRating',
+  comment: 'reviewComment',
 };
 
 export const commerceActionKeysMappingPerAction: Record<string, {[name: string]: string}> = {
-    add: productActionsKeysMapping,
-    bookmark_add: productActionsKeysMapping,
-    bookmark_remove: productActionsKeysMapping,
-    click: productActionsKeysMapping,
-    checkout: productActionsKeysMapping,
-    checkout_option: productActionsKeysMapping,
-    detail: productActionsKeysMapping,
-    impression: productActionsKeysMapping,
-    remove: productActionsKeysMapping,
-    refund: {
-        ...productActionsKeysMapping,
-        ...transactionActionsKeysMapping,
-    },
-    purchase: {
-        ...productActionsKeysMapping,
-        ...transactionActionsKeysMapping,
-    },
-    quickview: productActionsKeysMapping,
-    quote: {
-        ...productActionsKeysMapping,
-        ...quoteActionsKeysMapping,
-    },
-    review: {
-        ...productActionsKeysMapping,
-        ...reviewActionsKeysMapping,
-    },
+  add: productActionsKeysMapping,
+  bookmark_add: productActionsKeysMapping,
+  bookmark_remove: productActionsKeysMapping,
+  click: productActionsKeysMapping,
+  checkout: productActionsKeysMapping,
+  checkout_option: productActionsKeysMapping,
+  detail: productActionsKeysMapping,
+  impression: productActionsKeysMapping,
+  remove: productActionsKeysMapping,
+  refund: {
+    ...productActionsKeysMapping,
+    ...transactionActionsKeysMapping,
+  },
+  purchase: {
+    ...productActionsKeysMapping,
+    ...transactionActionsKeysMapping,
+  },
+  quickview: productActionsKeysMapping,
+  quote: {
+    ...productActionsKeysMapping,
+    ...quoteActionsKeysMapping,
+  },
+  review: {
+    ...productActionsKeysMapping,
+    ...reviewActionsKeysMapping,
+  },
 };
 
 export const convertProductToMeasurementProtocol = (product: Product, index: number) => {
-    return keysOf(product).reduce((mappedProduct, key) => {
-        const newKey = `pr${index + 1}${productKeysMapping[key] || key}`;
-        return {
-            ...mappedProduct,
-            [newKey]: product[key],
-        };
-    }, {});
+  return keysOf(product).reduce((mappedProduct, key) => {
+    const newKey = `pr${index + 1}${productKeysMapping[key] || key}`;
+    return {
+      ...mappedProduct,
+      [newKey]: product[key],
+    };
+  }, {});
 };
 
 export const convertImpressionListToMeasurementProtocol = (
-    impressionList: ImpressionList,
-    listIndex: number,
-    prefix: string,
+  impressionList: ImpressionList,
+  listIndex: number,
+  prefix: string
 ) => {
-    const payload: {[name: string]: any} = impressionList.impressions.reduce(
-        (mappedImpressions, impression, productIndex) => {
-            return {
-                ...mappedImpressions,
-                ...convertImpressionToMeasurementProtocol(impression, listIndex, productIndex, prefix),
-            };
-        },
-        {},
-    );
-
-    if (impressionList.listName) {
-        const listNameKey = `il${listIndex + 1}nm`;
-        payload[listNameKey] = impressionList.listName;
-    }
-    return payload;
+  const payload: {[name: string]: any} = impressionList.impressions.reduce(
+    (mappedImpressions, impression, productIndex) => {
+      return {
+        ...mappedImpressions,
+        ...convertImpressionToMeasurementProtocol(impression, listIndex, productIndex, prefix),
+      };
+    },
+    {}
+  );
+
+  if (impressionList.listName) {
+    const listNameKey = `il${listIndex + 1}nm`;
+    payload[listNameKey] = impressionList.listName;
+  }
+  return payload;
 };
 
 const convertImpressionToMeasurementProtocol = (
-    impression: BaseImpression,
-    listIndex: number,
-    productIndex: number,
-    prefix: string,
+  impression: BaseImpression,
+  listIndex: number,
+  productIndex: number,
+  prefix: string
 ) => {
-    return keysOf(impression).reduce((mappedImpression, key) => {
-        const newKey = `il${listIndex + 1}${prefix}${productIndex + 1}${impressionKeysMapping[key] || key}`;
-        return {
-            ...mappedImpression,
-            [newKey]: impression[key],
-        };
-    }, {});
+  return keysOf(impression).reduce((mappedImpression, key) => {
+    const newKey = `il${listIndex + 1}${prefix}${productIndex + 1}${impressionKeysMapping[key] || key}`;
+    return {
+      ...mappedImpression,
+      [newKey]: impression[key],
+    };
+  }, {});
 };
 
 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 impressionKeysMappingValues = keysOf(impressionKeysMapping).map(
+  (key) => impressionKeysMapping[key]
+);
+const productActionsKeysMappingValues = keysOf(productActionsKeysMapping).map(
+  (key) => productActionsKeysMapping[key]
+);
 const transactionActionsKeysMappingValues = keysOf(transactionActionsKeysMapping).map(
-    (key) => transactionActionsKeysMapping[key],
+  (key) => transactionActionsKeysMapping[key]
+);
+const reviewKeysMappingValues = keysOf(reviewActionsKeysMapping).map(
+  (key) => reviewActionsKeysMapping[key]
+);
+const quoteKeysMappingValues = keysOf(quoteActionsKeysMapping).map(
+  (key) => quoteActionsKeysMapping[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 impressionKeyRegex = new RegExp(
+  `^(${impressionPrefixMatchGroup}(${impressionSubKeysMatchGroup}))|(il[0-9]+nm)$`
+);
 const productActionsKeyRegex = new RegExp(`^(${productActionsKeysMappingValues.join('|')})$`);
-const transactionActionsKeyRegex = new RegExp(`^(${transactionActionsKeysMappingValues.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('|')})$`,
+  `^(${[...coveoCommerceExtensionKeys, ...reviewKeysMappingValues, ...quoteKeysMappingValues].join('|')})$`
 );
 
 const isProductKey = (key: string) => productKeyRegex.test(key);
@@ -176,10 +188,10 @@ const isTransactionActionsKeyRegex = (key: string) => transactionActionsKeyRegex
 const isCoveoCommerceExtensionKey = (key: string) => coveoCommerceExtensionKeysRegex.test(key);
 
 export const isCommerceKey = [
-    isImpressionKey,
-    isProductKey,
-    isProductActionsKey,
-    isTransactionActionsKeyRegex,
-    isCoveoCommerceExtensionKey,
+  isImpressionKey,
+  isProductKey,
+  isProductActionsKey,
+  isTransactionActionsKeyRegex,
+  isCoveoCommerceExtensionKey,
 ];
 export const isCustomCommerceKey = [customProductKeyRegex, customImpressionKeyRegex];

package/src/client/measurementProtocolMapping/serviceMeasurementProtocolMapper.ts

@@ -2,32 +2,32 @@ import {Ticket} from '../../plugins/svc';
 import {keysOf} from '../utils';
 
 const ticketKeysMapping: {[key in keyof Ticket]: string} = {
-    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',
+  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}$)`);
 
 export const serviceActionsKeysMapping: {[name: string]: string} = {
-    svcAction: 'svc_action',
-    svcActionData: 'svc_action_data',
+  svcAction: 'svc_action',
+  svcActionData: 'svc_action_data',
 };
 
 export const convertTicketToMeasurementProtocol = (ticket: Ticket) => {
-    return keysOf(ticket)
-        .filter((key) => ticket[key] !== undefined)
-        .reduce((mappedTicket, key) => {
-            const newKey = ticketKeysMapping[key] || key;
-            return {
-                ...mappedTicket,
-                [newKey]: ticket[key],
-            };
-        }, {});
+  return keysOf(ticket)
+    .filter((key) => ticket[key] !== undefined)
+    .reduce((mappedTicket, key) => {
+      const newKey = ticketKeysMapping[key] || key;
+      return {
+        ...mappedTicket,
+        [newKey]: ticket[key],
+      };
+    }, {});
 };
 
 const isTicketKey = (key: string) => ticketKeyRegex.test(key);

package/src/client/noopAnalytics.ts

@@ -1,76 +1,88 @@
 import {AnalyticsClient, PreparedEvent} from './analytics';
 import {
-    AnyEventResponse,
-    SearchEventResponse,
-    ClickEventResponse,
-    CustomEventResponse,
-    VisitResponse,
-    HealthResponse,
-    ViewEventResponse,
-    EventType,
-    PreparedSearchEventRequest,
-    SearchEventRequest,
-    ClickEventRequest,
-    CustomEventRequest,
-    PreparedClickEventRequest,
-    PreparedCustomEventRequest,
-    PreparedViewEventRequest,
-    ViewEventRequest,
+  AnyEventResponse,
+  SearchEventResponse,
+  ClickEventResponse,
+  CustomEventResponse,
+  VisitResponse,
+  HealthResponse,
+  ViewEventResponse,
+  EventType,
+  PreparedSearchEventRequest,
+  SearchEventRequest,
+  ClickEventRequest,
+  CustomEventRequest,
+  PreparedClickEventRequest,
+  PreparedCustomEventRequest,
+  PreparedViewEventRequest,
+  ViewEventRequest,
 } from '../events';
 import {libVersion} from '../version';
 import {NoopRuntime} from './runtimeEnvironment';
 
 export class NoopAnalytics implements AnalyticsClient {
-    getPayload(): Promise<any> {
-        return Promise.resolve();
-    }
-    getParameters(): Promise<any> {
-        return Promise.resolve();
-    }
-    makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
-        eventType: EventType | string,
-    ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>> {
-        return Promise.resolve({eventType: eventType as EventType, payload: null, log: () => Promise.resolve()});
-    }
-    sendEvent(): Promise<AnyEventResponse | void> {
-        return Promise.resolve();
-    }
-    makeSearchEvent() {
-        return this.makeEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>(EventType.search);
-    }
-    sendSearchEvent(): Promise<SearchEventResponse | void> {
-        return Promise.resolve();
-    }
-    makeClickEvent() {
-        return this.makeEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>(EventType.click);
-    }
-    sendClickEvent(): Promise<ClickEventResponse | void> {
-        return Promise.resolve();
-    }
-    makeCustomEvent() {
-        return this.makeEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>(EventType.custom);
-    }
-    sendCustomEvent(): Promise<CustomEventResponse | void> {
-        return Promise.resolve();
-    }
-    makeViewEvent() {
-        return this.makeEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>(EventType.view);
-    }
-    sendViewEvent(): Promise<ViewEventResponse | void> {
-        return Promise.resolve();
-    }
-    getVisit(): Promise<VisitResponse> {
-        return Promise.resolve({id: '', visitorId: ''});
-    }
-    getHealth(): Promise<HealthResponse> {
-        return Promise.resolve({status: ''});
-    }
-    registerBeforeSendEventHook(): void {}
-    registerAfterSendEventHook(): void {}
-    addEventTypeMapping(): void {}
-    runtime = new NoopRuntime();
-    public get version(): string {
-        return libVersion;
-    }
-    currentVisitorId = '';
+  getPayload(): Promise<any> {
+    return Promise.resolve();
+  }
+  getParameters(): Promise<any> {
+    return Promise.resolve();
+  }
+  makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
+    eventType: EventType | string
+  ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>> {
+    return Promise.resolve({
+      eventType: eventType as EventType,
+      payload: null,
+      log: () => Promise.resolve(),
+    });
+  }
+  sendEvent(): Promise<AnyEventResponse | void> {
+    return Promise.resolve();
+  }
+  makeSearchEvent() {
+    return this.makeEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>(
+      EventType.search
+    );
+  }
+  sendSearchEvent(): Promise<SearchEventResponse | void> {
+    return Promise.resolve();
+  }
+  makeClickEvent() {
+    return this.makeEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>(
+      EventType.click
+    );
+  }
+  sendClickEvent(): Promise<ClickEventResponse | void> {
+    return Promise.resolve();
+  }
+  makeCustomEvent() {
+    return this.makeEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>(
+      EventType.custom
+    );
+  }
+  sendCustomEvent(): Promise<CustomEventResponse | void> {
+    return Promise.resolve();
+  }
+  makeViewEvent() {
+    return this.makeEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>(
+      EventType.view
+    );
+  }
+  sendViewEvent(): Promise<ViewEventResponse | void> {
+    return Promise.resolve();
+  }
+  getVisit(): Promise<VisitResponse> {
+    return Promise.resolve({id: '', visitorId: ''});
+  }
+  getHealth(): Promise<HealthResponse> {
+    return Promise.resolve({status: ''});
+  }
+  registerBeforeSendEventHook(): void {}
+  registerAfterSendEventHook(): void {}
+  addEventTypeMapping(): void {}
+  runtime = new NoopRuntime();
+  public get version(): string {
+    return libVersion;
+  }
+  currentVisitorId = '';
 }

package/src/client/runtimeEnvironment.ts

@@ -1,65 +1,74 @@
 import {WebStorage, NullStorage, CookieAndLocalStorage} from '../storage';
 import {AnalyticsBeaconClient} from './analyticsBeaconClient';
 import {hasLocalStorage, hasCookieStorage} from '../detector';
-import {AnalyticsRequestClient, IAnalyticsClientOptions, NoopAnalyticsClient} from './analyticsRequestClient';
+import {
+  AnalyticsRequestClient,
+  IAnalyticsClientOptions,
+  NoopAnalyticsClient,
+} from './analyticsRequestClient';
 import {AnalyticsFetchClient} from './analyticsFetchClient';
 import {BufferedRequest} from './analytics';
 import {EventType} from '../events';
 
 export interface IRuntimeEnvironment {
-    storage: WebStorage;
-    client: AnalyticsRequestClient;
-    getClientDependingOnEventType(eventType: EventType): AnalyticsRequestClient;
+  storage: WebStorage;
+  client: AnalyticsRequestClient;
+  getClientDependingOnEventType(eventType: EventType): AnalyticsRequestClient;
 }
 
 export class BrowserRuntime implements IRuntimeEnvironment {
-    public storage: WebStorage;
-    public client: AnalyticsFetchClient;
-    private beaconClient: AnalyticsBeaconClient;
+  public storage: WebStorage;
+  public client: AnalyticsFetchClient;
+  private beaconClient: AnalyticsBeaconClient;
 
-    constructor(clientOptions: IAnalyticsClientOptions, getUnprocessedRequests: () => Array<BufferedRequest>) {
-        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);
-            }
-        });
+  constructor(
+    clientOptions: IAnalyticsClientOptions,
+    getUnprocessedRequests: () => Array<BufferedRequest>
+  ) {
+    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);
+      }
+    });
+  }
 
-    public getClientDependingOnEventType(eventType: EventType) {
-        return eventType === 'click' && this.beaconClient.isAvailable() ? this.beaconClient : this.client;
-    }
+  public getClientDependingOnEventType(eventType: EventType) {
+    return eventType === 'click' && this.beaconClient.isAvailable()
+      ? this.beaconClient
+      : this.client;
+  }
 }
 
 export class NodeJSRuntime implements IRuntimeEnvironment {
-    public storage: WebStorage;
-    public client: AnalyticsFetchClient;
+  public storage: WebStorage;
+  public client: AnalyticsFetchClient;
 
-    constructor(clientOptions: IAnalyticsClientOptions, storage?: WebStorage) {
-        this.storage = storage || new NullStorage();
-        this.client = new AnalyticsFetchClient(clientOptions);
-    }
+  constructor(clientOptions: IAnalyticsClientOptions, storage?: WebStorage) {
+    this.storage = storage || new NullStorage();
+    this.client = new AnalyticsFetchClient(clientOptions);
+  }
 
-    getClientDependingOnEventType(eventType: EventType): AnalyticsRequestClient {
-        return this.client;
-    }
+  getClientDependingOnEventType(eventType: EventType): AnalyticsRequestClient {
+    return this.client;
+  }
 }
 
 export class NoopRuntime implements IRuntimeEnvironment {
-    public storage = new NullStorage();
-    public client = new NoopAnalyticsClient();
+  public storage = new NullStorage();
+  public client = new NoopAnalyticsClient();
 
-    getClientDependingOnEventType(eventType: EventType): AnalyticsRequestClient {
-        return this.client;
-    }
+  getClientDependingOnEventType(eventType: EventType): AnalyticsRequestClient {
+    return this.client;
+  }
 }