@jbrowse/bandage-core 9.0.0 → 9.2.0

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-TLQ7F2ZT.js → chunk-HOOVOF2Y.js}

@@ -1,37 +1,40 @@
+import {
+  stripGeneGaps,
+  walkStripFrame,
+  walkStripLabelsTree
+} from "./chunk-UD5FOCI2.js";
+import {
+  Canvas2DRenderer
+} from "./chunk-WBCOREDZ.js";
 import {
   layoutGeometryInputs
 } from "./chunk-LOCJN3BZ.js";
 import {
   svgCanvas
 } from "./chunk-47DYCZOK.js";
-import {
-  stripGeneGaps,
-  walkStripFrame,
-  walkStripLabelsTree
-} from "./chunk-WDTXW7T2.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-MIW3HYPE.js";
+} from "./chunk-GFRPX6M2.js";
 import {
-  Canvas2DRenderer
-} from "./chunk-2WNBVB55.js";
+  genePins
+} from "./chunk-BUBZ32IC.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
   exonStretches
 } from "./chunk-3S3YVOJ7.js";
 import {
-  genePins
-} from "./chunk-BUBZ32IC.js";
+  axisScaleOf
+} from "./chunk-XKM5OHQQ.js";
 import {
   facetLifts,
   walkLift
-} from "./chunk-MBB7ATM6.js";
+} from "./chunk-LFKMASER.js";
 import {
   encodingStops
-} from "./chunk-DPV2CUIE.js";
+} from "./chunk-XPT66H6H.js";
 import {
   rangeText,
   walkKey
@@ -39,24 +42,21 @@ import {
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   version
-} from "./chunk-AMS3MAFP.js";
-import {
-  axisScaleOf
-} from "./chunk-TL4B342F.js";
+} from "./chunk-FM6XRXPX.js";
 import {
   walkRowLabels,
   walkRowsExtent
 } from "./chunk-3C5UXR2U.js";
-import {
-  nodeInk
-} from "./chunk-PBENCR5L.js";
 import {
   pathLegend,
   walkLabelsOf
 } from "./chunk-7GBL7SJY.js";
+import {
+  nodeInk
+} from "./chunk-PBENCR5L.js";
 import {
   referenceLabel
 } from "./chunk-RAKOB6IV.js";
@@ -91,7 +91,7 @@ import {
   FIT_PADDING,
   drawingBounds,
   fitTransform
-} from "./chunk-5OIVTEF7.js";
+} from "./chunk-ZGRYFUXE.js";
 import {
   deletionDrawing,
   deletionEdges

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-WDTXW7T2.js → chunk-UD5FOCI2.js}

@@ -2,7 +2,7 @@ import {
   alongRow,
   boxesGenes,
   rowPitch
-} from "./chunk-MIW3HYPE.js";
+} from "./chunk-GFRPX6M2.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/chunks/{chunk-2WNBVB55.js → chunk-WBCOREDZ.js}

@@ -68,45 +68,81 @@ var Canvas2DRenderer = class {
     }
     ctx.lineCap = "round";
     ctx.lineJoin = "round";
-    this.renderEdges(batch);
-    this.renderNodes(batch);
-    this.renderArrows(batch);
-  }
-  renderEdges(batch) {
-    const t = this.transform;
-    const ctx = this.ctx;
-    const hl = this.highlightedEdge === null ? void 0 : batch.edgeCurveRuns.get(this.highlightedEdge);
+    const factor = this.highlightFactor;
+    const edgeRun = this.edgeRun(batch.edgeCurveRuns);
     for (const { color, items } of groupByPaint(batch.edgeCurves, (e, i) => ({
-      color: inRun(hl, i) ? brightenAbgr(e.color, this.highlightFactor) : e.color,
+      color: inRun(edgeRun, i) ? brightenAbgr(e.color, factor) : e.color,
       weight: e.thickness,
-      last: inRun(hl, i)
+      last: inRun(edgeRun, i)
     }))) {
-      ctx.strokeStyle = abgrToCssRgba(color);
-      ctx.lineWidth = items[0].thickness * 2 * t.dpr;
-      ctx.beginPath();
-      for (const e of items) {
-        const first = e.curves[0];
-        ctx.moveTo(
-          first.x0 * t.scaleX + t.translateX,
-          first.y0 * t.scaleY + t.translateY
-        );
-        for (const c of e.curves) {
-          ctx.bezierCurveTo(
-            c.cx0 * t.scaleX + t.translateX,
-            c.cy0 * t.scaleY + t.translateY,
-            c.cx1 * t.scaleX + t.translateX,
-            c.cy1 * t.scaleY + t.translateY,
-            c.x1 * t.scaleX + t.translateX,
-            c.y1 * t.scaleY + t.translateY
-          );
-        }
-      }
-      ctx.stroke();
+      this.strokeCurves(items, color);
+    }
+    const lifted = this.liftedStrokes(batch);
+    for (const { color, items } of groupByPaint(batch.nodeStrokes, (s, i) => {
+      const f = lifted.get(i);
+      return {
+        color: f === void 0 ? s.color : brightenAbgr(s.color, f),
+        weight: s.thickness,
+        last: f !== void 0
+      };
+    })) {
+      this.strokeNodes(items, color);
+    }
+    const arrowRun = this.edgeRun(batch.arrowRuns);
+    for (const { color, items } of groupByPaint(batch.arrows, (a, i) => ({
+      color: inRun(arrowRun, i) ? brightenAbgr(a.color, factor) : a.color,
+      weight: 0,
+      last: inRun(arrowRun, i)
+    }))) {
+      this.fillArrows(items, color);
     }
   }
-  renderNodes(batch) {
-    const t = this.transform;
+  // Only what the highlights lift, over a transparent clear, for a hover layer
+  // stacked on a canvas that drew the batch without them: a pointer move then
+  // repaints one node or edge rather than the whole drawing
+  renderHighlights() {
     const ctx = this.ctx;
+    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+    const batch = this.batch;
+    if (!this.transform || !batch) {
+      return;
+    }
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    const factor = this.highlightFactor;
+    const curves = runItems(batch.edgeCurves, this.edgeRun(batch.edgeCurveRuns));
+    for (const { color, items } of groupByPaint(curves, (e) => ({
+      color: brightenAbgr(e.color, factor),
+      weight: e.thickness,
+      last: false
+    }))) {
+      this.strokeCurves(items, color);
+    }
+    const lifted = [...this.liftedStrokes(batch)];
+    for (const { color, items } of groupByPaint(lifted, ([i, f]) => ({
+      color: brightenAbgr(batch.nodeStrokes[i].color, f),
+      weight: batch.nodeStrokes[i].thickness,
+      last: false
+    }))) {
+      this.strokeNodes(
+        items.map(([i]) => batch.nodeStrokes[i]),
+        color
+      );
+    }
+    const arrows = runItems(batch.arrows, this.edgeRun(batch.arrowRuns));
+    for (const { color, items } of groupByPaint(arrows, (a) => ({
+      color: brightenAbgr(a.color, factor),
+      weight: 0,
+      last: false
+    }))) {
+      this.fillArrows(items, color);
+    }
+  }
+  edgeRun(runs) {
+    return this.highlightedEdge === null ? void 0 : runs.get(this.highlightedEdge);
+  }
+  // stroke index -> brighten factor, for the nodes the model lifted
+  liftedStrokes(batch) {
     const lifted = /* @__PURE__ */ new Map();
     for (const [nodeId, factor] of this.nodeHighlights) {
       const run = batch.nodeStrokeRuns.get(nodeId);
@@ -116,55 +152,63 @@ var Canvas2DRenderer = class {
         }
       }
     }
-    for (const { color, items } of groupByPaint(batch.nodeStrokes, (s, i) => {
-      const factor = lifted.get(i);
-      return {
-        color: factor === void 0 ? s.color : brightenAbgr(s.color, factor),
-        weight: s.thickness,
-        last: factor !== void 0
-      };
-    })) {
-      ctx.strokeStyle = abgrToCssRgba(color);
-      ctx.lineWidth = items[0].thickness * 2 * t.dpr;
-      ctx.beginPath();
-      for (const s of items) {
-        const p0 = s.points[0];
-        ctx.moveTo(
-          p0.x * t.scaleX + t.translateX,
-          p0.y * t.scaleY + t.translateY
+    return lifted;
+  }
+  strokeCurves(items, color) {
+    const t = this.transform;
+    const ctx = this.ctx;
+    ctx.strokeStyle = abgrToCssRgba(color);
+    ctx.lineWidth = items[0].thickness * 2 * t.dpr;
+    ctx.beginPath();
+    for (const e of items) {
+      const first = e.curves[0];
+      ctx.moveTo(
+        first.x0 * t.scaleX + t.translateX,
+        first.y0 * t.scaleY + t.translateY
+      );
+      for (const c of e.curves) {
+        ctx.bezierCurveTo(
+          c.cx0 * t.scaleX + t.translateX,
+          c.cy0 * t.scaleY + t.translateY,
+          c.cx1 * t.scaleX + t.translateX,
+          c.cy1 * t.scaleY + t.translateY,
+          c.x1 * t.scaleX + t.translateX,
+          c.y1 * t.scaleY + t.translateY
         );
-        for (let i = 1, l = s.points.length; i < l; i++) {
-          const p = s.points[i];
-          ctx.lineTo(
-            p.x * t.scaleX + t.translateX,
-            p.y * t.scaleY + t.translateY
-          );
-        }
       }
-      ctx.stroke();
     }
+    ctx.stroke();
   }
-  renderArrows(batch) {
+  strokeNodes(items, color) {
     const t = this.transform;
     const ctx = this.ctx;
-    const hl = this.highlightedEdge === null ? void 0 : batch.arrowRuns.get(this.highlightedEdge);
-    for (const { color, items } of groupByPaint(batch.arrows, (a, i) => ({
-      color: inRun(hl, i) ? brightenAbgr(a.color, this.highlightFactor) : a.color,
-      weight: 0,
-      last: inRun(hl, i)
-    }))) {
-      ctx.fillStyle = abgrToCssRgba(color);
-      ctx.beginPath();
-      for (const a of items) {
-        const [tip, left, notch, right] = arrowheadOutline(a, t);
-        ctx.moveTo(tip.x, tip.y);
-        ctx.lineTo(left.x, left.y);
-        ctx.lineTo(notch.x, notch.y);
-        ctx.lineTo(right.x, right.y);
-        ctx.closePath();
+    ctx.strokeStyle = abgrToCssRgba(color);
+    ctx.lineWidth = items[0].thickness * 2 * t.dpr;
+    ctx.beginPath();
+    for (const s of items) {
+      const p0 = s.points[0];
+      ctx.moveTo(p0.x * t.scaleX + t.translateX, p0.y * t.scaleY + t.translateY);
+      for (let i = 1, l = s.points.length; i < l; i++) {
+        const p = s.points[i];
+        ctx.lineTo(p.x * t.scaleX + t.translateX, p.y * t.scaleY + t.translateY);
       }
-      ctx.fill();
     }
+    ctx.stroke();
+  }
+  fillArrows(items, color) {
+    const t = this.transform;
+    const ctx = this.ctx;
+    ctx.fillStyle = abgrToCssRgba(color);
+    ctx.beginPath();
+    for (const a of items) {
+      const [tip, left, notch, right] = arrowheadOutline(a, t);
+      ctx.moveTo(tip.x, tip.y);
+      ctx.lineTo(left.x, left.y);
+      ctx.lineTo(notch.x, notch.y);
+      ctx.lineTo(right.x, right.y);
+      ctx.closePath();
+    }
+    ctx.fill();
   }
   dispose() {
     this.batch = null;
@@ -190,6 +234,9 @@ function arrowheadOutline(a, t) {
     { x: backX + uy * halfWidth, y: backY - ux * halfWidth }
   ];
 }
+function runItems(items, run) {
+  return run ? items.slice(run.start, run.start + run.count) : [];
+}
 function inRun(run, i) {
   return run !== void 0 && i >= run.start && i < run.start + run.count;
 }

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

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

package/dist/chunks/{chunk-WOO7QYKB.js → chunk-XKWD2RY3.js}

@@ -1,6 +1,6 @@
 import {
   SATURATED_PATH_COUNT
-} from "./chunk-MFKORG3F.js";
+} from "./chunk-FX4RDMDN.js";
 
 // src/bubbles/classifyBubble.ts
 var REPEAT_GROWTH = 10;
@@ -59,6 +59,9 @@ function classifyShape(b, repeats) {
   if (inversion) {
     return { kind: "inversion", label: `${formatBp(longest)} inv` };
   }
+  if (b.offReference) {
+    return shortest === longest ? sameLength(shortest) : { kind: "complex", label: `${range}, ${routes(pathCount)}` };
+  }
   const repeat = longest !== shortest ? coveringRepeat(b, repeats) : void 0;
   if (repeat) {
     const name = repeat.name ? ` (${repeat.name})` : "";
@@ -69,7 +72,7 @@ function classifyShape(b, repeats) {
   }
   const alleles = pathCount > 2 ? `, ${pathCount} alleles` : "";
   if (shortest === longest && shortest === refSpan) {
-    return refSpan <= 1 ? { kind: "snp", label: "SNP" } : { kind: "substitution", label: `${formatBp(refSpan)} sub` };
+    return sameLength(refSpan);
   }
   if (refSpan === 0 || shortest === refSpan) {
     return {
@@ -88,6 +91,9 @@ function classifyShape(b, repeats) {
     label: `${formatBp(refSpan)} ref \u2192 ${range}, ${pathCount} alleles`
   };
 }
+function sameLength(bp) {
+  return bp <= 1 ? { kind: "snp", label: "SNP" } : { kind: "substitution", label: `${formatBp(bp)} sub` };
+}
 var BUBBLE_KIND_COLORS = {
   snp: "#5b6b7a",
   substitution: "#5b6b7a",

package/dist/chunks/{chunk-DPV2CUIE.js → chunk-XPT66H6H.js}

@@ -2,7 +2,7 @@ import {
   REFERENCE_RAMP_ALT_COLOR,
   REFERENCE_RAMP_MAX_HUE,
   hslToRgb
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   packAbgr
 } from "./chunk-G2FD7S3C.js";