@mui/x-charts-pro 9.0.0-alpha.0 → 9.0.0-alpha.2

package/esm/Heatmap/HeatmapPlot.js

@@ -1,39 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["borderRadius"];
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { HeatmapSVGPlot } from "./HeatmapSVGPlot.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-function HeatmapPlot(_ref) {
-  let {
-      borderRadius
-    } = _ref,
-    props = _objectWithoutPropertiesLoose(_ref, _excluded);
-  return /*#__PURE__*/_jsx(HeatmapSVGPlot, _extends({
-    borderRadius: borderRadius
-  }, props));
-}
-process.env.NODE_ENV !== "production" ? HeatmapPlot.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  /**
-   * The border radius of the heatmap cells in pixels.
-   */
-  borderRadius: PropTypes.number,
-  /**
-   * The props used for each component slot.
-   * @default {}
-   */
-  slotProps: PropTypes.object,
-  /**
-   * Overridable component slots.
-   * @default {}
-   */
-  slots: PropTypes.object
-} : void 0;
-export { HeatmapPlot };

package/esm/Heatmap/HeatmapSVGPlot.d.ts

@@ -1,2 +0,0 @@
-import { type HeatmapRendererPlotProps } from "./Heatmap.types.js";
-export declare function HeatmapSVGPlot(props: HeatmapRendererPlotProps): import("react/jsx-runtime").JSX.Element | null;

package/esm/Heatmap/HeatmapSVGPlot.js

@@ -1,64 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { useXScale, useYScale, useZColorScale } from '@mui/x-charts/hooks';
-import { selectorChartsIsFadedCallback, selectorChartsIsHighlightedCallback, useStore, useRegisterPointerInteractions } from '@mui/x-charts/internals';
-import { useHeatmapSeriesContext } from "../hooks/index.js";
-import { HeatmapItem } from "./HeatmapItem.js";
-import { selectorHeatmapItemAtPosition } from "../plugins/selectors/useChartHeatmapPosition.selectors.js";
-import { shouldRegisterPointerInteractionsGlobally } from "./shouldRegisterPointerInteractionsGlobally.js";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const MemoHeatmapItem = /*#__PURE__*/React.memo(HeatmapItem);
-if (process.env.NODE_ENV !== "production") MemoHeatmapItem.displayName = "MemoHeatmapItem";
-export function HeatmapSVGPlot(props) {
-  const store = useStore();
-  const xScale = useXScale();
-  const yScale = useYScale();
-  const colorScale = useZColorScale();
-  const series = useHeatmapSeriesContext();
-  const isHighlighted = store.use(selectorChartsIsHighlightedCallback);
-  const isFaded = store.use(selectorChartsIsFadedCallback);
-  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__*/_jsxs(React.Fragment, {
-    children: [shouldRegisterPointerInteractionsGlobally(props.slots, props.slotProps) ? /*#__PURE__*/_jsx(RegisterHeatmapPointerInteractions, {}) : null, /*#__PURE__*/_jsx("g", {
-      children: seriesToDisplay.data.map(([xIndex, yIndex, value], dataIndex) => {
-        const x = xScale(xDomain[xIndex]);
-        const y = yScale(yDomain[yIndex]);
-        const color = colorScale?.(value);
-        if (x === undefined || y === undefined || !color) {
-          return null;
-        }
-        const item = {
-          seriesId: seriesToDisplay.id,
-          dataIndex
-        };
-        return /*#__PURE__*/_jsx(MemoHeatmapItem, {
-          width: xScale.bandwidth(),
-          height: yScale.bandwidth(),
-          x: x,
-          y: y,
-          xIndex: xIndex,
-          yIndex: yIndex,
-          color: color,
-          dataIndex: dataIndex,
-          seriesId: series.seriesOrder[0],
-          value: value,
-          slots: props.slots,
-          slotProps: props.slotProps,
-          isHighlighted: isHighlighted(item),
-          isFaded: isFaded(item),
-          borderRadius: props.borderRadius
-        }, `${xIndex}_${yIndex}`);
-      })
-    })]
-  });
-}
-function RegisterHeatmapPointerInteractions() {
-  useRegisterPointerInteractions(selectorHeatmapItemAtPosition);
-  return null;
-}

package/esm/Heatmap/HeatmapTooltip/HeatmapTooltip.classes.d.ts

@@ -1,2 +0,0 @@
-import { type HeatmapTooltipProps } from "./HeatmapTooltip.types.js";
-export declare const useUtilityClasses: (props: Pick<HeatmapTooltipProps, "classes">) => Record<"mark" | "table" | "cell" | "row" | "root" | "paper" | "markContainer" | "labelCell" | "valueCell", string>;

package/esm/Heatmap/HeatmapTooltip/HeatmapTooltip.d.ts

@@ -1,6 +0,0 @@
-import { type HeatmapTooltipProps } from "./HeatmapTooltip.types.js";
-declare function HeatmapTooltip(props: HeatmapTooltipProps): import("react/jsx-runtime").JSX.Element;
-declare namespace HeatmapTooltip {
-  var propTypes: any;
-}
-export { HeatmapTooltip };

package/esm/Heatmap/HeatmapTooltip/HeatmapTooltip.js

@@ -1,194 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import PropTypes from 'prop-types';
-import HTMLElementType from '@mui/utils/HTMLElementType';
-import { ChartsTooltipContainer } from '@mui/x-charts/ChartsTooltip';
-import { HeatmapTooltipContent } from "./HeatmapTooltipContent.js";
-import { useUtilityClasses } from "./HeatmapTooltip.classes.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-function HeatmapTooltip(props) {
-  const classes = useUtilityClasses({
-    classes: props.classes
-  });
-  return /*#__PURE__*/_jsx(ChartsTooltipContainer, _extends({
-    trigger: "item"
-  }, props, {
-    classes: classes,
-    children: /*#__PURE__*/_jsx(HeatmapTooltipContent, {
-      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"  |
-  // ----------------------------------------------------------------------
-  /**
-   * Determine if the tooltip should be placed on the pointer location or on the node.
-   * @default 'pointer'
-   */
-  anchor: PropTypes.oneOf(['node', 'pointer']),
-  /**
-   * 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 /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.object, PropTypes.func]),
-  /**
-   * 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.
-   *
-   * @deprecated use the `slots` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
-   * @default {}
-   */
-  components: PropTypes.shape({
-    Root: PropTypes.elementType
-  }),
-  /**
-   * The props used for each slot inside the Popper.
-   *
-   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
-   * @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
-    })
-  })]),
-  /**
-   * Determines the tooltip position relatively to the anchor.
-   */
-  position: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
-  /**
-   * The props used for each slot inside the Popper.
-   * @default {}
-   */
-  slotProps: PropTypes.object,
-  /**
-   * The components used for each slot inside the Popper.
-   * Either a string to use a HTML element or a component.
-   * @default {}
-   */
-  slots: PropTypes.object,
-  /**
-   * The system prop that allows defining system overrides as well as additional CSS styles.
-   */
-  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
-  /**
-   * Help supporting a react-transition-group/Transition component.
-   * @default false
-   */
-  transition: PropTypes.bool,
-  /**
-   * Select the kind of tooltip to display
-   * - 'item': Shows data about the item below the mouse.
-   * - 'none': Does not display tooltip
-   * @default 'item'
-   */
-  trigger: PropTypes.oneOf(['item', 'none'])
-} : void 0;
-export { HeatmapTooltip };

package/esm/Heatmap/HeatmapTooltip/HeatmapTooltip.types.d.ts

@@ -1,14 +0,0 @@
-import { type ChartsTooltipContainerProps, type ChartsTooltipClasses, type ChartsTooltipSlots, type ChartsTooltipSlotProps } from '@mui/x-charts/ChartsTooltip';
-export interface HeatmapTooltipSlots extends ChartsTooltipSlots {}
-export interface HeatmapTooltipSlotProps extends ChartsTooltipSlotProps {}
-export interface HeatmapTooltipClasses extends ChartsTooltipClasses {}
-export interface HeatmapTooltipContentClasses extends ChartsTooltipClasses {}
-export interface HeatmapTooltipProps extends Omit<ChartsTooltipContainerProps, 'trigger' | 'children'> {
-  /**
-   * Select the kind of tooltip to display
-   * - 'item': Shows data about the item below the mouse.
-   * - 'none': Does not display tooltip
-   * @default 'item'
-   */
-  trigger?: 'item' | 'none';
-}

package/esm/Heatmap/HeatmapTooltip/HeatmapTooltipContent.d.ts

@@ -1,6 +0,0 @@
-import { type HeatmapTooltipProps } from "./HeatmapTooltip.types.js";
-export interface HeatmapTooltipContentProps extends Pick<HeatmapTooltipProps, 'classes'> {}
-export declare function HeatmapTooltipContent(props: HeatmapTooltipContentProps): import("react/jsx-runtime").JSX.Element | null;
-export declare namespace HeatmapTooltipContent {
-  var propTypes: any;
-}

package/esm/Heatmap/HeatmapTooltip/HeatmapTooltipContent.js

@@ -1,88 +0,0 @@
-'use client';
-
-import PropTypes from 'prop-types';
-import clsx from 'clsx';
-import { ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipRow, ChartsTooltipCell, useItemTooltip } from '@mui/x-charts/ChartsTooltip';
-import { useXAxis, useYAxis } from '@mui/x-charts/hooks';
-import { getLabel, ChartsLabelMark } from '@mui/x-charts/internals';
-import { useHeatmapSeriesContext } from "../../hooks/useHeatmapSeries.js";
-import { HeatmapTooltipAxesValue } from "./HeatmapTooltipAxesValue.js";
-import { useUtilityClasses } from "./HeatmapTooltip.classes.js";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-export function HeatmapTooltipContent(props) {
-  const classes = useUtilityClasses(props);
-  const xAxis = useXAxis();
-  const yAxis = useYAxis();
-  const heatmapSeries = useHeatmapSeriesContext();
-  const tooltipData = useItemTooltip();
-  const dataIndex = tooltipData?.identifier.dataIndex;
-  if (!tooltipData || dataIndex === undefined || !heatmapSeries || heatmapSeries.seriesOrder.length === 0) {
-    return null;
-  }
-  const {
-    series,
-    seriesOrder
-  } = heatmapSeries;
-  const seriesId = seriesOrder[0];
-  const {
-    color,
-    value,
-    markType
-  } = tooltipData;
-  const [xIndex, yIndex] = value;
-  const formattedX = xAxis.valueFormatter?.(xAxis.data[xIndex], {
-    location: 'tooltip',
-    scale: xAxis.scale
-  }) ?? xAxis.data[xIndex].toLocaleString();
-  const formattedY = yAxis.valueFormatter?.(yAxis.data[yIndex], {
-    location: 'tooltip',
-    scale: yAxis.scale
-  }) ?? yAxis.data[yIndex].toLocaleString();
-  const formattedValue = series[seriesId].valueFormatter(value, {
-    dataIndex
-  });
-  const seriesLabel = getLabel(series[seriesId].label, 'tooltip');
-  return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
-    className: classes.paper,
-    children: /*#__PURE__*/_jsxs(ChartsTooltipTable, {
-      className: classes.table,
-      children: [/*#__PURE__*/_jsxs(HeatmapTooltipAxesValue, {
-        children: [/*#__PURE__*/_jsx("span", {
-          children: formattedX
-        }), /*#__PURE__*/_jsx("span", {
-          children: formattedY
-        })]
-      }), /*#__PURE__*/_jsx("tbody", {
-        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
-          className: classes.row,
-          children: [/*#__PURE__*/_jsxs(ChartsTooltipCell, {
-            className: clsx(classes.labelCell, classes.cell),
-            component: "th",
-            children: [/*#__PURE__*/_jsx("div", {
-              className: classes.markContainer,
-              children: /*#__PURE__*/_jsx(ChartsLabelMark, {
-                type: markType,
-                color: color,
-                className: classes.mark
-              })
-            }), seriesLabel]
-          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
-            className: clsx(classes.valueCell, classes.cell),
-            component: "td",
-            children: formattedValue
-          })]
-        })
-      })]
-    })
-  });
-}
-process.env.NODE_ENV !== "production" ? HeatmapTooltipContent.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;

package/esm/Heatmap/HeatmapTooltip/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./HeatmapTooltip.js";
-export * from "./HeatmapTooltipContent.js";
-export type { HeatmapTooltipProps, HeatmapTooltipClasses, HeatmapTooltipContentClasses, HeatmapTooltipSlots, HeatmapTooltipSlotProps } from "./HeatmapTooltip.types.js";

package/esm/Heatmap/HeatmapTooltip/index.js

@@ -1,3 +0,0 @@
-export * from "./HeatmapTooltip.js";
-export * from "./HeatmapTooltipContent.js";
-export {};

package/esm/Heatmap/heatmapClasses.d.ts

@@ -1,16 +0,0 @@
-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;
-  /**
-   * Styles applied to the root element for a specified series.
-   * Needs to be suffixed with the series ID: `.${heatmapClasses.series}-${seriesId}`.
-   */
-  series: string;
-}
-export type HeatmapClassKey = keyof HeatmapClasses;
-export declare function getHeatmapUtilityClass(slot: string): string;
-export declare const heatmapClasses: HeatmapClasses;

package/esm/Heatmap/index.d.ts

@@ -1,9 +0,0 @@
-export { Heatmap } from "./Heatmap.js";
-export type { HeatmapSeries, HeatmapProps, HeatmapSlots, HeatmapSlotProps } from "./Heatmap.js";
-export { HeatmapPlot, type HeatmapPlotProps } from "./HeatmapPlot.js";
-export type { HeatmapPlotSlots, HeatmapPlotSlotProps } from "./Heatmap.types.js";
-export * from "./FocusedHeatmapCell.js";
-export type { HeatmapCellProps } from "./internals/HeatmapCell.js";
-export * from "./HeatmapTooltip/index.js";
-export * from "./Heatmap.plugins.js";
-export * from "./heatmapClasses.js";

package/esm/Heatmap/index.js

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

package/esm/Heatmap/internals/HeatmapCell.d.ts

@@ -1,21 +0,0 @@
-import type * as React from 'react';
-import type { SeriesId } from '@mui/x-charts/models';
-import type { HeatmapClasses } from "../heatmapClasses.js";
-export interface HeatmapItemOwnerState {
-  seriesId: SeriesId;
-  dataIndex: number;
-  color: string;
-  isFaded: boolean;
-  isHighlighted: boolean;
-  classes?: Partial<HeatmapClasses>;
-}
-export interface HeatmapCellProps extends React.ComponentPropsWithRef<'rect'> {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  ownerState: HeatmapItemOwnerState;
-}
-export declare const HeatmapCell: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & {
-  ownerState: HeatmapItemOwnerState;
-}, Pick<React.SVGProps<SVGRectElement>, keyof React.SVGProps<SVGRectElement>>, {}>;

package/esm/Heatmap/seriesConfig/getItemAtPosition.d.ts

@@ -1,6 +0,0 @@
-import type { ChartState, UseChartCartesianAxisSignature } from '@mui/x-charts/internals';
-import type { SeriesItemIdentifier } from '@mui/x-charts/models';
-export default function getItemAtPosition(state: ChartState<[UseChartCartesianAxisSignature]>, point: {
-  x: number;
-  y: number;
-}): SeriesItemIdentifier<'heatmap'> | undefined;

package/esm/Heatmap/seriesConfig/index.js

@@ -1,24 +0,0 @@
-import { cartesianSeriesTypes, identifierSerializerSeriesIdDataIndex, identifierCleanerSeriesIdDataIndex } from '@mui/x-charts/internals';
-import { getBaseExtremum } from "./extremums.js";
-import seriesProcessor from "./seriesProcessor.js";
-import getColor from "./getColor.js";
-import tooltipGetter from "./tooltip.js";
-import getSeriesWithDefaultValues from "./getSeriesWithDefaultValues.js";
-import tooltipItemPositionGetter from "./tooltipPosition.js";
-import getItemAtPosition from "./getItemAtPosition.js";
-import keyboardFocusHandler from "./keyboardFocusHandler.js";
-cartesianSeriesTypes.addType('heatmap');
-export const heatmapSeriesConfig = {
-  seriesProcessor,
-  colorProcessor: getColor,
-  legendGetter: () => [],
-  tooltipGetter,
-  tooltipItemPositionGetter,
-  xExtremumGetter: getBaseExtremum,
-  yExtremumGetter: getBaseExtremum,
-  getSeriesWithDefaultValues,
-  identifierSerializer: identifierSerializerSeriesIdDataIndex,
-  identifierCleaner: identifierCleanerSeriesIdDataIndex,
-  getItemAtPosition,
-  keyboardFocusHandler
-};

package/esm/Heatmap/shouldRegisterPointerInteractionsGlobally.d.ts

@@ -1,2 +0,0 @@
-import { type HeatmapPlotProps } from "./HeatmapPlot.js";
-export declare function shouldRegisterPointerInteractionsGlobally(slots: HeatmapPlotProps['slots'], slotProps: HeatmapPlotProps['slotProps']): boolean;

package/esm/Heatmap/shouldRegisterPointerInteractionsGlobally.js

@@ -1,13 +0,0 @@
-import { HeatmapCell } from "./internals/HeatmapCell.js";
-
-/* Global pointer interactions should be registered when we're using the default HeatmapCell.
- * We only want to return false when a custom slot is being used to avoid breaking changes.
- *
- * This can be removed in v9. */
-export function shouldRegisterPointerInteractionsGlobally(slots, slotProps) {
-  // If 'onPointerEnter' is defined in the slotProps, we don't want to register globally.
-  if ('onPointerEnter' in (slotProps?.cell ?? {})) {
-    return false;
-  }
-  return slots === undefined || slots.cell === HeatmapCell;
-}

package/esm/Heatmap/useHeatmapProps.d.ts

@@ -1,24 +0,0 @@
-import { type ChartsWrapperProps } from '@mui/x-charts/ChartsWrapper';
-import * as React from 'react';
-import { type ChartsLegendProps, type ChartsLegendSlotExtension } from '@mui/x-charts/ChartsLegend';
-import type { ChartsOverlayProps } from '@mui/x-charts/ChartsOverlay';
-import { type ChartsClipPathProps } from '@mui/x-charts/ChartsClipPath';
-import type { ChartsAxisProps } from '@mui/x-charts/ChartsAxis';
-import { type HeatmapPluginSignatures } from "./Heatmap.plugins.js";
-import { type HeatmapProps } from "./Heatmap.js";
-import { type ChartDataProviderProProps } from "../ChartDataProviderPro/index.js";
-import { type HeatmapPlotProps } from "./HeatmapPlot.js";
-export type UseHeatmapProps = HeatmapProps;
-export declare function useHeatmapProps(props: UseHeatmapProps): {
-  chartDataProviderProProps: ChartDataProviderProProps<"heatmap", HeatmapPluginSignatures>;
-  chartsWrapperProps: Omit<ChartsWrapperProps, "children">;
-  heatmapPlotProps: HeatmapPlotProps;
-  clipPathProps: ChartsClipPathProps;
-  clipPathGroupProps: {
-    clipPath: string;
-  };
-  overlayProps: ChartsOverlayProps;
-  chartsAxisProps: ChartsAxisProps;
-  legendProps: ChartsLegendProps | ChartsLegendSlotExtension;
-  children: React.ReactNode;
-};