vccs 0.6.0 → 1.0.0-beta.2

package/dist/es/utils/chart.mjs

@@ -1,366 +1,8 @@
-import { isNan, isNullish, isNumOrStr, isNumber } from "./validate.mjs";
-import { findEntryInArray, mathSign } from "./data.mjs";
-import { formatAngleOfSector, getAngleOfPoint, polarToCartesian, reverseFormatAngleOfSector } from "./polar.mjs";
+import { getValueByDataKey as getValueByDataKey$1 } from "../core/data.mjs";
 import { toRaw } from "vue";
-import { stack, stackOffsetExpand, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderNone } from "victory-vendor/d3-shape";
-import { get, isNaN, sortBy } from "lodash-es";
 //#region src/utils/chart.ts
-/**
-* Get the ticks of an axis
-* @param  {object}  axis The configuration of an axis
-* @param {boolean} isGrid Whether or not are the ticks in grid
-* @param {boolean} isAll Return the ticks of all the points or not
-* @return {Array}  Ticks
-*/
-function getTicksOfAxis(axis, isGrid, isAll) {
-	if (!axis) return null;
-	const { duplicateDomain, type, range, scale, realScaleType, isCategorical, categoricalDomain, tickCount, ticks, niceTicks, axisType } = axis;
-	if (!scale) return null;
-	const offsetForBand = realScaleType === "scaleBand" ? scale.bandwidth() / 2 : 2;
-	let offset = (isGrid || isAll) && type === "category" && scale.bandwidth ? scale.bandwidth() / offsetForBand : 0;
-	offset = axisType === "angleAxis" && range.length >= 2 ? mathSign(range[0] - range[1]) * 2 * offset : offset;
-	if (isGrid && (ticks || niceTicks)) return (ticks || niceTicks).map((entry, index) => {
-		return {
-			coordinate: scale(duplicateDomain ? duplicateDomain.indexOf(entry) : entry) + offset,
-			value: entry,
-			offset,
-			index
-		};
-	}).filter((row) => !isNaN(row.coordinate));
-	if (isCategorical && categoricalDomain) return categoricalDomain.map((entry, index) => ({
-		coordinate: scale(entry) + offset,
-		value: entry,
-		index,
-		offset
-	}));
-	if (scale.ticks && !isAll) return scale.ticks(tickCount).map((entry, index) => ({
-		coordinate: scale(entry) + offset,
-		value: entry,
-		offset,
-		index
-	}));
-	return scale.domain().map((entry, index) => ({
-		coordinate: scale(entry) + offset,
-		value: duplicateDomain ? duplicateDomain[entry] : entry,
-		index,
-		offset
-	}));
-}
 function getValueByDataKey(obj, dataKey, defaultValue) {
-	if (isNullish(obj) || isNullish(dataKey)) return defaultValue;
-	if (isNumOrStr(dataKey)) return get(toRaw(obj), dataKey, defaultValue);
-	if (typeof dataKey === "function") return dataKey(obj);
-	return defaultValue;
-}
-var MIN_VALUE_REG = /^dataMin\s*-\s*(\d+(\.\d+)?)$/;
-var MAX_VALUE_REG = /^dataMax\s*\+\s*(\d+(\.\d+)?)$/;
-/**
-* Calculate the size between two category
-* @param  {object} axis  The options of axis
-* @param  {Array}  ticks The ticks of axis
-* @param  {boolean} isBar if items in axis are bars
-* @return {number} Size
-*/
-function getBandSizeOfAxis(axis, ticks, isBar) {
-	if (axis && axis.scale && axis.scale.bandwidth) {
-		const bandWidth = axis.scale.bandwidth();
-		if (!isBar || bandWidth > 0) return bandWidth;
-	}
-	if (axis && ticks && ticks.length >= 2) {
-		const orderedTicks = sortBy(ticks, (o) => o.coordinate);
-		let bandSize = Infinity;
-		for (let i = 1, len = orderedTicks.length; i < len; i++) {
-			const cur = orderedTicks[i];
-			const prev = orderedTicks[i - 1];
-			bandSize = Math.min((cur.coordinate || 0) - (prev.coordinate || 0), bandSize);
-		}
-		return bandSize === Infinity ? 0 : bandSize;
-	}
-	return isBar ? void 0 : 0;
-}
-/**
-* Both value and domain are tuples of two numbers
-* - but the type stays as array of numbers until we have better support in rest of the app
-* @param value input that will be truncated
-* @param domain boundaries
-* @returns tuple of two numbers
-*/
-function truncateByDomain(value, domain) {
-	if (!domain || domain.length !== 2 || !isNumber(domain[0]) || !isNumber(domain[1])) return value;
-	const minValue = Math.min(domain[0], domain[1]);
-	const maxValue = Math.max(domain[0], domain[1]);
-	const result = [value[0], value[1]];
-	if (!isNumber(value[0]) || value[0] < minValue) result[0] = minValue;
-	if (!isNumber(value[1]) || value[1] > maxValue) result[1] = maxValue;
-	if (result[0] > maxValue) result[0] = maxValue;
-	if (result[1] < minValue) result[1] = minValue;
-	return result;
-}
-function getNormalizedStackId(publicStackId) {
-	return publicStackId == null ? void 0 : String(publicStackId);
-}
-function getCateCoordinateOfLine({ axis, ticks, bandSize, entry, index, dataKey }) {
-	if (axis.type === "category") {
-		if (!axis.allowDuplicatedCategory && axis.dataKey && !isNullish(entry[axis.dataKey])) {
-			const matchedTick = findEntryInArray(ticks, "value", entry[axis.dataKey]);
-			if (matchedTick) return matchedTick.coordinate + bandSize / 2;
-		}
-		return ticks[index] ? ticks[index].coordinate + bandSize / 2 : null;
-	}
-	const value = getValueByDataKey(entry, !isNullish(dataKey) ? dataKey : axis.dataKey);
-	return !isNullish(value) ? axis.scale(value) : null;
-}
-function getChartPointer(event) {
-	const target = event.currentTarget;
-	const rect = target.getBoundingClientRect();
-	const scaleX = rect.width / target.offsetWidth;
-	const scaleY = rect.height / target.offsetHeight;
-	return {
-		chartX: Math.round((event.clientX - rect.left) / scaleX),
-		chartY: Math.round((event.clientY - rect.top) / scaleY)
-	};
-}
-function getTooltipEntry({ tooltipEntrySettings, dataKey, payload, value, name }) {
-	return {
-		...tooltipEntrySettings,
-		dataKey,
-		payload,
-		value,
-		name
-	};
-}
-function calculateTooltipPos(rangeObj, layout) {
-	if (layout === "horizontal") return rangeObj.x;
-	if (layout === "vertical") return rangeObj.y;
-	if (layout === "centric") return rangeObj.angle;
-	return rangeObj.radius;
-}
-function inRangeOfSector({ x, y }, viewBox) {
-	const { radius, angle } = getAngleOfPoint({
-		x,
-		y
-	}, viewBox);
-	const { innerRadius, outerRadius } = viewBox;
-	if (radius < innerRadius || radius > outerRadius) return null;
-	if (radius === 0) return null;
-	const { startAngle, endAngle } = formatAngleOfSector(viewBox);
-	let formatAngle = angle;
-	let 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 {
-		...viewBox,
-		radius,
-		angle: reverseFormatAngleOfSector(formatAngle, viewBox)
-	};
-	return null;
-}
-function inRange(x, y, layout, polarViewBox, offset) {
-	if (layout === "horizontal" || layout === "vertical") return x >= offset.left && x <= offset.left + offset.width && y >= offset.top && y <= offset.top + offset.height ? {
-		x,
-		y
-	} : null;
-	if (polarViewBox) return inRangeOfSector({
-		x,
-		y
-	}, polarViewBox);
-	return null;
-}
-function calculateActiveTickIndex(coordinate, ticks, unsortedTicks, axisType, range) {
-	let index = -1;
-	const len = ticks?.length ?? 0;
-	if (len <= 1) return 0;
-	if (axisType === "angleAxis" && range != null && Math.abs(Math.abs(range[1] - range[0]) - 360) <= 1e-6) for (let i = 0; i < len; i++) {
-		const before = i > 0 ? unsortedTicks[i - 1].coordinate : unsortedTicks[len - 1].coordinate;
-		const cur = unsortedTicks[i].coordinate;
-		const after = i >= len - 1 ? unsortedTicks[0].coordinate : unsortedTicks[i + 1].coordinate;
-		let sameDirectionCoord;
-		if (mathSign(cur - before) !== mathSign(after - cur)) {
-			const diffInterval = [];
-			if (mathSign(after - cur) === mathSign(range[1] - range[0])) {
-				sameDirectionCoord = after;
-				const 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;
-				const afterInRange = after + range[1] - range[0];
-				diffInterval[0] = Math.min(cur, (afterInRange + cur) / 2);
-				diffInterval[1] = Math.max(cur, (afterInRange + cur) / 2);
-			}
-			const 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]) {
-				index = unsortedTicks[i].index;
-				break;
-			}
-		} else {
-			const minValue = Math.min(before, after);
-			const maxValue = Math.max(before, after);
-			if (coordinate > (minValue + cur) / 2 && coordinate <= (maxValue + cur) / 2) {
-				index = unsortedTicks[i].index;
-				break;
-			}
-		}
-	}
-	else for (let i = 0; i < len; i++) if (i === 0 && coordinate <= (ticks[i].coordinate + ticks[i + 1].coordinate) / 2 || i > 0 && i < len - 1 && coordinate > (ticks[i].coordinate + ticks[i - 1].coordinate) / 2 && coordinate <= (ticks[i].coordinate + ticks[i + 1].coordinate) / 2 || i === len - 1 && coordinate > (ticks[i].coordinate + ticks[i - 1].coordinate) / 2) {
-		index = ticks[i].index;
-		break;
-	}
-	return index;
-}
-function getActiveCoordinate(layout, tooltipTicks, activeIndex, rangeObj) {
-	const entry = tooltipTicks.find((tick) => tick && tick.index === activeIndex);
-	if (entry) {
-		if (layout === "horizontal") return {
-			x: entry.coordinate,
-			y: rangeObj.y
-		};
-		if (layout === "vertical") return {
-			x: rangeObj.x,
-			y: entry.coordinate
-		};
-		if (layout === "centric") {
-			const angle = entry.coordinate;
-			const { radius } = rangeObj;
-			return {
-				...rangeObj,
-				...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
-				angle,
-				radius
-			};
-		}
-		const radius = entry.coordinate;
-		const { angle } = rangeObj;
-		return {
-			...rangeObj,
-			...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
-			angle,
-			radius
-		};
-	}
-	return {
-		x: 0,
-		y: 0
-	};
-}
-function makeDomainFinite(domain) {
-	return [domain[0] === Infinity ? 0 : domain[0], domain[1] === -Infinity ? 0 : domain[1]];
-}
-function getDomainOfSingle(data) {
-	const flat = data.flat(2).filter(isNumber);
-	return [Math.min(...flat), Math.max(...flat)];
-}
-function getDomainOfStackGroups(stackGroups, startIndex, endIndex) {
-	if (stackGroups == null) return;
-	return makeDomainFinite(Object.keys(stackGroups).reduce((result, stackId) => {
-		const { stackedData } = stackGroups[stackId];
-		const domain = stackedData.reduce((res, entry) => {
-			const s = getDomainOfSingle(entry.slice(startIndex, endIndex + 1));
-			return [Math.min(res[0], s[0]), Math.max(res[1], s[1])];
-		}, [Infinity, -Infinity]);
-		return [Math.min(domain[0], result[0]), Math.max(domain[1], result[1])];
-	}, [Infinity, -Infinity]));
-}
-var EPS = 1e-4;
-function checkDomainOfScale(scale) {
-	const domain = scale.domain();
-	if (!domain || domain.length <= 2) return;
-	const len = domain.length;
-	const range = scale.range();
-	const minValue = Math.min(range[0], range[1]) - EPS;
-	const maxValue = Math.max(range[0], range[1]) + EPS;
-	const first = scale(domain[0]);
-	const last = scale(domain[len - 1]);
-	if (first < minValue || first > maxValue || last < minValue || last > maxValue) scale.domain([domain[0], domain[len - 1]]);
-}
-function getTooltipNameProp(nameFromItem, dataKey) {
-	if (nameFromItem) return String(nameFromItem);
-	if (typeof dataKey === "string") return dataKey;
-}
-function isClipDot(dot) {
-	if (dot && typeof dot === "object" && "clipDot" in dot) return Boolean(dot.clipDot);
-	return true;
-}
-var offsetSign = (series) => {
-	const n = series.length;
-	if (n <= 0) return;
-	for (let j = 0, m = series[0].length; j < m; ++j) {
-		let positive = 0;
-		let negative = 0;
-		for (let i = 0; i < n; ++i) {
-			const value = isNan(series[i][j][1]) ? series[i][j][0] : series[i][j][1];
-			if (value >= 0) {
-				series[i][j][0] = positive;
-				series[i][j][1] = positive + value;
-				positive = series[i][j][1];
-			} else {
-				series[i][j][0] = negative;
-				series[i][j][1] = negative + value;
-				negative = series[i][j][1];
-			}
-		}
-	}
-};
-/**
-* Replaces all negative values with zero when stacking data.
-*
-* If all values in the series are positive then this behaves the same as 'none' stacker.
-*
-* @param {Array} series from d3-shape Stack
-* @return {Array} series with applied offset
-*/
-var offsetPositive = (series) => {
-	const n = series.length;
-	if (n <= 0) return;
-	for (let j = 0, m = series[0].length; j < m; ++j) {
-		let positive = 0;
-		for (let i = 0; i < n; ++i) {
-			const value = isNan(series[i][j][1]) ? series[i][j][0] : series[i][j][1];
-			if (value >= 0) {
-				series[i][j][0] = positive;
-				series[i][j][1] = positive + value;
-				positive = series[i][j][1];
-			} else {
-				series[i][j][0] = 0;
-				series[i][j][1] = 0;
-			}
-		}
-	}
-};
-var STACK_OFFSET_MAP = {
-	sign: offsetSign,
-	expand: stackOffsetExpand,
-	none: stackOffsetNone,
-	silhouette: stackOffsetSilhouette,
-	wiggle: stackOffsetWiggle,
-	positive: offsetPositive
-};
-function getStackedData(data, dataKeys, offsetType) {
-	const offsetAccessor = STACK_OFFSET_MAP[offsetType];
-	return stack().keys(dataKeys).value((d, key) => +getValueByDataKey(d, key, 0)).order(stackOrderNone).offset(offsetAccessor)(data);
-}
-function getBaseValueOfBar({ numericAxis }) {
-	const domain = numericAxis.scale.domain();
-	if (numericAxis.type === "number") {
-		const minValue = Math.min(domain[0], domain[1]);
-		const maxValue = Math.max(domain[0], domain[1]);
-		if (minValue <= 0 && maxValue >= 0) return 0;
-		if (maxValue < 0) return maxValue;
-		return minValue;
-	}
-	return domain[0];
-}
-function getCateCoordinateOfBar({ axis, ticks, offset, bandSize, entry, index }) {
-	if (axis.type === "category") return ticks[index] ? ticks[index].coordinate + offset : null;
-	const value = getValueByDataKey(entry, axis.dataKey, axis.scale.domain()[index]);
-	return !isNullish(value) ? axis.scale(value) - bandSize / 2 + offset : null;
+	return getValueByDataKey$1(typeof dataKey === "function" ? obj : toRaw(obj), dataKey, defaultValue);
 }
 //#endregion
-export { MAX_VALUE_REG, MIN_VALUE_REG, calculateActiveTickIndex, calculateTooltipPos, checkDomainOfScale, getActiveCoordinate, getBandSizeOfAxis, getBaseValueOfBar, getCateCoordinateOfBar, getCateCoordinateOfLine, getChartPointer, getDomainOfStackGroups, getNormalizedStackId, getStackedData, getTicksOfAxis, getTooltipEntry, getTooltipNameProp, getValueByDataKey, inRange, isClipDot, truncateByDomain };
+export { getValueByDataKey };

package/dist/es/utils/const.mjs

@@ -4,29 +4,6 @@
 * The index is the position of the element in the data array.
 * This can be either a number (for array-based charts) or a string (for the charts that have a matrix-shaped data).
 */
-var DATA_ITEM_INDEX_ATTRIBUTE_NAME = "data-recharts-item-index";
-/**
-* We use this attribute to identify which element is the one that the user is touching.
-* DataKey works here as a kind of identifier for the element. It's not a perfect identifier for ~two~ three reasons:
-*
-* 1. There can be two different elements with the same dataKey; we won't know which is it
-* 2. DataKey can be a function, and that serialized will be a `[Function: anonymous]` string
-* which means we will be able to identify that it was a function but can't tell which one.
-* This will lead to some weird bugs. A proper fix would be to either:
-* a) use a unique identifier for each element (passed from props, or generated)
-* b) figure out how to compare the dataKey or graphical item by object reference
-*
-* a) is a fuss because we don't have the unique identifier in props,
-* and b) is possible most of the time except for touchMove events which work differently from mouseEnter/mouseLeave:
-* - while mouseEnter is fired for the element that the mouse is over,
-* touchMove is fired for the element where user has started touching. As the finger moves,
-* we can identify the element that the user is touching by using the elementFromPoint method,
-* but it keeps calling the handler on the element where touchStart was fired.
-*
-* Okay and now I discovered a third reason: the dataKey can be undefined and that's still fine
-* because if dataKey is undefined then graphical elements assume the dataKey of the axes.
-* Which makes it a convenient way of using recharts to render a chart but horrible identifier.
-*/
-var DATA_ITEM_DATAKEY_ATTRIBUTE_NAME = "data-recharts-item-data-key";
+var DATA_ITEM_INDEX_ATTRIBUTE_NAME = "data-v-charts-item-index";
 //#endregion
-export { DATA_ITEM_DATAKEY_ATTRIBUTE_NAME, DATA_ITEM_INDEX_ATTRIBUTE_NAME };
+export { DATA_ITEM_INDEX_ATTRIBUTE_NAME };

package/dist/es/utils/createCategoricalInverse.mjs

@@ -37,10 +37,10 @@ function createCategoricalInverse(scale, allDataPointsOnAxis) {
 * Creates an inverse function: uses native `.invert` for numeric scales,
 * falls back to categorical bisect for ordinal/band/point scales.
 */
-function combineInverseScaleFunction(scale) {
+function inverseScaleFunction(scale) {
 	if (scale == null) return;
 	if ("invert" in scale && typeof scale.invert === "function") return scale.invert.bind(scale);
 	return createCategoricalInverse(scale, void 0);
 }
 //#endregion
-export { combineInverseScaleFunction, createCategoricalInverse };
+export { createCategoricalInverse, inverseScaleFunction };

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

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

package/dist/es/utils/data.mjs

@@ -1,5 +1,5 @@
 import { isNan, isNumber, isPercent } from "./validate.mjs";
-import { get } from "lodash-es";
+import { get } from "es-toolkit/compat";
 //#region src/utils/data.ts
 function mathSign(value) {
 	if (value === 0) return 0;

package/dist/es/utils/env.mjs

@@ -0,0 +1,10 @@
+//#region src/utils/env.ts
+/**
+* True without a DOM. Only for defaults outside a component, such as text measurement in
+* plain functions; inside setup use `isServerRender()` from model/runtime.
+*/
+function isServer() {
+	return typeof document === "undefined";
+}
+//#endregion
+export { isServer };

package/dist/es/utils/events.mjs

@@ -1,7 +1,34 @@
-import EventEmitter from "eventemitter3";
 //#region src/utils/events.ts
-var eventCenter = new EventEmitter();
 var TOOLTIP_SYNC_EVENT = "recharts.syncEvent.tooltip";
 var BRUSH_SYNC_EVENT = "recharts.syncEvent.brush";
+function createChannel() {
+	let listeners = [];
+	return {
+		on(listener) {
+			listeners.push(listener);
+		},
+		off(listener) {
+			listeners = listeners.filter((registered) => registered !== listener);
+		},
+		emit(...args) {
+			for (const listener of [...listeners]) listener(...args);
+		}
+	};
+}
+var channels = {
+	[TOOLTIP_SYNC_EVENT]: createChannel(),
+	[BRUSH_SYNC_EVENT]: createChannel()
+};
+var eventCenter = {
+	on(event, listener) {
+		channels[event].on(listener);
+	},
+	off(event, listener) {
+		channels[event].off(listener);
+	},
+	emit(event, ...args) {
+		channels[event].emit(...args);
+	}
+};
 //#endregion
 export { BRUSH_SYNC_EVENT, TOOLTIP_SYNC_EVENT, eventCenter };

package/dist/es/utils/labelColor.mjs

@@ -0,0 +1,16 @@
+import { color } from "d3-color";
+//#region src/utils/labelColor.ts
+function luminance(value) {
+	const channel = value / 255;
+	return channel <= .04045 ? channel / 12.92 : ((channel + .055) / 1.055) ** 2.4;
+}
+/** Variables and translucent fills need an explicit foreground from the theme. */
+function labelColor(fill) {
+	const parsed = color(fill)?.rgb();
+	if (!parsed || parsed.opacity !== 1) return "var(--v-charts-label-foreground, currentColor)";
+	const light = luminance(parsed.r) * .2126 + luminance(parsed.g) * .7152 + luminance(parsed.b) * .0722;
+	const dark = luminance(10);
+	return `var(--v-charts-label-foreground, ${1.05 / (light + .05) > (light + .05) / (dark + .05) ? "#ffffff" : "#0a0a0a"})`;
+}
+//#endregion
+export { labelColor };

package/dist/es/utils/log.mjs

@@ -1,14 +1,32 @@
+import { getCurrentInstance } from "vue";
 //#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++]));
+		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, () => String(args[argIndex++])));
+			}
 		}
 	}
 }
+var appWarnings = /* @__PURE__ */ new WeakMap();
+function warnOnce(message) {
+	if (!isDev) return;
+	const app = getCurrentInstance()?.appContext.app;
+	if (!app) return;
+	let messages = appWarnings.get(app);
+	if (!messages) {
+		messages = /* @__PURE__ */ new Set();
+		appWarnings.set(app, messages);
+	}
+	if (!messages.has(message)) {
+		messages.add(message);
+		warn(false, message);
+	}
+}
 //#endregion
-export { warn };
+export { warn, warnOnce };

package/dist/es/utils/pointer.mjs

@@ -0,0 +1,13 @@
+//#region src/utils/pointer.ts
+function getChartPointer(event) {
+	const target = event.currentTarget;
+	const rect = target.getBoundingClientRect();
+	const scaleX = rect.width / target.offsetWidth;
+	const scaleY = rect.height / target.offsetHeight;
+	return {
+		chartX: Math.round((event.clientX - rect.left) / scaleX),
+		chartY: Math.round((event.clientY - rect.top) / scaleY)
+	};
+}
+//#endregion
+export { getChartPointer };

package/dist/es/utils/polar.mjs

@@ -41,10 +41,15 @@ function reverseFormatAngleOfSector(angle, { startAngle, endAngle }) {
 	const endCnt = Math.floor(endAngle / 360);
 	return angle + Math.min(startCnt, endCnt) * 360;
 }
+/**
+* Node and browsers may return cos/sin values that differ in the last bit. Rounding to 1e-6 px
+* makes the server and the browser print the same SVG attributes, so hydration matches.
+*/
+var roundCoordinate = (value) => Math.round(value * 1e6) / 1e6;
 function polarToCartesian(cx, cy, radius, angle) {
 	return {
-		x: cx + Math.cos(-RADIAN * angle) * radius,
-		y: cy + Math.sin(-RADIAN * angle) * radius
+		x: roundCoordinate(cx + Math.cos(-RADIAN * angle) * radius),
+		y: roundCoordinate(cy + Math.sin(-RADIAN * angle) * radius)
 	};
 }
 function getMaxRadius(width, height, offset = {

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

@@ -1,15 +1,15 @@
-import { compose, map, memoize, range, reverse } from "./utils/utils.mjs";
 import { getDigitCount, rangeStep } from "./utils/arithmetic.mjs";
+import { memoize, range } from "./utils/utils.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
+* @param  interval The minimum and maximum values
 * @return {Array} An interval
 */
-function getValidInterval([min, max]) {
+function getValidInterval(interval) {
+	const [min, max] = interval;
 	let [validMin, validMax] = [min, max];
 	if (min > max) [validMin, validMax] = [max, min];
 	return [validMin, validMax];
@@ -52,7 +52,7 @@ function getTickOfSingleValue(value, tickCount, allowDecimals) {
 	} 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);
+	return range(0, tickCount).map((n) => middle.add(new Decimal(n - middleIndex).mul(step)).toNumber());
 }
 /**
 * Calculate the step
@@ -105,12 +105,12 @@ function getNiceTickValuesFn([min, max], tickCount = 6, allowDecimals = true) {
 	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;
+		return min > max ? values.reverse() : 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;
+	return min > max ? values.reverse() : values;
 }
 /**
 * Calculate the ticks of an interval, the count of ticks won't be guraranteed,
@@ -129,7 +129,7 @@ function getTickValuesFixedDomainFn([min, max], tickCount, allowDecimals = true)
 	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;
+	return min > max ? values.reverse() : values;
 }
 var getNiceTickValues = memoize(getNiceTickValuesFn);
 var getTickValuesFixedDomain = memoize(getTickValuesFixedDomainFn);

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

@@ -1,4 +1,3 @@
-import { curry } from "./utils.mjs";
 import Decimal from "decimal.js-light";
 //#region src/utils/scale/utils/arithmetic.ts
 /**
@@ -36,19 +35,5 @@ function rangeStep(start, end, step) {
 	}
 	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 };