@mui/x-charts 8.0.0-alpha.0 → 8.0.0-alpha.2

package/ChartsTooltip/ChartsTooltipContainer.js

@@ -0,0 +1,280 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["trigger", "classes", "children"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import HTMLElementType from '@mui/utils/HTMLElementType';
+import useLazyRef from '@mui/utils/useLazyRef';
+import { styled, useThemeProps } from '@mui/material/styles';
+import Popper from '@mui/material/Popper';
+import NoSsr from '@mui/material/NoSsr';
+import { useSvgRef } from "../hooks/useSvgRef.js";
+import { usePointerType } from "./utils.js";
+import { useSelector } from "../internals/store/useSelector.js";
+import { useStore } from "../internals/store/useStore.js";
+import { useXAxis } from "../hooks/index.js";
+import { selectorChartsInteractionItemIsDefined, selectorChartsInteractionXAxisIsDefined, selectorChartsInteractionYAxisIsDefined } from "../internals/plugins/featurePlugins/useChartInteraction/index.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const ChartsTooltipRoot = styled(Popper, {
+  name: 'MuiChartsTooltip',
+  slot: 'Root',
+  overridesResolver: (_, styles) => styles.root
+})(({
+  theme
+}) => ({
+  pointerEvents: 'none',
+  zIndex: theme.zIndex.modal
+}));
+
+/**
+ * Demos:
+ *
+ * - [ChartsTooltip](https://mui.com/x/react-charts/tooltip/)
+ *
+ * API:
+ *
+ * - [ChartsTooltip API](https://mui.com/x/api/charts/charts-tool-tip/)
+ */
+function ChartsTooltipContainer(inProps) {
+  const props = useThemeProps({
+    props: inProps,
+    name: 'MuiChartsTooltipContainer'
+  });
+  const {
+      trigger = 'axis',
+      classes,
+      children
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const svgRef = useSvgRef();
+  const pointerType = usePointerType();
+  const xAxis = useXAxis();
+  const xAxisHasData = xAxis.data !== undefined && xAxis.data.length !== 0;
+  const popperRef = React.useRef(null);
+  const positionRef = useLazyRef(() => ({
+    x: 0,
+    y: 0
+  }));
+  const store = useStore();
+  const isOpen = useSelector(store,
+  // eslint-disable-next-line no-nested-ternary
+  trigger === 'axis' ? xAxisHasData ? selectorChartsInteractionXAxisIsDefined : selectorChartsInteractionYAxisIsDefined : selectorChartsInteractionItemIsDefined);
+  const popperOpen = pointerType !== null && isOpen; // tooltipHasData;
+
+  React.useEffect(() => {
+    const element = svgRef.current;
+    if (element === null) {
+      return () => {};
+    }
+    const handleMove = event => {
+      // eslint-disable-next-line react-compiler/react-compiler
+      positionRef.current = {
+        x: event.clientX,
+        y: event.clientY
+      };
+      popperRef.current?.update();
+    };
+    element.addEventListener('pointermove', handleMove);
+    return () => {
+      element.removeEventListener('pointermove', handleMove);
+    };
+  }, [svgRef, positionRef]);
+  if (trigger === 'none') {
+    return null;
+  }
+  return /*#__PURE__*/_jsx(NoSsr, {
+    children: popperOpen && /*#__PURE__*/_jsx(ChartsTooltipRoot, _extends({
+      className: classes?.root,
+      open: popperOpen,
+      placement: pointerType?.pointerType === 'mouse' ? 'right-start' : 'top',
+      popperRef: popperRef,
+      anchorEl: {
+        getBoundingClientRect: () => ({
+          x: positionRef.current.x,
+          y: positionRef.current.y,
+          top: positionRef.current.y,
+          left: positionRef.current.x,
+          right: positionRef.current.x,
+          bottom: positionRef.current.y,
+          width: 0,
+          height: 0,
+          toJSON: () => ''
+        })
+      },
+      modifiers: [{
+        name: 'offset',
+        options: {
+          offset: [0, pointerType?.pointerType === 'touch' ? 40 - pointerType.height : 0]
+        }
+      }]
+    }, other, {
+      children: children
+    }))
+  });
+}
+process.env.NODE_ENV !== "production" ? ChartsTooltipContainer.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 /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.object, PropTypes.func]),
+  /**
+   * Popper render function or node.
+   */
+  children: PropTypes.node,
+  /**
+   * 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,
+  /**
+   * Select the kind of tooltip to display
+   * - 'item': Shows data about the item below the mouse.
+   * - 'axis': Shows values associated with the hovered x value
+   * - 'none': Does not display tooltip
+   * @default 'axis'
+   */
+  trigger: PropTypes.oneOf(['axis', 'item', 'none'])
+} : void 0;
+export { ChartsTooltipContainer };

package/ChartsTooltip/ChartsTooltipTable.js

@@ -1,5 +1,5 @@
 import { styled } from '@mui/material/styles';
-import { shouldForwardProp } from '@mui/system';
+import { shouldForwardProp } from '@mui/system/createStyled';
 import { chartsTooltipClasses } from "./chartsTooltipClasses.js";
 
 /**

package/ChartsTooltip/chartsTooltipClasses.d.ts

@@ -21,3 +21,4 @@ export interface ChartsTooltipClasses {
 export type ChartsTooltipClassKey = keyof Omit<ChartsTooltipClasses, 'markCell' | 'labelCell' | 'valueCell'>;
 export declare function getChartsTooltipUtilityClass(slot: string): string;
 export declare const chartsTooltipClasses: ChartsTooltipClasses;
+export declare const useUtilityClasses: (classes?: Partial<ChartsTooltipClasses>) => Record<"cell" | "table" | "row" | "mark" | "root" | "paper" | "markCell" | "labelCell" | "valueCell", string>;

package/ChartsTooltip/chartsTooltipClasses.js

@@ -1,5 +1,21 @@
-import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
+import generateUtilityClass from '@mui/utils/generateUtilityClass';
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import composeClasses from '@mui/utils/composeClasses';
 export function getChartsTooltipUtilityClass(slot) {
   return generateUtilityClass('MuiChartsTooltip', slot);
 }
-export const chartsTooltipClasses = generateUtilityClasses('MuiChartsTooltip', ['root', 'paper', 'table', 'row', 'cell', 'mark', 'markCell', 'labelCell', 'valueCell']);
+export const chartsTooltipClasses = generateUtilityClasses('MuiChartsTooltip', ['root', 'paper', 'table', 'row', 'cell', 'mark', 'markCell', 'labelCell', 'valueCell']);
+export const useUtilityClasses = classes => {
+  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);
+};

package/ChartsTooltip/index.d.ts

@@ -1,9 +1,9 @@
 export * from './ChartsTooltip';
-export * from './chartsTooltipClasses';
+export * from './ChartsTooltipContainer';
+export type { ChartsTooltipClasses, ChartsTooltipClassKey } from './chartsTooltipClasses';
+export { getChartsTooltipUtilityClass, chartsTooltipClasses } from './chartsTooltipClasses';
 export * from './ChartsAxisTooltipContent';
 export * from './ChartsItemTooltipContent';
-export * from './DefaultChartsAxisTooltipContent';
-export * from './DefaultChartsItemTooltipContent';
 export * from './ChartsTooltipTable';
 export * from './useItemTooltip';
 export * from './useAxisTooltip';

package/ChartsTooltip/index.js

@@ -1,9 +1,8 @@
 export * from "./ChartsTooltip.js";
-export * from "./chartsTooltipClasses.js";
+export * from "./ChartsTooltipContainer.js";
+export { getChartsTooltipUtilityClass, chartsTooltipClasses } from "./chartsTooltipClasses.js";
 export * from "./ChartsAxisTooltipContent.js";
 export * from "./ChartsItemTooltipContent.js";
-export * from "./DefaultChartsAxisTooltipContent.js";
-export * from "./DefaultChartsItemTooltipContent.js";
 export * from "./ChartsTooltipTable.js";
 export * from "./useItemTooltip.js";
 export * from "./useAxisTooltip.js";

package/ChartsTooltip/useAxisTooltip.d.ts

@@ -1,8 +1,8 @@
-import { AxisInteractionData } from '../context/InteractionProvider';
 import { SeriesId } from '../models/seriesType/common';
 import { CartesianChartSeriesType, ChartsSeriesConfig } from '../models/seriesType/config';
 export interface UseAxisTooltipReturnValue<SeriesT extends CartesianChartSeriesType = CartesianChartSeriesType, AxisValueT extends string | number | Date = string | number | Date> {
-    identifier: AxisInteractionData;
+    axisDirection: 'x' | 'y';
+    dataIndex: number;
     seriesItems: SeriesItem<SeriesT>[];
     axisValue: AxisValueT;
     axisFormattedValue: string;

package/ChartsTooltip/useAxisTooltip.js

@@ -1,34 +1,33 @@
 'use client';
 
 import * as React from 'react';
-import { InteractionContext } from "../context/InteractionProvider.js";
 import { useSeries } from "../hooks/useSeries.js";
 import { useCartesianContext } from "../context/CartesianProvider/index.js";
 import { ZAxisContext } from "../context/ZAxisContextProvider.js";
 import { useColorProcessor } from "../context/PluginProvider/useColorProcessor.js";
+import { useStore } from "../internals/store/useStore.js";
+import { useSelector } from "../internals/store/useSelector.js";
 import { getLabel } from "../internals/getLabel.js";
 import { isCartesianSeriesType } from "../internals/isCartesian.js";
 import { utcFormatter } from "./utils.js";
+import { useXAxis, useYAxis } from "../hooks/useAxis.js";
+import { selectorChartsInteractionXAxis, selectorChartsInteractionYAxis } from "../internals/plugins/featurePlugins/useChartInteraction/index.js";
 export function useAxisTooltip() {
-  const {
-    axis
-  } = React.useContext(InteractionContext);
+  const defaultXAxis = useXAxis();
+  const defaultYAxis = useYAxis();
+  const xAxisHasData = defaultXAxis.data !== undefined && defaultXAxis.data.length !== 0;
+  const store = useStore();
+  const axisData = useSelector(store, xAxisHasData ? selectorChartsInteractionXAxis : selectorChartsInteractionYAxis);
   const series = useSeries();
   const {
     xAxis,
-    yAxis,
-    xAxisIds,
-    yAxisIds
+    yAxis
   } = useCartesianContext();
   const {
     zAxis,
     zAxisIds
   } = React.useContext(ZAxisContext);
   const colorProcessors = useColorProcessor();
-
-  // By default use the x-axis
-  const isXaxis = axis.x !== null && axis.x.index !== -1;
-  const axisData = isXaxis ? axis.x && axis.x : axis.y && axis.y;
   if (axisData === null) {
     return null;
   }
@@ -36,8 +35,8 @@ export function useAxisTooltip() {
     index: dataIndex,
     value: axisValue
   } = axisData;
-  const USED_AXIS_ID = isXaxis ? xAxisIds[0] : yAxisIds[0];
-  const usedAxis = isXaxis ? xAxis[USED_AXIS_ID] : yAxis[USED_AXIS_ID];
+  const USED_AXIS_ID = xAxisHasData ? defaultXAxis.id : defaultYAxis.id;
+  const usedAxis = xAxisHasData ? defaultXAxis : defaultYAxis;
   const relevantSeries = Object.keys(series).filter(isCartesianSeriesType).flatMap(seriesType => {
     const seriesOfType = series[seriesType];
     if (!seriesOfType) {
@@ -47,14 +46,14 @@ export function useAxisTooltip() {
       const seriesToAdd = seriesOfType.series[seriesId];
       const providedXAxisId = seriesToAdd.xAxisId;
       const providedYAxisId = seriesToAdd.yAxisId;
-      const axisKey = isXaxis ? providedXAxisId : providedYAxisId;
+      const axisKey = xAxisHasData ? providedXAxisId : providedYAxisId;
 
       // Test if the series uses the default axis
       if (axisKey === undefined || axisKey === USED_AXIS_ID) {
-        const xAxisId = providedXAxisId ?? xAxisIds[0];
-        const yAxisId = providedYAxisId ?? yAxisIds[0];
-        const zAxisId = seriesToAdd.zAxisId ?? zAxisIds[0];
-        const color = colorProcessors[seriesType]?.(seriesToAdd, xAxis[xAxisId], yAxis[yAxisId], zAxisId && zAxis[zAxisId])(dataIndex) ?? '';
+        const xAxisId = providedXAxisId ?? defaultXAxis.id;
+        const yAxisId = providedYAxisId ?? defaultYAxis.id;
+        const zAxisId = 'zAxisId' in seriesToAdd ? seriesToAdd.zAxisId : zAxisIds[0];
+        const color = colorProcessors[seriesType]?.(seriesToAdd, xAxis[xAxisId], yAxis[yAxisId], zAxisId ? zAxis[zAxisId] : undefined)(dataIndex) ?? '';
         const value = seriesToAdd.data[dataIndex] ?? null;
         const formattedValue = seriesToAdd.valueFormatter(value, {
           dataIndex
@@ -76,7 +75,8 @@ export function useAxisTooltip() {
     location: 'tooltip'
   });
   return {
-    identifier: axis,
+    axisDirection: xAxisHasData ? 'x' : 'y',
+    dataIndex,
     seriesItems: relevantSeries,
     axisValue,
     axisFormattedValue

package/ChartsTooltip/useItemTooltip.d.ts

@@ -1,7 +1,6 @@
-import { ItemInteractionData } from '../context/InteractionProvider';
-import { ChartSeriesType, ChartsSeriesConfig } from '../models/seriesType/config';
+import { ChartItemIdentifier, ChartSeriesType, ChartsSeriesConfig } from '../models/seriesType/config';
 export interface UseItemTooltipReturnValue<T extends ChartSeriesType> {
-    identifier: ItemInteractionData<T>;
+    identifier: ChartItemIdentifier<T>;
     color: string;
     label: string | undefined;
     value: ChartsSeriesConfig[T]['valueType'];

package/ChartsTooltip/useItemTooltip.js

@@ -2,16 +2,17 @@
 
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { InteractionContext } from "../context/InteractionProvider.js";
 import { useSeries } from "../hooks/useSeries.js";
 import { useCartesianContext } from "../context/CartesianProvider/index.js";
 import { ZAxisContext } from "../context/ZAxisContextProvider.js";
 import { useColorProcessor } from "../context/PluginProvider/useColorProcessor.js";
 import { getLabel } from "../internals/getLabel.js";
+import { selectorChartsInteractionItem } from "../internals/plugins/featurePlugins/useChartInteraction/index.js";
+import { useSelector } from "../internals/store/useSelector.js";
+import { useStore } from "../internals/store/useStore.js";
 export function useItemTooltip() {
-  const {
-    item
-  } = React.useContext(InteractionContext);
+  const store = useStore();
+  const item = useSelector(store, selectorChartsInteractionItem);
   const series = useSeries();
   const {
     xAxis,

package/ChartsTooltip/utils.d.ts

@@ -1,5 +1,3 @@
-import { AxisInteractionData, ItemInteractionData } from '../context/InteractionProvider';
-import { ChartSeriesType } from '../models/seriesType/config';
 type MousePosition = {
     x: number;
     y: number;
@@ -14,6 +12,5 @@ export declare function useMouseTracker(): UseMouseTrackerReturnValue;
 type PointerType = Pick<MousePosition, 'height' | 'pointerType'>;
 export declare function usePointerType(): null | PointerType;
 export type TriggerOptions = 'item' | 'axis' | 'none';
-export declare function getTooltipHasData(trigger: TriggerOptions, displayedData: null | AxisInteractionData | ItemInteractionData<ChartSeriesType>): boolean;
 export declare function utcFormatter(v: string | number | Date): string;
 export {};

package/ChartsTooltip/utils.js

@@ -74,14 +74,6 @@ export function usePointerType() {
   }, [svgRef]);
   return pointerType;
 }
-export function getTooltipHasData(trigger, displayedData) {
-  if (trigger === 'item') {
-    return displayedData !== null;
-  }
-  const hasAxisXData = displayedData.x !== null;
-  const hasAxisYData = displayedData.y !== null;
-  return hasAxisXData || hasAxisYData;
-}
 export function utcFormatter(v) {
   if (v instanceof Date) {
     return v.toUTCString();

package/ChartsVoronoiHandler/ChartsVoronoiHandler.js

@@ -1,12 +1,13 @@
 'use client';
 
+import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { Delaunay } from '@mui/x-charts-vendor/d3-delaunay';
 import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
-import { InteractionContext } from "../context/InteractionProvider.js";
 import { useCartesianContext } from "../context/CartesianProvider/index.js";
 import { getValueToPositionMapper } from "../hooks/useScale.js";
+import { useStore } from "../internals/store/useStore.js";
 import { getSVGPoint } from "../internals/getSVGPoint.js";
 import { useDrawingArea, useSvgRef } from "../hooks/index.js";
 import { useHighlighted } from "../context/index.js";
@@ -25,9 +26,7 @@ function ChartsVoronoiHandler(props) {
     xAxisIds,
     yAxisIds
   } = useCartesianContext();
-  const {
-    dispatch
-  } = React.useContext(InteractionContext);
+  const store = useStore();
   const {
     series,
     seriesOrder
@@ -42,17 +41,19 @@ function ChartsVoronoiHandler(props) {
   const defaultXAxisId = xAxisIds[0];
   const defaultYAxisId = yAxisIds[0];
   useEnhancedEffect(() => {
-    dispatch({
-      type: 'updateVoronoiUsage',
-      useVoronoiInteraction: true
-    });
+    store.update(prev => _extends({}, prev, {
+      interaction: _extends({}, prev.interaction, {
+        useVoronoiInteraction: true
+      })
+    }));
     return () => {
-      dispatch({
-        type: 'updateVoronoiUsage',
-        useVoronoiInteraction: false
-      });
+      store.update(prev => _extends({}, prev, {
+        interaction: _extends({}, prev.interaction, {
+          useVoronoiInteraction: false
+        })
+      }));
     };
-  }, [dispatch]);
+  }, [store]);
   useEnhancedEffect(() => {
     // This effect generate and store the Delaunay object that's used to map coordinate to closest point.
 
@@ -100,10 +101,10 @@ function ChartsVoronoiHandler(props) {
     lastFind.current = undefined;
   }, [defaultXAxisId, defaultYAxisId, series, seriesOrder, xAxis, yAxis, drawingArea]);
   React.useEffect(() => {
-    const element = svgRef.current;
-    if (element === null) {
+    if (svgRef.current === null) {
       return undefined;
     }
+    const element = svgRef.current;
     function getClosestPoint(event) {
       // Get mouse coordinate in global SVG space
       const svgPoint = getSVGPoint(element, event);
@@ -141,27 +142,38 @@ function ChartsVoronoiHandler(props) {
       };
     }
     const handleMouseLeave = () => {
-      dispatch({
-        type: 'exitChart'
-      });
+      store.update(prev => _extends({}, prev, {
+        interaction: _extends({}, prev.interaction, {
+          axis: {
+            x: null,
+            y: null
+          },
+          item: null
+        })
+      }));
       clearHighlighted();
     };
     const handleMouseMove = event => {
       const closestPoint = getClosestPoint(event);
       if (closestPoint === 'outside-chart') {
-        dispatch({
-          type: 'exitChart'
-        });
+        store.update(prev => _extends({}, prev, {
+          interaction: _extends({}, prev.interaction, {
+            axis: {
+              x: null,
+              y: null
+            },
+            item: null
+          })
+        }));
         clearHighlighted();
         return;
       }
       if (closestPoint === 'outside-voronoi-max-radius' || closestPoint === 'no-point-found') {
-        dispatch({
-          type: 'leaveItem',
-          data: {
-            type: 'scatter'
-          }
-        });
+        store.update(prev => _extends({}, prev, {
+          interaction: _extends({}, prev.interaction, {
+            item: null
+          })
+        }));
         clearHighlighted();
         return;
       }
@@ -169,14 +181,15 @@ function ChartsVoronoiHandler(props) {
         seriesId,
         dataIndex
       } = closestPoint;
-      dispatch({
-        type: 'enterItem',
-        data: {
-          type: 'scatter',
-          seriesId,
-          dataIndex
-        }
-      });
+      store.update(prev => _extends({}, prev, {
+        interaction: _extends({}, prev.interaction, {
+          item: {
+            type: 'scatter',
+            seriesId,
+            dataIndex
+          }
+        })
+      }));
       setHighlighted({
         seriesId,
         dataIndex
@@ -209,7 +222,7 @@ function ChartsVoronoiHandler(props) {
       element.removeEventListener('pointermove', handleMouseMove);
       element.removeEventListener('click', handleMouseClick);
     };
-  }, [svgRef, dispatch, yAxis, xAxis, voronoiMaxRadius, onItemClick, setHighlighted, clearHighlighted, drawingArea]);
+  }, [svgRef, yAxis, xAxis, voronoiMaxRadius, onItemClick, setHighlighted, clearHighlighted, drawingArea, store]);
 
   // eslint-disable-next-line react/jsx-no-useless-fragment
   return /*#__PURE__*/_jsx(React.Fragment, {});