@kubit-ui-web/react-charts 1.10.0 → 1.11.1

package/dist/esm/charts/barChart/fragments/barChartSeparator.js

@@ -1,84 +1,61 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useContext, useEffect } from 'react';
-import { BuildError, buildError, buildSeparatorXBreakAxisError, buildSeparatorXOutOfRangeError, buildSeparatorYBreakAxisError, buildSeparatorYOutOfRangeError, } from '../../../utils/buildErrors/buildErrors';
-import { getPoints } from '../../../utils/getPoints/getPoints';
-import { BarChartContext } from '../context/barChartContext';
-export const BarChartSeparator = ({ areaSeparator, dataTestId, rightSeparator, topSeparator, xBreakAxis, yBreakAxis, }) => {
-    const { addError, crossXAxis, crossYAxis, xAxisCoordinates, yAxisCoordinates } = useContext(BarChartContext);
-    // Extract tick values for stable dependencies
-    const xTickValues = xAxisCoordinates.tickValues;
-    const yTickValues = yAxisCoordinates.tickValues;
-    // Pre-calculate numeric values for dependencies
-    const xBreakNumeric = xBreakAxis !== undefined
-        ? typeof xBreakAxis === 'string'
-            ? parseFloat(xBreakAxis)
-            : xBreakAxis
-        : undefined;
-    const yBreakNumeric = yBreakAxis !== undefined
-        ? typeof yBreakAxis === 'string'
-            ? parseFloat(yBreakAxis)
-            : yBreakAxis
-        : undefined;
-    // Separator error validations
-    useEffect(() => {
-        // xBreakAxis validation
-        if (xBreakAxis !== undefined) {
-            const xValues = xTickValues.map(tick => tick.value);
-            if (xBreakNumeric === undefined || isNaN(xBreakNumeric)) {
-                addError?.('BAR_CHART_SEPARATOR_ERROR', {
-                    error: buildSeparatorXBreakAxisError(xBreakAxis),
-                });
-            }
-            else {
-                const minX = Math.min(...xValues.map(v => (typeof v === 'string' ? parseFloat(v) : v)));
-                const maxX = Math.max(...xValues.map(v => (typeof v === 'string' ? parseFloat(v) : v)));
-                if (xBreakNumeric < minX || xBreakNumeric > maxX) {
-                    addError?.('BAR_CHART_SEPARATOR_ERROR', {
-                        error: buildSeparatorXOutOfRangeError(xBreakNumeric, minX, maxX),
-                    });
-                }
-            }
-        }
-        // yBreakAxis validation
-        if (yBreakAxis !== undefined) {
-            const yValues = yTickValues.map(tick => tick.value);
-            if (yBreakNumeric === undefined || isNaN(yBreakNumeric)) {
-                addError?.('BAR_CHART_SEPARATOR_ERROR', {
-                    error: buildSeparatorYBreakAxisError(yBreakAxis),
-                });
-            }
-            else {
-                const minY = Math.min(...yValues.map(v => (typeof v === 'string' ? parseFloat(v) : v)));
-                const maxY = Math.max(...yValues.map(v => (typeof v === 'string' ? parseFloat(v) : v)));
-                if (yBreakNumeric < minY || yBreakNumeric > maxY) {
-                    addError?.('BAR_CHART_SEPARATOR_ERROR', {
-                        error: buildSeparatorYOutOfRangeError(yBreakNumeric, minY, maxY),
-                    });
-                }
-            }
-        }
-    }, [xBreakAxis, xBreakNumeric, xTickValues, yBreakAxis, yBreakNumeric, yTickValues]);
-    if (!topSeparator && !rightSeparator && !areaSeparator) {
-        return _jsx(_Fragment, {});
-    }
-    const customXEnd = xBreakAxis && getPoints(xAxisCoordinates.tickValues, [xBreakAxis], true)[0];
-    const customYEnd = yBreakAxis && getPoints(yAxisCoordinates.tickValues, [yBreakAxis])[0];
-    const autoXEnd = crossYAxis ? yAxisCoordinates.coordinates.x1 : xAxisCoordinates.coordinates.x2;
-    const autoYEnd = crossXAxis ? xAxisCoordinates.coordinates.y1 : yAxisCoordinates.coordinates.y1;
-    const xStart = xAxisCoordinates.coordinates.x1;
-    const xEnd = customXEnd ?? autoXEnd;
-    const yStart = yAxisCoordinates.coordinates.y2;
-    const yEnd = customYEnd ?? autoYEnd;
-    // Separator positioning validation
-    useEffect(() => {
-        if (xStart === xEnd && yStart === yEnd) {
-            addError?.('BAR_CHART_SEPARATOR_ERROR', {
-                error: buildError(BuildError.LINE_CHART_SEPARATOR_INVALID_COORDINATES),
-            });
-        }
-    }, [xStart, xEnd, yStart, yEnd]);
-    const squarePath = `M${xStart} ${yStart} H ${xEnd} V ${yEnd} H ${xStart} Z`;
-    const lineTop = `M${xStart} ${yEnd} H ${xEnd}`;
-    const lineRight = `M${xEnd} ${yStart} V ${yEnd}`;
-    return (_jsxs("g", { children: [_jsx("path", { d: squarePath, "data-testid": `${dataTestId}Area`, ...areaSeparator }), _jsx("path", { d: lineTop, "data-testid": `${dataTestId}Top`, ...topSeparator }), _jsx("path", { d: lineRight, "data-testid": `${dataTestId}Right`, ...rightSeparator })] }));
+import { BarChartContext } from "../context/barChartContext.js";
+import { BuildError, buildError, buildSeparatorXBreakAxisError, buildSeparatorXOutOfRangeError, buildSeparatorYBreakAxisError, buildSeparatorYOutOfRangeError } from "../../../utils/buildErrors/buildErrors.js";
+import { getPoints } from "../../../utils/getPoints/getPoints.js";
+import { useContext, useEffect } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+const BarChartSeparator = ({ areaSeparator: r, dataTestId: i, rightSeparator: a, topSeparator: o, xBreakAxis: s, yBreakAxis: c }) => {
+	let { addError: l, crossXAxis: u, crossYAxis: d, xAxisCoordinates: f, yAxisCoordinates: p } = useContext(BarChartContext), m = f.tickValues, h = p.tickValues, g = s === void 0 ? void 0 : typeof s == "string" ? parseFloat(s) : s, _ = c === void 0 ? void 0 : typeof c == "string" ? parseFloat(c) : c;
+	if (useEffect(() => {
+		if (s !== void 0) {
+			let e = m.map((e) => e.value);
+			if (g === void 0 || isNaN(g)) l?.("BAR_CHART_SEPARATOR_ERROR", { error: buildSeparatorXBreakAxisError(s) });
+			else {
+				let t = Math.min(...e.map((e) => typeof e == "string" ? parseFloat(e) : e)), n = Math.max(...e.map((e) => typeof e == "string" ? parseFloat(e) : e));
+				(g < t || g > n) && l?.("BAR_CHART_SEPARATOR_ERROR", { error: buildSeparatorXOutOfRangeError(g, t, n) });
+			}
+		}
+		if (c !== void 0) {
+			let e = h.map((e) => e.value);
+			if (_ === void 0 || isNaN(_)) l?.("BAR_CHART_SEPARATOR_ERROR", { error: buildSeparatorYBreakAxisError(c) });
+			else {
+				let t = Math.min(...e.map((e) => typeof e == "string" ? parseFloat(e) : e)), n = Math.max(...e.map((e) => typeof e == "string" ? parseFloat(e) : e));
+				(_ < t || _ > n) && l?.("BAR_CHART_SEPARATOR_ERROR", { error: buildSeparatorYOutOfRangeError(_, t, n) });
+			}
+		}
+	}, [
+		s,
+		g,
+		m,
+		c,
+		_,
+		h
+	]), !o && !a && !r) return /* @__PURE__ */ jsx(Fragment, {});
+	let v = s && getPoints(f.tickValues, [s], !0)[0], y = c && getPoints(p.tickValues, [c])[0], b = d ? p.coordinates.x1 : f.coordinates.x2, x = u ? f.coordinates.y1 : p.coordinates.y1, S = f.coordinates.x1, C = v ?? b, w = p.coordinates.y2, T = y ?? x;
+	useEffect(() => {
+		S === C && w === T && l?.("BAR_CHART_SEPARATOR_ERROR", { error: buildError(BuildError.LINE_CHART_SEPARATOR_INVALID_COORDINATES) });
+	}, [
+		S,
+		C,
+		w,
+		T
+	]);
+	let E = `M${S} ${w} H ${C} V ${T} H ${S} Z`, D = `M${S} ${T} H ${C}`, O = `M${C} ${w} V ${T}`;
+	return /* @__PURE__ */ jsxs("g", { children: [
+		/* @__PURE__ */ jsx("path", {
+			d: E,
+			"data-testid": `${i}Area`,
+			...r
+		}),
+		/* @__PURE__ */ jsx("path", {
+			d: D,
+			"data-testid": `${i}Top`,
+			...o
+		}),
+		/* @__PURE__ */ jsx("path", {
+			d: O,
+			"data-testid": `${i}Right`,
+			...a
+		})
+	] });
 };
+export { BarChartSeparator };

package/dist/esm/charts/barChart/fragments/barChartXAxis.js

@@ -1,28 +1,32 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext } from 'react';
-import { XAxis } from '../../../components/axisChart/xAxis/xAxis';
-import { Positions } from '../../../types/position.enum';
-import { getTickTextYCoordinate } from '../../../utils/getTickTextCoordinate/getTickTextCoordinates';
-import { CHART_SPACING_DEFAULTS } from '../../constants/chartDefaults';
-import { BarChartContext } from '../context/barChartContext';
-export const BarChartXAxis = ({ position = Positions.BOTTOM, tickLine, tickText, ...props }) => {
-    const { xAxisCoordinates: { coordinates, tickValues }, 
-    // xCursor,
-    ...context } = useContext(BarChartContext);
-    const tickTextY = getTickTextYCoordinate(position, coordinates.y1, Number(tickText?.fontSize), tickText?.top ?? CHART_SPACING_DEFAULTS.DEFAULT_SPACE);
-    const y1 = context.extraSpaceTopY;
-    const y2 = Number(context.canvasHeight) - context.extraSpaceBottomY;
-    return (_jsx(XAxis, { ...coordinates, ...props, canvasHeight: Number(context.canvasHeight), canvasWidth: Number(context.canvasWidth), 
-        // cursor={xCursor}
-        dataTestId: `${context.dataTestId}xAxis`, extraSpace: {
-            left: context.extraSpaceLeftX,
-            right: context.extraSpaceRightX,
-        }, tickLine: {
-            ...tickLine,
-            y1,
-            y2,
-        }, tickText: {
-            ...tickText,
-            y: tickTextY,
-        }, tickValues: tickText ? tickValues : undefined }));
+import { BarChartContext } from "../context/barChartContext.js";
+import { Positions } from "../../../types/position.enum.js";
+import { CHART_SPACING_DEFAULTS } from "../../constants/chartDefaults.js";
+import { XAxis } from "../../../components/axisChart/xAxis/xAxis.js";
+import { getTickTextYCoordinate } from "../../../utils/getTickTextCoordinate/getTickTextCoordinates.js";
+import { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+const BarChartXAxis = ({ position: e = Positions.BOTTOM, tickLine: t, tickText: n, ...r }) => {
+	let { xAxisCoordinates: { coordinates: i, tickValues: a }, ...o } = useContext(BarChartContext), s = getTickTextYCoordinate(e, i.y1, Number(n?.fontSize), n?.top ?? CHART_SPACING_DEFAULTS.DEFAULT_SPACE), c = o.extraSpaceTopY, l = Number(o.canvasHeight) - o.extraSpaceBottomY;
+	return /* @__PURE__ */ jsx(XAxis, {
+		...i,
+		...r,
+		canvasHeight: Number(o.canvasHeight),
+		canvasWidth: Number(o.canvasWidth),
+		dataTestId: `${o.dataTestId}xAxis`,
+		extraSpace: {
+			left: o.extraSpaceLeftX,
+			right: o.extraSpaceRightX
+		},
+		tickLine: {
+			...t,
+			y1: c,
+			y2: l
+		},
+		tickText: {
+			...n,
+			y: s
+		},
+		tickValues: n ? a : void 0
+	});
 };
+export { BarChartXAxis };

package/dist/esm/charts/barChart/fragments/barChartYAxis.js

@@ -1,21 +1,29 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext } from 'react';
-import { YAxis } from '../../../components/axisChart/yAxis/yAxis';
-import { Positions } from '../../../types/position.enum';
-import { ajustedTextSpace } from '../../../utils/ajustedTextSpace/ajustedTextSpace';
-import { getTickTextXCoordinate } from '../../../utils/getTickTextCoordinate/getTickTextCoordinates';
-import { CHART_SPACING_DEFAULTS } from '../../constants/chartDefaults';
-import { BarChartContext } from '../context/barChartContext';
-export const BarChartYAxis = ({ position = Positions.LEFT, tickLine, tickText, ...props }) => {
-    const { yAxisCoordinates: { coordinates, tickValues }, ...context } = useContext(BarChartContext);
-    const textAnchor = tickText?.textAnchor || 'middle';
-    const addSpace = position === Positions.RIGHT ? tickText?.right : tickText?.left;
-    const ajustedSpace = addSpace ?? CHART_SPACING_DEFAULTS.DEFAULT_SPACE;
-    const ajustedText = ajustedTextSpace(textAnchor, context.yAxisText, ajustedSpace);
-    const xTickText = getTickTextXCoordinate(position, coordinates.x1, ajustedText);
-    return (_jsx(YAxis, { ...coordinates, ...props, canvasHeight: Number(context.canvasHeight), canvasWidth: Number(context.canvasWidth), dataTestId: `${context.dataTestId}yAxis`, tickLine: {
-            ...tickLine,
-            x1: context.extraSpaceLeftX,
-            x2: Number(context.canvasWidth) - context.extraSpaceRightX,
-        }, tickText: { ...tickText, x: xTickText }, tickValues: tickText ? tickValues : undefined }));
+import { BarChartContext } from "../context/barChartContext.js";
+import { Positions } from "../../../types/position.enum.js";
+import { CHART_SPACING_DEFAULTS } from "../../constants/chartDefaults.js";
+import { getTickTextXCoordinate } from "../../../utils/getTickTextCoordinate/getTickTextCoordinates.js";
+import { YAxis } from "../../../components/axisChart/yAxis/yAxis.js";
+import { ajustedTextSpace } from "../../../utils/ajustedTextSpace/ajustedTextSpace.js";
+import { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+const BarChartYAxis = ({ position: e = Positions.LEFT, tickLine: t, tickText: n, ...r }) => {
+	let { yAxisCoordinates: { coordinates: i, tickValues: a }, ...o } = useContext(BarChartContext), s = ajustedTextSpace(n?.textAnchor || "middle", o.yAxisText, (e === Positions.RIGHT ? n?.right : n?.left) ?? CHART_SPACING_DEFAULTS.DEFAULT_SPACE), c = getTickTextXCoordinate(e, i.x1, s);
+	return /* @__PURE__ */ jsx(YAxis, {
+		...i,
+		...r,
+		canvasHeight: Number(o.canvasHeight),
+		canvasWidth: Number(o.canvasWidth),
+		dataTestId: `${o.dataTestId}yAxis`,
+		tickLine: {
+			...t,
+			x1: o.extraSpaceLeftX,
+			x2: Number(o.canvasWidth) - o.extraSpaceRightX
+		},
+		tickText: {
+			...n,
+			x: c
+		},
+		tickValues: n ? a : void 0
+	});
 };
+export { BarChartYAxis };

package/dist/esm/charts/barChart/index.js

@@ -1 +1 @@
-export * from './barChart';
+export * from './barChart.js';

package/dist/esm/charts/barChart/utils/countBarChildren.js

@@ -1,11 +1,9 @@
-import { Children, isValidElement } from 'react';
-import { BarChartPath } from '../fragments/barChartPath';
-export const countBarChildren = (children) => {
-    let higherOrder = 0;
-    Children.toArray(children).forEach(child => {
-        if (isValidElement(child) && child.type === BarChartPath && child.props.order > higherOrder) {
-            higherOrder = child.props.order;
-        }
-    });
-    return higherOrder;
+import { BarChartPath } from "../fragments/barChartPath.js";
+import { Children, isValidElement } from "react";
+const countBarChildren = (t) => {
+	let n = 0;
+	return Children.toArray(t).forEach((e) => {
+		isValidElement(e) && e.type === BarChartPath && e.props.order > n && (n = e.props.order);
+	}), n;
 };
+export { countBarChildren };

package/dist/esm/charts/barChart/utils/getAxisExtraSpacing.js

@@ -1,116 +1,82 @@
-import { Children, isValidElement } from 'react';
-import { BarOrientation } from '../../../components/bar/bar.type';
-import { Positions } from '../../../types/position.enum';
-import { buildTickValues } from '../../../utils/buildTickValues/buildTickValues';
-import { textBound } from '../../../utils/textBound/textBound';
-import { BarChartPath } from '../fragments/barChartPath';
-import { BarChartXAxis } from '../fragments/barChartXAxis';
-import { BarChartYAxis } from '../fragments/barChartYAxis';
-import { getBarDataValues } from './getBarDataValue';
-import { getBarKeyRoundMaxValue } from './getRoundedBarMaxValue';
-const handleBarChartXAxis = (child, data, pKey, ajustedX, barsSpacing, viewBox, canvasHeight, canvasWidth) => {
-    const { position, tickText, tickValues } = child.props;
-    const fontSize = tickText?.fontSize ?? 0;
-    const spaceFontSize = fontSize * ajustedX;
-    const xData = tickValues
-        ? getBarDataValues(tickValues)
-        : data.map(d => d[pKey]);
-    const fontSpacing = textBound({
-        bound: 'width',
-        data: xData,
-        fontSize,
-        svgHeight: `${canvasHeight}`,
-        svgWidth: `${canvasWidth}`,
-        viewBox,
-    });
-    const securityXSpace = (() => (barsSpacing > fontSpacing ? barsSpacing : fontSpacing))();
-    const extraSpaceBottomY = position === Positions.BOTTOM ? spaceFontSize + (tickText?.top ?? 0) : 0;
-    const extraSpaceTopY = position === Positions.TOP ? spaceFontSize + (tickText?.bottom ?? 0) : 0;
-    const barChartXPosition = (() => position || Positions.BOTTOM)();
-    const xBreakAxis = tickValues?.numeric
-        ? (tickValues.numeric.breakAxis ?? 0)
-        : (tickText?.custom?.breakAxis ?? 0);
-    return {
-        barChartXPosition,
-        extraSpaceBottomY,
-        extraSpaceTopY,
-        securityXSpace,
-        xBreakAxis,
-        xData,
-    };
+import { BarOrientation } from "../../../components/bar/bar.type.js";
+import { Positions } from "../../../types/position.enum.js";
+import { BarChartPath } from "../fragments/barChartPath.js";
+import { buildTickValues } from "../../../utils/buildTickValues/buildTickValues.js";
+import { textBound } from "../../../utils/textBound/textBound.js";
+import { BarChartXAxis } from "../fragments/barChartXAxis.js";
+import { BarChartYAxis } from "../fragments/barChartYAxis.js";
+import { getBarDataValues } from "./getBarDataValue.js";
+import { getBarKeyRoundMaxValue } from "./getRoundedBarMaxValue.js";
+import { Children, isValidElement } from "react";
+var handleBarChartXAxis = (e, n, r, a, o, c, l, u) => {
+	let { position: d, tickText: f, tickValues: p } = e.props, m = f?.fontSize ?? 0, h = m * a, g = p ? getBarDataValues(p) : n.map((e) => e[r]), _ = textBound({
+		bound: "width",
+		data: g,
+		fontSize: m,
+		svgHeight: `${l}`,
+		svgWidth: `${u}`,
+		viewBox: c
+	}), v = o > _ ? o : _, y = d === Positions.BOTTOM ? h + (f?.top ?? 0) : 0, b = d === Positions.TOP ? h + (f?.bottom ?? 0) : 0;
+	return {
+		barChartXPosition: d || Positions.BOTTOM,
+		extraSpaceBottomY: y,
+		extraSpaceTopY: b,
+		securityXSpace: v,
+		xBreakAxis: p?.numeric ? p.numeric.breakAxis ?? 0 : f?.custom?.breakAxis ?? 0,
+		xData: g
+	};
+}, handleBarChartYAxis = (e, n, a, o, l, u, d, f) => {
+	let { position: p, tickText: m, tickValues: h } = e.props, g = m?.fontSize ?? 0, _ = g * o, v = getBarDataValues(h || buildTickValues([...new Set(getBarKeyRoundMaxValue(n, a))])), y = l > _ ? l : _, b = textBound({
+		bound: "width",
+		data: v,
+		fontSize: g,
+		svgHeight: `${d}`,
+		svgWidth: `${f}`,
+		viewBox: u
+	}), x = p === Positions.LEFT ? b + (m?.right ?? 0) : 0, S = p === Positions.RIGHT ? b + (m?.left ?? 0) : 0;
+	return {
+		barChartYPosition: p || Positions.LEFT,
+		extraSpaceLeftX: x,
+		extraSpaceRightX: S,
+		securityYSpace: y,
+		yAxisText: b,
+		yBreakAxis: h?.numeric ? h.numeric.breakAxis ?? 0 : m?.custom?.breakAxis ?? 0,
+		yData: v
+	};
 };
-const handleBarChartYAxis = (child, data, pKey, ajustedY, barSpacing, viewBox, canvasHeight, canvasWidth) => {
-    const { position, tickText, tickValues } = child.props;
-    const fontSize = tickText?.fontSize ?? 0;
-    const spaceFontSize = fontSize * ajustedY; //! review
-    const dataValues = tickValues ||
-        buildTickValues([...new Set(getBarKeyRoundMaxValue(data, pKey))]);
-    const yData = getBarDataValues(dataValues);
-    const securityYSpace = (() => (barSpacing > spaceFontSize ? barSpacing : spaceFontSize))();
-    const textWidth = textBound({
-        bound: 'width',
-        data: yData,
-        fontSize,
-        svgHeight: `${canvasHeight}`,
-        svgWidth: `${canvasWidth}`,
-        viewBox,
-    });
-    const extraSpaceLeftX = position === Positions.LEFT ? textWidth + (tickText?.right ?? 0) : 0;
-    const extraSpaceRightX = position === Positions.RIGHT ? textWidth + (tickText?.left ?? 0) : 0;
-    const barChartYPosition = (() => position || Positions.LEFT)();
-    const yBreakAxis = tickValues?.numeric
-        ? (tickValues.numeric.breakAxis ?? 0)
-        : (tickText?.custom?.breakAxis ?? 0);
-    return {
-        barChartYPosition,
-        extraSpaceLeftX,
-        extraSpaceRightX,
-        securityYSpace,
-        yAxisText: textWidth,
-        yBreakAxis,
-        yData,
-    };
-};
-export const getAxisExtraSpacing = ({ ajustedX, ajustedY, canvasHeight, canvasWidth, children, data, gapBetweenBars, orientation, pKey, viewBox, }) => {
-    let result = {
-        barChartXPosition: Positions.BOTTOM,
-        barChartYPosition: Positions.LEFT,
-        extraSpaceBottomY: 0,
-        extraSpaceLeftX: 0,
-        extraSpaceRightX: 0,
-        extraSpaceTopY: 0,
-        securityXSpace: 0,
-        securityYSpace: 0,
-        xAxisText: 0,
-        xBreakAxis: 0,
-        xData: [],
-        yAxisText: 0,
-        yBreakAxis: 0,
-        yData: [],
-    };
-    let barsSpacing = gapBetweenBars;
-    const reviews = [];
-    Children.forEach(children, (child) => {
-        if (isValidElement(child)) {
-            if (child.type === BarChartPath && !reviews.includes(child.props.order)) {
-                reviews.push(child.props.order);
-                barsSpacing += child.props.barConfig.barWidth ?? 0;
-            }
-            if (child.type === BarChartXAxis) {
-                const securitySpace = orientation === BarOrientation.VERTICAL ? barsSpacing : 0;
-                result = {
-                    ...result,
-                    ...handleBarChartXAxis(child, data, pKey, ajustedX, securitySpace, viewBox, canvasHeight, canvasWidth),
-                };
-            }
-            else if (child.type === BarChartYAxis) {
-                const securitySpace = orientation === BarOrientation.HORIZONTAL ? barsSpacing : 0;
-                result = {
-                    ...result,
-                    ...handleBarChartYAxis(child, data, pKey, ajustedY, securitySpace, viewBox, canvasHeight, canvasWidth),
-                };
-            }
-        }
-    });
-    return result;
+const getAxisExtraSpacing = ({ ajustedX: r, ajustedY: i, canvasHeight: s, canvasWidth: c, children: p, data: m, gapBetweenBars: h, orientation: g, pKey: _, viewBox: v }) => {
+	let y = {
+		barChartXPosition: Positions.BOTTOM,
+		barChartYPosition: Positions.LEFT,
+		extraSpaceBottomY: 0,
+		extraSpaceLeftX: 0,
+		extraSpaceRightX: 0,
+		extraSpaceTopY: 0,
+		securityXSpace: 0,
+		securityYSpace: 0,
+		xAxisText: 0,
+		xBreakAxis: 0,
+		xData: [],
+		yAxisText: 0,
+		yBreakAxis: 0,
+		yData: []
+	}, b = h, x = [];
+	return Children.forEach(p, (t) => {
+		if (isValidElement(t)) {
+			if (t.type === BarChartPath && !x.includes(t.props.order) && (x.push(t.props.order), b += t.props.barConfig.barWidth ?? 0), t.type === BarChartXAxis) {
+				let n = g === BarOrientation.VERTICAL ? b : 0;
+				y = {
+					...y,
+					...handleBarChartXAxis(t, m, _, r, n, v, s, c)
+				};
+			} else if (t.type === BarChartYAxis) {
+				let n = g === BarOrientation.HORIZONTAL ? b : 0;
+				y = {
+					...y,
+					...handleBarChartYAxis(t, m, _, i, n, v, s, c)
+				};
+			}
+		}
+	}), y;
 };
+export { getAxisExtraSpacing };

package/dist/esm/charts/barChart/utils/getBarDataValue.js

@@ -1,24 +1,11 @@
-/**
- * Retrieves the data values from the given BarTickValuesAxisProps object.
- * @param data - The BarTickValuesAxisProps object containing the data values.
- * @returns An array of string values representing the data, or undefined if the data is invalid.
- */
-export const getBarDataValues = (data) => {
-    if (data.custom) {
-        return data.custom?.values;
-    }
-    if (data.numeric) {
-        const { max, min = 0, step } = data.numeric;
-        // Verify if the step is larger or equal than the range
-        const range = Math.abs(max - min);
-        if (step >= range || step <= 0) {
-            return [min.toString()];
-        }
-        const stepper = [];
-        for (let i = min; i <= max; i += step) {
-            stepper.push(i.toString());
-        }
-        return stepper;
-    }
-    return undefined;
+const getBarDataValues = (e) => {
+	if (e.custom) return e.custom?.values;
+	if (e.numeric) {
+		let { max: t, min: n = 0, step: r } = e.numeric;
+		if (r >= Math.abs(t - n) || r <= 0) return [n.toString()];
+		let i = [];
+		for (let e = n; e <= t; e += r) i.push(e.toString());
+		return i;
+	}
 };
+export { getBarDataValues };

package/dist/esm/charts/barChart/utils/getRoundedBarMaxValue.js

@@ -1,11 +1,2 @@
-/**
- * Returns an array of rounded maximum values for each yKey in the given data.
- * @param data - The array of data points.
- * @param xKey - The xKey used for filtering the data.
- * @returns An array of rounded maximum values.
- */
-export const getBarKeyRoundMaxValue = (data, Key) => {
-    return data.flatMap(point => Object.keys(point)
-        .filter(k => k !== Key && typeof point[k] === 'number')
-        .map(k => Number(point[k])));
-};
+const getBarKeyRoundMaxValue = (e, t) => e.flatMap((e) => Object.keys(e).filter((n) => n !== t && typeof e[n] == "number").map((t) => Number(e[t])));
+export { getBarKeyRoundMaxValue };