vccs 0.0.1 → 0.2.0

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

@@ -0,0 +1,10 @@
+import { RechartsRootState } from '../store';
+import { BrushSettings } from '../brushSlice';
+export declare const selectBrushSettings: (state: RechartsRootState) => BrushSettings;
+export type BrushDimensions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare const selectBrushDimensions: (state: RechartsRootState) => BrushDimensions;

package/dist/state/selectors/combiners/combineActiveLabel.d.ts

@@ -0,0 +1,3 @@
+import { TooltipIndex } from '../../tooltipSlice';
+import { TickItem } from '../../../types';
+export declare function combineActiveLabel(tooltipTicks: ReadonlyArray<TickItem>, activeIndex: TooltipIndex): string | undefined;

package/dist/state/selectors/combiners/combineActiveTooltipIndex.d.ts

@@ -0,0 +1,5 @@
+import { TooltipIndex, TooltipInteractionState } from '../../tooltipSlice';
+import { ChartData } from '../../chartDataSlice';
+import { CategoricalDomain, DataKey } from '../../../types';
+import { NumberDomain } from '../../../types/axis';
+export declare function combineActiveTooltipIndex(tooltipInteraction: TooltipInteractionState, chartData: ChartData, axisDataKey?: DataKey<unknown>, domain?: NumberDomain | CategoricalDomain): TooltipIndex | null;

package/dist/state/selectors/combiners/combineAxisRangeWithReverse.d.ts

@@ -0,0 +1,3 @@
+import { BaseCartesianAxis } from '../../cartesianAxisSlice';
+import { AxisRange } from '../axisSelectors';
+export declare function combineAxisRangeWithReverse(axisSettings: BaseCartesianAxis | undefined, axisRange: AxisRange | undefined): AxisRange | undefined;

package/dist/state/selectors/combiners/combineCoordinateForDefaultIndex.d.ts

@@ -0,0 +1,3 @@
+import { ChartOffset, Coordinate, LayoutType, TickItem } from '../../../types';
+import { TooltipIndex, TooltipPayloadConfiguration, TooltipPayloadSearcher } from '../../tooltipSlice';
+export declare function combineCoordinateForDefaultIndex(width: number, height: number, layout: LayoutType, offset: ChartOffset | undefined, tooltipTicks: ReadonlyArray<TickItem>, defaultIndex: TooltipIndex | undefined, tooltipConfigurations: ReadonlyArray<TooltipPayloadConfiguration>, tooltipPayloadSearcher: TooltipPayloadSearcher | undefined): Coordinate | undefined;

package/dist/state/selectors/combiners/combineTooltipInteractionState.d.ts

@@ -0,0 +1,3 @@
+import { TooltipIndex, TooltipInteractionState, TooltipState } from '../../tooltipSlice';
+import { TooltipEventType, TooltipTrigger } from '../../../types';
+export declare function combineTooltipInteractionState(tooltipState: TooltipState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined): TooltipInteractionState;

package/dist/state/selectors/combiners/combineTooltipPayloadConfigurations.d.ts

@@ -0,0 +1,3 @@
+import { TooltipEventType, TooltipTrigger } from '../../../types';
+import { TooltipIndex, TooltipPayloadConfiguration, TooltipState } from '../../tooltipSlice';
+export declare function combineTooltipPayloadConfigurations(tooltipState: TooltipState, tooltipEventType: TooltipEventType, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined): ReadonlyArray<TooltipPayloadConfiguration>;

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

@@ -0,0 +1,2 @@
+import { RechartsRootState } from '../store';
+export declare const selectChartLayout: (state: RechartsRootState) => import('../../types').LayoutType;

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

@@ -0,0 +1,6 @@
+import { Margin } from '../../types';
+import { RechartsRootState } from '../store';
+export declare const selectChartWidth: (state: RechartsRootState) => number;
+export declare const selectChartHeight: (state: RechartsRootState) => number;
+export declare const selectContainerScale: (state: RechartsRootState) => number;
+export declare const selectMargin: (state: RechartsRootState) => Margin | undefined;

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

@@ -0,0 +1,23 @@
+import { RechartsRootState } from '../store';
+import { ChartDataState } from '../chartDataSlice';
+import { AxisId } from '../cartesianAxisSlice';
+/**
+ * This selector always returns the data with the indexes set by a Brush.
+ * Trouble is, that might or might not be what you want.
+ *
+ * In charts with Brush, you will sometimes want to select the full range of data, and sometimes the one decided by the Brush
+ * - even if the Brush is active, the panorama inside the Brush should show the full range of data.
+ *
+ * So instead of this selector, consider using either selectChartDataAndAlwaysIgnoreIndexes or selectChartDataWithIndexesIfNotInPanorama
+ *
+ * @param state RechartsRootState
+ * @returns data defined on the chart root element, such as BarChart or ScatterChart
+ */
+export declare const selectChartDataWithIndexes: (state: RechartsRootState) => ChartDataState;
+/**
+ * This selector will always return the full range of data, ignoring the indexes set by a Brush.
+ * Useful for when you want to render the full range of data, even if a Brush is active.
+ * For example: in the Brush panorama, in Legend, in Tooltip.
+ */
+export declare const selectChartDataAndAlwaysIgnoreIndexes: (state: RechartsRootState) => ChartDataState;
+export declare function selectChartDataWithIndexesIfNotInPanorama(state: RechartsRootState, _xAxisId: AxisId, _yAxisId: AxisId, isPanorama: boolean): ChartDataState;

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

@@ -0,0 +1,69 @@
+import { RechartsRootState } from '../store';
+import { DataKey, TooltipType } from '../../types';
+export type ResolvedFunnelSettings = {
+    dataKey: DataKey<any>;
+    data: any[] | undefined;
+    nameKey: DataKey<any>;
+    tooltipType?: TooltipType;
+    lastShapeType?: 'triangle' | 'rectangle';
+    reversed?: boolean;
+    customWidth?: string | number;
+    presentationProps: Record<string, any> | null;
+};
+declare function pickFunnelSettings(_state: RechartsRootState, funnelSettings: ResolvedFunnelSettings): ResolvedFunnelSettings;
+export declare const selectFunnelTrapezoids: ((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;
+}, funnelSettings: ResolvedFunnelSettings) => import('../../cartesian/funnel/type').FunnelComposedData) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Required<import('../../types').ChartOffset>, resultFuncArgs_1: ResolvedFunnelSettings, resultFuncArgs_2: import('../chartDataSlice').ChartDataState) => import('../../cartesian/funnel/type').FunnelComposedData;
+    memoizedResultFunc: ((resultFuncArgs_0: Required<import('../../types').ChartOffset>, resultFuncArgs_1: ResolvedFunnelSettings, resultFuncArgs_2: import('../chartDataSlice').ChartDataState) => import('../../cartesian/funnel/type').FunnelComposedData) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import('../../cartesian/funnel/type').FunnelComposedData;
+    dependencies: [(state: RechartsRootState) => import('../../types').ChartOffsetRequired, typeof pickFunnelSettings, (state: RechartsRootState) => import('../chartDataSlice').ChartDataState];
+    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/legendSelectors.d.ts

@@ -0,0 +1,7 @@
+import { RechartsRootState } from '../store';
+import { LegendSettings } from '../legendSlice';
+import { Size } from '../../types';
+import { LegendPayload } from '../../components/DefaultLegendContent';
+export declare const selectLegendSettings: (state: RechartsRootState) => LegendSettings;
+export declare const selectLegendSize: (state: RechartsRootState) => Size;
+export declare const selectLegendPayload: (state: RechartsRootState) => ReadonlyArray<LegendPayload>;

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

@@ -0,0 +1,123 @@
+import { RechartsRootState } from '../store';
+import { AxisId } from '../cartesianAxisSlice';
+import { selectChartDataWithIndexesIfNotInPanorama } from './dataSelectors';
+import { ChartData } from '../chartDataSlice';
+import { DataKey } from '../../types';
+export type ResolvedLineSettings = {
+    data: ChartData | undefined;
+    dataKey: DataKey<any> | undefined;
+};
+declare function selectXAxisWithScale(state: RechartsRootState, xAxisId: AxisId, _yAxisId: AxisId, isPanorama: boolean): import('./axisSelectors').BaseAxisWithScale;
+declare function selectXAxisTicks(state: RechartsRootState, xAxisId: AxisId, _yAxisId: AxisId, isPanorama: boolean): import('../../types').TickItem[];
+declare function selectYAxisWithScale(state: RechartsRootState, _xAxisId: AxisId, yAxisId: AxisId, isPanorama: boolean): import('./axisSelectors').BaseAxisWithScale;
+declare function selectYAxisTicks(state: RechartsRootState, _xAxisId: AxisId, yAxisId: AxisId, isPanorama: boolean): import('../../types').TickItem[];
+export declare const selectLinePoints: ((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: 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<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<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;
+}, xAxisId: AxisId, yAxisId: AxisId, isPanorama: boolean, lineSettings: ResolvedLineSettings) => readonly import('../..').LinePointItem[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_2: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_3: import('../../types').TickItem[], resultFuncArgs_4: import('../../types').TickItem[], resultFuncArgs_5: ResolvedLineSettings, resultFuncArgs_6: number, resultFuncArgs_7: import('../chartDataSlice').ChartDataState) => readonly import('../..').LinePointItem[];
+    memoizedResultFunc: ((resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_2: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_3: import('../../types').TickItem[], resultFuncArgs_4: import('../../types').TickItem[], resultFuncArgs_5: ResolvedLineSettings, resultFuncArgs_6: number, resultFuncArgs_7: import('../chartDataSlice').ChartDataState) => readonly import('../..').LinePointItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => readonly import('../..').LinePointItem[];
+    dependencies: [(state: RechartsRootState) => import('../../types').LayoutType, typeof selectXAxisWithScale, typeof selectYAxisWithScale, typeof selectXAxisTicks, typeof selectYAxisTicks, (state: RechartsRootState, xAxisId: AxisId, yAxisId: AxisId, isPanorama: boolean, lineSettings: ResolvedLineSettings) => ResolvedLineSettings | undefined, ((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: 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<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+            angleAxis: Record<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;
+    }, xAxisId: AxisId, _yAxisId: AxisId, isPanorama: boolean) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_2: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_3: import('../../types').TickItem[], resultFuncArgs_4: import('../../types').TickItem[]) => number;
+        memoizedResultFunc: ((resultFuncArgs_0: import('../../types').LayoutType, resultFuncArgs_1: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_2: import('./axisSelectors').BaseAxisWithScale, resultFuncArgs_3: import('../../types').TickItem[], resultFuncArgs_4: import('../../types').TickItem[]) => number) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => number;
+        dependencies: [(state: RechartsRootState) => import('../../types').LayoutType, typeof selectXAxisWithScale, typeof selectYAxisWithScale, typeof selectXAxisTicks, typeof selectYAxisTicks];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, typeof selectChartDataWithIndexesIfNotInPanorama];
+    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/pickAxisId.d.ts

@@ -0,0 +1,3 @@
+import { RechartsRootState } from '../store';
+import { AxisId } from '../cartesianAxisSlice';
+export declare const pickAxisId: (_state: RechartsRootState, _axisType: unknown, axisId: AxisId) => AxisId;

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

@@ -0,0 +1,2 @@
+import { RechartsRootState } from '../store';
+export declare const pickAxisType: <T>(_state: RechartsRootState, axisType: T) => T;

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

@@ -0,0 +1,55 @@
+import { RechartsRootState } from '../store';
+import { ChartData } from '../chartDataSlice';
+import { ChartOffset, Coordinate, DataKey, TooltipType } from '../../types';
+import { LegendType } from '../../types/legend';
+import { LegendPayload } from '../../components/DefaultLegendContent';
+export type ResolvedPieSettings = {
+    name?: string | number | undefined;
+    nameKey: DataKey<any>;
+    data?: ChartData | undefined;
+    dataKey: DataKey<any> | undefined;
+    tooltipType?: TooltipType | undefined;
+    legendType?: LegendType;
+    fill: string;
+    cx?: number | string;
+    cy?: number | string;
+    startAngle?: number;
+    endAngle?: number;
+    paddingAngle?: number;
+    minAngle?: number;
+    innerRadius?: number | string;
+    outerRadius?: number | string | ((element: any) => number);
+    cornerRadius?: number | string;
+    presentationProps?: Record<string, string>;
+};
+export type PieCoordinate = {
+    cx: number;
+    cy: number;
+    innerRadius: number;
+    outerRadius: number;
+    maxRadius: number;
+};
+export type PieSectorDataItem = ResolvedPieSettings & PieCoordinate & {
+    cornerRadius: number | undefined;
+    percent: number;
+    value: number;
+    name: string | number;
+    startAngle: number;
+    endAngle: number;
+    midAngle: number;
+    middleRadius: number;
+    paddingAngle: number;
+    payload: any;
+    fill: string;
+    tooltipPosition: Coordinate;
+    dataKey: DataKey<any>;
+};
+export declare const selectDisplayedData: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => ChartData | undefined;
+export declare const selectPieLegend: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => ReadonlyArray<LegendPayload> | undefined;
+export declare const selectSynchronisedPieSettings: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => ResolvedPieSettings | undefined;
+export declare function computePieSectors({ pieSettings, displayedData, offset, }: {
+    pieSettings: ResolvedPieSettings;
+    displayedData: ChartData;
+    offset: ChartOffset;
+}): ReadonlyArray<PieSectorDataItem> | undefined;
+export declare const selectPieSectors: (state: RechartsRootState, pieSettings: ResolvedPieSettings) => Readonly<PieSectorDataItem[]> | undefined;

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

@@ -0,0 +1,49 @@
+import { RechartsRootState } from '../store';
+import { AxisId } from '../cartesianAxisSlice';
+import { AngleAxisSettings, RadiusAxisSettings } from '../polarAxisSlice';
+import { PolarChartOptions } from '../polarOptionsSlice';
+import { AxisRange } from './axisSelectors';
+import { PolarViewBoxRequired } from '../../cartesian/type';
+export declare const defaultPolarAngleAxisProps: {
+    readonly allowDuplicatedCategory: true;
+    readonly angleAxisId: 0;
+    readonly axisLine: true;
+    readonly cx: 0;
+    readonly cy: 0;
+    readonly orientation: "outer";
+    readonly reversed: false;
+    readonly scale: "auto";
+    readonly tick: true;
+    readonly tickLine: true;
+    readonly tickSize: 8;
+    readonly type: "category";
+};
+export declare const implicitAngleAxis: AngleAxisSettings;
+export declare const defaultPolarRadiusAxisProps: {
+    readonly allowDataOverflow: false;
+    readonly allowDuplicatedCategory: true;
+    readonly angle: 0;
+    readonly axisLine: true;
+    readonly cx: 0;
+    readonly cy: 0;
+    readonly orientation: "right";
+    readonly radiusAxisId: 0;
+    readonly scale: "auto";
+    readonly stroke: "#ccc";
+    readonly tick: true;
+    readonly tickCount: 5;
+    readonly type: "number";
+};
+export declare const implicitRadiusAxis: RadiusAxisSettings;
+export declare const implicitRadialBarAngleAxis: AngleAxisSettings;
+export declare const implicitRadialBarRadiusAxis: RadiusAxisSettings;
+export declare function selectAngleAxis(state: RechartsRootState, angleAxisId: AxisId): AngleAxisSettings | undefined;
+export declare function selectRadiusAxis(state: RechartsRootState, radiusAxisId: AxisId): RadiusAxisSettings | undefined;
+export declare const selectPolarOptions: (state: RechartsRootState) => PolarChartOptions | null;
+export declare const selectMaxRadius: (state: RechartsRootState) => number;
+export declare const selectOuterRadius: (state: RechartsRootState) => number | undefined;
+export declare const selectAngleAxisRange: (state: RechartsRootState) => AxisRange;
+export declare const selectAngleAxisRangeWithReversed: (state: RechartsRootState, angleAxisId: AxisId) => AxisRange | undefined;
+export declare const selectRadiusAxisRange: (state: RechartsRootState, radiusAxisId: AxisId) => AxisRange | undefined;
+export declare const selectRadiusAxisRangeWithReversed: (state: RechartsRootState, radiusAxisId: AxisId) => AxisRange | undefined;
+export declare const selectPolarViewBox: (state: RechartsRootState) => PolarViewBoxRequired | undefined;

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

@@ -0,0 +1,118 @@
+import { RechartsRootState } from '../store';
+import { AxisId } from '../cartesianAxisSlice';
+import { CartesianTickItem } from '../../types/tick';
+export type PolarAngles = Array<number>;
+export type PolarRadius = Array<number>;
+declare function selectAngleAxisTicks(state: RechartsRootState, anglexisId: AxisId): readonly CartesianTickItem[];
+export declare const selectPolarGridAngles: ((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: 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<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<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;
+}, anglexisId: AxisId) => PolarAngles) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: readonly CartesianTickItem[]) => PolarAngles;
+    memoizedResultFunc: ((resultFuncArgs_0: readonly CartesianTickItem[]) => PolarAngles) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => PolarAngles;
+    dependencies: [typeof selectAngleAxisTicks];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+declare function selectRadiusAxisTicks(state: RechartsRootState, radiusAxisId: AxisId): readonly CartesianTickItem[];
+export declare const selectPolarGridRadii: ((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: 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<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<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;
+}, radiusAxisId: AxisId) => PolarRadius) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: readonly CartesianTickItem[]) => PolarRadius;
+    memoizedResultFunc: ((resultFuncArgs_0: readonly CartesianTickItem[]) => PolarRadius) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => PolarRadius;
+    dependencies: [typeof selectRadiusAxisTicks];
+    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/polarScaleSelectors.d.ts

@@ -0,0 +1,9 @@
+import { RechartsRootState } from '../store';
+import { AxisId } from '../cartesianAxisSlice';
+import { RechartsScale } from '../../types/scale';
+import { CartesianTickItem } from '../../types/tick';
+export declare function selectPolarAxis(state: RechartsRootState, axisType: 'angleAxis' | 'radiusAxis', axisId: AxisId): import('../polarAxisSlice').RadiusAxisSettings;
+export declare const selectPolarAxisScale: (state: RechartsRootState, axisType: 'angleAxis' | 'radiusAxis', polarAxisId: AxisId) => RechartsScale | undefined;
+export declare const selectPolarCategoricalDomain: (state: RechartsRootState, axisType: 'angleAxis' | 'radiusAxis', polarAxisId: AxisId) => ReadonlyArray<unknown> | undefined;
+export declare const selectPolarAxisTicks: (state: RechartsRootState, axisType: 'angleAxis' | 'radiusAxis', polarAxisId: AxisId, isPanorama: boolean) => ReadonlyArray<CartesianTickItem> | undefined;
+export declare const selectPolarGraphicalItemAxisTicks: (state: RechartsRootState, axisType: 'angleAxis' | 'radiusAxis', polarAxisId: AxisId, isPanorama: boolean) => ReadonlyArray<CartesianTickItem> | undefined;

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

@@ -0,0 +1,70 @@
+import { AppliedChartData, ChartData } from '../chartDataSlice';
+import { RechartsRootState } from '../store';
+import { AxisId, BaseCartesianAxis } from '../cartesianAxisSlice';
+import { AppliedChartDataWithErrorDomain, selectBaseAxis } from './axisSelectors';
+import { PolarGraphicalItemSettings } from '../graphicalItemsSlice';
+import { NumberDomain } from '../../types/axis';
+import { CategoricalDomain } from '../../types';
+export type PolarAxisType = 'angleAxis' | 'radiusAxis';
+export declare const selectUnfilteredPolarItems: (state: RechartsRootState) => readonly PolarGraphicalItemSettings[];
+export declare const selectPolarItemsSettings: (state: RechartsRootState, axisType: PolarAxisType, polarAxisId: AxisId) => ReadonlyArray<PolarGraphicalItemSettings>;
+export declare const selectPolarDisplayedData: (state: RechartsRootState, axisType: PolarAxisType, polarAxisId: AxisId) => ChartData | undefined;
+export declare const selectPolarAppliedValues: (state: RechartsRootState, axisType: PolarAxisType, axisId: AxisId) => AppliedChartData;
+export declare const selectAllPolarAppliedNumericalValues: (state: RechartsRootState, axisType: PolarAxisType, axisId: AxisId) => ReadonlyArray<AppliedChartDataWithErrorDomain>;
+export declare const selectPolarAxisDomain: (state: RechartsRootState, axisType: PolarAxisType, polarAxisId: AxisId) => NumberDomain | CategoricalDomain | undefined;
+export declare const selectPolarNiceTicks: ((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: 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<AxisId, import('../polarAxisSlice').RadiusAxisSettings>;
+        angleAxis: Record<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;
+}, axisType: "angleAxis" | "radiusAxis", polarAxisId: AxisId) => readonly number[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: NumberDomain | CategoricalDomain, resultFuncArgs_1: BaseCartesianAxis, resultFuncArgs_2: string) => readonly number[];
+    memoizedResultFunc: ((resultFuncArgs_0: NumberDomain | CategoricalDomain, resultFuncArgs_1: BaseCartesianAxis, resultFuncArgs_2: string) => readonly number[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => readonly number[];
+    dependencies: [(state: RechartsRootState, axisType: PolarAxisType, polarAxisId: AxisId) => NumberDomain | CategoricalDomain | undefined, typeof selectBaseAxis, (state: RechartsRootState, axisType: "xAxis" | "yAxis" | "zAxis" | "angleAxis" | "radiusAxis", axisId: AxisId) => string | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const selectPolarAxisDomainIncludingNiceTicks: (state: RechartsRootState, axisType: PolarAxisType, polarAxisId: AxisId) => NumberDomain | CategoricalDomain | undefined;