@mui/x-charts-pro 8.0.0-alpha.9 → 8.0.0-beta.0

package/modern/FunnelChart/useFunnelChartProps.js

@@ -0,0 +1,161 @@
+'use client';
+
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["categoryAxis", "series", "width", "height", "margin", "colors", "sx", "children", "slots", "slotProps", "skipAnimation", "loading", "onItemClick", "highlightedItem", "onHighlightChange", "className", "hideLegend", "axisHighlight", "apiRef"];
+import { DEFAULT_MARGINS, DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from '@mui/x-charts/constants';
+import useId from '@mui/utils/useId';
+import { defaultizeMargin } from '@mui/x-charts/internals';
+import { warnOnce } from '@mui/x-internals/warning';
+function getCategoryAxisConfig(categoryAxis, series, isHorizontal, direction) {
+  const maxSeriesLength = Math.max(...series.map(s => (s.data ?? []).length), 0);
+  const maxSeriesValue = Array.from({
+    length: maxSeriesLength
+  }, (_, index) => series.reduce((a, s) => a + (s.data?.[index]?.value ?? 0), 0));
+  if (process.env.NODE_ENV !== 'production') {
+    if ((categoryAxis?.position === 'left' || categoryAxis?.position === 'right') && isHorizontal || (categoryAxis?.position === 'top' || categoryAxis?.position === 'bottom') && !isHorizontal) {
+      warnOnce([`MUI X: the categoryAxis position is set to '${categoryAxis.position}' but the series layout is ${isHorizontal ? 'horizontal' : 'vertical'}.`, `Ensure that the categoryAxis position is set to '${isHorizontal ? 'top' : 'left'}' or '${isHorizontal ? 'bottom' : 'right'}' for ${isHorizontal ? 'horizontal' : 'vertical'} layout.\n`], 'warning');
+    }
+  }
+  const side = isHorizontal ? 'bottom' : 'left';
+  const categoryValues = _extends({
+    id: direction === 'x' ? DEFAULT_X_AXIS_KEY : DEFAULT_Y_AXIS_KEY
+  }, categoryAxis, categoryAxis?.size ? {
+    [isHorizontal ? 'height' : 'width']: categoryAxis.size
+  } : {}, {
+    position: categoryAxis?.position ?? (categoryAxis?.categories ? side : 'none')
+  });
+
+  // If the scaleType is not defined or is 'band', our job is simple.
+  if (!categoryAxis?.scaleType || categoryAxis.scaleType === 'band') {
+    return _extends({
+      scaleType: 'band',
+      categoryGapRatio: 0,
+      // Use the categories as the domain if they are defined.
+      data: categoryAxis?.categories ? categoryAxis.categories :
+      // Otherwise we just need random data to create the band scale.
+      Array.from({
+        length: maxSeriesLength
+      }, (_, index) => index),
+      tickLabelPlacement: 'middle'
+    }, categoryValues);
+  }
+
+  // If the scaleType is other than 'band', we have to do some magic.
+  // First we need to calculate the tick values additively and in reverse order.
+  const tickValues = [...maxSeriesValue.toReversed().map((_, i, arr) => arr.slice(0, i).reduce((a, value) => a + value, 0)),
+  // We add the total value of the series as the last tick value
+  maxSeriesValue.reduce((a, value) => a + value, 0)];
+  return _extends({
+    scaleType: categoryAxis.scaleType,
+    domainLimit: 'strict',
+    tickLabelPlacement: 'middle',
+    tickInterval: tickValues,
+    // No need to show the first tick label
+    tickLabelInterval: (_, i) => i !== 0,
+    // We trick the valueFormatter to show the category values.
+    // By using the index of the tickValues array we can get the category value.
+    valueFormatter: value => `${categoryAxis.categories?.toReversed()[tickValues.findIndex(v => v === value) - 1]}`
+  }, categoryValues);
+}
+
+/**
+ * A helper function that extracts FunnelChartProps from the input props
+ * and returns an object with props for the children components of FunnelChart.
+ *
+ * @param props The input props for FunnelChart
+ * @returns An object with props for the children components of FunnelChart
+ */
+export const useFunnelChartProps = props => {
+  const {
+      categoryAxis,
+      series,
+      width,
+      height,
+      margin: marginProps,
+      colors,
+      sx,
+      children,
+      slots,
+      slotProps,
+      loading,
+      onItemClick,
+      highlightedItem,
+      onHighlightChange,
+      className,
+      axisHighlight,
+      apiRef
+    } = props,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  const margin = defaultizeMargin(marginProps, DEFAULT_MARGINS);
+  const id = useId();
+  const clipPathId = `${id}-clip-path`;
+  const isHorizontal = series.some(s => s.layout === 'horizontal');
+  const valueAxisConfig = {
+    id: isHorizontal ? DEFAULT_Y_AXIS_KEY : DEFAULT_X_AXIS_KEY,
+    scaleType: 'linear',
+    domainLimit: 'strict',
+    position: 'none'
+  };
+  const xAxis = isHorizontal ? getCategoryAxisConfig(categoryAxis, series, isHorizontal, 'x') : valueAxisConfig;
+  const yAxis = isHorizontal ? valueAxisConfig : getCategoryAxisConfig(categoryAxis, series, isHorizontal, 'y');
+  const chartContainerProps = _extends({}, rest, {
+    series: series.map(s => _extends({
+      type: 'funnel',
+      layout: isHorizontal ? 'horizontal' : 'vertical'
+    }, s)),
+    width,
+    height,
+    margin,
+    colors,
+    xAxis: [xAxis],
+    yAxis: [yAxis],
+    sx,
+    highlightedItem,
+    onHighlightChange,
+    className,
+    apiRef
+  });
+  const funnelPlotProps = {
+    onItemClick,
+    slots,
+    slotProps
+  };
+  const overlayProps = {
+    slots,
+    slotProps,
+    loading
+  };
+  const chartsAxisProps = {
+    slots,
+    slotProps
+  };
+  const legendProps = {
+    slots,
+    slotProps
+  };
+  const clipPathGroupProps = {
+    clipPath: `url(#${clipPathId})`
+  };
+  const clipPathProps = {
+    id: clipPathId
+  };
+  const chartsWrapperProps = {
+    sx,
+    legendPosition: props.slotProps?.legend?.position,
+    legendDirection: props.slotProps?.legend?.direction
+  };
+  const axisHighlightProps = _extends({}, axisHighlight);
+  return {
+    chartContainerProps,
+    funnelPlotProps,
+    overlayProps,
+    chartsAxisProps,
+    legendProps,
+    clipPathGroupProps,
+    clipPathProps,
+    chartsWrapperProps,
+    axisHighlightProps,
+    children
+  };
+};

package/modern/Heatmap/Heatmap.d.ts

@@ -0,0 +1,57 @@
+import * as React from 'react';
+import { MakeOptional } from '@mui/x-internals/types';
+import { ChartsAxisProps } from '@mui/x-charts/ChartsAxis';
+import { ChartsTooltipProps } from '@mui/x-charts/ChartsTooltip';
+import { ChartsAxisSlots, ChartsAxisSlotProps, ChartsXAxisProps, ChartsYAxisProps, AxisConfig } from '@mui/x-charts/internals';
+import { ChartsOverlayProps, ChartsOverlaySlotProps, ChartsOverlaySlots } from '@mui/x-charts/ChartsOverlay';
+import { ChartContainerProProps } from "../ChartContainerPro/index.js";
+import { HeatmapSeriesType } from "../models/seriesType/heatmap.js";
+import { HeatmapTooltipProps } from "./HeatmapTooltip.js";
+import { HeatmapItemSlotProps, HeatmapItemSlots } from "./HeatmapItem.js";
+import { HeatmapPluginsSignatures } from "./Heatmap.plugins.js";
+export interface HeatmapSlots extends ChartsAxisSlots, ChartsOverlaySlots, HeatmapItemSlots {
+  /**
+   * Custom component for the tooltip popper.
+   * @default ChartsTooltipRoot
+   */
+  tooltip?: React.ElementType<HeatmapTooltipProps>;
+}
+export interface HeatmapSlotProps extends ChartsAxisSlotProps, ChartsOverlaySlotProps, HeatmapItemSlotProps {
+  tooltip?: Partial<HeatmapTooltipProps>;
+}
+export interface HeatmapProps extends Omit<ChartContainerProProps<'heatmap', HeatmapPluginsSignatures>, 'series' | 'plugins' | 'xAxis' | 'yAxis' | 'skipAnimation'>, Omit<ChartsAxisProps, 'slots' | 'slotProps'>, Omit<ChartsOverlayProps, 'slots' | 'slotProps'> {
+  /**
+   * The configuration of the x-axes.
+   * If not provided, a default axis config is used.
+   * An array of [[AxisConfig]] objects.
+   */
+  xAxis: Readonly<MakeOptional<AxisConfig<'band', any, ChartsXAxisProps>, 'id' | 'scaleType'>[]>;
+  /**
+   * The configuration of the y-axes.
+   * If not provided, a default axis config is used.
+   * An array of [[AxisConfig]] objects.
+   */
+  yAxis: Readonly<MakeOptional<AxisConfig<'band', any, ChartsYAxisProps>, 'id' | 'scaleType'>[]>;
+  /**
+   * The series to display in the bar chart.
+   * An array of [[HeatmapSeriesType]] objects.
+   */
+  series: Readonly<MakeOptional<HeatmapSeriesType, 'type'>[]>;
+  /**
+   * The configuration of the tooltip.
+   * @see See {@link https://mui.com/x/react-charts/tooltip/ tooltip docs} for more details.
+   */
+  tooltip?: ChartsTooltipProps;
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: HeatmapSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: HeatmapSlotProps;
+}
+declare const Heatmap: React.ForwardRefExoticComponent<HeatmapProps & React.RefAttributes<SVGSVGElement>>;
+export { Heatmap };

package/modern/Heatmap/Heatmap.js

@@ -8,18 +8,29 @@ import useId from '@mui/utils/useId';
 import { interpolateRgbBasis } from '@mui/x-charts-vendor/d3-interpolate';
 import { ChartsAxis } from '@mui/x-charts/ChartsAxis';
 import { ChartsClipPath } from '@mui/x-charts/ChartsClipPath';
-import { ChartsOnAxisClickHandler } from '@mui/x-charts/ChartsOnAxisClickHandler';
 import { ChartsOverlay } from '@mui/x-charts/ChartsOverlay';
+import { DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from '@mui/x-charts/constants';
 import { ChartContainerPro } from "../ChartContainerPro/index.js";
 import { HeatmapPlot } from "./HeatmapPlot.js";
-import { plugin as heatmapPlugin } from "./plugin.js";
+import { seriesConfig as heatmapSeriesConfig } from "./seriesConfig/index.js";
 import { HeatmapTooltip } from "./HeatmapTooltip.js";
+import { HEATMAP_PLUGINS } from "./Heatmap.plugins.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']);
 const seriesConfig = {
-  heatmap: heatmapPlugin
+  heatmap: heatmapSeriesConfig
 };
+function getDefaultDataForAxis(series, dimension) {
+  if (series?.[0]?.data === undefined || series[0].data.length === 0) {
+    return [];
+  }
+  return Array.from({
+    length: Math.max(...series[0].data.map(dataPoint => dataPoint[dimension])) + 1
+  }, (_, index) => index);
+}
+const getDefaultDataForXAxis = series => getDefaultDataForAxis(series, 0);
+const getDefaultDataForYAxis = series => getDefaultDataForAxis(series, 1);
 const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
   const props = useThemeProps({
     props: inProps,
@@ -36,10 +47,6 @@ const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
     colors,
     dataset,
     sx,
-    topAxis,
-    leftAxis,
-    rightAxis,
-    bottomAxis,
     onAxisClick,
     children,
     slots,
@@ -50,14 +57,22 @@ const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
   } = props;
   const id = useId();
   const clipPathId = `${id}-clip-path`;
-  const defaultizedXAxis = React.useMemo(() => xAxis.map(axis => _extends({
+  const defaultizedXAxis = React.useMemo(() => (xAxis && xAxis.length > 0 ? xAxis : [{
+    id: DEFAULT_X_AXIS_KEY
+  }]).map(axis => _extends({
     scaleType: 'band',
     categoryGapRatio: 0
-  }, axis)), [xAxis]);
-  const defaultizedYAxis = React.useMemo(() => yAxis.map(axis => _extends({
+  }, axis, {
+    data: axis.data ?? getDefaultDataForXAxis(series)
+  })), [series, xAxis]);
+  const defaultizedYAxis = React.useMemo(() => (yAxis && yAxis.length > 0 ? yAxis : [{
+    id: DEFAULT_Y_AXIS_KEY
+  }]).map(axis => _extends({
     scaleType: 'band',
     categoryGapRatio: 0
-  }, axis)), [yAxis]);
+  }, axis, {
+    data: axis.data ?? getDefaultDataForYAxis(series)
+  })), [series, yAxis]);
   const defaultizedZAxis = React.useMemo(() => zAxis ?? [{
     colorMap: {
       type: 'continuous',
@@ -85,9 +100,9 @@ const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
     disableAxisListener: true,
     highlightedItem: highlightedItem,
     onHighlightChange: onHighlightChange,
-    children: [onAxisClick && /*#__PURE__*/_jsx(ChartsOnAxisClickHandler, {
-      onAxisClick: onAxisClick
-    }), /*#__PURE__*/_jsxs("g", {
+    onAxisClick: onAxisClick,
+    plugins: HEATMAP_PLUGINS,
+    children: [/*#__PURE__*/_jsxs("g", {
       clipPath: `url(#${clipPathId})`,
       children: [/*#__PURE__*/_jsx(HeatmapPlot, {
         slots: slots,
@@ -98,10 +113,6 @@ const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
         slotProps: slotProps
       })]
     }), /*#__PURE__*/_jsx(ChartsAxis, {
-      topAxis: topAxis,
-      leftAxis: leftAxis,
-      rightAxis: rightAxis,
-      bottomAxis: bottomAxis,
       slots: slots,
       slotProps: slotProps
     }), !loading && /*#__PURE__*/_jsx(Tooltip, _extends({}, slotProps?.tooltip)), /*#__PURE__*/_jsx(ChartsClipPath, {
@@ -115,21 +126,13 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
   // | To update them edit the TypeScript types and run "pnpm proptypes"  |
   // ----------------------------------------------------------------------
   apiRef: PropTypes.shape({
-    current: PropTypes.shape({
-      setZoomData: PropTypes.func.isRequired
-    })
+    current: PropTypes.object
   }),
-  /**
-   * Indicate which axis to display the bottom of the charts.
-   * Can be a string (the id of the axis) or an object `ChartsXAxisProps`.
-   * @default xAxisIds[0] The id of the first provided axis
-   */
-  bottomAxis: PropTypes.oneOfType([PropTypes.object, PropTypes.string]),
   children: PropTypes.node,
   className: PropTypes.string,
   /**
    * Color palette used to colorize multiple series.
-   * @default blueberryTwilightPalette
+   * @default rainbowSurgePalette
    */
   colors: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.func]),
   /**
@@ -148,31 +151,18 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
    */
   height: PropTypes.number,
   /**
-   * The item currently highlighted. Turns highlighting into a controlled prop.
+   * The highlighted item.
+   * Used when the highlight is controlled.
    */
   highlightedItem: PropTypes.shape({
     dataIndex: PropTypes.number,
-    seriesId: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+    seriesId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired
   }),
   /**
    * This prop is used to help implement the accessibility logic.
    * If you don't provide this prop. It falls back to a randomly generated id.
    */
   id: PropTypes.string,
-  /**
-   * The list of zoom data related to each axis.
-   */
-  initialZoom: PropTypes.arrayOf(PropTypes.shape({
-    axisId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
-    end: PropTypes.number.isRequired,
-    start: PropTypes.number.isRequired
-  })),
-  /**
-   * Indicate which axis to display the left of the charts.
-   * Can be a string (the id of the axis) or an object `ChartsYAxisProps`.
-   * @default yAxisIds[0] The id of the first provided axis
-   */
-  leftAxis: PropTypes.oneOfType([PropTypes.object, PropTypes.string]),
   /**
    * If `true`, a loading overlay is displayed.
    * @default false
@@ -181,14 +171,15 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
   /**
    * The margin between the SVG and the drawing area.
    * It's used for leaving some space for extra information such as the x- and y-axis or legend.
-   * Accepts an object with the optional properties: `top`, `bottom`, `left`, and `right`.
+   *
+   * Accepts a `number` to be used on all sides or an object with the optional properties: `top`, `bottom`, `left`, and `right`.
    */
-  margin: PropTypes.shape({
+  margin: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
     bottom: PropTypes.number,
     left: PropTypes.number,
     right: PropTypes.number,
     top: PropTypes.number
-  }),
+  })]),
   /**
    * The function called for onClick events.
    * The second argument contains information about all line/bar elements at the current mouse position.
@@ -202,12 +193,6 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
    * @param {HighlightItemData | null} highlightedItem  The newly highlighted item.
    */
   onHighlightChange: PropTypes.func,
-  /**
-   * Indicate which axis to display the right of the charts.
-   * Can be a string (the id of the axis) or an object `ChartsYAxisProps`.
-   * @default null
-   */
-  rightAxis: PropTypes.oneOfType([PropTypes.object, PropTypes.string]),
   /**
    * The series to display in the bar chart.
    * An array of [[HeatmapSeriesType]] objects.
@@ -236,12 +221,6 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
    * @see See {@link https://mui.com/x/react-charts/tooltip/ tooltip docs} for more details.
    */
   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]),
   /**
    * The width of the chart in px. If not defined, it takes the width of the parent element.
    */
@@ -252,6 +231,7 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
    * An array of [[AxisConfig]] objects.
    */
   xAxis: PropTypes.arrayOf(PropTypes.shape({
+    axis: PropTypes.oneOf(['x']),
     barGapRatio: PropTypes.number,
     categoryGapRatio: PropTypes.number,
     classes: PropTypes.object,
@@ -276,13 +256,15 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
     disableTicks: PropTypes.bool,
     domainLimit: PropTypes.oneOfType([PropTypes.oneOf(['nice', 'strict']), PropTypes.func]),
     fill: PropTypes.string,
+    height: PropTypes.number,
     hideTooltip: PropTypes.bool,
     id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
     label: PropTypes.string,
     labelStyle: PropTypes.object,
     max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
     min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-    position: PropTypes.oneOf(['bottom', 'top']),
+    offset: PropTypes.number,
+    position: PropTypes.oneOf(['bottom', 'none', 'top']),
     reverse: PropTypes.bool,
     scaleType: PropTypes.oneOf(['band']),
     slotProps: PropTypes.object,
@@ -291,6 +273,7 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
     sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
     tickInterval: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.array, PropTypes.func]),
     tickLabelInterval: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.func]),
+    tickLabelMinGap: PropTypes.number,
     tickLabelPlacement: PropTypes.oneOf(['middle', 'tick']),
     tickLabelStyle: PropTypes.object,
     tickMaxStep: PropTypes.number,
@@ -315,6 +298,7 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
    * An array of [[AxisConfig]] objects.
    */
   yAxis: PropTypes.arrayOf(PropTypes.shape({
+    axis: PropTypes.oneOf(['y']),
     barGapRatio: PropTypes.number,
     categoryGapRatio: PropTypes.number,
     classes: PropTypes.object,
@@ -345,7 +329,8 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
     labelStyle: PropTypes.object,
     max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
     min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-    position: PropTypes.oneOf(['left', 'right']),
+    offset: PropTypes.number,
+    position: PropTypes.oneOf(['left', 'none', 'right']),
     reverse: PropTypes.bool,
     scaleType: PropTypes.oneOf(['band']),
     slotProps: PropTypes.object,
@@ -362,6 +347,7 @@ process.env.NODE_ENV !== "production" ? Heatmap.propTypes = {
     tickPlacement: PropTypes.oneOf(['end', 'extremities', 'middle', 'start']),
     tickSize: PropTypes.number,
     valueFormatter: PropTypes.func,
+    width: PropTypes.number,
     zoom: PropTypes.oneOfType([PropTypes.shape({
       filterMode: PropTypes.oneOf(['discard', 'keep']),
       maxEnd: PropTypes.number,

package/modern/Heatmap/Heatmap.plugins.d.ts

@@ -0,0 +1,3 @@
+import { UseChartZAxisSignature, UseChartCartesianAxisSignature, UseChartInteractionSignature, UseChartHighlightSignature, ConvertSignaturesIntoPlugins } from '@mui/x-charts/internals';
+export type HeatmapPluginsSignatures = [UseChartZAxisSignature, UseChartCartesianAxisSignature<'heatmap'>, UseChartInteractionSignature, UseChartHighlightSignature];
+export declare const HEATMAP_PLUGINS: ConvertSignaturesIntoPlugins<HeatmapPluginsSignatures>;

package/modern/Heatmap/Heatmap.plugins.js

@@ -0,0 +1,2 @@
+import { useChartZAxis, useChartCartesianAxis, useChartInteraction, useChartHighlight } from '@mui/x-charts/internals';
+export const HEATMAP_PLUGINS = [useChartZAxis, useChartCartesianAxis, useChartInteraction, useChartHighlight];

package/modern/Heatmap/HeatmapItem.d.ts

@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { SeriesId } from '@mui/x-charts/internals';
+import { HeatmapClasses } from "./heatmapClasses.js";
+export interface HeatmapItemSlots {
+  /**
+   * The component that renders the heatmap cell.
+   * @default HeatmapCell
+   */
+  cell?: React.ElementType;
+}
+export interface HeatmapItemSlotProps {
+  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;
+}
+export interface HeatmapItemOwnerState {
+  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;
+}
+export { HeatmapItem };

package/modern/Heatmap/HeatmapItem.js

@@ -6,7 +6,7 @@ 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/context';
+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";
@@ -47,7 +47,11 @@ function HeatmapItem(props) {
       slots = {}
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
-  const getInteractionItemProps = useInteractionItemProps();
+  const interactionProps = useInteractionItemProps({
+    type: 'heatmap',
+    seriesId,
+    dataIndex
+  });
   const {
     isFaded,
     isHighlighted
@@ -67,11 +71,7 @@ function HeatmapItem(props) {
   const Cell = slots?.cell ?? HeatmapCell;
   const cellProps = useSlotProps({
     elementType: Cell,
-    additionalProps: _extends({}, getInteractionItemProps({
-      type: 'heatmap',
-      seriesId,
-      dataIndex
-    })),
+    additionalProps: interactionProps,
     externalForwardedProps: _extends({}, other),
     externalSlotProps: slotProps.cell,
     ownerState,

package/modern/Heatmap/HeatmapPlot.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+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;
+}
+export { HeatmapPlot };

package/modern/Heatmap/HeatmapPlot.js

@@ -3,14 +3,14 @@
 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 { useHeatmapSeriesContext } from "../hooks/useHeatmapSeries.js";
 import { HeatmapItem } from "./HeatmapItem.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 function HeatmapPlot(props) {
   const xScale = useXScale();
   const yScale = useYScale();
   const colorScale = useZColorScale();
-  const series = useHeatmapSeries();
+  const series = useHeatmapSeriesContext();
   const xDomain = xScale.domain();
   const yDomain = yScale.domain();
   if (!series || series.seriesOrder.length === 0) {

package/modern/Heatmap/HeatmapTooltip.d.ts

@@ -0,0 +1,8 @@
+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/modern/Heatmap/HeatmapTooltip.js

@@ -9,7 +9,7 @@ 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 { useHeatmapSeriesContext } from "../hooks/useHeatmapSeries.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const useUtilityClasses = ownerState => {
   const {
@@ -34,7 +34,7 @@ function DefaultHeatmapTooltipContent(props) {
   } = props;
   const xAxis = useXAxis();
   const yAxis = useYAxis();
-  const heatmapSeries = useHeatmapSeries();
+  const heatmapSeries = useHeatmapSeriesContext();
   const tooltipData = useItemTooltip();
   if (!tooltipData || !heatmapSeries || heatmapSeries.seriesOrder.length === 0) {
     return null;
@@ -52,10 +52,12 @@ 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
@@ -144,6 +146,8 @@ process.env.NODE_ENV !== "production" ? HeatmapTooltip.propTypes = {
   /**
    * The components used for each slot inside the Popper.
    * Either a string to use a HTML element or a component.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
    * @default {}
    */
   components: PropTypes.shape({
@@ -151,6 +155,8 @@ process.env.NODE_ENV !== "production" ? HeatmapTooltip.propTypes = {
   }),
   /**
    * The props used for each slot inside the Popper.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
    * @default {}
    */
   componentsProps: PropTypes.shape({

package/modern/Heatmap/heatmapClasses.d.ts

@@ -0,0 +1,11 @@
+export interface HeatmapClasses {
+  /** Styles applied to the heatmap cells. */
+  cell: string;
+  /** Styles applied to the cell element if highlighted. */
+  highlighted: string;
+  /** Styles applied to the cell element if faded. */
+  faded: string;
+}
+export type HeatmapClassKey = keyof HeatmapClasses;
+export declare function getHeatmapUtilityClass(slot: string): string;
+export declare const heatmapClasses: HeatmapClasses;

package/modern/Heatmap/index.d.ts

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