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

package/dist/esm/charts/lineChart/fragments/lineChartPath2.js

@@ -0,0 +1,122 @@
+import { BuildError, buildDataKeyNotFoundError, buildError } from "../../../utils/buildErrors/buildErrors.js";
+import { getPoints } from "../../../utils/getPoints/getPoints.js";
+import { pickCustomAttributes } from "../../../utils/pickCustomAttributes/pickCustomAttributes.js";
+import { useIndicator } from "../hook/useIndicator.js";
+import { Node } from "../../../components/node/node.js";
+import { Path } from "../../../components/path/path2.js";
+import { Line } from "../../../components/line/line.js";
+import { LineChartContext } from "../context/lineChartContext.js";
+import { findClosestNumber, findSurroundingNumber } from "../utils/findSurroundingNumber.js";
+import { getPathData } from "../utils/getPathData.js";
+import { handleNodesFocus } from "../utils/handleNodesFocus.js";
+/* empty css              */
+import { LineChartProjection } from "./lineChartProjection.js";
+import { useContext, useEffect, useRef } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var getAxisData = (e, t) => e.map((e) => e[t]);
+const LineChartPath = ({ ariaLabel: i, closestClick: a, curved: o, getNodeFocusInfo: s, getNodesCoords: c, indicatorConfig: l, lineProjection: u, onClick: d, ...f }) => {
+	let { addError: p, xAxisCoordinates: m, yAxisCoordinates: h, ...g } = useContext(LineChartContext), _ = f.dataKey, v = g.data.length > 0, y = g.data[0], b = y ? Object.prototype.hasOwnProperty.call(y, _) : !1, x = g.data.length;
+	useEffect(() => {
+		if (!_ || typeof _ != "string") {
+			p?.("LINE_CHART_PATH_ERROR", { error: buildError(BuildError.LINE_CHART_PATH_INVALID_DATAKEY) });
+			return;
+		}
+		if (v && !b) {
+			p?.("LINE_CHART_PATH_ERROR", { error: buildDataKeyNotFoundError(_) });
+			return;
+		}
+		if (o && x < 2) {
+			p?.("LINE_CHART_PATH_ERROR", { error: buildError(BuildError.LINE_CHART_PATH_INSUFFICIENT_POINTS) });
+			return;
+		}
+		let r = getAxisData(g.data, _);
+		r.length > 0 && r.every((e) => e == null) && p?.("LINE_CHART_PATH_ERROR", { error: buildError(BuildError.LINE_CHART_PATH_ALL_VALUES_NULL) });
+	}, [
+		p,
+		o,
+		_,
+		x,
+		v,
+		b,
+		g.data
+	]);
+	let { indicatorRef: S, pathRef: C } = useIndicator(g.xCursor, !!l), w = !!l && g.xCursor !== -Infinity, T = useRef(null), E = useRef(null), { autoClick: D, lineIndicator: O, ...k } = l || {}, { y1: A, y2: j } = h.coordinates, { x1: M, x2: N } = m.coordinates, P = g.xCursor >= M && g.xCursor <= N, { tickValues: F } = m, { tickValues: I } = h, L = getAxisData(g.data, g.xKey), R = getAxisData(g.data, _), z = getPoints(F, L, !0), B = getPoints(I, R), V = z.map((e, t) => [e, B[t]]), H = getPathData({
+		curved: o,
+		extendToBottom: !1,
+		points: V,
+		svgHeight: h.coordinates.y2
+	}), U = getPathData({
+		curved: o,
+		extendToBottom: !!f.fill || !!f.gradient,
+		points: V,
+		svgHeight: h.coordinates.y2
+	});
+	useEffect(() => {
+		if (!T.current?.path) return;
+		C.current = T.current.path;
+		let e = T.current.main, t = T.current.node, { mount: n, unmount: r } = handleNodesFocus({
+			data: L.map((e, t) => ({
+				x: e,
+				y: R[t]
+			})),
+			getNodeFocusInfo: s,
+			nodes: t,
+			ref: e
+		});
+		return n(), () => r();
+	}, []), useEffect(() => {
+		if (f.nodeConfig && w && D) {
+			let { idx: e, match: t } = findSurroundingNumber(z, g.xCursor);
+			if (t && e !== E.current) {
+				E.current = e;
+				let t = new MouseEvent("click", { bubbles: !0 });
+				t.autoClick = !0, T.current?.node?.[e]?.dispatchEvent(t), navigator?.vibrate?.(200);
+			} else E.current = null;
+		}
+	}, [g.xCursor]), useEffect(() => {
+		c?.(V);
+	}, [V]);
+	let W = (e) => {
+		if (d?.(e), a) {
+			let e = findClosestNumber(z, g.xCursor), t = new MouseEvent("click", { bubbles: !0 });
+			t.autoClick = !1, T.current?.node?.[e]?.dispatchEvent(t);
+		}
+	}, G = pickCustomAttributes(f), K = {
+		...f,
+		...G,
+		...i && { "aria-label": i }
+	};
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(Path, {
+			ref: T,
+			d: H,
+			dFill: U,
+			dataTestId: `${g.dataTestId}path`,
+			dataValue: g.data,
+			points: V,
+			xKey: g.xKey,
+			onClick: W,
+			...K
+		}),
+		u && /* @__PURE__ */ jsx(LineChartProjection, {
+			curved: o,
+			dataKey: f.dataKey,
+			lineProjection: u,
+			points: V,
+			svgHeight: h.coordinates.y2
+		}),
+		w && /* @__PURE__ */ jsxs(Fragment, { children: [!!O && P && /* @__PURE__ */ jsx(Line, {
+			...O,
+			className: "pointer-events-none",
+			x1: g.xCursor,
+			x2: g.xCursor,
+			y1: A,
+			y2: j
+		}), /* @__PURE__ */ jsx("g", {
+			ref: S,
+			className: "pointer-events-none",
+			children: /* @__PURE__ */ jsx(Node, { ...k })
+		})] })
+	] });
+};
+export { LineChartPath };

package/dist/esm/charts/lineChart/fragments/lineChartProjection.js

@@ -1,65 +1,58 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useContext, useEffect } from 'react';
-import { buildProjectionBoundsError, buildProjectionXOutOfRangeError, buildProjectionYOutOfRangeError, } from '../../../utils/buildErrors/charts/buildLineChartErrors';
-import { LineChartContext } from '../context/lineChartContext';
-import { getProjection } from '../utils/getProjection';
-import './lineChartPath.css';
-export const LineChartProjection = ({ curved, lineProjection, points, svgHeight, }) => {
-    const { addError } = useContext(LineChartContext);
-    const { lower, shapeColor, upper } = lineProjection;
-    const { xProjection: xUp, yProjection: yUp, ...upperProps } = upper || {};
-    const { xProjection: xDw, yProjection: yDw, ...lowerProps } = lower || {};
-    const upperProjection = xUp || yUp ? { x: xUp, y: yUp } : undefined;
-    const lowerProjection = xDw || yDw ? { x: xDw, y: yDw } : undefined;
-    // Extract values for stable dependencies
-    const upperY = upperProjection?.y;
-    const lowerY = lowerProjection?.y;
-    const upperX = upperProjection?.x;
-    const lowerX = lowerProjection?.x;
-    // Projection error validations
-    useEffect(() => {
-        // Invalid projection bounds - upper/lower overlap
-        if (upperProjection && lowerProjection) {
-            const upperYVal = upperY || 0;
-            const lowerYVal = lowerY || 0;
-            if (upperYVal >= lowerYVal) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionBoundsError(upperYVal, lowerYVal),
-                });
-            }
-        }
-        // Projection coordinates outside chart area
-        if (upperProjection) {
-            if (upperX !== undefined && (upperX < 0 || upperX > 100)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionXOutOfRangeError(upperX, true),
-                });
-            }
-            if (upperY !== undefined && (upperY < 0 || upperY > svgHeight)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionYOutOfRangeError(upperY, svgHeight, true),
-                });
-            }
-        }
-        if (lowerProjection) {
-            if (lowerX !== undefined && (lowerX < 0 || lowerX > 100)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionXOutOfRangeError(lowerX, false),
-                });
-            }
-            if (lowerY !== undefined && (lowerY < 0 || lowerY > svgHeight)) {
-                addError?.('LINE_CHART_PROJECTION_ERROR', {
-                    error: buildProjectionYOutOfRangeError(lowerY, svgHeight, false),
-                });
-            }
-        }
-    }, [lowerProjection, lowerX, lowerY, svgHeight, upperProjection, upperX, upperY]);
-    const { downPath, shapePath, upPath } = getProjection({
-        curved,
-        lowerProjection,
-        points,
-        svgHeight,
-        upperProjection,
-    });
-    return (_jsxs("g", { className: "pointer-events-none", children: [_jsx("path", { d: shapePath, fill: shapeColor, stroke: "transparent", strokeWidth: "0.1" }), ";", upPath && _jsx("path", { d: upPath, ...upperProps }), downPath && _jsx("path", { d: downPath, ...lowerProps })] }));
+import { LineChartContext } from "../context/lineChartContext.js";
+/* empty css              */
+import { buildProjectionBoundsError, buildProjectionXOutOfRangeError, buildProjectionYOutOfRangeError } from "../../../utils/buildErrors/charts/buildLineChartErrors.js";
+import { getProjection } from "../utils/getProjection.js";
+import { useContext, useEffect } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+const LineChartProjection = ({ curved: n, lineProjection: r, points: i, svgHeight: a }) => {
+	let { addError: o } = useContext(LineChartContext), { lower: s, shapeColor: c, upper: l } = r, { xProjection: u, yProjection: d, ...f } = l || {}, { xProjection: p, yProjection: m, ...h } = s || {}, g = u || d ? {
+		x: u,
+		y: d
+	} : void 0, _ = p || m ? {
+		x: p,
+		y: m
+	} : void 0, v = g?.y, y = _?.y, b = g?.x, x = _?.x;
+	useEffect(() => {
+		if (g && _) {
+			let e = v || 0, t = y || 0;
+			e >= t && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionBoundsError(e, t) });
+		}
+		g && (b !== void 0 && (b < 0 || b > 100) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionXOutOfRangeError(b, !0) }), v !== void 0 && (v < 0 || v > a) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionYOutOfRangeError(v, a, !0) })), _ && (x !== void 0 && (x < 0 || x > 100) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionXOutOfRangeError(x, !1) }), y !== void 0 && (y < 0 || y > a) && o?.("LINE_CHART_PROJECTION_ERROR", { error: buildProjectionYOutOfRangeError(y, a, !1) }));
+	}, [
+		_,
+		x,
+		y,
+		a,
+		g,
+		b,
+		v
+	]);
+	let { downPath: S, shapePath: C, upPath: w } = getProjection({
+		curved: n,
+		lowerProjection: _,
+		points: i,
+		svgHeight: a,
+		upperProjection: g
+	});
+	return /* @__PURE__ */ jsxs("g", {
+		className: "pointer-events-none",
+		children: [
+			/* @__PURE__ */ jsx("path", {
+				d: C,
+				fill: c,
+				stroke: "transparent",
+				strokeWidth: "0.1"
+			}),
+			";",
+			w && /* @__PURE__ */ jsx("path", {
+				d: w,
+				...f
+			}),
+			S && /* @__PURE__ */ jsx("path", {
+				d: S,
+				...h
+			})
+		]
+	});
 };
+export { LineChartProjection };

package/dist/esm/charts/lineChart/fragments/lineChartSeparator.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 { LineChartContext } from '../context/lineChartContext';
-export const LineChartSeparator = ({ areaSeparator, dataTestId, rightSeparator, topSeparator, xBreakAxis, yBreakAxis, }) => {
-    const { addError, crossXAxis, crossYAxis, xAxisCoordinates, yAxisCoordinates } = useContext(LineChartContext);
-    // 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?.('LINE_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?.('LINE_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?.('LINE_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?.('LINE_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?.('LINE_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 { BuildError, buildError, buildSeparatorXBreakAxisError, buildSeparatorXOutOfRangeError, buildSeparatorYBreakAxisError, buildSeparatorYOutOfRangeError } from "../../../utils/buildErrors/buildErrors.js";
+import { getPoints } from "../../../utils/getPoints/getPoints.js";
+import { LineChartContext } from "../context/lineChartContext.js";
+import { useContext, useEffect } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+const LineChartSeparator = ({ areaSeparator: r, dataTestId: i, rightSeparator: a, topSeparator: o, xBreakAxis: s, yBreakAxis: c }) => {
+	let { addError: l, crossXAxis: u, crossYAxis: d, xAxisCoordinates: f, yAxisCoordinates: p } = useContext(LineChartContext), 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?.("LINE_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?.("LINE_CHART_SEPARATOR_ERROR", { error: buildSeparatorXOutOfRangeError(g, t, n) });
+			}
+		}
+		if (c !== void 0) {
+			let e = h.map((e) => e.value);
+			if (_ === void 0 || isNaN(_)) l?.("LINE_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?.("LINE_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?.("LINE_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 { LineChartSeparator };

package/dist/esm/charts/lineChart/fragments/lineChartXAxis.js

@@ -1,32 +1,34 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext } from 'react';
-import { XAxis } from '../../../components/axisChart/xAxis/xAxis';
-import { TickDataUtils } from '../../../components/tick/tick.types';
-import { Positions } from '../../../types/position.enum';
-import { getTickTextYCoordinate } from '../../../utils/getTickTextCoordinate/getTickTextCoordinates';
-import { pickCustomAttributes } from '../../../utils/pickCustomAttributes/pickCustomAttributes';
-import { LineChartContext } from '../context/lineChartContext';
-export const LineChartXAxis = ({ ariaLabel, position = Positions.BOTTOM, tickLine, tickText, valueFormatter = (value) => value, ...props }) => {
-    const { xAxisCoordinates: { coordinates, tickValues: contextTickValues }, xCursor, ...context } = useContext(LineChartContext);
-    const tickTextY = getTickTextYCoordinate(position, coordinates.y1, Number(tickText?.fontSize), tickText?.top ?? 0);
-    const tickValues = tickText
-        ? TickDataUtils.formatTicksValues(contextTickValues, valueFormatter)
-        : undefined;
-    // Extract custom attributes (aria-*, data-*) and handle deprecated ariaLabel
-    const customAttributes = pickCustomAttributes(props);
-    const finalAriaLabel = ariaLabel || props['aria-label'];
-    // Merge all props including custom attributes and ariaLabel precedence
-    const mergedProps = {
-        ...props,
-        ...customAttributes,
-        ...(finalAriaLabel && { 'aria-label': finalAriaLabel }),
-    };
-    return (_jsx(XAxis, { ...coordinates, ...mergedProps, canvasHeight: Number(context.canvasHeight), canvasWidth: Number(context.canvasWidth), cursor: xCursor, dataTestId: `${context.dataTestId}xAxis`, tickLine: {
-            ...tickLine,
-            y1: context.yAxisCoordinates.coordinates.y1,
-            y2: context.yAxisCoordinates.coordinates.y2,
-        }, tickText: {
-            ...tickText,
-            y: tickTextY,
-        }, tickValues: tickValues }));
+import { Positions } from "../../../types/position.enum.js";
+import { pickCustomAttributes } from "../../../utils/pickCustomAttributes/pickCustomAttributes.js";
+import { XAxis } from "../../../components/axisChart/xAxis/xAxis.js";
+import { getTickTextYCoordinate } from "../../../utils/getTickTextCoordinate/getTickTextCoordinates.js";
+import { LineChartContext } from "../context/lineChartContext.js";
+import { TickDataUtils } from "../../../components/tick/tick.types.js";
+import { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+const LineChartXAxis = ({ ariaLabel: t, position: n = Positions.BOTTOM, tickLine: r, tickText: i, valueFormatter: a = (e) => e, ...o }) => {
+	let { xAxisCoordinates: { coordinates: s, tickValues: c }, xCursor: l, ...u } = useContext(LineChartContext), d = getTickTextYCoordinate(n, s.y1, Number(i?.fontSize), i?.top ?? 0), f = i ? TickDataUtils.formatTicksValues(c, a) : void 0, p = pickCustomAttributes(o), m = t || o["aria-label"], h = {
+		...o,
+		...p,
+		...m && { "aria-label": m }
+	};
+	return /* @__PURE__ */ jsx(XAxis, {
+		...s,
+		...h,
+		canvasHeight: Number(u.canvasHeight),
+		canvasWidth: Number(u.canvasWidth),
+		cursor: l,
+		dataTestId: `${u.dataTestId}xAxis`,
+		tickLine: {
+			...r,
+			y1: u.yAxisCoordinates.coordinates.y1,
+			y2: u.yAxisCoordinates.coordinates.y2
+		},
+		tickText: {
+			...i,
+			y: d
+		},
+		tickValues: f
+	});
 };
+export { LineChartXAxis };

package/dist/esm/charts/lineChart/fragments/lineChartYAxis.js

@@ -1,41 +1,39 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext } from 'react';
-import { YAxis } from '../../../components/axisChart/yAxis/yAxis';
-import { TickDataUtils } from '../../../components/tick/tick.types';
-import { Positions } from '../../../types/position.enum';
-import { pickCustomAttributes } from '../../../utils/pickCustomAttributes/pickCustomAttributes';
-import { LineChartContext } from '../context/lineChartContext';
-import { getYAxisTextXCoordinate } from '../utils/tickTextPosition';
-export const LineChartYAxis = ({ ariaLabel, position = Positions.LEFT, tickLine, tickText, valueFormatter = (value) => value, 
-// NOTE: tickValues prop is destructured but NOT USED - see TODO in lineChart.type.ts
-...props }) => {
-    const { yAxisCoordinates: { coordinates, tickValues: contextTickValues }, yCursor, ...context } = useContext(LineChartContext);
-    // TODO: Currently ignoring props.tickValues and using contextTickValues instead
-    // This means custom tickValues prop has no effect. Implementation needed to:
-    // 1. Check if props.tickValues exists
-    // 2. Use custom tick values instead of context values when provided
-    // 3. Update buildLineContextValue to handle custom Y-axis tick values
-    const xTickText = getYAxisTextXCoordinate({
-        tickText,
-        yAxisPosition: position,
-        textWidth: context.yAxisText,
-        yAxisX1: coordinates.x1,
-    });
-    const tickValues = tickText
-        ? TickDataUtils.formatTicksValues(contextTickValues, valueFormatter)
-        : undefined;
-    // Extract custom attributes (aria-*, data-*) and handle deprecated ariaLabel
-    const customAttributes = pickCustomAttributes(props);
-    const finalAriaLabel = ariaLabel || props['aria-label'];
-    // Merge all props including custom attributes and ariaLabel precedence
-    const mergedProps = {
-        ...props,
-        ...customAttributes,
-        ...(finalAriaLabel && { 'aria-label': finalAriaLabel }),
-    };
-    return (_jsx(YAxis, { ...coordinates, ...mergedProps, canvasHeight: Number(context.canvasHeight), canvasWidth: Number(context.canvasWidth), cursor: yCursor, dataTestId: `${context.dataTestId}yAxis`, tickLine: {
-            ...tickLine,
-            x1: context.xAxisCoordinates.coordinates.x1,
-            x2: context.xAxisCoordinates.coordinates.x2,
-        }, tickText: { ...tickText, x: xTickText }, tickValues: tickValues }));
+import { Positions } from "../../../types/position.enum.js";
+import { pickCustomAttributes } from "../../../utils/pickCustomAttributes/pickCustomAttributes.js";
+import { YAxis } from "../../../components/axisChart/yAxis/yAxis.js";
+import { LineChartContext } from "../context/lineChartContext.js";
+import { TickDataUtils } from "../../../components/tick/tick.types.js";
+import { getYAxisTextXCoordinate } from "../utils/tickTextPosition.js";
+import { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+const LineChartYAxis = ({ ariaLabel: t, position: n = Positions.LEFT, tickLine: r, tickText: i, valueFormatter: a = (e) => e, ...o }) => {
+	let { yAxisCoordinates: { coordinates: s, tickValues: c }, yCursor: l, ...u } = useContext(LineChartContext), d = getYAxisTextXCoordinate({
+		tickText: i,
+		yAxisPosition: n,
+		textWidth: u.yAxisText,
+		yAxisX1: s.x1
+	}), f = i ? TickDataUtils.formatTicksValues(c, a) : void 0, p = pickCustomAttributes(o), m = t || o["aria-label"], h = {
+		...o,
+		...p,
+		...m && { "aria-label": m }
+	};
+	return /* @__PURE__ */ jsx(YAxis, {
+		...s,
+		...h,
+		canvasHeight: Number(u.canvasHeight),
+		canvasWidth: Number(u.canvasWidth),
+		cursor: l,
+		dataTestId: `${u.dataTestId}yAxis`,
+		tickLine: {
+			...r,
+			x1: u.xAxisCoordinates.coordinates.x1,
+			x2: u.xAxisCoordinates.coordinates.x2
+		},
+		tickText: {
+			...i,
+			x: d
+		},
+		tickValues: f
+	});
 };
+export { LineChartYAxis };

package/dist/esm/charts/lineChart/hook/useAutoClick.js

@@ -1,19 +1,14 @@
-import { useEffect, useImperativeHandle, useRef } from 'react';
-export const useAutoClick = (ref) => {
-    const autoClick = useRef(false);
-    const innerRef = useRef(null);
-    useImperativeHandle(ref, () => innerRef.current, []);
-    const handleClick = (e) => {
-        autoClick.current = !!e.autoClick;
-    };
-    useEffect(() => {
-        if (!innerRef.current) {
-            return;
-        }
-        const element = innerRef.current;
-        element.addEventListener('click', handleClick);
-        // eslint-disable-next-line consistent-return
-        return () => element.removeEventListener('click', handleClick);
-    }, []);
-    return [innerRef, autoClick];
+import { useEffect, useImperativeHandle, useRef } from "react";
+const useAutoClick = (t) => {
+	let n = useRef(!1), r = useRef(null);
+	useImperativeHandle(t, () => r.current, []);
+	let i = (e) => {
+		n.current = !!e.autoClick;
+	};
+	return useEffect(() => {
+		if (!r.current) return;
+		let e = r.current;
+		return e.addEventListener("click", i), () => e.removeEventListener("click", i);
+	}, []), [r, n];
 };
+export { useAutoClick };

package/dist/esm/charts/lineChart/hook/useHover.js

@@ -1,30 +1,18 @@
-import { useCallback, useState } from 'react';
-const outRange = -Infinity;
-export const useHover = ({ canvasHeight, canvasWidth }) => {
-    const [[xCursor, yCursor], setCursor] = useState([outRange, outRange]);
-    const getCursor = useCallback((e, node) => {
-        const { height, left, top, width } = node.getBoundingClientRect();
-        // get the x and y position of the mouse
-        const x = e.clientX - left;
-        const y = e.clientY - top;
-        // scale the x and y to the canvas size
-        const xPosition = (x * canvasWidth) / width;
-        const yPosition = (y * canvasHeight) / height;
-        // save the positions
-        setCursor([xPosition, yPosition]);
-    }, [canvasWidth, canvasHeight]);
-    const startTouch = (e) => {
-        e.preventDefault();
-    };
-    const svgRef = useCallback((node) => {
-        if (node) {
-            node.addEventListener('touchstart', startTouch);
-            node.addEventListener('touchmove', e => getCursor(e.touches[0], node));
-            node.addEventListener('mousemove', e => getCursor(e, node));
-        }
-        node?.removeEventListener('touchstart', startTouch);
-        node?.removeEventListener('touchmove', e => getCursor(e.touches[0], node));
-        node?.removeEventListener('mousemove', e => getCursor(e, node));
-    }, [canvasHeight, canvasWidth]);
-    return { svgRef, xCursor, yCursor };
+import { useCallback, useState } from "react";
+var outRange = -Infinity;
+const useHover = ({ canvasHeight: r, canvasWidth: i }) => {
+	let [[a, o], s] = useState([outRange, outRange]), c = useCallback((e, t) => {
+		let { height: n, left: a, top: o, width: c } = t.getBoundingClientRect(), l = e.clientX - a, u = e.clientY - o;
+		s([l * i / c, u * r / n]);
+	}, [i, r]), l = (e) => {
+		e.preventDefault();
+	};
+	return {
+		svgRef: useCallback((e) => {
+			e && (e.addEventListener("touchstart", l), e.addEventListener("touchmove", (t) => c(t.touches[0], e)), e.addEventListener("mousemove", (t) => c(t, e))), e?.removeEventListener("touchstart", l), e?.removeEventListener("touchmove", (t) => c(t.touches[0], e)), e?.removeEventListener("mousemove", (t) => c(t, e));
+		}, [r, i]),
+		xCursor: a,
+		yCursor: o
+	};
 };
+export { useHover };