@kubit-ui-web/react-charts 0.1.0

package/dist/types/components/zoomArea/hooks/useDragInteraction.d.ts

@@ -0,0 +1,42 @@
+import { ZoomAreaElements, ZoomAreaInteractionConfig, ZoomRange } from '../zoomArea.type';
+/**
+ * Parameters for the useDragInteraction hook
+ */
+interface UseDragInteractionParams {
+    /** Current zoom range */
+    currentRange: ZoomRange;
+    /** Width of the zoom area */
+    width: number;
+    /** Total length of the data array */
+    dataLength: number;
+    /** Callback when range changes */
+    onRangeChange: (range: ZoomRange) => void;
+    /** Interaction configuration with resolved defaults */
+    interactionConfig: Required<ZoomAreaInteractionConfig>;
+}
+/**
+ * Return value for the useDragInteraction hook
+ */
+interface UseDragInteractionReturn {
+    /** Reference to the SVG group element */
+    groupRef: React.RefObject<SVGSVGElement>;
+    /** Handler for mouse down events on different elements */
+    handleMouseDown: (target: (typeof ZoomAreaElements)[keyof typeof ZoomAreaElements]) => (event: React.MouseEvent) => void;
+    /** Handler for touch start events on different elements */
+    handleTouchStart: (target: (typeof ZoomAreaElements)[keyof typeof ZoomAreaElements]) => (event: React.TouchEvent) => void;
+    /** Currently dragging element, if any */
+    isDragging: (typeof ZoomAreaElements)[keyof typeof ZoomAreaElements] | null;
+}
+/**
+ * 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 declare const useDragInteraction: (params: UseDragInteractionParams) => UseDragInteractionReturn;
+export {};
+//# sourceMappingURL=useDragInteraction.d.ts.map

package/dist/types/components/zoomArea/hooks/useDragInteraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDragInteraction.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/hooks/useDragInteraction.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,KAAK,yBAAyB,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEpG;;GAEG;AACH,UAAU,wBAAwB;IAChC,yBAAyB;IACzB,YAAY,EAAE,SAAS,CAAC;IACxB,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,aAAa,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IAC1C,uDAAuD;IACvD,iBAAiB,EAAE,QAAQ,CAAC,yBAAyB,CAAC,CAAC;CACxD;AAED;;GAEG;AACH,UAAU,wBAAwB;IAChC,yCAAyC;IACzC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IACzC,0DAA0D;IAC1D,eAAe,EAAE,CACf,MAAM,EAAE,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,KAC7D,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IACvC,2DAA2D;IAC3D,gBAAgB,EAAE,CAChB,MAAM,EAAE,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,KAC7D,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IACvC,yCAAyC;IACzC,UAAU,EAAE,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,GAAG,IAAI,CAAC;CAC7E;AAsCD;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,wBAAwB,KAAG,wBAsHrE,CAAC"}

package/dist/types/components/zoomArea/hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,30 @@
+import { ZoomAreaElements, ZoomAreaInteractionConfig, ZoomRange } from '../zoomArea.type';
+/**
+ * Parameters for the useKeyboardNavigation hook
+ */
+interface UseKeyboardNavigationParams {
+    /** Current zoom range */
+    currentRange: ZoomRange;
+    /** Total length of the data array */
+    dataLength: number;
+    /** Callback when range changes */
+    onRangeChange: (range: ZoomRange) => void;
+    /** Interaction configuration with resolved defaults */
+    interactionConfig: Required<ZoomAreaInteractionConfig>;
+}
+/**
+ * Return value for the useKeyboardNavigation hook
+ */
+interface UseKeyboardNavigationReturn {
+    /** Handler for keyboard events on different elements */
+    handleKeyDown: (target: (typeof ZoomAreaElements)[keyof typeof ZoomAreaElements]) => (event: React.KeyboardEvent) => void;
+}
+/**
+ * Custom hook for handling keyboard navigation in ZoomArea
+ *
+ * @param params - Configuration parameters for keyboard navigation
+ * @returns Object with keyboard event handlers
+ */
+export declare const useKeyboardNavigation: (params: UseKeyboardNavigationParams) => UseKeyboardNavigationReturn;
+export {};
+//# sourceMappingURL=useKeyboardNavigation.d.ts.map

package/dist/types/components/zoomArea/hooks/useKeyboardNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardNavigation.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/hooks/useKeyboardNavigation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,KAAK,yBAAyB,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEpG;;GAEG;AACH,UAAU,2BAA2B;IACnC,yBAAyB;IACzB,YAAY,EAAE,SAAS,CAAC;IACxB,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,aAAa,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IAC1C,uDAAuD;IACvD,iBAAiB,EAAE,QAAQ,CAAC,yBAAyB,CAAC,CAAC;CACxD;AAED;;GAEG;AACH,UAAU,2BAA2B;IACnC,wDAAwD;IACxD,aAAa,EAAE,CACb,MAAM,EAAE,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,KAC7D,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,KAAK,IAAI,CAAC;CAC3C;AA4GD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAQ,2BAA2B,KAClC,2BA2CF,CAAC"}

package/dist/types/components/zoomArea/hooks/useResponsiveCanvas.d.ts

@@ -0,0 +1,62 @@
+import { CanvasConfig } from '../../../types/canvas.type';
+/**
+ * Universal responsive canvas hook for chart components.
+ *
+ * Manages canvas dimensions, responsive behavior, and viewBox calculation.
+ * Designed to eventually replace the legacy canvasConfig pattern across all chart components.
+ *
+ * Features:
+ * - Responsive dimensions with ResizeObserver
+ * - Automatic viewBox calculation
+ * - Backward compatibility with canvasConfig
+ * - Modern width/height prop API
+ *
+ * @param width - Canvas width (string with units or number in px)
+ * @param height - Canvas height (string with units or number in px)
+ * @param dataTestId - Unique identifier for the SVG element
+ * @param canvasConfig - Legacy canvas configuration (optional, for backward compatibility)
+ * @param extraSpace - Additional space around the canvas (default: 0)
+ * @returns Object containing parsed dimensions and viewBox
+ *
+ * **Return Values:**
+ * - `parsedCanvas`: Final calculated dimensions in pixels
+ * - `viewBox`: SVG viewBox string for responsive scaling
+ *
+ * @example
+ * ```tsx
+ * // Modern API
+ * const { parsedCanvas, viewBox } = useResponsiveCanvas({
+ *   width: "70%",
+ *   height: 400,
+ *   dataTestId: "my-chart",
+ *   extraSpace: 10
+ * });
+ *
+ * // Legacy compatibility
+ * const { parsedCanvas, viewBox } = useResponsiveCanvas({
+ *   width: "100%",
+ *   height: 300,
+ *   dataTestId: "legacy-chart",
+ *   canvasConfig: { width: "100%", height: 300, extraSpace: 5 }
+ * });
+ * ```
+ */
+interface UseResponsiveCanvasParams {
+    width: string | number;
+    height: string | number;
+    dataTestId: string;
+    canvasConfig?: CanvasConfig;
+    extraSpace?: number | string;
+}
+interface UseResponsiveCanvasReturn {
+    /** Parsed canvas dimensions in pixels */
+    parsedCanvas: {
+        width: number;
+        height: number;
+    };
+    /** SVG viewBox string */
+    viewBox: string;
+}
+export declare const useResponsiveCanvas: ({ canvasConfig, dataTestId, extraSpace, height, width, }: UseResponsiveCanvasParams) => UseResponsiveCanvasReturn;
+export {};
+//# sourceMappingURL=useResponsiveCanvas.d.ts.map

package/dist/types/components/zoomArea/hooks/useResponsiveCanvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResponsiveCanvas.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/hooks/useResponsiveCanvas.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,UAAU,yBAAyB;IACjC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B;AAED,UAAU,yBAAyB;IACjC,yCAAyC;IACzC,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,mBAAmB,GAAI,0DAMjC,yBAAyB,KAAG,yBAyF9B,CAAC"}

package/dist/types/components/zoomArea/hooks/useZoomAreaFocus.d.ts

@@ -0,0 +1,24 @@
+import { ZoomAreaElements } from '../zoomArea.type';
+/**
+ * Return value for the useZoomAreaFocus hook
+ */
+interface UseZoomAreaFocusReturn {
+    /** Handler for focusing on a specific element */
+    handleFocus: (target: keyof typeof ZoomAreaElements) => () => void;
+    /** Handler for clearing focus */
+    handleBlur: () => void;
+    /** Utility to check if an element is focused */
+    isFocused: (target: keyof typeof ZoomAreaElements) => boolean;
+}
+/**
+ * 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 declare const useZoomAreaFocus: () => UseZoomAreaFocusReturn;
+export {};
+//# sourceMappingURL=useZoomAreaFocus.d.ts.map

package/dist/types/components/zoomArea/hooks/useZoomAreaFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useZoomAreaFocus.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/hooks/useZoomAreaFocus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;GAEG;AACH,UAAU,sBAAsB;IAC9B,iDAAiD;IACjD,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,OAAO,gBAAgB,KAAK,MAAM,IAAI,CAAC;IACnE,iCAAiC;IACjC,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,gDAAgD;IAChD,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,OAAO,gBAAgB,KAAK,OAAO,CAAC;CAC/D;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAO,sBAwBnC,CAAC"}

package/dist/types/components/zoomArea/hooks/useZoomData.d.ts

@@ -0,0 +1,33 @@
+import { IZoomAreaDataPoint, ZoomRange } from '../zoomArea.type';
+/**
+ * Custom hook for managing zoom data state and filtering logic.
+ *
+ * Handles the core zoom functionality including range state management,
+ * data filtering, and automatic emission of filtered data changes.
+ *
+ * @param data - Array of data points to be filtered
+ * @param initialRange - Optional initial zoom range
+ * @param onDataChange - Callback function to handle filtered data changes
+ * @returns Object containing current range and range change handler
+ *
+ * @example
+ * ```tsx
+ * const { currentRange, handleRangeChange } = useZoomData({
+ *   data: chartData,
+ *   initialRange: { start: 0, end: 10 },
+ *   onDataChange: (filteredData) => setChartData(filteredData)
+ * });
+ * ```
+ */
+interface UseZoomDataParams {
+    data: IZoomAreaDataPoint[];
+    initialRange?: ZoomRange;
+    onDataChange?: (filteredData: IZoomAreaDataPoint[]) => void;
+}
+interface UseZoomDataReturn {
+    currentRange: ZoomRange;
+    handleRangeChange: (newRange: ZoomRange) => void;
+}
+export declare const useZoomData: ({ data, initialRange, onDataChange, }: UseZoomDataParams) => UseZoomDataReturn;
+export {};
+//# sourceMappingURL=useZoomData.d.ts.map

package/dist/types/components/zoomArea/hooks/useZoomData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useZoomData.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/hooks/useZoomData.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,UAAU,iBAAiB;IACzB,IAAI,EAAE,kBAAkB,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,YAAY,CAAC,EAAE,CAAC,YAAY,EAAE,kBAAkB,EAAE,KAAK,IAAI,CAAC;CAC7D;AAED,UAAU,iBAAiB;IACzB,YAAY,EAAE,SAAS,CAAC;IACxB,iBAAiB,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC;CAClD;AAED,eAAO,MAAM,WAAW,GAAI,uCAIzB,iBAAiB,KAAG,iBA8BtB,CAAC"}

package/dist/types/components/zoomArea/index.d.ts

@@ -0,0 +1,6 @@
+export * from './components';
+export * from './hooks';
+export * from './utils';
+export * from './zoomArea';
+export * from './zoomArea.type';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/zoomArea/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/zoomArea/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/types/components/zoomArea/utils/accessibilityLabels.d.ts

@@ -0,0 +1,28 @@
+import { IZoomAreaDataPoint, ScreenReaderConfig, ZoomRange } from '../zoomArea.type';
+/**
+ * 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 declare const getXAxisValue: (data: IZoomAreaDataPoint[], xKey: string, index: number) => string;
+/**
+ * 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 declare const generateAccessibilityLabels: (data: IZoomAreaDataPoint[], xKey: string, currentRange: ZoomRange, config?: ScreenReaderConfig) => {
+    startHandler: string;
+    endHandler: string;
+    selectionArea: string;
+};
+//# sourceMappingURL=accessibilityLabels.d.ts.map

package/dist/types/components/zoomArea/utils/accessibilityLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibilityLabels.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/utils/accessibilityLabels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAO1F;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,kBAAkB,EAAE,EAAE,MAAM,MAAM,EAAE,OAAO,MAAM,KAAG,MAGvF,CAAC;AAyBF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,GACtC,MAAM,kBAAkB,EAAE,EAC1B,MAAM,MAAM,EACZ,cAAc,SAAS,EACvB,SAAS,kBAAkB,KAC1B;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CAuBvB,CAAC"}

package/dist/types/components/zoomArea/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { getInteractionConfig } from './interactionConfig';
+export { generateCurvedPath, calculateLinesPathData } from './pathGeneration';
+export { calculateHandlerPositions, mouseToDataIndex, clampRange, createDefaultRange, isFullRange, } from './rangeAndPositions';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/zoomArea/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,WAAW,GACZ,MAAM,qBAAqB,CAAC"}

package/dist/types/components/zoomArea/utils/indexRounding.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 declare const roundStartIndex: (index: number, maxIndex: number) => number;
+/**
+ * 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 declare const roundEndIndex: (index: number, maxIndex: number) => number;
+/**
+ * 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 declare const getRangeIndices: (range: {
+    start: number;
+    end: number;
+}, dataLength: number) => {
+    startIndex: number;
+    endIndex: number;
+};
+//# sourceMappingURL=indexRounding.d.ts.map

package/dist/types/components/zoomArea/utils/indexRounding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexRounding.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/utils/indexRounding.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,EAAE,UAAU,MAAM,KAAG,MAGjE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,UAAU,MAAM,KAAG,MAG/D,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACrC,YAAY,MAAM,KACjB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAOxC,CAAC"}

package/dist/types/components/zoomArea/utils/interactionConfig.d.ts

@@ -0,0 +1,10 @@
+import { ZoomAreaInteractionConfig } from '../zoomArea.type';
+/**
+ * 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 declare const getInteractionConfig: (config?: ZoomAreaInteractionConfig) => Required<ZoomAreaInteractionConfig>;
+//# sourceMappingURL=interactionConfig.d.ts.map

package/dist/types/components/zoomArea/utils/interactionConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactionConfig.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/utils/interactionConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAclE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,yBAAyB,KACjC,QAAQ,CAAC,yBAAyB,CAInC,CAAC"}

package/dist/types/components/zoomArea/utils/pathGeneration.d.ts

@@ -0,0 +1,57 @@
+import { IZoomAreaDataPoint, ZoomAreaLineConfig } from '../zoomArea.type';
+/**
+ * Path generation utilities for ZoomArea SVG rendering
+ */
+/**
+ * Generates smooth curved path using simplified Bézier curves.
+ *
+ * This implementation is based on LineChart's curve algorithm but optimized for performance
+ * in the ZoomArea context. Uses cubic Bézier curves with control points positioned at 30%
+ * of the horizontal distance between consecutive points.
+ *
+ * @param points - Array of [x, y] coordinates representing the line points
+ * @returns SVG path string with curved segments (e.g., "M 0 10 C 3 10, 7 20, 10 20")
+ *
+ * @example
+ * ```typescript
+ * const points: Array<[number, number]> = [[0, 10], [10, 20], [20, 15]];
+ * const curvedPath = generateCurvedPath(points);
+ * // Returns: "M 0 10 C 3 10, 7 20, 10 20 C 13 20, 17 15, 20 15"
+ * ```
+ */
+export declare const generateCurvedPath: (points: Array<[number, number]>) => string;
+/**
+ * Calculates path data for all lines with unified Y-scale, supporting both curved and straight lines.
+ *
+ * This function processes multiple line configurations and generates SVG path strings for each line.
+ * All lines share the same Y-scale to maintain visual consistency when comparing different datasets.
+ *
+ * **Y-scaling behavior:** Uses padding to prevent lines from touching chart bounds, similar to LineChart.
+ * The effective chart area is reduced by 10% (5% top + 5% bottom) to provide visual breathing room.
+ *
+ * @param data - Array of data points containing values for all lines
+ * @param lines - Configuration for each line including styling and curve settings
+ * @param width - Canvas width for scaling X coordinates
+ * @param height - Canvas height for scaling Y coordinates
+ * @returns Array of objects containing line and fill paths with their configurations
+ *
+ * @example
+ * ```typescript
+ * const result = calculateLinesPathData(
+ *   [{ month: 'Jan', sales: 100, profit: 20 }, { month: 'Feb', sales: 150, profit: 30 }],
+ *   [
+ *     { yKey: 'sales', stroke: '#blue', curved: true },
+ *     { yKey: 'profit', stroke: '#red', curved: false }
+ *   ],
+ *   400, // width
+ *   100  // height
+ * );
+ * // Returns: [{ linePath: "M 0 80 C...", fillPath: "", config: {...} }, ...]
+ * ```
+ */
+export declare const calculateLinesPathData: (data: IZoomAreaDataPoint[], lines: ZoomAreaLineConfig[], width: number, height: number) => Array<{
+    linePath: string;
+    fillPath: string;
+    config: ZoomAreaLineConfig;
+}>;
+//# sourceMappingURL=pathGeneration.d.ts.map

package/dist/types/components/zoomArea/utils/pathGeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathGeneration.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/utils/pathGeneration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE/E;;GAEG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAG,MAqBpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,kBAAkB,EAAE,EAC1B,OAAO,kBAAkB,EAAE,EAC3B,OAAO,MAAM,EACb,QAAQ,MAAM,KACb,KAAK,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,kBAAkB,CAAC;CAC5B,CA8CA,CAAC"}

package/dist/types/components/zoomArea/utils/rangeAndPositions.d.ts

@@ -0,0 +1,60 @@
+import { ZoomRange } from '../zoomArea.type';
+/**
+ * Range operations and position calculation utilities for ZoomArea
+ */
+/**
+ * Calculates handler positions based on current range
+ *
+ * @param currentRange - The current zoom range
+ * @param dataLength - Total length of the dataset
+ * @param width - Canvas width for scaling
+ * @returns Object with startX and endX positions
+ */
+export declare const calculateHandlerPositions: (currentRange: ZoomRange, dataLength: number, width: number) => {
+    startX: number;
+    endX: number;
+};
+/**
+ * Converts mouse position to continuous data index
+ *
+ * @param mouseX - Mouse X coordinate relative to the chart
+ * @param width - Canvas width
+ * @param dataLength - Total length of the dataset
+ * @returns Data index
+ */
+export declare const mouseToDataIndex: (mouseX: number, width: number, dataLength: number) => number;
+/**
+ * Clamps a range to valid bounds
+ *
+ * @param range - The range to clamp
+ * @param dataLength - Total length of the dataset
+ * @param minDistance - Minimum distance between start and end (default: 0.1)
+ * @returns Clamped range within valid bounds
+ */
+export declare const clampRange: (range: ZoomRange, dataLength: number, minDistance?: number) => ZoomRange;
+/**
+ * Creates a default range for the given data length
+ *
+ * @param dataLength - Total length of the dataset
+ * @returns Default range covering the full dataset
+ */
+export declare const createDefaultRange: (dataLength: number) => ZoomRange;
+/**
+ * Determines if the current range covers the full dataset.
+ * According to design specs: overlay is "only visible when a range is defined".
+ * A range is considered "defined" when it doesn't cover the complete dataset.
+ *
+ * @param range - The current zoom range
+ * @param dataLength - Total length of the dataset
+ * @returns true if the range covers the full dataset (no selection defined)
+ *
+ * @example
+ * ```typescript
+ * // Dataset with 10 elements [0-9]
+ * isFullRange({ start: 0, end: 9 }, 10); // true - covers full dataset
+ * isFullRange({ start: 1, end: 8 }, 10); // false - partial selection
+ * isFullRange({ start: 0, end: 7 }, 10); // false - partial selection
+ * ```
+ */
+export declare const isFullRange: (range: ZoomRange, dataLength: number) => boolean;
+//# sourceMappingURL=rangeAndPositions.d.ts.map

package/dist/types/components/zoomArea/utils/rangeAndPositions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rangeAndPositions.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/utils/rangeAndPositions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;GAEG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GACpC,cAAc,SAAS,EACvB,YAAY,MAAM,EAClB,OAAO,MAAM,KACZ;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAIhC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,EAAE,OAAO,MAAM,EAAE,YAAY,MAAM,KAAG,MAIpF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,SAAS,EAChB,YAAY,MAAM,EAClB,cAAa,MAAY,KACxB,SAQF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,KAAG,SAGtD,CAAC;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,SAAS,EAAE,YAAY,MAAM,KAAG,OAElE,CAAC"}

package/dist/types/components/zoomArea/utils/selectionConfig.d.ts

@@ -0,0 +1,10 @@
+import { ZoomAreaSelectionConfig } from '../zoomArea.type';
+/**
+ * Utility function to get resolved selection configuration.
+ * Merges user-provided config with sensible defaults.
+ *
+ * @param config - Optional user configuration
+ * @returns Complete selection configuration with defaults applied
+ */
+export declare const getSelectionConfig: (config?: ZoomAreaSelectionConfig) => Required<ZoomAreaSelectionConfig>;
+//# sourceMappingURL=selectionConfig.d.ts.map

package/dist/types/components/zoomArea/utils/selectionConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionConfig.d.ts","sourceRoot":"","sources":["../../../../../src/components/zoomArea/utils/selectionConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAkBhE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,uBAAuB,KAC/B,QAAQ,CAAC,uBAAuB,CAOjC,CAAC"}

package/dist/types/components/zoomArea/zoomArea.d.ts

@@ -0,0 +1,12 @@
+import { ZoomAreaProps } from './zoomArea.type';
+/**
+ * `ZoomArea` component that renders a scaled chart with draggable zoom handlers for interactive data filtering.
+ *
+ * It includes full keyboard navigation support, accessibility features, and customizable appearance.
+ *
+ * @param props - See {@link ZoomAreaProps} for detailed documentation of all available properties.
+ *
+ * @returns A React functional component that renders an SVG-based zoom area with interactive handlers and accessibility features.
+ */
+export declare const ZoomArea: React.FC<ZoomAreaProps>;
+//# sourceMappingURL=zoomArea.d.ts.map

package/dist/types/components/zoomArea/zoomArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoomArea.d.ts","sourceRoot":"","sources":["../../../../src/components/zoomArea/zoomArea.tsx"],"names":[],"mappings":"AAmBA,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEvE;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CA6K5C,CAAC"}