coveo.analytics 2.30.56 → 2.32.0

package/src/storage.spec.ts

@@ -2,69 +2,69 @@ import {CookieStorage, CookieAndLocalStorage} from './storage';
 import {Cookie} from './cookieutils';
 
 describe('CookieStorage', () => {
-    const key = 'wow';
-    const someData = 'something';
+  const key = 'wow';
+  const someData = 'something';
 
-    it('setItem writes data to a cookie', () => {
-        const storage = new CookieStorage();
-        storage.setItem(key, someData);
-        expect(storage.getItem(key)).toBe(someData);
-    });
+  it('setItem writes data to a cookie', () => {
+    const storage = new CookieStorage();
+    storage.setItem(key, someData);
+    expect(storage.getItem(key)).toBe(someData);
+  });
 
-    it('removeItem removes the cookie', () => {
-        const storage = new CookieStorage();
-        storage.setItem(key, someData);
-        storage.removeItem(key);
-        expect(storage.getItem(key)).toBe(null);
-    });
+  it('removeItem removes the cookie', () => {
+    const storage = new CookieStorage();
+    storage.setItem(key, someData);
+    storage.removeItem(key);
+    expect(storage.getItem(key)).toBe(null);
+  });
 
-    it('honors expiration date', async () => {
-        const storage = new CookieStorage();
-        storage.setItem(key, someData, 1000);
-        await new Promise((res) => setTimeout(res, 1000)); // wait for 1 sec
-        expect(storage.getItem(key)).toBe(null);
-    });
+  it('honors expiration date', async () => {
+    const storage = new CookieStorage();
+    storage.setItem(key, someData, 1000);
+    await new Promise((res) => setTimeout(res, 1000)); // wait for 1 sec
+    expect(storage.getItem(key)).toBe(null);
+  });
 });
 
 describe('CookieAndLocalStorage', () => {
-    const key = 'hello';
-    const someData = 'world';
-    let storage: CookieAndLocalStorage;
-    let cookie: CookieStorage;
+  const key = 'hello';
+  const someData = 'world';
+  let storage: CookieAndLocalStorage;
+  let cookie: CookieStorage;
 
-    beforeEach(() => {
-        storage = new CookieAndLocalStorage();
-        cookie = new CookieStorage();
-    });
+  beforeEach(() => {
+    storage = new CookieAndLocalStorage();
+    cookie = new CookieStorage();
+  });
 
-    it('setItem writes data to a cookie and local storage', () => {
-        storage.setItem(key, someData);
-        expect(cookie.getItem(key)).toBe(someData);
-        expect(localStorage.getItem(key)).toBe(someData);
-    });
+  it('setItem writes data to a cookie and local storage', () => {
+    storage.setItem(key, someData);
+    expect(cookie.getItem(key)).toBe(someData);
+    expect(localStorage.getItem(key)).toBe(someData);
+  });
 
-    it('removeItem removes the cookie and local storage', () => {
-        storage.setItem(key, someData);
-        storage.removeItem(key);
+  it('removeItem removes the cookie and local storage', () => {
+    storage.setItem(key, someData);
+    storage.removeItem(key);
 
-        expect(storage.getItem(key)).toBe(null);
-        expect(cookie.getItem(key)).toBe(null);
-        expect(localStorage.getItem(key)).toBe(null);
-    });
+    expect(storage.getItem(key)).toBe(null);
+    expect(cookie.getItem(key)).toBe(null);
+    expect(localStorage.getItem(key)).toBe(null);
+  });
 
-    it('get item uses local storage first', () => {
-        cookie.setItem(key, 'fail');
-        localStorage.setItem(key, someData);
+  it('get item uses local storage first', () => {
+    cookie.setItem(key, 'fail');
+    localStorage.setItem(key, someData);
 
-        storage.getItem(key);
-        expect(storage.getItem(key)).toBe(someData);
-    });
+    storage.getItem(key);
+    expect(storage.getItem(key)).toBe(someData);
+  });
 
-    it('get item fallback on cookie storage if absent from local storage', () => {
-        localStorage.setItem(key, '');
-        cookie.setItem(key, someData);
+  it('get item fallback on cookie storage if absent from local storage', () => {
+    localStorage.setItem(key, '');
+    cookie.setItem(key, someData);
 
-        storage.getItem(key);
-        expect(storage.getItem(key)).toBe(someData);
-    });
+    storage.getItem(key);
+    expect(storage.getItem(key)).toBe(someData);
+  });
 });

package/src/storage.ts

@@ -4,66 +4,66 @@ import {Cookie} from './cookieutils';
 export let preferredStorage: WebStorage | null = null;
 
 export interface WebStorage {
-    getItem(key: string): string | null | Promise<string | null>;
-    removeItem(key: string): void;
-    setItem(key: string, data: string): void | Promise<void>;
+  getItem(key: string): string | null | Promise<string | null>;
+  removeItem(key: string): void;
+  setItem(key: string, data: string): void | Promise<void>;
 }
 
 export function getAvailableStorage(): WebStorage {
-    if (preferredStorage) {
-        return preferredStorage;
-    }
-    if (detector.hasLocalStorage()) {
-        return localStorage;
-    }
-    if (detector.hasCookieStorage()) {
-        return new CookieStorage();
-    }
-    if (detector.hasSessionStorage()) {
-        return sessionStorage;
-    }
-    return new NullStorage();
+  if (preferredStorage) {
+    return preferredStorage;
+  }
+  if (detector.hasLocalStorage()) {
+    return localStorage;
+  }
+  if (detector.hasCookieStorage()) {
+    return new CookieStorage();
+  }
+  if (detector.hasSessionStorage()) {
+    return sessionStorage;
+  }
+  return new NullStorage();
 }
 
 export class CookieStorage implements WebStorage {
-    static prefix = 'coveo_';
-    getItem(key: string): string | null {
-        return Cookie.get(`${CookieStorage.prefix}${key}`);
-    }
-    removeItem(key: string) {
-        Cookie.erase(`${CookieStorage.prefix}${key}`);
-    }
-    setItem(key: string, data: string, expire?: number): void {
-        Cookie.set(`${CookieStorage.prefix}${key}`, data, expire);
-    }
+  static prefix = 'coveo_';
+  getItem(key: string): string | null {
+    return Cookie.get(`${CookieStorage.prefix}${key}`);
+  }
+  removeItem(key: string) {
+    Cookie.erase(`${CookieStorage.prefix}${key}`);
+  }
+  setItem(key: string, data: string, expire?: number): void {
+    Cookie.set(`${CookieStorage.prefix}${key}`, data, expire);
+  }
 }
 
 export class CookieAndLocalStorage implements WebStorage {
-    private cookieStorage = new CookieStorage();
+  private cookieStorage = new CookieStorage();
 
-    getItem(key: string): string | null {
-        return localStorage.getItem(key) || this.cookieStorage.getItem(key);
-    }
+  getItem(key: string): string | null {
+    return localStorage.getItem(key) || this.cookieStorage.getItem(key);
+  }
 
-    removeItem(key: string): void {
-        this.cookieStorage.removeItem(key);
-        localStorage.removeItem(key);
-    }
+  removeItem(key: string): void {
+    this.cookieStorage.removeItem(key);
+    localStorage.removeItem(key);
+  }
 
-    setItem(key: string, data: string): void {
-        localStorage.setItem(key, data);
-        this.cookieStorage.setItem(key, data, 31556926000); // 1 year first party cookie
-    }
+  setItem(key: string, data: string): void {
+    localStorage.setItem(key, data);
+    this.cookieStorage.setItem(key, data, 31556926000); // 1 year first party cookie
+  }
 }
 
 export class NullStorage implements WebStorage {
-    getItem(key: string): string | null {
-        return null;
-    }
-    removeItem(key: string) {
-        /**/
-    }
-    setItem(key: string, data: string): void {
-        /**/
-    }
+  getItem(key: string): string | null {
+    return null;
+  }
+  removeItem(key: string) {
+    /**/
+  }
+  setItem(key: string, data: string): void {
+    /**/
+  }
 }

package/dist/definitions/bundle/browser-fetch.d.ts

@@ -1 +0,0 @@
-export declare const fetch: typeof globalThis.fetch;

package/dist/definitions/src/coveoua/browser.d.ts

@@ -1,6 +0,0 @@
-export interface CoveoUAGlobal {
-    (action: string, ...params: any[]): void;
-    q?: [string, any[]][];
-}
-declare const _default: any;
-export default _default;

package/dist/definitions/src/coveoua/headless.d.ts

@@ -1,6 +0,0 @@
-export { CoveoSearchPageClient, SearchPageClientProvider } from '../searchPage/searchPageClient';
-export { CaseAssistClient, CaseAssistClientProvider } from '../caseAssist/caseAssistClient';
-export { CoveoInsightClient, InsightClientProvider } from '../insight/insightClient';
-export { CoveoAnalyticsClient, AnalyticsClientSendEventHook } from '../client/analytics';
-export { PreprocessAnalyticsRequest } from '../client/analyticsRequestClient';
-export * as history from '../history';

package/dist/definitions/src/coveoua/library.d.ts

@@ -1,17 +0,0 @@
-import * as analytics from '../client/analytics';
-import * as donottrack from '../donottrack';
-import * as history from '../history';
-import * as SimpleAnalytics from './simpleanalytics';
-import * as storage from '../storage';
-export { CoveoAnalyticsClient, AnalyticsClientSendEventHook } from '../client/analytics';
-export { PreprocessAnalyticsRequest } from '../client/analyticsRequestClient';
-export { IRuntimeEnvironment } from '../client/runtimeEnvironment';
-export { CoveoUA, getCurrentClient, handleOneAnalyticsEvent } from './simpleanalytics';
-export { CoveoSearchPageClient, SearchPageClientProvider, EventDescription, EventBuilder, } from '../searchPage/searchPageClient';
-export { CaseAssistClient, CaseAssistClientProvider } from '../caseAssist/caseAssistClient';
-export { CoveoInsightClient, InsightClientProvider } from '../insight/insightClient';
-export * from '../searchPage/searchPageEvents';
-export * from '../caseAssist/caseAssistActions';
-export * from '../insight/insightEvents';
-export * from '../events';
-export { analytics, donottrack, history, SimpleAnalytics, storage };

package/dist/definitions/src/coveoua/plugins.d.ts

@@ -1,10 +0,0 @@
-import { PluginClass, PluginOptions } from '../plugins/BasePlugin';
-export declare class Plugins {
-    static readonly DefaultPlugins: string[];
-    private registeredPluginsMap;
-    private requiredPlugins;
-    require(name: string, options: PluginOptions): void;
-    provide(name: string, plugin: PluginClass): void;
-    clearRequired(): void;
-    execute(name: string, fn: string, ...args: any[]): any;
-}

package/dist/definitions/src/coveoua/simpleanalytics.d.ts

@@ -1,33 +0,0 @@
-import { AnyEventResponse, SendEventArguments } from '../events';
-import { AnalyticsClient } from '../client/analytics';
-import { PluginOptions } from '../plugins/BasePlugin';
-import { PluginClass } from '../plugins/BasePlugin';
-export type AvailableActions = keyof CoveoUA;
-export interface CoveoUAOptions {
-    endpoint?: string;
-    isCustomEndpoint?: boolean;
-    plugins?: string[];
-}
-export declare class CoveoUA {
-    client?: AnalyticsClient;
-    private plugins;
-    private params;
-    init(token: string | AnalyticsClient, optionsOrEndpoint: string | CoveoUAOptions): void;
-    private isAnalyticsClient;
-    private getPluginKeys;
-    private getEndpoint;
-    private getIsCustomEndpoint;
-    initForProxy(endpoint: string, isCustomEndpoint?: boolean): void;
-    set(keyOrObject: string | any, value: string): void;
-    send(...[event, ...payload]: SendEventArguments): Promise<AnyEventResponse | void>;
-    onLoad(callback: Function): void;
-    provide(name: string, plugin: PluginClass): void;
-    require(name: string, options: Omit<PluginOptions, 'client'>): void;
-    callPlugin(pluginName: string, fn: string, ...args: any): any;
-    reset(): void;
-    version(): string;
-}
-export declare const coveoua: CoveoUA;
-export declare const getCurrentClient: () => AnalyticsClient | undefined;
-export declare const handleOneAnalyticsEvent: (command: string, ...params: any[]) => any;
-export default handleOneAnalyticsEvent;

package/dist/definitions/src/react-native/index.d.ts

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

package/dist/definitions/src/react-native/react-native-runtime.d.ts

@@ -1,19 +0,0 @@
-import { WebStorage } from '../storage';
-import { AnalyticsFetchClient } from '../client/analyticsFetchClient';
-import { IRuntimeEnvironment } from '../client/runtimeEnvironment';
-import { PreprocessAnalyticsRequest } from '../client/analyticsRequestClient';
-export type ReactNativeStorage = WebStorage;
-export interface ReactNativeRuntimeOptions {
-    storage: ReactNativeStorage;
-    visitorIdKey?: string;
-    token?: string;
-    version?: string;
-    endpoint?: string;
-    preprocessRequest?: PreprocessAnalyticsRequest;
-}
-export declare class ReactNativeRuntime implements IRuntimeEnvironment {
-    client: AnalyticsFetchClient;
-    storage: ReactNativeStorage;
-    constructor(options: ReactNativeRuntimeOptions);
-    getClientDependingOnEventType(): AnalyticsFetchClient;
-}