vccs 0.1.0 → 0.2.0

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

@@ -1,148 +1,167 @@
-import { selectChartHeight as e, selectChartWidth as t } from "./containerSelectors.mjs";
-import { selectChartOffset as n } from "./selectChartOffset.mjs";
-import { combineAxisRangeWithReverse as r } from "./combiners/combineAxisRangeWithReverse.mjs";
-import { getMaxRadius as i } from "../../utils/polar.mjs";
-import { getPercentValue as a } from "../../utils/data.mjs";
-import { selectChartLayout as o } from "./common.mjs";
-import { createSelector as s } from "@reduxjs/toolkit";
+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 c = {
-	allowDuplicatedCategory: !0,
+var defaultPolarAngleAxisProps = {
+	allowDuplicatedCategory: true,
 	angleAxisId: 0,
-	axisLine: !0,
+	axisLine: true,
 	cx: 0,
 	cy: 0,
 	orientation: "outer",
-	reversed: !1,
+	reversed: false,
 	scale: "auto",
-	tick: !0,
-	tickLine: !0,
+	tick: true,
+	tickLine: true,
 	tickSize: 8,
 	type: "category"
-}, l = {
-	allowDataOverflow: !1,
-	allowDecimals: !1,
-	allowDuplicatedCategory: !1,
+};
+var implicitAngleAxis = {
+	allowDataOverflow: false,
+	allowDecimals: false,
+	allowDuplicatedCategory: false,
 	dataKey: void 0,
 	domain: void 0,
 	id: void 0,
-	includeHidden: !1,
+	includeHidden: false,
 	name: void 0,
-	reversed: c.reversed,
-	scale: c.scale,
-	tick: c.tick,
+	reversed: defaultPolarAngleAxisProps.reversed,
+	scale: defaultPolarAngleAxisProps.scale,
+	tick: defaultPolarAngleAxisProps.tick,
 	tickCount: void 0,
 	ticks: void 0,
-	type: c.type,
+	type: defaultPolarAngleAxisProps.type,
 	unit: void 0
-}, u = {
-	allowDataOverflow: !1,
-	allowDuplicatedCategory: !0,
+};
+var defaultPolarRadiusAxisProps = {
+	allowDataOverflow: false,
+	allowDuplicatedCategory: true,
 	angle: 0,
-	axisLine: !0,
+	axisLine: true,
 	cx: 0,
 	cy: 0,
 	orientation: "right",
 	radiusAxisId: 0,
 	scale: "auto",
 	stroke: "#ccc",
-	tick: !0,
+	tick: true,
 	tickCount: 5,
 	type: "number"
-}, d = {
-	allowDataOverflow: u.allowDataOverflow,
-	allowDecimals: !1,
-	allowDuplicatedCategory: u.allowDuplicatedCategory,
+};
+var implicitRadiusAxis = {
+	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
 	dataKey: void 0,
 	domain: void 0,
 	id: void 0,
-	includeHidden: !1,
+	includeHidden: false,
 	name: void 0,
-	reversed: !1,
-	scale: u.scale,
-	tick: u.tick,
-	tickCount: u.tickCount,
+	reversed: false,
+	scale: defaultPolarRadiusAxisProps.scale,
+	tick: defaultPolarRadiusAxisProps.tick,
+	tickCount: defaultPolarRadiusAxisProps.tickCount,
 	ticks: void 0,
-	type: u.type,
+	type: defaultPolarRadiusAxisProps.type,
 	unit: void 0
-}, f = {
-	allowDataOverflow: !1,
-	allowDecimals: !1,
-	allowDuplicatedCategory: c.allowDuplicatedCategory,
+};
+var implicitRadialBarAngleAxis = {
+	allowDataOverflow: false,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarAngleAxisProps.allowDuplicatedCategory,
 	dataKey: void 0,
 	domain: void 0,
 	id: void 0,
-	includeHidden: !1,
+	includeHidden: false,
 	name: void 0,
-	reversed: !1,
-	scale: c.scale,
-	tick: c.tick,
+	reversed: false,
+	scale: defaultPolarAngleAxisProps.scale,
+	tick: defaultPolarAngleAxisProps.tick,
 	tickCount: void 0,
 	ticks: void 0,
 	type: "number",
 	unit: void 0
-}, p = {
-	allowDataOverflow: u.allowDataOverflow,
-	allowDecimals: !1,
-	allowDuplicatedCategory: u.allowDuplicatedCategory,
+};
+var implicitRadialBarRadiusAxis = {
+	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
 	dataKey: void 0,
 	domain: void 0,
 	id: void 0,
-	includeHidden: !1,
+	includeHidden: false,
 	name: void 0,
-	reversed: !1,
-	scale: u.scale,
-	tick: u.tick,
-	tickCount: u.tickCount,
+	reversed: false,
+	scale: defaultPolarRadiusAxisProps.scale,
+	tick: defaultPolarRadiusAxisProps.tick,
+	tickCount: defaultPolarRadiusAxisProps.tickCount,
 	ticks: void 0,
 	type: "category",
 	unit: void 0
 };
-function m(e, t) {
-	return e.polarAxis.angleAxis[t] == null ? e.layout.layoutType === "radial" ? f : l : e.polarAxis.angleAxis[t];
+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 h(e, t) {
-	return e.polarAxis.radiusAxis[t] == null ? e.layout.layoutType === "radial" ? p : d : e.polarAxis.radiusAxis[t];
+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 g = (e) => e.polarOptions, _ = s([
-	t,
-	e,
-	n
-], i), v = s([g, _], (e, t) => {
-	if (e != null) return a(e.innerRadius, t, 0);
-}), y = s([g, _], (e, t) => {
-	if (e != null) return a(e.outerRadius, t, t * .8);
+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 b(e) {
-	if (e == null) return [0, 0];
-	let { startAngle: t, endAngle: n } = e;
-	return [t, n];
+function combineAngleAxisRange(polarOptions) {
+	if (polarOptions == null) return [0, 0];
+	const { startAngle, endAngle } = polarOptions;
+	return [startAngle, endAngle];
 }
-var x = s([g], b), S = s([m, x], r), C = s([
-	_,
-	v,
-	y
-], (e, t, n) => {
-	if (!(e == null || t == null || n == null)) return [t, n];
-}), w = s([h, C], r), T = s([
-	o,
-	g,
-	v,
-	y,
-	t,
-	e
-], (e, t, n, r, i, o) => {
-	if (e !== "centric" && e !== "radial" || t == null || n == null || r == null) return;
-	let { cx: s, cy: c, startAngle: l, endAngle: u } = t;
+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: a(s, i, i / 2),
-		cy: a(c, o, o / 2),
-		innerRadius: n,
-		outerRadius: r,
-		startAngle: l,
-		endAngle: u,
-		clockWise: !1
+		cx: getPercentValue(cx, width, width / 2),
+		cy: getPercentValue(cy, height, height / 2),
+		innerRadius,
+		outerRadius,
+		startAngle,
+		endAngle,
+		clockWise: false
 	};
 });
 //#endregion
-export { m as selectAngleAxis, x as selectAngleAxisRange, S as selectAngleAxisRangeWithReversed, T as selectPolarViewBox, h as selectRadiusAxis, C as selectRadiusAxisRange, w as selectRadiusAxisRangeWithReversed };
+export { selectAngleAxis, selectAngleAxisRange, selectAngleAxisRangeWithReversed, selectPolarViewBox, selectRadiusAxis, selectRadiusAxisRange, selectRadiusAxisRangeWithReversed };

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

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

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

@@ -1,52 +1,55 @@
-import { selectChartLayout as e } from "./common.mjs";
-import { selectAngleAxis as t, selectAngleAxisRangeWithReversed as n, selectRadiusAxis as r, selectRadiusAxisRangeWithReversed as i } from "./polarAxisSelectors.mjs";
-import { pickAxisType as a } from "./pickAxisType.mjs";
-import { combineAxisTicks as o, combineCategoricalDomain as s, combineGraphicalItemTicks as c, combineScaleFunction as l, selectAxisSettings as u, selectDuplicateDomain as d, selectRealScaleType as f } from "./axisSelectors.mjs";
-import { selectPolarAppliedValues as p, selectPolarAxisDomainIncludingNiceTicks as m, selectPolarNiceTicks as h } from "./polarSelectors.mjs";
-import { createSelector as g } from "@reduxjs/toolkit";
+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 _(e, n, i) {
-	switch (n) {
-		case "angleAxis": return t(e, i);
-		case "radiusAxis": return r(e, i);
-		default: throw Error(`Unexpected axis type: ${n}`);
+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 v(e, t, r) {
-	switch (t) {
-		case "angleAxis": return n(e, r);
-		case "radiusAxis": return i(e, r);
-		default: throw Error(`Unexpected axis type: ${t}`);
+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 y = g([
-	_,
-	f,
-	m,
-	v
-], l), b = g([
-	e,
-	p,
-	u,
-	a
-], s), x = g([
-	e,
-	_,
-	f,
-	y,
-	h,
-	v,
-	d,
-	b,
-	a
-], o), S = g([
-	e,
-	_,
-	y,
-	v,
-	d,
-	b,
-	a
-], c);
+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 { y as selectPolarAxisScale, x as selectPolarAxisTicks, S as selectPolarGraphicalItemAxisTicks };
+export { selectPolarAxisScale, selectPolarAxisTicks, selectPolarGraphicalItemAxisTicks };

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

@@ -1,64 +1,81 @@
-import { selectChartDataAndAlwaysIgnoreIndexes as e, selectChartDataWithIndexes as t } from "./dataSelectors.mjs";
-import { selectStackOffsetType as n } from "./rootPropsSelectors.mjs";
-import { selectChartLayout as r } from "./common.mjs";
-import { pickAxisType as i } from "./pickAxisType.mjs";
-import { pickAxisId as a } from "./pickAxisId.mjs";
-import { getValueByDataKey as o } from "../../utils/chart.mjs";
-import { combineAppliedValues as s, combineAxisDomain as c, combineAxisDomainWithNiceTicks as l, combineDisplayedData as u, combineDomainOfStackGroups as d, combineGraphicalItemsData as f, combineGraphicalItemsSettings as p, combineNiceTicks as m, combineNumericalDomain as h, combineStackGroups as g, itemAxisPredicate as _, selectBaseAxis as v, selectDomainDefinition as y, selectRealScaleType as b } from "./axisSelectors.mjs";
-import { createSelector as x } from "@reduxjs/toolkit";
+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 S = (e) => e.graphicalItems.polarItems, C = x([
-	S,
-	v,
-	x([i, a], _)
-], p), w = x([x([C], f), e], u), T = x([
-	w,
-	v,
-	C
-], s), E = x([
-	w,
-	v,
-	C
-], (e, t, n) => n.length > 0 ? e.flatMap((e) => n.flatMap((n) => ({
-	value: o(e, t.dataKey ?? n.dataKey),
-	errorDomain: []
-}))).filter(Boolean) : t?.dataKey == null ? e.map((e) => ({
-	value: e,
-	errorDomain: []
-})) : e.map((e) => ({
-	value: o(e, t.dataKey),
-	errorDomain: []
-}))), D = x([
-	v,
-	r,
-	w,
-	T,
-	n,
-	i,
-	x([
-		v,
-		y,
-		x([
-			x([
-				w,
-				C,
-				n
-			], g),
-			t,
-			i
-		], d),
-		E,
-		() => void 0
-	], h)
-], c), O = x([
-	D,
-	v,
-	b
-], m), k = x([
-	v,
-	D,
-	O,
-	i
-], l);
+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 { T as selectPolarAppliedValues, k as selectPolarAxisDomainIncludingNiceTicks, w as selectPolarDisplayedData, C as selectPolarItemsSettings, O as selectPolarNiceTicks, S as selectUnfilteredPolarItems };
+export { selectPolarAppliedValues, selectPolarAxisDomainIncludingNiceTicks, selectPolarDisplayedData, selectPolarItemsSettings, selectPolarNiceTicks, selectUnfilteredPolarItems };