coveo.analytics 2.30.56 → 2.32.0

package/src/coveoua/simpleanalytics.ts

@@ -8,181 +8,187 @@ import {libVersion} from '../version';
 export type AvailableActions = keyof CoveoUA;
 
 export interface CoveoUAOptions {
-    endpoint?: string;
-    isCustomEndpoint?: boolean;
-    plugins?: string[];
+  endpoint?: string;
+  isCustomEndpoint?: boolean;
+  plugins?: string[];
 }
 
 // CoveoUA mimics the GoogleAnalytics API.
 export class CoveoUA {
-    public client?: AnalyticsClient;
-    private plugins: Plugins = new Plugins();
-    private params: {[name: string]: string} = {};
-
-    // init initializes a new SimpleAPI client.
-    // @param token is your coveo access_token / api_key / ...
-    // @param endpoint is the endpoint you want to target defaults to the
-    //        usage analytics production endpoint
-    init(token: string | AnalyticsClient, optionsOrEndpoint: string | CoveoUAOptions): void {
-        if (!token) {
-            throw new Error(`You must pass your token when you call 'init'`);
-        }
-
-        if (typeof token === 'string') {
-            this.client = new CoveoAnalyticsClient({
-                token: token,
-                endpoint: this.getEndpoint(optionsOrEndpoint),
-                isCustomEndpoint: this.getIsCustomEndpoint(optionsOrEndpoint),
-            });
-        } else if (this.isAnalyticsClient(token)) {
-            this.client = token;
-        }
-
-        if (this.client) {
-            const pluginOptions: PluginOptions = {client: this.client};
-            this.plugins.clearRequired();
-            this.getPluginKeys(optionsOrEndpoint).forEach((pluginKey) =>
-                this.plugins.require(pluginKey, pluginOptions),
-            );
-            this.client.registerBeforeSendEventHook((eventType, payload) => ({
-                ...payload,
-                ...this.params,
-            }));
-        } else {
-            throw new Error(`You must pass either your token or a valid object when you call 'init'`);
-        }
+  public client?: AnalyticsClient;
+  private plugins: Plugins = new Plugins();
+  private params: {[name: string]: string} = {};
+
+  // init initializes a new SimpleAPI client.
+  // @param token is your coveo access_token / api_key / ...
+  // @param endpoint is the endpoint you want to target defaults to the
+  //        usage analytics production endpoint
+  init(token: string | AnalyticsClient, optionsOrEndpoint: string | CoveoUAOptions): void {
+    if (!token) {
+      throw new Error(`You must pass your token when you call 'init'`);
     }
 
-    private isAnalyticsClient(token: AnalyticsClient): token is AnalyticsClient {
-        return typeof token === 'object' && typeof token.sendEvent !== 'undefined';
+    if (typeof token === 'string') {
+      this.client = new CoveoAnalyticsClient({
+        token: token,
+        endpoint: this.getEndpoint(optionsOrEndpoint),
+        isCustomEndpoint: this.getIsCustomEndpoint(optionsOrEndpoint),
+      });
+    } else if (this.isAnalyticsClient(token)) {
+      this.client = token;
     }
 
-    private getPluginKeys(optionsOrEndpoint: string | CoveoUAOptions): string[] {
-        if (typeof optionsOrEndpoint === 'string') {
-            return Plugins.DefaultPlugins;
-        }
-        return Array.isArray(optionsOrEndpoint?.plugins) ? optionsOrEndpoint.plugins : Plugins.DefaultPlugins;
+    if (this.client) {
+      const pluginOptions: PluginOptions = {client: this.client};
+      this.plugins.clearRequired();
+      this.getPluginKeys(optionsOrEndpoint).forEach((pluginKey) =>
+        this.plugins.require(pluginKey, pluginOptions)
+      );
+      this.client.registerBeforeSendEventHook((eventType, payload) => ({
+        ...payload,
+        ...this.params,
+      }));
+    } else {
+      throw new Error(`You must pass either your token or a valid object when you call 'init'`);
     }
+  }
 
-    private getEndpoint(optionsOrEndpoint: string | CoveoUAOptions) {
-        if (typeof optionsOrEndpoint === 'string') {
-            return optionsOrEndpoint || Endpoints.default;
-        } else if (optionsOrEndpoint?.endpoint) {
-            return optionsOrEndpoint.endpoint;
-        }
-        return Endpoints.default;
-    }
+  private isAnalyticsClient(token: AnalyticsClient): token is AnalyticsClient {
+    return typeof token === 'object' && typeof token.sendEvent !== 'undefined';
+  }
 
-    private getIsCustomEndpoint(optionsOrEndpoint: string | CoveoUAOptions) {
-        if (typeof optionsOrEndpoint === 'string') {
-            return false;
-        } else if (optionsOrEndpoint?.isCustomEndpoint) {
-            return optionsOrEndpoint.isCustomEndpoint;
-        }
-        return false;
+  private getPluginKeys(optionsOrEndpoint: string | CoveoUAOptions): string[] {
+    if (typeof optionsOrEndpoint === 'string') {
+      return Plugins.DefaultPlugins;
     }
-
-    // init initializes a new client intended to be used with a proxy that injects the access token.
-    // @param endpoint is the endpoint of your proxy.
-    initForProxy(endpoint: string, isCustomEndpoint = false): void {
-        if (!endpoint) {
-            throw new Error(`You must pass your endpoint when you call 'initForProxy'`);
-        }
-
-        if (typeof endpoint !== 'string') {
-            throw new Error(`You must pass a string as the endpoint parameter when you call 'initForProxy'`);
-        }
-
-        this.client = new CoveoAnalyticsClient({
-            endpoint: endpoint,
-            isCustomEndpoint: isCustomEndpoint,
-        });
+    return Array.isArray(optionsOrEndpoint?.plugins)
+      ? optionsOrEndpoint.plugins
+      : Plugins.DefaultPlugins;
+  }
+
+  private getEndpoint(optionsOrEndpoint: string | CoveoUAOptions) {
+    if (typeof optionsOrEndpoint === 'string') {
+      return optionsOrEndpoint || Endpoints.default;
+    } else if (optionsOrEndpoint?.endpoint) {
+      return optionsOrEndpoint.endpoint;
     }
-
-    set(keyOrObject: string | any, value: string): void {
-        if (typeof keyOrObject === 'string') {
-            this.params[keyOrObject] = value;
-        } else {
-            Object.keys(keyOrObject).map((key) => {
-                this.params[key] = keyOrObject[key];
-            });
-        }
+    return Endpoints.default;
+  }
+
+  private getIsCustomEndpoint(optionsOrEndpoint: string | CoveoUAOptions) {
+    if (typeof optionsOrEndpoint === 'string') {
+      return false;
+    } else if (optionsOrEndpoint?.isCustomEndpoint) {
+      return optionsOrEndpoint.isCustomEndpoint;
+    }
+    return false;
+  }
+
+  // init initializes a new client intended to be used with a proxy that injects the access token.
+  // @param endpoint is the endpoint of your proxy.
+  initForProxy(endpoint: string, isCustomEndpoint = false): void {
+    if (!endpoint) {
+      throw new Error(`You must pass your endpoint when you call 'initForProxy'`);
     }
 
-    send(...[event, ...payload]: SendEventArguments): Promise<AnyEventResponse | void> {
-        if (typeof this.client == 'undefined') {
-            throw new Error(`You must call init before sending an event`);
-        }
-
-        if (!event) {
-            throw new Error(`You must provide an event type when calling "send".`);
-        }
-
-        return this.client.sendEvent(event.toLowerCase(), ...(payload as VariableArgumentsPayload));
+    if (typeof endpoint !== 'string') {
+      throw new Error(
+        `You must pass a string as the endpoint parameter when you call 'initForProxy'`
+      );
     }
 
-    onLoad(callback: Function) {
-        if (typeof callback == 'undefined') {
-            throw new Error(`You must pass a function when you call 'onLoad'`);
-        }
+    this.client = new CoveoAnalyticsClient({
+      endpoint: endpoint,
+      isCustomEndpoint: isCustomEndpoint,
+    });
+  }
 
-        callback();
+  set(keyOrObject: string | any, value: string): void {
+    if (typeof keyOrObject === 'string') {
+      this.params[keyOrObject] = value;
+    } else {
+      Object.keys(keyOrObject).map((key) => {
+        this.params[key] = keyOrObject[key];
+      });
     }
+  }
 
-    provide(name: string, plugin: PluginClass) {
-        this.plugins.provide(name, plugin);
+  send(...[event, ...payload]: SendEventArguments): Promise<AnyEventResponse | void> {
+    if (typeof this.client == 'undefined') {
+      throw new Error(`You must call init before sending an event`);
     }
 
-    require(name: string, options: Omit<PluginOptions, 'client'>) {
-        if (!this.client) {
-            throw new Error(`You must call init before requiring a plugin`);
-        }
-        this.plugins.require(name, {...options, client: this.client});
+    if (!event) {
+      throw new Error(`You must provide an event type when calling "send".`);
     }
 
-    callPlugin(pluginName: string, fn: string, ...args: any): any {
-        if (!this.client) {
-            throw new Error(`You must call init before calling a plugin function`);
-        }
-        return this.plugins.execute(pluginName, fn, ...args);
+    return this.client.sendEvent(event.toLowerCase(), ...(payload as VariableArgumentsPayload));
+  }
+
+  onLoad(callback: Function) {
+    if (typeof callback == 'undefined') {
+      throw new Error(`You must pass a function when you call 'onLoad'`);
     }
 
-    reset() {
-        this.client = undefined;
-        this.plugins = new Plugins();
-        this.params = {};
+    callback();
+  }
+
+  provide(name: string, plugin: PluginClass) {
+    this.plugins.provide(name, plugin);
+  }
+
+  require(name: string, options: Omit<PluginOptions, 'client'>) {
+    if (!this.client) {
+      throw new Error(`You must call init before requiring a plugin`);
     }
+    this.plugins.require(name, {...options, client: this.client});
+  }
 
-    version(): string {
-        return libVersion;
+  callPlugin(pluginName: string, fn: string, ...args: any): any {
+    if (!this.client) {
+      throw new Error(`You must call init before calling a plugin function`);
     }
+    return this.plugins.execute(pluginName, fn, ...args);
+  }
+
+  reset() {
+    this.client = undefined;
+    this.plugins = new Plugins();
+    this.params = {};
+  }
+
+  version(): string {
+    return libVersion;
+  }
 }
 
 export const coveoua = new CoveoUA();
 export const getCurrentClient = () => coveoua.client;
 
 export const handleOneAnalyticsEvent = (command: string, ...params: any[]) => {
-    const [, trackerName, pluginName, fn] = /^(?:(\w+)\.)?(?:(\w+):)?(\w+)$/.exec(command)!;
-
-    const actionFunction = (<any>coveoua)[fn];
-    if (pluginName && fn) {
-        return coveoua.callPlugin(pluginName as string, fn, ...params);
-    } else if (actionFunction) {
-        return actionFunction.apply(coveoua, params);
-    } else {
-        const actions: AvailableActions[] = [
-            'init',
-            'set',
-            'send',
-            'onLoad',
-            'callPlugin',
-            'reset',
-            'require',
-            'provide',
-            'version',
-        ];
-        throw new Error(`The action "${command}" does not exist. Available actions: ${actions.join(', ')}.`);
-    }
+  const [, trackerName, pluginName, fn] = /^(?:(\w+)\.)?(?:(\w+):)?(\w+)$/.exec(command)!;
+
+  const actionFunction = (<any>coveoua)[fn];
+  if (pluginName && fn) {
+    return coveoua.callPlugin(pluginName as string, fn, ...params);
+  } else if (actionFunction) {
+    return actionFunction.apply(coveoua, params);
+  } else {
+    const actions: AvailableActions[] = [
+      'init',
+      'set',
+      'send',
+      'onLoad',
+      'callPlugin',
+      'reset',
+      'require',
+      'provide',
+      'version',
+    ];
+    throw new Error(
+      `The action "${command}" does not exist. Available actions: ${actions.join(', ')}.`
+    );
+  }
 };
 
 export default handleOneAnalyticsEvent;

package/src/detector.ts

@@ -1,43 +1,43 @@
 export function hasWindow(): boolean {
-    return typeof window !== 'undefined';
+  return typeof window !== 'undefined';
 }
 
 export function hasNavigator(): boolean {
-    return typeof navigator !== 'undefined';
+  return typeof navigator !== 'undefined';
 }
 
 export function hasDocument(): boolean {
-    return typeof document !== 'undefined';
+  return typeof document !== 'undefined';
 }
 
 export function hasLocalStorage(): boolean {
-    try {
-        return typeof localStorage !== 'undefined';
-    } catch (error) {
-        return false;
-    }
+  try {
+    return typeof localStorage !== 'undefined';
+  } catch (error) {
+    return false;
+  }
 }
 
 export function hasSessionStorage(): boolean {
-    try {
-        return typeof sessionStorage !== 'undefined';
-    } catch (error) {
-        return false;
-    }
+  try {
+    return typeof sessionStorage !== 'undefined';
+  } catch (error) {
+    return false;
+  }
 }
 
 export function hasCookieStorage(): boolean {
-    return hasNavigator() && navigator.cookieEnabled;
+  return hasNavigator() && navigator.cookieEnabled;
 }
 
 export function hasCrypto(): boolean {
-    return typeof crypto !== 'undefined';
+  return typeof crypto !== 'undefined';
 }
 
 export function hasCryptoRandomValues(): boolean {
-    return hasCrypto() && typeof crypto.getRandomValues !== 'undefined';
+  return hasCrypto() && typeof crypto.getRandomValues !== 'undefined';
 }
 
 export function hasLocation(): boolean {
-    return typeof location !== 'undefined';
+  return typeof location !== 'undefined';
 }