vccs 0.1.0 → 0.3.0

package/dist/es/cartesian/bar/components/BarBackground.mjs

@@ -1,29 +1,32 @@
-import { Layer as e } from "../../../container/Layer.mjs";
-import { useBarContext as t } from "../hooks/useBar.mjs";
-import { Rectangle as n } from "../../../shape/Rectangle.mjs";
-import { Fragment as r, createVNode as i, defineComponent as a } from "vue";
+import { Layer } from "../../../container/Layer.mjs";
+import { useBarContext } from "../hooks/useBar.mjs";
+import { Rectangle } from "../../../shape/Rectangle.mjs";
+import { Fragment, createVNode, defineComponent } from "vue";
 //#region src/cartesian/bar/components/BarBackground.tsx
-var o = /* @__PURE__ */ a({
+var BarBackground = /* @__PURE__ */ defineComponent({
 	name: "BarBackground",
-	inheritAttrs: !1,
-	setup(a, { attrs: o }) {
-		let { props: s, data: c } = t();
+	inheritAttrs: false,
+	setup(_, { attrs }) {
+		const { props, data: barData } = useBarContext();
 		return () => {
-			let t = c.value, a = s.background;
-			return !a || !t ? null : i(r, null, [t.map((t, r) => {
-				let { value: o, background: s, tooltipPosition: c, ...l } = t;
-				if (!s) return null;
-				let u = typeof a == "object" ? a : {}, d = {
-					option: a,
-					...l,
+			const data = barData.value;
+			const backgroundFromProps = props.background;
+			if (!backgroundFromProps || !data) return null;
+			return createVNode(Fragment, null, [data.map((entry, i) => {
+				const { value, background: backgroundFromDataEntry, tooltipPosition, ...rest } = entry;
+				if (!backgroundFromDataEntry) return null;
+				const backgroundObjectProps = typeof backgroundFromProps === "object" ? backgroundFromProps : {};
+				const barRectangleProps = {
+					option: backgroundFromProps,
+					...rest,
 					fill: "#eee",
-					...s,
-					...u
+					...backgroundFromDataEntry,
+					...backgroundObjectProps
 				};
-				return i(e, { key: `background-bar-${r}` }, { default: () => [i(n, d, null)] });
+				return createVNode(Layer, { "key": `background-bar-${i}` }, { default: () => [createVNode(Rectangle, barRectangleProps, null)] });
 			})]);
 		};
 	}
 });
 //#endregion
-export { o as BarBackground };
+export { BarBackground };

package/dist/es/cartesian/bar/components/BarRectangles.mjs

@@ -1,106 +1,143 @@
-import { mouseLeaveItem as e, setActiveClickItemIndex as t, setActiveMouseOverItemIndex as n } from "../../../state/tooltipSlice.mjs";
-import { selectActiveTooltipDataKey as r, selectActiveTooltipIndex as i } from "../../../state/selectors/tooltipSelectors.mjs";
-import { useAppDispatch as a, useAppSelector as o } from "../../../state/hooks.mjs";
-import { filterProps as s } from "../../../utils/VueUtils.mjs";
-import { Layer as c } from "../../../container/Layer.mjs";
-import { Animate as l } from "../../../animation/Animate.mjs";
-import { useBarContext as u } from "../hooks/useBar.mjs";
-import { Rectangle as d } from "../../../shape/Rectangle.mjs";
-import { Fragment as f, createVNode as p, defineComponent as m, isVNode as h } from "vue";
+import { mouseLeaveItem, setActiveClickItemIndex, setActiveMouseOverItemIndex } from "../../../state/tooltipSlice.mjs";
+import { selectActiveTooltipDataKey, selectActiveTooltipIndex } from "../../../state/selectors/tooltipSelectors.mjs";
+import { useAppDispatch, useAppSelector } from "../../../state/hooks.mjs";
+import { filterProps } from "../../../utils/VueUtils.mjs";
+import { Layer } from "../../../container/Layer.mjs";
+import { Animate } from "../../../animation/Animate.mjs";
+import { useBarContext } from "../hooks/useBar.mjs";
+import { Rectangle } from "../../../shape/Rectangle.mjs";
+import { Fragment, createVNode, defineComponent, isVNode } from "vue";
 //#region src/cartesian/bar/components/BarRectangles.tsx
-function g(e) {
-	return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !h(e);
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
 }
-var _ = /* @__PURE__ */ m({
+var BarRectangles = /* @__PURE__ */ defineComponent({
 	name: "BarRectangles",
-	inheritAttrs: !1,
-	setup(m) {
-		let h = a(), _ = o(i), v = o(r), y = null, b = 0, { props: x, data: S, layout: C, isAnimating: w, shapeSlot: T, activeBarSlot: E, cellProps: D } = u(), { dataKey: O, isAnimationActive: k, onAnimationStart: A, onAnimationEnd: j, activeBar: M, activeIndex: N } = x, P = (e, t) => (r) => {
-			h(n({
-				activeDataKey: O,
-				activeIndex: String(t),
+	inheritAttrs: false,
+	setup(_) {
+		const dispatch = useAppDispatch();
+		const activeIndex = useAppSelector(selectActiveTooltipIndex);
+		const activeDataKey = useAppSelector(selectActiveTooltipDataKey);
+		let previousRectangles = null;
+		let animationId = 0;
+		const { props, data: barData, layout, isAnimating, shapeSlot, activeBarSlot, cellProps } = useBarContext();
+		const { dataKey, isAnimationActive, onAnimationStart, onAnimationEnd, activeBar, activeIndex: activeIndexProp } = props;
+		const onMouseEnterFromContext = (entry, index) => (e) => {
+			dispatch(setActiveMouseOverItemIndex({
+				activeDataKey: dataKey,
+				activeIndex: String(index),
 				activeCoordinate: {
-					x: e.tooltipPosition.x,
-					y: e.tooltipPosition.y
+					x: entry.tooltipPosition.x,
+					y: entry.tooltipPosition.y
 				}
 			}));
-		}, F = (t, n) => (t) => {
-			h(e());
-		}, I = (e, n) => (r) => {
-			h(t({
-				activeDataKey: O,
-				activeIndex: String(n),
+		};
+		const onMouseLeaveFromContext = (entry, index) => (e) => {
+			dispatch(mouseLeaveItem());
+		};
+		const onClickFromContext = (entry, index) => (e) => {
+			dispatch(setActiveClickItemIndex({
+				activeDataKey: dataKey,
+				activeIndex: String(index),
 				activeCoordinate: {
-					x: e.tooltipPosition.x,
-					y: e.tooltipPosition.y
+					x: entry.tooltipPosition.x,
+					y: entry.tooltipPosition.y
 				}
 			}));
-		}, L = s(x, !1), R = (e, t) => (n) => e + (t - e) * n, z = (e) => e ? p(f, null, [e.map((e, t) => {
-			let n, r = M !== !1 || N != null || !!E, i = N == null ? r && String(t) === _.value && (v.value == null || O === v.value) : r && t === N, a = i && typeof M == "object" ? M : {}, o = e.payload?.fill, s = D.value?.[t], l = {
-				...L,
-				...o ? { fill: o } : {},
-				...e,
-				...s ?? {},
-				...i ? a : {},
-				isActive: i,
-				index: t,
-				dataKey: O
-			};
-			return p(c, {
-				key: `rectangle-${e?.x}-${e?.y}-${e?.value}-${t}`,
-				class: "v-charts-bar-rectangle",
-				onMouseenter: P(e, t),
-				onMouseleave: F(e, t),
-				onClick: I(e, t)
-			}, g(n = i && E ? E(l) : T ? T(l) : p(d, l, null)) ? n : { default: () => [n] });
-		})]) : null;
+		};
+		const baseProps = filterProps(props, false);
+		const interpolateNumber = (from, to) => (t) => from + (to - from) * t;
+		const renderRectangles = (data) => {
+			if (!data) return null;
+			return createVNode(Fragment, null, [data.map((entry, i) => {
+				let _slot;
+				const activeEnabled = activeBar !== false || activeIndexProp != null || !!activeBarSlot;
+				const isActive = activeIndexProp != null ? activeEnabled && i === activeIndexProp : activeEnabled && String(i) === activeIndex.value && (activeDataKey.value == null || dataKey === activeDataKey.value);
+				const activeBarProps = isActive && typeof activeBar === "object" ? activeBar : {};
+				const entryFill = entry.payload?.fill;
+				const cellPropsForIndex = cellProps.value?.[i];
+				const barRectangleProps = {
+					...baseProps,
+					...entryFill ? { fill: entryFill } : {},
+					...entry,
+					...cellPropsForIndex ?? {},
+					...isActive ? activeBarProps : {},
+					isActive,
+					index: i,
+					dataKey
+				};
+				const renderShape = () => {
+					if (isActive && activeBarSlot) return activeBarSlot(barRectangleProps);
+					if (shapeSlot) return shapeSlot(barRectangleProps);
+					return createVNode(Rectangle, barRectangleProps, null);
+				};
+				return createVNode(Layer, {
+					"key": `rectangle-${entry?.x}-${entry?.y}-${entry?.value}-${i}`,
+					"class": "v-charts-bar-rectangle",
+					"onMouseenter": onMouseEnterFromContext(entry, i),
+					"onMouseleave": onMouseLeaveFromContext(entry, i),
+					"onClick": onClickFromContext(entry, i)
+				}, _isSlot(_slot = renderShape()) ? _slot : { default: () => [_slot] });
+			})]);
+		};
 		return () => {
-			let e = S.value;
-			if (!e) return null;
-			if (k && y !== e) {
-				let t = y;
-				return b++, w.value = !0, p(l, {
-					key: b,
-					transition: x.transition,
-					isActive: k,
-					onAnimationStart: A,
-					onAnimationEnd: () => {
-						w.value = !1, j?.();
+			const data = barData.value;
+			if (!data) return null;
+			if (isAnimationActive && previousRectangles !== data) {
+				const prevData = previousRectangles;
+				animationId++;
+				isAnimating.value = true;
+				return createVNode(Animate, {
+					"key": animationId,
+					"transition": props.transition,
+					"isActive": isAnimationActive,
+					"onAnimationStart": onAnimationStart,
+					"onAnimationEnd": () => {
+						isAnimating.value = false;
+						onAnimationEnd?.();
 					}
-				}, { default: (n) => {
-					let r = n === 1 ? e : e.map((e, r) => {
-						let i = t?.[r];
-						if (i && i.stackedBarStart === e.stackedBarStart) {
-							let t = R(i.x || 0, e.x || 0), r = R(i.y || 0, e.y || 0), a = R(i.width, e.width), o = R(i.height, e.height);
+				}, { default: (t) => {
+					const stepData = t === 1 ? data : data.map((entry, index) => {
+						const prev = prevData?.[index];
+						if (prev && prev.stackedBarStart === entry.stackedBarStart) {
+							const interpolatorX = interpolateNumber(prev.x || 0, entry.x || 0);
+							const interpolatorY = interpolateNumber(prev.y || 0, entry.y || 0);
+							const interpolatorWidth = interpolateNumber(prev.width, entry.width);
+							const interpolatorHeight = interpolateNumber(prev.height, entry.height);
 							return {
-								...e,
-								x: t(n),
-								y: r(n),
-								width: a(n),
-								height: o(n)
+								...entry,
+								x: interpolatorX(t),
+								y: interpolatorY(t),
+								width: interpolatorWidth(t),
+								height: interpolatorHeight(t)
 							};
 						}
-						if (C.value === "horizontal") {
-							let t = R(0, e.height)(n), r = R(e.stackedBarStart, e.y)(n);
+						if (layout.value === "horizontal") {
+							const h = interpolateNumber(0, entry.height)(t);
+							const y = interpolateNumber(entry.stackedBarStart, entry.y)(t);
 							return {
-								...e,
-								y: r,
-								height: t
+								...entry,
+								y,
+								height: h
 							};
 						}
-						let a = R(0, e.width)(n), o = R(e.stackedBarStart, e.x)(n);
+						const w = interpolateNumber(0, entry.width)(t);
+						const x = interpolateNumber(entry.stackedBarStart, entry.x)(t);
 						return {
-							...e,
-							width: a,
-							x: o
+							...entry,
+							width: w,
+							x
 						};
 					});
-					return n > 0 && (y = r), p("g", null, [z(r)]);
+					if (t > 0) previousRectangles = stepData;
+					return createVNode("g", null, [renderRectangles(stepData)]);
 				} });
 			}
-			return w.value = !1, y = e, p("g", null, [z(e)]);
+			isAnimating.value = false;
+			previousRectangles = data;
+			return createVNode("g", null, [renderRectangles(data)]);
 		};
 	}
 });
 //#endregion
-export { _ as BarRectangles };
+export { BarRectangles };

package/dist/es/cartesian/bar/hooks/useBar.mjs

@@ -1,41 +1,53 @@
-import { uniqueId as e } from "../../../utils/data-utils.mjs";
-import { useIsPanorama as t } from "../../../context/PanoramaContextProvider.mjs";
-import { getNormalizedStackId as n } from "../../../utils/chart.mjs";
-import { useAppSelector as r } from "../../../state/hooks.mjs";
-import { useChartLayout as i } from "../../../context/chartLayoutContext.mjs";
-import { useNeedsClip as a } from "../../useNeedsClip.mjs";
-import { selectBarRectangles as o } from "../../../state/selectors/barSelectors.mjs";
-import { computed as s, ref as c, shallowRef as l, useAttrs as u } from "vue";
-import { createContext as d } from "motion-v";
+import { uniqueId } from "../../../utils/data-utils.mjs";
+import { useIsPanorama } from "../../../context/PanoramaContextProvider.mjs";
+import { getNormalizedStackId } from "../../../utils/chart.mjs";
+import { useAppSelector } from "../../../state/hooks.mjs";
+import { useChartLayout } from "../../../context/chartLayoutContext.mjs";
+import { useNeedsClip } from "../../useNeedsClip.mjs";
+import { selectBarRectangles } from "../../../state/selectors/barSelectors.mjs";
+import { computed, ref, shallowRef, useAttrs } from "vue";
+import { createContext } from "motion-v";
 //#region src/cartesian/bar/hooks/useBar.ts
-var [f, p] = d("BarContext");
-function m(d, f, m) {
-	let h = t(), g = u(), _ = i(), { needClip: v } = a(d.xAxisId, d.yAxisId), y = s(() => ({
-		barSize: d.barSize,
-		data: d.data,
-		dataKey: d.dataKey,
-		maxBarSize: d.maxBarSize,
-		minPointSize: d.minPointSize,
-		stackId: n(d.stackId)
-	})), b = r((e) => o(e, d.xAxisId, d.yAxisId, h, y.value)), x = s(() => (_.value === "vertical" || _.value === "horizontal") && !d.hide), S = e("v-charts-bar-"), C = c(!1), w = l([]);
-	return p({
-		clipPathId: S,
-		layout: _,
-		props: d,
-		attrs: g,
-		data: b,
-		isAnimating: C,
-		shapeSlot: f,
-		activeBarSlot: m,
-		cellProps: w
-	}), {
-		shouldRender: x,
-		needClip: v,
-		clipPathId: S,
-		barData: b,
-		isAnimating: C,
-		cellProps: w
+var [useBarContext, provideBarContext] = createContext("BarContext");
+function useBar(props, shapeSlot, activeBarSlot) {
+	const isPanorama = useIsPanorama();
+	const attrs = useAttrs();
+	const layout = useChartLayout();
+	const { needClip } = useNeedsClip(props.xAxisId, props.yAxisId);
+	const barSettings = computed(() => ({
+		barSize: props.barSize,
+		data: props.data,
+		dataKey: props.dataKey,
+		maxBarSize: props.maxBarSize,
+		minPointSize: props.minPointSize,
+		stackId: getNormalizedStackId(props.stackId)
+	}));
+	const rects = useAppSelector((state) => selectBarRectangles(state, props.xAxisId, props.yAxisId, isPanorama, barSettings.value));
+	const shouldRender = computed(() => {
+		return (layout.value === "vertical" || layout.value === "horizontal") && !props.hide;
+	});
+	const clipPathId = uniqueId("v-charts-bar-");
+	const isAnimating = ref(false);
+	const cellPropsRef = shallowRef([]);
+	provideBarContext({
+		clipPathId,
+		layout,
+		props,
+		attrs,
+		data: rects,
+		isAnimating,
+		shapeSlot,
+		activeBarSlot,
+		cellProps: cellPropsRef
+	});
+	return {
+		shouldRender,
+		needClip,
+		clipPathId,
+		barData: rects,
+		isAnimating,
+		cellProps: cellPropsRef
 	};
 }
 //#endregion
-export { m as useBar, f as useBarContext };
+export { useBar, useBarContext };

package/dist/es/cartesian/bar/type.mjs

@@ -1,9 +1,7 @@
+import { classProp } from "../../types/common.mjs";
 //#region src/cartesian/bar/type.ts
-var e = {
-	class: {
-		type: String,
-		default: void 0
-	},
+var BarVueProps = {
+	class: classProp,
 	barSize: { type: [String, Number] },
 	data: {
 		type: Array,
@@ -15,7 +13,7 @@ var e = {
 			Number,
 			Function
 		],
-		required: !0
+		required: true
 	},
 	fill: {
 		type: String,
@@ -49,11 +47,11 @@ var e = {
 	maxBarSize: { type: Number },
 	hide: {
 		type: Boolean,
-		default: !1
+		default: false
 	},
 	background: {
 		type: [Boolean, Object],
-		default: !1
+		default: false
 	},
 	radius: {
 		type: [Number, Array],
@@ -69,7 +67,7 @@ var e = {
 	},
 	isAnimationActive: {
 		type: Boolean,
-		default: !0
+		default: true
 	},
 	activeBar: {
 		type: [
@@ -77,7 +75,7 @@ var e = {
 			Boolean,
 			Function
 		],
-		default: !1
+		default: false
 	},
 	activeIndex: {
 		type: Number,
@@ -99,18 +97,6 @@ var e = {
 		type: [String, Number],
 		default: 0
 	},
-	animationBegin: {
-		type: Number,
-		default: 0
-	},
-	animationDuration: {
-		type: Number,
-		default: 1500
-	},
-	animationEasing: {
-		type: String,
-		default: "ease"
-	},
 	transition: {
 		type: Object,
 		default: {
@@ -120,12 +106,12 @@ var e = {
 	},
 	needClip: {
 		type: Boolean,
-		default: !1
+		default: false
 	},
 	label: {
 		type: [Boolean, Object],
-		default: !1
+		default: false
 	}
 };
 //#endregion
-export { e as BarVueProps };
+export { BarVueProps };

package/dist/es/cartesian/bar/utils.mjs

@@ -1,84 +1,111 @@
-import { isNullish as e, isNumber as t } from "../../utils/validate.mjs";
-import { mathSign as n } from "../../utils/data.mjs";
-import { getBaseValueOfBar as r, getCateCoordinateOfBar as i, getValueByDataKey as a, truncateByDomain as o } from "../../utils/chart.mjs";
-import { toRaw as s } from "vue";
-import { isNaN as c } from "es-toolkit/compat";
-import { invariant as l } from "es-toolkit";
+import { isNullish, isNumber } from "../../utils/validate.mjs";
+import { mathSign } from "../../utils/data.mjs";
+import { getBaseValueOfBar, getCateCoordinateOfBar, getValueByDataKey, truncateByDomain } from "../../utils/chart.mjs";
+import { toRaw } from "vue";
+import { isNaN } from "es-toolkit/compat";
+import { invariant } from "es-toolkit";
 //#region src/cartesian/bar/utils.ts
-function u(n, r = 0) {
-	return (i, a) => {
-		if (t(n)) return n;
-		let o = t(i) || e(i);
-		return o ? n(i, a) : (l(o, `minPointSize callback function received a value with type of ${typeof i}. Currently only numbers or null/undefined are supported.`), r);
+/**
+* Safely gets minPointSize from the minPointSize prop if it is a function
+* @param minPointSize minPointSize as passed to the Bar component
+* @param defaultValue default minPointSize
+* @returns minPointSize
+*/
+function minPointSizeCallback(minPointSize, defaultValue = 0) {
+	return (value, index) => {
+		if (isNumber(minPointSize)) return minPointSize;
+		const isValueNumberOrNil = isNumber(value) || isNullish(value);
+		if (isValueNumberOrNil) return minPointSize(value, index);
+		invariant(isValueNumberOrNil, `minPointSize callback function received a value with type of ${typeof value}. Currently only numbers or null/undefined are supported.`);
+		return defaultValue;
 	};
 }
-var d = 0;
-function f({ layout: e, barSettings: { dataKey: t, minPointSize: l }, pos: f, bandSize: p, xAxis: m, yAxis: h, xAxisTicks: g, yAxisTicks: _, stackedData: v, displayedData: y, offset: b }) {
-	let x = {
-		x: b.left,
-		y: b.top,
-		width: b.width,
-		height: b.height
-	}, S = e === "horizontal" ? h : m, C = v ? S.scale.domain() : null, w = r({ numericAxis: S }), T = S.scale(w);
-	return y.map((r, y) => {
-		let S = s(r), E, D, O, k, A, j;
-		v ? E = o(v[y], C) : (E = a(S, t), Array.isArray(E) || (E = [w, E]));
-		let M = u(l, d)(E[1], y);
-		if (e === "horizontal") {
-			let [e, t] = [h.scale(E[0]), h.scale(E[1])];
-			D = i({
-				axis: m,
-				ticks: g,
-				bandSize: p,
-				offset: f.offset,
-				entry: S,
-				index: y
-			}), O = t ?? e ?? void 0, k = f.size;
-			let r = e - t;
-			if (A = c(r) ? 0 : r, j = {
-				x: D,
-				y: b.top,
-				width: k,
-				height: b.height
-			}, Math.abs(M) > 0 && Math.abs(A) < Math.abs(M)) {
-				let e = n(A || M) * (Math.abs(M) - Math.abs(A));
-				O -= e, A += e;
+var defaultMinPointSize = 0;
+function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: minPointSizeProp }, pos, bandSize, xAxis, yAxis, xAxisTicks, yAxisTicks, stackedData, displayedData, offset }) {
+	const parentViewBox = {
+		x: offset.left,
+		y: offset.top,
+		width: offset.width,
+		height: offset.height
+	};
+	const numericAxis = layout === "horizontal" ? yAxis : xAxis;
+	const stackedDomain = stackedData ? numericAxis.scale.domain() : null;
+	const baseValue = getBaseValueOfBar({ numericAxis });
+	const stackedBarStart = numericAxis.scale(baseValue);
+	return displayedData.map((rawEntry, index) => {
+		const entry = toRaw(rawEntry);
+		let value, x, y, width, height, background;
+		if (stackedData) value = truncateByDomain(stackedData[index], stackedDomain);
+		else {
+			value = getValueByDataKey(entry, dataKey);
+			if (!Array.isArray(value)) value = [baseValue, value];
+		}
+		const minPointSize = minPointSizeCallback(minPointSizeProp, defaultMinPointSize)(value[1], index);
+		if (layout === "horizontal") {
+			const [baseValueScale, currentValueScale] = [yAxis.scale(value[0]), yAxis.scale(value[1])];
+			x = getCateCoordinateOfBar({
+				axis: xAxis,
+				ticks: xAxisTicks,
+				bandSize,
+				offset: pos.offset,
+				entry,
+				index
+			});
+			y = currentValueScale ?? baseValueScale ?? void 0;
+			width = pos.size;
+			const computedHeight = baseValueScale - currentValueScale;
+			height = isNaN(computedHeight) ? 0 : computedHeight;
+			background = {
+				x,
+				y: offset.top,
+				width,
+				height: offset.height
+			};
+			if (Math.abs(minPointSize) > 0 && Math.abs(height) < Math.abs(minPointSize)) {
+				const delta = mathSign(height || minPointSize) * (Math.abs(minPointSize) - Math.abs(height));
+				y -= delta;
+				height += delta;
 			}
 		} else {
-			let [e, t] = [m.scale(E[0]), m.scale(E[1])];
-			if (D = e, O = i({
-				axis: h,
-				ticks: _,
-				bandSize: p,
-				offset: f.offset,
-				entry: S,
-				index: y
-			}), k = t - e, A = f.size, j = {
-				x: b.left,
-				y: O,
-				width: b.width,
-				height: A
-			}, Math.abs(M) > 0 && Math.abs(k) < Math.abs(M)) {
-				let e = n(k || M) * (Math.abs(M) - Math.abs(k));
-				k += e;
+			const [baseValueScale, currentValueScale] = [xAxis.scale(value[0]), xAxis.scale(value[1])];
+			x = baseValueScale;
+			y = getCateCoordinateOfBar({
+				axis: yAxis,
+				ticks: yAxisTicks,
+				bandSize,
+				offset: pos.offset,
+				entry,
+				index
+			});
+			width = currentValueScale - baseValueScale;
+			height = pos.size;
+			background = {
+				x: offset.left,
+				y,
+				width: offset.width,
+				height
+			};
+			if (Math.abs(minPointSize) > 0 && Math.abs(width) < Math.abs(minPointSize)) {
+				const delta = mathSign(width || minPointSize) * (Math.abs(minPointSize) - Math.abs(width));
+				width += delta;
 			}
 		}
 		return {
-			x: D,
-			y: O,
-			width: k,
-			height: A,
-			stackedBarStart: T ?? 0,
-			value: v ? E : E[1],
-			payload: S,
-			background: j,
+			x,
+			y,
+			width,
+			height,
+			stackedBarStart: stackedBarStart ?? 0,
+			value: stackedData ? value : value[1],
+			payload: entry,
+			background,
 			tooltipPosition: {
-				x: D + k / 2,
-				y: O + A / 2
+				x: x + width / 2,
+				y: y + height / 2
 			},
-			parentViewBox: x
+			parentViewBox
 		};
 	});
 }
 //#endregion
-export { f as computeBarRectangles };
+export { computeBarRectangles };