@octanejs/recharts 0.1.40 → 0.1.42

package/src/util/getActiveCoordinate.ts

@@ -0,0 +1,210 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import {
+	AxisType,
+	CartesianLayout,
+	ChartOffsetInternal,
+	RelativePointer,
+	Coordinate,
+	PolarCoordinate,
+	PolarLayout,
+	RangeObj,
+	TickItem,
+} from './types';
+import { polarToCartesian } from './PolarUtils';
+import { AxisRange } from '../state/selectors/axisSelectors';
+import { mathSign } from './DataUtils';
+
+export const getActiveCartesianCoordinate = (
+	layout: CartesianLayout,
+	tooltipTicks: readonly TickItem[],
+	activeIndex: number | undefined,
+	pointer: RelativePointer,
+): Coordinate => {
+	const entry = tooltipTicks.find((tick) => tick && tick.index === activeIndex);
+
+	if (entry) {
+		if (layout === 'horizontal') {
+			return { x: entry.coordinate, y: pointer.relativeY };
+		}
+		if (layout === 'vertical') {
+			return { x: pointer.relativeX, y: entry.coordinate };
+		}
+	}
+
+	return { x: 0, y: 0 };
+};
+
+/**
+ * Get the active coordinate in polar coordinate system.
+ * Internally we only really use x and y, but this returned object is part of public API
+ * (because it goes straight to the tooltip content) so we keep all the other properties
+ * for backwards compatibility.
+ *
+ * @param layout - The polar layout type ('centric' or 'radial').
+ * @param tooltipTicks - Array of tick items used for tooltips.
+ * @param activeIndex - The index of the active tick.
+ * @param rangeObj - The range object containing polar chart properties.
+ * @returns The active coordinate object with polar properties.
+ */
+export const getActivePolarCoordinate = (
+	layout: PolarLayout,
+	tooltipTicks: readonly TickItem[],
+	activeIndex: number | undefined,
+	rangeObj: RangeObj,
+): PolarCoordinate => {
+	const entry = tooltipTicks.find((tick) => tick && tick.index === activeIndex);
+
+	if (entry) {
+		if (layout === 'centric') {
+			const angle = entry.coordinate;
+			const { radius } = rangeObj;
+
+			return {
+				...rangeObj,
+				...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+				angle,
+				radius,
+			};
+		}
+
+		const radius = entry.coordinate;
+		const { angle } = rangeObj;
+
+		return {
+			...rangeObj,
+			...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+			angle,
+			radius,
+		};
+	}
+
+	return {
+		angle: 0,
+		clockWise: false,
+		cx: 0,
+		cy: 0,
+		endAngle: 0,
+		innerRadius: 0,
+		outerRadius: 0,
+		radius: 0,
+		startAngle: 0,
+		x: 0,
+		y: 0,
+	};
+};
+
+export function isInCartesianRange(pointer: RelativePointer, offset: ChartOffsetInternal): boolean {
+	const { relativeX: x, relativeY: y } = pointer;
+	return (
+		x >= offset.left &&
+		x <= offset.left + offset.width &&
+		y >= offset.top &&
+		y <= offset.top + offset.height
+	);
+}
+
+export const calculateActiveTickIndex = (
+	/**
+	 * For different layouts, `coordinate` is different:
+	 * In horizontal layout, this is expected to be the `x` coordinate
+	 * vertical -> y
+	 * centric -> angle
+	 * radial -> radius
+	 */
+	coordinate: number | undefined,
+	ticks: ReadonlyArray<TickItem> | undefined,
+	unsortedTicks: ReadonlyArray<TickItem>,
+	axisType: AxisType | undefined,
+	range: AxisRange | undefined,
+): number | undefined => {
+	const len = ticks?.length ?? 0;
+
+	// if there are 1 or fewer ticks or if there is no coordinate then the active tick is at index 0
+	if (len <= 1 || coordinate == null) {
+		return 0;
+	}
+
+	if (
+		axisType === 'angleAxis' &&
+		range != null &&
+		Math.abs(Math.abs(range[1] - range[0]) - 360) <= 1e-6
+	) {
+		// ticks are distributed in a circle
+		for (let i = 0; i < len; i++) {
+			const before = i > 0 ? unsortedTicks[i - 1]?.coordinate : unsortedTicks[len - 1]?.coordinate;
+			const cur = unsortedTicks[i]?.coordinate;
+			const after = i >= len - 1 ? unsortedTicks[0]?.coordinate : unsortedTicks[i + 1]?.coordinate;
+			let sameDirectionCoord;
+
+			if (before == null || cur == null || after == null) {
+				continue;
+			}
+
+			if (mathSign(cur - before) !== mathSign(after - cur)) {
+				const diffInterval = [];
+				if (mathSign(after - cur) === mathSign(range[1] - range[0])) {
+					sameDirectionCoord = after;
+
+					const curInRange = cur + range[1] - range[0];
+					diffInterval[0] = Math.min(curInRange, (curInRange + before) / 2);
+					diffInterval[1] = Math.max(curInRange, (curInRange + before) / 2);
+				} else {
+					sameDirectionCoord = before;
+
+					const afterInRange = after + range[1] - range[0];
+					diffInterval[0] = Math.min(cur, (afterInRange + cur) / 2);
+					diffInterval[1] = Math.max(cur, (afterInRange + cur) / 2);
+				}
+				const sameInterval: [number, number] = [
+					Math.min(cur, (sameDirectionCoord + cur) / 2),
+					Math.max(cur, (sameDirectionCoord + cur) / 2),
+				];
+
+				if (
+					(coordinate > sameInterval[0] && coordinate <= sameInterval[1]) ||
+					(coordinate >= diffInterval[0] && coordinate <= diffInterval[1])
+				) {
+					return unsortedTicks[i]?.index;
+				}
+			} else {
+				const minValue = Math.min(before, after);
+				const maxValue = Math.max(before, after);
+
+				if (coordinate > (minValue + cur) / 2 && coordinate <= (maxValue + cur) / 2) {
+					return unsortedTicks[i]?.index;
+				}
+			}
+		}
+	} else if (ticks) {
+		// ticks are distributed in a single direction
+		for (let i = 0; i < len; i++) {
+			const curr = ticks[i];
+			if (curr == null) {
+				continue;
+			}
+			const next = ticks[i + 1];
+			const prev = ticks[i - 1];
+
+			if (i === 0 && next != null && coordinate <= (curr.coordinate + next.coordinate) / 2) {
+				return curr.index;
+			}
+
+			if (i === len - 1 && prev != null && coordinate > (curr.coordinate + prev.coordinate) / 2) {
+				return curr.index;
+			}
+
+			if (
+				i > 0 &&
+				i < len - 1 &&
+				prev != null &&
+				next != null &&
+				coordinate > (curr.coordinate + prev.coordinate) / 2 &&
+				coordinate <= (curr.coordinate + next.coordinate) / 2
+			) {
+				return curr.index;
+			}
+		}
+	}
+
+	return -1;
+};

package/src/util/{getAxisTypeBasedOnLayout.js → getAxisTypeBasedOnLayout.ts}

@@ -1,12 +1,16 @@
-// Vendored verbatim from recharts@3.9.2 es6/util/getAxisTypeBasedOnLayout.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { AxisDomainTypeInput, AxisType, EvaluatedAxisDomainType, LayoutType } from './types';
 import { isCategoricalAxis } from './ChartUtils';
 
 /**
  * This function evaluates the "auto" axis domain type based on the chart layout and axis type.
  * It outputs a definitive axis domain type that can be used for further processing.
  */
-export function getAxisTypeBasedOnLayout(layout, axisType, axisDomainType) {
+export function getAxisTypeBasedOnLayout(
+	layout: LayoutType | undefined,
+	axisType: AxisType,
+	axisDomainType: AxisDomainTypeInput,
+): EvaluatedAxisDomainType | undefined {
 	if (axisDomainType !== 'auto') {
 		return axisDomainType;
 	}

package/src/util/getClassNameFromUnknown.ts

@@ -0,0 +1,7 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+export function getClassNameFromUnknown(u: unknown): string {
+	if (u && typeof u === 'object' && 'className' in u && typeof u.className === 'string') {
+		return u.className;
+	}
+	return '';
+}

package/src/util/{getEveryNth.js → getEveryNth.ts}

@@ -1,5 +1,4 @@
-// Vendored verbatim from recharts@3.9.2 es6/util/getEveryNth.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
 /**
  * Given an array and a number N, return a new array which contains every nTh
  * element of the input array. For n below 1, an empty array is returned.
@@ -11,16 +10,16 @@
  * @param n A number specifying which elements to take.
  * @returns The result array of the same type as the input array.
  */
-export function getEveryNth(array, n) {
+export function getEveryNth<Type>(array: ReadonlyArray<Type>, n: number): ReadonlyArray<Type> {
 	if (n < 1) {
 		return [];
 	}
 	if (n === 1) {
 		return array;
 	}
-	var result = [];
-	for (var i = 0; i < array.length; i += n) {
-		var item = array[i];
+	const result: Type[] = [];
+	for (let i = 0; i < array.length; i += n) {
+		const item = array[i];
 		if (item !== undefined) {
 			result.push(item);
 		}

package/src/util/getRadiusAndStrokeWidthFromDot.ts

@@ -0,0 +1,31 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { ActiveDotType, DotType } from './types';
+import { svgPropertiesNoEventsFromUnknown } from './svgPropertiesNoEvents';
+
+export function getRadiusAndStrokeWidthFromDot(dot: ActiveDotType | DotType): {
+	r: number;
+	strokeWidth: number;
+} {
+	const props = svgPropertiesNoEventsFromUnknown(dot);
+	const defaultR = 3;
+	const defaultStrokeWidth = 2;
+	if (props != null) {
+		const { r, strokeWidth } = props;
+		let realR = Number(r);
+		let realStrokeWidth = Number(strokeWidth);
+		if (Number.isNaN(realR) || realR < 0) {
+			realR = defaultR;
+		}
+		if (Number.isNaN(realStrokeWidth) || realStrokeWidth < 0) {
+			realStrokeWidth = defaultStrokeWidth;
+		}
+		return {
+			r: realR,
+			strokeWidth: realStrokeWidth,
+		};
+	}
+	return {
+		r: defaultR,
+		strokeWidth: defaultStrokeWidth,
+	};
+}

package/src/util/{getRelativeCoordinate.js → getRelativeCoordinate.ts}

@@ -1,9 +1,18 @@
-// Vendored verbatim from recharts@3.9.2 es6/util/getRelativeCoordinate.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import {
+	RelativePointer,
+	MousePointer,
+	SVGMousePointer,
+	TouchPointer,
+	SVGTouchPointer,
+} from './types';
+
 /**
  * Type guard to check if the pointer event is from an SVG element.
  */
-function isSvgPointer(pointer) {
+function isSvgPointer(
+	pointer: MousePointer | TouchPointer,
+): pointer is SVGMousePointer | SVGTouchPointer {
 	return 'getBBox' in pointer.currentTarget && typeof pointer.currentTarget.getBBox === 'function';
 }
 
@@ -60,22 +69,28 @@ function isSvgPointer(pointer) {
  * @param event The mouse or touch event from React event handlers (works with both HTML and SVG elements)
  * @returns Coordinates relative to the top-left corner of the element. Single object for Mouse events, array of objects for Touch events.
  */
+export function getRelativeCoordinate(event: MousePointer): RelativePointer;
+export function getRelativeCoordinate(event: TouchPointer): Array<RelativePointer>;
+export function getRelativeCoordinate(
+	event: MousePointer | TouchPointer,
+): RelativePointer | Array<RelativePointer> {
+	const rect = event.currentTarget.getBoundingClientRect();
+
+	let scaleX: number, scaleY: number;
 
-export function getRelativeCoordinate(event) {
-	var rect = event.currentTarget.getBoundingClientRect();
-	var scaleX, scaleY;
 	if (isSvgPointer(event)) {
 		// For SVG elements, use getBBox() to get the intrinsic size in SVG coordinates
-		var bbox = event.currentTarget.getBBox();
+		const bbox = event.currentTarget.getBBox();
 		scaleX = bbox.width > 0 ? rect.width / bbox.width : 1;
 		scaleY = bbox.height > 0 ? rect.height / bbox.height : 1;
 	} else {
 		// For HTML elements, use offsetWidth/offsetHeight
-		var element = event.currentTarget;
+		const element = event.currentTarget;
 		scaleX = element.offsetWidth > 0 ? rect.width / element.offsetWidth : 1;
 		scaleY = element.offsetHeight > 0 ? rect.height / element.offsetHeight : 1;
 	}
-	var getCoordinates = (clientX, clientY) => ({
+
+	const getCoordinates = (clientX: number, clientY: number): RelativePointer => ({
 		/*
 		 * Here it's important to use:
 		 * - event.clientX and event.clientY to get the mouse position relative to the viewport, including scroll.
@@ -89,8 +104,10 @@ export function getRelativeCoordinate(event) {
 		relativeX: Math.round((clientX - rect.left) / scaleX),
 		relativeY: Math.round((clientY - rect.top) / scaleY),
 	});
+
 	if ('touches' in event) {
 		return Array.from(event.touches).map((touch) => getCoordinates(touch.clientX, touch.clientY));
 	}
+
 	return getCoordinates(event.clientX, event.clientY);
 }

package/src/util/getSliced.ts

@@ -0,0 +1,14 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+export function getSliced<T>(
+	arr: ReadonlyArray<T>,
+	startIndex: number,
+	endIndex: number,
+): ReadonlyArray<T> {
+	if (!Array.isArray(arr)) {
+		return arr;
+	}
+	if (arr && startIndex + endIndex !== 0) {
+		return arr.slice(startIndex, endIndex + 1);
+	}
+	return arr;
+}

package/src/util/{isDomainSpecifiedByUser.js → isDomainSpecifiedByUser.ts}

@@ -1,83 +1,24 @@
-// Vendored verbatim from recharts@3.9.2 es6/util/isDomainSpecifiedByUser.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
-function _slicedToArray(r, e) {
-	return (
-		_arrayWithHoles(r) ||
-		_iterableToArrayLimit(r, e) ||
-		_unsupportedIterableToArray(r, e) ||
-		_nonIterableRest()
-	);
-}
-function _nonIterableRest() {
-	throw new TypeError(
-		'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
-	);
-}
-function _unsupportedIterableToArray(r, a) {
-	if (r) {
-		if ('string' == typeof r) return _arrayLikeToArray(r, a);
-		var t = {}.toString.call(r).slice(8, -1);
-		return (
-			'Object' === t && r.constructor && (t = r.constructor.name),
-			'Map' === t || 'Set' === t
-				? Array.from(r)
-				: 'Arguments' === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
-					? _arrayLikeToArray(r, a)
-					: void 0
-		);
-	}
-}
-function _arrayLikeToArray(r, a) {
-	(null == a || a > r.length) && (a = r.length);
-	for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-	return n;
-}
-function _iterableToArrayLimit(r, l) {
-	var t =
-		null == r ? null : ('undefined' != typeof Symbol && r[Symbol.iterator]) || r['@@iterator'];
-	if (null != t) {
-		var e,
-			n,
-			i,
-			u,
-			a = [],
-			f = !0,
-			o = !1;
-		try {
-			if (((i = (t = t.call(r)).next), 0 === l)) {
-				if (Object(t) !== t) return;
-				f = !1;
-			} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-		} catch (r) {
-			((o = !0), (n = r));
-		} finally {
-			try {
-				if (!f && null != t.return && ((u = t.return()), Object(u) !== u)) return;
-			} finally {
-				if (o) throw n;
-			}
-		}
-		return a;
-	}
-}
-function _arrayWithHoles(r) {
-	if (Array.isArray(r)) return r;
-}
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
 import { MAX_VALUE_REG, MIN_VALUE_REG } from './ChartUtils';
 import { isNumber } from './DataUtils';
+import { AxisDomain, NumberDomain } from './types';
 import { isWellBehavedNumber } from './isWellBehavedNumber';
-export function isWellFormedNumberDomain(v) {
+
+export function isWellFormedNumberDomain(v: unknown): v is NumberDomain {
 	if (Array.isArray(v) && v.length === 2) {
-		var _v = _slicedToArray(v, 2),
-			min = _v[0],
-			max = _v[1];
+		const [min, max] = v;
 		if (isWellBehavedNumber(min) && isWellBehavedNumber(max)) {
 			return true;
 		}
 	}
 	return false;
 }
-export function extendDomain(providedDomain, boundaryDomain, allowDataOverflow) {
+
+export function extendDomain(
+	providedDomain: NumberDomain,
+	boundaryDomain: NumberDomain,
+	allowDataOverflow: boolean,
+): NumberDomain {
 	if (allowDataOverflow) {
 		// If the data are allowed to overflow - we're fine with whatever user provided
 		return providedDomain;
@@ -115,7 +56,10 @@ export function extendDomain(providedDomain, boundaryDomain, allowDataOverflow)
  *
  * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
  */
-export function numericalDomainSpecifiedWithoutRequiringData(userDomain, allowDataOverflow) {
+export function numericalDomainSpecifiedWithoutRequiringData(
+	userDomain: AxisDomain | undefined,
+	allowDataOverflow: boolean,
+) {
 	if (!allowDataOverflow) {
 		// Cannot compute data overflow if the data is not provided
 		return undefined;
@@ -125,23 +69,24 @@ export function numericalDomainSpecifiedWithoutRequiringData(userDomain, allowDa
 		return undefined;
 	}
 	if (Array.isArray(userDomain) && userDomain.length === 2) {
-		var _userDomain = _slicedToArray(userDomain, 2),
-			providedMin = _userDomain[0],
-			providedMax = _userDomain[1];
-		var finalMin, finalMax;
+		const [providedMin, providedMax] = userDomain;
+		let finalMin, finalMax: string | number | undefined;
+
 		if (isWellBehavedNumber(providedMin)) {
 			finalMin = providedMin;
 		} else if (typeof providedMin === 'function') {
 			// The user function expects the data to be provided as an argument
 			return undefined;
 		}
+
 		if (isWellBehavedNumber(providedMax)) {
 			finalMax = providedMax;
 		} else if (typeof providedMax === 'function') {
 			// The user function expects the data to be provided as an argument
 			return undefined;
 		}
-		var candidate = [finalMin, finalMax];
+
+		const candidate = [finalMin, finalMax];
 		if (isWellFormedNumberDomain(candidate)) {
 			return candidate;
 		}
@@ -169,26 +114,29 @@ export function numericalDomainSpecifiedWithoutRequiringData(userDomain, allowDa
  *
  * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
  */
-export function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverflow) {
+export function parseNumericalUserDomain(
+	userDomain: AxisDomain | undefined,
+	dataDomain: NumberDomain | undefined,
+	allowDataOverflow: boolean,
+): NumberDomain | undefined {
 	if (!allowDataOverflow && dataDomain == null) {
 		// Cannot compute data overflow if the data is not provided
 		return undefined;
 	}
 	if (typeof userDomain === 'function' && dataDomain != null) {
 		try {
-			var result = userDomain(dataDomain, allowDataOverflow);
+			const result = userDomain(dataDomain, allowDataOverflow);
 			if (isWellFormedNumberDomain(result)) {
 				return extendDomain(result, dataDomain, allowDataOverflow);
 			}
-		} catch (_unused) {
+		} catch {
 			/* ignore the exception and compute domain from data later */
 		}
 	}
 	if (Array.isArray(userDomain) && userDomain.length === 2) {
-		var _userDomain2 = _slicedToArray(userDomain, 2),
-			providedMin = _userDomain2[0],
-			providedMax = _userDomain2[1];
-		var finalMin, finalMax;
+		const [providedMin, providedMax] = userDomain;
+		let finalMin, finalMax: string | number | undefined;
+
 		if (providedMin === 'auto') {
 			if (dataDomain != null) {
 				finalMin = Math.min(...dataDomain);
@@ -198,24 +146,23 @@ export function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverfl
 		} else if (typeof providedMin === 'function') {
 			try {
 				if (dataDomain != null) {
-					finalMin = providedMin(
-						dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[0],
-					);
+					finalMin = providedMin(dataDomain?.[0]);
 				}
-			} catch (_unused2) {
+			} catch {
 				/* ignore the exception and compute domain from data later */
 			}
 		} else if (typeof providedMin === 'string' && MIN_VALUE_REG.test(providedMin)) {
-			var match = MIN_VALUE_REG.exec(providedMin);
+			const match = MIN_VALUE_REG.exec(providedMin);
 			if (match == null || match[1] == null || dataDomain == null) {
 				finalMin = undefined;
 			} else {
-				var value = +match[1];
+				const value = +match[1];
 				finalMin = dataDomain[0] - value;
 			}
 		} else {
-			finalMin = dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[0];
+			finalMin = dataDomain?.[0];
 		}
+
 		if (providedMax === 'auto') {
 			if (dataDomain != null) {
 				finalMax = Math.max(...dataDomain);
@@ -225,25 +172,24 @@ export function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverfl
 		} else if (typeof providedMax === 'function') {
 			try {
 				if (dataDomain != null) {
-					finalMax = providedMax(
-						dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[1],
-					);
+					finalMax = providedMax(dataDomain?.[1]);
 				}
-			} catch (_unused3) {
+			} catch {
 				/* ignore the exception and compute domain from data later */
 			}
 		} else if (typeof providedMax === 'string' && MAX_VALUE_REG.test(providedMax)) {
-			var _match = MAX_VALUE_REG.exec(providedMax);
-			if (_match == null || _match[1] == null || dataDomain == null) {
+			const match = MAX_VALUE_REG.exec(providedMax);
+			if (match == null || match[1] == null || dataDomain == null) {
 				finalMax = undefined;
 			} else {
-				var _value = +_match[1];
-				finalMax = dataDomain[1] + _value;
+				const value = +match[1];
+				finalMax = dataDomain[1] + value;
 			}
 		} else {
-			finalMax = dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[1];
+			finalMax = dataDomain?.[1];
 		}
-		var candidate = [finalMin, finalMax];
+
+		const candidate = [finalMin, finalMax];
 		if (isWellFormedNumberDomain(candidate)) {
 			if (dataDomain == null) {
 				return candidate;

package/src/util/isWellBehavedNumber.ts

@@ -0,0 +1,8 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+export function isWellBehavedNumber(n: unknown): n is number {
+	return Number.isFinite(n);
+}
+
+export function isPositiveNumber(n: unknown): n is number {
+	return typeof n === 'number' && n > 0 && Number.isFinite(n);
+}

package/src/util/payload/getUniqPayload.ts

@@ -1,4 +1,4 @@
-import uniqBy from 'es-toolkit/compat/uniqBy';
+import { uniqBy } from 'es-toolkit/compat';
 
 type UniqueFunc<T> = (entry: T) => unknown;
 

package/src/util/{propsAreEqual.js → propsAreEqual.ts}

@@ -1,8 +1,7 @@
-// Vendored from recharts@3.9.2 es6/util/propsAreEqual.js with ONE adaptation:
-// shallowEqual comes from @octanejs/redux instead of react-redux (identical
-// algorithm). Update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
 import { shallowEqual } from '@octanejs/redux';
-var propsToShallowCompare = new Set([
+
+const propsToShallowCompare = new Set<string>([
 	'axisLine',
 	'tickLine',
 	'activeBar',
@@ -40,7 +39,7 @@ var propsToShallowCompare = new Set([
  * @param y second value to compare
  * return true if the same, false if different
  */
-function sameValueZero(x, y) {
+function sameValueZero(x: unknown, y: unknown): boolean {
 	if (x == null && y == null) {
 		/*
 		 * treat null and undefined as equal. Internally in Recharts we make no difference between these two
@@ -67,9 +66,12 @@ function sameValueZero(x, y) {
  * @param prevProps
  * @param nextProps
  */
-export function propsAreEqual(prevProps, nextProps) {
-	var allKeys = new Set([...Object.keys(prevProps), ...Object.keys(nextProps)]);
-	for (var key of allKeys) {
+export function propsAreEqual<T extends Record<string, unknown>>(
+	prevProps: T,
+	nextProps: T,
+): boolean {
+	const allKeys = new Set<string>([...Object.keys(prevProps), ...Object.keys(nextProps)]);
+	for (const key of allKeys) {
 		/*
 		 * If a key is on a special allowlist, go one level deeper
 		 * and do a shallow comparison of the values.