vccs 0.1.0 → 0.2.0

package/dist/es/state/selectors/combiners/combineTooltipPayloadConfigurations.mjs

@@ -1,9 +1,13 @@
 //#region src/state/selectors/combiners/combineTooltipPayloadConfigurations.ts
-function e(e, t, n, r) {
-	if (t === "axis") return e.tooltipItemPayloads;
-	if (e.tooltipItemPayloads.length === 0) return [];
-	let i;
-	return i = n === "hover" ? e.itemInteraction.hover.dataKey : e.itemInteraction.click.dataKey, e.syncInteraction.active && i == null ? e.tooltipItemPayloads : i == null && r != null ? [e.tooltipItemPayloads[0]] : e.tooltipItemPayloads.filter((e) => e.settings?.dataKey === i);
+function combineTooltipPayloadConfigurations(tooltipState, tooltipEventType, trigger, defaultIndex) {
+	if (tooltipEventType === "axis") return tooltipState.tooltipItemPayloads;
+	if (tooltipState.tooltipItemPayloads.length === 0) return [];
+	let filterByDataKey;
+	if (trigger === "hover") filterByDataKey = tooltipState.itemInteraction.hover.dataKey;
+	else filterByDataKey = tooltipState.itemInteraction.click.dataKey;
+	if (tooltipState.syncInteraction.active && filterByDataKey == null) return tooltipState.tooltipItemPayloads;
+	if (filterByDataKey == null && defaultIndex != null) return [tooltipState.tooltipItemPayloads[0]];
+	return tooltipState.tooltipItemPayloads.filter((tpc) => tpc.settings?.dataKey === filterByDataKey);
 }
 //#endregion
-export { e as combineTooltipPayloadConfigurations };
+export { combineTooltipPayloadConfigurations };

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

@@ -1,4 +1,4 @@
 //#region src/state/selectors/common.ts
-var e = (e) => e.layout.layoutType;
+var selectChartLayout = (state) => state.layout.layoutType;
 //#endregion
-export { e as selectChartLayout };
+export { selectChartLayout };

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

@@ -1,4 +1,7 @@
 //#region src/state/selectors/containerSelectors.ts
-var e = (e) => e.layout.width, t = (e) => e.layout.height, n = (e) => e.layout.scale, r = (e) => e.layout.margin;
+var selectChartWidth = (state) => state.layout.width;
+var selectChartHeight = (state) => state.layout.height;
+var selectContainerScale = (state) => state.layout.scale;
+var selectMargin = (state) => state.layout.margin;
 //#endregion
-export { t as selectChartHeight, e as selectChartWidth, n as selectContainerScale, r as selectMargin };
+export { selectChartHeight, selectChartWidth, selectContainerScale, selectMargin };

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

@@ -1,16 +1,35 @@
-import { createSelector as e } from "@reduxjs/toolkit";
+import { createSelector } from "@reduxjs/toolkit";
 //#region src/state/selectors/dataSelectors.ts
-var t = (e) => e.chartData, n = e([t], (e) => {
-	let t = e.chartData == null ? 0 : e.chartData.length - 1;
+/**
+* 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
+*/
+var selectChartDataWithIndexes = (state) => state.chartData;
+/**
+* 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.
+*/
+var selectChartDataAndAlwaysIgnoreIndexes = createSelector([selectChartDataWithIndexes], (dataState) => {
+	const dataEndIndex = dataState.chartData != null ? dataState.chartData.length - 1 : 0;
 	return {
-		chartData: e.chartData,
-		computedData: e.computedData,
-		dataEndIndex: t,
+		chartData: dataState.chartData,
+		computedData: dataState.computedData,
+		dataEndIndex,
 		dataStartIndex: 0
 	};
 });
-function r(e, r, i, a) {
-	return a ? n(e) : t(e);
+function selectChartDataWithIndexesIfNotInPanorama(state, _xAxisId, _yAxisId, isPanorama) {
+	if (isPanorama) return selectChartDataAndAlwaysIgnoreIndexes(state);
+	return selectChartDataWithIndexes(state);
 }
 //#endregion
-export { n as selectChartDataAndAlwaysIgnoreIndexes, t as selectChartDataWithIndexes, r as selectChartDataWithIndexesIfNotInPanorama };
+export { selectChartDataAndAlwaysIgnoreIndexes, selectChartDataWithIndexes, selectChartDataWithIndexesIfNotInPanorama };

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

@@ -0,0 +1,38 @@
+import { selectChartDataAndAlwaysIgnoreIndexes } from "./dataSelectors.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { computeFunnelTrapezoids } from "../../cartesian/funnel/utils.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/funnelSelectors.ts
+function pickFunnelSettings(_state, funnelSettings) {
+	return funnelSettings;
+}
+var selectFunnelTrapezoids = createSelector([
+	selectChartOffset,
+	pickFunnelSettings,
+	selectChartDataAndAlwaysIgnoreIndexes
+], (offset, { data, dataKey, nameKey, tooltipType, lastShapeType, reversed, customWidth, presentationProps }, { chartData }) => {
+	let displayedData;
+	if (data != null && data.length > 0) displayedData = data;
+	else if (chartData != null && chartData.length > 0) displayedData = chartData;
+	if (displayedData && displayedData.length) displayedData = displayedData.map((entry, index) => ({
+		payload: entry,
+		...presentationProps,
+		...entry
+	}));
+	else return {
+		trapezoids: [],
+		data: displayedData
+	};
+	return computeFunnelTrapezoids({
+		dataKey,
+		nameKey,
+		displayedData,
+		tooltipType,
+		lastShapeType,
+		reversed,
+		offset,
+		customWidth
+	});
+});
+//#endregion
+export { selectFunnelTrapezoids };

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

@@ -1,9 +1,10 @@
-import { createSelector as e } from "@reduxjs/toolkit";
+import { createSelector } from "@reduxjs/toolkit";
 //#region src/state/selectors/legendSelectors.ts
-var t = (e) => e.legend.settings, n = (e) => e.legend.size;
-function r(e) {
-	return e.legend.payload;
+var selectLegendSettings = (state) => state.legend.settings;
+var selectLegendSize = (state) => state.legend.size;
+function selectAllLegendPayload2DArray(state) {
+	return state.legend.payload;
 }
-var i = e([r], (e) => e.flat(1));
+var selectLegendPayload = createSelector([selectAllLegendPayload2DArray], (payloads) => payloads.flat(1));
 //#endregion
-export { i as selectLegendPayload, t as selectLegendSettings, n as selectLegendSize };
+export { selectLegendPayload, selectLegendSettings, selectLegendSize };

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

@@ -1,57 +1,64 @@
-import { isCategoricalAxis as e } from "../../utils/validate.mjs";
-import { selectChartDataWithIndexesIfNotInPanorama as t } from "./dataSelectors.mjs";
-import { selectChartLayout as n } from "./common.mjs";
-import { getBandSizeOfAxis as r } from "../../utils/chart.mjs";
-import { selectAxisWithScale as i, selectTicksOfGraphicalItem as a, selectUnfilteredCartesianItems as o } from "./axisSelectors.mjs";
-import { computeLinePoints as s } from "../../cartesian/line/utils.mjs";
-import { createSelector as c } from "@reduxjs/toolkit";
+import { isCategoricalAxis } from "../../utils/validate.mjs";
+import { selectChartDataWithIndexesIfNotInPanorama } from "./dataSelectors.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { getBandSizeOfAxis } from "../../utils/chart.mjs";
+import { selectAxisWithScale, selectTicksOfGraphicalItem, selectUnfilteredCartesianItems } from "./axisSelectors.mjs";
+import { computeLinePoints } from "../../cartesian/line/utils.mjs";
+import { createSelector } from "@reduxjs/toolkit";
 //#region src/state/selectors/lineSelectors.ts
-function l(e, t, n, r) {
-	return i(e, "xAxis", t, r);
+function selectXAxisWithScale(state, xAxisId, _yAxisId, isPanorama) {
+	return selectAxisWithScale(state, "xAxis", xAxisId, isPanorama);
 }
-function u(e, t, n, r) {
-	return a(e, "xAxis", t, r);
+function selectXAxisTicks(state, xAxisId, _yAxisId, isPanorama) {
+	return selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama);
 }
-function d(e, t, n, r) {
-	return i(e, "yAxis", n, r);
+function selectYAxisWithScale(state, _xAxisId, yAxisId, isPanorama) {
+	return selectAxisWithScale(state, "yAxis", yAxisId, isPanorama);
 }
-function f(e, t, n, r) {
-	return a(e, "yAxis", n, r);
+function selectYAxisTicks(state, _xAxisId, yAxisId, isPanorama) {
+	return selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama);
 }
-var p = c([
-	n,
-	l,
-	d,
-	u,
-	f
-], (t, n, i, a, o) => e(t, "xAxis") ? r(n, a, !1) : r(i, o, !1));
-function m(e, t, n, r, i) {
-	return i;
+var selectBandSize = createSelector([
+	selectChartLayout,
+	selectXAxisWithScale,
+	selectYAxisWithScale,
+	selectXAxisTicks,
+	selectYAxisTicks
+], (layout, xAxis, yAxis, xAxisTicks, yAxisTicks) => {
+	if (isCategoricalAxis(layout, "xAxis")) return getBandSizeOfAxis(xAxis, xAxisTicks, false);
+	return getBandSizeOfAxis(yAxis, yAxisTicks, false);
+});
+function pickLineSettings(_state, _xAxisId, _yAxisId, _isPanorama, lineSettings) {
+	return lineSettings;
 }
-var h = c([
-	n,
-	l,
-	d,
-	u,
-	f,
-	c([o, m], (e, t) => {
-		if (e.some((e) => e.type === "line" && t.dataKey === e.dataKey && t.data === e.data)) return t;
+var selectLinePoints = createSelector([
+	selectChartLayout,
+	selectXAxisWithScale,
+	selectYAxisWithScale,
+	selectXAxisTicks,
+	selectYAxisTicks,
+	createSelector([selectUnfilteredCartesianItems, pickLineSettings], (graphicalItems, lineSettingsFromProps) => {
+		if (graphicalItems.some((cgis) => cgis.type === "line" && lineSettingsFromProps.dataKey === cgis.dataKey && lineSettingsFromProps.data === cgis.data)) return lineSettingsFromProps;
 	}),
-	p,
-	t
-], (e, t, n, r, i, a, o, { chartData: c, dataStartIndex: l, dataEndIndex: u }) => {
-	if (a == null || t == null || n == null || r == null || i == null || r.length === 0 || i.length === 0) return;
-	let { dataKey: d, data: f } = a, p;
-	if (p = f?.length > 0 ? f : c?.slice(l, u + 1), p != null) return s({
-		layout: e,
-		xAxis: t,
-		yAxis: n,
-		xAxisTicks: r,
-		yAxisTicks: i,
-		dataKey: d,
-		bandSize: o,
-		displayedData: p
+	selectBandSize,
+	selectChartDataWithIndexesIfNotInPanorama
+], (layout, xAxis, yAxis, xAxisTicks, yAxisTicks, lineSettings, bandSize, { chartData, dataStartIndex, dataEndIndex }) => {
+	if (lineSettings == null || xAxis == null || yAxis == null || xAxisTicks == null || yAxisTicks == null || xAxisTicks.length === 0 || yAxisTicks.length === 0) return;
+	const { dataKey, data } = lineSettings;
+	let displayedData;
+	if (data?.length > 0) displayedData = data;
+	else displayedData = chartData?.slice(dataStartIndex, dataEndIndex + 1);
+	if (displayedData == null) return;
+	return computeLinePoints({
+		layout,
+		xAxis,
+		yAxis,
+		xAxisTicks,
+		yAxisTicks,
+		dataKey,
+		bandSize,
+		displayedData
 	});
 });
 //#endregion
-export { h as selectLinePoints };
+export { selectLinePoints };

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

@@ -1,4 +1,4 @@
 //#region src/state/selectors/pickAxisId.ts
-var e = (e, t, n) => n;
+var pickAxisId = (_state, _axisType, axisId) => axisId;
 //#endregion
-export { e as pickAxisId };
+export { pickAxisId };

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

@@ -1,4 +1,4 @@
 //#region src/state/selectors/pickAxisType.ts
-var e = (e, t) => t;
+var pickAxisType = (_state, axisType) => axisType;
 //#endregion
-export { e as pickAxisType };
+export { pickAxisType };

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

@@ -1,97 +1,132 @@
-import { isNumber as e } from "../../utils/validate.mjs";
-import { selectChartDataAndAlwaysIgnoreIndexes as t } from "./dataSelectors.mjs";
-import { selectChartOffset as n } from "./selectChartOffset.mjs";
-import { getMaxRadius as r, polarToCartesian as i } from "../../utils/polar.mjs";
-import { getPercentValue as a, mathSign as o } from "../../utils/data.mjs";
-import { getValueByDataKey as s } from "../../utils/chart.mjs";
-import { selectUnfilteredPolarItems as c } from "./polarSelectors.mjs";
-import { createSelector as l } from "@reduxjs/toolkit";
+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 u = (e, t) => t, d = [];
-function f(e, t) {
-	return d;
+var pickPieSettings = (_state, pieSettings) => pieSettings;
+var EMPTY_CELLS = [];
+function pickCells(_state, _pieSettings) {
+	return EMPTY_CELLS;
 }
-var p = l([
-	t,
-	u,
-	f
-], ({ chartData: e }, t, n) => {
-	let r;
-	if (r = t.data != null && t.data.length > 0 ? t.data : e, !r || r.length, r != null) return r;
-}), m = l([p, u], (e, t) => {
-	if (e != null) return e.map((e, n) => {
-		let r = s(e, t.nameKey, t.name), i;
-		return i = typeof e == "object" && e && "fill" in e && typeof e.fill == "string" ? e.fill : t.fill, {
-			value: r ?? String(t.dataKey ?? n),
-			color: i,
-			payload: e,
-			type: t.legendType
+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
 		};
 	});
-}), h = l([c, u], (e, t) => {
-	if (e.some((e) => e.type === "pie" && t.dataKey === e.dataKey)) return t;
 });
-function g(e, t) {
-	return o(t - e) * Math.min(Math.abs(t - e), 360);
+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 _(e, t, n) {
-	return a(typeof t == "function" ? t(e) : t ?? n * .8, n, n * .8);
+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 v(e, t, n) {
-	let { top: i, left: o, width: s, height: c } = t, l = r(s, c);
+function parseCoordinateOfPie(pieSettings, offset, dataPoint) {
+	const { top, left, width, height } = offset;
+	const maxPieRadius = getMaxRadius(width, height);
 	return {
-		cx: o + a(e.cx ?? s / 2, s, s / 2),
-		cy: i + a(e.cy ?? c / 2, c, c / 2),
-		innerRadius: a(e.innerRadius ?? 0, l, 0),
-		outerRadius: _(n, e.outerRadius, l),
-		maxRadius: Math.sqrt(s * s + c * c) / 2
+		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 y({ pieSettings: t, displayedData: n, offset: r }) {
-	if (!n || n.length === 0) return;
-	let { cornerRadius: a, dataKey: c, nameKey: l, tooltipType: u } = t, d = t.startAngle ?? 0, f = t.endAngle ?? 360, p = Math.abs(t.minAngle ?? 0), m = g(d, f), h = Math.abs(m), _ = n.length <= 1 ? 0 : t.paddingAngle ?? 0, y = n.filter((e) => s(e, c, 0) !== 0).length, b = (h >= 360 ? y : y - 1) * _, x = h - y * p - b, S = n.reduce((t, n) => {
-		let r = s(n, c, 0);
-		return t + (e(r) ? r : 0);
+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 (S <= 0) return;
-	let C;
-	return n.map((n, f) => {
-		let h = s(n, c, 0), g = s(n, l, f), y = v(t, r, n), b = (e(h) ? h : 0) / S, w = { ...n }, T = w != null && "fill" in w && typeof w.fill == "string" ? w.fill : t.fill, E;
-		E = f ? C.endAngle + o(m) * _ * (h === 0 ? 0 : 1) : d;
-		let D = E + o(m) * ((h === 0 ? 0 : p) + b * x), O = (E + D) / 2, k = (y.innerRadius + y.outerRadius) / 2, A = i(y.cx, y.cy, k, O);
-		return C = {
-			...t.presentationProps,
-			percent: b,
-			cornerRadius: typeof a == "string" ? parseFloat(a) : a,
-			name: g,
-			midAngle: O,
-			middleRadius: k,
-			tooltipPosition: A,
-			...w,
-			...y,
-			value: h,
-			dataKey: c,
-			startAngle: E,
-			endAngle: D,
-			payload: w,
-			paddingAngle: o(m) * _,
-			fill: T,
-			nameKey: l,
-			tooltipType: u
-		}, C;
+	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;
 	});
 }
-l([
-	p,
-	h,
-	f,
-	n
-], (e, t, n, r) => {
-	if (!(t == null || e == null)) return y({
-		offset: r,
-		pieSettings: t,
-		displayedData: e
+createSelector([
+	selectDisplayedData,
+	selectSynchronisedPieSettings,
+	pickCells,
+	selectChartOffset
+], (displayedData, pieSettings, _cells, offset) => {
+	if (pieSettings == null || displayedData == null) return;
+	return computePieSectors({
+		offset,
+		pieSettings,
+		displayedData
 	});
 });
 //#endregion
-export { y as computePieSectors, p as selectDisplayedData, m as selectPieLegend, h as selectSynchronisedPieSettings };
+export { computePieSectors, selectDisplayedData, selectPieLegend, selectSynchronisedPieSettings };