@octanejs/recharts 0.1.0

package/src/util/DOMUtils.js

@@ -0,0 +1,180 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/DOMUtils.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 { Global } from './Global';
+import { LRUCache } from './LRUCache';
+var defaultConfig = {
+	cacheSize: 2000,
+	enableCache: true,
+};
+var currentConfig = _objectSpread({}, defaultConfig);
+var stringCache = new LRUCache(currentConfig.cacheSize);
+var SPAN_STYLE = {
+	position: 'absolute',
+	top: '-20000px',
+	left: 0,
+	padding: 0,
+	margin: 0,
+	border: 'none',
+	whiteSpace: 'pre',
+};
+var MEASUREMENT_SPAN_ID = 'recharts_measurement_span';
+function createCacheKey(text, style) {
+	// Simple string concatenation for better performance than JSON.stringify
+	var fontSize = style.fontSize || '';
+	var fontFamily = style.fontFamily || '';
+	var fontWeight = style.fontWeight || '';
+	var fontStyle = style.fontStyle || '';
+	var letterSpacing = style.letterSpacing || '';
+	var textTransform = style.textTransform || '';
+	return ''
+		.concat(text, '|')
+		.concat(fontSize, '|')
+		.concat(fontFamily, '|')
+		.concat(fontWeight, '|')
+		.concat(fontStyle, '|')
+		.concat(letterSpacing, '|')
+		.concat(textTransform);
+}
+
+/**
+ * Measure text using DOM (accurate but slower)
+ * @param text - The text to measure
+ * @param style - CSS style properties to apply
+ * @returns The size of the text
+ */
+var measureTextWithDOM = (text, style) => {
+	try {
+		var measurementSpan = document.getElementById(MEASUREMENT_SPAN_ID);
+		if (!measurementSpan) {
+			measurementSpan = document.createElement('span');
+			measurementSpan.setAttribute('id', MEASUREMENT_SPAN_ID);
+			measurementSpan.setAttribute('aria-hidden', 'true');
+			document.body.appendChild(measurementSpan);
+		}
+
+		// Apply styles directly without unnecessary object creation
+		Object.assign(measurementSpan.style, SPAN_STYLE, style);
+		measurementSpan.textContent = ''.concat(text);
+		var rect = measurementSpan.getBoundingClientRect();
+		return {
+			width: rect.width,
+			height: rect.height,
+		};
+	} catch (_unused) {
+		return {
+			width: 0,
+			height: 0,
+		};
+	}
+};
+export var getStringSize = function getStringSize(text) {
+	var style = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+	if (text === undefined || text === null || Global.isSsr) {
+		return {
+			width: 0,
+			height: 0,
+		};
+	}
+
+	// If caching is disabled, measure directly
+	if (!currentConfig.enableCache) {
+		return measureTextWithDOM(text, style);
+	}
+	var cacheKey = createCacheKey(text, style);
+	var cachedResult = stringCache.get(cacheKey);
+	if (cachedResult) {
+		return cachedResult;
+	}
+
+	// Measure using DOM
+	var result = measureTextWithDOM(text, style);
+
+	// Store in LRU cache
+	stringCache.set(cacheKey, result);
+	return result;
+};
+
+/**
+ * Configure text measurement behavior
+ * @param config - Partial configuration to apply
+ * @returns void
+ */
+export var configureTextMeasurement = (config) => {
+	var newConfig = _objectSpread(_objectSpread({}, currentConfig), config);
+	if (newConfig.cacheSize !== currentConfig.cacheSize) {
+		stringCache = new LRUCache(newConfig.cacheSize);
+	}
+	currentConfig = newConfig;
+};
+
+/**
+ * Get current text measurement configuration
+ * @returns Current configuration
+ */
+export var getTextMeasurementConfig = () => _objectSpread({}, currentConfig);
+
+/**
+ * Clear the string size cache. Useful for testing or memory management.
+ * @returns void
+ */
+export var clearStringCache = () => {
+	stringCache.clear();
+};
+
+/**
+ * Get cache statistics for debugging purposes.
+ * @returns Cache statistics including size and max size
+ */
+export var getStringCacheStats = () => ({
+	size: stringCache.size(),
+	maxSize: currentConfig.cacheSize,
+});

package/src/util/DataUtils.js

@@ -0,0 +1,199 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/DataUtils.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Sanctioned deviation: es-toolkit compat imports normalized to the ESM barrel
+// ('es-toolkit/compat') — the per-function subpaths are CJS-only and break
+// consumers that compile this binding from source (vite dev prebundle).
+import { get } from 'es-toolkit/compat';
+import { round } from './round';
+export var mathSign = (value) => {
+	if (value === 0) {
+		return 0;
+	}
+	if (value > 0) {
+		return 1;
+	}
+	return -1;
+};
+export var isNan = (value) => {
+	// eslint-disable-next-line eqeqeq
+	return typeof value == 'number' && value != +value;
+};
+
+/**
+ * Checks if the value is a percent string.
+ * A valid percent string must end with '%' and have at least one character before the '%'.
+ *
+ * @param {string | number | undefined} value The value to check
+ * @returns {boolean} true if the value is a percent string
+ */
+export var isPercent = (value) =>
+	typeof value === 'string' && value.length > 1 && value.indexOf('%') === value.length - 1;
+export var isNumber = (value) =>
+	(typeof value === 'number' || value instanceof Number) && !isNan(value);
+export var isNumOrStr = (value) => isNumber(value) || typeof value === 'string';
+var idCounter = 0;
+export var uniqueId = (prefix) => {
+	var id = ++idCounter;
+	return ''.concat(prefix || '').concat(id);
+};
+
+/**
+ * Calculates the numeric value represented by a percent string or number, based on a total value.
+ *
+ * - If `percent` is not a number or string, returns `defaultValue`.
+ * - If `percent` is a percent string but `totalValue` is null/undefined, returns `defaultValue`.
+ * - If the result is NaN, returns `defaultValue`.
+ * - If `validate` is true and the result exceeds `totalValue`, returns `totalValue`.
+ *
+ * @param percent - The percent value to convert. Can be a number (e.g. 25) or a string ending with '%' (e.g. '25%').
+ *                  If a string, it must end with '%' to be treated as a percent; otherwise, it is parsed as a number.
+ * @param totalValue - The total value to calculate the percent of. Required if `percent` is a percent string.
+ * @param defaultValue - The value returned if `percent` is undefined, invalid, or cannot be converted to a number.
+ * @param validate - If true, ensures the result does not exceed `totalValue` (when provided).
+ * @returns The calculated value, or `defaultValue` for invalid input.
+ */
+export var getPercentValue = function getPercentValue(percent, totalValue) {
+	var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+	var validate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+	if (!isNumber(percent) && typeof percent !== 'string') {
+		return defaultValue;
+	}
+	var value;
+	if (isPercent(percent)) {
+		if (totalValue == null) {
+			return defaultValue;
+		}
+		var index = percent.indexOf('%');
+		value = (totalValue * parseFloat(percent.slice(0, index))) / 100;
+	} else {
+		value = +percent;
+	}
+	if (isNan(value)) {
+		value = defaultValue;
+	}
+	if (validate && totalValue != null && value > totalValue) {
+		value = totalValue;
+	}
+	return value;
+};
+export var hasDuplicate = (ary) => {
+	if (!Array.isArray(ary)) {
+		return false;
+	}
+	var len = ary.length;
+	var cache = {};
+	for (var i = 0; i < len; i++) {
+		if (!cache[String(ary[i])]) {
+			cache[String(ary[i])] = true;
+		} else {
+			return true;
+		}
+	}
+	return false;
+};
+
+/**
+ * Function to interpolate between two numbers.
+ * If both start and end are numbers, it calculates the interpolated value based on the parameter animationElapsedTime (0 to 1).
+ * If either start or end is not a number, it returns the end value directly.
+ *
+ * You will typically use this function when implementing custom animations.
+ *
+ * `animationElapsedTime` can be outside the (0, 1) range, depending on easing.
+ *
+ * This one interpolates only numbers;
+ * if you want to interpolate colors or strings then perhaps see {@link https://d3js.org/d3-interpolate d3-interpolate}.
+ * @param start the starting value (when animationElapsedTime=0)
+ * @param end the final value (when animationElapsedTime=1)
+ * @param animationElapsedTime interpolation factor; values in [0, 1] interpolate between start and end, and values outside that range extrapolate
+ *
+ * @since 3.9
+ */
+
+export function interpolate(start, end, animationElapsedTime) {
+	if (isNumber(start) && isNumber(end)) {
+		return round(start + animationElapsedTime * (end - start));
+	}
+	return end;
+}
+export function findEntryInArray(ary, specifiedKey, specifiedValue) {
+	if (!ary || !ary.length) {
+		return undefined;
+	}
+	return ary.find(
+		(entry) =>
+			entry &&
+			(typeof specifiedKey === 'function' ? specifiedKey(entry) : get(entry, specifiedKey)) ===
+				specifiedValue,
+	);
+}
+/**
+ * The least square linear regression
+ * @param {Array} data The array of points
+ * @returns {Object} The domain of x, and the parameter of linear function
+ */
+export var getLinearRegression = (data) => {
+	var len = data.length;
+	var xsum = 0;
+	var ysum = 0;
+	var xysum = 0;
+	var xxsum = 0;
+	var xmin = Infinity;
+	var xmax = -Infinity;
+	var xcurrent = 0;
+	var ycurrent = 0;
+	for (var i = 0; i < len; i++) {
+		var _data$i, _data$i2;
+		xcurrent = ((_data$i = data[i]) === null || _data$i === void 0 ? void 0 : _data$i.cx) || 0;
+		ycurrent = ((_data$i2 = data[i]) === null || _data$i2 === void 0 ? void 0 : _data$i2.cy) || 0;
+		xsum += xcurrent;
+		ysum += ycurrent;
+		xysum += xcurrent * ycurrent;
+		xxsum += xcurrent * xcurrent;
+		xmin = Math.min(xmin, xcurrent);
+		xmax = Math.max(xmax, xcurrent);
+	}
+	var a =
+		len * xxsum !== xsum * xsum ? (len * xysum - xsum * ysum) / (len * xxsum - xsum * xsum) : 0;
+	return {
+		xmin,
+		xmax,
+		a,
+		b: (ysum - a * xsum) / len,
+	};
+};
+/**
+ * Checks if the value is null or undefined
+ * @param value The value to check
+ * @returns true if the value is null or undefined
+ */
+export var isNullish = (value) => {
+	return value === null || typeof value === 'undefined';
+};
+
+/**
+ * Uppercase the first letter of a string
+ * @param {string} value The string to uppercase
+ * @returns {string} The uppercased string
+ */
+export var upperFirst = (value) => {
+	if (isNullish(value)) {
+		return value;
+	}
+	return ''.concat(value.charAt(0).toUpperCase()).concat(value.slice(1));
+};
+
+/**
+ * Checks if the value is not null nor undefined.
+ * @param value The value to check
+ * @returns true if the value is not null nor undefined
+ */
+export function isNotNil(value) {
+	return value != null;
+}
+
+/**
+ * No-operation function that does nothing.
+ * Useful as a placeholder or default callback function.
+ */
+export function noop() {}

package/src/util/Events.js

@@ -0,0 +1,7 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/Events.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import EventEmitter from 'eventemitter3';
+var eventCenter = new EventEmitter();
+export { eventCenter };
+export var TOOLTIP_SYNC_EVENT = 'recharts.syncEvent.tooltip';
+export var BRUSH_SYNC_EVENT = 'recharts.syncEvent.brush';

package/src/util/Global.js

@@ -0,0 +1,13 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/Global.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+var parseIsSsrByDefault = () =>
+	!(
+		typeof window !== 'undefined' &&
+		window.document &&
+		Boolean(window.document.createElement) &&
+		window.setTimeout
+	);
+export var Global = {
+	devToolsEnabled: true,
+	isSsr: parseIsSsrByDefault(),
+};

package/src/util/LRUCache.js

@@ -0,0 +1,58 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/LRUCache.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+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);
+}
+/**
+ * Simple LRU (Least Recently Used) cache implementation
+ */
+export class LRUCache {
+	constructor(maxSize) {
+		_defineProperty(this, 'cache', new Map());
+		this.maxSize = maxSize;
+	}
+	get(key) {
+		var value = this.cache.get(key);
+		if (value !== undefined) {
+			this.cache.delete(key);
+			this.cache.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (this.cache.has(key)) {
+			this.cache.delete(key);
+		} else if (this.cache.size >= this.maxSize) {
+			var firstKey = this.cache.keys().next().value;
+			if (firstKey != null) {
+				this.cache.delete(firstKey);
+			}
+		}
+		this.cache.set(key, value);
+	}
+	clear() {
+		this.cache.clear();
+	}
+	size() {
+		return this.cache.size;
+	}
+}

package/src/util/LogUtils.js

@@ -0,0 +1,29 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/LogUtils.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+/* eslint no-console: 0 */
+var isDev = true;
+export var warn = function warn(condition, format) {
+	for (
+		var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2;
+		_key < _len;
+		_key++
+	) {
+		args[_key - 2] = arguments[_key];
+	}
+	if (isDev && typeof console !== 'undefined' && console.warn) {
+		if (format === undefined) {
+			console.warn('LogUtils requires an error message argument');
+		}
+		if (!condition) {
+			if (format === undefined) {
+				console.warn(
+					'Minified exception occurred; use the non-minified dev environment ' +
+						'for the full error message and additional helpful warnings.',
+				);
+			} else {
+				var argIndex = 0;
+				console.warn(format.replace(/%s/g, () => args[argIndex++]));
+			}
+		}
+	}
+};

package/src/util/PolarUtils.js

@@ -0,0 +1,190 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/PolarUtils.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);
+}
+export var RADIAN = Math.PI / 180;
+export var degreeToRadian = (angle) => (angle * Math.PI) / 180;
+export var radianToDegree = (angleInRadian) => (angleInRadian * 180) / Math.PI;
+export var polarToCartesian = (cx, cy, radius, angle) => ({
+	x: cx + Math.cos(-RADIAN * angle) * radius,
+	y: cy + Math.sin(-RADIAN * angle) * radius,
+});
+export var getMaxRadius = function getMaxRadius(width, height) {
+	var offset =
+		arguments.length > 2 && arguments[2] !== undefined
+			? arguments[2]
+			: {
+					top: 0,
+					right: 0,
+					bottom: 0,
+					left: 0,
+					width: 0,
+					height: 0,
+					brushBottom: 0,
+				};
+	return (
+		Math.min(
+			Math.abs(width - (offset.left || 0) - (offset.right || 0)),
+			Math.abs(height - (offset.top || 0) - (offset.bottom || 0)),
+		) / 2
+	);
+};
+var distanceBetweenPoints = (point, anotherPoint) => {
+	var x1 = point.x,
+		y1 = point.y;
+	var x2 = anotherPoint.x,
+		y2 = anotherPoint.y;
+	return Math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2);
+};
+var getAngleOfPoint = (_ref, _ref2) => {
+	var x = _ref.x,
+		y = _ref.y;
+	var cx = _ref2.cx,
+		cy = _ref2.cy;
+	var radius = distanceBetweenPoints(
+		{
+			x,
+			y,
+		},
+		{
+			x: cx,
+			y: cy,
+		},
+	);
+	if (radius <= 0) {
+		return {
+			radius,
+			angle: 0,
+		};
+	}
+	var cos = (x - cx) / radius;
+	var angleInRadian = Math.acos(cos);
+	if (y > cy) {
+		angleInRadian = 2 * Math.PI - angleInRadian;
+	}
+	return {
+		radius,
+		angle: radianToDegree(angleInRadian),
+		angleInRadian,
+	};
+};
+var formatAngleOfSector = (_ref3) => {
+	var startAngle = _ref3.startAngle,
+		endAngle = _ref3.endAngle;
+	var startCnt = Math.floor(startAngle / 360);
+	var endCnt = Math.floor(endAngle / 360);
+	var min = Math.min(startCnt, endCnt);
+	return {
+		startAngle: startAngle - min * 360,
+		endAngle: endAngle - min * 360,
+	};
+};
+var reverseFormatAngleOfSector = (angle, _ref4) => {
+	var startAngle = _ref4.startAngle,
+		endAngle = _ref4.endAngle;
+	var startCnt = Math.floor(startAngle / 360);
+	var endCnt = Math.floor(endAngle / 360);
+	var min = Math.min(startCnt, endCnt);
+	return angle + min * 360;
+};
+export var inRangeOfSector = (_ref5, viewBox) => {
+	var x = _ref5.relativeX,
+		y = _ref5.relativeY;
+	var _getAngleOfPoint = getAngleOfPoint(
+			{
+				x,
+				y,
+			},
+			viewBox,
+		),
+		radius = _getAngleOfPoint.radius,
+		angle = _getAngleOfPoint.angle;
+	var innerRadius = viewBox.innerRadius,
+		outerRadius = viewBox.outerRadius;
+	if (radius < innerRadius || radius > outerRadius) {
+		return null;
+	}
+	if (radius === 0) {
+		return null;
+	}
+	var _formatAngleOfSector = formatAngleOfSector(viewBox),
+		startAngle = _formatAngleOfSector.startAngle,
+		endAngle = _formatAngleOfSector.endAngle;
+	var formatAngle = angle;
+	var inRange;
+	if (startAngle <= endAngle) {
+		while (formatAngle > endAngle) {
+			formatAngle -= 360;
+		}
+		while (formatAngle < startAngle) {
+			formatAngle += 360;
+		}
+		inRange = formatAngle >= startAngle && formatAngle <= endAngle;
+	} else {
+		while (formatAngle > startAngle) {
+			formatAngle -= 360;
+		}
+		while (formatAngle < endAngle) {
+			formatAngle += 360;
+		}
+		inRange = formatAngle >= endAngle && formatAngle <= startAngle;
+	}
+	if (inRange) {
+		return _objectSpread(
+			_objectSpread({}, viewBox),
+			{},
+			{
+				radius,
+				angle: reverseFormatAngleOfSector(formatAngle, viewBox),
+			},
+		);
+	}
+	return null;
+};