@jbrowse/bandage-core 8.2.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-GQ2AOHU4.js → chunk-2ZT7ZF7A.js}

@@ -1,35 +1,14 @@
-import {
-  isBackbone
-} from "./chunk-FYQWPEEY.js";
-
 // src/tubeMap/connectors.ts
-function referenceNodes(graph, layout) {
-  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
-  const out = [];
-  layout.nodes.forEach((node) => {
-    const graphNode = nodeById.get(node.name);
-    if (node.order >= 0 && graphNode && isBackbone(graphNode)) {
-      out.push({
-        node: node.name,
-        bp0: graphNode.stable.start,
-        bp1: graphNode.stable.start + node.sequenceLength,
-        x0: node.x,
-        x1: node.x + node.pixelWidth
-      });
-    }
-  });
-  return out;
-}
-function tubeMapConnectors(nodes, bpToScreen, tubeToScreen, width) {
+function tubeMapConnectors(boxes, bpToScreen, tubeToScreen, width) {
   const out = [];
-  for (const n of nodes) {
-    const bottom0 = tubeToScreen(n.x0);
-    const bottom1 = tubeToScreen(n.x1);
+  for (const box of boxes) {
+    const bottom0 = tubeToScreen(box.x0);
+    const bottom1 = tubeToScreen(box.x1);
     if (bottom1 >= 0 && bottom0 <= width) {
       out.push({
-        node: n.node,
-        top0: bpToScreen(n.bp0),
-        top1: bpToScreen(n.bp1),
+        node: box.name,
+        top0: bpToScreen(box.bp0),
+        top1: bpToScreen(box.bp1),
         bottom0,
         bottom1
       });
@@ -90,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);
@@ -105,8 +87,8 @@ function drawTubeMapConnectors(ctx, connectors, bottom, {
 }
 
 export {
-  referenceNodes,
   tubeMapConnectors,
   connectorAt,
-  drawTubeMapConnectors
+  drawTubeMapConnectors,
+  drawLitConnector
 };

package/dist/chunks/{chunk-DE4UFDUZ.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-3FXPFVKJ.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-KCRL5JB2.js → chunk-75HR3756.js}

@@ -1,9 +1,9 @@
 import {
   tubeMapMismatches
-} from "./chunk-733L2TS6.js";
+} from "./chunk-XXT2JCAC.js";
 import {
   readColor
-} from "./chunk-TEDQJPMI.js";
+} from "./chunk-CWFNEKST.js";
 
 // src/tubeMap/draw.ts
 import { curvePaths, nodeOutlinePath } from "@jbrowse/tubemap-core";
@@ -53,9 +53,9 @@ function extentOf(commands) {
   }
   return { x0, x1 };
 }
-function shapeOf(d, color, track) {
+function shapeOf(d, color, id, haplotype) {
   const commands = parsePath(d);
-  return { commands, color, track, ...extentOf(commands) };
+  return { commands, color, id, haplotype, ...extentOf(commands) };
 }
 function trackColors(layout, pathColors) {
   return new Map(
@@ -67,20 +67,21 @@ function trackColors(layout, pathColors) {
 }
 function layerOf(layout, type, colors) {
   const { shapes } = layout;
+  const haplotype = type === "haplotype";
   const colorOf = (s) => colors.get(s.id);
-  const trackOf = (s) => type === "haplotype" ? s.id : void 0;
   const rects = [...shapes.rectangles, ...shapes.verticalRectangles].filter((r) => r.type === type).map((r) => ({
     color: colorOf(r),
-    track: trackOf(r),
+    id: r.id,
+    haplotype,
     x0: r.xStart,
     x1: r.xEnd + 1,
     y0: r.yStart,
     y1: r.yEnd + 1
   }));
   const curves = curvePaths(shapes.curves, type).map(
-    (c) => shapeOf(c.path, colorOf(c), trackOf(c))
+    (c) => shapeOf(c.path, colorOf(c), c.id, haplotype)
   );
-  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, colorOf(c), trackOf(c)));
+  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, colorOf(c), c.id, haplotype));
   return { rects, shapes: [...curves, ...corners] };
 }
 function tubeMapPicture({
@@ -177,7 +178,7 @@ var NODE_TINT_ALPHA = 0.55;
 function drawTubeMap(ctx, picture, frame) {
   const { x, y, width } = frame;
   const visible = (item) => x(item.x1) >= 0 && x(item.x0) <= width;
-  const colorOf = (item) => item.track !== void 0 && frame.tubeColors?.[item.track] || item.color;
+  const colorOf = (item) => item.haplotype && frame.tubeColors?.[item.id] || item.color;
   ctx.globalAlpha = 1;
   for (const layer of picture.layers) {
     fillByColor(ctx, layer.rects, visible, colorOf, (r) => {
@@ -191,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) {
@@ -235,6 +252,7 @@ function drawMismatches(ctx, marks, frame) {
   }
   ctx.fill();
   ctx.font = `${fontPx}px monospace`;
+  ctx.textAlign = "left";
   ctx.textBaseline = "alphabetic";
   ctx.fillStyle = darkMode ? "#ffffff" : "#000000";
   for (const m of marks) {
@@ -248,12 +266,32 @@ function drawMismatches(ctx, marks, frame) {
     }
   }
 }
+function tubeMapTrackAt(picture, { x, y }, sx, sy) {
+  for (let l = picture.layers.length - 1; l >= 0; l--) {
+    for (const r of picture.layers[l].rects) {
+      if (x(r.x0) <= sx && sx <= x(r.x1) && y(r.y0) <= sy && sy <= y(r.y1)) {
+        return r.id;
+      }
+    }
+  }
+  return void 0;
+}
+var INSERTION_SLOP_PX = 4;
+function tubeMapMismatchAt(picture, frame, sx, sy) {
+  const { x, y, yScale } = frame;
+  return mismatchesLegible(yScale) ? picture.mismatches.find(
+    (m) => y(m.y) <= sy && sy <= y(m.y + m.height) && (m.kind === "insertion" ? Math.abs(x(m.x) - sx) <= INSERTION_SLOP_PX : x(m.x0) <= sx && sx <= x(m.x1))
+  ) : void 0;
+}
 
 export {
   parsePath,
   trackColors,
   tubeMapPicture,
   drawTubeMap,
+  drawTubeMapHighlight,
   mismatchesLegible,
-  mismatchOnScreen
+  mismatchOnScreen,
+  tubeMapTrackAt,
+  tubeMapMismatchAt
 };

package/dist/chunks/{chunk-DRA7733Q.js → chunk-BPRXQ2SS.js}

@@ -6,17 +6,22 @@ import {
 } from "./chunk-FYQWPEEY.js";
 
 // src/tubeMap/axis.ts
-function referenceBoxes(graph, layout) {
+function referenceBoxes({
+  graph,
+  layout
+}) {
   const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
   const byRefName = /* @__PURE__ */ new Map();
-  layout.nodes.forEach((node) => {
+  layout.nodes.forEach((node, index) => {
     const graphNode = nodeById.get(node.name);
     if (node.order >= 0 && graphNode && isBackbone(graphNode)) {
       const { refName, start } = graphNode.stable;
       const boxes = byRefName.get(refName) ?? byRefName.set(refName, []).get(refName);
       boxes.push({
+        name: node.name,
+        index,
         bp0: start,
-        bp1: start + node.sequenceLength,
+        bp1: start + graphNode.length,
         x0: node.x,
         x1: node.x + node.pixelWidth
       });

package/dist/chunks/{chunk-TEDQJPMI.js → chunk-CWFNEKST.js}

@@ -30,16 +30,30 @@ function mismatchesByStep(record, lengths) {
     return byStep;
   }
   const starts = stepStarts(lengths, record.pathLength);
+  const known = starts.flatMap((start, s) => start === void 0 ? [] : [s]);
+  const startOf = (k) => starts[known[k]];
+  const endOf = (k) => startOf(k) + lengths[known[k]];
+  let first = 0;
   const stepAt = (pos2, atEnd = false) => {
-    for (let s = 0; s < starts.length; s++) {
-      const start = starts[s];
-      const length = lengths[s];
-      if (start !== void 0 && length !== void 0 && start <= pos2 && (pos2 < start + length || atEnd && pos2 === start + length)) {
-        return { s, local: pos2 - start, room: start + length - pos2 };
+    while (first < known.length && endOf(first) < pos2) {
+      first++;
+    }
+    for (let k = first; k < known.length && startOf(k) <= pos2; k++) {
+      const end = endOf(k);
+      if (pos2 < end || atEnd && pos2 === end) {
+        return { s: known[k], local: pos2 - startOf(k), room: end - pos2 };
       }
     }
     return void 0;
   };
+  const unplacedFrom = (pos2) => {
+    for (let k = first; k < known.length; k++) {
+      if (startOf(k) > pos2) {
+        return startOf(k) - pos2;
+      }
+    }
+    return Infinity;
+  };
   const add = (s, mismatch) => {
     const list = byStep[s];
     const last = list.at(-1);
@@ -68,7 +82,7 @@ function mismatchesByStep(record, lengths) {
       let left = op.length;
       while (left > 0) {
         const at = stepAt(pos);
-        const take = at ? Math.min(left, at.room) : left;
+        const take = Math.min(left, at ? at.room : unplacedFrom(pos));
         if (at) {
           add(at.s, { type: "deletion", pos: at.local, length: take });
         }
@@ -106,7 +120,8 @@ function tubeMapReads(graph, records, firstId) {
         })),
         firstNodeOffset: first === 0 ? record.pathStart : 0,
         finalNodeCoverLength: last === record.path.length - 1 ? lastLength - (record.pathLength - record.pathEnd) : lastLength,
-        mapping_quality: record.mappingQuality === 255 ? 0 : record.mappingQuality,
+        // 255 is GAF's missing MAPQ
+        mapping_quality: record.mappingQuality === 255 ? void 0 : record.mappingQuality,
         is_secondary: record.secondary,
         is_reverse: record.strand === "-"
       });