@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/impressions/counter.js

@@ -0,0 +1,52 @@
+import { truncateTimeFrame } from '../utils/time';
+import objectAssign from 'object-assign';
+
+var ImpressionCounter = /*#__PURE__*/function () {
+  function ImpressionCounter() {
+    this.cache = {};
+  }
+  /**
+  * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
+  */
+
+
+  var _proto = ImpressionCounter.prototype;
+
+  _proto._makeKey = function _makeKey(featureName, timeFrame) {
+    return featureName + "::" + truncateTimeFrame(timeFrame);
+  }
+  /**
+  * Increments the quantity of impressions with the passed featureName and timeFrame.
+  */
+  ;
+
+  _proto.inc = function inc(featureName, timeFrame, amount) {
+    var key = this._makeKey(featureName, timeFrame);
+
+    var currentAmount = this.cache[key];
+    this.cache[key] = currentAmount ? currentAmount + amount : amount;
+  }
+  /**
+  * Returns all the elements stored in the cache and resets the cache.
+  */
+  ;
+
+  _proto.popAll = function popAll() {
+    var res = {};
+    objectAssign(res, this.cache);
+    this.cache = {};
+    return res;
+  }
+  /**
+  * Returns how many keys are stored in cache.
+  */
+  ;
+
+  _proto.size = function size() {
+    return Object.keys(this.cache).length;
+  };
+
+  return ImpressionCounter;
+}();
+
+export default ImpressionCounter;

package/es/impressions/hasher/buildKey.js

@@ -0,0 +1,3 @@
+export function buildKey(impression) {
+  return impression.keyName + ":" + impression.feature + ":" + impression.treatment + ":" + impression.label + ":" + impression.changeNumber;
+}

package/es/impressions/hasher/hashImpression128.js

@@ -0,0 +1,5 @@
+import { hash128 } from '../../engine/engine/murmur3/murmur3_128_x86';
+import { buildKey } from './buildKey';
+export function hashImpression128(impression) {
+  return hash128(buildKey(impression));
+}

package/es/impressions/hasher/hashImpression32.js

@@ -0,0 +1,5 @@
+import murmur from '../../engine/engine/murmur3/murmur3';
+import { buildKey } from './buildKey';
+export function hashImpression32(impression) {
+  return murmur.hash(buildKey(impression));
+}

package/es/impressions/observer/browser.js

@@ -0,0 +1,9 @@
+import ImpressionObserver from './observer';
+import { hashImpression32 } from '../hasher/hashImpression32';
+var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes
+
+var BrowserImpressionObserverFactory = function BrowserImpressionObserverFactory() {
+  return new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression32);
+};
+
+export default BrowserImpressionObserverFactory;

package/es/impressions/observer/node.js

@@ -0,0 +1,9 @@
+import ImpressionObserver from './observer';
+import { hashImpression128 } from '../hasher/hashImpression128';
+var LAST_SEEN_CACHE_SIZE = 500000; // cache up to 500k impression hashes
+
+var NodeImpressionObserverFactory = function NodeImpressionObserverFactory() {
+  return new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression128);
+};
+
+export default NodeImpressionObserverFactory;

package/es/impressions/observer/observer.js

@@ -0,0 +1,21 @@
+import LRU from '../../utils/lrucache/lrucache';
+
+var ImpressionObserver = /*#__PURE__*/function () {
+  function ImpressionObserver(size, hasher) {
+    this.cache = new LRU(size);
+    this.hasher = hasher;
+  }
+
+  var _proto = ImpressionObserver.prototype;
+
+  _proto.testAndSet = function testAndSet(impression) {
+    var hash = this.hasher(impression);
+    var previous = this.cache.get(hash);
+    this.cache.set(hash, impression.time);
+    return previous;
+  };
+
+  return ImpressionObserver;
+}();
+
+export default ImpressionObserver;

package/es/index.js

@@ -1 +1,132 @@
-export { SplitFactory } from './factory';
+import ManagerFactory from './manager';
+import StorageFactory from './storage';
+import ReadinessGateFacade from './readiness';
+import SettingsFactory from './utils/settings';
+import Context from './utils/context';
+import keyParser from './utils/key/parser';
+import logFactory, { API } from './utils/logger';
+var log = logFactory('splitio');
+import tracker from './utils/timeTracker';
+import SplitFactoryOnline from './factory/online';
+import SplitFactoryOffline from './factory/offline';
+import sdkStatusManager from './readiness/statusManager';
+import { LOCALHOST_MODE } from './utils/constants';
+import { validateApiKey, validateKey, validateTrafficType } from './utils/inputValidation';
+import IntegrationsManagerFactory from './integrations';
+import ImpressionCounter from './impressions/counter';
+
+var buildInstanceId = function buildInstanceId(key, trafficType) {
+  return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType !== undefined ? trafficType : '');
+};
+
+export function SplitFactory(config) {
+  // Cache instances created per factory.
+  var clientInstances = {}; // Tracking times. We need to do it here because we need the storage created.
+
+  var readyLatencyTrackers = {
+    splitsReadyTracker: tracker.start(tracker.TaskNames.SPLITS_READY),
+    segmentsReadyTracker: tracker.start(tracker.TaskNames.SEGMENTS_READY),
+    sdkReadyTracker: tracker.start(tracker.TaskNames.SDK_READY)
+  };
+  var context = new Context(); // Put settings config within context
+
+  var settings = SettingsFactory(config);
+  context.put(context.constants.SETTINGS, settings); // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+
+  validateApiKey(settings.core.authorizationKey); // Put readiness and statusManager within context
+  // Done before adding storage, to let it access readiness gate synchronously
+
+  var gateFactory = ReadinessGateFacade();
+  var readiness = gateFactory(settings.startup.readyTimeout);
+  context.put(context.constants.READINESS, readiness);
+  var statusManager = sdkStatusManager(context);
+  context.put(context.constants.STATUS_MANAGER, statusManager); // Put storage config within context
+
+  var storage = StorageFactory(context);
+  context.put(context.constants.STORAGE, storage); // Put counter
+
+  var impressionsCounter = new ImpressionCounter(); // Instantiates new counter for Impressions
+
+  context.put(context.constants.IMPRESSIONS_COUNTER, impressionsCounter); // Put integrationsManager within context.
+  // It needs to access the storage, settings and potentially other pieces, so it's registered after them.
+
+  var integrationsManager = IntegrationsManagerFactory(context);
+  context.put(context.constants.INTEGRATIONS_MANAGER, integrationsManager); // Define which type of factory to use
+
+  var splitFactory = settings.mode === LOCALHOST_MODE ? SplitFactoryOffline : SplitFactoryOnline;
+
+  var _splitFactory = splitFactory(context, readyLatencyTrackers),
+      mainClientInstance = _splitFactory.api,
+      mainClientMetricCollectors = _splitFactory.metricCollectors; // It makes no sense to have multiple instances of the manager.
+
+
+  var managerInstance = ManagerFactory(storage.splits, context);
+  var parsedDefaultKey = keyParser(settings.core.key);
+  var defaultInstanceId = buildInstanceId(parsedDefaultKey, settings.core.trafficType);
+  clientInstances[defaultInstanceId] = mainClientInstance;
+  log.info('New Split SDK instance created.');
+  return {
+    // Split evaluation and event tracking engine
+    client: function client(key, trafficType) {
+      if (key === undefined) {
+        log.debug('Retrieving default SDK client.');
+        return mainClientInstance;
+      }
+
+      if (typeof storage.shared != 'function') {
+        throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');
+      } // Validate the key value
+
+
+      var validKey = validateKey(key, 'Shared Client instantiation');
+
+      if (validKey === false) {
+        throw new Error('Shared Client needs a valid key.');
+      }
+
+      var validTrafficType;
+
+      if (trafficType !== undefined) {
+        validTrafficType = validateTrafficType(trafficType, 'Shared Client instantiation');
+
+        if (validTrafficType === false) {
+          throw new Error('Shared Client needs a valid traffic type or no traffic type at all.');
+        }
+      }
+
+      var instanceId = buildInstanceId(validKey, validTrafficType);
+
+      if (!clientInstances[instanceId]) {
+        var sharedSettings = settings.overrideKeyAndTT(validKey, validTrafficType);
+        var sharedContext = new Context();
+
+        var _readiness = gateFactory(sharedSettings.startup.readyTimeout);
+
+        sharedContext.put(context.constants.READY_FROM_CACHE, context.get(context.constants.READY_FROM_CACHE, true));
+        sharedContext.put(context.constants.READINESS, _readiness); // for shared clients, the internal offset of added/removed SDK_READY callbacks is -1
+
+        sharedContext.put(context.constants.STATUS_MANAGER, sdkStatusManager(sharedContext, -1));
+        sharedContext.put(context.constants.SETTINGS, sharedSettings);
+        sharedContext.put(context.constants.STORAGE, storage.shared(sharedSettings));
+        sharedContext.put(context.constants.IMPRESSIONS_COUNTER, impressionsCounter); // As shared clients reuse all the storage information, we don't need to check here if we
+        // will use offline or online mode. We should stick with the original decision.
+
+        clientInstances[instanceId] = splitFactory(sharedContext, false, mainClientMetricCollectors).api;
+        log.info('New shared client instance created.');
+      } else {
+        log.debug('Retrieving existing SDK client.');
+      }
+
+      return clientInstances[instanceId];
+    },
+    // Manager API to explore available information
+    manager: function manager() {
+      log.info('Manager instance retrieved.');
+      return managerInstance;
+    },
+    // Logger wrapper API
+    Logger: API,
+    // Expose SDK settings
+    settings: settings
+  };
+}

package/es/integrations/browser.js

@@ -0,0 +1,62 @@
+import GaToSplit from './ga/GaToSplit';
+import SplitToGa from './ga/SplitToGa';
+import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS, SPLIT_IMPRESSION, SPLIT_EVENT } from '../utils/constants';
+/**
+ * Factory function for browser IntegrationsManager.
+ * The integrations manager instantiates integration modules, and bypass tracked events and impressions to them.
+ *
+ * @param {Context} context SplitFactory context
+ *
+ * @returns integration manager or null if `integrations` are not present in settings.
+ */
+
+var integrationsManagerFactory = function integrationsManagerFactory(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var listeners = []; // No need to check if `settings.integrations` is an array. It was already validated in settings validation
+
+  settings.integrations.forEach(function (integrationOptions) {
+    var type = integrationOptions.type;
+    var integration;
+
+    switch (type) {
+      case GOOGLE_ANALYTICS_TO_SPLIT:
+        {
+          var storage = context.get(context.constants.STORAGE);
+          var coreSettings = settings.core;
+          integration = GaToSplit(integrationOptions, storage, coreSettings);
+          break;
+        }
+
+      case SPLIT_TO_GOOGLE_ANALYTICS:
+        {
+          integration = new SplitToGa(integrationOptions);
+          break;
+        }
+    }
+
+    if (integration && integration.queue) listeners.push(integration);
+  }); // If `listeners` is empty, not return a integration manager
+
+  if (listeners.length === 0) return; // Exception safe methods: each integration module is responsable for handling errors
+
+  return {
+    handleImpression: function handleImpression(impressionData) {
+      listeners.forEach(function (listener) {
+        return listener.queue({
+          type: SPLIT_IMPRESSION,
+          payload: impressionData
+        });
+      });
+    },
+    handleEvent: function handleEvent(eventData) {
+      listeners.forEach(function (listener) {
+        return listener.queue({
+          type: SPLIT_EVENT,
+          payload: eventData
+        });
+      });
+    }
+  };
+};
+
+export default integrationsManagerFactory;

package/es/integrations/ga/GaToSplit.js

@@ -0,0 +1,246 @@
+import objectAssign from 'object-assign';
+import { isString, numberIsFinite, unicAsStrings } from '../../utils/lang';
+import logFactory from '../../utils/logger';
+import { validateEvent, validateEventValue, validateEventProperties, validateKey, validateTrafficType } from '../../utils/inputValidation';
+var logName = 'splitio-ga-to-split',
+    logNameMapper = logName + ':mapper';
+var log = logFactory(logName);
+/**
+ * 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 {string} pluginName The plugin name identifier.
+ * @param {Function} pluginConstructor The plugin constructor function.
+ */
+
+function providePlugin(pluginName, pluginConstructor) {
+  // get reference to global command queue. Init it if not defined yet.
+  var gaAlias = window.GoogleAnalyticsObject || 'ga';
+
+  window[gaAlias] = window[gaAlias] || function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    (window[gaAlias].q = window[gaAlias].q || []).push(args);
+  }; // provides the plugin for use with analytics.js.
+
+
+  window[gaAlias]('provide', pluginName, pluginConstructor);
+} // Default mapping: object used for building the default mapper from hits to Split events
+
+
+var 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) {
+  return function (model) {
+    var hitType = model.get('hitType');
+    var eventTypeId = model.get(mapping.eventTypeId[hitType] || 'hitType');
+    var value = model.get(mapping.eventValue[hitType]);
+    var properties = {};
+    var fields = mapping.eventProperties[hitType];
+
+    if (fields) {
+      for (var i = 0; i < fields.length; i++) {
+        properties[fields[i]] = model.get(fields[i]);
+      }
+    }
+
+    return {
+      eventTypeId: eventTypeId,
+      value: value,
+      properties: properties,
+      timestamp: Date.now()
+    };
+  };
+} // exposed for unit testing purposses.
+
+
+export var defaultMapper = mapperBuilder(defaultMapping);
+export var 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) {
+  if (!Array.isArray(identities)) return []; // Remove duplicated identities
+
+  var uniqueIdentities = unicAsStrings(identities); // Filter based on rum-agent identities validator
+
+  return uniqueIdentities.filter(function (identity) {
+    if (!identity) return false;
+    var maybeKey = identity.key;
+    var maybeTT = identity.trafficType;
+    if (!isString(maybeKey) && !numberIsFinite(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(eventData) {
+  if (!validateEvent(eventData.eventTypeId, logNameMapper)) return false;
+  if (validateEventValue(eventData.value, logNameMapper) === false) return false;
+
+  var _validateEventPropert = validateEventProperties(eventData.properties, logNameMapper),
+      properties = _validateEventPropert.properties;
+
+  if (properties === false) return false;
+  if (eventData.timestamp && !numberIsFinite(eventData.timestamp)) return false;
+  if (eventData.key && validateKey(eventData.key, logNameMapper) === false) return false;
+  if (eventData.trafficTypeName && validateTrafficType(eventData.trafficTypeName, logNameMapper) === false) return false;
+  return true;
+}
+var INVALID_PREFIX_REGEX = /^[^a-zA-Z0-9]+/;
+var 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 {string} eventTypeId string value to fix.
+ * @returns {string} Fixed version of `eventTypeId`.
+ */
+
+export function fixEventTypeId(eventTypeId) {
+  // return the input eventTypeId if it cannot be fixed
+  if (!isString(eventTypeId) || eventTypeId.length === 0) {
+    return eventTypeId;
+  } // replace invalid substrings and truncate
+
+
+  var fixed = eventTypeId.replace(INVALID_PREFIX_REGEX, '').replace(INVALID_SUBSTRING_REGEX, '_');
+  var truncated = fixed.slice(0, 80);
+  if (truncated.length < fixed.length) log.warn('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
+ * @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
+ */
+
+function GaToSplit(sdkOptions, storage, coreSettings) {
+  var 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
+  };
+
+  var SplitTracker = // Constructor for the SplitTracker plugin.
+  function SplitTracker(tracker, pluginOptions) {
+    // precedence of options: SDK options (config.integrations) overwrite pluginOptions (`ga('require', 'splitTracker', pluginOptions)`)
+    var opts = objectAssign({}, defaultOptions, sdkOptions, pluginOptions);
+    this.tracker = tracker; // Validate identities
+
+    var validIdentities = validateIdentities(opts.identities);
+
+    if (validIdentities.length === 0) {
+      log.warn('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;
+    }
+
+    var invalids = validIdentities.length - opts.identities.length;
+
+    if (invalids) {
+      log.warn(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('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
+
+
+    var originalSendHitTask = tracker.get('sendHitTask');
+    tracker.set('sendHitTask', function (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("GaToSplit custom filter threw: " + err);
+        return;
+      } // map hit into an EventData instance
+
+
+      var eventData = defaultMapper(model);
+
+      if (opts.mapper) {
+        try {
+          eventData = opts.mapper(model, eventData);
+        } catch (err) {
+          log.warn("GaToSplit 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(eventData.eventTypeId);
+      if (!validateEventData(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(function (identity) {
+          var event = objectAssign({
+            key: identity.key,
+            trafficTypeName: identity.trafficType
+          }, eventData);
+          storage.events.track(event);
+        });
+      }
+    });
+    log.info('Started GA-to-Split integration');
+  }; // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
+
+
+  providePlugin('splitTracker', SplitTracker);
+}
+
+export default GaToSplit;

package/es/integrations/ga/SplitToGa.js

@@ -0,0 +1,127 @@
+import logFactory from '../../utils/logger';
+import { uniq } from '../../utils/lang';
+import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../../utils/constants';
+var log = logFactory('splitio-split-to-ga');
+
+var SplitToGa = /*#__PURE__*/function () {
+  // Default mapper function.
+  SplitToGa.defaultMapper = function defaultMapper(_ref) {
+    var type = _ref.type,
+        payload = _ref.payload;
+
+    switch (type) {
+      case SPLIT_IMPRESSION:
+        return {
+          hitType: 'event',
+          eventCategory: 'split-impression',
+          eventAction: 'Evaluate ' + payload.impression.feature,
+          eventLabel: 'Treatment: ' + payload.impression.treatment + '. Targeting rule: ' + payload.impression.label + '.',
+          nonInteraction: true
+        };
+
+      case SPLIT_EVENT:
+        return {
+          hitType: 'event',
+          eventCategory: 'split-event',
+          eventAction: payload.eventTypeId,
+          eventValue: payload.value,
+          nonInteraction: true
+        };
+    }
+
+    return null;
+  } // Util to access ga command queue, accounting for the possibility that it has been renamed.
+  ;
+
+  SplitToGa.getGa = function getGa() {
+    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 {UniversalAnalytics.FieldsObject} fieldsObject object to validate.
+   * @returns {boolean} Whether the data instance is a valid FieldsObject or not.
+   */
+  ;
+
+  SplitToGa.validateFieldsObject = function validateFieldsObject(fieldsObject) {
+    if (fieldsObject && fieldsObject.hitType) return true;
+    log.warn('your custom mapper returned an invalid FieldsObject instance. It must be an object with at least a `hitType` field.');
+    return false;
+  };
+
+  function SplitToGa(options) {
+    // Check if `ga` object is available
+    if (typeof SplitToGa.getGa() !== 'function') {
+      log.warn('`ga` command queue not found. No hits will be sent.'); // Return an empty object to avoid creating a SplitToGa instance
+
+      return {};
+    }
+
+    this.trackerNames = SplitToGa.defaultTrackerNames;
+
+    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.
+
+      this.impressions = options.impressions;
+      this.events = options.events;
+    }
+
+    log.info('Started Split-to-GA integration');
+  }
+
+  var _proto = SplitToGa.prototype;
+
+  _proto.queue = function queue(data) {
+    // access ga command queue via `getGa` method, accounting for the possibility that
+    // the global `ga` reference was not yet mutated by analytics.js.
+    var ga = SplitToGa.getGa();
+
+    if (ga) {
+      if (this.impressions === false && data.type === SPLIT_IMPRESSION) return;
+      if (this.events === false && data.type === SPLIT_EVENT) return;
+      var fieldsObject;
+
+      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(fieldsObject)) return;
+        }
+      } catch (err) {
+        log.warn("SplitToGa queue method threw: " + err + ". No hit was sent.");
+        return;
+      } // send the hit
+
+
+      this.trackerNames.forEach(function (trackerName) {
+        var 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);
+      });
+    }
+  };
+
+  return SplitToGa;
+}(); // A falsy object represents the default tracker
+
+
+SplitToGa.defaultTrackerNames = [''];
+export default SplitToGa;