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

package/node/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-charts-pro v8.0.0-alpha.7
+ * @mui/x-charts-pro v8.0.0-alpha.8
  *
  * @license MUI X Commercial
  * This source code is licensed under the commercial license found in the
@@ -329,15 +329,4 @@ Object.keys(_LineChartPro).forEach(function (key) {
       return _LineChartPro[key];
     }
   });
-});
-var _context2 = require("./context");
-Object.keys(_context2).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _context2[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _context2[key];
-    }
-  });
 });

package/node/internals/plugins/allPlugins.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ALL_PLUGINS = void 0;
+var _internals = require("@mui/x-charts/internals");
+var _useChartProZoom = require("./useChartProZoom");
+// This file should be removed after creating all plugins in favor of a file per chart type.
+
+const ALL_PLUGINS = exports.ALL_PLUGINS = [_internals.useChartZAxis, _internals.useChartCartesianAxis, _internals.useChartInteraction, _useChartProZoom.useChartProZoom];

package/node/internals/plugins/useChartProZoom/defaultizeZoom.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultizeZoom = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+const defaultZoomOptions = {
+  minStart: 0,
+  maxEnd: 100,
+  step: 5,
+  minSpan: 10,
+  maxSpan: 100,
+  panning: true,
+  filterMode: 'keep'
+};
+const defaultizeZoom = (zoom, axisId, axisDirection) => {
+  if (!zoom) {
+    return undefined;
+  }
+  if (zoom === true) {
+    return (0, _extends2.default)({
+      axisId,
+      axisDirection
+    }, defaultZoomOptions);
+  }
+  return (0, _extends2.default)({
+    axisId,
+    axisDirection
+  }, defaultZoomOptions, zoom);
+};
+exports.defaultizeZoom = defaultizeZoom;

package/node/internals/plugins/useChartProZoom/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _useChartProZoom = require("./useChartProZoom.selectors");
+Object.keys(_useChartProZoom).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useChartProZoom[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useChartProZoom[key];
+    }
+  });
+});
+var _useChartProZoom2 = require("./useChartProZoom");
+Object.keys(_useChartProZoom2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useChartProZoom2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useChartProZoom2[key];
+    }
+  });
+});
+var _useChartProZoom3 = require("./useChartProZoom.types");
+Object.keys(_useChartProZoom3).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useChartProZoom3[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useChartProZoom3[key];
+    }
+  });
+});

package/node/internals/plugins/useChartProZoom/useChartProZoom.js

@@ -0,0 +1,331 @@
+"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 _defaultizeZoom = require("./defaultizeZoom");
+var _useChartProZoom = require("./useChartProZoom.utils");
+var _useChartProZoom2 = require("./useChartProZoom.selectors");
+// 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(({
+    axisId,
+    minStart: start,
+    maxEnd: end
+  }) => ({
+    axisId,
+    start,
+    end
+  }));
+}
+const useChartProZoom = ({
+  store,
+  instance,
+  svgRef,
+  params
+}) => {
+  const drawingArea = (0, _internals.useSelector)(store, _internals.selectorChartDrawingArea);
+  const optionsLookup = (0, _internals.useSelector)(store, _useChartProZoom2.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);
+  const setIsInteracting = React.useCallback(isInteracting => {
+    store.update(prev => (0, _extends2.default)({}, prev, {
+      zoom: (0, _extends2.default)({}, prev.zoom, {
+        isInteracting
+      })
+    }));
+  }, [store]);
+  const setZoomDataCallback = React.useCallback(zoomData => {
+    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, {
+          zoomData: newZoomData
+        })
+      });
+    });
+  }, [params, store]);
+
+  // Add event for chart panning
+  const isPanEnabled = React.useMemo(() => Object.values(optionsLookup).some(v => v.panning) || false, [optionsLookup]);
+  const isDraggingRef = React.useRef(false);
+  const touchStartRef = React.useRef(null);
+  React.useEffect(() => {
+    const element = svgRef.current;
+    if (element === null || !isPanEnabled) {
+      return () => {};
+    }
+    const handlePan = event => {
+      if (element === null || !isDraggingRef.current || panningEventCacheRef.current.length > 1) {
+        return;
+      }
+      if (touchStartRef.current == null) {
+        return;
+      }
+      const point = (0, _internals.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 options = optionsLookup[zoom.axisId];
+        if (!options || !options.panning) {
+          return zoom;
+        }
+        const min = zoom.start;
+        const max = zoom.end;
+        const span = max - min;
+        const MIN_PERCENT = options.minStart;
+        const MAX_PERCENT = options.maxEnd;
+        const movement = options.axisDirection === 'x' ? movementX : movementY;
+        const dimension = options.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 < options.minSpan || span > options.maxSpan) {
+          return zoom;
+        }
+        return (0, _extends2.default)({}, zoom, {
+          start: newMinPercent,
+          end: newMaxPercent
+        });
+      });
+      setZoomDataCallback(newZoomData);
+    };
+    const handleDown = event => {
+      panningEventCacheRef.current.push(event);
+      const point = (0, _internals.getSVGPoint)(element, event);
+      if (!instance.isPointInside(point)) {
+        return;
+      }
+      // If there is only one pointer, prevent selecting text
+      if (panningEventCacheRef.current.length === 1) {
+        event.preventDefault();
+      }
+      isDraggingRef.current = true;
+      setIsInteracting(true);
+      touchStartRef.current = {
+        x: point.x,
+        y: point.y,
+        zoomData: store.getSnapshot().zoom.zoomData
+      };
+    };
+    const handleUp = event => {
+      panningEventCacheRef.current.splice(panningEventCacheRef.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);
+    };
+  }, [instance, svgRef, isDraggingRef, setIsInteracting, isPanEnabled, optionsLookup, drawingArea.width, drawingArea.height, setZoomDataCallback, store]);
+
+  // Add event for chart zoom in/out
+  React.useEffect(() => {
+    const element = svgRef.current;
+    if (element === null || !isZoomEnabled) {
+      return () => {};
+    }
+    const wheelHandler = event => {
+      if (element === null) {
+        return;
+      }
+      const point = (0, _internals.getSVGPoint)(element, event);
+      if (!instance.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);
+      setZoomDataCallback(prevZoomData => {
+        return prevZoomData.map(zoom => {
+          const option = optionsLookup[zoom.axisId];
+          if (!option) {
+            return zoom;
+          }
+          const centerRatio = option.axisDirection === 'x' ? (0, _useChartProZoom.getHorizontalCenterRatio)(point, drawingArea) : (0, _useChartProZoom.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)) {
+            return zoom;
+          }
+          return {
+            axisId: zoom.axisId,
+            start: newMinRange,
+            end: newMaxRange
+          };
+        });
+      });
+    };
+    function pointerDownHandler(event) {
+      zoomEventCacheRef.current.push(event);
+      setIsInteracting(true);
+    }
+    function pointerMoveHandler(event) {
+      if (element === null) {
+        return;
+      }
+      const index = zoomEventCacheRef.current.findIndex(cachedEv => cachedEv.pointerId === event.pointerId);
+      zoomEventCacheRef.current[index] = event;
+
+      // Not a pinch gesture
+      if (zoomEventCacheRef.current.length !== 2) {
+        return;
+      }
+      const firstEvent = zoomEventCacheRef.current[0];
+      const curDiff = (0, _useChartProZoom.getDiff)(zoomEventCacheRef.current);
+      setZoomDataCallback(prevZoomData => {
+        const newZoomData = prevZoomData.map(zoom => {
+          const option = optionsLookup[zoom.axisId];
+          if (!option) {
+            return zoom;
+          }
+          const {
+            scaleRatio,
+            isZoomIn
+          } = (0, _useChartProZoom.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)) {
+            return zoom;
+          }
+          return {
+            axisId: zoom.axisId,
+            start: newMinRange,
+            end: newMaxRange
+          };
+        });
+        eventPrevDiff.current = curDiff;
+        return newZoomData;
+      });
+    }
+    function pointerUpHandler(event) {
+      zoomEventCacheRef.current.splice(zoomEventCacheRef.current.findIndex(cachedEvent => cachedEvent.pointerId === event.pointerId), 1);
+      if (zoomEventCacheRef.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', _useChartProZoom.preventDefault);
+    element.addEventListener('touchmove', _useChartProZoom.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', _useChartProZoom.preventDefault);
+      element.removeEventListener('touchmove', _useChartProZoom.preventDefault);
+      if (interactionTimeoutRef.current) {
+        clearTimeout(interactionTimeoutRef.current);
+      }
+    };
+  }, [svgRef, drawingArea, isZoomEnabled, optionsLookup, setIsInteracting, instance, setZoomDataCallback]);
+  return {
+    publicAPI: {
+      setZoomData: setZoomDataCallback
+    },
+    instance: {
+      setZoomData: setZoomDataCallback
+    }
+  };
+};
+exports.useChartProZoom = useChartProZoom;
+useChartProZoom.params = {
+  initialZoom: true,
+  onZoomChange: true
+};
+useChartProZoom.getDefaultizedParams = ({
+  params
+}) => {
+  const optionsLookup = (0, _extends2.default)({}, params.defaultizedXAxis.reduce((acc, v) => {
+    const {
+      zoom,
+      id: axisId
+    } = v;
+    const defaultizedZoom = (0, _defaultizeZoom.defaultizeZoom)(zoom, axisId, 'x');
+    if (defaultizedZoom) {
+      acc[axisId] = defaultizedZoom;
+    }
+    return acc;
+  }, {}), params.defaultizedYAxis.reduce((acc, v) => {
+    const {
+      zoom,
+      id: axisId
+    } = v;
+    const defaultizedZoom = (0, _defaultizeZoom.defaultizeZoom)(zoom, axisId, 'y');
+    if (defaultizedZoom) {
+      acc[axisId] = defaultizedZoom;
+    }
+    return acc;
+  }, {}));
+  return (0, _extends2.default)({}, params, {
+    optionsLookup
+  });
+};
+useChartProZoom.getInitialState = params => {
+  return {
+    zoom: {
+      optionsLookup: params.optionsLookup,
+      zoomData: params.initialZoom === undefined ? initializeZoomData(params.optionsLookup) : params.initialZoom,
+      isInteracting: false
+    }
+  };
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectorChartZoomState = exports.selectorChartZoomOptionsLookup = exports.selectorChartZoomIsInteracting = exports.selectorChartZoomIsEnabled = exports.selectorChartZoomData = void 0;
+var _internals = require("@mui/x-charts/internals");
+const selectorChartZoomState = state => state.zoom;
+exports.selectorChartZoomState = selectorChartZoomState;
+const selectorChartZoomOptionsLookup = exports.selectorChartZoomOptionsLookup = (0, _internals.createSelector)(selectorChartZoomState, zoom => zoom.optionsLookup);
+const selectorChartZoomData = exports.selectorChartZoomData = (0, _internals.createSelector)(selectorChartZoomState, zoom => zoom.zoomData);
+const selectorChartZoomIsInteracting = exports.selectorChartZoomIsInteracting = (0, _internals.createSelector)(selectorChartZoomState, zoom => zoom.isInteracting);
+const selectorChartZoomIsEnabled = exports.selectorChartZoomIsEnabled = (0, _internals.createSelector)(selectorChartZoomOptionsLookup, optionsLookup => Object.keys(optionsLookup).length > 0);

package/node/internals/plugins/useChartProZoom/useChartProZoom.utils.js

@@ -0,0 +1,140 @@
+"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) => {
+  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];
+};
+
+/**
+ * Checks if the new span is valid.
+ */
+exports.zoomAtPoint = zoomAtPoint;
+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/node/internals/plugins/useChartProZoom/zoom.types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/internals/utils/releaseInfo.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.getReleaseInfo = void 0;
 var _ponyfillGlobal = _interopRequireDefault(require("@mui/utils/ponyfillGlobal"));
 const getReleaseInfo = () => {
-  const releaseInfo = "MTczNjM3NzIwMDAwMA==";
+  const releaseInfo = "MTczNjk4MjAwMDAwMA==";
   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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-charts-pro",
-  "version": "8.0.0-alpha.7",
+  "version": "8.0.0-alpha.8",
   "description": "The Pro plan edition of the Charts components (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -35,10 +35,10 @@
     "@react-spring/web": "^9.7.5",
     "clsx": "^2.1.1",
     "prop-types": "^15.8.1",
-    "@mui/x-charts-vendor": "8.0.0-alpha.7",
-    "@mui/x-internals": "8.0.0-alpha.7",
-    "@mui/x-charts": "8.0.0-alpha.7",
-    "@mui/x-license": "8.0.0-alpha.7"
+    "@mui/x-charts": "8.0.0-alpha.8",
+    "@mui/x-charts-vendor": "8.0.0-alpha.8",
+    "@mui/x-internals": "8.0.0-alpha.8",
+    "@mui/x-license": "8.0.0-alpha.8"
   },
   "peerDependencies": {
     "@emotion/react": "^11.9.0",

package/typeOverloads/modules.d.ts

@@ -1,6 +1,7 @@
 import { DefaultizedProps } from '@mui/x-internals/types';
+import { AxisId } from '@mui/x-charts/internals';
 import { HeatmapItemIdentifier, HeatmapSeriesType, DefaultizedHeatmapSeriesType, HeatmapValueType } from '../models/seriesType/heatmap';
-import { ZoomOptions } from '../context/ZoomProvider';
+import { ZoomOptions as ZoomOptionsPro } from '../internals/plugins/useChartProZoom/zoom.types';
 declare module '@mui/x-charts/internals' {
     interface ChartsSeriesConfig {
         heatmap: {
@@ -12,6 +13,12 @@ declare module '@mui/x-charts/internals' {
             cartesian: true;
         };
     }
+    interface ZoomOptions extends ZoomOptionsPro {
+    }
+    interface DefaultizedZoomOptions extends Required<ZoomOptionsPro> {
+        axisId: AxisId;
+        axisDirection: 'x' | 'y';
+    }
     interface AxisConfigExtension {
         zoom?: boolean | ZoomOptions;
     }

package/context/CartesianProviderPro/CartesianProviderPro.d.ts

@@ -1,6 +0,0 @@
-import * as React from 'react';
-import { CartesianProviderProps } from '@mui/x-charts/internals';
-export interface CartesianProviderProProps extends CartesianProviderProps {
-}
-declare function CartesianProviderPro(props: CartesianProviderProProps): React.JSX.Element;
-export { CartesianProviderPro };