@availity/analytics-core 1.0.0

package/src/analytics.js

@@ -0,0 +1,197 @@
+import {
+  camelCase,
+  getComposedPath,
+  isLeftClickEvent,
+  isModifiedEvent,
+  isPluginEnabled,
+  isValidEventTypeOnTarget,
+} from './util';
+
+export default class AvAnalytics {
+  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) {
+      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();
+    }
+  }
+
+  startAutoTrack = () => {
+    document.body.addEventListener('click', this.handleEvent, true);
+    document.body.addEventListener('focus', this.handleEvent, true);
+    document.body.addEventListener('blur', this.handleEvent, true);
+  };
+
+  stopAutoTrack = () => {
+    document.body.removeEventListener('click', this.handleEvent, true);
+    document.body.removeEventListener('focus', this.handleEvent, true);
+    document.body.removeEventListener('blur', this.handleEvent, true);
+  };
+
+  handleEvent = (event) => {
+    if (this.invalidEvent(event)) {
+      return;
+    }
+    const target = event.target || event.srcElement;
+    const path = getComposedPath(event.target);
+
+    let analyticAttrs = {};
+
+    if (this.recursive) {
+      // Reverse the array so we pull attributes from top down
+      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') || undefined;
+        }
+      }
+    } else {
+      analyticAttrs = this.getAnalyticAttrs(target);
+    }
+
+    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') || 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);
+
+  getAnalyticAttrs = (elem) => {
+    if (!elem.attributes) {
+      return {};
+    }
+
+    const attrs = elem.attributes;
+    const analyticAttrs = {};
+
+    if (elem.nodeType === 1) {
+      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));
+          analyticAttrs[camelName] = elem.getAttribute(name);
+        }
+      }
+    }
+    return analyticAttrs;
+  };
+
+  startPageTracking = () => {
+    if (!this.pageListener) {
+      this.pageListener = this.trackPageView;
+      window.addEventListener('hashchange', this.pageListener, false);
+    }
+  };
+
+  stopPageTracking = () => {
+    if (this.pageListener) {
+      window.removeEventListener('hashchange', this.pageListener, false);
+      delete this.pageListener;
+    }
+  };
+
+  init = () => {
+    this.setPageTracking();
+
+    for (const plugin of this.plugins) {
+      if (isPluginEnabled(plugin) && typeof plugin.init === 'function') {
+        plugin.init();
+      }
+    }
+  };
+
+  setPageTracking = (value) => {
+    // eslint-disable-next-line eqeqeq
+    if (value != undefined) {
+      this.pageTracking = !!value;
+    }
+
+    const 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;
+    }
+  };
+
+  trackEvent = (properties) => {
+    const promises = [];
+    properties.url = properties.url || window.location.href || 'N/A';
+
+    for (const plugin of this.plugins) {
+      const props = {
+        ...properties,
+      };
+
+      if (isPluginEnabled(plugin) && typeof plugin.trackEvent === 'function') {
+        promises.push(plugin.trackEvent(props));
+      }
+    }
+    return this.Promise.all(promises);
+  };
+
+  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 = [];
+    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.d.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import AvAnalyticsPlugin from './plugin';
+
+declare class AvDmaAnalytics extends AvAnalyticsPlugin {
+  constructor(AvLogMessages: any, enabled?: boolean);
+
+  trackEvent(properties: any): any;
+
+  trackPageView(url: string): any;
+}
+
+export default AvDmaAnalytics;

package/src/dma.js

@@ -0,0 +1,45 @@
+import * as yup from 'yup';
+import AvAnalyticsPlugin from './plugin';
+
+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) {
+    super(enabled);
+    this.AvLogMessages = AvLogMessages;
+  }
+
+  trackEvent(properties) {
+    properties.level = properties.level || 'info';
+    // joi validate the properties
+    schema.validateSync(properties, {
+      strict: true,
+    });
+
+    return this.AvLogMessages[properties.level](properties);
+  }
+
+  trackPageView(url) {
+    return this.trackEvent({ event: 'page', url });
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,4 @@
+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/index.js

@@ -0,0 +1,4 @@
+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/plugin.d.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare class AvAnalyticsPlugin {
+  constructor(enabled?: boolean);
+
+  trackEvent(): any;
+
+  trackPageView(): any;
+
+  isEnabled(): boolean;
+}
+
+export default AvAnalyticsPlugin;

package/src/plugin.js

@@ -0,0 +1,13 @@
+export default class AvAnalyticsPlugin {
+  constructor(enabled = true) {
+    this.enabled = !!enabled;
+  }
+
+  trackEvent() {}
+
+  trackPageView() {}
+
+  isEnabled() {
+    return this.enabled;
+  }
+}

package/src/splunk.d.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import AvAnalyticsPlugin from './plugin';
+
+declare class AvSplunkAnalytics extends AvAnalyticsPlugin {
+  constructor(AvLogMessages: any, enabled?: boolean);
+
+  trackEvent(properties: any): any;
+
+  trackPageView(url: string): any;
+}
+
+export default AvSplunkAnalytics;

package/src/splunk.js

@@ -0,0 +1,17 @@
+import AvAnalyticsPlugin from './plugin';
+
+export default class AvSplunkAnalytics extends AvAnalyticsPlugin {
+  constructor(AvLogMessages, enabled) {
+    super(enabled);
+    this.AvLogMessages = AvLogMessages;
+  }
+
+  trackEvent(properties) {
+    properties.level = properties.level || 'info';
+    return this.AvLogMessages[properties.level](properties);
+  }
+
+  trackPageView(url) {
+    return this.trackEvent({ event: 'page', url });
+  }
+}

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);
+  });
+});