@gravity-ui/charts 1.23.0 → 1.24.1

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

@@ -1,33 +1,7 @@
 import { group } from 'd3';
-import { getDataCategoryValue, getLabelsSize, getLeftPosition } from '../../../utils';
+import { getDataCategoryValue, getLabelsSize, getTextSizeFn } from '../../../utils';
 import { getFormattedValue } from '../../../utils/chart/format';
 import { getXValue, getYValue } from '../utils';
-async function getLabelData(point, series, xMax) {
-    const text = getFormattedValue(Object.assign({ value: point.data.label || point.data.y }, series.dataLabels));
-    const style = series.dataLabels.style;
-    const size = await getLabelsSize({ labels: [text], style, html: series.dataLabels.html });
-    const labelData = {
-        text,
-        x: point.x,
-        y: point.y - series.dataLabels.padding,
-        style,
-        size: { width: size.maxWidth, height: size.maxHeight },
-        textAnchor: 'middle',
-        series: series,
-        active: true,
-    };
-    const left = getLeftPosition(labelData);
-    if (left < 0) {
-        labelData.x = labelData.x + Math.abs(left);
-    }
-    else {
-        const right = left + labelData.size.width;
-        if (right > xMax) {
-            labelData.x = labelData.x - (right - xMax);
-        }
-    }
-    return labelData;
-}
 function getXValues(series, xAxis, xScale) {
     const categories = xAxis.categories || [];
     const xValues = series.reduce((acc, s) => {
@@ -53,148 +27,175 @@ function getXValues(series, xAxis, xScale) {
     }
     return Array.from(xValues);
 }
+async function prepareDataLabels({ series, points, xMax, yAxisTop, }) {
+    const svgLabels = [];
+    const htmlLabels = [];
+    const getTextSize = getTextSizeFn({ style: series.dataLabels.style });
+    for (let pointsIndex = 0; pointsIndex < points.length; pointsIndex++) {
+        const point = points[pointsIndex];
+        if (point.y === null) {
+            continue;
+        }
+        const text = getFormattedValue(Object.assign({ value: point.data.label || point.data.y }, series.dataLabels));
+        if (series.dataLabels.html) {
+            const size = await getLabelsSize({
+                labels: [text],
+                style: series.dataLabels.style,
+                html: series.dataLabels.html,
+            });
+            const labelSize = { width: size.maxWidth, height: size.maxHeight };
+            const x = Math.min(xMax - labelSize.width, Math.max(0, point.x - labelSize.width / 2));
+            const y = Math.max(yAxisTop, point.y - series.dataLabels.padding - labelSize.height);
+            htmlLabels.push({
+                x,
+                y,
+                content: text,
+                size: labelSize,
+                style: series.dataLabels.style,
+            });
+        }
+        else {
+            const labelSize = await getTextSize(text);
+            const x = Math.min(xMax - labelSize.width, Math.max(0, point.x - labelSize.width / 2));
+            const y = Math.max(yAxisTop, point.y - series.dataLabels.padding - labelSize.height);
+            svgLabels.push({
+                text,
+                x,
+                y,
+                style: series.dataLabels.style,
+                size: labelSize,
+                textAnchor: 'start',
+                series,
+                active: true,
+            });
+        }
+    }
+    return { svgLabels, htmlLabels };
+}
 export const prepareAreaData = async (args) => {
-    var _a;
-    const { series, xAxis, xScale, yAxis, yScale, boundsHeight: plotHeight, isOutsideBounds } = args;
+    var _a, _b;
+    const { series, xAxis, xScale, yAxis, yScale, boundsHeight: plotHeight, split, isOutsideBounds, } = args;
     const [_xMin, xRangeMax] = xScale.range();
     const xMax = xRangeMax / (1 - xAxis.maxPadding);
     const result = [];
-    const list = Array.from(group(series, (s) => s.stackId));
-    for (let i = 0; i < list.length; i++) {
-        const [_stackId, seriesStack] = list[i];
-        const xValues = getXValues(seriesStack, xAxis, xScale);
-        const accumulatedYValues = new Map();
-        xValues.forEach(([key]) => {
-            accumulatedYValues.set(key, 0);
-        });
-        const seriesStackData = [];
-        for (let j = 0; j < seriesStack.length; j++) {
-            const s = seriesStack[j];
-            const yAxisIndex = s.yAxis;
-            const seriesYAxis = yAxis[yAxisIndex];
-            const seriesYScale = yScale[yAxisIndex];
-            if (!seriesYScale) {
-                continue;
-            }
-            const yMin = (_a = getYValue({
-                point: { y: 0 },
-                points: s.data,
-                yAxis: seriesYAxis,
-                yScale: seriesYScale,
-            })) !== null && _a !== void 0 ? _a : 0;
-            const seriesData = s.data.reduce((m, d) => {
-                const key = String(xAxis.type === 'category'
-                    ? getDataCategoryValue({
-                        axisDirection: 'x',
-                        categories: xAxis.categories || [],
-                        data: d,
-                    })
-                    : d.x);
-                return m.set(key, d);
-            }, new Map());
-            const points = xValues.reduce((pointsAcc, [x, xValue]) => {
-                var _a;
-                const accumulatedYValue = accumulatedYValues.get(x) || 0;
-                const d = (_a = seriesData.get(x)) !== null && _a !== void 0 ? _a : {
-                    x,
-                    y: 0,
-                };
-                const yValue = getYValue({ point: d, yAxis: seriesYAxis, yScale: seriesYScale });
-                const yPointValue = yValue === null ? null : yValue - accumulatedYValue;
-                if (yPointValue !== null) {
-                    accumulatedYValues.set(x, yMin - yPointValue);
+    const dataByPlots = Array.from(group(series, (s) => {
+        const yAxisIndex = s.yAxis;
+        const seriesYAxis = yAxis[yAxisIndex];
+        const plotIndex = seriesYAxis.plotIndex;
+        return plotIndex;
+    }, (s) => s.stackId));
+    const plotIndexes = Object.keys(dataByPlots);
+    for (let plotDataIndex = 0; plotDataIndex < plotIndexes.length; plotDataIndex++) {
+        const [plotIndex, stackItems] = dataByPlots[plotDataIndex];
+        const list = Array.from(stackItems);
+        for (let i = 0; i < list.length; i++) {
+            const [_stackId, seriesStack] = list[i];
+            const xValues = getXValues(seriesStack, xAxis, xScale);
+            const accumulatedYValues = new Map();
+            xValues.forEach(([key]) => {
+                accumulatedYValues.set(key, 0);
+            });
+            const seriesStackData = [];
+            for (let j = 0; j < seriesStack.length; j++) {
+                const s = seriesStack[j];
+                const yAxisIndex = s.yAxis;
+                const seriesYAxis = yAxis[yAxisIndex];
+                const seriesYScale = yScale[yAxisIndex];
+                if (!seriesYScale) {
+                    continue;
                 }
-                pointsAcc.push({
-                    y0: yMin - accumulatedYValue,
-                    x: xValue,
-                    y: yPointValue,
-                    data: d,
-                    series: s,
-                });
-                return pointsAcc;
-            }, []);
-            let labels = [];
-            const htmlElements = [];
-            if (s.dataLabels.enabled) {
-                const labelItems = await Promise.all(points.reduce((labelItemsAcc, p) => {
-                    if (p.y === null) {
-                        return labelItemsAcc;
+                const yAxisTop = ((_a = split.plots[plotIndex]) === null || _a === void 0 ? void 0 : _a.top) || 0;
+                const yMin = (_b = getYValue({
+                    point: { y: 0 },
+                    points: s.data,
+                    yAxis: seriesYAxis,
+                    yScale: seriesYScale,
+                })) !== null && _b !== void 0 ? _b : 0;
+                const seriesData = s.data.reduce((m, d) => {
+                    const key = String(xAxis.type === 'category'
+                        ? getDataCategoryValue({
+                            axisDirection: 'x',
+                            categories: xAxis.categories || [],
+                            data: d,
+                        })
+                        : d.x);
+                    return m.set(key, d);
+                }, new Map());
+                const points = xValues.reduce((pointsAcc, [x, xValue]) => {
+                    var _a;
+                    const accumulatedYValue = accumulatedYValues.get(x) || 0;
+                    const d = (_a = seriesData.get(x)) !== null && _a !== void 0 ? _a : {
+                        x,
+                        y: 0,
+                    };
+                    const yValue = getYValue({ point: d, yAxis: seriesYAxis, yScale: seriesYScale });
+                    const yPointValue = yValue === null ? null : yValue - accumulatedYValue;
+                    if (yPointValue !== null) {
+                        accumulatedYValues.set(x, yMin - yPointValue);
                     }
-                    labelItemsAcc.push(getLabelData(p, s, xMax));
-                    return labelItemsAcc;
-                }, []));
-                if (s.dataLabels.html) {
-                    const htmlLabels = await Promise.all(labelItems.map(async (l) => {
-                        var _a;
-                        const style = (_a = l.style) !== null && _a !== void 0 ? _a : s.dataLabels.style;
-                        const labelSize = await getLabelsSize({
-                            labels: [l.text],
-                            style,
-                            html: true,
-                        });
-                        return {
-                            x: l.x - l.size.width / 2,
-                            y: l.y,
-                            content: l.text,
-                            size: {
-                                width: labelSize.maxWidth,
-                                height: labelSize.maxHeight,
-                            },
-                            style,
-                        };
-                    }));
-                    htmlElements.push(...htmlLabels);
+                    pointsAcc.push({
+                        y0: yAxisTop + yMin - accumulatedYValue,
+                        x: xValue,
+                        y: yPointValue === null ? null : yAxisTop + (yPointValue !== null && yPointValue !== void 0 ? yPointValue : 0),
+                        data: d,
+                        series: s,
+                    });
+                    return pointsAcc;
+                }, []);
+                const labels = [];
+                const htmlElements = [];
+                if (s.dataLabels.enabled) {
+                    const labelsData = await prepareDataLabels({ series: s, points, xMax, yAxisTop });
+                    labels.push(...labelsData.svgLabels);
+                    htmlElements.push(...labelsData.htmlLabels);
                 }
-                else {
-                    labels = labelItems;
+                let markers = [];
+                if (s.marker.states.normal.enabled || s.marker.states.hover.enabled) {
+                    markers = points.reduce((markersAcc, p) => {
+                        if (p.y === null) {
+                            return markersAcc;
+                        }
+                        markersAcc.push({
+                            point: p,
+                            active: true,
+                            hovered: false,
+                            clipped: isOutsideBounds(p.x, p.y),
+                        });
+                        return markersAcc;
+                    }, []);
                 }
+                seriesStackData.push({
+                    points,
+                    markers,
+                    labels,
+                    color: s.color,
+                    opacity: s.opacity,
+                    width: s.lineWidth,
+                    series: s,
+                    hovered: false,
+                    active: true,
+                    id: s.id,
+                    htmlElements,
+                });
             }
-            let markers = [];
-            if (s.marker.states.normal.enabled || s.marker.states.hover.enabled) {
-                markers = points.reduce((markersAcc, p) => {
-                    if (p.y === null) {
-                        return markersAcc;
-                    }
-                    markersAcc.push({
-                        point: p,
-                        active: true,
-                        hovered: false,
-                        clipped: isOutsideBounds(p.x, p.y),
+            if (series.some((s) => s.stacking === 'percent')) {
+                xValues.forEach(([x], index) => {
+                    const stackHeight = accumulatedYValues.get(x) || 0;
+                    let acc = 0;
+                    const ratio = plotHeight / stackHeight;
+                    seriesStackData.forEach((item) => {
+                        const point = item.points[index];
+                        if (point.y !== null && point.y !== undefined) {
+                            const height = (point.y0 - point.y) * ratio;
+                            point.y0 = plotHeight - height - acc;
+                            point.y = point.y0 + height;
+                            acc += height;
+                        }
                     });
-                    return markersAcc;
-                }, []);
-            }
-            seriesStackData.push({
-                points,
-                markers,
-                labels,
-                color: s.color,
-                opacity: s.opacity,
-                width: s.lineWidth,
-                series: s,
-                hovered: false,
-                active: true,
-                id: s.id,
-                htmlElements,
-            });
-        }
-        if (series.some((s) => s.stacking === 'percent')) {
-            xValues.forEach(([x], index) => {
-                const stackHeight = accumulatedYValues.get(x) || 0;
-                let acc = 0;
-                const ratio = plotHeight / stackHeight;
-                seriesStackData.forEach((item) => {
-                    const point = item.points[index];
-                    if (point.y !== null && point.y !== undefined) {
-                        const height = (point.y0 - point.y) * ratio;
-                        point.y0 = plotHeight - height - acc;
-                        point.y = point.y0 + height;
-                        acc += height;
-                    }
                 });
-            });
+            }
+            result.push(...seriesStackData);
         }
-        result.push(...seriesStackData);
     }
     return result;
 };

package/dist/cjs/hooks/useShapes/bar-x/index.d.ts

@@ -5,10 +5,10 @@ import type { PreparedBarXData } from './types';
 export { prepareBarXData } from './prepare-data';
 export * from './types';
 type Args = {
-    dispatcher: Dispatch<object>;
+    clipPathId: string;
+    htmlLayout: HTMLElement | null;
     preparedData: PreparedBarXData[];
     seriesOptions: PreparedSeriesOptions;
-    htmlLayout: HTMLElement | null;
-    clipPathId: string;
+    dispatcher?: Dispatch<object>;
 };
 export declare const BarXSeriesShapes: (args: Args) => React.JSX.Element;

package/dist/cjs/hooks/useShapes/bar-x/index.js

@@ -104,9 +104,9 @@ export const BarXSeriesShapes = (args) => {
         if (hoveredDataRef.current !== null) {
             handleShapeHover(hoveredDataRef.current);
         }
-        dispatcher.on('hover-shape.bar-x', handleShapeHover);
+        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.on('hover-shape.bar-x', handleShapeHover);
         return () => {
-            dispatcher.on('hover-shape.bar-x', null);
+            dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.on('hover-shape.bar-x', null);
         };
     }, [dispatcher, preparedData, seriesOptions]);
     return (React.createElement(React.Fragment, null,

package/dist/cjs/hooks/useShapes/bar-x/prepare-data.d.ts

@@ -1,13 +1,15 @@
+import type { PreparedXAxis, PreparedYAxis } from '../../useAxis/types';
 import type { ChartScale } from '../../useAxisScales';
-import type { PreparedAxis } from '../../useChartOptions/types';
 import type { PreparedBarXSeries, PreparedSeriesOptions } from '../../useSeries/types';
+import type { PreparedSplit } from '../../useSplit/types';
 import type { PreparedBarXData } from './types';
 export declare const prepareBarXData: (args: {
     series: PreparedBarXSeries[];
     seriesOptions: PreparedSeriesOptions;
-    xAxis: PreparedAxis;
+    xAxis: PreparedXAxis;
     xScale: ChartScale;
-    yAxis: PreparedAxis[];
+    yAxis: PreparedYAxis[];
     yScale: (ChartScale | undefined)[];
     boundsHeight: number;
+    split: PreparedSplit;
 }) => Promise<PreparedBarXData[]>;

package/dist/cjs/hooks/useShapes/bar-x/prepare-data.js

@@ -33,8 +33,8 @@ async function getLabelData(d) {
 }
 // eslint-disable-next-line complexity
 export const prepareBarXData = async (args) => {
-    var _a;
-    const { series, seriesOptions, xAxis, xScale, yScale, boundsHeight: plotHeight } = args;
+    var _a, _b, _c;
+    const { series, seriesOptions, xAxis, xScale, yAxis, yScale, boundsHeight: plotHeight, split, } = args;
     const stackGap = seriesOptions['bar-x'].stackGap;
     const categories = get(xAxis, 'categories', []);
     const barMaxWidth = get(seriesOptions, 'bar-x.barMaxWidth');
@@ -55,8 +55,17 @@ export const prepareBarXData = async (args) => {
             }
         }
     })();
-    const data = {};
+    // series grouped by plotIndex > xValue > data[];
+    const dataByPlots = new Map();
     series.forEach((s) => {
+        var _a;
+        const yAxisIndex = s.yAxis;
+        const seriesYAxis = yAxis[yAxisIndex];
+        const plotIndex = seriesYAxis.plotIndex;
+        if (!dataByPlots.has(plotIndex)) {
+            dataByPlots.set(plotIndex, {});
+        }
+        const data = (_a = dataByPlots.get(plotIndex)) !== null && _a !== void 0 ? _a : {};
         s.data.forEach((d) => {
             if (!isSeriesDataValid(d)) {
                 return;
@@ -96,94 +105,105 @@ export const prepareBarXData = async (args) => {
             }
         });
     }
-    const maxGroupSize = max(Object.values(data), (d) => Object.values(d).length) || 1;
-    const groupGap = Math.max(bandWidth * groupPadding, MIN_BAR_GROUP_GAP);
-    const groupWidth = bandWidth - groupGap;
-    const rectGap = Math.max(bandWidth * barPadding, MIN_BAR_GAP);
-    const rectWidth = Math.max(MIN_BAR_WIDTH, Math.min(groupWidth / maxGroupSize - rectGap, barMaxWidth));
     const result = [];
-    const groupedData = Object.entries(data);
-    for (let groupedDataIndex = 0; groupedDataIndex < groupedData.length; groupedDataIndex++) {
-        const [xValue, val] = groupedData[groupedDataIndex];
-        const stacks = Object.values(val);
-        const currentGroupWidth = rectWidth * stacks.length + rectGap * (stacks.length - 1);
-        for (let groupItemIndex = 0; groupItemIndex < stacks.length; groupItemIndex++) {
-            const yValues = stacks[groupItemIndex];
-            let stackHeight = 0;
-            const stackItems = [];
-            const sortedData = sortKey
-                ? sort(yValues, (a, b) => comparator(get(a, sortKey), get(b, sortKey)))
-                : yValues;
-            for (let yValueIndex = 0; yValueIndex < sortedData.length; yValueIndex++) {
-                const yValue = sortedData[yValueIndex];
-                const yAxisIndex = yValue.series.yAxis;
-                const seriesYScale = yScale[yAxisIndex];
-                if (!seriesYScale) {
-                    continue;
-                }
-                let xCenter;
-                if (xAxis.type === 'category') {
-                    const xBandScale = xScale;
-                    const xBandScaleDomain = xBandScale.domain();
-                    if (xBandScaleDomain.indexOf(xValue) === -1) {
+    const plotIndexes = Array.from(dataByPlots.keys());
+    for (let plotDataIndex = 0; plotDataIndex < plotIndexes.length; plotDataIndex++) {
+        const data = (_a = dataByPlots.get(plotIndexes[plotDataIndex])) !== null && _a !== void 0 ? _a : {};
+        const maxGroupSize = max(Object.values(data), (d) => Object.values(d).length) || 1;
+        const groupGap = Math.max(bandWidth * groupPadding, MIN_BAR_GROUP_GAP);
+        const groupWidth = bandWidth - groupGap;
+        const rectGap = Math.max(bandWidth * barPadding, MIN_BAR_GAP);
+        const rectWidth = Math.max(MIN_BAR_WIDTH, Math.min(groupWidth / maxGroupSize - rectGap, barMaxWidth));
+        const groupedData = Object.entries(data);
+        for (let groupedDataIndex = 0; groupedDataIndex < groupedData.length; groupedDataIndex++) {
+            const [xValue, val] = groupedData[groupedDataIndex];
+            const stacks = Object.values(val);
+            const currentGroupWidth = rectWidth * stacks.length + rectGap * (stacks.length - 1);
+            for (let groupItemIndex = 0; groupItemIndex < stacks.length; groupItemIndex++) {
+                const yValues = stacks[groupItemIndex];
+                let stackHeight = 0;
+                const stackItems = [];
+                const sortedData = sortKey
+                    ? sort(yValues, (a, b) => comparator(get(a, sortKey), get(b, sortKey)))
+                    : yValues;
+                for (let yValueIndex = 0; yValueIndex < sortedData.length; yValueIndex++) {
+                    const yValue = sortedData[yValueIndex];
+                    const yAxisIndex = yValue.series.yAxis;
+                    const seriesYScale = yScale[yAxisIndex];
+                    if (!seriesYScale) {
                         continue;
                     }
-                    xCenter = (xBandScale(xValue) || 0) + xBandScale.bandwidth() / 2;
-                }
-                else {
-                    const xLinearScale = xScale;
-                    xCenter = xLinearScale(Number(xValue));
-                }
-                const x = xCenter - currentGroupWidth / 2 + (rectWidth + rectGap) * groupItemIndex;
-                const yDataValue = ((_a = yValue.data.y) !== null && _a !== void 0 ? _a : 0);
-                const y = seriesYScale(yDataValue);
-                const base = seriesYScale(0);
-                const isLastStackItem = yValueIndex === sortedData.length - 1;
-                const height = yDataValue > 0 ? base - y : y - base;
-                let shapeHeight = height - (stackItems.length ? stackGap : 0);
-                if (shapeHeight < 0) {
-                    shapeHeight = height;
-                }
-                if (shapeHeight < 0) {
-                    continue;
+                    const seriesYAxis = yAxis[yAxisIndex];
+                    const yAxisTop = ((_b = split.plots[seriesYAxis.plotIndex]) === null || _b === void 0 ? void 0 : _b.top) || 0;
+                    let xCenter;
+                    if (xAxis.type === 'category') {
+                        const xBandScale = xScale;
+                        const xBandScaleDomain = xBandScale.domain();
+                        if (xBandScaleDomain.indexOf(xValue) === -1) {
+                            continue;
+                        }
+                        xCenter = (xBandScale(xValue) || 0) + xBandScale.bandwidth() / 2;
+                    }
+                    else {
+                        const xLinearScale = xScale;
+                        xCenter = xLinearScale(Number(xValue));
+                    }
+                    const x = xCenter - currentGroupWidth / 2 + (rectWidth + rectGap) * groupItemIndex;
+                    const yDataValue = ((_c = yValue.data.y) !== null && _c !== void 0 ? _c : 0);
+                    const y = seriesYScale(yDataValue);
+                    const base = seriesYScale(0);
+                    const isLastStackItem = yValueIndex === sortedData.length - 1;
+                    const height = Math.abs(base - y);
+                    let shapeHeight = height - (stackItems.length ? stackGap : 0);
+                    if (shapeHeight < 0) {
+                        shapeHeight = height;
+                    }
+                    if (shapeHeight < 0) {
+                        continue;
+                    }
+                    const barData = {
+                        x,
+                        y: yAxisTop + (yDataValue > 0 ? y - stackHeight : base),
+                        width: rectWidth,
+                        height: shapeHeight,
+                        opacity: get(yValue.data, 'opacity', null),
+                        data: yValue.data,
+                        series: yValue.series,
+                        htmlElements: [],
+                        isLastStackItem,
+                    };
+                    stackItems.push(barData);
+                    stackHeight += height;
                 }
-                const barData = {
-                    x,
-                    y: yDataValue > 0 ? y - stackHeight : seriesYScale(0),
-                    width: rectWidth,
-                    height: shapeHeight,
-                    opacity: get(yValue.data, 'opacity', null),
-                    data: yValue.data,
-                    series: yValue.series,
-                    htmlElements: [],
-                    isLastStackItem,
-                };
-                const label = await getLabelData(barData);
-                if (yValue.series.dataLabels.html && label) {
-                    barData.htmlElements.push({
-                        x: label.x,
-                        y: label.y,
-                        content: label.text,
-                        size: label.size,
-                        style: label.style,
+                if (series.some((s) => s.stacking === 'percent')) {
+                    let acc = 0;
+                    const ratio = plotHeight / (stackHeight - stackItems.length);
+                    stackItems.forEach((item) => {
+                        item.height = item.height * ratio;
+                        item.y = plotHeight - item.height - acc;
+                        acc += item.height + 1;
                     });
                 }
-                else {
-                    barData.label = await getLabelData(barData);
-                }
-                stackItems.push(barData);
-                stackHeight += height;
+                result.push(...stackItems);
             }
-            if (series.some((s) => s.stacking === 'percent')) {
-                let acc = 0;
-                const ratio = plotHeight / (stackHeight - stackItems.length);
-                stackItems.forEach((item) => {
-                    item.height = item.height * ratio;
-                    item.y = plotHeight - item.height - acc;
-                    acc += item.height + 1;
+        }
+    }
+    for (let i = 0; i < result.length; i++) {
+        const barData = result[i];
+        if (barData.series.dataLabels.enabled) {
+            const label = await getLabelData(barData);
+            if (barData.series.dataLabels.html && label) {
+                barData.htmlElements.push({
+                    x: label.x,
+                    y: label.y,
+                    content: label.text,
+                    size: label.size,
+                    style: label.style,
                 });
             }
-            result.push(...stackItems);
+            else {
+                barData.label = label;
+            }
         }
     }
     return result;

package/dist/cjs/hooks/useShapes/bar-y/index.d.ts

@@ -4,10 +4,10 @@ import type { PreparedSeriesOptions } from '../../useSeries/types';
 import type { BarYShapesArgs } from './types';
 export { prepareBarYData } from './prepare-data';
 type Args = {
-    dispatcher: Dispatch<object>;
+    clipPathId: string;
+    htmlLayout: HTMLElement | null;
     preparedData: BarYShapesArgs;
     seriesOptions: PreparedSeriesOptions;
-    htmlLayout: HTMLElement | null;
-    clipPathId: string;
+    dispatcher?: Dispatch<object>;
 };
 export declare function BarYSeriesShapes(args: Args): React.JSX.Element;

package/dist/cjs/hooks/useShapes/bar-y/index.js

@@ -86,9 +86,9 @@ export function BarYSeriesShapes(args) {
         if (hoveredDataRef.current !== null) {
             handleShapeHover(hoveredDataRef.current);
         }
-        dispatcher.on('hover-shape.bar-y', handleShapeHover);
+        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.on('hover-shape.bar-y', handleShapeHover);
         return () => {
-            dispatcher.on('hover-shape.bar-y', null);
+            dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.on('hover-shape.bar-y', null);
         };
     }, [dataLabels, dispatcher, preparedData, seriesOptions]);
     return (React.createElement(React.Fragment, null,

package/dist/cjs/hooks/useShapes/bar-y/prepare-data.d.ts

@@ -1,5 +1,5 @@
+import type { PreparedXAxis, PreparedYAxis } from '../../useAxis/types';
 import type { ChartScale } from '../../useAxisScales';
-import type { PreparedAxis } from '../../useChartOptions/types';
 import type { PreparedBarYSeries, PreparedSeriesOptions } from '../../useSeries/types';
 import type { BarYShapesArgs } from './types';
 export declare function prepareBarYData(args: {
@@ -7,8 +7,8 @@ export declare function prepareBarYData(args: {
     boundsWidth: number;
     series: PreparedBarYSeries[];
     seriesOptions: PreparedSeriesOptions;
-    xAxis: PreparedAxis;
+    xAxis: PreparedXAxis;
     xScale: ChartScale;
-    yAxis: PreparedAxis[];
+    yAxis: PreparedYAxis[];
     yScale: (ChartScale | undefined)[];
 }): Promise<BarYShapesArgs>;