@mui/x-charts 8.0.0-alpha.1 → 8.0.0-alpha.10

package/internals/plugins/featurePlugins/useChartHighlight/useChartHighlight.selectors.js

@@ -0,0 +1,31 @@
+import { createSelector } from "../../utils/selectors.js";
+import { createIsHighlighted } from "./createIsHighlighted.js";
+import { createIsFaded } from "./createIsFaded.js";
+const selectHighlight = state => state.highlight;
+const selectSeries = state => state.series;
+export const selectorChartsHighlightScopePerSeriesId = createSelector(selectSeries, series => {
+  const map = new Map();
+  Object.keys(series.processedSeries).forEach(seriesType => {
+    const seriesData = series.processedSeries[seriesType];
+    Object.keys(seriesData?.series ?? {}).forEach(seriesId => {
+      const seriesItem = seriesData?.series[seriesId];
+      map.set(seriesId, seriesItem?.highlightScope);
+    });
+  });
+  return map;
+});
+export const selectorChartsHighlightedItem = createSelector(selectHighlight, highlight => highlight.item);
+export const selectorChartsHighlightScope = createSelector([selectorChartsHighlightScopePerSeriesId, selectorChartsHighlightedItem], (seriesIdToHighlightScope, highlightedItem) => {
+  if (!highlightedItem) {
+    return null;
+  }
+  const highlightScope = seriesIdToHighlightScope.get(highlightedItem.seriesId);
+  if (highlightScope === undefined) {
+    return null;
+  }
+  return highlightScope;
+});
+export const selectorChartsIsHighlightedCallback = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem], createIsHighlighted);
+export const selectorChartsIsFadedCallback = createSelector([selectorChartsHighlightScope, selectorChartsHighlightedItem], createIsFaded);
+export const selectorChartsIsHighlighted = createSelector([selectorChartsIsHighlightedCallback, (_, item) => item], (callback, item) => callback(item));
+export const selectorChartsIsFaded = createSelector([selectorChartsIsFadedCallback, (_, item) => item], (callback, item) => callback(item));

package/internals/plugins/featurePlugins/useChartHighlight/useChartHighlight.types.d.ts

@@ -0,0 +1,71 @@
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { ChartPluginSignature } from '../../models';
+import { SeriesId } from '../../../../models/seriesType/common';
+import { UseChartSeriesSignature } from '../../corePlugins/useChartSeries';
+/**
+ * The data of the highlighted item.
+ * To highlight an item, you need to provide the series id and the item id.
+ * If targeting the whole series, you can omit the item id.
+ * To clear the highlight, set the value to an empty object.
+ *
+ * @example
+ * // Highlight the item with the series id 'london' and the item id 0.
+ * { seriesId: 'london', dataIndex: 0 }
+ *
+ * // Highlight the whole series with the series id 'london'.
+ * { seriesId: 'london' }
+ *
+ * // Clear the highlight.
+ * {}
+ */
+export type HighlightItemData = {
+    /**
+     * The series id of the highlighted item.
+     */
+    seriesId: SeriesId;
+    /**
+     * The index of the item in series data.
+     */
+    dataIndex?: number;
+};
+export interface UseChartHighlightInstance {
+    /**
+     * Remove all highlight.
+     */
+    clearHighlight: () => void;
+    /**
+     * Set the highlighted item.
+     * @param {HighlightItemData} item The item to highlight.
+     */
+    setHighlight: (item: HighlightItemData) => void;
+}
+export interface UseChartHighlightParameters {
+    /**
+     * The highlighted item.
+     * Used when the highlight is controlled.
+     */
+    highlightedItem?: HighlightItemData | null;
+    /**
+     * The callback fired when the highlighted item changes.
+     *
+     * @param {HighlightItemData | null} highlightedItem  The newly highlighted item.
+     */
+    onHighlightChange?: (highlightedItem: HighlightItemData | null) => void;
+}
+export type UseChartHighlightDefaultizedParameters = DefaultizedProps<UseChartHighlightParameters, 'highlightedItem'>;
+export interface UseChartHighlightState {
+    highlight: {
+        /**
+         * The item currently highlighted.
+         */
+        item: HighlightItemData | null;
+    };
+}
+export type UseChartHighlightSignature = ChartPluginSignature<{
+    instance: UseChartHighlightInstance;
+    state: UseChartHighlightState;
+    params: UseChartHighlightParameters;
+    defaultizedParams: UseChartHighlightDefaultizedParameters;
+    modelNames: 'highlightedItem';
+    dependencies: [UseChartSeriesSignature];
+}>;

package/internals/plugins/featurePlugins/useChartInteraction/index.d.ts

@@ -0,0 +1,3 @@
+export { useChartInteraction } from './useChartInteraction';
+export * from './useChartInteraction.selectors';
+export type { UseChartInteractionSignature } from './useChartInteraction.types';

package/internals/plugins/featurePlugins/useChartInteraction/index.js

@@ -0,0 +1,2 @@
+export { useChartInteraction } from "./useChartInteraction.js";
+export * from "./useChartInteraction.selectors.js";

package/internals/plugins/featurePlugins/useChartInteraction/useChartInteraction.d.ts

@@ -0,0 +1,3 @@
+import { ChartPlugin } from '../../models';
+import { UseChartInteractionSignature } from './useChartInteraction.types';
+export declare const useChartInteraction: ChartPlugin<UseChartInteractionSignature>;

package/internals/plugins/featurePlugins/useChartInteraction/useChartInteraction.js

@@ -0,0 +1,90 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import useEventCallback from '@mui/utils/useEventCallback';
+export const useChartInteraction = ({
+  store
+}) => {
+  const cleanInteraction = useEventCallback(() => {
+    store.update(prev => {
+      return _extends({}, prev, {
+        interaction: _extends({}, prev.interaction, {
+          axis: {
+            x: null,
+            y: null
+          },
+          item: null
+        })
+      });
+    });
+  });
+  const removeItemInteraction = useEventCallback(itemToRemove => {
+    store.update(prev => {
+      const prevItem = prev.interaction.item;
+      if (prevItem === null || Object.keys(itemToRemove).some(key => itemToRemove[key] !== prevItem[key])) {
+        // The item is already something else, no need to clean it.
+        return prev;
+      }
+      return _extends({}, prev, {
+        interaction: _extends({}, prev.interaction, {
+          item: null
+        })
+      });
+    });
+  });
+  const setItemInteraction = useEventCallback(newItem => {
+    store.update(prev => _extends({}, prev, {
+      interaction: _extends({}, prev.interaction, {
+        item: newItem
+      })
+    }));
+  });
+  const setAxisInteraction = useEventCallback(({
+    x: newStateX,
+    y: newStateY
+  }) => {
+    store.update(prev => _extends({}, prev, {
+      interaction: _extends({}, prev.interaction, {
+        axis: _extends({}, prev.interaction.axis, prev.interaction.axis.x?.index !== newStateX?.index || prev.interaction.axis.x?.value !== newStateX?.value ? {
+          x: newStateX
+        } : {}, prev.interaction.axis.y?.index !== newStateY?.index || prev.interaction.axis.y?.value !== newStateY?.value ? {
+          y: newStateY
+        } : {})
+      })
+    }));
+  });
+  const enableVoronoid = useEventCallback(() => {
+    store.update(prev => _extends({}, prev, {
+      interaction: _extends({}, prev.interaction, {
+        isVoronoiEnabled: true
+      })
+    }));
+  });
+  const disableVoronoid = useEventCallback(() => {
+    store.update(prev => _extends({}, prev, {
+      interaction: _extends({}, prev.interaction, {
+        isVoronoiEnabled: false
+      })
+    }));
+  });
+  return {
+    params: {},
+    instance: {
+      cleanInteraction,
+      setItemInteraction,
+      removeItemInteraction,
+      setAxisInteraction,
+      enableVoronoid,
+      disableVoronoid
+    }
+  };
+};
+useChartInteraction.getInitialState = () => ({
+  interaction: {
+    item: null,
+    axis: {
+      x: null,
+      y: null
+    },
+    isVoronoiEnabled: false
+  }
+});
+useChartInteraction.params = {};

package/internals/plugins/featurePlugins/useChartInteraction/useChartInteraction.selectors.d.ts

@@ -0,0 +1,376 @@
+import { ChartRootSelector } from '../../utils/selectors';
+import { UseChartInteractionSignature } from './useChartInteraction.types';
+export declare const selectorChartsInteractionItem: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null;
+    dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionAxis: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => import("./useChartInteraction.types").AxisInteractionData) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("./useChartInteraction.types").AxisInteractionData;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("./useChartInteraction.types").AxisInteractionData) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./useChartInteraction.types").AxisInteractionData;
+    dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionXAxis: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => {
+    value: number | Date | string;
+    index: number;
+} | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionYAxis: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => {
+    value: number | Date | string;
+    index: number;
+} | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionItemIsDefined: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+        cacheKey: import("../../models").ChartStateCacheKey;
+    }) => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+            axis: import("./useChartInteraction.types").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+            axis: import("./useChartInteraction.types").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("../../../..").BarItemIdentifier | import("../../../..").ScatterItemIdentifier | import("../../../..").LineItemIdentifier | import("../../../..").PieItemIdentifier | null;
+        dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionXAxisIsDefined: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+        cacheKey: import("../../models").ChartStateCacheKey;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+            axis: import("./useChartInteraction.types").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+            axis: import("./useChartInteraction.types").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionYAxisIsDefined: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+        cacheKey: import("../../models").ChartStateCacheKey;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+            axis: import("./useChartInteraction.types").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+            axis: import("./useChartInteraction.types").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionIsVoronoiEnabled: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartInteraction.types").UseChartInteractionState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => boolean | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => boolean | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../../..").ChartItemIdentifier<import("../../..").ChartSeriesType>;
+        axis: import("./useChartInteraction.types").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => boolean | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean | undefined;
+    dependencies: [ChartRootSelector<UseChartInteractionSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};

package/{context/InteractionSelectors.js → internals/plugins/featurePlugins/useChartInteraction/useChartInteraction.selectors.js}

@@ -1,7 +1,5 @@
-import { createSelector } from "../internals/plugins/utils/selectors.js";
-function selectInteraction(state) {
-  return state.interaction;
-}
+import { createSelector } from "../../utils/selectors.js";
+const selectInteraction = state => state.interaction;
 export const selectorChartsInteractionItem = createSelector(selectInteraction, interaction => interaction.item);
 export const selectorChartsInteractionAxis = createSelector(selectInteraction, interaction => interaction.axis);
 export const selectorChartsInteractionXAxis = createSelector(selectInteraction, interaction => interaction.axis.x);

package/internals/plugins/featurePlugins/useChartInteraction/useChartInteraction.types.d.ts

@@ -0,0 +1,62 @@
+import { ChartPluginSignature } from '../../models';
+import { ChartItemIdentifier, ChartSeriesType } from '../../../../models/seriesType/config';
+export interface UseChartInteractionInstance {
+    /**
+     * Remove all interaction.
+     */
+    cleanInteraction: () => void;
+    /**
+     * Setter for the item the user is interacting with.
+     * @param {ChartItemIdentifier} newItem The identifier of the item.
+     */
+    setItemInteraction: (newItem: ChartItemIdentifier<ChartSeriesType>) => void;
+    /**
+     * Remove item interaction if the current if the provided item is still the one interacting.
+     * @param {ChartItemIdentifier} itemToRemove The identifier of the item.
+     */
+    removeItemInteraction: (itemToRemove: ChartItemIdentifier<ChartSeriesType>) => void;
+    /**
+     * Set the new axis the user is interacting with.
+     * @param {Partial<AxisInteractionData>} newAxis The new axis identifier.
+     */
+    setAxisInteraction: (newAxis: Partial<AxisInteractionData>) => void;
+    /**
+     * Enable the voronoi computation.
+     */
+    enableVoronoid: () => void;
+    /**
+     * Disable the voronoi computation.
+     */
+    disableVoronoid: () => void;
+}
+export type AxisInteractionData = {
+    x: null | {
+        value: number | Date | string;
+        index: number;
+    };
+    y: null | {
+        value: number | Date | string;
+        index: number;
+    };
+};
+export interface UseChartInteractionState {
+    interaction: {
+        /**
+         * The item currently interacting.
+         */
+        item: null | ChartItemIdentifier<ChartSeriesType>;
+        /**
+         * The x- and y-axes currently interacting.
+         */
+        axis: AxisInteractionData;
+        /**
+         * Set to `true` when `VoronoiHandler` is active.
+         * Used to prevent collision with mouseEnter events.
+         */
+        isVoronoiEnabled?: boolean;
+    };
+}
+export type UseChartInteractionSignature = ChartPluginSignature<{
+    instance: UseChartInteractionInstance;
+    state: UseChartInteractionState;
+}>;

package/internals/plugins/featurePlugins/useChartZAxis/index.d.ts

@@ -0,0 +1,3 @@
+export { useChartZAxis } from './useChartZAxis';
+export type * from './useChartZAxis.types';
+export * from './useChartZAxis.selectors';