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

package/internals/plugins/corePlugins/useChartId/useChartId.selectors.js

@@ -0,0 +1,9 @@
+import { createSelector } from "../../utils/selectors.js";
+const selectorChartIdState = state => state.id;
+
+/**
+ * Get the id attribute of the chart.
+ * @param {ChartState<[UseChartIdSignature]>} state The state of the chart.
+ * @returns {string} The id attribute of the chart.
+ */
+export const selectorChartId = createSelector(selectorChartIdState, idState => idState.chartId);

package/internals/plugins/corePlugins/useChartId/useChartId.types.d.ts

@@ -0,0 +1,20 @@
+import { ChartPluginSignature } from '../../models';
+export interface UseChartIdParameters {
+    /**
+     * This prop is used to help implement the accessibility logic.
+     * If you don't provide this prop. It falls back to a randomly generated id.
+     */
+    id?: string;
+}
+export type UseChartIdDefaultizedParameters = UseChartIdParameters;
+export interface UseChartIdState {
+    id: {
+        chartId: string;
+        providedChartId: string | undefined;
+    };
+}
+export type UseChartIdSignature = ChartPluginSignature<{
+    params: UseChartIdParameters;
+    defaultizedParams: UseChartIdDefaultizedParameters;
+    state: UseChartIdState;
+}>;

package/internals/plugins/corePlugins/useChartId/useChartId.utils.d.ts

@@ -0,0 +1 @@
+export declare const createChartDefaultId: () => string;

package/internals/plugins/corePlugins/useChartId/useChartId.utils.js

@@ -0,0 +1,5 @@
+let globalChartDefaultId = 0;
+export const createChartDefaultId = () => {
+  globalChartDefaultId += 1;
+  return `mui-chart-${globalChartDefaultId}`;
+};

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,73 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import useEventCallback from '@mui/utils/useEventCallback';
+export const useChartInteraction = ({
+  store
+}) => {
+  const cleanInteraction = useEventCallback(() => {
+    store.update(prev => _extends({}, prev, {
+      interaction: _extends({}, prev.interaction, {
+        axis: {
+          x: null,
+          y: null
+        },
+        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,
+      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("./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;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionAxis: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & 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;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionXAxis: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & 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;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionYAxis: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & 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;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionItemIsDefined: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & 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("./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;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionXAxisIsDefined: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & 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("./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;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionYAxisIsDefined: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & 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("./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;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionIsVoronoiEnabled: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & 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;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,10 @@
+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);
+export const selectorChartsInteractionYAxis = createSelector(selectInteraction, interaction => interaction.axis.y);
+export const selectorChartsInteractionItemIsDefined = createSelector(selectorChartsInteractionItem, item => item !== null);
+export const selectorChartsInteractionXAxisIsDefined = createSelector(selectorChartsInteractionXAxis, x => x !== null);
+export const selectorChartsInteractionYAxisIsDefined = createSelector(selectorChartsInteractionYAxis, y => y !== null);
+export const selectorChartsInteractionIsVoronoiEnabled = createSelector(selectInteraction, interaction => interaction.isVoronoiEnabled);

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

@@ -0,0 +1,57 @@
+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;
+    /**
+     * 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/useChartInteraction/useChartInteraction.types.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/models/chart.d.ts

@@ -0,0 +1,14 @@
+import type { ChartAnyPluginSignature } from './plugin';
+import type { MergeSignaturesProperty } from './helpers';
+import type { ChartCorePluginSignatures } from '../corePlugins';
+export type ChartInstance<TSignatures extends readonly ChartAnyPluginSignature[], TOptionalSignatures extends readonly ChartAnyPluginSignature[] = []> = MergeSignaturesProperty<[...ChartCorePluginSignatures, ...TSignatures], 'instance'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
+export type ChartPublicAPI<TSignatures extends readonly ChartAnyPluginSignature[], TOptionalSignatures extends readonly ChartAnyPluginSignature[] = []> = MergeSignaturesProperty<[...ChartCorePluginSignatures, ...TSignatures], 'publicAPI'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
+export type ChartStateCacheKey = {
+    id: number;
+};
+export type ChartState<TSignatures extends readonly ChartAnyPluginSignature[], TOptionalSignatures extends readonly ChartAnyPluginSignature[] = []> = MergeSignaturesProperty<[...ChartCorePluginSignatures, ...TSignatures], 'state'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'state'>> & {
+    /**
+     * The key used to identify the chart in the global cache object.
+     */
+    cacheKey: ChartStateCacheKey;
+};

package/internals/plugins/models/chart.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/models/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { ChartAnyPluginSignature, ChartPlugin } from './plugin';
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export type OptionalIfEmpty<A extends string, B> = keyof B extends never ? Partial<Record<A, B>> : IsAny<B> extends true ? Partial<Record<A, B>> : Record<A, B>;
+export type MergeSignaturesProperty<TSignatures extends readonly any[], TProperty extends keyof ChartAnyPluginSignature> = TSignatures extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends ChartAnyPluginSignature ? P[TProperty] & MergeSignaturesProperty<R, TProperty> : {} : {};
+export type ConvertPluginsIntoSignatures<TPlugins extends readonly ChartPlugin<ChartAnyPluginSignature>[]> = TPlugins extends readonly [plugin: infer TPlugin, ...otherPlugin: infer R] ? R extends readonly ChartPlugin<any>[] ? TPlugin extends ChartPlugin<infer TSignature> ? readonly [TSignature, ...ConvertPluginsIntoSignatures<R>] : never : never : [];
+export type ConvertSignaturesIntoPlugins<TSignatures extends readonly ChartAnyPluginSignature[]> = TSignatures extends readonly [signature: infer TSignature, ...otherSignatures: infer R] ? R extends readonly ChartAnyPluginSignature[] ? TSignature extends ChartAnyPluginSignature ? readonly [ChartPlugin<TSignature>, ...ConvertSignaturesIntoPlugins<R>] : never : never : [];
+export {};

package/internals/plugins/models/helpers.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/models/index.d.ts

@@ -1,35 +1,3 @@
-import { ChartItemIdentifier, ChartSeriesType } from '../../../models/seriesType/config';
-export type ItemInteractionData<T extends ChartSeriesType> = ChartItemIdentifier<T>;
-export type AxisInteractionData = {
-    x: null | {
-        value: number | Date | string;
-        index: number;
-    };
-    y: null | {
-        value: number | Date | string;
-        index: number;
-    };
-};
-type InteractionState = {
-    /**
-     * The item currently interacting.
-     */
-    item: null | ItemInteractionData<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 ChartStateCacheKey = {
-    id: number;
-};
-export type ChartState = {
-    interaction: InteractionState;
-    cacheKey: ChartStateCacheKey;
-};
-export {};
+export * from './helpers';
+export * from './plugin';
+export * from './chart';

package/internals/plugins/models/index.js

@@ -1 +1,3 @@
-export {};
+export * from "./helpers.js";
+export * from "./plugin.js";
+export * from "./chart.js";