@mui/x-charts 6.0.0-alpha.8 → 6.18.0

package/legacy/ChartsLegend/ChartsLegend.js

@@ -1,12 +1,18 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _extends from "@babel/runtime/helpers/esm/extends";
+var _excluded = ["rotate", "dominantBaseline"],
+  _excluded2 = ["label"];
 import * as React from 'react';
 import { useSlotProps } from '@mui/base/utils';
+import { NoSsr } from '@mui/base/NoSsr';
 import { unstable_composeClasses as composeClasses } from '@mui/utils';
 import { useThemeProps, useTheme, styled } from '@mui/material/styles';
 import { DrawingContext } from '../context/DrawingProvider';
 import { getSeriesToDisplay } from './utils';
 import { SeriesContext } from '../context/SeriesContextProvider';
 import { getChartsLegendUtilityClass } from './chartsLegendClasses';
+import { ChartsText, getWordsByLines } from '../internals/components/ChartsText';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 var useUtilityClasses = function useUtilityClasses(ownerState) {
@@ -20,165 +26,224 @@ var useUtilityClasses = function useUtilityClasses(ownerState) {
   };
   return composeClasses(slots, getChartsLegendUtilityClass, classes);
 };
-function getTranslePosition(_ref) {
-  var position = _ref.position,
-    drawingArea = _ref.drawingArea;
-  var xValue;
-  switch (position.horizontal) {
-    case 'left':
-      xValue = "calc(var(--ChartsLegend-rootOffsetX, 0px) + ".concat(drawingArea.left, "px - var(--ChartsLegend-rootWidth))");
-      break;
-    case 'middle':
-      xValue = "calc(var(--ChartsLegend-rootOffsetX, 0px) + ".concat(drawingArea.left + drawingArea.width / 2, "px - 0.5 * var(--ChartsLegend-rootWidth))");
-      break;
-    default:
-      xValue = "calc(var(--ChartsLegend-rootOffsetX, 0px) + ".concat(drawingArea.left + drawingArea.width, "px)");
-      break;
-  }
-  var yValue;
-  switch (position.vertical) {
-    case 'top':
-      yValue = "calc(var(--ChartsLegend-rootOffsetY, 0px) + ".concat(drawingArea.top, "px - var(--ChartsLegend-rootHeight))");
-      break;
-    case 'middle':
-      yValue = "calc(var(--ChartsLegend-rootOffsetY, 0px) + ".concat(drawingArea.top + drawingArea.height / 2, "px - 0.5 * var(--ChartsLegend-rootHeight))");
-      break;
-    default:
-      yValue = "calc(var(--ChartsLegend-rootOffsetY, 0px) + ".concat(drawingArea.top + drawingArea.height, "px)");
-      break;
-  }
-  return {
-    transform: "translate(".concat(xValue, ", ").concat(yValue, ")")
-  };
-}
 export var ChartsLegendRoot = styled('g', {
   name: 'MuiChartsLegend',
   slot: 'Root',
   overridesResolver: function overridesResolver(props, styles) {
     return styles.root;
   }
-})(function (_ref2) {
-  var ownerState = _ref2.ownerState;
-  var direction = ownerState.direction,
-    drawingArea = ownerState.drawingArea,
-    offsetX = ownerState.offsetX,
-    offsetY = ownerState.offsetY,
-    seriesNumber = ownerState.seriesNumber,
-    position = ownerState.position;
-  return _extends({
-    '--ChartsLegend-rootOffsetX': typeof offsetX === 'number' ? "".concat(offsetX, "px") : undefined,
-    '--ChartsLegend-rootOffsetY': typeof offsetY === 'number' ? "".concat(offsetY, "px") : undefined,
-    '--ChartsLegend-rootWidth': direction === 'row' ? "calc(var(--ChartsLegend-itemWidth) * ".concat(seriesNumber, " + var(--ChartsLegend-rootSpacing) * ").concat(seriesNumber - 1, " )") : 'var(--ChartsLegend-itemWidth)',
-    '--ChartsLegend-rootHeight': direction === 'row' ? 'var(--ChartsLegend-itemMarkSize)' : "calc(var(--ChartsLegend-itemMarkSize) * ".concat(seriesNumber, " + var(--ChartsLegend-rootSpacing) * ").concat(seriesNumber - 1, " )")
-  }, getTranslePosition({
-    position: position,
-    drawingArea: drawingArea,
-    offsetX: offsetX,
-    offsetY: offsetY
-  }));
-});
-export var ChartsSeriesLegendGroup = styled('g', {
-  name: 'MuiChartsLegend',
-  slot: 'ChartsSeriesLegendGroup',
-  overridesResolver: function overridesResolver(props, styles) {
-    return styles.series;
-  }
-})(function (_ref3) {
-  var ownerState = _ref3.ownerState;
-  var direction = ownerState.direction,
-    seriesIndex = ownerState.seriesIndex;
-  if (direction === 'row') {
-    return {
-      transform: "translate(calc(".concat(seriesIndex, " * (var(--ChartsLegend-itemWidth) + var(--ChartsLegend-rootSpacing))), 0)")
-    };
-  }
-  return {
-    transform: "translate(0, calc(".concat(seriesIndex, " * (var(--ChartsLegend-itemMarkSize) + var(--ChartsLegend-rootSpacing))))")
-  };
-});
-export var ChartsLegendMark = styled('rect', {
-  name: 'MuiChartsLegend',
-  slot: 'Mark',
-  overridesResolver: function overridesResolver(props, styles) {
-    return styles.mark;
-  }
-})(function (_ref4) {
-  var ownerState = _ref4.ownerState;
-  return {
-    x: 0,
-    y: 0,
-    width: 'var(--ChartsLegend-itemMarkSize)',
-    height: 'var(--ChartsLegend-itemMarkSize)',
-    fill: ownerState.color
-  };
-});
-export var ChartsLegendLabel = styled('text', {
-  name: 'MuiChartsLegend',
-  slot: 'Label',
-  overridesResolver: function overridesResolver(props, styles) {
-    return styles.label;
-  }
-})(function (_ref5) {
-  var theme = _ref5.theme;
-  return _extends({}, theme.typography.body1, {
-    color: 'inherit',
-    transform: "translate(\n      calc(var(--ChartsLegend-itemMarkSize) + var(--ChartsLegend-labelSpacing)),\n      calc(0.5 * var(--ChartsLegend-itemMarkSize))\n      )",
-    fill: theme.palette.text.primary,
-    dominantBaseline: 'central'
-  });
-});
+})({});
 var defaultProps = {
   position: {
     horizontal: 'middle',
     vertical: 'top'
   },
-  direction: 'row',
-  markSize: 20,
-  itemWidth: 100,
-  spacing: 2
+  direction: 'row'
+};
+/**
+ * Transforms number or partial padding object to a defaultized padding object.
+ */
+var getStandardizedPadding = function getStandardizedPadding(padding) {
+  if (typeof padding === 'number') {
+    return {
+      left: padding,
+      right: padding,
+      top: padding,
+      bottom: padding
+    };
+  }
+  return _extends({
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0
+  }, padding);
 };
 function DefaultChartsLegend(props) {
   var hidden = props.hidden,
     position = props.position,
     direction = props.direction,
-    offset = props.offset,
-    series = props.series,
     seriesToDisplay = props.seriesToDisplay,
     drawingArea = props.drawingArea,
-    classes = props.classes;
+    classes = props.classes,
+    _props$itemMarkWidth = props.itemMarkWidth,
+    itemMarkWidth = _props$itemMarkWidth === void 0 ? 20 : _props$itemMarkWidth,
+    _props$itemMarkHeight = props.itemMarkHeight,
+    itemMarkHeight = _props$itemMarkHeight === void 0 ? 20 : _props$itemMarkHeight,
+    _props$markGap = props.markGap,
+    markGap = _props$markGap === void 0 ? 5 : _props$markGap,
+    _props$itemGap = props.itemGap,
+    itemGap = _props$itemGap === void 0 ? 10 : _props$itemGap,
+    _props$padding = props.padding,
+    paddingProps = _props$padding === void 0 ? 10 : _props$padding,
+    inLabelStyle = props.labelStyle;
+  var theme = useTheme();
+  var labelStyle = React.useMemo(function () {
+    return _extends({}, theme.typography.subtitle1, {
+      color: 'inherit',
+      dominantBaseline: 'central',
+      textAnchor: 'start',
+      fill: (theme.vars || theme).palette.text.primary,
+      lineHeight: 1
+    }, inLabelStyle);
+  },
+  // To say to TS that the dominantBaseline and textAnchor are correct
+  [inLabelStyle, theme]);
+  var padding = React.useMemo(function () {
+    return getStandardizedPadding(paddingProps);
+  }, [paddingProps]);
+  var getItemSpace = React.useCallback(function (label) {
+    var inStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var rotate = inStyle.rotate,
+      dominantBaseline = inStyle.dominantBaseline,
+      style = _objectWithoutProperties(inStyle, _excluded);
+    var linesSize = getWordsByLines({
+      style: style,
+      needsComputation: true,
+      text: label
+    });
+    var innerSize = {
+      innerWidth: itemMarkWidth + markGap + Math.max.apply(Math, _toConsumableArray(linesSize.map(function (size) {
+        return size.width;
+      }))),
+      innerHeight: Math.max(itemMarkHeight, linesSize.length * linesSize[0].height)
+    };
+    return _extends({}, innerSize, {
+      outerWidth: innerSize.innerWidth + itemGap,
+      outerHeight: innerSize.innerHeight + itemGap
+    });
+  }, [itemGap, itemMarkHeight, itemMarkWidth, markGap]);
+  var totalWidth = drawingArea.left + drawingArea.width + drawingArea.right;
+  var totalHeight = drawingArea.top + drawingArea.height + drawingArea.bottom;
+  var availableWidth = totalWidth - padding.left - padding.right;
+  var availableHeight = totalHeight - padding.top - padding.bottom;
+  var seriesWithPosition = React.useMemo(function () {
+    // Start at 0, 0. Will be modified later by padding and position.
+    var x = 0;
+    var y = 0;
+
+    // total values used to align legend later.
+    var totalWidthUsed = 0;
+    var totalHeightUsed = 0;
+    var rowIndex = 0;
+    var rowMaxHeight = [0];
+    var seriesWithRawPosition = seriesToDisplay.map(function (_ref) {
+      var label = _ref.label,
+        other = _objectWithoutProperties(_ref, _excluded2);
+      var itemSpace = getItemSpace(label, labelStyle);
+      var rep = _extends({}, other, {
+        label: label,
+        positionX: x,
+        positionY: y,
+        innerHeight: itemSpace.innerHeight,
+        innerWidth: itemSpace.innerWidth,
+        outerHeight: itemSpace.outerHeight,
+        outerWidth: itemSpace.outerWidth,
+        rowIndex: rowIndex
+      });
+      if (direction === 'row') {
+        if (x + itemSpace.innerWidth > availableWidth) {
+          // This legend item would create overflow along the x-axis, so we start a new row.
+          x = 0;
+          y += rowMaxHeight[rowIndex];
+          rowIndex += 1;
+          if (rowMaxHeight.length <= rowIndex) {
+            rowMaxHeight.push(0);
+          }
+          rep.positionX = x;
+          rep.positionY = y;
+          rep.rowIndex = rowIndex;
+        }
+        totalWidthUsed = Math.max(totalWidthUsed, x + itemSpace.outerWidth);
+        totalHeightUsed = Math.max(totalHeightUsed, y + itemSpace.outerHeight);
+        rowMaxHeight[rowIndex] = Math.max(rowMaxHeight[rowIndex], itemSpace.outerHeight);
+        x += itemSpace.outerWidth;
+      }
+      if (direction === 'column') {
+        if (y + itemSpace.innerHeight > availableHeight) {
+          // This legend item would create overflow along the y-axis, so we start a new column.
+          x = totalWidthUsed + itemGap;
+          y = 0;
+          rowIndex = 0;
+          rep.positionX = x;
+          rep.positionY = y;
+          rep.rowIndex = rowIndex;
+        }
+        if (rowMaxHeight.length <= rowIndex) {
+          rowMaxHeight.push(0);
+        }
+        totalWidthUsed = Math.max(totalWidthUsed, x + itemSpace.outerWidth);
+        totalHeightUsed = Math.max(totalHeightUsed, y + itemSpace.outerHeight);
+        rowIndex += 1;
+        y += itemSpace.outerHeight;
+      }
+      return rep;
+    });
+
+    // Move the legend according to padding and position
+    var gapX = 0;
+    var gapY = 0;
+    switch (position.horizontal) {
+      case 'left':
+        gapX = padding.left;
+        break;
+      case 'right':
+        gapX = totalWidth - padding.right - totalWidthUsed;
+        break;
+      default:
+        gapX = (totalWidth - totalWidthUsed) / 2;
+        break;
+    }
+    switch (position.vertical) {
+      case 'top':
+        gapY = padding.top;
+        break;
+      case 'bottom':
+        gapY = totalHeight - padding.bottom - totalHeightUsed;
+        break;
+      default:
+        gapY = (totalHeight - totalHeightUsed) / 2;
+        break;
+    }
+    return seriesWithRawPosition.map(function (item) {
+      return _extends({}, item, {
+        // Add the gap due to the position
+        positionX: item.positionX + gapX,
+        // Add the gap due to the position
+        positionY: item.positionY + gapY + (direction === 'row' ? rowMaxHeight[item.rowIndex] / 2 // Get the center of the entire row
+        : item.outerHeight / 2) // Get the center of the item
+      });
+    });
+  }, [seriesToDisplay, position.horizontal, position.vertical, getItemSpace, labelStyle, direction, availableWidth, availableHeight, itemGap, padding.left, padding.right, padding.top, padding.bottom, totalWidth, totalHeight]);
   if (hidden) {
     return null;
   }
-  return /*#__PURE__*/_jsx(ChartsLegendRoot, {
-    ownerState: {
-      direction: direction,
-      offsetX: offset == null ? void 0 : offset.x,
-      offsetY: offset == null ? void 0 : offset.y,
-      seriesNumber: seriesToDisplay.length,
-      position: position,
-      drawingArea: drawingArea
-    },
-    className: classes.root,
-    children: seriesToDisplay.map(function (_ref6, seriesIndex) {
-      var id = _ref6.id,
-        label = _ref6.label,
-        color = _ref6.color;
-      return /*#__PURE__*/_jsxs(ChartsSeriesLegendGroup, {
-        ownerState: _extends({
-          direction: direction,
-          seriesIndex: seriesIndex
-        }, series),
-        className: classes.series,
-        children: [/*#__PURE__*/_jsx(ChartsLegendMark, {
-          ownerState: {
-            color: color
-          },
-          className: classes.mark
-        }), /*#__PURE__*/_jsx(ChartsLegendLabel, {
-          className: classes.label,
-          children: label
-        })]
-      }, id);
+  return /*#__PURE__*/_jsx(NoSsr, {
+    children: /*#__PURE__*/_jsx(ChartsLegendRoot, {
+      className: classes.root,
+      children: seriesWithPosition.map(function (_ref2) {
+        var id = _ref2.id,
+          label = _ref2.label,
+          color = _ref2.color,
+          positionX = _ref2.positionX,
+          positionY = _ref2.positionY;
+        return /*#__PURE__*/_jsxs("g", {
+          className: classes.series,
+          transform: "translate(".concat(positionX, " ").concat(positionY, ")"),
+          children: [/*#__PURE__*/_jsx("rect", {
+            className: classes.mark,
+            y: -itemMarkHeight / 2,
+            width: itemMarkWidth,
+            height: itemMarkHeight,
+            fill: color
+          }), /*#__PURE__*/_jsx(ChartsText, {
+            style: labelStyle,
+            text: label,
+            x: itemMarkWidth + markGap,
+            y: 0
+          })]
+        }, id);
+      })
     })
   });
 }
@@ -190,7 +255,6 @@ export function ChartsLegend(inProps) {
   });
   var position = props.position,
     direction = props.direction,
-    offset = props.offset,
     hidden = props.hidden,
     slots = props.slots,
     slotProps = props.slotProps;
@@ -208,7 +272,6 @@ export function ChartsLegend(inProps) {
     additionalProps: {
       position: position,
       direction: direction,
-      offset: offset,
       classes: classes,
       drawingArea: drawingArea,
       series: series,

package/legacy/ChartsSurface.js

@@ -1,8 +1,7 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-var _excluded = ["children", "width", "height", "viewBox", "disableAxisListener", "className", "sx"];
-import { styled } from '@mui/system';
+var _excluded = ["children", "width", "height", "viewBox", "disableAxisListener", "className"];
+import { styled } from '@mui/material/styles';
 import * as React from 'react';
 import { useAxisEvents } from './hooks/useAxisEvents';
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -21,7 +20,6 @@ export var ChartsSurface = /*#__PURE__*/React.forwardRef(function ChartsSurface(
     _props$disableAxisLis = props.disableAxisListener,
     disableAxisListener = _props$disableAxisLis === void 0 ? false : _props$disableAxisLis,
     className = props.className,
-    sx = props.sx,
     other = _objectWithoutProperties(props, _excluded);
   var svgView = _extends({
     width: width,
@@ -34,14 +32,7 @@ export var ChartsSurface = /*#__PURE__*/React.forwardRef(function ChartsSurface(
     width: width,
     height: height,
     viewBox: "".concat(svgView.x, " ").concat(svgView.y, " ").concat(svgView.width, " ").concat(svgView.height),
-    ref: ref,
-    sx: [{
-      '--ChartsLegend-itemWidth': '100px',
-      '--ChartsLegend-itemMarkSize': '20px',
-      '--ChartsLegend-rootSpacing': '5px',
-      '--ChartsLegend-labelSpacing': '5px',
-      '--ChartsLegend-rootOffsetY': '-20px'
-    }].concat(_toConsumableArray(Array.isArray(sx) ? sx : [sx]))
+    ref: ref
   }, other, {
     children: [/*#__PURE__*/_jsx("title", {
       children: props.title

package/legacy/ChartsTooltip/ChartsAxisTooltipContent.js

@@ -1,5 +1,7 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import Typography from '@mui/material/Typography';
+import { useSlotProps } from '@mui/base/utils';
 import { SeriesContext } from '../context/SeriesContextProvider';
 import { CartesianContext } from '../context/CartesianContextProvider';
 import { ChartsTooltipCell, ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipMark, ChartsTooltipRow } from './ChartsTooltipTable';
@@ -21,7 +23,6 @@ export function DefaultChartsAxisContent(props) {
   };
   return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
     sx: sx,
-    variant: "outlined",
     className: classes.root,
     children: /*#__PURE__*/_jsxs(ChartsTooltipTable, {
       children: [axisValue != null && !axis.hideTooltip && /*#__PURE__*/_jsx("thead", {
@@ -40,6 +41,10 @@ export function DefaultChartsAxisContent(props) {
             label = _ref.label,
             valueFormatter = _ref.valueFormatter,
             data = _ref.data;
+          var formattedValue = valueFormatter(data[dataIndex]);
+          if (formattedValue == null) {
+            return null;
+          }
           return /*#__PURE__*/_jsxs(ChartsTooltipRow, {
             children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
               className: classes.markCell,
@@ -57,7 +62,7 @@ export function DefaultChartsAxisContent(props) {
             }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
               className: classes.valueCell,
               children: /*#__PURE__*/_jsx(Typography, {
-                children: valueFormatter(data[dataIndex])
+                children: formattedValue
               })
             })]
           }, id);
@@ -68,6 +73,7 @@ export function DefaultChartsAxisContent(props) {
 }
 export function ChartsAxisTooltipContent(props) {
   var content = props.content,
+    contentProps = props.contentProps,
     axisData = props.axisData,
     sx = props.sx,
     classes = props.classes;
@@ -100,13 +106,19 @@ export function ChartsAxisTooltipContent(props) {
     return isXaxis ? xAxis[USED_AXIS_ID] : yAxis[USED_AXIS_ID];
   }, [USED_AXIS_ID, isXaxis, xAxis, yAxis]);
   var Content = content != null ? content : DefaultChartsAxisContent;
-  return /*#__PURE__*/_jsx(Content, {
-    axisData: axisData,
-    series: relevantSeries,
-    axis: relevantAxis,
-    dataIndex: dataIndex,
-    axisValue: axisValue,
-    sx: sx,
-    classes: classes
+  var chartTooltipContentProps = useSlotProps({
+    elementType: Content,
+    externalSlotProps: contentProps,
+    additionalProps: {
+      axisData: axisData,
+      series: relevantSeries,
+      axis: relevantAxis,
+      dataIndex: dataIndex,
+      axisValue: axisValue,
+      sx: sx,
+      classes: classes
+    },
+    ownerState: {}
   });
+  return /*#__PURE__*/_jsx(Content, _extends({}, chartTooltipContentProps));
 }

package/legacy/ChartsTooltip/ChartsItemTooltipContent.js

@@ -1,4 +1,6 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
+import { useSlotProps } from '@mui/base/utils';
 import { SeriesContext } from '../context/SeriesContextProvider';
 import { ChartsTooltipTable, ChartsTooltipCell, ChartsTooltipMark, ChartsTooltipPaper, ChartsTooltipRow } from './ChartsTooltipTable';
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -26,7 +28,6 @@ export function DefaultChartsItemContent(props) {
   var formattedValue = series.valueFormatter(series.data[itemData.dataIndex]);
   return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
     sx: sx,
-    variant: "outlined",
     className: classes.root,
     children: /*#__PURE__*/_jsx(ChartsTooltipTable, {
       children: /*#__PURE__*/_jsx("tbody", {
@@ -54,13 +55,20 @@ export function ChartsItemTooltipContent(props) {
   var content = props.content,
     itemData = props.itemData,
     sx = props.sx,
-    classes = props.classes;
+    classes = props.classes,
+    contentProps = props.contentProps;
   var series = React.useContext(SeriesContext)[itemData.type].series[itemData.seriesId];
   var Content = content != null ? content : DefaultChartsItemContent;
-  return /*#__PURE__*/_jsx(Content, {
-    itemData: itemData,
-    series: series,
-    sx: sx,
-    classes: classes
+  var chartTooltipContentProps = useSlotProps({
+    elementType: Content,
+    externalSlotProps: contentProps,
+    additionalProps: {
+      itemData: itemData,
+      series: series,
+      sx: sx,
+      classes: classes
+    },
+    ownerState: {}
   });
+  return /*#__PURE__*/_jsx(Content, _extends({}, chartTooltipContentProps));
 }

package/legacy/ChartsTooltip/ChartsTooltip.js

@@ -1,8 +1,11 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import { unstable_composeClasses as composeClasses } from '@mui/utils';
-import Popper from '@mui/material/Popper';
-import NoSsr from '@mui/material/NoSsr';
+import composeClasses from '@mui/utils/composeClasses';
+import { styled } from '@mui/material/styles';
+import { Popper } from '@mui/base/Popper';
+import { NoSsr } from '@mui/base/NoSsr';
+import { useSlotProps } from '@mui/base/utils';
 import { InteractionContext } from '../context/InteractionProvider';
 import { generateVirtualElement, useMouseTracker, getTootipHasData } from './utils';
 import { ChartsItemTooltipContent } from './ChartsItemTooltipContent';
@@ -19,11 +22,37 @@ var useUtilityClasses = function useUtilityClasses(ownerState) {
   };
   return composeClasses(slots, getTooltipUtilityClass, classes);
 };
+var ChartsTooltipRoot = styled(Popper, {
+  name: 'MuiChartsTooltip',
+  slot: 'Root',
+  overridesResolver: function overridesResolver(_, styles) {
+    return styles.root;
+  }
+})(function (_ref) {
+  var theme = _ref.theme;
+  return {
+    pointerEvents: 'none',
+    zIndex: theme.zIndex.modal
+  };
+});
+
+/**
+ * Demos:
+ *
+ * - [ChartsTooltip](https://mui.com/x/react-charts/tooltip/)
+ *
+ * API:
+ *
+ * - [ChartsTooltip API](https://mui.com/x/api/charts/charts-tool-tip/)
+ */
 function ChartsTooltip(props) {
+  var _slots$popper, _slots$itemContent, _slots$axisContent;
   var _props$trigger = props.trigger,
     trigger = _props$trigger === void 0 ? 'axis' : _props$trigger,
     itemContent = props.itemContent,
-    axisContent = props.axisContent;
+    axisContent = props.axisContent,
+    slots = props.slots,
+    slotProps = props.slotProps;
   var mousePosition = useMouseTracker();
   var _React$useContext = React.useContext(InteractionContext),
     item = _React$useContext.item,
@@ -34,33 +63,40 @@ function ChartsTooltip(props) {
   var classes = useUtilityClasses({
     classes: props.classes
   });
+  var PopperComponent = (_slots$popper = slots == null ? void 0 : slots.popper) != null ? _slots$popper : ChartsTooltipRoot;
+  var popperProps = useSlotProps({
+    elementType: PopperComponent,
+    externalSlotProps: slotProps == null ? void 0 : slotProps.popper,
+    additionalProps: {
+      open: popperOpen,
+      placement: 'right-start',
+      anchorEl: generateVirtualElement(mousePosition)
+    },
+    ownerState: {}
+  });
   if (trigger === 'none') {
     return null;
   }
   return /*#__PURE__*/_jsx(NoSsr, {
-    children: popperOpen && /*#__PURE__*/_jsx(Popper, {
-      open: popperOpen,
-      placement: "right-start",
-      anchorEl: generateVirtualElement(mousePosition),
-      style: {
-        pointerEvents: 'none'
-      },
+    children: popperOpen && /*#__PURE__*/_jsx(PopperComponent, _extends({}, popperProps, {
       children: trigger === 'item' ? /*#__PURE__*/_jsx(ChartsItemTooltipContent, {
         itemData: displayedData,
-        content: itemContent,
+        content: (_slots$itemContent = slots == null ? void 0 : slots.itemContent) != null ? _slots$itemContent : itemContent,
+        contentProps: slotProps == null ? void 0 : slotProps.itemContent,
         sx: {
           mx: 2
         },
         classes: classes
       }) : /*#__PURE__*/_jsx(ChartsAxisTooltipContent, {
         axisData: displayedData,
-        content: axisContent,
+        content: (_slots$axisContent = slots == null ? void 0 : slots.axisContent) != null ? _slots$axisContent : axisContent,
+        contentProps: slotProps == null ? void 0 : slotProps.axisContent,
         sx: {
           mx: 2
         },
         classes: classes
       })
-    })
+    }))
   });
 }
 process.env.NODE_ENV !== "production" ? ChartsTooltip.propTypes = {
@@ -70,6 +106,7 @@ process.env.NODE_ENV !== "production" ? ChartsTooltip.propTypes = {
   // ----------------------------------------------------------------------
   /**
    * Component to override the tooltip content when triger is set to 'axis'.
+   * @deprecated Use slots.axisContent instead
    */
   axisContent: PropTypes.elementType,
   /**
@@ -78,8 +115,19 @@ process.env.NODE_ENV !== "production" ? ChartsTooltip.propTypes = {
   classes: PropTypes.object,
   /**
    * Component to override the tooltip content when triger is set to 'item'.
+   * @deprecated Use slots.itemContent instead
    */
   itemContent: PropTypes.elementType,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: PropTypes.object,
   /**
    * Select the kind of tooltip to display
    * - 'item': Shows data about the item below the mouse.