vccs 0.0.1 → 0.2.0

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

@@ -0,0 +1,76 @@
+import { RechartsRootState } from '../store';
+import { BaseAxisWithScale } from './axisSelectors';
+import { AxisId } from '../cartesianAxisSlice';
+import { ChartDataState } from '../chartDataSlice';
+import { AngleAxisSettings, RadiusAxisSettings } from '../polarAxisSlice';
+import { RechartsScale } from '../../types/scale';
+import { AngleAxisForRadar, RadarComposedData, RadiusAxisForRadar } from '../../types/radar';
+import { DataKey, LayoutType } from '../../types';
+export declare const selectRadiusAxisForBandSize: (state: RechartsRootState, radiusAxisId: AxisId) => BaseAxisWithScale | undefined;
+declare function selectAngleAxisForRadar(state: RechartsRootState, _radiusAxisId: AxisId, angleAxisId: AxisId): AngleAxisSettings | undefined;
+declare function selectPolarAxisScaleForRadar(state: RechartsRootState, _radiusAxisId: AxisId, angleAxisId: AxisId): RechartsScale | undefined;
+export declare const selectAngleAxisForBandSize: ((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, RadiusAxisSettings>;
+        angleAxis: Record<AxisId, 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;
+}, _radiusAxisId: AxisId, angleAxisId: AxisId) => BaseAxisWithScale) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: AngleAxisSettings, resultFuncArgs_1: RechartsScale) => BaseAxisWithScale;
+    memoizedResultFunc: ((resultFuncArgs_0: AngleAxisSettings, resultFuncArgs_1: RechartsScale) => BaseAxisWithScale) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => BaseAxisWithScale;
+    dependencies: [typeof selectAngleAxisForRadar, typeof selectPolarAxisScaleForRadar];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const selectAngleAxisWithScaleAndViewport: (state: RechartsRootState, _radiusAxisId: AxisId, angleAxisId: AxisId) => AngleAxisForRadar;
+export declare function computeRadarPoints({ radiusAxis, angleAxis, displayedData, dataKey, bandSize, }: {
+    radiusAxis: RadiusAxisForRadar;
+    angleAxis: AngleAxisForRadar;
+    displayedData: any[];
+    dataKey: DataKey<any>;
+    bandSize: number;
+}): RadarComposedData;
+export declare const selectRadarPoints: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId, isPanorama: boolean, radarDataKey: DataKey<any> | undefined) => RadarComposedData | undefined;
+export {};

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

@@ -0,0 +1,61 @@
+import { Series } from 'victory-vendor/d3-shape';
+import { RechartsRootState } from '../store';
+import { AxisId } from '../cartesianAxisSlice';
+import { BaseAxisWithScale } from './axisSelectors';
+import { BarWithPosition, MaybeStackedGraphicalItem, SizeList } from './barSelectors';
+import { DataKey, LayoutType, TickItem } from '../../types';
+import { StackId } from '../../types/tick';
+import { BarPositionPosition } from '../../types/bar';
+import { LegendType } from '../../types/legend';
+import { LegendPayload } from '../../components/DefaultLegendContent';
+import { SectorProps } from '../../shape/Sector';
+export interface RadialBarSettings extends MaybeStackedGraphicalItem {
+    dataKey: DataKey<any> | undefined;
+    minPointSize: number;
+    stackId: StackId | undefined;
+    maxBarSize: number | undefined;
+}
+export declare const selectRadiusAxisWithScale: (state: RechartsRootState, radiusAxisId: AxisId) => BaseAxisWithScale | undefined;
+export declare function selectRadiusAxisTicks(state: RechartsRootState, radiusAxisId: AxisId, _angleAxisId: AxisId, isPanorama: boolean): ReadonlyArray<TickItem> | undefined;
+export declare const selectAngleAxisWithScale: (state: RechartsRootState, _radiusAxisId: AxisId, angleAxisId: AxisId) => BaseAxisWithScale | undefined;
+export declare const selectBandSizeOfPolarAxis: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId, isPanorama: boolean) => number | undefined;
+export declare const selectBaseValue: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId) => number | unknown;
+export declare function pickMaxBarSize(_state: RechartsRootState, _radiusAxisId: AxisId, _angleAxisId: AxisId, radialBarSettings: RadialBarSettings): number | undefined;
+export declare const selectPolarBarSizeList: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId, radialBarSettings: RadialBarSettings) => SizeList | undefined;
+export declare const selectPolarBarBandSize: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId, radialBarSettings: RadialBarSettings) => number | undefined;
+export declare const selectAllPolarBarPositions: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId, radialBarSettings: RadialBarSettings) => ReadonlyArray<BarWithPosition> | undefined;
+export declare const selectPolarBarPosition: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId, radialBarSettings: RadialBarSettings) => BarPositionPosition | undefined;
+export interface RadialBarDataItem {
+    cx: number;
+    cy: number;
+    innerRadius: number | null | undefined;
+    outerRadius: number | undefined;
+    startAngle: number | null;
+    endAngle: number;
+    value?: any;
+    payload?: any;
+    background?: SectorProps;
+    [key: string]: any;
+}
+export declare function computeRadialBarDataItems({ displayedData, stackedData, dataStartIndex, stackedDomain, dataKey, baseValue, layout, radiusAxis, radiusAxisTicks, bandSize, pos, angleAxis, minPointSize, cx, cy, angleAxisTicks, startAngle: rootStartAngle, endAngle: rootEndAngle, }: {
+    displayedData: ReadonlyArray<any>;
+    stackedData: Series<Record<number, number>, DataKey<any>> | undefined;
+    dataStartIndex: number;
+    stackedDomain: ReadonlyArray<unknown> | null;
+    dataKey: DataKey<any> | undefined;
+    baseValue: number | unknown;
+    layout: LayoutType;
+    radiusAxis: BaseAxisWithScale;
+    radiusAxisTicks: ReadonlyArray<TickItem>;
+    bandSize: number;
+    pos: BarPositionPosition;
+    angleAxis: BaseAxisWithScale;
+    minPointSize: number;
+    cx: number;
+    cy: number;
+    angleAxisTicks: ReadonlyArray<TickItem>;
+    startAngle: number;
+    endAngle: number;
+}): ReadonlyArray<RadialBarDataItem>;
+export declare const selectRadialBarSectors: (state: RechartsRootState, radiusAxisId: AxisId, angleAxisId: AxisId, radialBarSettings: RadialBarSettings) => ReadonlyArray<RadialBarDataItem> | undefined;
+export declare const selectRadialBarLegendPayload: (state: RechartsRootState, legendType: LegendType) => Array<LegendPayload> | undefined;

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

@@ -0,0 +1,11 @@
+import { StackOffsetType, SyncMethod } from '../../types';
+import { RechartsRootState } from '../store';
+export declare const selectRootMaxBarSize: (state: RechartsRootState) => number;
+export declare const selectBarGap: (state: RechartsRootState) => string | number;
+export declare function selectBarCategoryGap(state: RechartsRootState): string | number;
+export declare const selectRootBarSize: (state: RechartsRootState) => string | number;
+export declare const selectStackOffsetType: (state: RechartsRootState) => StackOffsetType;
+export declare const selectChartName: (state: RechartsRootState) => string;
+export declare const selectSyncId: (state: RechartsRootState) => string | number;
+export declare const selectSyncMethod: (state: RechartsRootState) => SyncMethod;
+export declare const selectEventEmitter: (state: RechartsRootState) => symbol;

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

@@ -0,0 +1,21 @@
+import { RechartsRootState } from '../store';
+import { AxisId } from '../cartesianAxisSlice';
+import { ChartData } from '../chartDataSlice';
+import { BaseAxisWithScale, ZAxisWithScale } from './axisSelectors';
+import { DataKey, ScatterPointItem, TickItem, TooltipType } from '../../types';
+export type ResolvedScatterSettings = {
+    data: ChartData | undefined;
+    dataKey: DataKey<any> | undefined;
+    tooltipType: TooltipType | undefined;
+    name: string | number;
+};
+export declare function computeScatterPoints({ displayedData, xAxis, yAxis, zAxis, scatterSettings, xAxisTicks, yAxisTicks, }: {
+    displayedData: ReadonlyArray<unknown>;
+    xAxis: BaseAxisWithScale;
+    yAxis: BaseAxisWithScale;
+    zAxis: ZAxisWithScale | undefined;
+    scatterSettings: ResolvedScatterSettings;
+    xAxisTicks: ReadonlyArray<TickItem> | undefined;
+    yAxisTicks: ReadonlyArray<TickItem> | undefined;
+}): ReadonlyArray<ScatterPointItem>;
+export declare const selectScatterPoints: (state: RechartsRootState, xAxisId: AxisId, yAxisId: AxisId, zAxisId: AxisId, scatterSettings: ResolvedScatterSettings, isPanorama: boolean) => ReadonlyArray<ScatterPointItem> | undefined;

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

@@ -0,0 +1,382 @@
+import { RechartsRootState } from '../store';
+import { selectTooltipAxisType } from './tooltipSelectors';
+import { ChartPointer } from '../../types';
+export declare const selectActivePropsFromChartPointer: ((state: {
+    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;
+}, chartPointer: ChartPointer) => import('../tooltipSlice').ActiveTooltipProps) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ChartPointer, resultFuncArgs_1: import('../../types').LayoutType, resultFuncArgs_2: Required<import('../../cartesian/type').PolarViewBox>, resultFuncArgs_3: import('./axisSelectors').XorYType, resultFuncArgs_4: import('./axisSelectors').AxisRange, resultFuncArgs_5: readonly import('../../types').TickItem[], resultFuncArgs_6: import('../../types').TickItem[], resultFuncArgs_7: Required<import('../../types').ChartOffset>) => import('../tooltipSlice').ActiveTooltipProps;
+    memoizedResultFunc: ((resultFuncArgs_0: ChartPointer, resultFuncArgs_1: import('../../types').LayoutType, resultFuncArgs_2: Required<import('../../cartesian/type').PolarViewBox>, resultFuncArgs_3: import('./axisSelectors').XorYType, resultFuncArgs_4: import('./axisSelectors').AxisRange, resultFuncArgs_5: readonly import('../../types').TickItem[], resultFuncArgs_6: import('../../types').TickItem[], resultFuncArgs_7: Required<import('../../types').ChartOffset>) => import('../tooltipSlice').ActiveTooltipProps) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import('../tooltipSlice').ActiveTooltipProps;
+    dependencies: [(_state: RechartsRootState, chartPointer: ChartPointer) => ChartPointer, (state: RechartsRootState) => import('../../types').LayoutType, (state: RechartsRootState) => import('../../cartesian/type').PolarViewBoxRequired | undefined, typeof selectTooltipAxisType, ((state: {
+        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('./axisSelectors').AxisRange) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_1: import('./axisSelectors').AxisRange) => import('./axisSelectors').AxisRange;
+        memoizedResultFunc: ((resultFuncArgs_0: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_1: import('./axisSelectors').AxisRange) => import('./axisSelectors').AxisRange) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import('./axisSelectors').AxisRange;
+        dependencies: [typeof import('./tooltipSelectors').selectTooltipAxis, (state: RechartsRootState) => import('./axisSelectors').AxisRange | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, ((state: {
+        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;
+    }) => readonly import('../../types').TickItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_2: string, resultFuncArgs_3: import('../../types/scale').RechartsScale, resultFuncArgs_4: import('./axisSelectors').AxisRange, resultFuncArgs_5: readonly unknown[], resultFuncArgs_6: readonly unknown[], resultFuncArgs_7: import('./axisSelectors').XorYType) => readonly import('../../types').TickItem[];
+        memoizedResultFunc: ((resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_2: string, resultFuncArgs_3: import('../../types/scale').RechartsScale, resultFuncArgs_4: import('./axisSelectors').AxisRange, resultFuncArgs_5: readonly unknown[], resultFuncArgs_6: readonly unknown[], resultFuncArgs_7: import('./axisSelectors').XorYType) => readonly import('../../types').TickItem[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => readonly import('../../types').TickItem[];
+        dependencies: [(state: RechartsRootState) => import('../../types').LayoutType, typeof import('./tooltipSelectors').selectTooltipAxis, ((state: {
+            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;
+        }) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string;
+            memoizedResultFunc: ((resultFuncArgs_0: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => string;
+            dependencies: [typeof import('./tooltipSelectors').selectTooltipAxis, typeof import('./axisSelectors').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) => import('../../types/scale').RechartsScale | undefined, (state: RechartsRootState) => import('./axisSelectors').AxisRange | undefined, (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;
+    }, ((state: {
+        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('../../types').TickItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: readonly import('../../types').TickItem[]) => import('../../types').TickItem[];
+        memoizedResultFunc: ((resultFuncArgs_0: readonly import('../../types').TickItem[]) => import('../../types').TickItem[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import('../../types').TickItem[];
+        dependencies: [((state: {
+            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;
+        }) => readonly import('../../types').TickItem[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_2: string, resultFuncArgs_3: import('../../types/scale').RechartsScale, resultFuncArgs_4: import('./axisSelectors').AxisRange, resultFuncArgs_5: readonly unknown[], resultFuncArgs_6: readonly unknown[], resultFuncArgs_7: import('./axisSelectors').XorYType) => readonly import('../../types').TickItem[];
+            memoizedResultFunc: ((resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_2: string, resultFuncArgs_3: import('../../types/scale').RechartsScale, resultFuncArgs_4: import('./axisSelectors').AxisRange, resultFuncArgs_5: readonly unknown[], resultFuncArgs_6: readonly unknown[], resultFuncArgs_7: import('./axisSelectors').XorYType) => readonly import('../../types').TickItem[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => readonly import('../../types').TickItem[];
+            dependencies: [(state: RechartsRootState) => import('../../types').LayoutType, typeof import('./tooltipSelectors').selectTooltipAxis, ((state: {
+                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;
+            }) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string;
+                memoizedResultFunc: ((resultFuncArgs_0: import('./axisSelectors').AxisWithTicksSettings, resultFuncArgs_1: boolean, resultFuncArgs_2: string) => string) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => string;
+                dependencies: [typeof import('./tooltipSelectors').selectTooltipAxis, typeof import('./axisSelectors').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) => import('../../types/scale').RechartsScale | undefined, (state: RechartsRootState) => import('./axisSelectors').AxisRange | undefined, (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;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, (state: RechartsRootState) => import('../../types').ChartOffsetRequired];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};

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

@@ -0,0 +1,4 @@
+import { RechartsRootState } from '../store';
+import { XAxisSettings, YAxisSettings } from '../cartesianAxisSlice';
+export declare const selectAllXAxes: (state: RechartsRootState) => ReadonlyArray<XAxisSettings>;
+export declare const selectAllYAxes: (state: RechartsRootState) => ReadonlyArray<YAxisSettings>;