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

package/Heatmap/HeatmapItem.d.ts

@@ -1,49 +1,49 @@
 import * as React from 'react';
 import { SeriesId } from '@mui/x-charts/internals';
-import { HeatmapClasses } from './heatmapClasses';
+import { HeatmapClasses } from "./heatmapClasses.js";
 export interface HeatmapItemSlots {
-    /**
-     * The component that renders the heatmap cell.
-     * @default HeatmapCell
-     */
-    cell?: React.ElementType;
+  /**
+   * The component that renders the heatmap cell.
+   * @default HeatmapCell
+   */
+  cell?: React.ElementType;
 }
 export interface HeatmapItemSlotProps {
-    cell?: Partial<React.ComponentPropsWithRef<'rect'>>;
+  cell?: Partial<React.ComponentPropsWithRef<'rect'>>;
 }
 export interface HeatmapItemProps {
-    dataIndex: number;
-    seriesId: SeriesId;
-    value: number;
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-    color: string;
-    /**
-     * The props used for each component slot.
-     * @default {}
-     */
-    slotProps?: HeatmapItemSlotProps;
-    /**
-     * Overridable component slots.
-     * @default {}
-     */
-    slots?: HeatmapItemSlots;
+  dataIndex: number;
+  seriesId: SeriesId;
+  value: number;
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+  color: string;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: HeatmapItemSlotProps;
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: HeatmapItemSlots;
 }
 export interface HeatmapItemOwnerState {
-    seriesId: SeriesId;
-    dataIndex: number;
-    color: string;
-    isFaded: boolean;
-    isHighlighted: boolean;
-    classes?: Partial<HeatmapClasses>;
+  seriesId: SeriesId;
+  dataIndex: number;
+  color: string;
+  isFaded: boolean;
+  isHighlighted: boolean;
+  classes?: Partial<HeatmapClasses>;
 }
 /**
  * @ignore - internal component.
  */
 declare function HeatmapItem(props: HeatmapItemProps): React.JSX.Element;
 declare namespace HeatmapItem {
-    var propTypes: any;
+  var propTypes: any;
 }
-export { HeatmapItem };
+export { HeatmapItem };

package/Heatmap/HeatmapItem.js

@@ -1,16 +1,24 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HeatmapItem = HeatmapItem;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _styles = require("@mui/material/styles");
+var _useSlotProps = _interopRequireDefault(require("@mui/utils/useSlotProps"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _hooks = require("@mui/x-charts/hooks");
+var _internals = require("@mui/x-charts/internals");
+var _heatmapClasses = require("./heatmapClasses");
+var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["seriesId", "dataIndex", "color", "value", "slotProps", "slots"];
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { styled } from '@mui/material/styles';
-import useSlotProps from '@mui/utils/useSlotProps';
-import composeClasses from '@mui/utils/composeClasses';
-import { useItemHighlighted } from '@mui/x-charts/hooks';
-import { useInteractionItemProps } from '@mui/x-charts/internals';
-import { getHeatmapUtilityClass } from "./heatmapClasses.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const HeatmapCell = styled('rect', {
+const HeatmapCell = (0, _styles.styled)('rect', {
   name: 'MuiHeatmap',
   slot: 'Cell',
   overridesResolver: (_, styles) => styles.arc
@@ -31,7 +39,7 @@ const useUtilityClasses = ownerState => {
   const slots = {
     cell: ['cell', `series-${seriesId}`, isFaded && 'faded', isHighlighted && 'highlighted']
   };
-  return composeClasses(slots, getHeatmapUtilityClass, classes);
+  return (0, _composeClasses.default)(slots, _heatmapClasses.getHeatmapUtilityClass, classes);
 };
 
 /**
@@ -46,12 +54,12 @@ function HeatmapItem(props) {
       slotProps = {},
       slots = {}
     } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
-  const getInteractionItemProps = useInteractionItemProps();
+    other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const getInteractionItemProps = (0, _internals.useInteractionItemProps)();
   const {
     isFaded,
     isHighlighted
-  } = useItemHighlighted({
+  } = (0, _hooks.useItemHighlighted)({
     seriesId,
     dataIndex
   });
@@ -65,42 +73,41 @@ function HeatmapItem(props) {
   };
   const classes = useUtilityClasses(ownerState);
   const Cell = slots?.cell ?? HeatmapCell;
-  const cellProps = useSlotProps({
+  const cellProps = (0, _useSlotProps.default)({
     elementType: Cell,
-    additionalProps: _extends({}, getInteractionItemProps({
+    additionalProps: (0, _extends2.default)({}, getInteractionItemProps({
       type: 'heatmap',
       seriesId,
       dataIndex
     })),
-    externalForwardedProps: _extends({}, other),
+    externalForwardedProps: (0, _extends2.default)({}, other),
     externalSlotProps: slotProps.cell,
     ownerState,
     className: classes.cell
   });
-  return /*#__PURE__*/_jsx(Cell, _extends({}, cellProps));
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(Cell, (0, _extends2.default)({}, cellProps));
 }
 process.env.NODE_ENV !== "production" ? HeatmapItem.propTypes = {
   // ----------------------------- Warning --------------------------------
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "pnpm proptypes"  |
   // ----------------------------------------------------------------------
-  color: PropTypes.string.isRequired,
-  dataIndex: PropTypes.number.isRequired,
-  height: PropTypes.number.isRequired,
-  seriesId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+  color: _propTypes.default.string.isRequired,
+  dataIndex: _propTypes.default.number.isRequired,
+  height: _propTypes.default.number.isRequired,
+  seriesId: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]).isRequired,
   /**
    * The props used for each component slot.
    * @default {}
    */
-  slotProps: PropTypes.object,
+  slotProps: _propTypes.default.object,
   /**
    * Overridable component slots.
    * @default {}
    */
-  slots: PropTypes.object,
-  value: PropTypes.number.isRequired,
-  width: PropTypes.number.isRequired,
-  x: PropTypes.number.isRequired,
-  y: PropTypes.number.isRequired
-} : void 0;
-export { HeatmapItem };
+  slots: _propTypes.default.object,
+  value: _propTypes.default.number.isRequired,
+  width: _propTypes.default.number.isRequired,
+  x: _propTypes.default.number.isRequired,
+  y: _propTypes.default.number.isRequired
+} : void 0;

package/Heatmap/HeatmapPlot.d.ts

@@ -1,9 +1,8 @@
 import * as React from 'react';
-import { HeatmapItemProps } from './HeatmapItem';
-export interface HeatmapPlotProps extends Pick<HeatmapItemProps, 'slots' | 'slotProps'> {
-}
+import { HeatmapItemProps } from "./HeatmapItem.js";
+export interface HeatmapPlotProps extends Pick<HeatmapItemProps, 'slots' | 'slotProps'> {}
 declare function HeatmapPlot(props: HeatmapPlotProps): React.JSX.Element | null;
 declare namespace HeatmapPlot {
-    var propTypes: any;
+  var propTypes: any;
 }
-export { HeatmapPlot };
+export { HeatmapPlot };

package/Heatmap/HeatmapPlot.js

@@ -1,23 +1,30 @@
+"use strict";
 'use client';
 
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { useXScale, useYScale, useZColorScale } from '@mui/x-charts/hooks';
-import { useHeatmapSeries } from "../hooks/useSeries.js";
-import { HeatmapItem } from "./HeatmapItem.js";
-import { jsx as _jsx } from "react/jsx-runtime";
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HeatmapPlot = HeatmapPlot;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _hooks = require("@mui/x-charts/hooks");
+var _useHeatmapSeries = require("../hooks/useHeatmapSeries");
+var _HeatmapItem = require("./HeatmapItem");
+var _jsxRuntime = require("react/jsx-runtime");
 function HeatmapPlot(props) {
-  const xScale = useXScale();
-  const yScale = useYScale();
-  const colorScale = useZColorScale();
-  const series = useHeatmapSeries();
+  const xScale = (0, _hooks.useXScale)();
+  const yScale = (0, _hooks.useYScale)();
+  const colorScale = (0, _hooks.useZColorScale)();
+  const series = (0, _useHeatmapSeries.useHeatmapSeriesContext)();
   const xDomain = xScale.domain();
   const yDomain = yScale.domain();
   if (!series || series.seriesOrder.length === 0) {
     return null;
   }
   const seriesToDisplay = series.series[series.seriesOrder[0]];
-  return /*#__PURE__*/_jsx("g", {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("g", {
     children: seriesToDisplay.data.map(([xIndex, yIndex, value], dataIndex) => {
       const x = xScale(xDomain[xIndex]);
       const y = yScale(yDomain[yIndex]);
@@ -25,7 +32,7 @@ function HeatmapPlot(props) {
       if (x === undefined || y === undefined || !color) {
         return null;
       }
-      return /*#__PURE__*/_jsx(HeatmapItem, {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_HeatmapItem.HeatmapItem, {
         width: xScale.bandwidth(),
         height: yScale.bandwidth(),
         x: x,
@@ -49,11 +56,10 @@ process.env.NODE_ENV !== "production" ? HeatmapPlot.propTypes = {
    * The props used for each component slot.
    * @default {}
    */
-  slotProps: PropTypes.object,
+  slotProps: _propTypes.default.object,
   /**
    * Overridable component slots.
    * @default {}
    */
-  slots: PropTypes.object
-} : void 0;
-export { HeatmapPlot };
+  slots: _propTypes.default.object
+} : void 0;

package/Heatmap/HeatmapTooltip.d.ts

@@ -1,9 +1,8 @@
 import * as React from 'react';
 import { ChartsTooltipContainerProps } from '@mui/x-charts/ChartsTooltip';
-export interface HeatmapTooltipProps extends Omit<ChartsTooltipContainerProps, 'trigger' | 'children'> {
-}
+export interface HeatmapTooltipProps extends Omit<ChartsTooltipContainerProps, 'trigger' | 'children'> {}
 declare function HeatmapTooltip(props: HeatmapTooltipProps): React.JSX.Element;
 declare namespace HeatmapTooltip {
-    var propTypes: any;
+  var propTypes: any;
 }
-export { HeatmapTooltip };
+export { HeatmapTooltip };

package/Heatmap/HeatmapTooltip.js

@@ -1,16 +1,23 @@
+"use strict";
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import clsx from 'clsx';
-import HTMLElementType from '@mui/utils/HTMLElementType';
-import composeClasses from '@mui/utils/composeClasses';
-import { ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipRow, ChartsTooltipCell, useItemTooltip, getChartsTooltipUtilityClass, ChartsTooltipContainer } from '@mui/x-charts/ChartsTooltip';
-import { useXAxis, useYAxis } from '@mui/x-charts/hooks';
-import { getLabel, ChartsLabelMark } from '@mui/x-charts/internals';
-import { useHeatmapSeries } from "../hooks/useSeries.js";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HeatmapTooltip = HeatmapTooltip;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _HTMLElementType = _interopRequireDefault(require("@mui/utils/HTMLElementType"));
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _ChartsTooltip = require("@mui/x-charts/ChartsTooltip");
+var _hooks = require("@mui/x-charts/hooks");
+var _internals = require("@mui/x-charts/internals");
+var _useHeatmapSeries = require("../hooks/useHeatmapSeries");
+var _jsxRuntime = require("react/jsx-runtime");
 const useUtilityClasses = ownerState => {
   const {
     classes
@@ -26,16 +33,16 @@ const useUtilityClasses = ownerState => {
     labelCell: ['labelCell'],
     valueCell: ['valueCell']
   };
-  return composeClasses(slots, getChartsTooltipUtilityClass, classes);
+  return (0, _composeClasses.default)(slots, _ChartsTooltip.getChartsTooltipUtilityClass, classes);
 };
 function DefaultHeatmapTooltipContent(props) {
   const {
     classes
   } = props;
-  const xAxis = useXAxis();
-  const yAxis = useYAxis();
-  const heatmapSeries = useHeatmapSeries();
-  const tooltipData = useItemTooltip();
+  const xAxis = (0, _hooks.useXAxis)();
+  const yAxis = (0, _hooks.useYAxis)();
+  const heatmapSeries = (0, _useHeatmapSeries.useHeatmapSeriesContext)();
+  const tooltipData = (0, _ChartsTooltip.useItemTooltip)();
   if (!tooltipData || !heatmapSeries || heatmapSeries.seriesOrder.length === 0) {
     return null;
   }
@@ -52,45 +59,47 @@ function DefaultHeatmapTooltipContent(props) {
   } = tooltipData;
   const [xIndex, yIndex] = value;
   const formattedX = xAxis.valueFormatter?.(xAxis.data[xIndex], {
-    location: 'tooltip'
+    location: 'tooltip',
+    scale: xAxis.scale
   }) ?? xAxis.data[xIndex].toLocaleString();
   const formattedY = yAxis.valueFormatter?.(yAxis.data[yIndex], {
-    location: 'tooltip'
+    location: 'tooltip',
+    scale: yAxis.scale
   }) ?? yAxis.data[yIndex].toLocaleString();
   const formattedValue = series[seriesId].valueFormatter(value, {
     dataIndex: identifier.dataIndex
   });
-  const seriesLabel = getLabel(series[seriesId].label, 'tooltip');
-  return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
+  const seriesLabel = (0, _internals.getLabel)(series[seriesId].label, 'tooltip');
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipPaper, {
     className: classes?.paper,
-    children: /*#__PURE__*/_jsxs(ChartsTooltipTable, {
+    children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_ChartsTooltip.ChartsTooltipTable, {
       className: classes?.table,
-      children: [/*#__PURE__*/_jsx("thead", {
-        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("thead", {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_ChartsTooltip.ChartsTooltipRow, {
           className: classes?.row,
-          children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipCell, {
             className: classes?.cell,
             children: formattedX
-          }), formattedX && formattedY && /*#__PURE__*/_jsx(ChartsTooltipCell, {}), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+          }), formattedX && formattedY && /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipCell, {}), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipCell, {
             className: classes?.cell,
             children: formattedY
           })]
         })
-      }), /*#__PURE__*/_jsx("tbody", {
-        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)("tbody", {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_ChartsTooltip.ChartsTooltipRow, {
           className: classes?.row,
-          children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
-            className: clsx(classes?.markCell, classes?.cell),
-            children: /*#__PURE__*/_jsx(ChartsLabelMark, {
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipCell, {
+            className: (0, _clsx.default)(classes?.markCell, classes?.cell),
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_internals.ChartsLabelMark, {
               type: markType,
               color: color,
               className: classes?.mark
             })
-          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
-            className: clsx(classes?.labelCell, classes?.cell),
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipCell, {
+            className: (0, _clsx.default)(classes?.labelCell, classes?.cell),
             children: seriesLabel
-          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
-            className: clsx(classes?.valueCell, classes?.cell),
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipCell, {
+            className: (0, _clsx.default)(classes?.valueCell, classes?.cell),
             children: formattedValue
           })]
         })
@@ -106,16 +115,16 @@ process.env.NODE_ENV !== "production" ? DefaultHeatmapTooltipContent.propTypes =
   /**
    * Override or extend the styles applied to the component.
    */
-  classes: PropTypes.object
+  classes: _propTypes.default.object
 } : void 0;
 function HeatmapTooltip(props) {
   const classes = useUtilityClasses({
     classes: props.classes
   });
-  return /*#__PURE__*/_jsx(ChartsTooltipContainer, _extends({}, props, {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsTooltip.ChartsTooltipContainer, (0, _extends2.default)({}, props, {
     classes: classes,
     trigger: "item",
-    children: /*#__PURE__*/_jsx(DefaultHeatmapTooltipContent, {
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(DefaultHeatmapTooltipContent, {
       classes: classes
     })
   }));
@@ -131,30 +140,30 @@ process.env.NODE_ENV !== "production" ? HeatmapTooltip.propTypes = {
    * 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 /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.object, PropTypes.func]),
+  anchorEl: _propTypes.default /* @typescript-to-proptypes-ignore */.oneOfType([_HTMLElementType.default, _propTypes.default.object, _propTypes.default.func]),
   /**
    * Override or extend the styles applied to the component.
    */
-  classes: PropTypes.object,
+  classes: _propTypes.default.object,
   /**
    * The component used for the root node.
    * Either a string to use a HTML element or a component.
    */
-  component: PropTypes.elementType,
+  component: _propTypes.default.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
+  components: _propTypes.default.shape({
+    Root: _propTypes.default.elementType
   }),
   /**
    * The props used for each slot inside the Popper.
    * @default {}
    */
-  componentsProps: PropTypes.shape({
-    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  componentsProps: _propTypes.default.shape({
+    root: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object])
   }),
   /**
    * An HTML element or function that returns one.
@@ -166,7 +175,7 @@ process.env.NODE_ENV !== "production" ? HeatmapTooltip.propTypes = {
    * 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) => {
+  container: _propTypes.default.oneOfType([(props, propName) => {
     if (props[propName] == null) {
       return new Error(`Prop '${propName}' is required but wasn't specified`);
     }
@@ -174,19 +183,19 @@ process.env.NODE_ENV !== "production" ? HeatmapTooltip.propTypes = {
       return new Error(`Expected prop '${propName}' to be of type Element`);
     }
     return null;
-  }, PropTypes.func]),
+  }, _propTypes.default.func]),
   /**
    * The `children` will be under the DOM hierarchy of the parent component.
    * @default false
    */
-  disablePortal: PropTypes.bool,
+  disablePortal: _propTypes.default.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,
+  keepMounted: _propTypes.default.bool,
   /**
    * Popper.js is based on a "plugin-like" architecture,
    * most of its features are fully encapsulated "modifiers".
@@ -196,79 +205,78 @@ process.env.NODE_ENV !== "production" ? HeatmapTooltip.propTypes = {
    * 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)
+  modifiers: _propTypes.default.arrayOf(_propTypes.default.shape({
+    data: _propTypes.default.object,
+    effect: _propTypes.default.func,
+    enabled: _propTypes.default.bool,
+    fn: _propTypes.default.func,
+    name: _propTypes.default.any,
+    options: _propTypes.default.object,
+    phase: _propTypes.default.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),
+    requires: _propTypes.default.arrayOf(_propTypes.default.string),
+    requiresIfExists: _propTypes.default.arrayOf(_propTypes.default.string)
   })),
   /**
    * If `true`, the component is shown.
    */
-  open: PropTypes.bool,
+  open: _propTypes.default.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']),
+  placement: _propTypes.default.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'])
+  popperOptions: _propTypes.default.shape({
+    modifiers: _propTypes.default.array,
+    onFirstUpdate: _propTypes.default.func,
+    placement: _propTypes.default.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.default.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
+  popperRef: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.shape({
+    current: _propTypes.default.shape({
+      destroy: _propTypes.default.func.isRequired,
+      forceUpdate: _propTypes.default.func.isRequired,
+      setOptions: _propTypes.default.func.isRequired,
+      state: _propTypes.default.shape({
+        attributes: _propTypes.default.object.isRequired,
+        elements: _propTypes.default.object.isRequired,
+        modifiersData: _propTypes.default.object.isRequired,
+        options: _propTypes.default.object.isRequired,
+        orderedModifiers: _propTypes.default.arrayOf(_propTypes.default.object).isRequired,
+        placement: _propTypes.default.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.default.object.isRequired,
+        reset: _propTypes.default.bool.isRequired,
+        scrollParents: _propTypes.default.object.isRequired,
+        strategy: _propTypes.default.oneOf(['absolute', 'fixed']).isRequired,
+        styles: _propTypes.default.object.isRequired
       }).isRequired,
-      update: PropTypes.func.isRequired
+      update: _propTypes.default.func.isRequired
     })
   })]),
   /**
    * The props used for each slot inside the Popper.
    * @default {}
    */
-  slotProps: PropTypes.object,
+  slotProps: _propTypes.default.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,
+  slots: _propTypes.default.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]),
+  sx: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object, _propTypes.default.bool])), _propTypes.default.func, _propTypes.default.object]),
   /**
    * Help supporting a react-transition-group/Transition component.
    * @default false
    */
-  transition: PropTypes.bool
-} : void 0;
-export { HeatmapTooltip };
+  transition: _propTypes.default.bool
+} : void 0;