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

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

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './plugin';
+export * from './chart';

package/internals/plugins/models/index.js

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

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

@@ -0,0 +1,75 @@
+import * as React from 'react';
+import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
+import type { ChartCorePluginSignatures } from '../corePlugins';
+import { ChartStore } from '../utils/ChartStore';
+export interface ChartPluginOptions<TSignature extends ChartAnyPluginSignature> {
+    instance: ChartUsedInstance<TSignature>;
+    params: ChartUsedDefaultizedParams<TSignature>;
+    store: ChartUsedStore<TSignature>;
+    svgRef: React.RefObject<SVGSVGElement>;
+    plugins: ChartPlugin<ChartAnyPluginSignature>[];
+}
+type ChartResponse<TSignature extends ChartAnyPluginSignature> = OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']>;
+export type ChartPluginSignature<T extends {
+    params?: {};
+    defaultizedParams?: {};
+    instance?: {};
+    publicAPI?: {};
+    state?: {};
+    dependencies?: readonly ChartAnyPluginSignature[];
+    optionalDependencies?: readonly ChartAnyPluginSignature[];
+}> = {
+    params: T extends {
+        params: {};
+    } ? T['params'] : {};
+    defaultizedParams: T extends {
+        defaultizedParams: {};
+    } ? T['defaultizedParams'] : {};
+    instance: T extends {
+        instance: {};
+    } ? T['instance'] : {};
+    state: T extends {
+        state: {};
+    } ? T['state'] : {};
+    publicAPI: T extends {
+        publicAPI: {};
+    } ? T['publicAPI'] : {};
+    dependencies: T extends {
+        dependencies: Array<any>;
+    } ? T['dependencies'] : [];
+    optionalDependencies: T extends {
+        optionalDependencies: Array<any>;
+    } ? T['optionalDependencies'] : [];
+};
+export type ChartAnyPluginSignature = {
+    state: any;
+    instance: any;
+    params: any;
+    defaultizedParams: any;
+    dependencies: any;
+    optionalDependencies: any;
+    publicAPI: any;
+};
+type ChartRequiredPlugins<TSignature extends ChartAnyPluginSignature> = [
+    ...ChartCorePluginSignatures,
+    ...TSignature['dependencies']
+];
+type PluginPropertyWithDependencies<TSignature extends ChartAnyPluginSignature, TProperty extends keyof ChartAnyPluginSignature> = TSignature[TProperty] & MergeSignaturesProperty<ChartRequiredPlugins<TSignature>, TProperty> & Partial<MergeSignaturesProperty<TSignature['optionalDependencies'], TProperty>>;
+export type ChartUsedParams<TSignature extends ChartAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'params'>;
+type ChartUsedDefaultizedParams<TSignature extends ChartAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'defaultizedParams'>;
+export type ChartUsedInstance<TSignature extends ChartAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'instance'> & {
+    /**
+     * Private property only defined in TypeScript to be able to access the plugin signature from the instance object.
+     */
+    $$signature: TSignature;
+};
+export type ChartUsedStore<TSignature extends ChartAnyPluginSignature> = ChartStore<[
+    TSignature,
+    ...TSignature['dependencies']
+]>;
+export type ChartPlugin<TSignature extends ChartAnyPluginSignature> = {
+    (options: ChartPluginOptions<TSignature>): ChartResponse<TSignature>;
+    getInitialState?: (params: ChartUsedDefaultizedParams<TSignature>) => TSignature['state'];
+    params: Record<keyof TSignature['params'], true>;
+};
+export {};

package/internals/plugins/models/plugin.js

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

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

@@ -0,0 +1,13 @@
+import type { ChartState } from '../models/chart';
+import type { ChartAnyPluginSignature } from '../models/plugin';
+type Listener<T> = (value: T) => void;
+export type StoreUpdater<TSignatures extends readonly ChartAnyPluginSignature[]> = (prevState: ChartState<TSignatures>) => ChartState<TSignatures>;
+export declare class ChartStore<TSignatures extends readonly ChartAnyPluginSignature[]> {
+    value: ChartState<TSignatures>;
+    private listeners;
+    constructor(value: ChartState<TSignatures>);
+    subscribe: (fn: Listener<ChartState<TSignatures>>) => () => void;
+    getSnapshot: () => ChartState<TSignatures>;
+    update: (updater: StoreUpdater<TSignatures>) => void;
+}
+export {};

package/internals/plugins/utils/ChartStore.js

@@ -0,0 +1,24 @@
+export class ChartStore {
+  constructor(value) {
+    this.value = void 0;
+    this.listeners = void 0;
+    this.subscribe = fn => {
+      this.listeners.add(fn);
+      return () => {
+        this.listeners.delete(fn);
+      };
+    };
+    this.getSnapshot = () => {
+      return this.value;
+    };
+    this.update = updater => {
+      const newState = updater(this.value);
+      if (newState !== this.value) {
+        this.value = newState;
+        this.listeners.forEach(l => l(newState));
+      }
+    };
+    this.value = value;
+    this.listeners = new Set();
+  }
+}

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

@@ -0,0 +1,9 @@
+import { CreateSelectorFunction } from 'reselect';
+import { ChartAnyPluginSignature, ChartState } from '../models';
+export type ChartRootSelector<TSignature extends ChartAnyPluginSignature> = <TSignatures extends [TSignature]>(state: ChartState<TSignatures>) => TSignature['state'][keyof TSignature['state']];
+export type ChartsSelector<TState, TArgs, TResult> = (state: TState, args: TArgs) => TResult;
+/**
+ * Method wrapping reselect's createSelector to provide caching for chart instances.
+ *
+ */
+export declare const createSelector: CreateSelectorFunction;

package/internals/plugins/utils/selectors.js

@@ -0,0 +1,37 @@
+import { lruMemoize, createSelectorCreator } from 'reselect';
+const reselectCreateSelector = createSelectorCreator({
+  memoize: lruMemoize,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+});
+const cache = new WeakMap();
+/**
+ * Method wrapping reselect's createSelector to provide caching for chart instances.
+ *
+ */
+export const createSelector = (...createSelectorArgs) => {
+  const selector = (state, selectorArgs) => {
+    const cacheKey = state.cacheKey;
+
+    // If there is no cache for the current chart instance, create one.
+    let cacheForCurrentChartInstance = cache.get(cacheKey);
+    if (!cacheForCurrentChartInstance) {
+      cacheForCurrentChartInstance = new Map();
+      cache.set(cacheKey, cacheForCurrentChartInstance);
+    }
+
+    // If there is a cached selector, execute it.
+    const cachedSelector = cacheForCurrentChartInstance.get(createSelectorArgs);
+    if (cachedSelector) {
+      return cachedSelector(state, selectorArgs);
+    }
+
+    // Otherwise, create a new selector and cache it and execute it.
+    const fn = reselectCreateSelector(...createSelectorArgs);
+    cacheForCurrentChartInstance.set(createSelectorArgs, fn);
+    return fn(state, selectorArgs);
+  };
+  return selector;
+};