@astrato-io/visualizations 0.0.0-stage → 0.6.4

package/chunks/standalone-BqWyrnZI.js

@@ -0,0 +1,281 @@
+import { o as e } from "./rolldown-runtime-DleVn1XH.js";
+import { Oa as t, On as n, Pn as r, Po as i, Ta as a, Ti as o, Xs as s, bo as c, hc as l, pc as u, qs as d, yo as f, zn as p } from "./interfaces-VUY4_yVO.js";
+import { I as m, Ki as h, P as g, Zt as _, wi as v } from "./utils-Ba9T0TqC.js";
+import { Hn as y, Rn as b } from "./event-bus-KiSiCJrC.js";
+import { t as x } from "./stroke-dash-UgMEcCS4.js";
+import { B as S, Et as C, Ft as w, G as T, I as E, Jt as D, L as O, M as k, N as ee, Pt as A, Rt as j, St as M, Wt as N, Xt as P, Y as F, Yt as I, Zt as L, at as R, dt as z, ft as B, gt as V, ht as H, i as U, j as W, kt as G, mt as K, n as q, nn as J, on as Y, st as te, un as X, ut as Z, vt as Q } from "./escobar-BGqT1EsE.js";
+import { o as ne, t as re } from "./coloring-C16AUZEi.js";
+import { t as ie } from "./set-coloring-datafield-B3uIS1Pe.js";
+var ae = /* @__PURE__ */ e(h()), oe = (e, t, r) => {
+	let i = e.dimensions.filter((e) => o(e)), a = e.measures.filter((e) => o(e)), c = i[0], f = a[0], m = !1, h = {}, { coloring: g } = e || {}, _ = g?.fieldId;
+	if (g?.type === s.Categorical && (_ ||= u(c.dataItem)), g?.type === s.Gradient && (_ ||= u(f.dataItem)), _ && H(r, 0, { color: { field: _ } }), c && e?.axes?.dimension?.continuousAxis) {
+		let e = l(c.dataItem), t = !!c.datePart, r = n(e) || p(e);
+		m = !t && r;
+	}
+	if (h = M(ie(e, _), t, h), h = T(e, h, r.collections, m, !0), a.filter((e) => e.graphType === d.Bar).length > 1 && !e.barSettings?.grouped) {
+		let t = P(e, a.find((e) => e.graphType === d.Bar));
+		h[t].data = { collection: C.ComboChartCollection };
+	}
+	return {
+		...r,
+		scales: h
+	};
+}, $ = (e, t, n) => {
+	let r = e.measures.filter((e) => o(e)), i = e.dimensions.filter((e) => o(e)), a = (e.supportingMeasures ?? []).filter((e) => o(e)), s = r.reduce((e, t) => {
+		let n = u(t.dataItem);
+		return e[n] = { field: n }, e;
+	}, {}), c = k(a), l = i.reduce((e, t) => {
+		let n = u(t.dataItem);
+		return e[n] = { field: n }, e;
+	}, {}), f = i[0];
+	if (!f) return n;
+	let p = u(f.dataItem), m = {
+		key: C.ComboChartCollection,
+		data: { extract: [] }
+	};
+	if (m.data.extract = r.map((e, t) => {
+		let n = u(e.dataItem);
+		return {
+			field: p,
+			props: {
+				end: { field: n },
+				...s,
+				...c,
+				...l,
+				start: 0,
+				graphType: e.graphType,
+				measureIndex: t,
+				fieldId: n
+			}
+		};
+	}), r.filter((e) => e.graphType === d.Bar).length > 1) {
+		let t = !!r.find((e) => e.graphType === d.Bar)?.secondaryAxis, n = new Map(r.map((e) => [u(e.dataItem), !!e.secondaryAxis]));
+		e.barSettings?.grouped || (m.data.stack = {
+			stackKey: (e) => e.graphType.value === d.Bar ? `${e.value}` : `${e.value}-${e.graphType.value}-${e.measureIndex.value}`,
+			value: (e) => {
+				let r = e.fieldId?.value;
+				return typeof r != "string" || n.get(r) !== t ? null : e.end.value;
+			},
+			offset: y.Diverging
+		});
+	}
+	return {
+		...n,
+		collections: [...n.collections, m]
+	};
+}, se = (e, t, n, r, i, a) => {
+	let s = [];
+	return e.measures.filter((e) => o(e)).forEach((r) => {
+		let o = u(r.dataItem), c = (e) => e.fieldId.value === o;
+		switch (r.graphType || e.type) {
+			case d.Bar:
+				s.push(le(e, t, i, n, r, a, c));
+				break;
+			case d.Point:
+				s.push(B(e, t, n, r, !1, C.ComboChartCollection, c));
+				break;
+			default: s.push(ce(e, t, n, r, c)), s.push(B(e, t, n, r, !r.showDataPoints, C.ComboChartCollection, c));
+		}
+	}), s.sort((e) => e.type === X.Box ? -1 : 0), {
+		...n,
+		components: [...n.components, ...s]
+	};
+};
+function ce(e, t, n, r, a) {
+	let s = e.dimensions.filter((e) => o(e));
+	if (!s[0]) throw Error("Combo chart without dimension is not supported.");
+	if (s.length > 1) throw Error("Combo chart currently support only one dimension.");
+	let c = x(r.strokeDash), l = u(r.dataItem), f = ne(e, n, t, r, l);
+	return {
+		type: X.Line,
+		layout: { displayOrder: w.VisualizationElement },
+		key: K(e, r, d.Line),
+		data: {
+			collection: C.ComboChartCollection,
+			filter: a
+		},
+		settings: {
+			orientation: e.orientation === i.Horizontal ? i.Vertical : i.Horizontal,
+			coordinates: {
+				major: { scale: I(e) },
+				minor: {
+					scale: P(e, r),
+					ref: l
+				}
+			},
+			layers: {
+				curve: e.lineSettings?.lineCurve,
+				skipCollisions: !0,
+				line: {
+					stroke: f,
+					strokeWidth: r.strokeWidth,
+					strokeDasharray: c
+				}
+			}
+		},
+		animations: {
+			enabled: !0,
+			presetId: "simple-opacity"
+		}
+	};
+}
+function le(e, t, n, a, s, c, l) {
+	let f = e.dimensions.filter((e) => o(e)), p = e.measures.filter((e) => o(e) && e.graphType === d.Bar);
+	if (!f[0]) throw Error("Combo chart without dimension is not supported.");
+	let m = { scale: I(e) }, h = {
+		scale: P(e, s),
+		end: { ref: "end" }
+	}, g = {
+		minWidthPx: 2,
+		rx: r(e?.barSettings.barRadius, 0),
+		roundAllEdges: e?.barSettings?.roundAllEdges,
+		useCustomBoxRounding: !0,
+		boxPadding: e?.barSettings?.barPadding ?? Y.scale.padding
+	};
+	g.fill = new re(e, t, n?.[0]?.itemsNotAffectedByFiltering).getColorDefinition({ ref: "fieldId" });
+	let _ = {
+		enabled: !0,
+		presetId: "bar-chart"
+	}, v = s?.graphType !== d.Bar;
+	if (p.length > 1 && e.barSettings?.grouped) {
+		let t = 1 * (1 / p.length), n = (1 - (e.barSettings?.barPadding ?? 0)) * t, r = .5 / p.length, i = (1 + 0 * (p.length - 1)) * r, a = p.findIndex((e) => u(e.dataItem) === u(s.dataItem));
+		m.fn = (n) => {
+			let r = n.resources.scale(I(e));
+			return r(n.datum.value) + i * r.bandwidth?.() + a * r.bandwidth?.() * t;
+		}, g.width = n;
+	}
+	return {
+		type: X.Box,
+		layout: { displayOrder: w.VisualizationElement },
+		key: K(e, s, d.Bar),
+		data: {
+			collection: C.ComboChartCollection,
+			filter: l
+		},
+		settings: {
+			orientation: e.orientation ?? i.Vertical,
+			major: m,
+			minor: h,
+			box: g
+		},
+		animations: _,
+		brush: v ? null : N([""], c)
+	};
+}
+var ue = (e, t) => {
+	let n = t ? [b.Inside] : [
+		b.Inside,
+		b.Outside,
+		b.Opposite
+	];
+	return (e || [
+		{
+			position: b.Inside,
+			justify: 1
+		},
+		{ position: b.Outside },
+		{ position: b.Opposite }
+	]).map((e) => ({
+		...e,
+		possible: n.includes(e.position)
+	}));
+}, de = ({ data: e }) => e ? e.end.value > e.start.value ? "up" : "down" : null, fe = ({ data: e }) => e ? e.end.value > e.start.value ? "right" : "left" : null, pe = (e, n, r, i, a, s) => {
+	let l = e.measures.filter((e) => o(e)), p = l.filter((e) => e.graphType === d.Bar), m = p.filter((e) => e.dataLabels?.show), h = p.length >= 2 && !("barSettings" in e && e.barSettings?.grouped), g = L(e), _ = m.map((r) => {
+		let i = !!r.dataLabels?.barLabelPlacements, a = ue(r.dataLabels?.barLabelPlacements, h).filter((e) => e.possible).map((e) => ({
+			position: e.position,
+			fill: e.position === b.Inside ? t.white : "#242424",
+			...e.justify === void 0 ? {} : { justify: e.justify },
+			...i ? { overflow: [b.Outside, b.Opposite].includes(e.position) } : {}
+		}));
+		return r.dataLabels?.showBackdrop && !h && (a = a.map((e) => ee(e, n, g))), {
+			key: `combo-bar-labels-${r.dataItem.uniqueSignature}`,
+			type: X.Labels,
+			layout: { displayOrder: w.Labels },
+			settings: { sources: [{
+				component: K(e, r, d.Bar),
+				selector: J.Rect,
+				strategy: {
+					type: "bar",
+					settings: {
+						direction: g ? fe : de,
+						fontSize: D(r.dataLabels?.size),
+						fontFamily: n.fonts.general.fontFamily,
+						labels: [{
+							label: E(r),
+							placements: a
+						}]
+					}
+				}
+			}] },
+			animations: {
+				enabled: !0,
+				presetId: "chart-labels"
+			}
+		};
+	}), v = {}, y = {}, x = l.filter((e) => e.graphType !== d.Bar).map((t) => {
+		let n = u(t.dataItem), r = K(e, t, d.Point);
+		return y[r] = n, v[r] = {
+			enabled: t.dataLabels?.show || !1,
+			fontSize: D(t.dataLabels?.size),
+			backdropColor: t.dataLabels?.backdropColor,
+			textColor: t.dataLabels?.textColor,
+			isColored: t.dataLabels?.isColored,
+			colorType: t.dataLabels?.showBackdrop ? f.Backdrop : f.Text,
+			density: t.dataLabels?.density || c.Medium
+		}, r;
+	}).filter((e) => v[e].enabled), C = x.length ? [S({
+		targetComponentKeys: x,
+		targetSelector: `.${z}`,
+		label: ({ data: e, node: t }) => e[y[t.key]]?.label,
+		skipBrush: !0
+	}, v, s, n)] : [];
+	if (_.length && C.length) {
+		let e = {
+			...C[0],
+			settings: {
+				...C[0].settings,
+				sources: [..._.flatMap((e) => e.settings.sources), ...C[0].settings.sources]
+			}
+		};
+		return {
+			...r,
+			components: [...r.components, e]
+		};
+	}
+	return {
+		...r,
+		components: [
+			...r.components,
+			..._,
+			...C
+		]
+	};
+}, me = class extends W {
+	constructor() {
+		super([
+			$,
+			oe,
+			j,
+			Q,
+			se,
+			te,
+			V,
+			pe,
+			R,
+			F,
+			G,
+			A,
+			Z,
+			O
+		]);
+	}
+}, he = v(), ge = _(({ vSpec: e, vTheme: t, data: n, elementSize: r, vizProperties: i }) => {
+	let o = g(), [s] = (0, ae.useState)(() => new me()), c = m(), l = t || a, u = s.compile(e, l, n, r, i, d.Combo, o, c, q());
+	return u ? /* @__PURE__ */ (0, he.jsx)(U, {
+		config: i,
+		definition: u,
+		size: r,
+		vSpec: e
+	}) : null;
+});
+export { ge as ComboChart };

package/chunks/standalone-C85u7U6I.js

@@ -0,0 +1,340 @@
+import { o as e, r as t } from "./rolldown-runtime-DleVn1XH.js";
+import { La as n, Oa as r, Po as i, Ta as a, Ti as o, Xa as s, Xs as c, pc as l, qs as u } from "./interfaces-VUY4_yVO.js";
+import { Ki as d, P as f, Zt as p, fn as m, pn as h, wi as g } from "./utils-Ba9T0TqC.js";
+import { Rn as _ } from "./event-bus-KiSiCJrC.js";
+import { t as v } from "./gauge-target-type-BkKXAqkX.js";
+import { Ct as y, Ft as b, Jt as x, K as S, M as C, St as w, Tt as T, Wt as E, X as D, gt as ee, i as te, in as ne, j as O, nn as k, on as A, un as j } from "./escobar-BGqT1EsE.js";
+import { t as M } from "./coloring-C16AUZEi.js";
+import { t as re } from "./set-coloring-datafield-B3uIS1Pe.js";
+var ie = /* @__PURE__ */ e(d()), N = {
+	outerRadius: .95,
+	cornerRadius: 10,
+	additionalTextAnchorHeight: 50,
+	barMinWidth: 1,
+	barMaxWidth: 200,
+	minScaleValue: 0,
+	maxScaleValue: 100,
+	scalePadding: 1,
+	backgroundBarOpacity: .2,
+	barWidthRadiusPadding: .2,
+	maxBarWidthOfRadius: .15,
+	gaugeCollectionKey: "Gauge-Collection"
+}, P = (e) => e.gaugeSettings?.barMode ?? !1, F = (e) => e.gaugeSettings?.comparisonMode ?? !1, ae = (e) => {
+	let { coloring: t } = e || {};
+	return t?.type === c.Categorical || t?.type === c.Single ? y(e, []) : T(e);
+}, I = (e, t, r) => {
+	let a = { ...w(re(e, ae(e)), t, {}) }, s = e.gaugeSettings?.barPadding ?? A.scale.padding;
+	a = S(e, a, s);
+	let c = e.dimensions.filter(o), u = e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE);
+	return !c.length && P(e) ? a.onlyMeasures = {
+		data: F(e) ? { extract: { field: u.length > 0 ? l(u[0].dataItem) : void 0 } } : u.map((e) => l(e.dataItem)),
+		type: ne.Band,
+		padding: s
+	} : F(e) || (a.onlyMeasures = {
+		data: { fields: u.map((e) => l(e.dataItem)) },
+		include: [0],
+		expand: .05
+	}), P(e) && (a.barScale = {
+		min: N.minScaleValue - N.scalePadding,
+		max: N.maxScaleValue + N.scalePadding,
+		invert: e.gaugeSettings?.orientation === i.Vertical
+	}), {
+		...r,
+		scales: a
+	};
+}, L = (e, t, r, i, a) => {
+	if (!a) return r;
+	let s = e.dimensions.filter(o), c = e.measures.filter(o), u = C((e.supportingMeasures ?? []).filter(o)), d = c.filter((e) => e.role === n.GAUGE_VALUE), f = s[0], p = d[0], { targetType: m } = e.gaugeSettings, h = P(e), g = f?.dataItem ?? p.dataItem, _ = [], y = N.minScaleValue;
+	if (F(e) ? _.push(...z(e, g, a, u)) : f ? _.push(...R(e, g, a, u)) : _.push(...B(e, a, u)), h) {
+		let t = l(p.dataItem), n = {
+			field: l(g),
+			props: {
+				actual: { field: t },
+				color: t,
+				start: y,
+				end: N.maxScaleValue,
+				background: !0,
+				...u
+			}
+		};
+		(m === v.Data || m === v.Manual) && (n.props.target = U(e, a)), c.forEach((e) => {
+			let t = `measure-${l(e.dataItem)}`;
+			n.props[t] = { field: l(e.dataItem) };
+		}), _.push(n);
+	}
+	let b = [{
+		key: N.gaugeCollectionKey,
+		data: { extract: _ }
+	}];
+	return {
+		...r,
+		collections: b
+	};
+}, R = (e, t, r, i) => {
+	let a = e.measures.filter(o), s = a.filter((e) => e.role === n.GAUGE_VALUE), c = a.filter((e) => e.role === n.GAUGE_TARGET), u = s[0], d = c[0], { targetType: f } = e.gaugeSettings, p = P(e), m = [], h = l(u.dataItem);
+	return p || m.push({
+		field: l(t),
+		props: {
+			actual: { field: h },
+			[h]: { field: h },
+			color: h,
+			...i
+		}
+	}), m.push({
+		field: l(t),
+		props: {
+			actual: { field: h },
+			start: p ? N.minScaleValue : void 0,
+			end: p ? { getValue: V(e, r) } : void 0,
+			[h]: { field: h },
+			color: h,
+			...i
+		}
+	}), (f === v.Data || f === v.Manual) && m.forEach((t) => {
+		t.props.target = U(e, r), d && f === v.Data && (t.props[l(d.dataItem)] = { field: l(d.dataItem) });
+	}), m;
+}, z = (e, t, r, i) => {
+	let a = P(e), s = e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE), c = s.reduce((e, t) => {
+		let n = l(t.dataItem);
+		return e[n] = { field: n }, e;
+	}, {});
+	return s.map((n, o) => {
+		let s = l(n.dataItem);
+		return {
+			field: l(t),
+			props: {
+				measure: { field: s },
+				color: s,
+				start: a ? N.minScaleValue : void 0,
+				end: a ? { getValue: V(e, r, o) } : void 0,
+				...c,
+				...i
+			}
+		};
+	});
+}, B = (e, t, r) => {
+	let i = P(e), a = [];
+	return e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE).forEach((n) => {
+		let o = l(n.dataItem), s = t[0].items[0][o], c = U(e, t, n), u = [];
+		u.push({
+			field: o,
+			props: {
+				measureValue: o,
+				measure: { field: o },
+				actual: { field: o },
+				color: o,
+				start: i ? N.minScaleValue : void 0,
+				end: i && typeof s == "number" && typeof c == "number" ? H(s, c) : void 0,
+				[o]: { field: o },
+				...r
+			}
+		}), u.push({
+			field: o,
+			props: {
+				measureValue: o,
+				measure: { field: o },
+				actual: { field: o },
+				color: o,
+				start: i ? N.minScaleValue : void 0,
+				end: i ? N.maxScaleValue : void 0,
+				background: !0,
+				[o]: { field: o },
+				...r
+			}
+		}), (e.gaugeSettings?.targetType ?? v.Auto) !== v.Auto && u.forEach((e) => {
+			e.props.target = c;
+		}), a.push(...u);
+	}), a;
+}, V = (e, t, r) => {
+	let i = e.measures.filter(o), a = i.filter((e) => e.role === n.GAUGE_VALUE), s = i.filter((e) => e.role === n.GAUGE_TARGET), c = a[0], u = s[0];
+	return (n, i, o) => {
+		let s = a.find((e, t) => t === r), d = s && o[l(s.dataItem)];
+		if (typeof d == "number" && d < 0) return N.minScaleValue;
+		let f = o[l(c.dataItem)], p;
+		if (p = e.gaugeSettings?.targetType === v.Data ? o[l(u?.dataItem)] : U(e, t), !o || typeof f != "number" || typeof p != "number") return N.minScaleValue;
+		if (!F(e) || r === void 0) return H(f, p);
+		let m = 0, h = 0;
+		return a.forEach((e, t) => {
+			let n = Math.max(0, o[l(e.dataItem)]);
+			m += n, t <= r && (h += n);
+		}), h / m * N.maxScaleValue;
+	};
+}, H = (e, t) => {
+	let n = t ? Math.max(0, e) / t : 1;
+	return Math.min(n, 1) * N.maxScaleValue;
+}, U = (e, t, r) => {
+	let { targetType: i, targetValue: a } = e.gaugeSettings, s = e.measures.filter(o), c = s.filter((e) => e.role === n.GAUGE_TARGET)[0];
+	return i === v.Auto ? t[0].items.map((e) => s.map((t) => e[l(t.dataItem)])).reduce((e, t) => Math.max(...t, e), 0) * (1 + A.scale.padding) : c && i === v.Data ? { field: l(c.dataItem) } : r && i === v.PerMeasure ? r.targetValue ?? 0 : i === v.Manual ? a ?? 0 : 0;
+}, W = /* @__PURE__ */ function(e) {
+	return e.Foreground = "foreground", e.Background = "background", e;
+}({}), G = (e, t, n = 0) => `${e}-${t}-${n}`, K = (e) => Math.min(N.maxBarWidthOfRadius, N.outerRadius / e), q = (e, t, r) => {
+	let i = e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE);
+	return (e) => r !== void 0 && e.measure?.source?.field !== l(i[r]?.dataItem) ? !1 : e.background?.value ? t === W.Background : t === W.Foreground;
+}, J = (e, t) => !t || e.coloring?.type === c.Single ? !1 : !F(e) || e.coloring?.type === c.Categorical, Y = (e, t, r, i, a, s, c, u) => {
+	let d = r.dimensions.filter(o)[0], f = new M(r, i, t?.[0]?.itemsNotAffectedByFiltering), p = f.getColorDefinition(J(r, d) ? { ref: f.MAIN_FIELD } : {}), m = (e, t) => !F(r) && t === 1 || s && F(r) ? "transparent" : typeof p == "function" ? p(e) : p, h = K(c), g = Number(r.gaugeSettings?.size), _ = Number(r.gaugeSettings?.startAngle), y = isNaN(g) ? 360 : g ?? 360, b = isNaN(_) ? 0 : _ ?? 0, x = b + y, S = b / 180 * Math.PI, C = x / 180 * Math.PI;
+	return {
+		key: G(j.Pie, s ? W.Background : W.Foreground, a),
+		type: j.Pie,
+		animations: {
+			enabled: !0,
+			presetId: "pie-chart"
+		},
+		data: {
+			collection: N.gaugeCollectionKey,
+			filter: (t) => {
+				if (!d) {
+					let e = r.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE);
+					return F(r) || e[a] && t.measure?.source?.field === l(e[a].dataItem);
+				}
+				return `${t.value}` == `${e[l(d.dataItem)]}`;
+			}
+		},
+		settings: {
+			startAngle: S,
+			endAngle: C,
+			slice: {
+				cornerRadius: r.gaugeSettings?.cornerRadius ?? 10,
+				outerRadius: N.outerRadius - a * h,
+				innerRadius: N.outerRadius - (a + (1 - N.barWidthRadiusPadding)) * h,
+				fill: m,
+				strokeWidth: .1,
+				opacity: s ? N.backgroundBarOpacity : 1,
+				arc: (e, t) => {
+					if (s) return +(t === 0);
+					if (F(r)) return e.datum.measure.value;
+					if ((r.gaugeSettings.targetType ?? v.Auto) !== v.Auto) return t === 0 ? e.datum.actual.value : Number(e.datum.target.value) - Number(e.datum.actual.value);
+					{
+						let n = e.resources.scale("onlyMeasures"), r = Number(n(e.datum.actual.value)) || 0;
+						return t === 0 ? r : 1 - r;
+					}
+				}
+			}
+		},
+		brush: E([""], u, { overwriteOpacity: s ? N.backgroundBarOpacity : null })
+	};
+}, X = (e, t, n, a, s, c) => {
+	let u = e.dimensions.filter(o)[0], d = new M(e, t, n?.[0]?.itemsNotAffectedByFiltering), f;
+	f = a === W.Background && e.gaugeSettings?.backgroundBarColor ? e.gaugeSettings?.backgroundBarColor : d.getColorDefinition(J(e, u) ? { ref: d.MAIN_FIELD } : {}, !e.gaugeSettings?.backgroundBarColor && a === W.Background ? N.backgroundBarOpacity : null);
+	let p = u ? l(u.dataItem) : "onlyMeasures", m = !u && !F(e) ? "measureValue" : void 0, h = {
+		key: G(j.Box, a, s),
+		type: j.Box,
+		animations: { enabled: !0 },
+		data: {
+			collection: N.gaugeCollectionKey,
+			filter: q(e, a, s)
+		},
+		settings: {
+			orientation: e.gaugeSettings.orientation ?? i.Horizontal,
+			major: {
+				scale: p,
+				ref: m
+			},
+			minor: { scale: "barScale" },
+			box: {
+				minWidthPx: 2,
+				fill: f,
+				rx: e.gaugeSettings?.barRadius ?? 0
+			}
+		},
+		brush: E([""], c, { disable: { triggers: a === W.Foreground } })
+	};
+	return e.gaugeSettings?.strokeEnabled ? (h.settings.box.stroke = e.gaugeSettings?.strokeColor || t.colors.brandColors[0], h.settings.box.strokeWidth = e.gaugeSettings?.strokeWidth) : h.settings.box.stroke = r.transparent, h;
+}, oe = (e, t, n, r, i, a) => {
+	if (!i) return n;
+	let o = [];
+	return o = P(e) ? ce(e, t, r, i, a) : se(e, t, r, i, a), {
+		...n,
+		components: [...n.components, ...o]
+	};
+}, se = (e, t, r, i, a) => {
+	let s = e.dimensions.filter(o), c = e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE);
+	return !s[0] && !F(e) ? c.map((n, r) => [Y(i[0].items[0], i, e, t, r, !0, c.length), Y(i[0].items[0], i, e, t, r, !1, c.length)]).reduce((e, t) => e.concat(t), []) : i[0].items.map((n, r) => [Y(n, i, e, t, r, !0, i[0].items.length, a), Y(n, i, e, t, r, !1, i[0].items.length, a)]).reduce((e, t) => e.concat(t), []);
+}, ce = (e, t, r, i, a) => {
+	let s = e.dimensions.filter(o), c = e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE), l = s[0], u = [];
+	if (F(e)) for (let n = c.length - 1; n >= 0; n--) u.push(X(e, t, i, W.Foreground, n, a));
+	else if (l) u = [X(e, t, i, W.Background, void 0, a), X(e, t, i, W.Foreground, void 0, a)];
+	else for (let n = c.length - 1; n >= 0; n--) u.push(X(e, t, i, W.Background, n)), u.push(X(e, t, i, W.Foreground, n));
+	return u;
+}, le = (e, t, r) => {
+	let i = e.dimensions.filter(o), a = e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE);
+	if (!e.gaugeSettings?.barMode || !i.length && e.gaugeSettings?.comparisonMode) return r;
+	let s = [];
+	return i.length ? (e.gaugeSettings?.showDimensionLabels !== !1 && i[0] && s.push(Z(!1, t, i[0].formatter, "dimension", void 0, e.gaugeSettings)), !e.gaugeSettings?.comparisonMode && e.gaugeSettings?.showValueLabels !== !1 && a[0] && s.push(Z(!0, t, a[0].formatter, "value", void 0, e.gaugeSettings))) : e.gaugeSettings?.showValueLabels !== !1 && a.forEach((n, r) => {
+		s.push(Z(!0, t, n.formatter, String(r), r, e.gaugeSettings));
+	}), {
+		...r,
+		components: [...r.components, ...s]
+	};
+}, Z = (e, t, n, r, a, o) => {
+	let s = +!!e, c = {
+		type: "bar",
+		settings: {
+			direction: o?.orientation === i.Vertical ? "up" : "right",
+			fontSize: x(o?.labelFontSize),
+			fontFamily: t.fonts.general.fontFamily,
+			labels: [{
+				label: (t) => t.data ? e ? ue(t.data.actual.value, n, t) : `${h(n, t.data?.label)}` : "",
+				placements: e ? [{
+					position: _.Outside,
+					fill: "#000",
+					justify: 0
+				}, {
+					position: _.Inside,
+					fill: "#fff",
+					justify: s
+				}] : [{
+					position: _.Inside,
+					fill: "#fff",
+					justify: s
+				}]
+			}]
+		}
+	};
+	return {
+		type: j.Labels,
+		key: `gauge-bar-labels-${r}`,
+		layout: { displayOrder: b.Labels },
+		settings: { sources: [{
+			component: G(j.Box, W.Foreground, a),
+			selector: k.Rect,
+			strategy: c
+		}] },
+		animations: {
+			enabled: !0,
+			presetId: "chart-labels"
+		}
+	};
+}, ue = (e, t, n) => e === null ? "-" : typeof t != "string" && s(t) ? m(t.format, t)(e, void 0, n.data) : `${h(t, e)}`, Q = (e, t, n, r) => ee(e, t, n, r), de = (e, t, r, i, a) => {
+	if (!a) return r;
+	let s = e.dimensions.filter(o), c = e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE), l = s[0], u = P(e), d = F(e), f = u ? j.Box : j.Pie, p = u && !d ? W.Background : W.Foreground, m = ((u || !l ? c : a[0]?.items) || []).map((e, t) => G(f, p, t));
+	return D(e, t, r, {
+		filter: (e) => e.filter((e) => m.findIndex((t) => t === e.key) !== -1),
+		placement: {
+			type: u ? "bounds" : "slice",
+			area: "target"
+		}
+	});
+}, fe = class extends O {
+	constructor() {
+		super([
+			L,
+			I,
+			oe,
+			le,
+			Q,
+			de
+		]);
+	}
+	preCompile(e) {
+		if (!e.measures.filter(o).filter((e) => e.role === n.GAUGE_VALUE).length) throw Error("Charts w/o measures are not supported ATM.");
+	}
+}, pe = g(), $ = p(({ vSpec: e, vTheme: t, data: n, elementSize: r, vizProperties: i }) => {
+	let o = f(), [s] = (0, ie.useState)(() => new fe()), c = t || a, l = s.compile(e, c, n, r, i, u.Gauge, o);
+	return l ? /* @__PURE__ */ (0, pe.jsx)(te, {
+		config: i,
+		definition: l,
+		size: r,
+		vSpec: e
+	}) : null;
+}), me = /* @__PURE__ */ t({ GaugeChart: () => $ });
+export { $ as n, me as t };