@heartlandone/vega 2.78.0 → 2.80.0

package/dist/collection/utils/spec-utils.js

@@ -1,225 +0,0 @@
-import { MockMouseEvent } from '@stencil/core/mock-doc';
-import { newSpecPage } from '@stencil/core/testing';
-/**
- * NOTE: This method is only for **SPEC** test cases.
- *
- * @typedef T HTMLElement
- * @param {HTMLElement | ShadowRoot} host - The start root to find
- * @param {selector} selector - The CSS selector path.
- * @returns {T} - Return the found element
- */
-export const find = (host, selector) => {
-  const selectorParts = selector.split('>>>').map((item) => item.trim());
-  const rootSelector = selectorParts[0];
-  const nestedSelectors = selectorParts.slice(1);
-  let element = host.querySelector(rootSelector);
-  nestedSelectors.forEach((item) => {
-    var _a;
-    element = (_a = element === null || element === void 0 ? void 0 : element.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(item);
-  });
-  return element;
-};
-/**
- * NOTE: This method is only for **SPEC** test cases.
- */
-export const MockedMutationObserver = jest.fn(function MutationObserver(callback) {
-  this.observe = jest.fn();
-  this.disconnect = jest.fn();
-  /**
-   * Mock the trigger for spec test to trigger observer callback
-   *
-   * @param {MutationRecord[]} mutations - mocked MutationObserver entries
-   */
-  this.trigger = (mutations) => {
-    callback(mutations, this);
-  };
-});
-/**
- * NOTE: This method is only for **SPEC** test cases.
- */
-export const MockedResizeObserver = jest.fn(function ResizeObserver(callback) {
-  this.observe = jest.fn();
-  this.disconnect = jest.fn();
-  /**
-   * Mock the trigger for spec test to trigger observer callback
-   *
-   * @param {ResizeObserverEntry[]} entries - mocked ResizeObserver entries
-   */
-  this.trigger = (entries) => {
-    callback(entries, this);
-  };
-});
-/**
- * NOTE: This method is only for **SPEC** test cases.
- * When the your want to mock some properties, but the properties is not existing on the target object, you should use this function
- *
- * @param {MockHTMLElement} element - the target dom object that you want to mock
- * @param {string} propertyKey - the property key name will be mocked
- * @param {unknown} value - the propertyKey's value
- */
-export const setPropOnMockHTMLElement = (element, propertyKey, value) => {
-  Object.defineProperty(element, propertyKey, { value });
-};
-/**
- * NOTE: This method is only for **SPEC** test cases.
- * It triggers a mouse event on a given element
- *
- * @param {HTMLElement} element - The element to trigger the event on.
- * @param {string} eventName - The name of the event to trigger.
- */
-export const triggerMouseEvent = (element, eventName) => {
-  if (element instanceof HTMLElement) {
-    element.dispatchEvent(new MouseEvent(eventName, { bubbles: true, cancelable: true, view: window }));
-  }
-  else {
-    element.dispatchEvent(new MockMouseEvent(eventName, { bubbles: true, cancelable: true, view: window }));
-  }
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **SPEC** test cases.
- * It swallows unhandled rejections that match a given error message pattern
- *
- * @typedef NodeJS
- * @param {NodeJS.Process} testProcess - The process object of the test process.
- * @param {RegExp[]} [rejectionPatterns] - A regular expression that will be used to test the rejection message. If the
- * message matches the pattern, the rejection will be swallowed. If the message does not match the pattern, the rejection
- * will be thrown.
- */
-export const swallowJestUnhandledRejection = (testProcess, rejectionPatterns) => {
-  testProcess.on('unhandledRejection', (rejection) => {
-    if (!rejectionPatterns.some((rejectionPattern) => rejectionPattern.test(rejection.message))) {
-      throw rejection;
-    }
-  });
-};
-/**
- * NOTE: This method is only for **SPEC** test cases.
- * It creates a new spec page, mocks the ResizeObserver, and returns the page
- *
- * @param {NewSpecPageOptions} opts - NewSpecPageOptions - This is the same as the opts parameter in the newSpecPage function.
- * @returns {Promise<SpecPage>} A SpecPage object.
- */
-export const initFormFieldSpecPage = async (opts) => {
-  const page = await newSpecPage(opts);
-  MockedResizeObserver.mock.instances.forEach((item) => {
-    item['trigger']([{ contentRect: { height: 100 } }]);
-  });
-  return page;
-};
-/**
- * NOTE: This method is only for **SPEC** test cases.
- * It takes a page object and a list of selectors, and then it empties the text content of all elements
- * that match the selectors
- *
- * @param {HTMLElement} body - HTMLElement - this is the page object that is passed into the test.
- * @param {string[]} selectors - string[] - An array of selectors to empty the content of.
- */
-export const emptyContentBySelector = (body, ...selectors) => {
-  body.querySelectorAll(selectors.join(',')).forEach((element) => {
-    element.textContent = '';
-  });
-};
-/**
- * NOTE: This method is only for **SPEC** test cases.
- * It sets the value of a property on a component, and then triggers a mutation observer to simulate
- * the component's reaction to the change
- *
- * @param {ComponentInterface} element - The element that you want to set the property on.
- * @param {string} property - The property of the element that you want to change.
- * @param {string | boolean | null | number | FormFieldValidationRule<unknown>[]} value - The value to
- * set the property to.
- * @param {number} [mutationObserverIndex] - This is the index of the MockedMutationObserver instance
- * that you want to trigger. If you don't pass this parameter, the last instance will be triggered.
- * @returns {void} - void.
- */
-export const setComponentPropertyWithMutationObserver = (element, property, value, mutationObserverIndex) => {
-  var _a;
-  element[property] = value;
-  const index = mutationObserverIndex ? mutationObserverIndex : 0;
-  let mockedAttributeMutationObserver = MockedMutationObserver.mock.instances[index];
-  if (!mutationObserverIndex && MockedMutationObserver.mock.instances.length > 1) {
-    for (let i = MockedMutationObserver.mock.instances.length - 1; i >= 0; i--) {
-      if (((_a = MockedMutationObserver.mock.instances[i]['observe'].mock.calls[0]) === null || _a === void 0 ? void 0 : _a[0]) === element) {
-        mockedAttributeMutationObserver = MockedMutationObserver.mock.instances[i];
-        break;
-      }
-    }
-  }
-  mockedAttributeMutationObserver['trigger']([
-    {
-      target: element,
-      attributeName: property,
-    },
-  ]);
-};
-/**
- * query the first dropdown item element found within a Vega dropdown component on a given page.
- *
- * @param {SpecPage} page - a rendered page or component in a testing environment
- * @param {string} [itemSelector=vega-dropdown-item] - The `itemSelector` parameter is a string that
- * represents the CSS selector for the dropdown item element you want to query. It is optional and
- * defaults to `'vega-dropdown-item'`.
- * @returns {HTMLElement} an HTMLElement.
- */
-export function queryVegaDropdownItem(page, itemSelector = 'vega-dropdown-item') {
-  const dropdownBox = page.body.querySelector('vega-dropdown-content-box');
-  const virtualScroll = dropdownBox.shadowRoot.querySelector('vega-virtual-scroll');
-  return virtualScroll.shadowRoot.querySelector(itemSelector);
-}
-/**
- * Dispatch paste event for a element.
- *
- * @param {HTMLElement} element - Content editable element, such as input, textarea.
- * @param {string} data - data to paste.
- * @returns {ClipboardEvent} - Paste event.
- */
-export function dispatchPasteEvent(element, data) {
-  element.focus();
-  const pasteEvent = new Event('paste', {
-    bubbles: true,
-    cancelable: true,
-  });
-  const clipboardDataMock = {
-    getData: jest.fn().mockReturnValue(data),
-  };
-  Object.defineProperty(pasteEvent, 'clipboardData', { value: clipboardDataMock });
-  element.dispatchEvent(pasteEvent);
-  if (!pasteEvent.defaultPrevented) {
-    const inputEvent = new Event('input', { bubbles: true, cancelable: true });
-    Object.defineProperty(inputEvent, 'inputType', { value: 'insertFromPaste' });
-    Object.defineProperty(inputEvent, 'data', { value: data });
-    Object.defineProperty(element, 'selectionStart', { value: data.length });
-    element['value'] = data;
-    element.dispatchEvent(inputEvent);
-  }
-  return pasteEvent;
-}
-/**
- * Mock the global Date object to a specific date for testing purposes.
- * This is useful for testing date-dependent functionality in a consistent manner.
- *
- * @param {string} dateString - A date string that can be parsed by the Date constructor (e.g., '2023-01-01T00:00:00Z').
- */
-export function mockedSpecDate(dateString) {
-  const mockDate = new Date(dateString);
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  const MockedDate = class extends Date {
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    constructor(...args) {
-      if (args.length === 0) {
-        super(mockDate.getTime());
-      }
-      else {
-        super(...args);
-      }
-    }
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    static now() {
-      return mockDate.getTime();
-    }
-  };
-  Object.setPrototypeOf(MockedDate.prototype, global.Date.prototype);
-  Object.setPrototypeOf(MockedDate, global.Date);
-  global.Date = MockedDate;
-}

package/dist/collection/utils/test/accessibility.test.js

@@ -1,40 +0,0 @@
-import { createEnterKeyHandlerToTriggerClick } from '../accessibility';
-test('createEnterKeyHandlerToTriggerClick should return a valid function that triggers click if enter key pressed', () => {
-  const mockClickListener = jest.fn((e) => {
-    expect(e.target).toBe(document);
-    expect(e.currentTarget).toBe(document);
-  });
-  document.addEventListener('click', mockClickListener);
-  document.addEventListener('keydown', createEnterKeyHandlerToTriggerClick());
-  const enterKeyDownEvent = new KeyboardEvent('keydown', { key: 'Enter' });
-  document.dispatchEvent(enterKeyDownEvent);
-  expect(mockClickListener.mock.calls.length).toBe(1);
-});
-test("createEnterKeyHandlerToTriggerClick should return a valid function that doesn't trigger click if non-enter key pressed", () => {
-  const mockClickListener = jest.fn((e) => {
-    expect(e.target).toBe(document);
-    expect(e.currentTarget).toBe(document);
-  });
-  document.addEventListener('click', mockClickListener);
-  document.addEventListener('keydown', createEnterKeyHandlerToTriggerClick());
-  const enterKeyDownEvent = new KeyboardEvent('keydown', { key: 'a' });
-  document.dispatchEvent(enterKeyDownEvent);
-  expect(mockClickListener.mock.calls.length).toBe(0);
-});
-test('createEnterKeyHandlerToTriggerClick should not trigger click event while currentTarget is undefined', () => {
-  const mockClickListener = jest.fn();
-  document.addEventListener('click', mockClickListener);
-  document.addEventListener('keydown', createEnterKeyHandlerToTriggerClick());
-  const enterKeyDownEvent = new KeyboardEvent('keydown', { key: 'Enter' });
-  Object.defineProperty(enterKeyDownEvent, 'currentTarget', {
-    get: () => {
-      return null;
-    },
-    set: () => {
-      return;
-    },
-    configurable: false,
-  });
-  document.dispatchEvent(enterKeyDownEvent);
-  expect(mockClickListener.mock.calls.length).toBe(0);
-});

package/dist/collection/utils/test/api.test.js

@@ -1,34 +0,0 @@
-import { ApiUtil } from '../api';
-beforeAll(() => {
-  global.fetch = () => Promise.resolve({
-    json: () => Promise.resolve([{ gap: 'test1' }, { gap: 'test2' }]),
-  });
-});
-test('get json data by api when call get', async () => {
-  const url = `http://test.url/banner-view?email=test@123.com`;
-  const result = await ApiUtil.get(url);
-  expect(result).toEqual([{ gap: 'test1' }, { gap: 'test2' }]);
-});
-test('get json data by api when call post', async () => {
-  const url = `http://test.url/banner-view`;
-  const params = {
-    param: 'test',
-  };
-  const result = await ApiUtil.post(url, params);
-  expect(result).toEqual([{ gap: 'test1' }, { gap: 'test2' }]);
-});
-test('get json data by api when call get and add header', async () => {
-  const url = `http://test.url/banner-view?email=test@123.com`;
-  const headers = {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    'Ocp-Apim-Subscription-Key': 'test',
-  };
-  const result = await ApiUtil.get(url, headers);
-  expect(result).toEqual([{ gap: 'test1' }, { gap: 'test2' }]);
-});
-test('should throw an error when call get', async () => {
-  global.fetch = null;
-  void expect(async () => {
-    await ApiUtil.get(`http://test.url/banner-view`);
-  }).rejects.toThrow('{}');
-});

package/dist/collection/utils/test/array.test.js

@@ -1,260 +0,0 @@
-import { convertArrayToNestedArray, findNodeList, flatNestedArray, flattenChildren, getLongestTextLengthFromArray, isArrayEqual, isObjectArrayLike, sortArrayOrNestedArray, sortAsExistArray, } from '../array';
-import { deepEqual } from '../object';
-test('flattenChildren as expected when array have children', () => {
-  const source = [
-    {
-      url: '',
-      name: 'Main Heading',
-      icon: 'search',
-      children: [
-        {
-          url: '',
-          name: 'Sub-Heading',
-          selected: true,
-        },
-      ],
-    },
-  ];
-  const result = flattenChildren(source);
-  expect(result[0].selected).toEqual(true);
-  expect(result[0].name).toEqual('Sub-Heading');
-});
-test('flattenChildren as expected when array not have children', () => {
-  const source = [
-    {
-      url: '',
-      name: 'Main Heading',
-      icon: 'search',
-      selected: false,
-    },
-  ];
-  const result = flattenChildren(source);
-  expect(result[0].selected).toEqual(false);
-  expect(result[0].name).toEqual('Main Heading');
-});
-test('flattenChildren as expected when array not have multiple children', () => {
-  const source = [
-    {
-      url: '',
-      name: 'Main Heading',
-      icon: 'search',
-      children: [
-        {
-          url: '',
-          name: 'First',
-          selected: true,
-          children: [
-            {
-              url: '',
-              name: 'Second',
-              selected: false,
-            },
-          ],
-        },
-      ],
-    },
-  ];
-  const result = flattenChildren(source);
-  expect(result[0].selected).toEqual(false);
-  expect(result[0].name).toEqual('Second');
-});
-describe('isArrayEqual', () => {
-  test('while comparator is default', () => {
-    expect(isArrayEqual([1, 2, 3], [1, 2, 3], true)).toBeTruthy();
-    expect(isArrayEqual([3, 2, 1], [1, 3, 2], true)).toBeTruthy();
-    expect(isArrayEqual([3, 2, 1, 2], [1, 3, 2, 2], true)).toBeTruthy();
-    expect(isArrayEqual([1, 2, 3], [1, 2, 3, 4], true)).toBeFalsy();
-    expect(isArrayEqual([1, 2, 3], [1, 2], true)).toBeFalsy();
-    expect(isArrayEqual([1, 2, 3], [1, 2, 4], true)).toBeFalsy();
-  });
-  test('should return properly result if comparator is objectComparator', () => {
-    const objectComparator = (a, b) => {
-      return deepEqual(a, b) ? 0 : -1;
-    };
-    const array1 = [
-      {
-        type: 'custom',
-        trigger: 'blur',
-        options: {
-          mask: 'XXXXXXXXXXX8888',
-          slot: '8',
-          accept: /\d/,
-          insertMode: false,
-          triggerAtInit: true,
-        },
-      },
-      {
-        type: 'custom',
-        trigger: 'input',
-        options: {
-          mask: 'XXXXXXXXXXX8888',
-          slot: '8',
-          accept: /\d/,
-          insertMode: false,
-          triggerAtInit: true,
-        },
-      },
-    ];
-    const array2 = [
-      {
-        type: 'custom',
-        trigger: 'blur',
-        options: {
-          mask: 'XXXXXXXXXXX8888',
-          slot: '8',
-          accept: /\d/,
-          insertMode: false,
-          triggerAtInit: true,
-        },
-      },
-      {
-        type: 'custom',
-        trigger: 'input',
-        options: {
-          mask: 'XXXXXXXXXXX8888',
-          slot: '8',
-          accept: /\d/,
-          insertMode: false,
-          triggerAtInit: true,
-        },
-      },
-    ];
-    expect(JSON.stringify(array1) === JSON.stringify(array2)).toBeTruthy();
-    expect(isArrayEqual(array1, array2, true, objectComparator)).toBeTruthy();
-    expect(isArrayEqual(array1, array2, false, objectComparator)).toBeTruthy();
-  });
-  test('should return properly result if comparator is objectComparator with different order', () => {
-    const array1 = [
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' },
-    ];
-    const array2 = [
-      { id: 2, name: 'Bob' },
-      { id: 1, name: 'Alice' },
-    ];
-    const userComparator = (a, b) => {
-      if (a.id < b.id)
-        return -1;
-      if (a.id > b.id)
-        return 1;
-      return 0; // Assume equality is based on the 'id' field
-    };
-    expect(JSON.stringify(array1) === JSON.stringify(array2)).toBeFalsy();
-    expect(isArrayEqual(array1, array2, true, userComparator)).toBeTruthy();
-    expect(isArrayEqual(array1, array2, false, userComparator)).toBeFalsy();
-  });
-});
-describe('isObjectArrayLike', () => {
-  test('return true if not all keys are number string', () => {
-    expect(isObjectArrayLike({ 1: 'test', '2': 'test2' })).toEqual(true);
-    expect(isObjectArrayLike({ '1': 'test', '2': 'test2' })).toEqual(true);
-    expect(isObjectArrayLike({ 1: 'test', 2: 'test2' })).toEqual(true);
-  });
-  test('return false if not all keys are number string', () => {
-    expect(isObjectArrayLike({ keyA: 'valueA' })).toEqual(false);
-    expect(isObjectArrayLike({ 'keyA': 'valueA', '1': 'test' })).toEqual(false);
-  });
-});
-test('sortArrayOrNestedArray', () => {
-  const array = [
-    { x: 2, y: 10 },
-    { x: 1, y: 20 },
-  ];
-  const expectArray = [
-    { x: 1, y: 20 },
-    { x: 2, y: 10 },
-  ];
-  expect(sortArrayOrNestedArray(array, (data) => data.x)).toEqual(expectArray);
-  expect(sortArrayOrNestedArray([array], (data) => data.x)).toEqual([
-    expectArray,
-  ]);
-});
-test('flatNestedArray', () => {
-  const singleArray = [8, 9, 10];
-  const array = [[1, 2, 3], [3, 2, 1], [4, 5], singleArray];
-  const expectArray = [1, 2, 3, 3, 2, 1, 4, 5, 8, 9, 10];
-  expect(flatNestedArray(singleArray)).toEqual(singleArray);
-  expect(flatNestedArray(array)).toEqual(expectArray);
-});
-test('convertArrayToNestedArray array[]', () => {
-  const lengthArray = [2, 4, 5];
-  const flatArray = [1, 2, 3, 3, 2, 1, 4, 5, 8, 9, 10];
-  const originArray = [
-    [1, 2],
-    [3, 3, 2, 1],
-    [4, 5, 8, 9, 10],
-  ];
-  expect(convertArrayToNestedArray(flatArray, lengthArray)).toEqual(originArray);
-});
-test('convertArrayToNestedArray array', () => {
-  const lengthArray = [];
-  const flatArray = [1, 2, 3, 3, 2, 1, 4, 5, 8, 9, 10];
-  const originArray = [1, 2, 3, 3, 2, 1, 4, 5, 8, 9, 10];
-  expect(convertArrayToNestedArray(flatArray, lengthArray)).toEqual(originArray);
-});
-test('getLongestTextLengthFromArray', () => {
-  const longestText = 'test test test test test test text';
-  const testArray = ['test', 'test', 'test text', longestText];
-  expect(getLongestTextLengthFromArray([])).toEqual(0);
-  expect(getLongestTextLengthFromArray(testArray)).toEqual(longestText.length);
-});
-test('sortAsExistArray', () => {
-  const existArray = [
-    'Monday',
-    'Tuesday',
-    'Wednesday',
-    'Thursday',
-    'Friday',
-    'Saturday',
-    'Sunday',
-  ];
-  const needSortArray = [
-    { x: 'Tuesday', y: 10 },
-    { x: 'Sunday', y: 5 },
-    { x: 'Wednesday', y: 20 },
-  ];
-  const expectResult = [
-    { x: 'Tuesday', y: 10 },
-    { x: 'Wednesday', y: 20 },
-    { x: 'Sunday', y: 5 },
-  ];
-  const needSortStringArray = ['Sunday', 'Saturday', 'Thursday'];
-  const expectStringArrayResult = ['Thursday', 'Saturday', 'Sunday'];
-  const needSortArrayNoExistArray = [
-    ['A', 'B', 'C'],
-    ['B', 'A'],
-    ['D', 'B', 'A', 'F'],
-  ];
-  const expectArrayNoExistArray = [
-    ['A', 'B', 'C'],
-    ['A', 'B'],
-    ['A', 'B', 'D', 'F'],
-  ];
-  //VD-990
-  const needSortTimeArrayNoExistArray = [
-    ['2011-01-02', '2011-02-31', '2011-01-01'],
-    ['2011-03-11', '2011-01-01'],
-    ['2011-02-01', '2012-01-01'],
-  ];
-  const expectTimeArrayNoExistArray = [
-    ['2011-01-01', '2011-01-02', '2011-02-31'],
-    ['2011-01-01', '2011-03-11'],
-    ['2011-02-01', '2012-01-01'],
-  ];
-  expect(sortAsExistArray(needSortArray, (item) => item.x, undefined, existArray)).toEqual(expectResult);
-  expect(sortAsExistArray(needSortStringArray, undefined, undefined, expectStringArrayResult)).toEqual(expectStringArrayResult);
-  expect(sortAsExistArray(needSortArrayNoExistArray)).toEqual(expectArrayNoExistArray);
-  expect(sortAsExistArray(needSortTimeArrayNoExistArray, undefined, (item, nextItem) => new Date(item).valueOf() - new Date(nextItem).valueOf())).toEqual(expectTimeArrayNoExistArray);
-});
-test('findNodeList', () => {
-  const container = document.createElement('div');
-  container.innerHTML = `
-		<div class='test'></div>
-		<div class='test'></div>
-		<div class='test book'>book</div>
-		<div class='test'></div>
-	`;
-  const items = container.childNodes;
-  expect(findNodeList(items, (item) => { var _a; return (_a = item.classList) === null || _a === void 0 ? void 0 : _a.contains('book'); })).toEqualHtml(`<div class='test book'>book</div>`);
-  expect(findNodeList(items, (item) => { var _a; return (_a = item.classList) === null || _a === void 0 ? void 0 : _a.contains('none'); })).toEqual(undefined);
-});

package/dist/collection/utils/test/breakpoint.test.js

@@ -1,37 +0,0 @@
-import { createCompleteResponsiveMap, getCurrentBreakpoint } from '../breakpoints';
-test('log as expected when call createCompleteResponsiveMap', () => {
-  const type = {
-    default: 'size-12',
-    L: 'size-24',
-  };
-  const expectResult = {
-    default: 'size-12',
-    S: 'size-12',
-    M: 'size-12',
-    L: 'size-24',
-    XL: 'size-24',
-  };
-  const result = createCompleteResponsiveMap(type);
-  expect(result).toEqual(expectResult);
-  expect(createCompleteResponsiveMap({ default: 'h1', S: '', M: 'h2' })).toEqual({
-    default: 'h1',
-    S: '',
-    M: 'h2',
-    L: 'h2',
-    XL: 'h2',
-  });
-  expect(createCompleteResponsiveMap({ default: 'h1', M: '', L: 'h2' })).toEqual({
-    default: 'h1',
-    S: 'h1',
-    M: '',
-    L: 'h2',
-    XL: 'h2',
-  });
-});
-test('log as expected when call getCurrentBreakpoint', () => {
-  Object.defineProperty(window, 'innerWidth', {
-    value: 150,
-  });
-  const result = getCurrentBreakpoint();
-  expect(result).toEqual('default');
-});

package/dist/collection/utils/test/component.test.js

@@ -1,59 +0,0 @@
-import { VegaFlex } from '../../components/vega-flex/vega-flex';
-import { isComponentLifecycleMethod, sanitizeVegaComponent } from '../component';
-import { LogUtility } from '../log';
-describe('sanitizeVegaComponent', () => {
-  it('sanitizeVegaComponent should catch external defined class on vega components and log an error', async () => {
-    spyOn(LogUtility, 'warn');
-    const vegaComponent = new VegaFlex();
-    vegaComponent['$attrs$'] = { class: 'verified-class-A verified-class-B' };
-    const hostElement = new HTMLElement();
-    Object.defineProperty(hostElement, 'classList', {
-      value: ['culprit-external-class', 'vega-flex-shrink', 'M:vega-flex-shrink-0'],
-    });
-    sanitizeVegaComponent(vegaComponent, hostElement);
-    expect(hostElement.dataset['verifiedClasses']).toEqual('hydrated verified-class-A verified-class-B');
-    expect(hostElement.classList).toEqual([
-      'culprit-external-class',
-      'vega-flex-shrink',
-      'M:vega-flex-shrink-0',
-    ]);
-    expect(LogUtility.warn).toHaveBeenCalledWith(`Found class(es) culprit-external-class added to component:`, expect.anything(), ' which is anti vega design pattern and we will forbid this behavior in the future release.', ' for more details, please refer to: https://heartlandpayments.github.io/Vega/?path=/docs/best-practice--page');
-  });
-  it('sanitizeVegaComponent should skip external classes added by Angular', async () => {
-    spyOn(LogUtility, 'warn');
-    const vegaComponent = new VegaFlex();
-    vegaComponent['$attrs$'] = { class: 'verified-class-A verified-class-B' };
-    const hostElement = new HTMLElement();
-    Object.defineProperty(hostElement, 'classList', { value: ['ng-dirty', 'ng-touched', 'ng-invalid'] });
-    sanitizeVegaComponent(vegaComponent, hostElement);
-    expect(hostElement.dataset['verifiedClasses']).toEqual('hydrated verified-class-A verified-class-B');
-    expect(hostElement.classList).toEqual(['ng-dirty', 'ng-touched', 'ng-invalid']);
-    expect(LogUtility.warn).toHaveBeenCalledTimes(0);
-  });
-  it('sanitizeVegaComponent should catch attribute of data-shrink="0" and log an warn', async () => {
-    spyOn(LogUtility, 'warn');
-    const vegaComponent = new VegaFlex();
-    vegaComponent['$attrs$'] = { class: 'verified-class-A verified-class-B' };
-    const hostElement = new HTMLElement();
-    const node = new HTMLElement();
-    hostElement.appendChild(node);
-    node.setAttribute('data-shrink', '0');
-    sanitizeVegaComponent(vegaComponent, hostElement);
-    expect(node.dataset['shrink']).toEqual('0');
-    expect(LogUtility.warn).toHaveBeenCalledWith(`Found attribute [data-shrink='0'] inside component:`, expect.anything(), ` which will be deprecated, please use classes of vega-flex-shrink, vega-flex-grow, vega-flex-shrink-0, vega-flex-grow-0, vega-flex-basis-0 instead.`);
-  });
-});
-describe('component', () => {
-  it('should return as expected when calling isComponentLifecycleMethod', () => {
-    expect(isComponentLifecycleMethod('connectedCallback')).toBeTruthy();
-    expect(isComponentLifecycleMethod('disconnectedCallback')).toBeTruthy();
-    expect(isComponentLifecycleMethod('componentWillRender')).toBeTruthy();
-    expect(isComponentLifecycleMethod('componentDidRender')).toBeTruthy();
-    expect(isComponentLifecycleMethod('componentWillLoad')).toBeTruthy();
-    expect(isComponentLifecycleMethod('componentDidLoad')).toBeTruthy();
-    expect(isComponentLifecycleMethod('componentWillUpdate')).toBeTruthy();
-    expect(isComponentLifecycleMethod('componentDidUpdate')).toBeTruthy();
-    expect(isComponentLifecycleMethod('render')).toBeTruthy();
-    expect(isComponentLifecycleMethod('testMethod')).toBeFalsy();
-  });
-});