visualproof 0.1.0 → 0.3.0

package/dist/web/src/bundles.js

@@ -0,0 +1,151 @@
+// Hierarchical edge bundling (CanvasSpec.md, "Edges"; Holten 2006).
+//
+// An edge's control points are the cluster origins on its tree path: up from one end to the
+// lowest common ancestor, and down to the other. Dependencies that travel the same way through
+// the hierarchy share control points and run together as a bundle.
+//
+// Ends are "units": what an edge end stands for on screen right now. A declaration is its own
+// unit, unless it sits in a cluster that is folded, or too small on screen to tell apart from its
+// siblings — then that cluster is the unit, and every edge into it is aggregated. Zoomed out the
+// overview shows which parts of the project depend on which; zoomed in, which declarations do.
+//
+// Position ids, shared with the positions texture: cluster c → c, node i → nc + i.
+const MAX_POINTS = 8;
+/** Each node's unit (a position id): itself, or the outermost cluster above it that is shut or
+ *  smaller than `minPx` on screen. */
+export function units(S, k, minPx) {
+    const cu = new Int32Array(S.nc).fill(-1);
+    for (let c = 0; c < S.nc; c++) {
+        const p = S.parent[c];
+        if (p >= 0 && cu[p] >= 0)
+            cu[c] = cu[p];
+        else if (S.rep[c] === c || S.curR[c] * k < minPx)
+            cu[c] = c;
+    }
+    const out = new Int32Array(S.n);
+    for (let i = 0; i < S.n; i++) {
+        const c = S.nodeCluster[i];
+        out[i] = c >= 0 && cu[c] >= 0 ? cu[c] : S.nc + i;
+    }
+    return out;
+}
+/** Edges between units, counted. `keep` filters nodes (hidden externals, say). */
+export function aggregate(g, unit, sites, keep) {
+    const counts = new Map();
+    const W = 1 << 22;
+    for (let u = 0; u < g.n; u++) {
+        if (!keep(u))
+            continue;
+        const a = unit[u];
+        for (let e = g.outStart[u]; e < g.outStart[u + 1]; e++) {
+            if (!(g.outSite[e] & sites))
+                continue;
+            const v = g.outDst[e];
+            if (!keep(v))
+                continue;
+            const b = unit[v];
+            if (a === b)
+                continue;
+            const key = a * W + b;
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        }
+    }
+    const n = counts.size;
+    const out = { n, a: new Int32Array(n), b: new Int32Array(n), w: new Int32Array(n) };
+    let k = 0;
+    for (const [key, w] of counts) {
+        const a = Math.floor(key / W);
+        out.a[k] = a;
+        out.b[k] = key - a * W;
+        out.w[k] = w;
+        k++;
+    }
+    return out;
+}
+/** Indices of the `cap` highest scores among `idx` (all of them if there are fewer), in no
+ *  particular order. Linear time: a selection, not a sort. */
+export function topK(idx, score, cap) {
+    const n = idx.length;
+    if (n <= cap)
+        return idx;
+    const s = new Float64Array(n);
+    for (let k = 0; k < n; k++)
+        s[k] = score[idx[k]];
+    // the (n - cap)-th smallest score is the threshold (Hoare's quickselect)
+    const want = n - cap;
+    let lo = 0, hi = n - 1;
+    while (lo < hi) {
+        const pivot = s[(lo + hi) >> 1];
+        let i = lo, j = hi;
+        while (i <= j) {
+            while (s[i] < pivot)
+                i++;
+            while (s[j] > pivot)
+                j--;
+            if (i <= j) {
+                const t = s[i];
+                s[i] = s[j];
+                s[j] = t;
+                i++;
+                j--;
+            }
+        }
+        if (want <= j)
+            hi = j;
+        else if (want >= i)
+            lo = i;
+        else
+            break;
+    }
+    const threshold = s[want];
+    const out = new Int32Array(cap);
+    let m = 0;
+    for (let k = 0; k < n && m < cap; k++)
+        if (score[idx[k]] > threshold)
+            out[m++] = idx[k];
+    for (let k = 0; k < n && m < cap; k++)
+        if (score[idx[k]] === threshold)
+            out[m++] = idx[k];
+    return out;
+}
+/** The control points from one end to the other through the tree, at most MAX_POINTS. */
+export function pathOf(S, a, b) {
+    const chain = (id) => {
+        const out = [id];
+        let c = id < S.nc ? S.parent[id] : S.nodeCluster[id - S.nc];
+        while (c >= 0) {
+            out.push(c);
+            c = S.parent[c];
+        }
+        return out;
+    };
+    return joinChains(chain(a), chain(b));
+}
+/** The control points between two ends, each given with its chain of ancestors up to the top level
+ *  (`ca[0]` and `cb[0]` the ends): up to the common ancestor, through it, down to the other end, at
+ *  most MAX_POINTS. A visitor's chain runs through its temporary clusters (ViewSpec decision 27). */
+export function joinChains(ca, cb) {
+    const inB = new Map();
+    cb.forEach((x, k) => inB.set(x, k));
+    let path;
+    const ka = ca.findIndex((x) => inB.has(x));
+    if (ka >= 0) {
+        const kb = inB.get(ca[ka]);
+        // up to the common ancestor, through it, down to the other end
+        path = [...ca.slice(0, ka + 1), ...cb.slice(0, kb).reverse()];
+        // an end that is the ancestor itself (an edge into its own cluster) is just a short hop
+        if (path.length < 2)
+            path = [ca[0], cb[0]];
+    }
+    else {
+        path = [...ca, ...[...cb].reverse()];
+    }
+    if (path.length > MAX_POINTS) {
+        const keep = [path[0]];
+        for (let k = 1; k < MAX_POINTS - 1; k++)
+            keep.push(path[Math.round((k * (path.length - 1)) / (MAX_POINTS - 1))]);
+        keep.push(path[path.length - 1]);
+        path = keep;
+    }
+    return path;
+}