@smwb/ui-react 2.7.0 → 2.9.0

package/dist/components/dataDisplay/dagView/dagLayout.js

@@ -0,0 +1,289 @@
+const _ = (o) => {
+  var l;
+  return (l = o.id) != null ? l : `${o.source}->${o.target}`;
+};
+function G(o) {
+  var a;
+  const l = (a = o.warn) != null ? a : (() => {
+  }), i = [], f = /* @__PURE__ */ new Map();
+  for (const n of o.nodes) {
+    if (f.has(n.id)) {
+      l(`node "${n.id}" is listed twice; the second is dropped.`);
+      continue;
+    }
+    f.set(n.id, i.length), i.push(n);
+  }
+  const h = [], e = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set();
+  for (const n of o.edges) {
+    const d = f.get(n.source), x = f.get(n.target);
+    if (d === void 0 || x === void 0) {
+      const M = d === void 0 ? n.source : n.target;
+      l(`edge ${n.source} -> ${n.target} names an unknown node "${M}"; it is dropped.`);
+      continue;
+    }
+    if (d === x) {
+      l(`edge ${n.source} -> ${n.target} is a self-loop; it is dropped.`);
+      continue;
+    }
+    const y = `${d} ${x}`, w = _(n);
+    if (e.has(y) || c.has(w)) {
+      l(`edge ${n.source} -> ${n.target} is listed twice; the second is dropped.`);
+      continue;
+    }
+    e.add(y), c.add(w), h.push({ id: w, source: n.source, target: n.target, from: d, to: x, reversed: !1 });
+  }
+  const s = i.map(() => []);
+  h.forEach((n, d) => s[n.from].push(d));
+  const t = new Uint8Array(i.length);
+  for (let n = 0; n < i.length; n++) {
+    if (t[n]) continue;
+    const d = [[n, 0]];
+    for (t[n] = 1; d.length; ) {
+      const x = d[d.length - 1], [y, w] = x, M = s[y];
+      if (w >= M.length) {
+        t[y] = 2, d.pop();
+        continue;
+      }
+      x[1] = w + 1;
+      const S = h[M[w]];
+      t[S.to] === 1 ? S.reversed = !0 : t[S.to] === 0 && (t[S.to] = 1, d.push([S.to, 0]));
+    }
+  }
+  return { nodes: i, index: f, edges: h };
+}
+function N(o, l) {
+  const i = Array.from({ length: o }, () => []), f = new Array(o).fill(0);
+  for (const [t, a] of l)
+    i[t].push(a), f[a]++;
+  const h = f.map((t) => t > 0), e = new Array(o).fill(0), c = [], s = [];
+  for (let t = 0; t < o; t++) f[t] === 0 && s.push(t);
+  for (let t = 0; t < s.length; t++) {
+    const a = s[t];
+    c.push(a);
+    for (const n of i[a])
+      e[n] = Math.max(e[n], e[a] + 1), --f[n] === 0 && s.push(n);
+  }
+  for (let t = c.length - 1; t >= 0; t--) {
+    const a = c[t], n = i[a];
+    n.length === 0 || h[a] || (e[a] = Math.min(...n.map((d) => e[d])) - 1);
+  }
+  return e;
+}
+function O(o, l, i) {
+  const f = [];
+  for (const s of o) for (const t of l[s].succs) f.push([i[s], i[t]]);
+  f.sort((s, t) => s[0] - t[0] || s[1] - t[1]);
+  let h = 1;
+  for (const [, s] of f) h = Math.max(h, s + 2);
+  const e = new Int32Array(h + 1);
+  let c = 0;
+  for (let s = f.length - 1; s >= 0; s--) {
+    const t = f[s][1];
+    for (let a = t; a > 0; a -= a & -a) c += e[a];
+    for (let a = t + 1; a <= h; a += a & -a) e[a]++;
+  }
+  return c;
+}
+function P(o, l, i) {
+  let f = 0;
+  for (let h = 0; h + 1 < o.length; h++) f += O(o[h], l, i);
+  return f;
+}
+function R(o, l, i, f) {
+  const h = /* @__PURE__ */ new Map();
+  for (const e of o) {
+    const c = f ? l[e].preds : l[e].succs;
+    c.length === 0 ? h.set(e, i[e]) : h.set(e, c.reduce((s, t) => s + i[t], 0) / c.length);
+  }
+  o.sort((e, c) => h.get(e) - h.get(c) || i[e] - i[c]), o.forEach((e, c) => i[e] = c);
+}
+function j(o, l, i) {
+  const f = new Int32Array(l.length);
+  for (const s of o) s.forEach((t, a) => f[t] = a);
+  let h = o.map((s) => s.slice()), e = P(o, l, f), c = 0;
+  for (let s = 0; s < i && e > 0; s++) {
+    if (s % 2 === 0) for (let n = 1; n < o.length; n++) R(o[n], l, f, !0);
+    else for (let n = o.length - 2; n >= 0; n--) R(o[n], l, f, !1);
+    const a = P(o, l, f);
+    if (a < e)
+      e = a, h = o.map((n) => n.slice()), c = 0;
+    else if (++c >= 2) break;
+  }
+  h.forEach((s, t) => o[t] = s);
+}
+function B(o, l, i) {
+  const f = [0];
+  for (let c = 1; c < o.length; c++) f.push(f[c - 1] + l[c - 1]);
+  const h = [];
+  o.forEach((c, s) => {
+    let t = { value: c - f[s], weight: i[s], count: 1 };
+    for (; h.length && h[h.length - 1].value > t.value; ) {
+      const a = h.pop(), n = a.weight + t.weight;
+      t = {
+        value: (a.value * a.weight + t.value * t.weight) / n,
+        weight: n,
+        count: a.count + t.count
+      };
+    }
+    h.push(t);
+  });
+  const e = [];
+  for (const c of h) for (let s = 0; s < c.count; s++) e.push(c.value + f[e.length]);
+  return e;
+}
+function F(o, l, i) {
+  const f = (e, c) => {
+    const s = l[e], t = l[c], a = s.node < 0 && t.node < 0 ? i / 2 : i;
+    return s.crossSize / 2 + a + t.crossSize / 2;
+  };
+  for (const e of o) {
+    let c = 0;
+    e.forEach((s, t) => {
+      t > 0 && (c += f(e[t - 1], s)), l[s].cross = c;
+    });
+  }
+  const h = ["down", "up", "down", "up", "both", "both"];
+  for (const e of h) {
+    const c = e === "up" ? o.map((s, t) => o.length - 1 - t) : o.map((s, t) => t);
+    for (const s of c) {
+      const t = o[s];
+      if (t.length === 0) continue;
+      const a = t.map((x) => {
+        const y = l[x], w = e === "down" ? y.preds : e === "up" ? y.succs : [...y.preds, ...y.succs];
+        return w.length === 0 ? y.cross : w.reduce((M, S) => M + l[S].cross, 0) / w.length;
+      }), n = t.slice(1).map((x, y) => f(t[y], x)), d = t.map((x) => l[x].node < 0 ? 2 : 1);
+      B(a, n, d).forEach((x, y) => l[t[y]].cross = x);
+    }
+  }
+}
+function q(o, l, i, f, h, e, c, s) {
+  const t = /* @__PURE__ */ new Map();
+  o.forEach((g, p) => t.set(g, p));
+  const a = i.map((g) => {
+    const p = l.edges[g], $ = t.get(p.from), r = t.get(p.to);
+    return p.reversed ? [r, $] : [$, r];
+  }), n = N(o.length, a), d = o.map((g, p) => ({
+    node: g,
+    rankSize: f(g),
+    crossSize: h(g),
+    layer: n[p],
+    cross: 0,
+    preds: [],
+    succs: []
+  })), x = i.map((g, p) => {
+    const [$, r] = a[p], u = [$];
+    let m = $;
+    for (let k = d[$].layer + 1; k < d[r].layer; k++) {
+      const E = d.length;
+      d.push({ node: -1, rankSize: 0, crossSize: 0, layer: k, cross: 0, preds: [], succs: [] }), d[m].succs.push(E), d[E].preds.push(m), u.push(E), m = E;
+    }
+    return d[m].succs.push(r), d[r].preds.push(m), u.push(r), { edge: g, chain: u };
+  }), y = d.reduce((g, p) => Math.max(g, p.layer + 1), 0), w = Array.from({ length: y }, () => []);
+  d.forEach((g, p) => w[g.layer].push(p)), j(w, d, s), F(w, d, c);
+  const M = w.map((g) => g.reduce((p, $) => Math.max(p, d[$].rankSize), 0)), S = [];
+  let A = 0;
+  M.forEach((g, p) => {
+    S[p] = A, A += g + (p + 1 < M.length ? e : 0);
+  });
+  let v = 1 / 0, z = -1 / 0;
+  for (const g of d)
+    v = Math.min(v, g.cross - g.crossSize / 2), z = Math.max(z, g.cross + g.crossSize / 2);
+  const I = Number.isFinite(v) ? -v : 0, C = /* @__PURE__ */ new Map();
+  w.forEach(
+    (g, p) => g.forEach(($, r) => {
+      const u = d[$];
+      u.node < 0 || C.set(u.node, {
+        rank: S[p] + (M[p] - u.rankSize) / 2,
+        cross: u.cross - u.crossSize / 2 + I,
+        layer: p,
+        order: r
+      });
+    })
+  );
+  const L = /* @__PURE__ */ new Map();
+  for (const { edge: g, chain: p } of x) {
+    const $ = [];
+    p.forEach((r, u) => {
+      const m = d[r], k = m.layer, E = m.cross + I, b = S[k] + (M[k] - m.rankSize) / 2;
+      u === 0 ? $.push({ rank: b + m.rankSize, cross: E }) : u === p.length - 1 ? $.push({ rank: b, cross: E }) : $.push({ rank: S[k], cross: E }, { rank: S[k] + M[k], cross: E });
+    }), l.edges[g].reversed && $.reverse(), L.set(g, $);
+  }
+  return {
+    nodes: C,
+    edges: L,
+    rankExtent: A,
+    crossExtent: Number.isFinite(z) ? z - v : 0
+  };
+}
+function D(o) {
+  var L, g, p, $;
+  const l = (L = o.direction) != null ? L : "LR", i = (g = o.rankGap) != null ? g : 64, f = (p = o.nodeGap) != null ? p : 24, h = ($ = o.sweeps) != null ? $ : 8, e = G(o), c = l === "LR", s = (r) => c ? e.nodes[r].width : e.nodes[r].height, t = (r) => c ? e.nodes[r].height : e.nodes[r].width, a = e.nodes.map((r, u) => u), n = (r) => {
+    for (; a[r] !== r; )
+      a[r] = a[a[r]], r = a[r];
+    return r;
+  };
+  for (const r of e.edges) {
+    const u = n(r.from), m = n(r.to);
+    u !== m && (a[Math.max(u, m)] = Math.min(u, m));
+  }
+  const d = /* @__PURE__ */ new Map();
+  e.nodes.forEach((r, u) => {
+    const m = n(u);
+    d.has(m) || d.set(m, { members: [], edges: [] }), d.get(m).members.push(u);
+  }), e.edges.forEach((r, u) => d.get(n(r.from)).edges.push(u));
+  const x = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), w = (r, u) => c ? { x: r, y: u } : { x: u, y: r };
+  let M = 0, S = 0;
+  for (const r of d.values()) {
+    const u = q(r.members, e, r.edges, s, t, i, f, h);
+    for (const [m, k] of u.nodes) {
+      const E = e.nodes[m];
+      x.set(m, {
+        id: E.id,
+        ...w(k.rank, k.cross + M),
+        width: E.width,
+        height: E.height,
+        layer: k.layer,
+        order: k.order
+      });
+    }
+    for (const [m, k] of u.edges)
+      y.set(
+        m,
+        k.map((E) => w(E.rank, E.cross + M))
+      );
+    S = Math.max(S, u.rankExtent), M += u.crossExtent + f * 2;
+  }
+  const A = Math.max(0, M - f * 2), v = /* @__PURE__ */ new Map();
+  e.nodes.forEach((r, u) => v.set(r.id, x.get(u)));
+  const z = new Set(e.edges.map((r) => `${r.from} ${r.to}`)), I = e.edges.map((r, u) => {
+    let m = y.get(u);
+    if (r.reversed && z.has(`${r.to} ${r.from}`)) {
+      const k = (b) => c ? e.nodes[b].height : e.nodes[b].width, E = Math.min(8, k(r.from) / 4, k(r.to) / 4);
+      m = m.map((b) => c ? { x: b.x, y: b.y + E } : { x: b.x + E, y: b.y });
+    }
+    return { id: r.id, source: r.source, target: r.target, points: m, reversed: r.reversed };
+  }), C = w(S, A);
+  return { nodes: v, edges: I, width: C.x, height: C.y };
+}
+function U(o, l = "LR") {
+  if (o.length === 0) return "";
+  const i = (e) => Math.round(e * 10) / 10, f = o[0];
+  let h = `M${i(f.x)},${i(f.y)}`;
+  for (let e = 1; e < o.length; e++) {
+    const c = o[e - 1], s = o[e];
+    if (l === "LR") {
+      const t = (c.x + s.x) / 2;
+      h += ` C${i(t)},${i(c.y)} ${i(t)},${i(s.y)} ${i(s.x)},${i(s.y)}`;
+    } else {
+      const t = (c.y + s.y) / 2;
+      h += ` C${i(c.x)},${i(t)} ${i(s.x)},${i(t)} ${i(s.x)},${i(s.y)}`;
+    }
+  }
+  return h;
+}
+export {
+  _ as dagEdgeId,
+  U as dagEdgePath,
+  D as dagLayout
+};
+//# sourceMappingURL=dagLayout.js.map

package/dist/components/dataDisplay/dagView/dagLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dagLayout.js","sources":["../../../../src/components/dataDisplay/dagView/dagLayout.ts"],"sourcesContent":["// A layered (Sugiyama-style) layout for directed graphs: pure, synchronous and\n// deterministic, with no imports from Solid or the DOM, so the server and the\n// browser compute the same picture and a React port can copy the file as is.\n//\n// Steps: normalise the input; reverse the back edges of cycles; put each node\n// in a layer by the longest path from the sources; split edges that span\n// several layers with dummy points; order each layer by barycenter sweeps to\n// cut crossings; place nodes along the layer, pulled toward their neighbours\n// without overlapping; lay disconnected parts side by side; route each edge as\n// a list of points through its dummies.\n\n/** Which way the layers run: left to right, or top to bottom. */\nexport type DagDirection = \"LR\" | \"TB\";\n\nexport interface DagLayoutInputNode {\n  id: string;\n  width: number;\n  height: number;\n}\n\nexport interface DagLayoutInputEdge {\n  /** `source->target` unless given. */\n  id?: string | undefined;\n  source: string;\n  target: string;\n}\n\nexport interface DagLayoutInput {\n  nodes: readonly DagLayoutInputNode[];\n  edges: readonly DagLayoutInputEdge[];\n  /** \"LR\" by default. */\n  direction?: DagDirection | undefined;\n  /** The space between layers; 64 by default. */\n  rankGap?: number | undefined;\n  /** The space between nodes in a layer, and twice it between disconnected parts; 24 by default. */\n  nodeGap?: number | undefined;\n  /** Ordering sweeps (down and up count as one each); 8 by default. */\n  sweeps?: number | undefined;\n  /** Told what was dropped from the input: unknown ids, self-loops, duplicates. */\n  warn?: ((message: string) => void) | undefined;\n}\n\nexport interface DagPoint {\n  x: number;\n  y: number;\n}\n\nexport interface DagLayoutNode {\n  id: string;\n  /** The left edge. */\n  x: number;\n  /** The top edge. */\n  y: number;\n  width: number;\n  height: number;\n  /** The node's layer, 0 for the first. */\n  layer: number;\n  /** The node's place in its layer, 0 for the first (dummies included). */\n  order: number;\n}\n\nexport interface DagLayoutEdge {\n  id: string;\n  source: string;\n  target: string;\n  /** From the source's side to the target's side, through the layers between. */\n  points: DagPoint[];\n  /** The edge closes a cycle and was drawn against the layer direction. */\n  reversed: boolean;\n}\n\nexport interface DagLayoutResult {\n  /** Every node drawn, in input order. */\n  nodes: Map<string, DagLayoutNode>;\n  /** Every edge drawn, in input order. */\n  edges: DagLayoutEdge[];\n  width: number;\n  height: number;\n}\n\n/** The id an edge is drawn and highlighted by. */\nexport const dagEdgeId = (edge: DagLayoutInputEdge): string => edge.id ?? `${edge.source}->${edge.target}`;\n\ninterface Vertex {\n  /** Index into the real nodes, or -1 for a dummy. */\n  node: number;\n  /** Size along the layer axis (width in LR) and across it. */\n  rankSize: number;\n  crossSize: number;\n  layer: number;\n  /** Centre across the layer axis. */\n  cross: number;\n  preds: number[];\n  succs: number[];\n}\n\ninterface Segment {\n  /** The edge's index in the normalised list. */\n  edge: number;\n  /** Vertices from the layered source to the layered target, dummies between. */\n  chain: number[];\n}\n\n// ---- Steps 1-2: normalise, break cycles ----\n\ninterface Normalised {\n  nodes: DagLayoutInputNode[];\n  index: Map<string, number>;\n  edges: Array<{ id: string; source: string; target: string; from: number; to: number; reversed: boolean }>;\n}\n\nfunction normalise(input: DagLayoutInput): Normalised {\n  const warn = input.warn ?? (() => undefined);\n  const nodes: DagLayoutInputNode[] = [];\n  const index = new Map<string, number>();\n  for (const node of input.nodes) {\n    if (index.has(node.id)) {\n      warn(`node \"${node.id}\" is listed twice; the second is dropped.`);\n      continue;\n    }\n    index.set(node.id, nodes.length);\n    nodes.push(node);\n  }\n  const edges: Normalised[\"edges\"] = [];\n  const pairs = new Set<string>();\n  const ids = new Set<string>();\n  for (const edge of input.edges) {\n    const from = index.get(edge.source);\n    const to = index.get(edge.target);\n    if (from === undefined || to === undefined) {\n      const missing = from === undefined ? edge.source : edge.target;\n      warn(`edge ${edge.source} -> ${edge.target} names an unknown node \"${missing}\"; it is dropped.`);\n      continue;\n    }\n    if (from === to) {\n      warn(`edge ${edge.source} -> ${edge.target} is a self-loop; it is dropped.`);\n      continue;\n    }\n    const pair = `${from} ${to}`;\n    const id = dagEdgeId(edge);\n    if (pairs.has(pair) || ids.has(id)) {\n      warn(`edge ${edge.source} -> ${edge.target} is listed twice; the second is dropped.`);\n      continue;\n    }\n    pairs.add(pair);\n    ids.add(id);\n    edges.push({ id, source: edge.source, target: edge.target, from, to, reversed: false });\n  }\n\n  // A depth-first walk in input order: an edge to a node still on the stack\n  // closes a cycle, and is turned around so the rest can be layered.\n  const out: number[][] = nodes.map(() => []);\n  edges.forEach((edge, i) => out[edge.from].push(i));\n  const state = new Uint8Array(nodes.length); // 0 new, 1 on the stack, 2 done\n  for (let root = 0; root < nodes.length; root++) {\n    if (state[root]) continue;\n    const stack: Array<[number, number]> = [[root, 0]];\n    state[root] = 1;\n    while (stack.length) {\n      const top = stack[stack.length - 1];\n      const [v, next] = top;\n      const list = out[v];\n      if (next >= list.length) {\n        state[v] = 2;\n        stack.pop();\n        continue;\n      }\n      top[1] = next + 1;\n      const edge = edges[list[next]];\n      if (state[edge.to] === 1) edge.reversed = true;\n      else if (state[edge.to] === 0) {\n        state[edge.to] = 1;\n        stack.push([edge.to, 0]);\n      }\n    }\n  }\n  return { nodes, index, edges };\n}\n\n// ---- Step 3: layers by the longest path ----\n\nfunction assignLayers(count: number, arcs: Array<[number, number]>): number[] {\n  const out: number[][] = Array.from({ length: count }, () => []);\n  const inDegree = new Array<number>(count).fill(0);\n  for (const [u, v] of arcs) {\n    out[u].push(v);\n    inDegree[v]++;\n  }\n  const hasPred = inDegree.map((d) => d > 0);\n  const layer = new Array<number>(count).fill(0);\n  const order: number[] = [];\n  const queue: number[] = [];\n  for (let v = 0; v < count; v++) if (inDegree[v] === 0) queue.push(v);\n  for (let head = 0; head < queue.length; head++) {\n    const u = queue[head];\n    order.push(u);\n    for (const v of out[u]) {\n      layer[v] = Math.max(layer[v], layer[u] + 1);\n      if (--inDegree[v] === 0) queue.push(v);\n    }\n  }\n  // A source sits just before the first layer it feeds, not in layer 0 with a\n  // long edge across: a late input stays next to the step that reads it.\n  for (let i = order.length - 1; i >= 0; i--) {\n    const v = order[i];\n    const succs = out[v];\n    if (succs.length === 0 || hasPred[v]) continue;\n    layer[v] = Math.min(...succs.map((s) => layer[s])) - 1;\n  }\n  return layer;\n}\n\n// ---- Step 5: ordering ----\n\n/** Crossings between two neighbouring layers, by counting inversions. */\nfunction crossingsBetween(upper: number[], vertices: Vertex[], position: Int32Array): number {\n  const pairs: Array<[number, number]> = [];\n  for (const u of upper) for (const v of vertices[u].succs) pairs.push([position[u], position[v]]);\n  pairs.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n  // Inversions of the lower ends, with a Fenwick tree.\n  let size = 1;\n  for (const [, b] of pairs) size = Math.max(size, b + 2);\n  const tree = new Int32Array(size + 1);\n  let crossings = 0;\n  for (let i = pairs.length - 1; i >= 0; i--) {\n    const b = pairs[i][1];\n    for (let j = b; j > 0; j -= j & -j) crossings += tree[j];\n    for (let j = b + 1; j <= size; j += j & -j) tree[j]++;\n  }\n  return crossings;\n}\n\nfunction totalCrossings(layers: number[][], vertices: Vertex[], position: Int32Array): number {\n  let sum = 0;\n  for (let l = 0; l + 1 < layers.length; l++) sum += crossingsBetween(layers[l], vertices, position);\n  return sum;\n}\n\nfunction reorder(layer: number[], vertices: Vertex[], position: Int32Array, down: boolean): void {\n  const key = new Map<number, number>();\n  for (const v of layer) {\n    const neighbours = down ? vertices[v].preds : vertices[v].succs;\n    if (neighbours.length === 0) key.set(v, position[v]);\n    else key.set(v, neighbours.reduce((sum, n) => sum + position[n], 0) / neighbours.length);\n  }\n  // Ties keep the current order, so the result is the same on every run.\n  layer.sort((a, b) => key.get(a)! - key.get(b)! || position[a] - position[b]);\n  layer.forEach((v, i) => (position[v] = i));\n}\n\nfunction orderLayers(layers: number[][], vertices: Vertex[], sweeps: number): void {\n  const position = new Int32Array(vertices.length);\n  for (const layer of layers) layer.forEach((v, i) => (position[v] = i));\n  let best = layers.map((layer) => layer.slice());\n  let bestCrossings = totalCrossings(layers, vertices, position);\n  let stale = 0;\n  for (let sweep = 0; sweep < sweeps && bestCrossings > 0; sweep++) {\n    const down = sweep % 2 === 0;\n    if (down) for (let l = 1; l < layers.length; l++) reorder(layers[l], vertices, position, true);\n    else for (let l = layers.length - 2; l >= 0; l--) reorder(layers[l], vertices, position, false);\n    const crossings = totalCrossings(layers, vertices, position);\n    if (crossings < bestCrossings) {\n      bestCrossings = crossings;\n      best = layers.map((layer) => layer.slice());\n      stale = 0;\n    } else if (++stale >= 2) break;\n  }\n  best.forEach((layer, l) => (layers[l] = layer));\n}\n\n// ---- Step 6: positions across the layer ----\n\n/**\n * Centres as close to `desired` as they can get, in order, at least `gap`\n * apart: an isotonic regression by pooling adjacent violators.\n */\nfunction place(desired: number[], gaps: number[], weights: number[]): number[] {\n  // Shift out the gaps, so the constraint becomes \"non-decreasing\".\n  const offset: number[] = [0];\n  for (let i = 1; i < desired.length; i++) offset.push(offset[i - 1] + gaps[i - 1]);\n  const blocks: Array<{ value: number; weight: number; count: number }> = [];\n  desired.forEach((d, i) => {\n    let block = { value: d - offset[i], weight: weights[i], count: 1 };\n    while (blocks.length && blocks[blocks.length - 1].value > block.value) {\n      const last = blocks.pop()!;\n      const weight = last.weight + block.weight;\n      block = {\n        value: (last.value * last.weight + block.value * block.weight) / weight,\n        weight,\n        count: last.count + block.count,\n      };\n    }\n    blocks.push(block);\n  });\n  const result: number[] = [];\n  for (const block of blocks) for (let k = 0; k < block.count; k++) result.push(block.value + offset[result.length]);\n  return result;\n}\n\nfunction assignCross(layers: number[][], vertices: Vertex[], nodeGap: number): void {\n  const gapBetween = (a: number, b: number): number => {\n    const va = vertices[a];\n    const vb = vertices[b];\n    // Dummies keep less room between each other than real nodes do.\n    const gap = va.node < 0 && vb.node < 0 ? nodeGap / 2 : nodeGap;\n    return va.crossSize / 2 + gap + vb.crossSize / 2;\n  };\n  for (const layer of layers) {\n    let at = 0;\n    layer.forEach((v, i) => {\n      if (i > 0) at += gapBetween(layer[i - 1], v);\n      vertices[v].cross = at;\n    });\n  }\n  // Pull toward the neighbours: down from the layer before, up from the layer\n  // after, and once more from both sides. Dummies weigh more, so long edges run straight.\n  const passes: Array<\"down\" | \"up\" | \"both\"> = [\"down\", \"up\", \"down\", \"up\", \"both\", \"both\"];\n  for (const pass of passes) {\n    const range = pass === \"up\" ? layers.map((_, l) => layers.length - 1 - l) : layers.map((_, l) => l);\n    for (const l of range) {\n      const layer = layers[l];\n      if (layer.length === 0) continue;\n      const desired = layer.map((v) => {\n        const vertex = vertices[v];\n        const neighbours =\n          pass === \"down\" ? vertex.preds : pass === \"up\" ? vertex.succs : [...vertex.preds, ...vertex.succs];\n        if (neighbours.length === 0) return vertex.cross;\n        return neighbours.reduce((sum, n) => sum + vertices[n].cross, 0) / neighbours.length;\n      });\n      const gaps = layer.slice(1).map((v, i) => gapBetween(layer[i], v));\n      const weights = layer.map((v) => (vertices[v].node < 0 ? 2 : 1));\n      place(desired, gaps, weights).forEach((cross, i) => (vertices[layer[i]].cross = cross));\n    }\n  }\n}\n\n// ---- Steps 4, 7, 8: one connected part, then all of them ----\n\ninterface PartLayout {\n  /** Real node index → its rectangle in part coordinates (rank, cross). */\n  nodes: Map<number, { rank: number; cross: number; layer: number; order: number }>;\n  /** Edge index → points in part coordinates (rank, cross). */\n  edges: Map<number, Array<{ rank: number; cross: number }>>;\n  rankExtent: number;\n  crossExtent: number;\n}\n\nfunction layoutPart(\n  members: number[],\n  graph: Normalised,\n  edgeList: number[],\n  rankSizeOf: (n: number) => number,\n  crossSizeOf: (n: number) => number,\n  rankGap: number,\n  nodeGap: number,\n  sweeps: number\n): PartLayout {\n  const local = new Map<number, number>();\n  members.forEach((n, i) => local.set(n, i));\n  const arcs: Array<[number, number]> = edgeList.map((e) => {\n    const edge = graph.edges[e];\n    const from = local.get(edge.from)!;\n    const to = local.get(edge.to)!;\n    return edge.reversed ? [to, from] : [from, to];\n  });\n  const layerOf = assignLayers(members.length, arcs);\n\n  const vertices: Vertex[] = members.map((n, i) => ({\n    node: n,\n    rankSize: rankSizeOf(n),\n    crossSize: crossSizeOf(n),\n    layer: layerOf[i],\n    cross: 0,\n    preds: [],\n    succs: [],\n  }));\n  const segments: Segment[] = edgeList.map((e, k) => {\n    const [from, to] = arcs[k];\n    const chain = [from];\n    let previous = from;\n    for (let l = vertices[from].layer + 1; l < vertices[to].layer; l++) {\n      const dummy = vertices.length;\n      vertices.push({ node: -1, rankSize: 0, crossSize: 0, layer: l, cross: 0, preds: [], succs: [] });\n      vertices[previous].succs.push(dummy);\n      vertices[dummy].preds.push(previous);\n      chain.push(dummy);\n      previous = dummy;\n    }\n    vertices[previous].succs.push(to);\n    vertices[to].preds.push(previous);\n    chain.push(to);\n    return { edge: e, chain };\n  });\n\n  // Each layer starts in the order of first appearance in a walk from the\n  // sources in input order; the sweeps take it from there.\n  const layerCount = vertices.reduce((max, v) => Math.max(max, v.layer + 1), 0);\n  const layers: number[][] = Array.from({ length: layerCount }, () => []);\n  vertices.forEach((v, i) => layers[v.layer].push(i));\n  orderLayers(layers, vertices, sweeps);\n  assignCross(layers, vertices, nodeGap);\n\n  // Layer bands along the rank axis: each as thick as its thickest node.\n  const thickness = layers.map((layer) => layer.reduce((max, v) => Math.max(max, vertices[v].rankSize), 0));\n  const start: number[] = [];\n  let rank = 0;\n  thickness.forEach((t, l) => {\n    start[l] = rank;\n    rank += t + (l + 1 < thickness.length ? rankGap : 0);\n  });\n\n  let minCross = Infinity;\n  let maxCross = -Infinity;\n  for (const v of vertices) {\n    minCross = Math.min(minCross, v.cross - v.crossSize / 2);\n    maxCross = Math.max(maxCross, v.cross + v.crossSize / 2);\n  }\n  const shift = Number.isFinite(minCross) ? -minCross : 0;\n\n  const nodes: PartLayout[\"nodes\"] = new Map();\n  layers.forEach((layer, l) =>\n    layer.forEach((v, order) => {\n      const vertex = vertices[v];\n      if (vertex.node < 0) return;\n      nodes.set(vertex.node, {\n        rank: start[l] + (thickness[l] - vertex.rankSize) / 2,\n        cross: vertex.cross - vertex.crossSize / 2 + shift,\n        layer: l,\n        order,\n      });\n    })\n  );\n\n  const edges: PartLayout[\"edges\"] = new Map();\n  for (const { edge, chain } of segments) {\n    const points: Array<{ rank: number; cross: number }> = [];\n    chain.forEach((v, i) => {\n      const vertex = vertices[v];\n      const l = vertex.layer;\n      const cross = vertex.cross + shift;\n      const bandStart = start[l] + (thickness[l] - vertex.rankSize) / 2;\n      if (i === 0) points.push({ rank: bandStart + vertex.rankSize, cross });\n      else if (i === chain.length - 1) points.push({ rank: bandStart, cross });\n      else {\n        // Straight through the band of a layer it skips, so it never cuts a node.\n        points.push({ rank: start[l], cross }, { rank: start[l] + thickness[l], cross });\n      }\n    });\n    if (graph.edges[edge].reversed) points.reverse();\n    edges.set(edge, points);\n  }\n\n  return {\n    nodes,\n    edges,\n    rankExtent: rank,\n    crossExtent: Number.isFinite(maxCross) ? maxCross - minCross : 0,\n  };\n}\n\n/**\n * Lays out a directed graph in layers. Never throws: unknown ids, self-loops\n * and duplicates are dropped (and reported through `warn`), and the edges that\n * close a cycle are drawn against the layer direction, marked `reversed`.\n */\nexport function dagLayout(input: DagLayoutInput): DagLayoutResult {\n  const direction = input.direction ?? \"LR\";\n  const rankGap = input.rankGap ?? 64;\n  const nodeGap = input.nodeGap ?? 24;\n  const sweeps = input.sweeps ?? 8;\n  const graph = normalise(input);\n  const lr = direction === \"LR\";\n  const rankSizeOf = (n: number): number => (lr ? graph.nodes[n].width : graph.nodes[n].height);\n  const crossSizeOf = (n: number): number => (lr ? graph.nodes[n].height : graph.nodes[n].width);\n\n  // Connected parts (edges taken both ways), in the order of their first node.\n  const parent = graph.nodes.map((_, i) => i);\n  const find = (v: number): number => {\n    while (parent[v] !== v) {\n      parent[v] = parent[parent[v]]!;\n      v = parent[v]!;\n    }\n    return v;\n  };\n  for (const edge of graph.edges) {\n    const a = find(edge.from);\n    const b = find(edge.to);\n    if (a !== b) parent[Math.max(a, b)] = Math.min(a, b);\n  }\n  const parts = new Map<number, { members: number[]; edges: number[] }>();\n  graph.nodes.forEach((_, i) => {\n    const root = find(i);\n    if (!parts.has(root)) parts.set(root, { members: [], edges: [] });\n    parts.get(root)!.members.push(i);\n  });\n  graph.edges.forEach((edge, e) => parts.get(find(edge.from))!.edges.push(e));\n\n  const placedNodes = new Map<number, DagLayoutNode>();\n  const placedEdges = new Map<number, DagPoint[]>();\n  const toPoint = (rank: number, cross: number): DagPoint => (lr ? { x: rank, y: cross } : { x: cross, y: rank });\n  let crossAt = 0;\n  let rankExtent = 0;\n  for (const part of parts.values()) {\n    const laid = layoutPart(part.members, graph, part.edges, rankSizeOf, crossSizeOf, rankGap, nodeGap, sweeps);\n    for (const [n, p] of laid.nodes) {\n      const node = graph.nodes[n];\n      placedNodes.set(n, {\n        id: node.id,\n        ...toPoint(p.rank, p.cross + crossAt),\n        width: node.width,\n        height: node.height,\n        layer: p.layer,\n        order: p.order,\n      });\n    }\n    for (const [e, points] of laid.edges) {\n      placedEdges.set(\n        e,\n        points.map((p) => toPoint(p.rank, p.cross + crossAt))\n      );\n    }\n    rankExtent = Math.max(rankExtent, laid.rankExtent);\n    crossAt += laid.crossExtent + nodeGap * 2;\n  }\n  const crossExtent = Math.max(0, crossAt - nodeGap * 2);\n\n  const nodes = new Map<string, DagLayoutNode>();\n  graph.nodes.forEach((node, i) => nodes.set(node.id, placedNodes.get(i)!));\n  // A two-cycle (a->b and b->a) would draw both edges on one curve: the\n  // turned-around one moves across, still ending on both nodes.\n  const pairs = new Set(graph.edges.map((edge) => `${edge.from} ${edge.to}`));\n  const edges = graph.edges.map((edge, e) => {\n    let points = placedEdges.get(e)!;\n    if (edge.reversed && pairs.has(`${edge.to} ${edge.from}`)) {\n      const across = (n: number): number => (lr ? graph.nodes[n].height : graph.nodes[n].width);\n      const offset = Math.min(8, across(edge.from) / 4, across(edge.to) / 4);\n      points = points.map((p) => (lr ? { x: p.x, y: p.y + offset } : { x: p.x + offset, y: p.y }));\n    }\n    return { id: edge.id, source: edge.source, target: edge.target, points, reversed: edge.reversed };\n  });\n  const extent = toPoint(rankExtent, crossExtent);\n  return { nodes, edges, width: extent.x, height: extent.y };\n}\n\n/**\n * An SVG path through an edge's points: a smooth S-curve between layers, a\n * straight line through the layers it skips.\n */\nexport function dagEdgePath(points: readonly DagPoint[], direction: DagDirection = \"LR\"): string {\n  if (points.length === 0) return \"\";\n  const round = (n: number): number => Math.round(n * 10) / 10;\n  const first = points[0];\n  let d = `M${round(first.x)},${round(first.y)}`;\n  for (let i = 1; i < points.length; i++) {\n    const a = points[i - 1];\n    const b = points[i];\n    if (direction === \"LR\") {\n      const mid = (a.x + b.x) / 2;\n      d += ` C${round(mid)},${round(a.y)} ${round(mid)},${round(b.y)} ${round(b.x)},${round(b.y)}`;\n    } else {\n      const mid = (a.y + b.y) / 2;\n      d += ` C${round(a.x)},${round(mid)} ${round(b.x)},${round(mid)} ${round(b.x)},${round(b.y)}`;\n    }\n  }\n  return d;\n}\n"],"names":["dagEdgeId","edge","_a","normalise","input","warn","nodes","index","node","edges","pairs","ids","from","to","missing","pair","id","out","i","state","root","stack","top","v","next","list","assignLayers","count","arcs","inDegree","u","hasPred","d","layer","order","queue","head","succs","s","crossingsBetween","upper","vertices","position","a","b","size","tree","crossings","j","totalCrossings","layers","sum","l","reorder","down","key","neighbours","n","orderLayers","sweeps","best","bestCrossings","stale","sweep","place","desired","gaps","weights","offset","blocks","block","last","weight","result","k","assignCross","nodeGap","gapBetween","va","vb","gap","at","passes","pass","range","_","vertex","cross","layoutPart","members","graph","edgeList","rankSizeOf","crossSizeOf","rankGap","local","e","layerOf","segments","chain","previous","dummy","layerCount","max","thickness","start","rank","t","minCross","maxCross","shift","points","bandStart","dagLayout","_b","_c","_d","direction","lr","parent","find","parts","placedNodes","placedEdges","toPoint","crossAt","rankExtent","part","laid","p","crossExtent","across","extent","dagEdgePath","round","first","mid"],"mappings":"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"}

package/dist/components/dataDisplay/dagView/dagView.d.ts

@@ -0,0 +1,157 @@
+import React from "react";
+import { type DagDirection, type DagLayoutInput, type DagLayoutResult } from "./dagLayout";
+import { type Viewport } from "./panZoom";
+/** A node's status: a built-in one, coloured by the theme, or any word of the app's, styled by `[data-status]`. */
+export type DagViewStatus = "idle" | "pending" | "running" | "success" | "warning" | "error" | "skipped" | (string & {});
+export interface DagViewNode<T = unknown> {
+    /** Unique among the nodes; edges name nodes by it. */
+    id: string;
+    /** What the default node shows, and its accessible name; the id unless given. */
+    label?: React.ReactNode;
+    /** Colours the node's accent from the theme. */
+    status?: DagViewStatus | undefined;
+    /** The node's accent colour, over its status colour: any CSS colour. */
+    accent?: string | undefined;
+    /** The node's width in pixels; `nodeWidth` unless given. */
+    width?: number | undefined;
+    /** The node's height in pixels; `nodeHeight` unless given. */
+    height?: number | undefined;
+    /** Anything of the app's, handed back to `renderNode` and `onNodeClick`. */
+    data?: T;
+    /** Shown, focusable, but not selectable. */
+    disabled?: boolean | undefined;
+}
+export interface DagViewEdge {
+    /** `source->target` unless given. */
+    id?: string | undefined;
+    /** The id of the node the edge starts from: the one depended on. */
+    source: string;
+    /** The id of the node the edge points to: the one that depends on `source`. */
+    target: string;
+}
+/** A node's state for `renderNode`: a snapshot of the render it is passed to. */
+export interface DagViewNodeState {
+    readonly selected: boolean;
+    /** Next to the selected node: "upstream" feeds it, "downstream" depends on it. */
+    readonly related: "upstream" | "downstream" | null;
+    /** Set apart from the selected node and its neighbours, with `dimUnrelated`. */
+    readonly dimmed: boolean;
+    /** Has keyboard focus. */
+    readonly focused: boolean;
+}
+/** Where the graph is: moved by x, y (pixels) and scaled by zoom. */
+export type DagViewViewport = Viewport;
+/** Moves the view from outside; handed over by `apiRef` once the graph is in the page. */
+export interface DagViewApi {
+    /** Fits the whole graph in view. */
+    fitView(): void;
+    /** Zooms to `zoom` around the middle of the view. */
+    zoomTo(zoom: number): void;
+    /** Zooms by `factor` around the middle of the view. */
+    zoomBy(factor: number): void;
+    /** Moves the node with this id to the middle of the view. */
+    centerNode(id: string): void;
+}
+/** Texts for assistive technology and the zoom buttons, English by default. */
+export interface DagViewLabels {
+    /** What the graph is called as a widget: "dependency graph". */
+    roleDescription: string;
+    /** "Status", before a node's status word. */
+    status: string;
+    /** "Depends on", before the names of the nodes a node's edges come from. */
+    dependsOn: string;
+    /** "Required by", before the names of the nodes a node's edges go to. */
+    requiredBy: string;
+    /** Status words, shown on the default nodes and read out: { running: "Running", … }. */
+    statuses: Record<string, string>;
+    zoomIn: string;
+    zoomOut: string;
+    fitView: string;
+    /** The name of the group of zoom buttons. */
+    controls: string;
+}
+export interface DagViewProps<T = unknown> extends Omit<React.HTMLAttributes<HTMLDivElement>, "onClick"> {
+    /** What the graph shows: its accessible name. */
+    label: string;
+    /** The graph in words, for screen readers; it is there on the server too. */
+    summary?: string | undefined;
+    /** The nodes. A change of status, label or data alone does not lay the graph out again. */
+    nodes: readonly DagViewNode<T>[];
+    /** The edges, from the node depended on to the node that depends on it. */
+    edges: readonly DagViewEdge[];
+    /**
+     * Draws a node's content inside its box; the default shows a status dot,
+     * the label and the status word. `node` and `state` are a snapshot of the
+     * render they are passed to. Keep the content non-interactive where you can:
+     * a node is an ARIA option, whose content assistive technology may read as
+     * plain text, and a click in it also selects the node. Links and buttons in
+     * it are left out of the Tab order except in the node that is the graph's
+     * Tab stop.
+     */
+    renderNode?: ((node: DagViewNode<T>, state: DagViewNodeState) => React.ReactNode) | undefined;
+    /** Which way the layers run: "LR" (left to right, default) or "TB" (top to bottom). */
+    direction?: DagDirection | undefined;
+    /** A node's width in pixels, unless the node sets its own; 180 by default. */
+    nodeWidth?: number | undefined;
+    /** A node's height in pixels, unless the node sets its own; 56 by default. */
+    nodeHeight?: number | undefined;
+    /** The space between layers in pixels; 64 by default. */
+    rankGap?: number | undefined;
+    /** The space between nodes in a layer in pixels; 24 by default. */
+    nodeGap?: number | undefined;
+    /**
+     * Lays the graph out in place of the built-in layout, e.g. with dagre or elk. It must be
+     * synchronous. The layout re-runs when the graph's shape changes; swapping this function
+     * alone does not.
+     */
+    layout?: ((input: DagLayoutInput) => DagLayoutResult) | undefined;
+    /** The selected node's id (controlled); null selects nothing. */
+    selectedId?: string | null | undefined;
+    /** The node selected at first (uncontrolled). */
+    defaultSelectedId?: string | null | undefined;
+    /** A node was selected (its id) or the selection was cleared (null). */
+    onSelectedChange?: ((id: string | null) => void) | undefined;
+    /** A node was clicked, or chosen with Enter or Space. Not called for a disabled node. */
+    onNodeClick?: ((node: DagViewNode<T>, event: React.MouseEvent | React.KeyboardEvent) => void) | undefined;
+    /** Fades the nodes and edges that are not next to the selected node. */
+    dimUnrelated?: boolean | undefined;
+    /** Where the graph is (controlled). */
+    viewport?: DagViewViewport | undefined;
+    /** Where the graph is at first (uncontrolled); with `fit={false}` the page does not move after it loads. */
+    defaultViewport?: DagViewViewport | undefined;
+    /** The view moved or zoomed: at most once per frame during a gesture. */
+    onViewportChange?: ((viewport: DagViewViewport) => void) | undefined;
+    /** Fits the graph in view once it is in the page, and again when its nodes or edges change; true by default. */
+    fit?: boolean | undefined;
+    /** The smallest zoom; 0.1 by default. */
+    minZoom?: number | undefined;
+    /** The largest zoom; 2 by default. */
+    maxZoom?: number | undefined;
+    /** What a plain mouse wheel does: "zoom" (default), "pan", or "none" (the page scrolls). Ctrl+wheel and a trackpad pinch always zoom. */
+    wheel?: "zoom" | "pan" | "none" | undefined;
+    /** Shows the zoom in, zoom out and fit buttons; true by default. */
+    controls?: boolean | undefined;
+    /** Texts for assistive technology and the buttons, over the English defaults. */
+    labels?: Partial<DagViewLabels> | undefined;
+    /**
+     * The graph's height: a number of pixels or any CSS length; 480 by default,
+     * from the stylesheet, so a height in `style` works too. It fills the width.
+     */
+    height?: number | string | undefined;
+    /** Gets the functions that move the view from outside. */
+    apiRef?: ((api: DagViewApi) => void) | undefined;
+    /** Test id of the root `<div>`; `dag-view` unless given. */
+    "data-testid"?: string | undefined;
+}
+/**
+ * A directed graph of dependencies: nodes in layers, left to right or top to
+ * bottom, joined by arrows. A node is selected by a click or the keyboard, and
+ * the edges into and out of it light up; the view pans and zooms with a mouse,
+ * a trackpad, touch or the keyboard.
+ *
+ * `forwardRef` pins the props' generic to its default, so the export is
+ * re-typed over it: `T` is inferred from `nodes`, and `renderNode` and
+ * `onNodeClick` see `node.data` as `T`.
+ */
+export declare const DagView: <T = unknown>(props: DagViewProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
+export default DagView;