@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;

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

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

var isLeftClickEvent = function isLeftClickEvent(event) {
  return event.button === 0;
};

var isModifiedEvent = function isModifiedEvent(event) {
  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
};

var trackMap = {
  select: ['focus', 'blur'],
  textarea: ['focus', 'blur'],
  input: ['focus', 'blur'],
  "default": ['click']
};

var isValidEventTypeOnTarget = function isValidEventTypeOnTarget(event) {
  return (trackMap[event.target.nodeName.toLowerCase()] || trackMap["default"]).indexOf(event.type) > -1;
};

var isPluginEnabled = function isPluginEnabled(plugin) {
  return typeof plugin.isEnabled === 'function' ? plugin.isEnabled() : plugin.isEnabled;
};

var camelCase = function camelCase(str) {
  return str.replace(/-([a-z\d])/gi, function (match, _char) {
    return _char.toUpperCase();
  });
};
/**
 * Polyfill for [`Event.composedPath()`][1].
 * https://gist.github.com/kleinfreund/e9787d73776c0e3750dcfcdc89f100ec
 */


var getComposedPath = function getComposedPath(node) {
  var parent;

  if (node.parentNode) {
    parent = node.parentNode;
  } else if (node.host) {
    parent = node.host;
  } else if (node.defaultView) {
    parent = node.defaultView;
  }

  if (parent !== undefined) {
    return [node].concat(getComposedPath(parent));
  }

  return [node];
};

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 = getComposedPath(event.target);
    var analyticAttrs = {};

    if (_this.recursive) {
      // Reverse the array so we pull attributes from top down
      path.reverse().forEach(function (pth) {
        var attrs = _this.getAnalyticAttrs(pth);

        analyticAttrs = (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');
        }
      });
    } else {
      analyticAttrs = _this.getAnalyticAttrs(target);
    }

    if (!Object.keys(analyticAttrs).length > 0 || _this.recursive && !analyticAttrs.action || analyticAttrs.action !== event.type) {
      return;
    }

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

    _this.trackEvent(analyticAttrs);
  };

  this.invalidEvent = function (event) {
    return isModifiedEvent(event) || event.type === 'click' && !isLeftClickEvent(event) || !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 = 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();

    _this.plugins.forEach(function (plugin) {
      if (isPluginEnabled(plugin) && typeof plugin.init === 'function') {
        plugin.init();
      }
    });
  };

  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';

    _this.plugins.forEach(function (plugin) {
      var props = (0, _objectSpread2["default"])({}, properties);

      if (isPluginEnabled(plugin) && typeof plugin.trackEvent === 'function') {
        promises.push(plugin.trackEvent(props));
      }
    });

    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 = [];

    _this.plugins.forEach(function (plugin) {
      if (isPluginEnabled(plugin) && typeof plugin.trackPageView === 'function') {
        promises.push(plugin.trackPageView(url));
      }
    });

    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;
  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;