@availity/analytics-core/lib/analytics.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

require("core-js/modules/es.object.to-string.js");

require("core-js/modules/es.promise.js");

require("core-js/modules/es.object.keys.js");

require("core-js/modules/es.array.filter.js");

require("core-js/modules/es.function.name.js");

require("core-js/modules/es.array.slice.js");

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));

var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _util = require("./util");

var AvAnalytics = function AvAnalytics(plugins) {
  var _this = this;

  var promise = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Promise;
  var pageTracking = arguments.length > 2 ? arguments[2] : undefined;
  var autoTrack = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
  var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
  (0, _classCallCheck2["default"])(this, AvAnalytics);

  this.startAutoTrack = function () {
    document.body.addEventListener('click', _this.handleEvent, true);
    document.body.addEventListener('focus', _this.handleEvent, true);
    document.body.addEventListener('blur', _this.handleEvent, true);
  };

  this.stopAutoTrack = function () {
    document.body.removeEventListener('click', _this.handleEvent, true);
    document.body.removeEventListener('focus', _this.handleEvent, true);
    document.body.removeEventListener('blur', _this.handleEvent, true);
  };

  this.handleEvent = function (event) {
    if (_this.invalidEvent(event)) {
      return;
    }

    var target = event.target || event.srcElement;
    var path = (0, _util.getComposedPath)(event.target);
    var analyticAttrs = {};

    if (_this.recursive) {
      // Reverse the array so we pull attributes from top down
      var _iterator = (0, _createForOfIteratorHelper2["default"])(path.reverse()),
          _step;

      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var pth = _step.value;

          var attrs = _this.getAnalyticAttrs(pth);

          analyticAttrs = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, analyticAttrs), attrs); // To consider using the element it has to have analytics attrs

          if (Object.keys(attrs).length > 0) {
            analyticAttrs.elemId = pth.getAttribute('id') || pth.getAttribute('name') || undefined;
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
    } else {
      analyticAttrs = _this.getAnalyticAttrs(target);
    }

    var actions = analyticAttrs ? _this.eventModifiers.filter(function (mod) {
      return analyticAttrs[mod] === event.type;
    }) : [];

    if (Object.keys(analyticAttrs).length === 0 || _this.recursive && actions.length === 0 || actions.length === 0) {
      return;
    }

    analyticAttrs.action = analyticAttrs.action || event.type;
    analyticAttrs.event = event.type;
    analyticAttrs.elemId = analyticAttrs.elemId || target.getAttribute('id') || target.getAttribute('name') || undefined;

    if (analyticAttrs.elemId === undefined) {
      delete analyticAttrs.elemId;
    } // remove keys for the click listeners


    var _iterator2 = (0, _createForOfIteratorHelper2["default"])(actions),
        _step2;

    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var key = _step2.value;

        if (key !== 'action' && key !== 'event') {
          delete analyticAttrs[key];
        }
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }

    _this.trackEvent(analyticAttrs);
  };

  this.invalidEvent = function (event) {
    return (0, _util.isModifiedEvent)(event) || event.type === 'click' && !(0, _util.isLeftClickEvent)(event) || !(0, _util.isValidEventTypeOnTarget)(event);
  };

  this.getAnalyticAttrs = function (elem) {
    if (!elem.attributes) {
      return {};
    }

    var attrs = elem.attributes;
    var analyticAttrs = {};

    if (elem.nodeType === 1) {
      for (var i = attrs.length - 1; i >= 0; i--) {
        var name = attrs[i].name;

        if (name.indexOf("".concat(_this.attributePrefix, "-")) === 0) {
          var camelName = (0, _util.camelCase)(name.slice(_this.attributePrefix.length + 1));
          analyticAttrs[camelName] = elem.getAttribute(name);
        }
      }
    }

    return analyticAttrs;
  };

  this.startPageTracking = function () {
    if (!_this.pageListener) {
      _this.pageListener = _this.trackPageView;
      window.addEventListener('hashchange', _this.pageListener, false);
    }
  };

  this.stopPageTracking = function () {
    if (_this.pageListener) {
      window.removeEventListener('hashchange', _this.pageListener, false);
      delete _this.pageListener;
    }
  };

  this.init = function () {
    _this.setPageTracking();

    var _iterator3 = (0, _createForOfIteratorHelper2["default"])(_this.plugins),
        _step3;

    try {
      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
        var plugin = _step3.value;

        if ((0, _util.isPluginEnabled)(plugin) && typeof plugin.init === 'function') {
          plugin.init();
        }
      }
    } catch (err) {
      _iterator3.e(err);
    } finally {
      _iterator3.f();
    }
  };

  this.setPageTracking = function (value) {
    // eslint-disable-next-line eqeqeq
    if (value != undefined) {
      _this.pageTracking = !!value;
    }

    var canPageTrack = typeof _this.startPageTracking === 'function' && typeof _this.stopPageTracking === 'function';

    if (canPageTrack && _this.pageTracking !== _this.isPageTracking) {
      if (_this.pageTracking) {
        _this.startPageTracking();
      } else {
        _this.stopPageTracking();
      }

      _this.isPageTracking = _this.pageTracking;
    }
  };

  this.trackEvent = function (properties) {
    var promises = [];
    properties.url = properties.url || window.location.href || 'N/A';

    var _iterator4 = (0, _createForOfIteratorHelper2["default"])(_this.plugins),
        _step4;

    try {
      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
        var plugin = _step4.value;
        var props = (0, _objectSpread2["default"])({}, properties);

        if ((0, _util.isPluginEnabled)(plugin) && typeof plugin.trackEvent === 'function') {
          promises.push(plugin.trackEvent(props));
        }
      }
    } catch (err) {
      _iterator4.e(err);
    } finally {
      _iterator4.f();
    }

    return _this.Promise.all(promises);
  };

  this.trackPageView = function (url) {
    // hashchanges are an object so we want to grab the new url from it
    if (typeof url === 'object') {
      url = url.newURL;
    }

    url = url || window.location.href;
    var promises = [];

    var _iterator5 = (0, _createForOfIteratorHelper2["default"])(_this.plugins),
        _step5;

    try {
      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
        var plugin = _step5.value;

        if ((0, _util.isPluginEnabled)(plugin) && typeof plugin.trackPageView === 'function') {
          promises.push(plugin.trackPageView(url));
        }
      }
    } catch (err) {
      _iterator5.e(err);
    } finally {
      _iterator5.f();
    }

    return _this.Promise.all(promises);
  };

  // if plugins or promise are undefined,
  // or if either is skipped and pageTracking boolean is used in their place
  if (!plugins || !promise) {
    throw new Error('[plugins], and [promise] must be defined');
  }

  this.plugins = Array.isArray(plugins) ? plugins : [plugins];
  this.pageTracking = !!pageTracking;

  if (options.eventModifiers) {
    this.eventModifiers = Array.isArray(options.eventModifiers) ? options.eventModifiers : [options.eventModifiers];
  } else {
    this.eventModifiers = ['action'];
  }

  this.Promise = promise;
  this.recursive = !!options.recursive;
  this.attributePrefix = options.attributePrefix || 'data-analytics';
  this.isPageTracking = false;
  this.hasInit = false;

  if (autoTrack) {
    this.startAutoTrack();
  }
};

exports["default"] = AvAnalytics;