vccs 0.0.1 → 0.2.0

package/dist/state/selectors/tooltipSelectors.d.ts

@@ -0,0 +1,581 @@
+import { RechartsRootState } from '../store';
+import { AxisRange, AxisWithTicksSettings, XorYType, selectHasBar } from './axisSelectors';
+import { AxisId } from '../cartesianAxisSlice';
+import { ChartData, ChartDataState } from '../chartDataSlice';
+import { GraphicalItemSettings } from '../graphicalItemsSlice';
+import { ReferenceAreaSettings, ReferenceDotSettings, ReferenceLineSettings } from '../referenceElementsSlice';
+import { TooltipIndex, TooltipPayload, TooltipPayloadConfiguration, TooltipPayloadEntry, TooltipPayloadSearcher } from '../tooltipSlice';
+import { NumberDomain } from '../../types/axis';
+import { CategoricalDomain, Coordinate, DataKey, LayoutType, TickItem, TooltipEventType } from '../../types';
+import { RechartsScale } from '../../types/scale';
+import { BaseAxisProps } from '../../cartesian/axis/type';
+export declare function combineTooltipPayload(tooltipPayloadConfigurations: ReadonlyArray<TooltipPayloadConfiguration>, activeIndex: TooltipIndex, chartDataState: ChartDataState, tooltipAxis: BaseAxisProps | undefined, activeLabel: string | undefined, tooltipPayloadSearcher: TooltipPayloadSearcher | undefined, tooltipEventType: TooltipEventType): TooltipPayload | undefined;
+export declare function selectTooltipAxisType(state: RechartsRootState): XorYType;
+export declare const selectTooltipAxisId: (state: RechartsRootState) => AxisId;
+export declare function selectTooltipAxis(state: RechartsRootState): AxisWithTicksSettings;
+export declare const selectTooltipAxisRealScaleType: ((state: {
+    brush: import('../brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: ChartDataState;
+    graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: LayoutType;
+        width: number;
+        height: number;
+        margin: import('../../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('../legendSlice').LegendSettings;
+        size: import('../../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('../optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<ReferenceDotSettings>;
+        areas: ReadonlyArray<ReferenceAreaSettings>;
+        lines: ReadonlyArray<ReferenceLineSettings>;
+    };
+    rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('../tooltipSlice').TooltipState;
+}) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [typeof selectTooltipAxis, typeof selectHasBar, (state: RechartsRootState) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const selectAllUnfilteredGraphicalItems: (state: RechartsRootState) => ReadonlyArray<GraphicalItemSettings>;
+export declare const selectAllGraphicalItemsSettings: ((state: {
+    brush: import('../brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: ChartDataState;
+    graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: LayoutType;
+        width: number;
+        height: number;
+        margin: import('../../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('../legendSlice').LegendSettings;
+        size: import('../../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('../optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<ReferenceDotSettings>;
+        areas: ReadonlyArray<ReferenceAreaSettings>;
+        lines: ReadonlyArray<ReferenceLineSettings>;
+    };
+    rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('../tooltipSlice').TooltipState;
+}) => GraphicalItemSettings[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: readonly GraphicalItemSettings[], resultFuncArgs_1: AxisWithTicksSettings, resultFuncArgs_2: (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) => GraphicalItemSettings[];
+    memoizedResultFunc: ((resultFuncArgs_0: readonly GraphicalItemSettings[], resultFuncArgs_1: AxisWithTicksSettings, resultFuncArgs_2: (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) => GraphicalItemSettings[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => GraphicalItemSettings[];
+    dependencies: [(state: RechartsRootState) => ReadonlyArray<GraphicalItemSettings>, typeof selectTooltipAxis, ((state: {
+        brush: import('../brushSlice').BrushSettings;
+        cartesianAxis: {
+            xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+            yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+            zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+        };
+        chartData: ChartDataState;
+        graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+        layout: {
+            layoutType: LayoutType;
+            width: number;
+            height: number;
+            margin: import('../../types').Margin;
+            scale: number;
+        };
+        legend: {
+            settings: import('../legendSlice').LegendSettings;
+            size: import('../../types').Size;
+            payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+        };
+        options: import('../optionsSlice').ChartOptions;
+        polarAxis: {
+            radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+            angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+        };
+        polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+        referenceElements: {
+            dots: ReadonlyArray<ReferenceDotSettings>;
+            areas: ReadonlyArray<ReferenceAreaSettings>;
+            lines: ReadonlyArray<ReferenceLineSettings>;
+        };
+        rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+        tooltip: import('../tooltipSlice').TooltipState;
+    }) => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: XorYType, resultFuncArgs_1: AxisId) => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean;
+        memoizedResultFunc: ((resultFuncArgs_0: XorYType, resultFuncArgs_1: AxisId) => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean;
+        dependencies: [typeof selectTooltipAxisType, (state: RechartsRootState) => AxisId];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const selectTooltipGraphicalItemsData: ((state: {
+    brush: import('../brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: ChartDataState;
+    graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: LayoutType;
+        width: number;
+        height: number;
+        margin: import('../../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('../legendSlice').LegendSettings;
+        size: import('../../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('../optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<ReferenceDotSettings>;
+        areas: ReadonlyArray<ReferenceAreaSettings>;
+        lines: ReadonlyArray<ReferenceLineSettings>;
+    };
+    rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('../tooltipSlice').TooltipState;
+}) => unknown[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: GraphicalItemSettings[]) => unknown[];
+    memoizedResultFunc: ((resultFuncArgs_0: GraphicalItemSettings[]) => unknown[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => unknown[];
+    dependencies: [((state: {
+        brush: import('../brushSlice').BrushSettings;
+        cartesianAxis: {
+            xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+            yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+            zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+        };
+        chartData: ChartDataState;
+        graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+        layout: {
+            layoutType: LayoutType;
+            width: number;
+            height: number;
+            margin: import('../../types').Margin;
+            scale: number;
+        };
+        legend: {
+            settings: import('../legendSlice').LegendSettings;
+            size: import('../../types').Size;
+            payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+        };
+        options: import('../optionsSlice').ChartOptions;
+        polarAxis: {
+            radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+            angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+        };
+        polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+        referenceElements: {
+            dots: ReadonlyArray<ReferenceDotSettings>;
+            areas: ReadonlyArray<ReferenceAreaSettings>;
+            lines: ReadonlyArray<ReferenceLineSettings>;
+        };
+        rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+        tooltip: import('../tooltipSlice').TooltipState;
+    }) => GraphicalItemSettings[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: readonly GraphicalItemSettings[], resultFuncArgs_1: AxisWithTicksSettings, resultFuncArgs_2: (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) => GraphicalItemSettings[];
+        memoizedResultFunc: ((resultFuncArgs_0: readonly GraphicalItemSettings[], resultFuncArgs_1: AxisWithTicksSettings, resultFuncArgs_2: (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) => GraphicalItemSettings[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => GraphicalItemSettings[];
+        dependencies: [(state: RechartsRootState) => ReadonlyArray<GraphicalItemSettings>, typeof selectTooltipAxis, ((state: {
+            brush: import('../brushSlice').BrushSettings;
+            cartesianAxis: {
+                xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+                yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+                zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+            };
+            chartData: ChartDataState;
+            graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+            layout: {
+                layoutType: LayoutType;
+                width: number;
+                height: number;
+                margin: import('../../types').Margin;
+                scale: number;
+            };
+            legend: {
+                settings: import('../legendSlice').LegendSettings;
+                size: import('../../types').Size;
+                payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+            };
+            options: import('../optionsSlice').ChartOptions;
+            polarAxis: {
+                radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+                angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+            };
+            polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+            referenceElements: {
+                dots: ReadonlyArray<ReferenceDotSettings>;
+                areas: ReadonlyArray<ReferenceAreaSettings>;
+                lines: ReadonlyArray<ReferenceLineSettings>;
+            };
+            rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+            tooltip: import('../tooltipSlice').TooltipState;
+        }) => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: XorYType, resultFuncArgs_1: AxisId) => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean;
+            memoizedResultFunc: ((resultFuncArgs_0: XorYType, resultFuncArgs_1: AxisId) => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => (item: import('../graphicalItemsSlice').CartesianGraphicalItemSettings | import('../graphicalItemsSlice').PolarGraphicalItemSettings) => boolean;
+            dependencies: [typeof selectTooltipAxisType, (state: RechartsRootState) => AxisId];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+            memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+/**
+ * Data for tooltip always use the data with indexes set by a Brush,
+ * and never accept the isPanorama flag:
+ * because Tooltip never displays inside the panorama anyway
+ * so we don't need to worry what would happen there.
+ */
+export declare const selectTooltipDisplayedData: (state: RechartsRootState) => ChartData;
+export declare const selectTooltipAxisDomain: (state: RechartsRootState) => NumberDomain | CategoricalDomain | undefined;
+export declare const selectTooltipAxisDomainIncludingNiceTicks: (state: RechartsRootState) => NumberDomain | CategoricalDomain | undefined;
+declare function selectTooltipAxisRange(state: RechartsRootState): AxisRange | undefined;
+export declare const selectTooltipAxisRangeWithReverse: ((state: {
+    brush: import('../brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: ChartDataState;
+    graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: LayoutType;
+        width: number;
+        height: number;
+        margin: import('../../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('../legendSlice').LegendSettings;
+        size: import('../../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('../optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<ReferenceDotSettings>;
+        areas: ReadonlyArray<ReferenceAreaSettings>;
+        lines: ReadonlyArray<ReferenceLineSettings>;
+    };
+    rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('../tooltipSlice').TooltipState;
+}) => AxisRange) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: AxisWithTicksSettings, resultFuncArgs_1: AxisRange) => AxisRange;
+    memoizedResultFunc: ((resultFuncArgs_0: AxisWithTicksSettings, resultFuncArgs_1: AxisRange) => AxisRange) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => AxisRange;
+    dependencies: [typeof selectTooltipAxis, typeof selectTooltipAxisRange];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const selectTooltipAxisScale: (state: RechartsRootState) => RechartsScale | undefined;
+export declare const selectTooltipCategoricalDomain: (state: RechartsRootState) => ReadonlyArray<unknown> | undefined;
+export declare const selectTooltipAxisTicks: ((state: {
+    brush: import('../brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: ChartDataState;
+    graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: LayoutType;
+        width: number;
+        height: number;
+        margin: import('../../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('../legendSlice').LegendSettings;
+        size: import('../../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('../optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<ReferenceDotSettings>;
+        areas: ReadonlyArray<ReferenceAreaSettings>;
+        lines: ReadonlyArray<ReferenceLineSettings>;
+    };
+    rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('../tooltipSlice').TooltipState;
+}) => readonly TickItem[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LayoutType, resultFuncArgs_1: AxisWithTicksSettings, resultFuncArgs_2: string, resultFuncArgs_3: RechartsScale, resultFuncArgs_4: AxisRange, resultFuncArgs_5: readonly unknown[], resultFuncArgs_6: readonly unknown[], resultFuncArgs_7: XorYType) => readonly TickItem[];
+    memoizedResultFunc: ((resultFuncArgs_0: LayoutType, resultFuncArgs_1: AxisWithTicksSettings, resultFuncArgs_2: string, resultFuncArgs_3: RechartsScale, resultFuncArgs_4: AxisRange, resultFuncArgs_5: readonly unknown[], resultFuncArgs_6: readonly unknown[], resultFuncArgs_7: XorYType) => readonly TickItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => readonly TickItem[];
+    dependencies: [(state: RechartsRootState) => LayoutType, typeof selectTooltipAxis, ((state: {
+        brush: import('../brushSlice').BrushSettings;
+        cartesianAxis: {
+            xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+            yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+            zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+        };
+        chartData: ChartDataState;
+        graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+        layout: {
+            layoutType: LayoutType;
+            width: number;
+            height: number;
+            margin: import('../../types').Margin;
+            scale: number;
+        };
+        legend: {
+            settings: import('../legendSlice').LegendSettings;
+            size: import('../../types').Size;
+            payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+        };
+        options: import('../optionsSlice').ChartOptions;
+        polarAxis: {
+            radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+            angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+        };
+        polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+        referenceElements: {
+            dots: ReadonlyArray<ReferenceDotSettings>;
+            areas: ReadonlyArray<ReferenceAreaSettings>;
+            lines: ReadonlyArray<ReferenceLineSettings>;
+        };
+        rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+        tooltip: import('../tooltipSlice').TooltipState;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string;
+        memoizedResultFunc: ((resultFuncArgs_0: AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string;
+        dependencies: [typeof selectTooltipAxis, typeof selectHasBar, (state: RechartsRootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, (state: RechartsRootState) => RechartsScale | undefined, typeof selectTooltipAxisRange, (state: RechartsRootState) => ReadonlyArray<unknown> | undefined, (state: RechartsRootState) => ReadonlyArray<unknown> | undefined, typeof selectTooltipAxisType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const selectActiveTooltipIndex: (state: RechartsRootState) => TooltipIndex | null;
+export declare const selectActiveLabel: (state: RechartsRootState) => string | undefined;
+export declare const selectActiveTooltipDataKey: (state: RechartsRootState) => DataKey<any> | undefined;
+export declare const selectActiveTooltipCoordinate: (state: RechartsRootState) => Coordinate | undefined;
+export declare const selectIsTooltipActive: (state: RechartsRootState) => boolean;
+export declare const selectActiveTooltipPayload: (state: RechartsRootState) => TooltipPayload | undefined;
+export declare const selectActiveTooltipDataPoints: ((state: {
+    brush: import('../brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<AxisId, import('../cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<AxisId, import('../cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<AxisId, import('../cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: ChartDataState;
+    graphicalItems: import('../graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: LayoutType;
+        width: number;
+        height: number;
+        margin: import('../../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('../legendSlice').LegendSettings;
+        size: import('../../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('../optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<AxisId, import('../polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('../polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<ReferenceDotSettings>;
+        areas: ReadonlyArray<ReferenceAreaSettings>;
+        lines: ReadonlyArray<ReferenceLineSettings>;
+    };
+    rootProps: import('../rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('../tooltipSlice').TooltipState;
+}) => TooltipPayloadEntry[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: TooltipPayload) => TooltipPayloadEntry[];
+    memoizedResultFunc: ((resultFuncArgs_0: TooltipPayload) => TooltipPayloadEntry[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => TooltipPayloadEntry[];
+    dependencies: [(state: RechartsRootState) => TooltipPayload | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export {};

package/dist/state/selectors/touchSelectors.d.ts

@@ -0,0 +1,4 @@
+import { RechartsRootState } from '../store';
+import { TooltipIndex } from '../tooltipSlice';
+import { Coordinate, DataKey } from '../../types';
+export declare const selectTooltipCoordinate: (state: RechartsRootState, tooltipIndex: TooltipIndex, dataKey: DataKey<any> | undefined) => Coordinate | undefined;

package/dist/state/store.d.ts

@@ -0,0 +1,74 @@
+import { Action, Dispatch, Store } from '@reduxjs/toolkit';
+declare const rootReducer: import('@reduxjs/toolkit').Reducer<{
+    brush: import('./brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<import('./cartesianAxisSlice').AxisId, import('./cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<import('./cartesianAxisSlice').AxisId, import('./cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<import('./cartesianAxisSlice').AxisId, import('./cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: import('./chartDataSlice').ChartDataState;
+    graphicalItems: import('./graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: import('../types').LayoutType;
+        width: number;
+        height: number;
+        margin: import('../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('./legendSlice').LegendSettings;
+        size: import('../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('./optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<import('./cartesianAxisSlice').AxisId, import('./polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<import('./cartesianAxisSlice').AxisId, import('./polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('./polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<import('./referenceElementsSlice').ReferenceDotSettings>;
+        areas: ReadonlyArray<import('./referenceElementsSlice').ReferenceAreaSettings>;
+        lines: ReadonlyArray<import('./referenceElementsSlice').ReferenceLineSettings>;
+    };
+    rootProps: import('./rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('./tooltipSlice').TooltipState;
+}, import('@reduxjs/toolkit').UnknownAction, Partial<{
+    brush: import('./brushSlice').BrushSettings;
+    cartesianAxis: {
+        xAxis: Record<import('./cartesianAxisSlice').AxisId, import('./cartesianAxisSlice').XAxisSettings>;
+        yAxis: Record<import('./cartesianAxisSlice').AxisId, import('./cartesianAxisSlice').YAxisSettings>;
+        zAxis: Record<import('./cartesianAxisSlice').AxisId, import('./cartesianAxisSlice').ZAxisSettings>;
+    };
+    chartData: import('./chartDataSlice').ChartDataState;
+    graphicalItems: import('./graphicalItemsSlice').GraphicalItemsState;
+    layout: {
+        layoutType: import('../types').LayoutType;
+        width: number;
+        height: number;
+        margin: import('../types').Margin;
+        scale: number;
+    };
+    legend: {
+        settings: import('./legendSlice').LegendSettings;
+        size: import('../types').Size;
+        payload: ReadonlyArray<ReadonlyArray<import('../components/DefaultLegendContent').LegendPayload>>;
+    };
+    options: import('./optionsSlice').ChartOptions;
+    polarAxis: {
+        radiusAxis: Record<import('./cartesianAxisSlice').AxisId, import('./polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<import('./cartesianAxisSlice').AxisId, import('./polarAxisSlice').AngleAxisSettings>;
+    };
+    polarOptions: import('./polarOptionsSlice').PolarChartOptions;
+    referenceElements: {
+        dots: ReadonlyArray<import('./referenceElementsSlice').ReferenceDotSettings>;
+        areas: ReadonlyArray<import('./referenceElementsSlice').ReferenceAreaSettings>;
+        lines: ReadonlyArray<import('./referenceElementsSlice').ReferenceLineSettings>;
+    };
+    rootProps: import('./rootPropsSlice').UpdatableChartOptions;
+    tooltip: import('./tooltipSlice').TooltipState;
+}>>;
+export declare function createRechartsStore(preloadedState?: Partial<RechartsRootState>, chartName?: string): Store<RechartsRootState>;
+export type RechartsRootState = ReturnType<typeof rootReducer>;
+export type AppDispatch = Dispatch<Action>;
+export {};