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

package/dist/esm/charts/barChart/context/buildBarContextValues.js

@@ -1,262 +1,156 @@
-import { BarOrientation } from '../../../components/bar/bar.type';
-import { ErrorType } from '../../../types/errors.type';
-import { Positions } from '../../../types/position.enum';
-import { BuildError, buildBarDistributionError, buildCanvasDimensionsError, buildError, } from '../../../utils/buildErrors/buildErrors';
-import { getXCoordinates, getYCoordinates } from '../../../utils/getCoordinates/getCoordinates';
-import { getPoints } from '../../../utils/getPoints/getPoints';
-import { getXTicks, getYTicks } from '../../../utils/getTicks/getTicks';
-import { AXIS_VALIDATION, BAR_CHART_DEFAULTS, BAR_CHART_FALLBACK_DATA, BREAK_AXIS_DEFAULTS, CHART_CANVAS_DEFAULTS, SHARED_FALLBACK_DATA, } from '../../constants/chartDefaults';
-import { countBarChildren } from '../utils/countBarChildren';
-import { getAxisExtraSpacing } from '../utils/getAxisExtraSpacing';
-/**
- * Builds the context value for the line chart.
- *
- * @param {BuildContextValue} options - The options for building the context value.
- * @returns {LineContextValue} - The built context value.
- */
-export const buildBarContextValue = ({ addError, ajustedX, ajustedY, canvasHeight, canvasWidth, children, data, gapBetweenBars, orientation, pKey, viewBox, }) => {
-    let error = undefined;
-    // 1. Validate data exists
-    if (!data || data.length === 0) {
-        const dataError = {
-            error: buildError(BuildError.BAR_CHART_NO_DATA),
-        };
-        addError?.('BAR_CHART_CONTEXT_ERROR', dataError);
-        error = dataError;
-    }
-    // 2. Validate canvas dimensions
-    if (canvasWidth <= 0 || canvasHeight <= 0) {
-        const canvasError = {
-            error: buildCanvasDimensionsError(canvasWidth, canvasHeight),
-        };
-        addError?.('BAR_CHART_CONTEXT_ERROR', canvasError);
-        error = canvasError;
-    }
-    // 3. Validate bar spacing and distribution
-    const barChildrenCount = countBarChildren(children);
-    const defaultBarWidth = BAR_CHART_DEFAULTS.BAR_WIDTH; // Default width used in BarChartPath
-    const requiredSpace = barChildrenCount * defaultBarWidth;
-    const totalGapSpace = (barChildrenCount - 1) * gapBetweenBars;
-    const availableSpace = orientation === BarOrientation.VERTICAL ? canvasWidth : canvasHeight;
-    if (requiredSpace + totalGapSpace > availableSpace) {
-        const distributionError = {
-            error: buildBarDistributionError('all', `Insufficient space: requires ${requiredSpace + totalGapSpace}px but only ${availableSpace}px available`),
-        };
-        addError?.('BAR_CHART_CONTEXT_ERROR', distributionError);
-        error = distributionError;
-    }
-    // Use safe defaults for data processing if there are critical errors
-    const safeData = data && data.length > 0
-        ? data
-        : [
-            {
-                [BAR_CHART_FALLBACK_DATA.FALLBACK_SECONDARY_KEY]: BAR_CHART_FALLBACK_DATA.DEFAULT_X_VALUE,
-                [pKey]: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST,
-            },
-            {
-                [BAR_CHART_FALLBACK_DATA.FALLBACK_SECONDARY_KEY]: BAR_CHART_FALLBACK_DATA.DEFAULT_X_VALUE,
-                [pKey]: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND,
-            },
-        ];
-    const safeCanvasWidth = canvasWidth > 0 ? canvasWidth : CHART_CANVAS_DEFAULTS.SAFE_WIDTH;
-    const safeCanvasHeight = canvasHeight > 0 ? canvasHeight : CHART_CANVAS_DEFAULTS.SAFE_HEIGHT;
-    /**
-     * Get the extra spacings for the line chart.
-     */
-    const { barChartXPosition, barChartYPosition, extraSpaceBottomY, extraSpaceLeftX, extraSpaceRightX, extraSpaceTopY, securityXSpace, securityYSpace, xAxisText, xBreakAxis, xData, yAxisText, yBreakAxis, yData, } = getAxisExtraSpacing({
-        ajustedX,
-        ajustedY,
-        canvasHeight: safeCanvasHeight,
-        canvasWidth: safeCanvasWidth,
-        children,
-        data: safeData,
-        gapBetweenBars,
-        orientation,
-        pKey,
-        viewBox,
-    });
-    /**
-     * Calculate the tick values for the X Axis.
-     */
-    const crossXAxis = barChartXPosition !== Positions.TOP && barChartXPosition !== Positions.BOTTOM;
-    const yAxisSpace = extraSpaceLeftX + extraSpaceRightX;
-    const xTickValue = getXTicks({
-        initPos: extraSpaceLeftX,
-        maxSpaceAvailable: safeCanvasWidth,
-        otherAxisSpace: yAxisSpace,
-        securitySpace: securityXSpace,
-        tickValues: xData,
-    });
-    if ((xTickValue ?? []).some(({ position }) => isNaN(position))) {
-        const xTickError = {
-            error: buildError(BuildError.INVALID_X_TICK),
-        };
-        addError?.('BAR_CHART_CONTEXT_ERROR', xTickError);
-        error = xTickError;
-    }
-    // Validate X-axis tick values
-    if (xTickValue) {
-        const hasInsufficientTicks = xTickValue.length < AXIS_VALIDATION.MIN_TICK_COUNT;
-        const hasIdenticalValues = xTickValue.length >= AXIS_VALIDATION.MIN_TICK_COUNT &&
-            new Set(xTickValue.map(tick => tick.value)).size === AXIS_VALIDATION.UNIQUE_VALUE_THRESHOLD;
-        if (hasInsufficientTicks) {
-            const xAxisError = {
-                error: buildError(BuildError.LINE_CHART_X_AXIS_INSUFFICIENT_TICKS),
-            };
-            addError?.('BAR_CHART_X_AXIS_ERROR', xAxisError);
-            if (!error) {
-                error = xAxisError;
-            }
-        }
-        if (hasIdenticalValues) {
-            const xAxisError = {
-                error: buildError(BuildError.LINE_CHART_X_AXIS_IDENTICAL_VALUES),
-            };
-            addError?.('BAR_CHART_X_AXIS_ERROR', xAxisError);
-            if (!error) {
-                error = xAxisError;
-            }
-        }
-    }
-    /**
-     * Calculate the tick values for the Y Axis.
-     */
-    const crossYAxis = barChartYPosition !== Positions.LEFT && barChartYPosition !== Positions.RIGHT;
-    const otherAxisSpace = extraSpaceTopY + extraSpaceBottomY;
-    const yTickValue = getYTicks({
-        initPos: safeCanvasHeight - extraSpaceBottomY,
-        maxSpaceAvailable: safeCanvasHeight,
-        needAjusted: orientation === BarOrientation.HORIZONTAL,
-        otherAxisSpace,
-        securitySpace: securityYSpace,
-        tickValues: yData,
-    });
-    // Validate Y-axis tick values
-    if (yTickValue) {
-        const hasInsufficientTicks = yTickValue.length < AXIS_VALIDATION.MIN_TICK_COUNT;
-        const hasIdenticalValues = yTickValue.length >= AXIS_VALIDATION.MIN_TICK_COUNT &&
-            new Set(yTickValue.map(tick => tick.value)).size === AXIS_VALIDATION.UNIQUE_VALUE_THRESHOLD;
-        if (hasInsufficientTicks) {
-            const yAxisError = {
-                error: buildError(BuildError.LINE_CHART_Y_AXIS_INSUFFICIENT_TICKS),
-            };
-            addError?.('BAR_CHART_Y_AXIS_ERROR', yAxisError);
-            if (!error) {
-                error = yAxisError;
-            }
-        }
-        if (hasIdenticalValues) {
-            const yAxisError = {
-                error: buildError(BuildError.LINE_CHART_Y_AXIS_IDENTICAL_VALUES),
-            };
-            addError?.('BAR_CHART_Y_AXIS_ERROR', yAxisError);
-            if (!error) {
-                error = yAxisError;
-            }
-        }
-    }
-    /**
-     * Calculate the custom breakAxis for the X and Y Axis.
-     */
-    const customBreakXAxis = crossXAxis
-        ? getPoints(yTickValue || [], [String(xBreakAxis)])[0]
-        : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE;
-    const customBreakYAxis = crossYAxis
-        ? getPoints(xTickValue || [], [String(yBreakAxis)])[0]
-        : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE;
-    /**
-     * Calculate the X coordinates for the line chart.
-     */
-    const xCoordinates = getXCoordinates({
-        canvasHeight: safeCanvasHeight,
-        canvasWidth: safeCanvasWidth,
-        customBreakAxis: Number(customBreakXAxis),
-        extraSpaceBottomY,
-        extraSpaceLeftX,
-        extraSpaceRightX,
-        extraSpaceTopY,
-        position: barChartXPosition,
-        securityYSpace,
-    });
-    /**
-     * Calculate the Y coordinates for the line chart.
-     */
-    const yCoordinates = getYCoordinates({
-        canvasHeight: safeCanvasHeight,
-        canvasWidth: safeCanvasWidth,
-        customBreakAxis: Number(customBreakYAxis),
-        extraSpaceBottomY,
-        extraSpaceLeftX,
-        extraSpaceRightX,
-        extraSpaceTopY,
-        position: barChartYPosition,
-        securityYSpace,
-    });
-    // Validate axis coordinates for zero-length axes
-    if (xCoordinates.x1 === xCoordinates.x2) {
-        const xAxisError = {
-            error: buildError(BuildError.LINE_CHART_X_AXIS_ZERO_LENGTH),
-        };
-        addError?.('BAR_CHART_X_AXIS_ERROR', xAxisError);
-        if (!error) {
-            error = xAxisError;
-        }
-    }
-    if (yCoordinates.y1 === yCoordinates.y2) {
-        const yAxisError = {
-            error: buildError(BuildError.LINE_CHART_Y_AXIS_ZERO_LENGTH),
-        };
-        addError?.('BAR_CHART_Y_AXIS_ERROR', yAxisError);
-        if (!error) {
-            error = yAxisError;
-        }
-    }
-    const baseContext = {
-        addError,
-        crossXAxis,
-        crossYAxis,
-        data: safeData,
-        extraSpaceBottomY,
-        extraSpaceLeftX,
-        extraSpaceRightX,
-        extraSpaceTopY,
-        securityXSpace,
-        securityYSpace,
-        xAxisCoordinates: {
-            coordinates: xCoordinates,
-            tickValues: xTickValue ||
-                (error
-                    ? [
-                        {
-                            position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
-                            value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST,
-                        },
-                        { position: safeCanvasWidth, value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND },
-                    ]
-                    : []),
-        },
-        xAxisText,
-        yAxisCoordinates: {
-            coordinates: yCoordinates,
-            tickValues: yTickValue ||
-                (error
-                    ? [
-                        { position: safeCanvasHeight, value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST },
-                        {
-                            position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
-                            value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND,
-                        },
-                    ]
-                    : []),
-        },
-        yAxisText,
-    };
-    // Add error only if it exists
-    if (error) {
-        return {
-            ...baseContext,
-            error: { ...error, type: ErrorType.BAR_CHART_CONTEXT_ERROR },
-        };
-    }
-    return baseContext;
+import { BarOrientation } from "../../../components/bar/bar.type.js";
+import { ErrorType } from "../../../types/errors.type.js";
+import { Positions } from "../../../types/position.enum.js";
+import { buildBarDistributionError } from "../../../utils/buildErrors/charts/buildBarChartErrors.js";
+import { BuildError, buildCanvasDimensionsError, buildError } from "../../../utils/buildErrors/buildErrors.js";
+import { getXCoordinates, getYCoordinates } from "../../../utils/getCoordinates/getCoordinates.js";
+import { getPoints } from "../../../utils/getPoints/getPoints.js";
+import { getXTicks, getYTicks } from "../../../utils/getTicks/getTicks.js";
+import { AXIS_VALIDATION, BAR_CHART_DEFAULTS, BAR_CHART_FALLBACK_DATA, BREAK_AXIS_DEFAULTS, CHART_CANVAS_DEFAULTS, SHARED_FALLBACK_DATA } from "../../constants/chartDefaults.js";
+import { countBarChildren } from "../utils/countBarChildren.js";
+import { getAxisExtraSpacing } from "../utils/getAxisExtraSpacing.js";
+const buildBarContextValue = ({ addError: n, ajustedX: r, ajustedY: i, canvasHeight: a, canvasWidth: o, children: s, data: c, gapBetweenBars: l, orientation: u, pKey: d, viewBox: f }) => {
+	let p;
+	if (!c || c.length === 0) {
+		let e = { error: buildError(BuildError.BAR_CHART_NO_DATA) };
+		n?.("BAR_CHART_CONTEXT_ERROR", e), p = e;
+	}
+	if (o <= 0 || a <= 0) {
+		let e = { error: buildCanvasDimensionsError(o, a) };
+		n?.("BAR_CHART_CONTEXT_ERROR", e), p = e;
+	}
+	let m = countBarChildren(s), h = m * BAR_CHART_DEFAULTS.BAR_WIDTH, g = (m - 1) * l, _ = u === BarOrientation.VERTICAL ? o : a;
+	if (h + g > _) {
+		let e = { error: buildBarDistributionError("all", `Insufficient space: requires ${h + g}px but only ${_}px available`) };
+		n?.("BAR_CHART_CONTEXT_ERROR", e), p = e;
+	}
+	let v = c && c.length > 0 ? c : [{
+		[BAR_CHART_FALLBACK_DATA.FALLBACK_SECONDARY_KEY]: BAR_CHART_FALLBACK_DATA.DEFAULT_X_VALUE,
+		[d]: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST
+	}, {
+		[BAR_CHART_FALLBACK_DATA.FALLBACK_SECONDARY_KEY]: BAR_CHART_FALLBACK_DATA.DEFAULT_X_VALUE,
+		[d]: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND
+	}], y = o > 0 ? o : CHART_CANVAS_DEFAULTS.SAFE_WIDTH, b = a > 0 ? a : CHART_CANVAS_DEFAULTS.SAFE_HEIGHT, { barChartXPosition: x, barChartYPosition: S, extraSpaceBottomY: C, extraSpaceLeftX: w, extraSpaceRightX: T, extraSpaceTopY: E, securityXSpace: D, securityYSpace: O, xAxisText: k, xBreakAxis: A, xData: j, yAxisText: M, yBreakAxis: N, yData: P } = getAxisExtraSpacing({
+		ajustedX: r,
+		ajustedY: i,
+		canvasHeight: b,
+		canvasWidth: y,
+		children: s,
+		data: v,
+		gapBetweenBars: l,
+		orientation: u,
+		pKey: d,
+		viewBox: f
+	}), F = x !== Positions.TOP && x !== Positions.BOTTOM, I = getXTicks({
+		initPos: w,
+		maxSpaceAvailable: y,
+		otherAxisSpace: w + T,
+		securitySpace: D,
+		tickValues: j
+	});
+	if ((I ?? []).some(({ position: e }) => isNaN(e))) {
+		let e = { error: buildError(BuildError.INVALID_X_TICK) };
+		n?.("BAR_CHART_CONTEXT_ERROR", e), p = e;
+	}
+	if (I) {
+		let e = I.length < AXIS_VALIDATION.MIN_TICK_COUNT, t = I.length >= AXIS_VALIDATION.MIN_TICK_COUNT && new Set(I.map((e) => e.value)).size === AXIS_VALIDATION.UNIQUE_VALUE_THRESHOLD;
+		if (e) {
+			let e = { error: buildError(BuildError.LINE_CHART_X_AXIS_INSUFFICIENT_TICKS) };
+			n?.("BAR_CHART_X_AXIS_ERROR", e), p ||= e;
+		}
+		if (t) {
+			let e = { error: buildError(BuildError.LINE_CHART_X_AXIS_IDENTICAL_VALUES) };
+			n?.("BAR_CHART_X_AXIS_ERROR", e), p ||= e;
+		}
+	}
+	let L = S !== Positions.LEFT && S !== Positions.RIGHT, R = E + C, z = getYTicks({
+		initPos: b - C,
+		maxSpaceAvailable: b,
+		needAjusted: u === BarOrientation.HORIZONTAL,
+		otherAxisSpace: R,
+		securitySpace: O,
+		tickValues: P
+	});
+	if (z) {
+		let e = z.length < AXIS_VALIDATION.MIN_TICK_COUNT, t = z.length >= AXIS_VALIDATION.MIN_TICK_COUNT && new Set(z.map((e) => e.value)).size === AXIS_VALIDATION.UNIQUE_VALUE_THRESHOLD;
+		if (e) {
+			let e = { error: buildError(BuildError.LINE_CHART_Y_AXIS_INSUFFICIENT_TICKS) };
+			n?.("BAR_CHART_Y_AXIS_ERROR", e), p ||= e;
+		}
+		if (t) {
+			let e = { error: buildError(BuildError.LINE_CHART_Y_AXIS_IDENTICAL_VALUES) };
+			n?.("BAR_CHART_Y_AXIS_ERROR", e), p ||= e;
+		}
+	}
+	let B = F ? getPoints(z || [], [String(A)])[0] : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE, V = L ? getPoints(I || [], [String(N)])[0] : BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE, H = getXCoordinates({
+		canvasHeight: b,
+		canvasWidth: y,
+		customBreakAxis: Number(B),
+		extraSpaceBottomY: C,
+		extraSpaceLeftX: w,
+		extraSpaceRightX: T,
+		extraSpaceTopY: E,
+		position: x,
+		securityYSpace: O
+	}), U = getYCoordinates({
+		canvasHeight: b,
+		canvasWidth: y,
+		customBreakAxis: Number(V),
+		extraSpaceBottomY: C,
+		extraSpaceLeftX: w,
+		extraSpaceRightX: T,
+		extraSpaceTopY: E,
+		position: S,
+		securityYSpace: O
+	});
+	if (H.x1 === H.x2) {
+		let e = { error: buildError(BuildError.LINE_CHART_X_AXIS_ZERO_LENGTH) };
+		n?.("BAR_CHART_X_AXIS_ERROR", e), p ||= e;
+	}
+	if (U.y1 === U.y2) {
+		let e = { error: buildError(BuildError.LINE_CHART_Y_AXIS_ZERO_LENGTH) };
+		n?.("BAR_CHART_Y_AXIS_ERROR", e), p ||= e;
+	}
+	let W = {
+		addError: n,
+		crossXAxis: F,
+		crossYAxis: L,
+		data: v,
+		extraSpaceBottomY: C,
+		extraSpaceLeftX: w,
+		extraSpaceRightX: T,
+		extraSpaceTopY: E,
+		securityXSpace: D,
+		securityYSpace: O,
+		xAxisCoordinates: {
+			coordinates: H,
+			tickValues: I || (p ? [{
+				position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
+				value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST
+			}, {
+				position: y,
+				value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND
+			}] : [])
+		},
+		xAxisText: k,
+		yAxisCoordinates: {
+			coordinates: U,
+			tickValues: z || (p ? [{
+				position: b,
+				value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_FIRST
+			}, {
+				position: BREAK_AXIS_DEFAULTS.DEFAULT_BREAK_VALUE,
+				value: SHARED_FALLBACK_DATA.FALLBACK_PKEY_SECOND
+			}] : [])
+		},
+		yAxisText: M
+	};
+	return p ? {
+		...W,
+		error: {
+			...p,
+			type: ErrorType.BAR_CHART_CONTEXT_ERROR
+		}
+	} : W;
 };
+export { buildBarContextValue };

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

@@ -1,71 +1,58 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useEffect } from 'react';
-import { Bar } from '../../../components/bar/bar';
-import { BarOrientation } from '../../../components/bar/bar.type';
-import { buildBarNegativeValueError, buildBarValueError, buildDataKeyNotFoundError, } from '../../../utils/buildErrors/buildErrors';
-import { getPoints } from '../../../utils/getPoints/getPoints';
-import { BarChartContext } from '../context/barChartContext';
-/**
- * Extracts the values for a specific key from the dataset
- * @param data Array of data points
- * @param key Key to extract values from
- * @returns Array of values for the given key
- */
-export const BarChartPath = ({ barConfig, dataIdx, dataKey, focusConfig, onBlur, onFocus, order, tabIndex, ...props }) => {
-    const { addError, xAxisCoordinates, yAxisCoordinates, ...context } = useContext(BarChartContext);
-    const { coordinates: xACoord, tickValues: xTickValues } = xAxisCoordinates;
-    const { coordinates: yACoord, tickValues: yTickValues } = yAxisCoordinates;
-    const isVertical = context.orientation === BarOrientation.VERTICAL;
-    const xKey = isVertical ? context.pKey : dataKey;
-    const yKey = isVertical ? dataKey : context.pKey;
-    // Safe data access
-    const dataItem = context.data[dataIdx];
-    const xData = dataItem?.[xKey];
-    const yData = dataItem?.[yKey];
-    // Extract values for stable dependencies
-    const firstDataItem = context.data[0];
-    const hasDataKey = firstDataItem
-        ? Object.prototype.hasOwnProperty.call(firstDataItem, dataKey)
-        : false;
-    const hasData = context.data.length > 0;
-    const numericYData = Number(yData);
-    // Path error validations - only validates the data for this specific bar
-    useEffect(() => {
-        // Validate dataKey exists in dataset
-        if (hasData && !hasDataKey) {
-            addError?.('BAR_CHART_PATH_ERROR', {
-                error: buildDataKeyNotFoundError(dataKey),
-            });
-            return; // Stop validation if dataKey doesn't exist
-        }
-        // Validate bar value is numeric
-        if (isNaN(numericYData)) {
-            addError?.('BAR_CHART_PATH_ERROR', {
-                error: buildBarValueError(yData, dataKey),
-            });
-            return;
-        }
-        // Validate negative values
-        if (numericYData < 0) {
-            addError?.('BAR_CHART_PATH_ERROR', {
-                error: buildBarNegativeValueError(numericYData, dataKey),
-            });
-        }
-    }, [dataKey, hasData, hasDataKey, numericYData, yData]);
-    const xPoint = getPoints(xTickValues, [String(xData)], true)[0];
-    const yPoint = getPoints(yTickValues, [String(yData)])[0];
-    const points = isVertical
-        ? {
-            x1: xPoint,
-            x2: xPoint,
-            y1: xACoord.y1,
-            y2: yPoint,
-        }
-        : {
-            x1: yACoord.x1,
-            x2: xPoint,
-            y1: yPoint,
-            y2: yPoint,
-        };
-    return (_jsx(Bar, { barConfig: barConfig, currentBars: context.barChildrenCount, dataKey: dataKey, extraSpacing: context.gapBetweenBars, focusConfig: focusConfig, order: order, orientation: context.orientation, tabIndex: tabIndex, xData: xData, xKey: xKey, yData: yData, yKey: yKey, onBlur: onBlur, onFocus: onFocus, ...points, ...props }));
+import { BarChartContext } from "../context/barChartContext.js";
+import { BarOrientation } from "../../../components/bar/bar.type.js";
+import { buildBarNegativeValueError, buildBarValueError } from "../../../utils/buildErrors/charts/buildBarChartErrors.js";
+import { buildDataKeyNotFoundError } from "../../../utils/buildErrors/buildErrors.js";
+import { getPoints } from "../../../utils/getPoints/getPoints.js";
+import { Bar } from "../../../components/bar/bar.js";
+import { useContext, useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+const BarChartPath = ({ barConfig: e, dataIdx: t, dataKey: n, focusConfig: r, onBlur: i, onFocus: a, order: o, tabIndex: s, ...c }) => {
+	let { addError: l, xAxisCoordinates: u, yAxisCoordinates: d, ...f } = useContext(BarChartContext), { coordinates: p, tickValues: m } = u, { coordinates: h, tickValues: g } = d, _ = f.orientation === BarOrientation.VERTICAL, v = _ ? f.pKey : n, y = _ ? n : f.pKey, b = f.data[t], x = b?.[v], S = b?.[y], C = f.data[0], w = C ? Object.prototype.hasOwnProperty.call(C, n) : !1, T = f.data.length > 0, E = Number(S);
+	useEffect(() => {
+		if (T && !w) {
+			l?.("BAR_CHART_PATH_ERROR", { error: buildDataKeyNotFoundError(n) });
+			return;
+		}
+		if (isNaN(E)) {
+			l?.("BAR_CHART_PATH_ERROR", { error: buildBarValueError(S, n) });
+			return;
+		}
+		E < 0 && l?.("BAR_CHART_PATH_ERROR", { error: buildBarNegativeValueError(E, n) });
+	}, [
+		n,
+		T,
+		w,
+		E,
+		S
+	]);
+	let D = getPoints(m, [String(x)], !0)[0], O = getPoints(g, [String(S)])[0];
+	return /* @__PURE__ */ jsx(Bar, {
+		barConfig: e,
+		currentBars: f.barChildrenCount,
+		dataKey: n,
+		extraSpacing: f.gapBetweenBars,
+		focusConfig: r,
+		order: o,
+		orientation: f.orientation,
+		tabIndex: s,
+		xData: x,
+		xKey: v,
+		yData: S,
+		yKey: y,
+		onBlur: i,
+		onFocus: a,
+		..._ ? {
+			x1: D,
+			x2: D,
+			y1: p.y1,
+			y2: O
+		} : {
+			x1: h.x1,
+			x2: D,
+			y1: O,
+			y2: O
+		},
+		...c
+	});
 };
+export { BarChartPath };