@availity/analytics-core 3.0.0-alpha.6 → 3.1.2

package/lib/plugin.js

@@ -1,23 +1,36 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports["default"] = void 0;
 
-class AvAnalyticsPlugin {
-  constructor(enabled = true) {
-    this.enabled = !!enabled;
-  }
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
-  trackEvent() {}
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-  trackPageView() {}
-
-  isEnabled() {
-    return this.enabled;
+var AvAnalyticsPlugin = /*#__PURE__*/function () {
+  function AvAnalyticsPlugin() {
+    var enabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    (0, _classCallCheck2["default"])(this, AvAnalyticsPlugin);
+    this.enabled = !!enabled;
   }
 
-}
+  (0, _createClass2["default"])(AvAnalyticsPlugin, [{
+    key: "trackEvent",
+    value: function trackEvent() {}
+  }, {
+    key: "trackPageView",
+    value: function trackPageView() {}
+  }, {
+    key: "isEnabled",
+    value: function isEnabled() {
+      return this.enabled;
+    }
+  }]);
+  return AvAnalyticsPlugin;
+}();
 
-exports.default = AvAnalyticsPlugin;
+exports["default"] = AvAnalyticsPlugin;

package/lib/splunk.js

@@ -5,28 +5,48 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
 
 var _plugin = _interopRequireDefault(require("./plugin"));
 
-class AvSplunkAnalytics extends _plugin.default {
-  constructor(AvLogMessages, enabled) {
-    super(enabled);
-    this.AvLogMessages = AvLogMessages;
-  }
+var AvSplunkAnalytics = /*#__PURE__*/function (_AvAnalyticsPlugin) {
+  (0, _inherits2["default"])(AvSplunkAnalytics, _AvAnalyticsPlugin);
 
-  trackEvent(properties) {
-    properties.level = properties.level || 'info';
-    return this.AvLogMessages[properties.level](properties);
-  }
+  var _super = (0, _createSuper2["default"])(AvSplunkAnalytics);
 
-  trackPageView(url) {
-    return this.trackEvent({
-      event: 'page',
-      url: url
-    });
-  }
+  function AvSplunkAnalytics(AvLogMessages, enabled) {
+    var _this;
 
-}
+    (0, _classCallCheck2["default"])(this, AvSplunkAnalytics);
+    _this = _super.call(this, enabled);
+    _this.AvLogMessages = AvLogMessages;
+    return _this;
+  }
 
-exports.default = AvSplunkAnalytics;
+  (0, _createClass2["default"])(AvSplunkAnalytics, [{
+    key: "trackEvent",
+    value: function trackEvent(properties) {
+      properties.level = properties.level || 'info';
+      return this.AvLogMessages[properties.level](properties);
+    }
+  }, {
+    key: "trackPageView",
+    value: function trackPageView(url) {
+      return this.trackEvent({
+        event: 'page',
+        url: url
+      });
+    }
+  }]);
+  return AvSplunkAnalytics;
+}(_plugin["default"]);
+
+exports["default"] = AvSplunkAnalytics;

package/lib/util.js

@@ -0,0 +1,73 @@
+"use strict";
+
+require("core-js/modules/es.regexp.exec");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidEventTypeOnTarget = exports.isPluginEnabled = exports.isModifiedEvent = exports.isLeftClickEvent = exports.getComposedPath = exports.camelCase = void 0;
+
+require("core-js/modules/es.string.replace.js");
+
+var isLeftClickEvent = function isLeftClickEvent(event) {
+  return event.button === 0;
+};
+
+exports.isLeftClickEvent = isLeftClickEvent;
+
+var isModifiedEvent = function isModifiedEvent(event) {
+  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+};
+
+exports.isModifiedEvent = isModifiedEvent;
+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;
+};
+
+exports.isValidEventTypeOnTarget = isValidEventTypeOnTarget;
+
+var isPluginEnabled = function isPluginEnabled(plugin) {
+  return typeof plugin.isEnabled === 'function' ? plugin.isEnabled() : plugin.isEnabled;
+};
+
+exports.isPluginEnabled = isPluginEnabled;
+
+var camelCase = function camelCase(str) {
+  return str.replace(/-([\da-z])/gi, function (match, _char) {
+    return _char.toUpperCase();
+  });
+};
+/**
+ * Polyfill for [`Event.composedPath()`][1].
+ * https://gist.github.com/kleinfreund/e9787d73776c0e3750dcfcdc89f100ec
+ */
+
+
+exports.camelCase = camelCase;
+
+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, getComposedPath(parent)];
+  }
+
+  return [node];
+};
+
+exports.getComposedPath = getComposedPath;

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "@availity/analytics-core",
-  "version": "3.0.0-alpha.6+fa3cf31",
+  "version": "3.1.2",
   "description": "Analytics base configuration for sdk-js",
   "main": "lib/index.js",
   "module": "src/index.js",
+  "types": "types/index.d.ts",
   "author": "Kasey Powers <kasey.powers@availity.com>",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "fa3cf31fb566cea8e0c963f98ee55cba94cf35db"
+  "gitHead": "a247c20c27816eb3e3b68b983d12631a6cadd72b",
+  "dependencies": {
+    "@babel/runtime": "^7.10.2",
+    "core-js": "^3.12.1",
+    "yup": "^0.28.4"
+  },
+  "devDependencies": {
+    "@availity/api-axios": "^6.0.4"
+  }
 }

package/src/analytics.js

@@ -1,57 +1,14 @@
-const isLeftClickEvent = event => event.button === 0;
-
-const isModifiedEvent = event =>
-  !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
-
-const trackMap = {
-  select: ['focus', 'blur'],
-  textarea: ['focus', 'blur'],
-  input: ['focus', 'blur'],
-  default: ['click'],
-};
-
-const isValidEventTypeOnTarget = event =>
-  (trackMap[event.target.nodeName.toLowerCase()] || trackMap.default).indexOf(
-    event.type
-  ) > -1;
-
-const isPluginEnabled = plugin =>
-  typeof plugin.isEnabled === 'function'
-    ? plugin.isEnabled()
-    : plugin.isEnabled;
-
-const camelCase = str =>
-  str.replace(/-([a-z\d])/gi, (match, char) => char.toUpperCase());
-
-/**
- * Polyfill for [`Event.composedPath()`][1].
- * https://gist.github.com/kleinfreund/e9787d73776c0e3750dcfcdc89f100ec
- */
-const getComposedPath = node => {
-  let 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];
-};
+import {
+  camelCase,
+  getComposedPath,
+  isLeftClickEvent,
+  isModifiedEvent,
+  isPluginEnabled,
+  isValidEventTypeOnTarget,
+} from './util';
 
 export default class AvAnalytics {
-  constructor(
-    plugins,
-    promise = Promise,
-    pageTracking,
-    autoTrack = true,
-    options = {}
-  ) {
+  constructor(plugins, promise = Promise, pageTracking, autoTrack = true, options = {}) {
     // if plugins or promise are undefined,
     // or if either is skipped and pageTracking boolean is used in their place
     if (!plugins || !promise) {
@@ -61,6 +18,12 @@ export default class AvAnalytics {
     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';
@@ -85,7 +48,7 @@ export default class AvAnalytics {
     document.body.removeEventListener('blur', this.handleEvent, true);
   };
 
-  handleEvent = event => {
+  handleEvent = (event) => {
     if (this.invalidEvent(event)) {
       return;
     }
@@ -96,44 +59,49 @@ export default class AvAnalytics {
 
     if (this.recursive) {
       // Reverse the array so we pull attributes from top down
-      path.reverse().forEach(pth => {
+      for (const pth of path.reverse()) {
         const attrs = this.getAnalyticAttrs(pth);
 
         analyticAttrs = { ...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');
+          analyticAttrs.elemId = pth.getAttribute('id') || pth.getAttribute('name') || undefined;
         }
-      });
+      }
     } else {
       analyticAttrs = this.getAnalyticAttrs(target);
     }
 
-    if (
-      !Object.keys(analyticAttrs).length > 0 ||
-      (this.recursive && !analyticAttrs.action)
-    ) {
+    const actions = analyticAttrs ? this.eventModifiers.filter((mod) => 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');
+      analyticAttrs.elemId || target.getAttribute('id') || target.getAttribute('name') || undefined;
+
+    if (analyticAttrs.elemId === undefined) {
+      delete analyticAttrs.elemId;
+    }
+
+    // remove keys for the click listeners
+    for (const key of actions) {
+      if (key !== 'action' && key !== 'event') {
+        delete analyticAttrs[key];
+      }
+    }
 
     this.trackEvent(analyticAttrs);
   };
 
-  invalidEvent = event =>
-    isModifiedEvent(event) ||
-    (event.type === 'click' && !isLeftClickEvent(event)) ||
-    !isValidEventTypeOnTarget(event);
+  invalidEvent = (event) =>
+    isModifiedEvent(event) || (event.type === 'click' && !isLeftClickEvent(event)) || !isValidEventTypeOnTarget(event);
 
-  getAnalyticAttrs = elem => {
+  getAnalyticAttrs = (elem) => {
     if (!elem.attributes) {
       return {};
     }
@@ -145,9 +113,7 @@ export default class AvAnalytics {
       for (let i = attrs.length - 1; i >= 0; i--) {
         const { name } = attrs[i];
         if (name.indexOf(`${this.attributePrefix}-`) === 0) {
-          const camelName = camelCase(
-            name.slice(this.attributePrefix.length + 1)
-          );
+          const camelName = camelCase(name.slice(this.attributePrefix.length + 1));
           analyticAttrs[camelName] = elem.getAttribute(name);
         }
       }
@@ -172,22 +138,20 @@ export default class AvAnalytics {
   init = () => {
     this.setPageTracking();
 
-    this.plugins.forEach(plugin => {
+    for (const plugin of this.plugins) {
       if (isPluginEnabled(plugin) && typeof plugin.init === 'function') {
         plugin.init();
       }
-    });
+    }
   };
 
-  setPageTracking = value => {
+  setPageTracking = (value) => {
     // eslint-disable-next-line eqeqeq
     if (value != undefined) {
       this.pageTracking = !!value;
     }
 
-    const canPageTrack =
-      typeof this.startPageTracking === 'function' &&
-      typeof this.stopPageTracking === 'function';
+    const canPageTrack = typeof this.startPageTracking === 'function' && typeof this.stopPageTracking === 'function';
 
     if (canPageTrack && this.pageTracking !== this.isPageTracking) {
       if (this.pageTracking) {
@@ -199,29 +163,35 @@ export default class AvAnalytics {
     }
   };
 
-  trackEvent = properties => {
+  trackEvent = (properties) => {
     const promises = [];
     properties.url = properties.url || window.location.href || 'N/A';
 
-    this.plugins.forEach(plugin => {
+    for (const plugin of this.plugins) {
+      const props = {
+        ...properties,
+      };
+
       if (isPluginEnabled(plugin) && typeof plugin.trackEvent === 'function') {
-        promises.push(plugin.trackEvent(properties));
+        promises.push(plugin.trackEvent(props));
       }
-    });
+    }
     return this.Promise.all(promises);
   };
 
-  trackPageView = url => {
+  trackPageView = (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;
     const promises = [];
-    this.plugins.forEach(plugin => {
-      if (
-        isPluginEnabled(plugin) &&
-        typeof plugin.trackPageView === 'function'
-      ) {
+    for (const plugin of this.plugins) {
+      if (isPluginEnabled(plugin) && typeof plugin.trackPageView === 'function') {
         promises.push(plugin.trackPageView(url));
       }
-    });
+    }
     return this.Promise.all(promises);
   };
 }

package/src/dma.js

@@ -1,11 +1,27 @@
+import * as yup from 'yup';
 import AvAnalyticsPlugin from './plugin';
 
-const requiredFields = [
-  'tradingPartnerId',
-  'customerId',
-  'category',
-  'applicationId',
-];
+const schema = yup
+  .object()
+  .shape({
+    level: yup.string().optional(),
+    applicationId: yup.string().optional(),
+    payerSpaceId: yup.string().optional(),
+    label: yup.string().optional(),
+    appName: yup.string().optional(),
+    category: yup.string().optional(),
+    section: yup.string().optional(),
+    url: yup.string().optional(),
+    value: yup.string().optional(),
+    raw: yup.string().optional(),
+    feed: yup.string().optional(),
+    feedback: yup.string().optional(),
+    feedbackName: yup.string().optional(),
+    additionalFeedback: yup.string().optional(),
+    smile: yup.string().optional(),
+    surveyId: yup.string().optional(),
+  })
+  .noUnknown(true);
 
 export default class AvDmaAnalytics extends AvAnalyticsPlugin {
   constructor(AvLogMessages, enabled) {
@@ -14,44 +30,13 @@ export default class AvDmaAnalytics extends AvAnalyticsPlugin {
   }
 
   trackEvent(properties) {
-    if (!properties) return {};
-
-    const data = {};
-
-    if (properties.ApplicationId) {
-      properties.applicationId = properties.ApplicationId;
-      delete properties.ApplicationId;
-    }
-
-    if (properties.Category) {
-      properties.category = properties.Category;
-      delete properties.Category;
-    }
-
-    if (properties.tradingPartnerId || properties.TradingPartnerId) {
-      properties.tradingPartnerId =
-        properties.tradingPartnerId || properties.TradingPartnerId;
-      delete properties.TradingPartnerId;
-    }
-
-    if (properties.customerId || properties.CustomerId) {
-      properties.customerId = properties.customerId || properties.CustomerId;
-      delete properties.CustomerId;
-    } else {
-      properties.customerId = 'NA';
-    }
-
-    Object.keys(properties).forEach(key => {
-      const isRequiredField = requiredFields.filter(field => key === field)
-        .length;
-      if (!isRequiredField) {
-        data[key] = properties[key];
-
-        delete properties[key];
-      }
+    properties.level = properties.level || 'info';
+    // joi validate the properties
+    schema.validateSync(properties, {
+      strict: true,
     });
 
-    return this.AvLogMessages.send([{ ...properties, data }]);
+    return this.AvLogMessages[properties.level](properties);
   }
 
   trackPageView(url) {

package/src/index.js

@@ -1,6 +1,4 @@
-import AvAnalytics from './analytics';
-import AvAnalyticsPlugin from './plugin';
-import AvSplunkAnalytics from './splunk';
-import AvDmaAnalytics from './dma';
-
-export { AvAnalytics, AvAnalyticsPlugin, AvSplunkAnalytics, AvDmaAnalytics };
+export { default as AvAnalytics } from './analytics';
+export { default as AvAnalyticsPlugin } from './plugin';
+export { default as AvSplunkAnalytics } from './splunk';
+export { default as AvDmaAnalytics } from './dma';

package/src/tests/analytics.test.js

@@ -123,16 +123,16 @@ describe('AvAnalytics', () => {
 
     test('should check each plugin is enabled', () => {
       mockAvAnalytics.init();
-      plugins.forEach(plugin => {
+      for (const plugin of plugins) {
         expect(plugin.isEnabled).toHaveBeenCalled();
-      });
+      }
     });
 
     test('should call init on enabled plugins', () => {
       mockAvAnalytics.init();
-      plugins.forEach(plugin => {
+      for (const plugin of plugins) {
         expect(plugin.init).toHaveBeenCalledTimes(1);
-      });
+      }
 
       plugins[0].isEnabled.mockImplementationOnce(() => false);
       mockAvAnalytics.init();

package/src/tests/dma.test.js

@@ -1,15 +1,15 @@
+import { avLogMessagesApiV2 } from '@availity/api-axios';
 import { AvDmaAnalytics } from '..';
 
+jest.mock('@availity/api-axios');
+
 describe('AvSplunkAnalytics', () => {
-  let mockLog;
   let mockAvSplunkAnalytics;
 
   beforeEach(() => {
-    mockLog = {
-      send: jest.fn(),
-    };
-
-    mockAvSplunkAnalytics = new AvDmaAnalytics(mockLog);
+    avLogMessagesApiV2.sendBeacon = jest.fn();
+    // avLogMessagesApiV2.info = jest.fn;
+    mockAvSplunkAnalytics = new AvDmaAnalytics(avLogMessagesApiV2);
   });
 
   test('AvSplunkAnalytics should be defined', () => {
@@ -18,15 +18,14 @@ describe('AvSplunkAnalytics', () => {
 
   test('trackEvent should call AvLogMessages.send', () => {
     const level = 'info';
-    mockAvSplunkAnalytics.trackEvent({ level });
-    expect(mockLog.send).toHaveBeenCalledTimes(1);
+    mockAvSplunkAnalytics.trackEvent({ level, label: 'test' });
+    expect(avLogMessagesApiV2.info).toHaveBeenCalledTimes(1);
   });
 
-  test('should fill in customerId and TradingPartnerId if empty', () => {
+  test('trackEvent should not allow unknown keys', () => {
     const level = 'info';
-    mockAvSplunkAnalytics.trackEvent({ level });
-    expect(mockLog.send).toHaveBeenCalledWith(
-      expect.arrayContaining([{ customerId: 'NA', data: { level } }])
-    );
+    expect(() => {
+      mockAvSplunkAnalytics.trackEvent({ level, test: 'test' });
+    }).toThrow();
   });
 });

package/src/tests/util.test.js

@@ -0,0 +1,53 @@
+import {
+  camelCase,
+  getComposedPath,
+  isLeftClickEvent,
+  isModifiedEvent,
+  isPluginEnabled,
+  isValidEventTypeOnTarget,
+} from '../util';
+
+describe('analytics-core utils', () => {
+  test('isLeftClickEvent', () => {
+    expect(isLeftClickEvent({ button: 0 })).toBeTruthy();
+    expect(isLeftClickEvent({ button: 1 })).toBeFalsy();
+  });
+
+  test('isModifiedEvent', () => {
+    expect(isModifiedEvent({ metaKey: 1 })).toBeTruthy();
+    expect(isModifiedEvent({ altKey: 1 })).toBeTruthy();
+    expect(isModifiedEvent({ ctrlKey: 1 })).toBeTruthy();
+    expect(isModifiedEvent({ shiftKey: 1 })).toBeTruthy();
+    expect(isModifiedEvent({ key: 1 })).toBeFalsy();
+  });
+
+  test('isValidEventTypeOnTarget', () => {
+    expect(isValidEventTypeOnTarget({ target: { nodeName: 'click' }, type: 'click' })).toBeTruthy();
+    expect(isValidEventTypeOnTarget({ target: { nodeName: 'select' }, type: 'click' })).toBeFalsy();
+  });
+
+  test('isPluginEnabled', () => {
+    expect(isPluginEnabled({ isEnabled: () => true })).toBeTruthy();
+    expect(isPluginEnabled({ isEnabled: () => false })).toBeFalsy();
+    expect(isPluginEnabled({ isEnabled: true })).toBeTruthy();
+    expect(isPluginEnabled({ isEnabled: false })).toBeFalsy();
+  });
+
+  test('camelCase', () => {
+    expect(camelCase('foo')).toBe('foo');
+    expect(camelCase('foo-bar')).toBe('fooBar');
+    expect(camelCase('foo-bar-baz')).toBe('fooBarBaz');
+  });
+
+  test('getComposedPath', () => {
+    expect(getComposedPath({}).length).toBe(1);
+    expect(getComposedPath({ parentNode: {} }).length).toBe(2);
+    expect(getComposedPath({ host: {} }).length).toBe(2);
+    expect(getComposedPath({ defaultView: {} }).length).toBe(2);
+
+    const result =
+      '[{"parentNode":{"host":{"defaultView":{}}}},[{"host":{"defaultView":{}}},[{"defaultView":{}},[{}]]]]';
+    const nested = getComposedPath({ parentNode: { host: { defaultView: {} } } });
+    expect(JSON.stringify(nested)).toEqual(result);
+  });
+});