minerva-design 1.3.0 → 1.5.0

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

@@ -0,0 +1,325 @@
+//#region src/engine/graph/force.ts
+function e() {
+	return function(e) {
+		let t = e.n, n = e.x, r = e.y, i = e.radius, a = new Float64Array(t), o = new Float64Array(t), s = new Float64Array(t).fill(NaN), c = new Float64Array(t).fill(NaN), l = new Uint8Array(t), u = e.seed | 0 || 1, d = () => {
+			u = u + 1831565813 | 0;
+			let e = Math.imul(u ^ u >>> 15, 1 | u);
+			return e = e + Math.imul(e ^ e >>> 7, 61 | e) ^ e, ((e ^ e >>> 14) >>> 0) / 4294967296;
+		}, f = () => (d() - .5) * 1e-6, p = Math.PI * (3 - Math.sqrt(5)), m = Math.max(10, e.linkDistance * .35);
+		for (let i = 0; i < t; i++) {
+			if (!(Number.isFinite(n[i]) && Number.isFinite(r[i]))) {
+				let e = m * Math.sqrt(.5 + i), t = i * p;
+				n[i] = e * Math.cos(t) + f(), r[i] = e * Math.sin(t) + f();
+			}
+			e.fixed[i] && (l[i] = 1, s[i] = n[i], c[i] = r[i]);
+		}
+		let h = e.source.length, g = e.source, _ = e.target, v = new Int32Array(t);
+		for (let e = 0; e < h; e++) v[g[e]]++, v[_[e]]++;
+		let y = new Float64Array(h), b = new Float64Array(h);
+		for (let t = 0; t < h; t++) {
+			let n = v[g[t]], r = v[_[t]];
+			y[t] = n / (n + r);
+			let i = Number.isFinite(e.linkStrength) ? e.linkStrength : 1 / Math.min(n, r);
+			b[t] = i * (e.weight[t] || 1);
+		}
+		let x = e.alpha > 0 ? e.alpha : 1, S = .001, ee = 1 - S ** (1 / Math.max(1, e.iterations)), C = 0, te = e.theta * e.theta, w = e.charge, T = e.collide, E = 0;
+		for (let e = 0; e < t; e++) E = Math.max(E, i[e]);
+		let D = 0, O = /* @__PURE__ */ new Float64Array(), k = /* @__PURE__ */ new Float64Array(), A = /* @__PURE__ */ new Float64Array(), j = /* @__PURE__ */ new Int32Array(), M = /* @__PURE__ */ new Int32Array(), N = /* @__PURE__ */ new Uint8Array(), P = /* @__PURE__ */ new Float64Array(), F = /* @__PURE__ */ new Float64Array(), I = /* @__PURE__ */ new Float64Array(), L = new Int32Array(t), R = 0, z = (e) => {
+			if (e <= D) return;
+			let t = Math.max(e, D * 2, 64), n = (e) => {
+				let n = new Float64Array(t);
+				return n.set(e), n;
+			};
+			O = n(O), k = n(k), A = n(A), P = n(P), F = n(F), I = n(I);
+			let r = new Int32Array(t * 4);
+			r.set(j), j = r;
+			let i = new Int32Array(t);
+			i.set(M), M = i;
+			let a = new Uint8Array(t);
+			a.set(N), N = a, D = t;
+		}, ne = (e, t, n) => {
+			z(R + 1);
+			let r = R++;
+			return O[r] = e, k[r] = t, A[r] = n, j[r * 4] = -1, j[r * 4 + 1] = -1, j[r * 4 + 2] = -1, j[r * 4 + 3] = -1, M[r] = -1, N[r] = 0, r;
+		}, B = (e, t, n) => {
+			let r = A[e] / 2;
+			return +(t >= O[e] + r) | (n >= k[e] + r ? 2 : 0);
+		}, V = (e, t) => {
+			let n = A[e] / 2;
+			return ne(O[e] + (t & 1 ? n : 0), k[e] + (t & 2 ? n : 0), n);
+		}, re = (e) => {
+			let t = 0, i = n[e], a = r[e];
+			for (let o = 0;; o++) {
+				if (N[t]) {
+					let n = B(t, i, a), r = j[t * 4 + n];
+					if (r < 0) {
+						r = V(t, n), j[t * 4 + n] = r, M[r] = e, L[e] = -1;
+						return;
+					}
+					t = r;
+					continue;
+				}
+				let s = M[t];
+				if (s < 0) {
+					M[t] = e, L[e] = -1;
+					return;
+				}
+				if (n[s] === i && r[s] === a || o > 48) {
+					L[e] = s, M[t] = e;
+					return;
+				}
+				M[t] = -1, N[t] = 1;
+				let c = B(t, n[s], r[s]), l = V(t, c);
+				j[t * 4 + c] = l, M[l] = s;
+			}
+		}, ie = () => {
+			let e = Infinity, i = Infinity, a = -Infinity, o = -Infinity;
+			for (let s = 0; s < t; s++) n[s] < e && (e = n[s]), n[s] > a && (a = n[s]), r[s] < i && (i = r[s]), r[s] > o && (o = r[s]);
+			let s = Math.max(a - e, o - i, 1) * 1.0001 + 1e-6;
+			R = 0, z(t * 2 + 8), ne(e, i, s);
+			for (let e = 0; e < t; e++) re(e);
+			for (let e = R - 1; e >= 0; e--) if (N[e]) {
+				let t = 0, n = 0, r = 0, i = 0;
+				for (let a = 0; a < 4; a++) {
+					let o = j[e * 4 + a];
+					if (o < 0) continue;
+					let s = Math.abs(P[o]);
+					t += P[o], n += s, r += s * F[o], i += s * I[o];
+				}
+				P[e] = t, F[e] = n ? r / n : O[e], I[e] = n ? i / n : k[e];
+			} else {
+				let t = 0;
+				for (let n = M[e]; n >= 0; n = L[n]) t += w;
+				P[e] = t, F[e] = n[M[e]], I[e] = r[M[e]];
+			}
+		}, H = /* @__PURE__ */ new Int32Array(256), ae = () => {
+			if (!(!w || t < 2)) {
+				ie();
+				for (let e = 0; e < t; e++) {
+					let t = n[e], i = r[e], s = 0;
+					for (H[s++] = 0; s;) {
+						let c = H[--s];
+						if (P[c]) {
+							if (N[c]) {
+								let n = F[c] - t, r = I[c] - i, l = A[c], u = n * n + r * r;
+								if (l * l / te < u) {
+									u < 1 && (u = Math.sqrt(u));
+									let t = P[c] * x / u;
+									a[e] += n * t, o[e] += r * t;
+									continue;
+								}
+								if (s + 4 > H.length) {
+									let e = new Int32Array(H.length * 2);
+									e.set(H), H = e;
+								}
+								for (let e = 0; e < 4; e++) {
+									let t = j[c * 4 + e];
+									t >= 0 && (H[s++] = t);
+								}
+							} else for (let s = M[c]; s >= 0; s = L[s]) {
+								if (s === e) continue;
+								let c = n[s] - t, l = r[s] - i, u = c * c + l * l;
+								c === 0 && (c = f(), u += c * c), l === 0 && (l = f(), u += l * l), u < 1 && (u = Math.sqrt(u));
+								let d = w * x / u;
+								a[e] += c * d, o[e] += l * d;
+							}
+						}
+					}
+				}
+			}
+		}, oe = () => {
+			let t = e.linkDistance;
+			for (let e = 0; e < h; e++) {
+				let s = g[e], c = _[e];
+				if (s === c) continue;
+				let l = n[c] + a[c] - n[s] - a[s] || f(), u = r[c] + o[c] - r[s] - o[s] || f(), d = Math.sqrt(l * l + u * u);
+				d = (d - t - i[s] - i[c]) / d * x * b[e], l *= d, u *= d;
+				let p = y[e];
+				a[c] -= l * p, o[c] -= u * p, a[s] += l * (1 - p), o[s] += u * (1 - p);
+			}
+		}, se = () => {
+			let i = e.gravity * x;
+			if (!i) return;
+			let s = Math.sqrt(Math.max(.25, Math.min(4, e.aspect > 0 ? e.aspect : 1))), c = i / s, l = i * s;
+			for (let e = 0; e < t; e++) a[e] -= n[e] * c, o[e] -= r[e] * l;
+		}, U = 1;
+		for (; U < t * 2;) U <<= 1;
+		let W = new Int32Array(U + 1), G = new Int32Array(t), K = new Int32Array(t), q = (e, t) => (Math.imul(e, 73856093) ^ Math.imul(t, 19349663)) & U - 1, ce = (e, n, r) => {
+			let i = Math.max(1e-6, (E + r) * 2);
+			W.fill(0);
+			for (let r = 0; r < t; r++) {
+				let t = q(Math.floor(e[r] / i), Math.floor(n[r] / i));
+				K[r] = t, W[t + 1]++;
+			}
+			for (let e = 0; e < U; e++) W[e + 1] += W[e];
+			let a = W.slice(0, U);
+			for (let e = 0; e < t; e++) G[a[K[e]]++] = e;
+			return i;
+		}, J = new Int32Array(U).fill(-1), Y = (e, n, r, i) => {
+			let a = ce(e, n, r);
+			J.fill(-1);
+			for (let r = 0; r < t; r++) {
+				let t = Math.floor(e[r] / a), o = Math.floor(n[r] / a);
+				for (let e = -1; e <= 1; e++) for (let n = -1; n <= 1; n++) {
+					let a = q(t + n, o + e);
+					if (J[a] !== r) {
+						J[a] = r;
+						for (let e = W[a]; e < W[a + 1]; e++) {
+							let t = G[e];
+							t > r && i(r, t);
+						}
+					}
+				}
+			}
+		}, X = new Float64Array(t), Z = new Float64Array(t), le = () => {
+			if (!(T < 0 || t < 2)) {
+				for (let e = 0; e < t; e++) X[e] = n[e] + a[e], Z[e] = r[e] + o[e];
+				Y(X, Z, T, (e, t) => {
+					let s = i[e] + T, c = i[t] + T, l = s + c, u = n[e] + a[e] - n[t] - a[t], d = r[e] + o[e] - r[t] - o[t], p = u * u + d * d;
+					if (p >= l * l) return;
+					u === 0 && (u = f(), p += u * u), d === 0 && (d = f(), p += d * d);
+					let m = Math.sqrt(p), h = (l - m) / m * .7;
+					u *= h, d *= h;
+					let g = c * c, _ = g / (s * s + g);
+					a[e] += u * _, o[e] += d * _, a[t] -= u * (1 - _), o[t] -= d * (1 - _);
+				});
+			}
+		}, ue = () => {
+			let e = 0, i = 0;
+			for (let a = 0; a < t; a++) {
+				if (!Number.isNaN(s[a])) return;
+				e += n[a], i += r[a];
+			}
+			e /= t || 1, i /= t || 1;
+			for (let a = 0; a < t; a++) n[a] -= e, r[a] -= i;
+		}, Q = e.aspect > 0 ? e.aspect : 1, de = e.alpha >= 1 && t > 2 && Math.abs(Math.log(Q)) > .15, fe = () => {
+			let e = 0, i = 0, c = 0;
+			for (let a = 0; a < t; a++) {
+				if (!Number.isNaN(s[a])) return;
+				e += n[a] * n[a], i += r[a] * r[a], c += n[a] * r[a];
+			}
+			if (Math.hypot(e - i, 2 * c) < (e + i) * .04) return;
+			let l = .5 * Math.atan2(2 * c, e - i), u = (Q > 1 ? 0 : Math.PI / 2) - l;
+			if (u > Math.PI / 2 && (u -= Math.PI), u < -Math.PI / 2 && (u += Math.PI), u *= .12, Math.abs(u) < 1e-5) return;
+			let d = Math.cos(u), f = Math.sin(u);
+			for (let e = 0; e < t; e++) {
+				let t = n[e], i = a[e];
+				n[e] = t * d - r[e] * f, r[e] = t * f + r[e] * d, a[e] = i * d - o[e] * f, o[e] = i * f + o[e] * d;
+			}
+		}, pe = () => {
+			x += (C - x) * ee, oe(), ae(), se(), le();
+			let i = 1 - e.velocityDecay;
+			for (let e = 0; e < t; e++) Number.isNaN(s[e]) ? (a[e] *= i, o[e] *= i, n[e] += a[e], r[e] += o[e]) : (n[e] = s[e], r[e] = c[e], a[e] = o[e] = 0);
+			ue(), de && fe();
+		}, $ = () => x < S && C === 0;
+		return {
+			x: n,
+			y: r,
+			tick(e = 1) {
+				for (let t = 0; t < e; t++) {
+					if ($()) return !1;
+					pe();
+				}
+				return !$();
+			},
+			alpha: () => x,
+			reheat(e = .3) {
+				x = Math.max(x, e);
+			},
+			drag(e, i, a) {
+				e < 0 || e >= t || (s[e] = n[e] = i, c[e] = r[e] = a, C = .3, x < .3 && (x = .3));
+			},
+			release(e, n) {
+				C = 0, !(e < 0 || e >= t || n || l[e]) && (s[e] = NaN, c[e] = NaN);
+			},
+			done: $,
+			settle() {
+				let e = Math.max(0, T);
+				for (let t = 0; t < 80; t++) {
+					let t = !1;
+					if (Y(n, r, e, (a, o) => {
+						let c = i[a] + i[o] + e * 2, l = n[a] - n[o], u = r[a] - r[o], f = l * l + u * u;
+						if (f >= c * c * .9999) return;
+						f === 0 && (l = d() - .5, u = d() - .5, f = l * l + u * u);
+						let p = Math.sqrt(f), m = (c - p) / p, h = +!!Number.isNaN(s[a]), g = +!!Number.isNaN(s[o]);
+						if (!h && !g) return;
+						let _ = h / (h + g), v = g / (h + g);
+						n[a] += l * m * _ * 1.001, r[a] += u * m * _ * 1.001, n[o] -= l * m * v * 1.001, r[o] -= u * m * v * 1.001, t = !0;
+					}), !t) break;
+				}
+			}
+		};
+	};
+}
+var t = {
+	linkDistance: 60,
+	charge: -160,
+	theta: .9,
+	gravity: .04,
+	collide: 2,
+	velocityDecay: .4,
+	iterations: 300,
+	seed: 1
+}, n = (e, n, r, i, a = {}) => {
+	let o = i ?? {}, s = o.collide === !1 ? -1 : typeof o.collide == "number" ? Math.max(0, o.collide) : t.collide;
+	return {
+		n: e,
+		x: a.x ?? new Float64Array(e).fill(NaN),
+		y: a.y ?? new Float64Array(e).fill(NaN),
+		radius: a.radius ?? new Float64Array(e).fill(6),
+		fixed: a.fixed ?? new Uint8Array(e),
+		source: n,
+		target: r,
+		weight: a.weight ?? new Float64Array(n.length).fill(1),
+		linkDistance: o.linkDistance ?? t.linkDistance,
+		linkStrength: o.linkStrength ?? NaN,
+		charge: o.charge ?? t.charge,
+		theta: o.theta ?? t.theta,
+		gravity: o.gravity ?? t.gravity,
+		collide: s,
+		velocityDecay: o.velocityDecay ?? t.velocityDecay,
+		iterations: o.iterations ?? t.iterations,
+		seed: o.seed ?? t.seed,
+		alpha: a.alpha ?? 1,
+		aspect: a.aspect ?? 1
+	};
+}, r = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	e.forEach((e, t) => {
+		n.has(e.id) || n.set(e.id, t);
+	});
+	let r = [], i = [], a = [];
+	return t.forEach((e, t) => {
+		let o = n.get(e.source), s = n.get(e.target);
+		o !== void 0 && s !== void 0 && (r.push(o), i.push(s), a.push(t));
+	}), {
+		index: n,
+		source: Int32Array.from(r),
+		target: Int32Array.from(i),
+		edge: Int32Array.from(a)
+	};
+}, i = (t, i, a) => {
+	let { source: o, target: s, edge: c } = r(t, i), l = t.length, u = new Float64Array(l).fill(NaN), d = new Float64Array(l).fill(NaN), f = new Uint8Array(l), p = new Float64Array(l);
+	t.forEach((e, t) => {
+		Number.isFinite(e.x) && Number.isFinite(e.y) && (u[t] = e.x, d[t] = e.y, e.fixed && (f[t] = 1)), p[t] = a?.radius?.(e, t) ?? 6;
+	});
+	let m = Array.from(c, (e) => i[e].value), h = m.filter((e) => Number.isFinite(e) && e > 0), g = h.length ? h.reduce((e, t) => e + t, 0) / h.length : 1, _ = Float64Array.from(m, (e) => Number.isFinite(e) && e > 0 ? Math.max(.5, Math.min(2, Math.sqrt(e / g))) : 1);
+	return e()(n(l, o, s, a, {
+		x: u,
+		y: d,
+		fixed: f,
+		radius: p,
+		weight: _
+	}));
+}, a = (e, t, n) => i(e, t, n), o = (e, t, n) => {
+	let r = i(e, t, n);
+	for (; r.tick(16););
+	return r.settle(), {
+		x: r.x,
+		y: r.y
+	};
+};
+//#endregion
+export { t as FORCE_DEFAULTS, a as createForceSimulation, n as forceInit, e as forceKernel, o as forceLayout, r as indexGraph };
+
+//# sourceMappingURL=force.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"force.js","names":["forceKernel","n","init","x","y","radius","vx","vy","fx","fy","pinned","seed","random","t","jiggle","angle","spread","r","a","m","src","tgt","count","l","bias","strength","b","base","alpha","alphaMin","alphaDecay","alphaTarget","theta2","charge","collidePad","maxRadius","i","cap","qx0","qy0","qsize","qchild","qpoint","qinner","qmass","qcx","qcy","nextPoint","qcount","grow","need","next","copyF","c","p","q","newQuad","x0","y0","size","quadrant","half","py","childQuad","k","insert","px","depth","j","buildTree","x1","y1","mass","weight","sx","sy","w","stack","manyBody","xi","yi","top","dx","dy","f","s","links","distance","gravity","g","stretch","gx","gy","tableSize","cellStart","cellItems","cellOf","hash","cx","cy","bucket","cell","pad","h","fillAt","visited","eachPair","oy","ox","pair","collide","ri","rj","d","rj2","share","center","aspect","orient","align","sxx","syy","sxy","axis","turn","pvx","step","decay","done","value","px2","py2","keep","pass","moved","push","fi","fj","si","sj","FORCE_DEFAULTS","forceInit","options","extra","source","indexGraph","index","node","e","edges","edge","simulationOf","nodes","fixed","values","known","v","mean","target","createForceSimulation","forceLayout","sim"],"sources":["../../../../../charts/src/engine/graph/force.ts"],"sourcesContent":["// Force-directed layout: Barnes–Hut many-body (flat quadtree), links (d3\n// semantics), gravity, centering and collisions (hash grid), with alpha\n// cooling and a deterministic seed. `forceKernel` is self-contained (no\n// reference to anything outside its body): it is serialized into the Web\n// Worker of large graphs (see worker.ts).\n\nimport type {\n  GraphForceLayoutOptions,\n  GraphForceSimulation,\n  GraphEdge,\n  GraphLayoutResult,\n  GraphNode,\n} from \"./types\";\n\n/** Data of a simulation (index-based, transferable to a worker) */\nexport interface ForceKernelInit {\n  n: number;\n  /** Initial positions (NaN = automatic) */\n  x: Float64Array;\n  y: Float64Array;\n  radius: Float64Array;\n  /** 1 = pinned at its initial position */\n  fixed: Uint8Array;\n  source: Int32Array;\n  target: Int32Array;\n  /** Strength multiplier per link */\n  weight: Float64Array;\n  linkDistance: number;\n  /** NaN = 1 / min(degree) */\n  linkStrength: number;\n  charge: number;\n  theta: number;\n  gravity: number;\n  /** Extra spacing of the collisions; negative disables them */\n  collide: number;\n  velocityDecay: number;\n  iterations: number;\n  seed: number;\n  /** Starting temperature (1 for a new layout, lower to refine one) */\n  alpha: number;\n  /** Width / height of the view: gravity stretches the layout to it */\n  aspect: number;\n}\n\nexport type ForceKernel = (init: ForceKernelInit) => GraphForceSimulation;\n\n/** Returns the simulation factory (self-contained: serialized into workers) */\nexport function forceKernel(): ForceKernel {\n  return function createSim(init: ForceKernelInit): GraphForceSimulation {\n    const n = init.n;\n    const x = init.x;\n    const y = init.y;\n    const radius = init.radius;\n    const vx = new Float64Array(n);\n    const vy = new Float64Array(n);\n    const fx = new Float64Array(n).fill(NaN);\n    const fy = new Float64Array(n).fill(NaN);\n    const pinned = new Uint8Array(n);\n    let seed = init.seed | 0 || 1;\n    const random = () => {\n      // mulberry32\n      seed = (seed + 0x6d2b79f5) | 0;\n      let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);\n      t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n      return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n    };\n    const jiggle = () => (random() - 0.5) * 1e-6;\n\n    // phyllotaxis start (like d3), seeded jitter keeps it deterministic\n    const angle = Math.PI * (3 - Math.sqrt(5));\n    const spread = Math.max(10, init.linkDistance * 0.35);\n    for (let i = 0; i < n; i++) {\n      if (!(Number.isFinite(x[i]) && Number.isFinite(y[i]))) {\n        const r = spread * Math.sqrt(0.5 + i);\n        const a = i * angle;\n        x[i] = r * Math.cos(a) + jiggle();\n        y[i] = r * Math.sin(a) + jiggle();\n      }\n      if (init.fixed[i]) {\n        pinned[i] = 1;\n        fx[i] = x[i];\n        fy[i] = y[i];\n      }\n    }\n\n    // links\n    const m = init.source.length;\n    const src = init.source;\n    const tgt = init.target;\n    const count = new Int32Array(n);\n    for (let l = 0; l < m; l++) {\n      count[src[l]]++;\n      count[tgt[l]]++;\n    }\n    const bias = new Float64Array(m);\n    const strength = new Float64Array(m);\n    for (let l = 0; l < m; l++) {\n      const a = count[src[l]];\n      const b = count[tgt[l]];\n      bias[l] = a / (a + b);\n      const base = Number.isFinite(init.linkStrength)\n        ? init.linkStrength\n        : 1 / Math.min(a, b);\n      strength[l] = base * (init.weight[l] || 1);\n    }\n\n    let alpha = init.alpha > 0 ? init.alpha : 1;\n    const alphaMin = 0.001;\n    const alphaDecay = 1 - Math.pow(alphaMin, 1 / Math.max(1, init.iterations));\n    let alphaTarget = 0;\n    const theta2 = init.theta * init.theta;\n    const charge = init.charge;\n    const collidePad = init.collide;\n    let maxRadius = 0;\n    for (let i = 0; i < n; i++) maxRadius = Math.max(maxRadius, radius[i]);\n\n    // ---- flat quadtree (rebuilt every tick)\n    let cap = 0;\n    let qx0 = new Float64Array(0);\n    let qy0 = new Float64Array(0);\n    let qsize = new Float64Array(0);\n    let qchild = new Int32Array(0);\n    let qpoint = new Int32Array(0);\n    let qinner = new Uint8Array(0);\n    let qmass = new Float64Array(0);\n    let qcx = new Float64Array(0);\n    let qcy = new Float64Array(0);\n    const nextPoint = new Int32Array(n);\n    let qcount = 0;\n\n    const grow = (need: number) => {\n      if (need <= cap) return;\n      const next = Math.max(need, cap * 2, 64);\n      const copyF = (a: Float64Array) => {\n        const b = new Float64Array(next);\n        b.set(a);\n        return b;\n      };\n      qx0 = copyF(qx0);\n      qy0 = copyF(qy0);\n      qsize = copyF(qsize);\n      qmass = copyF(qmass);\n      qcx = copyF(qcx);\n      qcy = copyF(qcy);\n      const c = new Int32Array(next * 4);\n      c.set(qchild);\n      qchild = c;\n      const p = new Int32Array(next);\n      p.set(qpoint);\n      qpoint = p;\n      const q = new Uint8Array(next);\n      q.set(qinner);\n      qinner = q;\n      cap = next;\n    };\n\n    const newQuad = (x0: number, y0: number, size: number) => {\n      grow(qcount + 1);\n      const q = qcount++;\n      qx0[q] = x0;\n      qy0[q] = y0;\n      qsize[q] = size;\n      qchild[q * 4] = -1;\n      qchild[q * 4 + 1] = -1;\n      qchild[q * 4 + 2] = -1;\n      qchild[q * 4 + 3] = -1;\n      qpoint[q] = -1;\n      qinner[q] = 0;\n      return q;\n    };\n\n    const quadrant = (q: number, px: number, py: number) => {\n      const half = qsize[q] / 2;\n      return (px >= qx0[q] + half ? 1 : 0) | (py >= qy0[q] + half ? 2 : 0);\n    };\n\n    const childQuad = (q: number, k: number) => {\n      const half = qsize[q] / 2;\n      return newQuad(\n        qx0[q] + (k & 1 ? half : 0),\n        qy0[q] + (k & 2 ? half : 0),\n        half,\n      );\n    };\n\n    const insert = (i: number) => {\n      let q = 0;\n      const px = x[i];\n      const py = y[i];\n      for (let depth = 0; ; depth++) {\n        if (qinner[q]) {\n          const k = quadrant(q, px, py);\n          let c = qchild[q * 4 + k];\n          if (c < 0) {\n            c = childQuad(q, k);\n            qchild[q * 4 + k] = c;\n            qpoint[c] = i;\n            nextPoint[i] = -1;\n            return;\n          }\n          q = c;\n          continue;\n        }\n        const j = qpoint[q];\n        if (j < 0) {\n          qpoint[q] = i;\n          nextPoint[i] = -1;\n          return;\n        }\n        if ((x[j] === px && y[j] === py) || depth > 48) {\n          nextPoint[i] = j;\n          qpoint[q] = i;\n          return;\n        }\n        // split: the points of the leaf move to a child\n        qpoint[q] = -1;\n        qinner[q] = 1;\n        const k = quadrant(q, x[j], y[j]);\n        const c = childQuad(q, k);\n        qchild[q * 4 + k] = c;\n        qpoint[c] = j;\n      }\n    };\n\n    const buildTree = () => {\n      let x0 = Infinity;\n      let y0 = Infinity;\n      let x1 = -Infinity;\n      let y1 = -Infinity;\n      for (let i = 0; i < n; i++) {\n        if (x[i] < x0) x0 = x[i];\n        if (x[i] > x1) x1 = x[i];\n        if (y[i] < y0) y0 = y[i];\n        if (y[i] > y1) y1 = y[i];\n      }\n      const size = Math.max(x1 - x0, y1 - y0, 1) * 1.0001 + 1e-6;\n      qcount = 0;\n      grow(n * 2 + 8);\n      newQuad(x0, y0, size);\n      for (let i = 0; i < n; i++) insert(i);\n      // aggregates, children before parents\n      for (let q = qcount - 1; q >= 0; q--) {\n        if (qinner[q]) {\n          let mass = 0;\n          let weight = 0;\n          let sx = 0;\n          let sy = 0;\n          for (let k = 0; k < 4; k++) {\n            const c = qchild[q * 4 + k];\n            if (c < 0) continue;\n            const w = Math.abs(qmass[c]);\n            mass += qmass[c];\n            weight += w;\n            sx += w * qcx[c];\n            sy += w * qcy[c];\n          }\n          qmass[q] = mass;\n          qcx[q] = weight ? sx / weight : qx0[q];\n          qcy[q] = weight ? sy / weight : qy0[q];\n        } else {\n          let mass = 0;\n          for (let j = qpoint[q]; j >= 0; j = nextPoint[j]) mass += charge;\n          qmass[q] = mass;\n          qcx[q] = x[qpoint[q]];\n          qcy[q] = y[qpoint[q]];\n        }\n      }\n    };\n\n    let stack = new Int32Array(256);\n    const manyBody = () => {\n      if (!charge || n < 2) return;\n      buildTree();\n      for (let i = 0; i < n; i++) {\n        const xi = x[i];\n        const yi = y[i];\n        let top = 0;\n        stack[top++] = 0;\n        while (top) {\n          const q = stack[--top];\n          if (!qmass[q]) continue;\n          if (qinner[q]) {\n            const dx = qcx[q] - xi;\n            const dy = qcy[q] - yi;\n            const w = qsize[q];\n            let l = dx * dx + dy * dy;\n            if ((w * w) / theta2 < l) {\n              if (l < 1) l = Math.sqrt(l);\n              const f = (qmass[q] * alpha) / l;\n              vx[i] += dx * f;\n              vy[i] += dy * f;\n              continue;\n            }\n            if (top + 4 > stack.length) {\n              const s = new Int32Array(stack.length * 2);\n              s.set(stack);\n              stack = s;\n            }\n            for (let k = 0; k < 4; k++) {\n              const c = qchild[q * 4 + k];\n              if (c >= 0) stack[top++] = c;\n            }\n          } else {\n            for (let j = qpoint[q]; j >= 0; j = nextPoint[j]) {\n              if (j === i) continue;\n              let dx = x[j] - xi;\n              let dy = y[j] - yi;\n              let l = dx * dx + dy * dy;\n              if (dx === 0) {\n                dx = jiggle();\n                l += dx * dx;\n              }\n              if (dy === 0) {\n                dy = jiggle();\n                l += dy * dy;\n              }\n              if (l < 1) l = Math.sqrt(l);\n              const f = (charge * alpha) / l;\n              vx[i] += dx * f;\n              vy[i] += dy * f;\n            }\n          }\n        }\n      }\n    };\n\n    const links = () => {\n      const distance = init.linkDistance;\n      for (let l = 0; l < m; l++) {\n        const s = src[l];\n        const t = tgt[l];\n        if (s === t) continue;\n        let dx = x[t] + vx[t] - x[s] - vx[s] || jiggle();\n        let dy = y[t] + vy[t] - y[s] - vy[s] || jiggle();\n        let d = Math.sqrt(dx * dx + dy * dy);\n        d = ((d - distance - radius[s] - radius[t]) / d) * alpha * strength[l];\n        dx *= d;\n        dy *= d;\n        const b = bias[l];\n        vx[t] -= dx * b;\n        vy[t] -= dy * b;\n        vx[s] += dx * (1 - b);\n        vy[s] += dy * (1 - b);\n      }\n    };\n\n    const gravity = () => {\n      const g = init.gravity * alpha;\n      if (!g) return;\n      // a stronger pull along the short side of the view\n      const stretch = Math.sqrt(\n        Math.max(0.25, Math.min(4, init.aspect > 0 ? init.aspect : 1)),\n      );\n      const gx = g / stretch;\n      const gy = g * stretch;\n      for (let i = 0; i < n; i++) {\n        vx[i] -= x[i] * gx;\n        vy[i] -= y[i] * gy;\n      }\n    };\n\n    // ---- hash grid of the collisions\n    let tableSize = 1;\n    while (tableSize < n * 2) tableSize <<= 1;\n    const cellStart = new Int32Array(tableSize + 1);\n    const cellItems = new Int32Array(n);\n    const cellOf = new Int32Array(n);\n    const hash = (cx: number, cy: number) =>\n      (Math.imul(cx, 73856093) ^ Math.imul(cy, 19349663)) & (tableSize - 1);\n\n    /** Buckets the nodes by cell of (`px`, `py`); returns the cell size */\n    const bucket = (px: Float64Array, py: Float64Array, pad: number) => {\n      const cell = Math.max(1e-6, (maxRadius + pad) * 2);\n      cellStart.fill(0);\n      for (let i = 0; i < n; i++) {\n        const h = hash(Math.floor(px[i] / cell), Math.floor(py[i] / cell));\n        cellOf[i] = h;\n        cellStart[h + 1]++;\n      }\n      for (let h = 0; h < tableSize; h++) cellStart[h + 1] += cellStart[h];\n      const fillAt = cellStart.slice(0, tableSize);\n      for (let i = 0; i < n; i++) cellItems[fillAt[cellOf[i]]++] = i;\n      return cell;\n    };\n\n    const visited = new Int32Array(tableSize).fill(-1);\n\n    /** Calls `pair(i, j)` (i < j) for nodes in neighboring cells */\n    const eachPair = (\n      px: Float64Array,\n      py: Float64Array,\n      pad: number,\n      pair: (i: number, j: number) => void,\n    ) => {\n      const cell = bucket(px, py, pad);\n      visited.fill(-1);\n      for (let i = 0; i < n; i++) {\n        const cx = Math.floor(px[i] / cell);\n        const cy = Math.floor(py[i] / cell);\n        for (let oy = -1; oy <= 1; oy++) {\n          for (let ox = -1; ox <= 1; ox++) {\n            const h = hash(cx + ox, cy + oy);\n            // two neighbor cells may share a bucket: visit it once\n            if (visited[h] === i) continue;\n            visited[h] = i;\n            for (let k = cellStart[h]; k < cellStart[h + 1]; k++) {\n              const j = cellItems[k];\n              if (j > i) pair(i, j);\n            }\n          }\n        }\n      }\n    };\n\n    const px = new Float64Array(n);\n    const py = new Float64Array(n);\n    const collide = () => {\n      if (collidePad < 0 || n < 2) return;\n      for (let i = 0; i < n; i++) {\n        px[i] = x[i] + vx[i];\n        py[i] = y[i] + vy[i];\n      }\n      eachPair(px, py, collidePad, (i, j) => {\n        const ri = radius[i] + collidePad;\n        const rj = radius[j] + collidePad;\n        const r = ri + rj;\n        let dx = x[i] + vx[i] - x[j] - vx[j];\n        let dy = y[i] + vy[i] - y[j] - vy[j];\n        let l = dx * dx + dy * dy;\n        if (l >= r * r) return;\n        if (dx === 0) {\n          dx = jiggle();\n          l += dx * dx;\n        }\n        if (dy === 0) {\n          dy = jiggle();\n          l += dy * dy;\n        }\n        const d = Math.sqrt(l);\n        const f = ((r - d) / d) * 0.7;\n        dx *= f;\n        dy *= f;\n        const rj2 = rj * rj;\n        const share = rj2 / (ri * ri + rj2);\n        vx[i] += dx * share;\n        vy[i] += dy * share;\n        vx[j] -= dx * (1 - share);\n        vy[j] -= dy * (1 - share);\n      });\n    };\n\n    const center = () => {\n      let sx = 0;\n      let sy = 0;\n      for (let i = 0; i < n; i++) {\n        if (!Number.isNaN(fx[i])) return;\n        sx += x[i];\n        sy += y[i];\n      }\n      sx /= n || 1;\n      sy /= n || 1;\n      for (let i = 0; i < n; i++) {\n        x[i] -= sx;\n        y[i] -= sy;\n      }\n    };\n\n    // a fresh layout turns its long axis toward the long side of the view\n    // (rigid, so the forces are unchanged): wide boxes are filled, not just\n    // their middle\n    const aspect = init.aspect > 0 ? init.aspect : 1;\n    const orient =\n      init.alpha >= 1 && n > 2 && Math.abs(Math.log(aspect)) > 0.15;\n    const align = () => {\n      let sxx = 0;\n      let syy = 0;\n      let sxy = 0;\n      for (let i = 0; i < n; i++) {\n        if (!Number.isNaN(fx[i])) return;\n        sxx += x[i] * x[i];\n        syy += y[i] * y[i];\n        sxy += x[i] * y[i];\n      }\n      const spread2 = Math.hypot(sxx - syy, 2 * sxy);\n      // a round layout has no long axis\n      if (spread2 < (sxx + syy) * 0.04) return;\n      const axis = 0.5 * Math.atan2(2 * sxy, sxx - syy);\n      let turn = (aspect > 1 ? 0 : Math.PI / 2) - axis;\n      if (turn > Math.PI / 2) turn -= Math.PI;\n      if (turn < -Math.PI / 2) turn += Math.PI;\n      turn *= 0.12;\n      if (Math.abs(turn) < 1e-5) return;\n      const c = Math.cos(turn);\n      const s = Math.sin(turn);\n      for (let i = 0; i < n; i++) {\n        const px = x[i];\n        const pvx = vx[i];\n        x[i] = px * c - y[i] * s;\n        y[i] = px * s + y[i] * c;\n        vx[i] = pvx * c - vy[i] * s;\n        vy[i] = pvx * s + vy[i] * c;\n      }\n    };\n\n    const step = () => {\n      alpha += (alphaTarget - alpha) * alphaDecay;\n      links();\n      manyBody();\n      gravity();\n      collide();\n      const decay = 1 - init.velocityDecay;\n      for (let i = 0; i < n; i++) {\n        if (Number.isNaN(fx[i])) {\n          vx[i] *= decay;\n          vy[i] *= decay;\n          x[i] += vx[i];\n          y[i] += vy[i];\n        } else {\n          x[i] = fx[i];\n          y[i] = fy[i];\n          vx[i] = vy[i] = 0;\n        }\n      }\n      center();\n      if (orient) align();\n    };\n\n    const done = () => alpha < alphaMin && alphaTarget === 0;\n\n    return {\n      x,\n      y,\n      tick(k = 1) {\n        for (let i = 0; i < k; i++) {\n          if (done()) return false;\n          step();\n        }\n        return !done();\n      },\n      alpha: () => alpha,\n      reheat(value = 0.3) {\n        alpha = Math.max(alpha, value);\n      },\n      drag(i, px2, py2) {\n        if (i < 0 || i >= n) return;\n        fx[i] = x[i] = px2;\n        fy[i] = y[i] = py2;\n        alphaTarget = 0.3;\n        if (alpha < 0.3) alpha = 0.3;\n      },\n      release(i, keep) {\n        alphaTarget = 0;\n        if (i < 0 || i >= n || keep || pinned[i]) return;\n        fx[i] = NaN;\n        fy[i] = NaN;\n      },\n      done,\n      settle() {\n        // position-based passes until no two nodes overlap\n        const pad = Math.max(0, collidePad);\n        for (let pass = 0; pass < 80; pass++) {\n          let moved = false;\n          eachPair(x, y, pad, (i, j) => {\n            const r = radius[i] + radius[j] + pad * 2;\n            let dx = x[i] - x[j];\n            let dy = y[i] - y[j];\n            let l = dx * dx + dy * dy;\n            if (l >= r * r * 0.9999) return;\n            if (l === 0) {\n              dx = random() - 0.5;\n              dy = random() - 0.5;\n              l = dx * dx + dy * dy;\n            }\n            const d = Math.sqrt(l);\n            const push = (r - d) / d;\n            const fi = Number.isNaN(fx[i]) ? 1 : 0;\n            const fj = Number.isNaN(fx[j]) ? 1 : 0;\n            if (!fi && !fj) return;\n            const si = fi / (fi + fj);\n            const sj = fj / (fi + fj);\n            x[i] += dx * push * si * 1.001;\n            y[i] += dy * push * si * 1.001;\n            x[j] -= dx * push * sj * 1.001;\n            y[j] -= dy * push * sj * 1.001;\n            moved = true;\n          });\n          if (!moved) break;\n        }\n      },\n    };\n  };\n}\n\n// ------------------------------------------------------------- inputs\n\nexport const FORCE_DEFAULTS = {\n  linkDistance: 60,\n  charge: -160,\n  theta: 0.9,\n  gravity: 0.04,\n  collide: 2,\n  velocityDecay: 0.4,\n  iterations: 300,\n  seed: 1,\n};\n\n/** Kernel input from index-based data */\nexport const forceInit = (\n  n: number,\n  source: Int32Array,\n  target: Int32Array,\n  options: GraphForceLayoutOptions | undefined,\n  extra: {\n    x?: Float64Array;\n    y?: Float64Array;\n    radius?: Float64Array;\n    fixed?: Uint8Array;\n    weight?: Float64Array;\n    alpha?: number;\n    aspect?: number;\n  } = {},\n): ForceKernelInit => {\n  const o = options ?? {};\n  const collide =\n    o.collide === false\n      ? -1\n      : typeof o.collide === \"number\"\n        ? Math.max(0, o.collide)\n        : FORCE_DEFAULTS.collide;\n  return {\n    n,\n    x: extra.x ?? new Float64Array(n).fill(NaN),\n    y: extra.y ?? new Float64Array(n).fill(NaN),\n    radius: extra.radius ?? new Float64Array(n).fill(6),\n    fixed: extra.fixed ?? new Uint8Array(n),\n    source,\n    target,\n    weight: extra.weight ?? new Float64Array(source.length).fill(1),\n    linkDistance: o.linkDistance ?? FORCE_DEFAULTS.linkDistance,\n    linkStrength: o.linkStrength ?? NaN,\n    charge: o.charge ?? FORCE_DEFAULTS.charge,\n    theta: o.theta ?? FORCE_DEFAULTS.theta,\n    gravity: o.gravity ?? FORCE_DEFAULTS.gravity,\n    collide,\n    velocityDecay: o.velocityDecay ?? FORCE_DEFAULTS.velocityDecay,\n    iterations: o.iterations ?? FORCE_DEFAULTS.iterations,\n    seed: o.seed ?? FORCE_DEFAULTS.seed,\n    alpha: extra.alpha ?? 1,\n    aspect: extra.aspect ?? 1,\n  };\n};\n\n/** Index of the ids and the valid edges (unknown ids are skipped) */\nexport const indexGraph = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n): {\n  index: Map<string, number>;\n  source: Int32Array;\n  target: Int32Array;\n  edge: Int32Array;\n} => {\n  const index = new Map<string, number>();\n  nodes.forEach((node, i) => {\n    if (!index.has(node.id)) index.set(node.id, i);\n  });\n  const s: number[] = [];\n  const t: number[] = [];\n  const e: number[] = [];\n  edges.forEach((edge, k) => {\n    const a = index.get(edge.source);\n    const b = index.get(edge.target);\n    if (a === undefined || b === undefined) return;\n    s.push(a);\n    t.push(b);\n    e.push(k);\n  });\n  return {\n    index,\n    source: Int32Array.from(s),\n    target: Int32Array.from(t),\n    edge: Int32Array.from(e),\n  };\n};\n\nconst simulationOf = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options: GraphForceLayoutOptions | undefined,\n): GraphForceSimulation => {\n  const { source, target, edge } = indexGraph(nodes, edges);\n  const n = nodes.length;\n  const x = new Float64Array(n).fill(NaN);\n  const y = new Float64Array(n).fill(NaN);\n  const fixed = new Uint8Array(n);\n  const radius = new Float64Array(n);\n  nodes.forEach((node, i) => {\n    if (Number.isFinite(node.x) && Number.isFinite(node.y)) {\n      x[i] = node.x!;\n      y[i] = node.y!;\n      if (node.fixed) fixed[i] = 1;\n    }\n    radius[i] = options?.radius?.(node, i) ?? 6;\n  });\n  const values = Array.from(edge, (k) => edges[k].value);\n  const known = values.filter((v): v is number => Number.isFinite(v) && v! > 0);\n  const mean = known.length\n    ? known.reduce((a, b) => a + b, 0) / known.length\n    : 1;\n  const weight = Float64Array.from(values, (v) =>\n    Number.isFinite(v) && v! > 0\n      ? Math.max(0.5, Math.min(2, Math.sqrt(v! / mean)))\n      : 1,\n  );\n  return forceKernel()(\n    forceInit(n, source, target, options, { x, y, fixed, radius, weight }),\n  );\n};\n\n/**\n * A force simulation of the nodes and edges, stepped by the caller (no DOM,\n * no timers: usable in workers and mini-programs)\n */\nexport const createForceSimulation = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options?: GraphForceLayoutOptions,\n): GraphForceSimulation => simulationOf(nodes, edges, options);\n\n/** Runs a force simulation to the end and returns the positions (synchronous) */\nexport const forceLayout = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options?: GraphForceLayoutOptions,\n): GraphLayoutResult => {\n  const sim = simulationOf(nodes, edges, options);\n  while (sim.tick(16));\n  sim.settle();\n  return { x: sim.x, y: sim.y };\n};\n"],"mappings":"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"}

package/dist/charts/engine/graph/geometry.cjs

@@ -0,0 +1,2 @@
+var e=(e,t,n,r,i,a,o,s,c)=>{let l=Math.hypot(r-t,i-n)+Math.hypot(a-r,o-i)+Math.hypot(s-a,c-o),u=Math.max(4,Math.min(28,Math.ceil(l/10)));for(let l=1;l<=u;l++){let d=l/u,f=1-d,p=f*f*f,m=3*f*f*d,h=3*f*d*d,g=d*d*d;e.push(p*t+m*r+h*a+g*s,p*n+m*i+h*o+g*c)}},t=(t,n,r,i,a,o)=>{let s=[t,n];return e(s,t,n,t+(r-t)*2/3,n+(i-n)*2/3,a+(r-a)*2/3,o+(i-o)*2/3,a,o),s},n=(t,n)=>{let r=[t[0],t[1]];for(let i=2;i<t.length;i+=2){let a=t[i-2],o=t[i-1],s=t[i],c=t[i+1];if(n){let t=(o+c)/2;e(r,a,o,a,t,s,t,s,c)}else{let t=(a+s)/2;e(r,a,o,t,o,t,c,s,c)}}return r},r=(e,t,n,r,i,a)=>{let o=e[e.length-2],s=e[e.length-1],c=Math.hypot(t-o,n-s),l=Math.hypot(r-t,i-n),u=Math.min(a,c/2,l/2);if(u<.5){e.push(t,n);return}let d=t-(t-o)/c*u,f=n-(n-s)/c*u,p=t+(r-t)/l*u,m=n+(i-n)/l*u;e.push(d,f);for(let r=1;r<=4;r++){let i=r/4,a=1-i;e.push(a*a*d+2*a*i*t+i*i*p,a*a*f+2*a*i*n+i*i*m)}},i=(e,t,n)=>{let r=[e[0],e[1]];for(let n=2;n<e.length;n+=2){let i=e[n-2],a=e[n-1],o=e[n],s=e[n+1];if(Math.abs(t?o-i:s-a)>.5){if(t){let e=(a+s)/2;r.push(i,e,o,e)}else{let e=(i+o)/2;r.push(e,a,e,s)}}r.push(o,s)}return a(r,n)},a=(e,t)=>{let n=[e[0],e[1]],i=e.length-2;for(let a=2;a<i;a+=2)r(n,e[a],e[a+1],e[a+2],e[a+3],t);return i>=2&&n.push(e[i],e[i+1]),n},o=(e,t,n)=>{let r=(e+t)/2,i=Math.abs(t-e)/2,a=2*Math.max(4,Math.min(32,Math.ceil(i/12))),o=[],s=e<t?Math.PI:0,c=e<t?0:Math.PI;for(let e=0;e<=a;e++){let t=s+(c-s)*e/a;o.push(r+i*Math.cos(t),n-i*Math.sin(t))}return o},s=e=>{let t=0;for(let n=2;n<e.length;n+=2)t+=Math.hypot(e[n]-e[n-2],e[n+1]-e[n-1]);return t},c=(e,t,n)=>{let r=s(e);if(r<=t+n+1e-6){if(e.length<4)return e;let i=l(e,(t+n>0?t/(t+n):.5)*r);return[i[0],i[1],i[0],i[1]]}let i=[],a=l(e,t),o=l(e,r-n);i.push(a[0],a[1]);let c=0;for(let a=2;a<e.length;a+=2)c+=Math.hypot(e[a]-e[a-2],e[a+1]-e[a-1]),c>t&&c<r-n&&i.push(e[a],e[a+1]);return i.push(o[0],o[1]),i},l=(e,t)=>{let n=0;for(let r=2;r<e.length;r+=2){let i=e[r]-e[r-2],a=e[r+1]-e[r-1],o=Math.hypot(i,a);if(n+o>=t&&o>0){let s=(t-n)/o;return[e[r-2]+i*s,e[r-1]+a*s,i/o,a/o]}n+=o}let r=e.length-2,i=r>=2?e[r]-e[r-2]:1,a=r>=2?e[r+1]-e[r-1]:0,o=Math.hypot(i,a)||1;return[e[r],e[r+1],i/o,a/o]},u=e=>{for(let t=e.length-4;t>=0;t-=2){let n=e[e.length-2]-e[t],r=e[e.length-1]-e[t+1],i=Math.hypot(n,r);if(i>1e-9)return[n/i,r/i]}return[1,0]},d=(e,t,n,r,i)=>{if(!e)return t/2;let a=Math.abs(r),o=Math.abs(i),s=a>1e-9?t/2/a:1/0,c=o>1e-9?n/2/o:1/0;return Math.min(s,c)},f=(e,t,n,r,i,a,o)=>{let s=a*.42,c=t-r*a,l=n-i*a,u=c-i*s,d=l+r*s,f=c+i*s,p=l-r*s;e.push(u,d,t,n,f,p,u,d,o,o),e.push(t,n,c,l,o,o);let m=(u+c)/2,h=(d+l)/2,g=(f+c)/2,_=(p+l)/2;e.push(t,n,m,h,o,o,t,n,g,_,o,o)},p=(e,t,n,r)=>{let i=[],a=s(e),o=t+n;if(o<=0||a<=0)return e.slice();for(let n=0;n<a;n+=o){let o=Math.min(a,n+t),s=l(e,n);i.push(s[0],s[1]);let c=0;for(let t=2;t<e.length;t+=2)c+=Math.hypot(e[t]-e[t-2],e[t+1]-e[t-1]),c>n&&c<o&&i.push(e[t],e[t+1]);let u=l(e,o);i.push(u[0],u[1],r,r)}return i},m=(e,t,n)=>{let r=1/0;for(let i=2;i<e.length;i+=2){let a=e[i-2],o=e[i-1],s=e[i]-a,c=e[i+1]-o,l=s*s+c*c,u=l>0?Math.max(0,Math.min(1,((t-a)*s+(n-o)*c)/l)):0,d=a+s*u-t,f=o+c*u-n;r=Math.min(r,d*d+f*f)}return r};exports.arcPath=o,exports.arrowHead=f,exports.boundaryDistance=d,exports.cubicPoints=e,exports.dashPath=p,exports.distanceToPath=m,exports.endDirection=u,exports.orthogonalPath=i,exports.pathLength=s,exports.pointAt=l,exports.quadraticPath=t,exports.roundCorners=a,exports.splinePath=n,exports.trimPath=c;
+//# sourceMappingURL=geometry.cjs.map

package/dist/charts/engine/graph/geometry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.cjs","names":["cubicPoints","length","x1","x0","y1","y0","x2","y2","x3","y3","segments","i","t","u","a","b","c","d","out","quadraticPath","cx","cy","splinePath","points","vertical","my","mx","corner","px","py","inLen","outLen","nx","ny","r","radius","ax","ay","bx","by","orthogonalPath","corners","roundCorners","last","arcPath","from","to","y","pathLength","trimPath","total","start","end","p","pointAt","startPoint","endPoint","walked","dx","dy","l","distance","k","endDirection","boundaryDistance","box","width","ux","uy","tx","ty","height","arrowHead","w","lx","ly","rx","ry","gap","dashPath","period","dash","space","distanceToPath","best","qx","qy"],"sources":["../../../../../charts/src/engine/graph/geometry.ts"],"sourcesContent":["// Edge geometry in layout units: curves sampled into polylines, trimming at\n// the node boundaries, arrowheads and dashes. Polylines are flat\n// `[x0, y0, x1, y1, …]` arrays.\n\n/** Points of a cubic Bézier (the start point excluded) */\nexport const cubicPoints = (\n  out: number[],\n  x0: number,\n  y0: number,\n  x1: number,\n  y1: number,\n  x2: number,\n  y2: number,\n  x3: number,\n  y3: number,\n): void => {\n  const length =\n    Math.hypot(x1 - x0, y1 - y0) +\n    Math.hypot(x2 - x1, y2 - y1) +\n    Math.hypot(x3 - x2, y3 - y2);\n  const segments = Math.max(4, Math.min(28, Math.ceil(length / 10)));\n  for (let i = 1; i <= segments; i++) {\n    const t = i / segments;\n    const u = 1 - t;\n    const a = u * u * u;\n    const b = 3 * u * u * t;\n    const c = 3 * u * t * t;\n    const d = t * t * t;\n    out.push(\n      a * x0 + b * x1 + c * x2 + d * x3,\n      a * y0 + b * y1 + c * y2 + d * y3,\n    );\n  }\n};\n\n/** Points of a quadratic Bézier (the start point included) */\nexport const quadraticPath = (\n  x0: number,\n  y0: number,\n  cx: number,\n  cy: number,\n  x1: number,\n  y1: number,\n): number[] => {\n  const out = [x0, y0];\n  cubicPoints(\n    out,\n    x0,\n    y0,\n    x0 + ((cx - x0) * 2) / 3,\n    y0 + ((cy - y0) * 2) / 3,\n    x1 + ((cx - x1) * 2) / 3,\n    y1 + ((cy - y1) * 2) / 3,\n    x1,\n    y1,\n  );\n  return out;\n};\n\n/**\n * Smooth path through waypoints whose tangents follow the flow axis\n * (vertical for top → bottom layouts): C1 at every waypoint\n */\nexport const splinePath = (\n  points: readonly number[],\n  vertical: boolean,\n): number[] => {\n  const out = [points[0], points[1]];\n  for (let i = 2; i < points.length; i += 2) {\n    const x0 = points[i - 2];\n    const y0 = points[i - 1];\n    const x1 = points[i];\n    const y1 = points[i + 1];\n    if (vertical) {\n      const my = (y0 + y1) / 2;\n      cubicPoints(out, x0, y0, x0, my, x1, my, x1, y1);\n    } else {\n      const mx = (x0 + x1) / 2;\n      cubicPoints(out, x0, y0, mx, y0, mx, y1, x1, y1);\n    }\n  }\n  return out;\n};\n\n/** Rounded corner from the end of `out` through (cx, cy) towards (nx, ny) */\nconst corner = (\n  out: number[],\n  cx: number,\n  cy: number,\n  nx: number,\n  ny: number,\n  radius: number,\n) => {\n  const px = out[out.length - 2];\n  const py = out[out.length - 1];\n  const inLen = Math.hypot(cx - px, cy - py);\n  const outLen = Math.hypot(nx - cx, ny - cy);\n  const r = Math.min(radius, inLen / 2, outLen / 2);\n  if (r < 0.5) {\n    out.push(cx, cy);\n    return;\n  }\n  const ax = cx - ((cx - px) / inLen) * r;\n  const ay = cy - ((cy - py) / inLen) * r;\n  const bx = cx + ((nx - cx) / outLen) * r;\n  const by = cy + ((ny - cy) / outLen) * r;\n  out.push(ax, ay);\n  // quadratic arc around the corner\n  for (let i = 1; i <= 4; i++) {\n    const t = i / 4;\n    const u = 1 - t;\n    out.push(\n      u * u * ax + 2 * u * t * cx + t * t * bx,\n      u * u * ay + 2 * u * t * cy + t * t * by,\n    );\n  }\n};\n\n/**\n * Orthogonal path through waypoints: along the flow axis to the middle,\n * across, then along the axis again, with rounded corners\n */\nexport const orthogonalPath = (\n  points: readonly number[],\n  vertical: boolean,\n  radius: number,\n): number[] => {\n  const corners: number[] = [points[0], points[1]];\n  for (let i = 2; i < points.length; i += 2) {\n    const x0 = points[i - 2];\n    const y0 = points[i - 1];\n    const x1 = points[i];\n    const y1 = points[i + 1];\n    if (Math.abs(vertical ? x1 - x0 : y1 - y0) > 0.5) {\n      if (vertical) {\n        const my = (y0 + y1) / 2;\n        corners.push(x0, my, x1, my);\n      } else {\n        const mx = (x0 + x1) / 2;\n        corners.push(mx, y0, mx, y1);\n      }\n    }\n    corners.push(x1, y1);\n  }\n  return roundCorners(corners, radius);\n};\n\n/** Polyline with rounded corners */\nexport const roundCorners = (\n  corners: readonly number[],\n  radius: number,\n): number[] => {\n  const out = [corners[0], corners[1]];\n  const last = corners.length - 2;\n  for (let i = 2; i < last; i += 2) {\n    corner(\n      out,\n      corners[i],\n      corners[i + 1],\n      corners[i + 2],\n      corners[i + 3],\n      radius,\n    );\n  }\n  if (last >= 2) out.push(corners[last], corners[last + 1]);\n  return out;\n};\n\n/** Upper half circle between two points of the x axis (arc diagrams) */\nexport const arcPath = (ax: number, bx: number, y: number): number[] => {\n  const cx = (ax + bx) / 2;\n  const r = Math.abs(bx - ax) / 2;\n  const segments = 2 * Math.max(4, Math.min(32, Math.ceil(r / 12)));\n  const out: number[] = [];\n  const from = ax < bx ? Math.PI : 0;\n  const to = ax < bx ? 0 : Math.PI;\n  for (let i = 0; i <= segments; i++) {\n    const a = from + ((to - from) * i) / segments;\n    out.push(cx + r * Math.cos(a), y - r * Math.sin(a));\n  }\n  return out;\n};\n\n/** Length of a polyline */\nexport const pathLength = (points: readonly number[]): number => {\n  let length = 0;\n  for (let i = 2; i < points.length; i += 2)\n    length += Math.hypot(\n      points[i] - points[i - 2],\n      points[i + 1] - points[i - 1],\n    );\n  return length;\n};\n\n/** Removes `start` / `end` units from the ends of a polyline */\nexport const trimPath = (\n  points: number[],\n  start: number,\n  end: number,\n): number[] => {\n  const total = pathLength(points);\n  if (total <= start + end + 1e-6) {\n    // too short: a zero-length segment in the middle keeps the direction\n    if (points.length < 4) return points;\n    const t = start + end > 0 ? start / (start + end) : 0.5;\n    const p = pointAt(points, t * total);\n    return [p[0], p[1], p[0], p[1]];\n  }\n  const out: number[] = [];\n  const startPoint = pointAt(points, start);\n  const endPoint = pointAt(points, total - end);\n  out.push(startPoint[0], startPoint[1]);\n  let walked = 0;\n  for (let i = 2; i < points.length; i += 2) {\n    walked += Math.hypot(\n      points[i] - points[i - 2],\n      points[i + 1] - points[i - 1],\n    );\n    if (walked > start && walked < total - end)\n      out.push(points[i], points[i + 1]);\n  }\n  out.push(endPoint[0], endPoint[1]);\n  return out;\n};\n\n/** Point and direction at a distance along a polyline */\nexport const pointAt = (\n  points: readonly number[],\n  distance: number,\n): [number, number, number, number] => {\n  let walked = 0;\n  for (let i = 2; i < points.length; i += 2) {\n    const dx = points[i] - points[i - 2];\n    const dy = points[i + 1] - points[i - 1];\n    const l = Math.hypot(dx, dy);\n    if (walked + l >= distance && l > 0) {\n      const t = (distance - walked) / l;\n      return [points[i - 2] + dx * t, points[i - 1] + dy * t, dx / l, dy / l];\n    }\n    walked += l;\n  }\n  const k = points.length - 2;\n  const dx = k >= 2 ? points[k] - points[k - 2] : 1;\n  const dy = k >= 2 ? points[k + 1] - points[k - 1] : 0;\n  const l = Math.hypot(dx, dy) || 1;\n  return [points[k], points[k + 1], dx / l, dy / l];\n};\n\n/** Direction at the end of a polyline (unit vector) */\nexport const endDirection = (points: readonly number[]): [number, number] => {\n  for (let i = points.length - 4; i >= 0; i -= 2) {\n    const dx = points[points.length - 2] - points[i];\n    const dy = points[points.length - 1] - points[i + 1];\n    const l = Math.hypot(dx, dy);\n    if (l > 1e-9) return [dx / l, dy / l];\n  }\n  return [1, 0];\n};\n\n/** Distance from the center of a node to its boundary in direction (ux, uy) */\nexport const boundaryDistance = (\n  box: boolean,\n  width: number,\n  height: number,\n  ux: number,\n  uy: number,\n): number => {\n  if (!box) return width / 2;\n  const ax = Math.abs(ux);\n  const ay = Math.abs(uy);\n  const tx = ax > 1e-9 ? width / 2 / ax : Infinity;\n  const ty = ay > 1e-9 ? height / 2 / ay : Infinity;\n  return Math.min(tx, ty);\n};\n\n/**\n * Arrowhead at (tx, ty) pointing along (ux, uy): the outline of a narrow\n * triangle and its axis, drawn with the line width it looks solid\n */\nexport const arrowHead = (\n  out: number[],\n  tx: number,\n  ty: number,\n  ux: number,\n  uy: number,\n  length: number,\n  gap: number,\n): void => {\n  const w = length * 0.42;\n  const bx = tx - ux * length;\n  const by = ty - uy * length;\n  const lx = bx - uy * w;\n  const ly = by + ux * w;\n  const rx = bx + uy * w;\n  const ry = by - ux * w;\n  out.push(lx, ly, tx, ty, rx, ry, lx, ly, gap, gap);\n  out.push(tx, ty, bx, by, gap, gap);\n  const mx = (lx + bx) / 2;\n  const my = (ly + by) / 2;\n  const nx = (rx + bx) / 2;\n  const ny = (ry + by) / 2;\n  out.push(tx, ty, mx, my, gap, gap, tx, ty, nx, ny, gap, gap);\n};\n\n/** Splits a polyline into dashes (`dash` / `space` in layout units) */\nexport const dashPath = (\n  points: readonly number[],\n  dash: number,\n  space: number,\n  gap: number,\n): number[] => {\n  const out: number[] = [];\n  const total = pathLength(points);\n  const period = dash + space;\n  if (period <= 0 || total <= 0) return points.slice();\n  for (let start = 0; start < total; start += period) {\n    const end = Math.min(total, start + dash);\n    const a = pointAt(points, start);\n    out.push(a[0], a[1]);\n    let walked = 0;\n    for (let i = 2; i < points.length; i += 2) {\n      walked += Math.hypot(\n        points[i] - points[i - 2],\n        points[i + 1] - points[i - 1],\n      );\n      if (walked > start && walked < end) out.push(points[i], points[i + 1]);\n    }\n    const b = pointAt(points, end);\n    out.push(b[0], b[1], gap, gap);\n  }\n  return out;\n};\n\n/** Squared distance from (px, py) to a polyline */\nexport const distanceToPath = (\n  points: readonly number[],\n  px: number,\n  py: number,\n): number => {\n  let best = Infinity;\n  for (let i = 2; i < points.length; i += 2) {\n    const ax = points[i - 2];\n    const ay = points[i - 1];\n    const dx = points[i] - ax;\n    const dy = points[i + 1] - ay;\n    const l = dx * dx + dy * dy;\n    const t =\n      l > 0\n        ? Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / l))\n        : 0;\n    const qx = ax + dx * t - px;\n    const qy = ay + dy * t - py;\n    best = Math.min(best, qx * qx + qy * qy);\n  }\n  return best;\n};\n"],"mappings":"AAKA,IAAaA,GACX,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,IACS,CACT,IAAMC,EACJ,KAAK,MAAMC,EAAKC,EAAIC,EAAKC,CAAE,EAC3B,KAAK,MAAMC,EAAKJ,EAAIK,EAAKH,CAAE,EAC3B,KAAK,MAAMI,EAAKF,EAAIG,EAAKF,CAAE,EACvBG,EAAW,KAAK,IAAI,EAAG,KAAK,IAAI,GAAI,KAAK,KAAKT,EAAS,EAAE,CAAC,CAAC,EACjE,IAAK,IAAIU,EAAI,EAAGA,GAAKD,EAAU,IAAK,CAClC,IAAME,EAAID,EAAID,EACRG,EAAI,EAAID,EACRE,EAAID,EAAIA,EAAIA,EACZE,EAAI,EAAIF,EAAIA,EAAID,EAChBI,EAAI,EAAIH,EAAID,EAAIA,EAChBK,EAAIL,EAAIA,EAAIA,EAClBM,EAAI,KACFJ,EAAIX,EAAKY,EAAIb,EAAKc,EAAIV,EAAKW,EAAIT,EAC/BM,EAAIT,EAAKU,EAAIX,EAAKY,EAAIT,EAAKU,EAAIR,CACjC,CACF,CACF,EAGaU,GACX,EACA,EACA,EACA,EACA,EACA,IACa,CACb,IAAMD,EAAM,CAACf,EAAIE,CAAE,EAYnB,OAXAL,EACEkB,EACAf,EACAE,EACAF,GAAOiB,EAAKjB,GAAM,EAAK,EACvBE,GAAOgB,EAAKhB,GAAM,EAAK,EACvBH,GAAOkB,EAAKlB,GAAM,EAAK,EACvBE,GAAOiB,EAAKjB,GAAM,EAAK,EACvBF,EACAE,CACF,EACOc,CACT,EAMaI,GACX,EACA,IACa,CACb,IAAMJ,EAAM,CAACK,EAAO,GAAIA,EAAO,EAAE,EACjC,IAAK,IAAI,EAAI,EAAG,EAAIA,EAAO,OAAQ,GAAK,EAAG,CACzC,IAAMpB,EAAKoB,EAAO,EAAI,GAChBlB,EAAKkB,EAAO,EAAI,GAChBrB,EAAKqB,EAAO,GACZnB,EAAKmB,EAAO,EAAI,GACtB,GAAIC,EAAU,CACZ,IAAMC,GAAMpB,EAAKD,GAAM,EACvBJ,EAAYkB,EAAKf,EAAIE,EAAIF,EAAIsB,EAAIvB,EAAIuB,EAAIvB,EAAIE,CAAE,CACjD,KAAO,CACL,IAAMsB,GAAMvB,EAAKD,GAAM,EACvBF,EAAYkB,EAAKf,EAAIE,EAAIqB,EAAIrB,EAAIqB,EAAItB,EAAIF,EAAIE,CAAE,CACjD,CACF,CACA,OAAOc,CACT,EAGMS,GACJ,EACA,EACA,EACA,EACA,EACA,IACG,CACH,IAAMC,EAAKV,EAAIA,EAAI,OAAS,GACtBW,EAAKX,EAAIA,EAAI,OAAS,GACtBY,EAAQ,KAAK,MAAMV,EAAKQ,EAAIP,EAAKQ,CAAE,EACnCE,EAAS,KAAK,MAAMC,EAAKZ,EAAIa,EAAKZ,CAAE,EACpCa,EAAI,KAAK,IAAIC,EAAQL,EAAQ,EAAGC,EAAS,CAAC,EAChD,GAAIG,EAAI,GAAK,CACXhB,EAAI,KAAKE,EAAIC,CAAE,EACf,MACF,CACA,IAAMe,EAAKhB,GAAOA,EAAKQ,GAAME,EAASI,EAChCG,EAAKhB,GAAOA,EAAKQ,GAAMC,EAASI,EAChCI,EAAKlB,GAAOY,EAAKZ,GAAMW,EAAUG,EACjCK,EAAKlB,GAAOY,EAAKZ,GAAMU,EAAUG,EACvChB,EAAI,KAAKkB,EAAIC,CAAE,EAEf,IAAK,IAAI1B,EAAI,EAAGA,GAAK,EAAG,IAAK,CAC3B,IAAMC,EAAID,EAAI,EACRE,EAAI,EAAID,EACdM,EAAI,KACFL,EAAIA,EAAIuB,EAAK,EAAIvB,EAAID,EAAIQ,EAAKR,EAAIA,EAAI0B,EACtCzB,EAAIA,EAAIwB,EAAK,EAAIxB,EAAID,EAAIS,EAAKT,EAAIA,EAAI2B,CACxC,CACF,CACF,EAMaC,GACX,EACA,EACA,IACa,CACb,IAAMC,EAAoB,CAAClB,EAAO,GAAIA,EAAO,EAAE,EAC/C,IAAK,IAAIZ,EAAI,EAAGA,EAAIY,EAAO,OAAQ,GAAK,EAAG,CACzC,IAAMpB,EAAKoB,EAAOZ,EAAI,GAChBN,EAAKkB,EAAOZ,EAAI,GAChBT,EAAKqB,EAAOZ,GACZP,EAAKmB,EAAOZ,EAAI,GACtB,GAAI,KAAK,IAAIa,EAAWtB,EAAKC,EAAKC,EAAKC,CAAE,EAAI,GAAK,CAChD,GAAImB,EAAU,CACZ,IAAMC,GAAMpB,EAAKD,GAAM,EACvBqC,EAAQ,KAAKtC,EAAIsB,EAAIvB,EAAIuB,CAAE,CAC7B,KAAO,CACL,IAAMC,GAAMvB,EAAKD,GAAM,EACvBuC,EAAQ,KAAKf,EAAIrB,EAAIqB,EAAItB,CAAE,CAC7B,CACF,CACAqC,EAAQ,KAAKvC,EAAIE,CAAE,CACrB,CACA,OAAOsC,EAAaD,EAASN,CAAM,CACrC,EAGaO,GACX,EACA,IACa,CACb,IAAMxB,EAAM,CAACuB,EAAQ,GAAIA,EAAQ,EAAE,EAC7BE,EAAOF,EAAQ,OAAS,EAC9B,IAAK,IAAI9B,EAAI,EAAGA,EAAIgC,EAAM,GAAK,EAC7BhB,EACET,EACAuB,EAAQ9B,GACR8B,EAAQ9B,EAAI,GACZ8B,EAAQ9B,EAAI,GACZ8B,EAAQ9B,EAAI,GACZwB,CACF,EAGF,OADIQ,GAAQ,GAAGzB,EAAI,KAAKuB,EAAQE,GAAOF,EAAQE,EAAO,EAAE,EACjDzB,CACT,EAGa0B,GAAW,EAAY,EAAY,IAAwB,CACtE,IAAMxB,GAAMgB,EAAKE,GAAM,EACjBJ,EAAI,KAAK,IAAII,EAAKF,CAAE,EAAI,EACxB1B,EAAW,EAAI,KAAK,IAAI,EAAG,KAAK,IAAI,GAAI,KAAK,KAAKwB,EAAI,EAAE,CAAC,CAAC,EAC1DhB,EAAgB,CAAC,EACjB2B,EAAOT,EAAKE,EAAK,KAAK,GAAK,EAC3BQ,EAAKV,EAAKE,EAAK,EAAI,KAAK,GAC9B,IAAK,IAAI3B,EAAI,EAAGA,GAAKD,EAAU,IAAK,CAClC,IAAMI,EAAI+B,GAASC,EAAKD,GAAQlC,EAAKD,EACrCQ,EAAI,KAAKE,EAAKc,EAAI,KAAK,IAAIpB,CAAC,EAAGiC,EAAIb,EAAI,KAAK,IAAIpB,CAAC,CAAC,CACpD,CACA,OAAOI,CACT,EAGa8B,EAAc,GAAsC,CAC/D,IAAI/C,EAAS,EACb,IAAK,IAAIU,EAAI,EAAGA,EAAIY,EAAO,OAAQ,GAAK,EACtC,GAAU,KAAK,MACbA,EAAOZ,GAAKY,EAAOZ,EAAI,GACvBY,EAAOZ,EAAI,GAAKY,EAAOZ,EAAI,EAC7B,EACF,OAAOV,CACT,EAGagD,GACX,EACA,EACA,IACa,CACb,IAAMC,EAAQF,EAAWzB,CAAM,EAC/B,GAAI2B,GAASC,EAAQC,EAAM,KAAM,CAE/B,GAAI7B,EAAO,OAAS,EAAG,OAAOA,EAE9B,IAAM8B,EAAIC,EAAQ/B,GADR4B,EAAQC,EAAM,EAAID,GAASA,EAAQC,GAAO,IACtBF,CAAK,EACnC,MAAO,CAACG,EAAE,GAAIA,EAAE,GAAIA,EAAE,GAAIA,EAAE,EAAE,CAChC,CACA,IAAMnC,EAAgB,CAAC,EACjBqC,EAAaD,EAAQ/B,EAAQ4B,CAAK,EAClCK,EAAWF,EAAQ/B,EAAQ2B,EAAQE,CAAG,EAC5ClC,EAAI,KAAKqC,EAAW,GAAIA,EAAW,EAAE,EACrC,IAAIE,EAAS,EACb,IAAK,IAAI9C,EAAI,EAAGA,EAAIY,EAAO,OAAQ,GAAK,EACtC,GAAU,KAAK,MACbA,EAAOZ,GAAKY,EAAOZ,EAAI,GACvBY,EAAOZ,EAAI,GAAKY,EAAOZ,EAAI,EAC7B,EACI8C,EAASN,GAASM,EAASP,EAAQE,GACrClC,EAAI,KAAKK,EAAOZ,GAAIY,EAAOZ,EAAI,EAAE,EAGrC,OADAO,EAAI,KAAKsC,EAAS,GAAIA,EAAS,EAAE,EAC1BtC,CACT,EAGaoC,GACX,EACA,IACqC,CACrC,IAAIG,EAAS,EACb,IAAK,IAAI9C,EAAI,EAAGA,EAAIY,EAAO,OAAQ,GAAK,EAAG,CACzC,IAAMmC,EAAKnC,EAAOZ,GAAKY,EAAOZ,EAAI,GAC5BgD,EAAKpC,EAAOZ,EAAI,GAAKY,EAAOZ,EAAI,GAChCiD,EAAI,KAAK,MAAMF,EAAIC,CAAE,EAC3B,GAAIF,EAASG,GAAKC,GAAYD,EAAI,EAAG,CACnC,IAAMhD,GAAKiD,EAAWJ,GAAUG,EAChC,MAAO,CAACrC,EAAOZ,EAAI,GAAK+C,EAAK9C,EAAGW,EAAOZ,EAAI,GAAKgD,EAAK/C,EAAG8C,EAAKE,EAAGD,EAAKC,CAAC,CACxE,CACA,GAAUA,CACZ,CACA,IAAME,EAAIvC,EAAO,OAAS,EACpBmC,EAAKI,GAAK,EAAIvC,EAAOuC,GAAKvC,EAAOuC,EAAI,GAAK,EAC1CH,EAAKG,GAAK,EAAIvC,EAAOuC,EAAI,GAAKvC,EAAOuC,EAAI,GAAK,EAC9CF,EAAI,KAAK,MAAMF,EAAIC,CAAE,GAAK,EAChC,MAAO,CAACpC,EAAOuC,GAAIvC,EAAOuC,EAAI,GAAIJ,EAAKE,EAAGD,EAAKC,CAAC,CAClD,EAGaG,EAAgB,GAAgD,CAC3E,IAAK,IAAIpD,EAAIY,EAAO,OAAS,EAAGZ,GAAK,EAAG,GAAK,EAAG,CAC9C,IAAM+C,EAAKnC,EAAOA,EAAO,OAAS,GAAKA,EAAOZ,GACxCgD,EAAKpC,EAAOA,EAAO,OAAS,GAAKA,EAAOZ,EAAI,GAC5CiD,EAAI,KAAK,MAAMF,EAAIC,CAAE,EAC3B,GAAIC,EAAI,KAAM,MAAO,CAACF,EAAKE,EAAGD,EAAKC,CAAC,CACtC,CACA,MAAO,CAAC,EAAG,CAAC,CACd,EAGaI,GACX,EACA,EACA,EACA,EACA,IACW,CACX,GAAI,CAACC,EAAK,OAAOC,EAAQ,EACzB,IAAM9B,EAAK,KAAK,IAAI+B,CAAE,EAChB9B,EAAK,KAAK,IAAI+B,CAAE,EAChBC,EAAKjC,EAAK,KAAO8B,EAAQ,EAAI9B,EAAK,IAClCkC,EAAKjC,EAAK,KAAOkC,EAAS,EAAIlC,EAAK,IACzC,OAAO,KAAK,IAAIgC,EAAIC,CAAE,CACxB,EAMaE,GACX,EACA,EACA,EACA,EACA,EACA,EACA,IACS,CACT,IAAMC,EAAIxE,EAAS,IACbqC,EAAK+B,EAAKF,EAAKlE,EACfsC,EAAK+B,EAAKF,EAAKnE,EACfyE,EAAKpC,EAAK8B,EAAKK,EACfE,EAAKpC,EAAK4B,EAAKM,EACfG,EAAKtC,EAAK8B,EAAKK,EACfI,EAAKtC,EAAK4B,EAAKM,EACrBvD,EAAI,KAAKwD,EAAIC,EAAIN,EAAIC,EAAIM,EAAIC,EAAIH,EAAIC,EAAIG,EAAKA,CAAG,EACjD5D,EAAI,KAAKmD,EAAIC,EAAIhC,EAAIC,EAAIuC,EAAKA,CAAG,EACjC,IAAMpD,GAAMgD,EAAKpC,GAAM,EACjBb,GAAMkD,EAAKpC,GAAM,EACjBP,GAAM4C,EAAKtC,GAAM,EACjBL,GAAM4C,EAAKtC,GAAM,EACvBrB,EAAI,KAAKmD,EAAIC,EAAI5C,EAAID,EAAIqD,EAAKA,EAAKT,EAAIC,EAAItC,EAAIC,EAAI6C,EAAKA,CAAG,CAC7D,EAGaC,GACX,EACA,EACA,EACA,IACa,CACb,IAAM7D,EAAgB,CAAC,EACjBgC,EAAQF,EAAWzB,CAAM,EACzByD,EAASC,EAAOC,EACtB,GAAIF,GAAU,GAAK9B,GAAS,EAAG,OAAO3B,EAAO,MAAM,EACnD,IAAK,IAAI4B,EAAQ,EAAGA,EAAQD,EAAO,GAAS8B,EAAQ,CAClD,IAAM5B,EAAM,KAAK,IAAIF,EAAOC,EAAQ8B,CAAI,EAClCnE,EAAIwC,EAAQ/B,EAAQ4B,CAAK,EAC/BjC,EAAI,KAAKJ,EAAE,GAAIA,EAAE,EAAE,EACnB,IAAI2C,EAAS,EACb,IAAK,IAAI9C,EAAI,EAAGA,EAAIY,EAAO,OAAQ,GAAK,EACtC,GAAU,KAAK,MACbA,EAAOZ,GAAKY,EAAOZ,EAAI,GACvBY,EAAOZ,EAAI,GAAKY,EAAOZ,EAAI,EAC7B,EACI8C,EAASN,GAASM,EAASL,GAAKlC,EAAI,KAAKK,EAAOZ,GAAIY,EAAOZ,EAAI,EAAE,EAEvE,IAAMI,EAAIuC,EAAQ/B,EAAQ6B,CAAG,EAC7BlC,EAAI,KAAKH,EAAE,GAAIA,EAAE,GAAI+D,EAAKA,CAAG,CAC/B,CACA,OAAO5D,CACT,EAGaiE,GACX,EACA,EACA,IACW,CACX,IAAIC,EAAO,IACX,IAAK,IAAI,EAAI,EAAG,EAAI7D,EAAO,OAAQ,GAAK,EAAG,CACzC,IAAMa,EAAKb,EAAO,EAAI,GAChBc,EAAKd,EAAO,EAAI,GAChBmC,EAAKnC,EAAO,GAAKa,EACjBuB,EAAKpC,EAAO,EAAI,GAAKc,EACrB,EAAIqB,EAAKA,EAAKC,EAAKA,EACnB/C,EACJ,EAAI,EACA,KAAK,IAAI,EAAG,KAAK,IAAI,IAAKgB,EAAKQ,GAAMsB,GAAM7B,EAAKQ,GAAMsB,GAAM,CAAC,CAAC,EAC9D,EACA0B,EAAKjD,EAAKsB,EAAK9C,EAAIgB,EACnB0D,EAAKjD,EAAKsB,EAAK/C,EAAIiB,EACzB,EAAO,KAAK,IAAIuD,EAAMC,EAAKA,EAAKC,EAAKA,CAAE,CACzC,CACA,OAAOF,CACT"}

package/dist/charts/engine/graph/geometry.d.cts

@@ -0,0 +1,37 @@
+/** Points of a cubic Bézier (the start point excluded) */
+export declare const cubicPoints: (out: number[], x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number) => void;
+/** Points of a quadratic Bézier (the start point included) */
+export declare const quadraticPath: (x0: number, y0: number, cx: number, cy: number, x1: number, y1: number) => number[];
+/**
+ * Smooth path through waypoints whose tangents follow the flow axis
+ * (vertical for top → bottom layouts): C1 at every waypoint
+ */
+export declare const splinePath: (points: readonly number[], vertical: boolean) => number[];
+/**
+ * Orthogonal path through waypoints: along the flow axis to the middle,
+ * across, then along the axis again, with rounded corners
+ */
+export declare const orthogonalPath: (points: readonly number[], vertical: boolean, radius: number) => number[];
+/** Polyline with rounded corners */
+export declare const roundCorners: (corners: readonly number[], radius: number) => number[];
+/** Upper half circle between two points of the x axis (arc diagrams) */
+export declare const arcPath: (ax: number, bx: number, y: number) => number[];
+/** Length of a polyline */
+export declare const pathLength: (points: readonly number[]) => number;
+/** Removes `start` / `end` units from the ends of a polyline */
+export declare const trimPath: (points: number[], start: number, end: number) => number[];
+/** Point and direction at a distance along a polyline */
+export declare const pointAt: (points: readonly number[], distance: number) => [number, number, number, number];
+/** Direction at the end of a polyline (unit vector) */
+export declare const endDirection: (points: readonly number[]) => [number, number];
+/** Distance from the center of a node to its boundary in direction (ux, uy) */
+export declare const boundaryDistance: (box: boolean, width: number, height: number, ux: number, uy: number) => number;
+/**
+ * Arrowhead at (tx, ty) pointing along (ux, uy): the outline of a narrow
+ * triangle and its axis, drawn with the line width it looks solid
+ */
+export declare const arrowHead: (out: number[], tx: number, ty: number, ux: number, uy: number, length: number, gap: number) => void;
+/** Splits a polyline into dashes (`dash` / `space` in layout units) */
+export declare const dashPath: (points: readonly number[], dash: number, space: number, gap: number) => number[];
+/** Squared distance from (px, py) to a polyline */
+export declare const distanceToPath: (points: readonly number[], px: number, py: number) => number;

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

@@ -0,0 +1,37 @@
+/** Points of a cubic Bézier (the start point excluded) */
+export declare const cubicPoints: (out: number[], x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number) => void;
+/** Points of a quadratic Bézier (the start point included) */
+export declare const quadraticPath: (x0: number, y0: number, cx: number, cy: number, x1: number, y1: number) => number[];
+/**
+ * Smooth path through waypoints whose tangents follow the flow axis
+ * (vertical for top → bottom layouts): C1 at every waypoint
+ */
+export declare const splinePath: (points: readonly number[], vertical: boolean) => number[];
+/**
+ * Orthogonal path through waypoints: along the flow axis to the middle,
+ * across, then along the axis again, with rounded corners
+ */
+export declare const orthogonalPath: (points: readonly number[], vertical: boolean, radius: number) => number[];
+/** Polyline with rounded corners */
+export declare const roundCorners: (corners: readonly number[], radius: number) => number[];
+/** Upper half circle between two points of the x axis (arc diagrams) */
+export declare const arcPath: (ax: number, bx: number, y: number) => number[];
+/** Length of a polyline */
+export declare const pathLength: (points: readonly number[]) => number;
+/** Removes `start` / `end` units from the ends of a polyline */
+export declare const trimPath: (points: number[], start: number, end: number) => number[];
+/** Point and direction at a distance along a polyline */
+export declare const pointAt: (points: readonly number[], distance: number) => [number, number, number, number];
+/** Direction at the end of a polyline (unit vector) */
+export declare const endDirection: (points: readonly number[]) => [number, number];
+/** Distance from the center of a node to its boundary in direction (ux, uy) */
+export declare const boundaryDistance: (box: boolean, width: number, height: number, ux: number, uy: number) => number;
+/**
+ * Arrowhead at (tx, ty) pointing along (ux, uy): the outline of a narrow
+ * triangle and its axis, drawn with the line width it looks solid
+ */
+export declare const arrowHead: (out: number[], tx: number, ty: number, ux: number, uy: number, length: number, gap: number) => void;
+/** Splits a polyline into dashes (`dash` / `space` in layout units) */
+export declare const dashPath: (points: readonly number[], dash: number, space: number, gap: number) => number[];
+/** Squared distance from (px, py) to a polyline */
+export declare const distanceToPath: (points: readonly number[], px: number, py: number) => number;