vccs 0.1.0 → 0.2.0

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

@@ -1,77 +1,90 @@
-import { isCategoricalAxis as e, isNan as t, isNumOrStr as n, isNumber as r, isWellBehavedNumber as i } from "../../utils/validate.mjs";
-import { selectChartDataWithIndexes as a, selectChartDataWithIndexesIfNotInPanorama as o } from "./dataSelectors.mjs";
-import { selectChartHeight as s, selectChartWidth as c } from "./containerSelectors.mjs";
-import { selectAllXAxes as l, selectAllYAxes as u } from "./selectAllAxes.mjs";
-import { selectChartOffset as d } from "./selectChartOffset.mjs";
-import { selectBrushDimensions as f, selectBrushSettings as p } from "./brushSelectors.mjs";
-import { selectBarCategoryGap as ee, selectChartName as m, selectStackOffsetType as h } from "./rootPropsSelectors.mjs";
-import { combineAxisRangeWithReverse as g } from "./combiners/combineAxisRangeWithReverse.mjs";
-import { getPercentValue as te, hasDuplicate as ne, mathSign as re } from "../../utils/data.mjs";
-import { selectChartLayout as _ } from "./common.mjs";
-import { selectAngleAxis as ie, selectAngleAxisRange as ae, selectRadiusAxis as oe, selectRadiusAxisRange as se } from "./polarAxisSelectors.mjs";
-import { pickAxisType as v } from "./pickAxisType.mjs";
-import { pickAxisId as y } from "./pickAxisId.mjs";
-import { checkDomainOfScale as ce, getDomainOfStackGroups as le, getStackedData as ue, getValueByDataKey as b } from "../../utils/chart.mjs";
-import { isWellFormedNumberDomain as de, numericalDomainSpecifiedWithoutRequiringData as fe, parseNumericalUserDomain as pe } from "../../utils/isDomainSpecifiedByUser.mjs";
-import { getNiceTickValues as me, getTickValuesFixedDomain as he } from "../../utils/scale/getNiceTickValues.mjs";
-import { createSelector as x } from "@reduxjs/toolkit";
-import { range as ge, upperFirst as _e } from "lodash-es";
-import * as S from "victory-vendor/d3-scale";
+import { isCategoricalAxis, isNan, isNumOrStr, isNumber, isWellBehavedNumber } from "../../utils/validate.mjs";
+import { selectChartDataWithIndexes, selectChartDataWithIndexesIfNotInPanorama } from "./dataSelectors.mjs";
+import { selectChartHeight, selectChartWidth } from "./containerSelectors.mjs";
+import { selectAllXAxes, selectAllYAxes } from "./selectAllAxes.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { selectBrushDimensions, selectBrushSettings } from "./brushSelectors.mjs";
+import { selectBarCategoryGap, selectChartName, selectStackOffsetType } from "./rootPropsSelectors.mjs";
+import { combineAxisRangeWithReverse } from "./combiners/combineAxisRangeWithReverse.mjs";
+import { getPercentValue, hasDuplicate, mathSign } from "../../utils/data.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { selectAngleAxis, selectAngleAxisRange, selectRadiusAxis, selectRadiusAxisRange } from "./polarAxisSelectors.mjs";
+import { pickAxisType } from "./pickAxisType.mjs";
+import { pickAxisId } from "./pickAxisId.mjs";
+import { checkDomainOfScale, getDomainOfStackGroups, getStackedData, getValueByDataKey } from "../../utils/chart.mjs";
+import { isWellFormedNumberDomain, numericalDomainSpecifiedWithoutRequiringData, parseNumericalUserDomain } from "../../utils/isDomainSpecifiedByUser.mjs";
+import { getNiceTickValues, getTickValuesFixedDomain } from "../../utils/scale/getNiceTickValues.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+import { range, upperFirst } from "lodash-es";
+import * as d3Scales from "victory-vendor/d3-scale";
 //#region src/state/selectors/axisSelectors.ts
-var C = [0, "auto"], ve = {
-	allowDataOverflow: !1,
-	allowDecimals: !0,
-	allowDuplicatedCategory: !0,
+var defaultNumericDomain = [0, "auto"];
+/**
+* If an axis is not explicitly defined as an element,
+* we still need to render something in the chart and we need
+* some object to hold the domain and default settings.
+*/
+var implicitXAxis = {
+	allowDataOverflow: false,
+	allowDecimals: true,
+	allowDuplicatedCategory: true,
 	angle: 0,
 	dataKey: void 0,
 	domain: void 0,
 	height: 30,
-	hide: !0,
+	hide: true,
 	id: void 0,
-	includeHidden: !1,
+	includeHidden: false,
 	interval: "preserveEnd",
 	minTickGap: 5,
-	mirror: !1,
+	mirror: false,
 	name: void 0,
 	orientation: "bottom",
 	padding: {
 		left: 0,
 		right: 0
 	},
-	reversed: !1,
+	reversed: false,
 	scale: "auto",
-	tick: !0,
+	tick: true,
 	tickCount: 5,
 	tickFormatter: void 0,
 	ticks: void 0,
 	type: "category",
 	unit: void 0
 };
-function w(e, t) {
-	return e.cartesianAxis.xAxis[t] ?? ve;
-}
-var ye = {
-	allowDataOverflow: !1,
-	allowDecimals: !0,
-	allowDuplicatedCategory: !0,
+function selectXAxisSettings(state, axisId) {
+	const axis = state.cartesianAxis.xAxis[axisId];
+	if (axis == null) return implicitXAxis;
+	return axis;
+}
+/**
+* If an axis is not explicitly defined as an element,
+* we still need to render something in the chart and we need
+* some object to hold the domain and default settings.
+*/
+var implicitYAxis = {
+	allowDataOverflow: false,
+	allowDecimals: true,
+	allowDuplicatedCategory: true,
 	angle: 0,
 	dataKey: void 0,
-	domain: C,
-	hide: !0,
+	domain: defaultNumericDomain,
+	hide: true,
 	id: void 0,
-	includeHidden: !1,
+	includeHidden: false,
 	interval: "preserveEnd",
 	minTickGap: 5,
-	mirror: !1,
+	mirror: false,
 	name: void 0,
 	orientation: "left",
 	padding: {
 		top: 0,
 		bottom: 0
 	},
-	reversed: !1,
+	reversed: false,
 	scale: "auto",
-	tick: !0,
+	tick: true,
 	tickCount: 5,
 	tickFormatter: void 0,
 	ticks: void 0,
@@ -79,15 +92,17 @@ var ye = {
 	unit: void 0,
 	width: 60
 };
-function T(e, t) {
-	return e.cartesianAxis.yAxis[t] ?? ye;
+function selectYAxisSettings(state, axisId) {
+	const axis = state.cartesianAxis.yAxis[axisId];
+	if (axis == null) return implicitYAxis;
+	return axis;
 }
-var be = {
+var implicitZAxis = {
 	domain: [0, "auto"],
-	includeHidden: !1,
-	reversed: !1,
-	allowDataOverflow: !1,
-	allowDuplicatedCategory: !1,
+	includeHidden: false,
+	reversed: false,
+	allowDataOverflow: false,
+	allowDuplicatedCategory: false,
 	dataKey: void 0,
 	id: void 0,
 	name: "",
@@ -96,598 +111,769 @@ var be = {
 	type: "number",
 	unit: ""
 };
-function E(e, t) {
-	return e.cartesianAxis.zAxis[t] ?? be;
-}
-function D(e, t, n) {
-	switch (t) {
-		case "xAxis": return w(e, n);
-		case "yAxis": return T(e, n);
-		case "zAxis": return E(e, n);
-		case "angleAxis": return ie(e, n);
-		case "radiusAxis": return oe(e, n);
-		default: throw Error(`Unexpected axis type: ${t}`);
+function selectZAxisSettings(state, axisId) {
+	const axis = state.cartesianAxis.zAxis[axisId];
+	if (axis == null) return implicitZAxis;
+	return axis;
+}
+function selectBaseAxis(state, axisType, axisId) {
+	switch (axisType) {
+		case "xAxis": return selectXAxisSettings(state, axisId);
+		case "yAxis": return selectYAxisSettings(state, axisId);
+		case "zAxis": return selectZAxisSettings(state, axisId);
+		case "angleAxis": return selectAngleAxis(state, axisId);
+		case "radiusAxis": return selectRadiusAxis(state, axisId);
+		default: throw new Error(`Unexpected axis type: ${axisType}`);
 	}
 }
-function xe(e, t, n) {
-	switch (t) {
-		case "xAxis": return w(e, n);
-		case "yAxis": return T(e, n);
-		default: throw Error(`Unexpected axis type: ${t}`);
+function selectCartesianAxisSettings(state, axisType, axisId) {
+	switch (axisType) {
+		case "xAxis": return selectXAxisSettings(state, axisId);
+		case "yAxis": return selectYAxisSettings(state, axisId);
+		default: throw new Error(`Unexpected axis type: ${axisType}`);
 	}
 }
-function O(e, t, n = 0) {
-	switch (t) {
-		case "xAxis": return w(e, n);
-		case "yAxis": return T(e, n);
-		case "angleAxis": return ie(e, n);
-		case "radiusAxis": return oe(e, n);
-		default: throw Error(`Unexpected axis type: ${t}`);
+/**
+* Selects either an X or Y axis. Doesn't work with Z axis - for that, instead use selectBaseAxis.
+* @param state Root state
+* @param axisType xAxis | yAxis
+* @param axisId xAxisId | yAxisId
+* @returns axis settings object
+*/
+function selectAxisSettings(state, axisType, axisId = 0) {
+	switch (axisType) {
+		case "xAxis": return selectXAxisSettings(state, axisId);
+		case "yAxis": return selectYAxisSettings(state, axisId);
+		case "angleAxis": return selectAngleAxis(state, axisId);
+		case "radiusAxis": return selectRadiusAxis(state, axisId);
+		default: throw new Error(`Unexpected axis type: ${axisType}`);
 	}
 }
-function k(e) {
-	return e.graphicalItems.cartesianItems.some((e) => e.type === "bar") || e.graphicalItems.polarItems.some((e) => e.type === "radialBar");
-}
-function A(e, t) {
-	return (n) => {
-		switch (e) {
-			case "xAxis": return "xAxisId" in n && n.xAxisId === t;
-			case "yAxis": return "yAxisId" in n && n.yAxisId === t;
-			case "zAxis": return "zAxisId" in n && n.zAxisId === t;
-			case "angleAxis": return "angleAxisId" in n && n.angleAxisId === t;
-			case "radiusAxis": return "radiusAxisId" in n && n.radiusAxisId === t;
-			default: return !1;
+/**
+* @param state RechartsRootState
+* @return boolean true if there is at least one Bar or RadialBar
+*/
+function selectHasBar(state) {
+	return state.graphicalItems.cartesianItems.some((item) => item.type === "bar") || state.graphicalItems.polarItems.some((item) => item.type === "radialBar");
+}
+/**
+* Filters CartesianGraphicalItemSettings by the relevant axis ID
+* @param axisType 'xAxis' | 'yAxis' | 'zAxis' | 'radiusAxis' | 'angleAxis'
+* @param axisId from props, defaults to 0
+*
+* @returns Predicate function that return true for CartesianGraphicalItemSettings that are relevant to the specified axis
+*/
+function itemAxisPredicate(axisType, axisId) {
+	return (item) => {
+		switch (axisType) {
+			case "xAxis": return "xAxisId" in item && item.xAxisId === axisId;
+			case "yAxis": return "yAxisId" in item && item.yAxisId === axisId;
+			case "zAxis": return "zAxisId" in item && item.zAxisId === axisId;
+			case "angleAxis": return "angleAxisId" in item && item.angleAxisId === axisId;
+			case "radiusAxis": return "radiusAxisId" in item && item.radiusAxisId === axisId;
+			default: return false;
 		}
 	};
 }
-function j(e) {
-	return e.graphicalItems.cartesianItems;
-}
-var Se = x([v, y], A);
-function M(e, t, n) {
-	return e.filter(n).filter((e) => t?.includeHidden === !0 ? !0 : !e.hide);
-}
-var N = x([
-	j,
-	D,
-	Se
-], M);
-function P(e) {
-	return e.filter((e) => e.stackId === void 0);
-}
-var Ce = x([N], P);
-function F(e) {
-	return e.map((e) => e.data).filter(Boolean).flat(1);
-}
-var we = x([N], F);
-function Te(e, { chartData: t = [], dataStartIndex: n, dataEndIndex: r }) {
-	return e.length > 0 ? e : t.slice(n, r + 1);
-}
-var I = x([we, o], Te);
-function Ee(e, t, n) {
-	return t?.dataKey == null ? n.length > 0 ? n.map((e) => e.dataKey).flatMap((t) => e.map((e) => ({ value: b(e, t) }))) : e.map((e) => ({ value: e })) : e.map((e) => ({ value: b(e, t.dataKey) }));
-}
-var L = x([
-	I,
-	D,
-	N
-], Ee);
-function De(e, t) {
-	switch (e) {
-		case "xAxis": return t.direction === "x";
-		case "yAxis": return t.direction === "y";
-		default: return !1;
+function selectUnfilteredCartesianItems(state) {
+	return state.graphicalItems.cartesianItems;
+}
+var selectAxisPredicate = createSelector([pickAxisType, pickAxisId], itemAxisPredicate);
+function combineGraphicalItemsSettings(graphicalItems, axisSettings, axisPredicate) {
+	return graphicalItems.filter(axisPredicate).filter((item) => {
+		if (axisSettings?.includeHidden === true) return true;
+		return !item.hide;
+	});
+}
+var selectCartesianItemsSettings = createSelector([
+	selectUnfilteredCartesianItems,
+	selectBaseAxis,
+	selectAxisPredicate
+], combineGraphicalItemsSettings);
+function filterGraphicalNotStackedItems(cartesianItems) {
+	return cartesianItems.filter((item) => item.stackId === void 0);
+}
+var selectCartesianItemsSettingsExceptStacked = createSelector([selectCartesianItemsSettings], filterGraphicalNotStackedItems);
+function combineGraphicalItemsData(cartesianItems) {
+	return cartesianItems.map((item) => item.data).filter(Boolean).flat(1);
+}
+/**
+* This is a "cheap" selector - it returns the data but doesn't iterate them, so it is not sensitive on the array length.
+* Also does not apply dataKey yet.
+* @param state RechartsRootState
+* @returns data defined on the chart graphical items, such as Line or Scatter or Pie, and filtered with appropriate dataKey
+*/
+var selectCartesianGraphicalItemsData = createSelector([selectCartesianItemsSettings], combineGraphicalItemsData);
+function combineDisplayedData(graphicalItemsData, { chartData = [], dataStartIndex, dataEndIndex }) {
+	if (graphicalItemsData.length > 0) return graphicalItemsData;
+	return chartData.slice(dataStartIndex, dataEndIndex + 1);
+}
+/**
+* This selector will return all data there is in the chart: graphical items, chart root, all together.
+* Useful for figuring out an axis domain (because that needs to know of everything),
+* not useful for rendering individual graphical elements (because they need to know which data is theirs and which is not).
+*
+* This function will discard the original indexes, so it is also not useful for anything that depends on ordering.
+*/
+var selectDisplayedData = createSelector([selectCartesianGraphicalItemsData, selectChartDataWithIndexesIfNotInPanorama], combineDisplayedData);
+function combineAppliedValues(data, axisSettings, items) {
+	if (axisSettings?.dataKey != null) return data.map((item) => ({ value: getValueByDataKey(item, axisSettings.dataKey) }));
+	if (items.length > 0) return items.map((item) => item.dataKey).flatMap((dataKey) => data.map((entry) => ({ value: getValueByDataKey(entry, dataKey) })));
+	return data.map((entry) => ({ value: entry }));
+}
+/**
+* This selector will return all values with the appropriate dataKey applied on them.
+* Which dataKey is appropriate depends on where it is defined.
+*
+* This is an expensive selector - it will iterate all data and compute their value using the provided dataKey.
+*/
+var selectAllAppliedValues = createSelector([
+	selectDisplayedData,
+	selectBaseAxis,
+	selectCartesianItemsSettings
+], combineAppliedValues);
+function isErrorBarRelevantForAxisType(axisType, errorBar) {
+	switch (axisType) {
+		case "xAxis": return errorBar.direction === "x";
+		case "yAxis": return errorBar.direction === "y";
+		default: return false;
 	}
 }
-function R(e) {
-	return e.filter((e) => n(e) || e instanceof Date).map(Number).filter((e) => t(e) === !1);
+function onlyAllowNumbers(data) {
+	return data.filter((v) => isNumOrStr(v) || v instanceof Date).map(Number).filter((n) => isNan(n) === false);
+}
+/**
+* @param entry One item in the 'data' array. Could be anything really - this is defined externally. This is the raw, before dataKey application
+* @param appliedValue This is the result of applying the 'main' dataKey on the `entry`.
+* @param relevantErrorBars Error bars that are relevant for the current axis and layout and all that.
+* @return either undefined or an array of ErrorValue
+*/
+function getErrorDomainByDataKey(entry, appliedValue, relevantErrorBars) {
+	if (!relevantErrorBars || typeof appliedValue !== "number" || isNan(appliedValue)) return [];
+	if (!relevantErrorBars.length) return [];
+	return onlyAllowNumbers(relevantErrorBars.flatMap((eb) => {
+		const errorValue = getValueByDataKey(entry, eb.dataKey);
+		let lowBound, highBound;
+		if (Array.isArray(errorValue)) [lowBound, highBound] = errorValue;
+		else lowBound = highBound = errorValue;
+		if (!isWellBehavedNumber(lowBound) || !isWellBehavedNumber(highBound)) return;
+		return [appliedValue - lowBound, appliedValue + highBound];
+	}));
 }
-function Oe(e, n, r) {
-	return !r || typeof n != "number" || t(n) || !r.length ? [] : R(r.flatMap((t) => {
-		let r = b(e, t.dataKey), a, o;
-		if (Array.isArray(r) ? [a, o] = r : a = o = r, !(!i(a) || !i(o))) return [n - a, n + o];
+function combineStackGroups(displayedData, items, stackOffsetType) {
+	const itemsGroup = items.reduce((acc, item) => {
+		if (item.stackId == null) return acc;
+		if (acc[item.stackId] == null) acc[item.stackId] = [];
+		acc[item.stackId].push(item);
+		return acc;
+	}, {});
+	return Object.fromEntries(Object.entries(itemsGroup).map(([stackId, graphicalItems]) => {
+		return [stackId, {
+			stackedData: getStackedData(displayedData, graphicalItems.map((i) => i.dataKey), stackOffsetType),
+			graphicalItems
+		}];
 	}));
 }
-function ke(e, t, n) {
-	let r = t.reduce((e, t) => t.stackId == null ? e : (e[t.stackId] ?? (e[t.stackId] = []), e[t.stackId].push(t), e), {});
-	return Object.fromEntries(Object.entries(r).map(([t, r]) => [t, {
-		stackedData: ue(e, r.map((e) => e.dataKey), n),
-		graphicalItems: r
-	}]));
-}
-var Ae = x([
-	I,
-	N,
-	h
-], ke);
-function je(e, { dataStartIndex: t, dataEndIndex: n }, r) {
-	if (r === "zAxis") return;
-	let i = le(e, t, n);
-	if (!(i != null && i[0] === 0 && i[1] === 0)) return i;
-}
-var Me = x([
-	Ae,
-	a,
-	v
-], je);
-function Ne(e, t, n, r) {
-	return n.length > 0 ? e.flatMap((e) => n.flatMap((n) => {
-		let i = n.errorBars?.filter((e) => De(r, e)), a = b(e, t.dataKey || n.dataKey);
-		return {
-			value: a,
-			errorDomain: Oe(e, a, i)
-		};
-	})).filter(Boolean) : t?.dataKey == null ? e.map((e) => ({
-		value: e,
+/**
+* Stack groups are groups of graphical items that stack on each other.
+* Stack is a function of axis type (X, Y), axis ID, and stack ID.
+* Graphical items that do not have a stack ID are not going to be present in stack groups.
+*/
+var selectStackGroups = createSelector([
+	selectDisplayedData,
+	selectCartesianItemsSettings,
+	selectStackOffsetType
+], combineStackGroups);
+function combineDomainOfStackGroups(stackGroups, { dataStartIndex, dataEndIndex }, axisType) {
+	if (axisType === "zAxis") return;
+	const domainOfStackGroups = getDomainOfStackGroups(stackGroups, dataStartIndex, dataEndIndex);
+	if (domainOfStackGroups != null && domainOfStackGroups[0] === 0 && domainOfStackGroups[1] === 0) return;
+	return domainOfStackGroups;
+}
+var selectDomainOfStackGroups = createSelector([
+	selectStackGroups,
+	selectChartDataWithIndexes,
+	pickAxisType
+], combineDomainOfStackGroups);
+function combineAppliedNumericalValuesIncludingErrorValues(data, axisSettings, items, axisType) {
+	if (items.length > 0) return data.flatMap((entry) => {
+		return items.flatMap((item) => {
+			const relevantErrorBars = item.errorBars?.filter((errorBar) => isErrorBarRelevantForAxisType(axisType, errorBar));
+			const valueByDataKey = getValueByDataKey(entry, axisSettings.dataKey || item.dataKey);
+			return {
+				value: valueByDataKey,
+				errorDomain: getErrorDomainByDataKey(entry, valueByDataKey, relevantErrorBars)
+			};
+		});
+	}).filter(Boolean);
+	if (axisSettings?.dataKey != null) return data.map((item) => ({
+		value: getValueByDataKey(item, axisSettings.dataKey),
 		errorDomain: []
-	})) : e.map((e) => ({
-		value: b(e, t.dataKey),
+	}));
+	return data.map((entry) => ({
+		value: entry,
 		errorDomain: []
 	}));
 }
-var Pe = x(I, D, Ce, v, Ne);
-function Fe(e) {
-	let { value: t } = e;
-	if (n(t) || t instanceof Date) return t;
-}
-function Ie(e) {
-	let t = R(e.flatMap((e) => [e.value, e.errorDomain]).flat(1));
-	if (t.length !== 0) return [Math.min(...t), Math.max(...t)];
-}
-function Le(e, t, n) {
-	let r = e.map(Fe).filter((e) => e != null);
-	return n && (t.dataKey == null || t.allowDuplicatedCategory && ne(r)) ? ge(0, e.length) : t.allowDuplicatedCategory ? r : Array.from(new Set(r));
-}
-function z(e) {
-	if (e == null || !("domain" in e)) return C;
-	if (e.domain != null) return e.domain;
-	if (e.ticks != null) {
-		if (e.type === "number") {
-			let t = R(e.ticks);
-			return [Math.min(...t), Math.max(...t)];
+var selectAllAppliedNumericalValuesIncludingErrorValues = createSelector(selectDisplayedData, selectBaseAxis, selectCartesianItemsSettingsExceptStacked, pickAxisType, combineAppliedNumericalValuesIncludingErrorValues);
+function onlyAllowNumbersAndStringsAndDates(item) {
+	const { value } = item;
+	if (isNumOrStr(value) || value instanceof Date) return value;
+}
+function computeNumericalDomain(dataWithErrorDomains) {
+	const onlyNumbers = onlyAllowNumbers(dataWithErrorDomains.flatMap((d) => [d.value, d.errorDomain]).flat(1));
+	if (onlyNumbers.length === 0) return;
+	return [Math.min(...onlyNumbers), Math.max(...onlyNumbers)];
+}
+function computeDomainOfTypeCategory(allDataSquished, axisSettings, isCategorical) {
+	const categoricalDomain = allDataSquished.map(onlyAllowNumbersAndStringsAndDates).filter((v) => v != null);
+	if (isCategorical && (axisSettings.dataKey == null || axisSettings.allowDuplicatedCategory && hasDuplicate(categoricalDomain))) return range(0, allDataSquished.length);
+	if (axisSettings.allowDuplicatedCategory) return categoricalDomain;
+	return Array.from(new Set(categoricalDomain));
+}
+function getDomainDefinition(axisSettings) {
+	if (axisSettings == null || !("domain" in axisSettings)) return defaultNumericDomain;
+	if (axisSettings.domain != null) return axisSettings.domain;
+	if (axisSettings.ticks != null) {
+		if (axisSettings.type === "number") {
+			const allValues = onlyAllowNumbers(axisSettings.ticks);
+			return [Math.min(...allValues), Math.max(...allValues)];
 		}
-		if (e.type === "category") return e.ticks.map(String);
+		if (axisSettings.type === "category") return axisSettings.ticks.map(String);
 	}
-	return e?.domain ?? C;
-}
-function B(...e) {
-	let t = e.filter(Boolean);
-	if (t.length === 0) return;
-	let n = t.flat().filter(r);
-	return [Math.min(...n), Math.max(...n)];
-}
-function Re(e) {
-	return e.referenceElements.dots;
-}
-function V(e, t, n) {
-	return e.filter((e) => e.ifOverflow === "extendDomain").filter((e) => t === "xAxis" ? e.xAxisId === n : e.yAxisId === n);
-}
-var ze = x([
-	Re,
-	v,
-	y
-], V);
-function Be(e) {
-	return e.referenceElements.areas;
-}
-var Ve = x([
-	Be,
-	v,
-	y
-], V);
-function He(e) {
-	return e.referenceElements.lines;
-}
-var Ue = x([
-	He,
-	v,
-	y
-], V);
-function H(e, t) {
-	let n = R(e.map((e) => t === "xAxis" ? e.x : e.y));
-	if (n.length !== 0) return [Math.min(...n), Math.max(...n)];
-}
-var We = x(ze, v, H);
-function Ge(e, t) {
-	let n = R(e.flatMap((e) => [t === "xAxis" ? e.x1 : e.y1, t === "xAxis" ? e.x2 : e.y2]));
-	if (n.length !== 0) return [Math.min(...n), Math.max(...n)];
-}
-var Ke = x([Ve, v], Ge);
-function qe(e, t) {
-	let n = R(e.map((e) => t === "xAxis" ? e.x : e.y));
-	if (n.length !== 0) return [Math.min(...n), Math.max(...n)];
-}
-var Je = x(We, x(Ue, v, qe), Ke, (e, t, n) => B(e, n, t)), Ye = x([D], z);
-function Xe(e, t, n, r, i) {
-	return fe(t, e.allowDataOverflow) ?? pe(t, B(n, i, Ie(r)), e.allowDataOverflow);
-}
-var Ze = x([
-	D,
-	Ye,
-	Me,
-	Pe,
-	Je
-], Xe), Qe = [0, 1];
-function $e(t, n, r, i, a, o, s) {
-	if ((t == null || r == null || r.length === 0) && s === void 0) return;
-	let { dataKey: c, type: l } = t, u = e(n, o);
-	if (u && c == null) {
-		let e = Array.isArray(t.domain) ? t.domain.length : 0;
-		return ge(0, Math.max(r.length, e));
+	return axisSettings?.domain ?? defaultNumericDomain;
+}
+function mergeDomains(...domains) {
+	const allDomains = domains.filter(Boolean);
+	if (allDomains.length === 0) return;
+	const allNumbers = allDomains.flat().filter(isNumber);
+	return [Math.min(...allNumbers), Math.max(...allNumbers)];
+}
+function selectReferenceDots(state) {
+	return state.referenceElements.dots;
+}
+function filterReferenceElements(elements, axisType, axisId) {
+	return elements.filter((el) => el.ifOverflow === "extendDomain").filter((el) => {
+		if (axisType === "xAxis") return el.xAxisId === axisId;
+		return el.yAxisId === axisId;
+	});
+}
+var selectReferenceDotsByAxis = createSelector([
+	selectReferenceDots,
+	pickAxisType,
+	pickAxisId
+], filterReferenceElements);
+function selectReferenceAreas(state) {
+	return state.referenceElements.areas;
+}
+var selectReferenceAreasByAxis = createSelector([
+	selectReferenceAreas,
+	pickAxisType,
+	pickAxisId
+], filterReferenceElements);
+function selectReferenceLines(state) {
+	return state.referenceElements.lines;
+}
+var selectReferenceLinesByAxis = createSelector([
+	selectReferenceLines,
+	pickAxisType,
+	pickAxisId
+], filterReferenceElements);
+function combineDotsDomain(dots, axisType) {
+	const allCoords = onlyAllowNumbers(dots.map((dot) => axisType === "xAxis" ? dot.x : dot.y));
+	if (allCoords.length === 0) return;
+	return [Math.min(...allCoords), Math.max(...allCoords)];
+}
+var selectReferenceDotsDomain = createSelector(selectReferenceDotsByAxis, pickAxisType, combineDotsDomain);
+function combineAreasDomain(areas, axisType) {
+	const allCoords = onlyAllowNumbers(areas.flatMap((area) => [axisType === "xAxis" ? area.x1 : area.y1, axisType === "xAxis" ? area.x2 : area.y2]));
+	if (allCoords.length === 0) return;
+	return [Math.min(...allCoords), Math.max(...allCoords)];
+}
+var selectReferenceAreasDomain = createSelector([selectReferenceAreasByAxis, pickAxisType], combineAreasDomain);
+function combineLinesDomain(lines, axisType) {
+	const allCoords = onlyAllowNumbers(lines.map((line) => axisType === "xAxis" ? line.x : line.y));
+	if (allCoords.length === 0) return;
+	return [Math.min(...allCoords), Math.max(...allCoords)];
+}
+var selectReferenceElementsDomain = createSelector(selectReferenceDotsDomain, createSelector(selectReferenceLinesByAxis, pickAxisType, combineLinesDomain), selectReferenceAreasDomain, (dotsDomain, linesDomain, areasDomain) => {
+	return mergeDomains(dotsDomain, areasDomain, linesDomain);
+});
+var selectDomainDefinition = createSelector([selectBaseAxis], getDomainDefinition);
+function combineNumericalDomain(axisSettings, domainDefinition, domainOfStackGroups, allDataWithErrorDomains, referenceElementsDomain) {
+	const domainFromUserPreference = numericalDomainSpecifiedWithoutRequiringData(domainDefinition, axisSettings.allowDataOverflow);
+	if (domainFromUserPreference != null) return domainFromUserPreference;
+	return parseNumericalUserDomain(domainDefinition, mergeDomains(domainOfStackGroups, referenceElementsDomain, computeNumericalDomain(allDataWithErrorDomains)), axisSettings.allowDataOverflow);
+}
+var selectNumericalDomain = createSelector([
+	selectBaseAxis,
+	selectDomainDefinition,
+	selectDomainOfStackGroups,
+	selectAllAppliedNumericalValuesIncludingErrorValues,
+	selectReferenceElementsDomain
+], combineNumericalDomain);
+/**
+* Expand by design maps everything between 0 and 1,
+* there is nothing to compute.
+* See https://d3js.org/d3-shape/stack#stack-offsets
+*/
+var expandDomain = [0, 1];
+function combineAxisDomain(axisSettings, layout, displayedData, allAppliedValues, stackOffsetType, axisType, numericalDomain) {
+	if ((axisSettings == null || displayedData == null || displayedData.length === 0) && numericalDomain === void 0) return;
+	const { dataKey, type } = axisSettings;
+	const isCategorical = isCategoricalAxis(layout, axisType);
+	if (isCategorical && dataKey == null) {
+		const domainLen = Array.isArray(axisSettings.domain) ? axisSettings.domain.length : 0;
+		return range(0, Math.max(displayedData.length, domainLen));
 	}
-	return l === "category" ? Le(i, t, u) : a === "expand" ? Qe : s;
-}
-var U = x([
-	D,
-	_,
-	I,
-	L,
-	h,
-	v,
-	Ze
-], $e);
-function et(e, t, n) {
-	if (e == null) return;
-	let { scale: r, type: i } = e;
-	if (r === "auto") return i === "category" && n && (n.includes("LineChart") || n.includes("AreaChart") || n.includes("ComposedChart") && !t) ? "point" : i === "category" ? "band" : "linear";
-	if (typeof r == "string") {
-		let e = `scale${_e(r)}`;
-		return e in S ? e : "point";
+	if (type === "category") return computeDomainOfTypeCategory(allAppliedValues, axisSettings, isCategorical);
+	if (stackOffsetType === "expand") return expandDomain;
+	return numericalDomain;
+}
+var selectAxisDomain = createSelector([
+	selectBaseAxis,
+	selectChartLayout,
+	selectDisplayedData,
+	selectAllAppliedValues,
+	selectStackOffsetType,
+	pickAxisType,
+	selectNumericalDomain
+], combineAxisDomain);
+function combineRealScaleType(axisConfig, hasBar, chartType) {
+	if (axisConfig == null) return;
+	const { scale, type } = axisConfig;
+	if (scale === "auto") {
+		if (type === "category" && chartType && (chartType.includes("LineChart") || chartType.includes("AreaChart") || chartType.includes("ComposedChart") && !hasBar)) return "point";
+		if (type === "category") return "band";
+		return "linear";
 	}
-}
-var W = x([
-	D,
-	k,
-	m
-], et);
-function tt(e) {
-	if (e == null) return;
-	if (e in S) return S[e]();
-	let t = `scale${_e(e)}`;
-	if (t in S) return S[t]();
-}
-function G(e, t, n, r) {
-	if (n == null || r == null) return;
-	if (typeof e.scale == "function") return e.scale.copy().domain(n).range(r);
-	let i = tt(t);
-	if (i == null) return;
-	let a = i.domain(n).range(r);
-	return ce(a), a;
-}
-function nt(e, t, n) {
-	let r = z(t);
-	if (!(n !== "auto" && n !== "linear")) {
-		if (t != null && t.tickCount && Array.isArray(r) && (r[0] === "auto" || r[1] === "auto") && de(e)) return me(e, t.tickCount, t.allowDecimals);
-		if (t != null && t.tickCount && t.type === "number" && e != null) return he(e, t.tickCount, t.allowDecimals);
+	if (typeof scale === "string") {
+		const name = `scale${upperFirst(scale)}`;
+		return name in d3Scales ? name : "point";
 	}
 }
-var K = x([
-	U,
-	O,
-	W
-], nt);
-function rt(e, t, n, r) {
-	if (r !== "angleAxis" && e?.type === "number" && de(t) && Array.isArray(n) && n.length > 0) {
-		let e = t[0], r = n[0], i = t[1], a = n[n.length - 1];
-		return [Math.min(e, r), Math.max(i, a)];
+var selectRealScaleType = createSelector([
+	selectBaseAxis,
+	selectHasBar,
+	selectChartName
+], combineRealScaleType);
+function getD3ScaleFromType(realScaleType) {
+	if (realScaleType == null) return;
+	if (realScaleType in d3Scales) return d3Scales[realScaleType]();
+	const name = `scale${upperFirst(realScaleType)}`;
+	if (name in d3Scales) return d3Scales[name]();
+}
+function combineScaleFunction(axis, realScaleType, axisDomain, axisRange) {
+	if (axisDomain == null || axisRange == null) return;
+	if (typeof axis.scale === "function") return axis.scale.copy().domain(axisDomain).range(axisRange);
+	const d3ScaleFunction = getD3ScaleFromType(realScaleType);
+	if (d3ScaleFunction == null) return;
+	const scale = d3ScaleFunction.domain(axisDomain).range(axisRange);
+	checkDomainOfScale(scale);
+	return scale;
+}
+function combineNiceTicks(axisDomain, axisSettings, realScaleType) {
+	const domainDefinition = getDomainDefinition(axisSettings);
+	if (realScaleType !== "auto" && realScaleType !== "linear") return;
+	if (axisSettings != null && axisSettings.tickCount && Array.isArray(domainDefinition) && (domainDefinition[0] === "auto" || domainDefinition[1] === "auto") && isWellFormedNumberDomain(axisDomain)) return getNiceTickValues(axisDomain, axisSettings.tickCount, axisSettings.allowDecimals);
+	if (axisSettings != null && axisSettings.tickCount && axisSettings.type === "number" && axisDomain != null) return getTickValuesFixedDomain(axisDomain, axisSettings.tickCount, axisSettings.allowDecimals);
+}
+var selectNiceTicks = createSelector([
+	selectAxisDomain,
+	selectAxisSettings,
+	selectRealScaleType
+], combineNiceTicks);
+function combineAxisDomainWithNiceTicks(axisSettings, domain, niceTicks, axisType) {
+	if (axisType !== "angleAxis" && axisSettings?.type === "number" && isWellFormedNumberDomain(domain) && Array.isArray(niceTicks) && niceTicks.length > 0) {
+		const minFromDomain = domain[0];
+		const minFromTicks = niceTicks[0];
+		const maxFromDomain = domain[1];
+		const maxFromTicks = niceTicks[niceTicks.length - 1];
+		return [Math.min(minFromDomain, minFromTicks), Math.max(maxFromDomain, maxFromTicks)];
 	}
-	return t;
-}
-var it = x([
-	D,
-	U,
-	K,
-	v
-], rt), at = x(x(L, D, (e, t) => {
-	if (!t || t.type !== "number") return;
-	let n = Infinity, r = Array.from(R(e.map((e) => e.value))).sort((e, t) => e - t);
-	if (r.length < 2) return Infinity;
-	let i = r[r.length - 1] - r[0];
-	if (i === 0) return Infinity;
-	for (let e = 0; e < r.length - 1; e++) {
-		let t = r[e + 1] - r[e];
-		n = Math.min(n, t);
+	return domain;
+}
+var selectAxisDomainIncludingNiceTicks = createSelector([
+	selectBaseAxis,
+	selectAxisDomain,
+	selectNiceTicks,
+	pickAxisType
+], combineAxisDomainWithNiceTicks);
+var selectCalculatedPadding = createSelector(createSelector(selectAllAppliedValues, selectBaseAxis, (allDataSquished, axisSettings) => {
+	if (!axisSettings || axisSettings.type !== "number") return;
+	let smallestDistanceBetweenValues = Infinity;
+	const sortedValues = Array.from(onlyAllowNumbers(allDataSquished.map((d) => d.value))).sort((a, b) => a - b);
+	if (sortedValues.length < 2) return Infinity;
+	const diff = sortedValues[sortedValues.length - 1] - sortedValues[0];
+	if (diff === 0) return Infinity;
+	for (let i = 0; i < sortedValues.length - 1; i++) {
+		const distance = sortedValues[i + 1] - sortedValues[i];
+		smallestDistanceBetweenValues = Math.min(smallestDistanceBetweenValues, distance);
 	}
-	return n / i;
-}), _, ee, d, (e, t, n, r) => r, (e, t, n, r, a) => {
-	if (!i(e)) return 0;
-	let o = t === "vertical" ? r.height : r.width;
-	if (a === "gap") return e * o / 2;
-	if (a === "no-gap") {
-		let t = te(n, e * o), r = e * o / 2;
-		return r - t - (r - t) / o * t;
+	return smallestDistanceBetweenValues / diff;
+}), selectChartLayout, selectBarCategoryGap, selectChartOffset, (_1, _2, _3, padding) => padding, (smallestDistanceInPercent, layout, barCategoryGap, offset, padding) => {
+	if (!isWellBehavedNumber(smallestDistanceInPercent)) return 0;
+	const rangeWidth = layout === "vertical" ? offset.height : offset.width;
+	if (padding === "gap") return smallestDistanceInPercent * rangeWidth / 2;
+	if (padding === "no-gap") {
+		const gap = getPercentValue(barCategoryGap, smallestDistanceInPercent * rangeWidth);
+		const halfBand = smallestDistanceInPercent * rangeWidth / 2;
+		return halfBand - gap - (halfBand - gap) / rangeWidth * gap;
 	}
 	return 0;
-}), ot = (e, t) => {
-	let n = w(e, t);
-	return n == null || typeof n.padding != "string" ? 0 : at(e, "xAxis", t, n.padding);
-}, st = (e, t) => {
-	let n = T(e, t);
-	return n == null || typeof n.padding != "string" ? 0 : at(e, "yAxis", t, n.padding);
-}, ct = x(w, ot, (e, t) => {
-	if (e == null) return {
+});
+var selectCalculatedXAxisPadding = (state, axisId) => {
+	const xAxisSettings = selectXAxisSettings(state, axisId);
+	if (xAxisSettings == null || typeof xAxisSettings.padding !== "string") return 0;
+	return selectCalculatedPadding(state, "xAxis", axisId, xAxisSettings.padding);
+};
+var selectCalculatedYAxisPadding = (state, axisId) => {
+	const yAxisSettings = selectYAxisSettings(state, axisId);
+	if (yAxisSettings == null || typeof yAxisSettings.padding !== "string") return 0;
+	return selectCalculatedPadding(state, "yAxis", axisId, yAxisSettings.padding);
+};
+var selectXAxisPadding = createSelector(selectXAxisSettings, selectCalculatedXAxisPadding, (xAxisSettings, calculated) => {
+	if (xAxisSettings == null) return {
 		left: 0,
 		right: 0
 	};
-	let { padding: n } = e;
-	return typeof n == "string" ? {
-		left: t,
-		right: t
-	} : {
-		left: (n.left ?? 0) + t,
-		right: (n.right ?? 0) + t
+	const { padding } = xAxisSettings;
+	if (typeof padding === "string") return {
+		left: calculated,
+		right: calculated
 	};
-}), lt = x(T, st, (e, t) => {
-	if (e == null) return {
+	return {
+		left: (padding.left ?? 0) + calculated,
+		right: (padding.right ?? 0) + calculated
+	};
+});
+var selectYAxisPadding = createSelector(selectYAxisSettings, selectCalculatedYAxisPadding, (yAxisSettings, calculated) => {
+	if (yAxisSettings == null) return {
 		top: 0,
 		bottom: 0
 	};
-	let { padding: n } = e;
-	return typeof n == "string" ? {
-		top: t,
-		bottom: t
-	} : {
-		top: (n.top ?? 0) + t,
-		bottom: (n.bottom ?? 0) + t
+	const { padding } = yAxisSettings;
+	if (typeof padding === "string") return {
+		top: calculated,
+		bottom: calculated
+	};
+	return {
+		top: (padding.top ?? 0) + calculated,
+		bottom: (padding.bottom ?? 0) + calculated
 	};
-}), ut = x([
-	d,
-	ct,
-	f,
-	p,
-	(e, t, n) => n
-], (e, t, n, { padding: r }, i) => i ? [r.left, n.width - r.right] : [e.left + t.left, e.left + e.width - t.right]), dt = x([
-	d,
-	_,
-	lt,
-	f,
-	p,
-	(e, t, n) => n
-], (e, t, n, r, { padding: i }, a) => a ? [r.height - i.bottom, i.top] : t === "horizontal" ? [e.top + e.height - n.bottom, e.top + n.top] : [e.top + n.top, e.top + e.height - n.bottom]);
-function q(e, t, n, r) {
-	switch (t) {
-		case "xAxis": return ut(e, n, r);
-		case "yAxis": return dt(e, n, r);
-		case "zAxis": return E(e, n)?.range;
-		case "angleAxis": return ae(e);
-		case "radiusAxis": return se(e, n);
+});
+var combineXAxisRange = createSelector([
+	selectChartOffset,
+	selectXAxisPadding,
+	selectBrushDimensions,
+	selectBrushSettings,
+	(_state, _axisId, isPanorama) => isPanorama
+], (offset, padding, brushDimensions, { padding: brushPadding }, isPanorama) => {
+	if (isPanorama) return [brushPadding.left, brushDimensions.width - brushPadding.right];
+	return [offset.left + padding.left, offset.left + offset.width - padding.right];
+});
+var combineYAxisRange = createSelector([
+	selectChartOffset,
+	selectChartLayout,
+	selectYAxisPadding,
+	selectBrushDimensions,
+	selectBrushSettings,
+	(_state, _axisId, isPanorama) => isPanorama
+], (offset, layout, padding, brushDimensions, { padding: brushPadding }, isPanorama) => {
+	if (isPanorama) return [brushDimensions.height - brushPadding.bottom, brushPadding.top];
+	if (layout === "horizontal") return [offset.top + offset.height - padding.bottom, offset.top + padding.top];
+	return [offset.top + padding.top, offset.top + offset.height - padding.bottom];
+});
+function selectAxisRange(state, axisType, axisId, isPanorama) {
+	switch (axisType) {
+		case "xAxis": return combineXAxisRange(state, axisId, isPanorama);
+		case "yAxis": return combineYAxisRange(state, axisId, isPanorama);
+		case "zAxis": return selectZAxisSettings(state, axisId)?.range;
+		case "angleAxis": return selectAngleAxisRange(state);
+		case "radiusAxis": return selectRadiusAxisRange(state, axisId);
 		default: return;
 	}
 }
-var ft = x([D, q], g), J = x([
-	D,
-	W,
-	it,
-	ft
-], G);
-x(N, v, (e, t) => e.flatMap((e) => e.errorBars ?? []).filter((e) => De(t, e)));
-function pt(e, t) {
-	return e.id < t.id ? -1 : e.id > t.id ? 1 : 0;
-}
-var Y = (e, t) => t, X = (e, t, n) => n, mt = x(l, Y, X, (e, t, n) => e.filter((e) => e.orientation === t).filter((e) => e.mirror === n).sort(pt)), ht = x(u, Y, X, (e, t, n) => e.filter((e) => e.orientation === t).filter((e) => e.mirror === n).sort(pt));
-function gt(e, t) {
+var selectAxisRangeWithReverse = createSelector([selectBaseAxis, selectAxisRange], combineAxisRangeWithReverse);
+var selectAxisScale = createSelector([
+	selectBaseAxis,
+	selectRealScaleType,
+	selectAxisDomainIncludingNiceTicks,
+	selectAxisRangeWithReverse
+], combineScaleFunction);
+createSelector(selectCartesianItemsSettings, pickAxisType, (items, axisType) => {
+	return items.flatMap((item) => {
+		return item.errorBars ?? [];
+	}).filter((e) => {
+		return isErrorBarRelevantForAxisType(axisType, e);
+	});
+});
+function compareIds(a, b) {
+	if (a.id < b.id) return -1;
+	if (a.id > b.id) return 1;
+	return 0;
+}
+var pickAxisOrientation = (_state, orientation) => orientation;
+var pickMirror = (_state, _orientation, mirror) => mirror;
+var selectAllXAxesWithOffsetType = createSelector(selectAllXAxes, pickAxisOrientation, pickMirror, (allAxes, orientation, mirror) => allAxes.filter((axis) => axis.orientation === orientation).filter((axis) => axis.mirror === mirror).sort(compareIds));
+var selectAllYAxesWithOffsetType = createSelector(selectAllYAxes, pickAxisOrientation, pickMirror, (allAxes, orientation, mirror) => allAxes.filter((axis) => axis.orientation === orientation).filter((axis) => axis.mirror === mirror).sort(compareIds));
+function getXAxisSize(offset, axisSettings) {
 	return {
-		width: e.width,
-		height: t.height
+		width: offset.width,
+		height: axisSettings.height
 	};
 }
-function _t(e, t) {
+function getYAxisSize(offset, axisSettings) {
 	return {
-		width: t.width,
-		height: e.height
+		width: axisSettings.width,
+		height: offset.height
 	};
 }
-var vt = x(d, w, gt);
-function yt(e, t, n) {
-	switch (t) {
-		case "top": return e.top;
-		case "bottom": return n - e.bottom;
+var selectXAxisSize = createSelector(selectChartOffset, selectXAxisSettings, getXAxisSize);
+function combineXAxisPositionStartingPoint(offset, orientation, chartHeight) {
+	switch (orientation) {
+		case "top": return offset.top;
+		case "bottom": return chartHeight - offset.bottom;
 		default: return 0;
 	}
 }
-function bt(e, t, n) {
-	switch (t) {
-		case "left": return e.left;
-		case "right": return n - e.right;
+function combineYAxisPositionStartingPoint(offset, orientation, chartWidth) {
+	switch (orientation) {
+		case "left": return offset.left;
+		case "right": return chartWidth - offset.right;
 		default: return 0;
 	}
 }
-var xt = x(s, d, mt, Y, X, (e, t, n, r, i) => {
-	let a = {}, o;
-	return n.forEach((n) => {
-		let s = gt(t, n);
-		o ??= yt(t, r, e);
-		let c = r === "top" && !i || r === "bottom" && i;
-		a[n.id] = o - Number(c) * s.height, o += (c ? -1 : 1) * s.height;
-	}), a;
-}), St = x(c, d, ht, Y, X, (e, t, n, r, i) => {
-	let a = {}, o;
-	return n.forEach((n) => {
-		let s = _t(t, n);
-		o ??= bt(t, r, e);
-		let c = r === "left" && !i || r === "right" && i;
-		a[n.id] = o - Number(c) * s.width, o += (c ? -1 : 1) * s.width;
-	}), a;
+var selectAllXAxesOffsetSteps = createSelector(selectChartHeight, selectChartOffset, selectAllXAxesWithOffsetType, pickAxisOrientation, pickMirror, (chartHeight, offset, allAxesWithSameOffsetType, orientation, mirror) => {
+	const steps = {};
+	let position;
+	allAxesWithSameOffsetType.forEach((axis) => {
+		const axisSize = getXAxisSize(offset, axis);
+		if (position == null) position = combineXAxisPositionStartingPoint(offset, orientation, chartHeight);
+		const needSpace = orientation === "top" && !mirror || orientation === "bottom" && mirror;
+		steps[axis.id] = position - Number(needSpace) * axisSize.height;
+		position += (needSpace ? -1 : 1) * axisSize.height;
+	});
+	return steps;
+});
+var selectAllYAxesOffsetSteps = createSelector(selectChartWidth, selectChartOffset, selectAllYAxesWithOffsetType, pickAxisOrientation, pickMirror, (chartWidth, offset, allAxesWithSameOffsetType, orientation, mirror) => {
+	const steps = {};
+	let position;
+	allAxesWithSameOffsetType.forEach((axis) => {
+		const axisSize = getYAxisSize(offset, axis);
+		if (position == null) position = combineYAxisPositionStartingPoint(offset, orientation, chartWidth);
+		const needSpace = orientation === "left" && !mirror || orientation === "right" && mirror;
+		steps[axis.id] = position - Number(needSpace) * axisSize.width;
+		position += (needSpace ? -1 : 1) * axisSize.width;
+	});
+	return steps;
 });
-function Ct(e, t) {
-	let n = d(e), r = w(e, t);
-	if (r == null) return;
-	let i = xt(e, r.orientation, r.mirror)[t];
-	return i == null ? {
-		x: n.left,
+function selectXAxisPosition(state, axisId) {
+	const offset = selectChartOffset(state);
+	const axisSettings = selectXAxisSettings(state, axisId);
+	if (axisSettings == null) return;
+	const stepOfThisAxis = selectAllXAxesOffsetSteps(state, axisSettings.orientation, axisSettings.mirror)[axisId];
+	if (stepOfThisAxis == null) return {
+		x: offset.left,
 		y: 0
-	} : {
-		x: n.left,
-		y: i
+	};
+	return {
+		x: offset.left,
+		y: stepOfThisAxis
 	};
 }
-function wt(e, t) {
-	let n = d(e), r = T(e, t);
-	if (r == null) return;
-	let i = St(e, r.orientation, r.mirror)[t];
-	return i == null ? {
+function selectYAxisPosition(state, axisId) {
+	const offset = selectChartOffset(state);
+	const axisSettings = selectYAxisSettings(state, axisId);
+	if (axisSettings == null) return;
+	const stepOfThisAxis = selectAllYAxesOffsetSteps(state, axisSettings.orientation, axisSettings.mirror)[axisId];
+	if (stepOfThisAxis == null) return {
 		x: 0,
-		y: n.top
-	} : {
-		x: i,
-		y: n.top
+		y: offset.top
+	};
+	return {
+		x: stepOfThisAxis,
+		y: offset.top
 	};
 }
-var Tt = x(d, T, (e, t) => ({
-	width: t.width,
-	height: e.height
-}));
-function Et(e, t, n) {
-	switch (t) {
-		case "xAxis": return vt(e, n).width;
-		case "yAxis": return Tt(e, n).height;
+var selectYAxisSize = createSelector(selectChartOffset, selectYAxisSettings, (offset, axisSettings) => {
+	return {
+		width: axisSettings.width,
+		height: offset.height
+	};
+});
+function selectCartesianAxisSize(state, axisType, axisId) {
+	switch (axisType) {
+		case "xAxis": return selectXAxisSize(state, axisId).width;
+		case "yAxis": return selectYAxisSize(state, axisId).height;
 		default: return;
 	}
 }
-function Dt(t, n, r, i) {
-	if (r == null) return;
-	let { allowDuplicatedCategory: a, type: o, dataKey: s } = r, c = e(t, i), l = n.map((e) => e.value);
-	if (s && c && o === "category" && a && ne(l)) return l;
-}
-var Z = x([
-	_,
-	L,
-	D,
-	v
-], Dt);
-function Ot(t, n, r, i) {
-	if (r == null || r.dataKey == null) return;
-	let { type: a, scale: o } = r;
-	if (e(t, i) && (a === "number" || o !== "auto")) return n.map((e) => e.value);
-}
-var Q = x([
-	_,
-	L,
-	O,
-	v
-], Ot), kt = x([
-	_,
-	xe,
-	W,
-	J,
-	Z,
-	Q,
-	q,
-	K,
-	v
-], (t, n, r, i, a, o, s, c, l) => {
-	if (n == null) return null;
-	let u = e(t, l);
+function combineDuplicateDomain(chartLayout, appliedValues, axis, axisType) {
+	if (axis == null) return;
+	const { allowDuplicatedCategory, type, dataKey } = axis;
+	const isCategorical = isCategoricalAxis(chartLayout, axisType);
+	const allData = appliedValues.map((av) => av.value);
+	if (dataKey && isCategorical && type === "category" && allowDuplicatedCategory && hasDuplicate(allData)) return allData;
+}
+var selectDuplicateDomain = createSelector([
+	selectChartLayout,
+	selectAllAppliedValues,
+	selectBaseAxis,
+	pickAxisType
+], combineDuplicateDomain);
+function combineCategoricalDomain(layout, appliedValues, axis, axisType) {
+	if (axis == null || axis.dataKey == null) return;
+	const { type, scale } = axis;
+	if (isCategoricalAxis(layout, axisType) && (type === "number" || scale !== "auto")) return appliedValues.map((d) => d.value);
+}
+var selectCategoricalDomain = createSelector([
+	selectChartLayout,
+	selectAllAppliedValues,
+	selectAxisSettings,
+	pickAxisType
+], combineCategoricalDomain);
+var selectAxisPropsNeededForCartesianGridTicksGenerator = createSelector([
+	selectChartLayout,
+	selectCartesianAxisSettings,
+	selectRealScaleType,
+	selectAxisScale,
+	selectDuplicateDomain,
+	selectCategoricalDomain,
+	selectAxisRange,
+	selectNiceTicks,
+	pickAxisType
+], (layout, axis, realScaleType, scale, duplicateDomain, categoricalDomain, axisRange, niceTicks, axisType) => {
+	if (axis == null) return null;
+	const isCategorical = isCategoricalAxis(layout, axisType);
 	return {
-		angle: n.angle,
-		interval: n.interval,
-		minTickGap: n.minTickGap,
-		orientation: n.orientation,
-		tick: n.tick,
-		tickCount: n.tickCount,
-		tickFormatter: n.tickFormatter,
-		ticks: n.ticks,
-		type: n.type,
-		unit: n.unit,
-		axisType: l,
-		categoricalDomain: o,
-		duplicateDomain: a,
-		isCategorical: u,
-		niceTicks: c,
-		range: s,
-		realScaleType: r,
-		scale: i
+		angle: axis.angle,
+		interval: axis.interval,
+		minTickGap: axis.minTickGap,
+		orientation: axis.orientation,
+		tick: axis.tick,
+		tickCount: axis.tickCount,
+		tickFormatter: axis.tickFormatter,
+		ticks: axis.ticks,
+		type: axis.type,
+		unit: axis.unit,
+		axisType,
+		categoricalDomain,
+		duplicateDomain,
+		isCategorical,
+		niceTicks,
+		range: axisRange,
+		realScaleType,
+		scale
 	};
 });
-function At(n, r, i, a, o, s, c, l, u) {
-	if (r == null || a == null) return;
-	let d = e(n, u), { type: f, ticks: p, tickCount: ee } = r, m = i === "scaleBand" ? a.bandwidth() / 2 : 2, h = f === "category" && a.bandwidth ? a.bandwidth() / m : 0;
-	h = u === "angleAxis" && s?.length >= 2 ? re(s[0] - s[1]) * 2 * h : h;
-	let g = p || o;
-	return g ? g.map((e, t) => ({
-		index: t,
-		coordinate: a(c ? c.indexOf(e) : e) + h,
-		value: e,
-		offset: h
-	})).filter((e) => !t(e.coordinate)) : d && l ? l.map((e, t) => ({
-		coordinate: a(e) + h,
-		value: e,
-		index: t,
-		offset: h
-	})) : a.ticks ? a.ticks(ee).map((e) => ({
-		coordinate: a(e) + h,
-		value: e,
-		offset: h
-	})) : a.domain().map((e, t) => ({
-		coordinate: a(e) + h,
-		value: c ? c[e] : e,
-		index: t,
-		offset: h
+function combineAxisTicks(layout, axis, realScaleType, scale, niceTicks, axisRange, duplicateDomain, categoricalDomain, axisType) {
+	if (axis == null || scale == null) return;
+	const isCategorical = isCategoricalAxis(layout, axisType);
+	const { type, ticks, tickCount } = axis;
+	const offsetForBand = realScaleType === "scaleBand" ? scale.bandwidth() / 2 : 2;
+	let offset = type === "category" && scale.bandwidth ? scale.bandwidth() / offsetForBand : 0;
+	offset = axisType === "angleAxis" && axisRange?.length >= 2 ? mathSign(axisRange[0] - axisRange[1]) * 2 * offset : offset;
+	const ticksOrNiceTicks = ticks || niceTicks;
+	if (ticksOrNiceTicks) return ticksOrNiceTicks.map((entry, index) => {
+		return {
+			index,
+			coordinate: scale(duplicateDomain ? duplicateDomain.indexOf(entry) : entry) + offset,
+			value: entry,
+			offset
+		};
+	}).filter((row) => !isNan(row.coordinate));
+	if (isCategorical && categoricalDomain) return categoricalDomain.map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		index,
+		offset
+	}));
+	if (scale.ticks) return scale.ticks(tickCount).map((entry) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		offset
+	}));
+	return scale.domain().map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: duplicateDomain ? duplicateDomain[entry] : entry,
+		index,
+		offset
 	}));
 }
-var jt = x([
-	_,
-	O,
-	W,
-	J,
-	K,
-	q,
-	Z,
-	Q,
-	v
-], At);
-function $(t, n, r, i, a, o, s) {
-	if (n == null || r == null || i == null || i[0] === i[1]) return null;
-	let c = e(t, s), { tickCount: l } = n, u = 0;
-	return u = s === "angleAxis" && i?.length >= 2 ? re(i[0] - i[1]) * 2 * u : u, c && o ? o.map((e, t) => ({
-		coordinate: r(e) + u,
-		value: e,
-		index: t,
-		offset: u
-	})) : r.ticks ? r.ticks(l).map((e) => ({
-		coordinate: r(e) + u,
-		value: e,
-		offset: u
-	})) : r.domain().map((e, t) => ({
-		coordinate: r(e) + u,
-		value: a ? a[e] : e,
-		index: t,
-		offset: u
+var selectTicksOfAxis = createSelector([
+	selectChartLayout,
+	selectAxisSettings,
+	selectRealScaleType,
+	selectAxisScale,
+	selectNiceTicks,
+	selectAxisRange,
+	selectDuplicateDomain,
+	selectCategoricalDomain,
+	pickAxisType
+], combineAxisTicks);
+function combineGraphicalItemTicks(layout, axis, scale, axisRange, duplicateDomain, categoricalDomain, axisType) {
+	if (axis == null || scale == null || axisRange == null || axisRange[0] === axisRange[1]) return null;
+	const isCategorical = isCategoricalAxis(layout, axisType);
+	const { tickCount } = axis;
+	let offset = 0;
+	offset = axisType === "angleAxis" && axisRange?.length >= 2 ? mathSign(axisRange[0] - axisRange[1]) * 2 * offset : offset;
+	if (isCategorical && categoricalDomain) return categoricalDomain.map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		index,
+		offset
+	}));
+	if (scale.ticks) return scale.ticks(tickCount).map((entry) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		offset
+	}));
+	return scale.domain().map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: duplicateDomain ? duplicateDomain[entry] : entry,
+		index,
+		offset
 	}));
 }
-var Mt = x([
-	_,
-	O,
-	J,
-	q,
-	Z,
-	Q,
-	v
-], $), Nt = x(D, J, (e, t) => {
-	if (!(e == null || t == null)) return {
-		...e,
-		scale: t
+var selectTicksOfGraphicalItem = createSelector([
+	selectChartLayout,
+	selectAxisSettings,
+	selectAxisScale,
+	selectAxisRange,
+	selectDuplicateDomain,
+	selectCategoricalDomain,
+	pickAxisType
+], combineGraphicalItemTicks);
+var selectAxisWithScale = createSelector(selectBaseAxis, selectAxisScale, (axis, scale) => {
+	if (axis == null || scale == null) return;
+	return {
+		...axis,
+		scale
 	};
-}), Pt = x((e, t, n) => E(e, n), x([
-	D,
-	W,
-	U,
-	ft
-], G), (e, t) => {
-	if (!(e == null || t == null)) return {
-		...e,
-		scale: t
+});
+var selectZAxisWithScale = createSelector((state, _axisType, axisId) => selectZAxisSettings(state, axisId), createSelector([
+	selectBaseAxis,
+	selectRealScaleType,
+	selectAxisDomain,
+	selectAxisRangeWithReverse
+], combineScaleFunction), (axis, scale) => {
+	if (axis == null || scale == null) return;
+	return {
+		...axis,
+		scale
 	};
-}), Ft = x([
-	_,
-	l,
-	u
-], (e, t, n) => {
-	switch (e) {
-		case "horizontal": return t.some((e) => e.reversed) ? "right-to-left" : "left-to-right";
-		case "vertical": return n.some((e) => e.reversed) ? "bottom-to-top" : "top-to-bottom";
+});
+var selectChartDirection = createSelector([
+	selectChartLayout,
+	selectAllXAxes,
+	selectAllYAxes
+], (layout, allXAxes, allYAxes) => {
+	switch (layout) {
+		case "horizontal": return allXAxes.some((axis) => axis.reversed) ? "right-to-left" : "left-to-right";
+		case "vertical": return allYAxes.some((axis) => axis.reversed) ? "bottom-to-top" : "top-to-bottom";
 		default: return;
 	}
 });
 //#endregion
-export { Ne as combineAppliedNumericalValuesIncludingErrorValues, Ee as combineAppliedValues, Ge as combineAreasDomain, $e as combineAxisDomain, rt as combineAxisDomainWithNiceTicks, At as combineAxisTicks, Ot as combineCategoricalDomain, Te as combineDisplayedData, je as combineDomainOfStackGroups, H as combineDotsDomain, Dt as combineDuplicateDomain, $ as combineGraphicalItemTicks, F as combineGraphicalItemsData, M as combineGraphicalItemsSettings, qe as combineLinesDomain, nt as combineNiceTicks, Xe as combineNumericalDomain, et as combineRealScaleType, G as combineScaleFunction, ke as combineStackGroups, P as filterGraphicalNotStackedItems, V as filterReferenceElements, z as getDomainDefinition, ve as implicitXAxis, ye as implicitYAxis, be as implicitZAxis, A as itemAxisPredicate, B as mergeDomains, kt as selectAxisPropsNeededForCartesianGridTicksGenerator, q as selectAxisRange, J as selectAxisScale, O as selectAxisSettings, Nt as selectAxisWithScale, D as selectBaseAxis, Et as selectCartesianAxisSize, Ft as selectChartDirection, Ye as selectDomainDefinition, Z as selectDuplicateDomain, k as selectHasBar, W as selectRealScaleType, Be as selectReferenceAreas, Re as selectReferenceDots, He as selectReferenceLines, Ae as selectStackGroups, jt as selectTicksOfAxis, Mt as selectTicksOfGraphicalItem, j as selectUnfilteredCartesianItems, Ct as selectXAxisPosition, w as selectXAxisSettings, vt as selectXAxisSize, wt as selectYAxisPosition, T as selectYAxisSettings, Tt as selectYAxisSize, Pt as selectZAxisWithScale };
+export { combineAppliedNumericalValuesIncludingErrorValues, combineAppliedValues, combineAreasDomain, combineAxisDomain, combineAxisDomainWithNiceTicks, combineAxisTicks, combineCategoricalDomain, combineDisplayedData, combineDomainOfStackGroups, combineDotsDomain, combineDuplicateDomain, combineGraphicalItemTicks, combineGraphicalItemsData, combineGraphicalItemsSettings, combineLinesDomain, combineNiceTicks, combineNumericalDomain, combineRealScaleType, combineScaleFunction, combineStackGroups, filterGraphicalNotStackedItems, filterReferenceElements, getDomainDefinition, implicitXAxis, implicitYAxis, implicitZAxis, itemAxisPredicate, mergeDomains, selectAxisPropsNeededForCartesianGridTicksGenerator, selectAxisRange, selectAxisScale, selectAxisSettings, selectAxisWithScale, selectBaseAxis, selectCartesianAxisSize, selectChartDirection, selectDomainDefinition, selectDuplicateDomain, selectHasBar, selectRealScaleType, selectReferenceAreas, selectReferenceDots, selectReferenceLines, selectStackGroups, selectTicksOfAxis, selectTicksOfGraphicalItem, selectUnfilteredCartesianItems, selectXAxisPosition, selectXAxisSettings, selectXAxisSize, selectYAxisPosition, selectYAxisSettings, selectYAxisSize, selectZAxisWithScale };