@astrato-io/visualizations 0.0.0-stage → 0.6.4

package/chunks/shared-CKDL4hx9.js

@@ -0,0 +1,1171 @@
+import { No as e, Po as t, Ss as n, ds as r, gs as i, hs as a, is as o } from "./interfaces-VUY4_yVO.js";
+import { On as s, Rn as c, Un as l, Vt as u, Xt as d, an as ee, pn as te, qt as ne, yn as re } from "./event-bus-KiSiCJrC.js";
+import { $u as f, Ju as p, Md as ie, Wd as m, Xf as ae, Zu as h, _f as g, af as oe, df as se, ed as ce, nd as le, of as ue, rd as de, sf as fe, vd as _, vf as pe, yf as me } from "./src-Dun_jXtz.js";
+import { T as he, d as ge, t as v, y } from "./src-C0LgoUWY.js";
+import { z as b } from "zod";
+var x = r(), S = (e) => e, C = b.string().trim().min(1).max(100), w = b.string().min(1).refine((e) => e.trim().length > 0, "Field key cannot be blank."), _e = S(re.shape.dataType), ve = S(te.shape.formatType), ye = b.object({
+	distinct: b.boolean().optional(),
+	name: b.string().trim().min(1),
+	resultType: b.string().optional()
+}).strict(), be = b.object({
+	aggregations: b.array(ye).default([]),
+	dataType: _e,
+	fieldKey: w,
+	isManualData: b.boolean().optional(),
+	kind: b.literal("field").default("field"),
+	name: b.string().min(1),
+	schema: b.string().min(1),
+	view: b.string().min(1)
+}).strict(), T = b.object({
+	description: b.string().optional(),
+	id: b.string().min(1).optional(),
+	key: w,
+	name: b.string().min(1),
+	views: b.array(b.string()).optional()
+}).passthrough(), xe = T.extend({
+	dimension: b.record(b.string(), b.unknown()),
+	type: b.literal("dimension")
+}), Se = T.extend({
+	measure: b.object({ aggregation: b.string().min(1) }).passthrough(),
+	type: b.literal("measure")
+}), Ce = T.extend({
+	calculation: b.record(b.string(), b.unknown()),
+	type: b.literal("calculation")
+}), we = b.object({
+	fieldKey: w,
+	item: xe,
+	kind: b.literal("dimension"),
+	name: b.string().min(1)
+}).strict(), Te = b.object({
+	fieldKey: w,
+	item: Se,
+	kind: b.literal("measure"),
+	name: b.string().min(1)
+}).strict(), Ee = b.object({
+	fieldKey: w,
+	item: Ce,
+	kind: b.literal("calculation"),
+	name: b.string().min(1)
+}).strict(), E = b.union([
+	be,
+	we,
+	Te,
+	Ee
+]).superRefine((e, t) => {
+	e.kind !== "field" && e.item.key !== e.fieldKey && t.addIssue({
+		code: "custom",
+		message: "Semantic item key must match fieldKey.",
+		path: ["item", "key"]
+	});
+}), D = b.object({
+	currency: b.string().min(1).optional(),
+	currencyIsPrefix: b.boolean().optional(),
+	formatString: b.string().optional(),
+	formatType: ve.optional(),
+	negativeType: S(te.shape.negativeType.unwrap()).optional()
+}).strict(), De = b.discriminatedUnion("mode", [b.object({
+	dateLevel: S(b.enum(x.DateLevel)).describe("Year-aware bucket, such as month over time."),
+	mode: b.literal("level")
+}).strict(), b.object({
+	datePart: S(b.enum(x.DatePart)).describe("Date part, such as month of year."),
+	mode: b.literal("part")
+}).strict()]), O = b.object({
+	fieldKey: w,
+	format: D.pick({
+		formatString: !0,
+		formatType: !0
+	}).optional(),
+	ref: C,
+	showNullValues: b.boolean().optional(),
+	temporalGrouping: De.describe("Groups a date dimension. Applied before format; format must then suit the grouping.").optional()
+}).strict(), Oe = b.object({
+	placements: b.array(S(b.enum(c))).min(1).optional(),
+	visible: b.boolean()
+}).strict(), k = b.object({
+	aggregation: b.string().trim().min(1).describe("Required for a raw field measure; omit for a predefined measure or calculation.").optional(),
+	dataLabels: Oe.optional(),
+	fieldKey: w,
+	format: D.optional(),
+	ref: C
+}).strict(), ke = b.object({
+	fieldKey: w,
+	operator: S(b.enum(se)),
+	value: b.string()
+}).strict(), Ae = b.object({
+	fieldKey: w,
+	operator: S(b.enum(fe)),
+	valueFrom: b.string(),
+	valueTo: b.string()
+}).strict(), je = b.object({
+	fieldKey: w,
+	operator: S(b.enum(oe)),
+	values: b.array(b.string()).min(1)
+}).strict(), Me = b.object({
+	fieldKey: w,
+	operator: S(b.enum(ue))
+}).strict(), Ne = b.union([
+	ke,
+	Ae,
+	je,
+	Me
+]), A = b.lazy(() => b.object({
+	filters: b.array(b.union([Ne, A])),
+	operator: b.enum(["and", "or"])
+}).strict()), j = b.object({
+	by: C,
+	direction: S(u.shape.sortDirection),
+	enabled: b.boolean().optional()
+}).strict(), Pe = b.object({
+	by: C,
+	count: b.number().int().positive(),
+	direction: S(u.shape.sortDirection),
+	showOthers: b.boolean().optional()
+}).strict(), Fe = b.object({
+	queryLimit: b.number().int().positive().optional(),
+	topN: Pe.optional()
+}).strict(), M = b.object({
+	position: S(ee.shape.position).optional(),
+	title: b.string().optional(),
+	visible: b.boolean().optional()
+}).strict(), N = b.object({
+	labelsVisible: b.boolean().optional(),
+	lineVisible: b.boolean().optional(),
+	ticksVisible: b.boolean().optional(),
+	title: b.string().optional(),
+	titleVisible: b.boolean().optional()
+}).strict(), Ie = b.union([b.object({
+	max: b.number().optional(),
+	min: b.number().optional().describe("Must be less than max when both are set")
+}).strict(), b.object({ startsAtZero: b.boolean() }).strict()]).describe("Fix min, max or both, or set startsAtZero on an axis fitted to the data"), Le = b.array(ae).optional().describe("Shaded ranges drawn across the plot between two primary measure axis values"), Re = g({}), ze = g({ dimension: C.describe(`Alias of a dimension in data.dimensions. ${me}`) }), Be = pe({ measure: C.describe("Alias of the measure in data.measures whose value is compared") }), Ve = "Colors bound to dimension values, eg. \"Happy\" is dark teal. The first matching entry wins, ahead of rules and the palette. For ordered bands, add one entry per band with colors taken along a ramp.", He = b.array(Be).min(1).describe("Colors bound to measure thresholds, eg. red when sales is below 100. The first matching rule wins."), P = (e) => b.object({
+	overwrites: b.array(e.requiresOverwriteDimension ? ze : Re).min(1).describe(Ve).optional(),
+	...e.rules ? { rules: He.optional() } : {}
+}).strict(), F = {
+	inverted: b.boolean().optional().describe("Reverse the direction of the axis values, eg. to put rank 1 at the top"),
+	range: Ie.optional()
+}, I = { bands: Le }, L = { scale: S(b.enum(l)).optional() };
+N.extend({
+	...F,
+	...I,
+	...L
+}).strict();
+var R = ({ logScale: e = !1, primaryMeasureBands: t = !1, rangedMeasureAxes: n = [] } = {}) => {
+	let r = (t, r) => N.extend({
+		...n.includes(t) ? F : {},
+		...r ? I : {},
+		...e ? L : {}
+	}).strict();
+	return b.object({
+		dimension: N.optional(),
+		primaryMeasure: r("primaryMeasure", t).optional(),
+		secondaryMeasure: r("secondaryMeasure", !1).optional()
+	}).strict();
+};
+R();
+var z = b.object({
+	axes: R({
+		logScale: !0,
+		primaryMeasureBands: !0,
+		rangedMeasureAxes: ["primaryMeasure", "secondaryMeasure"]
+	}).optional(),
+	legend: M.optional(),
+	orientation: S(b.enum(t)).optional()
+}).strict(), Ue = k.extend({ axis: b.enum(["primary", "secondary"]).optional() }), We = b.object({
+	data: b.object({
+		dimensions: b.array(O).min(1),
+		measures: b.array(Ue).min(1)
+	}).strict(),
+	filterGroup: A.optional(),
+	limiting: Fe.optional(),
+	presentation: z.extend({ coloring: P({ rules: !0 }).optional() }).optional(),
+	sorting: b.array(j).optional(),
+	type: b.literal("bar"),
+	version: b.literal(1)
+}).strict(), B = b.object({ visible: b.boolean() }).strict(), V = (e, t) => b.array(e).min(t.min).max(t.max), H = (e, n) => {
+	let r = {};
+	if (n.dimensions.max > 0) {
+		let e = V(O, n.dimensions);
+		r.dimensions = n.dimensions.min === 0 ? e.optional() : e;
+	}
+	if (n.measures.max > 0) {
+		let e = n.dataLabels ? k.omit({ dataLabels: !0 }).extend({ dataLabels: B.optional() }) : k.omit({ dataLabels: !0 }), t = n.comboSeriesTypes ? e.extend({ seriesType: b.enum([
+			"bar",
+			"line",
+			"point"
+		]).optional() }) : e, i = V(n.measureAxis ? t.extend({ axis: b.enum(["primary", "secondary"]).optional() }) : t, n.measures);
+		r.measures = n.measures.min === 0 ? i.optional() : i;
+	}
+	let i = {};
+	if (n.axes) {
+		let e = R({
+			logScale: n.measureAxisScale,
+			primaryMeasureBands: n.measureAxisBands,
+			rangedMeasureAxes: n.rangedMeasureAxes
+		});
+		i.axes = (n.secondaryDimensionAxis ? e.extend({ secondaryDimension: N.optional() }) : e).optional();
+	}
+	n.conditionalColoring && (i.coloring = P(n.conditionalColoring).optional()), n.dataLabels && (i.dataLabels = B.optional()), n.gaugeDisplayMode && (i.displayMode = b.enum(["bar", "radial"]).optional()), n.legend && (i.legend = M.optional()), n.orientation && (i.orientation = S(b.enum(t)).optional()), n.treeLayout && (i.layout = b.object({
+		compact: b.boolean().optional(),
+		direction: b.enum([
+			"bottom",
+			"left",
+			"right",
+			"top"
+		]).optional(),
+		forceAutoFit: b.boolean().optional(),
+		initialExpandedLevels: b.number().int().min(0).optional()
+	}).strict().optional());
+	let a = {
+		data: b.object(r).strict(),
+		filterGroup: A.optional(),
+		type: b.literal(e),
+		version: b.literal(1)
+	};
+	return n.queryLimit && (a.limiting = b.object({ queryLimit: b.number().int().positive().optional() }).strict().optional()), Object.keys(i).length > 0 && (a.presentation = b.object(i).strict().optional()), n.sorting && (a.sorting = b.array(j).optional()), b.object(a).strict().superRefine((t, r) => {
+		let i = t.data, a = n.validateCounts?.(i.dimensions?.length ?? 0, i.measures?.length ?? 0);
+		a && r.addIssue({
+			code: "custom",
+			message: a,
+			path: ["data"]
+		});
+		let o = n.conditionalColoring?.minDimensions ?? 0;
+		t.presentation?.coloring && (i.dimensions?.length ?? 0) < o && r.addIssue({
+			code: "custom",
+			message: `${e} value colors require at least ${o} dimensions.`,
+			path: ["presentation", "coloring"]
+		}), n.validateDefinition?.(t, r);
+	});
+}, Ge = H("combo", {
+	axes: !0,
+	comboSeriesTypes: !0,
+	dataLabels: !0,
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	legend: !0,
+	measureAxis: !0,
+	measureAxisBands: !0,
+	measureAxisScale: !0,
+	measures: {
+		min: 1,
+		max: 10
+	},
+	orientation: !0,
+	queryLimit: !0,
+	sorting: !0,
+	rangedMeasureAxes: ["primaryMeasure", "secondaryMeasure"],
+	validateDefinition: (e, t) => {
+		let n = e.data.measures ?? [];
+		n.forEach((e, n) => {
+			e.dataLabels?.visible && e.seriesType !== "bar" && t.addIssue({
+				code: "custom",
+				message: "Combo data labels are supported only for bar series.",
+				path: [
+					"data",
+					"measures",
+					n,
+					"dataLabels"
+				]
+			});
+		}), e.presentation?.dataLabels?.visible && !n.some((e) => e.seriesType === "bar") && t.addIssue({
+			code: "custom",
+			message: "Visible combo data labels require at least one bar series.",
+			path: ["presentation", "dataLabels"]
+		}), new Set(n.filter((e) => e.seriesType === "bar" && e.axis).map((e) => e.axis)).size > 1 && n.forEach((e, n) => {
+			e.seriesType === "bar" && e.axis && t.addIssue({
+				code: "custom",
+				message: "Combo bar series share one measure axis, so every bar measure must name the same axis.",
+				path: [
+					"data",
+					"measures",
+					n,
+					"axis"
+				]
+			});
+		});
+	}
+}), Ke = H("dot", {
+	conditionalColoring: { rules: !0 },
+	axes: !0,
+	dimensions: {
+		min: 2,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 1
+	},
+	orientation: !0,
+	rangedMeasureAxes: ["primaryMeasure"]
+}), qe = H("scatter", {
+	conditionalColoring: { rules: !0 },
+	axes: !0,
+	dimensions: {
+		min: 1,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 2,
+		max: 3
+	},
+	queryLimit: !0,
+	rangedMeasureAxes: ["primaryMeasure", "secondaryMeasure"],
+	sorting: !0
+}), Je = H("histogram", {
+	axes: !0,
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	legend: !0,
+	measureAxisBands: !0,
+	measures: {
+		min: 0,
+		max: 0
+	},
+	orientation: !0,
+	rangedMeasureAxes: ["primaryMeasure"]
+}), Ye = H("heatMap", {
+	conditionalColoring: { rules: !0 },
+	axes: !0,
+	dimensions: {
+		min: 2,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 2
+	},
+	queryLimit: !0,
+	secondaryDimensionAxis: !0,
+	sorting: !0
+}), Xe = H("radar", {
+	conditionalColoring: {
+		minDimensions: 2,
+		rules: !1
+	},
+	dimensions: {
+		min: 0,
+		max: 2
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 5
+	},
+	validateCounts: (e, t) => {
+		if (e === 0 && t < 2) return "Radar charts without dimensions require at least two measures.";
+		if (e > 0 && t > 1) return "Radar charts with dimensions support exactly one measure.";
+	}
+}), Ze = H("gauge", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 0,
+		max: 1
+	},
+	gaugeDisplayMode: !0,
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 20
+	},
+	validateCounts: (e, t) => e === 1 && t > 2 ? "Gauge charts with a dimension support at most two measures." : void 0
+}), Qe = H("distribution-gauge", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 0,
+		max: 1
+	},
+	gaugeDisplayMode: !0,
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 20
+	}
+}), $e = H("pie", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 2
+	},
+	queryLimit: !0,
+	sorting: !0
+}), et = H("tree", {
+	dimensions: {
+		min: 0,
+		max: 10
+	},
+	measures: {
+		min: 0,
+		max: 100
+	},
+	queryLimit: !0,
+	sorting: !0,
+	treeLayout: !0,
+	validateCounts: (e, t) => e + t === 0 ? "Tree charts require at least one dimension or measure." : e > 0 && t > 1 ? "Tree charts with dimensions support at most one measure." : void 0
+}), tt = H("treemap", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 1,
+		max: 10
+	},
+	legend: !0,
+	measures: {
+		min: 1,
+		max: 1
+	}
+}), nt = H("sankey", {
+	conditionalColoring: {
+		requiresOverwriteDimension: !0,
+		rules: !0
+	},
+	dimensions: {
+		min: 2,
+		max: 15
+	},
+	measures: {
+		min: 1,
+		max: 1
+	}
+}), rt = H("waterfall", {
+	axes: !0,
+	dataLabels: !0,
+	dimensions: {
+		min: 0,
+		max: 0
+	},
+	measureAxisBands: !0,
+	measures: {
+		min: 1,
+		max: 100
+	},
+	orientation: !0,
+	rangedMeasureAxes: ["primaryMeasure"]
+}), it = H("word-cloud", {
+	conditionalColoring: { rules: !0 },
+	dimensions: {
+		min: 1,
+		max: 1
+	},
+	measures: {
+		min: 1,
+		max: 1
+	}
+}), at = b.enum(["dropdown", "listbox"]), ot = b.object({
+	mode: at.optional(),
+	quickSelect: b.boolean().optional(),
+	responsive: b.boolean().optional(),
+	searchable: b.boolean().optional(),
+	showProgressBar: b.boolean().optional()
+}).strict(), st = b.object({
+	data: b.object({ field: O.omit({
+		format: !0,
+		showNullValues: !0,
+		temporalGrouping: !0
+	}) }).strict(),
+	presentation: ot.optional(),
+	type: b.literal("filter"),
+	version: b.literal(1)
+}).strict(), ct = b.object({
+	orientation: b.enum(["horizontal", "vertical"]).optional(),
+	selectionMode: b.enum([
+		"inherit",
+		"auto",
+		"manual"
+	]).optional(),
+	enableAddingNewFilters: b.boolean().optional(),
+	enableAssociativeFilter: b.boolean().optional(),
+	showClearAll: b.boolean().optional(),
+	showChartBreakdown: b.boolean().optional(),
+	selectableFieldKeys: b.array(b.string()).optional()
+}).strict(), lt = b.object({
+	settings: ct.optional(),
+	type: b.literal("astrato-app-filter-bar"),
+	version: b.literal(1)
+}).strict(), ut = k.omit({ dataLabels: !0 }).extend({
+	axis: b.enum(["primary", "secondary"]).optional(),
+	dataPointShape: S(d.shape.dataPointShape)
+}), dt = b.object({
+	density: ne.optional(),
+	visible: b.boolean()
+}).strict(), ft = z.extend({
+	coloring: P({ rules: !1 }).optional(),
+	dataLabels: dt.optional()
+}), pt = b.object({
+	data: b.object({
+		dimensions: b.array(O).min(1),
+		measures: b.array(ut).min(1)
+	}).strict(),
+	filterGroup: A.optional(),
+	limiting: b.object({ queryLimit: b.number().int().positive().optional() }).strict().optional(),
+	presentation: ft.optional(),
+	sorting: b.array(j).optional(),
+	type: b.literal("line"),
+	version: b.literal(1)
+}).strict().superRefine((e, t) => {
+	e.presentation?.coloring && e.data.dimensions.length < 2 && t.addIssue({
+		code: "custom",
+		message: "Line value colors require at least two dimensions.",
+		path: ["presentation", "coloring"]
+	}), e.presentation?.dataLabels?.visible && e.data.measures.forEach((e, n) => {
+		e.dataPointShape || t.addIssue({
+			code: "custom",
+			message: "Visible line data labels require a data-point shape for every measure.",
+			path: [
+				"data",
+				"measures",
+				n,
+				"dataPointShape"
+			]
+		});
+	});
+}), mt = b.object({
+	data: b.object({ measure: k.omit({ dataLabels: !0 }) }).strict(),
+	filterGroup: A.optional(),
+	type: b.literal("number"),
+	version: b.literal(1)
+}).strict(), ht = S(ie.pick({
+	endDateLabel: !0,
+	pickerState: !0,
+	pickerType: !0,
+	quickSelect: !0,
+	responsive: !0,
+	startDateLabel: !0,
+	timePickerVisibility: !0,
+	weekStart: !0
+}).partial()), gt = b.object({
+	data: b.object({ field: O.omit({
+		format: !0,
+		showNullValues: !0,
+		temporalGrouping: !0
+	}) }).strict(),
+	settings: ht.optional(),
+	type: b.literal("date-picker"),
+	version: b.literal(1)
+}).strict(), _t = b.object({
+	settings: b.object({ url: b.string().url().nullable() }).strict(),
+	type: b.literal("iframe"),
+	version: b.literal(1)
+}).strict(), vt = b.object({
+	settings: S(b.object({
+		blur: _.shape.blur.optional(),
+		fit: _.shape.image.unwrap().shape.imageFit.optional(),
+		opacity: _.shape.opacity.optional(),
+		saturation: _.shape.saturation.optional(),
+		shadow: _.shape.shadow.optional(),
+		source: ge.optional()
+	}).strict()),
+	type: b.literal("image"),
+	version: b.literal(1)
+}).strict(), yt = b.object({
+	settings: S(de.pick({
+		backgroundColor: !0,
+		backgroundType: !0,
+		borderEnabled: !0,
+		borderRadius: !0,
+		heightBasedSize: !0,
+		imageFit: !0,
+		imageURL: !0,
+		lineThickness: !0,
+		preserveAspectRatio: !0,
+		rotate: !0,
+		scale: !0,
+		shape: !0,
+		strokeColor: !0
+	}).partial().strict()),
+	type: b.literal("shape"),
+	version: b.literal(1)
+}).strict(), U = le.shape.simpleTextObjectSettings, bt = b.object({
+	settings: S(b.object({
+		align: U.shape.align.optional(),
+		content: b.string().optional(),
+		fontFamily: U.shape.fontFamily.optional(),
+		fontSize: U.shape.fontSize.optional(),
+		position: U.shape.position.optional(),
+		representation: U.shape.representation.optional(),
+		responsive: U.shape.responsive.optional(),
+		textColor: U.shape.textColor.optional(),
+		wordWrap: U.shape.wordWrap.optional()
+	}).strict()),
+	type: b.literal("simpleTextObject"),
+	version: b.literal(1)
+}).strict(), xt = b.object({
+	settings: S(b.object({
+		customLabel: m.shape.commonSettings.shape.customLabel.optional(),
+		hideLabel: m.shape.commonSettings.shape.hideLabel.optional(),
+		inputType: m.shape.type.optional(),
+		placeholder: m.shape.commonSettings.shape.placeholder.optional(),
+		responsive: m.shape.commonSettings.shape.responsive.optional(),
+		variableId: m.shape.commonSettings.shape.variableId.optional()
+	}).strict()),
+	type: b.literal("atomic-input"),
+	version: b.literal(1)
+}).strict(), St = b.object({
+	data: b.object({ field: O.omit({
+		format: !0,
+		showNullValues: !0,
+		temporalGrouping: !0
+	}) }).strict(),
+	settings: S(ce.pick({
+		layout: !0,
+		quickSelect: !0,
+		range: !0,
+		step: !0
+	}).partial()).optional(),
+	type: b.literal("slider"),
+	version: b.literal(1)
+}).strict(), Ct = O.extend({ role: b.literal("dimension") }), W = k.omit({ dataLabels: !0 }), wt = W.extend({ role: b.literal("measure") }), Tt = b.object({
+	columns: b.array(b.discriminatedUnion("role", [Ct, wt])).min(1),
+	structure: b.literal("normal").optional()
+}).strict(), Et = b.object({
+	dimensions: b.array(O).min(1),
+	measures: b.array(W).min(1),
+	structure: b.literal("expandable")
+}).strict(), Dt = b.object({
+	columnDimensions: b.array(O).min(1),
+	measures: b.array(W).min(1),
+	rowDimensions: b.array(O).min(1),
+	structure: b.literal("pivot")
+}).strict(), Ot = b.union([
+	Tt,
+	Et,
+	Dt
+]), kt = b.object({
+	applyTo: p.shape.applyTo,
+	enabled: p.shape.enabled,
+	showRecordsCount: p.shape.showRecordsCount,
+	style: b.object({
+		backgroundColor: f.shape.backgroundColor.optional(),
+		fontColor: f.shape.fontColor.optional(),
+		fontStyle: h.optional(),
+		position: f.shape.position.optional(),
+		responsiveHeight: f.shape.responsive
+	}).strict().optional()
+}).strict(), At = b.object({
+	background: b.object({
+		color: s.optional(),
+		evenColor: s.optional(),
+		oddColor: s.optional(),
+		type: b.enum([
+			"none",
+			"single",
+			"zebra"
+		])
+	}).strict().optional(),
+	body: b.object({
+		fontColor: s.optional(),
+		fontFamily: b.string().trim().min(1).optional(),
+		fontSize: b.number().positive().optional(),
+		fontStyle: h.optional(),
+		horizontalAlign: b.enum([
+			"auto",
+			"center",
+			"left",
+			"right"
+		]).optional(),
+		verticalAlign: b.enum([
+			"auto",
+			"bottom",
+			"middle",
+			"top"
+		]).optional()
+	}).strict().optional(),
+	borders: b.object({
+		color: s.optional(),
+		dividerColor: s.optional(),
+		dividers: b.enum([
+			"all",
+			"auto",
+			"horizontal",
+			"none",
+			"vertical"
+		]).optional(),
+		enabled: b.boolean(),
+		lineStyle: b.enum([
+			"dashed",
+			"dotted",
+			"line"
+		]).optional(),
+		radius: b.number().nonnegative().optional(),
+		strokeWidth: b.number().nonnegative().optional()
+	}).strict().optional(),
+	header: b.object({
+		backgroundColor: s.optional(),
+		borderColor: s.optional(),
+		fontColor: s.optional(),
+		fontFamily: b.string().trim().min(1).optional(),
+		fontSize: b.number().positive().optional(),
+		fontStyle: h.optional(),
+		responsiveHeight: b.boolean().optional()
+	}).strict().optional(),
+	highlight: b.object({
+		backgroundColor: s.optional(),
+		mode: b.enum([
+			"column",
+			"none",
+			"row",
+			"row-and-column"
+		]),
+		textColor: s.optional()
+	}).strict().optional(),
+	layout: b.object({
+		columnWidthBehavior: b.enum(["responsive", "static"]).optional(),
+		rowHeight: b.number().positive().optional()
+	}).strict().optional()
+}).strict(), jt = b.object({
+	data: Ot,
+	filterGroup: A.optional(),
+	limiting: b.object({ queryLimit: b.number().int().positive().optional() }).strict().optional(),
+	presentation: At.optional(),
+	sorting: b.array(j).optional(),
+	totals: kt.optional(),
+	type: b.literal("table"),
+	version: b.literal(1)
+}).strict(), G = (e) => typeof e == "object" && !!e && !Array.isArray(e), Mt = (e) => {
+	let t = e.fieldKey ?? e.key;
+	return typeof t == "string" ? t : void 0;
+}, Nt = (e) => {
+	if (Array.isArray(e)) return e;
+	if (!G(e)) throw Error("Available field metadata must be an array or an object.");
+	return [
+		"fields",
+		"dimensions",
+		"measures"
+	].flatMap((t) => {
+		let n = e[t];
+		if (n === void 0) return [];
+		if (!Array.isArray(n)) throw Error(`Available field metadata "${t}" must be an array.`);
+		return n;
+	});
+}, Pt = (e, t) => {
+	let n = e.type;
+	if (!(n === "dimension" && G(e.dimension) || n === "measure" && G(e.measure) || n === "calculation" && G(e.calculation))) return;
+	let r = E.safeParse({
+		fieldKey: e.key,
+		item: e,
+		kind: n,
+		name: e.name
+	});
+	if (!r.success) throw Error(`Invalid available semantic item at index ${t}: ${r.error.message}`);
+	return r.data;
+}, Ft = (e, t) => {
+	if (!G(e)) throw Error(`Available field at index ${t} must be an object.`);
+	let n = E.safeParse(e);
+	if (n.success) return n.data;
+	let r = Pt(e, t);
+	if (r) return r;
+	let i = Array.isArray(e.aggregations) ? e.aggregations : Array.isArray(e.aggregators) ? e.aggregators : [], a = E.safeParse({
+		aggregations: i.map((e) => G(e) ? {
+			distinct: e.distinct,
+			name: e.name ?? e.funcName,
+			resultType: e.resultType
+		} : e),
+		dataType: e.dataType,
+		fieldKey: Mt(e),
+		isManualData: e.isManualData,
+		kind: "field",
+		name: e.name,
+		schema: e.schema,
+		view: e.view
+	});
+	if (!a.success) throw Error(`Invalid available field at index ${t}: ${a.error.message}`);
+	return a.data;
+}, It = (e) => {
+	let t = Nt(e).map(Ft), n = /* @__PURE__ */ new Map();
+	return t.forEach((e, t) => {
+		let r = n.get(e.fieldKey);
+		if (r !== void 0) throw Error(`Duplicate available field key "${e.fieldKey}" at indexes ${r} and ${t}.`);
+		n.set(e.fieldKey, t);
+	}), t;
+}, Lt = (e) => e.kind === "field" ? [...new Set(e.aggregations.flatMap((e) => [e.name, ...e.distinct ? [`${e.name}_DISTINCT`] : []]))] : [], Rt = (e, t) => e.kind === "field" || t === "dimension" && e.kind === "dimension" || t === "measure" && (e.kind === "measure" || e.kind === "calculation"), zt = (e) => {
+	if (e.kind !== "dimension") return e.kind;
+}, Bt = (e) => ({
+	...structuredClone(e.item),
+	id: e.item.id ?? e.fieldKey
+}), Vt = (e) => e.map((e) => e.kind === "dimension" ? i(Bt(e)) : e.kind === "measure" || e.kind === "calculation" ? a(Bt(e)) : {
+	aggregators: n(e.aggregations.map((e) => ({
+		distinct: e.distinct ?? !1,
+		name: e.name,
+		resultType: e.resultType
+	}))),
+	dataType: e.dataType,
+	isManualData: e.isManualData,
+	key: e.fieldKey,
+	name: e.name,
+	schema: e.schema,
+	view: e.view,
+	views: [e.view]
+}), K = (e) => e.reduce((e, t) => typeof t == "number" ? `${e}[${t}]` : /^[A-Za-z_$][\w$]*$/.test(t) ? e ? `${e}.${t}` : t : `${e}[${JSON.stringify(t)}]`, "") || "definition", q = (e) => {
+	if (typeof e == "number" && !Number.isFinite(e)) return String(e);
+	try {
+		return JSON.stringify(e) ?? String(e);
+	} catch {
+		return String(e);
+	}
+}, Ht = (e, t) => t.reduce((e, t) => typeof e == "object" && e && Object.prototype.hasOwnProperty.call(e, t) ? e[t] : void 0, e), Ut = (e) => {
+	if (e.code === "invalid_value") return e.values;
+	if (e.code !== "invalid_union" || e.errors.length === 0) return;
+	let t = e.errors.map((e) => e.length === 1 && e[0].path.length === 0 ? Ut(e[0]) : void 0);
+	return t.every((e) => e !== void 0) ? [...new Set(t.flat())] : void 0;
+}, Wt = (e, t, n = []) => {
+	let r = (e, i) => {
+		let a = [...i, ...e.path.filter((e) => typeof e != "symbol")];
+		if (e.code === "unrecognized_keys") return e.keys.map((r) => {
+			let i = [
+				...n,
+				...a,
+				r
+			];
+			return {
+				code: "invalid_structure",
+				path: i,
+				message: `${K(i)}: Unrecognized key.`,
+				details: {
+					received: Ht(t, [...a, r]),
+					zodCode: e.code
+				}
+			};
+		});
+		let o = [...n, ...a], s = Ht(t, a), c = Ut(e), l = {
+			received: s,
+			zodCode: e.code
+		}, u = c ? `Unsupported value ${q(s)}. Allowed values: ${c.map(q).join(", ")}.` : `${e.message}. Received: ${q(s)}.`;
+		if (e.code === "invalid_union" && !c && e.errors.length > 0) {
+			let t = e.errors.filter((e) => !e.some((e) => e.code === "unrecognized_keys"));
+			if (t.length === 1) return t[0].flatMap((e) => r(e, a));
+			let n = e.errors.map((e) => e.flatMap((e) => r(e, a)));
+			l.alternatives = n, u = `Value does not match any allowed shape. ${n.map((e, t) => `Alternative ${t + 1}: ${e.map((e) => e.message).join(" ")}`).join(" ")}`;
+		}
+		return [{
+			code: "invalid_structure",
+			path: o,
+			message: `${K(o)}: ${u}`,
+			details: l,
+			...c ? { allowedValues: c } : {}
+		}];
+	};
+	return e.issues.flatMap((e) => r(e, []));
+}, Gt = (t, n) => {
+	let r = "legend" in t && !!t.legend, i = n.position !== void 0 || n.title !== void 0, a = [];
+	return n.visible !== void 0 && (n.visible || i || r) ? a.push({
+		name: "setLegendEnabled",
+		payload: n.visible
+	}) : n.visible === void 0 && i && !r && a.push({
+		name: "setLegendEnabled",
+		payload: !0
+	}), n.position === void 0 ? (n.visible === !0 || i && !r) && a.push({
+		name: "setLegendPosition",
+		payload: e.Right
+	}) : a.push({
+		name: "setLegendPosition",
+		payload: n.position
+	}), n.title !== void 0 && a.push({
+		name: "setLegendTitle",
+		payload: n.title
+	}), a;
+}, J = (e, t, n, r = {}) => ({
+	code: e,
+	message: n,
+	path: t,
+	...r
+}), Kt = (e) => {
+	let t = Object.entries(e).find(([, e]) => e.success === !1);
+	return t ? {
+		id: t[0],
+		result: t[1]
+	} : void 0;
+}, Y = async (e, t, n) => {
+	let r = t.map((e, t) => ({
+		...e,
+		id: e.id ?? `definition:${t}`
+	})), i = await v(e.vSpec, e.availableFields, r.map(({ id: e, name: t, payload: n }) => ({
+		id: e,
+		name: t,
+		payload: n
+	})), e.input.variables ?? [], [], e.input.theme), a = Kt(i.results);
+	if (!a) return {
+		state: {
+			...e,
+			vSpec: i.vSpec
+		},
+		success: !0
+	};
+	let o = r.find((e) => e.id === a.id), s = o?.definitionContext, c = s?.path ?? n, l = o?.name ?? a.id, u = a.result.error ?? "Operation failed.", d = s ? `Cannot apply ${q(s.received)} to ${s.kind} ${q(s.ref)}` : "Operation failed";
+	return {
+		issue: J("operation_failed", c, `${K(c)}: ${d} (operation "${l}"): ${u}`, { details: {
+			error: a.result.error,
+			operationId: a.id,
+			operationName: l,
+			...s ? {
+				received: s.received,
+				ref: s.ref,
+				role: s.kind
+			} : {}
+		} }),
+		success: !1
+	};
+}, qt = (e, t, n, r, i, a) => ({
+	name: e,
+	payload: {
+		...X(t),
+		[i]: a
+	},
+	definitionContext: {
+		path: [
+			...r,
+			"format",
+			i
+		],
+		received: a,
+		ref: n,
+		kind: t.kind
+	}
+}), Jt = (e, t, n, r, i, a, o) => ({
+	name: e,
+	payload: {
+		name: t,
+		[i]: a
+	},
+	definitionContext: {
+		path: [
+			...r,
+			"format",
+			i
+		],
+		received: a,
+		ref: n,
+		kind: o
+	}
+}), Yt = (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
+	};
+}, X = (e) => ({
+	dataItemInternalKey: e.dataItemInternalKey,
+	dataItemUniqueSignature: e.dataItemUniqueSignature
+}), Xt = (e) => {
+	let t = [], n = /* @__PURE__ */ new Set();
+	return e.forEach(({ items: e, path: r }) => {
+		e.forEach((e, i) => {
+			n.has(e.ref) && t.push(J("duplicate_alias", [
+				...r,
+				i,
+				"ref"
+			], `Reference "${e.ref}" is duplicated.`)), n.add(e.ref);
+		});
+	}), t;
+}, Zt = (e, t) => {
+	let n = e, r = n.referencedData;
+	return t.every((e) => !Array.isArray(n[e]) || n[e].length === 0) && (typeof r != "object" || !r || Object.keys(r).length === 0);
+}, Qt = (e, t) => ({
+	availableFields: Vt(e.availableFields),
+	input: e,
+	resolvedRefs: {},
+	vSpec: t
+}), $t = async (e, t, n, r, i, a) => {
+	let o = `${n}:${t.ref}`, s = await v(e.vSpec, e.availableFields, [{
+		id: o,
+		name: r,
+		payload: i
+	}], e.input.variables ?? [], [], e.input.theme), c = Kt(s.results), l = Yt(s.results[o], n);
+	return c || !l ? {
+		issue: J("operation_failed", a, c?.result.error ?? `${n} operation did not return the created data-item identity.`),
+		success: !1
+	} : {
+		state: {
+			...e,
+			resolvedRefs: {
+				...e.resolvedRefs,
+				[t.ref]: l
+			},
+			vSpec: s.vSpec
+		},
+		success: !0
+	};
+}, en = (e, t, n, r) => {
+	let i = [
+		"formatType",
+		"formatString",
+		"currency",
+		"currencyIsPrefix",
+		"negativeType"
+	];
+	return Y(e, t.flatMap((t, a) => {
+		let o = e.resolvedRefs[t.ref];
+		return i.flatMap((e) => {
+			let i = t.format?.[e], s = n[e];
+			return i !== void 0 && s ? [qt(s, o, t.ref, t.path ?? [...r, a], e, i)] : [];
+		});
+	}), r);
+}, tn = (e, t, n, r, i) => ({
+	name: e,
+	payload: {
+		...X(t),
+		...i
+	},
+	definitionContext: {
+		path: [...r, "temporalGrouping"],
+		received: i,
+		ref: n,
+		kind: t.kind
+	}
+}), nn = (e, t, n, r) => Y(e, t.flatMap((t, i) => t.temporalGrouping ? [tn(n, e.resolvedRefs[t.ref], t.ref, t.path ?? [...r, i], t.temporalGrouping)] : []), r), rn = (e, t, n, r) => Y(e, t.flatMap((t) => t.showNullValues === void 0 ? [] : [{
+	name: n,
+	payload: {
+		...X(e.resolvedRefs[t.ref]),
+		changes: { showNullValues: t.showNullValues }
+	}
+}]), r), an = (e) => "value" in e ? { value: e.value } : "values" in e ? {
+	secondValue: e.values.join(","),
+	value: ","
+} : "valueFrom" in e ? {
+	valueFrom: e.valueFrom,
+	valueTo: e.valueTo
+} : {}, Z = (e) => ({
+	filters: e.filters.map((e) => "filters" in e ? Z(e) : {
+		fieldKey: e.fieldKey,
+		operator: e.operator,
+		values: an(e)
+	}),
+	operator: e.operator
+}), on = (e, t) => t ? Y(e, [{
+	id: "filterGroup",
+	name: "setStaticFilterGroup",
+	payload: Z(t)
+}], ["filterGroup"]) : Promise.resolve({
+	state: e,
+	success: !0
+}), sn = (e, t, n, r) => {
+	if (!t?.length) return Promise.resolve({
+		state: e,
+		success: !0
+	});
+	let i = e.vSpec.querySettings?.sortingOrder ?? [], a = new Map(t.map((e) => [e.by, e])), o = new Map(Object.entries(e.resolvedRefs).map(([e, t]) => [`${t.dataItemInternalKey}:${t.dataItemUniqueSignature}`, e])), s = t.map((t) => e.resolvedRefs[t.by]), c = new Set(s.map((e) => `${e.dataItemInternalKey}:${e.dataItemUniqueSignature}`));
+	return Y(e, [{
+		name: n,
+		payload: { changeRequests: [...s, ...i.filter((e) => !c.has(`${e.dataItem.internalKey}:${e.dataItem.uniqueSignature}`)).map((e) => ({
+			dataItemInternalKey: e.dataItem.internalKey,
+			dataItemUniqueSignature: e.dataItem.uniqueSignature,
+			kind: "dimension"
+		}))].map((e, t) => {
+			let n = `${e.dataItemInternalKey}:${e.dataItemUniqueSignature}`, r = o.get(n), s = i.find((e) => `${e.dataItem.internalKey}:${e.dataItem.uniqueSignature}` === n);
+			return {
+				...X(e),
+				newIndex: t,
+				sortDirection: (r ? a.get(r)?.direction : void 0) ?? s?.sortDirection ?? "asc"
+			};
+		}) }
+	}, ...t.map((t) => ({
+		name: r,
+		payload: {
+			...X(e.resolvedRefs[t.by]),
+			enabled: t.enabled ?? !0
+		}
+	}))], ["sorting"]);
+}, cn = (e, t) => (e ?? []).flatMap((e, n) => t.includes(e.by) ? [] : [J("unknown_alias", [
+	"sorting",
+	n,
+	"by"
+], `Reference "${e.by}" does not exist.`, { allowedValues: t })]), Q = ["presentation", "coloring"], ln = (e, t, n) => [...(e?.overwrites ?? []).flatMap(({ dimension: e }, n) => e === void 0 || t.includes(e) ? [] : [J("unknown_alias", [
+	...Q,
+	"overwrites",
+	n,
+	"dimension"
+], `Dimension reference "${e}" does not exist.`, { allowedValues: t })]), ...(e?.rules ?? []).flatMap(({ measure: e }, t) => n.includes(e) ? [] : [J("unknown_alias", [
+	...Q,
+	"rules",
+	t,
+	"measure"
+], `Measure reference "${e}" does not exist.`, { allowedValues: n })])], un = (e, t) => {
+	let n = [];
+	return t?.overwrites && n.push({
+		name: he.SET_COLORING_OVERWRITES,
+		payload: { overwrites: t.overwrites.map(({ dimension: t, ...n }) => t === void 0 ? n : {
+			...n,
+			dimension: X(e.resolvedRefs[t])
+		}) }
+	}), t?.rules && n.push({
+		name: he.SET_COLORING_RULES,
+		payload: { rules: t.rules.map(({ measure: t, ...n }) => ({
+			...n,
+			measure: X(e.resolvedRefs[t])
+		})) }
+	}), Y(e, n, Q);
+}, dn = (e, t) => {
+	let n = t.safeParse(e.vSpec);
+	return n.success ? {
+		resolvedRefs: e.resolvedRefs,
+		success: !0,
+		vSpec: n.data
+	} : {
+		issues: [J("invalid_compiled_vspec", [], "Compiled vSpec failed final validation.", { details: { issues: n.error.issues } })],
+		success: !1
+	};
+}, $ = (e) => "startsAtZero" in e ? {} : e, fn = (e) => {
+	let { max: t, min: n } = $(e);
+	return n !== void 0 && t !== void 0 ? o.MinMax : n === void 0 ? t === void 0 ? o.Auto : o.Max : o.Min;
+}, pn = (e) => {
+	for (let [t, n] of Object.entries(e ?? {})) {
+		let { max: e, min: r } = n?.range ? $(n.range) : {};
+		if (r !== void 0 && e !== void 0 && r >= e) return J("invalid_structure", [
+			"presentation",
+			"axes",
+			t,
+			"range",
+			"min"
+		], `Axis range min (${r}) must be less than max (${e}).`);
+	}
+}, mn = (e, t) => {
+	let n = [];
+	t.inverted !== void 0 && n.push({
+		name: y.SET_INVERT_AXIS,
+		payload: {
+			axisName: e,
+			invertAxis: t.inverted
+		}
+	});
+	let { range: r } = t;
+	if (r) {
+		n.push({
+			name: y.SET_AXIS_RANGE_OPTION,
+			payload: {
+				axisName: e,
+				axisRangeOption: fn(r)
+			}
+		});
+		let { max: t, min: i } = $(r);
+		i !== void 0 && n.push({
+			name: y.SET_AXIS_RANGE_MIN,
+			payload: {
+				axisName: e,
+				minValue: i
+			}
+		}), t !== void 0 && n.push({
+			name: y.SET_AXIS_RANGE_MAX,
+			payload: {
+				axisName: e,
+				maxValue: t
+			}
+		}), "startsAtZero" in r && n.push({
+			name: y.SET_AXIS_STARTS_AT_ZERO,
+			payload: {
+				axisName: e,
+				startsAtZero: r.startsAtZero
+			}
+		});
+	}
+	return n;
+};
+export { tt as $, jt as A, lt as B, Xt as C, zt as D, Lt as E, yt as F, Ze as G, Ge as H, St as I, $e as J, Ye as K, bt as L, gt as M, _t as N, Rt as O, vt as P, et as Q, mt as R, ln as S, It as T, Qe as U, st as V, Ke as W, nt as X, Xe as Y, qe as Z, pn as _, en as a, Z as b, mn as c, J as d, rt as et, Gt as f, dn as g, Y as h, on as i, xt as j, Vt as k, qt as l, tn as m, un as n, We as nt, sn as o, Jt as p, Je as q, rn as r, E as rt, nn as s, $t as t, it as tt, Qt as u, Zt as v, Wt as w, cn as x, X as y, pt as z };