@astrato-io/visualizations 0.0.0-stage → 0.6.5

package/chunks/standalone-B7jax8wa.js

@@ -0,0 +1,339 @@
+import { o as e, r as t } from "./rolldown-runtime-DleVn1XH.js";
+import { Fa as n, Ja as r, Ks as i, No as a, Sa as o, Si as s, Ta as c, Ys as l, fc as u } from "./isEqual-BDxAhUo8.js";
+import { $t as d, Ei as f, P as p, Yi as m, hn as h, mn as g } from "./utils-Bg7K-t6K.js";
+import { Pm as _, zm as v } from "./handlers-VTBfIZYZ.js";
+import { Ct as y, Ft as b, Jt as x, K as S, M as C, St as w, Tt as ee, Wt as T, X as E, an as te, dn as D, gt as ne, i as O, j as k, rn as A, sn as j } from "./escobar-eDjtGpkC.js";
+import { t as M } from "./coloring-B1XAfg6b.js";
+import { t as re } from "./set-coloring-datafield-B3uIS1Pe.js";
+var ie = /* @__PURE__ */ e(m()), 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 === l.Categorical || t?.type === l.Single ? y(e, []) : ee(e);
+}, I = (e, t, r) => {
+	let i = { ...w(re(e, ae(e)), t, {}) }, o = e.gaugeSettings?.barPadding ?? j.scale.padding;
+	i = S(e, i, o);
+	let c = e.dimensions.filter(s), l = e.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE);
+	return !c.length && P(e) ? i.onlyMeasures = {
+		data: F(e) ? { extract: { field: l.length > 0 ? u(l[0].dataItem) : void 0 } } : l.map((e) => u(e.dataItem)),
+		type: te.Band,
+		padding: o
+	} : F(e) || (i.onlyMeasures = {
+		data: { fields: l.map((e) => u(e.dataItem)) },
+		include: [0],
+		expand: .05
+	}), P(e) && (i.barScale = {
+		min: N.minScaleValue - N.scalePadding,
+		max: N.maxScaleValue + N.scalePadding,
+		invert: e.gaugeSettings?.orientation === a.Vertical
+	}), {
+		...r,
+		scales: i
+	};
+}, L = (e, t, r, i, a) => {
+	if (!a) return r;
+	let o = e.dimensions.filter(s), c = e.measures.filter(s), l = C((e.supportingMeasures ?? []).filter(s)), d = c.filter((e) => e.role === n.GAUGE_VALUE), f = o[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, l)) : f ? _.push(...R(e, g, a, l)) : _.push(...B(e, a, l)), h) {
+		let t = u(p.dataItem), n = {
+			field: u(g),
+			props: {
+				actual: { field: t },
+				color: t,
+				start: y,
+				end: N.maxScaleValue,
+				background: !0,
+				...l
+			}
+		};
+		(m === v.Data || m === v.Manual) && (n.props.target = U(e, a)), c.forEach((e) => {
+			let t = `measure-${u(e.dataItem)}`;
+			n.props[t] = { field: u(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(s), o = a.filter((e) => e.role === n.GAUGE_VALUE), c = a.filter((e) => e.role === n.GAUGE_TARGET), l = o[0], d = c[0], { targetType: f } = e.gaugeSettings, p = P(e), m = [], h = u(l.dataItem);
+	return p || m.push({
+		field: u(t),
+		props: {
+			actual: { field: h },
+			[h]: { field: h },
+			color: h,
+			...i
+		}
+	}), m.push({
+		field: u(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[u(d.dataItem)] = { field: u(d.dataItem) });
+	}), m;
+}, z = (e, t, r, i) => {
+	let a = P(e), o = e.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE), c = o.reduce((e, t) => {
+		let n = u(t.dataItem);
+		return e[n] = { field: n }, e;
+	}, {});
+	return o.map((n, o) => {
+		let s = u(n.dataItem);
+		return {
+			field: u(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(s).filter((e) => e.role === n.GAUGE_VALUE).forEach((n) => {
+		let o = u(n.dataItem), s = t[0].items[0][o], c = U(e, t, n), l = [];
+		l.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
+			}
+		}), l.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 && l.forEach((e) => {
+			e.props.target = c;
+		}), a.push(...l);
+	}), a;
+}, V = (e, t, r) => {
+	let i = e.measures.filter(s), a = i.filter((e) => e.role === n.GAUGE_VALUE), o = i.filter((e) => e.role === n.GAUGE_TARGET), c = a[0], l = o[0];
+	return (n, i, o) => {
+		let s = a.find((e, t) => t === r), d = s && o[u(s.dataItem)];
+		if (typeof d == "number" && d < 0) return N.minScaleValue;
+		let f = o[u(c.dataItem)], p;
+		if (p = e.gaugeSettings?.targetType === v.Data ? o[u(l?.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[u(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, o = e.measures.filter(s), c = o.filter((e) => e.role === n.GAUGE_TARGET)[0];
+	return i === v.Auto ? t[0].items.map((e) => o.map((t) => e[u(t.dataItem)])).reduce((e, t) => Math.max(...t, e), 0) * (1 + j.scale.padding) : c && i === v.Data ? { field: u(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(s).filter((e) => e.role === n.GAUGE_VALUE);
+	return (e) => r !== void 0 && e.measure?.source?.field !== u(i[r]?.dataItem) ? !1 : e.background?.value ? t === W.Background : t === W.Foreground;
+}, J = (e, t) => !t || e.coloring?.type === l.Single ? !1 : !F(e) || e.coloring?.type === l.Categorical, Y = (e, t, r, i, a, o, c, l) => {
+	let d = r.dimensions.filter(s)[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 || o && 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(D.Pie, o ? W.Background : W.Foreground, a),
+		type: D.Pie,
+		animations: {
+			enabled: !0,
+			presetId: "pie-chart"
+		},
+		data: {
+			collection: N.gaugeCollectionKey,
+			filter: (t) => {
+				if (!d) {
+					let e = r.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE);
+					return F(r) || e[a] && t.measure?.source?.field === u(e[a].dataItem);
+				}
+				return `${t.value}` == `${e[u(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: o ? N.backgroundBarOpacity : 1,
+				arc: (e, t) => {
+					if (o) 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: T([""], l, { overwriteOpacity: o ? N.backgroundBarOpacity : null })
+	};
+}, X = (e, t, n, r, i, o) => {
+	let l = e.dimensions.filter(s)[0], d = new M(e, t, n?.[0]?.itemsNotAffectedByFiltering), f;
+	f = r === W.Background && e.gaugeSettings?.backgroundBarColor ? e.gaugeSettings?.backgroundBarColor : d.getColorDefinition(J(e, l) ? { ref: d.MAIN_FIELD } : {}, !e.gaugeSettings?.backgroundBarColor && r === W.Background ? N.backgroundBarOpacity : null);
+	let p = l ? u(l.dataItem) : "onlyMeasures", m = !l && !F(e) ? "measureValue" : void 0, h = {
+		key: G(D.Box, r, i),
+		type: D.Box,
+		animations: { enabled: !0 },
+		data: {
+			collection: N.gaugeCollectionKey,
+			filter: q(e, r, i)
+		},
+		settings: {
+			orientation: e.gaugeSettings.orientation ?? a.Horizontal,
+			major: {
+				scale: p,
+				ref: m
+			},
+			minor: { scale: "barScale" },
+			box: {
+				minWidthPx: 2,
+				fill: f,
+				rx: e.gaugeSettings?.barRadius ?? 0
+			}
+		},
+		brush: T([""], o, { disable: { triggers: r === 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 = c.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 o = e.dimensions.filter(s), c = e.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE);
+	return !o[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 o = e.dimensions.filter(s), c = e.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE), l = o[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(s), a = e.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE);
+	if (!e.gaugeSettings?.barMode || !i.length && e.gaugeSettings?.comparisonMode) return r;
+	let o = [];
+	return i.length ? (e.gaugeSettings?.showDimensionLabels !== !1 && i[0] && o.push(Z(!1, t, i[0].formatter, "dimension", void 0, e.gaugeSettings)), !e.gaugeSettings?.comparisonMode && e.gaugeSettings?.showValueLabels !== !1 && a[0] && o.push(Z(!0, t, a[0].formatter, "value", void 0, e.gaugeSettings))) : e.gaugeSettings?.showValueLabels !== !1 && a.forEach((n, r) => {
+		o.push(Z(!0, t, n.formatter, String(r), r, e.gaugeSettings));
+	}), {
+		...r,
+		components: [...r.components, ...o]
+	};
+}, Z = (e, t, n, r, i, o) => {
+	let s = +!!e, c = {
+		type: "bar",
+		settings: {
+			direction: o?.orientation === a.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: D.Labels,
+		key: `gauge-bar-labels-${r}`,
+		layout: { displayOrder: b.Labels },
+		settings: { sources: [{
+			component: G(D.Box, W.Foreground, i),
+			selector: A.Rect,
+			strategy: c
+		}] },
+		animations: {
+			enabled: !0,
+			presetId: "chart-labels"
+		}
+	};
+}, ue = (e, t, n) => e === null ? "-" : typeof t != "string" && r(t) ? g(t.format, t)(e, void 0, n.data) : `${h(t, e)}`, Q = (e, t, n, r) => ne(e, t, n, r), de = (e, t, r, i, a) => {
+	if (!a) return r;
+	let o = e.dimensions.filter(s), c = e.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE), l = o[0], u = P(e), d = F(e), f = u ? D.Box : D.Pie, p = u && !d ? W.Background : W.Foreground, m = ((u || !l ? c : a[0]?.items) || []).map((e, t) => G(f, p, t));
+	return E(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 k {
+	constructor() {
+		super([
+			L,
+			I,
+			oe,
+			le,
+			Q,
+			de
+		]);
+	}
+	preCompile(e) {
+		if (!e.measures.filter(s).filter((e) => e.role === n.GAUGE_VALUE).length) throw Error("Charts w/o measures are not supported ATM.");
+	}
+}, pe = f(), $ = d(({ vSpec: e, vTheme: t, data: n, elementSize: r, vizProperties: a }) => {
+	let s = p(), [c] = (0, ie.useState)(() => new fe()), l = t || o, u = c.compile(e, l, n, r, a, i.Gauge, s);
+	return u ? /* @__PURE__ */ (0, pe.jsx)(O, {
+		config: a,
+		definition: u,
+		size: r,
+		vSpec: e
+	}) : null;
+}), me = /* @__PURE__ */ t({ GaugeChart: () => $ });
+export { $ as n, me as t };