@mui/x-charts-pro 8.0.0-alpha.11 → 8.0.0-alpha.12

package/{node → esm}/internals/plugins/useChartProZoom/useChartProZoom.js

@@ -1,18 +1,10 @@
-"use strict";
 'use client';
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useChartProZoom = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var React = _interopRequireWildcard(require("react"));
-var _internals = require("@mui/x-charts/internals");
-var _creatZoomLookup = require("./creatZoomLookup");
-var _useChartProZoom = require("./useChartProZoom.utils");
-var _useChartProZoom2 = require("./useChartProZoom.selectors");
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useSelector, getSVGPoint, selectorChartDrawingArea, createZoomLookup, selectorChartZoomOptionsLookup } from '@mui/x-charts/internals';
+import { getDiff, getHorizontalCenterRatio, getPinchScaleRatio, getVerticalCenterRatio, getWheelScaleRatio, isSpanValid, preventDefault, zoomAtPoint } from "./useChartProZoom.utils.js";
+
 // It is helpful to avoid the need to provide the possibly auto-generated id for each axis.
 function initializeZoomData(options) {
   return Object.values(options).map(({
@@ -25,14 +17,14 @@ function initializeZoomData(options) {
     end
   }));
 }
-const useChartProZoom = ({
+export const useChartProZoom = ({
   store,
   instance,
   svgRef,
   params
 }) => {
-  const drawingArea = (0, _internals.useSelector)(store, _internals.selectorChartDrawingArea);
-  const optionsLookup = (0, _internals.useSelector)(store, _useChartProZoom2.selectorChartZoomOptionsLookup);
+  const drawingArea = useSelector(store, selectorChartDrawingArea);
+  const optionsLookup = useSelector(store, selectorChartZoomOptionsLookup);
   const isZoomEnabled = Object.keys(optionsLookup).length > 0;
 
   // Add events
@@ -41,8 +33,8 @@ const useChartProZoom = ({
   const eventPrevDiff = React.useRef(0);
   const interactionTimeoutRef = React.useRef(undefined);
   const setIsInteracting = React.useCallback(isInteracting => {
-    store.update(prev => (0, _extends2.default)({}, prev, {
-      zoom: (0, _extends2.default)({}, prev.zoom, {
+    store.update(prev => _extends({}, prev, {
+      zoom: _extends({}, prev.zoom, {
         isInteracting
       })
     }));
@@ -51,8 +43,8 @@ const useChartProZoom = ({
     store.update(prevState => {
       const newZoomData = typeof zoomData === 'function' ? zoomData(prevState.zoom.zoomData) : zoomData;
       params.onZoomChange?.(newZoomData);
-      return (0, _extends2.default)({}, prevState, {
-        zoom: (0, _extends2.default)({}, prevState.zoom, {
+      return _extends({}, prevState, {
+        zoom: _extends({}, prevState.zoom, {
           zoomData: newZoomData
         })
       });
@@ -75,7 +67,7 @@ const useChartProZoom = ({
       if (touchStartRef.current == null) {
         return;
       }
-      const point = (0, _internals.getSVGPoint)(element, event);
+      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 => {
@@ -103,7 +95,7 @@ const useChartProZoom = ({
         if (newMinPercent < MIN_PERCENT || newMaxPercent > MAX_PERCENT || span < options.minSpan || span > options.maxSpan) {
           return zoom;
         }
-        return (0, _extends2.default)({}, zoom, {
+        return _extends({}, zoom, {
           start: newMinPercent,
           end: newMaxPercent
         });
@@ -112,7 +104,7 @@ const useChartProZoom = ({
     };
     const handleDown = event => {
       panningEventCacheRef.current.push(event);
-      const point = (0, _internals.getSVGPoint)(element, event);
+      const point = getSVGPoint(element, event);
       if (!instance.isPointInside(point)) {
         return;
       }
@@ -158,7 +150,7 @@ const useChartProZoom = ({
       if (element === null) {
         return;
       }
-      const point = (0, _internals.getSVGPoint)(element, event);
+      const point = getSVGPoint(element, event);
       if (!instance.isPointInside(point)) {
         return;
       }
@@ -178,13 +170,13 @@ const useChartProZoom = ({
           if (!option) {
             return zoom;
           }
-          const centerRatio = option.axisDirection === 'x' ? (0, _useChartProZoom.getHorizontalCenterRatio)(point, drawingArea) : (0, _useChartProZoom.getVerticalCenterRatio)(point, drawingArea);
+          const centerRatio = option.axisDirection === 'x' ? getHorizontalCenterRatio(point, drawingArea) : getVerticalCenterRatio(point, drawingArea);
           const {
             scaleRatio,
             isZoomIn
-          } = (0, _useChartProZoom.getWheelScaleRatio)(event, option.step);
-          const [newMinRange, newMaxRange] = (0, _useChartProZoom.zoomAtPoint)(centerRatio, scaleRatio, zoom, option);
-          if (!(0, _useChartProZoom.isSpanValid)(newMinRange, newMaxRange, isZoomIn, option)) {
+          } = getWheelScaleRatio(event, option.step);
+          const [newMinRange, newMaxRange] = zoomAtPoint(centerRatio, scaleRatio, zoom, option);
+          if (!isSpanValid(newMinRange, newMaxRange, isZoomIn, option)) {
             return zoom;
           }
           return {
@@ -211,7 +203,7 @@ const useChartProZoom = ({
         return;
       }
       const firstEvent = zoomEventCacheRef.current[0];
-      const curDiff = (0, _useChartProZoom.getDiff)(zoomEventCacheRef.current);
+      const curDiff = getDiff(zoomEventCacheRef.current);
       setZoomDataCallback(prevZoomData => {
         const newZoomData = prevZoomData.map(zoom => {
           const option = optionsLookup[zoom.axisId];
@@ -221,16 +213,16 @@ const useChartProZoom = ({
           const {
             scaleRatio,
             isZoomIn
-          } = (0, _useChartProZoom.getPinchScaleRatio)(curDiff, eventPrevDiff.current, option.step);
+          } = 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 = (0, _internals.getSVGPoint)(element, firstEvent);
-          const centerRatio = option.axisDirection === 'x' ? (0, _useChartProZoom.getHorizontalCenterRatio)(point, drawingArea) : (0, _useChartProZoom.getVerticalCenterRatio)(point, drawingArea);
-          const [newMinRange, newMaxRange] = (0, _useChartProZoom.zoomAtPoint)(centerRatio, scaleRatio, zoom, option);
-          if (!(0, _useChartProZoom.isSpanValid)(newMinRange, newMaxRange, isZoomIn, option)) {
+          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 {
@@ -261,8 +253,8 @@ const useChartProZoom = ({
     element.addEventListener('pointerleave', pointerUpHandler);
 
     // Prevent zooming the entire page on touch devices
-    element.addEventListener('touchstart', _useChartProZoom.preventDefault);
-    element.addEventListener('touchmove', _useChartProZoom.preventDefault);
+    element.addEventListener('touchstart', preventDefault);
+    element.addEventListener('touchmove', preventDefault);
     return () => {
       element.removeEventListener('wheel', wheelHandler);
       element.removeEventListener('pointerdown', pointerDownHandler);
@@ -271,8 +263,8 @@ const useChartProZoom = ({
       element.removeEventListener('pointercancel', pointerUpHandler);
       element.removeEventListener('pointerout', pointerUpHandler);
       element.removeEventListener('pointerleave', pointerUpHandler);
-      element.removeEventListener('touchstart', _useChartProZoom.preventDefault);
-      element.removeEventListener('touchmove', _useChartProZoom.preventDefault);
+      element.removeEventListener('touchstart', preventDefault);
+      element.removeEventListener('touchmove', preventDefault);
       if (interactionTimeoutRef.current) {
         clearTimeout(interactionTimeoutRef.current);
       }
@@ -287,7 +279,6 @@ const useChartProZoom = ({
     }
   };
 };
-exports.useChartProZoom = useChartProZoom;
 useChartProZoom.params = {
   initialZoom: true,
   onZoomChange: true
@@ -295,15 +286,13 @@ useChartProZoom.params = {
 useChartProZoom.getDefaultizedParams = ({
   params
 }) => {
-  const optionsLookup = (0, _extends2.default)({}, (0, _creatZoomLookup.creatZoomLookup)('x')(params.defaultizedXAxis), (0, _creatZoomLookup.creatZoomLookup)('y')(params.defaultizedYAxis));
-  return (0, _extends2.default)({}, params, {
-    optionsLookup
-  });
+  return _extends({}, params);
 };
 useChartProZoom.getInitialState = params => {
+  const optionsLookup = _extends({}, createZoomLookup('x')(params.defaultizedXAxis), createZoomLookup('y')(params.defaultizedYAxis));
   return {
     zoom: {
-      zoomData: params.initialZoom === undefined ? initializeZoomData(params.optionsLookup) : params.initialZoom,
+      zoomData: params.initialZoom === undefined ? initializeZoomData(optionsLookup) : params.initialZoom,
       isInteracting: false
     }
   };

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

@@ -0,0 +1,201 @@
+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: import("@mui/x-charts/internals").ZoomData[];
+  }) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    isInteracting: boolean;
+    zoomData: import("@mui/x-charts/internals").ZoomData[];
+  }) => 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> & import("@mui/x-charts/internals").UseChartCartesianAxisState & Partial<{}> & {
+  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> & import("@mui/x-charts/internals").UseChartCartesianAxisState & Partial<{}> & {
+    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> & import("@mui/x-charts/internals").UseChartCartesianAxisState & Partial<{}> & {
+      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>[]) => 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>[]) => 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> & import("@mui/x-charts/internals").UseChartCartesianAxisState & Partial<{}> & {
+        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>[]) & {
+        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>[];
+        }) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[];
+        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>[];
+        }) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsXAxisProps>[]) & {
+          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>[];
+        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>[];
+        }];
+        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> & import("@mui/x-charts/internals").UseChartCartesianAxisState & Partial<{}> & {
+      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>[]) => 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>[]) => 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> & import("@mui/x-charts/internals").UseChartCartesianAxisState & Partial<{}> & {
+        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>[]) & {
+        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>[];
+        }) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[];
+        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>[];
+        }) => import("@mui/x-charts").AxisConfig<keyof import("@mui/x-charts/internals").AxisScaleConfig, any, import("@mui/x-charts").ChartsYAxisProps>[]) & {
+          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>[];
+        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>[];
+        }];
+        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/esm/internals/plugins/useChartProZoom/useChartProZoom.selectors.js

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

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

@@ -0,0 +1,44 @@
+import { UseChartSeriesSignature, ChartPluginSignature, UseChartCartesianAxisSignature, UseChartCartesianAxisDefaultizedParameters, ZoomData } from '@mui/x-charts/internals';
+export interface UseChartProZoomParameters {
+  /**
+   * The list of zoom data related to each axis.
+   */
+  initialZoom?: ZoomData[];
+  /**
+   * Callback fired when the zoom has changed.
+   *
+   * @param {ZoomData[]} zoomData Updated zoom data.
+   */
+  onZoomChange?: (zoomData: ZoomData[] | ((zoomData: ZoomData[]) => ZoomData[])) => void;
+}
+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: ZoomData[];
+  };
+}
+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/esm/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/{node → esm}/internals/plugins/useChartProZoom/useChartProZoom.utils.js

@@ -1,23 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getDiff = getDiff;
-exports.getHorizontalCenterRatio = getHorizontalCenterRatio;
-exports.getPinchScaleRatio = getPinchScaleRatio;
-exports.getVerticalCenterRatio = getVerticalCenterRatio;
-exports.getWheelScaleRatio = getWheelScaleRatio;
-exports.isSpanValid = isSpanValid;
-exports.preventDefault = preventDefault;
-exports.zoomAtPoint = void 0;
 /**
  * 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) => {
+export const zoomAtPoint = (centerRatio, scaleRatio, currentZoomData, options) => {
   const MIN_RANGE = options.minStart;
   const MAX_RANGE = options.maxEnd;
   const MIN_ALLOWED_SPAN = options.minSpan;
@@ -49,8 +36,7 @@ const zoomAtPoint = (centerRatio, scaleRatio, currentZoomData, options) => {
 /**
  * Checks if the new span is valid.
  */
-exports.zoomAtPoint = zoomAtPoint;
-function isSpanValid(minRange, maxRange, isZoomIn, option) {
+export function isSpanValid(minRange, maxRange, isZoomIn, option) {
   const newSpanPercent = maxRange - minRange;
   if (isZoomIn && newSpanPercent < option.minSpan || !isZoomIn && newSpanPercent > option.maxSpan) {
     return false;
@@ -77,7 +63,7 @@ function getMultiplier(event) {
 /**
  * Get the scale ratio and if it's a zoom in or out from a wheel event.
  */
-function getWheelScaleRatio(event, step) {
+export function getWheelScaleRatio(event, step) {
   const deltaY = -event.deltaY;
   const multiplier = getMultiplier(event);
   const scaledStep = step * multiplier * deltaY / 1000;
@@ -93,7 +79,7 @@ function getWheelScaleRatio(event, step) {
 /**
  * Get the scale ratio and if it's a zoom in or out from a pinch gesture.
  */
-function getPinchScaleRatio(curDiff, prevDiff, step) {
+export function getPinchScaleRatio(curDiff, prevDiff, step) {
   const scaledStep = step / 1000;
   let scaleRatio = 0;
   let isZoomIn = false;
@@ -113,7 +99,7 @@ function getPinchScaleRatio(curDiff, prevDiff, step) {
     isZoomIn
   };
 }
-function getDiff(eventCache) {
+export function getDiff(eventCache) {
   const [firstEvent, secondEvent] = eventCache;
   return Math.hypot(firstEvent.pageX - secondEvent.pageX, firstEvent.pageY - secondEvent.pageY);
 }
@@ -121,17 +107,17 @@ function getDiff(eventCache) {
 /**
  * Get the ratio of the point in the horizontal center of the area.
  */
-function getHorizontalCenterRatio(point, area) {
+export function getHorizontalCenterRatio(point, area) {
   const {
     left,
     width
   } = area;
   return (point.x - left) / width;
 }
-function preventDefault(event) {
+export function preventDefault(event) {
   event.preventDefault();
 }
-function getVerticalCenterRatio(point, area) {
+export function getVerticalCenterRatio(point, area) {
   const {
     top,
     height

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

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

package/esm/internals/utils/releaseInfo.js

@@ -0,0 +1,13 @@
+import ponyfillGlobal from '@mui/utils/ponyfillGlobal';
+export const getReleaseInfo = () => {
+  const releaseInfo = "MTczOTc0NjgwMDAwMA==";
+  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
+    if (releaseInfo === '__RELEASE' + '_INFO__') {
+      // eslint-disable-next-line no-underscore-dangle
+      return ponyfillGlobal.__MUI_RELEASE_INFO__;
+    }
+  }
+  return releaseInfo;
+};

package/esm/models/index.d.ts

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

package/esm/models/index.js

@@ -0,0 +1,2 @@
+export * from "./seriesType/index.js";
+export {};

package/esm/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 = [number, number, number];
+export interface HeatmapSeriesType extends Omit<CommonSeriesType<HeatmapValueType>, 'color'>, CartesianSeriesType {
+  type: 'heatmap';
+  /**
+   * Data associated to each bar.
+   */
+  data?: 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/esm/models/seriesType/index.d.ts

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

package/esm/models/seriesType/index.js

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

package/esm/package.json

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