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

package/internals/plugins/useChartProZoom/useChartProZoom.types.d.ts

@@ -1,50 +1,44 @@
-import { AxisId, UseChartSeriesSignature, ChartPluginSignature, DefaultizedZoomOptions, UseChartCartesianAxisSignature, UseChartCartesianAxisDefaultizedParameters, ZoomData } from '@mui/x-charts/internals';
+import { UseChartSeriesSignature, ChartPluginSignature, UseChartCartesianAxisSignature, UseChartCartesianAxisDefaultizedParameters, ZoomData } from '@mui/x-charts/internals';
 export interface UseChartProZoomParameters {
-    /**
-     * The list of zoom data related to each axis.
-     */
-    initialZoom?: ZoomData[];
-    /**
-     * Callback fired when the zoom has changed.
-     *
-     * @param {ZoomData[]} zoomData Updated zoom data.
-     */
-    onZoomChange?: (zoomData: ZoomData[] | ((zoomData: ZoomData[]) => ZoomData[])) => void;
+  /**
+   * The list of zoom data related to each axis.
+   */
+  initialZoom?: ZoomData[];
+  /**
+   * Callback fired when the zoom has changed.
+   *
+   * @param {ZoomData[]} zoomData Updated zoom data.
+   */
+  onZoomChange?: (zoomData: ZoomData[] | ((zoomData: ZoomData[]) => ZoomData[])) => void;
 }
-export type UseChartProZoomDefaultizedParameters = UseChartProZoomParameters & UseChartCartesianAxisDefaultizedParameters & {
+export type UseChartProZoomDefaultizedParameters = UseChartProZoomParameters & UseChartCartesianAxisDefaultizedParameters;
+export interface UseChartProZoomState {
+  zoom: {
     /**
-     * The zoom options for each axis.
+     * Whether the user is currently interacting with the chart.
+     * This is useful to disable animations while the user is interacting.
      */
-    optionsLookup: Record<AxisId, DefaultizedZoomOptions>;
-};
-export interface UseChartProZoomState {
-    zoom: {
-        /**
-         * Whether the user is currently interacting with the chart.
-         * This is useful to disable animations while the user is interacting.
-         */
-        isInteracting: boolean;
-        /**
-         * Mapping of axis id to the zoom data.
-         */
-        zoomData: ZoomData[];
-    };
-}
-export interface UseChartProZoomPublicApi {
+    isInteracting: boolean;
     /**
-     * Set the zoom data state.
-     * @param {ZoomData[] | ((prev: ZoomData[]) => ZoomData[])} value  The new value. Can either be the new zoom data, or an updater function.
-     * @returns {void}
+     * Mapping of axis id to the zoom data.
      */
-    setZoomData: (value: ZoomData[] | ((prev: ZoomData[]) => ZoomData[])) => void;
+    zoomData: ZoomData[];
+  };
 }
-export interface UseChartProZoomInstance extends UseChartProZoomPublicApi {
+export interface UseChartProZoomPublicApi {
+  /**
+   * Set the zoom data state.
+   * @param {ZoomData[] | ((prev: ZoomData[]) => ZoomData[])} value  The new value. Can either be the new zoom data, or an updater function.
+   * @returns {void}
+   */
+  setZoomData: (value: ZoomData[] | ((prev: ZoomData[]) => ZoomData[])) => void;
 }
+export interface UseChartProZoomInstance extends UseChartProZoomPublicApi {}
 export type UseChartProZoomSignature = ChartPluginSignature<{
-    params: UseChartProZoomParameters;
-    defaultizedParams: UseChartProZoomDefaultizedParameters;
-    state: UseChartProZoomState;
-    publicAPI: UseChartProZoomPublicApi;
-    instance: UseChartProZoomInstance;
-    dependencies: [UseChartSeriesSignature, UseChartCartesianAxisSignature];
-}>;
+  params: UseChartProZoomParameters;
+  defaultizedParams: UseChartProZoomDefaultizedParameters;
+  state: UseChartProZoomState;
+  publicAPI: UseChartProZoomPublicApi;
+  instance: UseChartProZoomInstance;
+  dependencies: [UseChartSeriesSignature, UseChartCartesianAxisSignature];
+}>;

package/internals/plugins/useChartProZoom/useChartProZoom.types.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/internals/plugins/useChartProZoom/useChartProZoom.utils.d.ts

@@ -14,32 +14,32 @@ export declare function isSpanValid(minRange: number, maxRange: number, isZoomIn
  * Get the scale ratio and if it's a zoom in or out from a wheel event.
  */
 export declare function getWheelScaleRatio(event: WheelEvent, step: number): {
-    scaleRatio: number;
-    isZoomIn: boolean;
+  scaleRatio: number;
+  isZoomIn: boolean;
 };
 /**
  * Get the scale ratio and if it's a zoom in or out from a pinch gesture.
  */
 export declare function getPinchScaleRatio(curDiff: number, prevDiff: number, step: number): {
-    scaleRatio: number;
-    isZoomIn: boolean;
+  scaleRatio: number;
+  isZoomIn: boolean;
 };
 export declare function getDiff(eventCache: PointerEvent[]): number;
 /**
  * Get the ratio of the point in the horizontal center of the area.
  */
 export declare function getHorizontalCenterRatio(point: {
-    x: number;
-    y: number;
+  x: number;
+  y: number;
 }, area: {
-    left: number;
-    width: number;
+  left: number;
+  width: number;
 }): number;
 export declare function preventDefault(event: TouchEvent): void;
 export declare function getVerticalCenterRatio(point: {
-    x: number;
-    y: number;
+  x: number;
+  y: number;
 }, area: {
-    top: number;
-    height: number;
-}): number;
+  top: number;
+  height: number;
+}): number;

package/internals/plugins/useChartProZoom/useChartProZoom.utils.js

@@ -1,10 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDiff = getDiff;
+exports.getHorizontalCenterRatio = getHorizontalCenterRatio;
+exports.getPinchScaleRatio = getPinchScaleRatio;
+exports.getVerticalCenterRatio = getVerticalCenterRatio;
+exports.getWheelScaleRatio = getWheelScaleRatio;
+exports.isSpanValid = isSpanValid;
+exports.preventDefault = preventDefault;
+exports.zoomAtPoint = void 0;
 /**
  * Helper to get the range (in percents of a reference range) corresponding to a given scale.
  * @param centerRatio {number} The ratio of the point that should not move between the previous and next range.
  * @param scaleRatio {number} The target scale ratio.
  * @returns The range to display.
  */
-export const zoomAtPoint = (centerRatio, scaleRatio, currentZoomData, options) => {
+const zoomAtPoint = (centerRatio, scaleRatio, currentZoomData, options) => {
   const MIN_RANGE = options.minStart;
   const MAX_RANGE = options.maxEnd;
   const MIN_ALLOWED_SPAN = options.minSpan;
@@ -36,7 +49,8 @@ export const zoomAtPoint = (centerRatio, scaleRatio, currentZoomData, options) =
 /**
  * Checks if the new span is valid.
  */
-export function isSpanValid(minRange, maxRange, isZoomIn, option) {
+exports.zoomAtPoint = zoomAtPoint;
+function isSpanValid(minRange, maxRange, isZoomIn, option) {
   const newSpanPercent = maxRange - minRange;
   if (isZoomIn && newSpanPercent < option.minSpan || !isZoomIn && newSpanPercent > option.maxSpan) {
     return false;
@@ -63,7 +77,7 @@ function getMultiplier(event) {
 /**
  * Get the scale ratio and if it's a zoom in or out from a wheel event.
  */
-export function getWheelScaleRatio(event, step) {
+function getWheelScaleRatio(event, step) {
   const deltaY = -event.deltaY;
   const multiplier = getMultiplier(event);
   const scaledStep = step * multiplier * deltaY / 1000;
@@ -79,7 +93,7 @@ export function getWheelScaleRatio(event, step) {
 /**
  * Get the scale ratio and if it's a zoom in or out from a pinch gesture.
  */
-export function getPinchScaleRatio(curDiff, prevDiff, step) {
+function getPinchScaleRatio(curDiff, prevDiff, step) {
   const scaledStep = step / 1000;
   let scaleRatio = 0;
   let isZoomIn = false;
@@ -99,7 +113,7 @@ export function getPinchScaleRatio(curDiff, prevDiff, step) {
     isZoomIn
   };
 }
-export function getDiff(eventCache) {
+function getDiff(eventCache) {
   const [firstEvent, secondEvent] = eventCache;
   return Math.hypot(firstEvent.pageX - secondEvent.pageX, firstEvent.pageY - secondEvent.pageY);
 }
@@ -107,17 +121,17 @@ export function getDiff(eventCache) {
 /**
  * Get the ratio of the point in the horizontal center of the area.
  */
-export function getHorizontalCenterRatio(point, area) {
+function getHorizontalCenterRatio(point, area) {
   const {
     left,
     width
   } = area;
   return (point.x - left) / width;
 }
-export function preventDefault(event) {
+function preventDefault(event) {
   event.preventDefault();
 }
-export function getVerticalCenterRatio(point, area) {
+function getVerticalCenterRatio(point, area) {
   const {
     top,
     height

package/internals/utils/releaseInfo.d.ts

@@ -1 +1 @@
-export declare const getReleaseInfo: () => any;
+export declare const getReleaseInfo: () => any;

package/internals/utils/releaseInfo.js

@@ -1,13 +1,21 @@
-import ponyfillGlobal from '@mui/utils/ponyfillGlobal';
-export const getReleaseInfo = () => {
-  const releaseInfo = "MTczODg4MjgwMDAwMA==";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReleaseInfo = void 0;
+var _ponyfillGlobal = _interopRequireDefault(require("@mui/utils/ponyfillGlobal"));
+const getReleaseInfo = () => {
+  const releaseInfo = "MTczOTc0NjgwMDAwMA==";
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).
     // eslint-disable-next-line no-useless-concat
     if (releaseInfo === '__RELEASE' + '_INFO__') {
       // eslint-disable-next-line no-underscore-dangle
-      return ponyfillGlobal.__MUI_RELEASE_INFO__;
+      return _ponyfillGlobal.default.__MUI_RELEASE_INFO__;
     }
   }
   return releaseInfo;
-};
+};
+exports.getReleaseInfo = getReleaseInfo;

package/models/index.d.ts

@@ -1,2 +1,2 @@
 export type { ZoomData } from '@mui/x-charts/internals';
-export * from './seriesType';
+export * from "./seriesType/index.js";

package/models/index.js

@@ -1,2 +1,16 @@
-export * from "./seriesType/index.js";
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _seriesType = require("./seriesType");
+Object.keys(_seriesType).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _seriesType[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _seriesType[key];
+    }
+  });
+});

package/models/seriesType/heatmap.d.ts

@@ -2,28 +2,27 @@ import { DefaultizedProps } from '@mui/x-internals/types';
 import { CommonDefaultizedProps, CommonSeriesType, CartesianSeriesType } from '@mui/x-charts/internals';
 export type HeatmapValueType = [number, number, number];
 export interface HeatmapSeriesType extends Omit<CommonSeriesType<HeatmapValueType>, 'color'>, CartesianSeriesType {
-    type: 'heatmap';
-    /**
-     * Data associated to each bar.
-     */
-    data?: HeatmapValueType[];
-    /**
-     * The key used to retrieve data from the dataset.
-     */
-    dataKey?: string;
-    /**
-     * The label to display on the tooltip or the legend. It can be a string or a function.
-     */
-    label?: string | ((location: 'tooltip' | 'legend') => string);
+  type: 'heatmap';
+  /**
+   * Data associated to each bar.
+   */
+  data?: HeatmapValueType[];
+  /**
+   * The key used to retrieve data from the dataset.
+   */
+  dataKey?: string;
+  /**
+   * The label to display on the tooltip or the legend. It can be a string or a function.
+   */
+  label?: string | ((location: 'tooltip' | 'legend') => string);
 }
 /**
  * An object that allows to identify a single bar.
  * Used for item interaction
  */
 export type HeatmapItemIdentifier = {
-    type: 'heatmap';
-    seriesId: DefaultizedHeatmapSeriesType['id'];
-    dataIndex: number;
+  type: 'heatmap';
+  seriesId: DefaultizedHeatmapSeriesType['id'];
+  dataIndex: number;
 };
-export interface DefaultizedHeatmapSeriesType extends DefaultizedProps<HeatmapSeriesType, CommonDefaultizedProps> {
-}
+export interface DefaultizedHeatmapSeriesType extends DefaultizedProps<HeatmapSeriesType, CommonDefaultizedProps> {}

package/models/seriesType/heatmap.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/models/seriesType/index.d.ts

@@ -1 +1 @@
-export * from './heatmap';
+export * from "./heatmap.js";

package/models/seriesType/index.js

@@ -1 +1,16 @@
-export * from "./heatmap.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _heatmap = require("./heatmap");
+Object.keys(_heatmap).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _heatmap[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _heatmap[key];
+    }
+  });
+});

package/modern/BarChartPro/BarChartPro.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { BarChartProps } from '@mui/x-charts/BarChart';
+import { ChartContainerProProps } from "../ChartContainerPro/index.js";
+export interface BarChartProProps extends Omit<BarChartProps, 'apiRef'>, Omit<ChartContainerProProps<'bar'>, 'series' | 'plugins' | 'seriesConfig'> {}
+/**
+ * Demos:
+ *
+ * - [Bars](https://mui.com/x/react-charts/bars/)
+ * - [Bar demonstration](https://mui.com/x/react-charts/bar-demo/)
+ * - [Stacking](https://mui.com/x/react-charts/stacking/)
+ *
+ * API:
+ *
+ * - [BarChart API](https://mui.com/x/api/charts/bar-chart/)
+ */
+declare const BarChartPro: React.ForwardRefExoticComponent<BarChartProProps & React.RefAttributes<SVGSVGElement>>;
+export { BarChartPro };

package/modern/BarChartPro/BarChartPro.plugins.d.ts

@@ -0,0 +1,4 @@
+import { UseChartZAxisSignature, UseChartCartesianAxisSignature, UseChartInteractionSignature, UseChartHighlightSignature, ConvertSignaturesIntoPlugins } from '@mui/x-charts/internals';
+import { UseChartProZoomSignature } from "../internals/plugins/useChartProZoom/index.js";
+export type BarChartProPluginsSignatures = [UseChartZAxisSignature, UseChartCartesianAxisSignature<'bar'>, UseChartInteractionSignature, UseChartHighlightSignature, UseChartProZoomSignature];
+export declare const BAR_CHART_PRO_PLUGINS: ConvertSignaturesIntoPlugins<BarChartProPluginsSignatures>;

package/modern/BarChartPro/index.d.ts

@@ -0,0 +1 @@
+export * from "./BarChartPro.js";

package/modern/ChartContainerPro/ChartContainerPro.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { ChartsSurfaceProps } from '@mui/x-charts/ChartsSurface';
+import { ChartAnyPluginSignature, ChartSeriesType } from '@mui/x-charts/internals';
+import { AllPluginSignatures } from "../internals/plugins/allPlugins.js";
+import { ChartDataProviderProProps } from "../ChartDataProviderPro/index.js";
+export type ChartContainerProProps<TSeries extends ChartSeriesType = ChartSeriesType, TSignatures extends readonly ChartAnyPluginSignature[] = AllPluginSignatures<TSeries>> = ChartDataProviderProProps<TSeries, TSignatures> & ChartsSurfaceProps;
+type ChartContainerProComponent = <TSeries extends ChartSeriesType = ChartSeriesType, TSignatures extends readonly ChartAnyPluginSignature[] = AllPluginSignatures<TSeries>>(props: ChartContainerProProps<TSeries, TSignatures> & {
+  ref?: React.ForwardedRef<SVGSVGElement>;
+}) => React.JSX.Element;
+/**
+ * It sets up the data providers as well as the `<svg>` for the chart.
+ *
+ * This is a combination of both the `ChartDataProviderPro` and `ChartsSurface` components.
+ *
+ * Demos:
+ *
+ * - [Composition](https://mui.com/x/api/charts/composition/)
+ *
+ * API:
+ *
+ * - [ChartContainer API](https://mui.com/x/api/charts/chart-container/)
+ *
+ * @example
+ * ```jsx
+ * <ChartContainerPro
+ *   series={[{ label: "Label", type: "bar", data: [10, 20] }]}
+ *   xAxis={[{ data: ["A", "B"], scaleType: "band", id: "x-axis" }]}
+ * >
+ *    <BarPlot />
+ *    <ChartsXAxis position="bottom" axisId="x-axis" />
+ * </ChartContainerPro>
+ * ```
+ */
+declare const ChartContainerPro: ChartContainerProComponent;
+export { ChartContainerPro };

package/modern/ChartContainerPro/index.d.ts

@@ -0,0 +1,2 @@
+import "../typeOverloads/index.js";
+export * from "./ChartContainerPro.js";

package/modern/ChartContainerPro/index.js

@@ -1 +1,2 @@
+import "../typeOverloads/index.js";
 export * from "./ChartContainerPro.js";

package/modern/ChartContainerPro/useChartContainerProProps.d.ts

@@ -0,0 +1,9 @@
+import { ChartAnyPluginSignature, ChartSeriesType, UseChartContainerPropsReturnValue } from '@mui/x-charts/internals';
+import * as React from 'react';
+import { ChartDataProviderProps } from '@mui/x-charts/ChartDataProvider';
+import type { ChartContainerProProps } from './ChartContainerPro';
+import { AllPluginSignatures } from "../internals/plugins/allPlugins.js";
+export type UseChartContainerProPropsReturnValue<TSeries extends ChartSeriesType, TSignatures extends readonly ChartAnyPluginSignature[]> = Pick<UseChartContainerPropsReturnValue<TSeries, TSignatures>, 'chartsSurfaceProps' | 'children'> & {
+  chartDataProviderProProps: ChartDataProviderProps<TSeries, TSignatures>;
+};
+export declare const useChartContainerProProps: <TSeries extends ChartSeriesType = keyof import("@mui/x-charts/internals").ChartsSeriesConfig, TSignatures extends readonly ChartAnyPluginSignature[] = AllPluginSignatures<TSeries>>(props: ChartContainerProProps<TSeries, TSignatures>, ref: React.Ref<SVGSVGElement>) => UseChartContainerProPropsReturnValue<TSeries, TSignatures>;

package/modern/ChartDataProviderPro/ChartDataProviderPro.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { ChartSeriesType, ChartAnyPluginSignature, ChartProviderProps } from '@mui/x-charts/internals';
+import { ChartDataProviderProps } from '@mui/x-charts/ChartDataProvider';
+import { AllPluginSignatures } from "../internals/plugins/allPlugins.js";
+export type ChartDataProviderProProps<TSeries extends ChartSeriesType = ChartSeriesType, TSignatures extends readonly ChartAnyPluginSignature[] = AllPluginSignatures<TSeries>> = ChartDataProviderProps<TSeries, TSignatures> & Omit<ChartProviderProps<TSeries, TSignatures>['pluginParams'], 'children'>;
+/**
+ * Orchestrates the data providers for the chart components and hooks.
+ *
+ * Use this component if you have custom HTML components that need to access the chart data.
+ *
+ * Demos:
+ *
+ * - [Composition](https://mui.com/x/api/charts/composition/)
+ *
+ * API:
+ *
+ * - [ChartDataProviderPro API](https://mui.com/x/api/charts/chart-data-provider/)
+ *
+ * @example
+ * ```jsx
+ * <ChartDataProviderPro
+ *   series={[{ label: "Label", type: "bar", data: [10, 20] }]}
+ *   xAxis={[{ data: ["A", "B"], scaleType: "band", id: "x-axis" }]}
+ * >
+ *   <ChartsSurface>
+ *      <BarPlot />
+ *      <ChartsXAxis position="bottom" axisId="x-axis" />
+ *   </ChartsSurface>
+ *   {'Custom Legend Component'}
+ * </ChartDataProviderPro>
+ * ```
+ */
+declare function ChartDataProviderPro<TSeries extends ChartSeriesType = ChartSeriesType, TSignatures extends readonly ChartAnyPluginSignature[] = AllPluginSignatures<TSeries>>(props: ChartDataProviderProProps<TSeries, TSignatures>): React.JSX.Element;
+declare namespace ChartDataProviderPro {
+  var propTypes: any;
+}
+export { ChartDataProviderPro };

package/modern/ChartDataProviderPro/index.d.ts

@@ -0,0 +1,2 @@
+import "../typeOverloads/index.js";
+export * from "./ChartDataProviderPro.js";

package/modern/ChartDataProviderPro/index.js

@@ -1 +1,2 @@
+import "../typeOverloads/index.js";
 export * from "./ChartDataProviderPro.js";

package/modern/ChartDataProviderPro/useChartDataProviderProProps.d.ts

@@ -0,0 +1,8 @@
+import { ChartAnyPluginSignature, ChartSeriesType } from '@mui/x-charts/internals';
+import type { ChartDataProviderProProps } from './ChartDataProviderPro';
+import type { AllPluginSignatures } from '../internals/plugins/allPlugins';
+export declare const useChartDataProviderProProps: <TSeries extends ChartSeriesType = keyof import("@mui/x-charts/internals").ChartsSeriesConfig, TSignatures extends readonly ChartAnyPluginSignature[] = AllPluginSignatures<TSeries>>(props: ChartDataProviderProProps<TSeries, TSignatures>) => {
+  children: import("react").ReactNode;
+  animationProviderProps: Omit<import("@mui/x-charts/internals").AnimationProviderProps, "children">;
+  chartProviderProps: Omit<import("@mui/x-charts/internals").ChartProviderProps<TSeries, TSignatures>, "children">;
+};

package/modern/Heatmap/Heatmap.d.ts

@@ -0,0 +1,56 @@
+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";
+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, 'series' | 'plugins' | 'xAxis' | 'yAxis' | 'zoom' | 'onZoomChange' | '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: 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: MakeOptional<AxisConfig<'band', any, ChartsYAxisProps>, 'id' | 'scaleType'>[];
+  /**
+   * The series to display in the bar chart.
+   * An array of [[HeatmapSeriesType]] objects.
+   */
+  series: 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

@@ -11,14 +11,14 @@ import { ChartsClipPath } from '@mui/x-charts/ChartsClipPath';
 import { ChartsOverlay } from '@mui/x-charts/ChartsOverlay';
 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
 };
 const Heatmap = /*#__PURE__*/React.forwardRef(function Heatmap(inProps, ref) {
   const props = useThemeProps({

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/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/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 };