vccs 0.0.1 → 0.2.0

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

@@ -0,0 +1,879 @@
+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 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: true,
+	id: void 0,
+	includeHidden: false,
+	interval: "preserveEnd",
+	minTickGap: 5,
+	mirror: false,
+	name: void 0,
+	orientation: "bottom",
+	padding: {
+		left: 0,
+		right: 0
+	},
+	reversed: false,
+	scale: "auto",
+	tick: true,
+	tickCount: 5,
+	tickFormatter: void 0,
+	ticks: void 0,
+	type: "category",
+	unit: void 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: defaultNumericDomain,
+	hide: true,
+	id: void 0,
+	includeHidden: false,
+	interval: "preserveEnd",
+	minTickGap: 5,
+	mirror: false,
+	name: void 0,
+	orientation: "left",
+	padding: {
+		top: 0,
+		bottom: 0
+	},
+	reversed: false,
+	scale: "auto",
+	tick: true,
+	tickCount: 5,
+	tickFormatter: void 0,
+	ticks: void 0,
+	type: "number",
+	unit: void 0,
+	width: 60
+};
+function selectYAxisSettings(state, axisId) {
+	const axis = state.cartesianAxis.yAxis[axisId];
+	if (axis == null) return implicitYAxis;
+	return axis;
+}
+var implicitZAxis = {
+	domain: [0, "auto"],
+	includeHidden: false,
+	reversed: false,
+	allowDataOverflow: false,
+	allowDuplicatedCategory: false,
+	dataKey: void 0,
+	id: void 0,
+	name: "",
+	range: [64, 64],
+	scale: "auto",
+	type: "number",
+	unit: ""
+};
+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 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}`);
+	}
+}
+/**
+* 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}`);
+	}
+}
+/**
+* @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 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 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 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
+		}];
+	}));
+}
+/**
+* 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: []
+	}));
+	return data.map((entry) => ({
+		value: entry,
+		errorDomain: []
+	}));
+}
+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 (axisSettings.type === "category") return axisSettings.ticks.map(String);
+	}
+	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));
+	}
+	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";
+	}
+	if (typeof scale === "string") {
+		const name = `scale${upperFirst(scale)}`;
+		return name in d3Scales ? name : "point";
+	}
+}
+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 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 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;
+});
+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
+	};
+	const { padding } = xAxisSettings;
+	if (typeof padding === "string") return {
+		left: calculated,
+		right: calculated
+	};
+	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
+	};
+	const { padding } = yAxisSettings;
+	if (typeof padding === "string") return {
+		top: calculated,
+		bottom: calculated
+	};
+	return {
+		top: (padding.top ?? 0) + calculated,
+		bottom: (padding.bottom ?? 0) + calculated
+	};
+});
+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 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: offset.width,
+		height: axisSettings.height
+	};
+}
+function getYAxisSize(offset, axisSettings) {
+	return {
+		width: axisSettings.width,
+		height: offset.height
+	};
+}
+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 combineYAxisPositionStartingPoint(offset, orientation, chartWidth) {
+	switch (orientation) {
+		case "left": return offset.left;
+		case "right": return chartWidth - offset.right;
+		default: return 0;
+	}
+}
+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 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
+	};
+	return {
+		x: offset.left,
+		y: stepOfThisAxis
+	};
+}
+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: offset.top
+	};
+	return {
+		x: stepOfThisAxis,
+		y: offset.top
+	};
+}
+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 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: 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 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 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 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
+	};
+});
+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
+	};
+});
+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 { 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 };