@astrato-io/visualizations 0.0.0-stage → 0.6.4

package/chunks/standalone-CY57qwZ-.js

@@ -0,0 +1,1129 @@
+import { o as e } from "./rolldown-runtime-DleVn1XH.js";
+import { No as t, Oa as n, Ta as r, Ti as i, Wc as a, Xs as o, Yn as s, lo as c, pc as l, qs as u, so as d, ta as f, ti as p } from "./interfaces-VUY4_yVO.js";
+import { I as m, Ki as h, P as g, Zt as _, o as v, wi as y } from "./utils-Ba9T0TqC.js";
+import { It as b, Jt as x, Lt as S, Vt as C, X as w, Z as T, bt as E, cn as D, en as ee, i as O, in as k, j as te, ln as A, n as ne, nn as j, rn as M, rt as re, sn as N, tn as ie, un as P, xt as ae } from "./escobar-BGqT1EsE.js";
+import { l as F, vt as I } from "./_baseFlatten-DPXPOrea.js";
+import { a as oe, r as se, t as ce } from "./coloring-C16AUZEi.js";
+import { f as le, r as L, t as ue, u as de } from "./src-D9XogOrc.js";
+var fe = /* @__PURE__ */ e(h()), R = /* @__PURE__ */ function(e) {
+	return e.sankey = "key-sankey", e.labels = "key-labels", e.columnLabels = "key-column-labels", e;
+}({}), z = /* @__PURE__ */ function(e) {
+	return e.NodeFlow = "flow", e.NodeColor = "color", e;
+}({}), B = /* @__PURE__ */ function(e) {
+	return e.ColumnTitleLeft = "columnTitleLeft", e.ColumnTitleCenter = "columnTitleCenter", e.ColumnTitleRight = "columnTitleRight", e.NodeLabelLeft = "nodeLabelLeft", e.NodeLabelCenter = "nodeLabelCenter", e.NodeLabelRight = "nodeLabelRight", e;
+}({}), pe = class extends ce {
+	dimensionIds = [];
+	dimensionColoring = {};
+	constructor(e, t, n) {
+		super(e, t, n), this.dimensionIds = [], this.vSpec.dimensions.filter((e) => i(e)).forEach((e) => {
+			let t = l(e.dataItem);
+			this.dimensionColoring[t] = e.coloring, this.dimensionIds.push(t);
+		});
+	}
+	getColorByScale(e, t = {}) {
+		let { ref: n } = t, r = this.getDatumFromProp(e, n, "color"), i = r?.value, a = e.resources.scale(r.source?.field ?? r.label), s = r.source.field && this.dimensionColoring[r.source.field];
+		if (s?.type === o.Categorical && s.persistentColors === !0) {
+			let e = a.range();
+			return e[this.getHash(i) % e.length];
+		}
+		return a(i);
+	}
+	getDatumFromProp(e, t, n) {
+		return t === this.MAIN_FIELD ? e.datum : e.datum[t || n];
+	}
+	getLinkOverwrite(e) {
+		let t = this.vSpec.coloring?.overwrites;
+		for (let n = 0; n < t.length; n++) {
+			let r = t[n], i = e.datum, a = r.operator || "equals";
+			if ([i, ...Object.keys(i).filter((e) => this.dimensionIds.includes(i[e]?.source?.field)).map((e) => i[e])].find((e) => e.source.field === r?.dataItemId ? a === "equals" ? r.value === e.value || r.value === String(e.value) : se(r, e.value) : !1)) return r.color;
+		}
+	}
+	getFilteredColor() {
+		return null;
+	}
+	getLinkColorDefinition() {
+		return (e) => {
+			if (this.notAffectedItems?.pattern?.length && this.vSpec.staticFilters.ignoreGlobalFilters && this.vSpec.staticFilters.showGlobalFiltersEffect) {
+				let t = oe(e, this.notAffectedItems);
+				if (t) return t;
+			}
+			if (this.isColorOverwriteActive()) {
+				let t = this.getLinkOverwrite(e);
+				if (t) return t;
+			}
+			if (this.isColorRulesActive()) {
+				let t = this.getColorByColorRules(e);
+				if (t) return t;
+			}
+		};
+	}
+}, me = (e, t) => e.data.value === t.data.value ? 0 : e.data.value < t.data.value ? 1 : -1, he = (e, t) => e.data.value === t.data.value ? 0 : e.data.value < t.data.value ? -1 : 1, ge = (e, t) => e.data.flow.value === t.data.flow.value ? 0 : e.data.flow.value < t.data.flow.value ? 1 : -1, _e = (e, t) => e.data.flow.value === t.data.flow.value ? 0 : e.data.flow.value < t.data.flow.value ? -1 : 1;
+function ve(e, t) {
+	let n = e.dimensions.filter((e) => i(e)), r = (e.querySettings?.sortingOrder ?? []).map((e) => ({
+		id: l(e.dataItem),
+		direction: e.sortDirection,
+		type: e.fieldType
+	})), a = r.find((e) => e.type === "measure"), o = r.indexOf(a);
+	return n.map((n) => {
+		let i = l(n.dataItem), s;
+		if (e.sankeySettings.applyDataSortOnNodeColumns) {
+			let e = r.find((e) => e.id === i), t = r.indexOf(e);
+			e && t < o ? s = e.direction === "desc" ? me : he : a && (s = a.direction === "desc" ? ge : _e);
+		}
+		return {
+			id: i,
+			sort: s,
+			isGrouped: p(e.dimensions, e.enableAlternate, t)
+		};
+	});
+}
+var ye = (e, t) => {
+	let r = e.sankeySettings.linkColoring?.opacity ?? .3, i = t.valuePickerMode ?? !1, a = i ? t.valuePickerTargetDataItemId : "";
+	return {
+		trigger: [{
+			on: D.Tap,
+			action: N.Toggle,
+			globalPropagation: "stop",
+			data: ["", "linkTarget"],
+			contexts: [M.Selection]
+		}, {
+			on: D.Over,
+			action: N.Set,
+			globalPropagation: "stop",
+			data: ["", "linkTarget"],
+			contexts: [M.Highlight]
+		}],
+		consume: [
+			{
+				context: M.Selection,
+				data: ["", "linkTarget"],
+				filter: (e) => e.data?.type?.value === "link",
+				mode: A.Or,
+				style: { inactive: { opacity: r * .25 } }
+			},
+			{
+				context: M.Selection,
+				data: [""],
+				filter: (e) => e.data?.type?.value === "node",
+				mode: A.Or,
+				style: { inactive: { fill: (e) => {
+					let t = !e.fill || e.fill === "none" || e.fill === "transparent";
+					switch (!0) {
+						case t:
+						case i && e.data.source.field === a: return e.fill;
+						default: return ee(ie(e.fill), .25);
+					}
+				} } }
+			},
+			{
+				context: M.Highlight,
+				data: [""],
+				filter: (e) => e.data?.type?.value === "node",
+				mode: A.Or,
+				style: { active: {
+					strokeWidth: (e) => i && e.data.source.field !== a ? 0 : 1,
+					stroke: n.mainDarkNavy
+				} }
+			}
+		]
+	};
+}, be = (e, t, n, r, a, o) => {
+	let s = e.dimensions.filter((e) => i(e)), c = new pe(e, t, a?.[0]?.itemsNotAffectedByFiltering), u = e.sankeySettings.linkColoring?.opacity ?? .3, d = e.sankeySettings.linkColoring, f = s.map((e) => l(e.dataItem)), p = f.map((e, t) => `dim${t}`), m = e.sankeySettings.showNullNodes ? (e, t) => p[f.indexOf(t) + 1] : (e, t) => {
+		let n = f.indexOf(t), r = f.slice(n + 1).find((t) => e[p[f.indexOf(t)]].value !== null);
+		return p[f.indexOf(r)];
+	}, h = {
+		key: R.sankey,
+		type: P.Sankey,
+		data: { collection: "coll" },
+		settings: {
+			showNullNodes: e.sankeySettings.showNullNodes,
+			nodePadding: e.sankeySettings.nodePadding,
+			nodeWidth: e.sankeySettings.nodeWidth,
+			linkMargin: e.sankeySettings.linkMargin,
+			showColumnHeaderLabels: e.sankeySettings.showColumnHeaderLabels,
+			linkFillStrategy: e.sankeySettings.linkColoring.type,
+			nodeFillOverride: e.sankeySettings.nodeColoring.override ? e.sankeySettings.nodeColoring.color || t.colors.brandColors[0] : void 0,
+			showNodeDimensionLabel: e.sankeySettings.nodeLabels.enabled && e.sankeySettings.nodeLabels.showDimensionValue,
+			showNodeFlowLabel: e.sankeySettings.nodeLabels.enabled && e.sankeySettings.nodeLabels.showFlowValue,
+			showNodeLabelBackdrop: e.sankeySettings.nodeLabels.showBackdrop !== !1,
+			nodeLabelBackdropColor: e.sankeySettings.nodeLabels.backdropColor,
+			columnFields: ve(e, o.isPrintMode),
+			nodeLabelPlacements: e.sankeySettings.nodeLabels.placements.filter((e) => e.enabled).map((e) => e.placement),
+			node: {
+				id: (e) => `${e.datum.source.field}::${e.datum.value}`,
+				fill: c.getColorDefinition({
+					ref: z.NodeColor,
+					overwriteSources: [c.MAIN_FIELD, "color"]
+				})
+			},
+			link: {
+				linkSource: (e) => `${e.datum.source.field}::${e.datum.value}`,
+				linkTarget: (e) => {
+					let t = m(e.datum, e.datum.source.field);
+					return t ? (e.datum.linkTarget = e.datum[t], `${e.datum[t].source.field}::${e.datum[t].value}`) : null;
+				},
+				value: { ref: "flow" },
+				dataFill: c.getLinkColorDefinition(),
+				fill: () => d.override ? d.color || t.colors.brandColors[0] : void 0,
+				opacity: u
+			}
+		},
+		brush: o.disable?.brushing === !0 ? void 0 : ye(e, o),
+		animations: {
+			presetId: "simple-opacity",
+			enabled: !0
+		}
+	};
+	return {
+		...n,
+		components: [...n.components, h]
+	};
+}, xe = (e, t, n) => {
+	let r = e.measures.filter((e) => i(e)), a = e.dimensions.filter((e) => i(e)), o = l(r[0].dataItem), s = a.map((e) => l(e.dataItem)), c = s.map((e) => ({
+		field: e,
+		trackBy: (e) => e,
+		reduce: "first",
+		props: {
+			[z.NodeFlow]: {
+				field: o,
+				reduce: "sum"
+			},
+			[o]: {
+				field: o,
+				reduce: "sum"
+			},
+			[z.NodeColor]: { field: e },
+			type: "node"
+		}
+	})), u = s.slice(0, s.length - 1).map((e, t) => {
+		let n = {
+			field: s[t],
+			props: {
+				flow: { field: o },
+				[o]: { field: o },
+				type: "link"
+			}
+		};
+		return s.forEach((e, t) => {
+			n.field !== e && (n.props[`dim${t}`] = { field: e });
+		}), n;
+	}), d = [{
+		key: "coll",
+		data: {
+			extract: [...c, ...u],
+			filter: e.sankeySettings.showNullNodes ? void 0 : (e) => e.value !== null
+		}
+	}];
+	return {
+		...n,
+		collections: d,
+		formatters: { flow: {
+			type: "excel-format",
+			format: r[0].formatter?.format
+		} }
+	};
+}, V = (e, t) => ({
+	component: R.sankey,
+	selector: e,
+	strategy: {
+		type: "rows",
+		settings: {
+			justify: .5,
+			align: t,
+			labels: [{
+				linkData: ({ node: e }) => e.desc.field,
+				label({ node: e }) {
+					let t = e.desc.label;
+					return e.desc?.isGrouped ? C(t) : t;
+				}
+			}]
+		}
+	}
+}), H = 64, Se = new F(I.fontLight), Ce = new F(I.fontDark), U = (e, t, n) => {
+	let r = new F(n.fonts.general.color);
+	return {
+		component: R.sankey,
+		selector: e,
+		strategy: {
+			type: "rows",
+			settings: {
+				justify: .5,
+				align: t,
+				labels: [{
+					id({ node: e }) {
+						return e.attrs?.id?.replace("::labelTarget", "");
+					},
+					backdrop({ node: e }) {
+						return e.desc?.backdrop;
+					},
+					fill({ node: e }) {
+						return !e.desc.backdrop && !e.desc.background ? r.rgb() : new F(e.desc?.backdrop?.fill || e.desc.background).betterContrast(r, Se, Ce).rgb();
+					},
+					linkData({ node: e }) {
+						return e.desc?.data;
+					},
+					label({ node: e, formatter: t }) {
+						let n = e.desc.showFlow ? t("flow")(e.desc?.data?.[z.NodeFlow]?.value) : void 0, r = e.desc?.label?.length > H - 1 ? `${e.desc?.label?.substring(0, H - 1).replace(/\s+$/, "")}…` : e.desc?.label;
+						return [e.desc.showDimension ? r : void 0, n].filter(Boolean).join(": ");
+					}
+				}]
+			}
+		}
+	};
+}, we = (e, n, r, o, c, u, d, f) => {
+	let m = [];
+	f && m.push(S(R.columnLabels, R.columnLabels, f));
+	let h = {
+		type: P.Labels,
+		key: R.columnLabels,
+		layout: { displayOrder: 2 },
+		settings: { sources: [
+			V(`.${B.ColumnTitleLeft}`, 0),
+			V(`.${B.ColumnTitleCenter}`, .5),
+			V(`.${B.ColumnTitleRight}`, 1)
+		] },
+		style: { label: "$title" },
+		animations: {
+			presetId: "simple-opacity",
+			enabled: !0
+		}
+	}, g = e?.measures.find(i), _ = g ? l(g.dataItem) : void 0, v = g && (s(g) || g.label || g.dataItem?.name || "Measure");
+	f && g && e.measures.length > 1 && m.push(b(P.Text, f));
+	let y = g && e.measures.length > 1 ? {
+		type: P.Text,
+		key: `text-${_}`,
+		dataItemType: a.Measure,
+		dataItemRole: g.role,
+		text: p(e.measures, e.enableAlternate, u.isPrintMode) ? C(v) : v,
+		layout: {
+			dock: t.Bottom,
+			color: "red"
+		},
+		style: { text: {
+			fontFamily: n.fonts.general.fontFamily,
+			fontSize: `${I.fieldTitle.fontSize}px`,
+			fontStyle: "normal",
+			fill: n.fonts.general.color
+		} },
+		anchor: t.Center
+	} : void 0, x = {
+		type: P.Labels,
+		key: R.labels,
+		layout: { displayOrder: 2 },
+		settings: { sources: [
+			U(`.${B.NodeLabelLeft}`, 0, n),
+			U(`.${B.NodeLabelCenter}`, .5, n),
+			U(`.${B.NodeLabelRight}`, 1, n)
+		] },
+		style: { label: "$label" },
+		brush: u.disable?.brushing === !0 ? void 0 : {
+			trigger: [{
+				on: D.Tap,
+				action: N.Toggle,
+				globalPropagation: "stop",
+				data: [""],
+				contexts: [M.Selection]
+			}],
+			consume: [{
+				context: M.Selection,
+				data: [""],
+				style: { inactive: { opacity: .3 } }
+			}]
+		},
+		animations: {
+			presetId: "simple-opacity",
+			enabled: !0
+		}
+	};
+	return {
+		...r,
+		components: [
+			...r.components,
+			h,
+			...y ? [y] : [],
+			x
+		],
+		interactions: r.interactions ? [...r.interactions, ...m] : [...m]
+	};
+}, Te = (e, t, n, r, i) => {
+	if (n.type !== o.PerEachDimension) {
+		let e = n.color || t?.colors?.brandColors?.[0] || "#aaa";
+		return {
+			type: k.CategoricalColor,
+			data: [],
+			range: [e],
+			unknown: e
+		};
+	}
+	let a = r.coloring || {};
+	if (a.type !== o.Categorical) {
+		let n = i[e.dimensions.indexOf(r) % i.length], o = a.color || n || t?.colors?.brandColors?.[0] || "#aaa";
+		return {
+			type: k.CategoricalColor,
+			data: [],
+			range: [o],
+			unknown: o
+		};
+	}
+	return ae(e, t, l(r.dataItem), {
+		customPalette: a.customPalette ?? f.customPalette,
+		palette: a.palette
+	});
+}, Ee = (e, t, n) => {
+	let r = e.dimensions.filter((e) => i(e));
+	if (!r[0]) return n;
+	let a = {}, o = E({
+		palette: e.coloring.palette,
+		customPalette: e.coloring.customPalette ?? f.customPalette
+	}, t);
+	return r.forEach((n) => {
+		let r = l(n.dataItem);
+		a[r] = Te(e, t, e.coloring, n, o);
+	}), {
+		...n,
+		scales: a
+	};
+}, De = (e, t, n) => {
+	let r = e.dimensions.filter((e) => i(e)), a = e.measures.filter((e) => i(e));
+	if (!r[0] || !a[0]) return n;
+	let o = {
+		"$font-family": t.fonts.general.fontFamily,
+		"$font-color": t.fonts.general.color,
+		"$font-size": `${x(e.sankeySettings?.nodeLabels?.fontSize)}px`,
+		$label: {
+			fontSize: "$font-size",
+			fontFamily: "$font-family",
+			fill: "$font-color",
+			padding: 1
+		},
+		$title: {
+			"@extend": "$label",
+			fontSize: `${I.fieldTitle.fontSize}px`,
+			padding: 4
+		}
+	};
+	return {
+		...n,
+		style: o
+	};
+}, Oe = (e, t) => t?.data?.type?.value === "link" ? `${t.data.label} - ${t.data.linkTarget.label}` : t.data.label, ke = (e, t, n, r, i, a, o) => {
+	let c = [], l = s(e[0]) || e[0].label || e[0].dataItem.name || "", u = e.length ? l : "Count", d = t.desc?.flow ?? t.data?.flow.value;
+	return d = o ? n.formatter(re())(d) : n.formatter("flow")(d), c.push({
+		label: u,
+		value: d
+	}), c;
+}, Ae = (e, t, n, r, i) => {
+	let a = { placement: ({ nodes: e }) => ({
+		area: "target",
+		type: e[0]?.data?.type?.value === "link" ? "pointer" : "bounds"
+	}) };
+	return a.extract = T(e, t, ke, Oe), w(e, t, n, a, "tooltip", i);
+}, je = class extends te {
+	constructor() {
+		super([
+			xe,
+			Ee,
+			be,
+			we,
+			De,
+			Ae
+		]);
+	}
+	preCompile(e, t) {
+		let n = e.measures.filter((e) => i(e)), r = e.dimensions.filter((e) => i(e)), a = n[0];
+		if (!a) return;
+		let o = l(a.dataItem), s = r.map((e) => l(e.dataItem));
+		t.forEach((t) => {
+			if (t.items?.length) {
+				if (t.items = t.items.filter((e) => e[o] > 0), !t.items.length) throw Error("Current data query resulted in only negative and/or null values which can not be displayed in this chart.");
+				if (!e.sankeySettings.showNullNodes && !t.items.find((e) => s.find((t) => e[t] !== null))) throw Error("Current dataset contains only non-null dimension values and can not be displayed in the current configuration of this chart.");
+			}
+		});
+	}
+}, W = {
+	showNullNodes: !1,
+	nodePadding: .2,
+	nodeWidth: .2,
+	linkMargin: 0,
+	showColumnHeaderLabels: !1,
+	linkFillStrategy: d.Interpolated,
+	nodeFillOverride: null,
+	showNodeFlowLabel: !0,
+	showNodeDimensionLabel: !0,
+	showNodeLabelBackdrop: !0,
+	nodeLabelBackdropColor: null,
+	columnFields: [],
+	nodeLabelPlacements: [c.Beside],
+	node: {
+		id: "",
+		fill: "#333333"
+	},
+	link: {
+		fill: "rgba(100, 100, 100, 0.5)",
+		linkSource: "",
+		linkTarget: "",
+		value: 1
+	}
+};
+function G(e, t) {
+	return e.dataFill === t.dataFill ? 0 : e.dataFill < t.dataFill ? -1 : 1;
+}
+function Me(e) {
+	let t = e.target.x0 - e.source.x1, n = e.y0 - e.y1, r = Math.abs(n) < .1 ? 0 : .5;
+	return [
+		`M${e.source.x1},${e.y0}`,
+		`C${e.source.x1 + t * r},${e.y0}`,
+		`${e.source.x1 + t * (1 - r)},${e.y1}`,
+		`${e.target.x0},${e.y1}`
+	].join(" ");
+}
+function Ne(e) {
+	return e.map((e) => ({
+		type: j.Path,
+		data: e.data,
+		desc: { flow: e.value },
+		d: Me(e),
+		fill: "none",
+		strokeWidth: Math.max(.5, e.width),
+		stroke: e.fill,
+		strokeLinecap: "butt",
+		opacity: e.opacity,
+		id: e.id,
+		collider: { visual: !0 }
+	}));
+}
+function Pe(e) {
+	let { data: t, resolver: n, settings: r, resolvedNodes: i } = e, a = {};
+	i.forEach((e) => {
+		a[e.id] = e;
+	});
+	let o = t.items.filter((e) => e.type.value === "link"), { items: s } = n.resolve({
+		data: { items: o },
+		defaults: { ...W.link },
+		settings: r.link
+	}), c = {};
+	return s.filter((e) => !!e.linkTarget).forEach((e) => {
+		let t = a[e.linkSource], n = a[e.linkTarget], i;
+		if (!e.fill && !e.dataFill) switch (r.linkFillStrategy) {
+			case d.Source:
+				e.fill = t.fill;
+				break;
+			case d.Target:
+				e.fill = n.fill;
+				break;
+			case d.Interpolated:
+				e.fill = {
+					type: "gradient",
+					orientation: "linear",
+					degree: -180,
+					stops: [{
+						color: t.fill,
+						offset: 0
+					}, {
+						color: n.fill,
+						offset: 1
+					}]
+				}, i = `${t.fill}::${n.fill}`;
+				break;
+		}
+		else e.dataFill && (e.fill = e.dataFill);
+		i ||= e.fill, e.fillId = i;
+		let o = `${e.linkSource}::${e.linkTarget}`;
+		c[o] && c[o].fillId !== e.fillId && (o += `::${e.fillId}`), c[o] ? c[o].value += e.value : (c[o] = e, e.id = o);
+	}), Object.values(c).map((e) => ({
+		source: e.linkSource,
+		target: e.linkTarget,
+		id: e.id,
+		value: e.value,
+		fill: e.fill,
+		dataFill: e.dataFill,
+		data: e.data,
+		opacity: e.opacity
+	}));
+}
+function Fe(e) {
+	let { data: t, resolver: n, settings: r } = e, i = t.items.filter((e) => e.type.value === "node"), { items: a } = n.resolve({
+		data: { items: i },
+		defaults: { ...W.node },
+		settings: {
+			...r.node,
+			fixedValue: ({ datum: e }) => e.flow.value
+		}
+	});
+	return a;
+}
+function Ie(e, t) {
+	let n = [];
+	return e.map((e) => {
+		let r = {};
+		e.sourceLinks.forEach((e) => {
+			e.dataFill && (r[e.dataFill] || (r[e.dataFill] = {
+				dataFill: e.dataFill,
+				sourceSum: 0,
+				targetSum: 0
+			}), r[e.dataFill].sourceSum += e.value);
+		}), e.targetLinks.forEach((e) => {
+			e.dataFill && (r[e.dataFill] || (r[e.dataFill] = {
+				dataFill: e.dataFill,
+				sourceSum: 0,
+				targetSum: 0
+			}), r[e.dataFill].targetSum += e.value);
+		});
+		let i = Object.values(r);
+		i.sort(G);
+		let a = i.reduce(([e, t], n) => [e + n.sourceSum, t + n.targetSum], [0, 0]), o = 1 - Math.max(...a) / e.value, s = e.y1 - e.y0, c = e.y0;
+		n.push({
+			id: e.id,
+			type: j.Rect,
+			x: e.x0 + t.nodeMargin,
+			width: e.x1 - e.x0 - t.nodeMargin * 2,
+			y: c,
+			height: Math.max(.5, o * s),
+			fill: e.fill,
+			opacity: 1,
+			data: e.data,
+			desc: {
+				data: e.data,
+				label: e.data.label,
+				flow: e.data.flow.value
+			}
+		}), c += o * s, i.forEach(({ dataFill: r, sourceSum: i, targetSum: a }, o) => {
+			let l = s * (Math.max(i, a) / e.value);
+			n.push({
+				id: `${e.id}::${o}`,
+				type: j.Rect,
+				x: e.x0 + t.nodeMargin,
+				width: e.x1 - e.x0 - t.nodeMargin * 2,
+				y: c,
+				height: Math.max(.5, l),
+				fill: r,
+				opacity: 1,
+				data: e.data,
+				desc: {
+					data: e.data,
+					label: e.data.label,
+					flow: e.data.flow.value
+				}
+			}), c += l;
+		});
+	}), n;
+}
+var K = (e, t, n = !1, r = [4, 2]) => ({
+	data: e.data,
+	background: n ? e.fill : void 0,
+	label: e.data.label,
+	showDimension: t.showDimensionLabel,
+	showFlow: t.showFlowLabel,
+	backdrop: t.showBackdrop ? {
+		fill: t.backdropColor ?? e.fill,
+		opacity: t.backdropColor ? 1 : .8,
+		padding: r
+	} : void 0
+}), Le = (e, t, n, r) => {
+	let { nodeLabelHeight: i, nodePadding: a } = r;
+	return a < i ? [] : e.map((e) => {
+		let t = n[e.layer], a = K(e, r, !1, [4, 0]), o = a.backdrop?.padding ?? [0, 0], s = t.align < .5 ? B.NodeLabelLeft : t.align > .5 ? B.NodeLabelRight : B.NodeLabelCenter;
+		return {
+			type: j.Rect,
+			id: `${e.id}::labelTarget`,
+			x: t.fullX + (t.align < .5 ? r.nodeMargin + o[0] : 0),
+			width: t.fullWidth - (t.align === .5 ? 0 : r.nodeMargin + o[0]),
+			y: e.y0 - i,
+			height: i,
+			desc: a,
+			tag: s,
+			fill: "none"
+		};
+	});
+}, Re = (e) => e.canShowNodeLabelAboveNode, ze = (e, t, n, r) => {
+	let { nodePadding: i } = r;
+	return e.filter((e) => e.y1 - e.y0 + i >= r.nodeLabelHeight).map((e) => {
+		let t = n[e.layer], a = t.align <= .5 ? B.NodeLabelLeft : B.NodeLabelRight, o = K(e, r, !1, [4, 2]), s = o.backdrop?.padding ?? [0, 0], c = [2, 2], l = [s[0] + c[0], s[1] + c[1]], u = {
+			type: j.Rect,
+			id: `${e.id}::labelTarget`,
+			x: t.gapX + l[0],
+			width: t.gapWidth - 2 * l[0],
+			y: e.y0 - i / 2,
+			height: e.y1 - e.y0 + i,
+			desc: o,
+			tag: a,
+			fill: "none"
+		};
+		return t.nodeWidth === 0 && (u.x = t.fullX + s[0], u.width = t.fullWidth - 2 * s[1], u.tag = t.align < .5 ? B.NodeLabelLeft : t.align > .5 ? B.NodeLabelRight : B.NodeLabelCenter), u;
+	});
+}, Be = (e) => e.columnGap >= 20, Ve = (e, t, n, r) => e.filter((e) => e.y1 - e.y0 >= r.nodeLabelHeight).map((e) => {
+	let t = K(e, r, !0, [4, 2]);
+	return {
+		type: j.Rect,
+		id: `${e.id}::labelTarget`,
+		x: e.x0 + r.nodeMargin,
+		width: e.x1 - e.x0 - r.nodeMargin * 2,
+		y: e.y0,
+		height: e.y1 - e.y0,
+		desc: t,
+		tag: B.NodeLabelCenter,
+		fill: "none"
+	};
+}), He = (e) => e.columnWidth >= 80, q = {
+	[c.Above]: {
+		condition: Re,
+		create: Le
+	},
+	[c.Beside]: {
+		condition: Be,
+		create: ze
+	},
+	[c.Inside]: {
+		condition: He,
+		create: Ve
+	}
+}, Ue = (e) => e.priority.find((t) => q[t]?.condition(e)), We = (e, t, n, r) => {
+	let i = [], a = n[0];
+	if (!r.showDimensionLabel && !r.showFlowLabel) return [];
+	let o = r.priority.find((e) => q[e]?.condition({
+		canShowNodeLabelAboveNode: r.canShowNodeLabelAboveNode,
+		columnGap: a.gapWidth,
+		columnWidth: a.nodeWidth,
+		priority: r.priority
+	}));
+	return o && i.push(...q[o].create(e, t, n, r)), i;
+};
+function Ge(e, t) {
+	let { headerHeight: n } = t;
+	return e.map((e) => {
+		let t = e.align < .5 ? B.ColumnTitleLeft : e.align > .5 ? B.ColumnTitleRight : B.ColumnTitleCenter;
+		return {
+			type: j.Rect,
+			id: `column::${e.field}::labelTarget`,
+			tag: t,
+			fill: "none",
+			strokeWidth: 0,
+			x: e.fullX,
+			y: 0,
+			width: e.fullWidth,
+			height: n,
+			desc: {
+				isGrouped: e.isGrouped,
+				field: e.field,
+				label: e.label
+			}
+		};
+	});
+}
+function Ke(e, t, n, r) {
+	let i = {};
+	e.columnFields.forEach((e) => {
+		i[e.id] = {
+			count: 0,
+			label: r.field(e.id).title()
+		};
+	}), t.forEach((t) => {
+		e.nodeFillOverride && (t.fill = e.nodeFillOverride);
+		let n = t.data.source.field;
+		i[n].count++;
+	});
+	let a = e.columnFields.map((e) => ({
+		...i[e.id],
+		isGrouped: e.isGrouped,
+		field: e.id,
+		sort: e.sort
+	}));
+	return qe(a, t, n, e.showNullNodes), a;
+}
+function qe(e, t, n, r = !1) {
+	(e.find((e) => !e.count) || !r) && e.forEach((r, i) => {
+		let a = `dummy-${i}`, o = `dummy-${i + 1}`;
+		t.unshift({
+			id: a,
+			fill: "none",
+			data: {
+				source: {
+					field: r.field,
+					key: ""
+				},
+				label: "",
+				value: null,
+				flow: {
+					value: 0,
+					label: ""
+				}
+			},
+			fixedValue: 0
+		}), i < e.length - 1 && n.unshift({
+			fill: "none",
+			source: a,
+			target: o,
+			value: 0
+		});
+	});
+}
+function Je(e, t) {
+	return {
+		nodes: e.filter((e) => !e.id.startsWith("dummy-")),
+		links: t.filter((e) => !e.source.id.startsWith("dummy-"))
+	};
+}
+function Ye(e, t, n) {
+	let r = n[1][1] - n[0][1], i = e.reduce(([e, t], n) => [Math.min(e, n.y0), Math.max(t, n.y1)], [e[0].y0, e[0].y1]), a = i[0] - n[0][1], o = n[1][1] - i[1], s = 0;
+	a > o && r / a > .1 ? s = -a / 2 : o > a && r / o > .1 && (s = o / 2), s !== 0 && (e.forEach((e) => {
+		e.y0 += s, e.y1 += s;
+	}), t.forEach((e) => {
+		e.y0 += s, e.y1 += s;
+	}));
+}
+function Xe(e, t, n) {
+	return e.map((r) => {
+		let i = t.find((e) => e.data.source.field === r.field), a = i.x0, o = i.x1 - i.x0, s = i.x1, c = n, l = i.x0 - n / 2, u = n + o, d = .5;
+		return i.layer ? i.layer === e.length - 2 ? c = n / 2 : i.layer === e.length - 1 && (u = o + n / 2, c = n / 2, s = a - n / 2, d = 1) : (u = o + n / 2, l = 0, d = 0), {
+			...r,
+			gapX: s,
+			gapWidth: c,
+			fullX: l,
+			fullWidth: u,
+			nodeX: a,
+			nodeWidth: o,
+			align: d
+		};
+	});
+}
+function Ze(e, t, n, r, i) {
+	let a = Math.max(0, n.width / (e.length * 2) * t.nodeWidth), o = a > 0 ? t.linkMargin * .5 * Math.min(24, (n.width - a * e.length) / (e.length - 1) / 2) : 0;
+	a += o * 2;
+	let s = (n.width - a * e.length) / (e.length - 1), l = Math.max(...e.map((e) => e.count)), u = r.measureText(i.title).height + 2 * i.title.padding, d = 8 + u, f = t.showColumnHeaderLabels && n.height - 8 - d > 0, p = r.measureText(i.label).height + 2 * i.label.padding, m = f ? d : 0, h = n.height - m, g = h / l / 2 * t.nodePadding, _ = (t.showNodeDimensionLabel || t.showNodeFlowLabel) && p * l < h / 2, v = g, y = Ue({
+		canShowNodeLabelAboveNode: _,
+		columnGap: s,
+		columnWidth: a,
+		priority: t.nodeLabelPlacements
+	});
+	return _ && y === c.Above && (m += p, v = Math.max(p, g)), {
+		columnGap: s,
+		columnWidth: a,
+		nodePadding: v,
+		availableHeight: h,
+		nodeLabelHeight: p,
+		nodeMargin: o,
+		top: m,
+		showHeader: f,
+		headerTitleHeight: u,
+		canShowNodeLabelAboveNode: _
+	};
+}
+function Qe(e, t) {
+	return e.sourceLinks.length ? e.depth : t - 1;
+}
+function J(e) {
+	return function() {
+		return e;
+	};
+}
+ue();
+function Y(e, t) {
+	return Z(e.source, t.source) || e.index - t.index;
+}
+function X(e, t) {
+	return Z(e.target, t.target) || e.index - t.index;
+}
+function Z(e, t) {
+	return e.y0 - t.y0;
+}
+function Q(e) {
+	return e.value;
+}
+function $e(e) {
+	return e.index;
+}
+function et(e) {
+	return e.nodes;
+}
+function tt(e) {
+	return e.links;
+}
+function nt(e, t) {
+	let n = e.get(t);
+	if (!n) throw Error("missing: " + t);
+	return n;
+}
+function rt({ nodes: e }) {
+	for (let t of e) {
+		let e = t.y0, n = e;
+		for (let n of t.sourceLinks) n.y0 = e + n.width / 2, e += n.width;
+		for (let e of t.targetLinks) e.y1 = n + e.width / 2, n += e.width;
+	}
+}
+function it() {
+	let e = 0, t = 0, n = 1, r = 1, i = 24, a = 8, o, s = $e, c = Qe, l, u, d = et, f = tt, p = 6;
+	function m() {
+		let e = {
+			nodes: d.apply(null, arguments),
+			links: f.apply(null, arguments)
+		};
+		return h(e), g(e), _(e), v(e), x(e), rt(e), e;
+	}
+	m.update = function(e) {
+		return rt(e), e;
+	}, m.nodeId = function(e) {
+		return arguments.length ? (s = typeof e == "function" ? e : J(e), m) : s;
+	}, m.nodeAlign = function(e) {
+		return arguments.length ? (c = typeof e == "function" ? e : J(e), m) : c;
+	}, m.nodeSort = function(e) {
+		return arguments.length ? (l = e, m) : l;
+	}, m.nodeWidth = function(e) {
+		return arguments.length ? (i = +e, m) : i;
+	}, m.nodePadding = function(e) {
+		return arguments.length ? (a = o = +e, m) : a;
+	}, m.nodes = function(e) {
+		return arguments.length ? (d = typeof e == "function" ? e : J(e), m) : d;
+	}, m.links = function(e) {
+		return arguments.length ? (f = typeof e == "function" ? e : J(e), m) : f;
+	}, m.linkSort = function(e) {
+		return arguments.length ? (u = e, m) : u;
+	}, m.size = function(i) {
+		return arguments.length ? (e = t = 0, n = +i[0], r = +i[1], m) : [n - e, r - t];
+	}, m.extent = function(i) {
+		return arguments.length ? (e = +i[0][0], n = +i[1][0], t = +i[0][1], r = +i[1][1], m) : [[e, t], [n, r]];
+	}, m.iterations = function(e) {
+		return arguments.length ? (p = +e, m) : p;
+	};
+	function h({ nodes: e, links: t }) {
+		for (let [t, n] of e.entries()) n.index = t, n.sourceLinks = [], n.targetLinks = [];
+		let n = new Map(e.map((t, n) => [s(t, n, e), t]));
+		for (let [e, r] of t.entries()) {
+			r.index = e;
+			let { source: t, target: i } = r;
+			typeof t != "object" && (t = r.source = nt(n, t)), typeof i != "object" && (i = r.target = nt(n, i)), t.sourceLinks.push(r), i.targetLinks.push(r);
+		}
+		if (u != null) for (let { sourceLinks: t, targetLinks: n } of e) t.sort(u), n.sort(u);
+	}
+	function g({ nodes: e }) {
+		for (let t of e) t.value = t.fixedValue === void 0 ? Math.max(L(t.sourceLinks, Q), L(t.targetLinks, Q)) : t.fixedValue;
+	}
+	function _({ nodes: e }) {
+		let t = e.length, n = new Set(e), r = /* @__PURE__ */ new Set(), i = 0;
+		for (; n.size;) {
+			for (let e of n) {
+				e.depth = i;
+				for (let { target: t } of e.sourceLinks) r.add(t);
+			}
+			if (++i > t) throw Error("circular link");
+			n = r, r = /* @__PURE__ */ new Set();
+		}
+	}
+	function v({ nodes: e }) {
+		let t = e.length, n = new Set(e), r = /* @__PURE__ */ new Set(), i = 0;
+		for (; n.size;) {
+			for (let e of n) {
+				e.height = i;
+				for (let { source: t } of e.targetLinks) r.add(t);
+			}
+			if (++i > t) throw Error("circular link");
+			n = r, r = /* @__PURE__ */ new Set();
+		}
+	}
+	function y({ nodes: t }) {
+		let r = le(t, (e) => e.depth) + 1, a = (n - e - i) / (r - 1), o = Array(r);
+		for (let n of t) {
+			let t = Math.max(0, Math.min(r - 1, Math.floor(c.call(null, n, r))));
+			n.layer = t, n.x0 = e + t * a, n.x1 = n.x0 + i, o[t] ? o[t].push(n) : o[t] = [n];
+		}
+		if (l) for (let e of o) e.sort(l);
+		return o;
+	}
+	function b(e) {
+		let n = de(e, (e) => (r - t - (e.length - 1) * o) / L(e, Q));
+		for (let i of e) {
+			let e = t;
+			for (let t of i) {
+				t.y0 = e, t.y1 = e + t.value * n, e = t.y1 + o;
+				for (let e of t.sourceLinks) e.width = e.value * n;
+			}
+			e = (r - e + o) / (i.length + 1);
+			for (let t = 0; t < i.length; ++t) {
+				let n = i[t];
+				n.y0 += e * (t + 1), n.y1 += e * (t + 1);
+			}
+			ee(i);
+		}
+	}
+	function x(e) {
+		let n = y(e);
+		o = Math.min(a, (r - t) / (le(n, (e) => e.length) - 1)), b(n);
+		for (let e = 0; e < p; ++e) {
+			let t = .99 ** e, r = Math.max(1 - t, (e + 1) / p);
+			C(n, t, r), S(n, t, r);
+		}
+	}
+	function S(e, t, n) {
+		for (let r = 1, i = e.length; r < i; ++r) {
+			let i = e[r];
+			for (let e of i) {
+				let n = 0, r = 0;
+				for (let { source: t, value: i } of e.targetLinks) {
+					let a = i * (e.layer - t.layer);
+					n += O(t, e) * a, r += a;
+				}
+				if (!(r > 0)) continue;
+				let i = (n / r - e.y0) * t;
+				e.y0 += i, e.y1 += i, D(e);
+			}
+			l === void 0 && i.sort(Z), w(i, n);
+		}
+	}
+	function C(e, t, n) {
+		for (let r = e.length - 2; r >= 0; --r) {
+			let i = e[r];
+			for (let e of i) {
+				let n = 0, r = 0;
+				for (let { target: t, value: i } of e.sourceLinks) {
+					let a = i * (t.layer - e.layer);
+					n += k(e, t) * a, r += a;
+				}
+				if (!(r > 0)) continue;
+				let i = (n / r - e.y0) * t;
+				e.y0 += i, e.y1 += i, D(e);
+			}
+			l === void 0 && i.sort(Z), w(i, n);
+		}
+	}
+	function w(e, n) {
+		let i = e.length >> 1, a = e[i];
+		E(e, a.y0 - o, i - 1, n), T(e, a.y1 + o, i + 1, n), E(e, r, e.length - 1, n), T(e, t, 0, n);
+	}
+	function T(e, t, n, r) {
+		for (; n < e.length; ++n) {
+			let i = e[n], a = (t - i.y0) * r;
+			a > 1e-6 && (i.y0 += a, i.y1 += a), t = i.y1 + o;
+		}
+	}
+	function E(e, t, n, r) {
+		for (; n >= 0; --n) {
+			let i = e[n], a = (i.y1 - t) * r;
+			a > 1e-6 && (i.y0 -= a, i.y1 -= a), t = i.y0 - o;
+		}
+	}
+	function D({ sourceLinks: e, targetLinks: t }) {
+		if (u === void 0) {
+			for (let { source: { sourceLinks: e } } of t) e.sort(X);
+			for (let { target: { targetLinks: t } } of e) t.sort(Y);
+		}
+	}
+	function ee(e) {
+		if (u === void 0) for (let { sourceLinks: t, targetLinks: n } of e) t.sort(X), n.sort(Y);
+	}
+	function O(e, t) {
+		let n = e.y0 - (e.sourceLinks.length - 1) * o / 2;
+		for (let { target: r, width: i } of e.sourceLinks) {
+			if (r === t) break;
+			n += i + o;
+		}
+		for (let { source: r, width: i } of t.targetLinks) {
+			if (r === e) break;
+			n -= i;
+		}
+		return n;
+	}
+	function k(e, t) {
+		let n = t.y0 - (t.targetLinks.length - 1) * o / 2;
+		for (let { source: r, width: i } of t.targetLinks) {
+			if (r === e) break;
+			n += i + o;
+		}
+		for (let { target: r, width: i } of e.sourceLinks) {
+			if (r === t) break;
+			n -= i;
+		}
+		return n;
+	}
+	return m;
+}
+var $ = 4;
+function at(e) {
+	let { columns: t, sankeyNodes: n, sankeyLinks: r, columnWidth: i, columnGap: a, nodePadding: o, top: s, rect: c } = e, l = t.map((e) => e.field), u = (e) => l.indexOf(e.data.source.field), d = t.find((e) => !!e.sort) ? (e, n) => t[e.layer].sort?.(e, n) : void 0, f = [[0, s + $], [c.width, c.height - 2 * $]];
+	it().nodeId((e) => e.id).nodePadding(o).nodeWidth(i).linkSort((e, t) => e.dataFill && t.dataFill ? G(e, t) : e.dataFill ? 1 : -1).nodeSort(d).nodeAlign(u).extent(f).iterations(6)({
+		nodes: n,
+		links: r
+	});
+	let p = Xe(t, n, a), { nodes: m, links: h } = Je(n, r);
+	return Ye(m, h, f), {
+		nodes: m,
+		links: h,
+		columns: p
+	};
+}
+var ot = {
+	require: [
+		"resolver",
+		"chart",
+		"renderer"
+	],
+	defaultSettings: {
+		settings: W,
+		style: {
+			title: "$title",
+			label: "$label"
+		}
+	},
+	render({ data: e }) {
+		let { settings: t } = this.settings, n = Fe({
+			data: e,
+			resolver: this.resolver,
+			settings: t
+		}), r = Pe({
+			data: e,
+			resolver: this.resolver,
+			settings: t,
+			resolvedNodes: n
+		}), i = Ke(t, n, r, this.chart.dataset()), { columnGap: a, columnWidth: o, nodePadding: s, availableHeight: c, nodeLabelHeight: l, nodeMargin: u, top: d, showHeader: f, headerTitleHeight: p, canShowNodeLabelAboveNode: m } = Ze(i, t, this.rect, this.renderer, this.style);
+		if (c < 8) return [];
+		let h = [];
+		({nodes: n, links: r, columns: h} = at({
+			columns: i,
+			sankeyNodes: n,
+			sankeyLinks: r,
+			columnWidth: o,
+			columnGap: a,
+			nodePadding: s,
+			top: d,
+			rect: this.rect
+		}));
+		let g = Ie(n, { nodeMargin: u }), _ = We(n, g, h, {
+			nodeLabelHeight: l,
+			canShowNodeLabelAboveNode: m,
+			nodePadding: s,
+			nodeMargin: u,
+			showDimensionLabel: t.showNodeDimensionLabel,
+			showFlowLabel: t.showNodeFlowLabel,
+			backdropColor: t.nodeLabelBackdropColor,
+			showBackdrop: t.showNodeLabelBackdrop,
+			priority: t.nodeLabelPlacements
+		});
+		return [
+			...Ne(r),
+			...g,
+			...f ? Ge(h, { headerHeight: p }) : [],
+			..._
+		];
+	}
+};
+function st(e) {
+	e.component(P.Sankey, ot);
+}
+var ct = y(), lt = _(({ vSpec: e, vTheme: t, data: n, elementSize: i, vizProperties: a }) => {
+	let o = g(), [s] = (0, fe.useState)(() => new je()), c = t || r, d = v(), f = m(), p = d.targetDataItemId;
+	if (!p && d.targetInternalKey) {
+		let t = e.dimensions.find((e) => e.dataItem.internalKey === d.targetInternalKey);
+		t && (p = l(t.dataItem));
+	}
+	let h = {
+		...a,
+		valuePickerMode: !!d.activeKey,
+		valuePickerTargetDataItemId: p
+	}, _ = s.compile(e, c, n, i, h, u.Sankey, o, f, ne());
+	return _ ? /* @__PURE__ */ (0, ct.jsx)(O, {
+		config: a,
+		definition: _,
+		size: i,
+		vSpec: e,
+		escobarPlugins: [st]
+	}) : null;
+});
+export { lt as Sankey };