@mui/x-charts-pro 8.0.0-alpha.6 → 8.0.0-alpha.8

package/context/ZoomProvider/useSetupPan.js

@@ -1,106 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useDrawingArea, useSvgRef } from '@mui/x-charts/hooks';
-import { getSVGPoint } from '@mui/x-charts/internals';
-import { useZoom } from "./useZoom.js";
-export const useSetupPan = () => {
-  const {
-    zoomData,
-    setZoomData,
-    setIsInteracting,
-    isPanEnabled,
-    options
-  } = useZoom();
-  const drawingArea = useDrawingArea();
-  const svgRef = useSvgRef();
-  const isDraggingRef = React.useRef(false);
-  const touchStartRef = React.useRef(null);
-  const eventCacheRef = React.useRef([]);
-  React.useEffect(() => {
-    const element = svgRef.current;
-    if (element === null || !isPanEnabled) {
-      return () => {};
-    }
-    const handlePan = event => {
-      if (element === null || !isDraggingRef.current || eventCacheRef.current.length > 1) {
-        return;
-      }
-      if (touchStartRef.current == null) {
-        return;
-      }
-      const point = getSVGPoint(element, event);
-      const movementX = point.x - touchStartRef.current.x;
-      const movementY = (point.y - touchStartRef.current.y) * -1;
-      const newZoomData = touchStartRef.current.zoomData.map(zoom => {
-        const option = options[zoom.axisId];
-        if (!option || !option.panning) {
-          return zoom;
-        }
-        const min = zoom.start;
-        const max = zoom.end;
-        const span = max - min;
-        const MIN_PERCENT = option.minStart;
-        const MAX_PERCENT = option.maxEnd;
-        const movement = option.axisDirection === 'x' ? movementX : movementY;
-        const dimension = option.axisDirection === 'x' ? drawingArea.width : drawingArea.height;
-        let newMinPercent = min - movement / dimension * span;
-        let newMaxPercent = max - movement / dimension * span;
-        if (newMinPercent < MIN_PERCENT) {
-          newMinPercent = MIN_PERCENT;
-          newMaxPercent = newMinPercent + span;
-        }
-        if (newMaxPercent > MAX_PERCENT) {
-          newMaxPercent = MAX_PERCENT;
-          newMinPercent = newMaxPercent - span;
-        }
-        if (newMinPercent < MIN_PERCENT || newMaxPercent > MAX_PERCENT || span < option.minSpan || span > option.maxSpan) {
-          return zoom;
-        }
-        return _extends({}, zoom, {
-          start: newMinPercent,
-          end: newMaxPercent
-        });
-      });
-      setZoomData(newZoomData);
-    };
-    const handleDown = event => {
-      eventCacheRef.current.push(event);
-      const point = getSVGPoint(element, event);
-      if (!drawingArea.isPointInside(point)) {
-        return;
-      }
-
-      // If there is only one pointer, prevent selecting text
-      if (eventCacheRef.current.length === 1) {
-        event.preventDefault();
-      }
-      isDraggingRef.current = true;
-      setIsInteracting(true);
-      touchStartRef.current = {
-        x: point.x,
-        y: point.y,
-        zoomData
-      };
-    };
-    const handleUp = event => {
-      eventCacheRef.current.splice(eventCacheRef.current.findIndex(cachedEvent => cachedEvent.pointerId === event.pointerId), 1);
-      setIsInteracting(false);
-      isDraggingRef.current = false;
-      touchStartRef.current = null;
-    };
-    element.addEventListener('pointerdown', handleDown);
-    document.addEventListener('pointermove', handlePan);
-    document.addEventListener('pointerup', handleUp);
-    document.addEventListener('pointercancel', handleUp);
-    document.addEventListener('pointerleave', handleUp);
-    return () => {
-      element.removeEventListener('pointerdown', handleDown);
-      document.removeEventListener('pointermove', handlePan);
-      document.removeEventListener('pointerup', handleUp);
-      document.removeEventListener('pointercancel', handleUp);
-      document.removeEventListener('pointerleave', handleUp);
-    };
-  }, [drawingArea, svgRef, isDraggingRef, setIsInteracting, zoomData, setZoomData, isPanEnabled, options]);
-};

package/context/ZoomProvider/useSetupZoom.d.ts

@@ -1 +0,0 @@
-export declare const useSetupZoom: () => void;

package/context/ZoomProvider/useSetupZoom.js

@@ -1,274 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { useDrawingArea, useSvgRef } from '@mui/x-charts/hooks';
-import { getSVGPoint } from '@mui/x-charts/internals';
-import { useZoom } from "./useZoom.js";
-/**
- * Helper to get the range (in percents of a reference range) corresponding to a given scale.
- * @param centerRatio {number} The ratio of the point that should not move between the previous and next range.
- * @param scaleRatio {number} The target scale ratio.
- * @returns The range to display.
- */
-const zoomAtPoint = (centerRatio, scaleRatio, currentZoomData, options) => {
-  const MIN_RANGE = options.minStart;
-  const MAX_RANGE = options.maxEnd;
-  const MIN_ALLOWED_SPAN = options.minSpan;
-  const minRange = currentZoomData.start;
-  const maxRange = currentZoomData.end;
-  const point = minRange + centerRatio * (maxRange - minRange);
-  let newMinRange = (minRange + point * (scaleRatio - 1)) / scaleRatio;
-  let newMaxRange = (maxRange + point * (scaleRatio - 1)) / scaleRatio;
-  let minSpillover = 0;
-  let maxSpillover = 0;
-  if (newMinRange < MIN_RANGE) {
-    minSpillover = Math.abs(newMinRange);
-    newMinRange = MIN_RANGE;
-  }
-  if (newMaxRange > MAX_RANGE) {
-    maxSpillover = Math.abs(newMaxRange - MAX_RANGE);
-    newMaxRange = MAX_RANGE;
-  }
-  if (minSpillover > 0 && maxSpillover > 0) {
-    return [MIN_RANGE, MAX_RANGE];
-  }
-  newMaxRange += minSpillover;
-  newMinRange -= maxSpillover;
-  newMinRange = Math.min(MAX_RANGE - MIN_ALLOWED_SPAN, Math.max(MIN_RANGE, newMinRange));
-  newMaxRange = Math.max(MIN_ALLOWED_SPAN, Math.min(MAX_RANGE, newMaxRange));
-  return [newMinRange, newMaxRange];
-};
-export const useSetupZoom = () => {
-  const {
-    setZoomData,
-    isZoomEnabled,
-    options,
-    setIsInteracting
-  } = useZoom();
-  const drawingArea = useDrawingArea();
-  const svgRef = useSvgRef();
-  const eventCacheRef = React.useRef([]);
-  const eventPrevDiff = React.useRef(0);
-  const interactionTimeoutRef = React.useRef(undefined);
-  React.useEffect(() => {
-    const element = svgRef.current;
-    if (element === null || !isZoomEnabled) {
-      return () => {};
-    }
-    const wheelHandler = event => {
-      if (element === null) {
-        return;
-      }
-      const point = getSVGPoint(element, event);
-      if (!drawingArea.isPointInside(point)) {
-        return;
-      }
-      event.preventDefault();
-      if (interactionTimeoutRef.current) {
-        clearTimeout(interactionTimeoutRef.current);
-      }
-      setIsInteracting(true);
-      // Debounce transition to `isInteractive=false`.
-      // Useful because wheel events don't have an "end" event.
-      interactionTimeoutRef.current = window.setTimeout(() => {
-        setIsInteracting(false);
-      }, 166);
-      setZoomData(prevZoomData => {
-        return prevZoomData.map(zoom => {
-          const option = options[zoom.axisId];
-          if (!option) {
-            return zoom;
-          }
-          const centerRatio = option.axisDirection === 'x' ? getHorizontalCenterRatio(point, drawingArea) : getVerticalCenterRatio(point, drawingArea);
-          const {
-            scaleRatio,
-            isZoomIn
-          } = getWheelScaleRatio(event, option.step);
-          const [newMinRange, newMaxRange] = zoomAtPoint(centerRatio, scaleRatio, zoom, option);
-          if (!isSpanValid(newMinRange, newMaxRange, isZoomIn, option)) {
-            return zoom;
-          }
-          return {
-            axisId: zoom.axisId,
-            start: newMinRange,
-            end: newMaxRange
-          };
-        });
-      });
-    };
-    function pointerDownHandler(event) {
-      eventCacheRef.current.push(event);
-      setIsInteracting(true);
-    }
-    function pointerMoveHandler(event) {
-      if (element === null) {
-        return;
-      }
-      const index = eventCacheRef.current.findIndex(cachedEv => cachedEv.pointerId === event.pointerId);
-      eventCacheRef.current[index] = event;
-
-      // Not a pinch gesture
-      if (eventCacheRef.current.length !== 2) {
-        return;
-      }
-      const firstEvent = eventCacheRef.current[0];
-      const curDiff = getDiff(eventCacheRef.current);
-      setZoomData(prevZoomData => {
-        const newZoomData = prevZoomData.map(zoom => {
-          const option = options[zoom.axisId];
-          if (!option) {
-            return zoom;
-          }
-          const {
-            scaleRatio,
-            isZoomIn
-          } = getPinchScaleRatio(curDiff, eventPrevDiff.current, option.step);
-
-          // If the scale ratio is 0, it means the pinch gesture is not valid.
-          if (scaleRatio === 0) {
-            return zoom;
-          }
-          const point = getSVGPoint(element, firstEvent);
-          const centerRatio = option.axisDirection === 'x' ? getHorizontalCenterRatio(point, drawingArea) : getVerticalCenterRatio(point, drawingArea);
-          const [newMinRange, newMaxRange] = zoomAtPoint(centerRatio, scaleRatio, zoom, option);
-          if (!isSpanValid(newMinRange, newMaxRange, isZoomIn, option)) {
-            return zoom;
-          }
-          return {
-            axisId: zoom.axisId,
-            start: newMinRange,
-            end: newMaxRange
-          };
-        });
-        eventPrevDiff.current = curDiff;
-        return newZoomData;
-      });
-    }
-    function pointerUpHandler(event) {
-      eventCacheRef.current.splice(eventCacheRef.current.findIndex(cachedEvent => cachedEvent.pointerId === event.pointerId), 1);
-      if (eventCacheRef.current.length < 2) {
-        eventPrevDiff.current = 0;
-      }
-      if (event.type === 'pointerup' || event.type === 'pointercancel') {
-        setIsInteracting(false);
-      }
-    }
-    element.addEventListener('wheel', wheelHandler);
-    element.addEventListener('pointerdown', pointerDownHandler);
-    element.addEventListener('pointermove', pointerMoveHandler);
-    element.addEventListener('pointerup', pointerUpHandler);
-    element.addEventListener('pointercancel', pointerUpHandler);
-    element.addEventListener('pointerout', pointerUpHandler);
-    element.addEventListener('pointerleave', pointerUpHandler);
-
-    // Prevent zooming the entire page on touch devices
-    element.addEventListener('touchstart', preventDefault);
-    element.addEventListener('touchmove', preventDefault);
-    return () => {
-      element.removeEventListener('wheel', wheelHandler);
-      element.removeEventListener('pointerdown', pointerDownHandler);
-      element.removeEventListener('pointermove', pointerMoveHandler);
-      element.removeEventListener('pointerup', pointerUpHandler);
-      element.removeEventListener('pointercancel', pointerUpHandler);
-      element.removeEventListener('pointerout', pointerUpHandler);
-      element.removeEventListener('pointerleave', pointerUpHandler);
-      element.removeEventListener('touchstart', preventDefault);
-      element.removeEventListener('touchmove', preventDefault);
-      if (interactionTimeoutRef.current) {
-        clearTimeout(interactionTimeoutRef.current);
-      }
-    };
-  }, [svgRef, setZoomData, drawingArea, isZoomEnabled, options, setIsInteracting]);
-};
-
-/**
- * Checks if the new span is valid.
- */
-function isSpanValid(minRange, maxRange, isZoomIn, option) {
-  const newSpanPercent = maxRange - minRange;
-  if (isZoomIn && newSpanPercent < option.minSpan || !isZoomIn && newSpanPercent > option.maxSpan) {
-    return false;
-  }
-  if (minRange < option.minStart || maxRange > option.maxEnd) {
-    return false;
-  }
-  return true;
-}
-function getMultiplier(event) {
-  const ctrlMultiplier = event.ctrlKey ? 3 : 1;
-
-  // DeltaMode: 0 is pixel, 1 is line, 2 is page
-  // This is defined by the browser.
-  if (event.deltaMode === 1) {
-    return 1 * ctrlMultiplier;
-  }
-  if (event.deltaMode) {
-    return 10 * ctrlMultiplier;
-  }
-  return 0.2 * ctrlMultiplier;
-}
-
-/**
- * Get the scale ratio and if it's a zoom in or out from a wheel event.
- */
-function getWheelScaleRatio(event, step) {
-  const deltaY = -event.deltaY;
-  const multiplier = getMultiplier(event);
-  const scaledStep = step * multiplier * deltaY / 1000;
-  // Clamp the scale ratio between 0.1 and 1.9 so that the zoom is not too big or too small.
-  const scaleRatio = Math.min(Math.max(1 + scaledStep, 0.1), 1.9);
-  const isZoomIn = deltaY > 0;
-  return {
-    scaleRatio,
-    isZoomIn
-  };
-}
-
-/**
- * Get the scale ratio and if it's a zoom in or out from a pinch gesture.
- */
-function getPinchScaleRatio(curDiff, prevDiff, step) {
-  const scaledStep = step / 1000;
-  let scaleRatio = 0;
-  let isZoomIn = false;
-  const hasMoved = prevDiff > 0;
-  if (hasMoved && curDiff > prevDiff) {
-    // The distance between the two pointers has increased
-    scaleRatio = 1 + scaledStep;
-    isZoomIn = true;
-  }
-  if (hasMoved && curDiff < prevDiff) {
-    // The distance between the two pointers has decreased
-    scaleRatio = 1 - scaledStep;
-    isZoomIn = false;
-  }
-  return {
-    scaleRatio,
-    isZoomIn
-  };
-}
-function getDiff(eventCache) {
-  const [firstEvent, secondEvent] = eventCache;
-  return Math.hypot(firstEvent.pageX - secondEvent.pageX, firstEvent.pageY - secondEvent.pageY);
-}
-
-/**
- * Get the ratio of the point in the horizontal center of the area.
- */
-function getHorizontalCenterRatio(point, area) {
-  const {
-    left,
-    width
-  } = area;
-  return (point.x - left) / width;
-}
-function preventDefault(event) {
-  event.preventDefault();
-}
-function getVerticalCenterRatio(point, area) {
-  const {
-    top,
-    height
-  } = area;
-  return (point.y - top) / height * -1 + 1;
-}

package/context/ZoomProvider/useZoom.d.ts

@@ -1,7 +0,0 @@
-import { ZoomState } from './Zoom.types';
-/**
- * Get access to the zoom state.
- *
- * @returns {ZoomState} The zoom state.
- */
-export declare function useZoom(): ZoomState;

package/context/ZoomProvider/useZoom.js

@@ -1,19 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { ZoomContext } from "./ZoomContext.js";
-/**
- * Get access to the zoom state.
- *
- * @returns {ZoomState} The zoom state.
- */
-export function useZoom() {
-  const {
-    data,
-    isInitialized
-  } = React.useContext(ZoomContext);
-  if (!isInitialized) {
-    throw new Error(['MUI X: Could not find the zoom context.', 'It looks like you rendered your component outside of a ChartsContainer parent component.'].join('\n'));
-  }
-  return data;
-}

package/context/index.d.ts

@@ -1,3 +0,0 @@
-export type { ZoomOptions, ZoomData, ZoomProps, ZoomState } from './ZoomProvider/Zoom.types';
-export * from './ZoomProvider/useZoom';
-export * from './ZoomProvider/ZoomSetup';

package/context/index.js

@@ -1,5 +0,0 @@
-// # Zoom & Pan
-
-export * from "./ZoomProvider/useZoom.js";
-export * from "./ZoomProvider/ZoomSetup.js";
-export {};

package/context/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": false,
-  "module": "./index.js",
-  "main": "../node/context/index.js",
-  "types": "./index.d.ts"
-}

package/modern/context/CartesianProviderPro/CartesianProviderPro.js

@@ -1,89 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useDrawingArea, useSeries, CartesianContext, computeAxisValue, useXExtremumGetter, useYExtremumGetter } from '@mui/x-charts/internals';
-import { useZoom } from "../ZoomProvider/useZoom.js";
-import { createAxisFilterMapper, createGetAxisFilters } from "./createAxisFilterMapper.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-function CartesianProviderPro(props) {
-  const {
-    xAxis,
-    yAxis,
-    children
-  } = props;
-  const formattedSeries = useSeries();
-  const drawingArea = useDrawingArea();
-  const {
-    zoomData,
-    options
-  } = useZoom();
-  const xExtremumGetters = useXExtremumGetter();
-  const yExtremumGetters = useYExtremumGetter();
-  const getFilters = React.useMemo(() => {
-    const xMapper = createAxisFilterMapper({
-      zoomData,
-      extremumGetter: xExtremumGetters,
-      formattedSeries,
-      direction: 'x'
-    });
-    const yMapper = createAxisFilterMapper({
-      zoomData,
-      extremumGetter: yExtremumGetters,
-      formattedSeries,
-      direction: 'y'
-    });
-    const xFilters = xAxis.reduce((acc, axis, index) => {
-      const filter = xMapper(axis, index);
-      if (filter !== null) {
-        acc[axis.id] = filter;
-      }
-      return acc;
-    }, {});
-    const yFilters = yAxis.reduce((acc, axis, index) => {
-      const filter = yMapper(axis, index);
-      if (filter !== null) {
-        acc[axis.id] = filter;
-      }
-      return acc;
-    }, {});
-    if (Object.keys(xFilters).length === 0 && Object.keys(yFilters).length === 0) {
-      return undefined;
-    }
-    return createGetAxisFilters(_extends({}, xFilters, yFilters));
-  }, [formattedSeries, xAxis, xExtremumGetters, yAxis, yExtremumGetters, zoomData]);
-  const xValues = React.useMemo(() => computeAxisValue({
-    drawingArea,
-    formattedSeries,
-    axis: xAxis,
-    extremumGetters: xExtremumGetters,
-    axisDirection: 'x',
-    zoomData,
-    zoomOptions: options,
-    getFilters
-  }), [drawingArea, formattedSeries, xAxis, xExtremumGetters, zoomData, options, getFilters]);
-  const yValues = React.useMemo(() => computeAxisValue({
-    drawingArea,
-    formattedSeries,
-    axis: yAxis,
-    extremumGetters: yExtremumGetters,
-    axisDirection: 'y',
-    zoomData,
-    zoomOptions: options,
-    getFilters
-  }), [drawingArea, formattedSeries, yAxis, yExtremumGetters, zoomData, options, getFilters]);
-  const value = React.useMemo(() => ({
-    isInitialized: true,
-    data: {
-      xAxis: xValues.axis,
-      yAxis: yValues.axis,
-      xAxisIds: xValues.axisIds,
-      yAxisIds: yValues.axisIds
-    }
-  }), [xValues, yValues]);
-  return /*#__PURE__*/_jsx(CartesianContext.Provider, {
-    value: value,
-    children: children
-  });
-}
-export { CartesianProviderPro };

package/modern/context/CartesianProviderPro/createAxisFilterMapper.js

@@ -1,60 +0,0 @@
-import { getAxisExtremum, isDefined, getScale } from '@mui/x-charts/internals';
-export const createAxisFilterMapper = ({
-  zoomData,
-  extremumGetter,
-  formattedSeries,
-  direction
-}) => (axis, axisIndex) => {
-  if (typeof axis.zoom !== 'object' || axis.zoom.filterMode !== 'discard') {
-    return null;
-  }
-  const zoom = zoomData?.find(({
-    axisId
-  }) => axisId === axis.id);
-  if (zoom === undefined || zoom.start <= 0 && zoom.end >= 100) {
-    // No zoom, or zoom with all data visible
-    return null;
-  }
-  let extremums = [];
-  const scaleType = axis.scaleType;
-  if (scaleType === 'point' || scaleType === 'band') {
-    extremums = [0, (axis.data?.length ?? 1) - 1];
-  } else {
-    extremums = getAxisExtremum(axis, extremumGetter, axisIndex, formattedSeries);
-  }
-  let min;
-  let max;
-
-  // @ts-expect-error The function defaults to linear scale if the scaleType is not recognized.
-  [min, max] = getScale(scaleType, extremums, [0, 100]).nice().domain();
-  min = min instanceof Date ? min.getTime() : min;
-  max = max instanceof Date ? max.getTime() : max;
-  const minVal = min + zoom.start * (max - min) / 100;
-  const maxVal = min + zoom.end * (max - min) / 100;
-  return (value, dataIndex) => {
-    const val = value[direction] ?? axis.data?.[dataIndex];
-    if (val == null) {
-      // If the value does not exist because of missing data point, or out of range index, we just ignore.
-      return true;
-    }
-    if (axis.scaleType === 'point' || axis.scaleType === 'band' || typeof val === 'string') {
-      return dataIndex >= minVal && dataIndex <= maxVal;
-    }
-    return val >= minVal && val <= maxVal;
-  };
-};
-export const createGetAxisFilters = filters => ({
-  currentAxisId,
-  seriesXAxisId,
-  seriesYAxisId,
-  isDefaultAxis
-}) => {
-  return (value, dataIndex) => {
-    const axisId = currentAxisId === seriesXAxisId ? seriesYAxisId : seriesXAxisId;
-    if (!axisId || isDefaultAxis) {
-      return Object.values(filters ?? {})[0]?.(value, dataIndex) ?? true;
-    }
-    const data = [seriesYAxisId, seriesXAxisId].filter(id => id !== currentAxisId).map(id => filters[id ?? '']).filter(isDefined);
-    return data.every(f => f(value, dataIndex));
-  };
-};

package/modern/context/CartesianProviderPro/index.js

@@ -1 +0,0 @@
-export * from "./CartesianProviderPro.js";

package/modern/context/ChartDataProviderPro/ChartDataProviderPro.js

@@ -1,50 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { DrawingAreaProvider, PluginProvider, SeriesProvider, AnimationProvider, SizeProvider, ChartProvider } from '@mui/x-charts/internals';
-import { HighlightedProvider, ZAxisContextProvider } from '@mui/x-charts/context';
-import { useLicenseVerifier } from '@mui/x-license/useLicenseVerifier';
-import { getReleaseInfo } from "../../internals/utils/releaseInfo.js";
-import { CartesianProviderPro } from "../CartesianProviderPro/index.js";
-import { ZoomProvider } from "../ZoomProvider/index.js";
-import { useChartContainerProProps } from "./useChartDataProviderProProps.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const releaseInfo = getReleaseInfo();
-function ChartDataProviderPro(props) {
-  const {
-    zoomProviderProps,
-    drawingAreaProviderProps,
-    seriesProviderProps,
-    zAxisContextProps,
-    highlightedProviderProps,
-    cartesianProviderProps,
-    sizeProviderProps,
-    pluginProviderProps,
-    animationProviderProps,
-    children
-  } = useChartContainerProProps(props);
-  useLicenseVerifier('x-charts-pro', releaseInfo);
-  return /*#__PURE__*/_jsx(ChartProvider, {
-    children: /*#__PURE__*/_jsx(SizeProvider, _extends({}, sizeProviderProps, {
-      children: /*#__PURE__*/_jsx(DrawingAreaProvider, _extends({}, drawingAreaProviderProps, {
-        children: /*#__PURE__*/_jsx(AnimationProvider, _extends({}, animationProviderProps, {
-          children: /*#__PURE__*/_jsx(PluginProvider, _extends({}, pluginProviderProps, {
-            children: /*#__PURE__*/_jsx(ZoomProvider, _extends({}, zoomProviderProps, {
-              children: /*#__PURE__*/_jsx(SeriesProvider, _extends({}, seriesProviderProps, {
-                children: /*#__PURE__*/_jsx(CartesianProviderPro, _extends({}, cartesianProviderProps, {
-                  children: /*#__PURE__*/_jsx(ZAxisContextProvider, _extends({}, zAxisContextProps, {
-                    children: /*#__PURE__*/_jsx(HighlightedProvider, _extends({}, highlightedProviderProps, {
-                      children: children
-                    }))
-                  }))
-                }))
-              }))
-            }))
-          }))
-        }))
-      }))
-    }))
-  });
-}
-export { ChartDataProviderPro };

package/modern/context/ChartDataProviderPro/index.js

@@ -1 +0,0 @@
-export * from "./ChartDataProviderPro.js";

package/modern/context/ChartDataProviderPro/useChartDataProviderProProps.js

@@ -1,43 +0,0 @@
-'use client';
-
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["zoom", "onZoomChange"];
-import { useChartDataProviderProps } from '@mui/x-charts/internals';
-export const useChartContainerProProps = props => {
-  const {
-      zoom,
-      onZoomChange
-    } = props,
-    baseProps = _objectWithoutPropertiesLoose(props, _excluded);
-  const {
-    children,
-    drawingAreaProviderProps,
-    seriesProviderProps,
-    cartesianProviderProps,
-    zAxisContextProps,
-    highlightedProviderProps,
-    sizeProviderProps,
-    pluginProviderProps,
-    animationProviderProps,
-    xAxis,
-    yAxis
-  } = useChartDataProviderProps(baseProps);
-  const zoomProviderProps = {
-    zoom,
-    onZoomChange,
-    xAxis,
-    yAxis
-  };
-  return {
-    zoomProviderProps,
-    children,
-    drawingAreaProviderProps,
-    pluginProviderProps,
-    seriesProviderProps,
-    cartesianProviderProps,
-    zAxisContextProps,
-    highlightedProviderProps,
-    sizeProviderProps,
-    animationProviderProps
-  };
-};