@heartlandone/vega 2.79.0 → 2.80.0

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

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

@@ -1,104 +0,0 @@
-import { compareIsAfter, compareIsBefore, compareIsSameOrBefore, convert12HourTo24HourFormat, isDateStr, isTimeStr, pad, } from '../date';
-import { LogUtility } from '../log';
-describe('isDateStr', () => {
-  test('return result as expected when the input is a date string', () => {
-    expect(isDateStr('5/5/2022')).toBeTruthy();
-    expect(isDateStr('2022/5/5')).toBeTruthy();
-    expect(isDateStr('05/05/2022')).toBeTruthy();
-    expect(isDateStr('2022/05/05')).toBeTruthy();
-    expect(isDateStr('05-05-2022')).toBeTruthy();
-    expect(isDateStr('2022-05-05')).toBeTruthy();
-    expect(isDateStr('05.05.2022')).toBeTruthy();
-    expect(isDateStr('2022.05.05')).toBeTruthy();
-    expect(isDateStr('2022 05 05')).toBeTruthy();
-    expect(isDateStr('05 05 2022')).toBeTruthy();
-    expect(isDateStr('05/05')).toBeTruthy();
-  });
-  test('return result as expected when the input is not a date string', () => {
-    expect(isDateStr('')).toBeFalsy();
-    expect(isDateStr(' ')).toBeFalsy();
-    expect(isDateStr(null)).toBeFalsy();
-    expect(isDateStr(undefined)).toBeFalsy();
-    expect(isDateStr('11111111')).toBeFalsy();
-    expect(isDateStr('05/051/2022')).toBeFalsy();
-    expect(isDateStr('051/05/2022')).toBeFalsy();
-  });
-});
-describe('compareIsAfter', () => {
-  test('return true if first date is after than second date', () => {
-    expect(compareIsAfter(new Date('05/10/2022'), new Date('05/05/2022'))).toBeTruthy();
-  });
-  test('return false if first date is not after than second date', () => {
-    expect(compareIsAfter(new Date('05/05/2022'), new Date('05/10/2022'))).toBeFalsy();
-  });
-});
-describe('compareIsBefore', () => {
-  test('return true if first date is before than second date', () => {
-    expect(compareIsBefore(new Date('05/05/2022'), new Date('05/10/2022'))).toBeTruthy();
-  });
-  test('return false if first date is not before than second date', () => {
-    expect(compareIsBefore(new Date('05/10/2022'), new Date('05/05/2022'))).toBeFalsy();
-  });
-});
-describe('compareIsSameOrBefore', () => {
-  test('return true if first date is before or the same as second date', () => {
-    expect(compareIsSameOrBefore(new Date('05/05/2022'), new Date('05/05/2022'))).toBeTruthy();
-  });
-  test('return false if first date is after than second date', () => {
-    expect(compareIsSameOrBefore(new Date('05/05/2022'), new Date('05/01/2022'))).toBeFalsy();
-  });
-});
-describe('isTimeStr', () => {
-  test('return false if first date is after than second date', () => {
-    expect(isTimeStr('01:02', '24-hour')).toBeTruthy();
-    expect(isTimeStr('01:02 AM', '12-hour')).toBeTruthy();
-    expect(isTimeStr('01:02 PM', '12-hour')).toBeTruthy();
-  });
-  test('return result as expected when the input is not a time string', () => {
-    expect(isTimeStr('', '24-hour')).toBeFalsy();
-    expect(isTimeStr(' ', '24-hour')).toBeFalsy();
-    expect(isTimeStr(null, '24-hour')).toBeFalsy();
-    expect(isTimeStr(undefined, '24-hour')).toBeFalsy();
-    expect(isTimeStr('1111', '24-hour')).toBeFalsy();
-    expect(isTimeStr('1:02', '24-hour')).toBeFalsy();
-    expect(isTimeStr('1:2', '24-hour')).toBeFalsy();
-    expect(isTimeStr('01:2', '24-hour')).toBeFalsy();
-    expect(isTimeStr('24:01', '24-hour')).toBeFalsy();
-    expect(isTimeStr('22:67', '24-hour')).toBeFalsy();
-    expect(isTimeStr('2222', '12-hour')).toBeFalsy();
-    expect(isTimeStr('01:01', '12-hour')).toBeFalsy();
-    expect(isTimeStr('1:01 AM', '12-hour')).toBeFalsy();
-    expect(isTimeStr('01:1 PM', '12-hour')).toBeFalsy();
-    expect(isTimeStr('1:1 AM', '12-hour')).toBeFalsy();
-    expect(isTimeStr('01:01 AA', '12-hour')).toBeFalsy();
-  });
-});
-describe('pad', () => {
-  test('The length of return value should be 2', () => {
-    expect(pad(1)).toEqual('01');
-    expect(pad(0)).toEqual('00');
-    expect(pad(102)).toEqual('102');
-    expect(pad(26, 4, '20')).toEqual('2026');
-    expect(pad(2126, 4, '20')).toEqual('2126');
-  });
-  test('return value should log an error', () => {
-    spyOn(LogUtility, 'error');
-    pad(null);
-    expect(LogUtility.error).toBeCalledTimes(1);
-    expect(pad(undefined)).toEqual(undefined);
-    expect(LogUtility.error).toBeCalledTimes(2);
-  });
-});
-describe('convert12HourTo24HourFormat', () => {
-  test('should get correct result when call the method', () => {
-    expect(convert12HourTo24HourFormat('')).toEqual('');
-    expect(convert12HourTo24HourFormat('12:00')).toEqual('12:00');
-    expect(convert12HourTo24HourFormat('00:00')).toEqual('00:00');
-    expect(convert12HourTo24HourFormat('24:00')).toEqual('24:00');
-    expect(convert12HourTo24HourFormat('12:00 AM')).toEqual('00:00');
-    expect(convert12HourTo24HourFormat('01:01 AM')).toEqual('01:01');
-    expect(convert12HourTo24HourFormat('12:01 PM')).toEqual('12:01');
-    expect(convert12HourTo24HourFormat('01:01 PM')).toEqual('13:01');
-    expect(convert12HourTo24HourFormat('11:59 PM')).toEqual('23:59');
-  });
-});

package/dist/collection/utils/test/design-token.test.js

@@ -1,91 +0,0 @@
-import { formatAndValidBackgroundColor, formatAndValidBorder, formatAndValidBorderColor, formatAndValidBorderRadius, formatAndValidBreakpointSize, formatAndValidFlexBreakpoint, formatAndValidGap, formatAndValidPadding, formatAndValidShadow, formatAndValidTextColor, formatAndValidTypographyToken, } from '../design-token';
-import { LogUtility } from '../log';
-test('return padding as expected when with spacingTypeToken', () => {
-  const result = formatAndValidPadding('size-16');
-  expect(result).toEqual('v-p-size-16');
-});
-test('return warn as expected when without spacingTypeToken', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidPadding('16');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return shadow as expected when with shadowToken', () => {
-  const result = formatAndValidShadow('shadow-card');
-  expect(result).toEqual('v-shadow-card');
-});
-test('return as expected when without shadowToken', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidShadow('shadow-card-no-exist');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return as expected when set borderRadiusToken', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidBorderRadius('rounded-2');
-  expect(formatAndValidBorderRadius('rounded-2')).toEqual('v-rounded-2');
-});
-test('return warn as expected when without BorderRadiusToken', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidBorderRadius('3');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return BorderColor as expected when with BorderColorToken', () => {
-  const result = formatAndValidBorderColor('border-color-action');
-  expect(result).toEqual('v-border-color-action');
-});
-test('return warn as expected when without BorderColorToken', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidBorderColor('border-color');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return warn as expected when without BackgroundColor', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidBackgroundColor('bg-accent6');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return warn as expected when without TextColor', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidTextColor('danger-link');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return warn as expected when without BreakpointSize', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidBreakpointSize('small');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return number as expected when BreakpointSize set', () => {
-  spyOn(LogUtility, 'warn');
-  const breakpoint = formatAndValidBreakpointSize('M');
-  expect(breakpoint).toBeGreaterThan(0);
-});
-test('return warn as expected when with ValidGap', () => {
-  const result = formatAndValidGap('size-12');
-  expect(result).toEqual('v-gap-size-12');
-});
-test('return warn as expected when with inValidGap', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidGap('12');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return as expected when with valid TypographyToken', () => {
-  const result = formatAndValidTypographyToken('font-h1');
-  expect(result).toEqual('v-font-h1');
-});
-test('return warn as expected when with invalid TypographyToken', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidTypographyToken('font-div');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return as expected when with valid BorderToken', () => {
-  const result = formatAndValidBorder('border-secondary-btn');
-  expect(result).toEqual('v-border-secondary-btn');
-});
-test('return warn as expected when with invalid BorderToken', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidBorder('border-s');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});
-test('return warn as expected when without FlexBreakpoint', () => {
-  spyOn(LogUtility, 'warn');
-  formatAndValidFlexBreakpoint('small');
-  expect(LogUtility.warn).toBeCalledTimes(1);
-});

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

@@ -1,64 +0,0 @@
-import { executeAfterTransition, reflow, triggerRipple } from '../effect';
-test('add class as expected when call triggerRipple', () => {
-  const container = document.createElement('div');
-  container.innerHTML = `<button ripple="true"><div class="v-animation-ripple-mask"></div><div></div></button>`;
-  const element = container.querySelector('button');
-  element.addEventListener('click', (e) => {
-    triggerRipple(e);
-  });
-  element.click();
-  const result = element.getAttribute('class');
-  expect(result).toEqual('v-animation-ripple-container');
-});
-test('reflow can update the offsetHeight of the given element in dataset', () => {
-  const randomOffsetHeight = Math.floor(Math.random() * 42);
-  const div = document.createElement('div');
-  Object.assign(div, { offsetHeight: randomOffsetHeight });
-  reflow(div);
-  expect(div.dataset['vegaReflow']).toEqual(randomOffsetHeight.toString());
-});
-test('reflow can update the offsetHeight of the given element in dataset with invalid value', () => {
-  const div = document.createElement('div');
-  Object.assign(div, { offsetHeight: NaN });
-  reflow(div);
-  expect(div.dataset['vegaReflow']).toEqual(undefined);
-});
-test('executeAfterTransition should be working properly for listening transitionend event only once', () => {
-  const div = document.createElement('div');
-  const listener = jest.fn();
-  executeAfterTransition(listener, div, 1000);
-  div.dispatchEvent(new CustomEvent('transitionend'));
-  div.dispatchEvent(new CustomEvent('transitionend'));
-  expect(listener).toHaveBeenCalledTimes(1);
-});
-test('executeAfterTransition should be executed after timeout if no event received', () => {
-  jest.useFakeTimers();
-  jest.spyOn(window, 'setTimeout');
-  const div = document.createElement('div');
-  const listener = jest.fn();
-  executeAfterTransition(listener, div, 1000);
-  jest.runAllTimers();
-  expect(setTimeout).toHaveBeenCalledTimes(1);
-  expect(listener).toHaveBeenCalledTimes(1);
-});
-test('executeAfterTransition should be executed only once if transitionend event fired before timeout', () => {
-  jest.useFakeTimers();
-  jest.spyOn(window, 'setTimeout');
-  const div = document.createElement('div');
-  const listener = jest.fn();
-  executeAfterTransition(listener, div, 1000);
-  div.dispatchEvent(new CustomEvent('transitionend'));
-  jest.runAllTimers();
-  expect(setTimeout).toHaveBeenCalledTimes(1);
-  expect(listener).toHaveBeenCalledTimes(1);
-});
-test('executeAfterTransition should not call setTimeout if timeout value passed-in is 0', () => {
-  jest.useFakeTimers();
-  jest.spyOn(window, 'setTimeout');
-  const div = document.createElement('div');
-  const listener = jest.fn();
-  executeAfterTransition(listener, div, 0);
-  jest.runAllTimers();
-  expect(setTimeout).toHaveBeenCalledTimes(0);
-  expect(listener).toHaveBeenCalledTimes(0);
-});

package/dist/collection/utils/test/local-storage.test.js

@@ -1,38 +0,0 @@
-import { setItem, getItem } from '../local-storage';
-test('store string data when call setItem', () => {
-  setItem('key', 'value');
-  expect(getItem('key')).toEqual('value');
-});
-test('store data in other formats when call setItem', () => {
-  setItem('key-boolean', true);
-  expect(getItem('key-boolean')).toEqual(true);
-  setItem('key-number', 23);
-  expect(getItem('key-number')).toEqual(23);
-  setItem('key-array', ['1', '2', '3']);
-  expect(getItem('key-array')).toEqual(['1', '2', '3']);
-  setItem('key-array-number', [1, 2, 3]);
-  expect(getItem('key-array-number')).toEqual([1, 2, 3]);
-  setItem('test', JSON.stringify({ gap: 'size-2', flag: true, number: 2 }));
-  expect(getItem('test')).not.toEqual({ gap: 'size-2', flag: true, number: 2 });
-  expect(getItem('test')).toEqual('{"gap":"size-2","flag":true,"number":2}');
-});
-test('get data when call getItem', () => {
-  setItem('key', 'value');
-  setItem('111', '222');
-  expect(getItem('key')).toEqual('value');
-  expect(getItem('111')).toEqual('222');
-  expect(getItem('test')).toEqual(null);
-});
-test('get null when localStorage not defined', () => {
-  setItem('key', 'value');
-  Object.defineProperty(window, 'localStorage', {
-    get: () => {
-      return null;
-    },
-    set: () => {
-      return;
-    },
-    configurable: false,
-  });
-  expect(getItem('key')).toEqual(null);
-});

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

@@ -1,49 +0,0 @@
-import { LogUtility, setVegaLogLevel } from '../log';
-test('log as expected when global log level is off', () => {
-  setVegaLogLevel('off');
-  console.error = jest.fn();
-  console.warn = jest.fn();
-  console.log = jest.fn();
-  LogUtility.error('error');
-  LogUtility.warn('warn');
-  LogUtility.log('log');
-  expect(console.error).toBeCalledTimes(0);
-  expect(console.warn).toBeCalledTimes(0);
-  expect(console.log).toBeCalledTimes(0);
-});
-test('log as expected when global log level is error', () => {
-  setVegaLogLevel('error');
-  console.error = jest.fn();
-  console.warn = jest.fn();
-  console.log = jest.fn();
-  LogUtility.error('error');
-  LogUtility.warn('warn');
-  LogUtility.log('log');
-  expect(console.error).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', 'error');
-  expect(console.warn).toBeCalledTimes(0);
-  expect(console.log).toBeCalledTimes(0);
-});
-test('log as expected when global log level is warn', () => {
-  setVegaLogLevel('warn');
-  console.error = jest.fn();
-  console.warn = jest.fn();
-  console.log = jest.fn();
-  LogUtility.error('error');
-  LogUtility.warn('warn');
-  LogUtility.log('log');
-  expect(console.error).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', 'error');
-  expect(console.warn).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', 'warn');
-  expect(console.log).toBeCalledTimes(0);
-});
-test('log as expected when global log level is log', () => {
-  setVegaLogLevel('log');
-  console.error = jest.fn();
-  console.warn = jest.fn();
-  console.log = jest.fn();
-  LogUtility.error('error');
-  LogUtility.warn('warn');
-  LogUtility.log('log');
-  expect(console.error).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', 'error');
-  expect(console.warn).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', 'warn');
-  expect(console.log).toHaveBeenCalledWith('%c[Vega]', 'font-weight: bold', 'log');
-});

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

@@ -1,40 +0,0 @@
-import { generateUUID, isAsyncFunction, isObjectEmpty } from '../misc';
-test('generateUUID as expected', () => {
-  const dateNowStub = jest.fn(() => 1530518207007);
-  global.Date.now = dateNowStub;
-  const mockMath = Object.create(global.Math);
-  mockMath.random = () => 0.5;
-  global.Math = mockMath;
-  expect(generateUUID()).toBe('1530518212007');
-});
-test('isObjectEmpty as expected', () => {
-  expect(isObjectEmpty({})).toBe(true);
-  expect(isObjectEmpty(null)).toBe(true);
-  expect(isObjectEmpty({ item: 1 })).toBe(false);
-});
-test('isAsyncFunction as expected', () => {
-  const testFn1 = async () => {
-    return Promise.resolve(true);
-  };
-  const testFn2 = async () => {
-    return true;
-  };
-  const testFn3 = async () => {
-    return await Promise.resolve(true);
-  };
-  const testFn4 = () => {
-    return Promise.resolve(true);
-  };
-  const testFn5 = () => {
-    return true;
-  };
-  const testFn6 = () => {
-    return testFn1();
-  };
-  expect(isAsyncFunction(testFn1)).toBeTruthy();
-  expect(isAsyncFunction(testFn2)).toBeTruthy();
-  expect(isAsyncFunction(testFn3)).toBeTruthy();
-  expect(isAsyncFunction(testFn4)).toBeFalsy();
-  expect(isAsyncFunction(testFn5)).toBeFalsy();
-  expect(isAsyncFunction(testFn6)).toBeFalsy();
-});

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

@@ -1,18 +0,0 @@
-import { convertToNumber, countDecimals, normalizeNumberByRanger } from '../number';
-test('convertToNumber as expected when input is number', () => {
-  expect(convertToNumber(123)).toEqual(123);
-  expect(convertToNumber('DDL', 0)).toEqual(0);
-  expect(convertToNumber('DDL')).toEqual(NaN);
-});
-test('normalizeNumberByRanger as expected when input set large than max', () => {
-  const numberValue = normalizeNumberByRanger(5, 1, 4);
-  expect(numberValue).toEqual(4);
-});
-test('normalizeNumberByRanger as expected when input set less than min', () => {
-  const numberValue = normalizeNumberByRanger(5, 10, 40);
-  expect(numberValue).toEqual(10);
-});
-test('countDecimals as expected', () => {
-  expect(countDecimals(123)).toEqual(0);
-  expect(countDecimals(123.123)).toEqual(3);
-});

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

@@ -1,77 +0,0 @@
-import { cleanObject, deepEqual, getValueByPath } from '../object';
-const records = {
-  a: {
-    b: {
-      c: '111',
-    },
-  },
-  d: {
-    e: '222',
-  },
-  f: '333',
-};
-describe('valueUtils', () => {
-  test('should get value from the dataIndex', () => {
-    expect(getValueByPath(records, 'f')).toEqual('333');
-    expect(getValueByPath(records, 'a')).toEqual({ b: { c: '111' } });
-    expect(getValueByPath(records, 'd.e')).toEqual('222');
-    expect(getValueByPath(records, 'a.b.c')).toEqual('111');
-  });
-  test('should get undefined when the path is not exist in the record', () => {
-    expect(getValueByPath(records, 'test')).toEqual(undefined);
-    expect(getValueByPath(records, 'e')).toEqual(undefined);
-    expect(getValueByPath(records, 'a.')).toEqual(undefined);
-    expect(getValueByPath(records, 'a.b.c.d')).toEqual(undefined);
-    expect(getValueByPath(records, '.')).toEqual(undefined);
-    expect(getValueByPath(records, '')).toEqual(undefined);
-    expect(getValueByPath(records, undefined)).toEqual(undefined);
-    expect(getValueByPath(records, 'xx.xx')).toEqual(undefined);
-  });
-  test('should get correct value when the input is type of HTMLElement', () => {
-    class MockedComponent {
-    }
-    const component = new MockedComponent();
-    const host = document.createElement('div');
-    component['host'] = host;
-    component['host']['name'] = 1;
-    component['host']['info'] = { value: 3 };
-    expect(getValueByPath(component['host'], 'name')).toEqual(1);
-    expect(getValueByPath(component['host'], 'info.value')).toEqual(3);
-  });
-  test('should return properly when two params are compared', () => {
-    expect(deepEqual(1, 1)).toEqual(true);
-    expect(deepEqual(1, 2)).toEqual(false);
-    expect(deepEqual(0, undefined)).toEqual(false);
-    expect(deepEqual(undefined, null)).toEqual(false);
-    expect(deepEqual('test', 'test')).toEqual(true);
-    expect(deepEqual('test', 'test2')).toEqual(false);
-    expect(deepEqual({ apple: 'banana' }, { apple: 'banana' })).toEqual(true);
-    expect(deepEqual({ apple: 'banana' }, { apple: 'banana2' })).toEqual(false);
-  });
-});
-describe('cleanObject', () => {
-  test('should clean object by removing null and undefined values', () => {
-    const obj = {
-      a: 1,
-      b: null,
-      c: undefined,
-      d: 'test',
-    };
-    expect(cleanObject(obj)).toStrictEqual({ a: 1, d: 'test' });
-  });
-  test('should return an empty object when all values are null or undefined', () => {
-    const obj = {
-      a: null,
-      b: undefined,
-    };
-    expect(cleanObject(obj)).toStrictEqual({});
-  });
-  test('should return the same object when no values are null or undefined', () => {
-    const obj = {
-      a: 1,
-      b: 'test',
-      c: true,
-    };
-    expect(cleanObject(obj)).toStrictEqual(obj);
-  });
-});

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

@@ -1,40 +0,0 @@
-import { generatePagerItems, MINIMAL_PAGER_ITEM_COUNT } from '../pagination';
-describe('pagination', () => {
-  test(`should render full pagers when the total pages is less than pagersCount`, () => {
-    let pagersCount = 7;
-    expect(generatePagerItems(1, 1)).toEqual([1]);
-    expect(generatePagerItems(1, 6)).toEqual([1, 2, 3, 4, 5, 6]);
-    expect(generatePagerItems(1, 1, pagersCount)).toEqual([1]);
-    expect(generatePagerItems(1, 6, pagersCount)).toEqual([1, 2, 3, 4, 5, 6]);
-    expect(generatePagerItems(1, 7, pagersCount)).toEqual([1, 2, 3, 4, 5, 6, 7]);
-    expect(generatePagerItems(5, 7, pagersCount)).toEqual([1, 2, 3, 4, 5, 6, 7]);
-    expect(generatePagerItems(7, 7, pagersCount)).toEqual([1, 2, 3, 4, 5, 6, 7]);
-    pagersCount = 11;
-    expect(generatePagerItems(1, 7, pagersCount)).toEqual([1, 2, 3, 4, 5, 6, 7]);
-    expect(generatePagerItems(1, 11, pagersCount)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
-    expect(generatePagerItems(11, 11, pagersCount)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
-  });
-  test(`should render pagers with ellipsis when the total pages is more than pagersCount`, () => {
-    let pagersCount = 7;
-    expect(generatePagerItems(1, 10, pagersCount)).toEqual([1, 2, 3, 4, 5, '...', 10]);
-    expect(generatePagerItems(4, 10, pagersCount)).toEqual([1, 2, 3, 4, 5, '...', 10]);
-    expect(generatePagerItems(5, 10, pagersCount)).toEqual([1, '...', 4, 5, 6, '...', 10]);
-    expect(generatePagerItems(6, 10, pagersCount)).toEqual([1, '...', 5, 6, 7, '...', 10]);
-    expect(generatePagerItems(9, 10, pagersCount)).toEqual([1, '...', 6, 7, 8, 9, 10]);
-    pagersCount = 9;
-    expect(generatePagerItems(3, 100, pagersCount)).toEqual([1, 2, 3, 4, 5, 6, 7, '...', 100]);
-    expect(generatePagerItems(9, 100, pagersCount)).toEqual([1, '...', 7, 8, 9, 10, 11, '...', 100]);
-    expect(generatePagerItems(94, 100, pagersCount)).toEqual([1, '...', 92, 93, 94, 95, 96, '...', 100]);
-    expect(generatePagerItems(99, 100, pagersCount)).toEqual([1, '...', 94, 95, 96, 97, 98, 99, 100]);
-  });
-  test(`should throw an error when the pagerCount is less than ${MINIMAL_PAGER_ITEM_COUNT}`, () => {
-    expect(() => {
-      generatePagerItems(1, 10, 5);
-    }).toThrow(`Must allow at least ${MINIMAL_PAGER_ITEM_COUNT} pager items`);
-  });
-  test(`should throw an error when the pagerCount is not an odd number`, () => {
-    expect(() => {
-      generatePagerItems(1, 10, 8);
-    }).toThrow('Must allow odd number of pager items');
-  });
-});

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

@@ -1,29 +0,0 @@
-import { parseNumberToPixelString, parsePixelStringToNumber, parseToPixelString } from '../pixel';
-test('parsePixelStringToNumber', () => {
-  expect(parsePixelStringToNumber('100px')).toEqual(100);
-  expect(parsePixelStringToNumber('100')).toEqual(100);
-  expect(parsePixelStringToNumber('100em')).toEqual(0);
-  expect(parsePixelStringToNumber('100vw')).toEqual(0);
-  expect(parsePixelStringToNumber('calc(100% - 100px)')).toEqual(0);
-  expect(parsePixelStringToNumber('100%')).toEqual(0);
-  expect(parsePixelStringToNumber(100)).toEqual(100);
-  expect(parsePixelStringToNumber(null)).toEqual(0);
-});
-test('parseNumberToPixelString', () => {
-  expect(parseNumberToPixelString(100)).toEqual('100px');
-  expect(parseNumberToPixelString('100px')).toEqual('100px');
-  expect(parseNumberToPixelString('100')).toEqual('100');
-  expect(parseNumberToPixelString('100em')).toEqual('100em');
-  expect(parseNumberToPixelString('100vw')).toEqual('100vw');
-  expect(parseNumberToPixelString('100%')).toEqual('100%');
-  expect(parseNumberToPixelString('calc(100% - 100px)')).toEqual('calc(100% - 100px)');
-  expect(parseNumberToPixelString(null)).toEqual(null);
-});
-test('parseToPixelString', () => {
-  expect(parseToPixelString(100)).toEqual('100px');
-  expect(parseToPixelString('100px')).toEqual('100px');
-  expect(parseToPixelString('100vw')).toEqual('100vw');
-  expect(parseToPixelString('100%')).toEqual('100%');
-  expect(parseToPixelString('calc(100% - 100px)')).toEqual('calc(100% - 100px)');
-  expect(parseToPixelString('size-12')).toEqual('12px');
-});

package/dist/collection/utils/test/safe-document.test.js

@@ -1,13 +0,0 @@
-import { tryGetDocument } from '../try-get-document';
-describe('tryGetDocument', () => {
-  it('should be defined if document is available', () => {
-    expect(typeof document).toBe('object');
-    expect(tryGetDocument()).toBe(document);
-  });
-  it('should be undefined if document is not available', () => {
-    const originalDocument = globalThis.document;
-    delete globalThis.document;
-    expect(tryGetDocument()).toBeUndefined();
-    globalThis.document = originalDocument;
-  });
-});