@gravity-ui/charts 1.11.4 → 1.13.0

package/dist/cjs/hooks/useShapes/waterfall/prepare-data.js

@@ -2,7 +2,7 @@ import get from 'lodash/get';
 import sortBy from 'lodash/sortBy';
 import { getLabelsSize } from '../../../utils';
 import { getFormattedValue } from '../../../utils/chart/format';
-import { MIN_BAR_GAP, MIN_BAR_WIDTH } from '../constants';
+import { MIN_BAR_GAP, MIN_BAR_WIDTH } from '../../constants';
 import { getXValue, getYValue } from '../utils';
 async function getLabelData(d, plotHeight) {
     var _a, _b;

package/dist/cjs/hooks/utils/bar-y.d.ts

@@ -0,0 +1,27 @@
+import type { BarYSeries, BarYSeriesData } from '../../types';
+import type { ChartScale } from '../useAxisScales';
+import type { PreparedAxis } from '../useChartOptions/types';
+import type { PreparedBarYSeries, PreparedSeriesOptions } from '../useSeries/types';
+export declare function groupBarYDataByYValue<T extends BarYSeries | PreparedBarYSeries>(series: T[], yAxis: PreparedAxis[]): Record<string | number, Record<string, {
+    data: BarYSeriesData;
+    series: T;
+}[]>>;
+export declare function getBarYLayoutForNumericScale(args: {
+    plotHeight: number;
+    seriesOptions: PreparedSeriesOptions;
+    groupedData: ReturnType<typeof groupBarYDataByYValue>;
+}): {
+    bandSize: number;
+    barGap: number;
+    barSize: number;
+    dataLength: number;
+};
+export declare function getBarYLayoutForCategoryScale(args: {
+    groupedData: ReturnType<typeof groupBarYDataByYValue>;
+    seriesOptions: PreparedSeriesOptions;
+    yScale: ChartScale;
+}): {
+    bandSize: number;
+    barGap: number;
+    barSize: number;
+};

package/dist/cjs/hooks/utils/bar-y.js

@@ -0,0 +1,55 @@
+import { max } from 'd3';
+import get from 'lodash/get';
+import { getDataCategoryValue } from '../../utils';
+import { MIN_BAR_GAP, MIN_BAR_GROUP_GAP, MIN_BAR_WIDTH } from '../constants';
+import { getSeriesStackId } from '../useSeries/utils';
+export function groupBarYDataByYValue(series, yAxis) {
+    const data = {};
+    series.forEach((s) => {
+        s.data.forEach((d) => {
+            const axisIndex = get(s, 'yAxis', 0);
+            const seriesYAxis = yAxis[axisIndex];
+            const categories = get(seriesYAxis, 'categories', []);
+            const key = seriesYAxis.type === 'category'
+                ? getDataCategoryValue({ axisDirection: 'y', categories, data: d })
+                : d.y;
+            if (key) {
+                if (!data[key]) {
+                    data[key] = {};
+                }
+                const stackId = getSeriesStackId(s);
+                if (!data[key][stackId]) {
+                    data[key][stackId] = [];
+                }
+                data[key][stackId].push({ data: d, series: s });
+            }
+        });
+    });
+    return data;
+}
+export function getBarYLayoutForNumericScale(args) {
+    const { plotHeight, groupedData, seriesOptions } = args;
+    const barMaxWidth = get(seriesOptions, 'bar-y.barMaxWidth');
+    const barPadding = get(seriesOptions, 'bar-y.barPadding');
+    const groupPadding = get(seriesOptions, 'bar-y.groupPadding');
+    const dataLength = Object.values(groupedData).reduce((sum, items) => sum + Object.keys(items).length, 0);
+    const bandSize = plotHeight / dataLength;
+    const groupGap = Math.max(bandSize * groupPadding, MIN_BAR_GROUP_GAP);
+    const groupSize = bandSize - groupGap;
+    const barGap = Math.max(bandSize * barPadding, MIN_BAR_GAP);
+    const barSize = Math.max(MIN_BAR_WIDTH, Math.min(groupSize - barGap, barMaxWidth));
+    return { bandSize, barGap, barSize, dataLength };
+}
+export function getBarYLayoutForCategoryScale(args) {
+    const { groupedData, seriesOptions, yScale } = args;
+    const barMaxWidth = get(seriesOptions, 'bar-y.barMaxWidth');
+    const barPadding = get(seriesOptions, 'bar-y.barPadding');
+    const groupPadding = get(seriesOptions, 'bar-y.groupPadding');
+    const bandSize = yScale.bandwidth();
+    const maxGroupSize = max(Object.values(groupedData), (d) => Object.values(d).length) || 1;
+    const groupGap = Math.max(bandSize * groupPadding, MIN_BAR_GROUP_GAP);
+    const groupSize = bandSize - groupGap;
+    const barGap = Math.max(bandSize * barPadding, MIN_BAR_GAP);
+    const barSize = Math.max(MIN_BAR_WIDTH, Math.min(groupSize / maxGroupSize - barGap, barMaxWidth));
+    return { bandSize, barGap, barSize };
+}

package/dist/cjs/hooks/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './bar-y';

package/dist/cjs/hooks/utils/index.js

@@ -0,0 +1 @@
+export * from './bar-y';

package/dist/cjs/i18n/keysets/en.json

@@ -13,6 +13,12 @@
     "label_invalid-treemap-missing-value": "It seems you are trying to use node without \"value\". Check node with this properties: { id: \"{{id}}\", name: \"{{name}}\" }",
     "label_invalid-y-axis-index": "It seems you are trying to use inappropriate index for Y axis: \"{{index}}\"",
     "label_invalid-axis-plot-band-option": "It seems you are trying to use inappropriate type for \"{{axis}}\" axis plot band option: \"{{option}}\"",
-    "label_axis-plot-band-options-not-equal": "It seems you are trying to use different type for \"{{axis}}\" axis plot band options"
+    "label_axis-plot-band-options-not-equal": "It seems you are trying to use different type for \"{{axis}}\" axis plot band options",
+    "label_invalid-tooltip-totals-aggregation-type": "It seems you are trying to use inappropriate data type for \"tooltip.totals.aggregation\". Available types: string, function.",
+    "label_invalid-tooltip-totals-aggregation-type-str": "It seems you are trying to use inappropriate value for built-in \"tooltip.totals.aggregation\". Available values: [{{values}}].",
+    "label_invalid-axis-type": "It seems you are trying to use inappropriate type for \"{{key}}\" axis. Available types: [{{values}}]."
+  },
+  "tooltip": {
+    "label_totals_sum": "Sum"
   }
 }

package/dist/cjs/i18n/keysets/ru.json

@@ -13,6 +13,12 @@
     "label_invalid-treemap-missing-value": "Похоже, что вы пытаетесь использовать узел без значения \"value\". Проверьте узел с этими свойствами: { id: \"{{id}}\", name: \"{{name}}\" }",
     "label_invalid-y-axis-index": "Похоже, что вы пытаетесь использовать некорректный индекс для оси Y: \"{{index}}\"",
     "label_invalid-axis-plot-band-option": "Похоже, что вы пытаетесь использовать некорректный тип для параметра полосы: \"{{option}}\" для оси \"{{axis}}\"",
-    "label_axis-plot-band-options-not-equal": "Похоже, что вы пытаетесь использовать разные типы для для параметра полосы для оси \"{{axis}}\""
+    "label_axis-plot-band-options-not-equal": "Похоже, что вы пытаетесь использовать разные типы для для параметра полосы для оси \"{{axis}}\"",
+    "label_invalid-tooltip-totals-aggregation-type": "Похоже, что вы пытаетесь использовать некорректный тип данных для \"tooltip.totals.aggregation\". Доступные типы: string, function.",
+    "label_invalid-tooltip-totals-aggregation-type-str": "Похоже, что вы пытаетесь использовать некорректное значение для встроенной агрегации \"tooltip.totals.aggregation\". Доступные значения: [{{values}}].",
+    "label_invalid-axis-type": "Похоже, что вы пытаетесь использовать некорректный тип для оси \"{{key}}\". Доступные типы: [{{values}}]."
+  },
+  "tooltip": {
+    "label_totals_sum": "Сумма"
   }
 }

package/dist/cjs/types/chart/axis.d.ts

@@ -1,7 +1,7 @@
-import type { DashStyle } from '../../constants';
+import type { AXIS_TYPE, DashStyle } from '../../constants';
 import type { FormatNumberOptions } from '../formatter';
 import type { BaseTextStyle } from './base';
-export type ChartAxisType = 'category' | 'datetime' | 'linear' | 'logarithmic';
+export type ChartAxisType = (typeof AXIS_TYPE)[keyof typeof AXIS_TYPE];
 export type ChartAxisTitleAlignment = 'left' | 'center' | 'right';
 export interface ChartAxisLabels {
     /** Enable or disable the axis labels. */
@@ -78,6 +78,10 @@ export interface ChartAxis {
     plotBands?: AxisPlotBand[];
     /** Whether axis, including axis title, line, ticks and labels, should be visible. */
     visible?: boolean;
+    /** Setting the order of the axis values. It is not applied by default.
+     * the "reverse" value is needed to use the reverse order without sorting
+     */
+    order?: 'sortAsc' | 'sortDesc' | 'reverse';
 }
 export interface ChartXAxis extends ChartAxis {
 }
@@ -92,6 +96,14 @@ export interface AxisPlot {
      * @default 1
      * */
     opacity?: number;
+    label?: {
+        text: string;
+        style?: Partial<BaseTextStyle>;
+        /** The pixel padding for label.
+         * @default 5
+         */
+        padding?: number;
+    };
 }
 export interface AxisPlotLine extends AxisPlot {
     /** The position of the line in axis units. */
@@ -121,7 +133,7 @@ export interface AxisPlotBand extends AxisPlot {
      */
     to: number | string;
 }
-export interface AxisCrosshair extends Omit<AxisPlotLine, 'value'> {
+export interface AxisCrosshair extends Omit<AxisPlotLine, 'value' | 'label'> {
     /** Whether the crosshair should snap to the point or follow the pointer independent of points.
      * @default true
      */

package/dist/cjs/types/chart/bar-y.d.ts

@@ -29,6 +29,16 @@ export interface BarYSeries<T = MeaningfulAny> extends BaseSeries {
     name: string;
     /** The main color of the series (hex, rgba) */
     color?: string;
+    /**
+     * The width of the border surrounding each bar.
+     *
+     * @default 0
+     */
+    borderWidth?: number;
+    /**
+     * The color of the border surrounding each bar.
+     */
+    borderColor?: string;
     /**
      * The corner radius of the border surrounding each bar.
      * @default 0

package/dist/cjs/types/chart/series.d.ts

@@ -115,6 +115,16 @@ export interface ChartSeriesOptions {
          * @default 0.2
          */
         groupPadding?: number;
+        /**
+         * The width of the border surrounding each bar.
+         *
+         * @default 0
+         */
+        borderWidth?: number;
+        /**
+         * The color of the border surrounding each bar.
+         */
+        borderColor?: string;
         /**
          * The corner radius of the border surrounding each bar.
          * @default 0

package/dist/cjs/types/chart/tooltip.d.ts

@@ -1,3 +1,4 @@
+import type { TOOLTIP_TOTALS_BUILT_IN_AGGREGATION } from '../../constants';
 import type { MeaningfulAny } from '../misc';
 import type { AreaSeries, AreaSeriesData } from './area';
 import type { ChartXAxis, ChartYAxis } from './axis';
@@ -79,6 +80,10 @@ export interface ChartTooltipRendererArgs<T = MeaningfulAny> {
     xAxis?: ChartXAxis | null;
     yAxis?: ChartYAxis;
 }
+export interface ChartTooltipTotalsAggregationArgs<T = MeaningfulAny> extends ChartTooltipRendererArgs<T> {
+}
+export type ChartTooltipTotalsBuiltInAggregation = (typeof TOOLTIP_TOTALS_BUILT_IN_AGGREGATION)[keyof typeof TOOLTIP_TOTALS_BUILT_IN_AGGREGATION];
+export type ChartTooltipTotalsAggregationValue = number | string | undefined;
 export interface ChartTooltip<T = MeaningfulAny> {
     enabled?: boolean;
     /** Specifies the renderer for the tooltip. If returned null default tooltip renderer will be used. */
@@ -91,4 +96,20 @@ export interface ChartTooltip<T = MeaningfulAny> {
     throttle?: number;
     /** Formatting settings for tooltip value. */
     valueFormat?: ValueFormat;
+    /** Settings for totals block in tooltip */
+    totals?: {
+        /**
+         * The aggregation method for calculating totals.
+         * It can be a built-in function (e.g., 'sum') or a custom function.
+         * @default 'sum'
+         */
+        aggregation?: ChartTooltipTotalsBuiltInAggregation | ((args: ChartTooltipTotalsAggregationArgs) => ChartTooltipTotalsAggregationValue);
+        /**
+         * Enables/disables the display of totals
+         * @default false
+         */
+        enabled?: boolean;
+        /** The label text for the totals. For built-in aggregations, the label can be omitted. */
+        label?: string;
+    };
 }

package/dist/cjs/utils/chart/axis-generators/bottom.js

@@ -93,18 +93,31 @@ export async function axisBottom(args) {
             let elementX = 0;
             // add an ellipsis to the labels that go beyond the boundaries of the chart
             // and remove overlapping labels
-            labels.each(function (_d, i, nodes) {
-                var _a, _b;
-                const currentElement = this;
-                const currentElementPosition = currentElement.getBoundingClientRect();
+            labels
+                .nodes()
+                .map((element) => {
+                const r = element.getBoundingClientRect();
+                return {
+                    left: r.left,
+                    right: r.right,
+                    node: element,
+                };
+            }, {})
+                .sort((a, b) => {
+                return a.left - b.left;
+            })
+                .forEach(function (item, i, nodes) {
+                var _a, _b, _c, _d;
+                const { node, left, right: currentElementPositionRigth } = item;
+                const currentElement = node;
                 if (i === 0) {
                     const text = select(currentElement);
-                    const nextElement = nodes[i + 1];
+                    const nextElement = (_a = nodes[i + 1]) === null || _a === void 0 ? void 0 : _a.node;
                     const nextElementPosition = nextElement === null || nextElement === void 0 ? void 0 : nextElement.getBoundingClientRect();
-                    if (currentElementPosition.left < leftmostLimit) {
-                        const rightmostPossiblePoint = (_a = nextElementPosition === null || nextElementPosition === void 0 ? void 0 : nextElementPosition.left) !== null && _a !== void 0 ? _a : right;
+                    if (left < leftmostLimit) {
+                        const rightmostPossiblePoint = (_b = nextElementPosition === null || nextElementPosition === void 0 ? void 0 : nextElementPosition.left) !== null && _b !== void 0 ? _b : right;
                         const remainSpace = rightmostPossiblePoint -
-                            currentElementPosition.right +
+                            currentElementPositionRigth +
                             x -
                             labelsMargin;
                         text.attr('text-anchor', 'start');
@@ -112,16 +125,16 @@ export async function axisBottom(args) {
                     }
                 }
                 else {
-                    if (currentElementPosition.left < elementX) {
-                        (_b = currentElement.closest('.tick')) === null || _b === void 0 ? void 0 : _b.remove();
+                    if (left < elementX) {
+                        (_c = currentElement.closest('.tick')) === null || _c === void 0 ? void 0 : _c.remove();
                         return;
                     }
-                    elementX = currentElementPosition.right + labelsPaddings;
+                    elementX = currentElementPositionRigth + labelsPaddings;
                     if (i === nodes.length - 1) {
-                        const prevElement = nodes[i - 1];
+                        const prevElement = (_d = nodes[i - 1]) === null || _d === void 0 ? void 0 : _d.node;
                         const text = select(currentElement);
                         const prevElementPosition = prevElement === null || prevElement === void 0 ? void 0 : prevElement.getBoundingClientRect();
-                        const lackingSpace = Math.max(0, currentElementPosition.right - right);
+                        const lackingSpace = Math.max(0, currentElementPositionRigth - right);
                         if (lackingSpace) {
                             const remainSpace = right - ((prevElementPosition === null || prevElementPosition === void 0 ? void 0 : prevElementPosition.right) || 0) - labelsPaddings;
                             const translateX = -lackingSpace;

package/dist/cjs/utils/chart/get-closest-data.js

@@ -49,7 +49,7 @@ export function getClosestPoints(args) {
     const groups = groupBy(shapesData, getSeriesType);
     // eslint-disable-next-line complexity
     Object.entries(groups).forEach(([seriesType, list]) => {
-        var _a, _b;
+        var _a, _b, _c;
         switch (seriesType) {
             case 'bar-x': {
                 const points = list.map((d) => ({
@@ -106,26 +106,27 @@ export function getClosestPoints(args) {
                 const points = list;
                 const sorted = sort(points, (p) => p.y);
                 const closestYIndex = bisector((p) => p.y).center(sorted, pointerY);
-                let closestPoints = [];
-                let closestXIndex = -1;
-                if (closestYIndex !== -1) {
-                    const closestY = sorted[closestYIndex].y;
-                    closestPoints = sort(points.filter((p) => p.y === closestY), (p) => p.x);
+                const closestYPoint = sorted[closestYIndex];
+                let selectedPoints = [];
+                let closestPointXValue = -1;
+                if (closestYPoint) {
+                    selectedPoints = points.filter((p) => p.data.y === closestYPoint.data.y);
+                    const closestPoints = sort(selectedPoints.filter((p) => p.y === closestYPoint.y), (p) => p.x);
                     const lastPoint = closestPoints[closestPoints.length - 1];
                     if (pointerX < ((_a = closestPoints[0]) === null || _a === void 0 ? void 0 : _a.x)) {
-                        closestXIndex = 0;
+                        closestPointXValue = closestPoints[0].x;
                     }
                     else if (lastPoint && pointerX > lastPoint.x + lastPoint.width) {
-                        closestXIndex = closestPoints.length - 1;
+                        closestPointXValue = lastPoint.x;
                     }
                     else {
-                        closestXIndex = closestPoints.findIndex((p) => pointerX > p.x && pointerX < p.x + p.width);
+                        closestPointXValue = (_b = closestPoints.find((p) => pointerX > p.x && pointerX < p.x + p.width)) === null || _b === void 0 ? void 0 : _b.x;
                     }
                 }
-                result.push(...closestPoints.map((p, i) => ({
+                result.push(...selectedPoints.map((p) => ({
                     data: p.data,
                     series: p.series,
-                    closest: i === closestXIndex,
+                    closest: p.x === closestPointXValue && p.y === closestYPoint.y,
                 })));
                 break;
             }
@@ -164,7 +165,7 @@ export function getClosestPoints(args) {
             }
             case 'treemap': {
                 const data = list;
-                const closestPoint = (_b = data[0]) === null || _b === void 0 ? void 0 : _b.leaves.find((l) => {
+                const closestPoint = (_c = data[0]) === null || _c === void 0 ? void 0 : _c.leaves.find((l) => {
                     return (pointerX >= l.x0 && pointerX <= l.x1 && pointerY >= l.y0 && pointerY <= l.y1);
                 });
                 if (closestPoint) {

package/dist/cjs/utils/chart/index.js

@@ -238,5 +238,5 @@ export function getClosestPointsRange(axis, points) {
     if (axis.type === 'category') {
         return undefined;
     }
-    return points[1] - points[0];
+    return Math.abs(points[1] - points[0]);
 }

package/dist/cjs/utils/chart/series/sorting.d.ts

@@ -1,2 +1,6 @@
-import type { ChartSeries } from '../../../types';
-export declare function getSortedSeriesData(seriesData: ChartSeries[]): ChartSeries[];
+import type { ChartAxis, ChartSeries } from '../../../types';
+export declare function getSortedSeriesData({ seriesData, yAxes, xAxis, }: {
+    seriesData: ChartSeries[];
+    yAxes?: ChartAxis[];
+    xAxis?: ChartAxis;
+}): ChartSeries[];

package/dist/cjs/utils/chart/series/sorting.js

@@ -1,12 +1,37 @@
 import { sort } from 'd3';
+import { isEmpty } from 'lodash';
+import get from 'lodash/get';
 import { SeriesType } from '../../../constants';
-export function getSortedSeriesData(seriesData) {
+import { getAxisCategories } from '../../../hooks/useChartOptions/utils';
+function applyAxisCategoriesOrder({ series, axis, key, }) {
+    var _a, _b;
+    const originalCategories = (_a = axis === null || axis === void 0 ? void 0 : axis.categories) !== null && _a !== void 0 ? _a : [];
+    if (isEmpty(originalCategories)) {
+        return series;
+    }
+    const axisCategories = (_b = getAxisCategories(axis)) !== null && _b !== void 0 ? _b : [];
+    const order = Object.fromEntries(axisCategories.map((value, index) => [value, index]));
+    const newSeriesData = series.data.map((d) => {
+        const value = get(d, key);
+        if (typeof value === 'number') {
+            return Object.assign(Object.assign({}, d), { [key]: order[originalCategories[value]] });
+        }
+        return d;
+    });
+    return Object.assign(Object.assign({}, series), { data: newSeriesData });
+}
+export function getSortedSeriesData({ seriesData, yAxes, xAxis, }) {
     return seriesData.map((s) => {
-        switch (s.type) {
+        const yAxis = yAxes === null || yAxes === void 0 ? void 0 : yAxes[0];
+        let sortedSeries = s;
+        sortedSeries = applyAxisCategoriesOrder({ series: sortedSeries, axis: yAxis, key: 'y' });
+        sortedSeries = applyAxisCategoriesOrder({ series: sortedSeries, axis: xAxis, key: 'x' });
+        switch (sortedSeries.type) {
             case SeriesType.Area: {
-                s.data = sort(s.data, (d) => d.x);
+                sortedSeries = Object.assign(Object.assign({}, sortedSeries), { data: sort(sortedSeries.data, (d) => d.x) });
+                break;
             }
         }
-        return s;
+        return sortedSeries;
     });
 }

package/dist/cjs/utils/chart/zoom.js

@@ -1,4 +1,5 @@
 import { SeriesType } from '../../constants';
+import { getAxisCategories } from '../../hooks/useChartOptions/utils';
 const SERIES_TYPE_WITH_HIDDEN_POINTS = [SeriesType.Area, SeriesType.Line];
 // eslint-disable-next-line complexity
 function isValueInRange(args) {
@@ -20,7 +21,7 @@ function isValueInRange(args) {
             return numValue >= numMin && numValue <= numMax;
         }
         case 'category': {
-            const categories = (axis === null || axis === void 0 ? void 0 : axis.categories) || [];
+            const categories = getAxisCategories(axis) || [];
             if (typeof value === 'string' && typeof min === 'number' && typeof max === 'number') {
                 const valueIndex = categories.indexOf(value);
                 if (min === -1 || max === -1 || valueIndex === -1) {

package/dist/cjs/validation/index.js

@@ -1,9 +1,35 @@
 import get from 'lodash/get';
 import isEmpty from 'lodash/isEmpty';
-import { DEFAULT_AXIS_TYPE, SeriesType } from '../constants';
+import { AXIS_TYPE, DEFAULT_AXIS_TYPE, SeriesType, TOOLTIP_TOTALS_BUILT_IN_AGGREGATION, } from '../constants';
 import { i18n } from '../i18n';
 import { CHART_ERROR_CODE, ChartError } from '../libs';
+function getTypeOf(value) {
+    return typeof value;
+}
 const AVAILABLE_SERIES_TYPES = Object.values(SeriesType);
+const AVAILABLE_TOOLTIP_TOTALS_BUILT_IN_AGGREGATIONS = Object.values(TOOLTIP_TOTALS_BUILT_IN_AGGREGATION);
+const AVAILABLE_TOOLTIP_TOTALS_AGGREGATION_TYPES = ['function', 'string'];
+const AVAILABLE_AXIS_TYPES = Object.values(AXIS_TYPE);
+function validateAxisType({ axis, key }) {
+    if (axis.type && !AVAILABLE_AXIS_TYPES.includes(axis.type)) {
+        throw new ChartError({
+            code: CHART_ERROR_CODE.INVALID_DATA,
+            message: i18n('error', 'label_invalid-axis-type', {
+                key,
+                values: AVAILABLE_AXIS_TYPES,
+            }),
+        });
+    }
+}
+function validateAxes(args) {
+    const { xAxis, yAxis = [] } = args;
+    if (xAxis) {
+        validateAxisType({ axis: xAxis, key: 'x' });
+    }
+    yAxis.forEach((axis) => {
+        validateAxisType({ axis, key: 'y' });
+    });
+}
 function validateXYSeries(args) {
     const { series, xAxis, yAxis = [] } = args;
     const yAxisIndex = get(series, 'yAxis', 0);
@@ -335,6 +361,32 @@ function countSeriesByType(args) {
     });
     return count;
 }
+function validateTooltip({ tooltip }) {
+    if (!tooltip) {
+        return;
+    }
+    if (tooltip.totals) {
+        const aggregation = tooltip.totals.aggregation;
+        if (aggregation) {
+            const aggregationType = getTypeOf(aggregation);
+            if (!AVAILABLE_TOOLTIP_TOTALS_AGGREGATION_TYPES.includes(aggregationType)) {
+                throw new ChartError({
+                    code: CHART_ERROR_CODE.INVALID_DATA,
+                    message: i18n('error', 'label_invalid-tooltip-totals-aggregation-type'),
+                });
+            }
+            if (typeof aggregation === 'string' &&
+                !AVAILABLE_TOOLTIP_TOTALS_BUILT_IN_AGGREGATIONS.includes(aggregation)) {
+                throw new ChartError({
+                    code: CHART_ERROR_CODE.INVALID_DATA,
+                    message: i18n('error', 'label_invalid-tooltip-totals-aggregation-type-str', {
+                        values: AVAILABLE_TOOLTIP_TOTALS_BUILT_IN_AGGREGATIONS,
+                    }),
+                });
+            }
+        }
+    }
+}
 export function validateData(data) {
     if (isEmpty(data) || isEmpty(data.series) || isEmpty(data.series.data)) {
         throw new ChartError({
@@ -342,6 +394,8 @@ export function validateData(data) {
             message: i18n('error', 'label_no-data'),
         });
     }
+    validateAxes({ xAxis: data.xAxis, yAxis: data.yAxis });
+    validateTooltip({ tooltip: data.tooltip });
     if (data.series.data.some((s) => isEmpty(s.data))) {
         throw new ChartError({
             code: CHART_ERROR_CODE.INVALID_DATA,