flikkui 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/components/charts/hooks/useTooltipPosition.js

@@ -0,0 +1,304 @@
+import { __assign } from '/Users/ggn/Development/ui-flik/node_modules/tslib/tslib.es6.js';
+import { useState, useRef, useEffect, useCallback } from 'react';
+
+// Optimized animation frame throttle for smooth movement
+function rafThrottle(func) {
+    var rafId = null;
+    var latestArgs = null;
+    var throttledFn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        latestArgs = args;
+        if (rafId === null) {
+            rafId = requestAnimationFrame(function () {
+                if (latestArgs) {
+                    func.apply(void 0, latestArgs);
+                }
+                rafId = null;
+                latestArgs = null;
+            });
+        }
+    };
+    // Add cleanup method
+    throttledFn.cancel = function () {
+        if (rafId !== null) {
+            cancelAnimationFrame(rafId);
+            rafId = null;
+            latestArgs = null;
+        }
+    };
+    return throttledFn;
+}
+function useTooltipPosition(_a) {
+    var containerRef = _a.containerRef, _b = _a.padding, padding = _b === void 0 ? 10 : _b, _c = _a.offset, offset = _c === void 0 ? 15 : _c, _d = _a.isMobile, isMobile = _d === void 0 ? false : _d, _e = _a.animation, animation = _e === void 0 ? {
+        duration: 0.08,
+        ease: "easeOut",
+        enabled: true,
+    } : _e;
+    var _f = useState(null), tooltipData = _f[0], setTooltipData = _f[1];
+    var tooltipRef = useRef(null);
+    var isUnmountedRef = useRef(false);
+    // Track component mount status to prevent state updates after unmount
+    useEffect(function () {
+        isUnmountedRef.current = false;
+        return function () {
+            isUnmountedRef.current = true;
+        };
+    }, []);
+    /**
+     * Safe state setter that checks if component is still mounted
+     * Supports both direct values and function updates like React.setState
+     */
+    var safeSetTooltipData = useCallback(function (data) {
+        if (!isUnmountedRef.current) {
+            setTooltipData(function (prevData) {
+                if (typeof data === 'function') {
+                    return data(prevData);
+                }
+                return data;
+            });
+        }
+    }, []);
+    /**
+     * Calculate bounded position within container with simplified logic
+     */
+    var calculateBoundedPosition = useCallback(function (x, y, tooltipWidth, tooltipHeight) {
+        if (tooltipWidth === void 0) { tooltipWidth = 0; }
+        if (tooltipHeight === void 0) { tooltipHeight = 0; }
+        if (!containerRef.current)
+            return { x: x, y: y };
+        try {
+            var containerRect = containerRef.current.getBoundingClientRect();
+            var viewportWidth = window.innerWidth;
+            var viewportHeight = window.innerHeight;
+            var boundedX = x;
+            var boundedY = y;
+            // Simple X positioning: try right, then left, then clamp
+            if (boundedX + tooltipWidth + padding > Math.min(containerRect.right, viewportWidth)) {
+                // Try positioning to the left of cursor
+                boundedX = x - tooltipWidth - offset;
+            }
+            // Ensure it doesn't go off the left edge
+            boundedX = Math.max(Math.max(containerRect.left, 0) + padding, boundedX);
+            // Final clamp to viewport
+            boundedX = Math.min(boundedX, viewportWidth - tooltipWidth - padding);
+            // Simple Y positioning: try below, then above, then clamp
+            if (boundedY + tooltipHeight + padding > Math.min(containerRect.bottom, viewportHeight)) {
+                // Try positioning above cursor
+                boundedY = y - tooltipHeight - offset;
+            }
+            // Ensure it doesn't go off the top edge
+            boundedY = Math.max(Math.max(containerRect.top, 0) + padding, boundedY);
+            // Final clamp to viewport
+            boundedY = Math.min(boundedY, viewportHeight - tooltipHeight - padding);
+            return { x: boundedX, y: boundedY };
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[useTooltipPosition]: Error calculating tooltip position:', error);
+            }
+            return { x: x, y: y };
+        }
+    }, [containerRef, padding, offset]);
+    /**
+     * Get tooltip position for mouse events with stable positioning
+     */
+    var getMouseTooltipPosition = useCallback(function (event) {
+        var _a, _b;
+        // Use page coordinates to avoid scroll issues
+        var x = event.clientX;
+        var y = event.clientY - offset;
+        // Get current tooltip dimensions or use estimated defaults
+        var tooltipWidth = ((_a = tooltipRef.current) === null || _a === void 0 ? void 0 : _a.offsetWidth) || 200; // reasonable default
+        var tooltipHeight = ((_b = tooltipRef.current) === null || _b === void 0 ? void 0 : _b.offsetHeight) || 60; // reasonable default
+        return calculateBoundedPosition(x, y, tooltipWidth, tooltipHeight);
+    }, [calculateBoundedPosition, offset]);
+    /**
+     * Get tooltip position for SVG elements (mobile/touch)
+     */
+    var getSVGTooltipPosition = useCallback(function (event, svgX, svgY, actualDimensions) {
+        var _a, _b;
+        try {
+            var svgElement = event.currentTarget.closest('svg');
+            var svgRect = svgElement === null || svgElement === void 0 ? void 0 : svgElement.getBoundingClientRect();
+            if (!svgRect || !actualDimensions.width || !actualDimensions.height) {
+                if (process.env.NODE_ENV !== 'production') {
+                    console.warn('[useTooltipPosition]: SVG positioning fallback: missing SVG rect or dimensions');
+                }
+                return getMouseTooltipPosition(event);
+            }
+            // Calculate scale factors using actual dimensions
+            var scaleX = svgRect.width / actualDimensions.width;
+            var scaleY = svgRect.height / actualDimensions.height;
+            // Convert SVG coordinates to screen coordinates
+            var screenX_1 = svgRect.left + svgX * scaleX;
+            var screenY_1 = svgRect.top + svgY * scaleY;
+            var x = screenX_1;
+            var y = screenY_1 - offset;
+            var tooltipWidth = ((_a = tooltipRef.current) === null || _a === void 0 ? void 0 : _a.offsetWidth) || 200;
+            var tooltipHeight = ((_b = tooltipRef.current) === null || _b === void 0 ? void 0 : _b.offsetHeight) || 60;
+            return calculateBoundedPosition(x, y, tooltipWidth, tooltipHeight);
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[useTooltipPosition]: Error in SVG tooltip positioning:', error);
+            }
+            return getMouseTooltipPosition(event);
+        }
+    }, [calculateBoundedPosition, getMouseTooltipPosition, offset]);
+    /**
+     * Show tooltip with content and position
+     */
+    var showTooltip = useCallback(function (content, position) {
+        safeSetTooltipData({
+            x: position.x,
+            y: position.y,
+            content: content,
+        });
+    }, [safeSetTooltipData]);
+    /**
+     * Update tooltip position (for mouse move events)
+     */
+    var updateTooltipPosition = useCallback(function (position) {
+        safeSetTooltipData(function (prev) {
+            return prev ? __assign(__assign({}, prev), { x: position.x, y: position.y }) : null;
+        });
+    }, [safeSetTooltipData]);
+    // Create RAF-throttled version of updateTooltipPosition for smooth movement
+    var rafThrottledUpdateRef = useRef(null);
+    var rafThrottledUpdate = useCallback(function (position) {
+        if (!isUnmountedRef.current) {
+            updateTooltipPosition(position);
+        }
+    }, [updateTooltipPosition]);
+    // Initialize RAF throttling
+    useEffect(function () {
+        rafThrottledUpdateRef.current = rafThrottle(rafThrottledUpdate);
+        return function () {
+            var _a;
+            if ((_a = rafThrottledUpdateRef.current) === null || _a === void 0 ? void 0 : _a.cancel) {
+                rafThrottledUpdateRef.current.cancel();
+            }
+        };
+    }, [rafThrottledUpdate]);
+    /**
+     * Hide tooltip and cancel any pending updates
+     */
+    var hideTooltip = useCallback(function () {
+        var _a;
+        // Cancel any pending RAF updates
+        if ((_a = rafThrottledUpdateRef.current) === null || _a === void 0 ? void 0 : _a.cancel) {
+            rafThrottledUpdateRef.current.cancel();
+        }
+        safeSetTooltipData(null);
+    }, [safeSetTooltipData]);
+    /**
+     * Handle mouse enter for chart elements
+     */
+    var handleMouseEnter = useCallback(function (event, content, svgCoordinates) {
+        try {
+            var position = void 0;
+            if (isMobile && svgCoordinates) {
+                position = getSVGTooltipPosition(event, svgCoordinates.x, svgCoordinates.y, svgCoordinates.dimensions);
+            }
+            else {
+                position = getMouseTooltipPosition(event);
+            }
+            showTooltip(content, position);
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[useTooltipPosition]: Error handling mouse enter:', error);
+            }
+        }
+    }, [isMobile, getSVGTooltipPosition, getMouseTooltipPosition, showTooltip]);
+    /**
+     * Handle mouse move with optimized RAF throttling for smooth movement
+     */
+    var handleMouseMove = useCallback(function (event, svgCoordinates) {
+        if (!tooltipData)
+            return;
+        try {
+            // Always use mouse position for consistent movement
+            var position = getMouseTooltipPosition(event);
+            if (rafThrottledUpdateRef.current) {
+                rafThrottledUpdateRef.current(position);
+            }
+            else {
+                // Fallback to direct update
+                updateTooltipPosition(position);
+            }
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[useTooltipPosition]: Error handling mouse move:', error);
+            }
+        }
+    }, [tooltipData, getMouseTooltipPosition, updateTooltipPosition]);
+    /**
+     * Handle mouse leave for chart elements
+     */
+    var handleMouseLeave = useCallback(function () {
+        hideTooltip();
+    }, [hideTooltip]);
+    // Update tooltip position when container resizes (simplified)
+    useEffect(function () {
+        if (!tooltipData || !containerRef.current)
+            return;
+        var handleResize = function () {
+            if (tooltipData && tooltipRef.current && !isUnmountedRef.current) {
+                try {
+                    var tooltipWidth = tooltipRef.current.offsetWidth;
+                    var tooltipHeight = tooltipRef.current.offsetHeight;
+                    var newPosition = calculateBoundedPosition(tooltipData.x, tooltipData.y, tooltipWidth, tooltipHeight);
+                    // Use direct update for resize, not RAF throttled
+                    updateTooltipPosition(newPosition);
+                }
+                catch (error) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        console.warn('[useTooltipPosition]: Error updating tooltip position on resize:', error);
+                    }
+                }
+            }
+        };
+        // Use window resize instead of ResizeObserver for better performance
+        window.addEventListener('resize', handleResize);
+        return function () {
+            window.removeEventListener('resize', handleResize);
+        };
+    }, [tooltipData, containerRef, calculateBoundedPosition, updateTooltipPosition]);
+    return {
+        tooltipData: tooltipData,
+        tooltipRef: tooltipRef,
+        showTooltip: showTooltip,
+        hideTooltip: hideTooltip,
+        updateTooltipPosition: updateTooltipPosition,
+        handleMouseEnter: handleMouseEnter,
+        handleMouseMove: handleMouseMove,
+        handleMouseLeave: handleMouseLeave,
+        getMouseTooltipPosition: getMouseTooltipPosition,
+        getSVGTooltipPosition: getSVGTooltipPosition,
+        // Animation configuration for the consuming component
+        animationConfig: {
+            animate: tooltipData ? { x: tooltipData.x, y: tooltipData.y, opacity: 1 } : { opacity: 0 },
+            transition: animation.enabled ? {
+                duration: animation.duration,
+                ease: animation.ease,
+                // Reduce layout thrashing by using transform instead of changing x/y directly
+                type: "tween",
+            } : { duration: 0 },
+            initial: { opacity: 0 },
+            style: tooltipData ? {
+                position: 'fixed',
+                left: 0,
+                top: 0,
+                transform: "translate(".concat(tooltipData.x, "px, ").concat(tooltipData.y, "px)"),
+                willChange: 'transform, opacity', // Optimize for animations
+            } : {},
+        },
+    };
+}
+
+export { useTooltipPosition };

package/dist/components/charts/index.d.ts

@@ -1,49 +1,52 @@
-export { ChartContainer } from './ChartContainer';
-export { BarChart } from './BarChart';
-export { LineChart } from './LineChart';
-export { AreaChart } from './AreaChart';
-export { DonutChart } from './DonutChart/DonutChart';
-export { MultiSegmentDonutChart } from './DonutChart/MultiSegmentDonutChart';
-export { Heatmap } from './Heatmap';
-export { FunnelChart } from './FunnelChart';
-export { ScatterPlot } from './ScatterPlot';
-export { ComboChart } from './ComboChart';
-export { ActivityRings } from './ActivityRings';
-export { ChartTooltip } from './shared/ChartTooltip';
-export { ChartLegend, ChartLegendContent } from './shared/ChartLegend';
-export { XAxis, YAxis } from './shared/ChartAxis';
-export { ChartText } from './shared/ChartText';
-export { ChartMarker } from './shared/ChartMarker';
-export { ChartCrosshair } from './shared/ChartCrosshair';
-export { HorizontalGrid } from './shared/ChartGrid';
-export { useChartTheme } from './hooks/useChartTheme';
-export { useTooltipPosition } from './hooks/useTooltipPosition';
-export { useChartAccessibility } from './hooks/useChartAccessibility';
-export { useChartValidation } from './hooks/useChartValidation';
-export { generateColorPalette, getContrastColor } from './utils/color-utils';
-export { processHeatmapData, calculateIntensity, createGridMatrix, getDefaultTooltipContent, formatAxisLabel, generateSampleData } from './Heatmap/utils/heatmapUtils';
-export type { ChartDataPoint, ChartConfig, ChartVariant, CurveType, BaseChartProps, StandardChartDisplayProps, StandardVisualProps, BarChartSpecificProps, StandardAxisConfig, ChartThemeOverrides, CHART_DEFAULTS, } from './types/chart.types';
-export type { ChartTooltipProps, ChartTooltipContentProps, } from './shared/ChartTooltip/ChartTooltip.types';
-export type { ChartLegendProps, ChartLegendContentProps, } from './shared/ChartLegend/ChartLegend.types';
-export type { BaseAxisProps, XAxisProps, YAxisProps, AxisTickProps, } from './shared/ChartAxis/ChartAxis.types';
-export type { ChartTextProps, ChartTextTheme, } from './shared/ChartText/ChartText.types';
-export type { ChartMarkerProps, ChartMarkerTheme, } from './shared/ChartMarker/ChartMarker.types';
-export type { ChartCrosshairProps, ChartCrosshairTheme, } from './shared/ChartCrosshair/ChartCrosshair.types';
-export type { HorizontalGridProps, } from './shared/ChartGrid';
-export type { BarChartProps } from './BarChart/BarChart.types';
-export type { LineChartProps } from './LineChart/LineChart.types';
-export type { AreaChartProps } from './AreaChart/AreaChart.types';
-export type { DonutChartProps } from './DonutChart/DonutChart.types';
-export type { MultiSegmentDonutChartProps, DonutSegment } from './DonutChart/MultiSegmentDonutChart.types';
-export type { HeatmapProps } from './Heatmap/Heatmap.types';
-export type { FunnelChartProps, FunnelChartDataPoint } from './FunnelChart/FunnelChart.types';
-export type { ScatterPlotProps, ScatterPlotDataPoint } from './ScatterPlot/ScatterPlot.types';
-export type { ComboChartProps, ComboChartConfig, SeriesType } from './ComboChart/ComboChart.types';
-export type { ActivityRingsProps, RingData, ActivityRingsThemeOverrides } from './ActivityRings/ActivityRings.types';
-export { chartTheme } from './theme/chart.theme';
-export { extractFillClass, extractStrokeClass, colorClassToVariable, combineClasses, createColorClass, generateSeriesColors, DEFAULT_CHART_COLORS, EXTENDED_CHART_COLORS, MINIMAL_CHART_COLORS, } from './utils/color-utils';
-export { validateChart, validateChartData, validateChartConfig, sanitizeChartData, calculateSafeScaleRange, SafeMath } from './utils/chart-validation';
-export { BAR_CHART_DEFAULTS } from './BarChart/BarChart.types';
-export { LINE_CHART_DEFAULTS } from './LineChart/LineChart.types';
-export { AREA_CHART_DEFAULTS } from './AreaChart/AreaChart.types';
-export { ChartErrorBoundary } from './shared/ChartErrorBoundary';
+export { ChartContainer } from "./ChartContainer";
+export { BarChart } from "./BarChart";
+export { StackedBarChart } from "./StackedBarChart";
+export { LineChart } from "./LineChart";
+export { AreaChart } from "./AreaChart";
+export { DonutChart } from "./DonutChart/DonutChart";
+export { MultiSegmentDonutChart } from "./DonutChart/MultiSegmentDonutChart";
+export { Heatmap } from "./Heatmap";
+export { FunnelChart } from "./FunnelChart";
+export { ScatterPlot } from "./ScatterPlot";
+export { ComboChart } from "./ComboChart";
+export { ActivityRings } from "./ActivityRings";
+export { ChartTooltip } from "./shared/ChartTooltip";
+export { ChartLegend, ChartLegendContent } from "./shared/ChartLegend";
+export { XAxis, YAxis } from "./shared/ChartAxis";
+export { ChartText } from "./shared/ChartText";
+export { ChartMarker } from "./shared/ChartMarker";
+export { ChartCrosshair } from "./shared/ChartCrosshair";
+export { HorizontalGrid } from "./shared/ChartGrid";
+export { useChartTheme } from "./hooks/useChartTheme";
+export { useTooltipPosition } from "./hooks/useTooltipPosition";
+export { useChartAccessibility } from "./hooks/useChartAccessibility";
+export { useChartValidation } from "./hooks/useChartValidation";
+export { generateColorPalette, getContrastColor } from "./utils/color-utils";
+export { processHeatmapData, calculateIntensity, createGridMatrix, getDefaultTooltipContent, formatAxisLabel, generateSampleData, } from "./Heatmap/utils/heatmapUtils";
+export type { ChartDataPoint, ChartConfig, ChartVariant, CurveType, BaseChartProps, StandardChartDisplayProps, StandardVisualProps, BarChartSpecificProps, StandardAxisConfig, ChartThemeOverrides, CHART_DEFAULTS, } from "./types/chart.types";
+export type { ChartTooltipProps, ChartTooltipContentProps, } from "./shared/ChartTooltip/ChartTooltip.types";
+export type { ChartLegendProps, ChartLegendContentProps, } from "./shared/ChartLegend/ChartLegend.types";
+export type { BaseAxisProps, XAxisProps, YAxisProps, AxisTickProps, } from "./shared/ChartAxis/ChartAxis.types";
+export type { ChartTextProps, ChartTextTheme, } from "./shared/ChartText/ChartText.types";
+export type { ChartMarkerProps, ChartMarkerTheme, } from "./shared/ChartMarker/ChartMarker.types";
+export type { ChartCrosshairProps, ChartCrosshairTheme, } from "./shared/ChartCrosshair/ChartCrosshair.types";
+export type { HorizontalGridProps } from "./shared/ChartGrid";
+export type { BarChartProps } from "./BarChart/BarChart.types";
+export type { StackedBarChartProps, StackOffset, } from "./StackedBarChart/StackedBarChart.types";
+export type { LineChartProps } from "./LineChart/LineChart.types";
+export type { AreaChartProps } from "./AreaChart/AreaChart.types";
+export type { DonutChartProps } from "./DonutChart/DonutChart.types";
+export type { MultiSegmentDonutChartProps, DonutSegment, } from "./DonutChart/MultiSegmentDonutChart.types";
+export type { HeatmapProps } from "./Heatmap/Heatmap.types";
+export type { FunnelChartProps, FunnelChartDataPoint, } from "./FunnelChart/FunnelChart.types";
+export type { ScatterPlotProps, ScatterPlotDataPoint, } from "./ScatterPlot/ScatterPlot.types";
+export type { ComboChartProps, ComboChartConfig, SeriesType, } from "./ComboChart/ComboChart.types";
+export type { ActivityRingsProps, RingData, ActivityRingsThemeOverrides, } from "./ActivityRings/ActivityRings.types";
+export { chartTheme } from "./theme/chart.theme";
+export { extractFillClass, extractStrokeClass, colorClassToVariable, combineClasses, createColorClass, generateSeriesColors, DEFAULT_CHART_COLORS, EXTENDED_CHART_COLORS, MINIMAL_CHART_COLORS, } from "./utils/color-utils";
+export { validateChart, validateChartData, validateChartConfig, sanitizeChartData, calculateSafeScaleRange, SafeMath, } from "./utils/chart-validation";
+export { BAR_CHART_DEFAULTS } from "./BarChart/BarChart.types";
+export { STACKED_BAR_CHART_DEFAULTS } from "./StackedBarChart/StackedBarChart.types";
+export { LINE_CHART_DEFAULTS } from "./LineChart/LineChart.types";
+export { AREA_CHART_DEFAULTS } from "./AreaChart/AreaChart.types";
+export { ChartErrorBoundary } from "./shared/ChartErrorBoundary";

package/dist/components/charts/index.js

@@ -0,0 +1,40 @@
+export { ChartContainer } from './ChartContainer.js';
+export { BarChart } from './BarChart/BarChart.js';
+export { StackedBarChart } from './StackedBarChart/StackedBarChart.js';
+export { STACKED_BAR_CHART_DEFAULTS } from './StackedBarChart/StackedBarChart.types.js';
+export { LineChart } from './LineChart/LineChart.js';
+export { AreaChart } from './AreaChart/AreaChart.js';
+export { DonutChart } from './DonutChart/DonutChart.js';
+export { MultiSegmentDonutChart } from './DonutChart/MultiSegmentDonutChart.js';
+export { Heatmap } from './Heatmap/Heatmap.js';
+import '/Users/ggn/Development/ui-flik/node_modules/tslib/tslib.es6.js';
+import 'react';
+import 'motion/react';
+import 'clsx';
+import 'tailwind-merge';
+export { calculateIntensity, createGridMatrix, formatAxisLabel, generateSampleData, getDefaultTooltipContent, processHeatmapData } from './Heatmap/utils/heatmapUtils.js';
+export { FunnelChart } from './FunnelChart/FunnelChart.js';
+export { ScatterPlot } from './ScatterPlot/ScatterPlot.js';
+export { ComboChart } from './ComboChart/ComboChart.js';
+import './ComboChart/ComboChart.types.js';
+export { ActivityRings } from './ActivityRings/ActivityRings.js';
+export { ChartTooltip } from './shared/ChartTooltip/ChartTooltip.js';
+export { ChartLegend } from './shared/ChartLegend/ChartLegend.js';
+export { ChartLegendContent } from './shared/ChartLegend/ChartLegendContent.js';
+export { XAxis } from './shared/ChartAxis/XAxis.js';
+export { YAxis } from './shared/ChartAxis/YAxis.js';
+export { ChartText } from './shared/ChartText/ChartText.js';
+export { ChartMarker } from './shared/ChartMarker/ChartMarker.js';
+export { ChartCrosshair } from './shared/ChartCrosshair/ChartCrosshair.js';
+export { HorizontalGrid } from './shared/ChartGrid/HorizontalGrid.js';
+export { useChartTheme } from './hooks/useChartTheme.js';
+export { useTooltipPosition } from './hooks/useTooltipPosition.js';
+export { useChartAccessibility } from './hooks/useChartAccessibility.js';
+export { useChartValidation } from './hooks/useChartValidation.js';
+export { DEFAULT_CHART_COLORS, EXTENDED_CHART_COLORS, MINIMAL_CHART_COLORS, colorClassToVariable, combineClasses, createColorClass, extractFillClass, extractStrokeClass, generateColorPalette, generateSeriesColors, getContrastColor } from './utils/color-utils.js';
+export { chartTheme } from './theme/chart.theme.js';
+export { SafeMath, calculateSafeScaleRange, sanitizeChartData, validateChart, validateChartConfig, validateChartData } from './utils/chart-validation.js';
+export { BAR_CHART_DEFAULTS } from './BarChart/BarChart.types.js';
+export { LINE_CHART_DEFAULTS } from './LineChart/LineChart.types.js';
+export { AREA_CHART_DEFAULTS } from './AreaChart/AreaChart.types.js';
+export { ChartErrorBoundary } from './shared/ChartErrorBoundary/ChartErrorBoundary.js';