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

package/ChartContainerPro/ChartContainerPro.js

@@ -3,49 +3,29 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import { ChartsSurface } from '@mui/x-charts/ChartsSurface';
-import { HighlightedProvider, ZAxisContextProvider } from '@mui/x-charts/context';
-import { ChartsAxesGradients, DrawingProvider, InteractionProvider, PluginProvider, SeriesProvider, AnimationProvider } from '@mui/x-charts/internals';
-import { useLicenseVerifier } from '@mui/x-license/useLicenseVerifier';
+import { Watermark } from '@mui/x-license/Watermark';
+import { ResizableContainer } from '@mui/x-charts/internals';
+import { ChartsSurface } from '@mui/x-charts';
 import { getReleaseInfo } from "../internals/utils/releaseInfo.js";
-import { CartesianProviderPro } from "../context/CartesianProviderPro/index.js";
-import { ZoomProvider } from "../context/ZoomProvider/index.js";
+import { ChartDataProviderPro } from "../context/ChartDataProviderPro/index.js";
 import { useChartContainerProProps } from "./useChartContainerProProps.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const releaseInfo = getReleaseInfo();
-const ChartContainerPro = /*#__PURE__*/React.forwardRef(function ChartContainer(props, ref) {
+const ChartContainerPro = /*#__PURE__*/React.forwardRef(function ChartContainerPro(props, ref) {
   const {
-    zoomProviderProps,
-    drawingProviderProps,
-    seriesProviderProps,
-    zAxisContextProps,
-    highlightedProviderProps,
-    cartesianProviderProps,
-    chartsSurfaceProps,
-    pluginProviderProps,
-    animationProviderProps,
-    children
+    chartDataProviderProProps,
+    children,
+    resizableContainerProps,
+    chartsSurfaceProps
   } = useChartContainerProProps(props, ref);
-  useLicenseVerifier('x-charts-pro', releaseInfo);
-  return /*#__PURE__*/_jsx(DrawingProvider, _extends({}, drawingProviderProps, {
-    children: /*#__PURE__*/_jsx(AnimationProvider, _extends({}, animationProviderProps, {
-      children: /*#__PURE__*/_jsx(PluginProvider, _extends({}, pluginProviderProps, {
-        children: /*#__PURE__*/_jsx(ZoomProvider, _extends({}, zoomProviderProps, {
-          children: /*#__PURE__*/_jsx(SeriesProvider, _extends({}, seriesProviderProps, {
-            children: /*#__PURE__*/_jsx(CartesianProviderPro, _extends({}, cartesianProviderProps, {
-              children: /*#__PURE__*/_jsx(ZAxisContextProvider, _extends({}, zAxisContextProps, {
-                children: /*#__PURE__*/_jsx(InteractionProvider, {
-                  children: /*#__PURE__*/_jsx(HighlightedProvider, _extends({}, highlightedProviderProps, {
-                    children: /*#__PURE__*/_jsxs(ChartsSurface, _extends({}, chartsSurfaceProps, {
-                      children: [/*#__PURE__*/_jsx(ChartsAxesGradients, {}), children]
-                    }))
-                  }))
-                })
-              }))
-            }))
-          }))
-        }))
-      }))
+  return /*#__PURE__*/_jsx(ChartDataProviderPro, _extends({}, chartDataProviderProProps, {
+    children: /*#__PURE__*/_jsxs(ResizableContainer, _extends({}, resizableContainerProps, {
+      children: [/*#__PURE__*/_jsx(ChartsSurface, _extends({}, chartsSurfaceProps, {
+        children: children
+      })), /*#__PURE__*/_jsx(Watermark, {
+        packageName: "x-charts-pro",
+        releaseInfo: releaseInfo
+      })]
     }))
   }));
 });
@@ -73,9 +53,9 @@ process.env.NODE_ENV !== "production" ? ChartContainerPro.propTypes = {
    */
   disableAxisListener: PropTypes.bool,
   /**
-   * The height of the chart in px.
+   * The height of the chart in px. If not defined, it takes the height of the parent element.
    */
-  height: PropTypes.number.isRequired,
+  height: PropTypes.number,
   /**
    * The item currently highlighted. Turns highlighting into a controlled prop.
    */
@@ -125,16 +105,10 @@ process.env.NODE_ENV !== "production" ? ChartContainerPro.propTypes = {
   skipAnimation: PropTypes.bool,
   sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
   title: PropTypes.string,
-  viewBox: PropTypes.shape({
-    height: PropTypes.number,
-    width: PropTypes.number,
-    x: PropTypes.number,
-    y: PropTypes.number
-  }),
   /**
-   * The width of the chart in px.
+   * The width of the chart in px. If not defined, it takes the width of the parent element.
    */
-  width: PropTypes.number.isRequired,
+  width: PropTypes.number,
   /**
    * The configuration of the x-axes.
    * If not provided, a default axis config is used.

package/ChartContainerPro/useChartContainerProProps.d.ts

@@ -1,16 +1,8 @@
-import { ZoomProviderProps } from '../context/ZoomProvider';
+import { UseChartContainerPropsReturnValue } from '@mui/x-charts/internals';
+import * as React from 'react';
+import type { ChartDataProviderProProps } from '../context/ChartDataProviderPro';
 import type { ChartContainerProProps } from './ChartContainerPro';
-export declare const useChartContainerProProps: (props: ChartContainerProProps, ref: React.ForwardedRef<unknown>) => {
-    zoomProviderProps: Omit<ZoomProviderProps, "children">;
-    children: import("react").ReactNode;
-    drawingProviderProps: Omit<import("@mui/x-charts/internals").DrawingProviderProps, "children">;
-    pluginProviderProps: Omit<import("@mui/x-charts/internals").PluginProviderProps, "children">;
-    seriesProviderProps: Omit<import("@mui/x-charts/internals").SeriesProviderProps, "children">;
-    cartesianProviderProps: Omit<import("@mui/x-charts/internals").CartesianProviderProps, "children">;
-    zAxisContextProps: Omit<import("@mui/x-charts").ZAxisContextProviderProps, "children">;
-    highlightedProviderProps: Omit<import("@mui/x-charts").HighlightedProviderProps, "children">;
-    chartsSurfaceProps: import("@mui/x-charts").ChartsSurfaceProps & {
-        ref: any;
-    };
-    animationProviderProps: Omit<import("@mui/x-charts/internals").AnimationProviderProps, "children">;
+export type UseChartContainerProPropsReturnValue = Omit<UseChartContainerPropsReturnValue, 'chartDataProviderProps'> & {
+    chartDataProviderProProps: ChartDataProviderProProps;
 };
+export declare const useChartContainerProProps: (props: ChartContainerProProps, ref: React.Ref<SVGSVGElement>) => UseChartContainerProPropsReturnValue;

package/ChartContainerPro/useChartContainerProProps.js

@@ -1,5 +1,6 @@
 'use client';
 
+import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 const _excluded = ["zoom", "onZoomChange"];
 import { useChartContainerProps } from '@mui/x-charts/internals';
@@ -9,35 +10,20 @@ export const useChartContainerProProps = (props, ref) => {
       onZoomChange
     } = props,
     baseProps = _objectWithoutPropertiesLoose(props, _excluded);
+  const chartDataProviderProProps = {
+    zoom,
+    onZoomChange
+  };
   const {
-    children,
-    drawingProviderProps,
-    seriesProviderProps,
-    cartesianProviderProps,
-    zAxisContextProps,
-    highlightedProviderProps,
+    chartDataProviderProps,
     chartsSurfaceProps,
-    pluginProviderProps,
-    animationProviderProps,
-    xAxis,
-    yAxis
+    resizableContainerProps,
+    children
   } = useChartContainerProps(baseProps, ref);
-  const zoomProviderProps = {
-    zoom,
-    onZoomChange,
-    xAxis,
-    yAxis
-  };
   return {
-    zoomProviderProps,
-    children,
-    drawingProviderProps,
-    pluginProviderProps,
-    seriesProviderProps,
-    cartesianProviderProps,
-    zAxisContextProps,
-    highlightedProviderProps,
+    chartDataProviderProProps: _extends({}, chartDataProviderProps, chartDataProviderProProps),
+    resizableContainerProps,
     chartsSurfaceProps,
-    animationProviderProps
+    children
   };
 };

package/Heatmap/Heatmap.d.ts

@@ -1,17 +1,25 @@
 import * as React from 'react';
+import { MakeOptional } from '@mui/x-internals/types';
 import { ChartsAxisProps } from '@mui/x-charts/ChartsAxis';
-import { ChartsTooltipProps, ChartsTooltipSlotProps, ChartsTooltipSlots } from '@mui/x-charts/ChartsTooltip';
-import { MakeOptional, ChartsAxisSlots, ChartsAxisSlotProps, ChartsXAxisProps, ChartsYAxisProps, AxisConfig } from '@mui/x-charts/internals';
+import { ChartsTooltipProps } from '@mui/x-charts/ChartsTooltip';
+import { ChartsAxisSlots, ChartsAxisSlotProps, ChartsXAxisProps, ChartsYAxisProps, AxisConfig } from '@mui/x-charts/internals';
 import { ChartsOnAxisClickHandlerProps } from '@mui/x-charts/ChartsOnAxisClickHandler';
 import { ChartsOverlayProps, ChartsOverlaySlotProps, ChartsOverlaySlots } from '@mui/x-charts/ChartsOverlay';
-import { ResponsiveChartContainerProProps } from '../ResponsiveChartContainerPro';
+import { ChartContainerProProps } from '../ChartContainerPro';
 import { HeatmapSeriesType } from '../models/seriesType/heatmap';
+import { HeatmapTooltipProps } from './HeatmapTooltip';
 import { HeatmapItemSlotProps, HeatmapItemSlots } from './HeatmapItem';
-export interface HeatmapSlots extends ChartsAxisSlots, Omit<ChartsTooltipSlots<'heatmap'>, 'axisContent'>, ChartsOverlaySlots, HeatmapItemSlots {
+export interface HeatmapSlots extends ChartsAxisSlots, ChartsOverlaySlots, HeatmapItemSlots {
+    /**
+     * Custom component for the tooltip popper.
+     * @default ChartsTooltipRoot
+     */
+    tooltip?: React.ElementType<HeatmapTooltipProps>;
 }
-export interface HeatmapSlotProps extends ChartsAxisSlotProps, Omit<ChartsTooltipSlotProps<'heatmap'>, 'axisContent'>, ChartsOverlaySlotProps, HeatmapItemSlotProps {
+export interface HeatmapSlotProps extends ChartsAxisSlotProps, ChartsOverlaySlotProps, HeatmapItemSlotProps {
+    tooltip?: Partial<HeatmapTooltipProps>;
 }
-export interface HeatmapProps extends Omit<ResponsiveChartContainerProProps, 'series' | 'plugins' | 'xAxis' | 'yAxis' | 'zoom' | 'onZoomChange' | 'skipAnimation'>, Omit<ChartsAxisProps, 'slots' | 'slotProps'>, Omit<ChartsOverlayProps, 'slots' | 'slotProps'>, ChartsOnAxisClickHandlerProps {
+export interface HeatmapProps extends Omit<ChartContainerProProps, 'series' | 'plugins' | 'xAxis' | 'yAxis' | 'zoom' | 'onZoomChange' | 'skipAnimation'>, Omit<ChartsAxisProps, 'slots' | 'slotProps'>, Omit<ChartsOverlayProps, 'slots' | 'slotProps'>, ChartsOnAxisClickHandlerProps {
     /**
      * The configuration of the x-axes.
      * If not provided, a default axis config is used.
@@ -33,7 +41,7 @@ export interface HeatmapProps extends Omit<ResponsiveChartContainerProProps, 'se
      * The configuration of the tooltip.
      * @see See {@link https://mui.com/x/react-charts/tooltip/ tooltip docs} for more details.
      */
-    tooltip?: ChartsTooltipProps<'heatmap'>;
+    tooltip?: ChartsTooltipProps;
     /**
      * Overridable component slots.
      * @default {}
@@ -45,5 +53,5 @@ export interface HeatmapProps extends Omit<ResponsiveChartContainerProProps, 'se
      */
     slotProps?: HeatmapSlotProps;
 }
-declare const Heatmap: React.ForwardRefExoticComponent<HeatmapProps & React.RefAttributes<unknown>>;
+declare const Heatmap: React.ForwardRefExoticComponent<HeatmapProps & React.RefAttributes<SVGSVGElement>>;
 export { Heatmap };

package/Heatmap/Heatmap.js

@@ -7,14 +7,13 @@ import { useThemeProps } from '@mui/material/styles';
 import useId from '@mui/utils/useId';
 import { interpolateRgbBasis } from '@mui/x-charts-vendor/d3-interpolate';
 import { ChartsAxis } from '@mui/x-charts/ChartsAxis';
-import { ChartsTooltip } from '@mui/x-charts/ChartsTooltip';
 import { ChartsClipPath } from '@mui/x-charts/ChartsClipPath';
 import { ChartsOnAxisClickHandler } from '@mui/x-charts/ChartsOnAxisClickHandler';
 import { ChartsOverlay } from '@mui/x-charts/ChartsOverlay';
-import { ResponsiveChartContainerPro } from "../ResponsiveChartContainerPro/index.js";
+import { ChartContainerPro } from "../ChartContainerPro/index.js";
 import { HeatmapPlot } from "./HeatmapPlot.js";
 import { plugin as heatmapPlugin } from "./plugin.js";
-import { DefaultHeatmapTooltip } from "./DefaultHeatmapTooltip.js";
+import { HeatmapTooltip } from "./HeatmapTooltip.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // The GnBu: https://github.com/d3/d3-scale-chromatic/blob/main/src/sequential-multi/GnBu.js
 const defaultColorMap = interpolateRgbBasis(['#f7fcf0', '#e0f3db', '#ccebc5', '#a8ddb5', '#7bccc4', '#4eb3d3', '#2b8cbe', '#0868ac', '#084081']);
@@ -34,7 +33,6 @@ const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
     colors,
     dataset,
     sx,
-    tooltip,
     topAxis,
     leftAxis,
     rightAxis,
@@ -65,7 +63,8 @@ const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
       color: defaultColorMap
     }
   }], [zAxis]);
-  return /*#__PURE__*/_jsxs(ResponsiveChartContainerPro, {
+  const Tooltip = props.slots?.tooltip ?? HeatmapTooltip;
+  return /*#__PURE__*/_jsxs(ChartContainerPro, {
     ref: ref,
     plugins: [heatmapPlugin],
     series: series.map(s => _extends({
@@ -102,14 +101,7 @@ const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
       bottomAxis: bottomAxis,
       slots: slots,
       slotProps: slotProps
-    }), !loading && /*#__PURE__*/_jsx(ChartsTooltip, _extends({
-      trigger: "item"
-    }, tooltip, {
-      slots: _extends({
-        itemContent: DefaultHeatmapTooltip
-      }, slots),
-      slotProps: slotProps
-    })), /*#__PURE__*/_jsx(ChartsClipPath, {
+    }), !loading && /*#__PURE__*/_jsx(Tooltip, _extends({}, slotProps?.tooltip)), /*#__PURE__*/_jsx(ChartsClipPath, {
       id: clipPathId
     }), children]
   });
@@ -190,16 +182,6 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
    * @param {HighlightItemData | null} highlightedItem  The newly highlighted item.
    */
   onHighlightChange: PropTypes.func,
-  /**
-   * The chart will try to wait for the parent container to resolve its size
-   * before it renders for the first time.
-   *
-   * This can be useful in some scenarios where the chart appear to grow after
-   * the first render, like when used inside a grid.
-   *
-   * @default false
-   */
-  resolveSizeBeforeRender: PropTypes.bool,
   /**
    * Indicate which axis to display the right of the charts.
    * Can be a string (the id of the axis) or an object `ChartsYAxisProps`.
@@ -227,26 +209,13 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
    * The configuration of the tooltip.
    * @see See {@link https://mui.com/x/react-charts/tooltip/ tooltip docs} for more details.
    */
-  tooltip: PropTypes.shape({
-    axisContent: PropTypes.elementType,
-    classes: PropTypes.object,
-    itemContent: PropTypes.elementType,
-    slotProps: PropTypes.object,
-    slots: PropTypes.object,
-    trigger: PropTypes.oneOf(['axis', 'item', 'none'])
-  }),
+  tooltip: PropTypes.object,
   /**
    * Indicate which axis to display the top of the charts.
    * Can be a string (the id of the axis) or an object `ChartsXAxisProps`.
    * @default null
    */
   topAxis: PropTypes.oneOfType([PropTypes.object, PropTypes.string]),
-  viewBox: PropTypes.shape({
-    height: PropTypes.number,
-    width: PropTypes.number,
-    x: PropTypes.number,
-    y: PropTypes.number
-  }),
   /**
    * The width of the chart in px. If not defined, it takes the width of the parent element.
    */

package/Heatmap/HeatmapTooltip.d.ts

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

package/Heatmap/HeatmapTooltip.js

@@ -0,0 +1,294 @@
+'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 composeClasses from '@mui/utils/composeClasses';
+import { ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipRow, ChartsTooltipCell, ChartsTooltipMark, useItemTooltip, getChartsTooltipUtilityClass, ChartsTooltipContainer } from '@mui/x-charts/ChartsTooltip';
+import { useXAxis, useYAxis } from '@mui/x-charts/hooks';
+import { getLabel } from '@mui/x-charts/internals';
+import { useHeatmapSeries } from "../hooks/useSeries.js";
+import { jsx as _jsx, jsxs as _jsxs } 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);
+};
+
+/**
+ * @ignore - internal component.
+ */
+function DefaultHeatmapTooltipContent(props) {
+  const {
+    classes
+  } = props;
+  const xAxis = useXAxis();
+  const yAxis = useYAxis();
+  const heatmapSeries = useHeatmapSeries();
+  const tooltipData = useItemTooltip();
+  if (!tooltipData || !heatmapSeries || heatmapSeries.seriesOrder.length === 0) {
+    return null;
+  }
+  const {
+    series,
+    seriesOrder
+  } = heatmapSeries;
+  const seriesId = seriesOrder[0];
+  const {
+    color,
+    value,
+    identifier
+  } = tooltipData;
+  const [xIndex, yIndex] = value;
+  const formattedX = xAxis.valueFormatter?.(xAxis.data[xIndex], {
+    location: 'tooltip'
+  }) ?? xAxis.data[xIndex].toLocaleString();
+  const formattedY = yAxis.valueFormatter?.(yAxis.data[yIndex], {
+    location: 'tooltip'
+  }) ?? yAxis.data[yIndex].toLocaleString();
+  const formattedValue = series[seriesId].valueFormatter(value, {
+    dataIndex: identifier.dataIndex
+  });
+  const seriesLabel = getLabel(series[seriesId].label, 'tooltip');
+  return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
+    className: classes?.paper,
+    children: /*#__PURE__*/_jsxs(ChartsTooltipTable, {
+      className: classes?.table,
+      children: [/*#__PURE__*/_jsx("thead", {
+        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+          className: classes?.row,
+          children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: classes?.cell,
+            children: formattedX
+          }), formattedX && formattedY && /*#__PURE__*/_jsx(ChartsTooltipCell, {}), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: classes?.cell,
+            children: formattedY
+          })]
+        })
+      }), /*#__PURE__*/_jsx("tbody", {
+        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+          className: classes?.row,
+          children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes?.markCell, classes?.cell),
+            children: /*#__PURE__*/_jsx(ChartsTooltipMark, {
+              color: color,
+              className: classes?.mark
+            })
+          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes?.labelCell, classes?.cell),
+            children: seriesLabel
+          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes?.valueCell, classes?.cell),
+            children: formattedValue
+          })]
+        })
+      })]
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? DefaultHeatmapTooltipContent.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object
+} : void 0;
+function HeatmapTooltip(props) {
+  const classes = useUtilityClasses({
+    classes: props.classes
+  });
+  return /*#__PURE__*/_jsx(ChartsTooltipContainer, _extends({}, props, {
+    classes: classes,
+    trigger: "item",
+    children: /*#__PURE__*/_jsx(DefaultHeatmapTooltipContent, {
+      classes: classes
+    })
+  }));
+}
+process.env.NODE_ENV !== "production" ? HeatmapTooltip.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
+  })]),
+  /**
+   * 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
+} : void 0;
+export { HeatmapTooltip };

package/Heatmap/index.d.ts

@@ -1,4 +1,4 @@
 export { Heatmap } from './Heatmap';
 export { HeatmapPlot } from './HeatmapPlot';
-export * from './DefaultHeatmapTooltip';
+export * from './HeatmapTooltip';
 export * from './heatmapClasses';

package/Heatmap/index.js

@@ -1,4 +1,4 @@
 export { Heatmap } from "./Heatmap.js";
 export { HeatmapPlot } from "./HeatmapPlot.js";
-export * from "./DefaultHeatmapTooltip.js";
+export * from "./HeatmapTooltip.js";
 export * from "./heatmapClasses.js";

package/LineChartPro/LineChartPro.d.ts

@@ -13,5 +13,5 @@ export interface LineChartProProps extends LineChartProps, ZoomProps {
  *
  * - [LineChart API](https://mui.com/x/api/charts/line-chart/)
  */
-declare const LineChartPro: React.ForwardRefExoticComponent<LineChartProProps & React.RefAttributes<unknown>>;
+declare const LineChartPro: React.ForwardRefExoticComponent<LineChartProProps & React.RefAttributes<SVGSVGElement>>;
 export { LineChartPro };