@octanejs/recharts 0.1.0

package/src/util/getActiveCoordinate.js

@@ -0,0 +1,253 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/getActiveCoordinate.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 { polarToCartesian } from './PolarUtils';
+import { mathSign } from './DataUtils';
+export var getActiveCartesianCoordinate = (layout, tooltipTicks, activeIndex, pointer) => {
+	var 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 var getActivePolarCoordinate = (layout, tooltipTicks, activeIndex, rangeObj) => {
+	var entry = tooltipTicks.find((tick) => tick && tick.index === activeIndex);
+	if (entry) {
+		if (layout === 'centric') {
+			var _angle = entry.coordinate;
+			var _radius = rangeObj.radius;
+			return _objectSpread(
+				_objectSpread(
+					_objectSpread({}, rangeObj),
+					polarToCartesian(rangeObj.cx, rangeObj.cy, _radius, _angle),
+				),
+				{},
+				{
+					angle: _angle,
+					radius: _radius,
+				},
+			);
+		}
+		var radius = entry.coordinate;
+		var angle = rangeObj.angle;
+		return _objectSpread(
+			_objectSpread(
+				_objectSpread({}, 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, offset) {
+	var x = pointer.relativeX,
+		y = pointer.relativeY;
+	return (
+		x >= offset.left &&
+		x <= offset.left + offset.width &&
+		y >= offset.top &&
+		y <= offset.top + offset.height
+	);
+}
+export var calculateActiveTickIndex = (coordinate, ticks, unsortedTicks, axisType, range) => {
+	var _ticks$length;
+	var len =
+		(_ticks$length = ticks === null || ticks === void 0 ? void 0 : ticks.length) !== null &&
+		_ticks$length !== void 0
+			? _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 (var i = 0; i < len; i++) {
+			var _unsortedTicks, _unsortedTicks2, _unsortedTicks$i, _unsortedTicks$, _unsortedTicks3;
+			var before =
+				i > 0
+					? (_unsortedTicks = unsortedTicks[i - 1]) === null || _unsortedTicks === void 0
+						? void 0
+						: _unsortedTicks.coordinate
+					: (_unsortedTicks2 = unsortedTicks[len - 1]) === null || _unsortedTicks2 === void 0
+						? void 0
+						: _unsortedTicks2.coordinate;
+			var cur =
+				(_unsortedTicks$i = unsortedTicks[i]) === null || _unsortedTicks$i === void 0
+					? void 0
+					: _unsortedTicks$i.coordinate;
+			var after =
+				i >= len - 1
+					? (_unsortedTicks$ = unsortedTicks[0]) === null || _unsortedTicks$ === void 0
+						? void 0
+						: _unsortedTicks$.coordinate
+					: (_unsortedTicks3 = unsortedTicks[i + 1]) === null || _unsortedTicks3 === void 0
+						? void 0
+						: _unsortedTicks3.coordinate;
+			var sameDirectionCoord = void 0;
+			if (before == null || cur == null || after == null) {
+				continue;
+			}
+			if (mathSign(cur - before) !== mathSign(after - cur)) {
+				var diffInterval = [];
+				if (mathSign(after - cur) === mathSign(range[1] - range[0])) {
+					sameDirectionCoord = after;
+					var 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;
+					var afterInRange = after + range[1] - range[0];
+					diffInterval[0] = Math.min(cur, (afterInRange + cur) / 2);
+					diffInterval[1] = Math.max(cur, (afterInRange + cur) / 2);
+				}
+				var sameInterval = [
+					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])
+				) {
+					var _unsortedTicks$i2;
+					return (_unsortedTicks$i2 = unsortedTicks[i]) === null || _unsortedTicks$i2 === void 0
+						? void 0
+						: _unsortedTicks$i2.index;
+				}
+			} else {
+				var minValue = Math.min(before, after);
+				var maxValue = Math.max(before, after);
+				if (coordinate > (minValue + cur) / 2 && coordinate <= (maxValue + cur) / 2) {
+					var _unsortedTicks$i3;
+					return (_unsortedTicks$i3 = unsortedTicks[i]) === null || _unsortedTicks$i3 === void 0
+						? void 0
+						: _unsortedTicks$i3.index;
+				}
+			}
+		}
+	} else if (ticks) {
+		// ticks are distributed in a single direction
+		for (var _i = 0; _i < len; _i++) {
+			var curr = ticks[_i];
+			if (curr == null) {
+				continue;
+			}
+			var next = ticks[_i + 1];
+			var 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

@@ -0,0 +1,17 @@
+// 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.
+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) {
+	if (axisDomainType !== 'auto') {
+		return axisDomainType;
+	}
+	if (layout == null) {
+		return undefined;
+	}
+	return isCategoricalAxis(layout, axisType) ? 'category' : 'number';
+}

package/src/util/getClassNameFromUnknown.js

@@ -0,0 +1,8 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/getClassNameFromUnknown.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export function getClassNameFromUnknown(u) {
+	if (u && typeof u === 'object' && 'className' in u && typeof u.className === 'string') {
+		return u.className;
+	}
+	return '';
+}

package/src/util/getEveryNth.js

@@ -0,0 +1,29 @@
+// 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.
+/**
+ * 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.
+ * For n equal to 1, the input array is returned as is.
+ * For n greater than the length of the array, an array containing the first element
+ * and every nTh element after that (if any) is returned.
+ *
+ * @param array An input array.
+ * @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) {
+	if (n < 1) {
+		return [];
+	}
+	if (n === 1) {
+		return array;
+	}
+	var result = [];
+	for (var i = 0; i < array.length; i += n) {
+		var item = array[i];
+		if (item !== undefined) {
+			result.push(item);
+		}
+	}
+	return result;
+}

package/src/util/getRadiusAndStrokeWidthFromDot.js

@@ -0,0 +1,28 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/getRadiusAndStrokeWidthFromDot.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { svgPropertiesNoEventsFromUnknown } from './svgPropertiesNoEvents';
+export function getRadiusAndStrokeWidthFromDot(dot) {
+	var props = svgPropertiesNoEventsFromUnknown(dot);
+	var defaultR = 3;
+	var defaultStrokeWidth = 2;
+	if (props != null) {
+		var r = props.r,
+			strokeWidth = props.strokeWidth;
+		var realR = Number(r);
+		var 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

@@ -0,0 +1,96 @@
+// 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.
+/**
+ * Type guard to check if the pointer event is from an SVG element.
+ */
+function isSvgPointer(pointer) {
+	return 'getBBox' in pointer.currentTarget && typeof pointer.currentTarget.getBBox === 'function';
+}
+
+/**
+ * Computes relative element coordinates from mouse or touch event.
+ *
+ * The output coordinates are relative to the top-left corner of the active element (= currentTarget),
+ * where the top-left corner is (0, 0).
+ * Moving right, the x-coordinate increases, and moving down, the y-coordinate increases.
+ *
+ * The coordinates are rounded to the nearest integer and account for CSS transform scale.
+ * So element that's scaled will return the same coordinates as element that's not scaled.
+ *
+ * In other words: you zoom in or out, numbers stay the same.
+ *
+ * This function works with both HTML elements and SVG elements.
+ *
+ * It works with both Mouse and Touch events.
+ * For Touch events, it returns an array of coordinates, one for each touch point.
+ * For Mouse events, it returns a single coordinate object.
+ *
+ * @example
+ * ```tsx
+ * // In an HTML element event handler. Legend passes the native event as the 3rd argument.
+ * <Legend onMouseMove={(_data, _i, e) => {
+ *   // These coordinates are relative to the top-left corner of the Legend element
+ *   const { relativeX, relativeY } = getRelativeCoordinate(e);
+ *   console.log(`Mouse at Legend position: (${relativeX}, ${relativeY})`);
+ * }}>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // In an SVG element event handler. Area is an SVG element, and passes the event as second argument.
+ * <Area onMouseMove={(_, e) => {
+ *   const { relativeX, relativeY } = getRelativeCoordinate(e);
+ *   console.log(`Mouse at Area position: (${relativeX}, ${relativeY})`);
+ *   // Here you can call usePlotArea to convert to chart coordinates
+ * }}>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // In a chart root touch handler. Chart root passes the event as second argument.
+ * <LineChart onTouchMove={(_, e) => {
+ *   const touchPoints = getRelativeCoordinate(e);
+ *   touchPoints.forEach(({ relativeX, relativeY }, index) => {
+ *     console.log(`Touch point ${index} at LineChart position: (${relativeX}, ${relativeY})`);
+ *   });
+ * }}>
+ * ```
+ *
+ * @since 3.8
+ * @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) {
+	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();
+		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;
+		scaleX = element.offsetWidth > 0 ? rect.width / element.offsetWidth : 1;
+		scaleY = element.offsetHeight > 0 ? rect.height / element.offsetHeight : 1;
+	}
+	var getCoordinates = (clientX, clientY) => ({
+		/*
+		 * Here it's important to use:
+		 * - event.clientX and event.clientY to get the mouse position relative to the viewport, including scroll.
+		 * - pageX and pageY are not used because they are relative to the whole document, and ignore scroll.
+		 * - rect.left and rect.top are used to get the position of the chart relative to the viewport.
+		 * - offsetX and offsetY are not used because they are relative to the offset parent
+		 *  which may or may not be the same as the clientX and clientY, depending on the position of the chart in the DOM
+		 *  and surrounding element styles. CSS position: relative, absolute, fixed, will change the offset parent.
+		 * - scaleX and scaleY are necessary for when the chart element is scaled using CSS `transform: scale(N)`.
+		 */
+		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.js

@@ -0,0 +1,11 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/getSliced.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export function getSliced(arr, startIndex, endIndex) {
+	if (!Array.isArray(arr)) {
+		return arr;
+	}
+	if (arr && startIndex + endIndex !== 0) {
+		return arr.slice(startIndex, endIndex + 1);
+	}
+	return arr;
+}