vccs 0.0.1 → 0.2.0

package/dist/es/state/selectors/pieSelectors.mjs

@@ -0,0 +1,132 @@
+import { isNumber } from "../../utils/validate.mjs";
+import { selectChartDataAndAlwaysIgnoreIndexes } from "./dataSelectors.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { getMaxRadius, polarToCartesian } from "../../utils/polar.mjs";
+import { getPercentValue, mathSign } from "../../utils/data.mjs";
+import { getValueByDataKey } from "../../utils/chart.mjs";
+import { selectUnfilteredPolarItems } from "./polarSelectors.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/pieSelectors.ts
+var pickPieSettings = (_state, pieSettings) => pieSettings;
+var EMPTY_CELLS = [];
+function pickCells(_state, _pieSettings) {
+	return EMPTY_CELLS;
+}
+var selectDisplayedData = createSelector([
+	selectChartDataAndAlwaysIgnoreIndexes,
+	pickPieSettings,
+	pickCells
+], ({ chartData }, pieSettings, cells) => {
+	let displayedData;
+	if (pieSettings.data != null && pieSettings.data.length > 0) displayedData = pieSettings.data;
+	else displayedData = chartData;
+	if (!displayedData || !displayedData.length) {}
+	if (displayedData == null) return;
+	return displayedData;
+});
+var selectPieLegend = createSelector([selectDisplayedData, pickPieSettings], (displayedData, pieSettings) => {
+	if (displayedData == null) return;
+	return displayedData.map((entry, i) => {
+		const name = getValueByDataKey(entry, pieSettings.nameKey, pieSettings.name);
+		let color;
+		if (typeof entry === "object" && entry != null && "fill" in entry && typeof entry.fill === "string") color = entry.fill;
+		else color = pieSettings.fill;
+		return {
+			value: name ?? String(pieSettings.dataKey ?? i),
+			color,
+			payload: entry,
+			type: pieSettings.legendType
+		};
+	});
+});
+var selectSynchronisedPieSettings = createSelector([selectUnfilteredPolarItems, pickPieSettings], (graphicalItems, pieSettingsFromProps) => {
+	if (graphicalItems.some((pgis) => pgis.type === "pie" && pieSettingsFromProps.dataKey === pgis.dataKey)) return pieSettingsFromProps;
+});
+function parseDeltaAngle(startAngle, endAngle) {
+	return mathSign(endAngle - startAngle) * Math.min(Math.abs(endAngle - startAngle), 360);
+}
+function getOuterRadius(dataPoint, outerRadius, maxPieRadius) {
+	if (typeof outerRadius === "function") return getPercentValue(outerRadius(dataPoint), maxPieRadius, maxPieRadius * .8);
+	return getPercentValue(outerRadius ?? maxPieRadius * .8, maxPieRadius, maxPieRadius * .8);
+}
+function parseCoordinateOfPie(pieSettings, offset, dataPoint) {
+	const { top, left, width, height } = offset;
+	const maxPieRadius = getMaxRadius(width, height);
+	return {
+		cx: left + getPercentValue(pieSettings.cx ?? width / 2, width, width / 2),
+		cy: top + getPercentValue(pieSettings.cy ?? height / 2, height, height / 2),
+		innerRadius: getPercentValue(pieSettings.innerRadius ?? 0, maxPieRadius, 0),
+		outerRadius: getOuterRadius(dataPoint, pieSettings.outerRadius, maxPieRadius),
+		maxRadius: Math.sqrt(width * width + height * height) / 2
+	};
+}
+function computePieSectors({ pieSettings, displayedData, offset }) {
+	if (!displayedData || displayedData.length === 0) return;
+	const { cornerRadius, dataKey, nameKey, tooltipType } = pieSettings;
+	const startAngle = pieSettings.startAngle ?? 0;
+	const endAngle = pieSettings.endAngle ?? 360;
+	const minAngle = Math.abs(pieSettings.minAngle ?? 0);
+	const deltaAngle = parseDeltaAngle(startAngle, endAngle);
+	const absDeltaAngle = Math.abs(deltaAngle);
+	const paddingAngle = displayedData.length <= 1 ? 0 : pieSettings.paddingAngle ?? 0;
+	const notZeroItemCount = displayedData.filter((entry) => getValueByDataKey(entry, dataKey, 0) !== 0).length;
+	const totalPaddingAngle = (absDeltaAngle >= 360 ? notZeroItemCount : notZeroItemCount - 1) * paddingAngle;
+	const realTotalAngle = absDeltaAngle - notZeroItemCount * minAngle - totalPaddingAngle;
+	const sum = displayedData.reduce((result, entry) => {
+		const val = getValueByDataKey(entry, dataKey, 0);
+		return result + (isNumber(val) ? val : 0);
+	}, 0);
+	if (sum <= 0) return;
+	let prev;
+	return displayedData.map((entry, i) => {
+		const val = getValueByDataKey(entry, dataKey, 0);
+		const name = getValueByDataKey(entry, nameKey, i);
+		const coordinate = parseCoordinateOfPie(pieSettings, offset, entry);
+		const percent = (isNumber(val) ? val : 0) / sum;
+		const entryWithInfo = { ...entry };
+		const sectorColor = entryWithInfo != null && "fill" in entryWithInfo && typeof entryWithInfo.fill === "string" ? entryWithInfo.fill : pieSettings.fill;
+		let tempStartAngle;
+		if (i) tempStartAngle = prev.endAngle + mathSign(deltaAngle) * paddingAngle * (val !== 0 ? 1 : 0);
+		else tempStartAngle = startAngle;
+		const tempEndAngle = tempStartAngle + mathSign(deltaAngle) * ((val !== 0 ? minAngle : 0) + percent * realTotalAngle);
+		const midAngle = (tempStartAngle + tempEndAngle) / 2;
+		const middleRadius = (coordinate.innerRadius + coordinate.outerRadius) / 2;
+		const tooltipPosition = polarToCartesian(coordinate.cx, coordinate.cy, middleRadius, midAngle);
+		prev = {
+			...pieSettings.presentationProps,
+			percent,
+			cornerRadius: typeof cornerRadius === "string" ? parseFloat(cornerRadius) : cornerRadius,
+			name,
+			midAngle,
+			middleRadius,
+			tooltipPosition,
+			...entryWithInfo,
+			...coordinate,
+			value: val,
+			dataKey,
+			startAngle: tempStartAngle,
+			endAngle: tempEndAngle,
+			payload: entryWithInfo,
+			paddingAngle: mathSign(deltaAngle) * paddingAngle,
+			fill: sectorColor,
+			nameKey,
+			tooltipType
+		};
+		return prev;
+	});
+}
+createSelector([
+	selectDisplayedData,
+	selectSynchronisedPieSettings,
+	pickCells,
+	selectChartOffset
+], (displayedData, pieSettings, _cells, offset) => {
+	if (pieSettings == null || displayedData == null) return;
+	return computePieSectors({
+		offset,
+		pieSettings,
+		displayedData
+	});
+});
+//#endregion
+export { computePieSectors, selectDisplayedData, selectPieLegend, selectSynchronisedPieSettings };

package/dist/es/state/selectors/polarAxisSelectors.mjs

@@ -0,0 +1,167 @@
+import { selectChartHeight, selectChartWidth } from "./containerSelectors.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { combineAxisRangeWithReverse } from "./combiners/combineAxisRangeWithReverse.mjs";
+import { getMaxRadius } from "../../utils/polar.mjs";
+import { getPercentValue } from "../../utils/data.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/polarAxisSelectors.ts
+var defaultPolarAngleAxisProps = {
+	allowDuplicatedCategory: true,
+	angleAxisId: 0,
+	axisLine: true,
+	cx: 0,
+	cy: 0,
+	orientation: "outer",
+	reversed: false,
+	scale: "auto",
+	tick: true,
+	tickLine: true,
+	tickSize: 8,
+	type: "category"
+};
+var implicitAngleAxis = {
+	allowDataOverflow: false,
+	allowDecimals: false,
+	allowDuplicatedCategory: false,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: defaultPolarAngleAxisProps.reversed,
+	scale: defaultPolarAngleAxisProps.scale,
+	tick: defaultPolarAngleAxisProps.tick,
+	tickCount: void 0,
+	ticks: void 0,
+	type: defaultPolarAngleAxisProps.type,
+	unit: void 0
+};
+var defaultPolarRadiusAxisProps = {
+	allowDataOverflow: false,
+	allowDuplicatedCategory: true,
+	angle: 0,
+	axisLine: true,
+	cx: 0,
+	cy: 0,
+	orientation: "right",
+	radiusAxisId: 0,
+	scale: "auto",
+	stroke: "#ccc",
+	tick: true,
+	tickCount: 5,
+	type: "number"
+};
+var implicitRadiusAxis = {
+	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: false,
+	scale: defaultPolarRadiusAxisProps.scale,
+	tick: defaultPolarRadiusAxisProps.tick,
+	tickCount: defaultPolarRadiusAxisProps.tickCount,
+	ticks: void 0,
+	type: defaultPolarRadiusAxisProps.type,
+	unit: void 0
+};
+var implicitRadialBarAngleAxis = {
+	allowDataOverflow: false,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarAngleAxisProps.allowDuplicatedCategory,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: false,
+	scale: defaultPolarAngleAxisProps.scale,
+	tick: defaultPolarAngleAxisProps.tick,
+	tickCount: void 0,
+	ticks: void 0,
+	type: "number",
+	unit: void 0
+};
+var implicitRadialBarRadiusAxis = {
+	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: false,
+	scale: defaultPolarRadiusAxisProps.scale,
+	tick: defaultPolarRadiusAxisProps.tick,
+	tickCount: defaultPolarRadiusAxisProps.tickCount,
+	ticks: void 0,
+	type: "category",
+	unit: void 0
+};
+function selectAngleAxis(state, angleAxisId) {
+	if (state.polarAxis.angleAxis[angleAxisId] != null) return state.polarAxis.angleAxis[angleAxisId];
+	if (state.layout.layoutType === "radial") return implicitRadialBarAngleAxis;
+	return implicitAngleAxis;
+}
+function selectRadiusAxis(state, radiusAxisId) {
+	if (state.polarAxis.radiusAxis[radiusAxisId] != null) return state.polarAxis.radiusAxis[radiusAxisId];
+	if (state.layout.layoutType === "radial") return implicitRadialBarRadiusAxis;
+	return implicitRadiusAxis;
+}
+var selectPolarOptions = (state) => state.polarOptions;
+var selectMaxRadius = createSelector([
+	selectChartWidth,
+	selectChartHeight,
+	selectChartOffset
+], getMaxRadius);
+var selectInnerRadius = createSelector([selectPolarOptions, selectMaxRadius], (polarChartOptions, maxRadius) => {
+	if (polarChartOptions == null) return;
+	return getPercentValue(polarChartOptions.innerRadius, maxRadius, 0);
+});
+var selectOuterRadius = createSelector([selectPolarOptions, selectMaxRadius], (polarChartOptions, maxRadius) => {
+	if (polarChartOptions == null) return;
+	return getPercentValue(polarChartOptions.outerRadius, maxRadius, maxRadius * .8);
+});
+function combineAngleAxisRange(polarOptions) {
+	if (polarOptions == null) return [0, 0];
+	const { startAngle, endAngle } = polarOptions;
+	return [startAngle, endAngle];
+}
+var selectAngleAxisRange = createSelector([selectPolarOptions], combineAngleAxisRange);
+var selectAngleAxisRangeWithReversed = createSelector([selectAngleAxis, selectAngleAxisRange], combineAxisRangeWithReverse);
+var selectRadiusAxisRange = createSelector([
+	selectMaxRadius,
+	selectInnerRadius,
+	selectOuterRadius
+], (maxRadius, innerRadius, outerRadius) => {
+	if (maxRadius == null || innerRadius == null || outerRadius == null) return;
+	return [innerRadius, outerRadius];
+});
+var selectRadiusAxisRangeWithReversed = createSelector([selectRadiusAxis, selectRadiusAxisRange], combineAxisRangeWithReverse);
+var selectPolarViewBox = createSelector([
+	selectChartLayout,
+	selectPolarOptions,
+	selectInnerRadius,
+	selectOuterRadius,
+	selectChartWidth,
+	selectChartHeight
+], (layout, polarOptions, innerRadius, outerRadius, width, height) => {
+	if (layout !== "centric" && layout !== "radial" || polarOptions == null || innerRadius == null || outerRadius == null) return;
+	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
+	};
+});
+//#endregion
+export { selectAngleAxis, selectAngleAxisRange, selectAngleAxisRangeWithReversed, selectPolarViewBox, selectRadiusAxis, selectRadiusAxisRange, selectRadiusAxisRangeWithReversed };

package/dist/es/state/selectors/polarGridSelectors.mjs

@@ -0,0 +1,19 @@
+import { selectPolarAxisTicks } from "./polarScaleSelectors.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/polarGridSelectors.ts
+function selectAngleAxisTicks(state, anglexisId) {
+	return selectPolarAxisTicks(state, "angleAxis", anglexisId, false);
+}
+var selectPolarGridAngles = createSelector([selectAngleAxisTicks], (ticks) => {
+	if (!ticks) return;
+	return ticks.map((tick) => tick.coordinate);
+});
+function selectRadiusAxisTicks(state, radiusAxisId) {
+	return selectPolarAxisTicks(state, "radiusAxis", radiusAxisId, false);
+}
+var selectPolarGridRadii = createSelector([selectRadiusAxisTicks], (ticks) => {
+	if (!ticks) return;
+	return ticks.map((tick) => tick.coordinate);
+});
+//#endregion
+export { selectPolarGridAngles, selectPolarGridRadii };

package/dist/es/state/selectors/polarScaleSelectors.mjs

@@ -0,0 +1,55 @@
+import { selectChartLayout } from "./common.mjs";
+import { selectAngleAxis, selectAngleAxisRangeWithReversed, selectRadiusAxis, selectRadiusAxisRangeWithReversed } from "./polarAxisSelectors.mjs";
+import { pickAxisType } from "./pickAxisType.mjs";
+import { combineAxisTicks, combineCategoricalDomain, combineGraphicalItemTicks, combineScaleFunction, selectAxisSettings, selectDuplicateDomain, selectRealScaleType } from "./axisSelectors.mjs";
+import { selectPolarAppliedValues, selectPolarAxisDomainIncludingNiceTicks, selectPolarNiceTicks } from "./polarSelectors.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/polarScaleSelectors.ts
+function selectPolarAxis(state, axisType, axisId) {
+	switch (axisType) {
+		case "angleAxis": return selectAngleAxis(state, axisId);
+		case "radiusAxis": return selectRadiusAxis(state, axisId);
+		default: throw new Error(`Unexpected axis type: ${axisType}`);
+	}
+}
+function selectPolarAxisRangeWithReversed(state, axisType, axisId) {
+	switch (axisType) {
+		case "angleAxis": return selectAngleAxisRangeWithReversed(state, axisId);
+		case "radiusAxis": return selectRadiusAxisRangeWithReversed(state, axisId);
+		default: throw new Error(`Unexpected axis type: ${axisType}`);
+	}
+}
+var selectPolarAxisScale = createSelector([
+	selectPolarAxis,
+	selectRealScaleType,
+	selectPolarAxisDomainIncludingNiceTicks,
+	selectPolarAxisRangeWithReversed
+], combineScaleFunction);
+var selectPolarCategoricalDomain = createSelector([
+	selectChartLayout,
+	selectPolarAppliedValues,
+	selectAxisSettings,
+	pickAxisType
+], combineCategoricalDomain);
+var selectPolarAxisTicks = createSelector([
+	selectChartLayout,
+	selectPolarAxis,
+	selectRealScaleType,
+	selectPolarAxisScale,
+	selectPolarNiceTicks,
+	selectPolarAxisRangeWithReversed,
+	selectDuplicateDomain,
+	selectPolarCategoricalDomain,
+	pickAxisType
+], combineAxisTicks);
+var selectPolarGraphicalItemAxisTicks = createSelector([
+	selectChartLayout,
+	selectPolarAxis,
+	selectPolarAxisScale,
+	selectPolarAxisRangeWithReversed,
+	selectDuplicateDomain,
+	selectPolarCategoricalDomain,
+	pickAxisType
+], combineGraphicalItemTicks);
+//#endregion
+export { selectPolarAxisScale, selectPolarAxisTicks, selectPolarGraphicalItemAxisTicks };

package/dist/es/state/selectors/polarSelectors.mjs

@@ -0,0 +1,81 @@
+import { selectChartDataAndAlwaysIgnoreIndexes, selectChartDataWithIndexes } from "./dataSelectors.mjs";
+import { selectStackOffsetType } from "./rootPropsSelectors.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { pickAxisType } from "./pickAxisType.mjs";
+import { pickAxisId } from "./pickAxisId.mjs";
+import { getValueByDataKey } from "../../utils/chart.mjs";
+import { combineAppliedValues, combineAxisDomain, combineAxisDomainWithNiceTicks, combineDisplayedData, combineDomainOfStackGroups, combineGraphicalItemsData, combineGraphicalItemsSettings, combineNiceTicks, combineNumericalDomain, combineStackGroups, itemAxisPredicate, selectBaseAxis, selectDomainDefinition, selectRealScaleType } from "./axisSelectors.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/polarSelectors.ts
+var selectUnfilteredPolarItems = (state) => state.graphicalItems.polarItems;
+var selectPolarItemsSettings = createSelector([
+	selectUnfilteredPolarItems,
+	selectBaseAxis,
+	createSelector([pickAxisType, pickAxisId], itemAxisPredicate)
+], combineGraphicalItemsSettings);
+var selectPolarDisplayedData = createSelector([createSelector([selectPolarItemsSettings], combineGraphicalItemsData), selectChartDataAndAlwaysIgnoreIndexes], combineDisplayedData);
+var selectPolarAppliedValues = createSelector([
+	selectPolarDisplayedData,
+	selectBaseAxis,
+	selectPolarItemsSettings
+], combineAppliedValues);
+var selectAllPolarAppliedNumericalValues = createSelector([
+	selectPolarDisplayedData,
+	selectBaseAxis,
+	selectPolarItemsSettings
+], (data, axisSettings, items) => {
+	if (items.length > 0) return data.flatMap((entry) => {
+		return items.flatMap((item) => {
+			return {
+				value: getValueByDataKey(entry, axisSettings.dataKey ?? item.dataKey),
+				errorDomain: []
+			};
+		});
+	}).filter(Boolean);
+	if (axisSettings?.dataKey != null) return data.map((item) => ({
+		value: getValueByDataKey(item, axisSettings.dataKey),
+		errorDomain: []
+	}));
+	return data.map((entry) => ({
+		value: entry,
+		errorDomain: []
+	}));
+});
+var selectPolarDomainOfStackGroups = createSelector([
+	createSelector([
+		selectPolarDisplayedData,
+		selectPolarItemsSettings,
+		selectStackOffsetType
+	], combineStackGroups),
+	selectChartDataWithIndexes,
+	pickAxisType
+], combineDomainOfStackGroups);
+var unsupportedInPolarChart = () => void 0;
+var selectPolarAxisDomain = createSelector([
+	selectBaseAxis,
+	selectChartLayout,
+	selectPolarDisplayedData,
+	selectPolarAppliedValues,
+	selectStackOffsetType,
+	pickAxisType,
+	createSelector([
+		selectBaseAxis,
+		selectDomainDefinition,
+		selectPolarDomainOfStackGroups,
+		selectAllPolarAppliedNumericalValues,
+		unsupportedInPolarChart
+	], combineNumericalDomain)
+], combineAxisDomain);
+var selectPolarNiceTicks = createSelector([
+	selectPolarAxisDomain,
+	selectBaseAxis,
+	selectRealScaleType
+], combineNiceTicks);
+var selectPolarAxisDomainIncludingNiceTicks = createSelector([
+	selectBaseAxis,
+	selectPolarAxisDomain,
+	selectPolarNiceTicks,
+	pickAxisType
+], combineAxisDomainWithNiceTicks);
+//#endregion
+export { selectPolarAppliedValues, selectPolarAxisDomainIncludingNiceTicks, selectPolarDisplayedData, selectPolarItemsSettings, selectPolarNiceTicks, selectUnfilteredPolarItems };

package/dist/es/state/selectors/radarSelectors.mjs

@@ -0,0 +1,133 @@
+import { isCategoricalAxis, isNullish } from "../../utils/validate.mjs";
+import { selectChartDataAndAlwaysIgnoreIndexes } from "./dataSelectors.mjs";
+import { polarToCartesian } from "../../utils/polar.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { selectAngleAxis, selectPolarViewBox, selectRadiusAxis } from "./polarAxisSelectors.mjs";
+import { getBandSizeOfAxis, getValueByDataKey } from "../../utils/chart.mjs";
+import { selectUnfilteredPolarItems } from "./polarSelectors.mjs";
+import { selectPolarAxisScale, selectPolarAxisTicks } from "./polarScaleSelectors.mjs";
+import { last } from "es-toolkit/compat";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/radarSelectors.ts
+function selectRadiusAxisScale(state, radiusAxisId) {
+	return selectPolarAxisScale(state, "radiusAxis", radiusAxisId);
+}
+var selectRadiusAxisForRadar = createSelector([selectRadiusAxisScale], (scale) => {
+	if (scale == null) return;
+	return { scale };
+});
+var selectRadiusAxisForBandSize = createSelector([selectRadiusAxis, selectRadiusAxisScale], (axisSettings, scale) => {
+	if (axisSettings == null || scale == null) return;
+	return {
+		...axisSettings,
+		scale
+	};
+});
+function selectRadiusAxisTicks(state, radiusAxisId, _angleAxisId, isPanorama) {
+	return selectPolarAxisTicks(state, "radiusAxis", radiusAxisId, isPanorama);
+}
+function selectAngleAxisForRadar(state, _radiusAxisId, angleAxisId) {
+	return selectAngleAxis(state, angleAxisId);
+}
+function selectPolarAxisScaleForRadar(state, _radiusAxisId, angleAxisId) {
+	return selectPolarAxisScale(state, "angleAxis", angleAxisId);
+}
+var selectAngleAxisForBandSize = createSelector([selectAngleAxisForRadar, selectPolarAxisScaleForRadar], (axisSettings, scale) => {
+	if (axisSettings == null || scale == null) return;
+	return {
+		...axisSettings,
+		scale
+	};
+});
+function selectAngleAxisTicks(state, _radiusAxisId, angleAxisId, isPanorama) {
+	return selectPolarAxisTicks(state, "angleAxis", angleAxisId, isPanorama);
+}
+var selectAngleAxisWithScaleAndViewport = createSelector([
+	selectAngleAxisForRadar,
+	selectPolarAxisScaleForRadar,
+	selectPolarViewBox
+], (axisOptions, scale, polarViewBox) => {
+	if (polarViewBox == null) return;
+	return {
+		scale,
+		type: axisOptions.type,
+		dataKey: axisOptions.dataKey,
+		cx: polarViewBox.cx,
+		cy: polarViewBox.cy
+	};
+});
+function pickDataKey(_state, _radiusAxisId, _angleAxisId, _isPanorama, radarDataKey) {
+	return radarDataKey;
+}
+var selectBandSizeOfAxis = createSelector([
+	selectChartLayout,
+	selectRadiusAxisForBandSize,
+	selectRadiusAxisTicks,
+	selectAngleAxisForBandSize,
+	selectAngleAxisTicks
+], (layout, radiusAxis, radiusAxisTicks, angleAxis, angleAxisTicks) => {
+	if (isCategoricalAxis(layout, "radiusAxis")) return getBandSizeOfAxis(radiusAxis, radiusAxisTicks, false);
+	return getBandSizeOfAxis(angleAxis, angleAxisTicks, false);
+});
+var selectSynchronisedRadarDataKey = createSelector([selectUnfilteredPolarItems, pickDataKey], (graphicalItems, radarDataKey) => {
+	if (graphicalItems.some((pgis) => pgis.type === "radar" && radarDataKey === pgis.dataKey)) return radarDataKey;
+});
+function computeRadarPoints({ radiusAxis, angleAxis, displayedData, dataKey, bandSize }) {
+	const { cx, cy } = angleAxis;
+	let isRange = false;
+	const points = [];
+	const angleBandSize = angleAxis.type !== "number" ? bandSize ?? 0 : 0;
+	displayedData.forEach((entry, i) => {
+		const name = getValueByDataKey(entry, angleAxis.dataKey, i);
+		const value = getValueByDataKey(entry, dataKey);
+		const angle = (angleAxis.scale(name) ?? 0) + angleBandSize;
+		const pointValue = Array.isArray(value) ? last(value) : value;
+		const radius = isNullish(pointValue) ? 0 : radiusAxis.scale(pointValue) ?? 0;
+		if (Array.isArray(value) && value.length >= 2) isRange = true;
+		points.push({
+			...polarToCartesian(cx, cy, radius, angle),
+			name,
+			value,
+			cx,
+			cy,
+			radius,
+			angle,
+			payload: entry
+		});
+	});
+	const baseLinePoints = [];
+	if (isRange) points.forEach((point) => {
+		if (Array.isArray(point.value)) {
+			const baseValue = point.value[0];
+			const radius = isNullish(baseValue) ? 0 : radiusAxis.scale(baseValue) ?? 0;
+			baseLinePoints.push({
+				...point,
+				radius,
+				...polarToCartesian(cx, cy, radius, point.angle)
+			});
+		} else baseLinePoints.push(point);
+	});
+	return {
+		points,
+		isRange,
+		baseLinePoints
+	};
+}
+var selectRadarPoints = createSelector([
+	selectRadiusAxisForRadar,
+	selectAngleAxisWithScaleAndViewport,
+	selectChartDataAndAlwaysIgnoreIndexes,
+	selectSynchronisedRadarDataKey,
+	selectBandSizeOfAxis
+], (radiusAxis, angleAxis, { chartData, dataStartIndex, dataEndIndex }, dataKey, bandSize) => {
+	if (radiusAxis == null || angleAxis == null || chartData == null || bandSize == null || dataKey == null) return;
+	return computeRadarPoints({
+		radiusAxis,
+		angleAxis,
+		displayedData: chartData.slice(dataStartIndex, dataEndIndex + 1),
+		dataKey,
+		bandSize
+	});
+});
+//#endregion
+export { selectRadarPoints };