vccs 0.1.0 → 0.3.0

package/dist/es/utils/chart.mjs

@@ -1,186 +1,248 @@
-import { isNan as e, isNullish as t, isNumOrStr as n, isNumber as r } from "./validate.mjs";
-import { formatAngleOfSector as i, getAngleOfPoint as a, polarToCartesian as o, reverseFormatAngleOfSector as s } from "./polar.mjs";
-import { findEntryInArray as c, mathSign as l } from "./data.mjs";
-import { toRaw as u } from "vue";
-import { stack as d, stackOffsetExpand as f, stackOffsetNone as p, stackOffsetSilhouette as m, stackOffsetWiggle as h, stackOrderNone as g } from "victory-vendor/d3-shape";
-import { get as _, isNaN as v, sortBy as y } from "lodash-es";
+import { isNan, isNullish, isNumOrStr, isNumber } from "./validate.mjs";
+import { formatAngleOfSector, getAngleOfPoint, polarToCartesian, reverseFormatAngleOfSector } from "./polar.mjs";
+import { findEntryInArray, mathSign } from "./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
-function b(e, t, n) {
-	if (!e) return null;
-	let { duplicateDomain: r, type: i, range: a, scale: o, realScaleType: s, isCategorical: c, categoricalDomain: u, tickCount: d, ticks: f, niceTicks: p, axisType: m } = e;
-	if (!o) return null;
-	let h = s === "scaleBand" ? o.bandwidth() / 2 : 2, g = (t || n) && i === "category" && o.bandwidth ? o.bandwidth() / h : 0;
-	return g = m === "angleAxis" && a.length >= 2 ? l(a[0] - a[1]) * 2 * g : g, t && (f || p) ? (f || p).map((e, t) => ({
-		coordinate: o(r ? r.indexOf(e) : e) + g,
-		value: e,
-		offset: g,
-		index: t
-	})).filter((e) => !v(e.coordinate)) : c && u ? u.map((e, t) => ({
-		coordinate: o(e) + g,
-		value: e,
-		index: t,
-		offset: g
-	})) : o.ticks && !n ? o.ticks(d).map((e, t) => ({
-		coordinate: o(e) + g,
-		value: e,
-		offset: g,
-		index: t
-	})) : o.domain().map((e, t) => ({
-		coordinate: o(e) + g,
-		value: r ? r[e] : e,
-		index: t,
-		offset: g
+/**
+* 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 x(e, r, i) {
-	return t(e) || t(r) ? i : n(r) ? _(u(e), r, i) : typeof r == "function" ? r(e) : i;
+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 S = /^dataMin\s*-\s*(\d+(\.\d+)?)$/, C = /^dataMax\s*\+\s*(\d+(\.\d+)?)$/;
-function w(e, t, n) {
-	if (e && e.scale && e.scale.bandwidth) {
-		let t = e.scale.bandwidth();
-		if (!n || t > 0) return t;
+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 (e && t && t.length >= 2) {
-		let e = y(t, (e) => e.coordinate), n = Infinity;
-		for (let t = 1, r = e.length; t < r; t++) {
-			let r = e[t], i = e[t - 1];
-			n = Math.min((r.coordinate || 0) - (i.coordinate || 0), n);
+	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 n === Infinity ? 0 : n;
+		return bandSize === Infinity ? 0 : bandSize;
 	}
-	return n ? void 0 : 0;
+	return isBar ? void 0 : 0;
 }
-function T(e, t) {
-	if (!t || t.length !== 2 || !r(t[0]) || !r(t[1])) return e;
-	let n = Math.min(t[0], t[1]), i = Math.max(t[0], t[1]), a = [e[0], e[1]];
-	return (!r(e[0]) || e[0] < n) && (a[0] = n), (!r(e[1]) || e[1] > i) && (a[1] = i), a[0] > i && (a[0] = i), a[1] < n && (a[1] = n), a;
+/**
+* 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 E(e) {
-	return e == null ? void 0 : String(e);
+function getNormalizedStackId(publicStackId) {
+	return publicStackId == null ? void 0 : String(publicStackId);
 }
-function D({ axis: e, ticks: n, bandSize: r, entry: i, index: a, dataKey: o }) {
-	if (e.type === "category") {
-		if (!e.allowDuplicatedCategory && e.dataKey && !t(i[e.dataKey])) {
-			let t = c(n, "value", i[e.dataKey]);
-			if (t) return t.coordinate + r / 2;
+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 n[a] ? n[a].coordinate + r / 2 : null;
+		return ticks[index] ? ticks[index].coordinate + bandSize / 2 : null;
 	}
-	let s = x(i, t(o) ? e.dataKey : o);
-	return t(s) ? null : e.scale(s);
+	const value = getValueByDataKey(entry, !isNullish(dataKey) ? dataKey : axis.dataKey);
+	return !isNullish(value) ? axis.scale(value) : null;
 }
-function O(e) {
-	let t = e.currentTarget, n = t.getBoundingClientRect(), r = n.width / t.offsetWidth, i = n.height / t.offsetHeight;
+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((e.clientX - n.left) / r),
-		chartY: Math.round((e.clientY - n.top) / i)
+		chartX: Math.round((event.clientX - rect.left) / scaleX),
+		chartY: Math.round((event.clientY - rect.top) / scaleY)
 	};
 }
-function k({ tooltipEntrySettings: e, dataKey: t, payload: n, value: r, name: i }) {
+function getTooltipEntry({ tooltipEntrySettings, dataKey, payload, value, name }) {
 	return {
-		...e,
-		dataKey: t,
-		payload: n,
-		value: r,
-		name: i
+		...tooltipEntrySettings,
+		dataKey,
+		payload,
+		value,
+		name
 	};
 }
-function A(e, t) {
-	return t === "horizontal" ? e.x : t === "vertical" ? e.y : t === "centric" ? e.angle : e.radius;
+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 j({ x: e, y: t }, n) {
-	let { radius: r, angle: o } = a({
-		x: e,
-		y: t
-	}, n), { innerRadius: c, outerRadius: l } = n;
-	if (r < c || r > l || r === 0) return null;
-	let { startAngle: u, endAngle: d } = i(n), f = o, p;
-	if (u <= d) {
-		for (; f > d;) f -= 360;
-		for (; f < u;) f += 360;
-		p = f >= u && f <= d;
+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 {
-		for (; f > u;) f -= 360;
-		for (; f < d;) f += 360;
-		p = f >= d && f <= u;
+		while (formatAngle > startAngle) formatAngle -= 360;
+		while (formatAngle < endAngle) formatAngle += 360;
+		inRange = formatAngle >= endAngle && formatAngle <= startAngle;
 	}
-	return p ? {
-		...n,
-		radius: r,
-		angle: s(f, n)
-	} : null;
+	if (inRange) return {
+		...viewBox,
+		radius,
+		angle: reverseFormatAngleOfSector(formatAngle, viewBox)
+	};
+	return null;
 }
-function M(e, t, n, r, i) {
-	return n === "horizontal" || n === "vertical" ? e >= i.left && e <= i.left + i.width && t >= i.top && t <= i.top + i.height ? {
-		x: e,
-		y: t
-	} : null : r ? j({
-		x: e,
-		y: t
-	}, r) : 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 N(e, t, n, r, i) {
-	let a = -1, o = t?.length ?? 0;
-	if (o <= 1) return 0;
-	if (r === "angleAxis" && i != null && Math.abs(Math.abs(i[1] - i[0]) - 360) <= 1e-6) for (let t = 0; t < o; t++) {
-		let r = t > 0 ? n[t - 1].coordinate : n[o - 1].coordinate, s = n[t].coordinate, c = t >= o - 1 ? n[0].coordinate : n[t + 1].coordinate, u;
-		if (l(s - r) !== l(c - s)) {
-			let o = [];
-			if (l(c - s) === l(i[1] - i[0])) {
-				u = c;
-				let e = s + i[1] - i[0];
-				o[0] = Math.min(e, (e + r) / 2), o[1] = Math.max(e, (e + r) / 2);
+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 {
-				u = r;
-				let e = c + i[1] - i[0];
-				o[0] = Math.min(s, (e + s) / 2), o[1] = Math.max(s, (e + s) / 2);
+				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);
 			}
-			let d = [Math.min(s, (u + s) / 2), Math.max(s, (u + s) / 2)];
-			if (e > d[0] && e <= d[1] || e >= o[0] && e <= o[1]) {
-				a = n[t].index;
+			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 {
-			let i = Math.min(r, c), o = Math.max(r, c);
-			if (e > (i + s) / 2 && e <= (o + s) / 2) {
-				a = n[t].index;
+			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 n = 0; n < o; n++) if (n === 0 && e <= (t[n].coordinate + t[n + 1].coordinate) / 2 || n > 0 && n < o - 1 && e > (t[n].coordinate + t[n - 1].coordinate) / 2 && e <= (t[n].coordinate + t[n + 1].coordinate) / 2 || n === o - 1 && e > (t[n].coordinate + t[n - 1].coordinate) / 2) {
-		a = t[n].index;
+	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 a;
+	return index;
 }
-function P(e, t, n, r) {
-	let i = t.find((e) => e && e.index === n);
-	if (i) {
-		if (e === "horizontal") return {
-			x: i.coordinate,
-			y: r.y
+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 (e === "vertical") return {
-			x: r.x,
-			y: i.coordinate
+		if (layout === "vertical") return {
+			x: rangeObj.x,
+			y: entry.coordinate
 		};
-		if (e === "centric") {
-			let e = i.coordinate, { radius: t } = r;
+		if (layout === "centric") {
+			const angle = entry.coordinate;
+			const { radius } = rangeObj;
 			return {
-				...r,
-				...o(r.cx, r.cy, t, e),
-				angle: e,
-				radius: t
+				...rangeObj,
+				...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+				angle,
+				radius
 			};
 		}
-		let t = i.coordinate, { angle: n } = r;
+		const radius = entry.coordinate;
+		const { angle } = rangeObj;
 		return {
-			...r,
-			...o(r.cx, r.cy, t, n),
-			angle: n,
-			radius: t
+			...rangeObj,
+			...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+			angle,
+			radius
 		};
 	}
 	return {
@@ -188,78 +250,117 @@ function P(e, t, n, r) {
 		y: 0
 	};
 }
-function F(e) {
-	return [e[0] === Infinity ? 0 : e[0], e[1] === -Infinity ? 0 : e[1]];
+function makeDomainFinite(domain) {
+	return [domain[0] === Infinity ? 0 : domain[0], domain[1] === -Infinity ? 0 : domain[1]];
 }
-function I(e) {
-	let t = e.flat(2).filter(r);
-	return [Math.min(...t), Math.max(...t)];
+function getDomainOfSingle(data) {
+	const flat = data.flat(2).filter(isNumber);
+	return [Math.min(...flat), Math.max(...flat)];
 }
-function L(e, t, n) {
-	if (e != null) return F(Object.keys(e).reduce((r, i) => {
-		let { stackedData: a } = e[i], o = a.reduce((e, r) => {
-			let i = I(r.slice(t, n + 1));
-			return [Math.min(e[0], i[0]), Math.max(e[1], i[1])];
+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(o[0], r[0]), Math.max(o[1], r[1])];
+		return [Math.min(domain[0], result[0]), Math.max(domain[1], result[1])];
 	}, [Infinity, -Infinity]));
 }
-var R = 1e-4;
-function z(e) {
-	let t = e.domain();
-	if (!t || t.length <= 2) return;
-	let n = t.length, r = e.range(), i = Math.min(r[0], r[1]) - R, a = Math.max(r[0], r[1]) + R, o = e(t[0]), s = e(t[n - 1]);
-	(o < i || o > a || s < i || s > a) && e.domain([t[0], t[n - 1]]);
+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 B(e, t) {
-	if (e) return String(e);
-	if (typeof t == "string") return t;
+function getTooltipNameProp(nameFromItem, dataKey) {
+	if (nameFromItem) return String(nameFromItem);
+	if (typeof dataKey === "string") return dataKey;
 }
-function V(e) {
-	return e && typeof e == "object" && "clipDot" in e ? !!e.clipDot : !0;
+function isClipDot(dot) {
+	if (dot && typeof dot === "object" && "clipDot" in dot) return Boolean(dot.clipDot);
+	return true;
 }
-var H = {
-	sign: (t) => {
-		let n = t.length;
-		if (!(n <= 0)) for (let r = 0, i = t[0].length; r < i; ++r) {
-			let i = 0, a = 0;
-			for (let o = 0; o < n; ++o) {
-				let n = e(t[o][r][1]) ? t[o][r][0] : t[o][r][1];
-				n >= 0 ? (t[o][r][0] = i, t[o][r][1] = i + n, i = t[o][r][1]) : (t[o][r][0] = a, t[o][r][1] = a + n, a = t[o][r][1]);
+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];
 			}
 		}
-	},
-	expand: f,
-	none: p,
-	silhouette: m,
-	wiggle: h,
-	positive: (t) => {
-		let n = t.length;
-		if (!(n <= 0)) for (let r = 0, i = t[0].length; r < i; ++r) {
-			let i = 0;
-			for (let a = 0; a < n; ++a) {
-				let n = e(t[a][r][1]) ? t[a][r][0] : t[a][r][1];
-				n >= 0 ? (t[a][r][0] = i, t[a][r][1] = i + n, i = t[a][r][1]) : (t[a][r][0] = 0, t[a][r][1] = 0);
+	}
+};
+/**
+* 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;
 			}
 		}
 	}
 };
-function U(e, t, n) {
-	let r = H[n];
-	return d().keys(t).value((e, t) => +x(e, t, 0)).order(g).offset(r)(e);
+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 W({ numericAxis: e }) {
-	let t = e.scale.domain();
-	if (e.type === "number") {
-		let e = Math.min(t[0], t[1]), n = Math.max(t[0], t[1]);
-		return e <= 0 && n >= 0 ? 0 : n < 0 ? n : e;
+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 t[0];
+	return domain[0];
 }
-function G({ axis: e, ticks: n, offset: r, bandSize: i, entry: a, index: o }) {
-	if (e.type === "category") return n[o] ? n[o].coordinate + r : null;
-	let s = x(a, e.dataKey, e.scale.domain()[o]);
-	return t(s) ? null : e.scale(s) - i / 2 + r;
+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;
 }
 //#endregion
-export { C as MAX_VALUE_REG, S as MIN_VALUE_REG, N as calculateActiveTickIndex, A as calculateTooltipPos, z as checkDomainOfScale, P as getActiveCoordinate, w as getBandSizeOfAxis, W as getBaseValueOfBar, G as getCateCoordinateOfBar, D as getCateCoordinateOfLine, O as getChartPointer, L as getDomainOfStackGroups, E as getNormalizedStackId, U as getStackedData, b as getTicksOfAxis, k as getTooltipEntry, B as getTooltipNameProp, x as getValueByDataKey, M as inRange, V as isClipDot, T as truncateByDomain };
+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 };

package/dist/es/utils/const.mjs

@@ -1,4 +1,32 @@
 //#region src/utils/const.ts
-var e = "data-recharts-item-index", t = "data-recharts-item-data-key";
+/**
+* We use this attribute to identify which element is the one that the user is touching.
+* 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";
 //#endregion
-export { t as DATA_ITEM_DATAKEY_ATTRIBUTE_NAME, e as DATA_ITEM_INDEX_ATTRIBUTE_NAME };
+export { DATA_ITEM_DATAKEY_ATTRIBUTE_NAME, DATA_ITEM_INDEX_ATTRIBUTE_NAME };