vccs 0.0.1 → 0.2.0

package/dist/es/utils/legend.mjs

@@ -0,0 +1,19 @@
+import { isNumber } from "./validate.mjs";
+//#region src/utils/legend.ts
+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 ((layout === "horizontal" || layout === "vertical" && align === "center") && verticalAlign !== "middle" && isNumber(offset[verticalAlign])) return {
+			...offset,
+			[verticalAlign]: offset[verticalAlign] + (boxHeight || 0)
+		};
+	}
+	return offset;
+}
+//#endregion
+export { appendOffsetOfLegend };

package/dist/es/utils/log.mjs

@@ -0,0 +1,14 @@
+//#region src/utils/log.ts
+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 { warn };

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

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

package/dist/es/utils/polar.mjs

@@ -0,0 +1,59 @@
+//#region src/utils/polar.ts
+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 formatAngleOfSector({ startAngle, endAngle }) {
+	const startCnt = Math.floor(startAngle / 360);
+	const endCnt = Math.floor(endAngle / 360);
+	const min = Math.min(startCnt, endCnt);
+	return {
+		startAngle: startAngle - min * 360,
+		endAngle: endAngle - min * 360
+	};
+}
+function getAngleOfPoint({ x, y }, { cx, cy }) {
+	const radius = distanceBetweenPoints({
+		x,
+		y
+	}, {
+		x: cx,
+		y: cy
+	});
+	if (radius <= 0) return {
+		radius,
+		angle: 0
+	};
+	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 reverseFormatAngleOfSector(angle, { startAngle, endAngle }) {
+	const startCnt = Math.floor(startAngle / 360);
+	const endCnt = Math.floor(endAngle / 360);
+	return angle + Math.min(startCnt, endCnt) * 360;
+}
+function polarToCartesian(cx, cy, radius, angle) {
+	return {
+		x: cx + Math.cos(-RADIAN * angle) * radius,
+		y: cy + Math.sin(-RADIAN * angle) * radius
+	};
+}
+function getMaxRadius(width, height, offset = {
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+}) {
+	return Math.min(Math.abs(width - (offset.left || 0) - (offset.right || 0)), Math.abs(height - (offset.top || 0) - (offset.bottom || 0))) / 2;
+}
+//#endregion
+export { RADIAN, formatAngleOfSector, getAngleOfPoint, getMaxRadius, polarToCartesian, reverseFormatAngleOfSector };

package/dist/es/utils/props.mjs

@@ -0,0 +1,20 @@
+//#region src/utils/props.ts
+/**
+* 将 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 newProps;
+}
+//#endregion
+export { applyDefaultProps };

package/dist/es/utils/resolveDefaultProps.mjs

@@ -0,0 +1,26 @@
+//#region src/utils/resolveDefaultProps.ts
+/**
+* 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 { resolveDefaultProps };

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

@@ -0,0 +1,137 @@
+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
+/**
+* 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];
+}
+/**
+* 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()));
+}
+/**
+* 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);
+}
+/**
+* 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))
+	};
+}
+/**
+* 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 (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;
+}
+/**
+* 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 getNiceTickValues = memoize(getNiceTickValuesFn);
+var getTickValuesFixedDomain = memoize(getTickValuesFixedDomainFn);
+//#endregion
+export { getNiceTickValues, getTickValuesFixedDomain };

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

@@ -0,0 +1,54 @@
+import { curry } from "./utils.mjs";
+import Decimal from "decimal.js-light";
+//#region src/utils/scale/utils/arithmetic.ts
+/**
+* 获取数值的位数
+* 其中绝对值属于区间[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;
+}
+/**
+* 按照固定的步长获取[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;
+}
+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 { getDigitCount, rangeStep };

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

@@ -0,0 +1,53 @@
+//#region src/utils/scale/utils/utils.ts
+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 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 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 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 reverse(arr) {
+	if (Array.isArray(arr)) return arr.reverse();
+	return arr.split("").reverse().join("");
+}
+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 { compose, curry, map, memoize, range, reverse };

package/dist/es/utils/style.mjs

@@ -0,0 +1,30 @@
+import { isNumber } from "./validate.mjs";
+//#region src/utils/style.ts
+/**
+* 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;
+}
+/**
+* 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: toPx(height),
+		width: toPx(width),
+		minHeight: toPx(minHeight),
+		maxHeight: toPx(maxHeight),
+		minWidth: toPx(minWidth),
+		maxWidth: toPx(maxWidth),
+		...rest
+	};
+}
+//#endregion
+export { normalizeStyle };

package/dist/es/utils/tick.mjs

@@ -0,0 +1,42 @@
+import { getAngledRectangleWidth } from "./cartesian.mjs";
+//#region src/utils/tick.ts
+function getNumberIntervalTicks(ticks, interval) {
+	return getEveryNthWithCondition(ticks, interval + 1);
+}
+/**
+* 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 result;
+}
+function getAngledTickWidth(contentSize, unitSize, angle) {
+	return getAngledRectangleWidth({
+		width: contentSize.width + unitSize.width,
+		height: contentSize.height + unitSize.height
+	}, angle);
+}
+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 { getAngledTickWidth, getEveryNthWithCondition, getNumberIntervalTicks, getTickBoundaries };

package/dist/es/utils/tooltip/translate.mjs

@@ -0,0 +1,73 @@
+import { isNumber } from "../validate.mjs";
+//#region src/utils/tooltip/translate.ts
+var CSS_CLASS_PREFIX = "v-charts-tooltip-wrapper";
+var TOOLTIP_HIDDEN = { visibility: "hidden" };
+function getTooltipCSSClassName({ coordinate, translateX, translateY }) {
+	return [CSS_CLASS_PREFIX, {
+		[`${CSS_CLASS_PREFIX}-right`]: isNumber(translateX) && coordinate && isNumber(coordinate.x) && translateX >= coordinate.x,
+		[`${CSS_CLASS_PREFIX}-left`]: isNumber(translateX) && coordinate && isNumber(coordinate.x) && translateX < coordinate.x,
+		[`${CSS_CLASS_PREFIX}-bottom`]: isNumber(translateY) && coordinate && isNumber(coordinate.y) && translateY >= coordinate.y,
+		[`${CSS_CLASS_PREFIX}-top`]: isNumber(translateY) && coordinate && isNumber(coordinate.y) && translateY < coordinate.y
+	}];
+}
+function getTooltipTranslateXY({ allowEscapeViewBox, coordinate, key, offsetTopLeft, position, reverseDirection, tooltipDimension, viewBox, viewBoxDimension }) {
+	if (position && isNumber(position[key])) return position[key];
+	const negative = coordinate[key] - tooltipDimension - (offsetTopLeft > 0 ? offsetTopLeft : 0);
+	const positive = coordinate[key] + offsetTopLeft;
+	if (allowEscapeViewBox[key]) return reverseDirection[key] ? negative : positive;
+	const viewBoxKey = viewBox[key];
+	if (viewBoxKey == null) return 0;
+	if (reverseDirection[key]) {
+		if (negative < viewBoxKey) return Math.max(positive, viewBoxKey);
+		return Math.max(negative, viewBoxKey);
+	}
+	if (viewBoxDimension == null) return 0;
+	if (positive + tooltipDimension > viewBoxKey + viewBoxDimension) return Math.max(negative, viewBoxKey);
+	return Math.max(positive, viewBoxKey);
+}
+function getTransformStyle({ translateX, translateY, useTranslate3d }) {
+	return { transform: useTranslate3d ? `translate3d(${translateX}px, ${translateY}px, 0)` : `translate(${translateX}px, ${translateY}px)` };
+}
+function getTooltipTranslate({ allowEscapeViewBox, coordinate, offsetTopLeft, position, reverseDirection, tooltipBox, useTranslate3d, viewBox }) {
+	let cssProperties, translateX, translateY;
+	if (tooltipBox.height > 0 && tooltipBox.width > 0 && coordinate) {
+		translateX = getTooltipTranslateXY({
+			allowEscapeViewBox,
+			coordinate,
+			key: "x",
+			offsetTopLeft,
+			position,
+			reverseDirection,
+			tooltipDimension: tooltipBox.width,
+			viewBox,
+			viewBoxDimension: viewBox.width
+		});
+		translateY = getTooltipTranslateXY({
+			allowEscapeViewBox,
+			coordinate,
+			key: "y",
+			offsetTopLeft,
+			position,
+			reverseDirection,
+			tooltipDimension: tooltipBox.height,
+			viewBox,
+			viewBoxDimension: viewBox.height
+		});
+		cssProperties = {};
+	} else cssProperties = TOOLTIP_HIDDEN;
+	return {
+		cssProperties,
+		cssClasses: getTooltipCSSClassName({
+			translateX,
+			translateY,
+			coordinate
+		}),
+		transform: getTransformStyle({
+			translateX: translateX ?? 0,
+			translateY: translateY ?? 0,
+			useTranslate3d
+		})
+	};
+}
+//#endregion
+export { getTooltipTranslate };

package/dist/es/utils/validate.mjs

@@ -0,0 +1,42 @@
+//#region src/utils/validate.ts
+function isNan(value) {
+	return typeof value == "number" && value != +value;
+}
+function isNumber(value) {
+	return (typeof value === "number" || value instanceof Number) && !isNan(value);
+}
+/**
+* validate the width and height props of a chart element
+* @param  {object} el A chart element
+* @return {boolean}   true If the props width and height are number, and greater than 0
+*/
+function validateWidthHeight({ width, height }) {
+	if (!isNumber(width) || width <= 0 || !isNumber(height) || height <= 0) return false;
+	return true;
+}
+function isWellBehavedNumber(n) {
+	return Number.isFinite(n);
+}
+function isPercent(value) {
+	return typeof value === "string" && value.indexOf("%") === value.length - 1;
+}
+function isCategoricalAxis(layout, axisType) {
+	return layout === "horizontal" && axisType === "xAxis" || layout === "vertical" && axisType === "yAxis" || layout === "centric" && axisType === "angleAxis" || layout === "radial" && axisType === "radiusAxis";
+}
+function isVisible(sign, tickPosition, getSize, start, end) {
+	if (sign * tickPosition < sign * start || sign * tickPosition > sign * end) return false;
+	const size = getSize();
+	return sign * (tickPosition - sign * size / 2 - start) >= 0 && sign * (tickPosition + sign * size / 2 - end) <= 0;
+}
+var isSsr = typeof window === "undefined";
+/**
+* Checks if the value is null or undefined
+* @param {any} value The value to check
+* @returns {boolean} true if the value is null or undefined
+*/
+function isNullish(value) {
+	return value === null || typeof value === "undefined";
+}
+var isNumOrStr = (value) => isNumber(value) || typeof value === "string";
+//#endregion
+export { isCategoricalAxis, isNan, isNullish, isNumOrStr, isNumber, isPercent, isSsr, isVisible, isWellBehavedNumber, validateWidthHeight };

package/dist/events/useChartSynchronisation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Will receive synchronisation events from other charts.
+ *
+ * Reads syncMethod from state and decides how to synchronise the tooltip based on that.
+ *
+ * @returns void
+ */
+export declare function useSynchronisedEventsFromOtherCharts(): void;

package/dist/hooks/useIsAnimating.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'vue';
+/**
+ * Tracks whether a component is currently animating.
+ *
+ * When `isAnimationActive` is `false`, always returns `false` regardless of
+ * internal state — this ensures `isAnimationActive={false}` immediately
+ * disables all animation-gated rendering (e.g. deferred LabelList).
+ *
+ * When `isAnimationActive` is `true`, starts as `true` and can be set to
+ * `false` via the returned ref (typically on animation end).
+ *
+ * Re-entering `isAnimationActive=true` resets internal state to `true`.
+ */
+export declare function useIsAnimating(isAnimationActive: () => boolean): Ref<boolean>;

package/dist/hooks/useSetupGraphicalItem.d.ts

@@ -0,0 +1,7 @@
+import { AreaProps } from '../cartesian/area/type';
+import { CartesianGraphicalItemType, ErrorBarsSettings } from '../state/graphicalItemsSlice';
+import { ShallowRef } from 'vue';
+export declare function useSetupGraphicalItem(props: AreaProps | any, type: CartesianGraphicalItemType, options?: {
+    skipTooltip?: boolean;
+    errorBars?: ShallowRef<ReadonlyArray<ErrorBarsSettings>>;
+}): void;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cartesian';
+export * from './chart';
+export * from './container';
+export * from './components';
+export * from './polar';
+export * from './shape';

package/dist/polar/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pie';
+export * from './radar';
+export * from './radial-bar';

package/dist/polar/pie/Pie.d.ts

@@ -0,0 +1,2 @@
+import { PiePropsWithSVG } from './type';
+export declare const Pie: import('vue').DefineComponent<PiePropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PiePropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/polar/pie/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Pie';
+export * from './type';