minerva-design 1.4.0 → 1.6.0

package/dist/charts/engine/graph/tree.d.ts

@@ -0,0 +1,30 @@
+import { GraphDirection, GraphEdge, GraphNode, GraphTreeLayoutOptions, GraphTreeLayoutResult } from './types.js';
+export type TreeType = "tree" | "radial" | "mindmap" | "org";
+export interface TreeInput {
+    n: number;
+    source: ArrayLike<number>;
+    target: ArrayLike<number>;
+    width: ArrayLike<number>;
+    height: ArrayLike<number>;
+    type: TreeType;
+    direction: GraphDirection;
+    /** Index of the root, -1 = nodes without a parent */
+    root: number;
+    levelGap: number;
+    siblingGap: number;
+    collapsed: ReadonlySet<number>;
+    /** Org charts: leaf children are stacked in a column under their parent */
+    compact?: boolean;
+}
+/** Shift of stacked org chart cards to the right of their parent (room for the connector) */
+export declare const STACK_SHIFT = 18;
+/** Default gap between levels of each tree type */
+export declare const TREE_LEVEL_GAP: Record<TreeType, number>;
+/** Tree layouts on index data */
+export declare const tidyTreeLayout: (input: TreeInput) => GraphTreeLayoutResult;
+/**
+ * Tree layouts of a hierarchy given as parent → child edges: tidy tree,
+ * radial tree, two-sided mind map or org chart. Edges that would make a
+ * cycle or give a second parent are ignored.
+ */
+export declare const treeLayout: (nodes: readonly GraphNode[], edges: readonly GraphEdge[], options?: GraphTreeLayoutOptions) => GraphTreeLayoutResult;

package/dist/charts/engine/graph/tree.js

@@ -0,0 +1,218 @@
+import { indexGraph as e } from "./force.js";
+var t = {
+	tree: 56,
+	radial: 90,
+	mindmap: 40,
+	org: 44
+}, n = (e, t) => {
+	let n = {
+		i: e,
+		parent: null,
+		children: [],
+		A: null,
+		z: 0,
+		m: 0,
+		c: 0,
+		s: 0,
+		t: null,
+		idx: 0,
+		depth: t
+	};
+	return n.a = n, n;
+}, r = (e) => e.children.length ? e.children[0] : e.t, i = (e) => e.children.length ? e.children[e.children.length - 1] : e.t, a = (e, t, n) => {
+	let r = n / (t.idx - e.idx);
+	t.c -= r, t.s += n, e.c += r, t.z += n, t.m += n;
+}, o = (e) => {
+	let t = 0, n = 0;
+	for (let r = e.children.length - 1; r >= 0; r--) {
+		let i = e.children[r];
+		i.z += t, i.m += t, t += i.s + (n += i.c);
+	}
+}, s = (e, t, n) => e.a.parent === t.parent ? e.a : n, c = (e, t, n) => {
+	let c = (e, n, o) => {
+		if (!n) return o;
+		let c = e, l = e, u = n, d = c.parent.children[0], f = c.m, p = l.m, m = u.m, h = d.m;
+		for (; u = i(u), c = r(c), u && c;) {
+			d = r(d), l = i(l), l.a = e;
+			let n = u.z + m - c.z - f + t(u, c);
+			n > 0 && (a(s(u, e, o), e, n), f += n, p += n), m += u.m, f += c.m, h += d.m, p += l.m;
+		}
+		return u && !i(l) && (l.t = u, l.m += m - p), c && !r(d) && (d.t = c, d.m += f - h, o = e), o;
+	}, l = (e) => {
+		let n = e.parent.children, r = e.idx ? n[e.idx - 1] : null;
+		if (e.children.length) {
+			o(e);
+			let n = (e.children[0].z + e.children[e.children.length - 1].z) / 2;
+			r ? (e.z = r.z + t(e, r), e.m = e.z - n) : e.z = n;
+		} else r && (e.z = r.z + t(e, r));
+		e.parent.A = c(e, r, e.parent.A || n[0]);
+	}, u = [], d = [e];
+	for (; d.length;) {
+		let e = d.pop();
+		u.push(e);
+		for (let t of e.children) d.push(t);
+	}
+	for (let e = u.length - 1; e >= 0; e--) l(u[e]);
+	e.parent.m = -e.z;
+	let f = [e];
+	for (let e = 0; e < f.length; e++) {
+		let t = f[e];
+		t.i >= 0 && (n[t.i] = t.z + t.parent.m), t.m += t.parent.m;
+		for (let e of t.children) f.push(e);
+	}
+}, l = (e) => {
+	let { n: t, type: r } = e, i = Array.from({ length: t }, () => []), a = new Uint8Array(t);
+	for (let n = 0; n < e.source.length; n++) {
+		let r = e.source[n], o = e.target[n];
+		r === o || r < 0 || o < 0 || r >= t || o >= t || (i[r].push(o), a[o] = 1);
+	}
+	let o = new Int32Array(t).fill(-1), s = new Int32Array(t), l = Array.from({ length: t }, () => []), u = new Uint8Array(t), d = [], f = (e) => {
+		if (u[e]) return;
+		u[e] = 1, d.push(e);
+		let t = [e];
+		for (let e = 0; e < t.length; e++) {
+			let n = t[e];
+			for (let e of i[n]) u[e] || (u[e] = 1, o[e] = n, s[e] = s[n] + 1, l[n].push(e), t.push(e));
+		}
+	};
+	e.root >= 0 && e.root < t && f(e.root);
+	for (let e = 0; e < t; e++) a[e] || f(e);
+	for (let e = 0; e < t; e++) f(e);
+	let p = new Uint8Array(t), m = [];
+	for (let t of d) {
+		let n = [t];
+		p[t] = 1;
+		for (let t = 0; t < n.length; t++) {
+			let r = n[t];
+			if (m.push(r), !e.collapsed.has(r)) for (let e of l[r]) p[e] = 1, n.push(e);
+		}
+	}
+	let h = new Uint8Array(t), g = new Uint8Array(t), _ = Int32Array.from(s);
+	if (r === "org" && e.compact !== !1) for (let t of m) {
+		if (e.collapsed.has(t)) continue;
+		let n = l[t];
+		n.length >= 2 && n.every((t) => e.collapsed.has(t) || !l[t].length) && (h[t] = 1, n.forEach((e) => g[e] = 1));
+	}
+	for (let e of m) {
+		let t = o[e];
+		t < 0 || (_[e] = _[t] + 1 + (g[e] ? l[t].indexOf(e) : 0));
+	}
+	let v = r === "mindmap" || r === "tree" && (e.direction === "LR" || e.direction === "RL"), y = (t) => r === "radial" ? Math.max(e.width[t], e.height[t]) : v ? e.height[t] : e.width[t] + (g[t] ? 36 : 0), b = (t) => r === "radial" ? Math.max(e.width[t], e.height[t]) : v ? e.width[t] : e.height[t], x = e.siblingGap, S = (e, t) => {
+		let n = (y(e.i) + y(t.i)) / 2 + x * (e.parent === t.parent ? 1 : 1.5);
+		return r === "radial" ? n / Math.max(1, e.depth) : n;
+	}, C = (t, r, i = 0) => {
+		let a = n(t, _[t] + i), o = [[a, r ?? (e.collapsed.has(t) ? [] : l[t])]];
+		for (; o.length;) {
+			let [t, s] = o.pop();
+			if ((!r || t !== a) && h[t.i] && s.length) {
+				let e = t;
+				for (let t of s) {
+					let r = n(t, _[t] + i);
+					r.parent = e, e.children.push(r), e = r;
+				}
+				continue;
+			}
+			s.forEach((r, a) => {
+				let s = n(r, _[r] + i);
+				s.parent = t, s.idx = a, t.children.push(s), o.push([s, e.collapsed.has(r) ? [] : l[r]]);
+			});
+		}
+		return a;
+	}, w = (e) => {
+		let t = n(-1, -1);
+		return t.children = [e], e.parent = t, t;
+	}, T = new Float64Array(t), E = new Float64Array(t), D = new Float64Array(t), O = new Float64Array(t), k = e.levelGap;
+	if (r === "mindmap" && d.length) {
+		let n = d[0], r = [...e.collapsed.has(n) ? [] : l[n], ...d.slice(1)], i = r.map((t) => {
+			let n = 0, r = [t];
+			for (; r.length;) {
+				let t = r.pop(), i = e.collapsed.has(t) ? [] : l[t];
+				i.length ? r.push(...i) : n++;
+			}
+			return n;
+		}), a = i.reduce((e, t) => e + t, 0), o = 0, s = 0;
+		for (; s < r.length && (o < a / 2 || s === 0);) o += i[s++];
+		let u = [[r.slice(0, s), 1], [r.slice(s), -1]], f = new Float64Array(t);
+		for (let [e, t] of u) {
+			if (!e.length) continue;
+			let r = C(n, e);
+			w(r), c(r, S, T);
+			let i = T[n], a = [r];
+			for (let e = 0; e < a.length; e++) {
+				let n = a[e];
+				for (let e of n.children) f[e.i] = f[n.i] + (b(n.i) + b(e.i)) / 2 + k, E[e.i] = t * f[e.i], D[e.i] = T[e.i] - i, O[e.i] = t, a.push(e);
+			}
+		}
+		E[n] = 0, D[n] = 0;
+	} else if (d.length) {
+		let t = d.length > 1, i;
+		if (t ? (i = n(-1, -1), d.forEach((e, t) => {
+			let n = C(e);
+			n.parent = i, n.idx = t, i.children.push(n);
+		})) : i = C(d[0]), w(i), c(i, S, T), r === "radial") {
+			let e = Infinity, n = -Infinity, r = 0;
+			for (let t of m) e = Math.min(e, T[t]), n = Math.max(n, T[t]), r = Math.max(r, s[t]);
+			let i = 0;
+			for (let e of m) i = Math.max(i, y(e));
+			let a = n - e + (i + x) / Math.max(1, r), o = Math.max(k, a / (2 * Math.PI));
+			for (let n of m) {
+				let r = a > 0 ? (T[n] - e) / a * Math.PI * 2 : 0, i = (s[n] + +!!t) * o;
+				O[n] = r - Math.PI / 2, E[n] = i * Math.cos(O[n]), D[n] = i * Math.sin(O[n]);
+			}
+		} else {
+			let t = [], n = [];
+			for (let e of m) {
+				let r = _[e];
+				t[r] = Math.max(t[r] ?? 0, b(e));
+				let i = !!g[e] && l[o[e]].indexOf(e) > 0;
+				n[r] = (n[r] ?? !0) && i;
+			}
+			let i = [0];
+			for (let e = 1; e < t.length; e++) i[e] = i[e - 1] + ((t[e - 1] ?? 0) + (t[e] ?? 0)) / 2 + (n[e] ? Math.max(10, x) : k);
+			let a = r === "org" ? "TB" : e.direction;
+			for (let e of m) {
+				let t = T[e] + (g[e] ? 18 : 0), n = i[_[e]];
+				a === "LR" ? (E[e] = n, D[e] = t) : a === "RL" ? (E[e] = -n, D[e] = t) : a === "BT" ? (E[e] = t, D[e] = -n) : (E[e] = t, D[e] = n);
+			}
+		}
+	}
+	for (let e = 0; e < t; e++) {
+		if (p[e]) continue;
+		let t = o[e];
+		for (; t >= 0 && !p[t];) t = o[t];
+		t >= 0 && (E[e] = E[t], D[e] = D[t], O[e] = O[t]);
+	}
+	return {
+		x: E,
+		y: D,
+		parent: o,
+		depth: s,
+		visible: p,
+		side: O,
+		children: l,
+		stacked: g
+	};
+}, u = (n, r, i = {}) => {
+	let { index: a, source: o, target: s } = e(n, r), c = i.type ?? "tree", u = new Float64Array(n.length), d = new Float64Array(n.length), f = i.cardSize ?? [168, 60];
+	return n.forEach((e, t) => {
+		let [n, r] = i.size?.(e, t) ?? (c === "org" ? f : [16, 16]);
+		u[t] = n, d[t] = r;
+	}), l({
+		n: n.length,
+		source: o,
+		target: s,
+		width: u,
+		height: d,
+		type: c,
+		direction: i.direction ?? "LR",
+		root: i.root === void 0 ? -1 : a.get(i.root) ?? -1,
+		levelGap: i.levelGap ?? t[c],
+		siblingGap: i.siblingGap ?? 12,
+		collapsed: i.collapsed ?? /* @__PURE__ */ new Set(),
+		compact: i.compact
+	});
+};
+//#endregion
+export { t as TREE_LEVEL_GAP, l as tidyTreeLayout, u as treeLayout };
+
+//# sourceMappingURL=tree.js.map

package/dist/charts/engine/graph/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.js","names":["TREE_LEVEL_GAP","tn","node","nextLeft","v","nextRight","moveSubtree","change","shift","wp","wm","executeShifts","i","w","nextAncestor","vim","ancestor","tidy","apportion","vip","vop","vom","sip","sop","sim","som","separation","firstWalk","siblings","midpoint","pre","stack","root","c","k","order","tidyTreeLayout","input","out","n","hasParent","e","s","t","parent","depth","children","visited","roots","grow","r","queue","visible","shown","stackedParent","stacked","ldepth","type","kids","p","horizontal","breadth","along","gap","base","a","b","build","top","depthOffset","list","prev","child","holder","h","X","x","y","side","levelGap","center","weights","count","total","acc","split","sides","dpos","dir","multi","sub","min","max","maxDepth","typical","span","ring","levels","tight","d","rest","levelPos","treeLayout","indexGraph","nodes","edges","options","width","height","card","index"],"sources":["../../../../../charts/src/engine/graph/tree.ts"],"sourcesContent":["// Tree layouts: tidy tree (Buchheim / Walker, linear time, d3-hierarchy's\n// formulation with size-aware separation), radial tree, two-sided mind map\n// and org chart. Collapsed nodes hide their descendants. No DOM.\n\nimport { indexGraph } from \"./force\";\nimport type {\n  GraphDirection,\n  GraphEdge,\n  GraphNode,\n  GraphTreeLayoutOptions,\n  GraphTreeLayoutResult,\n} from \"./types\";\n\nexport type TreeType = \"tree\" | \"radial\" | \"mindmap\" | \"org\";\n\nexport interface TreeInput {\n  n: number;\n  source: ArrayLike<number>;\n  target: ArrayLike<number>;\n  width: ArrayLike<number>;\n  height: ArrayLike<number>;\n  type: TreeType;\n  direction: GraphDirection;\n  /** Index of the root, -1 = nodes without a parent */\n  root: number;\n  levelGap: number;\n  siblingGap: number;\n  collapsed: ReadonlySet<number>;\n  /** Org charts: leaf children are stacked in a column under their parent */\n  compact?: boolean;\n}\n\n/** Shift of stacked org chart cards to the right of their parent (room for the connector) */\nexport const STACK_SHIFT = 18;\n\n/** Default gap between levels of each tree type */\nexport const TREE_LEVEL_GAP: Record<TreeType, number> = {\n  tree: 56,\n  radial: 90,\n  mindmap: 40,\n  org: 44,\n};\n\ninterface TN {\n  i: number;\n  parent: TN | null;\n  children: TN[];\n  A: TN | null;\n  a: TN;\n  z: number;\n  m: number;\n  c: number;\n  s: number;\n  t: TN | null;\n  idx: number;\n  depth: number;\n}\n\nconst tn = (i: number, depth: number): TN => {\n  const node = {\n    i,\n    parent: null,\n    children: [],\n    A: null,\n    z: 0,\n    m: 0,\n    c: 0,\n    s: 0,\n    t: null,\n    idx: 0,\n    depth,\n  } as unknown as TN;\n  node.a = node;\n  return node;\n};\n\nconst nextLeft = (v: TN) => (v.children.length ? v.children[0] : v.t);\nconst nextRight = (v: TN) =>\n  v.children.length ? v.children[v.children.length - 1] : v.t;\n\nconst moveSubtree = (wm: TN, wp: TN, shift: number) => {\n  const change = shift / (wp.idx - wm.idx);\n  wp.c -= change;\n  wp.s += shift;\n  wm.c += change;\n  wp.z += shift;\n  wp.m += shift;\n};\n\nconst executeShifts = (v: TN) => {\n  let shift = 0;\n  let change = 0;\n  for (let i = v.children.length - 1; i >= 0; i--) {\n    const w = v.children[i];\n    w.z += shift;\n    w.m += shift;\n    shift += w.s + (change += w.c);\n  }\n};\n\nconst nextAncestor = (vim: TN, v: TN, ancestor: TN) =>\n  vim.a.parent === v.parent ? vim.a : ancestor;\n\n/**\n * Tidy layout of the tree below `root` (whose `parent` must be set to a\n * holder node): writes the breadth coordinate of every node in `out`\n */\nconst tidy = (\n  root: TN,\n  separation: (a: TN, b: TN) => number,\n  out: Float64Array,\n) => {\n  const apportion = (v: TN, w: TN | null, ancestor: TN): TN => {\n    if (!w) return ancestor;\n    let vip: TN | null = v;\n    let vop: TN = v;\n    let vim: TN | null = w;\n    let vom: TN = vip.parent!.children[0];\n    let sip = vip.m;\n    let sop = vop.m;\n    let sim = vim.m;\n    let som = vom.m;\n    for (;;) {\n      vim = nextRight(vim);\n      vip = nextLeft(vip);\n      if (!vim || !vip) break;\n      vom = nextLeft(vom)!;\n      vop = nextRight(vop)!;\n      vop.a = v;\n      const shift = vim.z + sim - vip.z - sip + separation(vim, vip);\n      if (shift > 0) {\n        moveSubtree(nextAncestor(vim, v, ancestor), v, shift);\n        sip += shift;\n        sop += shift;\n      }\n      sim += vim.m;\n      sip += vip.m;\n      som += vom.m;\n      sop += vop.m;\n    }\n    if (vim && !nextRight(vop)) {\n      vop.t = vim;\n      vop.m += sim - sop;\n    }\n    if (vip && !nextLeft(vom)) {\n      vom.t = vip;\n      vom.m += sip - som;\n      ancestor = v;\n    }\n    return ancestor;\n  };\n\n  const firstWalk = (v: TN) => {\n    const siblings = v.parent!.children;\n    const w = v.idx ? siblings[v.idx - 1] : null;\n    if (v.children.length) {\n      executeShifts(v);\n      const midpoint =\n        (v.children[0].z + v.children[v.children.length - 1].z) / 2;\n      if (w) {\n        v.z = w.z + separation(v, w);\n        v.m = v.z - midpoint;\n      } else {\n        v.z = midpoint;\n      }\n    } else if (w) {\n      v.z = w.z + separation(v, w);\n    }\n    v.parent!.A = apportion(v, w, v.parent!.A || siblings[0]);\n  };\n\n  // pre-order (right to left); reversed it is the post-order (left to right)\n  const pre: TN[] = [];\n  const stack = [root];\n  while (stack.length) {\n    const v = stack.pop()!;\n    pre.push(v);\n    for (const c of v.children) stack.push(c);\n  }\n  for (let k = pre.length - 1; k >= 0; k--) firstWalk(pre[k]);\n  root.parent!.m = -root.z;\n  // parents before children\n  const order: TN[] = [root];\n  for (let k = 0; k < order.length; k++) {\n    const v = order[k];\n    if (v.i >= 0) out[v.i] = v.z + v.parent!.m;\n    v.m += v.parent!.m;\n    for (const c of v.children) order.push(c);\n  }\n};\n\n/** Tree layouts on index data */\nexport const tidyTreeLayout = (input: TreeInput): GraphTreeLayoutResult => {\n  const { n, type } = input;\n  const out: number[][] = Array.from({ length: n }, () => []);\n  const hasParent = new Uint8Array(n);\n  for (let e = 0; e < input.source.length; e++) {\n    const s = input.source[e];\n    const t = input.target[e];\n    if (s === t || s < 0 || t < 0 || s >= n || t >= n) continue;\n    out[s].push(t);\n    hasParent[t] = 1;\n  }\n  const parent = new Int32Array(n).fill(-1);\n  const depth = new Int32Array(n);\n  const children: number[][] = Array.from({ length: n }, () => []);\n  const visited = new Uint8Array(n);\n  const roots: number[] = [];\n  const grow = (r: number) => {\n    if (visited[r]) return;\n    visited[r] = 1;\n    roots.push(r);\n    const queue = [r];\n    for (let k = 0; k < queue.length; k++) {\n      const v = queue[k];\n      for (const w of out[v]) {\n        if (visited[w]) continue;\n        visited[w] = 1;\n        parent[w] = v;\n        depth[w] = depth[v] + 1;\n        children[v].push(w);\n        queue.push(w);\n      }\n    }\n  };\n  if (input.root >= 0 && input.root < n) grow(input.root);\n  for (let v = 0; v < n; v++) if (!hasParent[v]) grow(v);\n  for (let v = 0; v < n; v++) grow(v);\n\n  // visible nodes (descendants of collapsed nodes are hidden)\n  const visible = new Uint8Array(n);\n  const shown: number[] = [];\n  for (const r of roots) {\n    const queue = [r];\n    visible[r] = 1;\n    for (let k = 0; k < queue.length; k++) {\n      const v = queue[k];\n      shown.push(v);\n      if (input.collapsed.has(v)) continue;\n      for (const c of children[v]) {\n        visible[c] = 1;\n        queue.push(c);\n      }\n    }\n  }\n\n  // org charts: the leaf children of a node form a column (compact)\n  const stackedParent = new Uint8Array(n);\n  const stacked = new Uint8Array(n);\n  const ldepth = Int32Array.from(depth);\n  if (type === \"org\" && input.compact !== false) {\n    for (const v of shown) {\n      if (input.collapsed.has(v)) continue;\n      const kids = children[v];\n      if (\n        kids.length >= 2 &&\n        kids.every((c) => input.collapsed.has(c) || !children[c].length)\n      ) {\n        stackedParent[v] = 1;\n        kids.forEach((c) => (stacked[c] = 1));\n      }\n    }\n  }\n  for (const v of shown) {\n    const p = parent[v];\n    if (p < 0) continue;\n    ldepth[v] = ldepth[p] + 1 + (stacked[v] ? children[p].indexOf(v) : 0);\n  }\n\n  const horizontal =\n    type === \"mindmap\" ||\n    (type === \"tree\" && (input.direction === \"LR\" || input.direction === \"RL\"));\n  const breadth = (i: number) =>\n    type === \"radial\"\n      ? Math.max(input.width[i], input.height[i])\n      : horizontal\n        ? input.height[i]\n        : input.width[i] + (stacked[i] ? STACK_SHIFT * 2 : 0);\n  const along = (i: number) =>\n    type === \"radial\"\n      ? Math.max(input.width[i], input.height[i])\n      : horizontal\n        ? input.width[i]\n        : input.height[i];\n  const gap = input.siblingGap;\n  const separation = (a: TN, b: TN) => {\n    const base =\n      (breadth(a.i) + breadth(b.i)) / 2 +\n      gap * (a.parent === b.parent ? 1 : 1.5);\n    return type === \"radial\" ? base / Math.max(1, a.depth) : base;\n  };\n\n  /** Builds the visible subtree of `i` (with `kids` as its children when given) */\n  const build = (i: number, kids?: number[], depthOffset = 0): TN => {\n    const top = tn(i, ldepth[i] + depthOffset);\n    const stack: [TN, number[]][] = [\n      [top, kids ?? (input.collapsed.has(i) ? [] : children[i])],\n    ];\n    while (stack.length) {\n      const [node, list] = stack.pop()!;\n      if (!kids || node !== top) {\n        if (stackedParent[node.i] && list.length) {\n          // a chain: every card is the only child of the previous one\n          let prev = node;\n          for (const c of list) {\n            const child = tn(c, ldepth[c] + depthOffset);\n            child.parent = prev;\n            prev.children.push(child);\n            prev = child;\n          }\n          continue;\n        }\n      }\n      list.forEach((c, k) => {\n        const child = tn(c, ldepth[c] + depthOffset);\n        child.parent = node;\n        child.idx = k;\n        node.children.push(child);\n        stack.push([child, input.collapsed.has(c) ? [] : children[c]]);\n      });\n    }\n    return top;\n  };\n  const holder = (root: TN) => {\n    const h = tn(-1, -1);\n    h.children = [root];\n    root.parent = h;\n    return h;\n  };\n\n  const X = new Float64Array(n);\n  const x = new Float64Array(n);\n  const y = new Float64Array(n);\n  const side = new Float64Array(n);\n  const levelGap = input.levelGap;\n\n  if (type === \"mindmap\" && roots.length) {\n    const center = roots[0];\n    const kids = [\n      ...(input.collapsed.has(center) ? [] : children[center]),\n      ...roots.slice(1),\n    ];\n    const leaves = (i: number): number => {\n      let count = 0;\n      const stack = [i];\n      while (stack.length) {\n        const v = stack.pop()!;\n        const list = input.collapsed.has(v) ? [] : children[v];\n        if (!list.length) count++;\n        else stack.push(...list);\n      }\n      return count;\n    };\n    const weights = kids.map(leaves);\n    const total = weights.reduce((a, b) => a + b, 0);\n    let acc = 0;\n    let split = 0;\n    while (split < kids.length && (acc < total / 2 || split === 0)) {\n      acc += weights[split++];\n    }\n    const sides: [number[], number][] = [\n      [kids.slice(0, split), 1],\n      [kids.slice(split), -1],\n    ];\n    const dpos = new Float64Array(n);\n    for (const [list, dir] of sides) {\n      if (!list.length) continue;\n      const root = build(center, list);\n      holder(root);\n      tidy(root, separation, X);\n      const base = X[center];\n      // the extra roots hang below the center\n      const order: TN[] = [root];\n      for (let k = 0; k < order.length; k++) {\n        const v = order[k];\n        for (const c of v.children) {\n          dpos[c.i] = dpos[v.i] + (along(v.i) + along(c.i)) / 2 + levelGap;\n          x[c.i] = dir * dpos[c.i];\n          y[c.i] = X[c.i] - base;\n          side[c.i] = dir;\n          order.push(c);\n        }\n      }\n    }\n    x[center] = 0;\n    y[center] = 0;\n  } else if (roots.length) {\n    // several roots: a virtual parent keeps them side by side\n    const multi = roots.length > 1;\n    let top: TN;\n    if (multi) {\n      top = tn(-1, -1);\n      roots.forEach((r, k) => {\n        const sub = build(r);\n        sub.parent = top;\n        sub.idx = k;\n        top.children.push(sub);\n      });\n    } else {\n      top = build(roots[0]);\n    }\n    holder(top);\n    tidy(top, separation, X);\n\n    if (type === \"radial\") {\n      let min = Infinity;\n      let max = -Infinity;\n      let maxDepth = 0;\n      for (const v of shown) {\n        min = Math.min(min, X[v]);\n        max = Math.max(max, X[v]);\n        maxDepth = Math.max(maxDepth, depth[v]);\n      }\n      let typical = 0;\n      for (const v of shown) typical = Math.max(typical, breadth(v));\n      const span = max - min + (typical + gap) / Math.max(1, maxDepth);\n      const ring = Math.max(levelGap, span / (2 * Math.PI));\n      for (const v of shown) {\n        const a = span > 0 ? ((X[v] - min) / span) * Math.PI * 2 : 0;\n        const r = (depth[v] + (multi ? 1 : 0)) * ring;\n        side[v] = a - Math.PI / 2;\n        x[v] = r * Math.cos(side[v]);\n        y[v] = r * Math.sin(side[v]);\n      }\n    } else {\n      const levels: number[] = [];\n      // levels holding only the rest of card columns are packed tighter\n      const tight: boolean[] = [];\n      for (const v of shown) {\n        const d = ldepth[v];\n        levels[d] = Math.max(levels[d] ?? 0, along(v));\n        const rest = !!stacked[v] && children[parent[v]].indexOf(v) > 0;\n        tight[d] = (tight[d] ?? true) && rest;\n      }\n      const levelPos = [0];\n      for (let d = 1; d < levels.length; d++) {\n        levelPos[d] =\n          levelPos[d - 1] +\n          ((levels[d - 1] ?? 0) + (levels[d] ?? 0)) / 2 +\n          (tight[d] ? Math.max(10, gap) : levelGap);\n      }\n      const dir = type === \"org\" ? \"TB\" : input.direction;\n      for (const v of shown) {\n        const b = X[v] + (stacked[v] ? STACK_SHIFT : 0);\n        const d = levelPos[ldepth[v]];\n        if (dir === \"LR\") {\n          x[v] = d;\n          y[v] = b;\n        } else if (dir === \"RL\") {\n          x[v] = -d;\n          y[v] = b;\n        } else if (dir === \"BT\") {\n          x[v] = b;\n          y[v] = -d;\n        } else {\n          x[v] = b;\n          y[v] = d;\n        }\n      }\n    }\n  }\n\n  // hidden nodes sit on their closest visible ancestor (collapse animations)\n  for (let v = 0; v < n; v++) {\n    if (visible[v]) continue;\n    let a = parent[v];\n    while (a >= 0 && !visible[a]) a = parent[a];\n    if (a >= 0) {\n      x[v] = x[a];\n      y[v] = y[a];\n      side[v] = side[a];\n    }\n  }\n  return { x, y, parent, depth, visible, side, children, stacked };\n};\n\n/**\n * Tree layouts of a hierarchy given as parent → child edges: tidy tree,\n * radial tree, two-sided mind map or org chart. Edges that would make a\n * cycle or give a second parent are ignored.\n */\nexport const treeLayout = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options: GraphTreeLayoutOptions = {},\n): GraphTreeLayoutResult => {\n  const { index, source, target } = indexGraph(nodes, edges);\n  const type = options.type ?? \"tree\";\n  const width = new Float64Array(nodes.length);\n  const height = new Float64Array(nodes.length);\n  const card = options.cardSize ?? [168, 60];\n  nodes.forEach((node, i) => {\n    const [w, h] =\n      options.size?.(node, i) ?? (type === \"org\" ? card : [16, 16]);\n    width[i] = w;\n    height[i] = h;\n  });\n  return tidyTreeLayout({\n    n: nodes.length,\n    source,\n    target,\n    width,\n    height,\n    type,\n    direction: options.direction ?? \"LR\",\n    root: options.root !== undefined ? (index.get(options.root) ?? -1) : -1,\n    levelGap: options.levelGap ?? TREE_LEVEL_GAP[type],\n    siblingGap: options.siblingGap ?? 12,\n    collapsed: options.collapsed ?? new Set(),\n    compact: options.compact,\n  });\n};\n"],"mappings":"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"}