vccs 0.1.0 → 0.2.0

package/dist/es/utils/createContext.mjs

@@ -1,12 +1,31 @@
-import { inject as e, provide as t } from "vue";
+import { inject, provide } from "vue";
 //#region src/utils/createContext.ts
-function n(n) {
-	let r = n, i = Symbol(r);
-	return [(t) => {
-		let r = e(i, t);
-		if (r === void 0) throw Error(`Injection \`${i.toString()}\` not found. Component must be used within ${`\`${n}\``}`);
-		return r;
-	}, (e) => (t(i, e), e)];
+/**
+* @param providerComponentName - The name(s) of the component(s) providing the context.
+*
+* There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
+*
+* @param contextName The description for injection key symbol.
+*/
+function createContext(contextName) {
+	const symbolDescription = contextName;
+	const injectionKey = Symbol(symbolDescription);
+	/**
+	* @param fallback The context value to return if the injection fails.
+	*
+	* @throws When context injection failed and no fallback is specified.
+	* This happens when the component injecting the context is not a child of the root component providing the context.
+	*/
+	const injectContext = (fallback) => {
+		const context = inject(injectionKey, fallback);
+		if (context === void 0) throw new Error(`Injection \`${injectionKey.toString()}\` not found. Component must be used within ${`\`${contextName}\``}`);
+		return context;
+	};
+	const provideContext = (contextValue) => {
+		provide(injectionKey, contextValue);
+		return contextValue;
+	};
+	return [injectContext, provideContext];
 }
 //#endregion
-export { n as createContext };
+export { createContext };

package/dist/es/utils/data-utils.mjs

@@ -1,12 +1,13 @@
-import { isNumber as e } from "./validate.mjs";
+import { isNumber } from "./validate.mjs";
 //#region src/utils/data-utils.ts
-var t = 0;
-function n(e) {
-	let n = ++t;
-	return `${e || ""}${n}`;
+var idCounter = 0;
+function uniqueId(prefix) {
+	const id = ++idCounter;
+	return `${prefix || ""}${id}`;
 }
-function r(t, n, r) {
-	return e(t) && e(n) ? t + r * (n - t) : n;
+function interpolate(start, end, t) {
+	if (isNumber(start) && isNumber(end)) return start + t * (end - start);
+	return end;
 }
 //#endregion
-export { r as interpolate, n as uniqueId };
+export { interpolate, uniqueId };

package/dist/es/utils/data.mjs

@@ -1,27 +1,41 @@
-import { isNan as e, isNumber as t, isPercent as n } from "./validate.mjs";
-import { get as r } from "lodash-es";
+import { isNan, isNumber, isPercent } from "./validate.mjs";
+import { get } from "lodash-es";
 //#region src/utils/data.ts
-function i(e) {
-	return e === 0 ? 0 : e > 0 ? 1 : -1;
+function mathSign(value) {
+	if (value === 0) return 0;
+	if (value > 0) return 1;
+	return -1;
 }
-function a(e) {
-	if (!Array.isArray(e)) return !1;
-	let t = e.length, n = {};
-	for (let r = 0; r < t; r++) if (!n[e[r]]) n[e[r]] = !0;
-	else return !0;
-	return !1;
+function hasDuplicate(ary) {
+	if (!Array.isArray(ary)) return false;
+	const len = ary.length;
+	const cache = {};
+	for (let i = 0; i < len; i++) if (!cache[ary[i]]) cache[ary[i]] = true;
+	else return true;
+	return false;
 }
-function o(r, i, a = 0, o = !1) {
-	if (!t(r) && typeof r != "string") return a;
-	let s;
-	if (n(r)) {
-		let e = r.indexOf("%");
-		s = i * parseFloat(r.slice(0, e)) / 100;
-	} else s = +r;
-	return e(s) && (s = a), o && s > i && (s = i), s;
+/**
+* Get percent value of a total value
+* @param {number|string} percent A percent
+* @param {number} totalValue     Total value
+* @param {number} defaultValue   The value returned when percent is undefined or invalid
+* @param {boolean} validate      If set to be true, the result will be validated
+* @return {number} value
+*/
+function getPercentValue(percent, totalValue, defaultValue = 0, validate = false) {
+	if (!isNumber(percent) && typeof percent !== "string") return defaultValue;
+	let value;
+	if (isPercent(percent)) {
+		const index = percent.indexOf("%");
+		value = totalValue * parseFloat(percent.slice(0, index)) / 100;
+	} else value = +percent;
+	if (isNan(value)) value = defaultValue;
+	if (validate && value > totalValue) value = totalValue;
+	return value;
 }
-function s(e, t, n) {
-	return !e || !e.length ? null : e.find((e) => e && (typeof t == "function" ? t(e) : r(e, t)) === n);
+function findEntryInArray(ary, specifiedKey, specifiedValue) {
+	if (!ary || !ary.length) return null;
+	return ary.find((entry) => entry && (typeof specifiedKey === "function" ? specifiedKey(entry) : get(entry, specifiedKey)) === specifiedValue);
 }
 //#endregion
-export { s as findEntryInArray, o as getPercentValue, a as hasDuplicate, i as mathSign };
+export { findEntryInArray, getPercentValue, hasDuplicate, mathSign };

package/dist/es/utils/events.mjs

@@ -1,5 +1,7 @@
-import e from "eventemitter3";
+import EventEmitter from "eventemitter3";
 //#region src/utils/events.ts
-var t = new e(), n = "recharts.syncEvent.tooltip", r = "recharts.syncEvent.brush";
+var eventCenter = new EventEmitter();
+var TOOLTIP_SYNC_EVENT = "recharts.syncEvent.tooltip";
+var BRUSH_SYNC_EVENT = "recharts.syncEvent.brush";
 //#endregion
-export { r as BRUSH_SYNC_EVENT, n as TOOLTIP_SYNC_EVENT, t as eventCenter };
+export { BRUSH_SYNC_EVENT, TOOLTIP_SYNC_EVENT, eventCenter };

package/dist/es/utils/getLinearRegression.mjs

@@ -1,17 +1,34 @@
 //#region src/utils/getLinearRegression.ts
-function e(e) {
-	let t = e.length, n = 0, r = 0, i = 0, a = 0, o = Infinity, s = -Infinity;
-	for (let c = 0; c < t; c++) {
-		let t = e[c]?.cx || 0, l = e[c]?.cy || 0;
-		n += t, r += l, i += t * l, a += t * t, o = Math.min(o, t), s = Math.max(s, t);
+/**
+* The least square linear regression
+* @param data The array of points
+* @returns The domain of x, and the parameter of linear function y = ax + b
+*/
+function getLinearRegression(data) {
+	const len = data.length;
+	let xsum = 0;
+	let ysum = 0;
+	let xysum = 0;
+	let xxsum = 0;
+	let xmin = Infinity;
+	let xmax = -Infinity;
+	for (let i = 0; i < len; i++) {
+		const xcurrent = data[i]?.cx || 0;
+		const ycurrent = data[i]?.cy || 0;
+		xsum += xcurrent;
+		ysum += ycurrent;
+		xysum += xcurrent * ycurrent;
+		xxsum += xcurrent * xcurrent;
+		xmin = Math.min(xmin, xcurrent);
+		xmax = Math.max(xmax, xcurrent);
 	}
-	let c = t * a === n * n ? 0 : (t * i - n * r) / (t * a - n * n);
+	const a = len * xxsum !== xsum * xsum ? (len * xysum - xsum * ysum) / (len * xxsum - xsum * xsum) : 0;
 	return {
-		xmin: o,
-		xmax: s,
-		a: c,
-		b: (r - c * n) / t
+		xmin,
+		xmax,
+		a,
+		b: (ysum - a * xsum) / len
 	};
 }
 //#endregion
-export { e as getLinearRegression };
+export { getLinearRegression };

package/dist/es/utils/grid.mjs

@@ -1,8 +1,23 @@
 //#region src/utils/grid.ts
-function e(e, t, n, r) {
-	if (r) return e.map((e) => e.coordinate);
-	let i, a, o = e.map((e) => (e.coordinate === t && (i = !0), e.coordinate === n && (a = !0), e.coordinate));
-	return i || o.push(t), a || o.push(n), o;
+/**
+* Calculate the Coordinates of grid
+* @param  {Array} ticks           The ticks in axis
+* @param {number} minValue        The minimum value of axis
+* @param {number} maxValue        The maximum value of axis
+* @param {boolean} syncWithTicks  Synchronize grid lines with ticks or not
+* @return {Array}                 Coordinates
+*/
+function getCoordinatesOfGrid(ticks, minValue, maxValue, syncWithTicks) {
+	if (syncWithTicks) return ticks.map((entry) => entry.coordinate);
+	let hasMin, hasMax;
+	const values = ticks.map((entry) => {
+		if (entry.coordinate === minValue) hasMin = true;
+		if (entry.coordinate === maxValue) hasMax = true;
+		return entry.coordinate;
+	});
+	if (!hasMin) values.push(minValue);
+	if (!hasMax) values.push(maxValue);
+	return values;
 }
 //#endregion
-export { e as getCoordinatesOfGrid };
+export { getCoordinatesOfGrid };

package/dist/es/utils/isDomainSpecifiedByUser.mjs

@@ -1,65 +1,116 @@
-import { isNumber as e, isWellBehavedNumber as t } from "./validate.mjs";
-import { MAX_VALUE_REG as n, MIN_VALUE_REG as r } from "./chart.mjs";
+import { isNumber, isWellBehavedNumber } from "./validate.mjs";
+import { MAX_VALUE_REG, MIN_VALUE_REG } from "./chart.mjs";
 //#region src/utils/isDomainSpecifiedByUser.ts
-function i(e) {
-	if (Array.isArray(e) && e.length === 2) {
-		let [n, r] = e;
-		if (t(n) && t(r)) return !0;
+function isWellFormedNumberDomain(v) {
+	if (Array.isArray(v) && v.length === 2) {
+		const [min, max] = v;
+		if (isWellBehavedNumber(min) && isWellBehavedNumber(max)) return true;
 	}
-	return !1;
+	return false;
 }
-function a(e, t, n) {
-	return n ? e : [Math.min(e[0], t[0]), Math.max(e[1], t[1])];
+function extendDomain(providedDomain, boundaryDomain, allowDataOverflow) {
+	if (allowDataOverflow) return providedDomain;
+	return [Math.min(providedDomain[0], boundaryDomain[0]), Math.max(providedDomain[1], boundaryDomain[1])];
 }
-function o(e, n) {
-	if (n && typeof e != "function" && Array.isArray(e) && e.length === 2) {
-		let [n, r] = e, a, o;
-		if (t(n)) a = n;
-		else if (typeof n == "function") return;
-		if (t(r)) o = r;
-		else if (typeof r == "function") return;
-		let s = [a, o];
-		if (i(s)) return s;
+/**
+* So Recharts allows users to provide their own domains,
+* but it also places some expectations on what the domain is.
+* We can improve on the typescript typing, but we also need a runtime test
+to observe that the user-provided domain is well-formed,
+* that is: an array with exactly two numbers.
+*
+* This function does not accept data as an argument.
+* This is to enable a performance optimization - if the domain is there,
+* and we know what it is without traversing all the data,
+* then we don't have to traverse all the data!
+*
+* If the user-provided domain is not well-formed,
+* this function will return undefined - in which case we should traverse the data to calculate the real domain.
+*
+* This function is for parsing the numerical domain only.
+*
+* @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+* @param allowDataOverflow boolean, provided by users. If true then the data domain wins
+*
+* @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+*/
+function numericalDomainSpecifiedWithoutRequiringData(userDomain, allowDataOverflow) {
+	if (!allowDataOverflow) return;
+	if (typeof userDomain === "function") return;
+	if (Array.isArray(userDomain) && userDomain.length === 2) {
+		const [providedMin, providedMax] = userDomain;
+		let finalMin, finalMax;
+		if (isWellBehavedNumber(providedMin)) finalMin = providedMin;
+		else if (typeof providedMin === "function") return;
+		if (isWellBehavedNumber(providedMax)) finalMax = providedMax;
+		else if (typeof providedMax === "function") return;
+		const candidate = [finalMin, finalMax];
+		if (isWellFormedNumberDomain(candidate)) return candidate;
 	}
 }
-function s(t, o, s) {
-	if (!(!s && o == null)) {
-		if (typeof t == "function" && o != null) try {
-			let e = t(o, s);
-			if (i(e)) return a(e, o, s);
+/**
+* So Recharts allows users to provide their own domains,
+* but it also places some expectations on what the domain is.
+* We can improve on the typescript typing, but we also need a runtime test
+* to observe that the user-provided domain is well-formed,
+* that is: an array with exactly two numbers.
+* If the user-provided domain is not well-formed,
+* this function will return undefined - in which case we should traverse the data to calculate the real domain.
+*
+* This function is for parsing the numerical domain only.
+*
+* You are probably thinking, why does domain need tick count?
+* Well it adjusts the domain based on where the "nice ticks" land, and nice ticks depend on the tick count.
+*
+* @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+* @param dataDomain calculated from data. Can be undefined, as an option for performance optimization
+* @param allowDataOverflow provided by users. If true then the data domain wins
+*
+* @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+*/
+function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverflow) {
+	if (!allowDataOverflow && dataDomain == null) return;
+	if (typeof userDomain === "function" && dataDomain != null) try {
+		const result = userDomain(dataDomain, allowDataOverflow);
+		if (isWellFormedNumberDomain(result)) return extendDomain(result, dataDomain, allowDataOverflow);
+	} catch {}
+	if (Array.isArray(userDomain) && userDomain.length === 2) {
+		const [providedMin, providedMax] = userDomain;
+		let finalMin, finalMax;
+		if (providedMin === "auto") {
+			if (dataDomain != null) finalMin = Math.min(...dataDomain);
+		} else if (isNumber(providedMin)) finalMin = providedMin;
+		else if (typeof providedMin === "function") try {
+			if (dataDomain != null) finalMin = providedMin(dataDomain?.[0]);
 		} catch {}
-		if (Array.isArray(t) && t.length === 2) {
-			let [c, l] = t, u, d;
-			if (c === "auto") o != null && (u = Math.min(...o));
-			else if (e(c)) u = c;
-			else if (typeof c == "function") try {
-				o != null && (u = c(o?.[0]));
-			} catch {}
-			else if (typeof c == "string" && r.test(c)) {
-				let e = r.exec(c);
-				if (e == null || o == null) u = void 0;
-				else {
-					let t = +e[1];
-					u = o[0] - t;
-				}
-			} else u = o?.[0];
-			if (l === "auto") o != null && (d = Math.max(...o));
-			else if (e(l)) d = l;
-			else if (typeof l == "function") try {
-				o != null && (d = l(o?.[1]));
-			} catch {}
-			else if (typeof l == "string" && n.test(l)) {
-				let e = n.exec(l);
-				if (e == null || o == null) d = void 0;
-				else {
-					let t = +e[1];
-					d = o[1] + t;
-				}
-			} else d = o?.[1];
-			let f = [u, d];
-			if (i(f)) return o == null ? f : a(f, o, s);
+		else if (typeof providedMin === "string" && MIN_VALUE_REG.test(providedMin)) {
+			const match = MIN_VALUE_REG.exec(providedMin);
+			if (match == null || dataDomain == null) finalMin = void 0;
+			else {
+				const value = +match[1];
+				finalMin = dataDomain[0] - value;
+			}
+		} else finalMin = dataDomain?.[0];
+		if (providedMax === "auto") {
+			if (dataDomain != null) finalMax = Math.max(...dataDomain);
+		} else if (isNumber(providedMax)) finalMax = providedMax;
+		else if (typeof providedMax === "function") try {
+			if (dataDomain != null) finalMax = providedMax(dataDomain?.[1]);
+		} catch {}
+		else if (typeof providedMax === "string" && MAX_VALUE_REG.test(providedMax)) {
+			const match = MAX_VALUE_REG.exec(providedMax);
+			if (match == null || dataDomain == null) finalMax = void 0;
+			else {
+				const value = +match[1];
+				finalMax = dataDomain[1] + value;
+			}
+		} else finalMax = dataDomain?.[1];
+		const candidate = [finalMin, finalMax];
+		if (isWellFormedNumberDomain(candidate)) {
+			if (dataDomain == null) return candidate;
+			return extendDomain(candidate, dataDomain, allowDataOverflow);
 		}
 	}
 }
 //#endregion
-export { i as isWellFormedNumberDomain, o as numericalDomainSpecifiedWithoutRequiringData, s as parseNumericalUserDomain };
+export { isWellFormedNumberDomain, numericalDomainSpecifiedWithoutRequiringData, parseNumericalUserDomain };

package/dist/es/utils/legend.mjs

@@ -1,18 +1,19 @@
-import { isNumber as e } from "./validate.mjs";
+import { isNumber } from "./validate.mjs";
 //#region src/utils/legend.ts
-function t(t, n, r) {
-	if (n && r) {
-		let { width: i, height: a } = r, { align: o, verticalAlign: s, layout: c } = n;
-		if ((c === "vertical" || c === "horizontal" && s === "middle") && o !== "center" && e(t[o])) return {
-			...t,
-			[o]: t[o] + (i || 0)
+function appendOffsetOfLegend(offset, legendSettings, legendSize) {
+	if (legendSettings && legendSize) {
+		const { width: boxWidth, height: boxHeight } = legendSize;
+		const { align, verticalAlign, layout } = legendSettings;
+		if ((layout === "vertical" || layout === "horizontal" && verticalAlign === "middle") && align !== "center" && isNumber(offset[align])) return {
+			...offset,
+			[align]: offset[align] + (boxWidth || 0)
 		};
-		if ((c === "horizontal" || c === "vertical" && o === "center") && s !== "middle" && e(t[s])) return {
-			...t,
-			[s]: t[s] + (a || 0)
+		if ((layout === "horizontal" || layout === "vertical" && align === "center") && verticalAlign !== "middle" && isNumber(offset[verticalAlign])) return {
+			...offset,
+			[verticalAlign]: offset[verticalAlign] + (boxHeight || 0)
 		};
 	}
-	return t;
+	return offset;
 }
 //#endregion
-export { t as appendOffsetOfLegend };
+export { appendOffsetOfLegend };

package/dist/es/utils/log.mjs

@@ -1,11 +1,14 @@
 //#region src/utils/log.ts
-var e = process.env.NODE_ENV !== "production";
-function t(t, n, ...r) {
-	if (e && typeof console < "u" && console.warn && (n === void 0 && console.warn("LogUtils requires an error message argument"), !t)) if (n === void 0) console.warn("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
-	else {
-		let e = 0;
-		console.warn(n.replace(/%s/g, () => r[e++]));
+var isDev = process.env.NODE_ENV !== "production";
+function warn(condition, format, ...args) {
+	if (isDev && typeof console !== "undefined" && console.warn) {
+		if (format === void 0) console.warn("LogUtils requires an error message argument");
+		if (!condition) if (format === void 0) console.warn("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
+		else {
+			let argIndex = 0;
+			console.warn(format.replace(/%s/g, () => args[argIndex++]));
+		}
 	}
 }
 //#endregion
-export { t as warn };
+export { warn };

package/dist/es/utils/payload/getUniqPayload.mjs

@@ -1,7 +1,9 @@
-import { uniqBy as e } from "es-toolkit/compat";
+import { uniqBy } from "es-toolkit/compat";
 //#region src/utils/payload/getUniqPayload.ts
-function t(t, n, r) {
-	return n === !0 ? e(t, r) : typeof n == "function" ? e(t, n) : t;
+function getUniqPayload(payload, option, defaultUniqBy) {
+	if (option === true) return uniqBy(payload, defaultUniqBy);
+	if (typeof option === "function") return uniqBy(payload, option);
+	return payload;
 }
 //#endregion
-export { t as getUniqPayload };
+export { getUniqPayload };

package/dist/es/utils/polar.mjs

@@ -1,52 +1,59 @@
 //#region src/utils/polar.ts
-var e = Math.PI / 180, t = (e) => e * 180 / Math.PI;
-function n(e, t) {
-	let { x: n, y: r } = e, { x: i, y: a } = t;
-	return Math.sqrt((n - i) ** 2 + (r - a) ** 2);
+var RADIAN = Math.PI / 180;
+var radianToDegree = (angleInRadian) => angleInRadian * 180 / Math.PI;
+function distanceBetweenPoints(point, anotherPoint) {
+	const { x: x1, y: y1 } = point;
+	const { x: x2, y: y2 } = anotherPoint;
+	return Math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2);
 }
-function r({ startAngle: e, endAngle: t }) {
-	let n = Math.floor(e / 360), r = Math.floor(t / 360), i = Math.min(n, r);
+function formatAngleOfSector({ startAngle, endAngle }) {
+	const startCnt = Math.floor(startAngle / 360);
+	const endCnt = Math.floor(endAngle / 360);
+	const min = Math.min(startCnt, endCnt);
 	return {
-		startAngle: e - i * 360,
-		endAngle: t - i * 360
+		startAngle: startAngle - min * 360,
+		endAngle: endAngle - min * 360
 	};
 }
-function i({ x: e, y: r }, { cx: i, cy: a }) {
-	let o = n({
-		x: e,
-		y: r
+function getAngleOfPoint({ x, y }, { cx, cy }) {
+	const radius = distanceBetweenPoints({
+		x,
+		y
 	}, {
-		x: i,
-		y: a
+		x: cx,
+		y: cy
 	});
-	if (o <= 0) return {
-		radius: o,
+	if (radius <= 0) return {
+		radius,
 		angle: 0
 	};
-	let s = (e - i) / o, c = Math.acos(s);
-	return r > a && (c = 2 * Math.PI - c), {
-		radius: o,
-		angle: t(c),
-		angleInRadian: c
+	const cos = (x - cx) / radius;
+	let angleInRadian = Math.acos(cos);
+	if (y > cy) angleInRadian = 2 * Math.PI - angleInRadian;
+	return {
+		radius,
+		angle: radianToDegree(angleInRadian),
+		angleInRadian
 	};
 }
-function a(e, { startAngle: t, endAngle: n }) {
-	let r = Math.floor(t / 360), i = Math.floor(n / 360);
-	return e + Math.min(r, i) * 360;
+function reverseFormatAngleOfSector(angle, { startAngle, endAngle }) {
+	const startCnt = Math.floor(startAngle / 360);
+	const endCnt = Math.floor(endAngle / 360);
+	return angle + Math.min(startCnt, endCnt) * 360;
 }
-function o(t, n, r, i) {
+function polarToCartesian(cx, cy, radius, angle) {
 	return {
-		x: t + Math.cos(-e * i) * r,
-		y: n + Math.sin(-e * i) * r
+		x: cx + Math.cos(-RADIAN * angle) * radius,
+		y: cy + Math.sin(-RADIAN * angle) * radius
 	};
 }
-function s(e, t, n = {
+function getMaxRadius(width, height, offset = {
 	top: 0,
 	right: 0,
 	bottom: 0,
 	left: 0
 }) {
-	return Math.min(Math.abs(e - (n.left || 0) - (n.right || 0)), Math.abs(t - (n.top || 0) - (n.bottom || 0))) / 2;
+	return Math.min(Math.abs(width - (offset.left || 0) - (offset.right || 0)), Math.abs(height - (offset.top || 0) - (offset.bottom || 0))) / 2;
 }
 //#endregion
-export { e as RADIAN, r as formatAngleOfSector, i as getAngleOfPoint, s as getMaxRadius, o as polarToCartesian, a as reverseFormatAngleOfSector };
+export { RADIAN, formatAngleOfSector, getAngleOfPoint, getMaxRadius, polarToCartesian, reverseFormatAngleOfSector };

package/dist/es/utils/props.mjs

@@ -1,14 +1,20 @@
 //#region src/utils/props.ts
-function e(e, t) {
-	let n = { ...e };
-	for (let [e, r] of Object.entries(t)) if (e in n) {
-		let t = n[e];
-		typeof t == "object" && t && "type" in t && (n[e] = {
-			...t,
-			default: r
-		});
+/**
+* 将 defaultProps 的属性值作为 props 的 default 属性
+* @param props - Vue 组件的 props 定义对象
+* @param defaultProps - 默认值对象
+* @returns 新的 Vue 组件 props 对象
+*/
+function applyDefaultProps(props, defaultProps) {
+	const newProps = { ...props };
+	for (const [key, defaultValue] of Object.entries(defaultProps)) if (key in newProps) {
+		const propDef = newProps[key];
+		if (typeof propDef === "object" && propDef !== null && "type" in propDef) newProps[key] = {
+			...propDef,
+			default: defaultValue
+		};
 	}
-	return n;
+	return newProps;
 }
 //#endregion
-export { e as applyDefaultProps };
+export { applyDefaultProps };

package/dist/es/utils/resolveDefaultProps.mjs

@@ -1,7 +1,26 @@
 //#region src/utils/resolveDefaultProps.ts
-function e(e, t) {
-	let n = { ...e }, r = t;
-	return Object.keys(t).reduce((e, t) => (e[t] === void 0 && r[t] !== void 0 && (e[t] = r[t]), e), n);
+/**
+* This function mimics the behavior of the `defaultProps` static property in React.
+* Functional components do not have a defaultProps property, so this function is useful to resolve default props.
+*
+* The common recommendation is to use ES6 destructuring with default values in the function signature,
+* but you need to be careful there and make sure you destructure all the individual properties
+* and not the whole object. See the test file for example.
+*
+* And because destructuring all properties one by one is a faff, and it's easy to miss one property,
+* this function exists.
+*
+* @param realProps - the props object passed to the component by the user
+* @param defaultProps - the default props object defined in the component by Recharts
+* @returns - the props object with all the default props resolved. All `undefined` values are replaced with the default value.
+*/
+function resolveDefaultProps(realProps, defaultProps) {
+	const resolvedProps = { ...realProps };
+	const dp = defaultProps;
+	return Object.keys(defaultProps).reduce((acc, key) => {
+		if (acc[key] === void 0 && dp[key] !== void 0) acc[key] = dp[key];
+		return acc;
+	}, resolvedProps);
 }
 //#endregion
-export { e as resolveDefaultProps };
+export { resolveDefaultProps };