@availity/analytics-core 3.1.8 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@availity/analytics-core",
-  "version": "3.1.8",
+  "version": "4.0.2",
   "description": "Analytics base configuration for sdk-js",
   "keywords": [
     "availity",
@@ -17,24 +17,26 @@
   },
   "license": "MIT",
   "author": "Kasey Powers <kasey.powers@availity.com>",
-  "main": "lib/index.js",
-  "module": "src/index.js",
-  "types": "types/index.d.ts",
+  "browser": "./dist/index.js",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "yarn clean && yarn transpile",
-    "clean": "rimraf ./lib",
-    "transpile": "babel --root-mode upward src -d lib --ignore **/*.test.js"
+    "build": "tsup src/index.js --format esm,cjs --dts",
+    "dev": "tsup src/index.js --format esm,cjs --watch --dts",
+    "clean": "rm -rf node_modules && rm -rf dist",
+    "bundlesize": "bundlesize",
+    "publish": "yarn npm publish --tolerate-republish --access public"
   },
   "dependencies": {
-    "@babel/runtime": "^7.16.5",
-    "core-js": "^3.12.1",
     "yup": "^0.32.9"
   },
   "devDependencies": {
-    "@availity/api-axios": "^6.0.8"
+    "@availity/api-axios": "7.0.2",
+    "tsup": "^5.12.8",
+    "typescript": "^4.6.4"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "gitHead": "67c8772142e62d31efba07ed3f880994848a8ea4"
-}
+  }
+}

package/project.json

@@ -0,0 +1,39 @@
+{
+  "root": "packages/analytics-core",
+  "projectType": "library",
+  "targets": {
+    "test": {
+      "executor": "@nrwl/jest:jest",
+      "outputs": ["coverage/analytics-core"],
+      "options": {
+        "jestConfig": "packages/analytics-core/jest.config.js",
+        "passWithNoTests": true
+      }
+    },
+    "version": {
+      "executor": "@jscutlery/semver:version",
+      "options": {
+        "preset": "angular",
+        "commitMessageFormat": "chore(${projectName}): release version ${version} [skip ci]",
+        "tagPrefix": "@availity/${projectName}@",
+        "baseBranch": "master"
+      }
+    },
+    "lint": {
+      "executor": "@nrwl/linter:eslint",
+      "options": {
+        "eslintConfig": ".eslintrc.yaml",
+        "lintFilePatterns": ["packages/analytics-core/**/*.{js,ts}"],
+        "silent": false,
+        "fix": false,
+        "cache": true,
+        "cacheLocation": "./node_modules/.cache/analytics-core/.eslintcache",
+        "maxWarnings": -1,
+        "quiet": false,
+        "noEslintrc": false,
+        "hasTypeAwareRules": true,
+        "cacheStrategy": "metadata"
+      }
+    }
+  }
+}

package/{types → src}/analytics.d.ts

@@ -1,8 +1,20 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 declare class AvAnalytics {
+  plugins: any[];
+
+  attributePrefix: string;
+
+  recursive: boolean;
+
+  pageTracking: boolean;
+
+  isPageTracking: boolean;
+
+  hasInit: boolean;
+
   constructor(
-    plugins: any[],
+    plugins: any | any[],
     promise?: PromiseConstructor,
     pageTracking?: boolean,
     autoTrack?: boolean,
@@ -25,7 +37,7 @@ declare class AvAnalytics {
 
   init(): void;
 
-  setPageTracking(value: any): void;
+  setPageTracking(value?: any): void;
 
   trackEvent(properties: any): Promise<any[]>;
 

package/src/tests/analytics.test.ts

@@ -0,0 +1,187 @@
+import { AvAnalytics } from '..';
+
+type MockPlugin = {
+  isEnabled: jest.Mock;
+  init: jest.Mock | string;
+  trackEvent: jest.Mock | string;
+  trackPageView: jest.Mock | string;
+};
+
+function makePlugin() {
+  return {
+    isEnabled: jest.fn(() => true),
+    init: jest.fn(),
+    trackEvent: jest.fn(),
+    trackPageView: jest.fn(),
+  };
+}
+
+describe('AvAnalytics', () => {
+  let mockAvAnalytics: AvAnalytics;
+
+  test('AvAnalytics should be defined', () => {
+    const plugins = [makePlugin()];
+    mockAvAnalytics = new AvAnalytics(plugins, Promise, true);
+    expect(mockAvAnalytics).toBeDefined();
+    mockAvAnalytics = new AvAnalytics(plugins, Promise);
+    expect(mockAvAnalytics).toBeDefined();
+  });
+
+  test('AvAnalytics should throw error without plugins or Promise', () => {
+    expect(() => {
+      // @ts-expect-error: allow error for testing
+      mockAvAnalytics = new AvAnalytics();
+    }).toThrow('[plugins] and [promise] must be defined');
+  });
+
+  test('AvAnalytics should cast plugins to an array', () => {
+    const plugin = makePlugin();
+    mockAvAnalytics = new AvAnalytics(plugin, Promise);
+    expect(mockAvAnalytics.plugins).toEqual([plugin]);
+  });
+
+  test('AvAnalytics should use custom configs', () => {
+    mockAvAnalytics = new AvAnalytics([], Promise, true, true, {
+      attributePrefix: 'some-attr',
+      recursive: true,
+    });
+    expect(mockAvAnalytics.attributePrefix).toBe('some-attr');
+    expect(mockAvAnalytics.recursive).toBe(true);
+  });
+
+  describe('setPageTracking', () => {
+    beforeEach(() => {
+      const plugins = [makePlugin()];
+      mockAvAnalytics = new AvAnalytics(plugins, Promise);
+    });
+
+    test('passing in argument should change value of pageTracking', () => {
+      const initialTracking = true;
+      const setPageTracking = !initialTracking;
+
+      mockAvAnalytics.pageTracking = initialTracking;
+
+      mockAvAnalytics.setPageTracking(setPageTracking);
+      expect(mockAvAnalytics.pageTracking).toBe(setPageTracking);
+    });
+
+    test('with functions defined, will only call if pageTracking is opposite isPageTracking', () => {
+      mockAvAnalytics.startPageTracking = jest.fn();
+      mockAvAnalytics.stopPageTracking = jest.fn();
+
+      let testValue = true;
+      mockAvAnalytics.pageTracking = testValue;
+      mockAvAnalytics.isPageTracking = testValue;
+      mockAvAnalytics.setPageTracking();
+      expect(mockAvAnalytics.startPageTracking).not.toHaveBeenCalled();
+      expect(mockAvAnalytics.stopPageTracking).not.toHaveBeenCalled();
+
+      testValue = false;
+      mockAvAnalytics.pageTracking = testValue;
+      mockAvAnalytics.isPageTracking = testValue;
+      mockAvAnalytics.setPageTracking();
+      expect(mockAvAnalytics.startPageTracking).not.toHaveBeenCalled();
+      expect(mockAvAnalytics.stopPageTracking).not.toHaveBeenCalled();
+    });
+
+    test('with functions defined, will start/stop tracking based on pageTracking value', () => {
+      mockAvAnalytics.startPageTracking = jest.fn();
+      mockAvAnalytics.stopPageTracking = jest.fn();
+
+      let testValue = true;
+      mockAvAnalytics.pageTracking = testValue;
+      mockAvAnalytics.isPageTracking = !testValue;
+
+      mockAvAnalytics.setPageTracking();
+      expect(mockAvAnalytics.startPageTracking).toHaveBeenCalledTimes(1);
+      expect(mockAvAnalytics.stopPageTracking).toHaveBeenCalledTimes(0);
+      expect(mockAvAnalytics.isPageTracking).toBe(testValue);
+
+      testValue = false;
+      mockAvAnalytics.pageTracking = testValue;
+      mockAvAnalytics.isPageTracking = !testValue;
+
+      mockAvAnalytics.setPageTracking();
+      expect(mockAvAnalytics.startPageTracking).toHaveBeenCalledTimes(1);
+      expect(mockAvAnalytics.stopPageTracking).toHaveBeenCalledTimes(1);
+      expect(mockAvAnalytics.isPageTracking).toBe(testValue);
+    });
+  });
+
+  describe('init', () => {
+    let plugins: [MockPlugin, MockPlugin];
+    beforeEach(() => {
+      plugins = [makePlugin(), makePlugin()];
+      mockAvAnalytics = new AvAnalytics(plugins, Promise);
+      mockAvAnalytics.setPageTracking = jest.fn();
+    });
+
+    test('should call setPageTracking', () => {
+      mockAvAnalytics.init();
+      expect(mockAvAnalytics.setPageTracking).toHaveBeenCalled();
+    });
+
+    test('should check each plugin is enabled', () => {
+      mockAvAnalytics.init();
+      for (const plugin of plugins) {
+        expect(plugin.isEnabled).toHaveBeenCalled();
+      }
+    });
+
+    test('should call init on enabled plugins', () => {
+      mockAvAnalytics.init();
+      for (const plugin of plugins) {
+        expect(plugin.init).toHaveBeenCalledTimes(1);
+      }
+
+      plugins[0].isEnabled.mockImplementationOnce(() => false);
+      mockAvAnalytics.init();
+      expect(plugins[0].init).toHaveBeenCalledTimes(1);
+      expect(plugins[1].init).toHaveBeenCalledTimes(2);
+    });
+
+    test('should skip plugins without init function', () => {
+      plugins[1].init = 'test';
+      mockAvAnalytics.init();
+      expect(plugins[0].init).toHaveBeenCalled();
+    });
+  });
+
+  describe('event tracking', () => {
+    let plugins: [MockPlugin, MockPlugin, MockPlugin];
+    beforeEach(() => {
+      plugins = [makePlugin(), makePlugin(), makePlugin()];
+
+      mockAvAnalytics = new AvAnalytics(plugins, Promise);
+
+      plugins[0].isEnabled.mockImplementation(() => false);
+      plugins[1].trackEvent = 'test';
+      plugins[2].trackPageView = 'test';
+    });
+
+    test('trackEvent should call trackEvent on enabled plugins with properties', async () => {
+      const mockProperties = {};
+      await mockAvAnalytics.trackEvent(mockProperties);
+
+      expect(plugins[0].trackEvent).not.toHaveBeenCalled();
+      expect(plugins[2].trackEvent).toHaveBeenCalledWith(mockProperties);
+    });
+
+    test('trackEvent should call trackEvent on enabled plugins with url', async () => {
+      const mockProperties: { url?: string } = {};
+      await mockAvAnalytics.trackEvent(mockProperties);
+
+      expect(plugins[0].trackEvent).not.toHaveBeenCalled();
+      expect(mockProperties.url).toBeDefined();
+      expect(plugins[2].trackEvent).toHaveBeenCalledWith(mockProperties);
+    });
+
+    test('trackPageView should call trackPageView on enabled plugins with properties', async () => {
+      const mockUrl = 'testProperties';
+      await mockAvAnalytics.trackPageView(mockUrl);
+
+      expect(plugins[0].trackPageView).not.toHaveBeenCalled();
+      expect(plugins[1].trackPageView).toHaveBeenCalledWith(mockUrl);
+    });
+  });
+});

package/src/tests/dma.test.ts

@@ -0,0 +1,31 @@
+import { avLogMessagesApiV2 } from '@availity/api-axios';
+import { AvDmaAnalytics } from '..';
+
+jest.mock('@availity/api-axios');
+
+describe('AvSplunkAnalytics', () => {
+  let mockAvSplunkAnalytics: AvDmaAnalytics;
+
+  beforeEach(() => {
+    avLogMessagesApiV2.sendBeacon = jest.fn();
+    // avLogMessagesApiV2.info = jest.fn;
+    mockAvSplunkAnalytics = new AvDmaAnalytics(avLogMessagesApiV2);
+  });
+
+  test('AvSplunkAnalytics should be defined', () => {
+    expect(mockAvSplunkAnalytics).toBeDefined();
+  });
+
+  test('trackEvent should call AvLogMessages.send', () => {
+    const level = 'info';
+    mockAvSplunkAnalytics.trackEvent({ level, label: 'test' });
+    expect(avLogMessagesApiV2.info).toHaveBeenCalledTimes(1);
+  });
+
+  test('trackEvent should not allow unknown keys', () => {
+    const level = 'info';
+    expect(() => {
+      mockAvSplunkAnalytics.trackEvent({ level, test: 'test' });
+    }).toThrow();
+  });
+});

package/src/tests/plugin.test.ts

@@ -0,0 +1,23 @@
+import { AvAnalyticsPlugin } from '..';
+
+describe('AvAnalyticsPlugin', () => {
+  let mockPlugin: AvAnalyticsPlugin;
+
+  beforeEach(() => {
+    mockPlugin = new AvAnalyticsPlugin();
+  });
+
+  test('AvAnalyticsPlugin should be defined', () => {
+    expect(mockPlugin).toBeDefined();
+  });
+
+  test('should default enabled to true', () => {
+    expect(mockPlugin.isEnabled()).toBe(true);
+    mockPlugin = new AvAnalyticsPlugin(false);
+    expect(mockPlugin.isEnabled()).toBe(false);
+  });
+
+  test('isEnabled should return enabled value', () => {
+    expect(mockPlugin.isEnabled()).toBe(mockPlugin.isEnabled());
+  });
+});

package/src/tests/splunk.test.ts

@@ -0,0 +1,68 @@
+import { AvSplunkAnalytics } from '..';
+
+describe('AvSplunkAnalytics', () => {
+  let mockLog: { info: () => void; test: () => void };
+  let mockAvSplunkAnalytics: AvSplunkAnalytics;
+
+  beforeEach(() => {
+    mockLog = {
+      info: jest.fn(),
+      test: jest.fn(),
+    };
+
+    mockAvSplunkAnalytics = new AvSplunkAnalytics(mockLog);
+  });
+
+  test('AvSplunkAnalytics should be defined', () => {
+    expect(mockAvSplunkAnalytics).toBeDefined();
+  });
+
+  test('trackEvent should call AvLogMessages[level]', () => {
+    let level = 'info';
+    mockAvSplunkAnalytics.trackEvent({ level });
+    expect(mockLog.info).toHaveBeenCalledTimes(1);
+    expect(mockLog.test).toHaveBeenCalledTimes(0);
+    level = 'test';
+    mockAvSplunkAnalytics.trackEvent({ level });
+    expect(mockLog.info).toHaveBeenCalledTimes(1);
+    expect(mockLog.test).toHaveBeenCalledTimes(1);
+  });
+
+  test("trackEvent should default level to 'info'", () => {
+    mockAvSplunkAnalytics.trackEvent({});
+    expect(mockLog.info).toHaveBeenCalledTimes(1);
+    expect(mockLog.test).toHaveBeenCalledTimes(0);
+  });
+
+  test("trackEvent should default properties.url to location.href or 'N/A'", () => {
+    let startingObject: { message: string; url: string; level?: string } = {
+      message: 'hello world',
+      url: window.location.href || 'N/A',
+    };
+    const expectedCall = {
+      ...startingObject,
+      url: window.location.href || 'N/A',
+      level: 'info',
+    };
+    mockAvSplunkAnalytics.trackEvent(startingObject);
+    expect(mockLog.info).toHaveBeenCalledWith(expectedCall);
+
+    startingObject = {
+      message: 'hello world',
+      url: 'testUrl',
+      level: 'test',
+    };
+    mockAvSplunkAnalytics.trackEvent(startingObject);
+    expect(mockLog.test).toHaveBeenCalledWith(startingObject);
+  });
+
+  test("trackPageView should call trackEvent with event 'page' and passed in url", () => {
+    const testUrl = 'testUrl';
+    mockAvSplunkAnalytics.trackEvent = jest.fn();
+    mockAvSplunkAnalytics.trackPageView(testUrl);
+    expect(mockAvSplunkAnalytics.trackEvent).toHaveBeenCalledWith({
+      event: 'page',
+      url: testUrl,
+    });
+  });
+});

package/src/tests/util.test.ts

@@ -0,0 +1,52 @@
+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);
+  });
+});

package/src/util.d.ts

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare const isLeftClickEvent: (event: any) => boolean;
+
+declare const isModifiedEvent: (event: any) => boolean;
+
+declare const isValidEventTypeOnTarget: (event: any) => boolean;
+
+declare const isPluginEnabled: (plugin: any) => any;
+
+declare const camelCase: (str: any) => any;
+
+declare const getComposedPath: (node: any) => any;
+
+export { isLeftClickEvent, isModifiedEvent, isValidEventTypeOnTarget, isPluginEnabled, camelCase, getComposedPath };

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["."],
+  "exclude": ["dist", "build", "node_modules"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"],
+    "allowJs": true
+  },
+  "include": ["**/*.test.ts", "**/*.d.ts"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016-present Availity, LLC
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.