@jbrowse/bandage-core 9.0.0 → 9.1.0

package/dist/bubbles/bubbleHalos.js

@@ -1,11 +1,15 @@
 import {
-  bubbleHalos
-} from "../chunks/chunk-ISEI2FH3.js";
-import "../chunks/chunk-WOO7QYKB.js";
-import "../chunks/chunk-MFKORG3F.js";
+  WHOLE_FRACTION,
+  bubbleHalos,
+  coversGraph
+} from "../chunks/chunk-2AWUWGAD.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 {
-  bubbleHalos
+  WHOLE_FRACTION,
+  bubbleHalos,
+  coversGraph
 };

package/dist/bubbles/bubbleLine.js

@@ -1,13 +1,15 @@
 import {
   SATURATED_PATH_COUNT,
   bubbleDescription,
+  bubbleKey,
   bubbleLabel,
   parseBubbleLine,
   sameBubble
-} from "../chunks/chunk-MFKORG3F.js";
+} from "../chunks/chunk-FX4RDMDN.js";
 export {
   SATURATED_PATH_COUNT,
   bubbleDescription,
+  bubbleKey,
   bubbleLabel,
   parseBubbleLine,
   sameBubble

package/dist/bubbles/bubblesFromGraph.js

@@ -1,10 +1,14 @@
 import {
-  bubblesFromGraph
-} from "../chunks/chunk-4S47XRYA.js";
-import "../chunks/chunk-MFKORG3F.js";
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
+} from "../chunks/chunk-GOZYKNQ2.js";
+import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-HNQPEMYE.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-FYQWPEEY.js";
 export {
-  bubblesFromGraph
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
 };

package/dist/bubbles/classifyBubble.js

@@ -4,8 +4,8 @@ import {
   bubbleSegmentIds,
   classifyBubble,
   formatBp
-} from "../chunks/chunk-WOO7QYKB.js";
-import "../chunks/chunk-MFKORG3F.js";
+} from "../chunks/chunk-XKWD2RY3.js";
+import "../chunks/chunk-FX4RDMDN.js";
 export {
   BUBBLE_KIND_COLORS,
   BUBBLE_KIND_NAMES,

package/dist/bubbles/superbubbles.js

@@ -0,0 +1,21 @@
+import {
+  MAX_SUPERBUBBLES,
+  graphBubbles,
+  superbubblesFromGraph
+} from "../chunks/chunk-FUVI4WQP.js";
+import "../chunks/chunk-VHW7FDHU.js";
+import "../chunks/chunk-2AWUWGAD.js";
+import "../chunks/chunk-GOZYKNQ2.js";
+import "../chunks/chunk-XKWD2RY3.js";
+import "../chunks/chunk-FX4RDMDN.js";
+import "../chunks/chunk-HNQPEMYE.js";
+import "../chunks/chunk-ST2IBUAN.js";
+import "../chunks/chunk-BPLIXMH7.js";
+import "../chunks/chunk-2CVHXFK7.js";
+import "../chunks/chunk-CPMHA4W5.js";
+import "../chunks/chunk-FYQWPEEY.js";
+export {
+  MAX_SUPERBUBBLES,
+  graphBubbles,
+  superbubblesFromGraph
+};

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

@@ -2,7 +2,7 @@ import {
   bubbleSegmentIds,
   classifyBubble,
   formatBp
-} from "./chunk-WOO7QYKB.js";
+} from "./chunk-XKWD2RY3.js";
 import {
   svgPath
 } from "./chunk-2CVHXFK7.js";
@@ -12,6 +12,9 @@ import {
 
 // src/bubbles/bubbleHalos.ts
 var WHOLE_FRACTION = 0.9;
+function coversGraph(members, nodes) {
+  return members + 2 >= nodes || members >= WHOLE_FRACTION * nodes;
+}
 var NAMED_WALKS = 2;
 var MIN_CHIPPED_BP = 1e3;
 function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repeats = []) {
@@ -24,13 +27,14 @@ function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repe
     let minY = Infinity;
     const nodeIds = [];
     const ends = [];
-    for (const name of bubbleSegmentIds(bubble)) {
+    const names = bubbleSegmentIds(bubble);
+    for (const [i, name] of names.entries()) {
       const node = byName.get(name);
       const line = node && positions[node.id];
       if (!node || !line?.length) {
         continue;
       }
-      if (isBackbone(node) && (node.stable.start < bubble.start || node.stable.start >= bubble.end)) {
+      if (bubble.key ? i === 0 || i === names.length - 1 : isBackbone(node) && (node.stable.start < bubble.start || node.stable.start >= bubble.end)) {
         ends.push(line[Math.floor(line.length / 2)]);
         continue;
       }
@@ -90,7 +94,7 @@ function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repe
       labelAt,
       members: nodeIds.length,
       nodeIds,
-      whole: nodeIds.length >= WHOLE_FRACTION * graph.nodes.length,
+      whole: coversGraph(nodeIds.length, graph.nodes.length),
       routes
     });
   }
@@ -104,5 +108,7 @@ function routeText(route, walkLabel) {
 }
 
 export {
+  WHOLE_FRACTION,
+  coversGraph,
   bubbleHalos
 };

package/dist/chunks/{chunk-YOYLCLIG.js → chunk-2ZT7ZF7A.js}

@@ -69,7 +69,10 @@ function drawTubeMapConnectors(ctx, connectors, bottom, {
   ctx.strokeStyle = `rgba(${ink},0.35)`;
   ctx.lineWidth = 0.5;
   ctx.stroke();
-  const lit = connectors.find((c) => c.node === highlightNode);
+  drawLitConnector(ctx, connectors, bottom, highlightNode);
+}
+function drawLitConnector(ctx, connectors, bottom, node) {
+  const lit = bottom > 0 && node ? connectors.find((c) => c.node === node) : void 0;
   if (lit) {
     ctx.beginPath();
     band(ctx, lit, bottom);
@@ -86,5 +89,6 @@ function drawTubeMapConnectors(ctx, connectors, bottom, {
 export {
   tubeMapConnectors,
   connectorAt,
-  drawTubeMapConnectors
+  drawTubeMapConnectors,
+  drawLitConnector
 };

package/dist/chunks/{chunk-TLQ7F2ZT.js → chunk-3TGUKQWQ.js}

@@ -16,7 +16,7 @@ import {
 } from "./chunk-MIW3HYPE.js";
 import {
   Canvas2DRenderer
-} from "./chunk-2WNBVB55.js";
+} from "./chunk-WBCOREDZ.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
@@ -42,10 +42,10 @@ import {
 } from "./chunk-HBEKUQO4.js";
 import {
   version
-} from "./chunk-AMS3MAFP.js";
+} from "./chunk-UID3QBWH.js";
 import {
   axisScaleOf
-} from "./chunk-TL4B342F.js";
+} from "./chunk-MXDQGA7A.js";
 import {
   walkRowLabels,
   walkRowsExtent
@@ -91,7 +91,7 @@ import {
   FIT_PADDING,
   drawingBounds,
   fitTransform
-} from "./chunk-5OIVTEF7.js";
+} from "./chunk-OOXIMURX.js";
 import {
   deletionDrawing,
   deletionEdges

package/dist/chunks/{chunk-LLP3FXPM.js → chunk-75HR3756.js}

@@ -192,24 +192,40 @@ function drawTubeMap(ctx, picture, frame) {
   }
   const stroke = frame.darkMode ? "#d0d0d0" : "#000000";
   const fill = frame.darkMode ? "rgba(40,40,40,0.4)" : "rgba(255,255,255,0.4)";
-  ctx.lineWidth = 2 * Math.max(0.25, Math.min(1, frame.yScale));
+  ctx.lineWidth = outlineWidth(frame);
   for (const node of picture.nodes) {
-    if (visible(node)) {
-      const lit = node.name === frame.highlightNode;
+    if (visible(node) && node.name !== frame.highlightNode) {
       ctx.beginPath();
       trace(ctx, node.commands, x, y);
-      const tint = lit ? void 0 : frame.nodeColors?.get(node.name);
-      ctx.fillStyle = lit ? "rgba(255,192,203,0.5)" : tint ?? fill;
-      ctx.strokeStyle = lit ? "#ff0000" : stroke;
+      const tint = frame.nodeColors?.get(node.name);
+      ctx.fillStyle = tint ?? fill;
+      ctx.strokeStyle = stroke;
       ctx.globalAlpha = tint ? NODE_TINT_ALPHA : 1;
       ctx.fill();
-      ctx.globalAlpha = lit ? 1 : outlineAlpha(x(node.x1) - x(node.x0));
+      ctx.globalAlpha = outlineAlpha(x(node.x1) - x(node.x0));
       ctx.stroke();
       ctx.globalAlpha = 1;
     }
   }
+  drawTubeMapHighlight(ctx, picture, frame);
   drawMismatches(ctx, picture.mismatches, frame);
 }
+function outlineWidth(frame) {
+  return 2 * Math.max(0.25, Math.min(1, frame.yScale));
+}
+function drawTubeMapHighlight(ctx, picture, frame) {
+  const node = frame.highlightNode ? picture.nodes.find((n) => n.name === frame.highlightNode) : void 0;
+  if (node) {
+    ctx.beginPath();
+    trace(ctx, node.commands, frame.x, frame.y);
+    ctx.globalAlpha = 1;
+    ctx.lineWidth = outlineWidth(frame);
+    ctx.fillStyle = "rgba(255,192,203,0.5)";
+    ctx.strokeStyle = "#ff0000";
+    ctx.fill();
+    ctx.stroke();
+  }
+}
 var MISMATCH_FONT_PX = 12;
 var MIN_MISMATCH_FONT_PX = 6;
 function mismatchesLegible(yScale) {
@@ -273,6 +289,7 @@ export {
   trackColors,
   tubeMapPicture,
   drawTubeMap,
+  drawTubeMapHighlight,
   mismatchesLegible,
   mismatchOnScreen,
   tubeMapTrackAt,

package/dist/chunks/chunk-FUVI4WQP.js

@@ -0,0 +1,273 @@
+import {
+  bubbleSubgraph
+} from "./chunk-VHW7FDHU.js";
+import {
+  coversGraph
+} from "./chunk-2AWUWGAD.js";
+import {
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
+} from "./chunk-GOZYKNQ2.js";
+import {
+  bubbleSegmentIds
+} from "./chunk-XKWD2RY3.js";
+import {
+  SATURATED_PATH_COUNT
+} from "./chunk-FX4RDMDN.js";
+import {
+  strandSides
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} 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();
+  const pairs = [];
+  const degree = new Int32Array(slots);
+  for (const e of graph.edges) {
+    const a = index.get(e.from);
+    const b = index.get(e.to);
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    const sides = strandSides(e);
+    const ka = a * 2 + (sides.from === "end" ? 1 : 0);
+    const kb = b * 2 + (sides.to === "end" ? 1 : 0);
+    const id = Math.min(ka, kb) * slots + Math.max(ka, kb);
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    pairs.push(ka, kb);
+    degree[ka]++;
+    if (ka !== kb) {
+      degree[kb]++;
+    }
+  }
+  const offset = new Int32Array(slots + 1);
+  for (let k = 0; k < slots; k++) {
+    offset[k + 1] = offset[k] + degree[k];
+  }
+  const next = new Int32Array(offset[slots]);
+  const fill = offset.slice(0, slots);
+  for (let i = 0; i < pairs.length; i += 2) {
+    const ka = pairs[i];
+    const kb = pairs[i + 1];
+    next[fill[ka]++] = kb;
+    if (ka !== kb) {
+      next[fill[kb]++] = ka;
+    }
+  }
+  return { offset, next };
+}
+function searcher(nodes, offset, next) {
+  const visited = new Int32Array(nodes);
+  const pending = new Uint8Array(nodes * 2);
+  const stack = new Int32Array(nodes * 2);
+  const inside = new Int32Array(nodes);
+  const touched = [];
+  let stamp = 0;
+  return (start) => {
+    const s = start >> 1;
+    stamp++;
+    touched.length = 0;
+    let open = 0;
+    let top = 0;
+    let count = 0;
+    let found;
+    const expect = (k) => {
+      if (!pending[k]) {
+        pending[k] = 1;
+        open++;
+        touched.push(k);
+      }
+    };
+    expect(start);
+    stack[top++] = start;
+    search: while (top > 0) {
+      const k = stack[--top];
+      const v = k >> 1;
+      visited[v] = stamp;
+      if (v !== s) {
+        inside[count++] = k;
+      }
+      if (pending[k]) {
+        pending[k] = 0;
+        open--;
+      }
+      if (offset[k] === offset[k + 1]) {
+        break;
+      }
+      for (let p = offset[k]; p < offset[k + 1]; p++) {
+        const entry = next[p];
+        const u = entry >> 1;
+        if (u === s) {
+          break search;
+        }
+        expect(entry ^ 1);
+        if (visited[u] === stamp) {
+          continue;
+        }
+        let ready = true;
+        for (let q = offset[entry]; q < offset[entry + 1]; q++) {
+          if (visited[next[q] >> 1] !== stamp) {
+            ready = false;
+            break;
+          }
+        }
+        if (ready) {
+          stack[top++] = entry ^ 1;
+        }
+      }
+      if (top === 1 && open === 1) {
+        if (count > 0) {
+          found = {
+            source: start,
+            sink: stack[0],
+            inside: inside.slice(0, count)
+          };
+        }
+        break;
+      }
+    }
+    for (const k of touched) {
+      pending[k] = 0;
+    }
+    return found;
+  };
+}
+function reversed(f) {
+  return {
+    source: f.sink ^ 1,
+    sink: f.source ^ 1,
+    inside: f.inside.map((k) => k ^ 1).reverse()
+  };
+}
+var collator = new Intl.Collator(void 0, { numeric: true });
+function onReference(a, b) {
+  return isBackbone(a) && isBackbone(b) && a.stable.refName === b.stable.refName;
+}
+function forward(f, nodes) {
+  const a = nodes[f.source >> 1];
+  const b = nodes[f.sink >> 1];
+  const byRef = onReference(a, b) ? a.stable.start - b.stable.start : 0;
+  const bySide = ((f.sink ^ 1) & 1) - (f.source & 1);
+  return (byRef || bySide || collator.compare(a.name, b.name)) < 0;
+}
+function nodesOf(f) {
+  return [f.source >> 1, ...Array.from(f.inside, (k) => k >> 1), f.sink >> 1];
+}
+function allSuperbubbles(graph) {
+  const { nodes } = graph;
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  const { offset, next } = slotGraph(graph, index);
+  const find = searcher(nodes.length, offset, next);
+  const byEnds = /* @__PURE__ */ new Map();
+  for (let k = 0; k < nodes.length * 2; k++) {
+    const hit = find(k);
+    if (!hit) {
+      continue;
+    }
+    const a = hit.source >> 1;
+    const b = hit.sink >> 1;
+    const id = Math.min(a, b) * nodes.length + Math.max(a, b);
+    if (forward(hit, nodes) || !byEnds.has(id)) {
+      byEnds.set(id, hit);
+    }
+  }
+  const found = [...byEnds.values()].map(
+    (f) => forward(f, nodes) ? f : reversed(f)
+  );
+  return { found, offset, next };
+}
+function routesThrough(nodes, offset, next, f) {
+  const sink = f.sink >> 1;
+  const best = /* @__PURE__ */ new Map([
+    [f.source >> 1, { min: 0, max: 0, n: 1 }]
+  ]);
+  for (const k of [f.source, ...f.inside]) {
+    const cur = best.get(k >> 1);
+    if (!cur) {
+      continue;
+    }
+    for (let p = offset[k]; p < offset[k + 1]; p++) {
+      const u = next[p] >> 1;
+      const add = u === sink ? 0 : nodes[u].length;
+      const prev = best.get(u);
+      best.set(u, {
+        min: Math.min(prev?.min ?? Infinity, cur.min + add),
+        max: Math.max(prev?.max ?? -Infinity, cur.max + add),
+        n: Math.min(SATURATED_PATH_COUNT, cur.n + (prev?.n ?? 0))
+      });
+    }
+  }
+  return best.get(sink) ?? { min: 0, max: 0, n: 0 };
+}
+function superbubblesFromGraph(graph, span) {
+  const { nodes } = graph;
+  const { found, offset, next } = allSuperbubbles(graph);
+  const covers = found.map((f) => coversGraph(f.inside.length, nodes.length));
+  const members = found.map(nodesOf);
+  const holders = /* @__PURE__ */ new Map();
+  members.forEach((vs, i) => {
+    for (const v of vs) {
+      ;
+      (holders.get(v) ?? holders.set(v, []).get(v)).push(i);
+    }
+  });
+  const nested = (f, i) => holders.get(f.inside[0] >> 1).some(
+    (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 byId = new Map(nodes.map((n) => [n.id, n]));
+  const walkIndex = walkIndexOf(graph);
+  return outermost.map((f) => {
+    const source = nodes[f.source >> 1];
+    const sink = nodes[f.sink >> 1];
+    const walked = walkIndex && walkRoutes(graph, byId, walkIndex, source.id, sink.id);
+    const crossed = walked?.n ? walked : void 0;
+    const routes = crossed ?? routesThrough(nodes, offset, next, f);
+    const placedOn = onReference(source, sink);
+    return {
+      refName: placedOn ? source.stable.refName : span.refName,
+      start: placedOn ? source.stable.start + source.length : span.start,
+      end: placedOn ? sink.stable.start : span.end,
+      segmentCount: f.inside.length + 2,
+      pathCount: routes.n,
+      inversion: false,
+      shortestAlleleLength: routes.min,
+      longestAlleleLength: routes.max,
+      segments: nodesOf(f).map((v) => nodes[v].name).join(","),
+      shortestAllele: void 0,
+      longestAllele: void 0,
+      partial: walked !== void 0 && walked.left > 0,
+      routes: crossed?.routes,
+      key: `${source.name}>${sink.name}`,
+      ...placedOn ? {} : { offReference: true }
+    };
+  }).sort(
+    (a, b) => a.start - b.start || a.end - b.end || collator.compare(a.key, b.key)
+  );
+}
+function graphBubbles(graph, span) {
+  const n = graph.nodes.length;
+  const reach = bubblesFromGraph(graph);
+  return reach.length === 0 ? superbubblesFromGraph(graph, span) : reach.flatMap(
+    (b) => coversGraph(b.segmentCount - 2, n) ? superbubblesFromGraph(
+      b.segmentCount === n ? graph : bubbleSubgraph(graph, bubbleSegmentIds(b)),
+      b
+    ) : [b]
+  );
+}
+
+export {
+  MAX_SUPERBUBBLES,
+  superbubblesFromGraph,
+  graphBubbles
+};

package/dist/chunks/{chunk-MFKORG3F.js → chunk-FX4RDMDN.js}

@@ -19,7 +19,10 @@ function parseBubbleLine(line) {
   };
 }
 function sameBubble(a, b) {
-  return a.refName === b.refName && a.start === b.start && a.end === b.end;
+  return a.key !== void 0 || b.key !== void 0 ? a.key === b.key : a.refName === b.refName && a.start === b.start && a.end === b.end;
+}
+function bubbleKey(b) {
+  return b.key ?? `${b.refName}:${b.start}-${b.end}`;
 }
 function bubbleLabel(bubble) {
   const { shortestAlleleLength: min, longestAlleleLength: max } = bubble;
@@ -38,6 +41,7 @@ function bubbleDescription(bubble) {
 export {
   parseBubbleLine,
   sameBubble,
+  bubbleKey,
   bubbleLabel,
   SATURATED_PATH_COUNT,
   bubbleDescription

package/dist/chunks/{chunk-4S47XRYA.js → chunk-GOZYKNQ2.js}

@@ -1,6 +1,6 @@
 import {
   SATURATED_PATH_COUNT
-} from "./chunk-MFKORG3F.js";
+} from "./chunk-FX4RDMDN.js";
 import {
   referenceOrder
 } from "./chunk-HNQPEMYE.js";
@@ -38,15 +38,7 @@ function bubblesFromGraph(graph) {
   const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
   const ends = /* @__PURE__ */ new Set([backbone[0].id, backbone.at(-1).id]);
   const boundaries = backbone.map((node) => [node, indexOf.get(node.id)]).filter(([node, i]) => ends.has(node.id) || reach[i] === 0).sort(([a, ia], [b, ib]) => ia - ib || a.stable.start - b.stable.start);
-  const walkIndex = graph.paths?.map((p) => {
-    const at = /* @__PURE__ */ new Map();
-    p.nodeIds.forEach((id, i) => {
-      if (!at.has(id)) {
-        at.set(id, i);
-      }
-    });
-    return at;
-  });
+  const walkIndex = walkIndexOf(graph);
   const bubbles = [];
   for (let i = 0; i + 1 < boundaries.length; i++) {
     const [start, i0] = boundaries[i];
@@ -112,6 +104,17 @@ function bubblesFromGraph(graph) {
   }
   return bubbles;
 }
+function walkIndexOf(graph) {
+  return graph.paths?.map((p) => {
+    const at = /* @__PURE__ */ new Map();
+    p.nodeIds.forEach((id, i) => {
+      if (!at.has(id)) {
+        at.set(id, i);
+      }
+    });
+    return at;
+  });
+}
 function walkRoutes(graph, byId, walkIndex, startId, endId) {
   const seen = /* @__PURE__ */ new Map();
   let min = Infinity;
@@ -145,5 +148,7 @@ function walkRoutes(graph, byId, walkIndex, startId, endId) {
 }
 
 export {
-  bubblesFromGraph
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
 };

package/dist/chunks/{chunk-TL4B342F.js → chunk-MXDQGA7A.js}

@@ -1,6 +1,6 @@
 import {
   clampZoom
-} from "./chunk-5OIVTEF7.js";
+} from "./chunk-OOXIMURX.js";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {

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

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

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

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