coveo.analytics 2.30.56 → 2.32.0

package/src/plugins/ec.ts

@@ -1,241 +1,244 @@
 import {EventType} from '../events';
 import {v4 as uuidv4} from 'uuid';
 import {
-    convertProductToMeasurementProtocol,
-    convertImpressionListToMeasurementProtocol,
+  convertProductToMeasurementProtocol,
+  convertImpressionListToMeasurementProtocol,
 } from '../client/measurementProtocolMapping/commerceMeasurementProtocolMapper';
 import {BasePlugin, BasePluginEventTypes, PluginClass, PluginOptions} from './BasePlugin';
 import {coerceToNumber} from '../client/utils';
 
 export const ECPluginEventTypes = {
-    ...BasePluginEventTypes,
+  ...BasePluginEventTypes,
 };
 
 const allECEventTypes = Object.keys(ECPluginEventTypes).map(
-    (key) => ECPluginEventTypes[key as keyof typeof ECPluginEventTypes],
+  (key) => ECPluginEventTypes[key as keyof typeof ECPluginEventTypes]
 );
 
 // From https://stackoverflow.com/a/49725198/497731
 type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
-    {
-        [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-    }[Keys];
+  {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+  }[Keys];
 
 export type CustomValues = {
-    [key: string]: string | number | boolean;
+  [key: string]: string | number | boolean;
 };
 
 export interface CoveoExtensionProperties {
-    group?: string;
+  group?: string;
 }
 
 export interface ProductProperties extends CoveoExtensionProperties {
-    id?: string;
-    name?: string;
-    brand?: string;
-    category?: string;
-    variant?: string;
-    price?: number;
-    quantity?: number;
-    coupon?: string;
-    position?: number;
-    custom?: CustomValues;
+  id?: string;
+  name?: string;
+  brand?: string;
+  category?: string;
+  variant?: string;
+  price?: number;
+  quantity?: number;
+  coupon?: string;
+  position?: number;
+  custom?: CustomValues;
 }
 
 export type Product = RequireAtLeastOne<ProductProperties, 'id' | 'name'>;
 
 export interface ImpressionProperties extends CoveoExtensionProperties {
-    id?: string;
-    name?: string;
-    list?: string;
-    brand?: string;
-    category?: string;
-    variant?: string;
-    position?: number;
-    price?: number;
-    custom?: CustomValues;
+  id?: string;
+  name?: string;
+  list?: string;
+  brand?: string;
+  category?: string;
+  variant?: string;
+  position?: number;
+  price?: number;
+  custom?: CustomValues;
 }
 
 export type Impression = RequireAtLeastOne<ImpressionProperties, 'id' | 'name'>;
 export type BaseImpression = Omit<Impression, 'list'>;
 export interface ImpressionList {
-    listName?: string;
-    impressions: BaseImpression[];
+  listName?: string;
+  impressions: BaseImpression[];
 }
 
 export class ECPlugin extends BasePlugin {
-    public static readonly Id = 'ec';
-    private products: Product[] = [];
-    private impressions: Impression[] = [];
-
-    constructor({client, uuidGenerator = uuidv4}: PluginOptions) {
-        super({client, uuidGenerator});
-    }
-
-    public getApi(name: string): Function | null {
-        const superCall: Function | null = super.getApi(name);
-        if (superCall !== null) return superCall;
-        switch (name) {
-            case 'addProduct':
-                return this.addProduct;
-            case 'addImpression':
-                return this.addImpression;
-            default:
-                return null;
-        }
-    }
-
-    protected addHooks(): void {
-        this.addHooksForPageView();
-        this.addHooksForEvent();
-        this.addHooksForECEvents();
-    }
-
-    addProduct(product: Product) {
-        this.products.push(product);
-    }
-
-    addImpression(impression: Impression) {
-        this.impressions.push(impression);
-    }
-
-    protected clearPluginData() {
-        this.products = [];
-        this.impressions = [];
-    }
-
-    private addHooksForECEvents() {
-        this.client.registerBeforeSendEventHook((eventType, ...[payload]) => {
-            return allECEventTypes.indexOf(eventType) !== -1 ? this.addECDataToPayload(eventType, payload) : payload;
-        });
-        this.client.registerAfterSendEventHook((eventType, ...[payload]) => {
-            if (allECEventTypes.indexOf(eventType) !== -1) {
-                this.updateLocationInformation(eventType, payload);
-            }
-            return payload;
-        });
-    }
-
-    private addHooksForPageView() {
-        this.client.addEventTypeMapping(ECPluginEventTypes.pageview, {
-            newEventType: EventType.collect,
-            variableLengthArgumentsNames: ['page'],
-            addVisitorIdParameter: true,
-            usesMeasurementProtocol: true,
-        });
-    }
-
-    private addHooksForEvent() {
-        this.client.addEventTypeMapping(ECPluginEventTypes.event, {
-            newEventType: EventType.collect,
-            variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
-            addVisitorIdParameter: true,
-            usesMeasurementProtocol: true,
-        });
-    }
-
-    private addECDataToPayload(eventType: string, payload: any) {
-        const ecPayload = {
-            ...this.getLocationInformation(eventType, payload),
-            ...this.getDefaultContextInformation(eventType),
-            ...(this.action ? {action: this.action} : {}),
-            ...(this.actionData || {}),
+  public static readonly Id = 'ec';
+  private products: Product[] = [];
+  private impressions: Impression[] = [];
+
+  constructor({client, uuidGenerator = uuidv4}: PluginOptions) {
+    super({client, uuidGenerator});
+  }
+
+  public getApi(name: string): Function | null {
+    const superCall: Function | null = super.getApi(name);
+    if (superCall !== null) return superCall;
+    switch (name) {
+      case 'addProduct':
+        return this.addProduct;
+      case 'addImpression':
+        return this.addImpression;
+      default:
+        return null;
+    }
+  }
+
+  protected addHooks(): void {
+    this.addHooksForPageView();
+    this.addHooksForEvent();
+    this.addHooksForECEvents();
+  }
+
+  addProduct(product: Product) {
+    this.products.push(product);
+  }
+
+  addImpression(impression: Impression) {
+    this.impressions.push(impression);
+  }
+
+  protected clearPluginData() {
+    this.products = [];
+    this.impressions = [];
+  }
+
+  private addHooksForECEvents() {
+    this.client.registerBeforeSendEventHook((eventType, ...[payload]) => {
+      return allECEventTypes.indexOf(eventType) !== -1
+        ? this.addECDataToPayload(eventType, payload)
+        : payload;
+    });
+    this.client.registerAfterSendEventHook((eventType, ...[payload]) => {
+      if (allECEventTypes.indexOf(eventType) !== -1) {
+        this.updateLocationInformation(eventType, payload);
+      }
+      return payload;
+    });
+  }
+
+  private addHooksForPageView() {
+    this.client.addEventTypeMapping(ECPluginEventTypes.pageview, {
+      newEventType: EventType.collect,
+      variableLengthArgumentsNames: ['page'],
+      addVisitorIdParameter: true,
+      usesMeasurementProtocol: true,
+    });
+  }
+
+  private addHooksForEvent() {
+    this.client.addEventTypeMapping(ECPluginEventTypes.event, {
+      newEventType: EventType.collect,
+      variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
+      addVisitorIdParameter: true,
+      usesMeasurementProtocol: true,
+    });
+  }
+
+  private addECDataToPayload(eventType: string, payload: any) {
+    const ecPayload = {
+      ...this.getLocationInformation(eventType, payload),
+      ...this.getDefaultContextInformation(eventType),
+      ...(this.action ? {action: this.action} : {}),
+      ...(this.actionData || {}),
+    };
+
+    const productPayload = this.getProductPayload();
+    const impressionPayload = this.getImpressionPayload();
+
+    this.clearData();
+
+    return {
+      ...impressionPayload,
+      ...productPayload,
+      ...ecPayload,
+      ...payload,
+    };
+  }
+
+  private getProductPayload() {
+    return this.products
+      .map((product) => this.assureProductValidity(product))
+      .reduce((newPayload, product, index) => {
+        return {
+          ...newPayload,
+          ...convertProductToMeasurementProtocol(this.convertNumberTypes(product), index),
         };
-
-        const productPayload = this.getProductPayload();
-        const impressionPayload = this.getImpressionPayload();
-
-        this.clearData();
-
+      }, {});
+  }
+
+  private convertNumberTypes(product: Product): Product {
+    let updatedProduct: Product = {...product};
+    if ('quantity' in updatedProduct) {
+      updatedProduct.quantity = coerceToNumber(updatedProduct.quantity);
+    }
+    if ('position' in updatedProduct) {
+      updatedProduct.position = coerceToNumber(updatedProduct.position);
+    }
+    return updatedProduct;
+  }
+
+  private getImpressionPayload() {
+    const impressionsByList = this.getImpressionsByList();
+    return impressionsByList
+      .map(
+        ({impressions, ...rest}) =>
+          ({
+            ...rest,
+            impressions: impressions.map((baseImpression) =>
+              this.assureBaseImpressionValidity(baseImpression)
+            ),
+          }) as ImpressionList
+      )
+      .reduce((newPayload, impressionList, index) => {
         return {
-            ...impressionPayload,
-            ...productPayload,
-            ...ecPayload,
-            ...payload,
+          ...newPayload,
+          ...convertImpressionListToMeasurementProtocol(impressionList, index, 'pi'),
         };
-    }
-
-    private getProductPayload() {
-        return this.products
-            .map((product) => this.assureProductValidity(product))
-            .reduce((newPayload, product, index) => {
-                return {
-                    ...newPayload,
-                    ...convertProductToMeasurementProtocol(this.convertNumberTypes(product), index),
-                };
-            }, {});
-    }
-
-    private convertNumberTypes(product: Product): Product {
-        let updatedProduct: Product = {...product};
-        if ('quantity' in updatedProduct) {
-            updatedProduct.quantity = coerceToNumber(updatedProduct.quantity);
-        }
-        if ('position' in updatedProduct) {
-            updatedProduct.position = coerceToNumber(updatedProduct.position);
-        }
-        return updatedProduct;
-    }
-
-    private getImpressionPayload() {
-        const impressionsByList = this.getImpressionsByList();
-        return impressionsByList
-            .map(
-                ({impressions, ...rest}) =>
-                    ({
-                        ...rest,
-                        impressions: impressions.map((baseImpression) =>
-                            this.assureBaseImpressionValidity(baseImpression),
-                        ),
-                    }) as ImpressionList,
-            )
-            .reduce((newPayload, impressionList, index) => {
-                return {
-                    ...newPayload,
-                    ...convertImpressionListToMeasurementProtocol(impressionList, index, 'pi'),
-                };
-            }, {});
-    }
-
-    private assureProductValidity(product: Product) {
-        const {position, ...productRest} = product;
-        if (position !== undefined && position < 1) {
-            console.warn(
-                `The position for product '${product.name || product.id}' must be greater ` + `than 0 when provided.`,
-            );
-
-            return productRest;
-        }
-
-        return product;
-    }
-
-    private assureBaseImpressionValidity(baseImpression: BaseImpression) {
-        const {position, ...baseImpressionRest} = baseImpression;
-        if (position !== undefined && position < 1) {
-            console.warn(
-                `The position for impression '${baseImpression.name || baseImpression.id}'` +
-                    ` must be greater than 0 when provided.`,
-            );
-
-            return baseImpressionRest;
-        }
-
-        return baseImpression;
-    }
-
-    private getImpressionsByList() {
-        return this.impressions.reduce((lists, impression) => {
-            const {list: listName, ...baseImpression} = impression;
-            const list = lists.find((list) => list.listName === listName);
-            if (list) {
-                list.impressions.push(baseImpression);
-            } else {
-                lists.push({listName: listName, impressions: [baseImpression]});
-            }
-            return lists;
-        }, [] as ImpressionList[]);
-    }
+      }, {});
+  }
+
+  private assureProductValidity(product: Product) {
+    const {position, ...productRest} = product;
+    if (position !== undefined && position < 1) {
+      console.warn(
+        `The position for product '${product.name || product.id}' must be greater ` +
+          `than 0 when provided.`
+      );
+
+      return productRest;
+    }
+
+    return product;
+  }
+
+  private assureBaseImpressionValidity(baseImpression: BaseImpression) {
+    const {position, ...baseImpressionRest} = baseImpression;
+    if (position !== undefined && position < 1) {
+      console.warn(
+        `The position for impression '${baseImpression.name || baseImpression.id}'` +
+          ` must be greater than 0 when provided.`
+      );
+
+      return baseImpressionRest;
+    }
+
+    return baseImpression;
+  }
+
+  private getImpressionsByList() {
+    return this.impressions.reduce((lists, impression) => {
+      const {list: listName, ...baseImpression} = impression;
+      const list = lists.find((list) => list.listName === listName);
+      if (list) {
+        list.impressions.push(baseImpression);
+      } else {
+        lists.push({listName: listName, impressions: [baseImpression]});
+      }
+      return lists;
+    }, [] as ImpressionList[]);
+  }
 }
 
 export const EC: PluginClass = ECPlugin;