coveo.analytics 2.30.55 → 2.31.0

package/src/plugins/svc.spec.ts

@@ -1,184 +1,190 @@
+import {vi} from 'vitest';
 import {SVCPlugin, SVCPluginEventTypes} from './svc';
 import {createAnalyticsClientMock} from '../../tests/analyticsClientMock';
 
 describe('SVC plugin', () => {
-    let svc: SVCPlugin;
-    let client: ReturnType<typeof createAnalyticsClientMock>;
-
-    const someUUIDGenerator = jest.fn(() => someUUID);
-    const someUUID = '13ccebdb-0138-45e8-bf70-884817ead190';
-    const defaultResult = {
-        pageViewId: someUUID,
-        encoding: document.characterSet,
-        location: 'http://localhost/',
-        referrer: 'http://somewhere.over/thereferrer',
-        title: 'MAH PAGE',
-        screenColor: '24-bit',
-        screenResolution: '0x0',
-        time: expect.any(Number),
-        userAgent: navigator.userAgent,
-        language: 'en-US',
-        hitType: SVCPluginEventTypes.event,
-        eventId: someUUID,
-    };
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        client = createAnalyticsClientMock();
-        svc = new SVCPlugin({client, uuidGenerator: someUUIDGenerator as any});
+  let svc: SVCPlugin;
+  let client: ReturnType<typeof createAnalyticsClientMock>;
+
+  const someUUIDGenerator = vi.fn(() => someUUID);
+  const someUUID = '13ccebdb-0138-45e8-bf70-884817ead190';
+  const defaultResult = {
+    pageViewId: someUUID,
+    encoding: document.characterSet,
+    location: 'http://localhost/',
+    referrer: 'http://somewhere.over/thereferrer',
+    title: 'MAH PAGE',
+    screenColor: '24-bit',
+    screenResolution: '0x0',
+    time: expect.any(Number),
+    userAgent: navigator.userAgent,
+    language: 'en-US',
+    hitType: SVCPluginEventTypes.event,
+    eventId: someUUID,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = createAnalyticsClientMock();
+    svc = new SVCPlugin({client, uuidGenerator: someUUIDGenerator as any});
+  });
+
+  it('should register a hook in the client', () => {
+    expect(client.registerBeforeSendEventHook).toHaveBeenCalledTimes(1);
+  });
+
+  it('should register a mapping for each SVC type', () => {
+    expect(client.addEventTypeMapping).toHaveBeenCalledTimes(
+      Object.keys(SVCPluginEventTypes).length
+    );
+  });
+
+  describe('tickets', () => {
+    it('should set the ticket with the specific format and convert known ticket keys into the measurement protocol format when the hook is called', () => {
+      svc.setTicket({
+        id: 'Some ID',
+        subject: 'Some Subject',
+        description: 'Some Description',
+        category: 'Some Category',
+        productId: 'Some Product ID',
+        custom: {someCustomProp: 'some custom prop value'},
+      });
+
+      const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
+
+      expect(result).toEqual({
+        ...defaultResult,
+        svc_ticket_id: 'Some ID',
+        svc_ticket_subject: 'Some Subject',
+        svc_ticket_description: 'Some Description',
+        svc_ticket_category: 'Some Category',
+        svc_ticket_product_id: 'Some Product ID',
+        svc_ticket_custom: {someCustomProp: 'some custom prop value'},
+      });
     });
 
-    it('should register a hook in the client', () => {
-        expect(client.registerBeforeSendEventHook).toHaveBeenCalledTimes(1);
-    });
+    it('should append the ticket with the pageview event', () => {
+      svc.setTicket({subject: 'Some Subject'});
 
-    it('should register a mapping for each SVC type', () => {
-        expect(client.addEventTypeMapping).toHaveBeenCalledTimes(Object.keys(SVCPluginEventTypes).length);
-    });
+      const result = executeRegisteredHook(SVCPluginEventTypes.pageview, {});
 
-    describe('tickets', () => {
-        it('should set the ticket with the specific format and convert known ticket keys into the measurement protocol format when the hook is called', () => {
-            svc.setTicket({
-                id: 'Some ID',
-                subject: 'Some Subject',
-                description: 'Some Description',
-                category: 'Some Category',
-                productId: 'Some Product ID',
-                custom: {someCustomProp: 'some custom prop value'},
-            });
-
-            const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
-
-            expect(result).toEqual({
-                ...defaultResult,
-                svc_ticket_id: 'Some ID',
-                svc_ticket_subject: 'Some Subject',
-                svc_ticket_description: 'Some Description',
-                svc_ticket_category: 'Some Category',
-                svc_ticket_product_id: 'Some Product ID',
-                svc_ticket_custom: {someCustomProp: 'some custom prop value'},
-            });
-        });
-
-        it('should append the ticket with the pageview event', () => {
-            svc.setTicket({subject: 'Some Subject'});
-
-            const result = executeRegisteredHook(SVCPluginEventTypes.pageview, {});
-
-            expect(result).toEqual({
-                ...defaultResult,
-                hitType: SVCPluginEventTypes.pageview,
-                svc_ticket_subject: 'Some Subject',
-            });
-        });
-
-        it('should not append the product with a random event type', () => {
-            svc.setTicket({subject: 'Some Subject'});
-
-            const result = executeRegisteredHook('🎲', {});
-
-            expect(result).toEqual({});
-        });
-
-        it('should keep the ticket until a valid event type is used', () => {
-            svc.setTicket({subject: 'Some Subject'});
-
-            executeRegisteredHook('🎲', {});
-            executeRegisteredHook('🐟', {});
-            executeRegisteredHook('💀', {});
-            const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
-
-            expect(result).toEqual({...defaultResult, svc_ticket_subject: 'Some Subject'});
-        });
-
-        it('should keep custom metadata in the ticket', () => {
-            svc.setTicket({subject: '🧀', custom: {verycustom: 'value'}});
-
-            const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
-
-            expect(result).toEqual({
-                ...defaultResult,
-                svc_ticket_subject: '🧀',
-                svc_ticket_custom: {verycustom: 'value'},
-            });
-        });
-
-        it('should flush the ticket once they are sent', () => {
-            svc.setTicket({subject: '🍟', description: 'description'});
-
-            const firstResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
-            const secondResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
-
-            expect(firstResult).not.toEqual({});
-            expect(secondResult).toEqual({...defaultResult});
-        });
+      expect(result).toEqual({
+        ...defaultResult,
+        hitType: SVCPluginEventTypes.pageview,
+        svc_ticket_subject: 'Some Subject',
+      });
     });
 
-    it('should be able to set an action', () => {
-        svc.setAction('ok');
+    it('should not append the product with a random event type', () => {
+      svc.setTicket({subject: 'Some Subject'});
 
-        const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
+      const result = executeRegisteredHook('🎲', {});
 
-        expect(result).toEqual({
-            ...defaultResult,
-            svcAction: 'ok',
-        });
+      expect(result).toEqual({});
     });
 
-    it('should flush the action once it is sent', () => {
-        svc.setAction('ok');
+    it('should keep the ticket until a valid event type is used', () => {
+      svc.setTicket({subject: 'Some Subject'});
 
-        const firstResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
-        const secondResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
+      executeRegisteredHook('🎲', {});
+      executeRegisteredHook('🐟', {});
+      executeRegisteredHook('💀', {});
+      const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
 
-        expect(firstResult).not.toEqual({});
-        expect(secondResult).toEqual({...defaultResult});
+      expect(result).toEqual({
+        ...defaultResult,
+        svc_ticket_subject: 'Some Subject',
+      });
     });
 
-    it('should be able to clear all the data', () => {
-        svc.setTicket({subject: '🍨', description: 'Some desc'});
-        svc.clearData();
+    it('should keep custom metadata in the ticket', () => {
+      svc.setTicket({subject: '🧀', custom: {verycustom: 'value'}});
 
-        const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
+      const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
 
-        expect(result).toEqual({...defaultResult});
+      expect(result).toEqual({
+        ...defaultResult,
+        svc_ticket_subject: '🧀',
+        svc_ticket_custom: {verycustom: 'value'},
+      });
     });
 
-    it('should call the uuidv4 method', async () => {
-        await executeRegisteredHook(SVCPluginEventTypes.event, {});
-        await executeRegisteredHook(SVCPluginEventTypes.event, {});
-        await executeRegisteredHook(SVCPluginEventTypes.event, {});
+    it('should flush the ticket once they are sent', () => {
+      svc.setTicket({subject: '🍟', description: 'description'});
+
+      const firstResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
+      const secondResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
 
-        // One for generating pageViewId, one for each individual event.
-        expect(someUUIDGenerator).toHaveBeenCalledTimes(1 + 3);
+      expect(firstResult).not.toEqual({});
+      expect(secondResult).toEqual({...defaultResult});
     });
+  });
 
-    it('should update the location when sending a pageview with the page parameter', async () => {
-        const payload = {
-            page: '/somepage',
-        };
-
-        const pageview = await executeRegisteredHook(SVCPluginEventTypes.pageview, payload);
-        const event = await executeRegisteredHook(SVCPluginEventTypes.event, {});
-
-        expect(pageview).toEqual({
-            ...defaultResult,
-            hitType: SVCPluginEventTypes.pageview,
-            page: payload.page,
-            location: `${defaultResult.location}${payload.page.substring(1)}`,
-        });
-        expect(event).toEqual({
-            ...defaultResult,
-            hitType: SVCPluginEventTypes.event,
-            location: `${defaultResult.location}${payload.page.substring(1)}`,
-        });
+  it('should be able to set an action', () => {
+    svc.setAction('ok');
+
+    const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
+
+    expect(result).toEqual({
+      ...defaultResult,
+      svcAction: 'ok',
     });
+  });
+
+  it('should flush the action once it is sent', () => {
+    svc.setAction('ok');
+
+    const firstResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
+    const secondResult = executeRegisteredHook(SVCPluginEventTypes.event, {});
+
+    expect(firstResult).not.toEqual({});
+    expect(secondResult).toEqual({...defaultResult});
+  });
 
-    const executeRegisteredHook = (eventType: string, payload: any) => {
-        const [beforeHook] = client.registerBeforeSendEventHook.mock.calls[0];
-        const [afterHook] = client.registerAfterSendEventHook.mock.calls[0];
-        const result = beforeHook(eventType, payload);
-        afterHook(eventType, result);
-        return result;
+  it('should be able to clear all the data', () => {
+    svc.setTicket({subject: '🍨', description: 'Some desc'});
+    svc.clearData();
+
+    const result = executeRegisteredHook(SVCPluginEventTypes.event, {});
+
+    expect(result).toEqual({...defaultResult});
+  });
+
+  it('should call the uuidv4 method', async () => {
+    await executeRegisteredHook(SVCPluginEventTypes.event, {});
+    await executeRegisteredHook(SVCPluginEventTypes.event, {});
+    await executeRegisteredHook(SVCPluginEventTypes.event, {});
+
+    // One for generating pageViewId, one for each individual event.
+    expect(someUUIDGenerator).toHaveBeenCalledTimes(1 + 3);
+  });
+
+  it('should update the location when sending a pageview with the page parameter', async () => {
+    const payload = {
+      page: '/somepage',
     };
+
+    const pageview = await executeRegisteredHook(SVCPluginEventTypes.pageview, payload);
+    const event = await executeRegisteredHook(SVCPluginEventTypes.event, {});
+
+    expect(pageview).toEqual({
+      ...defaultResult,
+      hitType: SVCPluginEventTypes.pageview,
+      page: payload.page,
+      location: `${defaultResult.location}${payload.page.substring(1)}`,
+    });
+    expect(event).toEqual({
+      ...defaultResult,
+      hitType: SVCPluginEventTypes.event,
+      location: `${defaultResult.location}${payload.page.substring(1)}`,
+    });
+  });
+
+  const executeRegisteredHook = (eventType: string, payload: any) => {
+    const [beforeHook] = client.registerBeforeSendEventHook.mock.calls[0];
+    const [afterHook] = client.registerAfterSendEventHook.mock.calls[0];
+    const result = beforeHook(eventType, payload);
+    afterHook(eventType, result);
+    return result;
+  };
 });

package/src/plugins/svc.ts

@@ -4,112 +4,114 @@ import {convertTicketToMeasurementProtocol} from '../client/measurementProtocolM
 import {BasePlugin, BasePluginEventTypes, PluginClass, PluginOptions} from './BasePlugin';
 
 export const SVCPluginEventTypes = {
-    ...BasePluginEventTypes,
+  ...BasePluginEventTypes,
 };
 
 const allSVCEventTypes = Object.keys(SVCPluginEventTypes).map(
-    (key) => SVCPluginEventTypes[key as keyof typeof SVCPluginEventTypes],
+  (key) => SVCPluginEventTypes[key as keyof typeof SVCPluginEventTypes]
 );
 
 export type CustomValues = {
-    [key: string]: string | number | boolean;
+  [key: string]: string | number | boolean;
 };
 
 export interface TicketProperties {
-    id?: string;
-    subject?: string;
-    description?: string;
-    category?: string;
-    productId?: string;
-    custom?: CustomValues;
+  id?: string;
+  subject?: string;
+  description?: string;
+  category?: string;
+  productId?: string;
+  custom?: CustomValues;
 }
 
 export type Ticket = TicketProperties;
 
 export class SVCPlugin extends BasePlugin {
-    public static readonly Id = 'svc';
-    private ticket: Ticket = {};
-
-    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 'setTicket':
-                return this.setTicket;
-            default:
-                return null;
-        }
-    }
-
-    protected addHooks(): void {
-        this.addHooksForEvent();
-        this.addHooksForPageView();
-        this.addHooksForSVCEvents();
-    }
-
-    setTicket(ticket: Ticket) {
-        this.ticket = ticket;
-    }
-
-    protected clearPluginData() {
-        this.ticket = {};
-    }
-
-    private 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;
-        });
-    }
-
-    private addHooksForPageView() {
-        this.client.addEventTypeMapping(SVCPluginEventTypes.pageview, {
-            newEventType: EventType.collect,
-            variableLengthArgumentsNames: ['page'],
-            addVisitorIdParameter: true,
-            usesMeasurementProtocol: true,
-        });
-    }
-
-    private addHooksForEvent() {
-        this.client.addEventTypeMapping(SVCPluginEventTypes.event, {
-            newEventType: EventType.collect,
-            variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
-            addVisitorIdParameter: true,
-            usesMeasurementProtocol: true,
-        });
-    }
-
-    private addSVCDataToPayload(eventType: string, payload: any) {
-        const svcPayload = {
-            ...this.getLocationInformation(eventType, payload),
-            ...this.getDefaultContextInformation(eventType),
-            ...(this.action ? {svcAction: this.action} : {}),
-            ...(Object.keys(this.actionData ?? {}).length > 0 ? {svcActionData: this.actionData} : {}),
-        };
-
-        const ticketPayload = this.getTicketPayload();
-        this.clearData();
-
-        return {
-            ...ticketPayload,
-            ...svcPayload,
-            ...payload,
-        };
-    }
-
-    private getTicketPayload() {
-        return convertTicketToMeasurementProtocol(this.ticket);
+  public static readonly Id = 'svc';
+  private ticket: Ticket = {};
+
+  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 'setTicket':
+        return this.setTicket;
+      default:
+        return null;
     }
+  }
+
+  protected addHooks(): void {
+    this.addHooksForEvent();
+    this.addHooksForPageView();
+    this.addHooksForSVCEvents();
+  }
+
+  setTicket(ticket: Ticket) {
+    this.ticket = ticket;
+  }
+
+  protected clearPluginData() {
+    this.ticket = {};
+  }
+
+  private 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;
+    });
+  }
+
+  private addHooksForPageView() {
+    this.client.addEventTypeMapping(SVCPluginEventTypes.pageview, {
+      newEventType: EventType.collect,
+      variableLengthArgumentsNames: ['page'],
+      addVisitorIdParameter: true,
+      usesMeasurementProtocol: true,
+    });
+  }
+
+  private addHooksForEvent() {
+    this.client.addEventTypeMapping(SVCPluginEventTypes.event, {
+      newEventType: EventType.collect,
+      variableLengthArgumentsNames: ['eventCategory', 'eventAction', 'eventLabel', 'eventValue'],
+      addVisitorIdParameter: true,
+      usesMeasurementProtocol: true,
+    });
+  }
+
+  private addSVCDataToPayload(eventType: string, payload: any) {
+    const svcPayload = {
+      ...this.getLocationInformation(eventType, payload),
+      ...this.getDefaultContextInformation(eventType),
+      ...(this.action ? {svcAction: this.action} : {}),
+      ...(Object.keys(this.actionData ?? {}).length > 0 ? {svcActionData: this.actionData} : {}),
+    };
+
+    const ticketPayload = this.getTicketPayload();
+    this.clearData();
+
+    return {
+      ...ticketPayload,
+      ...svcPayload,
+      ...payload,
+    };
+  }
+
+  private getTicketPayload() {
+    return convertTicketToMeasurementProtocol(this.ticket);
+  }
 }
 
 export const SVC: PluginClass = SVCPlugin;

package/src/react-native/index.ts

@@ -1,3 +1,7 @@
-export {ReactNativeRuntime, ReactNativeRuntimeOptions, ReactNativeStorage} from './react-native-runtime';
+export {
+  ReactNativeRuntime,
+  ReactNativeRuntimeOptions,
+  ReactNativeStorage,
+} from './react-native-runtime';
 export * from '../coveoua/headless';
 import 'react-native-get-random-values';

package/src/react-native/react-native-runtime.ts

@@ -8,42 +8,42 @@ import {buildBaseUrl} from '../client/analytics';
 export type ReactNativeStorage = WebStorage;
 
 export interface ReactNativeRuntimeOptions {
-    /**
-     * Mandatory Storage implementation.
-     *
-     * We recommend using a storage library. There are a few options presented in the readme: https://github.com/coveo/coveo.analytics.js#using-react-native
-     */
-    storage: ReactNativeStorage;
-    /**
-     * Key for storing the visitor ID value.
-     * @defaut visitorId
-     */
-    visitorIdKey?: string;
-    token?: string;
-    version?: string;
-    endpoint?: string;
-    preprocessRequest?: PreprocessAnalyticsRequest;
+  /**
+   * Mandatory Storage implementation.
+   *
+   * We recommend using a storage library. There are a few options presented in the readme: https://github.com/coveo/coveo.analytics.js#using-react-native
+   */
+  storage: ReactNativeStorage;
+  /**
+   * Key for storing the visitor ID value.
+   * @default visitorId
+   */
+  visitorIdKey?: string;
+  token?: string;
+  version?: string;
+  endpoint?: string;
+  preprocessRequest?: PreprocessAnalyticsRequest;
 }
 
 export class ReactNativeRuntime implements IRuntimeEnvironment {
-    public client: AnalyticsFetchClient;
-    public storage: ReactNativeStorage;
+  public client: AnalyticsFetchClient;
+  public storage: ReactNativeStorage;
 
-    constructor(options: ReactNativeRuntimeOptions) {
-        const visitorIdKey = options.visitorIdKey ?? 'visitorId';
-        this.storage = options.storage;
-        this.client = new AnalyticsFetchClient({
-            preprocessRequest: options.preprocessRequest,
-            token: options.token,
-            baseUrl: buildBaseUrl(options.endpoint, options.version),
-            visitorIdProvider: {
-                getCurrentVisitorId: async () => (await this.storage.getItem(visitorIdKey)) || uuidv4(),
-                setCurrentVisitorId: (visitorId: string) => this.storage.setItem(visitorIdKey, visitorId),
-            },
-        });
-    }
+  constructor(options: ReactNativeRuntimeOptions) {
+    const visitorIdKey = options.visitorIdKey ?? 'visitorId';
+    this.storage = options.storage;
+    this.client = new AnalyticsFetchClient({
+      preprocessRequest: options.preprocessRequest,
+      token: options.token,
+      baseUrl: buildBaseUrl(options.endpoint, options.version),
+      visitorIdProvider: {
+        getCurrentVisitorId: async () => (await this.storage.getItem(visitorIdKey)) || uuidv4(),
+        setCurrentVisitorId: (visitorId: string) => this.storage.setItem(visitorIdKey, visitorId),
+      },
+    });
+  }
 
-    public getClientDependingOnEventType() {
-        return this.client;
-    }
+  public getClientDependingOnEventType() {
+    return this.client;
+  }
 }

package/src/react-native/react-native-utils.ts

@@ -5,5 +5,5 @@ export const ReactNativeRuntimeWarning = `
     `;
 
 export function isReactNative() {
-    return typeof navigator != 'undefined' && navigator.product == 'ReactNative';
+  return typeof navigator != 'undefined' && navigator.product == 'ReactNative';
 }