@octanejs/recharts 0.1.0

package/src/state/selectors/barSelectors.js

@@ -0,0 +1,263 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/barSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSelector } from 'reselect';
+import {
+	selectAxisWithScale,
+	selectCartesianAxisSize,
+	selectStackGroups,
+	selectTicksOfGraphicalItem,
+	selectUnfilteredCartesianItems,
+} from './axisSelectors';
+import { isNullish } from '../../util/DataUtils';
+import { getBandSizeOfAxis } from '../../util/ChartUtils';
+import { computeBarRectangles } from '../../cartesian/Bar';
+import { selectChartLayout } from '../../context/chartLayoutContext';
+import { selectChartDataWithIndexesIfNotInPanoramaPosition3 } from './dataSelectors';
+import { selectAxisViewBox, selectChartOffsetInternal } from './selectChartOffsetInternal';
+import {
+	selectBarCategoryGap,
+	selectBarGap,
+	selectRootBarSize,
+	selectRootMaxBarSize,
+} from './rootPropsSelectors';
+import { combineBarSizeList } from './combiners/combineBarSizeList';
+import { combineAllBarPositions } from './combiners/combineAllBarPositions';
+import { combineStackedData } from './combiners/combineStackedData';
+import {
+	selectXAxisIdFromGraphicalItemId,
+	selectYAxisIdFromGraphicalItemId,
+} from './graphicalItemSelectors';
+import { combineBarPosition } from './combiners/combineBarPosition';
+var pickIsPanorama = (_state, _id, isPanorama) => isPanorama;
+var pickBarId = (_state, id) => id;
+var selectSynchronisedBarSettings = createSelector(
+	[selectUnfilteredCartesianItems, pickBarId],
+	(graphicalItems, id) =>
+		graphicalItems.filter((item) => item.type === 'bar').find((item) => item.id === id),
+);
+export var selectMaxBarSize = createSelector([selectSynchronisedBarSettings], (barSettings) =>
+	barSettings === null || barSettings === void 0 ? void 0 : barSettings.maxBarSize,
+);
+var pickCells = (_state, _id, _isPanorama, cells) => cells;
+export var selectAllVisibleBars = createSelector(
+	[
+		selectChartLayout,
+		selectUnfilteredCartesianItems,
+		selectXAxisIdFromGraphicalItemId,
+		selectYAxisIdFromGraphicalItemId,
+		pickIsPanorama,
+	],
+	(layout, allItems, xAxisId, yAxisId, isPanorama) =>
+		allItems
+			.filter((i) => {
+				if (layout === 'horizontal') {
+					return i.xAxisId === xAxisId;
+				}
+				return i.yAxisId === yAxisId;
+			})
+			.filter((i) => i.isPanorama === isPanorama)
+			.filter((i) => i.hide === false)
+			.filter((i) => i.type === 'bar'),
+);
+var selectBarStackGroups = (state, id, isPanorama) => {
+	var layout = selectChartLayout(state);
+	var xAxisId = selectXAxisIdFromGraphicalItemId(state, id);
+	var yAxisId = selectYAxisIdFromGraphicalItemId(state, id);
+	if (xAxisId == null || yAxisId == null) {
+		return undefined;
+	}
+	if (layout === 'horizontal') {
+		return selectStackGroups(state, 'yAxis', yAxisId, isPanorama);
+	}
+	return selectStackGroups(state, 'xAxis', xAxisId, isPanorama);
+};
+export var selectBarCartesianAxisSize = (state, id) => {
+	var layout = selectChartLayout(state);
+	var xAxisId = selectXAxisIdFromGraphicalItemId(state, id);
+	var yAxisId = selectYAxisIdFromGraphicalItemId(state, id);
+	if (xAxisId == null || yAxisId == null) {
+		return undefined;
+	}
+	if (layout === 'horizontal') {
+		return selectCartesianAxisSize(state, 'xAxis', xAxisId);
+	}
+	return selectCartesianAxisSize(state, 'yAxis', yAxisId);
+};
+export var selectBarSizeList = createSelector(
+	[selectAllVisibleBars, selectRootBarSize, selectBarCartesianAxisSize],
+	combineBarSizeList,
+);
+export var selectBarBandSize = (state, id, isPanorama) => {
+	var _ref, _getBandSizeOfAxis;
+	var barSettings = selectSynchronisedBarSettings(state, id);
+	if (barSettings == null) {
+		return 0;
+	}
+	var xAxisId = selectXAxisIdFromGraphicalItemId(state, id);
+	var yAxisId = selectYAxisIdFromGraphicalItemId(state, id);
+	if (xAxisId == null || yAxisId == null) {
+		return 0;
+	}
+	var layout = selectChartLayout(state);
+	var globalMaxBarSize = selectRootMaxBarSize(state);
+	var childMaxBarSize = barSettings.maxBarSize;
+	var maxBarSize = isNullish(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize;
+	var axis, ticks;
+	if (layout === 'horizontal') {
+		axis = selectAxisWithScale(state, 'xAxis', xAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, 'xAxis', xAxisId, isPanorama);
+	} else {
+		axis = selectAxisWithScale(state, 'yAxis', yAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, 'yAxis', yAxisId, isPanorama);
+	}
+	return (_ref =
+		(_getBandSizeOfAxis = getBandSizeOfAxis(axis, ticks, true)) !== null &&
+		_getBandSizeOfAxis !== void 0
+			? _getBandSizeOfAxis
+			: maxBarSize) !== null && _ref !== void 0
+		? _ref
+		: 0;
+};
+export var selectAxisBandSize = (state, id, isPanorama) => {
+	var layout = selectChartLayout(state);
+	var xAxisId = selectXAxisIdFromGraphicalItemId(state, id);
+	var yAxisId = selectYAxisIdFromGraphicalItemId(state, id);
+	if (xAxisId == null || yAxisId == null) {
+		return undefined;
+	}
+	var axis, ticks;
+	if (layout === 'horizontal') {
+		axis = selectAxisWithScale(state, 'xAxis', xAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, 'xAxis', xAxisId, isPanorama);
+	} else {
+		axis = selectAxisWithScale(state, 'yAxis', yAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, 'yAxis', yAxisId, isPanorama);
+	}
+	return getBandSizeOfAxis(axis, ticks);
+};
+export var selectAllBarPositions = createSelector(
+	[
+		selectBarSizeList,
+		selectRootMaxBarSize,
+		selectBarGap,
+		selectBarCategoryGap,
+		selectBarBandSize,
+		selectAxisBandSize,
+		selectMaxBarSize,
+	],
+	combineAllBarPositions,
+);
+var selectXAxisWithScale = (state, id, isPanorama) => {
+	var xAxisId = selectXAxisIdFromGraphicalItemId(state, id);
+	if (xAxisId == null) {
+		return undefined;
+	}
+	return selectAxisWithScale(state, 'xAxis', xAxisId, isPanorama);
+};
+var selectYAxisWithScale = (state, id, isPanorama) => {
+	var yAxisId = selectYAxisIdFromGraphicalItemId(state, id);
+	if (yAxisId == null) {
+		return undefined;
+	}
+	return selectAxisWithScale(state, 'yAxis', yAxisId, isPanorama);
+};
+var selectXAxisTicks = (state, id, isPanorama) => {
+	var xAxisId = selectXAxisIdFromGraphicalItemId(state, id);
+	if (xAxisId == null) {
+		return undefined;
+	}
+	return selectTicksOfGraphicalItem(state, 'xAxis', xAxisId, isPanorama);
+};
+var selectYAxisTicks = (state, id, isPanorama) => {
+	var yAxisId = selectYAxisIdFromGraphicalItemId(state, id);
+	if (yAxisId == null) {
+		return undefined;
+	}
+	return selectTicksOfGraphicalItem(state, 'yAxis', yAxisId, isPanorama);
+};
+export var selectBarPosition = createSelector(
+	[selectAllBarPositions, selectSynchronisedBarSettings],
+	combineBarPosition,
+);
+export var selectStackedDataOfItem = createSelector(
+	[selectBarStackGroups, selectSynchronisedBarSettings],
+	combineStackedData,
+);
+export var selectBarRectangles = createSelector(
+	[
+		selectChartOffsetInternal,
+		selectAxisViewBox,
+		selectXAxisWithScale,
+		selectYAxisWithScale,
+		selectXAxisTicks,
+		selectYAxisTicks,
+		selectBarPosition,
+		selectChartLayout,
+		selectChartDataWithIndexesIfNotInPanoramaPosition3,
+		selectAxisBandSize,
+		selectStackedDataOfItem,
+		selectSynchronisedBarSettings,
+		pickCells,
+	],
+	(
+		offset,
+		axisViewBox,
+		xAxis,
+		yAxis,
+		xAxisTicks,
+		yAxisTicks,
+		pos,
+		layout,
+		_ref2,
+		bandSize,
+		stackedData,
+		barSettings,
+		cells,
+	) => {
+		var chartData = _ref2.chartData,
+			dataStartIndex = _ref2.dataStartIndex,
+			dataEndIndex = _ref2.dataEndIndex;
+		if (
+			barSettings == null ||
+			pos == null ||
+			axisViewBox == null ||
+			(layout !== 'horizontal' && layout !== 'vertical') ||
+			xAxis == null ||
+			yAxis == null ||
+			xAxisTicks == null ||
+			yAxisTicks == null ||
+			bandSize == null
+		) {
+			return undefined;
+		}
+		var data = barSettings.data;
+		var displayedData;
+		if (data != null && data.length > 0) {
+			displayedData = data;
+		} else {
+			displayedData =
+				chartData === null || chartData === void 0
+					? void 0
+					: chartData.slice(dataStartIndex, dataEndIndex + 1);
+		}
+		if (displayedData == null) {
+			return undefined;
+		}
+		return computeBarRectangles({
+			layout,
+			barSettings,
+			pos,
+			parentViewBox: axisViewBox,
+			bandSize,
+			xAxis,
+			yAxis,
+			xAxisTicks,
+			yAxisTicks,
+			stackedData,
+			displayedData,
+			offset,
+			cells,
+			dataStartIndex,
+		});
+	},
+);

package/src/state/selectors/barStackSelectors.js

@@ -0,0 +1,65 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/barStackSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSelector } from 'reselect';
+import { selectUnfilteredCartesianItems } from './axisSelectors';
+import { selectBarRectangles } from './barSelectors';
+var pickStackId = (state, stackId) => stackId;
+var pickIsPanorama = (state, stackId, isPanorama) => isPanorama;
+export var selectAllBarsInStack = createSelector(
+	[pickStackId, selectUnfilteredCartesianItems, pickIsPanorama],
+	(stackId, allItems, isPanorama) => {
+		return allItems
+			.filter((i) => i.type === 'bar')
+			.filter((i) => i.stackId === stackId)
+			.filter((i) => i.isPanorama === isPanorama)
+			.filter((i) => !i.hide);
+	},
+);
+var selectAllBarIdsInStack = createSelector([selectAllBarsInStack], (allBars) => {
+	return allBars.map((bar) => bar.id);
+});
+/**
+ * Takes two rectangles and returns a new rectangle that encompasses both.
+ * It takes the minimum x and y, and the maximum width and height.
+ * It handles overlapping rectangles, and rectangles with a gap between them.
+ * @param rect1
+ * @param rect2
+ */
+export var expandRectangle = (rect1, rect2) => {
+	if (!rect1) {
+		return rect2;
+	}
+	if (!rect2) {
+		return rect1;
+	}
+	var x = Math.min(rect1.x, rect1.x + rect1.width, rect2.x, rect2.x + rect2.width);
+	var y = Math.min(rect1.y, rect1.y + rect1.height, rect2.y, rect2.y + rect2.height);
+	var maxX = Math.max(rect1.x, rect1.x + rect1.width, rect2.x, rect2.x + rect2.width);
+	var maxY = Math.max(rect1.y, rect1.y + rect1.height, rect2.y, rect2.y + rect2.height);
+	var width = maxX - x;
+	var height = maxY - y;
+	return {
+		x,
+		y,
+		width,
+		height,
+	};
+};
+var combineStackRects = (state, stackId, isPanorama) => {
+	var allBarIds = selectAllBarIdsInStack(state, stackId, isPanorama);
+	var stackRects = [];
+	allBarIds.forEach((barId) => {
+		var rectangles = selectBarRectangles(state, barId, isPanorama, undefined);
+		rectangles === null ||
+			rectangles === void 0 ||
+			rectangles.forEach((rect) => {
+				var rectIndex = rect.originalDataIndex;
+				stackRects[rectIndex] = expandRectangle(stackRects[rectIndex], rect);
+			});
+	});
+	return stackRects;
+};
+export var selectStackRects = createSelector(
+	[(state) => state, pickStackId, pickIsPanorama],
+	combineStackRects,
+);

package/src/state/selectors/brushSelectors.js

@@ -0,0 +1,21 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/brushSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSelector } from 'reselect';
+import { selectChartOffsetInternal } from './selectChartOffsetInternal';
+import { selectMargin } from './containerSelectors';
+import { isNumber } from '../../util/DataUtils';
+export var selectBrushSettings = (state) => state.brush;
+export var selectBrushDimensions = createSelector(
+	[selectBrushSettings, selectChartOffsetInternal, selectMargin],
+	(brushSettings, offset, margin) => ({
+		height: brushSettings.height,
+		x: isNumber(brushSettings.x) ? brushSettings.x : offset.left,
+		y: isNumber(brushSettings.y)
+			? brushSettings.y
+			: offset.top +
+				offset.height +
+				offset.brushBottom -
+				((margin === null || margin === void 0 ? void 0 : margin.bottom) || 0),
+		width: isNumber(brushSettings.width) ? brushSettings.width : offset.width,
+	}),
+);

package/src/state/selectors/combiners/combineActiveLabel.js

@@ -0,0 +1,18 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineActiveLabel.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { isNan } from '../../../util/DataUtils';
+export var combineActiveLabel = (tooltipTicks, activeIndex) => {
+	var _tooltipTicks$n;
+	var n = Number(activeIndex);
+	if (isNan(n) || activeIndex == null) {
+		return undefined;
+	}
+	return n >= 0
+		? tooltipTicks === null ||
+			tooltipTicks === void 0 ||
+			(_tooltipTicks$n = tooltipTicks[n]) === null ||
+			_tooltipTicks$n === void 0
+			? void 0
+			: _tooltipTicks$n.value
+		: undefined;
+};

package/src/state/selectors/combiners/combineActiveTooltipIndex.js

@@ -0,0 +1,75 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineActiveTooltipIndex.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { isWellBehavedNumber } from '../../../util/isWellBehavedNumber';
+import { getValueByDataKey } from '../../../util/ChartUtils';
+import { isWellFormedNumberDomain } from '../../../util/isDomainSpecifiedByUser';
+function toFiniteNumber(value) {
+	if (typeof value === 'number') {
+		return Number.isFinite(value) ? value : undefined;
+	}
+	if (value instanceof Date) {
+		var numericValue = value.valueOf();
+		return Number.isFinite(numericValue) ? numericValue : undefined;
+	}
+	var parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+function isValueWithinNumberDomain(value, domain) {
+	var numericValue = toFiniteNumber(value);
+	var lowerBound = domain[0];
+	var upperBound = domain[1];
+	if (numericValue === undefined) {
+		return false;
+	}
+	var min = Math.min(lowerBound, upperBound);
+	var max = Math.max(lowerBound, upperBound);
+	return numericValue >= min && numericValue <= max;
+}
+function isValueWithinDomain(entry, axisDataKey, domain) {
+	if (domain == null || axisDataKey == null) {
+		return true;
+	}
+	var value = getValueByDataKey(entry, axisDataKey);
+	if (value == null) {
+		return true;
+	}
+	if (!isWellFormedNumberDomain(domain)) {
+		return true;
+	}
+	return isValueWithinNumberDomain(value, domain);
+}
+export var combineActiveTooltipIndex = (tooltipInteraction, chartData, axisDataKey, domain) => {
+	var desiredIndex =
+		tooltipInteraction === null || tooltipInteraction === void 0
+			? void 0
+			: tooltipInteraction.index;
+	if (desiredIndex == null) {
+		return null;
+	}
+	var indexAsNumber = Number(desiredIndex);
+	if (!isWellBehavedNumber(indexAsNumber)) {
+		// this is for charts like Sankey and Treemap that do not support numerical indexes. We need a proper solution for this before we can start supporting keyboard events on these charts.
+		return desiredIndex;
+	}
+
+	/*
+	 * Zero is a trivial limit for single-dimensional charts like Line and Area,
+	 * but this also needs a support for multidimensional charts like Sankey and Treemap! TODO
+	 */
+	var lowerLimit = 0;
+	var upperLimit = +Infinity;
+	if (chartData.length > 0) {
+		upperLimit = chartData.length - 1;
+	}
+
+	// now let's clamp the desiredIndex between the limits
+	var clampedIndex = Math.max(lowerLimit, Math.min(indexAsNumber, upperLimit));
+	var entry = chartData[clampedIndex];
+	if (entry == null) {
+		return String(clampedIndex);
+	}
+	if (!isValueWithinDomain(entry, axisDataKey, domain)) {
+		return null;
+	}
+	return String(clampedIndex);
+};

package/src/state/selectors/combiners/combineAllBarPositions.js

@@ -0,0 +1,169 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineAllBarPositions.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		(r &&
+			(o = o.filter(function (r) {
+				return Object.getOwnPropertyDescriptor(e, r).enumerable;
+			})),
+			t.push.apply(t, o));
+	}
+	return t;
+}
+function _objectSpread(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2
+			? ownKeys(Object(t), !0).forEach(function (r) {
+					_defineProperty(e, r, t[r]);
+				})
+			: Object.getOwnPropertyDescriptors
+				? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t))
+				: ownKeys(Object(t)).forEach(function (r) {
+						Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+					});
+	}
+	return e;
+}
+function _defineProperty(e, r, t) {
+	return (
+		(r = _toPropertyKey(r)) in e
+			? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 })
+			: (e[r] = t),
+		e
+	);
+}
+function _toPropertyKey(t) {
+	var i = _toPrimitive(t, 'string');
+	return 'symbol' == typeof i ? i : i + '';
+}
+function _toPrimitive(t, r) {
+	if ('object' != typeof t || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || 'default');
+		if ('object' != typeof i) return i;
+		throw new TypeError('@@toPrimitive must return a primitive value.');
+	}
+	return ('string' === r ? String : Number)(t);
+}
+import { getPercentValue, isNullish } from '../../../util/DataUtils';
+import { isWellBehavedNumber } from '../../../util/isWellBehavedNumber';
+function getBarPositions(barGap, barCategoryGap, bandSize, sizeList, maxBarSize) {
+	var _sizeList$;
+	var len = sizeList.length;
+	if (len < 1) {
+		return undefined;
+	}
+	var realBarGap = getPercentValue(barGap, bandSize, 0, true);
+	var result;
+	var initialValue = [];
+
+	// whether is barSize set by user
+	// Okay but why does it check only for the first element? What if the first element is set but others are not?
+	if (
+		isWellBehavedNumber(
+			(_sizeList$ = sizeList[0]) === null || _sizeList$ === void 0 ? void 0 : _sizeList$.barSize,
+		)
+	) {
+		var useFull = false;
+		var fullBarSize = bandSize / len;
+		var sum = sizeList.reduce((res, entry) => res + (entry.barSize || 0), 0);
+		sum += (len - 1) * realBarGap;
+		if (sum >= bandSize) {
+			sum -= (len - 1) * realBarGap;
+			realBarGap = 0;
+		}
+		if (sum >= bandSize && fullBarSize > 0) {
+			useFull = true;
+			fullBarSize *= 0.9;
+			sum = len * fullBarSize;
+		}
+		var offset = Math.round((bandSize - sum) / 2);
+		var prev = {
+			offset: offset - realBarGap,
+			size: 0,
+		};
+		result = sizeList.reduce((res, entry) => {
+			var _entry$barSize;
+			var newPosition = {
+				stackId: entry.stackId,
+				dataKeys: entry.dataKeys,
+				position: {
+					offset: prev.offset + prev.size + realBarGap,
+					size: useFull
+						? fullBarSize
+						: (_entry$barSize = entry.barSize) !== null && _entry$barSize !== void 0
+							? _entry$barSize
+							: 0,
+				},
+			};
+			var newRes = [...res, newPosition];
+			prev = newPosition.position;
+			return newRes;
+		}, initialValue);
+	} else {
+		var _offset = getPercentValue(barCategoryGap, bandSize, 0, true);
+		if (bandSize - 2 * _offset - (len - 1) * realBarGap <= 0) {
+			realBarGap = 0;
+		}
+		var originalSize = (bandSize - 2 * _offset - (len - 1) * realBarGap) / len;
+		if (originalSize > 1) {
+			originalSize = Math.round(originalSize);
+		}
+		var size = isWellBehavedNumber(maxBarSize) ? Math.min(originalSize, maxBarSize) : originalSize;
+		result = sizeList.reduce(
+			(res, entry, i) => [
+				...res,
+				{
+					stackId: entry.stackId,
+					dataKeys: entry.dataKeys,
+					position: {
+						offset: _offset + (originalSize + realBarGap) * i + (originalSize - size) / 2,
+						size,
+					},
+				},
+			],
+			initialValue,
+		);
+	}
+	return result;
+}
+export var combineAllBarPositions = (
+	sizeList,
+	globalMaxBarSize,
+	barGap,
+	barCategoryGap,
+	barBandSize,
+	bandSize,
+	childMaxBarSize,
+) => {
+	var maxBarSize = isNullish(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize;
+	var allBarPositions = getBarPositions(
+		barGap,
+		barCategoryGap,
+		barBandSize !== bandSize ? barBandSize : bandSize,
+		sizeList,
+		maxBarSize,
+	);
+	if (barBandSize !== bandSize && allBarPositions != null) {
+		allBarPositions = allBarPositions.map((pos) =>
+			_objectSpread(
+				_objectSpread({}, pos),
+				{},
+				{
+					position: _objectSpread(
+						_objectSpread({}, pos.position),
+						{},
+						{
+							offset: pos.position.offset - barBandSize / 2,
+						},
+					),
+				},
+			),
+		);
+	}
+	return allBarPositions;
+};

package/src/state/selectors/combiners/combineAxisRangeWithReverse.js

@@ -0,0 +1,11 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineAxisRangeWithReverse.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var combineAxisRangeWithReverse = (axisSettings, axisRange) => {
+	if (!axisSettings || !axisRange) {
+		return undefined;
+	}
+	if (axisSettings !== null && axisSettings !== void 0 && axisSettings.reversed) {
+		return [axisRange[1], axisRange[0]];
+	}
+	return axisRange;
+};

package/src/state/selectors/combiners/combineBarPosition.js

@@ -0,0 +1,17 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineBarPosition.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var combineBarPosition = (allBarPositions, barSettings) => {
+	if (allBarPositions == null || barSettings == null) {
+		return undefined;
+	}
+	var position = allBarPositions.find(
+		(p) =>
+			p.stackId === barSettings.stackId &&
+			barSettings.dataKey != null &&
+			p.dataKeys.includes(barSettings.dataKey),
+	);
+	if (position == null) {
+		return undefined;
+	}
+	return position.position;
+};