@globalpayments/vega 2.19.0 → 2.20.1

package/dist/collection/helpers/chart/test/drawers/legendDrawer.test.js

@@ -1,94 +0,0 @@
-import { LegendDrawer } from '../../drawers/legendDrawer';
-import { SVGRenderer } from '../../renderers/svgRenderer';
-import { SVGInteractor } from '../../interactors/svgInteractor';
-describe('legend drawer', () => {
-  it('should call renderer function when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawLegend = mockFn;
-    const legendOptions = {
-      position: { x: 0, y: 0 },
-      data: ['Test'],
-      colors: ['bg-accent1-primary'],
-      width: 200,
-      height: 150,
-    };
-    const legendDrawer = new LegendDrawer(mockRenderer, mockInteractor, {
-      renderOptions: legendOptions,
-    });
-    legendDrawer.execute();
-    expect(mockFn).toBeCalledWith(legendOptions.position, legendOptions.data[0], '#73E6DC', 'font-family:"Inter", sans-serif;font-size:12px;font-weight:400;line-height:16px;letter-spacing:0px');
-  });
-  it('should not call renderer function when run the execute function and the legend is empty', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawLegend = mockFn;
-    const legendOptions = {
-      position: { x: 0, y: 0 },
-      data: undefined,
-      colors: ['bg-accent1-primary'],
-      width: 200,
-      height: 150,
-    };
-    const legendDrawer = new LegendDrawer(mockRenderer, mockInteractor, {
-      renderOptions: legendOptions,
-    });
-    legendDrawer.execute();
-    expect(mockFn).toBeCalledTimes(0);
-  });
-  it('should return the correct value when call the getChartLegendOptions function', () => {
-    const expectedOptions = {
-      position: {
-        x: 20,
-        y: 20,
-      },
-      legends: [{ field: 'Test', color: '#73E6DC', icon: '' }],
-    };
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const legendDrawer = new LegendDrawer(mockRenderer, mockInteractor, {
-      renderOptions: { data: [], width: 200, height: 150 },
-    });
-    const resultOptions = legendDrawer['getChartLegendOptions'](['Test'], null, {
-      x: 20,
-      y: 20,
-    });
-    expect(resultOptions).toEqual(expectedOptions);
-  });
-  it('should return expect when call the getChartLegendOptions function and position is null', () => {
-    const expectedOptions = {
-      position: {
-        x: 10,
-        y: 0,
-      },
-      legends: [{ field: 'Test', color: '#73E6DC', icon: '' }],
-    };
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockRenderer = new SVGRenderer(mockContext);
-    const legendDrawer = new LegendDrawer(mockRenderer, mockInteractor, {
-      renderOptions: { data: [], width: 200, height: 150 },
-    });
-    const resultOptions = legendDrawer['getChartLegendOptions'](['Test'], null);
-    expect(resultOptions).toEqual(expectedOptions);
-  });
-  it('should return the default position when call the getLegendPosition', () => {
-    const expectPosition = {
-      x: 0,
-      y: 0,
-    };
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const legendDrawer = new LegendDrawer(mockRenderer, mockInteractor, {
-      renderOptions: { data: [], width: 200, height: 150 },
-    });
-    const position = legendDrawer['getLegendPosition']({ x: 0, y: 0 }, 0, 10);
-    expect(position).toEqual(expectPosition);
-  });
-});

package/dist/collection/helpers/chart/test/drawers/lineDrawer.test.js

@@ -1,25 +0,0 @@
-import { LineDrawer } from '../../drawers/lineDrawer';
-import { SVGRenderer } from '../../renderers/svgRenderer';
-import { SVGInteractor } from '../../interactors/svgInteractor';
-describe('line drawer', () => {
-  it('should call renderer function when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawLine = mockFn;
-    const from = {
-      x: 0,
-      y: 0,
-    };
-    const to = {
-      x: 100,
-      y: 100,
-    };
-    const lineDrawer = new LineDrawer(mockRenderer, mockInteractor, {
-      renderOptions: { from, to },
-    });
-    lineDrawer.execute();
-    expect(mockFn).toBeCalledWith(from, to, '#F0F3F7');
-  });
-});

package/dist/collection/helpers/chart/test/drawers/pathDrawer.test.js

@@ -1,21 +0,0 @@
-import { PathDrawer } from '../../drawers/pathDrawer';
-import { SVGRenderer } from '../../renderers/svgRenderer';
-import { SVGInteractor } from '../../interactors/svgInteractor';
-describe('path drawer', () => {
-  it('should call renderer function when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawLinePath = mockFn;
-    const pathOptions = {
-      positions: [{ x: 10, y: 20 }],
-      colors: ['bg-accent1-primary'],
-    };
-    const lineDrawer = new PathDrawer(mockRenderer, mockInteractor, {
-      renderOptions: pathOptions,
-    });
-    lineDrawer.execute();
-    expect(mockFn).toBeCalledWith(pathOptions.positions, '#73E6DC');
-  });
-});

package/dist/collection/helpers/chart/test/drawers/rectDrawer.test.js

@@ -1,78 +0,0 @@
-import { RectDrawer } from '../../drawers/rectDrawer';
-import { SVGRenderer } from '../../renderers/svgRenderer';
-import { SVGInteractor } from '../../interactors/svgInteractor';
-describe('react drawer', () => {
-  it('should call renderer function when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawRect = mockFn;
-    const xScale = jest.fn();
-    xScale['bandwidth'] = jest.fn();
-    const options = {
-      dataSource: [
-        { x: 'Mon', y: 1167 },
-        { x: 'Tue', y: 1492 },
-        { x: 'Wed', y: 1782 },
-        { x: 'Thu', y: 1253 },
-        { x: 'Fri', y: 1702 },
-        { x: 'Sat', y: 1288 },
-        { x: 'Sun', y: 1015 },
-      ],
-      xScale: xScale,
-      yScale: jest.fn(),
-      colors: ['bg-accent1-primary'],
-    };
-    const drawer = new RectDrawer(mockRenderer, mockInteractor, {
-      renderOptions: options,
-    });
-    drawer.execute();
-    expect(mockFn).toBeCalledTimes(7);
-  });
-  it('should not call renderer function when run the execute function and the data source is empty', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawRect = mockFn;
-    const xScale = jest.fn();
-    xScale['bandwidth'] = jest.fn();
-    const options = {
-      dataSource: undefined,
-      xScale: xScale,
-      yScale: jest.fn(),
-      colors: ['bg-accent1-primary'],
-    };
-    const drawer = new RectDrawer(mockRenderer, mockInteractor, {
-      renderOptions: options,
-    });
-    drawer.execute();
-    expect(mockFn).toBeCalledTimes(0);
-  });
-  it('should call renderer function with the expect parameter when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawRect = mockFn;
-    const xScale = jest.fn().mockReturnValue(0);
-    xScale['bandwidth'] = undefined;
-    const options = {
-      dataSource: [{ x: 'Mon', y: 1167 }],
-      xScale: xScale,
-      yScale: jest.fn().mockReturnValue(0),
-      colors: ['bg-accent1-primary'],
-    };
-    const drawer = new RectDrawer(mockRenderer, mockInteractor, {
-      renderOptions: options,
-    });
-    drawer.execute();
-    expect(mockFn).toBeCalledWith({ x: 0, y: 0 }, 5, 0, '#73E6DC');
-    const horizontalDrawer = new RectDrawer(mockRenderer, mockInteractor, {
-      renderOptions: Object.assign(Object.assign({}, options), { direction: 'horizontal' }),
-    });
-    horizontalDrawer.execute();
-    expect(mockFn).toBeCalledWith({ x: 0, y: 0 }, 5, 0, '#73E6DC');
-  });
-});

package/dist/collection/helpers/chart/test/drawers/textDrawer.test.js

@@ -1,25 +0,0 @@
-import { SVGRenderer } from '../../renderers/svgRenderer';
-import { TextDrawer } from '../../drawers/textDrawer';
-import { SVGInteractor } from '../../interactors/svgInteractor';
-describe('text drawer', () => {
-  it('should call renderer function when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawText = mockFn;
-    const textOptions = [
-      {
-        position: { x: 0, y: 0 },
-        styleToken: 'v-font-footnote2-short',
-        text: 'Test',
-        textAnchor: 'end',
-      },
-    ];
-    const drawer = new TextDrawer(mockRenderer, mockInteractor, {
-      renderOptions: textOptions,
-    });
-    drawer.execute();
-    expect(mockFn).toBeCalledWith(textOptions[0].position, textOptions[0].text, drawer.getStyleTextFromToken(textOptions[0].styleToken), textOptions[0].textAnchor, undefined);
-  });
-});

package/dist/collection/helpers/chart/test/drawers/xAxisDrawer.test.js

@@ -1,38 +0,0 @@
-import { XAxisDrawer } from '../../drawers/xAxisDrawer';
-import { SVGRenderer } from '../../renderers/svgRenderer';
-import { SVGInteractor } from '../../interactors/svgInteractor';
-describe('x axis drawer', () => {
-  it('should call renderer function when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawXAxis = mockFn;
-    const options = {
-      start: {
-        x: 0,
-        y: 15,
-      },
-      end: {
-        x: 20,
-        y: 15,
-      },
-      tickSize: 4,
-      scale: null,
-      width: 300,
-      height: 200,
-    };
-    const drawer = new XAxisDrawer(mockRenderer, mockInteractor, {
-      renderOptions: options,
-    });
-    drawer.execute();
-    expect(mockFn).toBeCalledWith({
-      end: { x: 20, y: 15 },
-      scale: null,
-      start: { x: 0, y: 15 },
-      tickSize: 4,
-      width: 300,
-      height: 200,
-    }, '#F0F3F7', 'font-family:"Inter", sans-serif;font-size:14px;font-weight:400;line-height:18px;color:rgba(107, 116, 125, 1);');
-  });
-});

package/dist/collection/helpers/chart/test/drawers/yAxisDrawer.test.js

@@ -1,44 +0,0 @@
-import { YAxisDrawer } from '../../drawers/yAxisDrawer';
-import { SVGRenderer } from '../../renderers/svgRenderer';
-import { SVGInteractor } from '../../interactors/svgInteractor';
-describe('y axis drawer', () => {
-  it('should call renderer function when run the execute function', () => {
-    const mockContext = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const mockRenderer = new SVGRenderer(mockContext);
-    const mockInteractor = new SVGInteractor(mockContext);
-    const mockFn = jest.fn();
-    mockRenderer.drawYAxis = mockFn;
-    const options = {
-      start: {
-        x: 0,
-        y: 0,
-      },
-      end: {
-        x: 0,
-        y: 15,
-      },
-      tickSize: 4,
-      scale: null,
-      width: 300,
-      height: 200,
-    };
-    const drawer = new YAxisDrawer(mockRenderer, mockInteractor, {
-      renderOptions: options,
-    });
-    drawer.execute();
-    expect(mockFn).toBeCalledWith({
-      start: {
-        x: 0,
-        y: 0,
-      },
-      end: {
-        x: 0,
-        y: 15,
-      },
-      tickSize: 4,
-      scale: null,
-      width: 300,
-      height: 200,
-    }, '#F0F3F7', 'font-family:"Inter", sans-serif;font-size:14px;font-weight:400;line-height:18px;color:rgba(107, 116, 125, 1);');
-  });
-});

package/dist/collection/helpers/chart/test/graphContextFactory.test.js

@@ -1,17 +0,0 @@
-import { GraphContextFactory } from '../graphContextFactory';
-test('GraphContextFactory svg', () => {
-  let context = GraphContextFactory.get('svg', document.body);
-  expect(context.tagName).toEqual('svg');
-  context.id = 'svg';
-  context = GraphContextFactory.get('svg', document.body);
-  expect(context.tagName).toEqual('svg');
-  expect(context.id).toEqual('svg');
-});
-test('GraphContextFactory canvas', () => {
-  let context = GraphContextFactory.get('canvas', document.body);
-  expect(context.tagName).toEqual('CANVAS');
-  context.id = 'canvas';
-  context = GraphContextFactory.get('canvas', document.body);
-  expect(context.tagName).toEqual('CANVAS');
-  expect(context.id).toEqual('canvas');
-});

package/dist/collection/helpers/chart/test/inputProcessors/formatTimePositionsInputProcessor.test.js

@@ -1,62 +0,0 @@
-import { FormatTimePositionsInputProcessor } from '../../inputProcessors/formatTimePositionsInputProcessor';
-import { timeParse as d3TimeParse } from 'd3';
-describe('formatTimePositionsInputProcessor', () => {
-  const formatTimePositionsInputProcessor = new FormatTimePositionsInputProcessor();
-  it('should return expect result when call the process function ', () => {
-    const numData = {
-      dataSource: [
-        { x: 1, y: 10 },
-        { x: 10, y: 20 },
-      ],
-      container: null,
-    };
-    const dateData = {
-      dataSource: [
-        { x: '2011-01-01', y: 10 },
-        { x: '2022-01-01', y: 20 },
-      ],
-      container: null,
-      xAxis: {
-        type: 'time',
-      },
-    };
-    const formatData = [
-      { x: d3TimeParse('%Y-%m-%d')('2011-01-01'), y: 10 },
-      { x: d3TimeParse('%Y-%m-%d')('2022-01-01'), y: 20 },
-    ];
-    expect(formatTimePositionsInputProcessor.process(numData)).toEqual(numData);
-    expect(formatTimePositionsInputProcessor.process(dateData).dataSource).toEqual(formatData);
-  });
-  it('should format date string array when call the formatTimePositionArray function', () => {
-    const dateStringArray = [{ x: '2021-01-01', y: 10 }];
-    const resultArray = [
-      { x: d3TimeParse('%Y-%m-%d')(dateStringArray[0].x), y: dateStringArray[0].y },
-    ];
-    expect(formatTimePositionsInputProcessor['formatTimePositionArray'](dateStringArray)).toEqual(resultArray);
-  });
-  it('should format date string array array when call the formatTimePositionArray function', () => {
-    const dateStringArray = [
-      [{ x: '2021-01-01', y: 10 }],
-      [
-        { x: '2021-01-01', y: 10 },
-        { x: '2022-01-01', y: 20 },
-      ],
-    ];
-    const resultArray = [
-      [{ x: d3TimeParse('%Y-%m-%d')('2021-01-01'), y: 10 }],
-      [
-        { x: d3TimeParse('%Y-%m-%d')('2021-01-01'), y: 10 },
-        { x: d3TimeParse('%Y-%m-%d')('2022-01-01'), y: 20 },
-      ],
-    ];
-    expect(formatTimePositionsInputProcessor['formatTimePositionArray'](dateStringArray)).toEqual(resultArray);
-  });
-  it('should not format Date type when call the formatTimePositionArray function', () => {
-    const formatterArray = [
-      { x: d3TimeParse('%Y-%m-%d')('2021-01-01'), y: 10 },
-      { x: d3TimeParse('%Y-%m-%d')('2022-01-01'), y: 20 },
-    ];
-    const resultArr = formatTimePositionsInputProcessor['formatTimePositionArray'].call(formatTimePositionsInputProcessor, formatterArray);
-    expect(resultArr).toEqual(formatterArray);
-  });
-});

package/dist/collection/helpers/chart/test/inputProcessors/horizontalXAxisInputProcessor.test.js

@@ -1,45 +0,0 @@
-import { HorizontalXAxisInputProcessor } from '../../inputProcessors/horizontalXAxisInputProcessor';
-describe('HorizontalXAxisInputProcessor', () => {
-  const horizontalXAxisInputProcessor = new HorizontalXAxisInputProcessor();
-  const layout = {
-    innerHeight: 300,
-    innerWidth: 500,
-    top: 0,
-    left: 0,
-    right: 0,
-    bottom: 0,
-    width: 500,
-    height: 300,
-  };
-  it('should return expect result when call the getScale function', () => {
-    const numberData = [
-      { x: 1, y: 2 },
-      { x: 10, y: 20 },
-      { x: 11, y: 10 },
-    ];
-    const width = 200;
-    expect(horizontalXAxisInputProcessor['getScale'](numberData, [0, width], 4).scale.range()).toEqual([
-      0,
-      width,
-    ]);
-    expect(horizontalXAxisInputProcessor['getScale'](numberData, [0, width], 4).scale.domain()[0]).toEqual(0);
-  });
-  it('should return expect result when call the process function', () => {
-    const numberData = [
-      { x: 1, y: 2 },
-      { x: 11, y: 20 },
-      { x: 10, y: 10 },
-    ];
-    const input = {
-      dataSource: numberData,
-      container: document.body,
-      yAxis: {
-        labelFormatter: jest.fn(),
-      },
-    };
-    const output = horizontalXAxisInputProcessor.process(input, layout);
-    expect(output.start).toEqual({ x: 0, y: layout.innerHeight });
-    expect(output.end).toEqual({ x: layout.innerWidth, y: layout.innerHeight });
-    expect(output.direction).toEqual('horizontal');
-  });
-});

package/dist/collection/helpers/chart/test/inputProcessors/horizontalYAxisInputProcessor.test.js

@@ -1,80 +0,0 @@
-import { HorizontalYAxisInputProcessor } from '../../inputProcessors/horizontalYAxisInputProcessor';
-describe('scaleGenerator', () => {
-  const horizontalYAxisInputProcessor = new HorizontalYAxisInputProcessor();
-  const layout = {
-    innerHeight: 300,
-    innerWidth: 500,
-    top: 0,
-    left: 0,
-    right: 0,
-    bottom: 0,
-    width: 500,
-    height: 300,
-  };
-  it('should return expect result when call the getScale function', () => {
-    const numberData = [
-      { x: 1, y: 2 },
-      { x: 10, y: 20 },
-      { x: 11, y: 20 },
-    ];
-    const dateData = [
-      { x: new Date('2023-01-01'), y: 2 },
-      { x: new Date('2021-01-01'), y: 20 },
-      { x: new Date('2021-10-01'), y: 20 },
-    ];
-    const stringData = [
-      { x: 'A', y: 2 },
-      { x: 'B', y: 20 },
-      { x: 'C', y: 20 },
-    ];
-    const stringDataNeedSort = [
-      { x: 'C', y: 2 },
-      { x: 'C', y: 2 },
-      { x: 'D', y: 20 },
-      { x: 'A', y: 20 },
-      { x: 'B', y: 20 },
-    ];
-    const width = 200;
-    expect(horizontalYAxisInputProcessor['getScale'](numberData, width, 'value').domain()).toEqual([
-      numberData[0].x,
-      numberData[2].x,
-    ]);
-    expect(horizontalYAxisInputProcessor['getScale'](dateData, width, 'time', 1).domain()).toEqual([
-      dateData[1].x,
-      dateData[0].x,
-    ]);
-    expect(horizontalYAxisInputProcessor['getScale'](stringData, width, 'category').domain()).toEqual(stringData.map((item) => item.x));
-    expect(horizontalYAxisInputProcessor['getScale'](stringDataNeedSort, width, 'category', 1, (item, nextItem) => 'ABCD'.indexOf(item) - 'ABCD'.indexOf(nextItem)).domain()).toEqual(['A', 'B', 'C', 'D']);
-  });
-  it('should return expect result when call the process function', () => {
-    const numberData = [
-      { x: 1, y: 2 },
-      { x: 11, y: 20 },
-      { x: 10, y: 10 },
-    ];
-    const stringData = [
-      { x: 'A', y: 1 },
-      { x: 'B', y: 2 },
-      { x: 'C', y: 3 },
-    ];
-    const input = {
-      dataSource: numberData,
-      container: document.createElement('vega-line-chart'),
-    };
-    const testFunction = () => {
-      horizontalYAxisInputProcessor.process(input, layout);
-    };
-    expect(testFunction).not.toThrowError();
-    const mockSorter = jest.fn().mockReturnValue(0);
-    horizontalYAxisInputProcessor.process({
-      dataSource: stringData,
-      container: input.container,
-      xAxis: {
-        type: 'category',
-        sorter: mockSorter,
-        labelFormatter: jest.fn(),
-      },
-    }, layout);
-    expect(mockSorter).toHaveBeenCalled();
-  });
-});

package/dist/collection/helpers/chart/test/inputProcessors/layoutInputProcessor.test.js

@@ -1,40 +0,0 @@
-import { LayoutInputProcessor } from '../../inputProcessors/layoutInputProcessor';
-test('LayoutInputProcessor should use default layout when input layout not defined', () => {
-  const layoutInputProcessor = new LayoutInputProcessor();
-  const container = document.createElement('div');
-  container.style.display = 'none';
-  const input = {
-    container,
-    layout: null,
-  };
-  const expectResult = {
-    width: 0,
-    height: 0,
-    innerWidth: 0,
-    innerHeight: 0,
-    top: 30,
-    left: 30,
-    right: 30,
-    bottom: 30,
-  };
-  const inputNoMargin = {
-    container,
-    layout: {
-      width: 300,
-      height: 200,
-      margin: null,
-    },
-  };
-  const expectResultNoMargin = {
-    width: 300,
-    height: 200,
-    innerWidth: 240,
-    innerHeight: 140,
-    top: 30,
-    left: 30,
-    right: 30,
-    bottom: 30,
-  };
-  expect(layoutInputProcessor.process(input)).toEqual(expectResult);
-  expect(layoutInputProcessor.process(inputNoMargin)).toEqual(expectResultNoMargin);
-});

package/dist/collection/helpers/chart/test/inputProcessors/linePathInputProcessor.test.js

@@ -1,16 +0,0 @@
-import { LinePathInputProcessor } from '../../inputProcessors/linePathInputProcessor';
-describe('linePathInputProcessor', () => {
-  const linePathInputProcessor = new LinePathInputProcessor();
-  it('should return expect result when call the getPathPositions function using array', () => {
-    const mockScale = ((num) => num + 1);
-    const dateNumArray = [{ x: 1, y: 10 }];
-    const resultArray = [[{ x: 2, y: 11 }]];
-    expect(linePathInputProcessor['getPathPositions'](dateNumArray, mockScale, mockScale)).toEqual(resultArray);
-  });
-  it('should return expect result when call the getPathPositions function using array array', () => {
-    const mockScale = ((num) => num + 1);
-    const dateNumArray = [[{ x: 1, y: 10 }], [{ x: 10, y: 20 }]];
-    const resultArray = [[{ x: 2, y: 11 }], [{ x: 11, y: 21 }]];
-    expect(linePathInputProcessor['getPathPositions'](dateNumArray, mockScale, mockScale)).toEqual(resultArray);
-  });
-});

package/dist/collection/helpers/chart/test/inputProcessors/pieChartFilterInputProcessor.test.js

@@ -1,20 +0,0 @@
-import { PieChartFilterInputProcessor } from '../../inputProcessors/pieChartFilterInputProcessor';
-describe('pieChartFilterInputProcessor', () => {
-  const pieChartFilterInputProcessor = new PieChartFilterInputProcessor();
-  it('should get expect result when filter the empty item', () => {
-    const data = {
-      dataSource: [
-        { name: 'A', value: 10 },
-        { name: null, value: 20 },
-        { name: '0', value: null },
-        { name: 'B', value: 0 },
-      ],
-      container: null,
-    };
-    const expectResult = {
-      dataSource: [{ name: 'A', value: 10 }],
-      container: null,
-    };
-    expect(pieChartFilterInputProcessor.process(data)).toEqual(expectResult);
-  });
-});

package/dist/collection/helpers/chart/test/inputProcessors/pieChartRadiusInputProcessor.test.js

@@ -1,48 +0,0 @@
-import { PieChartRadiusInputProcessor, } from '../../inputProcessors/pieChartRadiusInputProcessor';
-describe('pieChartRadiusInputProcessor', () => {
-  const pieChartRadiusInputProcessor = new PieChartRadiusInputProcessor();
-  it('should get expect result when the type is pie', () => {
-    const data = {
-      dataSource: [],
-      container: null,
-    };
-    const layout = {
-      innerWidth: 200,
-      innerHeight: 100,
-    };
-    const expectResult = {
-      center: {
-        x: 100,
-        y: 50,
-      },
-      radius: 50,
-      innerRadius: 0,
-    };
-    expect(pieChartRadiusInputProcessor.process(data, layout)).toEqual(expectResult);
-    expect(pieChartRadiusInputProcessor.process(Object.assign(Object.assign({}, data), { donutRadius: 0.5 }), layout)).toEqual(expectResult);
-  });
-  it('should get expect result when the type is donut', () => {
-    const data = {
-      dataSource: [],
-      container: null,
-      type: 'Donut',
-      donutRadius: 0.5,
-    };
-    const layout = {
-      innerWidth: 200,
-      innerHeight: 100,
-    };
-    const expectResult = {
-      center: {
-        x: 100,
-        y: 50,
-      },
-      radius: 50,
-      innerRadius: 25,
-    };
-    expect(pieChartRadiusInputProcessor.process(data, layout)).toEqual(expectResult);
-    expect(pieChartRadiusInputProcessor.process(Object.assign(Object.assign({}, data), { donutRadius: 1 }), layout)).toEqual(Object.assign(Object.assign({}, expectResult), { innerRadius: 45 }));
-    expect(pieChartRadiusInputProcessor.process(Object.assign(Object.assign({}, data), { donutRadius: -1 }), layout)).toEqual(Object.assign(Object.assign({}, expectResult), { innerRadius: 30 }));
-    expect(pieChartRadiusInputProcessor.process(Object.assign(Object.assign({}, data), { donutRadius: 0.8 }), layout)).toEqual(Object.assign(Object.assign({}, expectResult), { innerRadius: 40 }));
-  });
-});