@heartlandone/vega 2.79.0 → 2.80.0

package/dist/collection/helpers/chart/test/drawers/rect-drawer.test.js

@@ -1,78 +0,0 @@
-import { RectDrawer } from '../../drawers/rect-drawer';
-import { SVGRenderer } from '../../renderers/svg-renderer';
-import { SVGInteractor } from '../../interactors/svg-interactor';
-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/text-drawer.test.js

@@ -1,25 +0,0 @@
-import { SVGRenderer } from '../../renderers/svg-renderer';
-import { TextDrawer } from '../../drawers/text-drawer';
-import { SVGInteractor } from '../../interactors/svg-interactor';
-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/x-axis-drawer.test.js

@@ -1,38 +0,0 @@
-import { XAxisDrawer } from '../../drawers/x-axis-drawer';
-import { SVGRenderer } from '../../renderers/svg-renderer';
-import { SVGInteractor } from '../../interactors/svg-interactor';
-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/y-axis-drawer.test.js

@@ -1,44 +0,0 @@
-import { YAxisDrawer } from '../../drawers/y-axis-drawer';
-import { SVGRenderer } from '../../renderers/svg-renderer';
-import { SVGInteractor } from '../../interactors/svg-interactor';
-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/graph-context-factory.test.js

@@ -1,17 +0,0 @@
-import { GraphContextFactory } from '../graph-context-factory';
-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/input-processors/format-time-positions-input-processor.test.js

@@ -1,62 +0,0 @@
-import { FormatTimePositionsInputProcessor } from '../../input-processors/format-time-positions-input-processor';
-import { timeParse as d3TimeParse } from '../../../../polyfill/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/input-processors/horizontal-x-axis-input-processor.test.js

@@ -1,45 +0,0 @@
-import { HorizontalXAxisInputProcessor } from '../../input-processors/horizontal-x-axis-input-processor';
-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/input-processors/horizontal-y-axis-input-processor.test.js

@@ -1,80 +0,0 @@
-import { HorizontalYAxisInputProcessor } from '../../input-processors/horizontal-y-axis-input-processor';
-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/input-processors/layout-input-processor.test.js

@@ -1,40 +0,0 @@
-import { LayoutInputProcessor } from '../../input-processors/layout-input-processor';
-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/input-processors/line-path-input-processor.test.js

@@ -1,16 +0,0 @@
-import { LinePathInputProcessor } from '../../input-processors/line-path-input-processor';
-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/input-processors/pie-chart-filter-input-processor.test.js

@@ -1,20 +0,0 @@
-import { PieChartFilterInputProcessor } from '../../input-processors/pie-chart-filter-input-processor';
-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/input-processors/pie-chart-radius-input-processor.test.js

@@ -1,48 +0,0 @@
-import { PieChartRadiusInputProcessor, } from '../../input-processors/pie-chart-radius-input-processor';
-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 }));
-  });
-});

package/dist/collection/helpers/chart/test/input-processors/sort-positions-input-processor.test.js

@@ -1,53 +0,0 @@
-import { SortPositionsInputProcessor } from '../../input-processors/sort-positions-input-processor';
-import { timeParse as d3TimeParse } from '../../../../polyfill/d3';
-describe('sortPositionsInputProcessor', () => {
-  const sortPositionsInputProcessor = new SortPositionsInputProcessor();
-  it('should return expect result when call the process function ', () => {
-    const positionArray = [
-      { x: 1, y: 10 },
-      { x: 10, y: 20 },
-      { x: 5, y: 11 },
-    ];
-    const numData = {
-      dataSource: [...positionArray],
-      container: null,
-    };
-    const numDataArray = {
-      dataSource: [[...positionArray]],
-      container: null,
-    };
-    const dateArray = [
-      { x: d3TimeParse('%Y-%m-%d')('2022-01-01'), y: 20 },
-      { x: d3TimeParse('%Y-%m-%d')('2011-01-01'), y: 10 },
-    ];
-    const dateData = {
-      dataSource: [...dateArray],
-      container: null,
-      xAxis: {
-        type: 'time',
-      },
-    };
-    const dateDataArray = {
-      dataSource: [[...dateArray]],
-      container: null,
-      xAxis: {
-        type: 'time',
-      },
-    };
-    expect(sortPositionsInputProcessor.process(numData).dataSource).toEqual([
-      positionArray[0],
-      positionArray[2],
-      positionArray[1],
-    ]);
-    expect(sortPositionsInputProcessor.process(numDataArray).dataSource).toEqual([
-      [positionArray[0], positionArray[2], positionArray[1]],
-    ]);
-    expect(sortPositionsInputProcessor.process(dateData).dataSource).toEqual([
-      dateArray[1],
-      dateArray[0],
-    ]);
-    expect(sortPositionsInputProcessor.process(dateDataArray).dataSource).toEqual([
-      [dateArray[1], dateArray[0]],
-    ]);
-  });
-});

package/dist/collection/helpers/chart/test/input-processors/x-axis-input-processor.test.js

@@ -1,78 +0,0 @@
-import { XAxisInputProcessor } from '../../input-processors/x-axis-input-processor';
-describe('scaleGenerator', () => {
-  const xAxisInputProcessor = new XAxisInputProcessor();
-  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(xAxisInputProcessor['getScale'](numberData, width, 'value').domain()).toEqual([
-      numberData[0].x,
-      numberData[2].x,
-    ]);
-    expect(xAxisInputProcessor['getScale'](dateData, width, 'time', 1).domain()).toEqual([
-      dateData[1].x,
-      dateData[0].x,
-    ]);
-    expect(xAxisInputProcessor['getScale'](stringData, width, 'category').domain()).toEqual(stringData.map((item) => item.x));
-    expect(xAxisInputProcessor['getScale'](stringDataNeedSort, width, 'category', 1, (item, nextItem) => 'ABCD'.indexOf(item) - 'ABCD'.indexOf(nextItem)).domain()).toEqual(['A', 'B', 'C', 'D']);
-  });
-  it('should fall back to default domains when input data is empty', () => {
-    const width = 200;
-    expect(xAxisInputProcessor['getScale']([], width, 'value').domain()).toEqual([0, 0]);
-    const timeDomain = xAxisInputProcessor['getScale']([], width, 'time', 1).domain();
-    expect(timeDomain[0]).toBeInstanceOf(Date);
-    expect(timeDomain[1]).toBeInstanceOf(Date);
-    expect(Math.abs(timeDomain[1].getTime() - timeDomain[0].getTime())).toBeLessThan(10);
-  });
-  it('should pass correct padding to getScale based on container tagName', () => {
-    const getScaleSpy = jest
-      .spyOn(xAxisInputProcessor, 'getScale')
-      .mockReturnValue({});
-    const previousOutput = {
-      width: 200,
-      height: 100,
-      innerWidth: 200,
-      innerHeight: 100,
-      top: 0,
-      left: 0,
-      right: 0,
-      bottom: 0,
-    };
-    const dataSource = [];
-    const lineChartInput = {
-      dataSource,
-      container: document.createElement('vega-line-chart'),
-      xAxis: { type: 'value' },
-    };
-    xAxisInputProcessor.process(lineChartInput, previousOutput);
-    expect(getScaleSpy).toHaveBeenLastCalledWith(dataSource, 200, 'value', 1, undefined);
-    const divChartInput = {
-      dataSource,
-      container: document.createElement('div'),
-      xAxis: { type: 'value' },
-    };
-    xAxisInputProcessor.process(divChartInput, previousOutput);
-    expect(getScaleSpy).toHaveBeenLastCalledWith(dataSource, 200, 'value', 0.1, undefined);
-    getScaleSpy.mockRestore();
-  });
-});