solid-recharts 0.1.0

package/src/state/selectors/pieSelectors.ts

@@ -0,0 +1,103 @@
+// Ported from recharts 3.8.1 src/state/selectors/pieSelectors.ts (commit 7a23854).
+//
+// FULL SOLID-NATIVE REWRITE: reselect `createSelector` → plain functions
+// (memoization via `useAppSelector`'s `createMemo`).
+//
+// MINIMAL PORT. Deferred (documented): the `cells` parameter + Cell-derived
+// displayedData (no Cells), and `selectPieLegend` (legend wiring is a follow-up).
+// `selectUnfilteredPolarItems` is inlined here (polarSelectors not ported yet).
+import { RechartsRootState } from "../store";
+import { GraphicalItemId, PolarGraphicalItemSettings } from "../graphicalItemsSlice";
+import { selectChartDataAndAlwaysIgnoreIndexes } from "./dataSelectors";
+import { ChartData } from "../chartDataSlice";
+import { ChartOffsetInternal } from "../../util/types";
+import { selectChartOffsetInternal } from "./selectChartOffsetInternal";
+import { PieSettings } from "../types/PieSettings";
+import { computePieSectors, PieSectorDataItem } from "../../polar/Pie";
+import type { CellProps } from "../../component/Cell";
+import type { LegendPayload } from "../../component/DefaultLegendContent";
+import { getTooltipNameProp, getValueByDataKey } from "../../util/ChartUtils";
+
+const selectUnfilteredPolarItems = (
+  state: RechartsRootState,
+): ReadonlyArray<PolarGraphicalItemSettings> => state.graphicalItems.polarItems;
+
+export const selectSynchronisedPieSettings = (
+  state: RechartsRootState,
+  id: GraphicalItemId,
+): PieSettings | undefined =>
+  selectUnfilteredPolarItems(state)
+    .filter((item) => item.type === "pie")
+    .find((item) => item.id === id);
+
+export const selectDisplayedData = (
+  state: RechartsRootState,
+  id: GraphicalItemId,
+  cells?: ReadonlyArray<CellProps>,
+): ChartData | undefined => {
+  const pieSettings = selectSynchronisedPieSettings(state, id);
+  if (pieSettings == null) {
+    return undefined;
+  }
+  if (pieSettings.data != null && pieSettings.data.length > 0) {
+    return pieSettings.data;
+  }
+  const chartData = selectChartDataAndAlwaysIgnoreIndexes(state).chartData;
+  if (chartData != null && chartData.length > 0) {
+    return chartData;
+  }
+  // recharts: when the Pie has neither its own data nor inherited chart data, the
+  // <Cell> children become the data rows (each cell's props is a row).
+  if (cells != null && cells.length > 0) {
+    return cells;
+  }
+  return chartData;
+};
+
+/**
+ * One legend entry per displayed-data row. `value` is the row name (via nameKey),
+ * `color` is the per-row fill (a matching <Cell> wins over the Pie fill), `payload`
+ * is the raw row, `type` is the Pie legendType, and `dataKey` is the Pie dataKey.
+ */
+export const selectPieLegend = (
+  state: RechartsRootState,
+  id: GraphicalItemId,
+  cells?: ReadonlyArray<CellProps>,
+): ReadonlyArray<LegendPayload> | undefined => {
+  const pieSettings = selectSynchronisedPieSettings(state, id);
+  const displayedData = selectDisplayedData(state, id, cells);
+  if (pieSettings == null || displayedData == null) {
+    return undefined;
+  }
+  return displayedData.map((entry, i): LegendPayload => {
+    const row: Record<string, unknown> =
+      typeof entry === "object" && entry != null ? { ...entry } : {};
+    const cell = cells?.[i];
+    const cellFill = typeof cell?.fill === "string" ? cell.fill : undefined;
+    const rowFill = typeof row.fill === "string" ? row.fill : undefined;
+    // recharts: name defaults to pieSettings.name (NOT the row index), then
+    // getTooltipNameProp falls back to the dataKey string when name is nullish.
+    const nameRaw: unknown = getValueByDataKey(entry, pieSettings.nameKey, pieSettings.name);
+    return {
+      value: getTooltipNameProp(nameRaw, pieSettings.dataKey),
+      color: cellFill ?? rowFill ?? pieSettings.fill,
+      type: pieSettings.legendType,
+      payload: typeof entry === "object" && entry != null ? entry : undefined,
+      dataKey: pieSettings.dataKey,
+    };
+  });
+};
+
+export const selectPieSectors = (
+  state: RechartsRootState,
+  id: GraphicalItemId,
+  cells?: ReadonlyArray<CellProps>,
+): ReadonlyArray<PieSectorDataItem> | undefined => {
+  const displayedData = selectDisplayedData(state, id, cells);
+  const pieSettings = selectSynchronisedPieSettings(state, id);
+  if (pieSettings == null || displayedData == null) {
+    return undefined;
+  }
+  const offset: ChartOffsetInternal = selectChartOffsetInternal(state);
+  return computePieSectors({ offset, pieSettings, displayedData, cells });
+};

package/src/state/selectors/polarAxisSelectors.ts

@@ -0,0 +1,202 @@
+// Ported from recharts 3.8.1 src/state/selectors/polarAxisSelectors.ts (commit 7a23854).
+//
+// FULL SOLID-NATIVE REWRITE: reselect `createSelector` → plain functions
+// (memoization is provided by `useAppSelector`'s `createMemo`).
+//
+// SCOPE: both the polar-VIEWBOX cluster (selectPolarOptions, selectMaxRadius,
+// selectInnerRadius, selectOuterRadius, selectPolarViewBox) AND the angle/radius
+// AXIS selectors (selectAngleAxis/selectRadiusAxis + ranges, implicitAngle/
+// RadiusAxis) are ported in this file.
+import { RechartsRootState } from "../store";
+import { PolarChartState } from "../polarOptionsSlice";
+import { AxisId } from "../cartesianAxisSlice";
+import { AngleAxisSettings, RadiusAxisSettings } from "../polarAxisSlice";
+import { selectChartHeight, selectChartWidth } from "./containerSelectors";
+import { selectChartOffsetInternal } from "./selectChartOffsetInternal";
+import { getMaxRadius } from "../../util/PolarUtils";
+import { getPercentValue } from "../../util/DataUtils";
+import { AxisDomainTypeInput, PolarLayout, PolarViewBoxRequired } from "../../util/types";
+import { selectChartLayout, selectPolarChartLayout } from "../../context/chartLayoutContext";
+import { getAxisTypeBasedOnLayout } from "../../util/getAxisTypeBasedOnLayout";
+import { defaultPolarAngleAxisProps } from "../../polar/defaultPolarAngleAxisProps";
+import { defaultPolarRadiusAxisProps } from "../../polar/defaultPolarRadiusAxisProps";
+// Value-import cycle with axisSelectors (it imports selectAngleAxis/… back),
+// resolved lazily at call time — same shape recharts uses.
+import { AxisRange } from "./axisSelectors";
+import { combineAxisRangeWithReverse } from "./combiners/combineAxisRangeWithReverse";
+
+/**
+ * If an angle/radius axis is not explicitly declared we still need defaults to
+ * hold the domain. Mirrors recharts' implicitAngleAxis/implicitRadiusAxis;
+ * `type` is the unresolved `AxisDomainTypeInput` ("auto") — `selectAngleAxis`/
+ * `selectRadiusAxis` resolve it against the layout.
+ */
+export const implicitAngleAxis: Omit<AngleAxisSettings, "type"> & { type: AxisDomainTypeInput } = {
+  allowDataOverflow: defaultPolarAngleAxisProps.allowDataOverflow,
+  allowDecimals: defaultPolarAngleAxisProps.allowDecimals,
+  // recharts: false here on purpose (axis calc behaves as if false), despite the
+  // PolarAngleAxis default being true (which Tooltip sync needs).
+  allowDuplicatedCategory: false,
+  dataKey: undefined,
+  domain: undefined,
+  id: defaultPolarAngleAxisProps.angleAxisId,
+  includeHidden: false,
+  name: undefined,
+  reversed: defaultPolarAngleAxisProps.reversed,
+  scale: defaultPolarAngleAxisProps.scale,
+  tick: defaultPolarAngleAxisProps.tick,
+  tickCount: undefined,
+  ticks: undefined,
+  type: defaultPolarAngleAxisProps.type,
+  unit: undefined,
+  niceTicks: "auto",
+};
+
+export const implicitRadiusAxis: Omit<RadiusAxisSettings, "type"> & {
+  type: AxisDomainTypeInput;
+} = {
+  allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
+  allowDecimals: defaultPolarRadiusAxisProps.allowDecimals,
+  allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
+  dataKey: undefined,
+  domain: undefined,
+  id: defaultPolarRadiusAxisProps.radiusAxisId,
+  includeHidden: defaultPolarRadiusAxisProps.includeHidden,
+  name: undefined,
+  reversed: defaultPolarRadiusAxisProps.reversed,
+  scale: defaultPolarRadiusAxisProps.scale,
+  tick: defaultPolarRadiusAxisProps.tick,
+  tickCount: defaultPolarRadiusAxisProps.tickCount,
+  ticks: undefined,
+  type: defaultPolarRadiusAxisProps.type,
+  unit: undefined,
+  niceTicks: "auto",
+};
+
+const selectAngleAxisNoDefaults = (
+  state: RechartsRootState,
+  angleAxisId: AxisId | undefined,
+): AngleAxisSettings | undefined => {
+  if (angleAxisId == null) {
+    return undefined;
+  }
+  return state.polarAxis.angleAxis[angleAxisId];
+};
+
+export const selectAngleAxis = (
+  state: RechartsRootState,
+  angleAxisId: AxisId | undefined,
+): AngleAxisSettings => {
+  const angleAxisSettings = selectAngleAxisNoDefaults(state, angleAxisId);
+  if (angleAxisSettings != null) {
+    return angleAxisSettings;
+  }
+  const layout: PolarLayout | undefined = selectPolarChartLayout(state);
+  const evaluatedType =
+    getAxisTypeBasedOnLayout(layout, "angleAxis", implicitAngleAxis.type) ?? "category";
+  return { ...implicitAngleAxis, type: evaluatedType };
+};
+
+const selectRadiusAxisNoDefaults = (
+  state: RechartsRootState,
+  radiusAxisId: AxisId,
+): RadiusAxisSettings | undefined => state.polarAxis.radiusAxis[radiusAxisId];
+
+export const selectRadiusAxis = (
+  state: RechartsRootState,
+  radiusAxisId: AxisId,
+): RadiusAxisSettings => {
+  const radiusAxisSettings = selectRadiusAxisNoDefaults(state, radiusAxisId);
+  if (radiusAxisSettings != null) {
+    return radiusAxisSettings;
+  }
+  const layout: PolarLayout | undefined = selectPolarChartLayout(state);
+  const evaluatedType =
+    getAxisTypeBasedOnLayout(layout, "radiusAxis", implicitRadiusAxis.type) ?? "category";
+  return { ...implicitRadiusAxis, type: evaluatedType };
+};
+
+export const selectPolarOptions = (state: RechartsRootState): PolarChartState => state.polarOptions;
+
+export const selectMaxRadius = (state: RechartsRootState): number =>
+  getMaxRadius(selectChartWidth(state), selectChartHeight(state), selectChartOffsetInternal(state));
+
+export const selectInnerRadius = (state: RechartsRootState): number | undefined => {
+  const polarChartOptions = selectPolarOptions(state);
+  if (polarChartOptions == null) {
+    return undefined;
+  }
+  return getPercentValue(polarChartOptions.innerRadius, selectMaxRadius(state), 0);
+};
+
+export const selectOuterRadius = (state: RechartsRootState): number | undefined => {
+  const polarChartOptions = selectPolarOptions(state);
+  if (polarChartOptions == null) {
+    return undefined;
+  }
+  const maxRadius = selectMaxRadius(state);
+  return getPercentValue(polarChartOptions.outerRadius, maxRadius, maxRadius * 0.8);
+};
+
+export const selectPolarViewBox = (state: RechartsRootState): PolarViewBoxRequired | undefined => {
+  const layout = selectChartLayout(state);
+  const polarOptions = selectPolarOptions(state);
+  const innerRadius = selectInnerRadius(state);
+  const outerRadius = selectOuterRadius(state);
+  if (
+    (layout !== "centric" && layout !== "radial") ||
+    polarOptions == null ||
+    innerRadius == null ||
+    outerRadius == null
+  ) {
+    return undefined;
+  }
+  const width = selectChartWidth(state);
+  const height = selectChartHeight(state);
+  const { cx, cy, startAngle, endAngle } = polarOptions;
+  return {
+    cx: getPercentValue(cx, width, width / 2),
+    cy: getPercentValue(cy, height, height / 2),
+    innerRadius,
+    outerRadius,
+    startAngle,
+    endAngle,
+    clockWise: false,
+  };
+};
+
+export const selectAngleAxisRange = (state: RechartsRootState): AxisRange => {
+  const polarOptions = selectPolarOptions(state);
+  if (polarOptions == null) {
+    return [0, 0];
+  }
+  return [polarOptions.startAngle, polarOptions.endAngle];
+};
+
+export const selectAngleAxisRangeWithReversed = (
+  state: RechartsRootState,
+  angleAxisId: AxisId,
+): AxisRange | undefined =>
+  combineAxisRangeWithReverse(selectAngleAxis(state, angleAxisId), selectAngleAxisRange(state));
+
+export const selectRadiusAxisRange = (
+  state: RechartsRootState,
+  _radiusAxisId: AxisId,
+): AxisRange | undefined => {
+  const maxRadius = selectMaxRadius(state);
+  const innerRadius = selectInnerRadius(state);
+  const outerRadius = selectOuterRadius(state);
+  if (maxRadius == null || innerRadius == null || outerRadius == null) {
+    return undefined;
+  }
+  return [innerRadius, outerRadius];
+};
+
+export const selectRadiusAxisRangeWithReversed = (
+  state: RechartsRootState,
+  radiusAxisId: AxisId,
+): AxisRange | undefined =>
+  combineAxisRangeWithReverse(
+    selectRadiusAxis(state, radiusAxisId),
+    selectRadiusAxisRange(state, radiusAxisId),
+  );

package/src/state/selectors/polarGridSelectors.ts

@@ -0,0 +1,24 @@
+// Ported from recharts 3.8.1 src/state/selectors/polarGridSelectors.ts (commit 7a23854).
+// reselect `createSelector` → plain functions.
+import { RechartsRootState } from "../store";
+import { AxisId } from "../cartesianAxisSlice";
+import { selectPolarAxisTicks } from "./polarScaleSelectors";
+
+export type PolarAngles = ReadonlyArray<number>;
+export type PolarRadius = ReadonlyArray<number>;
+
+export const selectPolarGridAngles = (
+  state: RechartsRootState,
+  angleAxisId: AxisId,
+): PolarAngles | undefined => {
+  const ticks = selectPolarAxisTicks(state, "angleAxis", angleAxisId, false);
+  return ticks?.map((tick) => tick.coordinate);
+};
+
+export const selectPolarGridRadii = (
+  state: RechartsRootState,
+  radiusAxisId: AxisId,
+): PolarRadius | undefined => {
+  const ticks = selectPolarAxisTicks(state, "radiusAxis", radiusAxisId, false);
+  return ticks?.map((tick) => tick.coordinate);
+};

package/src/state/selectors/polarScaleSelectors.ts

@@ -0,0 +1,149 @@
+// Ported from recharts 3.8.1 src/state/selectors/polarScaleSelectors.ts (commit 7a23854).
+//
+// FULL SOLID-NATIVE REWRITE: reselect `createSelector` → plain functions. Reuses
+// the cartesian scale/tick combiners keyed by the polar axis type+id.
+import { RechartsRootState } from "../store";
+import { AxisId } from "../cartesianAxisSlice";
+import { CartesianTickItem, TickItem } from "../../util/types";
+import { selectChartLayout } from "../../context/chartLayoutContext";
+import { RechartsScale, rechartsScaleFactory } from "../../util/scale/RechartsScale";
+import { CustomScaleDefinition } from "../../util/scale/CustomScaleDefinition";
+import { pickAxisType } from "./pickAxisType";
+import { combineConfiguredScale } from "./combiners/combineConfiguredScale";
+import {
+  combineAxisTicks,
+  combineCategoricalDomain,
+  combineGraphicalItemTicks,
+  selectDuplicateDomain,
+  selectRealScaleType,
+  selectRenderableAxisSettings,
+} from "./axisSelectors";
+import {
+  selectAngleAxis,
+  selectAngleAxisRangeWithReversed,
+  selectRadiusAxis,
+  selectRadiusAxisRangeWithReversed,
+} from "./polarAxisSelectors";
+import {
+  selectPolarAppliedValues,
+  selectPolarAxisCheckedDomain,
+  selectPolarNiceTicks,
+  type PolarAxisType,
+} from "./polarSelectors";
+
+export const selectPolarAxis = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  axisId: AxisId,
+) => {
+  switch (axisType) {
+    case "angleAxis":
+      return selectAngleAxis(state, axisId);
+    case "radiusAxis":
+      return selectRadiusAxis(state, axisId);
+    default:
+      throw new Error(`Unexpected axis type: ${String(axisType)}`);
+  }
+};
+
+const selectPolarAxisRangeWithReversed = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  axisId: AxisId,
+) => {
+  switch (axisType) {
+    case "angleAxis":
+      return selectAngleAxisRangeWithReversed(state, axisId);
+    case "radiusAxis":
+      return selectRadiusAxisRangeWithReversed(state, axisId);
+    default:
+      throw new Error(`Unexpected axis type: ${String(axisType)}`);
+  }
+};
+
+const selectPolarConfiguredScale = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): CustomScaleDefinition | undefined =>
+  combineConfiguredScale(
+    selectPolarAxis(state, axisType, polarAxisId),
+    selectRealScaleType(state, axisType, polarAxisId),
+    selectPolarAxisCheckedDomain(state, axisType, polarAxisId),
+    selectPolarAxisRangeWithReversed(state, axisType, polarAxisId),
+  );
+
+export const selectPolarAxisScale = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): RechartsScale | undefined =>
+  rechartsScaleFactory(selectPolarConfiguredScale(state, axisType, polarAxisId));
+
+export const selectPolarCategoricalDomain = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): ReadonlyArray<unknown> | undefined =>
+  combineCategoricalDomain(
+    selectChartLayout(state),
+    selectPolarAppliedValues(state, axisType, polarAxisId),
+    selectRenderableAxisSettings(state, axisType, polarAxisId),
+    pickAxisType(state, axisType),
+  );
+
+export const selectPolarAxisTicks = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+  isPanorama: boolean,
+): ReadonlyArray<TickItem> | undefined =>
+  combineAxisTicks(
+    selectChartLayout(state),
+    selectPolarAxis(state, axisType, polarAxisId),
+    selectRealScaleType(state, axisType, polarAxisId),
+    selectPolarAxisScale(state, axisType, polarAxisId),
+    selectPolarNiceTicks(state, axisType, polarAxisId),
+    selectPolarAxisRangeWithReversed(state, axisType, polarAxisId),
+    selectDuplicateDomain(state, axisType, polarAxisId, isPanorama),
+    selectPolarCategoricalDomain(state, axisType, polarAxisId),
+    pickAxisType(state, axisType),
+  );
+
+export const selectPolarAngleAxisTicks = (
+  state: RechartsRootState,
+  axisType: "angleAxis",
+  polarAxisId: AxisId,
+  isPanorama: boolean,
+): ReadonlyArray<TickItem> | undefined => {
+  const ticks = selectPolarAxisTicks(state, axisType, polarAxisId, isPanorama);
+  // The angle axis is circular; ticks that overlap (e.g. 0° and 360°) must be
+  // de-duplicated to avoid rendering the same tick twice.
+  if (!ticks) {
+    return undefined;
+  }
+  const uniqueTicksMap = new Map<number, TickItem>();
+  ticks.forEach((tick) => {
+    const normalizedCoordinate = (tick.coordinate + 360) % 360;
+    if (!uniqueTicksMap.has(normalizedCoordinate)) {
+      uniqueTicksMap.set(normalizedCoordinate, tick);
+    }
+  });
+  return Array.from(uniqueTicksMap.values());
+};
+
+export const selectPolarGraphicalItemAxisTicks = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+  _isPanorama: boolean,
+): ReadonlyArray<CartesianTickItem> | undefined =>
+  combineGraphicalItemTicks(
+    selectChartLayout(state),
+    selectPolarAxis(state, axisType, polarAxisId),
+    selectPolarAxisScale(state, axisType, polarAxisId),
+    selectPolarAxisRangeWithReversed(state, axisType, polarAxisId),
+    selectDuplicateDomain(state, axisType, polarAxisId, _isPanorama),
+    selectPolarCategoricalDomain(state, axisType, polarAxisId),
+    pickAxisType(state, axisType),
+  );

package/src/state/selectors/polarSelectors.ts

@@ -0,0 +1,211 @@
+// Ported from recharts 3.8.1 src/state/selectors/polarSelectors.ts (commit 7a23854).
+//
+// FULL SOLID-NATIVE REWRITE: reselect `createSelector` → plain functions
+// (memoization via `useAppSelector`'s `createMemo`). The polar domain chain
+// reuses the cartesian axis combiners keyed by the polar axis type+id (the same
+// approach the reference uses).
+//
+// DEVIATION: `selectAllPolarAppliedNumericalValues` (an exported-but-internally-
+// unused helper returning the applied-value+errorDomain array) is omitted — the
+// numerical domain calls `combineDomainOfAllAppliedNumericalValuesIncludingErrorValues`
+// directly, so the helper is dead weight. Polar charts have no error bars.
+import { RechartsRootState } from "../store";
+import { AxisId } from "../cartesianAxisSlice";
+import { PolarGraphicalItemSettings } from "../graphicalItemsSlice";
+import { AppliedChartData, ChartData } from "../chartDataSlice";
+import { CategoricalDomain, NumberDomain } from "../../util/types";
+import { selectChartLayout } from "../../context/chartLayoutContext";
+import {
+  selectChartDataAndAlwaysIgnoreIndexes,
+  selectChartDataSliceIgnoringIndexes,
+  selectChartDataWithIndexes,
+} from "./dataSelectors";
+import { pickAxisType } from "./pickAxisType";
+import { selectReverseStackOrder, selectStackOffsetType } from "./rootPropsSelectors";
+import { combineCheckedDomain } from "./combiners/combineCheckedDomain";
+import {
+  combineAppliedValues,
+  combineAxisDomain,
+  combineAxisDomainWithNiceTicks,
+  combineDisplayedData,
+  combineDomainOfAllAppliedNumericalValuesIncludingErrorValues,
+  combineDomainOfStackGroups,
+  combineGraphicalItemsData,
+  combineGraphicalItemsSettings,
+  combineNiceTicks,
+  combineNumericalDomain,
+  combineStackGroups,
+  itemAxisPredicate,
+  selectAllErrorBarSettings,
+  selectBaseAxis,
+  selectDomainDefinition,
+  selectDomainFromUserPreference,
+  selectRealScaleType,
+  selectRenderableAxisSettings,
+  selectTooltipAxis,
+} from "./axisSelectors";
+import { isStacked } from "../types/StackedGraphicalItem";
+import { combineDisplayedStackedData } from "./combiners/combineDisplayedStackedData";
+import type { AllStackGroups } from "../../util/stacks/stackTypes";
+
+export type PolarAxisType = "angleAxis" | "radiusAxis";
+
+export const selectUnfilteredPolarItems = (
+  state: RechartsRootState,
+): ReadonlyArray<PolarGraphicalItemSettings> => state.graphicalItems.polarItems;
+
+const selectAxisPredicate = (
+  _state: RechartsRootState,
+  axisType: PolarAxisType,
+  axisId: AxisId,
+): ((item: PolarGraphicalItemSettings) => boolean) => itemAxisPredicate(axisType, axisId);
+
+export const selectPolarItemsSettings = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): ReadonlyArray<PolarGraphicalItemSettings> =>
+  combineGraphicalItemsSettings(
+    selectUnfilteredPolarItems(state),
+    selectBaseAxis(state, axisType, polarAxisId),
+    selectAxisPredicate(state, axisType, polarAxisId),
+  );
+
+const selectPolarGraphicalItemsData = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): ChartData => combineGraphicalItemsData(selectPolarItemsSettings(state, axisType, polarAxisId));
+
+export const selectPolarDisplayedData = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): ChartData =>
+  combineDisplayedData(
+    selectPolarGraphicalItemsData(state, axisType, polarAxisId),
+    selectChartDataAndAlwaysIgnoreIndexes(state),
+  );
+
+export const selectPolarAppliedValues = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  axisId: AxisId,
+): AppliedChartData =>
+  combineAppliedValues(
+    selectPolarDisplayedData(state, axisType, axisId),
+    selectBaseAxis(state, axisType, axisId),
+    selectPolarItemsSettings(state, axisType, axisId),
+  );
+
+const selectDomainOfAllPolarAppliedNumericalValues = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  axisId: AxisId,
+): NumberDomain | undefined =>
+  combineDomainOfAllAppliedNumericalValuesIncludingErrorValues(
+    selectPolarDisplayedData(state, axisType, axisId),
+    selectBaseAxis(state, axisType, axisId),
+    selectPolarItemsSettings(state, axisType, axisId),
+    selectAllErrorBarSettings(state),
+    pickAxisType(state, axisType),
+    selectChartDataSliceIgnoringIndexes(state),
+  );
+
+const selectPolarNumericalDomain = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  axisId: AxisId,
+): NumberDomain | undefined =>
+  combineNumericalDomain(
+    selectBaseAxis(state, axisType, axisId),
+    selectDomainDefinition(state, axisType, axisId),
+    selectDomainFromUserPreference(state, axisType, axisId),
+    // Stacked RadialBars contribute their stack totals (verified against released
+    // recharts: the implicit numeric angle axis spans [0, stack total]).
+    combineDomainOfStackGroups(
+      selectPolarStackGroups(state, axisType, axisId),
+      selectChartDataWithIndexes(state),
+      axisType,
+      selectDomainFromUserPreference(state, axisType, axisId),
+    ),
+    selectDomainOfAllPolarAppliedNumericalValues(state, axisType, axisId),
+    // Reference elements are unsupported in polar charts.
+    undefined,
+    selectChartLayout(state),
+    pickAxisType(state, axisType),
+  );
+
+// Stacked RadialBars sharing this polar axis → displayed stacked data → d3 stack
+// groups (reference selectStackedRadialBars/selectStackGroups, shared by the
+// numeric-domain selector above and selectRadialBarSectors).
+export const selectPolarStackGroups = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  axisId: AxisId,
+): AllStackGroups | undefined => {
+  const stackedItems = selectPolarItemsSettings(state, axisType, axisId)
+    .filter((item) => item.type === "radialBar")
+    .filter(isStacked);
+  if (stackedItems.length === 0) {
+    return undefined;
+  }
+  return combineStackGroups(
+    combineDisplayedStackedData(
+      stackedItems,
+      selectChartDataAndAlwaysIgnoreIndexes(state),
+      selectTooltipAxis(state),
+    ),
+    stackedItems,
+    selectStackOffsetType(state),
+    selectReverseStackOrder(state),
+  );
+};
+
+export const selectPolarAxisDomain = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): NumberDomain | CategoricalDomain | undefined =>
+  combineAxisDomain(
+    selectBaseAxis(state, axisType, polarAxisId),
+    selectChartLayout(state),
+    selectPolarDisplayedData(state, axisType, polarAxisId),
+    selectPolarAppliedValues(state, axisType, polarAxisId),
+    selectStackOffsetType(state),
+    pickAxisType(state, axisType),
+    selectPolarNumericalDomain(state, axisType, polarAxisId),
+  );
+
+export const selectPolarNiceTicks = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): ReadonlyArray<number> | undefined =>
+  combineNiceTicks(
+    selectPolarAxisDomain(state, axisType, polarAxisId),
+    selectRenderableAxisSettings(state, axisType, polarAxisId),
+    selectRealScaleType(state, axisType, polarAxisId),
+  );
+
+export const selectPolarAxisDomainIncludingNiceTicks = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): NumberDomain | CategoricalDomain | undefined =>
+  combineAxisDomainWithNiceTicks(
+    selectBaseAxis(state, axisType, polarAxisId),
+    selectPolarAxisDomain(state, axisType, polarAxisId),
+    selectPolarNiceTicks(state, axisType, polarAxisId),
+    pickAxisType(state, axisType),
+  );
+
+export const selectPolarAxisCheckedDomain = (
+  state: RechartsRootState,
+  axisType: PolarAxisType,
+  polarAxisId: AxisId,
+): NumberDomain | CategoricalDomain | undefined =>
+  combineCheckedDomain(
+    selectRealScaleType(state, axisType, polarAxisId),
+    selectPolarAxisDomainIncludingNiceTicks(state, axisType, polarAxisId),
+  );