@astrato-io/visualizations 0.6.4 → 0.6.5

package/chunks/standalone-DUDFTBqL.js

@@ -0,0 +1,833 @@
+import { o as e, r as t } from "./rolldown-runtime-DleVn1XH.js";
+import { An as n, Cn as r, Cs as i, Fn as a, Gn as o, Io as s, Is as c, Ja as l, Ks as u, Lc as d, Mo as f, No as p, Ns as m, Pa as h, Sa as g, Si as _, Ta as v, Uc as y, Ys as b, Zr as x, fc as S, mc as ee, qr as te } from "./isEqual-BDxAhUo8.js";
+import { $t as ne, Ei as re, I as ie, P as ae, Yi as oe, Zi as se, d as ce, o as le } from "./utils-Bg7K-t6K.js";
+import { Bm as C, Pm as w, Vm as ue, xd as T } from "./handlers-VTBfIZYZ.js";
+import { Vt as E, mt as D } from "./ui-DQWtv2iM.js";
+import { n as de, t as fe } from "./grouping-type-On4s9Thj.js";
+import { At as pe, Bt as me, Ct as he, Ft as O, G as ge, Gt as k, Ht as _e, I as ve, Jt as A, M as ye, Mt as be, N as xe, Nt as Se, Ot as j, Pt as Ce, Q as we, Qt as M, Rt as Te, St as Ee, Tt as De, U as Oe, V as ke, Wt as Ae, X as je, Xt as N, Yt as P, Z as F, Zt as I, _t as Me, an as L, at as Ne, dn as R, et as z, i as Pe, in as Fe, j as Ie, jt as Le, mt as B, n as Re, nt as ze, q as Be, rn as V, rt as H, sn as Ve, st as He, tt as U, un as W, ut as Ue, vt as We, zt as Ge } from "./escobar-eDjtGpkC.js";
+import { t as Ke } from "./coloring-B1XAfg6b.js";
+import { t as qe } from "./set-coloring-datafield-B3uIS1Pe.js";
+var Je = /* @__PURE__ */ e(oe()), Ye = (e, t, n) => {
+	let r = e.dimensions.filter((e) => _(e)), i = e.measures.filter((e) => _(e)), a = {
+		showAxisTooltip: e?.axes?.dimension?.showAxisTooltip,
+		formatter: r[0]?.formatter || {
+			type: "string",
+			format: ""
+		},
+		scale: P(e),
+		key: `${j.Dimension}-${e.orientation ?? p.Vertical}`,
+		settings: { direction: pe(e) }
+	}, o = i[0], [s, c] = Se([a, {
+		showAxisTooltip: e?.axes?.primaryMeasure?.showAxisTooltip,
+		formatter: o?.formatter,
+		scale: N(e, o),
+		key: `${j.Measure}-${e.orientation ?? p.Vertical}`,
+		settings: {
+			direction: be(e),
+			labelDock: Le(I(e), o?.secondaryAxis)
+		}
+	}]);
+	return {
+		...n,
+		components: [...n.components ?? [], ...s],
+		interactions: [...n.interactions ?? [], ...c]
+	};
+}, Xe = se(), Ze = (e, t, n) => {
+	let r = de(e, t), i = fe(n);
+	return r.includes(i) || (i = r[0]), {
+		grouped: i === T.Groups,
+		stacked: i === T.Stacked,
+		offset: i === T.Offset,
+		single: i === T.Bars
+	};
+}, Qe = (e, t) => {
+	let n = [
+		w.Inside,
+		w.Outside,
+		w.Opposite
+	];
+	return t && (n = [w.Inside]), (e || [
+		{
+			position: w.Inside,
+			justify: 1
+		},
+		{
+			position: w.Outside,
+			justify: 0
+		},
+		{
+			position: w.Opposite,
+			justify: 0
+		}
+	]).map((e) => ({
+		...e,
+		possible: n.includes(e.position)
+	}));
+}, G = (e) => {
+	let t = e.measures.filter((e) => _(e)), r = e.dimensions.filter((e) => _(e)), i = t.length > 1, a = r.length > 1, o = t.length > 0 && r.length === 0, { grouped: s, stacked: c, offset: l } = Ze(r.length, t.length, e.barSettings), u = {
+		...e.barSettings.offset,
+		enabled: l
+	}, d = s ? e.barSettings.groupPadding : e.barSettings.barPadding, f = e.barSettings.barPadding, p = e.coloring?.type !== b.Gradient && e.barSettings.translucentBars, m = n(e.barSettings.barRadius, 0);
+	return {
+		isMeasureOnly: o,
+		isMultiMeasure: i,
+		isMultiDimension: a,
+		stacked: c,
+		stackedOffset: e.barSettings.stackedOffset,
+		offset: u,
+		barRadius: m,
+		grouped: s,
+		barPadding: d ?? Ve.scale.padding,
+		groupPadding: f ?? Ve.scale.padding,
+		translucentBars: p,
+		roundAllEdges: e.barSettings.roundAllEdges,
+		useCustomBoxRounding: !!m,
+		ignoreOutOfBounds: e.barSettings.ignoreOutOfBounds
+	};
+}, $e = (e, t) => {
+	let [, n] = e.dimensions.filter((e) => _(e)), r = G(e);
+	return e.coloring?.type === b.Categorical ? r.isMultiDimension ? S(n?.dataItem) : he(e, t) : De(e);
+}, et = (e) => {
+	let { stacked: t } = G(e);
+	if (t && "barSettings" in e && e.barSettings?.stackedOffset === C.Expand) {
+		let t = e.measures.map((e) => ({
+			...e,
+			formatter: {
+				type: "excel-format",
+				format: { formatType: s.Percentage1Decimal }
+			}
+		}));
+		return {
+			...e,
+			measures: t
+		};
+	}
+	return { ...e };
+}, tt = (e, t) => {
+	if (t.min && t.max) {
+		let n = t.min(), r = t.max(), i = e.data.start?.value, a = e.data.end?.value;
+		return i < n && a < n || i > r && a > r;
+	}
+	return !1;
+}, nt = (e) => {
+	let t = I(e);
+	return (d(e) ? e.measures.filter((e) => _(e) && !e.secondaryAxis) : []).length > 0 ? t ? M.XAxisScale : M.YAxisScale : t ? M.X2AxisScale : M.Y2AxisScale;
+}, K = (e) => {
+	if (typeof e == "number") return e;
+	if (e && typeof e == "object" && "value" in e && typeof e.value == "number") return e.value;
+}, rt = (e) => {
+	if (typeof e == "string" || typeof e == "number") return e;
+	if (e && typeof e == "object" && "value" in e) {
+		let t = e.value;
+		return typeof t == "string" || typeof t == "number" ? t : void 0;
+	}
+}, q = (e) => String(rt(e.stackKey) ?? rt(e.value)), J = (e, t) => {
+	let n = K(e.start), r = K(e.end);
+	return typeof n == "number" && typeof r == "number" ? r - n : t ? K(e[t]) : void 0;
+}, it = (e, t, n, r, a, o, s, c) => {
+	let l = e.dimensions.filter((e) => _(e)), { stacked: u, isMeasureOnly: d } = G(e), p = e;
+	u && !d && (p = et(e), p.measures = p.measures.filter((e) => e.secondaryAxis !== !0)), n = Te(p, t, n, r, a, o, s, c);
+	let m = [], h = [];
+	if (!l.length && "axes" in e) {
+		let n = e.axes?.dimension || {};
+		if (!n.disabled) {
+			let r;
+			if (r = I(e) ? e.axes?.dimension?.secondaryAxis ? f.Right : f.Left : e.axes?.dimension?.secondaryAxis ? f.Top : f.Bottom, m.push(Ge("onlyMeasures", n, {
+				...t.axis.measure,
+				...t.fonts
+			}, r)), n.showAxisName) {
+				let a = x(e.dimensions, e.enableAlternate, o?.isPrintMode);
+				h.push(me([{ dataItem: {
+					internalKey: "Measures",
+					uniqueSignature: i(),
+					name: "Measures",
+					schema: "",
+					view: "",
+					type: y.Dimension,
+					dataType: Xe.FieldType.FLOAT
+				} }], a, r, {
+					...t.axis.measure,
+					...t.fonts
+				}, void 0, void 0, n?.titleFontSize));
+			}
+		}
+	}
+	return {
+		...n,
+		components: [
+			...n.components,
+			...m,
+			...h
+		]
+	};
+}, at = .2, ot = (e, t) => ({ data: n }) => {
+	let r = /* @__PURE__ */ new Map();
+	return (n.items || []).forEach((e) => {
+		if (!e || typeof e != "object") return;
+		let n = e, i = J(n, t);
+		if (typeof i == "number") {
+			let e = q(n);
+			r.set(e, (r.get(e) || 0) + i);
+		}
+	}), (r.size ? [...r.values()].some((t) => e ? t < 0 : t > 0) : (n.fields || []).some((t) => e ? t.min() < 0 : t.max() > 0)) ? at : 0;
+}, st = (e, t, n, i, s, c, l) => {
+	let d = e.dimensions.filter((e) => _(e)), f = e.measures.filter((e) => _(e)), p = G(e), m = $e(e, l), h = d[0], g = d.length, v = f.length, y = !1, b = {};
+	if (h && "axes" in e && e?.axes?.dimension?.continuousAxis) {
+		let e = ee(h?.dataItem), t = !!h.datePart, n = r(e) || a(e);
+		y = !t && n;
+	}
+	let x = y ? L.Linear : L.Band;
+	if (b = Ee(qe(e, m), t, b, n.collections, l), b = ge(e, b, n.collections, y), p.grouped) {
+		let e, t;
+		p.isMultiDimension ? (e = S(d[1]?.dataItem), t = { extract: { field: e } }) : p.isMultiMeasure && (e = "measures", t = f.map((e) => S(e.dataItem))), b[e] = {
+			data: t,
+			type: x,
+			min: 0,
+			max: 1,
+			padding: p.groupPadding
+		};
+	}
+	if (p.stacked || p.offset?.enabled && g === 1 && v === 1) {
+		let t = f[0].secondaryAxis ? e.axes?.secondaryMeasure : e.axes?.primaryMeasure, n = ke(t);
+		b[N(e, f[0])] = {
+			invert: Oe(!I(e), t),
+			data: { collection: M.Collection },
+			...n,
+			...p.stacked && e.barSettings.showTotal && n.type !== L.Log ? {
+				expandMin: ot(!0, S(f[0]?.dataItem)),
+				expandMax: ot(!1, S(f[0]?.dataItem))
+			} : {}
+		};
+	}
+	return p.isMeasureOnly && (b.onlyMeasures = {
+		data: { items: f.map((e) => {
+			let t = o(e) || e.label || e.dataItem.name;
+			return {
+				value: S(e.dataItem),
+				label: t
+			};
+		}) },
+		padding: p.barPadding,
+		type: x,
+		value: (e) => `${e.datum.value.value}`,
+		label: (e) => `${e.datum.value.label}`
+	}, p.stacked && (b[N(e, f[0])].data = { collection: "collection-no-dimension" }, b.onlyMeasures.data = { items: [{
+		value: "measures",
+		label: "measures"
+	}] })), e.type === u.Bar && f.forEach((t) => {
+		let n = t.secondaryAxis ? e.axes?.secondaryMeasure : e.axes?.primaryMeasure;
+		if (n?.axisRange || n?.scale === ue.Log) return;
+		let r = b[N(e, t)];
+		r && (r.include = [0]);
+	}), {
+		...n,
+		scales: b
+	};
+}, ct = { outOfRangeTitle: "axis out range" }, Y = {
+	StackTotal: "stackTotal",
+	StackTotalLabel: "stackTotalLabel",
+	Ratio: "ratio"
+}, X = { Share: "share" }, lt = (e, t, n, r, i, a, o) => {
+	let c = e.dimensions.filter((e) => _(e)), l = e.measures.filter((e) => _(e)), u = ye((e.supportingMeasures ?? []).filter((e) => _(e))), [d, f] = c, p = l[0], m = G(e), h = S(d?.dataItem), g = S(f?.dataItem), v = S(p?.dataItem);
+	if (m.isMeasureOnly) {
+		let e = [];
+		l.forEach((t) => {
+			let n = S(t.dataItem);
+			e.push({
+				field: n,
+				props: {
+					stackKey: "measures",
+					[n]: { field: n },
+					...u,
+					series: n,
+					[k.property]: _e(t),
+					start: 0,
+					color: n,
+					end: { field: n },
+					secondaryAxis: t.secondaryAxis,
+					isMultipleMeasures: m.isMultiMeasure
+				}
+			});
+		});
+		let t = {
+			key: "collection-no-dimension",
+			data: {
+				extract: e,
+				filter: (e) => (e[k.property].source = {
+					field: k.field,
+					key: k.sourceKey
+				}, !0)
+			}
+		};
+		return m.stacked && (t.data.stack = {
+			stackKey: (e) => `${e.stackKey.value}`,
+			value: (e) => e.end.value,
+			offset: C.Diverging
+		}), {
+			...n,
+			collections: [t]
+		};
+	}
+	let y = {
+		key: "collection",
+		data: { extract: [] }
+	};
+	if (m.isMultiMeasure) {
+		let e = l.reduce((e, t) => {
+			let n = S(t.dataItem);
+			return e[n] = { field: n }, e;
+		}, {});
+		y.data.extract = l.map((t) => {
+			let n = S(t.dataItem);
+			return {
+				field: h,
+				props: {
+					end: { field: n },
+					series: n,
+					color: n,
+					...e,
+					...u,
+					start: 0,
+					secondaryAxis: t.secondaryAxis,
+					isMultipleMeasures: m.isMultiMeasure
+				}
+			};
+		});
+	} else {
+		let t = $e(e, o), n = "coloring" in e && e.coloring?.type === b.Single;
+		y.data.extract.push({
+			field: h,
+			props: {
+				...m.isMultiDimension && { series: { field: g } },
+				start: 0,
+				end: { field: v },
+				color: n ? v : { field: t },
+				[v]: { field: v },
+				...u,
+				secondaryAxis: p.secondaryAxis,
+				isMultipleMeasures: m.isMultiMeasure
+			}
+		});
+	}
+	if (m.stacked && "barSettings" in e) y.data.stack = {
+		stackKey: (e) => `${e.value}`,
+		value: (e) => e.end.value,
+		offset: e.barSettings?.stackedOffset || C.Diverging
+	};
+	else if (m.offset?.enabled) {
+		let e = m.offset?.totalLabel ?? "Total";
+		y.data.stack = {
+			stackKey: m.offset?.showTotal ? (t) => +(t.value === e) : () => 0,
+			value: (e) => e.end.value
+		};
+	}
+	let x = { [X.Share]: {
+		type: "excel-format",
+		format: { formatType: s.Percentage1Decimal }
+	} };
+	return l?.forEach((e, t) => {
+		x[`measure-${t}`] = e.formatter || {
+			type: "excel-format",
+			format: { formatType: s.None }
+		};
+	}), {
+		...n,
+		collections: [y],
+		formatters: x
+	};
+}, ut = (e, t) => t || e.colors.brandColors[0], dt = (e, t, n, r) => {
+	let i = e.dimensions.filter((e) => _(e)), a = e.measures.filter((e) => _(e));
+	if (!i?.[0] || !r.offset?.enabled || !r.offset?.showLine) return null;
+	let o = P(e), s = N(e, a[0]), c = {
+		scale: o,
+		fn: n.scales[o]?.type === L.Linear ? void 0 : (e) => {
+			let t = e.scale;
+			return t(e.datum.value) + t.bandwidth();
+		}
+	}, l = {
+		scale: o,
+		fn: (e, t) => e.data.items[t + 1] ? e.scale(e.data.items[t + 1].value) : 1
+	}, u = {
+		scale: s,
+		ref: "end"
+	}, d = e.orientation === p.Horizontal ? {
+		y0: c,
+		y1: l,
+		x0: u,
+		x1: u
+	} : {
+		y0: u,
+		y1: u,
+		x0: c,
+		x1: l
+	};
+	return {
+		key: "bar-bridge",
+		type: R.LineCoord,
+		data: { collection: "collection" },
+		settings: {
+			...d,
+			show: (e, t) => !!e.data.items[t + 1],
+			stroke: r.offset.lineColor ?? t.axis.dimension.lineColor,
+			strokeWidth: 1,
+			strokeDasharray: "2 2",
+			opacity: 1
+		},
+		animations: {
+			enabled: !0,
+			presetId: "simple-opacity"
+		}
+	};
+}, ft = (e, t) => (n) => {
+	if (typeof n.datum.end.value != "number") return null;
+	let r = new D(typeof t == "function" ? t(n) : t), i = [{
+		color: r.rgb(),
+		opacity: 1,
+		offset: +(n.datum.end.value < 0)
+	}, {
+		color: r.rgb(),
+		opacity: .65,
+		offset: n.datum.end.value < 0 ? 0 : 1
+	}];
+	return n.datum.end.value < 0 && i.reverse(), {
+		type: "gradient",
+		degree: I(e) ? 0 : 90,
+		stops: i
+	};
+}, pt = (e, t, n, r, i, a) => {
+	let o = e.dimensions.filter((e) => _(e)), s = e.measures.filter((e) => _(e)), c = G(e), l = { scale: P(e) };
+	c.isMeasureOnly && (l = {
+		scale: "onlyMeasures",
+		ref: c.stacked ? "stackKey" : "series"
+	});
+	let u = new Ke(e, t, i?.[0]?.itemsNotAffectedByFiltering), d = o.reduce((e, t) => (e[S(t.dataItem)] = !0, e), {}), f = s.reduce((n, r, i) => {
+		if (c.stacked && i !== 0) return n;
+		let o = { collection: M.Collection };
+		if (c.isMeasureOnly && (o = {
+			collection: "collection-no-dimension",
+			filter: (e) => c.stacked || e?.source?.field === S(r.dataItem)
+		}), c.grouped) {
+			let e = S(r.dataItem);
+			o = {
+				...o,
+				filter: (t) => t.series?.source?.field ? d[t.series?.source?.field] : t.series?.value === e
+			};
+		}
+		let s = { overwriteSources: [u.MAIN_FIELD, "series"] };
+		(e.coloring?.type === b.Categorical || e.coloring?.type === b.Gradient) && (s.ref = "color");
+		let f = u.getColorDefinition(s);
+		c?.translucentBars && (f = ft(e, f));
+		let p = {
+			scale: N(e, r),
+			ref: "end"
+		}, m = _t(e, t, l, p, f);
+		return [...n, gt(e, r, m, o, a)];
+	}, []);
+	if (m(e)) {
+		let r = dt(e, t, n, c);
+		r && f.push(r);
+	}
+	return {
+		...n,
+		components: [...n.components, ...f]
+	};
+}, mt = (e) => {
+	let t = [], n = e.dimensions.filter((e) => _(e));
+	return n.length || t.push(k.property), n?.[0] && t.push(""), n?.[1] && t.push("series"), t;
+}, ht = (e) => {
+	let t, n = G(e), r = e.measures.filter((e) => _(e));
+	if (n.stacked && r.length > 0) {
+		let e = S(r[0].dataItem);
+		t = function() {
+			let t = {}, r = {}, i = {}, a = (e) => {
+				let t = e.end?.value;
+				return typeof t == "number" ? t : void 0;
+			}, o = this.data.items;
+			o.forEach((n) => {
+				let o = q(n), s = J(n, e);
+				if (r[o] || (r[o] = {
+					positive: void 0,
+					negative: void 0
+				}), i[o] || (i[o] = {
+					highest: void 0,
+					lowest: void 0
+				}), typeof s == "number") {
+					t[o] = (t[o] || 0) + s, s > 0 ? r[o].positive = n : s < 0 && (r[o].negative = n);
+					let e = a(n);
+					if (typeof e == "number") {
+						let { highest: t, lowest: r } = i[o];
+						(!t || e > a(t)) && (i[o].highest = n), (!r || e < a(r)) && (i[o].lowest = n);
+					}
+				}
+			}), o.forEach((a) => {
+				let o = q(a), s = t[o] || 0, c = (s >= 0 ? i[o].highest : i[o].lowest) ?? (s >= 0 ? r[o].positive : r[o].negative);
+				if (a[Y.StackTotal] = { value: s }, a[Y.StackTotalLabel] = { value: +(c === a) }, n.isMultiDimension) {
+					let t = J(a, e), n = typeof t == "number" && s !== 0 ? t / s : 0;
+					a[Y.Ratio] = { value: Number.isFinite(n) ? n : 0 };
+				}
+			});
+		};
+	}
+	return t;
+}, gt = (e, t, n, r, i) => {
+	let a = ht(e), o = e.dimensions.filter((e) => _(e)).length > 1, s = e.measures.filter((e) => _(e)), c = G(e).stacked && o && s.length === 1, l = Ae(mt(e), i, { valuePickerMode: i?.valuePickerMode }, c ? W.AndSubset : void 0);
+	return {
+		type: R.Box,
+		layout: { displayOrder: O.VisualizationElement },
+		key: B(e, t, u.Bar),
+		data: r,
+		settings: n,
+		animations: {
+			enabled: !0,
+			presetId: "bar-chart"
+		},
+		beforeRender: a,
+		brush: l
+	};
+}, _t = (e, t, r, i, a) => {
+	let o = e.dimensions.filter((e) => _(e)), s = e.measures.filter((e) => _(e)), [, c] = o, l = G(e), u = {
+		orientation: e.orientation ?? p.Vertical,
+		major: r,
+		minor: i,
+		box: {
+			minWidthPx: 2,
+			ref: "",
+			rx: n(l.barRadius, 0),
+			fill: a,
+			stacked: l.stacked,
+			grouped: l.grouped,
+			boxPadding: l.barPadding,
+			groupPadding: l.groupPadding,
+			itemsInStackCount: s?.length,
+			roundAllEdges: l.roundAllEdges ?? !1,
+			useCustomBoxRounding: l.useCustomBoxRounding ?? !1,
+			ignoreOutOfBounds: l.ignoreOutOfBounds ?? !1
+		}
+	};
+	if (e.barSettings?.strokeEnabled ? (u.box.stroke = ut(t, e.barSettings?.strokeColor), u.box.strokeWidth = e.barSettings?.strokeWidth) : u.box.stroke = v.transparent, !l.isMeasureOnly && l.grouped && !e?.axes?.dimension?.continuousAxis) {
+		let t = l.isMultiDimension ? S(c?.dataItem) : "measures";
+		u.major.fn = (n) => {
+			let r = n.resources.scale(P(e)), i = n.resources.scale(t), a = r.bandwidth(), o = i.bandwidth();
+			return Number(r(n.datum.value)) + .5 * a - .5 * (1 / o - 1) * o * a + a * Number(i(n.datum.series.value));
+		}, u.box.width = (e) => e.resources.scale(t).bandwidth();
+	}
+	return u;
+}, vt = new D(E.fontLight), yt = new D(E.fontDark), bt = (e) => {
+	switch (!0) {
+		case e.grouped: return "grouped";
+		case e.stacked: return "stacked";
+		default: return "normal";
+	}
+}, xt = (e, t, n, r, i, a) => {
+	let o = G(e), s = e.dimensions.filter(_), c = e.measures.filter(_), l = c[0], d = o.stacked && s.length > 1 && c.length === 1;
+	if (!l?.dataLabels?.show) return n;
+	let f = S(l.dataItem), p = new D(t.fonts.general.color), m = ({ node: e }) => {
+		let t = e.attrs, n = t?.fill && t.fill !== "transparent", r = n && t.fill?.type === "gradient" ? t.fill?.stops?.[0]?.color : t?.fill;
+		return new D(n ? r : "#ffffff").betterContrast(p, vt, yt).rgb();
+	}, g = [], v = l.dataLabels.displayParts?.includes(h.Value), y = l.dataLabels.displayParts?.includes(h.Ratio);
+	(v || !l.dataLabels.displayParts && o.stackedOffset !== C.Expand) && g.push({
+		id({ node: e }) {
+			return `${e.data._ID}::value`;
+		},
+		linkData({ node: e }) {
+			return e.data;
+		},
+		fill: m,
+		label({ node: e, formatter: t }) {
+			return t("measure-0")(e.data[f].value, void 0, e.data);
+		},
+		hideEllipsed: !0
+	}), (y || !l.dataLabels.displayParts && o.stackedOffset === C.Expand) && g.push({
+		id({ node: e }) {
+			return `${e.data._ID}::ratio`;
+		},
+		linkData({ node: e }) {
+			return e.data;
+		},
+		fill: m,
+		label({ node: e, formatter: t }) {
+			return t(X.Share)(e.data[Y.Ratio].value);
+		},
+		hideEllipsed: !0
+	});
+	let b = {
+		key: "bar-labels-stacked-0",
+		type: R.Labels,
+		layout: { displayOrder: O.Labels },
+		settings: { sources: [{
+			component: B(e, e.measures.filter(_)?.[0], u.Bar),
+			selector: V.Rect,
+			strategy: {
+				type: "rows",
+				settings: {
+					justify: .5,
+					align: .5,
+					fontSize: A(l.dataLabels?.size),
+					fontFamily: t.fonts.general.fontFamily,
+					labels: g
+				}
+			}
+		}] },
+		...a?.disable?.brushing ? {} : { brush: { consume: [{
+			context: Fe.Selection,
+			data: ["", "series"],
+			mode: d ? W.AndSubset : W.And,
+			style: { inactive: { opacity: .3 } }
+		}] } },
+		animations: {
+			presetId: "simple-opacity",
+			enabled: !0
+		}
+	};
+	return {
+		...n,
+		components: [...n.components, b]
+	};
+}, St = (e, t, n) => {
+	let r = G(e), i = ({ data: t }) => t ? t.end.value > t.start.value ? I(e) ? "right" : "up" : I(e) ? "left" : "down" : null, a = I(e), o = [], s = e.measures.filter(_);
+	return e.measures.forEach((n, c) => {
+		if (n.dataLabels?.show) {
+			let l = s.indexOf(n), d = r.stacked ? e.measures.filter(_)?.[0] : n, f = bt(r), p = Qe(n.dataLabels.barLabelPlacements, r.stacked).filter((e) => e.possible).map((e) => ({
+				position: e.position,
+				justify: e.justify,
+				overflow: [w.Outside, w.Opposite].includes(e.position),
+				fill: e.position === w.Inside ? "#fff" : "#242424"
+			}));
+			n.dataLabels?.showBackdrop && !r.stacked && (p = p.map((e) => xe(e, t, a, n.dataLabels?.backdropColor))), o.push({
+				key: `bar-labels-${f}-${c}`,
+				type: R.Labels,
+				layout: { displayOrder: O.Labels },
+				settings: { sources: [{
+					component: B(e, d, u.Bar),
+					selector: V.Rect,
+					strategy: {
+						type: "bar",
+						settings: {
+							direction: i,
+							fontSize: A(n.dataLabels?.size),
+							fontFamily: t.fonts.general.fontFamily,
+							labels: [{
+								label: ve(n, l >= 0 ? `measure-${l}` : void 0),
+								placements: p
+							}]
+						}
+					}
+				}] },
+				animations: {
+					enabled: !0,
+					presetId: "chart-labels"
+				}
+			});
+		}
+	}), {
+		...n,
+		components: [...n.components, ...o]
+	};
+}, Ct = (e, t, n, r, i, a) => {
+	let o = G(e);
+	return o.isMultiDimension && o.stacked ? xt(e, t, n, r, i, a) : St(e, t, n, r);
+}, wt = (e) => {
+	let t = e.measures.filter(_), n = t[t.length - 1];
+	return !!n?.formatter && te(n.formatter);
+}, Tt = (e, t) => {
+	let n = t.data[Y.StackTotal]?.value;
+	return typeof n == "number" ? n : e.measures.filter(_).reduce((e, n) => {
+		let r = t.data[S(n.dataItem)]?.value;
+		return e + (typeof r == "number" ? r : 0);
+	}, 0) || void 0;
+}, Et = (e) => ({ node: t }) => {
+	let n = Tt(e, t);
+	if (typeof n != "number") return null;
+	let r = n >= 0;
+	return I(e) ? r ? "right" : "left" : r ? "up" : "down";
+}, Dt = (e, t, n) => {
+	if (t.data[Y.StackTotalLabel]) return Math.round(t.data[Y.StackTotalLabel].value) === 1;
+	let r = t.data.end?.value;
+	if (typeof r != "number" || e.barSettings.stackedOffset === C.Expand) return !1;
+	if (t.data[Y.StackTotal]) return Math.round(r) === Math.round(n);
+	let i = [...e.measures.filter(_)].reverse().find((e) => {
+		let r = t.data[S(e.dataItem)]?.value;
+		return typeof r == "number" && (n >= 0 ? r > 0 : r < 0);
+	});
+	return t.data.series?.value === S(i?.dataItem);
+}, Ot = (e, t) => {
+	if (!e.barSettings.showTotal || !G(e).stacked) return;
+	let n = e.measures.filter(_), r = n[0], i = n.length - 1;
+	if (!(!r || i < 0)) return {
+		key: "bar-labels-stacked-total",
+		type: R.Labels,
+		layout: { displayOrder: O.Labels },
+		settings: { sources: [{
+			component: B(e, r, u.Bar),
+			selector: V.Rect,
+			strategy: {
+				type: "bar",
+				settings: {
+					direction: Et(e),
+					fontSize: A(r.dataLabels?.size),
+					fontFamily: t.fonts.general.fontFamily,
+					labels: [{
+						label({ node: t, formatter: n }) {
+							let r = Tt(e, t);
+							if (r === void 0 || !Dt(e, t, r)) return "";
+							if (e.barSettings.stackedOffset === C.Expand) {
+								let t = r < 0 ? -1 : 1;
+								return wt(e) ? n(X.Share)(t) : String(t);
+							}
+							return n(`measure-${i}`)(r);
+						},
+						placements: [{
+							position: w.Outside,
+							fill: "#242424",
+							justify: 0,
+							overflow: !0
+						}]
+					}]
+				}
+			}
+		}] },
+		animations: {
+			enabled: !0,
+			presetId: "chart-labels"
+		}
+	};
+}, kt = (e, t, n) => {
+	let r = Ot(e, t);
+	return r ? {
+		...n,
+		components: [...n.components, r]
+	} : n;
+}, At = (e, t, n, r, i) => {
+	let a = e.measures.filter((e) => _(e)), o = G(e), s = a.map((t) => B(e, t, u.Bar)), c = jt(e), l = o.grouped && o.isMultiMeasure ? U(e, i) : void 0, d = F(e, t, ze, c, i && i[0] ? i[0].sum : void 0, l);
+	if (o.stacked) {
+		let n = U(e, i), r = o?.stackedOffset === C.Expand, a = o.isMultiDimension ? Nt(n, r) : Pt(n, r);
+		d = F(et(e), t, a, c);
+	}
+	return o.isMeasureOnly && (d = F(e, t, Ft, c)), je(e, t, n, {
+		filter: (e) => e.filter((e) => s.findIndex((t) => t === e.key) !== -1),
+		placement: {
+			type: "bounds",
+			area: "target"
+		},
+		extract: d
+	}, `tooltip-${R.Box}`);
+}, jt = (e) => (t, n, r) => [Mt(e, n, r), we(t, n, r)].filter((e) => e?.length > 0).join("\n"), Mt = (e, t, n) => {
+	let r = nt(e);
+	return tt(t, n.scale(r)) ? ct.outOfRangeTitle : "";
+}, Z = (e, t, n, r, i) => {
+	let a = i && !l(e.formatter) ? H(e.formatter) : e.formatter;
+	return r.formatter(a)(t, void 0, n.data);
+}, Nt = (e, t = !1) => (n, r, i, a, s, c, l, u) => {
+	let d = n.filter((e) => _(e)), f = z(i), p = d.filter((e) => !f.has(S(e.dataItem))), m = d.map((e) => {
+		let t = S(e.dataItem), n = Object.keys(r.data).find((t) => r.data[t]?.source?.field === S(e.dataItem)), a;
+		if (r.data.end?.value !== void 0 && r.data.start?.value !== void 0 && !f.has(t)) a = r.data.end.value - r.data.start.value;
+		else if (n) a = r.data[n].value;
+		else return {
+			label: "",
+			value: ""
+		};
+		let s = o(e), c = a;
+		return (e.formatter || u) && (c = Z(e, a, r, i, u)), {
+			label: s || e.label || e.dataItem.name || "",
+			value: c
+		};
+	});
+	if (!l && e && e[r?.data?.value]) {
+		let n, a = p[0]?.formatter?.format?.formatType;
+		t && It(a) ? n = "100%" : (n = e[r?.data?.value], !u && p[0]?.formatter ? n = i.formatter(p[0].formatter)(e[r?.data?.value]) : u && (n = i.formatter(H(p[0]?.formatter))(e[r?.data?.value]))), m.push({
+			label: "Total",
+			value: n
+		});
+	}
+	return m;
+}, Pt = (e, t = !1) => (n, r, i, a, s, c, l, u) => {
+	let d = n.filter((e) => _(e)), f = z(i), p = d.filter((e) => !f.has(S(e.dataItem))), m = d.map((e) => {
+		let t = r.data.end?.value !== void 0 && r.data.start?.value !== void 0, n = S(e.dataItem), a = f.has(n), s;
+		if (t && r.data.series?.value.toString() === n) s = r.data.end.value - r.data.start.value;
+		else if (a) {
+			let e = Object.keys(r.data).find((e) => r.data[e]?.source?.field === n);
+			s = e ? r.data[e]?.value : void 0;
+		}
+		if (s === void 0) return {
+			label: "",
+			value: ""
+		};
+		let c = o(e), l = s;
+		return (e.formatter || u) && (l = Z(e, s, r, i, u)), {
+			label: c || e.label || e.dataItem.name || "",
+			value: l
+		};
+	});
+	if (!l && e && e[r?.data?.value]) {
+		let n = p[p.length - 1], a, o = n?.formatter?.format?.formatType;
+		t && It(o) ? a = "100%" : (a = e[r?.data?.value], !u && n?.formatter ? a = i.formatter(n.formatter)(e[r?.data?.value]) : u && (a = i.formatter(H(n?.formatter))(e[r?.data?.value]))), m.push({
+			label: "Total",
+			value: a
+		});
+	}
+	return m;
+}, Ft = (e, t, n) => {
+	let r = e.filter((e) => _(e)), i = z(n), a = t.data.series?.value?.toString(), s = a ? t.data[a]?.value : void 0, c = r.find((e) => S(e.dataItem) === a), l = o(c) || c?.label || c?.dataItem?.name, u = [];
+	return l && s !== void 0 && u.push({
+		label: l,
+		value: c?.formatter && n ? Z(c, s, t, n) : s
+	}), r.filter((e) => i.has(S(e.dataItem))).forEach((e) => {
+		let r = S(e.dataItem), i = Object.keys(t.data).find((e) => t.data[e]?.source?.field === r), a = i ? t.data[i]?.value : void 0;
+		if (a === void 0) return;
+		let s = o(e) || e.label || e.dataItem.name || "";
+		u.push({
+			label: s,
+			value: e.formatter && n ? Z(e, a, t, n) : a
+		});
+	}), u;
+}, It = (e) => e === s.PercentageNoDecimal || e === s.Percentage1Decimal || e === s.Percentage2Decimal, Lt = (e, t, n) => {
+	let r = e.barSettings?.offset?.enabled ?? !1, i = e.dimensions.filter((e) => _(e)), a = e.measures.filter((e) => _(e));
+	return i.length === 1 && a.length === 1 && !r ? Be(e, t, n) : n;
+}, Q = class extends Ie {
+	constructor() {
+		super([
+			lt,
+			st,
+			it,
+			We,
+			Me,
+			He,
+			pt,
+			Ct,
+			kt,
+			Ne,
+			Lt,
+			At,
+			Ye,
+			Ce,
+			Ue
+		]);
+	}
+	preCompile(e) {
+		let t = e, { stacked: n } = G(t);
+		n && (t.measures = t.measures.map((e) => ({
+			...e,
+			secondaryAxis: !1
+		})));
+	}
+}, Rt = re(), $ = ne(({ vSpec: e, vTheme: t, data: n, elementSize: r, vizProperties: i }) => {
+	let a = ae(), [o] = (0, Je.useState)(() => new Q()), s = ce(), { activeKey: l } = le(), d = ie(), f = Re();
+	if (!e || !n || !r || !m(e) && !c(e)) return null;
+	let p = {
+		...i,
+		valuePickerMode: !!l
+	}, h = t || g, _ = o.compile(e, h, n, r, {
+		...p,
+		onRenderDone: s
+	}, u.Bar, a, d, f);
+	return _ ? /* @__PURE__ */ (0, Rt.jsx)(Pe, {
+		config: p,
+		definition: _,
+		size: r,
+		vSpec: e
+	}) : null;
+}), zt = /* @__PURE__ */ t({
+	BarChart: () => $,
+	BarChartCompiler: () => Q
+});
+export { $ as n, Q as r, zt as t };