vccs 0.1.0 → 0.3.0

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 };

package/dist/es/utils/scale/getNiceTickValues.mjs

@@ -1,59 +1,137 @@
-import { compose as e, map as t, memoize as n, range as r, reverse as i } from "./utils/utils.mjs";
-import { getDigitCount as a, rangeStep as o } from "./utils/arithmetic.mjs";
-import s from "decimal.js-light";
+import { compose, map, memoize, range, reverse } from "./utils/utils.mjs";
+import { getDigitCount, rangeStep } from "./utils/arithmetic.mjs";
+import Decimal from "decimal.js-light";
 //#region src/utils/scale/getNiceTickValues.ts
-function c([e, t]) {
-	let [n, r] = [e, t];
-	return e > t && ([n, r] = [t, e]), [n, r];
+/**
+* Calculate a interval of a minimum value and a maximum value
+*
+* @param  {number} min       The minimum value
+* @param  {number} max       The maximum value
+* @return {Array} An interval
+*/
+function getValidInterval([min, max]) {
+	let [validMin, validMax] = [min, max];
+	if (min > max) [validMin, validMax] = [max, min];
+	return [validMin, validMax];
 }
-function l(e, t, n) {
-	if (e.lte(0)) return new s(0);
-	let r = a(e.toNumber()), i = new s(10).pow(r), o = e.div(i), c = r === 1 ? .1 : .05, l = new s(Math.ceil(o.div(c).toNumber())).add(n).mul(c).mul(i);
-	return t ? new s(l.toNumber()) : new s(Math.ceil(l.toNumber()));
+/**
+* Calculate the step which is easy to understand between ticks, like 10, 20, 25
+*
+* @param  {Decimal} roughStep        The rough step calculated by dividing the
+* difference by the tickCount
+* @param  {boolean} allowDecimals    Allow the ticks to be decimals or not
+* @param  {Integer} correctionFactor A correction factor
+* @return {Decimal} The step which is easy to understand between two ticks
+*/
+function getFormatStep(roughStep, allowDecimals, correctionFactor) {
+	if (roughStep.lte(0)) return new Decimal(0);
+	const digitCount = getDigitCount(roughStep.toNumber());
+	const digitCountValue = new Decimal(10).pow(digitCount);
+	const stepRatio = roughStep.div(digitCountValue);
+	const stepRatioScale = digitCount !== 1 ? .05 : .1;
+	const formatStep = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber())).add(correctionFactor).mul(stepRatioScale).mul(digitCountValue);
+	return allowDecimals ? new Decimal(formatStep.toNumber()) : new Decimal(Math.ceil(formatStep.toNumber()));
 }
-function u(n, i, o) {
-	let c = new s(1), l = new s(n);
-	if (!l.isint() && o) {
-		let e = Math.abs(n);
-		e < 1 ? (c = new s(10).pow(a(n) - 1), l = new s(Math.floor(l.div(c).toNumber())).mul(c)) : e > 1 && (l = new s(Math.floor(n)));
-	} else n === 0 ? l = new s(Math.floor((i - 1) / 2)) : o || (l = new s(Math.floor(n)));
-	let u = Math.floor((i - 1) / 2);
-	return e(t((e) => l.add(new s(e - u).mul(c)).toNumber()), r)(0, i);
+/**
+* calculate the ticks when the minimum value equals to the maximum value
+*
+* @param  value         The minimum value which is also the maximum value
+* @param  tickCount     The count of ticks
+* @param  allowDecimals Allow the ticks to be decimals or not
+* @return array of ticks
+*/
+function getTickOfSingleValue(value, tickCount, allowDecimals) {
+	let step = new Decimal(1);
+	let middle = new Decimal(value);
+	if (!middle.isint() && allowDecimals) {
+		const absVal = Math.abs(value);
+		if (absVal < 1) {
+			step = new Decimal(10).pow(getDigitCount(value) - 1);
+			middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step);
+		} else if (absVal > 1) middle = new Decimal(Math.floor(value));
+	} else if (value === 0) middle = new Decimal(Math.floor((tickCount - 1) / 2));
+	else if (!allowDecimals) middle = new Decimal(Math.floor(value));
+	const middleIndex = Math.floor((tickCount - 1) / 2);
+	return compose(map((n) => middle.add(new Decimal(n - middleIndex).mul(step)).toNumber()), range)(0, tickCount);
 }
-function d(e, t, n, r, i = 0) {
-	if (!Number.isFinite((t - e) / (n - 1))) return {
-		step: new s(0),
-		tickMin: new s(0),
-		tickMax: new s(0)
+/**
+* Calculate the step
+*
+* @param  {number}  min              The minimum value of an interval
+* @param  {number}  max              The maximum value of an interval
+* @param  {Integer} tickCount        The count of ticks
+* @param  {boolean} allowDecimals    Allow the ticks to be decimals or not
+* @param  {number}  correctionFactor A correction factor
+* @return {object}  The step, minimum value of ticks, maximum value of ticks
+*/
+function calculateStep(min, max, tickCount, allowDecimals, correctionFactor = 0) {
+	if (!Number.isFinite((max - min) / (tickCount - 1))) return {
+		step: new Decimal(0),
+		tickMin: new Decimal(0),
+		tickMax: new Decimal(0)
+	};
+	const step = getFormatStep(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor);
+	let middle;
+	if (min <= 0 && max >= 0) middle = new Decimal(0);
+	else {
+		middle = new Decimal(min).add(max).div(2);
+		middle = middle.sub(new Decimal(middle).mod(step));
+	}
+	let belowCount = Math.ceil(middle.sub(min).div(step).toNumber());
+	let upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());
+	const scaleCount = belowCount + upCount + 1;
+	if (scaleCount > tickCount) return calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1);
+	if (scaleCount < tickCount) {
+		upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount;
+		belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount);
+	}
+	return {
+		step,
+		tickMin: middle.sub(new Decimal(belowCount).mul(step)),
+		tickMax: middle.add(new Decimal(upCount).mul(step))
 	};
-	let a = l(new s(t).sub(e).div(n - 1), r, i), o;
-	e <= 0 && t >= 0 ? o = new s(0) : (o = new s(e).add(t).div(2), o = o.sub(new s(o).mod(a)));
-	let c = Math.ceil(o.sub(e).div(a).toNumber()), u = Math.ceil(new s(t).sub(o).div(a).toNumber()), f = c + u + 1;
-	return f > n ? d(e, t, n, r, i + 1) : (f < n && (u = t > 0 ? u + (n - f) : u, c = t > 0 ? c : c + (n - f)), {
-		step: a,
-		tickMin: o.sub(new s(c).mul(a)),
-		tickMax: o.add(new s(u).mul(a))
-	});
 }
-function f([e, t], n = 6, a = !0) {
-	if (!Number.isFinite(e) || !Number.isFinite(t)) return [];
-	let l = Math.max(n, 2), [f, p] = c([e, t]);
-	if (f === -Infinity || p === Infinity) {
-		let a = p === Infinity ? [f, ...r(0, n - 1).map(() => Infinity)] : [...r(0, n - 1).map(() => -Infinity), p];
-		return e > t ? i(a) : a;
+/**
+* Calculate the ticks of an interval, the count of ticks will be guaranteed
+*
+* @param  {number}  min, max      min: The minimum value, max: The maximum value
+* @param  {Integer} tickCount     The count of ticks
+* @param  {boolean} allowDecimals Allow the ticks to be decimals or not
+* @return {Array}   ticks
+*/
+function getNiceTickValuesFn([min, max], tickCount = 6, allowDecimals = true) {
+	if (!Number.isFinite(min) || !Number.isFinite(max)) return [];
+	const count = Math.max(tickCount, 2);
+	const [cormin, cormax] = getValidInterval([min, max]);
+	if (cormin === -Infinity || cormax === Infinity) {
+		const values = cormax === Infinity ? [cormin, ...range(0, tickCount - 1).map(() => Infinity)] : [...range(0, tickCount - 1).map(() => -Infinity), cormax];
+		return min > max ? reverse(values) : values;
 	}
-	if (f === p) return u(f, n, a);
-	let { step: m, tickMin: h, tickMax: g } = d(f, p, l, a, 0), _ = o(h, g.add(new s(.1).mul(m)), m);
-	return e > t ? i(_) : _;
+	if (cormin === cormax) return getTickOfSingleValue(cormin, tickCount, allowDecimals);
+	const { step, tickMin, tickMax } = calculateStep(cormin, cormax, count, allowDecimals, 0);
+	const values = rangeStep(tickMin, tickMax.add(new Decimal(.1).mul(step)), step);
+	return min > max ? reverse(values) : values;
 }
-function p([e, t], n, r = !0) {
-	if (!Number.isFinite(e) || !Number.isFinite(t)) return [];
-	let [a, u] = c([e, t]);
-	if (a === -Infinity || u === Infinity) return [e, t];
-	if (a === u) return [a];
-	let d = Math.max(n, 2), f = l(new s(u).sub(a).div(d - 1), r, 0), p = [...o(new s(a), new s(u).sub(new s(.99).mul(f)), f), u];
-	return e > t ? i(p) : p;
+/**
+* Calculate the ticks of an interval, the count of ticks won't be guraranteed,
+* but the domain will be guaranteed
+*
+* @param  {number}  min, max      min: The minimum value, max: The maximum value
+* @param  {Integer} tickCount     The count of ticks
+* @param  {boolean} allowDecimals Allow the ticks to be decimals or not
+* @return {Array}   ticks
+*/
+function getTickValuesFixedDomainFn([min, max], tickCount, allowDecimals = true) {
+	if (!Number.isFinite(min) || !Number.isFinite(max)) return [];
+	const [cormin, cormax] = getValidInterval([min, max]);
+	if (cormin === -Infinity || cormax === Infinity) return [min, max];
+	if (cormin === cormax) return [cormin];
+	const count = Math.max(tickCount, 2);
+	const step = getFormatStep(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
+	const values = [...rangeStep(new Decimal(cormin), new Decimal(cormax).sub(new Decimal(.99).mul(step)), step), cormax];
+	return min > max ? reverse(values) : values;
 }
-var m = n(f), h = n(p);
+var getNiceTickValues = memoize(getNiceTickValuesFn);
+var getTickValuesFixedDomain = memoize(getTickValuesFixedDomainFn);
 //#endregion
-export { m as getNiceTickValues, h as getTickValuesFixedDomain };
+export { getNiceTickValues, getTickValuesFixedDomain };

package/dist/es/utils/scale/utils/arithmetic.mjs

@@ -1,24 +1,54 @@
-import { curry as e } from "./utils.mjs";
-import t from "decimal.js-light";
+import { curry } from "./utils.mjs";
+import Decimal from "decimal.js-light";
 //#region src/utils/scale/utils/arithmetic.ts
-function n(e) {
-	let n;
-	return n = e === 0 ? 1 : Math.floor(new t(e).abs().log(10).toNumber()) + 1, n;
+/**
+* 获取数值的位数
+* 其中绝对值属于区间[0.1, 1)， 得到的值为0
+* 绝对值属于区间[0.01, 0.1)，得到的位数为 -1
+* 绝对值属于区间[0.001, 0.01)，得到的位数为 -2
+*
+* @param  {number} value 数值
+* @return {Integer} 位数
+*/
+function getDigitCount(value) {
+	let result;
+	if (value === 0) result = 1;
+	else result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;
+	return result;
 }
-function r(e, n, r) {
-	let i = new t(e), a = 0, o = [];
-	for (; i.lt(n) && a < 1e5;) o.push(i.toNumber()), i = i.add(r), a++;
-	return o;
+/**
+* 按照固定的步长获取[start, end)这个区间的数据
+* 并且需要处理js计算精度的问题
+*
+* @param  {Decimal} start 起点
+* @param  {Decimal} end   终点，不包含该值
+* @param  {Decimal} step  步长
+* @return {Array}         若干数值
+*/
+function rangeStep(start, end, step) {
+	let num = new Decimal(start);
+	let i = 0;
+	const result = [];
+	while (num.lt(end) && i < 1e5) {
+		result.push(num.toNumber());
+		num = num.add(step);
+		i++;
+	}
+	return result;
 }
-e((e, t, n) => {
-	let r = +e;
-	return r + n * (+t - r);
-}), e((e, t, n) => {
-	let r = t - +e;
-	return r ||= Infinity, (n - e) / r;
-}), e((e, t, n) => {
-	let r = t - +e;
-	return r ||= Infinity, Math.max(0, Math.min(1, (n - e) / r));
+curry((a, b, t) => {
+	const newA = +a;
+	return newA + t * (+b - newA);
+});
+curry((a, b, x) => {
+	let diff = b - +a;
+	diff = diff || Infinity;
+	return (x - a) / diff;
+});
+curry((a, b, x) => {
+	let diff = b - +a;
+	diff = diff || Infinity;
+	return Math.max(0, Math.min(1, (x - a) / diff));
 });
 //#endregion
-export { n as getDigitCount, r as rangeStep };
+export { getDigitCount, rangeStep };

package/dist/es/utils/scale/utils/utils.mjs

@@ -1,34 +1,53 @@
 //#region src/utils/scale/utils/utils.ts
-var e = (e) => e, t = { "@@functional/placeholder": !0 }, n = (e) => e === t;
-function r(e) {
-	return function t(...r) {
-		return r.length === 0 || r.length === 1 && n(r[0]) ? t : e(...r);
+var identity = (i) => i;
+var PLACE_HOLDER = { "@@functional/placeholder": true };
+var isPlaceHolder = (val) => val === PLACE_HOLDER;
+function curry0(fn) {
+	return function _curried(...args) {
+		if (args.length === 0 || args.length === 1 && isPlaceHolder(args[0])) return _curried;
+		return fn(...args);
 	};
 }
-function i(e, a) {
-	return e === 1 ? a : r((...o) => {
-		let s = o.filter((e) => e !== t).length;
-		return s >= e ? a(...o) : i(e - s, r((...e) => a(...o.map((t) => n(t) ? e.shift() : t), ...e)));
+function curryN(n, fn) {
+	if (n === 1) return fn;
+	return curry0((...args) => {
+		const argsLength = args.filter((arg) => arg !== PLACE_HOLDER).length;
+		if (argsLength >= n) return fn(...args);
+		return curryN(n - argsLength, curry0((...restArgs) => {
+			return fn(...args.map((arg) => isPlaceHolder(arg) ? restArgs.shift() : arg), ...restArgs);
+		}));
 	});
 }
-var a = (e) => i(e.length, e);
-function o(e, t) {
-	let n = [];
-	for (let r = e; r < t; ++r) n[r - e] = r;
-	return n;
+var curry = (fn) => curryN(fn.length, fn);
+function range(begin, end) {
+	const arr = [];
+	for (let i = begin; i < end; ++i) arr[i - begin] = i;
+	return arr;
 }
-var s = a((e, t) => Array.isArray(t) ? t.map(e) : Object.keys(t).map((e) => t[e]).map(e));
-function c(...t) {
-	if (!t.length) return e;
-	let n = t.reverse(), r = n[0], i = n.slice(1);
-	return (...e) => i.reduce((e, t) => t(e), r(...e));
+var map = curry((fn, arr) => {
+	if (Array.isArray(arr)) return arr.map(fn);
+	return Object.keys(arr).map((key) => arr[key]).map(fn);
+});
+function compose(...args) {
+	if (!args.length) return identity;
+	const fns = args.reverse();
+	const firstFn = fns[0];
+	const tailsFn = fns.slice(1);
+	return (...composeArgs) => tailsFn.reduce((res, fn) => fn(res), firstFn(...composeArgs));
 }
-function l(e) {
-	return Array.isArray(e) ? e.reverse() : e.split("").reverse().join("");
+function reverse(arr) {
+	if (Array.isArray(arr)) return arr.reverse();
+	return arr.split("").reverse().join("");
 }
-function u(e) {
-	let t = null, n = null;
-	return ((...r) => t && r.every((e, n) => e === t?.[n]) ? n : (t = r, n = e(...r), n));
+function memoize(fn) {
+	let lastArgs = null;
+	let lastResult = null;
+	return ((...args) => {
+		if (lastArgs && args.every((val, i) => val === lastArgs?.[i])) return lastResult;
+		lastArgs = args;
+		lastResult = fn(...args);
+		return lastResult;
+	});
 }
 //#endregion
-export { c as compose, a as curry, s as map, u as memoize, o as range, l as reverse };
+export { compose, curry, map, memoize, range, reverse };

package/dist/es/utils/scale.mjs

@@ -0,0 +1,46 @@
+import { isWellBehavedNumber } from "./validate.mjs";
+//#region src/utils/scale.ts
+/**
+* Convert a data value to pixel coordinate using a D3 scale.
+* Automatically centers on band-scale categories by adding half the bandwidth.
+*/
+function scaleCoord(scale, value) {
+	const coord = scale(value);
+	if (!isWellBehavedNumber(coord)) return void 0;
+	return coord + (scale.bandwidth?.() ?? 0) / 2;
+}
+/**
+* Convert a data value to pixel coordinate for range boundaries.
+* `start` returns the left/top edge; `end` returns the right/bottom edge (adding full bandwidth).
+*/
+function scaleValue(scale, value, position) {
+	const coord = scale(value);
+	if (!isWellBehavedNumber(coord)) return void 0;
+	const bandwidth = scale.bandwidth?.() ?? 0;
+	return position === "start" ? coord : coord + bandwidth;
+}
+/**
+* Check whether a pixel coordinate falls within the scale's output range.
+*/
+function isInRange(scale, coord) {
+	const r = scale.range();
+	const min = Math.min(r[0], r[1]);
+	const max = Math.max(r[0], r[1]);
+	return coord >= min && coord <= max;
+}
+/**
+* Get the minimum value of a scale's range.
+*/
+function rangeMin(scale) {
+	const r = scale.range();
+	return Math.min(r[0], r[1]);
+}
+/**
+* Get the maximum value of a scale's range.
+*/
+function rangeMax(scale) {
+	const r = scale.range();
+	return Math.max(r[0], r[1]);
+}
+//#endregion
+export { isInRange, rangeMax, rangeMin, scaleCoord, scaleValue };

package/dist/es/utils/style.mjs

@@ -1,19 +1,30 @@
-import { isNumber as e } from "./validate.mjs";
+import { isNumber } from "./validate.mjs";
 //#region src/utils/style.ts
-function t(t) {
-	if (t !== void 0) return e(t) ? `${t}px` : t;
+/**
+* Converts a style value to a string with 'px' if it's a number
+* @param value The style value to convert
+* @returns The converted style value
+*/
+function toPx(value) {
+	if (value === void 0) return void 0;
+	return isNumber(value) ? `${value}px` : value;
 }
-function n(e = {}) {
-	let { height: n, width: r, minHeight: i, maxHeight: a, minWidth: o, maxWidth: s, ...c } = e;
+/**
+* Converts style object values to use 'px' for numeric height/width values
+* @param style The style object to convert
+* @returns A new style object with converted values
+*/
+function normalizeStyle(style = {}) {
+	const { height, width, minHeight, maxHeight, minWidth, maxWidth, ...rest } = style;
 	return {
-		height: t(n),
-		width: t(r),
-		minHeight: t(i),
-		maxHeight: t(a),
-		minWidth: t(o),
-		maxWidth: t(s),
-		...c
+		height: toPx(height),
+		width: toPx(width),
+		minHeight: toPx(minHeight),
+		maxHeight: toPx(maxHeight),
+		minWidth: toPx(minWidth),
+		maxWidth: toPx(maxWidth),
+		...rest
 	};
 }
 //#endregion
-export { n as normalizeStyle };
+export { normalizeStyle };

package/dist/es/utils/tick.mjs

@@ -1,31 +1,42 @@
-import { getAngledRectangleWidth as e } from "./cartesian.mjs";
+import { getAngledRectangleWidth } from "./cartesian.mjs";
 //#region src/utils/tick.ts
-function t(e, t) {
-	return n(e, t + 1);
+function getNumberIntervalTicks(ticks, interval) {
+	return getEveryNthWithCondition(ticks, interval + 1);
 }
-function n(e, t, n) {
-	if (t < 1) return [];
-	if (t === 1 && n === void 0) return e;
-	let r = [];
-	for (let i = 0; i < e.length; i += t) if (n === void 0 || n(e[i]) === !0) r.push(e[i]);
+/**
+* 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.
+* If isValid is provided, all candidates must suffice the condition, else undefined is returned.
+* @param {T[]} array An input array.
+* @param {integer} n A number
+* @param {Function} isValid A function to evaluate a candidate form the array
+* @returns {T[]} The result array of the same type as the input array.
+*/
+function getEveryNthWithCondition(array, n, isValid) {
+	if (n < 1) return [];
+	if (n === 1 && isValid === void 0) return array;
+	const result = [];
+	for (let i = 0; i < array.length; i += n) if (isValid === void 0 || isValid(array[i]) === true) result.push(array[i]);
 	else return;
-	return r;
+	return result;
 }
-function r(t, n, r) {
-	return e({
-		width: t.width + n.width,
-		height: t.height + n.height
-	}, r);
+function getAngledTickWidth(contentSize, unitSize, angle) {
+	return getAngledRectangleWidth({
+		width: contentSize.width + unitSize.width,
+		height: contentSize.height + unitSize.height
+	}, angle);
 }
-function i(e, t, n) {
-	let r = n === "width", { x: i, y: a, width: o, height: s } = e;
-	return t === 1 ? {
-		start: r ? i : a,
-		end: r ? i + o : a + s
-	} : {
-		start: r ? i + o : a + s,
-		end: r ? i : a
+function getTickBoundaries(viewBox, sign, sizeKey) {
+	const isWidth = sizeKey === "width";
+	const { x, y, width, height } = viewBox;
+	if (sign === 1) return {
+		start: isWidth ? x : y,
+		end: isWidth ? x + width : y + height
+	};
+	return {
+		start: isWidth ? x + width : y + height,
+		end: isWidth ? x : y
 	};
 }
 //#endregion
-export { r as getAngledTickWidth, n as getEveryNthWithCondition, t as getNumberIntervalTicks, i as getTickBoundaries };
+export { getAngledTickWidth, getEveryNthWithCondition, getNumberIntervalTicks, getTickBoundaries };