vccs 0.1.0 → 0.2.0

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

@@ -1,113 +1,133 @@
-import { isCategoricalAxis as e, isNullish as t } from "../../utils/validate.mjs";
-import { selectChartDataAndAlwaysIgnoreIndexes as n } from "./dataSelectors.mjs";
-import { polarToCartesian as r } from "../../utils/polar.mjs";
-import { selectChartLayout as i } from "./common.mjs";
-import { selectAngleAxis as a, selectPolarViewBox as o, selectRadiusAxis as s } from "./polarAxisSelectors.mjs";
-import { getBandSizeOfAxis as c, getValueByDataKey as l } from "../../utils/chart.mjs";
-import { selectUnfilteredPolarItems as u } from "./polarSelectors.mjs";
-import { selectPolarAxisScale as d, selectPolarAxisTicks as f } from "./polarScaleSelectors.mjs";
-import { last as p } from "es-toolkit/compat";
-import { createSelector as m } from "@reduxjs/toolkit";
+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 h(e, t) {
-	return d(e, "radiusAxis", t);
+function selectRadiusAxisScale(state, radiusAxisId) {
+	return selectPolarAxisScale(state, "radiusAxis", radiusAxisId);
 }
-var g = m([h], (e) => {
-	if (e != null) return { scale: e };
-}), _ = m([s, h], (e, t) => {
-	if (!(e == null || t == null)) return {
-		...e,
-		scale: t
+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 v(e, t, n, r) {
-	return f(e, "radiusAxis", t, r);
+function selectRadiusAxisTicks(state, radiusAxisId, _angleAxisId, isPanorama) {
+	return selectPolarAxisTicks(state, "radiusAxis", radiusAxisId, isPanorama);
 }
-function y(e, t, n) {
-	return a(e, n);
+function selectAngleAxisForRadar(state, _radiusAxisId, angleAxisId) {
+	return selectAngleAxis(state, angleAxisId);
 }
-function b(e, t, n) {
-	return d(e, "angleAxis", n);
+function selectPolarAxisScaleForRadar(state, _radiusAxisId, angleAxisId) {
+	return selectPolarAxisScale(state, "angleAxis", angleAxisId);
 }
-var x = m([y, b], (e, t) => {
-	if (!(e == null || t == null)) return {
-		...e,
-		scale: t
+var selectAngleAxisForBandSize = createSelector([selectAngleAxisForRadar, selectPolarAxisScaleForRadar], (axisSettings, scale) => {
+	if (axisSettings == null || scale == null) return;
+	return {
+		...axisSettings,
+		scale
 	};
 });
-function S(e, t, n, r) {
-	return f(e, "angleAxis", n, r);
+function selectAngleAxisTicks(state, _radiusAxisId, angleAxisId, isPanorama) {
+	return selectPolarAxisTicks(state, "angleAxis", angleAxisId, isPanorama);
 }
-var C = m([
-	y,
-	b,
-	o
-], (e, t, n) => {
-	if (n != null) return {
-		scale: t,
-		type: e.type,
-		dataKey: e.dataKey,
-		cx: n.cx,
-		cy: n.cy
+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 w(e, t, n, r, i) {
-	return i;
+function pickDataKey(_state, _radiusAxisId, _angleAxisId, _isPanorama, radarDataKey) {
+	return radarDataKey;
 }
-var T = m([
-	i,
-	_,
-	v,
-	x,
-	S
-], (t, n, r, i, a) => e(t, "radiusAxis") ? c(n, r, !1) : c(i, a, !1)), E = m([u, w], (e, t) => {
-	if (e.some((e) => e.type === "radar" && t === e.dataKey)) return t;
+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 D({ radiusAxis: e, angleAxis: n, displayedData: i, dataKey: a, bandSize: o }) {
-	let { cx: s, cy: c } = n, u = !1, d = [], f = n.type === "number" ? 0 : o ?? 0;
-	i.forEach((i, o) => {
-		let m = l(i, n.dataKey, o), h = l(i, a), g = (n.scale(m) ?? 0) + f, _ = Array.isArray(h) ? p(h) : h, v = t(_) ? 0 : e.scale(_) ?? 0;
-		Array.isArray(h) && h.length >= 2 && (u = !0), d.push({
-			...r(s, c, v, g),
-			name: m,
-			value: h,
-			cx: s,
-			cy: c,
-			radius: v,
-			angle: g,
-			payload: i
+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
 		});
 	});
-	let m = [];
-	return u && d.forEach((n) => {
-		if (Array.isArray(n.value)) {
-			let i = n.value[0], a = t(i) ? 0 : e.scale(i) ?? 0;
-			m.push({
-				...n,
-				radius: a,
-				...r(s, c, a, n.angle)
+	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 m.push(n);
-	}), {
-		points: d,
-		isRange: u,
-		baseLinePoints: m
+		} else baseLinePoints.push(point);
+	});
+	return {
+		points,
+		isRange,
+		baseLinePoints
 	};
 }
-var O = m([
-	g,
-	C,
-	n,
-	E,
-	T
-], (e, t, { chartData: n, dataStartIndex: r, dataEndIndex: i }, a, o) => {
-	if (!(e == null || t == null || n == null || o == null || a == null)) return D({
-		radiusAxis: e,
-		angleAxis: t,
-		displayedData: n.slice(r, i + 1),
-		dataKey: a,
-		bandSize: o
+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 { O as selectRadarPoints };
+export { selectRadarPoints };