@jbrowse/bandage-core 10.2.7 → 10.3.0

package/dist/chunks/{chunk-HK5Y2YWV.js → chunk-MYDHU2UV.js}

@@ -1,3 +1,7 @@
+import {
+  partitionPoint
+} from "./chunk-HOAIOEI7.js";
+
 // src/tubeMap/warp.ts
 var MAX_GAP_PX = 24;
 var MAX_GAP_SHARE = 0.5;
@@ -55,17 +59,8 @@ function warpX(knots, tx) {
   if (tx >= last.tx) {
     return last.sx + (tx - last.tx);
   }
-  let lo = 0;
-  let hi = n - 1;
-  while (hi - lo > 1) {
-    const mid = lo + hi >> 1;
-    if (knots[mid].tx <= tx) {
-      lo = mid;
-    } else {
-      hi = mid;
-    }
-  }
-  const a = knots[lo];
+  const hi = 1 + partitionPoint(n - 2, (i) => knots[i + 1].tx <= tx);
+  const a = knots[hi - 1];
   const b = knots[hi];
   const span = b.tx - a.tx;
   return span > 0 ? a.sx + (tx - a.tx) / span * (b.sx - a.sx) : a.sx;

package/dist/chunks/{chunk-TZFWUT2C.js → chunk-MYLAJDKB.js}

@@ -1,9 +1,9 @@
 import {
   projectAlleles
-} from "./chunk-RVS2QCOX.js";
+} from "./chunk-3GLG3ZLE.js";
 import {
   buildNeighbors
-} from "./chunk-ES2N6V56.js";
+} from "./chunk-VX656OAZ.js";
 
 // src/layout/placeOffReference.ts
 var MIN_DELETION_BP = 1;

package/dist/chunks/{chunk-4HWM3FNK.js → chunk-OMUPUB4J.js}

@@ -1,12 +1,15 @@
 import {
   EdgeSpatialIndex,
   SpatialIndex
-} from "./chunk-KBEP7VYK.js";
+} from "./chunk-3VCKBSML.js";
+import {
+  weakMemo
+} from "./chunk-HMXCN6PG.js";
 import {
   pathRibbonOffsets,
   translateCurves,
   yToXOf
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
 
 // src/util/hitDetection.ts
 function distanceToSegment(px, py, x1, y1, x2, y2) {
@@ -19,40 +22,26 @@ function distanceToSegment(px, py, x1, y1, x2, y2) {
   const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
   return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
 }
-function distanceToCubicBezier(px, py, x1, y1, cx1, cy1, cx2, cy2, x2, y2) {
+function distanceToCubicBezier(px, py, c) {
   let minDist = Infinity;
   const samples = 20;
-  let lastX = x1;
-  let lastY = y1;
+  let lastX = c.x0;
+  let lastY = c.y0;
   for (let i = 1; i <= samples; i++) {
     const t = i / samples;
     const u = 1 - t;
-    const bx = u * u * u * x1 + 3 * u * u * t * cx1 + 3 * u * t * t * cx2 + t * t * t * x2;
-    const by = u * u * u * y1 + 3 * u * u * t * cy1 + 3 * u * t * t * cy2 + t * t * t * y2;
+    const bx = u * u * u * c.x0 + 3 * u * u * t * c.cx0 + 3 * u * t * t * c.cx1 + t * t * t * c.x1;
+    const by = u * u * u * c.y0 + 3 * u * u * t * c.cy0 + 3 * u * t * t * c.cy1 + t * t * t * c.y1;
     minDist = Math.min(minDist, distanceToSegment(px, py, lastX, lastY, bx, by));
     lastX = bx;
     lastY = by;
   }
   return minDist;
 }
-function distanceToBezierCurve(px, py, c) {
-  return distanceToCubicBezier(
-    px,
-    py,
-    c.x0,
-    c.y0,
-    c.cx0,
-    c.cy0,
-    c.cx1,
-    c.cy1,
-    c.x1,
-    c.y1
-  );
-}
 function distanceToEdgeCurves(px, py, curves, yToX = 1) {
   let minDist = Infinity;
   for (const c of curves) {
-    const d = distanceToBezierCurve(
+    const d = distanceToCubicBezier(
       px,
       py,
       yToX === 1 ? c : {
@@ -72,45 +61,39 @@ function distanceToEdgeCurves(px, py, curves, yToX = 1) {
   }
   return minDist;
 }
-var nodeCache = /* @__PURE__ */ new WeakMap();
+var nodeCache = weakMemo();
 function getSpatialIndex(nodePositions, version) {
-  const cached = nodeCache.get(nodePositions);
-  if (cached?.version === version) {
-    return cached.index;
-  }
-  const index = new SpatialIndex(nodePositions);
-  nodeCache.set(nodePositions, { version, index });
-  return index;
+  return nodeCache(
+    nodePositions,
+    [version],
+    () => new SpatialIndex(nodePositions)
+  );
 }
-var edgeCache = /* @__PURE__ */ new WeakMap();
+var edgeCache = weakMemo();
 function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version, deletions, routes, stranded = false) {
-  const cached = edgeCache.get(nodePositions);
-  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version && cached.deletions === deletions && cached.routes === routes && cached.stranded === stranded) {
-    return cached.index;
-  }
-  const index = new EdgeSpatialIndex(
+  return edgeCache(
     nodePositions,
-    graph,
-    drawPaths,
-    axis,
-    void 0,
-    deletions,
-    version,
-    routes,
-    stranded
+    [
+      graph,
+      drawPaths,
+      axis.scaleX,
+      axis.scaleY,
+      version,
+      deletions,
+      routes,
+      stranded
+    ],
+    () => new EdgeSpatialIndex(
+      nodePositions,
+      graph,
+      drawPaths,
+      axis,
+      deletions,
+      version,
+      routes,
+      stranded
+    )
   );
-  edgeCache.set(nodePositions, {
-    graph,
-    drawPaths,
-    scaleX: axis.scaleX,
-    scaleY: axis.scaleY,
-    version,
-    index,
-    deletions,
-    routes,
-    stranded
-  });
-  return index;
 }
 var MIN_NODE_REACH_PX = 5;
 function findHoveredNode(nodePositions, graphX, graphY, axis, version = 0, ink) {

package/dist/chunks/{chunk-PTABFYQ7.js → chunk-PFRQBCGC.js}

@@ -1,16 +1,21 @@
 import {
+  weakMemo
+} from "./chunk-HMXCN6PG.js";
+import {
+  labelWidth,
   occupancy
 } from "./chunk-AB35TJST.js";
 import {
   polylineMidpoint
-} from "./chunk-N73TI3VG.js";
+} from "./chunk-BZFOFC4D.js";
 import {
-  deletionArcCurves
-} from "./chunk-24WITXQY.js";
+  edgeCurvesOf
+} from "./chunk-CGMSKIEO.js";
 import {
   curveBounds,
-  curveMidpoint
-} from "./chunk-7SRWJLSC.js";
+  curveMidpoint,
+  polylinePx
+} from "./chunk-UBQSRCWR.js";
 
 // src/graphLabels.ts
 var MIN_DELETION_LABEL_PX = 26;
@@ -38,7 +43,7 @@ function boxAt(halfW, x, y) {
 function rowLabelBox(text, screenY) {
   return {
     x0: 6,
-    x1: 6 + text.length * 6.2 + 8 + LABEL_GAP_PX,
+    x1: 6 + labelWidth(text) + LABEL_GAP_PX,
     y0: screenY - 8 - LABEL_GAP_PX / 2,
     y1: screenY + 8 + LABEL_GAP_PX / 2
   };
@@ -78,15 +83,6 @@ function boxRayCrossing(box, dir) {
     dir.y === 0 ? Infinity : halfH / Math.abs(dir.y)
   );
 }
-function drawnLength(segments, scaleX, scaleY) {
-  let total = 0;
-  for (let i = 1; i < segments.length; i++) {
-    const a = segments[i - 1];
-    const b = segments[i];
-    total += Math.hypot((b.x - a.x) * scaleX, (b.y - a.y) * scaleY);
-  }
-  return total;
-}
 function runBounds(nodeIds, nodePositions) {
   let minX = Infinity;
   let minY = Infinity;
@@ -102,54 +98,46 @@ function runBounds(nodeIds, nodePositions) {
   }
   return minX === Infinity ? void 0 : { minX, minY, maxX, maxY };
 }
-var nodeOrderCache = /* @__PURE__ */ new WeakMap();
+var nodeOrderCache = weakMemo();
 function labelOrder(nodePositions, nodeLengths) {
-  const cached = nodeOrderCache.get(nodePositions);
-  if (cached?.nodeLengths === nodeLengths) {
-    return cached.order;
-  }
-  const order = Object.entries(nodePositions).filter(([id, segments]) => segments.length > 0 && nodeLengths.has(id)).sort(([a], [b]) => nodeLengths.get(b) - nodeLengths.get(a));
-  nodeOrderCache.set(nodePositions, { nodeLengths, order });
-  return order;
+  return nodeOrderCache(
+    nodePositions,
+    [nodeLengths],
+    () => Object.entries(nodePositions).filter(([id, segments]) => segments.length > 0 && nodeLengths.has(id)).sort(([a], [b]) => nodeLengths.get(b) - nodeLengths.get(a))
+  );
 }
-var arcCache = /* @__PURE__ */ new WeakMap();
+var arcCache = weakMemo();
 function arcPlacements(nodePositions, deletions, axis, version, routes, stranded) {
   const { scaleX, scaleY } = axis;
-  const cached = arcCache.get(nodePositions);
-  if (cached?.deletions === deletions && cached.routes === routes && cached.stranded === stranded && cached.scaleX === scaleX && cached.scaleY === scaleY && cached.version === version) {
-    return cached.arcs;
-  }
-  const arcs = [];
-  for (const deletion of [...deletions].sort((a, b) => b.bp - a.bp)) {
-    const curves = deletionArcCurves(
-      nodePositions,
-      deletion,
-      axis,
-      routes?.[deletion.edgeIndex],
-      stranded
-    );
-    const apex = curves ? curveMidpoint(curves) : void 0;
-    if (curves && apex) {
-      const { minX, minY, maxX, maxY } = curveBounds(curves);
-      arcs.push({
-        deletion,
-        curves,
-        apex,
-        // in screen px, so the two axes' units cannot be added by accident
-        extent: Math.max((maxX - minX) * scaleX, (maxY - minY) * scaleY)
-      });
+  return arcCache(
+    nodePositions,
+    [deletions, routes, stranded, scaleX, scaleY, version],
+    () => {
+      const arcs = [];
+      for (const deletion of [...deletions].sort((a, b) => b.bp - a.bp)) {
+        const curves = edgeCurvesOf(
+          nodePositions,
+          deletion,
+          axis,
+          deletion.bypassed,
+          routes?.[deletion.edgeIndex],
+          stranded
+        );
+        const apex = curves ? curveMidpoint(curves) : void 0;
+        if (curves && apex) {
+          const { minX, minY, maxX, maxY } = curveBounds(curves);
+          arcs.push({
+            deletion,
+            curves,
+            apex,
+            // in screen px, so the two axes' units cannot be added by accident
+            extent: Math.max((maxX - minX) * scaleX, (maxY - minY) * scaleY)
+          });
+        }
+      }
+      return arcs;
     }
-  }
-  arcCache.set(nodePositions, {
-    deletions,
-    routes,
-    stranded,
-    scaleX,
-    scaleY,
-    version,
-    arcs
-  });
-  return arcs;
+  );
 }
 function sizeLabelCandidates({
   nodePositions,
@@ -267,7 +255,7 @@ function sizeLabelCandidates({
     if (screenY + LABEL_HALF_HEIGHT <= 0 || screenY - LABEL_HALF_HEIGHT >= height) {
       continue;
     }
-    const drawn = drawnLength(segments, scaleX, scaleY);
+    const drawn = polylinePx(segments, scaleX, scaleY);
     if (drawn < MIN_LABEL_HALF_WIDTH * 2 / MAX_LABEL_OVERHANG) {
       continue;
     }
@@ -309,9 +297,10 @@ function placeSizeLabels(candidates, take, budget = Infinity) {
 }
 function graphLabels({
   reserved,
+  take,
   ...args
 }) {
-  const take = occupancy(args, reserved);
+  take ??= occupancy(args, reserved);
   const { deletions, nodes } = sizeLabelCandidates(args);
   return [
     ...placeSizeLabels(deletions, take),

package/dist/chunks/{chunk-T6V4KI2L.js → chunk-PPDE4IVT.js}

@@ -1,6 +1,6 @@
 import {
   trimOrigins
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-LGJBB5BP.js";
 
 // src/bubbles/popBubble.ts
 function bubbleSubgraph(graph, segmentIds) {

package/dist/chunks/{chunk-KC7T5RWG.js → chunk-PSCSZSVK.js}

@@ -1,12 +1,10 @@
 import {
   nodesUnderBox
-} from "./chunk-4HWM3FNK.js";
+} from "./chunk-OMUPUB4J.js";
 import {
-  nodeLabelBudget,
-  placeSizeLabels,
-  rowLabelBox,
-  sizeLabelCandidates
-} from "./chunk-PTABFYQ7.js";
+  graphLabels,
+  rowLabelBox
+} from "./chunk-PFRQBCGC.js";
 import {
   LABEL_CHAR_PX,
   LABEL_PAD,
@@ -131,7 +129,7 @@ function layoutLabels(m) {
     frame,
     take
   );
-  const sizeCandidates = m.nodePositions && m.labelsNodeSizes ? sizeLabelCandidates({
+  const sizes = m.nodePositions && m.labelsNodeSizes ? graphLabels({
     nodePositions: m.nodePositions,
     nodeLengths: m.nodeLengths,
     deletions: m.deletions,
@@ -143,19 +141,14 @@ function layoutLabels(m) {
     translateY,
     width,
     height,
-    version: m.positionsVersion
-  }) : { deletions: [], nodes: [] };
-  const deletionLabels = placeSizeLabels(sizeCandidates.deletions, take);
-  const nodeLabels = placeSizeLabels(
-    sizeCandidates.nodes,
-    take,
-    nodeLabelBudget(width, height)
-  );
+    version: m.positionsVersion,
+    take
+  }) : [];
   return {
     bubbles,
     ticks,
     genes,
-    sizes: [...deletionLabels, ...nodeLabels]
+    sizes
   };
 }
 

package/dist/chunks/{chunk-CG35S2S2.js → chunk-PTQPTDZH.js}

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

package/dist/chunks/{chunk-L2HDM2R3.js → chunk-QQCOVMMT.js}

@@ -1,6 +1,6 @@
 import {
   walkRows
-} from "./chunk-LKW2TP4N.js";
+} from "./chunk-5YILQTHE.js";
 import {
   ROW_HEIGHT_PX
 } from "./chunk-CPMHA4W5.js";
@@ -8,20 +8,19 @@ import {
   backboneNodes,
   backbonePositions,
   overlapsWindow
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/layout/walkRowLayout.ts
 var READOUT_ROOM = 1.3;
+function longestBar(walks) {
+  return Math.max(walks.reference.bp, ...walks.rows.map((r) => r.bp));
+}
 function walkRowsExtent(walks, pitch = {
   rowPx: ROW_HEIGHT_PX,
   readouts: true
 }) {
-  let longest = walks.reference.bp;
-  for (const row of walks.rows) {
-    longest = Math.max(longest, row.bp);
-  }
   return {
-    maxX: walks.origin + longest * (pitch.readouts ? READOUT_ROOM : 1),
+    maxX: walks.origin + longestBar(walks) * (pitch.readouts ? READOUT_ROOM : 1),
     maxY: walks.rows.length * pitch.rowPx
   };
 }
@@ -58,6 +57,7 @@ function walkRowLayout(graph, region) {
 
 export {
   READOUT_ROOM,
+  longestBar,
   walkRowsExtent,
   walkRowLabels,
   walkRowLayout

package/dist/chunks/{chunk-CQHUZHET.js → chunk-RFG42VIO.js}

@@ -3,10 +3,13 @@ import {
 } from "./chunk-FX4RDMDN.js";
 import {
   referenceOrder
-} from "./chunk-CM6LO6OC.js";
+} from "./chunk-UAFATXYA.js";
+import {
+  addTo
+} from "./chunk-BSOZW3FC.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/bubbles/bubblesFromGraph.ts
 function relax(best, to, cur, add) {
@@ -38,7 +41,7 @@ function bubblesFromGraph(graph) {
     reach[lo + 1]++;
     reach[hi]--;
     const [from, to] = a < b ? [e.from, e.to] : [e.to, e.from];
-    (succ.get(from) ?? succ.set(from, /* @__PURE__ */ new Set()).get(from)).add(to);
+    addTo(succ, from, to);
   }
   for (let i = 1; i < reach.length; i++) {
     reach[i] += reach[i - 1];
@@ -72,10 +75,14 @@ function bubblesFromGraph(graph) {
         relax(best, t, cur, t === end.id ? 0 : byId.get(t).length);
       }
     }
-    const walked = walkIndex && walkRoutes(graph, byId, walkIndex, start.id, end.id);
-    const crossed = walked?.n ? walked : void 0;
-    const routes = crossed ?? best.get(end.id) ?? { min: 0, max: 0, n: 0 };
-    const walksLeave = walked !== void 0 && walked.left > 0;
+    const walked = walkRoutes(
+      graph,
+      byId,
+      walkIndex,
+      start.id,
+      end.id,
+      () => best.get(end.id) ?? { min: 0, max: 0, n: 0 }
+    );
     const refStart = start.stable.start + start.length;
     const refEnd = end.stable.start;
     const chain = [
@@ -86,26 +93,15 @@ function bubblesFromGraph(graph) {
     const chainBroken = chain.some(
       (id, k) => k > 0 && !linked.has(`${chain[k - 1]}>${id}`)
     );
-    const partial = chainBroken || walksLeave;
-    const fallback = chainBroken && !crossed;
-    bubbles.push({
-      refName: start.stable.refName,
-      start: refStart,
-      end: refEnd,
-      segmentCount: interior.length + 2,
-      pathCount: routes.n,
-      // a real inversion test needs each walk's direction relative to the
-      // reference; the first visit's strand is just whichever path anchored the
-      // node
-      inversion: false,
-      shortestAlleleLength: fallback ? refEnd - refStart : routes.min,
-      longestAlleleLength: fallback ? refEnd - refStart : routes.max,
-      segments: [start, ...interior.map((id) => byId.get(id)), end].map((n) => n.name).join(","),
-      shortestAllele: void 0,
-      longestAllele: void 0,
-      partial,
-      routes: crossed?.routes
-    });
+    const refLength = refEnd - refStart;
+    bubbles.push(
+      derivedBubble(
+        { refName: start.stable.refName, start: refStart, end: refEnd },
+        [start, ...interior.map((id) => byId.get(id)), end],
+        chainBroken && !walked.routes ? { ...walked, min: refLength, max: refLength } : walked,
+        chainBroken || walked.walksLeave
+      )
+    );
   }
   return bubbles;
 }
@@ -129,7 +125,10 @@ function walkIndexOf(graph, ids) {
   });
   return index;
 }
-function walkRoutes(graph, byId, walkIndex, startId, endId) {
+function walkRoutes(graph, byId, walkIndex, startId, endId, fallback) {
+  if (!walkIndex) {
+    return { ...fallback(), walksLeave: false };
+  }
   const routes = [];
   let min = Infinity;
   let max = -Infinity;
@@ -165,12 +164,29 @@ function walkRoutes(graph, byId, walkIndex, startId, endId) {
     min = Math.min(min, route.bp);
     max = Math.max(max, route.bp);
   });
-  return routes.length || left ? { min, max, n: routes.length, left, routes } : void 0;
+  const walksLeave = left > 0;
+  return routes.length ? { min, max, n: routes.length, routes, walksLeave } : { ...fallback(), walksLeave };
+}
+function derivedBubble(place, segments, { min, max, n, routes }, partial) {
+  return {
+    ...place,
+    segmentCount: segments.length,
+    pathCount: n,
+    inversion: false,
+    shortestAlleleLength: min,
+    longestAlleleLength: max,
+    segments: segments.map((s) => s.name).join(","),
+    shortestAllele: void 0,
+    longestAllele: void 0,
+    partial,
+    routes
+  };
 }
 
 export {
   relax,
   bubblesFromGraph,
   walkIndexOf,
-  walkRoutes
+  walkRoutes,
+  derivedBubble
 };

package/dist/chunks/{chunk-FYQWPEEY.js → chunk-RJWPJCIB.js}

@@ -1,3 +1,7 @@
+import {
+  partitionPoint
+} from "./chunk-HOAIOEI7.js";
+
 // src/anchoredNodes.ts
 var REFERENCE_RANK = 0;
 function isAnchored(node) {
@@ -26,17 +30,7 @@ function backbonePositions(backbone) {
   return positions;
 }
 function firstNodeAtOrAfter(nodes, bp) {
-  let lo = 0;
-  let hi = nodes.length;
-  while (lo < hi) {
-    const mid = lo + hi >> 1;
-    if (nodes[mid].stable.start < bp) {
-      lo = mid + 1;
-    } else {
-      hi = mid;
-    }
-  }
-  return lo;
+  return partitionPoint(nodes.length, (i) => nodes[i].stable.start < bp);
 }
 function backboneSpan(backbone) {
   let min = Infinity;