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

package/modern/internals/plugins/useChartProZoom/useChartProZoom.js

@@ -2,10 +2,9 @@
 
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { useSelector, getSVGPoint, selectorChartDrawingArea } from '@mui/x-charts/internals';
-import { defaultizeZoom } from "./defaultizeZoom.js";
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import { useSelector, getSVGPoint, selectorChartDrawingArea, createZoomLookup, selectorChartZoomOptionsLookup } from '@mui/x-charts/internals';
 import { getDiff, getHorizontalCenterRatio, getPinchScaleRatio, getVerticalCenterRatio, getWheelScaleRatio, isSpanValid, preventDefault, zoomAtPoint } from "./useChartProZoom.utils.js";
-import { selectorChartZoomOptionsLookup } from "./useChartProZoom.selectors.js";
 
 // It is helpful to avoid the need to provide the possibly auto-generated id for each axis.
 function initializeZoomData(options) {
@@ -25,15 +24,46 @@ export const useChartProZoom = ({
   svgRef,
   params
 }) => {
+  const {
+    zoomData: paramsZoomData,
+    onZoomChange
+  } = params;
   const drawingArea = useSelector(store, selectorChartDrawingArea);
   const optionsLookup = useSelector(store, selectorChartZoomOptionsLookup);
   const isZoomEnabled = Object.keys(optionsLookup).length > 0;
 
-  // Add events
-  const panningEventCacheRef = React.useRef([]);
-  const zoomEventCacheRef = React.useRef([]);
-  const eventPrevDiff = React.useRef(0);
-  const interactionTimeoutRef = React.useRef(undefined);
+  // Manage controlled state
+
+  useEnhancedEffect(() => {
+    if (paramsZoomData === undefined) {
+      return undefined;
+    }
+    store.update(prevState => {
+      if (process.env.NODE_ENV !== 'production' && !prevState.zoom.isControlled) {
+        console.error([`MUI X: A chart component is changing the \`zoomData\` from uncontrolled to controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', 'Decide between using a controlled or uncontrolled for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
+      }
+      return _extends({}, prevState, {
+        zoom: _extends({}, prevState.zoom, {
+          isInteracting: true,
+          zoomData: paramsZoomData
+        })
+      });
+    });
+    const timeout = setTimeout(() => {
+      store.update(prevState => {
+        return _extends({}, prevState, {
+          zoom: _extends({}, prevState.zoom, {
+            isInteracting: false
+          })
+        });
+      });
+    }, 166);
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [store, paramsZoomData]);
+
+  // Add instance methods
   const setIsInteracting = React.useCallback(isInteracting => {
     store.update(prev => _extends({}, prev, {
       zoom: _extends({}, prev.zoom, {
@@ -43,15 +73,24 @@ export const useChartProZoom = ({
   }, [store]);
   const setZoomDataCallback = React.useCallback(zoomData => {
     store.update(prevState => {
-      const newZoomData = typeof zoomData === 'function' ? zoomData(prevState.zoom.zoomData) : zoomData;
-      params.onZoomChange?.(newZoomData);
+      const newZoomData = typeof zoomData === 'function' ? zoomData([...prevState.zoom.zoomData]) : zoomData;
+      onZoomChange?.(newZoomData);
+      if (prevState.zoom.isControlled) {
+        return prevState;
+      }
       return _extends({}, prevState, {
         zoom: _extends({}, prevState.zoom, {
           zoomData: newZoomData
         })
       });
     });
-  }, [params, store]);
+  }, [onZoomChange, store]);
+
+  // Add events
+  const panningEventCacheRef = React.useRef([]);
+  const zoomEventCacheRef = React.useRef([]);
+  const eventPrevDiff = React.useRef(0);
+  const interactionTimeoutRef = React.useRef(undefined);
 
   // Add event for chart panning
   const isPanEnabled = React.useMemo(() => Object.values(optionsLookup).some(v => v.panning) || false, [optionsLookup]);
@@ -283,42 +322,29 @@ export const useChartProZoom = ({
 };
 useChartProZoom.params = {
   initialZoom: true,
-  onZoomChange: true
+  onZoomChange: true,
+  zoomData: true
 };
 useChartProZoom.getDefaultizedParams = ({
   params
 }) => {
-  const optionsLookup = _extends({}, params.defaultizedXAxis.reduce((acc, v) => {
-    const {
-      zoom,
-      id: axisId
-    } = v;
-    const defaultizedZoom = defaultizeZoom(zoom, axisId, 'x');
-    if (defaultizedZoom) {
-      acc[axisId] = defaultizedZoom;
-    }
-    return acc;
-  }, {}), params.defaultizedYAxis.reduce((acc, v) => {
-    const {
-      zoom,
-      id: axisId
-    } = v;
-    const defaultizedZoom = defaultizeZoom(zoom, axisId, 'y');
-    if (defaultizedZoom) {
-      acc[axisId] = defaultizedZoom;
-    }
-    return acc;
-  }, {}));
-  return _extends({}, params, {
-    optionsLookup
-  });
+  return _extends({}, params);
 };
 useChartProZoom.getInitialState = params => {
+  const {
+    initialZoom,
+    zoomData,
+    defaultizedXAxis,
+    defaultizedYAxis
+  } = params;
+  const optionsLookup = _extends({}, createZoomLookup('x')(defaultizedXAxis), createZoomLookup('y')(defaultizedYAxis));
   return {
     zoom: {
-      optionsLookup: params.optionsLookup,
-      zoomData: params.initialZoom === undefined ? initializeZoomData(params.optionsLookup) : params.initialZoom,
-      isInteracting: false
+      zoomData:
+      // eslint-disable-next-line no-nested-ternary
+      zoomData !== undefined ? zoomData : initialZoom !== undefined ? initialZoom : initializeZoomData(optionsLookup),
+      isInteracting: false,
+      isControlled: zoomData !== undefined
     }
   };
 };

package/modern/internals/plugins/useChartProZoom/useChartProZoom.selectors.d.ts

@@ -0,0 +1,203 @@
+import { ChartRootSelector } from '@mui/x-charts/internals';
+import { UseChartProZoomSignature } from "./useChartProZoom.types.js";
+export declare const selectorChartZoomState: ChartRootSelector<UseChartProZoomSignature>;
+export declare const selectorChartZoomIsInteracting: ((state: import("@mui/x-charts/internals/plugins/corePlugins/useChartId/useChartId.types").UseChartIdState & import("@mui/x-charts/internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("@mui/x-charts/internals/plugins/corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("@mui/x-charts/internals").ChartsSeriesConfig> & import("./useChartProZoom.types").UseChartProZoomState & Partial<{}> & {
+  cacheKey: import("@mui/x-charts/internals").ChartStateCacheKey;
+}) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    isInteracting: boolean;
+    zoomData: readonly import("@mui/x-charts/internals").ZoomData[];
+    isControlled: boolean;
+  }) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    isInteracting: boolean;
+    zoomData: readonly import("@mui/x-charts/internals").ZoomData[];
+    isControlled: boolean;
+  }) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [ChartRootSelector<UseChartProZoomSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartZoomIsEnabled: ((state: import("@mui/x-charts/internals/plugins/corePlugins/useChartId/useChartId.types").UseChartIdState & import("@mui/x-charts/internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("@mui/x-charts/internals/plugins/corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("@mui/x-charts/internals").ChartsSeriesConfig> & Partial<import("@mui/x-charts/internals").UseChartCartesianAxisState> & {
+  cacheKey: import("@mui/x-charts/internals").ChartStateCacheKey;
+}) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    [x: string]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+    [x: number]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+  }) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    [x: string]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+    [x: number]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+  }) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: import("@mui/x-charts/internals/plugins/corePlugins/useChartId/useChartId.types").UseChartIdState & import("@mui/x-charts/internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("@mui/x-charts/internals/plugins/corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("@mui/x-charts/internals").ChartsSeriesConfig> & Partial<import("@mui/x-charts/internals").UseChartCartesianAxisState> & {
+    cacheKey: import("@mui/x-charts/internals").ChartStateCacheKey;
+  }) => {
+    [x: string]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+    [x: number]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>, resultFuncArgs_1: Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>) => {
+      [x: string]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+      [x: number]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>, resultFuncArgs_1: Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>) => {
+      [x: string]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+      [x: number]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      [x: string]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+      [x: number]: import("@mui/x-charts/internals").DefaultizedZoomOptions;
+    };
+    dependencies: [((state: import("@mui/x-charts/internals/plugins/corePlugins/useChartId/useChartId.types").UseChartIdState & import("@mui/x-charts/internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("@mui/x-charts/internals/plugins/corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("@mui/x-charts/internals").ChartsSeriesConfig> & Partial<import("@mui/x-charts/internals").UseChartCartesianAxisState> & {
+      cacheKey: import("@mui/x-charts/internals").ChartStateCacheKey;
+    }) => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    } & {
+      resultFunc: (resultFuncArgs_0: import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[] | undefined) => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>;
+      memoizedResultFunc: ((resultFuncArgs_0: import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[] | undefined) => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      };
+      lastResult: () => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>;
+      dependencies: [((state: import("@mui/x-charts/internals/plugins/corePlugins/useChartId/useChartId.types").UseChartIdState & import("@mui/x-charts/internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("@mui/x-charts/internals/plugins/corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("@mui/x-charts/internals").ChartsSeriesConfig> & Partial<import("@mui/x-charts/internals").UseChartCartesianAxisState> & {
+        cacheKey: import("@mui/x-charts/internals").ChartStateCacheKey;
+      }) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      } & {
+        resultFunc: (resultFuncArgs_0: {
+          x: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsXAxisProps>[];
+          y: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsYAxisProps>[];
+        } | undefined) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[] | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+          x: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsXAxisProps>[];
+          y: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsYAxisProps>[];
+        } | undefined) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[] | undefined) & {
+          clearCache: () => void;
+          resultsCount: () => number;
+          resetResultsCount: () => void;
+        };
+        lastResult: () => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[] | undefined;
+        dependencies: [(state: import("@mui/x-charts/internals").ChartState<[], [import("@mui/x-charts/internals").UseChartCartesianAxisSignature]>) => {
+          x: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsXAxisProps>[];
+          y: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsYAxisProps>[];
+        } | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+      } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+      }];
+      recomputations: () => number;
+      resetRecomputations: () => void;
+      dependencyRecomputations: () => number;
+      resetDependencyRecomputations: () => void;
+    } & {
+      memoize: typeof import("reselect").weakMapMemoize;
+      argsMemoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: import("@mui/x-charts/internals/plugins/corePlugins/useChartId/useChartId.types").UseChartIdState & import("@mui/x-charts/internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("@mui/x-charts/internals/plugins/corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("@mui/x-charts/internals").ChartsSeriesConfig> & Partial<import("@mui/x-charts/internals").UseChartCartesianAxisState> & {
+      cacheKey: import("@mui/x-charts/internals").ChartStateCacheKey;
+    }) => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    } & {
+      resultFunc: (resultFuncArgs_0: import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[] | undefined) => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>;
+      memoizedResultFunc: ((resultFuncArgs_0: import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[] | undefined) => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      };
+      lastResult: () => Record<import("@mui/x-charts/internals").AxisId, import("@mui/x-charts/internals").DefaultizedZoomOptions>;
+      dependencies: [((state: import("@mui/x-charts/internals/plugins/corePlugins/useChartId/useChartId.types").UseChartIdState & import("@mui/x-charts/internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("@mui/x-charts/internals/plugins/corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("@mui/x-charts/internals").ChartsSeriesConfig> & Partial<import("@mui/x-charts/internals").UseChartCartesianAxisState> & {
+        cacheKey: import("@mui/x-charts/internals").ChartStateCacheKey;
+      }) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+      } & {
+        resultFunc: (resultFuncArgs_0: {
+          x: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsXAxisProps>[];
+          y: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsYAxisProps>[];
+        } | undefined) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[] | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+          x: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsXAxisProps>[];
+          y: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsYAxisProps>[];
+        } | undefined) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[] | undefined) & {
+          clearCache: () => void;
+          resultsCount: () => number;
+          resetResultsCount: () => void;
+        };
+        lastResult: () => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[] | undefined;
+        dependencies: [(state: import("@mui/x-charts/internals").ChartState<[], [import("@mui/x-charts/internals").UseChartCartesianAxisSignature]>) => {
+          x: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsXAxisProps>[];
+          y: import("@mui/x-charts").AxisConfig<import("@mui/x-charts").ScaleName, any, import("@mui/x-charts").ChartsYAxisProps>[];
+        } | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+      } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+      }];
+      recomputations: () => number;
+      resetRecomputations: () => void;
+      dependencyRecomputations: () => number;
+      resetDependencyRecomputations: () => void;
+    } & {
+      memoize: typeof import("reselect").weakMapMemoize;
+      argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/modern/internals/plugins/useChartProZoom/useChartProZoom.selectors.js

@@ -1,6 +1,4 @@
-import { createSelector } from '@mui/x-charts/internals';
+import { createSelector, selectorChartZoomOptionsLookup } from '@mui/x-charts/internals';
 export const selectorChartZoomState = state => state.zoom;
-export const selectorChartZoomOptionsLookup = createSelector(selectorChartZoomState, zoom => zoom.optionsLookup);
-export const selectorChartZoomData = createSelector(selectorChartZoomState, zoom => zoom.zoomData);
 export const selectorChartZoomIsInteracting = createSelector(selectorChartZoomState, zoom => zoom.isInteracting);
 export const selectorChartZoomIsEnabled = createSelector(selectorChartZoomOptionsLookup, optionsLookup => Object.keys(optionsLookup).length > 0);

package/modern/internals/plugins/useChartProZoom/useChartProZoom.types.d.ts

@@ -0,0 +1,53 @@
+import { UseChartSeriesSignature, ChartPluginSignature, UseChartCartesianAxisSignature, UseChartCartesianAxisDefaultizedParameters, ZoomData } from '@mui/x-charts/internals';
+export interface UseChartProZoomParameters {
+  /**
+   * The list of zoom data related to each axis.
+   * Used to initialize the zoom in a specific configuration without controlling it.
+   */
+  initialZoom?: readonly ZoomData[];
+  /**
+   * Callback fired when the zoom has changed.
+   *
+   * @param {ZoomData[]} zoomData Updated zoom data.
+   */
+  onZoomChange?: (zoomData: ZoomData[]) => void;
+  /**
+   * The list of zoom data related to each axis.
+   */
+  zoomData?: readonly ZoomData[];
+}
+export type UseChartProZoomDefaultizedParameters = UseChartProZoomParameters & UseChartCartesianAxisDefaultizedParameters;
+export interface UseChartProZoomState {
+  zoom: {
+    /**
+     * Whether the user is currently interacting with the chart.
+     * This is useful to disable animations while the user is interacting.
+     */
+    isInteracting: boolean;
+    /**
+     * Mapping of axis id to the zoom data.
+     */
+    zoomData: readonly ZoomData[];
+    /**
+     * Internal information to know if the user control the state or not.
+     */
+    isControlled: boolean;
+  };
+}
+export interface UseChartProZoomPublicApi {
+  /**
+   * Set the zoom data state.
+   * @param {ZoomData[] | ((prev: ZoomData[]) => ZoomData[])} value  The new value. Can either be the new zoom data, or an updater function.
+   * @returns {void}
+   */
+  setZoomData: (value: ZoomData[] | ((prev: ZoomData[]) => ZoomData[])) => void;
+}
+export interface UseChartProZoomInstance extends UseChartProZoomPublicApi {}
+export type UseChartProZoomSignature = ChartPluginSignature<{
+  params: UseChartProZoomParameters;
+  defaultizedParams: UseChartProZoomDefaultizedParameters;
+  state: UseChartProZoomState;
+  publicAPI: UseChartProZoomPublicApi;
+  instance: UseChartProZoomInstance;
+  dependencies: [UseChartSeriesSignature, UseChartCartesianAxisSignature];
+}>;

package/modern/internals/plugins/useChartProZoom/useChartProZoom.utils.d.ts

@@ -0,0 +1,45 @@
+import { DefaultizedZoomOptions, ZoomData } from '@mui/x-charts/internals';
+/**
+ * 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.
+ */
+export declare const zoomAtPoint: (centerRatio: number, scaleRatio: number, currentZoomData: ZoomData, options: DefaultizedZoomOptions) => number[];
+/**
+ * Checks if the new span is valid.
+ */
+export declare function isSpanValid(minRange: number, maxRange: number, isZoomIn: boolean, option: DefaultizedZoomOptions): boolean;
+/**
+ * Get the scale ratio and if it's a zoom in or out from a wheel event.
+ */
+export declare function getWheelScaleRatio(event: WheelEvent, step: number): {
+  scaleRatio: number;
+  isZoomIn: boolean;
+};
+/**
+ * Get the scale ratio and if it's a zoom in or out from a pinch gesture.
+ */
+export declare function getPinchScaleRatio(curDiff: number, prevDiff: number, step: number): {
+  scaleRatio: number;
+  isZoomIn: boolean;
+};
+export declare function getDiff(eventCache: PointerEvent[]): number;
+/**
+ * Get the ratio of the point in the horizontal center of the area.
+ */
+export declare function getHorizontalCenterRatio(point: {
+  x: number;
+  y: number;
+}, area: {
+  left: number;
+  width: number;
+}): number;
+export declare function preventDefault(event: TouchEvent): void;
+export declare function getVerticalCenterRatio(point: {
+  x: number;
+  y: number;
+}, area: {
+  top: number;
+  height: number;
+}): number;

package/modern/internals/utils/releaseInfo.d.ts

@@ -0,0 +1 @@
+export declare const getReleaseInfo: () => any;

package/modern/internals/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import ponyfillGlobal from '@mui/utils/ponyfillGlobal';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTczNjk4MjAwMDAwMA==";
+  const releaseInfo = "MTc0MjI0ODgwMDAwMA==";
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).
     // eslint-disable-next-line no-useless-concat

package/modern/models/index.d.ts

@@ -0,0 +1,2 @@
+export type { ZoomData } from '@mui/x-charts/internals';
+export * from "./seriesType/index.js";

package/modern/models/seriesType/heatmap.d.ts

@@ -0,0 +1,28 @@
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { CommonDefaultizedProps, CommonSeriesType, CartesianSeriesType } from '@mui/x-charts/internals';
+export type HeatmapValueType = readonly [number, number, number];
+export interface HeatmapSeriesType extends Omit<CommonSeriesType<HeatmapValueType>, 'color'>, CartesianSeriesType {
+  type: 'heatmap';
+  /**
+   * Data associated to each bar.
+   */
+  data?: readonly HeatmapValueType[];
+  /**
+   * The key used to retrieve data from the dataset.
+   */
+  dataKey?: string;
+  /**
+   * The label to display on the tooltip or the legend. It can be a string or a function.
+   */
+  label?: string | ((location: 'tooltip' | 'legend') => string);
+}
+/**
+ * An object that allows to identify a single bar.
+ * Used for item interaction
+ */
+export type HeatmapItemIdentifier = {
+  type: 'heatmap';
+  seriesId: DefaultizedHeatmapSeriesType['id'];
+  dataIndex: number;
+};
+export interface DefaultizedHeatmapSeriesType extends DefaultizedProps<HeatmapSeriesType, CommonDefaultizedProps> {}

package/modern/models/seriesType/index.d.ts

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

package/modern/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/modern/themeAugmentation/components.d.ts

@@ -0,0 +1,23 @@
+import { ComponentsProps, ComponentsOverrides } from '@mui/material/styles';
+export interface ChartsProComponents<Theme = unknown> {
+  // BarChartPro components
+  MuiBarChartPro?: {
+    defaultProps?: ComponentsProps['MuiBarChartPro'];
+  };
+  // LineChartPro components
+  MuiLineChartPro?: {
+    defaultProps?: ComponentsProps['MuiLineChartPro'];
+  };
+  // Heatmap components
+  MuiHeatmap?: {
+    defaultProps?: ComponentsProps['MuiHeatmap'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiHeatmap'];
+  };
+  // ScatterChartPro components
+  MuiScatterChartPro?: {
+    defaultProps?: ComponentsProps['MuiScatterChartPro'];
+  };
+}
+declare module '@mui/material/styles' {
+  interface Components<Theme = unknown> extends ChartsProComponents<Theme> {}
+}

package/modern/themeAugmentation/index.d.ts

@@ -0,0 +1,4 @@
+export type * from '@mui/x-charts/themeAugmentation';
+export type * from './overrides';
+export type * from './props';
+export type * from './components';

package/modern/themeAugmentation/overrides.d.ts

@@ -0,0 +1,11 @@
+import { HeatmapClassKey } from "../Heatmap/index.js";
+export interface ChartsProComponentNameToClassKey {
+  // Heatmap components
+  MuiHeatmap: HeatmapClassKey;
+}
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends ChartsProComponentNameToClassKey {}
+}
+
+// disable automatic export
+export {};

package/modern/themeAugmentation/props.d.ts

@@ -0,0 +1,20 @@
+import { ScatterChartProProps } from "../ScatterChartPro/index.js";
+import { BarChartProProps } from "../BarChartPro/index.js";
+import { HeatmapProps } from "../Heatmap/Heatmap.js";
+import { LineChartProProps } from "../LineChartPro/index.js";
+export interface ChartsProComponentsPropsList {
+  // BarChartPro components
+  MuiBarChartPro: BarChartProProps;
+  // LineChartPro components
+  MuiLineChartPro: LineChartProProps;
+  // Heatmap components
+  MuiHeatmap: HeatmapProps;
+  // ScatterChartPro components
+  MuiScatterChartPro: ScatterChartProProps;
+}
+declare module '@mui/material/styles' {
+  interface ComponentsPropsList extends ChartsProComponentsPropsList {}
+}
+
+// disable automatic export
+export {};

package/modern/typeOverloads/index.d.ts

@@ -0,0 +1 @@
+export {} from "./modules.js";

package/modern/typeOverloads/modules.d.ts

@@ -0,0 +1,33 @@
+import { DefaultizedProps, MakeRequired } from '@mui/x-internals/types';
+import { AxisId, ZoomOptions } from '@mui/x-charts/internals';
+import { HeatmapItemIdentifier, HeatmapSeriesType, DefaultizedHeatmapSeriesType, HeatmapValueType } from "../models/seriesType/heatmap.js";
+import { DefaultizedFunnelSeriesType, FunnelItemIdentifier, FunnelSeriesType, FunnelValueType } from "../FunnelChart/funnel.types.js";
+declare module '@mui/x-charts/internals' {
+  interface ChartsSeriesConfig {
+    heatmap: {
+      seriesInput: DefaultizedProps<HeatmapSeriesType, 'id'>;
+      series: DefaultizedHeatmapSeriesType;
+      seriesProp: HeatmapSeriesType;
+      itemIdentifier: HeatmapItemIdentifier;
+      valueType: HeatmapValueType;
+      axisType: 'cartesian';
+    };
+    funnel: {
+      seriesInput: Omit<DefaultizedProps<FunnelSeriesType, 'id'>, 'data'> & {
+        data: MakeRequired<FunnelValueType, 'color'>[];
+      };
+      series: DefaultizedFunnelSeriesType;
+      seriesProp: FunnelSeriesType;
+      itemIdentifier: FunnelItemIdentifier;
+      valueType: MakeRequired<FunnelValueType, 'id' | 'color'>;
+      axisType: 'cartesian';
+    };
+  }
+  interface DefaultizedZoomOptions extends Required<ZoomOptions> {
+    axisId: AxisId;
+    axisDirection: 'x' | 'y';
+  }
+  interface AxisConfigExtension {
+    zoom?: boolean | ZoomOptions;
+  }
+}