@smwb/ui-solid 0.12.1 → 0.14.0

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

@@ -0,0 +1,284 @@
+const _ = (n) => n.id ?? `${n.source}->${n.target}`;
+function G(n) {
+  const u = n.warn ?? (() => {
+  }), a = [], i = /* @__PURE__ */ new Map();
+  for (const e of n.nodes) {
+    if (i.has(e.id)) {
+      u(`node "${e.id}" is listed twice; the second is dropped.`);
+      continue;
+    }
+    i.set(e.id, a.length), a.push(e);
+  }
+  const l = [], s = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+  for (const e of n.edges) {
+    const h = i.get(e.source), g = i.get(e.target);
+    if (h === void 0 || g === void 0) {
+      const $ = h === void 0 ? e.source : e.target;
+      u(`edge ${e.source} -> ${e.target} names an unknown node "${$}"; it is dropped.`);
+      continue;
+    }
+    if (h === g) {
+      u(`edge ${e.source} -> ${e.target} is a self-loop; it is dropped.`);
+      continue;
+    }
+    const y = `${h} ${g}`, m = _(e);
+    if (s.has(y) || r.has(m)) {
+      u(`edge ${e.source} -> ${e.target} is listed twice; the second is dropped.`);
+      continue;
+    }
+    s.add(y), r.add(m), l.push({ id: m, source: e.source, target: e.target, from: h, to: g, reversed: !1 });
+  }
+  const o = a.map(() => []);
+  l.forEach((e, h) => o[e.from].push(h));
+  const t = new Uint8Array(a.length);
+  for (let e = 0; e < a.length; e++) {
+    if (t[e]) continue;
+    const h = [[e, 0]];
+    for (t[e] = 1; h.length; ) {
+      const g = h[h.length - 1], [y, m] = g, $ = o[y];
+      if (m >= $.length) {
+        t[y] = 2, h.pop();
+        continue;
+      }
+      g[1] = m + 1;
+      const k = l[$[m]];
+      t[k.to] === 1 ? k.reversed = !0 : t[k.to] === 0 && (t[k.to] = 1, h.push([k.to, 0]));
+    }
+  }
+  return { nodes: a, index: i, edges: l };
+}
+function N(n, u) {
+  const a = Array.from({ length: n }, () => []), i = new Array(n).fill(0);
+  for (const [t, e] of u)
+    a[t].push(e), i[e]++;
+  const l = i.map((t) => t > 0), s = new Array(n).fill(0), r = [], o = [];
+  for (let t = 0; t < n; t++) i[t] === 0 && o.push(t);
+  for (let t = 0; t < o.length; t++) {
+    const e = o[t];
+    r.push(e);
+    for (const h of a[e])
+      s[h] = Math.max(s[h], s[e] + 1), --i[h] === 0 && o.push(h);
+  }
+  for (let t = r.length - 1; t >= 0; t--) {
+    const e = r[t], h = a[e];
+    h.length === 0 || l[e] || (s[e] = Math.min(...h.map((g) => s[g])) - 1);
+  }
+  return s;
+}
+function O(n, u, a) {
+  const i = [];
+  for (const o of n) for (const t of u[o].succs) i.push([a[o], a[t]]);
+  i.sort((o, t) => o[0] - t[0] || o[1] - t[1]);
+  let l = 1;
+  for (const [, o] of i) l = Math.max(l, o + 2);
+  const s = new Int32Array(l + 1);
+  let r = 0;
+  for (let o = i.length - 1; o >= 0; o--) {
+    const t = i[o][1];
+    for (let e = t; e > 0; e -= e & -e) r += s[e];
+    for (let e = t + 1; e <= l; e += e & -e) s[e]++;
+  }
+  return r;
+}
+function P(n, u, a) {
+  let i = 0;
+  for (let l = 0; l + 1 < n.length; l++) i += O(n[l], u, a);
+  return i;
+}
+function R(n, u, a, i) {
+  const l = /* @__PURE__ */ new Map();
+  for (const s of n) {
+    const r = i ? u[s].preds : u[s].succs;
+    r.length === 0 ? l.set(s, a[s]) : l.set(s, r.reduce((o, t) => o + a[t], 0) / r.length);
+  }
+  n.sort((s, r) => l.get(s) - l.get(r) || a[s] - a[r]), n.forEach((s, r) => a[s] = r);
+}
+function j(n, u, a) {
+  const i = new Int32Array(u.length);
+  for (const o of n) o.forEach((t, e) => i[t] = e);
+  let l = n.map((o) => o.slice()), s = P(n, u, i), r = 0;
+  for (let o = 0; o < a && s > 0; o++) {
+    if (o % 2 === 0) for (let h = 1; h < n.length; h++) R(n[h], u, i, !0);
+    else for (let h = n.length - 2; h >= 0; h--) R(n[h], u, i, !1);
+    const e = P(n, u, i);
+    if (e < s)
+      s = e, l = n.map((h) => h.slice()), r = 0;
+    else if (++r >= 2) break;
+  }
+  l.forEach((o, t) => n[t] = o);
+}
+function B(n, u, a) {
+  const i = [0];
+  for (let r = 1; r < n.length; r++) i.push(i[r - 1] + u[r - 1]);
+  const l = [];
+  n.forEach((r, o) => {
+    let t = { value: r - i[o], weight: a[o], count: 1 };
+    for (; l.length && l[l.length - 1].value > t.value; ) {
+      const e = l.pop(), h = e.weight + t.weight;
+      t = {
+        value: (e.value * e.weight + t.value * t.weight) / h,
+        weight: h,
+        count: e.count + t.count
+      };
+    }
+    l.push(t);
+  });
+  const s = [];
+  for (const r of l) for (let o = 0; o < r.count; o++) s.push(r.value + i[s.length]);
+  return s;
+}
+function F(n, u, a) {
+  const i = (s, r) => {
+    const o = u[s], t = u[r], e = o.node < 0 && t.node < 0 ? a / 2 : a;
+    return o.crossSize / 2 + e + t.crossSize / 2;
+  };
+  for (const s of n) {
+    let r = 0;
+    s.forEach((o, t) => {
+      t > 0 && (r += i(s[t - 1], o)), u[o].cross = r;
+    });
+  }
+  const l = ["down", "up", "down", "up", "both", "both"];
+  for (const s of l) {
+    const r = s === "up" ? n.map((o, t) => n.length - 1 - t) : n.map((o, t) => t);
+    for (const o of r) {
+      const t = n[o];
+      if (t.length === 0) continue;
+      const e = t.map((y) => {
+        const m = u[y], $ = s === "down" ? m.preds : s === "up" ? m.succs : [...m.preds, ...m.succs];
+        return $.length === 0 ? m.cross : $.reduce((k, E) => k + u[E].cross, 0) / $.length;
+      }), h = t.slice(1).map((y, m) => i(t[m], y)), g = t.map((y) => u[y].node < 0 ? 2 : 1);
+      B(e, h, g).forEach((y, m) => u[t[m]].cross = y);
+    }
+  }
+}
+function q(n, u, a, i, l, s, r, o) {
+  const t = /* @__PURE__ */ new Map();
+  n.forEach((c, d) => t.set(c, d));
+  const e = a.map((c) => {
+    const d = u.edges[c], p = t.get(d.from), w = t.get(d.to);
+    return d.reversed ? [w, p] : [p, w];
+  }), h = N(n.length, e), g = n.map((c, d) => ({
+    node: c,
+    rankSize: i(c),
+    crossSize: l(c),
+    layer: h[d],
+    cross: 0,
+    preds: [],
+    succs: []
+  })), y = a.map((c, d) => {
+    const [p, w] = e[d], x = [p];
+    let M = p;
+    for (let S = g[p].layer + 1; S < g[w].layer; S++) {
+      const b = g.length;
+      g.push({ node: -1, rankSize: 0, crossSize: 0, layer: S, cross: 0, preds: [], succs: [] }), g[M].succs.push(b), g[b].preds.push(M), x.push(b), M = b;
+    }
+    return g[M].succs.push(w), g[w].preds.push(M), x.push(w), { edge: c, chain: x };
+  }), m = g.reduce((c, d) => Math.max(c, d.layer + 1), 0), $ = Array.from({ length: m }, () => []);
+  g.forEach((c, d) => $[c.layer].push(d)), j($, g, o), F($, g, r);
+  const k = $.map((c) => c.reduce((d, p) => Math.max(d, g[p].rankSize), 0)), E = [];
+  let A = 0;
+  k.forEach((c, d) => {
+    E[d] = A, A += c + (d + 1 < k.length ? s : 0);
+  });
+  let v = 1 / 0, z = -1 / 0;
+  for (const c of g)
+    v = Math.min(v, c.cross - c.crossSize / 2), z = Math.max(z, c.cross + c.crossSize / 2);
+  const L = Number.isFinite(v) ? -v : 0, C = /* @__PURE__ */ new Map();
+  $.forEach(
+    (c, d) => c.forEach((p, w) => {
+      const x = g[p];
+      x.node < 0 || C.set(x.node, {
+        rank: E[d] + (k[d] - x.rankSize) / 2,
+        cross: x.cross - x.crossSize / 2 + L,
+        layer: d,
+        order: w
+      });
+    })
+  );
+  const f = /* @__PURE__ */ new Map();
+  for (const { edge: c, chain: d } of y) {
+    const p = [];
+    d.forEach((w, x) => {
+      const M = g[w], S = M.layer, b = M.cross + L, I = E[S] + (k[S] - M.rankSize) / 2;
+      x === 0 ? p.push({ rank: I + M.rankSize, cross: b }) : x === d.length - 1 ? p.push({ rank: I, cross: b }) : p.push({ rank: E[S], cross: b }, { rank: E[S] + k[S], cross: b });
+    }), u.edges[c].reversed && p.reverse(), f.set(c, p);
+  }
+  return {
+    nodes: C,
+    edges: f,
+    rankExtent: A,
+    crossExtent: Number.isFinite(z) ? z - v : 0
+  };
+}
+function D(n) {
+  const u = n.direction ?? "LR", a = n.rankGap ?? 64, i = n.nodeGap ?? 24, l = n.sweeps ?? 8, s = G(n), r = u === "LR", o = (f) => r ? s.nodes[f].width : s.nodes[f].height, t = (f) => r ? s.nodes[f].height : s.nodes[f].width, e = s.nodes.map((f, c) => c), h = (f) => {
+    for (; e[f] !== f; )
+      e[f] = e[e[f]], f = e[f];
+    return f;
+  };
+  for (const f of s.edges) {
+    const c = h(f.from), d = h(f.to);
+    c !== d && (e[Math.max(c, d)] = Math.min(c, d));
+  }
+  const g = /* @__PURE__ */ new Map();
+  s.nodes.forEach((f, c) => {
+    const d = h(c);
+    g.has(d) || g.set(d, { members: [], edges: [] }), g.get(d).members.push(c);
+  }), s.edges.forEach((f, c) => g.get(h(f.from)).edges.push(c));
+  const y = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), $ = (f, c) => r ? { x: f, y: c } : { x: c, y: f };
+  let k = 0, E = 0;
+  for (const f of g.values()) {
+    const c = q(f.members, s, f.edges, o, t, a, i, l);
+    for (const [d, p] of c.nodes) {
+      const w = s.nodes[d];
+      y.set(d, {
+        id: w.id,
+        ...$(p.rank, p.cross + k),
+        width: w.width,
+        height: w.height,
+        layer: p.layer,
+        order: p.order
+      });
+    }
+    for (const [d, p] of c.edges)
+      m.set(
+        d,
+        p.map((w) => $(w.rank, w.cross + k))
+      );
+    E = Math.max(E, c.rankExtent), k += c.crossExtent + i * 2;
+  }
+  const A = Math.max(0, k - i * 2), v = /* @__PURE__ */ new Map();
+  s.nodes.forEach((f, c) => v.set(f.id, y.get(c)));
+  const z = new Set(s.edges.map((f) => `${f.from} ${f.to}`)), L = s.edges.map((f, c) => {
+    let d = m.get(c);
+    if (f.reversed && z.has(`${f.to} ${f.from}`)) {
+      const p = (x) => r ? s.nodes[x].height : s.nodes[x].width, w = Math.min(8, p(f.from) / 4, p(f.to) / 4);
+      d = d.map((x) => r ? { x: x.x, y: x.y + w } : { x: x.x + w, y: x.y });
+    }
+    return { id: f.id, source: f.source, target: f.target, points: d, reversed: f.reversed };
+  }), C = $(E, A);
+  return { nodes: v, edges: L, width: C.x, height: C.y };
+}
+function U(n, u = "LR") {
+  if (n.length === 0) return "";
+  const a = (s) => Math.round(s * 10) / 10, i = n[0];
+  let l = `M${a(i.x)},${a(i.y)}`;
+  for (let s = 1; s < n.length; s++) {
+    const r = n[s - 1], o = n[s];
+    if (u === "LR") {
+      const t = (r.x + o.x) / 2;
+      l += ` C${a(t)},${a(r.y)} ${a(t)},${a(o.y)} ${a(o.x)},${a(o.y)}`;
+    } else {
+      const t = (r.y + o.y) / 2;
+      l += ` C${a(r.x)},${a(t)} ${a(o.x)},${a(t)} ${a(o.x)},${a(o.y)}`;
+    }
+  }
+  return l;
+}
+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","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","reorder","down","key","neighbours","n","orderLayers","sweeps","best","bestCrossings","stale","sweep","l","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","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,151 @@
+import { type JSX } from "solid-js";
+import { type Ref } from "../../../primitives/mergeRefs";
+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?: JSX.Element;
+    /** 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`. Its fields are reactive: read them in JSX or an effect. */
+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<JSX.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. Called once per node: `node` and `state`
+     * are reactive, so read their fields in JSX. 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) => JSX.Element) | 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. */
+    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: MouseEvent | 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;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * 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.
+ */
+export declare function DagView<T = unknown>(props: DagViewProps<T>): JSX.Element;
+export default DagView;