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

package/dist/esm/components/zoomArea/hooks/useDragInteraction.js

@@ -1,110 +1,56 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { clampRange, mouseToDataIndex } from '../utils/rangeAndPositions';
-import { ZoomAreaElements } from '../zoomArea.type';
-/**
- * Calculate new range based on drag type and pointer position
- */
-const calculateNewRange = (dragType, currentRange, dataIndex, dataLength, interactionConfig) => {
-    const newRange = { ...currentRange };
-    if (dragType === ZoomAreaElements.START_HANDLER) {
-        newRange.start = Math.max(0, Math.min(dataIndex, currentRange.end - interactionConfig.minHandlerDistance));
-    }
-    else if (dragType === ZoomAreaElements.END_HANDLER) {
-        newRange.end = Math.min(dataLength - 1, Math.max(dataIndex, currentRange.start + interactionConfig.minHandlerDistance));
-    }
-    else if (dragType === ZoomAreaElements.SELECTION_AREA) {
-        // Moving entire selection
-        const selectionWidth = currentRange.end - currentRange.start;
-        const newStart = Math.max(0, Math.min(dataLength - 1 - selectionWidth, dataIndex - selectionWidth / 2));
-        newRange.start = newStart;
-        newRange.end = newStart + selectionWidth;
-    }
-    return newRange;
+import { clampRange, mouseToDataIndex } from "../utils/rangeAndPositions.js";
+import { ZoomAreaElements } from "../zoomArea.type.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+var calculateNewRange = (e, t, r, i, a) => {
+	let o = { ...t };
+	if (e === ZoomAreaElements.START_HANDLER) o.start = Math.max(0, Math.min(r, t.end - a.minHandlerDistance));
+	else if (e === ZoomAreaElements.END_HANDLER) o.end = Math.min(i - 1, Math.max(r, t.start + a.minHandlerDistance));
+	else if (e === ZoomAreaElements.SELECTION_AREA) {
+		let e = t.end - t.start, n = Math.max(0, Math.min(i - 1 - e, r - e / 2));
+		o.start = n, o.end = n + e;
+	}
+	return o;
 };
-/**
- * Custom hook for handling mouse and touch drag interactions in ZoomArea
- *
- * Supports both mouse and touch events for cross-platform compatibility.
- * Simplified implementation that works with overflow:visible SVG containers.
- * No complex viewBox calculations needed - coordinates are direct and intuitive.
- *
- * @param params - Configuration parameters for drag functionality
- * @returns Object with drag handlers and state
- */
-export const useDragInteraction = (params) => {
-    const { currentRange, dataLength, interactionConfig, onRangeChange, width } = params;
-    const groupRef = useRef(null);
-    const [isDragging, setIsDragging] = useState(null);
-    const handleMouseDown = useCallback((target) => {
-        return () => {
-            setIsDragging(target);
-        };
-    }, []);
-    const handleTouchStart = useCallback((target) => {
-        return () => {
-            setIsDragging(target);
-        };
-    }, []);
-    // Common logic for handling pointer movement (mouse or touch)
-    const handlePointerMove = useCallback((clientX) => {
-        if (!isDragging || !groupRef.current) {
-            return;
-        }
-        // Get the SVG element's bounding rect for coordinate conversion
-        const svgElement = groupRef.current;
-        if (!svgElement) {
-            return;
-        }
-        // Simple coordinate calculation - no viewBox complexity!
-        const rect = svgElement.getBoundingClientRect();
-        const pointerX = clientX - rect.left;
-        // Convert pointer X to data index (0 to dataLength-1)
-        const dataIndex = mouseToDataIndex(pointerX, width, dataLength);
-        const newRange = calculateNewRange(isDragging, currentRange, dataIndex, dataLength, interactionConfig);
-        const clampedRange = clampRange(newRange, dataLength, interactionConfig.minHandlerDistance);
-        onRangeChange(clampedRange);
-    }, [isDragging, width, dataLength, currentRange, onRangeChange, interactionConfig]);
-    const handleMouseMove = useCallback((event) => {
-        handlePointerMove(event.clientX);
-    }, [handlePointerMove]);
-    const handleTouchMove = useCallback((event) => {
-        if (event.touches.length === 0) {
-            return;
-        }
-        // Prevent default native scrolling behavior while dragging
-        event.preventDefault();
-        handlePointerMove(event.touches[0].clientX);
-    }, [handlePointerMove]);
-    const handleMouseUp = useCallback(() => {
-        setIsDragging(null);
-    }, []);
-    const handleTouchEnd = useCallback(() => {
-        setIsDragging(null);
-    }, []);
-    // Set up global mouse and touch events when dragging
-    useEffect(() => {
-        if (isDragging) {
-            // Mouse events
-            document.addEventListener('mousemove', handleMouseMove);
-            document.addEventListener('mouseup', handleMouseUp);
-            // Touch events
-            document.addEventListener('touchmove', handleTouchMove, { passive: false });
-            document.addEventListener('touchend', handleTouchEnd);
-            return () => {
-                // Cleanup mouse events
-                document.removeEventListener('mousemove', handleMouseMove);
-                document.removeEventListener('mouseup', handleMouseUp);
-                // Cleanup touch events
-                document.removeEventListener('touchmove', handleTouchMove);
-                document.removeEventListener('touchend', handleTouchEnd);
-            };
-        }
-        return undefined;
-    }, [isDragging, handleMouseMove, handleMouseUp, handleTouchMove, handleTouchEnd]);
-    return {
-        groupRef,
-        handleMouseDown,
-        handleTouchStart,
-        isDragging,
-    };
+const useDragInteraction = (n) => {
+	let { currentRange: s, dataLength: c, interactionConfig: l, onRangeChange: u, width: d } = n, f = useRef(null), [p, m] = useState(null), h = useCallback((e) => () => {
+		m(e);
+	}, []), g = useCallback((e) => () => {
+		m(e);
+	}, []), _ = useCallback((n) => {
+		if (!p || !f.current) return;
+		let r = f.current;
+		r && u(clampRange(calculateNewRange(p, s, mouseToDataIndex(n - r.getBoundingClientRect().left, d, c), c, l), c, l.minHandlerDistance));
+	}, [
+		p,
+		d,
+		c,
+		s,
+		u,
+		l
+	]), v = useCallback((e) => {
+		_(e.clientX);
+	}, [_]), y = useCallback((e) => {
+		e.touches.length !== 0 && (e.preventDefault(), _(e.touches[0].clientX));
+	}, [_]), b = useCallback(() => {
+		m(null);
+	}, []), x = useCallback(() => {
+		m(null);
+	}, []);
+	return useEffect(() => {
+		if (p) return document.addEventListener("mousemove", v), document.addEventListener("mouseup", b), document.addEventListener("touchmove", y, { passive: !1 }), document.addEventListener("touchend", x), () => {
+			document.removeEventListener("mousemove", v), document.removeEventListener("mouseup", b), document.removeEventListener("touchmove", y), document.removeEventListener("touchend", x);
+		};
+	}, [
+		p,
+		v,
+		b,
+		y,
+		x
+	]), {
+		groupRef: f,
+		handleMouseDown: h,
+		handleTouchStart: g,
+		isDragging: p
+	};
 };
+export { useDragInteraction };

package/dist/esm/components/zoomArea/hooks/useKeyboardNavigation.js

@@ -1,122 +1,70 @@
-import { useCallback } from 'react';
-import { clampRange } from '../utils/rangeAndPositions';
-import { ZoomAreaElements } from '../zoomArea.type';
-/**
- * Handle left arrow and down arrow key movement (decrease values)
- */
-const handleArrowLeft = (target, currentRange, step, interactionConfig) => {
-    const newRange = { ...currentRange };
-    if (target === ZoomAreaElements.START_HANDLER) {
-        newRange.start = Math.max(0, currentRange.start - step);
-    }
-    else if (target === ZoomAreaElements.END_HANDLER) {
-        newRange.end = Math.max(currentRange.start + interactionConfig.minHandlerDistance, currentRange.end - step);
-    }
-    else if (target === ZoomAreaElements.SELECTION_AREA) {
-        // Move entire selection left
-        const selectionWidth = currentRange.end - currentRange.start;
-        const newStart = Math.max(0, currentRange.start - step);
-        newRange.start = newStart;
-        newRange.end = newStart + selectionWidth;
-    }
-    return newRange;
+import { clampRange } from "../utils/rangeAndPositions.js";
+import { ZoomAreaElements } from "../zoomArea.type.js";
+import { useCallback } from "react";
+var handleArrowLeft = (e, n, r, i) => {
+	let a = { ...n };
+	if (e === ZoomAreaElements.START_HANDLER) a.start = Math.max(0, n.start - r);
+	else if (e === ZoomAreaElements.END_HANDLER) a.end = Math.max(n.start + i.minHandlerDistance, n.end - r);
+	else if (e === ZoomAreaElements.SELECTION_AREA) {
+		let e = n.end - n.start, t = Math.max(0, n.start - r);
+		a.start = t, a.end = t + e;
+	}
+	return a;
+}, handleArrowRight = (e, n, r, i, a) => {
+	let o = { ...n };
+	if (e === ZoomAreaElements.START_HANDLER) o.start = Math.min(n.end - a.minHandlerDistance, n.start + r);
+	else if (e === ZoomAreaElements.END_HANDLER) o.end = Math.min(i - 1, n.end + r);
+	else if (e === ZoomAreaElements.SELECTION_AREA) {
+		let e = n.end - n.start, t = Math.min(i - 1 - e, n.start + r);
+		o.start = t, o.end = t + e;
+	}
+	return o;
+}, handleHome = (e, n, r) => {
+	let i = { ...n };
+	if (e === ZoomAreaElements.START_HANDLER) i.start = 0;
+	else if (e === ZoomAreaElements.END_HANDLER) i.end = r - 1;
+	else if (e === ZoomAreaElements.SELECTION_AREA) {
+		let e = n.end - n.start;
+		i.start = 0, i.end = e;
+	}
+	return i;
+}, handleEnd = (e, n, r, i) => {
+	let a = { ...n };
+	if (e === ZoomAreaElements.START_HANDLER) a.start = n.end - i.minHandlerDistance;
+	else if (e === ZoomAreaElements.END_HANDLER) a.end = r - 1;
+	else if (e === ZoomAreaElements.SELECTION_AREA) {
+		let e = n.end - n.start;
+		a.start = r - 1 - e, a.end = r - 1;
+	}
+	return a;
 };
-/**
- * Handle right arrow and up arrow key movement (increase values)
- */
-const handleArrowRight = (target, currentRange, step, dataLength, interactionConfig) => {
-    const newRange = { ...currentRange };
-    if (target === ZoomAreaElements.START_HANDLER) {
-        newRange.start = Math.min(currentRange.end - interactionConfig.minHandlerDistance, currentRange.start + step);
-    }
-    else if (target === ZoomAreaElements.END_HANDLER) {
-        newRange.end = Math.min(dataLength - 1, currentRange.end + step);
-    }
-    else if (target === ZoomAreaElements.SELECTION_AREA) {
-        // Move entire selection right
-        const selectionWidth = currentRange.end - currentRange.start;
-        const newStart = Math.min(dataLength - 1 - selectionWidth, currentRange.start + step);
-        newRange.start = newStart;
-        newRange.end = newStart + selectionWidth;
-    }
-    return newRange;
-};
-/**
- * Handle Home key - move to beginning
- */
-const handleHome = (target, currentRange, dataLength) => {
-    const newRange = { ...currentRange };
-    if (target === ZoomAreaElements.START_HANDLER) {
-        newRange.start = 0;
-    }
-    else if (target === ZoomAreaElements.END_HANDLER) {
-        newRange.end = dataLength - 1;
-    }
-    else if (target === ZoomAreaElements.SELECTION_AREA) {
-        const selectionWidth = currentRange.end - currentRange.start;
-        newRange.start = 0;
-        newRange.end = selectionWidth;
-    }
-    return newRange;
-};
-/**
- * Handle End key - move to end
- */
-const handleEnd = (target, currentRange, dataLength, interactionConfig) => {
-    const newRange = { ...currentRange };
-    if (target === ZoomAreaElements.START_HANDLER) {
-        newRange.start = currentRange.end - interactionConfig.minHandlerDistance;
-    }
-    else if (target === ZoomAreaElements.END_HANDLER) {
-        newRange.end = dataLength - 1;
-    }
-    else if (target === ZoomAreaElements.SELECTION_AREA) {
-        const selectionWidth = currentRange.end - currentRange.start;
-        newRange.start = dataLength - 1 - selectionWidth;
-        newRange.end = dataLength - 1;
-    }
-    return newRange;
-};
-/**
- * Custom hook for handling keyboard navigation in ZoomArea
- *
- * @param params - Configuration parameters for keyboard navigation
- * @returns Object with keyboard event handlers
- */
-export const useKeyboardNavigation = (params) => {
-    const { currentRange, dataLength, interactionConfig, onRangeChange } = params;
-    const handleKeyDown = useCallback((target) => {
-        return (event) => {
-            // Shift key = fast navigation, normal keys = precise control
-            const step = event.shiftKey
-                ? interactionConfig.keyboardFastStep
-                : interactionConfig.keyboardStep;
-            let newRange = { ...currentRange };
-            switch (event.key) {
-                case 'ArrowLeft':
-                case 'ArrowDown':
-                    event.preventDefault();
-                    newRange = handleArrowLeft(target, currentRange, step, interactionConfig);
-                    break;
-                case 'ArrowRight':
-                case 'ArrowUp':
-                    event.preventDefault();
-                    newRange = handleArrowRight(target, currentRange, step, dataLength, interactionConfig);
-                    break;
-                case 'Home':
-                    event.preventDefault();
-                    newRange = handleHome(target, currentRange, dataLength);
-                    break;
-                case 'End':
-                    event.preventDefault();
-                    newRange = handleEnd(target, currentRange, dataLength, interactionConfig);
-                    break;
-                default:
-                    return; // Don't handle other keys
-            }
-            const clampedRange = clampRange(newRange, dataLength, interactionConfig.minHandlerDistance);
-            onRangeChange(clampedRange);
-        };
-    }, [currentRange, dataLength, onRangeChange, interactionConfig]);
-    return { handleKeyDown };
+const useKeyboardNavigation = (t) => {
+	let { currentRange: s, dataLength: c, interactionConfig: l, onRangeChange: u } = t;
+	return { handleKeyDown: useCallback((t) => (n) => {
+		let d = n.shiftKey ? l.keyboardFastStep : l.keyboardStep, f = { ...s };
+		switch (n.key) {
+			case "ArrowLeft":
+			case "ArrowDown":
+				n.preventDefault(), f = handleArrowLeft(t, s, d, l);
+				break;
+			case "ArrowRight":
+			case "ArrowUp":
+				n.preventDefault(), f = handleArrowRight(t, s, d, c, l);
+				break;
+			case "Home":
+				n.preventDefault(), f = handleHome(t, s, c);
+				break;
+			case "End":
+				n.preventDefault(), f = handleEnd(t, s, c, l);
+				break;
+			default: return;
+		}
+		u(clampRange(f, c, l.minHandlerDistance));
+	}, [
+		s,
+		c,
+		u,
+		l
+	]) };
 };
+export { useKeyboardNavigation };

package/dist/esm/components/zoomArea/hooks/useZoomAreaFocus.js

@@ -1,28 +1,12 @@
-import { useCallback, useState } from 'react';
-/**
- * Custom hook for managing focus state of zoom area elements.
- *
- * Provides centralized focus management for all interactive elements
- * (start handler, end handler, selection area) with proper coordination.
- *
- * @param params - Configuration parameters for the hook
- * @returns Object with focus handlers and utilities
- */
-export const useZoomAreaFocus = () => {
-    const [focusedElement, setFocusedElement] = useState(null);
-    const handleFocus = useCallback((target) => {
-        return () => setFocusedElement(target);
-    }, []);
-    const handleBlur = useCallback(() => {
-        setFocusedElement(null);
-    }, []);
-    // Helper function to check focus state
-    const isFocused = useCallback((target) => {
-        return focusedElement === target;
-    }, [focusedElement]);
-    return {
-        handleBlur,
-        handleFocus,
-        isFocused,
-    };
+import { useCallback, useState } from "react";
+const useZoomAreaFocus = () => {
+	let [t, n] = useState(null), r = useCallback((e) => () => n(e), []);
+	return {
+		handleBlur: useCallback(() => {
+			n(null);
+		}, []),
+		handleFocus: r,
+		isFocused: useCallback((e) => t === e, [t])
+	};
 };
+export { useZoomAreaFocus };

package/dist/esm/components/zoomArea/hooks/useZoomData.js

@@ -1,31 +1,19 @@
-import { useEffect, useState } from 'react';
-import { getRangeIndices } from '../utils/indexRounding';
-import { createDefaultRange } from '../utils/rangeAndPositions';
-export const useZoomData = ({ data, initialRange, onDataChange, }) => {
-    // Initialize range state
-    const defaultRange = initialRange || createDefaultRange(data.length);
-    const [currentRange, setCurrentRange] = useState(defaultRange);
-    // Filter data based on current range and emit changes
-    const filterData = (range) => {
-        if (!onDataChange || data.length === 0) {
-            return;
-        }
-        // Use centralized rounding logic to ensure consistency with accessibility labels
-        const { endIndex, startIndex } = getRangeIndices(range, data.length);
-        const filteredData = data.slice(startIndex, endIndex + 1);
-        onDataChange(filteredData);
-    };
-    // Handle range changes - updates state and filters data
-    const handleRangeChange = (newRange) => {
-        setCurrentRange(newRange);
-        filterData(newRange);
-    };
-    // Emit initial filtered data on mount
-    useEffect(() => {
-        filterData(currentRange);
-    }, []);
-    return {
-        currentRange,
-        handleRangeChange,
-    };
+import { createDefaultRange } from "../utils/rangeAndPositions.js";
+import { getRangeIndices } from "../utils/indexRounding.js";
+import { useEffect, useState } from "react";
+const useZoomData = ({ data: r, initialRange: i, onDataChange: a }) => {
+	let [o, s] = useState(i || createDefaultRange(r.length)), c = (e) => {
+		if (!a || r.length === 0) return;
+		let { endIndex: t, startIndex: n } = getRangeIndices(e, r.length);
+		a(r.slice(n, t + 1));
+	};
+	return useEffect(() => {
+		c(o);
+	}, []), {
+		currentRange: o,
+		handleRangeChange: (e) => {
+			s(e), c(e);
+		}
+	};
 };
+export { useZoomData };

package/dist/esm/components/zoomArea/utils/accessibilityLabels.js

@@ -1,60 +1,17 @@
-import { getRangeIndices } from './indexRounding';
-// Template keys for accessibility labels
-const ACCESSIBILITY_START_VALUE_KEY = '{{startValue}}';
-const ACCESSIBILITY_END_VALUE_KEY = '{{endValue}}';
-/**
- * Extracts the X-axis value from data at a specific index.
- *
- * @param data - Array of data points
- * @param xKey - Property name to extract from data points
- * @param index - Integer index (should be pre-rounded using indexRounding utils)
- * @returns String representation of the X-axis value, or fallback to string index
- */
-export const getXAxisValue = (data, xKey, index) => {
-    // Index should already be rounded and clamped by getRangeIndices()
-    return data[index]?.[xKey]?.toString() || `${index}`;
+import { getRangeIndices } from "./indexRounding.js";
+var ACCESSIBILITY_START_VALUE_KEY = "{{startValue}}", ACCESSIBILITY_END_VALUE_KEY = "{{endValue}}";
+const getXAxisValue = (e, t, n) => e[n]?.[t]?.toString() || `${n}`;
+var buildScreenReaderText = (e, r, i) => {
+	if (!e) return e;
+	let a = new RegExp(ACCESSIBILITY_START_VALUE_KEY, "g"), o = new RegExp(ACCESSIBILITY_END_VALUE_KEY, "g");
+	return e.replace(a, r).replace(o, i);
 };
-/**
- * Builds screen reader text by replacing template keys with actual values
- *
- * @param template - Template string with {{startValue}} and/or {{endValue}} placeholders
- * @param startValue - Value to replace {{startValue}} with
- * @param endValue - Value to replace {{endValue}} with
- * @returns String with placeholders replaced, or undefined if template is not provided
- */
-const buildScreenReaderText = (template, startValue, endValue) => {
-    if (!template) {
-        return template;
-    }
-    const startValueRegExp = new RegExp(ACCESSIBILITY_START_VALUE_KEY, 'g');
-    const endValueRegExp = new RegExp(ACCESSIBILITY_END_VALUE_KEY, 'g');
-    return template.replace(startValueRegExp, startValue).replace(endValueRegExp, endValue);
-};
-/**
- * Generates consistent accessibility labels for ZoomArea handlers and selection area.
- *
- * Uses the same floor/ceil logic as data filtering to ensure that screen reader
- * announcements exactly match the boundaries of the filtered data.
- *
- * @param data - Array of data points
- * @param xKey - Property name to extract X-axis values from
- * @param currentRange - Current zoom range with start and end indices
- * @param config - Optional configuration for custom label templates
- * @returns Object with formatted accessibility labels for UI components
- */
-export const generateAccessibilityLabels = (data, xKey, currentRange, config) => {
-    // Use EXACT same indexing logic as useZoomData.filterData() via shared utilities
-    const { endIndex, startIndex } = getRangeIndices(currentRange, data.length);
-    const startValue = getXAxisValue(data, xKey, startIndex);
-    const endValue = getXAxisValue(data, xKey, endIndex);
-    // Use custom templates or fall back to simple defaults (just the values)
-    const startHandler = buildScreenReaderText(config?.startHandler, startValue, endValue) ?? startValue;
-    const endHandler = buildScreenReaderText(config?.endHandler, startValue, endValue) ?? endValue;
-    const selectionArea = buildScreenReaderText(config?.selectionArea, startValue, endValue) ??
-        `${startValue} - ${endValue}`;
-    return {
-        endHandler,
-        selectionArea,
-        startHandler,
-    };
+const generateAccessibilityLabels = (t, n, a, o) => {
+	let { endIndex: s, startIndex: c } = getRangeIndices(a, t.length), l = getXAxisValue(t, n, c), u = getXAxisValue(t, n, s), d = buildScreenReaderText(o?.startHandler, l, u) ?? l;
+	return {
+		endHandler: buildScreenReaderText(o?.endHandler, l, u) ?? u,
+		selectionArea: buildScreenReaderText(o?.selectionArea, l, u) ?? `${l} - ${u}`,
+		startHandler: d
+	};
 };
+export { generateAccessibilityLabels };

package/dist/esm/components/zoomArea/utils/indexRounding.js

@@ -1,68 +1,8 @@
-/**
- * Index rounding utilities for consistent data filtering and accessibility labels.
- *
- * These utilities ensure that both data filtering (useZoomData) and accessibility labels
- * (generateAccessibilityLabels) use exactly the same rounding logic, preventing
- * inconsistencies between what users see and what screen readers announce.
- */
-/**
- * Rounds a fractional index to be used as a start index (inclusive lower bound).
- * Uses Math.floor() to include the current data point and everything after it.
- *
- * @param index - Continuous index (can be fractional)
- * @param maxIndex - Maximum valid index (usually data.length - 1)
- * @returns Rounded index clamped to valid bounds
- *
- * @example
- * ```typescript
- * roundStartIndex(1.3, 4); // Math.floor(1.3) = 1, clamped to [0,4] → 1
- * roundStartIndex(-0.5, 4); // Math.floor(-0.5) = -1, clamped to [0,4] → 0
- * ```
- */
-export const roundStartIndex = (index, maxIndex) => {
-    const rounded = Math.floor(index);
-    return Math.max(0, Math.min(maxIndex, rounded));
-};
-/**
- * Rounds a fractional index to be used as an end index (inclusive upper bound).
- * Uses Math.ceil() to include the current data point and everything before it.
- *
- * @param index - Continuous index (can be fractional)
- * @param maxIndex - Maximum valid index (usually data.length - 1)
- * @returns Rounded index clamped to valid bounds
- *
- * @example
- * ```typescript
- * roundEndIndex(2.7, 4); // Math.ceil(2.7) = 3, clamped to [0,4] → 3
- * roundEndIndex(5.2, 4); // Math.ceil(5.2) = 6, clamped to [0,4] → 4
- * ```
- */
-export const roundEndIndex = (index, maxIndex) => {
-    const rounded = Math.ceil(index);
-    return Math.max(0, Math.min(maxIndex, rounded));
-};
-/**
- * Converts a fractional range to integer indices using consistent rounding.
- * This is the core function that both data filtering and accessibility use.
- *
- * @param range - Zoom range with potentially fractional start/end values
- * @param dataLength - Length of the data array
- * @returns Object with rounded startIndex and endIndex
- *
- * @example
- * ```typescript
- * const indices = getRangeIndices({ start: 1.3, end: 3.7 }, 10);
- * // Returns: { startIndex: 1, endIndex: 4 }
- *
- * // This can be used for:
- * // 1. Data filtering: data.slice(startIndex, endIndex + 1)
- * // 2. Accessibility: data[startIndex][xKey] to data[endIndex][xKey]
- * ```
- */
-export const getRangeIndices = (range, dataLength) => {
-    const maxIndex = Math.max(0, dataLength - 1);
-    return {
-        endIndex: roundEndIndex(range.end, maxIndex),
-        startIndex: roundStartIndex(range.start, maxIndex),
-    };
+const roundStartIndex = (e, t) => Math.max(0, Math.min(t, Math.floor(e))), roundEndIndex = (e, t) => Math.max(0, Math.min(t, Math.ceil(e))), getRangeIndices = (n, r) => {
+	let i = Math.max(0, r - 1);
+	return {
+		endIndex: roundEndIndex(n.end, i),
+		startIndex: roundStartIndex(n.start, i)
+	};
 };
+export { getRangeIndices };

package/dist/esm/components/zoomArea/utils/interactionConfig.js

@@ -1,23 +1,11 @@
-/**
- * Default configuration for ZoomArea interactions
- */
-const DEFAULT_INTERACTION_CONFIG = {
-    /** Fast keyboard movement step (Shift + arrows) */
-    KEYBOARD_FAST_STEP: 2,
-    /** Default keyboard movement step (arrows without modifiers) */
-    KEYBOARD_STEP: 1,
-    /** Minimum distance between start and end handlers */
-    MIN_HANDLER_DISTANCE: 1,
+var DEFAULT_INTERACTION_CONFIG = {
+	KEYBOARD_FAST_STEP: 2,
+	KEYBOARD_STEP: 1,
+	MIN_HANDLER_DISTANCE: 1
 };
-/**
- * Utility function to get resolved interaction configuration.
- * Merges user-provided config with sensible defaults.
- *
- * @param config - Optional user configuration
- * @returns Complete interaction configuration with defaults applied
- */
-export const getInteractionConfig = (config) => ({
-    keyboardFastStep: config?.keyboardFastStep ?? DEFAULT_INTERACTION_CONFIG.KEYBOARD_FAST_STEP,
-    keyboardStep: config?.keyboardStep ?? DEFAULT_INTERACTION_CONFIG.KEYBOARD_STEP,
-    minHandlerDistance: config?.minHandlerDistance ?? DEFAULT_INTERACTION_CONFIG.MIN_HANDLER_DISTANCE,
+const getInteractionConfig = (e) => ({
+	keyboardFastStep: e?.keyboardFastStep ?? DEFAULT_INTERACTION_CONFIG.KEYBOARD_FAST_STEP,
+	keyboardStep: e?.keyboardStep ?? DEFAULT_INTERACTION_CONFIG.KEYBOARD_STEP,
+	minHandlerDistance: e?.minHandlerDistance ?? DEFAULT_INTERACTION_CONFIG.MIN_HANDLER_DISTANCE
 });
+export { getInteractionConfig };