@splitsoftware/splitio-commons 1.17.1-rc.3 → 2.0.0-rc.0

package/src/integrations/ga/GaToSplit.ts

@@ -1,299 +0,0 @@
-import { objectAssign } from '../../utils/lang/objectAssign';
-import { isString, isFiniteNumber, uniqAsStrings } from '../../utils/lang';
-import {
-  validateEvent,
-  validateEventValue,
-  validateEventProperties,
-  validateKey,
-  validateTrafficType
-} from '../../utils/inputValidation';
-import { SplitIO } from '../../types';
-import { Identity, GoogleAnalyticsToSplitOptions } from './types';
-import { ILogger } from '../../logger/types';
-import { IIntegrationFactoryParams } from '../types';
-import { ITelemetryTracker } from '../../trackers/types';
-
-const logPrefix = 'ga-to-split: ';
-const logNameMapper = 'ga-to-split:mapper';
-
-/**
- * Provides a plugin to use with analytics.js, accounting for the possibility
- * that the global command queue has been renamed or not yet defined.
- * @param window Reference to global object.
- * @param pluginName The plugin name identifier.
- * @param pluginConstructor The plugin constructor function.
- * @param log Logger instance.
- * @param autoRequire If true, log error when auto-require script is not detected
- */
-function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire: boolean, telemetryTracker?: ITelemetryTracker) {
-  // get reference to global command queue. Init it if not defined yet.
-  const gaAlias = window.GoogleAnalyticsObject || 'ga';
-  window[gaAlias] = window[gaAlias] || function () {
-    (window[gaAlias].q = window[gaAlias].q || []).push(arguments);
-  };
-
-  // provides the plugin for use with analytics.js.
-  window[gaAlias]('provide', pluginName, pluginConstructor);
-
-  const hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;
-  if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found
-    log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
-  }
-  if (telemetryTracker && hasAutoRequire) {
-    telemetryTracker.addTag('integration:ga-autorequire');
-  }
-}
-
-// Default mapping: object used for building the default mapper from hits to Split events
-const defaultMapping = {
-  eventTypeId: {
-    event: 'eventAction',
-    social: 'socialAction',
-  },
-  eventValue: {
-    event: 'eventValue',
-    timing: 'timingValue',
-  },
-  eventProperties: {
-    pageview: ['page'],
-    screenview: ['screenName'],
-    event: ['eventCategory', 'eventLabel'],
-    social: ['socialNetwork', 'socialTarget'],
-    timing: ['timingCategory', 'timingVar', 'timingLabel'],
-    exception: ['exDescription', 'exFatal'],
-  }
-};
-
-/**
- * Build a mapper function based on a mapping object
- *
- * @param {object} mapping
- */
-function mapperBuilder(mapping: typeof defaultMapping) {
-  return function (model: UniversalAnalytics.Model): SplitIO.EventData {
-    const hitType: string = model.get('hitType');
-    // @ts-expect-error
-    const eventTypeId = model.get(mapping.eventTypeId[hitType] || 'hitType');
-    // @ts-expect-error
-    const value = model.get(mapping.eventValue[hitType]);
-
-    const properties: Record<string, any> = {}; // @ts-expect-error
-    const fields: string[] = mapping.eventProperties[hitType];
-    if (fields) {
-      for (let i = 0; i < fields.length; i++) {
-        const fieldValue = model.get(fields[i]);
-        if (fieldValue !== undefined) properties[fields[i]] = fieldValue;
-      }
-    }
-
-    return {
-      eventTypeId,
-      value,
-      properties,
-      timestamp: Date.now(),
-    };
-  };
-}
-
-// exposed for unit testing purposses.
-export const defaultMapper = mapperBuilder(defaultMapping);
-
-export const defaultPrefix = 'ga';
-
-/**
- * Return a new list of identities removing invalid and duplicated ones.
- *
- * @param {Array} identities list of identities
- * @returns list of valid and unique identities. The list might be empty if `identities` is not an array or all its elements are invalid.
- */
-export function validateIdentities(identities?: Identity[]) {
-  if (!Array.isArray(identities))
-    return [];
-
-  // Remove duplicated identities
-  const uniqueIdentities = uniqAsStrings(identities);
-
-  // Filter based on rum-agent identities validator
-  return uniqueIdentities.filter(identity => {
-    if (!identity) return false;
-
-    const maybeKey = identity.key;
-    const maybeTT = identity.trafficType;
-
-    if (!isString(maybeKey) && !isFiniteNumber(maybeKey))
-      return false;
-    if (!isString(maybeTT))
-      return false;
-
-    return true;
-  });
-}
-
-/**
- * Checks if EventData fields (except EventTypeId) are valid, and logs corresponding warnings.
- * EventTypeId is validated separately.
- *
- * @param {EventData} data event data instance to validate. Precondition: data != undefined
- * @returns {boolean} Whether the data instance is a valid EventData or not.
- */
-export function validateEventData(log: ILogger, eventData: any): eventData is SplitIO.EventData {
-  if (!validateEvent(log, eventData.eventTypeId, logNameMapper))
-    return false;
-
-  if (validateEventValue(log, eventData.value, logNameMapper) === false)
-    return false;
-
-  const { properties } = validateEventProperties(log, eventData.properties, logNameMapper);
-  if (properties === false)
-    return false;
-
-  if (eventData.timestamp && !isFiniteNumber(eventData.timestamp))
-    return false;
-
-  if (eventData.key && validateKey(log, eventData.key, logNameMapper) === false)
-    return false;
-
-  if (eventData.trafficTypeName && validateTrafficType(log, eventData.trafficTypeName, logNameMapper) === false)
-    return false;
-
-  return true;
-}
-
-const INVALID_PREFIX_REGEX = /^[^a-zA-Z0-9]+/;
-const INVALID_SUBSTRING_REGEX = /[^-_.:a-zA-Z0-9]+/g;
-/**
- * Fixes the passed string value to comply with EventTypeId format, by removing invalid characters and truncating if necessary.
- *
- * @param {object} log factory logger
- * @param {string} eventTypeId string value to fix.
- * @returns {string} Fixed version of `eventTypeId`.
- */
-export function fixEventTypeId(log: ILogger, eventTypeId: any) {
-  // return the input eventTypeId if it cannot be fixed
-  if (!isString(eventTypeId) || eventTypeId.length === 0) {
-    return eventTypeId;
-  }
-
-  // replace invalid substrings and truncate
-  const fixed = eventTypeId
-    .replace(INVALID_PREFIX_REGEX, '')
-    .replace(INVALID_SUBSTRING_REGEX, '_');
-  const truncated = fixed.slice(0, 80);
-  if (truncated.length < fixed.length) log.warn(logPrefix + 'EventTypeId was truncated because it cannot be more than 80 characters long.');
-  return truncated;
-}
-
-/**
- * GaToSplit integration.
- * This function provides the SplitTracker plugin to ga command queue.
- *
- * @param {object} sdkOptions options passed at the SDK integrations settings (isomorphic SDK) or the GoogleAnalyticsToSplit plugin (pluggable browser SDK)
- * @param {object} storage SDK storage passed to track events
- * @param {object} coreSettings core settings used to define an identity if no one provided as SDK or plugin options
- * @param {object} log factory logger
- */
-export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIntegrationFactoryParams) {
-
-  const { storage, settings: { core: coreSettings, log }, telemetryTracker } = params;
-
-  const defaultOptions = {
-    prefix: defaultPrefix,
-    // We set default identities if key and TT are present in settings.core
-    identities: (coreSettings.key && coreSettings.trafficType) ?
-      [{ key: coreSettings.key, trafficType: coreSettings.trafficType }] :
-      undefined
-  };
-
-  class SplitTracker {
-
-    private tracker: UniversalAnalytics.Tracker;
-
-    // Constructor for the SplitTracker plugin.
-    constructor(tracker: UniversalAnalytics.Tracker, pluginOptions: GoogleAnalyticsToSplitOptions) {
-
-      // precedence of options: SDK options (config.integrations) overwrite pluginOptions (`ga('require', 'splitTracker', pluginOptions)`)
-      const opts = objectAssign({}, defaultOptions, sdkOptions, pluginOptions) as GoogleAnalyticsToSplitOptions & { identities: Identity[] };
-
-      this.tracker = tracker;
-
-      // Validate identities
-      const validIdentities = validateIdentities(opts.identities);
-
-      if (validIdentities.length === 0) {
-        log.warn(logPrefix + 'No valid identities were provided. Please check that you are passing a valid list of identities or providing a traffic type at the SDK configuration.');
-        return;
-      }
-
-      const invalids = validIdentities.length - opts.identities.length;
-      if (invalids) {
-        log.warn(logPrefix + `${invalids} identities were discarded because they are invalid or duplicated. Identities must be an array of objects with key and trafficType.`);
-      }
-      opts.identities = validIdentities;
-
-      // Validate prefix
-      if (!isString(opts.prefix)) {
-        log.warn(logPrefix + 'The provided `prefix` was ignored since it is invalid. Please check that you are passing a string object as `prefix`.');
-        opts.prefix = undefined;
-      }
-
-      // Overwrite sendHitTask to perform plugin tasks:
-      // 1) filter hits
-      // 2) map hits to Split events
-      // 3) handle events, i.e., validate and send them to Split BE
-      const originalSendHitTask = tracker.get('sendHitTask');
-      tracker.set('sendHitTask', function (model: UniversalAnalytics.Model) {
-        originalSendHitTask(model);
-
-        // filter hit if `hits` flag is false or if it comes from Split-to-GA integration
-        if (opts.hits === false || model.get('splitHit')) return;
-        try {
-          if (opts.filter && !opts.filter(model)) return;
-        } catch (err) {
-          log.warn(logPrefix + `custom filter threw: ${err}`);
-          return;
-        }
-
-        // map hit into an EventData instance
-        let eventData: SplitIO.EventData = defaultMapper(model);
-        if (opts.mapper) {
-          try {
-            eventData = opts.mapper(model, eventData as SplitIO.EventData);
-          } catch (err) {
-            log.warn(logPrefix + `custom mapper threw: ${err}`);
-            return;
-          }
-          if (!eventData)
-            return;
-        }
-
-        // Add prefix. Nothing is appended if the prefix is falsy, e.g. undefined or ''.
-        if (opts.prefix) eventData.eventTypeId = `${opts.prefix}.${eventData.eventTypeId}`;
-
-        eventData.eventTypeId = fixEventTypeId(log, eventData.eventTypeId);
-
-        if (!validateEventData(log, eventData))
-          return;
-
-        // Store the event
-        if (eventData.key && eventData.trafficTypeName) {
-          storage.events.track(eventData);
-        } else { // Store the event for each Key-TT pair (identities), if key and TT is not present in eventData
-          opts.identities.forEach(identity => {
-            const event = objectAssign({
-              key: identity.key,
-              trafficTypeName: identity.trafficType,
-            }, eventData);
-            storage.events.track(event);
-          });
-        }
-      });
-
-      log.info(logPrefix + 'integration started');
-    }
-
-  }
-
-  // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-  // eslint-disable-next-line no-undef
-  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
-}

package/src/integrations/ga/GoogleAnalyticsToSplit.ts

@@ -1,14 +0,0 @@
-import { IIntegrationFactoryParams, IntegrationFactory } from '../types';
-import { GaToSplit } from './GaToSplit';
-import { GoogleAnalyticsToSplitOptions } from './types';
-
-export function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions = {}): IntegrationFactory {
-
-  // GaToSplit integration factory
-  function GoogleAnalyticsToSplitFactory(params: IIntegrationFactoryParams) {
-    return GaToSplit(options, params);
-  }
-
-  GoogleAnalyticsToSplitFactory.type = 'GOOGLE_ANALYTICS_TO_SPLIT';
-  return GoogleAnalyticsToSplitFactory;
-}

package/src/integrations/ga/SplitToGa.ts

@@ -1,135 +0,0 @@
-/* eslint-disable no-undef */
-import { uniq } from '../../utils/lang';
-import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../../utils/constants';
-import { SplitIO } from '../../types';
-import { IIntegration } from '../types';
-import { SplitToGoogleAnalyticsOptions } from './types';
-import { ILogger } from '../../logger/types';
-
-const logPrefix = 'split-to-ga: ';
-const noGaWarning = '`ga` command queue not found.';
-const noHit = 'No hit was sent.';
-
-export class SplitToGa implements IIntegration {
-
-  // A falsy object represents the default tracker
-  static defaultTrackerNames = [''];
-
-  private trackerNames: string[];
-  private filter?: (data: SplitIO.IntegrationData) => boolean;
-  private mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
-  private impressions: boolean | undefined;
-  private events: boolean | undefined;
-  private log: ILogger;
-
-  // Default mapper function.
-  static defaultMapper({ type, payload }: SplitIO.IntegrationData): UniversalAnalytics.FieldsObject {
-    switch (type) {
-      case SPLIT_IMPRESSION:
-        return {
-          hitType: 'event',
-          eventCategory: 'split-impression',
-          eventAction: 'Evaluate ' + (payload as SplitIO.ImpressionData).impression.feature,
-          eventLabel: 'Treatment: ' + (payload as SplitIO.ImpressionData).impression.treatment + '. Targeting rule: ' + (payload as SplitIO.ImpressionData).impression.label + '.',
-          nonInteraction: true,
-        };
-      case SPLIT_EVENT:
-        return {
-          hitType: 'event',
-          eventCategory: 'split-event',
-          eventAction: (payload as SplitIO.EventData).eventTypeId,
-          eventValue: (payload as SplitIO.EventData).value,
-          nonInteraction: true,
-        };
-    }
-  }
-
-  // Util to access ga command queue, accounting for the possibility that it has been renamed.
-  static getGa(): UniversalAnalytics.ga | undefined { // @ts-expect-error
-    return typeof window !== 'undefined' ? window[window['GoogleAnalyticsObject'] || 'ga'] : undefined;
-  }
-
-  /**
-   * Validates if a given object is a UniversalAnalytics.FieldsObject instance, and logs a warning if not.
-   * It checks that the object contains a `hitType`, since it is the minimal field required to send the hit
-   * and avoid the GA error `No hit type specified. Aborting hit.`.
-   * Other validations (e.g., an `event` hitType must have a `eventCategory` and `eventAction`) are handled
-   * and logged (as warnings or errors depending the case) by GA debugger, but the hit is sent anyway.
-   *
-   * @param {object} log factory logger
-   * @param {UniversalAnalytics.FieldsObject} fieldsObject object to validate.
-   * @returns {boolean} Whether the data instance is a valid FieldsObject or not.
-   */
-  static validateFieldsObject(log: ILogger, fieldsObject: any): fieldsObject is UniversalAnalytics.FieldsObject {
-    if (fieldsObject && fieldsObject.hitType) return true;
-
-    log.warn(logPrefix + 'your custom mapper returned an invalid FieldsObject instance. It must be an object with at least a `hitType` field.');
-    return false;
-  }
-
-  /**
-   * constructor description
-   * @param {object} options options passed at the SDK integrations settings (isomorphic SDK) or the SplitToGoogleAnalytics plugin (pluggable browser SDK)
-   */
-  constructor(log: ILogger, options: SplitToGoogleAnalyticsOptions) {
-
-    this.trackerNames = SplitToGa.defaultTrackerNames;
-    this.log = log;
-
-    if (options) {
-      if (typeof options.filter === 'function') this.filter = options.filter;
-      if (typeof options.mapper === 'function') this.mapper = options.mapper;
-      // We strip off duplicated values if we received a `trackerNames` param.
-      // We don't warn if a tracker does not exist, since the user might create it after the SDK is initialized.
-      // Note: GA allows to create and get trackers using a string or number as tracker name, and does nothing if other types are used.
-      if (Array.isArray(options.trackerNames)) this.trackerNames = uniq(options.trackerNames);
-
-      // No need to validate `impressions` and `events` flags. Any other value than `false` is ignored (considered true by default).
-      this.impressions = options.impressions;
-      this.events = options.events;
-    }
-
-    log.info(logPrefix + 'integration started');
-    if (typeof SplitToGa.getGa() !== 'function') log.warn(logPrefix + `${noGaWarning} No hits will be sent until it is available.`);
-  }
-
-  queue(data: SplitIO.IntegrationData) {
-    // access ga command queue via `getGa` method, accounting for the possibility that
-    // the global `ga` reference was not yet mutated by analytics.js.
-    const ga = SplitToGa.getGa();
-    if (ga) {
-
-      if (this.impressions === false && data.type === SPLIT_IMPRESSION) return;
-      if (this.events === false && data.type === SPLIT_EVENT) return;
-
-      let fieldsObject: UniversalAnalytics.FieldsObject & { splitHit?: boolean };
-      try { // only try/catch filter and mapper, which might be defined by the user
-        // filter
-        if (this.filter && !this.filter(data)) return;
-
-        // map data into a FieldsObject instance
-        fieldsObject = SplitToGa.defaultMapper(data);
-        if (this.mapper) {
-          fieldsObject = this.mapper(data, fieldsObject);
-          // don't send the hit if it is falsy or invalid
-          if (!fieldsObject || !SplitToGa.validateFieldsObject(this.log, fieldsObject)) return;
-        }
-      } catch (err) {
-        this.log.warn(logPrefix + `queue method threw: ${err}. ${noHit}`);
-        return;
-      }
-
-      // send the hit
-      this.trackerNames.forEach(trackerName => {
-        const sendCommand = trackerName ? `${trackerName}.send` : 'send';
-        // mark the hit as a Split one to avoid the loop.
-        fieldsObject.splitHit = true;
-        // Send to GA using our reference to the GA object.
-        ga(sendCommand, fieldsObject);
-      });
-    } else {
-      this.log.warn(logPrefix + `${noGaWarning} ${noHit}`);
-    }
-  }
-
-}

package/src/integrations/ga/SplitToGoogleAnalytics.ts

@@ -1,14 +0,0 @@
-import { IIntegrationFactoryParams, IntegrationFactory } from '../types';
-import { SplitToGa } from './SplitToGa';
-import { SplitToGoogleAnalyticsOptions } from './types';
-
-export function SplitToGoogleAnalytics(options: SplitToGoogleAnalyticsOptions = {}): IntegrationFactory {
-
-  // SplitToGa integration factory
-  function SplitToGoogleAnalyticsFactory(params: IIntegrationFactoryParams) {
-    return new SplitToGa(params.settings.log, options);
-  }
-
-  SplitToGoogleAnalyticsFactory.type = 'SPLIT_TO_GOOGLE_ANALYTICS';
-  return SplitToGoogleAnalyticsFactory;
-}

package/src/integrations/ga/autoRequire.js

@@ -1,33 +0,0 @@
-/* eslint-disable no-undef */
-/**
- * Auto-require script to use with GoogleAnalyticsToSplit integration
- */
-(function (w, g, o) {
-  w[o] = w[o] || g;
-  w[g] = w[g] || function () { w[g].q.push(arguments); };
-  w[g].q = w[g].q || [];
-
-  var trackerNames = {};
-  function name(arg) { return typeof arg === 'object' && typeof arg.name === 'string' && arg.name; }
-
-  function processCommand(command) { // Queue a `require` command if v is a `create` command
-    if (command && command[0] === 'create') {
-      var trackerName = name(command[1]) || name(command[2]) || name(command[3]) || (typeof command[3] === 'string' ? command[3] : undefined); // Get tracker name
-
-      if (!trackerNames[trackerName]) {
-        trackerNames[trackerName] = true;
-        w[g]((trackerName ? trackerName + '.' : '') + 'require', 'splitTracker'); // Auto-require
-      }
-    }
-  }
-
-  w[g].q.forEach(processCommand); // Process already queued commands
-
-  var originalPush = w[g].q.push;
-  w[g].q.push = function (command) { // Spy new queued commands
-    var result = originalPush.apply(this, arguments);
-    processCommand(command);
-    return result;
-  };
-
-})(window, 'ga', 'GoogleAnalyticsObject');

package/src/integrations/ga/types.ts

@@ -1,153 +0,0 @@
-import { SplitIO } from '../../types';
-
-/**
- * A pair of user key and it's trafficType, required for tracking valid Split events.
- * @typedef {Object} Identity
- * @property {string} key The user key.
- * @property {string} trafficType The key traffic type.
- */
-export type Identity = {
-  key: string;
-  trafficType: string;
-};
-
-/**
- * Options for GoogleAnalyticsToSplit integration plugin
- */
-export interface GoogleAnalyticsToSplitOptions {
-  /**
-   * Optional flag to filter GA hits from being tracked as Split events.
-   * @property {boolean} hits
-   * @default true
-   */
-  hits?: boolean,
-  /**
-   * Optional predicate used to define a custom filter for tracking GA hits as Split events.
-   * For example, the following filter allows to track only 'event' hits:
-   *  `(model) => model.get('hitType') === 'event'`
-   * By default, all hits are tracked as Split events.
-   */
-  filter?: (model: UniversalAnalytics.Model) => boolean,
-  /**
-   * Optional function useful when you need to modify the Split event before tracking it.
-   * This function is invoked with two arguments:
-   * 1. the GA model object representing the hit.
-   * 2. the default format of the mapped Split event instance.
-   * The return value must be a Split event, that can be the second argument or a new object.
-   *
-   * For example, the following mapper adds a custom property to events:
-   *  `(model, defaultMapping) => {
-   *      defaultMapping.properties.someProperty = SOME_VALUE;
-   *      return defaultMapping;
-   *  }`
-   */
-  mapper?: (model: UniversalAnalytics.Model, defaultMapping: SplitIO.EventData) => SplitIO.EventData,
-  /**
-   * Optional prefix for EventTypeId, to prevent any kind of data collision between events.
-   * @property {string} prefix
-   * @default 'ga'
-   */
-  prefix?: string,
-  /**
-   * List of Split identities (key & traffic type pairs) used to track events.
-   * If not provided, events are sent using the key and traffic type provided at SDK config
-   */
-  identities?: Identity[],
-  /**
-   * Optional flag to log an error if the `auto-require` script is not detected.
-   * The auto-require script automatically requires the `splitTracker` plugin for created trackers,
-   * and should be placed right after your Google Analytics, Google Tag Manager or gtag.js script tag.
-   *
-   * @see {@link https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js}
-   *
-   * @property {boolean} autoRequire
-   * @default false
-   */
-  autoRequire?: boolean,
-}
-
-/**
- * Enable 'Google Analytics to Split' integration, to track Google Analytics hits as Split events.
- * Used by the browser variant of the isomorphic JS SDK.
- *
- * @see {@link https://help.split.io/hc/en-us/articles/360040838752#google-analytics-to-split}
- */
-export interface IGoogleAnalyticsToSplitConfig extends GoogleAnalyticsToSplitOptions {
-  type: 'GOOGLE_ANALYTICS_TO_SPLIT'
-}
-
-/**
- * Options for SplitToGoogleAnalytics integration plugin
- */
-export interface SplitToGoogleAnalyticsOptions {
-  /**
-   * Optional flag to filter Split impressions from being tracked as GA hits.
-   * @property {boolean} impressions
-   * @default true
-   */
-  impressions?: boolean,
-  /**
-   * Optional flag to filter Split events from being tracked as GA hits.
-   * @property {boolean} events
-   * @default true
-   */
-  events?: boolean,
-  /**
-   * Optional predicate used to define a custom filter for tracking Split data (events and impressions) as GA hits.
-   * For example, the following filter allows to track only impressions, equivalent to setting events to false:
-   *  `(data) => data.type === 'IMPRESSION'`
-   */
-  filter?: (data: SplitIO.IntegrationData) => boolean,
-  /**
-   * Optional function useful when you need to modify the GA hit before sending it.
-   * This function is invoked with two arguments:
-   * 1. the input data (Split event or impression).
-   * 2. the default format of the mapped FieldsObject instance (GA hit).
-   * The return value must be a FieldsObject, that can be the second argument or a new object.
-   *
-   * For example, the following mapper adds a custom dimension to hits:
-   *  `(data, defaultMapping) => {
-   *      defaultMapping.dimension1 = SOME_VALUE;
-   *      return defaultMapping;
-   *  }`
-   *
-   * Default FieldsObject instance for data.type === 'IMPRESSION':
-   *  `{
-   *    hitType: 'event',
-   *    eventCategory: 'split-impression',
-   *    eventAction: 'Evaluate ' + data.payload.impression.feature,
-   *    eventLabel: 'Treatment: ' + data.payload.impression.treatment + '. Targeting rule: ' + data.payload.impression.label + '.',
-   *    nonInteraction: true,
-   *  }`
-   * Default FieldsObject instance for data.type === 'EVENT':
-   *  `{
-   *    hitType: 'event',
-   *    eventCategory: 'split-event',
-   *    eventAction: data.payload.eventTypeId,
-   *    eventValue: data.payload.value,
-   *    nonInteraction: true,
-   *  }`
-   */
-  mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject,
-  /**
-   * List of tracker names to send the hit. An empty string represents the default tracker.
-   * If not provided, hits are only sent to default tracker.
-   */
-  trackerNames?: string[],
-}
-
-/**
- * Enable 'Split to Google Analytics' integration, to track Split impressions and events as Google Analytics hits.
- * Used by the browser variant of the isomorphic JS SDK.
- *
- * @see {@link https://help.split.io/hc/en-us/articles/360040838752#split-to-google-analytics}
- */
-export interface ISplitToGoogleAnalyticsConfig extends SplitToGoogleAnalyticsOptions {
-  type: 'SPLIT_TO_GOOGLE_ANALYTICS'
-}
-
-/**
- * Available integration options for the browser
- * Used by the browser variant of the isomorphic JS SDK.
- */
-export type BrowserIntegration = ISplitToGoogleAnalyticsConfig | IGoogleAnalyticsToSplitConfig;