@mui/x-charts 7.22.3 → 8.0.0-alpha.1

package/modern/ChartsTooltip/ChartsTooltip.js

@@ -3,45 +3,11 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import composeClasses from '@mui/utils/composeClasses';
-import { styled, useThemeProps } from '@mui/material/styles';
-import Popper from '@mui/material/Popper';
-import NoSsr from '@mui/material/NoSsr';
-import useSlotProps from '@mui/utils/useSlotProps';
-import { InteractionContext } from "../context/InteractionProvider.js";
-import { generateVirtualElement, useMouseTracker, getTooltipHasData } from "./utils.js";
 import { ChartsItemTooltipContent } from "./ChartsItemTooltipContent.js";
 import { ChartsAxisTooltipContent } from "./ChartsAxisTooltipContent.js";
-import { getChartsTooltipUtilityClass } from "./chartsTooltipClasses.js";
+import { ChartsTooltipContainer } from "./ChartsTooltipContainer.js";
+import { useUtilityClasses } from "./chartsTooltipClasses.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-const useUtilityClasses = ownerState => {
-  const {
-    classes
-  } = ownerState;
-  const slots = {
-    root: ['root'],
-    paper: ['paper'],
-    table: ['table'],
-    row: ['row'],
-    cell: ['cell'],
-    mark: ['mark'],
-    markCell: ['markCell'],
-    labelCell: ['labelCell'],
-    valueCell: ['valueCell']
-  };
-  return composeClasses(slots, getChartsTooltipUtilityClass, classes);
-};
-const ChartsTooltipRoot = styled(Popper, {
-  name: 'MuiChartsTooltip',
-  slot: 'Root',
-  overridesResolver: (_, styles) => styles.root
-})(({
-  theme
-}) => ({
-  pointerEvents: 'none',
-  zIndex: theme.zIndex.modal
-}));
-
 /**
  * Demos:
  *
@@ -51,71 +17,20 @@ const ChartsTooltipRoot = styled(Popper, {
  *
  * - [ChartsTooltip API](https://mui.com/x/api/charts/charts-tool-tip/)
  */
-function ChartsTooltip(inProps) {
-  const props = useThemeProps({
-    props: inProps,
-    name: 'MuiChartsTooltip'
-  });
+function ChartsTooltip(props) {
   const {
-    trigger = 'axis',
-    itemContent,
-    axisContent,
-    slots,
-    slotProps
+    classes: propClasses,
+    trigger = 'axis'
   } = props;
-  const mousePosition = useMouseTracker();
-  const {
-    item,
-    axis
-  } = React.useContext(InteractionContext);
-  const displayedData = trigger === 'item' ? item : axis;
-  const tooltipHasData = getTooltipHasData(trigger, displayedData);
-  const popperOpen = mousePosition !== null && tooltipHasData;
-  const classes = useUtilityClasses({
-    classes: props.classes
-  });
-  const PopperComponent = slots?.popper ?? ChartsTooltipRoot;
-  const popperProps = useSlotProps({
-    elementType: PopperComponent,
-    externalSlotProps: slotProps?.popper,
-    additionalProps: {
-      open: popperOpen,
-      placement: mousePosition?.pointerType === 'mouse' ? 'right-start' : 'top',
-      anchorEl: generateVirtualElement(mousePosition),
-      modifiers: [{
-        name: 'offset',
-        options: {
-          offset: [0, mousePosition?.pointerType === 'touch' ? 40 - mousePosition.height : 0]
-        }
-      }]
-    },
-    ownerState: {}
-  });
-  if (trigger === 'none') {
-    return null;
-  }
-  return /*#__PURE__*/_jsx(NoSsr, {
-    children: popperOpen && /*#__PURE__*/_jsx(PopperComponent, _extends({}, popperProps, {
-      className: classes.root,
-      children: trigger === 'item' ? /*#__PURE__*/_jsx(ChartsItemTooltipContent, {
-        itemData: displayedData,
-        content: slots?.itemContent ?? itemContent,
-        contentProps: slotProps?.itemContent,
-        sx: {
-          mx: 2
-        },
-        classes: classes
-      }) : /*#__PURE__*/_jsx(ChartsAxisTooltipContent, {
-        axisData: displayedData,
-        content: slots?.axisContent ?? axisContent,
-        contentProps: slotProps?.axisContent,
-        sx: {
-          mx: 2
-        },
-        classes: classes
-      })
-    }))
-  });
+  const classes = useUtilityClasses(propClasses);
+  return /*#__PURE__*/_jsx(ChartsTooltipContainer, _extends({}, props, {
+    classes: classes,
+    children: trigger === 'axis' ? /*#__PURE__*/_jsx(ChartsAxisTooltipContent, {
+      classes: classes
+    }) : /*#__PURE__*/_jsx(ChartsItemTooltipContent, {
+      classes: classes
+    })
+  }));
 }
 process.env.NODE_ENV !== "production" ? ChartsTooltip.propTypes = {
   // ----------------------------- Warning --------------------------------
@@ -123,29 +38,169 @@ process.env.NODE_ENV !== "production" ? ChartsTooltip.propTypes = {
   // | To update them edit the TypeScript types and run "pnpm proptypes"  |
   // ----------------------------------------------------------------------
   /**
-   * Component to override the tooltip content when trigger is set to 'axis'.
-   * @deprecated Use slots.axisContent instead
+   * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
+   * or a function that returns either.
+   * It's used to set the position of the popper.
+   * The return value will passed as the reference object of the Popper instance.
    */
-  axisContent: PropTypes.elementType,
+  anchorEl: PropTypes.oneOfType([(props, propName) => {
+    if (props[propName] == null) {
+      return new Error(`Prop '${propName}' is required but wasn't specified`);
+    }
+    if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+      return new Error(`Expected prop '${propName}' to be of type Element`);
+    }
+    return null;
+  }, PropTypes.func, PropTypes.shape({
+    contextElement: (props, propName) => {
+      if (props[propName] == null) {
+        return null;
+      }
+      if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+        return new Error(`Expected prop '${propName}' to be of type Element`);
+      }
+      return null;
+    },
+    getBoundingClientRect: PropTypes.func.isRequired
+  })]),
   /**
    * Override or extend the styles applied to the component.
    */
   classes: PropTypes.object,
   /**
-   * Component to override the tooltip content when trigger is set to 'item'.
-   * @deprecated Use slots.itemContent instead
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
    */
-  itemContent: PropTypes.elementType,
+  components: PropTypes.shape({
+    Root: PropTypes.elementType
+  }),
   /**
-   * The props used for each component slot.
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  componentsProps: PropTypes.shape({
+    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: PropTypes.oneOfType([(props, propName) => {
+    if (props[propName] == null) {
+      return new Error(`Prop '${propName}' is required but wasn't specified`);
+    }
+    if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+      return new Error(`Expected prop '${propName}' to be of type Element`);
+    }
+    return null;
+  }, PropTypes.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: PropTypes.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Popper.
+   * @default false
+   */
+  keepMounted: PropTypes.bool,
+  /**
+   * Popper.js is based on a "plugin-like" architecture,
+   * most of its features are fully encapsulated "modifiers".
+   *
+   * A modifier is a function that is called each time Popper.js needs to
+   * compute the position of the popper.
+   * For this reason, modifiers should be very performant to avoid bottlenecks.
+   * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
+   */
+  modifiers: PropTypes.arrayOf(PropTypes.shape({
+    data: PropTypes.object,
+    effect: PropTypes.func,
+    enabled: PropTypes.bool,
+    fn: PropTypes.func,
+    name: PropTypes.any,
+    options: PropTypes.object,
+    phase: PropTypes.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),
+    requires: PropTypes.arrayOf(PropTypes.string),
+    requiresIfExists: PropTypes.arrayOf(PropTypes.string)
+  })),
+  /**
+   * If `true`, the component is shown.
+   */
+  open: PropTypes.bool,
+  /**
+   * Popper placement.
+   * @default 'bottom'
+   */
+  placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+  /**
+   * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
+   * @default {}
+   */
+  popperOptions: PropTypes.shape({
+    modifiers: PropTypes.array,
+    onFirstUpdate: PropTypes.func,
+    placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+    strategy: PropTypes.oneOf(['absolute', 'fixed'])
+  }),
+  /**
+   * A ref that points to the used popper instance.
+   */
+  popperRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      destroy: PropTypes.func.isRequired,
+      forceUpdate: PropTypes.func.isRequired,
+      setOptions: PropTypes.func.isRequired,
+      state: PropTypes.shape({
+        attributes: PropTypes.object.isRequired,
+        elements: PropTypes.object.isRequired,
+        modifiersData: PropTypes.object.isRequired,
+        options: PropTypes.object.isRequired,
+        orderedModifiers: PropTypes.arrayOf(PropTypes.object).isRequired,
+        placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']).isRequired,
+        rects: PropTypes.object.isRequired,
+        reset: PropTypes.bool.isRequired,
+        scrollParents: PropTypes.object.isRequired,
+        strategy: PropTypes.oneOf(['absolute', 'fixed']).isRequired,
+        styles: PropTypes.object.isRequired
+      }).isRequired,
+      update: PropTypes.func.isRequired
+    })
+  })]),
+  /**
+   * The props used for each slot inside the Popper.
    * @default {}
    */
   slotProps: PropTypes.object,
   /**
-   * Overridable component slots.
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
    * @default {}
    */
   slots: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * Help supporting a react-transition-group/Transition component.
+   * @default false
+   */
+  transition: PropTypes.bool,
   /**
    * Select the kind of tooltip to display
    * - 'item': Shows data about the item below the mouse.

package/modern/ChartsTooltip/ChartsTooltipContainer.js

@@ -0,0 +1,298 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["trigger", "classes", "children"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import useLazyRef from '@mui/utils/useLazyRef';
+import { styled, useThemeProps } from '@mui/material/styles';
+import Popper from '@mui/material/Popper';
+import NoSsr from '@mui/material/NoSsr';
+import { useSvgRef } from "../hooks/useSvgRef.js";
+import { usePointerType } from "./utils.js";
+import { useSelector } from "../internals/useSelector.js";
+import { useStore } from "../internals/useStore.js";
+import { useXAxis } from "../hooks/index.js";
+import { selectorChartsInteractionItemIsDefined, selectorChartsInteractionXAxisIsDefined, selectorChartsInteractionYAxisIsDefined } from "../context/InteractionSelectors.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const ChartsTooltipRoot = styled(Popper, {
+  name: 'MuiChartsTooltip',
+  slot: 'Root',
+  overridesResolver: (_, styles) => styles.root
+})(({
+  theme
+}) => ({
+  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 ChartsTooltipContainer(inProps) {
+  const props = useThemeProps({
+    props: inProps,
+    name: 'MuiChartsTooltipContainer'
+  });
+  const {
+      trigger = 'axis',
+      classes,
+      children
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const svgRef = useSvgRef();
+  const pointerType = usePointerType();
+  const xAxis = useXAxis();
+  const xAxisHasData = xAxis.data !== undefined && xAxis.data.length !== 0;
+  const popperRef = React.useRef(null);
+  const positionRef = useLazyRef(() => ({
+    x: 0,
+    y: 0
+  }));
+  const store = useStore();
+  const isOpen = useSelector(store,
+  // eslint-disable-next-line no-nested-ternary
+  trigger === 'axis' ? xAxisHasData ? selectorChartsInteractionXAxisIsDefined : selectorChartsInteractionYAxisIsDefined : selectorChartsInteractionItemIsDefined);
+  const popperOpen = pointerType !== null && isOpen; // tooltipHasData;
+
+  React.useEffect(() => {
+    const element = svgRef.current;
+    if (element === null) {
+      return () => {};
+    }
+    const handleMove = event => {
+      // eslint-disable-next-line react-compiler/react-compiler
+      positionRef.current = {
+        x: event.clientX,
+        y: event.clientY
+      };
+      popperRef.current?.update();
+    };
+    element.addEventListener('pointermove', handleMove);
+    return () => {
+      element.removeEventListener('pointermove', handleMove);
+    };
+  }, [svgRef, positionRef]);
+  if (trigger === 'none') {
+    return null;
+  }
+  return /*#__PURE__*/_jsx(NoSsr, {
+    children: popperOpen && /*#__PURE__*/_jsx(ChartsTooltipRoot, _extends({
+      className: classes?.root,
+      open: popperOpen,
+      placement: pointerType?.pointerType === 'mouse' ? 'right-start' : 'top',
+      popperRef: popperRef,
+      anchorEl: {
+        getBoundingClientRect: () => ({
+          x: positionRef.current.x,
+          y: positionRef.current.y,
+          top: positionRef.current.y,
+          left: positionRef.current.x,
+          right: positionRef.current.x,
+          bottom: positionRef.current.y,
+          width: 0,
+          height: 0,
+          toJSON: () => ''
+        })
+      },
+      modifiers: [{
+        name: 'offset',
+        options: {
+          offset: [0, pointerType?.pointerType === 'touch' ? 40 - pointerType.height : 0]
+        }
+      }]
+    }, other, {
+      children: children
+    }))
+  });
+}
+process.env.NODE_ENV !== "production" ? ChartsTooltipContainer.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
+   * or a function that returns either.
+   * It's used to set the position of the popper.
+   * The return value will passed as the reference object of the Popper instance.
+   */
+  anchorEl: PropTypes.oneOfType([(props, propName) => {
+    if (props[propName] == null) {
+      return new Error(`Prop '${propName}' is required but wasn't specified`);
+    }
+    if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+      return new Error(`Expected prop '${propName}' to be of type Element`);
+    }
+    return null;
+  }, PropTypes.func, PropTypes.shape({
+    contextElement: (props, propName) => {
+      if (props[propName] == null) {
+        return null;
+      }
+      if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+        return new Error(`Expected prop '${propName}' to be of type Element`);
+      }
+      return null;
+    },
+    getBoundingClientRect: PropTypes.func.isRequired
+  })]),
+  /**
+   * Popper render function or node.
+   */
+  children: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  components: PropTypes.shape({
+    Root: PropTypes.elementType
+  }),
+  /**
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  componentsProps: PropTypes.shape({
+    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: PropTypes.oneOfType([(props, propName) => {
+    if (props[propName] == null) {
+      return new Error(`Prop '${propName}' is required but wasn't specified`);
+    }
+    if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+      return new Error(`Expected prop '${propName}' to be of type Element`);
+    }
+    return null;
+  }, PropTypes.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: PropTypes.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Popper.
+   * @default false
+   */
+  keepMounted: PropTypes.bool,
+  /**
+   * Popper.js is based on a "plugin-like" architecture,
+   * most of its features are fully encapsulated "modifiers".
+   *
+   * A modifier is a function that is called each time Popper.js needs to
+   * compute the position of the popper.
+   * For this reason, modifiers should be very performant to avoid bottlenecks.
+   * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
+   */
+  modifiers: PropTypes.arrayOf(PropTypes.shape({
+    data: PropTypes.object,
+    effect: PropTypes.func,
+    enabled: PropTypes.bool,
+    fn: PropTypes.func,
+    name: PropTypes.any,
+    options: PropTypes.object,
+    phase: PropTypes.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),
+    requires: PropTypes.arrayOf(PropTypes.string),
+    requiresIfExists: PropTypes.arrayOf(PropTypes.string)
+  })),
+  /**
+   * If `true`, the component is shown.
+   */
+  open: PropTypes.bool,
+  /**
+   * Popper placement.
+   * @default 'bottom'
+   */
+  placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+  /**
+   * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
+   * @default {}
+   */
+  popperOptions: PropTypes.shape({
+    modifiers: PropTypes.array,
+    onFirstUpdate: PropTypes.func,
+    placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+    strategy: PropTypes.oneOf(['absolute', 'fixed'])
+  }),
+  /**
+   * A ref that points to the used popper instance.
+   */
+  popperRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      destroy: PropTypes.func.isRequired,
+      forceUpdate: PropTypes.func.isRequired,
+      setOptions: PropTypes.func.isRequired,
+      state: PropTypes.shape({
+        attributes: PropTypes.object.isRequired,
+        elements: PropTypes.object.isRequired,
+        modifiersData: PropTypes.object.isRequired,
+        options: PropTypes.object.isRequired,
+        orderedModifiers: PropTypes.arrayOf(PropTypes.object).isRequired,
+        placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']).isRequired,
+        rects: PropTypes.object.isRequired,
+        reset: PropTypes.bool.isRequired,
+        scrollParents: PropTypes.object.isRequired,
+        strategy: PropTypes.oneOf(['absolute', 'fixed']).isRequired,
+        styles: PropTypes.object.isRequired
+      }).isRequired,
+      update: PropTypes.func.isRequired
+    })
+  })]),
+  /**
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * Help supporting a react-transition-group/Transition component.
+   * @default false
+   */
+  transition: PropTypes.bool,
+  /**
+   * Select the kind of tooltip to display
+   * - 'item': Shows data about the item below the mouse.
+   * - 'axis': Shows values associated with the hovered x value
+   * - 'none': Does not display tooltip
+   * @default 'axis'
+   */
+  trigger: PropTypes.oneOf(['axis', 'item', 'none'])
+} : void 0;
+export { ChartsTooltipContainer };

package/modern/ChartsTooltip/chartsTooltipClasses.js

@@ -1,5 +1,21 @@
-import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import composeClasses from '@mui/utils/composeClasses';
 export function getChartsTooltipUtilityClass(slot) {
   return generateUtilityClass('MuiChartsTooltip', slot);
 }
-export const chartsTooltipClasses = generateUtilityClasses('MuiChartsTooltip', ['root', 'paper', 'table', 'row', 'cell', 'mark', 'markCell', 'labelCell', 'valueCell']);
+export const chartsTooltipClasses = generateUtilityClasses('MuiChartsTooltip', ['root', 'paper', 'table', 'row', 'cell', 'mark', 'markCell', 'labelCell', 'valueCell']);
+export const useUtilityClasses = classes => {
+  const slots = {
+    root: ['root'],
+    paper: ['paper'],
+    table: ['table'],
+    row: ['row'],
+    cell: ['cell'],
+    mark: ['mark'],
+    markCell: ['markCell'],
+    labelCell: ['labelCell'],
+    valueCell: ['valueCell']
+  };
+  return composeClasses(slots, getChartsTooltipUtilityClass, classes);
+};

package/modern/ChartsTooltip/index.js

@@ -1,9 +1,8 @@
 export * from "./ChartsTooltip.js";
-export * from "./chartsTooltipClasses.js";
+export * from "./ChartsTooltipContainer.js";
+export { getChartsTooltipUtilityClass, chartsTooltipClasses } from "./chartsTooltipClasses.js";
 export * from "./ChartsAxisTooltipContent.js";
 export * from "./ChartsItemTooltipContent.js";
-export * from "./DefaultChartsAxisTooltipContent.js";
-export * from "./DefaultChartsItemTooltipContent.js";
 export * from "./ChartsTooltipTable.js";
 export * from "./useItemTooltip.js";
 export * from "./useAxisTooltip.js";