@octanejs/recharts 0.1.41 → 0.1.42

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

@@ -0,0 +1,130 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { getPercentValue, isNullish } from '../../../util/DataUtils';
+import { BarWithPosition, SizeList } from '../barSelectors';
+import { isWellBehavedNumber } from '../../../util/isWellBehavedNumber';
+import { BarPositionPosition } from '../../../util/ChartUtils';
+import { BarCategory } from './combineBarSizeList';
+
+function getBarPositions(
+	barGap: string | number,
+	barCategoryGap: string | number,
+	bandSize: number,
+	sizeList: SizeList,
+	maxBarSize: number | undefined,
+): ReadonlyArray<BarWithPosition> | undefined {
+	const len = sizeList.length;
+	if (len < 1) {
+		return undefined;
+	}
+
+	let realBarGap = getPercentValue(barGap, bandSize, 0, true);
+
+	let result: ReadonlyArray<BarWithPosition>;
+	const initialValue: ReadonlyArray<BarWithPosition> = [];
+
+	// 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[0]?.barSize)) {
+		let useFull = false;
+		let fullBarSize: number = bandSize / len;
+		let 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;
+		}
+
+		const offset = Math.round((bandSize - sum) / 2);
+		let prev: BarPositionPosition = { offset: offset - realBarGap, size: 0 };
+
+		result = sizeList.reduce(
+			(res: ReadonlyArray<BarWithPosition>, entry: BarCategory): ReadonlyArray<BarWithPosition> => {
+				const newPosition: BarWithPosition = {
+					stackId: entry.stackId,
+					dataKeys: entry.dataKeys,
+					position: {
+						offset: prev.offset + prev.size + realBarGap,
+						size: useFull ? fullBarSize : (entry.barSize ?? 0),
+					},
+				};
+				const newRes: Array<BarWithPosition> = [...res, newPosition];
+
+				prev = newPosition.position;
+
+				return newRes;
+			},
+			initialValue,
+		);
+	} else {
+		const offset = getPercentValue(barCategoryGap, bandSize, 0, true);
+
+		if (bandSize - 2 * offset - (len - 1) * realBarGap <= 0) {
+			realBarGap = 0;
+		}
+
+		let originalSize = (bandSize - 2 * offset - (len - 1) * realBarGap) / len;
+		if (originalSize > 1) {
+			originalSize = Math.round(originalSize);
+		}
+		const size = isWellBehavedNumber(maxBarSize)
+			? Math.min(originalSize, maxBarSize)
+			: originalSize;
+		result = sizeList.reduce(
+			(
+				res: ReadonlyArray<BarWithPosition>,
+				entry: BarCategory,
+				i,
+			): ReadonlyArray<BarWithPosition> => [
+				...res,
+				{
+					stackId: entry.stackId,
+					dataKeys: entry.dataKeys,
+					position: {
+						offset: offset + (originalSize + realBarGap) * i + (originalSize - size) / 2,
+						size,
+					},
+				},
+			],
+			initialValue,
+		);
+	}
+
+	return result;
+}
+
+export const combineAllBarPositions = (
+	sizeList: SizeList,
+	globalMaxBarSize: number | undefined,
+	barGap: string | number,
+	barCategoryGap: string | number,
+	barBandSize: number,
+	bandSize: number | undefined,
+	childMaxBarSize: number | undefined,
+): ReadonlyArray<BarWithPosition> | undefined => {
+	const maxBarSize: number | undefined = isNullish(childMaxBarSize)
+		? globalMaxBarSize
+		: childMaxBarSize;
+
+	let allBarPositions: ReadonlyArray<BarWithPosition> | undefined = getBarPositions(
+		barGap,
+		barCategoryGap,
+		barBandSize !== bandSize ? barBandSize : bandSize,
+		sizeList,
+		maxBarSize,
+	);
+
+	if (barBandSize !== bandSize && allBarPositions != null) {
+		allBarPositions = allBarPositions.map((pos) => ({
+			...pos,
+			position: { ...pos.position, offset: pos.position.offset - barBandSize / 2 },
+		}));
+	}
+
+	return allBarPositions;
+};

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

@@ -0,0 +1,16 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { BaseCartesianAxis } from '../../cartesianAxisSlice';
+import { AxisRange } from '../axisSelectors';
+
+export const combineAxisRangeWithReverse = (
+	axisSettings: BaseCartesianAxis | undefined,
+	axisRange: AxisRange | undefined,
+): AxisRange | undefined => {
+	if (!axisSettings || !axisRange) {
+		return undefined;
+	}
+	if (axisSettings?.reversed) {
+		return [axisRange[1], axisRange[0]];
+	}
+	return axisRange;
+};

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

@@ -0,0 +1,23 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { MaybeStackedGraphicalItem } from '../../types/StackedGraphicalItem';
+import { BarPositionPosition } from '../../../util/ChartUtils';
+import { BarWithPosition } from '../barSelectors';
+
+export const combineBarPosition = (
+	allBarPositions: ReadonlyArray<BarWithPosition> | undefined,
+	barSettings: MaybeStackedGraphicalItem | undefined,
+): BarPositionPosition | undefined => {
+	if (allBarPositions == null || barSettings == null) {
+		return undefined;
+	}
+	const position = allBarPositions.find(
+		(p: BarWithPosition) =>
+			p.stackId === barSettings.stackId &&
+			barSettings.dataKey != null &&
+			p.dataKeys.includes(barSettings.dataKey),
+	);
+	if (position == null) {
+		return undefined;
+	}
+	return position.position;
+};

package/src/state/selectors/combiners/combineBarSizeList.ts

@@ -0,0 +1,79 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import {
+	DefinitelyStackedGraphicalItem,
+	isStacked,
+	MaybeStackedGraphicalItem,
+} from '../../types/StackedGraphicalItem';
+import { StackId } from '../../../util/ChartUtils';
+import { SizeList } from '../barSelectors';
+import { getPercentValue, isNullish } from '../../../util/DataUtils';
+import { DataKey } from '../../../util/types';
+
+const getBarSize = (
+	globalSize: string | number | undefined,
+	totalSize: number | undefined,
+	selfSize: number | string | undefined,
+): number | undefined => {
+	const barSize: string | number | undefined = selfSize ?? globalSize;
+
+	if (isNullish(barSize)) {
+		return undefined;
+	}
+	return getPercentValue(barSize, totalSize, 0);
+};
+
+export const combineBarSizeList = (
+	allBars: ReadonlyArray<MaybeStackedGraphicalItem>,
+	globalSize: string | number | undefined,
+	totalSize: number | undefined,
+): SizeList => {
+	const initialValue: Record<StackId, Array<DefinitelyStackedGraphicalItem>> = {};
+
+	const stackedBars: ReadonlyArray<DefinitelyStackedGraphicalItem> = allBars.filter(isStacked);
+	const unstackedBars = allBars.filter((b) => b.stackId == null);
+
+	const groupByStack: Record<StackId, Array<DefinitelyStackedGraphicalItem>> = stackedBars.reduce(
+		(acc, bar) => {
+			let s = acc[bar.stackId];
+			if (s == null) {
+				s = [];
+			}
+			s.push(bar);
+			acc[bar.stackId] = s;
+			return acc;
+		},
+		initialValue,
+	);
+
+	const stackedSizeList: SizeList = Object.entries(groupByStack).map(
+		([stackId, bars]): BarCategory => {
+			const dataKeys = bars.map((b) => b.dataKey);
+			const barSize: number | undefined = getBarSize(globalSize, totalSize, bars[0]?.barSize);
+			return { stackId, dataKeys, barSize };
+		},
+	);
+
+	const unstackedSizeList: SizeList = unstackedBars.map((b): BarCategory => {
+		const dataKeys = [b.dataKey].filter((dk) => dk != null);
+		const barSize: number | undefined = getBarSize(globalSize, totalSize, b.barSize);
+		return { stackId: undefined, dataKeys, barSize };
+	});
+
+	return [...stackedSizeList, ...unstackedSizeList];
+};
+export type BarCategory = {
+	stackId: StackId | undefined;
+	/**
+	 * List of dataKeys of items stacked at this position.
+	 * All of these Bars are either sharing the same stackId,
+	 * or this is an array with one Bar because it has no stackId defined.
+	 *
+	 * This structure limits us to having one dataKey only once per stack which I think is reasonable.
+	 * People who want to have the same data twice can duplicate their data to have two distinct dataKeys.
+	 */
+	dataKeys: ReadonlyArray<DataKey<any>>;
+	/**
+	 * Width (in horizontal chart) or height (in vertical chart) of this stack of items
+	 */
+	barSize: number | undefined;
+};

package/src/state/selectors/combiners/{combineCheckedDomain.js → combineCheckedDomain.ts}

@@ -1,12 +1,15 @@
-// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineCheckedDomain.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { CategoricalDomain, NumberDomain } from '../../../util/types';
 import { isWellFormedNumberDomain } from '../../../util/isDomainSpecifiedByUser';
 import { isWellBehavedNumber } from '../../../util/isWellBehavedNumber';
 
 /**
  * This function validates and transforms the axis domain so that it is safe to use in the provided scale.
  */
-export var combineCheckedDomain = (realScaleType, axisDomain) => {
+export const combineCheckedDomain = (
+	realScaleType: string | undefined,
+	axisDomain: NumberDomain | CategoricalDomain | undefined,
+): NumberDomain | CategoricalDomain | undefined => {
 	if (axisDomain == null) {
 		return undefined;
 	}
@@ -18,9 +21,9 @@ export var combineCheckedDomain = (realScaleType, axisDomain) => {
 			 * let's pick the min and max from it.
 			 */
 			if (!isWellFormedNumberDomain(axisDomain)) {
-				var min, max;
-				for (var i = 0; i < axisDomain.length; i++) {
-					var value = axisDomain[i];
+				let min: number | undefined, max: number | undefined;
+				for (let i = 0; i < axisDomain.length; i++) {
+					const value = axisDomain[i];
 					if (!isWellBehavedNumber(value)) {
 						continue;
 					}

package/src/state/selectors/combiners/combineConfiguredScale.ts

@@ -0,0 +1,100 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import * as d3Scales from 'victory-vendor/d3-scale';
+import { BaseCartesianAxis } from '../../cartesianAxisSlice';
+import {
+	CategoricalDomain,
+	CategoricalDomainItem,
+	D3ScaleType,
+	NumberDomain,
+	RechartsScaleType,
+} from '../../../util/types';
+import { CustomScaleDefinition } from '../../../util/scale/CustomScaleDefinition';
+import { AxisRange } from '../axisSelectors';
+import { upperFirst } from '../../../util/DataUtils';
+
+function getD3ScaleFromType<Domain extends CategoricalDomainItem = CategoricalDomainItem>(
+	realScaleType: D3ScaleType | RechartsScaleType,
+): CustomScaleDefinition<Domain> | undefined {
+	const scales = d3Scales as Record<string, unknown>;
+	if (realScaleType in scales && typeof scales[realScaleType] === 'function') {
+		return scales[realScaleType]();
+	}
+	const name = `scale${upperFirst(realScaleType)}`;
+	if (name in scales && typeof scales[name] === 'function') {
+		return scales[name]();
+	}
+	return undefined;
+}
+
+/**
+ * Converts external scale definition into internal RechartsScale definition.
+ * @param scale custom function scale - if you have the `string` from outside, use `combineRealScaleType` first which will validate it and return RechartsScaleType or undefined
+ * @param axisDomain
+ * @param axisRange
+ */
+export function combineConfiguredScaleInternal(
+	scale:
+		| CustomScaleDefinition
+		| CustomScaleDefinition<string>
+		| CustomScaleDefinition<number>
+		| CustomScaleDefinition<Date>,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): CustomScaleDefinition;
+export function combineConfiguredScaleInternal(
+	scale: D3ScaleType | RechartsScaleType,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): CustomScaleDefinition;
+export function combineConfiguredScaleInternal(
+	scale: D3ScaleType | RechartsScaleType | undefined,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): CustomScaleDefinition | undefined;
+export function combineConfiguredScaleInternal(
+	scale: undefined,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): undefined;
+export function combineConfiguredScaleInternal<
+	Domain extends CategoricalDomainItem = CategoricalDomainItem,
+>(
+	scale: D3ScaleType | RechartsScaleType | CustomScaleDefinition<Domain> | undefined,
+	axisDomain: ReadonlyArray<Domain>,
+	axisRange: AxisRange,
+): CustomScaleDefinition<Domain> | undefined;
+export function combineConfiguredScaleInternal<
+	Domain extends CategoricalDomainItem = CategoricalDomainItem,
+>(
+	scale: D3ScaleType | RechartsScaleType | CustomScaleDefinition<Domain> | undefined,
+	axisDomain: ReadonlyArray<Domain>,
+	axisRange: AxisRange,
+): CustomScaleDefinition<Domain> | undefined {
+	if (typeof scale === 'function') {
+		return scale.copy().domain(axisDomain).range(axisRange);
+	}
+	if (scale == null) {
+		return undefined;
+	}
+	const d3ScaleFunction: CustomScaleDefinition<Domain> | undefined = getD3ScaleFromType(scale);
+	if (d3ScaleFunction == null) {
+		return undefined;
+	}
+	d3ScaleFunction.domain(axisDomain).range(axisRange);
+	return d3ScaleFunction;
+}
+
+export function combineConfiguredScale(
+	axis: BaseCartesianAxis,
+	realScaleType: D3ScaleType | RechartsScaleType | undefined,
+	axisDomain: NumberDomain | CategoricalDomain | undefined,
+	axisRange: AxisRange | undefined,
+): CustomScaleDefinition | undefined {
+	if (axisDomain == null || axisRange == null) {
+		return undefined;
+	}
+	if (typeof axis.scale === 'function') {
+		return combineConfiguredScaleInternal(axis.scale, axisDomain, axisRange);
+	}
+	return combineConfiguredScaleInternal(realScaleType, axisDomain, axisRange);
+}

package/src/state/selectors/combiners/combineCoordinateForDefaultIndex.ts

@@ -0,0 +1,46 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { ChartOffsetInternal, Coordinate, LayoutType, TickItem } from '../../../util/types';
+import { TooltipIndex, TooltipPayloadConfiguration } from '../../tooltipSlice';
+
+export const combineCoordinateForDefaultIndex = (
+	width: number,
+	height: number,
+	layout: LayoutType,
+	offset: ChartOffsetInternal,
+	tooltipTicks: ReadonlyArray<TickItem> | undefined,
+	defaultIndex: TooltipIndex | undefined,
+	tooltipConfigurations: ReadonlyArray<TooltipPayloadConfiguration>,
+): Coordinate | undefined => {
+	if (defaultIndex == null) {
+		return undefined;
+	}
+	/*
+	 * With defaultIndex alone, we don't have enough information to decide _which_ of the multiple tooltips to display.
+	 * Maybe one day we could add new prop `activeGraphicalItemId` to the chart to help with that.
+	 * Until then, we choose the first one.
+	 */
+	const firstConfiguration = tooltipConfigurations[0];
+	const maybePosition: Coordinate | undefined = firstConfiguration?.getPosition(defaultIndex);
+	if (maybePosition != null) {
+		return maybePosition;
+	}
+	const tick = tooltipTicks?.[Number(defaultIndex)];
+	if (!tick) {
+		return undefined;
+	}
+	switch (layout) {
+		case 'horizontal': {
+			return {
+				x: tick.coordinate,
+				y: (offset.top + height) / 2,
+			};
+		}
+		default: {
+			// This logic is not super sound - it conflates vertical, radial, centric layouts into just one. TODO improve!
+			return {
+				x: (offset.left + width) / 2,
+				y: tick.coordinate,
+			};
+		}
+	}
+};

package/src/state/selectors/combiners/{combineDisplayedStackedData.js → combineDisplayedStackedData.ts}

@@ -1,7 +1,10 @@
-// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineDisplayedStackedData.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { ChartDataState } from '../../chartDataSlice';
+import { BaseCartesianAxis } from '../../cartesianAxisSlice';
 import { getStackSeriesIdentifier } from '../../../util/stacks/getStackSeriesIdentifier';
 import { getValueByDataKey } from '../../../util/ChartUtils';
+import { StackSeriesIdentifier } from '../../../util/stacks/stackTypes';
+import { DefinitelyStackedGraphicalItem } from '../../types/StackedGraphicalItem';
 
 /**
  * In a stacked chart, each graphical item has its own data. That data could be either:
@@ -13,40 +16,41 @@ import { getValueByDataKey } from '../../../util/ChartUtils';
  * This type represents a single data point in a stacked chart, where each key is a series identifier
  * and the value is the numeric value for that series using the numerical axis dataKey.
  */
+export type DisplayedStackedDataPoint = Record<StackSeriesIdentifier, number>;
 
-export function combineDisplayedStackedData(stackedGraphicalItems, _ref, tooltipAxisSettings) {
-	var _ref$chartData = _ref.chartData,
-		chartData = _ref$chartData === void 0 ? [] : _ref$chartData;
-	var allowDuplicatedCategory = tooltipAxisSettings.allowDuplicatedCategory,
-		tooltipDataKey = tooltipAxisSettings.dataKey;
+export type DisplayedStackedData = ReadonlyArray<DisplayedStackedDataPoint>;
+
+export function combineDisplayedStackedData(
+	stackedGraphicalItems: ReadonlyArray<DefinitelyStackedGraphicalItem>,
+	{ chartData = [] }: ChartDataState,
+	tooltipAxisSettings: BaseCartesianAxis,
+): DisplayedStackedData {
+	const { allowDuplicatedCategory, dataKey: tooltipDataKey } = tooltipAxisSettings;
 
 	// A map of tooltip data keys to the stacked data points
-	var knownItemsByDataKey = new Map();
+	const knownItemsByDataKey = new Map<string | number, DisplayedStackedDataPoint>();
+
 	stackedGraphicalItems.forEach((item) => {
-		var _item$data;
 		// If there is no data on the individual item then we use the root chart data
-		var resolvedData =
-			(_item$data = item.data) !== null && _item$data !== void 0 ? _item$data : chartData;
+		const resolvedData = item.data ?? chartData;
 		if (resolvedData == null || resolvedData.length === 0) {
 			// if that doesn't work then we skip this item
 			return;
 		}
-		var stackIdentifier = getStackSeriesIdentifier(item);
+		const stackIdentifier = getStackSeriesIdentifier(item);
 		resolvedData.forEach((entry, index) => {
-			var tooltipValue =
+			const tooltipValue =
 				tooltipDataKey == null || allowDuplicatedCategory
 					? index
 					: String(getValueByDataKey(entry, tooltipDataKey, null));
-			var numericValue = getValueByDataKey(entry, item.dataKey, 0);
-			var curr;
+			const numericValue = getValueByDataKey(entry, item.dataKey, 0);
+			let curr;
 			if (knownItemsByDataKey.has(tooltipValue)) {
-				curr = knownItemsByDataKey.get(tooltipValue);
+				curr = knownItemsByDataKey.get(tooltipValue)!;
 			} else {
 				curr = {};
 			}
-			Object.assign(curr, {
-				[stackIdentifier]: numericValue,
-			});
+			Object.assign(curr, { [stackIdentifier]: numericValue });
 			knownItemsByDataKey.set(tooltipValue, curr);
 		});
 	});

package/src/state/selectors/combiners/combineInverseScaleFunction.ts

@@ -0,0 +1,16 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { InverseScaleFunction } from '../../../hooks';
+import { createCategoricalInverse } from '../../../util/scale/createCategoricalInverse';
+import { CustomScaleDefinition } from '../../../util/scale/CustomScaleDefinition';
+
+export function combineInverseScaleFunction(
+	configuredScale: CustomScaleDefinition | undefined,
+): InverseScaleFunction | undefined {
+	if (configuredScale == null) {
+		return undefined;
+	}
+	if ('invert' in configuredScale && typeof configuredScale.invert === 'function') {
+		return configuredScale.invert.bind(configuredScale);
+	}
+	return createCategoricalInverse(configuredScale, undefined);
+}

package/src/state/selectors/combiners/{combineRealScaleType.js → combineRealScaleType.ts}

@@ -1,19 +1,26 @@
-// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineRealScaleType.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
 import * as d3Scales from 'victory-vendor/d3-scale';
+import { D3ScaleType, RechartsScaleType } from '../../../util/types';
+import { BaseCartesianAxis } from '../../cartesianAxisSlice';
 import { upperFirst } from '../../../util/DataUtils';
-function getD3ScaleName(name) {
-	return 'scale'.concat(upperFirst(name));
+
+function getD3ScaleName(name: string): D3ScaleType {
+	return `scale${upperFirst(name)}` as D3ScaleType;
 }
-function isSupportedScaleName(name) {
+
+function isSupportedScaleName(name: string): name is RechartsScaleType {
 	return getD3ScaleName(name) in d3Scales;
 }
-export var combineRealScaleType = (axisConfig, hasBar, chartType) => {
+
+export const combineRealScaleType = (
+	axisConfig: BaseCartesianAxis | undefined,
+	hasBar: boolean,
+	chartType: string,
+): RechartsScaleType | undefined => {
 	if (axisConfig == null) {
 		return undefined;
 	}
-	var scale = axisConfig.scale,
-		type = axisConfig.type;
+	const { scale, type } = axisConfig;
 	if (scale === 'auto') {
 		if (
 			type === 'category' &&
@@ -27,6 +34,7 @@ export var combineRealScaleType = (axisConfig, hasBar, chartType) => {
 		if (type === 'category') {
 			return 'band';
 		}
+
 		return 'linear';
 	}
 	if (typeof scale === 'string') {

package/src/state/selectors/combiners/combineStackedData.ts

@@ -0,0 +1,27 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { AllStackGroups, StackGroup, StackSeries } from '../../../util/stacks/stackTypes';
+import { MaybeStackedGraphicalItem } from '../../types/StackedGraphicalItem';
+import { getStackSeriesIdentifier } from '../../../util/stacks/getStackSeriesIdentifier';
+
+export const combineStackedData = (
+	stackGroups: AllStackGroups | undefined,
+	barSettings: MaybeStackedGraphicalItem | undefined,
+): StackSeries | undefined => {
+	const stackSeriesIdentifier = getStackSeriesIdentifier(barSettings);
+	if (!stackGroups || stackSeriesIdentifier == null || barSettings == null) {
+		return undefined;
+	}
+	const { stackId } = barSettings;
+	if (stackId == null) {
+		return undefined;
+	}
+	const stackGroup: StackGroup | undefined = stackGroups[stackId];
+	if (!stackGroup) {
+		return undefined;
+	}
+	const { stackedData }: StackGroup = stackGroup;
+	if (!stackedData) {
+		return undefined;
+	}
+	return stackedData.find((sd) => sd.key === stackSeriesIdentifier);
+};

package/src/state/selectors/combiners/combineTooltipInteractionState.ts

@@ -0,0 +1,86 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import {
+	noInteraction,
+	TooltipIndex,
+	TooltipInteractionState,
+	TooltipState,
+} from '../../tooltipSlice';
+import { TooltipEventType } from '../../../util/types';
+import { TooltipTrigger } from '../../../chart/types';
+
+function chooseAppropriateMouseInteraction(
+	tooltipState: TooltipState,
+	tooltipEventType: TooltipEventType,
+	trigger: TooltipTrigger,
+): TooltipInteractionState | undefined {
+	if (tooltipEventType === 'axis') {
+		if (trigger === 'click') {
+			return tooltipState.axisInteraction.click;
+		}
+		return tooltipState.axisInteraction.hover;
+	}
+	if (trigger === 'click') {
+		return tooltipState.itemInteraction.click;
+	}
+	return tooltipState.itemInteraction.hover;
+}
+
+function hasBeenActivePreviously(tooltipInteractionState: TooltipInteractionState): boolean {
+	return tooltipInteractionState.index != null;
+}
+
+export const combineTooltipInteractionState = (
+	tooltipState: TooltipState,
+	tooltipEventType: TooltipEventType | undefined,
+	trigger: TooltipTrigger,
+	defaultIndex: TooltipIndex | undefined,
+): TooltipInteractionState => {
+	if (tooltipEventType == null) {
+		return noInteraction;
+	}
+	const appropriateMouseInteraction = chooseAppropriateMouseInteraction(
+		tooltipState,
+		tooltipEventType,
+		trigger,
+	);
+
+	if (appropriateMouseInteraction == null) {
+		return noInteraction;
+	}
+
+	if (appropriateMouseInteraction.active) {
+		return appropriateMouseInteraction;
+	}
+
+	if (tooltipState.keyboardInteraction.active) {
+		return tooltipState.keyboardInteraction;
+	}
+
+	if (tooltipState.syncInteraction.active && tooltipState.syncInteraction.index != null) {
+		return tooltipState.syncInteraction;
+	}
+
+	const activeFromProps = tooltipState.settings.active === true;
+
+	if (hasBeenActivePreviously(appropriateMouseInteraction)) {
+		if (activeFromProps) {
+			return {
+				...appropriateMouseInteraction,
+				active: true,
+			};
+		}
+	} else if (defaultIndex != null) {
+		return {
+			active: true,
+			coordinate: undefined,
+			dataKey: undefined,
+			index: defaultIndex,
+			graphicalItemId: undefined,
+		};
+	}
+
+	return {
+		...noInteraction,
+		coordinate: appropriateMouseInteraction.coordinate,
+	};
+};