@astrato-io/visualizations 0.6.4 → 0.6.5

package/chunks/bar.compiler-CT0ZbQKc.js

@@ -0,0 +1,374 @@
+import { To as e, a as t } from "./isEqual-BDxAhUo8.js";
+import { E as n, M as r, O as i, S as a, T as o, _ as s, b as c, c as l, d as u, f as d, h as f, it as p, k as m, l as h, m as g, n as _, w as v } from "./shared-CBvcC5YV.js";
+import { bd as y, jf as b } from "./handlers-VTBfIZYZ.js";
+import { _ as x, b as S, t as C, u as w, v as T, w as E } from "./operations-CTNUX6Sy.js";
+t();
+var D = (e) => {
+	let t = [...e.data.dimensions.map((e, t) => ({
+		item: e,
+		path: [
+			"data",
+			"dimensions",
+			t,
+			"ref"
+		]
+	})), ...e.data.measures.map((e, t) => ({
+		item: e,
+		path: [
+			"data",
+			"measures",
+			t,
+			"ref"
+		]
+	}))], n = t.map(({ item: e }) => e.ref), r = new Set(n), i = /* @__PURE__ */ new Set(), o = [];
+	t.forEach(({ item: e, path: t }) => {
+		i.has(e.ref) && o.push(u("duplicate_alias", t, `Reference "${e.ref}" is duplicated.`)), i.add(e.ref);
+	}), e.sorting?.forEach((e, t) => {
+		r.has(e.by) || o.push(u("unknown_alias", [
+			"sorting",
+			t,
+			"by"
+		], `Reference "${e.by}" does not exist.`, { allowedValues: n }));
+	}), o.push(...a(e.presentation?.coloring, e.data.dimensions.map((e) => e.ref), e.data.measures.map((e) => e.ref)));
+	let s = e.limiting?.topN?.by;
+	return s && !e.data.measures.some((e) => e.ref === s) && o.push(u("unknown_alias", [
+		"limiting",
+		"topN",
+		"by"
+	], `Measure reference "${s}" does not exist.`, { allowedValues: e.data.measures.map((e) => e.ref) })), o;
+}, O = (e) => {
+	if (e.type !== "bar") return u("unsupported_visualization", ["baseVSpec", "type"], `Definition type "bar" cannot compile against base vSpec type "${e.type}".`);
+	let t = e;
+	return t.dimensions.length > 0 || t.measures.length > 0 || (t.supportingMeasures?.length ?? 0) > 0 || Object.keys(t.referencedData).length > 0 ? u("non_fresh_base_vspec", ["baseVSpec"], "Bar visualization definitions can only compile against a fresh base vSpec.") : void 0;
+}, k = {
+	formatString: "setDimensionFormatString",
+	formatType: "setDimensionFormatType"
+}, A = {
+	currency: "setMeasureCurrency",
+	currencyIsPrefix: "setMeasureCurrencyIsPrefix",
+	formatString: "setMeasureFormatString",
+	formatType: "setMeasureFormatType",
+	negativeType: "setMeasureNegativeType"
+}, j = (e) => {
+	let t = Object.entries(e).find(([, e]) => e.success === !1);
+	return t ? {
+		id: t[0],
+		result: t[1]
+	} : void 0;
+}, M = (e, t) => {
+	if (!e || typeof e.data != "object" || e.data === null || !("dataItem" in e.data)) return;
+	let n = e.data.dataItem;
+	if (!(typeof n != "object" || !n || !("internalKey" in n) || typeof n.internalKey != "string" || !("uniqueSignature" in n) || typeof n.uniqueSignature != "string")) return {
+		dataItemInternalKey: n.internalKey,
+		dataItemUniqueSignature: n.uniqueSignature,
+		kind: t
+	};
+}, N = async (e, t) => {
+	let r = e;
+	for (let [e, n] of t.data.dimensions.entries()) {
+		let t = `dimension:${n.ref}`, i = await C(r.vSpec, r.availableFields, [{
+			id: t,
+			name: w.ADD_DIMENSION,
+			payload: { key: n.fieldKey }
+		}], r.input.variables ?? [], [], r.input.theme), a = j(i.results), o = M(i.results[t], "dimension");
+		if (a || !o) return {
+			issue: u("operation_failed", [
+				"data",
+				"dimensions",
+				e
+			], a?.result.error ?? "Dimension operation did not return the created data-item identity."),
+			success: !1
+		};
+		r = {
+			...r,
+			resolvedRefs: {
+				...r.resolvedRefs,
+				[n.ref]: o
+			},
+			vSpec: i.vSpec
+		};
+	}
+	for (let [i, a] of t.data.measures.entries()) {
+		let t = n(a, e.input.availableFields), s = `measure:${a.ref}`, c = await C(r.vSpec, r.availableFields, [{
+			id: s,
+			name: w.ADD_MEASURE,
+			payload: o(a, e.input.availableFields)
+		}], r.input.variables ?? [], [], r.input.theme), l = j(c.results), d = M(c.results[s], "measure");
+		if (l || !d) return {
+			issue: u("operation_failed", [
+				"data",
+				"measures",
+				i
+			], l?.result.error ?? "Measure operation did not return the created data-item identity."),
+			success: !1
+		};
+		r = {
+			...r,
+			measureAggregations: {
+				...r.measureAggregations,
+				[a.ref]: t
+			},
+			resolvedRefs: {
+				...r.resolvedRefs,
+				[a.ref]: d
+			},
+			vSpec: c.vSpec
+		};
+	}
+	return {
+		state: r,
+		success: !0
+	};
+}, P = (e) => ({
+	dataItemInternalKey: e.dataItemInternalKey,
+	dataItemUniqueSignature: e.dataItemUniqueSignature
+}), F = async (e, t) => {
+	let n = [];
+	return t.data.dimensions.forEach((t, r) => {
+		let i = e.resolvedRefs[t.ref];
+		t.showNullValues !== void 0 && n.push({
+			name: w.UPDATE_DIMENSION,
+			payload: {
+				...P(i),
+				changes: { showNullValues: t.showNullValues }
+			}
+		}), t.temporalGrouping && n.push(g("setDimensionTemporalGrouping", i, t.ref, [
+			"data",
+			"dimensions",
+			r
+		], t.temporalGrouping)), t.format?.formatType !== void 0 && n.push(h(k.formatType, i, t.ref, [
+			"data",
+			"dimensions",
+			r
+		], "formatType", t.format.formatType)), t.format?.formatString !== void 0 && n.push(h(k.formatString, i, t.ref, [
+			"data",
+			"dimensions",
+			r
+		], "formatString", t.format.formatString));
+	}), t.data.measures.forEach((t, r) => {
+		let i = e.resolvedRefs[t.ref];
+		[
+			"formatType",
+			"formatString",
+			"currency",
+			"currencyIsPrefix",
+			"negativeType"
+		].forEach((e) => {
+			let a = t.format?.[e];
+			a !== void 0 && n.push(h(A[e], i, t.ref, [
+				"data",
+				"measures",
+				r
+			], e, a));
+		}), t.dataLabels && n.push({
+			name: E.SET_MEASURE_DATA_LABELS_SHOW,
+			payload: {
+				...P(i),
+				show: t.dataLabels.visible
+			}
+		}), t.dataLabels?.placements && n.push({
+			name: E.SET_MEASURE_DATA_LABEL_BAR_PLACEMENTS,
+			payload: {
+				...P(i),
+				placements: t.dataLabels.placements.map((e) => ({ position: e }))
+			}
+		}), t.axis && n.push({
+			name: x.CHANGE_MEASURE_AXIS,
+			payload: {
+				...P(i),
+				secondaryAxis: t.axis === "secondary"
+			}
+		});
+	}), f(e, n, ["data"]);
+}, I = (e, t) => f(e, t.filterGroup ? [{
+	id: "filterGroup",
+	name: "setStaticFilterGroup",
+	payload: c(t.filterGroup)
+}] : [], ["filterGroup"]), L = async (t, n) => {
+	if (!n.sorting?.length) return {
+		state: t,
+		success: !0
+	};
+	let r = t.vSpec, i = new Map(n.sorting.map((e) => [e.by, e])), a = new Map(Object.entries(t.resolvedRefs).map(([e, t]) => [`${t.dataItemInternalKey}:${t.dataItemUniqueSignature}`, e])), o = r.querySettings?.sortingOrder ?? [], s = n.sorting.map((e) => t.resolvedRefs[e.by]), c = new Set(s.map((e) => `${e.dataItemInternalKey}:${e.dataItemUniqueSignature}`)), l = [...s, ...o.filter((e) => !c.has(`${e.dataItem.internalKey}:${e.dataItem.uniqueSignature}`)).map((e) => ({
+		dataItemInternalKey: e.dataItem.internalKey,
+		dataItemUniqueSignature: e.dataItem.uniqueSignature,
+		kind: e.fieldType === "dimension" ? "dimension" : "measure"
+	}))].map((t, n) => {
+		let r = a.get(`${t.dataItemInternalKey}:${t.dataItemUniqueSignature}`), s = o.find((e) => e.dataItem.internalKey === t.dataItemInternalKey && e.dataItem.uniqueSignature === t.dataItemUniqueSignature);
+		return {
+			...P(t),
+			newIndex: n,
+			sortDirection: (r ? i.get(r)?.direction : void 0) ?? s?.sortDirection ?? e.Asc
+		};
+	}), u = await f(t, [{
+		name: w.CHANGE_SORT_ORDER_AND_DIRECTION,
+		payload: { changeRequests: l }
+	}], ["sorting"]);
+	if (!u.success) return u;
+	let d = n.sorting.map((e) => ({
+		name: w.TOGGLE_SORTING_ITEM,
+		payload: {
+			...P(t.resolvedRefs[e.by]),
+			enabled: e.enabled ?? !0
+		}
+	}));
+	return u = await f(u.state, d, ["sorting"]), u;
+}, R = (e, t) => {
+	let n = [], { limiting: r } = t;
+	if (r?.queryLimit !== void 0 && n.push({
+		name: w.SET_QUERY_LIMIT,
+		payload: r.queryLimit
+	}), r?.topN) {
+		let t = e.resolvedRefs[r.topN.by];
+		n.push({
+			name: w.ENABLE_TOP_N,
+			payload: !0
+		}, {
+			name: w.SET_TOP_N_NUMBER_OF_VALUES,
+			payload: r.topN.count
+		}, {
+			name: w.SET_TOP_N_SORT_ORDER,
+			payload: r.topN.direction
+		}, {
+			name: w.SET_TOP_N_SHOW_OTHERS,
+			payload: r.topN.showOthers ?? !1
+		}, {
+			name: w.SET_TOP_N_RANK_MEASURE,
+			payload: {
+				...P(t),
+				...e.measureAggregations[r.topN.by] ? { aggregation: e.measureAggregations[r.topN.by] } : {}
+			}
+		});
+	}
+	return f(e, n, ["limiting"]);
+}, z = (e, t) => {
+	let n = [], { presentation: r } = t, i = s(r?.axes);
+	if (i) return Promise.resolve({
+		issue: i,
+		success: !1
+	});
+	r?.orientation !== void 0 && n.push({
+		name: w.SET_BAR_CHART_ORIENTATION,
+		payload: r.orientation
+	});
+	let a = r?.legend;
+	a && n.push(...d(e.vSpec, a)), Object.entries(r?.axes ?? {}).forEach(([e, t]) => {
+		t.titleVisible !== void 0 && n.push({
+			name: w.SET_SHOW_AXIS_TITLE,
+			payload: {
+				axisName: e,
+				showAxisName: t.titleVisible
+			}
+		}), t.title !== void 0 && n.push({
+			name: w.SET_AXIS_TITLE,
+			payload: {
+				axisName: e,
+				axisTitle: t.title
+			}
+		}), t.labelsVisible !== void 0 && n.push({
+			name: w.SET_SHOW_AXIS_LABELS,
+			payload: {
+				axisName: e,
+				showLabels: t.labelsVisible
+			}
+		}), t.ticksVisible !== void 0 && n.push({
+			name: w.SET_SHOW_AXIS_TICKS,
+			payload: {
+				axisName: e,
+				showAxisTicks: t.ticksVisible
+			}
+		}), t.lineVisible !== void 0 && n.push({
+			name: w.SET_SHOW_AXIS_LINE,
+			payload: {
+				axisName: e,
+				showAxisLine: t.lineVisible
+			}
+		}), n.push(...l(e, t)), "scale" in t && t.scale !== void 0 && n.push({
+			name: T.SET_AXIS_SCALE,
+			payload: {
+				axisName: e,
+				scale: t.scale
+			}
+		});
+	});
+	let o = r?.axes?.primaryMeasure?.bands;
+	return o && n.push({
+		name: S.SET_MEASURE_AXIS_BANDS,
+		payload: { bands: o }
+	}), f(e, n, ["presentation"]);
+}, B = async (e) => {
+	let t = y(e);
+	if (t) return {
+		issues: [{
+			code: "invalid_structure",
+			message: t,
+			path: []
+		}],
+		success: !1
+	};
+	let n = p.safeParse(e.definition);
+	if (!n.success) return {
+		issues: v(n.error, e.definition),
+		success: !1
+	};
+	let a = b.safeParse(e.baseVSpec);
+	if (!a.success) return {
+		issues: [u("invalid_structure", ["baseVSpec"], "Base bar vSpec is invalid.", { details: { issues: a.error.issues } })],
+		success: !1
+	};
+	let o = a.data, s = O(o);
+	if (s) return {
+		issues: [s],
+		success: !1
+	};
+	let c = n.data.data.measures.find((e) => e.ref === n.data.limiting?.topN?.by), l = (c ? e.availableFields.find((e) => e.fieldKey === c.fieldKey) : void 0)?.kind === "measure" ? [u("unsupported_feature", [
+		"limiting",
+		"topN",
+		"by"
+	], "Top N ranking by a predefined measure is not supported by the current query builder. Use a raw field or calculation.")] : [], d = [
+		...D(n.data),
+		...i(n.data.data.dimensions, e.availableFields, ["data", "dimensions"], "dimension"),
+		...i(n.data.data.measures, e.availableFields, ["data", "measures"], "measure"),
+		...m(n.data.filterGroup, e.availableFields),
+		...l
+	];
+	if (d.length > 0) return {
+		issues: d,
+		success: !1
+	};
+	let f = await N({
+		availableFields: r(e.availableFields),
+		input: e,
+		measureAggregations: {},
+		resolvedRefs: {},
+		vSpec: o
+	}, n.data), h = [
+		F,
+		I,
+		L,
+		R,
+		z,
+		(e, t) => _(e, t.presentation?.coloring)
+	];
+	for (let e of h) {
+		if ("issue" in f) return {
+			issues: [f.issue],
+			success: !1
+		};
+		f = await e(f.state, n.data);
+	}
+	if ("issue" in f) return {
+		issues: [f.issue],
+		success: !1
+	};
+	let g = b.safeParse(f.state.vSpec);
+	return g.success ? {
+		resolvedRefs: f.state.resolvedRefs,
+		success: !0,
+		vSpec: g.data
+	} : {
+		issues: [u("invalid_compiled_vspec", [], "Compiled bar vSpec failed final validation.", { details: { issues: g.error.issues } })],
+		success: !1
+	};
+};
+export { B as compileBarVisualizationDefinition };