vccs 0.6.0 → 1.0.0-beta.2

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

@@ -1,908 +0,0 @@
-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 { getPercentValue, hasDuplicate, mathSign } from "../../utils/data.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 { 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 { combineInverseScaleFunction, createCategoricalInverse } from "../../utils/createCategoricalInverse.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);
-function sortBy$1(a, b) {
-	const aNum = Number(a);
-	const bNum = Number(b);
-	if (Number.isNaN(aNum) && Number.isNaN(bNum)) return 0;
-	if (Number.isNaN(aNum)) return -1;
-	if (Number.isNaN(bNum)) return 1;
-	return aNum - bNum;
-}
-var selectSortedDataPoints = createSelector([selectAllAppliedValues], (appliedData) => {
-	return appliedData?.map((item) => item.value).sort(sortBy$1);
-});
-var selectAxisInverseScale = createSelector([selectAxisScale], combineInverseScaleFunction);
-var selectAxisInverseDataSnapScale = createSelector([selectAxisScale, selectSortedDataPoints], createCategoricalInverse);
-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: typeof axisSettings.width === "number" ? axisSettings.width : 60,
-		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: typeof axisSettings.width === "number" ? axisSettings.width : 60,
-		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);
-var selectAxisInverseTickSnapScale = createSelector([selectTicksOfAxis], (ticks) => {
-	if (!ticks || ticks.length === 0) return;
-	return (pixelValue) => {
-		let minDistance = Infinity;
-		let closestTick = ticks[0];
-		for (const tick of ticks) {
-			const distance = Math.abs(tick.coordinate - pixelValue);
-			if (distance < minDistance) {
-				minDistance = distance;
-				closestTick = tick;
-			}
-		}
-		return closestTick?.value;
-	};
-});
-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, selectAxisDomain, selectAxisInverseDataSnapScale, selectAxisInverseScale, selectAxisInverseTickSnapScale, 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 };