@jbrowse/bandage-core 9.1.0 → 9.3.0

package/dist/bubbles/bubbleHalos.js

@@ -1,14 +1,16 @@
 import {
+  SMALL_VARIANT_BP,
   WHOLE_FRACTION,
   bubbleHalos,
   coversGraph
-} from "../chunks/chunk-2AWUWGAD.js";
+} from "../chunks/chunk-ABOZYAN5.js";
 import "../chunks/chunk-XKWD2RY3.js";
 import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-2CVHXFK7.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-FYQWPEEY.js";
 export {
+  SMALL_VARIANT_BP,
   WHOLE_FRACTION,
   bubbleHalos,
   coversGraph

package/dist/bubbles/superbubbles.js

@@ -1,12 +1,11 @@
 import {
-  MAX_SUPERBUBBLES,
   graphBubbles,
   superbubblesFromGraph
-} from "../chunks/chunk-FUVI4WQP.js";
+} from "../chunks/chunk-ROYHPOYF.js";
 import "../chunks/chunk-VHW7FDHU.js";
-import "../chunks/chunk-2AWUWGAD.js";
-import "../chunks/chunk-GOZYKNQ2.js";
+import "../chunks/chunk-ABOZYAN5.js";
 import "../chunks/chunk-XKWD2RY3.js";
+import "../chunks/chunk-GOZYKNQ2.js";
 import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-HNQPEMYE.js";
 import "../chunks/chunk-ST2IBUAN.js";
@@ -15,7 +14,6 @@ import "../chunks/chunk-2CVHXFK7.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-FYQWPEEY.js";
 export {
-  MAX_SUPERBUBBLES,
   graphBubbles,
   superbubblesFromGraph
 };

package/dist/chunks/{chunk-GJMC3PGM.js → chunk-3FOOZ5VL.js}

@@ -92,24 +92,24 @@ function layoutLabels(m) {
   const onRows = m.drawnRowLabels.length > 0;
   const rowsTop = onRows ? Math.min(...m.drawnRowLabels.map((r) => r.y)) : Infinity;
   const halo = m.contigThickness * HALO_FACTOR;
-  const byBubble = byExtent(m.bubbleHalos, (h) => h.members);
+  const above = (h, gap) => {
+    const { x, y } = screen({
+      x: h.labelAt.x,
+      y: Math.min(h.labelAt.y, rowsTop)
+    });
+    const baseline = y - halo / 2 - gap;
+    return { x, y: onRows ? Math.max(baseline, TOPMOST_BASELINE) : baseline };
+  };
+  const byBubble = byExtent(
+    m.bubbleHalos.filter((h) => !h.tick),
+    (h) => h.members
+  );
   const bubbles = placeLabels(
-    byBubble.map((h) => {
-      const { x, y } = screen({
-        x: h.labelAt.x,
-        y: Math.min(h.labelAt.y, rowsTop)
-      });
-      const baseline = y - halo / 2 - 6;
-      return {
-        item: h,
-        x,
-        y: onRows ? Math.max(baseline, TOPMOST_BASELINE) : baseline,
-        text: h.label
-      };
-    }),
+    byBubble.map((h) => ({ item: h, ...above(h, 6), text: h.label })),
     frame,
     take
   );
+  const ticks = m.bubbleHalos.filter((h) => h.tick && !h.whole).map((h) => ({ item: h, ...above(h, 2) })).filter((t) => t.x >= 0 && t.x <= width && t.y >= 0 && t.y <= height);
   const genes = placeLabels(
     geneLabelCandidates(
       m.genePins,
@@ -162,6 +162,7 @@ function layoutLabels(m) {
   );
   return {
     bubbles,
+    ticks,
     genes,
     routes,
     sizes: [...deletionLabels, ...nodeLabels]

package/dist/chunks/{chunk-FFFQNQUI.js → chunk-A4MYLGKG.js}

@@ -1,7 +1,7 @@
 import {
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-2AWUWGAD.js → chunk-ABOZYAN5.js}

@@ -15,6 +15,7 @@ var WHOLE_FRACTION = 0.9;
 function coversGraph(members, nodes) {
   return members + 2 >= nodes || members >= WHOLE_FRACTION * nodes;
 }
+var SMALL_VARIANT_BP = 50;
 var NAMED_WALKS = 2;
 var MIN_CHIPPED_BP = 1e3;
 function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repeats = []) {
@@ -95,6 +96,8 @@ function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repe
       members: nodeIds.length,
       nodeIds,
       whole: coversGraph(nodeIds.length, graph.nodes.length),
+      // a partial bubble's lengths are a floor, so it may be no small variant
+      tick: !bubble.partial && bubble.longestAlleleLength < SMALL_VARIANT_BP,
       routes
     });
   }
@@ -110,5 +113,6 @@ function routeText(route, walkLabel) {
 export {
   WHOLE_FRACTION,
   coversGraph,
+  SMALL_VARIANT_BP,
   bubbleHalos
 };

package/dist/chunks/chunk-B4645SM2.js

@@ -0,0 +1,358 @@
+import {
+  ownStrand
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/foldVariants.ts
+function foldVariants(graph, belowBp) {
+  if (!(belowBp > 0) || graph.paths?.length || !graph.nodes.some((node) => isBackbone(node))) {
+    return graph;
+  }
+  const { nodes, edges } = graph;
+  const index = new Map(nodes.map((node, i) => [node.id, i]));
+  const sides = edges.map(forwardSides);
+  const links = linksAt(nodes.length, edges, sides, index);
+  const allele = alleleOf(nodes, edges, sides, index);
+  const members = groupBy(allele);
+  const kept = new Uint8Array(nodes.length);
+  const big = [];
+  for (const group of members.values()) {
+    if (alleleContent(group, nodes, links, allele) >= belowBp) {
+      for (const i of group) {
+        kept[i] = 1;
+      }
+      if (!isBackbone(nodes[group[0]])) {
+        big.push(group);
+      }
+    }
+  }
+  const { dist, pred } = distancesFromBackbone(nodes, links);
+  for (const group of big) {
+    for (const [i, side] of alleleEnds(group, nodes, links, allele)) {
+      let next = nearestOutside(i, side, links, allele, dist, nodes);
+      while (next !== void 0 && !kept[next]) {
+        kept[next] = 1;
+        next = isBackbone(nodes[next]) ? void 0 : pred[next];
+      }
+    }
+  }
+  const keptEdges = edges.filter((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a === void 0 || b === void 0) {
+      return false;
+    }
+    const skip = skipped(nodes[a], sides[k].from, nodes[b], sides[k].to);
+    return kept[a] && kept[b] && !(skip > 0 && skip < belowBp);
+  });
+  return mergeAlleleRuns({ ...graph, edges: keptEdges }, kept, allele);
+}
+function forwardSides(edge) {
+  return {
+    from: (edge.fromStrand ?? ownStrand(edge.from)) === "+" ? "e" : "s",
+    to: (edge.toStrand ?? ownStrand(edge.to)) === "+" ? "s" : "e"
+  };
+}
+function linksAt(count, edges, sides, index) {
+  const links = Array.from({ length: count }, () => []);
+  edges.forEach((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a !== void 0 && b !== void 0) {
+      links[a].push({ other: b, side: sides[k].from });
+      links[b].push({ other: a, side: sides[k].to });
+    }
+  });
+  return links;
+}
+function onOneSequence(a, b) {
+  const sa = a.stable;
+  const sb = b.stable;
+  return sa && sb?.refName === sa.refName && sb.rank === sa.rank ? [sa, sb] : void 0;
+}
+function continues(a, aSide, b, bSide) {
+  const pair = onOneSequence(a, b);
+  if (!pair || aSide === bSide) {
+    return false;
+  }
+  const [sa, sb] = pair;
+  return sa.start + a.length === sb.start || sb.start + b.length === sa.start;
+}
+function skipped(a, aSide, b, bSide) {
+  const pair = onOneSequence(a, b);
+  if (!pair || continues(a, aSide, b, bSide)) {
+    return 0;
+  }
+  const [sa, sb] = pair;
+  return Math.max(
+    sb.start - (sa.start + a.length),
+    sa.start - (sb.start + b.length)
+  );
+}
+function alleleOf(nodes, edges, sides, index) {
+  const parent = nodes.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  edges.forEach((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a !== void 0 && b !== void 0 && continues(nodes[a], sides[k].from, nodes[b], sides[k].to)) {
+      parent[find(a)] = find(b);
+    }
+  });
+  return nodes.map((_, i) => find(i));
+}
+function groupBy(allele) {
+  const groups = /* @__PURE__ */ new Map();
+  allele.forEach((root, i) => {
+    const group = groups.get(root);
+    if (group) {
+      group.push(i);
+    } else {
+      groups.set(root, [i]);
+    }
+  });
+  return groups;
+}
+function alleleContent(group, nodes, links, allele) {
+  if (isBackbone(nodes[group[0]])) {
+    return Infinity;
+  }
+  let length = 0;
+  let refName;
+  let lo = Infinity;
+  let hi = -Infinity;
+  let oneSequence = true;
+  for (const i of group) {
+    length += nodes[i].length;
+    for (const { other } of links[i]) {
+      const node = nodes[other];
+      if (allele[other] !== allele[i] && isBackbone(node)) {
+        refName ??= node.stable.refName;
+        oneSequence &&= node.stable.refName === refName;
+        lo = Math.min(lo, node.stable.start + node.length);
+        hi = Math.max(hi, node.stable.start);
+      }
+    }
+  }
+  return oneSequence && hi > lo ? Math.max(length, hi - lo) : length;
+}
+function alleleEnds(group, nodes, links, allele) {
+  const start = (i) => nodes[i].stable?.start ?? 0;
+  const end = (i) => start(i) + nodes[i].length;
+  let first = group[0];
+  let last = group[0];
+  for (const i of group) {
+    if (start(i) < start(first)) {
+      first = i;
+    }
+    if (end(i) > end(last)) {
+      last = i;
+    }
+  }
+  const ends = [];
+  for (const i of /* @__PURE__ */ new Set([first, last])) {
+    for (const side of ["s", "e"]) {
+      if (!links[i].some(
+        (link) => link.side === side && allele[link.other] === allele[i]
+      )) {
+        ends.push([i, side]);
+      }
+    }
+  }
+  return ends;
+}
+function nearestOutside(i, side, links, allele, dist, nodes) {
+  let best;
+  for (const link of links[i]) {
+    const j = link.other;
+    if (link.side === side && allele[j] !== allele[i] && Number.isFinite(dist[j]) && (best === void 0 || dist[j] < dist[best] || dist[j] === dist[best] && nodes[j].id < nodes[best].id)) {
+      best = j;
+    }
+  }
+  return best;
+}
+function distancesFromBackbone(nodes, links) {
+  const dist = new Float64Array(nodes.length).fill(Infinity);
+  const pred = new Int32Array(nodes.length).fill(-1);
+  const heap = new MinHeap(
+    ([da, a], [db, b]) => da - db || cmp(nodes[a].id, nodes[b].id)
+  );
+  nodes.forEach((node, i) => {
+    if (isBackbone(node)) {
+      dist[i] = 0;
+      heap.push([0, i]);
+    }
+  });
+  for (let top = heap.pop(); top !== void 0; top = heap.pop()) {
+    const [d0, i] = top;
+    if (d0 > dist[i]) {
+      continue;
+    }
+    for (const { other } of links[i]) {
+      if (isBackbone(nodes[other])) {
+        continue;
+      }
+      const d = d0 + nodes[other].length;
+      if (d < dist[other]) {
+        dist[other] = d;
+        pred[other] = i;
+        heap.push([d, other]);
+      } else if (d === dist[other] && cmp(nodes[i].id, nodes[pred[other]].id) < 0) {
+        pred[other] = i;
+      }
+    }
+  }
+  return { dist, pred: Array.from(pred, (p) => p < 0 ? void 0 : p) };
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var MinHeap = class {
+  constructor(order) {
+    this.order = order;
+    this.items = [];
+  }
+  push(item) {
+    const { items } = this;
+    items.push(item);
+    let i = items.length - 1;
+    while (i > 0) {
+      const up = i - 1 >> 1;
+      if (this.order(items[i], items[up]) >= 0) {
+        break;
+      }
+      ;
+      [items[i], items[up]] = [items[up], items[i]];
+      i = up;
+    }
+  }
+  pop() {
+    const { items } = this;
+    const top = items[0];
+    const last = items.pop();
+    if (items.length > 0 && last !== void 0) {
+      items[0] = last;
+      let i = 0;
+      for (; ; ) {
+        const l = 2 * i + 1;
+        const r = l + 1;
+        let m = i;
+        if (l < items.length && this.order(items[l], items[m]) < 0) {
+          m = l;
+        }
+        if (r < items.length && this.order(items[r], items[m]) < 0) {
+          m = r;
+        }
+        if (m === i) {
+          break;
+        }
+        ;
+        [items[i], items[m]] = [items[m], items[i]];
+        i = m;
+      }
+    }
+    return top;
+  }
+};
+function mergeAlleleRuns(graph, kept, allele) {
+  const { nodes, edges } = graph;
+  const index = new Map(nodes.map((node, i) => [node.id, i]));
+  const sides = edges.map(forwardSides);
+  const ends = edges.map((edge, k) => [
+    { i: index.get(edge.from), side: sides[k].from },
+    { i: index.get(edge.to), side: sides[k].to }
+  ]);
+  const degree = /* @__PURE__ */ new Map();
+  const sideKey = (i, side) => `${i}${side}`;
+  for (const pair of ends) {
+    for (const { i, side } of pair) {
+      degree.set(sideKey(i, side), (degree.get(sideKey(i, side)) ?? 0) + 1);
+    }
+  }
+  const next = /* @__PURE__ */ new Map();
+  const hasPrev = /* @__PURE__ */ new Set();
+  const internal = /* @__PURE__ */ new Set();
+  ends.forEach(([a, b], k) => {
+    if (a.i !== b.i && allele[a.i] === allele[b.i] && continues(nodes[a.i], a.side, nodes[b.i], b.side) && degree.get(sideKey(a.i, a.side)) === 1 && degree.get(sideKey(b.i, b.side)) === 1) {
+      const [left, right] = nodes[a.i].stable.start < nodes[b.i].stable.start ? [a, b] : [b, a];
+      next.set(left.i, { j: right.i, out: left.side, in: right.side });
+      hasPrev.add(right.i);
+      internal.add(k);
+    }
+  });
+  const headOf = nodes.map((_, i) => i);
+  const outer = /* @__PURE__ */ new Map();
+  const merged = /* @__PURE__ */ new Map();
+  nodes.forEach((_, i) => {
+    if (!kept[i] || hasPrev.has(i) || !next.has(i)) {
+      return;
+    }
+    const run = [i];
+    let into = flip(next.get(i).out);
+    outer.set(sideKey(i, into), "s");
+    for (let step = next.get(i); step; step = next.get(step.j)) {
+      run.push(step.j);
+      into = step.in;
+    }
+    outer.set(sideKey(run.at(-1), flip(into)), "e");
+    for (const j of run) {
+      headOf[j] = i;
+    }
+    merged.set(i, mergedNode(run.map((j) => nodes[j])));
+  });
+  const endpoint = ({ i, side }) => ({
+    id: nodes[headOf[i]].id,
+    side: headOf[i] === i && !merged.has(i) ? side : outer.get(sideKey(i, side))
+  });
+  return {
+    ...graph,
+    nodes: nodes.flatMap(
+      (node, i) => !kept[i] || headOf[i] !== i ? [] : [merged.get(i) ?? node]
+    ),
+    edges: edges.flatMap((edge, k) => {
+      if (internal.has(k)) {
+        return [];
+      }
+      const [a, b] = ends[k];
+      if (!merged.has(headOf[a.i]) && !merged.has(headOf[b.i])) {
+        return [edge];
+      }
+      const from = endpoint(a);
+      const to = endpoint(b);
+      return [
+        {
+          ...edge,
+          from: from.id,
+          to: to.id,
+          fromStrand: from.side === "e" ? "+" : "-",
+          toStrand: to.side === "s" ? "+" : "-"
+        }
+      ];
+    })
+  };
+}
+function flip(side) {
+  return side === "s" ? "e" : "s";
+}
+function mergedNode(run) {
+  const { samples: firstSamples, ...first } = run[0];
+  const length = run.reduce((sum, node) => sum + node.length, 0);
+  const depth = length > 0 ? run.reduce((sum, node) => sum + node.depth * node.length, 0) / length : first.depth;
+  const samples = run.every((node) => node.samples) ? run.reduce(
+    (common, node) => common.filter((s) => node.samples.includes(s)),
+    firstSamples
+  ) : void 0;
+  return samples ? { ...first, length, depth, samples } : { ...first, length, depth };
+}
+
+export {
+  foldVariants
+};

package/dist/chunks/chunk-B4YH42OP.js

@@ -0,0 +1,24 @@
+// src/gfa/writeRgfa.ts
+function writeRgfa(graph) {
+  const nameOf = new Map(graph.nodes.map((n) => [n.id, n.name]));
+  return [
+    "H	VN:Z:1.0",
+    ...graph.nodes.map(segmentLine),
+    ...graph.edges.map(
+      (e) => `L	${nameOf.get(e.from)}	${e.fromStrand ?? "+"}	${nameOf.get(e.to)}	${e.toStrand ?? "+"}	0M`
+    ),
+    ""
+  ].join("\n");
+}
+function segmentLine(node) {
+  const { stable } = node;
+  if (!stable) {
+    throw new Error(`segment ${node.name} has no stable coordinate to file`);
+  }
+  const samples = node.samples?.length ? `	SM:Z:${node.samples.join(",")}` : "";
+  return `S	${node.name}	*	LN:i:${node.length}	SN:Z:${stable.refName}	SO:i:${stable.start}	SR:i:${stable.rank}${samples}`;
+}
+
+export {
+  writeRgfa
+};

package/dist/chunks/{chunk-XLCTQHBE.js → chunk-BLRJ6IGK.js}

@@ -1,6 +1,6 @@
 import {
   ENGINE_DEFAULTS
-} from "./chunk-OOXIMURX.js";
+} from "./chunk-ZGRYFUXE.js";
 
 // src/figureSettings.ts
 var FIGURE_DEFAULTS = {

package/dist/chunks/{chunk-UID3QBWH.js → chunk-BTMPPLDF.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "9.1.0";
+var version = "9.3.0";
 
 export {
   version

package/dist/chunks/{chunk-RRZMMYBG.js → chunk-BV64PQ2C.js}

@@ -1,7 +1,7 @@
 import {
   engineKey,
   forceLayout
-} from "./chunk-OOXIMURX.js";
+} from "./chunk-ZGRYFUXE.js";
 
 // src/layout/forceCache.ts
 var DEFAULT_SIZE = 4;

package/dist/chunks/{chunk-W253V6RR.js → chunk-CVYDR2OP.js}

@@ -2,7 +2,7 @@ import {
   LIFT_BACKDROP_CSS,
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-MIW3HYPE.js → chunk-GFRPX6M2.js}

@@ -3,10 +3,10 @@ import {
   RAMP_GRADIENT_STOPS,
   rampHueCss,
   rampStops
-} from "./chunk-6ZNQJ5ZD.js";
+} from "./chunk-OXTR3BVF.js";
 import {
   REFERENCE_RAMP_ALT_CSS
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/chunks/{chunk-MBB7ATM6.js → chunk-LFKMASER.js}

@@ -1,7 +1,7 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-DPV2CUIE.js";
+} from "./chunk-XPT66H6H.js";
 import {
   pathOrigin
 } from "./chunk-ST2IBUAN.js";

package/dist/chunks/{chunk-6ZNQJ5ZD.js → chunk-OXTR3BVF.js}

@@ -1,6 +1,6 @@
 import {
   REFERENCE_RAMP_MAX_HUE
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 
 // src/referenceRampCss.ts
 function rampHueCss(hue) {

package/dist/chunks/{chunk-FUVI4WQP.js → chunk-ROYHPOYF.js}

@@ -3,15 +3,15 @@ import {
 } from "./chunk-VHW7FDHU.js";
 import {
   coversGraph
-} from "./chunk-2AWUWGAD.js";
+} from "./chunk-ABOZYAN5.js";
+import {
+  bubbleSegmentIds
+} from "./chunk-XKWD2RY3.js";
 import {
   bubblesFromGraph,
   walkIndexOf,
   walkRoutes
 } from "./chunk-GOZYKNQ2.js";
-import {
-  bubbleSegmentIds
-} from "./chunk-XKWD2RY3.js";
 import {
   SATURATED_PATH_COUNT
 } from "./chunk-FX4RDMDN.js";
@@ -23,7 +23,6 @@ import {
 } from "./chunk-FYQWPEEY.js";
 
 // src/bubbles/superbubbles.ts
-var MAX_SUPERBUBBLES = 50;
 function slotGraph(graph, index) {
   const slots = graph.nodes.length * 2;
   const seen = /* @__PURE__ */ new Set();
@@ -224,7 +223,9 @@ function superbubblesFromGraph(graph, span) {
     (j) => j !== i && !covers[j] && members[j].length > members[i].length && members[i].every((v) => holders.get(v).includes(j))
   );
   const placed = (f) => span !== void 0 || onReference(nodes[f.source >> 1], nodes[f.sink >> 1]);
-  const outermost = found.filter((f, i) => !covers[i] && placed(f) && !nested(f, i)).sort((a, b) => b.inside.length - a.inside.length).slice(0, MAX_SUPERBUBBLES);
+  const outermost = found.filter(
+    (f, i) => !covers[i] && placed(f) && !nested(f, i)
+  );
   const byId = new Map(nodes.map((n) => [n.id, n]));
   const walkIndex = walkIndexOf(graph);
   return outermost.map((f) => {
@@ -267,7 +268,6 @@ function graphBubbles(graph, span) {
 }
 
 export {
-  MAX_SUPERBUBBLES,
   superbubblesFromGraph,
   graphBubbles
 };