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

package/dist/esm/charts/lineChart/utils/getExtraSpacing.js

@@ -1,141 +1,111 @@
-import { Children, isValidElement } from 'react';
-import { Positions } from '../../../types/position.enum';
-import { buildTickValues } from '../../../utils/buildTickValues/buildTickValues';
-import { textBound } from '../../../utils/textBound/textBound';
-import { LineChartXAxis } from '../fragments/lineChartXAxis';
-import { LineChartYAxis } from '../fragments/lineChartYAxis';
-import { getDataValues } from './getDataValues';
-import { getYKeyRoundMaxValue } from './getRoundedMaxValue';
-import { getXAxisLeftTextSpacing, getXAxisRightTextSpacing, getYAxisLeftTextSpacing, getYAxisRightTextSpacing, } from './tickTextPosition';
-const getBreakAxis = ({ tickValues, tickText }) => {
-    if (tickValues?.numeric) {
-        return tickValues.numeric.breakAxis ?? 0;
-    }
-    return tickText?.custom?.breakAxis ?? 0;
+import { Positions } from "../../../types/position.enum.js";
+import { buildTickValues } from "../../../utils/buildTickValues/buildTickValues.js";
+import { textBound } from "../../../utils/textBound/textBound.js";
+import { LineChartXAxis } from "../fragments/lineChartXAxis.js";
+import { getXAxisLeftTextSpacing, getXAxisRightTextSpacing, getYAxisLeftTextSpacing, getYAxisRightTextSpacing } from "./tickTextPosition.js";
+import { LineChartYAxis } from "../fragments/lineChartYAxis.js";
+import { getDataValues } from "./getDataValues.js";
+import { getYKeyRoundMaxValue } from "./getRoundedMaxValue.js";
+import { Children, isValidElement } from "react";
+var getBreakAxis = ({ tickValues: e, tickText: t }) => e?.numeric ? e.numeric.breakAxis ?? 0 : t?.custom?.breakAxis ?? 0, handleLineChartXAxis = (t, r, o, s, c, u) => {
+	let { position: d = Positions.BOTTOM, tickText: f, tickValues: p, valueFormatter: m } = t.props, h = f?.fontSize ?? 0, g = p ? getDataValues(p) : r.map((e) => e[o]), _ = m ? g.map(m) : g, v = textBound({
+		bound: "width",
+		data: _,
+		fontSize: h,
+		svgHeight: `${c}`,
+		svgWidth: `${u}`,
+		viewBox: s
+	}), y = textBound({
+		bound: "height",
+		data: _,
+		fontSize: h,
+		svgHeight: `${c}`,
+		svgWidth: `${u}`,
+		viewBox: s
+	}), b = d === Positions.BOTTOM ? y + (f?.top ?? 0) : 0, x = d === Positions.TOP ? y + (f?.bottom ?? 0) : 0, S = getBreakAxis({
+		tickValues: p,
+		tickText: f
+	});
+	return {
+		xAxisLeftSpacing: getXAxisLeftTextSpacing({
+			textWidth: v,
+			tickText: f
+		}),
+		xAxisTopSpacing: x,
+		xAxisRightSpacing: getXAxisRightTextSpacing({
+			textWidth: v,
+			tickText: f
+		}),
+		xAxisBottomSpacing: b,
+		lineChartXPosition: d,
+		xBreakAxis: S,
+		xData: g
+	};
+}, handleLineChartYAxis = (r, i, a, c, d, f) => {
+	let { position: p = Positions.LEFT, tickText: m, tickValues: h, valueFormatter: g } = r.props, _ = m?.fontSize ?? 0, v = getDataValues(h || buildTickValues([...new Set(getYKeyRoundMaxValue(i, a))])), y = g ? v.map(g) : v, b = textBound({
+		bound: "width",
+		data: y,
+		fontSize: _,
+		svgHeight: `${d}`,
+		svgWidth: `${f}`,
+		viewBox: c
+	}), x = textBound({
+		bound: "height",
+		data: y,
+		fontSize: _,
+		svgHeight: `${d}`,
+		svgWidth: `${f}`,
+		viewBox: c
+	});
+	return {
+		yAxisLeftSpacing: getYAxisLeftTextSpacing({
+			tickText: m,
+			textWidth: b,
+			yAxisPosition: p
+		}),
+		yAxisTopSpacing: x,
+		yAxisRightSpacing: getYAxisRightTextSpacing({
+			tickText: m,
+			textWidth: b,
+			yAxisPosition: p
+		}),
+		yAxisBottomSpacing: 0,
+		lineChartYPosition: p,
+		yAxisText: b,
+		yBreakAxis: getBreakAxis({
+			tickValues: h,
+			tickText: m
+		}),
+		yData: v
+	};
 };
-const handleLineChartXAxis = (child, data, xKey, viewBox, canvasHeight, canvasWidth) => {
-    const { position = Positions.BOTTOM, tickText, tickValues, valueFormatter } = child.props;
-    const fontSize = tickText?.fontSize ?? 0;
-    const xData = tickValues ? getDataValues(tickValues) : data.map(d => d[xKey]);
-    // Apply the valueFormatter if provided to get the actual rendered text width
-    const formattedXData = valueFormatter ? xData.map(valueFormatter) : xData;
-    const textWidth = textBound({
-        bound: 'width',
-        data: formattedXData,
-        fontSize,
-        svgHeight: `${canvasHeight}`,
-        svgWidth: `${canvasWidth}`,
-        viewBox,
-    });
-    const textHeight = textBound({
-        bound: 'height',
-        data: formattedXData,
-        fontSize,
-        svgHeight: `${canvasHeight}`,
-        svgWidth: `${canvasWidth}`,
-        viewBox,
-    });
-    const xAxisBottomSpacing = position === Positions.BOTTOM ? textHeight + (tickText?.top ?? 0) : 0;
-    const xAxisTopSpacing = position === Positions.TOP ? textHeight + (tickText?.bottom ?? 0) : 0;
-    const xBreakAxis = getBreakAxis({ tickValues, tickText });
-    return {
-        xAxisLeftSpacing: getXAxisLeftTextSpacing({
-            textWidth,
-            tickText,
-        }),
-        xAxisTopSpacing,
-        xAxisRightSpacing: getXAxisRightTextSpacing({
-            textWidth,
-            tickText,
-        }),
-        xAxisBottomSpacing,
-        lineChartXPosition: position,
-        xBreakAxis,
-        xData,
-    };
-};
-const handleLineChartYAxis = (child, data, xKey, viewBox, canvasHeight, canvasWidth) => {
-    const { position = Positions.LEFT, tickText, tickValues, valueFormatter } = child.props;
-    const fontSize = tickText?.fontSize ?? 0;
-    const dataValues = tickValues ||
-        buildTickValues([...new Set(getYKeyRoundMaxValue(data, xKey))]);
-    const yData = getDataValues(dataValues);
-    // Apply the valueFormatter if provided to get the actual rendered text width
-    const formattedYData = valueFormatter ? yData.map(valueFormatter) : yData;
-    const yAxisText = textBound({
-        bound: 'width',
-        data: formattedYData,
-        fontSize: fontSize,
-        svgHeight: `${canvasHeight}`,
-        svgWidth: `${canvasWidth}`,
-        viewBox,
-    });
-    const textHeight = textBound({
-        bound: 'height',
-        data: formattedYData,
-        fontSize,
-        svgHeight: `${canvasHeight}`,
-        svgWidth: `${canvasWidth}`,
-        viewBox,
-    });
-    return {
-        yAxisLeftSpacing: getYAxisLeftTextSpacing({
-            tickText,
-            textWidth: yAxisText,
-            yAxisPosition: position,
-        }),
-        yAxisTopSpacing: textHeight,
-        yAxisRightSpacing: getYAxisRightTextSpacing({
-            tickText,
-            textWidth: yAxisText,
-            yAxisPosition: position,
-        }),
-        yAxisBottomSpacing: 0,
-        lineChartYPosition: position,
-        yAxisText,
-        yBreakAxis: getBreakAxis({ tickValues, tickText }),
-        yData,
-    };
-};
-/**
- * Calculates the extra spacing required for a line chart.
- * @param {GetExtraSpacing} options - The options for calculating extra spacing.
- * @returns {LineChartExtraSpacings} - The calculated extra spacings for the line chart.
- */
-export const getExtraSpacing = ({ canvasHeight, canvasWidth, children, data, viewBox, xKey, }) => {
-    let result = {
-        xAxisLeftSpacing: 0,
-        xAxisTopSpacing: 0,
-        xAxisRightSpacing: 0,
-        xAxisBottomSpacing: 0,
-        yAxisLeftSpacing: 0,
-        yAxisTopSpacing: 0,
-        yAxisRightSpacing: 0,
-        yAxisBottomSpacing: 0,
-        lineChartXPosition: Positions.BOTTOM,
-        lineChartYPosition: Positions.LEFT,
-        xAxisText: 0,
-        xBreakAxis: 0,
-        xData: [],
-        yAxisText: 0,
-        yBreakAxis: 0,
-        yData: [],
-    };
-    Children.forEach(children, (child) => {
-        if (isValidElement(child)) {
-            if (child.type === LineChartXAxis) {
-                result = {
-                    ...result,
-                    ...handleLineChartXAxis(child, data, xKey, viewBox, canvasHeight, canvasWidth),
-                };
-            }
-            else if (child.type === LineChartYAxis) {
-                result = {
-                    ...result,
-                    ...handleLineChartYAxis(child, data, xKey, viewBox, canvasHeight, canvasWidth),
-                };
-            }
-        }
-    });
-    return result;
+const getExtraSpacing = ({ canvasHeight: t, canvasWidth: n, children: i, data: a, viewBox: o, xKey: s }) => {
+	let l = {
+		xAxisLeftSpacing: 0,
+		xAxisTopSpacing: 0,
+		xAxisRightSpacing: 0,
+		xAxisBottomSpacing: 0,
+		yAxisLeftSpacing: 0,
+		yAxisTopSpacing: 0,
+		yAxisRightSpacing: 0,
+		yAxisBottomSpacing: 0,
+		lineChartXPosition: Positions.BOTTOM,
+		lineChartYPosition: Positions.LEFT,
+		xAxisText: 0,
+		xBreakAxis: 0,
+		xData: [],
+		yAxisText: 0,
+		yBreakAxis: 0,
+		yData: []
+	};
+	return Children.forEach(i, (e) => {
+		isValidElement(e) && (e.type === LineChartXAxis ? l = {
+			...l,
+			...handleLineChartXAxis(e, a, s, o, t, n)
+		} : e.type === LineChartYAxis && (l = {
+			...l,
+			...handleLineChartYAxis(e, a, s, o, t, n)
+		}));
+	}), l;
 };
+export { getExtraSpacing };

package/dist/esm/charts/lineChart/utils/getPathData.js

@@ -1,33 +1,9 @@
-/**
- * Generates SVG path data from an array of points.
- * @param points - An array of points, where each point is an array of two numbers representing the x and y coordinates.
- * @param curved - A boolean indicating whether the path should be a cubic Bezier curve (true) or a straight line (false). Defaults to false.
- * @param svgWidth - The width of the SVG container.
- * @param svgHeight - The height of the SVG container.
- * @param extendToBottom - A boolean indicating whether the path should extend to the bottom of the SVG container. Defaults to false.
- * @returns The SVG path data as a string.
- */
-export const getPathData = ({ curved = false, extendToBottom = false, points, svgHeight, }) => {
-    if (points.length === 0) {
-        return '';
-    }
-    const [firstPoint, ...remainingPoints] = points;
-    let pathData = `M ${firstPoint[0]} ${firstPoint[1]}`;
-    if (curved) {
-        pathData += remainingPoints.reduce((data, point, i) => {
-            const [x1, y1] = points[i];
-            const [x2, y2] = point;
-            const dx = (x2 - x1) * 0.3;
-            const controlPoint1 = [x1 + dx, y1];
-            const controlPoint2 = [x2 - dx, y2];
-            return `${data} C ${controlPoint1[0]} ${controlPoint1[1]}, ${controlPoint2[0]} ${controlPoint2[1]}, ${x2} ${y2}`;
-        }, '');
-    }
-    else {
-        pathData += remainingPoints.reduce((data, point) => `${data} L ${point[0]} ${point[1]}`, '');
-    }
-    if (extendToBottom) {
-        pathData += ` L ${remainingPoints[remainingPoints.length - 1][0]} ${svgHeight} L ${firstPoint[0]} ${svgHeight} Z`;
-    }
-    return pathData;
+const getPathData = ({ curved: e = !1, extendToBottom: t = !1, points: n, svgHeight: r }) => {
+	if (n.length === 0) return "";
+	let [i, ...a] = n, o = `M ${i[0]} ${i[1]}`;
+	return e ? o += a.reduce((e, t, r) => {
+		let [i, a] = n[r], [o, s] = t, c = (o - i) * .3, l = [i + c, a], u = [o - c, s];
+		return `${e} C ${l[0]} ${l[1]}, ${u[0]} ${u[1]}, ${o} ${s}`;
+	}, "") : o += a.reduce((e, t) => `${e} L ${t[0]} ${t[1]}`, ""), t && (o += ` L ${a[a.length - 1][0]} ${r} L ${i[0]} ${r} Z`), o;
 };
+export { getPathData };

package/dist/esm/charts/lineChart/utils/getProjection.js

@@ -1,105 +1,42 @@
-const addXProjection = (point, projection) => {
-    if (!projection) {
-        return point;
-    }
-    const isNegative = projection < 0;
-    const diff = Math.abs(projection);
-    const pointDiff = (point * diff) / 100;
-    return isNegative ? point - pointDiff : point + pointDiff;
+var addXProjection = (e, t) => {
+	if (!t) return e;
+	let n = t < 0, r = e * Math.abs(t) / 100;
+	return n ? e - r : e + r;
+}, addYProjection = (e, t, n) => {
+	if (!n) return e;
+	let r = n < 0, i = (e === 0 ? t : e) * Math.abs(n) / 100;
+	return r ? e + i : e - i;
 };
-const addYProjection = (point, svgHeight, projection) => {
-    if (!projection) {
-        return point;
-    }
-    const isNegative = projection < 0;
-    const diff = Math.abs(projection);
-    const ref = point === 0 ? svgHeight : point;
-    const pointDiff = (ref * diff) / 100;
-    return isNegative ? point + pointDiff : point - pointDiff;
-};
-/**
- * Generates the SVG path data for a line chart with optional upper and lower projections.
- *
- * @param {Object} params - The parameters for generating the projection.
- * @param {PointType[]} params.points - The data points for the line chart.
- * @param {boolean} params.curved - Whether the line should be curved.
- * @param {number} params.svgHeight - The height of the SVG element.
- * @param {ProjectionType} [params.upperProjection] - The upper projection data.
- * @param {ProjectionType} [params.lowerProjection] - The lower projection data.
- * @returns {GetProjectionReturnType} The generated SVG path data.
- */
-export const getProjection = ({ curved, lowerProjection, points, svgHeight, upperProjection, }) => {
-    const hasProjections = upperProjection || lowerProjection;
-    if (points.length === 0 && !hasProjections) {
-        return { shapePath: '' };
-    }
-    const [firstPoint, ...remainingPoints] = points;
-    const startPath = `M ${firstPoint[0]} ${firstPoint[1]}`;
-    let shapePath = startPath;
-    let upPath = upperProjection ? startPath : undefined;
-    let downPath = lowerProjection ? startPath : undefined;
-    const upperData = [];
-    const lowerData = [];
-    remainingPoints.forEach(([x, y]) => {
-        const lineUp = upperProjection
-            ? [addXProjection(x, upperProjection.x), addYProjection(y, svgHeight, upperProjection.y)]
-            : [x, y];
-        const lineDown = lowerProjection
-            ? [
-                addXProjection(x, -(lowerProjection.x ?? 0)),
-                addYProjection(y, svgHeight, -(lowerProjection.y ?? 0)),
-            ]
-            : [x, y];
-        upperData.push(lineUp);
-        lowerData.push(lineDown);
-    });
-    const hasAllProjections = upperProjection && lowerProjection;
-    const combinedData = hasAllProjections
-        ? [...upperData, remainingPoints.at(-1), ...lowerData.reverse(), firstPoint]
-        : [...upperData, ...lowerData.reverse(), firstPoint];
-    if (curved) {
-        shapePath += combinedData.reduce((data, point, i) => {
-            const start = i === 0 ? firstPoint : combinedData[i - 1];
-            const [x1, y1] = start;
-            const [x2, y2] = point;
-            const dx = (x2 - x1) * 0.3;
-            const controlPoint1 = [x1 + dx, y1];
-            const controlPoint2 = [x2 - dx, y2];
-            return `${data} C ${controlPoint1[0]} ${controlPoint1[1]}, ${controlPoint2[0]} ${controlPoint2[1]}, ${x2} ${y2}`;
-        }, '');
-        if (upPath) {
-            upPath += upperData.reduce((data, point, i) => {
-                const start = i === 0 ? firstPoint : upperData[i - 1];
-                const [x1, y1] = start;
-                const [x2, y2] = point;
-                const dx = (x2 - x1) * 0.3;
-                const controlPoint1 = [x1 + dx, y1];
-                const controlPoint2 = [x2 - dx, y2];
-                return `${data} C ${controlPoint1[0]} ${controlPoint1[1]}, ${controlPoint2[0]} ${controlPoint2[1]}, ${x2} ${y2}`;
-            }, '');
-        }
-        if (downPath) {
-            downPath += lowerData.reverse().reduce((data, point, i) => {
-                const start = i === 0 ? firstPoint : lowerData[i - 1];
-                const [x1, y1] = start;
-                const [x2, y2] = point;
-                const dx = (x2 - x1) * 0.3;
-                const controlPoint1 = [x1 + dx, y1];
-                const controlPoint2 = [x2 - dx, y2];
-                return `${data} C ${controlPoint1[0]} ${controlPoint1[1]}, ${controlPoint2[0]} ${controlPoint2[1]}, ${x2} ${y2}`;
-            }, '');
-        }
-    }
-    else {
-        shapePath += combinedData.reduce((data, point) => `${data} L ${point?.[0]} ${point?.[1]}`, '');
-        if (upPath) {
-            upPath += upperData.reduce((data, point) => `${data} L ${point[0]} ${point[1]}`, '');
-        }
-        if (downPath) {
-            downPath += lowerData
-                .reverse()
-                .reduce((data, point) => `${data} L ${point[0]} ${point[1]}`, '');
-        }
-    }
-    return { downPath, shapePath, upPath };
+const getProjection = ({ curved: n, lowerProjection: r, points: i, svgHeight: a, upperProjection: o }) => {
+	if (i.length === 0 && !(o || r)) return { shapePath: "" };
+	let [s, ...c] = i, l = `M ${s[0]} ${s[1]}`, u = l, d = o ? l : void 0, f = r ? l : void 0, p = [], m = [];
+	c.forEach(([n, i]) => {
+		let s = o ? [addXProjection(n, o.x), addYProjection(i, a, o.y)] : [n, i], c = r ? [addXProjection(n, -(r.x ?? 0)), addYProjection(i, a, -(r.y ?? 0))] : [n, i];
+		p.push(s), m.push(c);
+	});
+	let h = o && r ? [
+		...p,
+		c.at(-1),
+		...m.reverse(),
+		s
+	] : [
+		...p,
+		...m.reverse(),
+		s
+	];
+	return n ? (u += h.reduce((e, t, n) => {
+		let [r, i] = n === 0 ? s : h[n - 1], [a, o] = t, c = (a - r) * .3, l = [r + c, i], u = [a - c, o];
+		return `${e} C ${l[0]} ${l[1]}, ${u[0]} ${u[1]}, ${a} ${o}`;
+	}, ""), d && (d += p.reduce((e, t, n) => {
+		let [r, i] = n === 0 ? s : p[n - 1], [a, o] = t, c = (a - r) * .3, l = [r + c, i], u = [a - c, o];
+		return `${e} C ${l[0]} ${l[1]}, ${u[0]} ${u[1]}, ${a} ${o}`;
+	}, "")), f && (f += m.reverse().reduce((e, t, n) => {
+		let [r, i] = n === 0 ? s : m[n - 1], [a, o] = t, c = (a - r) * .3, l = [r + c, i], u = [a - c, o];
+		return `${e} C ${l[0]} ${l[1]}, ${u[0]} ${u[1]}, ${a} ${o}`;
+	}, ""))) : (u += h.reduce((e, t) => `${e} L ${t?.[0]} ${t?.[1]}`, ""), d && (d += p.reduce((e, t) => `${e} L ${t[0]} ${t[1]}`, "")), f && (f += m.reverse().reduce((e, t) => `${e} L ${t[0]} ${t[1]}`, ""))), {
+		downPath: f,
+		shapePath: u,
+		upPath: d
+	};
 };
+export { getProjection };

package/dist/esm/charts/lineChart/utils/getRoundedMaxValue.js

@@ -1,25 +1,2 @@
-/**
- * Extracts the maximum value from the data points that do not correspond to the provided key.
- * The maximum value is rounded up to the nearest multiple of 10.
- * @param data - The data points.
- * @param key - The key to exclude in the data.
- * @returns The rounded maximum value.
- */
-export const getRoundedMaxValue = (data, key) => {
-    const values = data.flatMap(point => Object.keys(point)
-        .filter(k => k !== key && typeof point[k] === 'number')
-        .map(k => point[k]));
-    const maxNumber = Math.max(...values);
-    return Math.ceil(maxNumber / 10) * 10;
-};
-/**
- * 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 getYKeyRoundMaxValue = (data, xKey) => {
-    return data.flatMap(point => Object.keys(point)
-        .filter(k => k !== xKey && typeof point[k] === 'number')
-        .map(k => point[k]));
-};
+const getYKeyRoundMaxValue = (e, t) => e.flatMap((e) => Object.keys(e).filter((n) => n !== t && typeof e[n] == "number").map((t) => e[t]));
+export { getYKeyRoundMaxValue };

package/dist/esm/charts/lineChart/utils/getTicks.js

@@ -1,36 +1,24 @@
-export const getXTicks = ({ tickValues, maxSpaceAvailable, xAxisLeftSpacing, xAxisRightSpacing, yAxisLeftSpacing, yAxisRightSpacing, }) => {
-    const initPos = Math.max(yAxisLeftSpacing, xAxisLeftSpacing);
-    const endPos = maxSpaceAvailable - Math.max(xAxisRightSpacing, yAxisRightSpacing);
-    if (tickValues.length <= 1) {
-        return [
-            {
-                position: initPos,
-                value: tickValues[0],
-            },
-        ];
-    }
-    const step = (endPos - initPos) / (tickValues.length - 1);
-    const ticks = tickValues.map((value, idx) => {
-        const position = initPos + step * idx;
-        return { position, value };
-    });
-    return ticks;
-};
-export const getYTicks = ({ maxSpaceAvailable, tickValues, xAxisTopSpacing, xAxisBottomSpacing, yAxisTopSpacing, yAxisBottomSpacing, }) => {
-    const initPos = maxSpaceAvailable - Math.max(xAxisBottomSpacing, yAxisBottomSpacing);
-    const endPos = Math.max(yAxisTopSpacing, xAxisTopSpacing);
-    if (tickValues.length <= 1) {
-        return [
-            {
-                position: initPos,
-                value: tickValues[0],
-            },
-        ];
-    }
-    const step = (initPos - endPos) / (tickValues.length - 1);
-    const ticks = tickValues.map((value, idx) => {
-        const position = initPos - step * idx;
-        return { position, value };
-    });
-    return ticks;
+const getXTicks = ({ tickValues: e, maxSpaceAvailable: t, xAxisLeftSpacing: n, xAxisRightSpacing: r, yAxisLeftSpacing: i, yAxisRightSpacing: a }) => {
+	let o = Math.max(i, n), s = t - Math.max(r, a);
+	if (e.length <= 1) return [{
+		position: o,
+		value: e[0]
+	}];
+	let c = (s - o) / (e.length - 1);
+	return e.map((e, t) => ({
+		position: o + c * t,
+		value: e
+	}));
+}, getYTicks = ({ maxSpaceAvailable: e, tickValues: t, xAxisTopSpacing: n, xAxisBottomSpacing: r, yAxisTopSpacing: i, yAxisBottomSpacing: a }) => {
+	let o = e - Math.max(r, a), s = Math.max(i, n);
+	if (t.length <= 1) return [{
+		position: o,
+		value: t[0]
+	}];
+	let c = (o - s) / (t.length - 1);
+	return t.map((e, t) => ({
+		position: o - c * t,
+		value: e
+	}));
 };
+export { getXTicks, getYTicks };

package/dist/esm/charts/lineChart/utils/handleNodesFocus.js

@@ -1,34 +1,17 @@
-export const handleNodesFocus = ({ data, getNodeFocusInfo, nodes, ref, }) => {
-    let currentNode = undefined;
-    const g = ref.querySelector('[data-draw]');
-    const handleKeyDown = (e) => {
-        let newCurrentNode = undefined;
-        if (e.key === 'ArrowRight') {
-            newCurrentNode =
-                currentNode === undefined || currentNode === nodes.length - 1 ? 0 : currentNode + 1;
-        }
-        else if (e.key === 'ArrowLeft') {
-            newCurrentNode =
-                currentNode === undefined || currentNode === 0 ? nodes.length - 1 : currentNode - 1;
-        }
-        if (newCurrentNode !== undefined) {
-            currentNode = newCurrentNode;
-            if (nodes[currentNode]) {
-                nodes[currentNode].focus();
-                getNodeFocusInfo?.(data[currentNode]);
-            }
-        }
-    };
-    const handleFocus = () => {
-        currentNode = undefined;
-    };
-    const mount = () => {
-        g?.addEventListener('focus', handleFocus);
-        ref.addEventListener('keydown', (e) => handleKeyDown(e));
-    };
-    const unmount = () => {
-        g?.removeEventListener('focus', handleFocus);
-        ref.removeEventListener('keydown', (e) => handleKeyDown(e));
-    };
-    return { mount, unmount };
+const handleNodesFocus = ({ data: e, getNodeFocusInfo: t, nodes: n, ref: r }) => {
+	let i, a = r.querySelector("[data-draw]"), o = (r) => {
+		let a;
+		r.key === "ArrowRight" ? a = i === void 0 || i === n.length - 1 ? 0 : i + 1 : r.key === "ArrowLeft" && (a = i === void 0 || i === 0 ? n.length - 1 : i - 1), a !== void 0 && (i = a, n[i] && (n[i].focus(), t?.(e[i])));
+	}, s = () => {
+		i = void 0;
+	};
+	return {
+		mount: () => {
+			a?.addEventListener("focus", s), r.addEventListener("keydown", (e) => o(e));
+		},
+		unmount: () => {
+			a?.removeEventListener("focus", s), r.removeEventListener("keydown", (e) => o(e));
+		}
+	};
 };
+export { handleNodesFocus };