@jbrowse/bandage-core 10.2.7 → 10.3.1

package/dist/chunks/{chunk-LKW2TP4N.js → chunk-OOIOX36I.js}

@@ -1,10 +1,13 @@
 import {
   pathOrigin
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-B5X2RLJG.js";
+import {
+  groupBy
+} from "./chunk-BSOZW3FC.js";
 import {
   panSNContig,
   panSNSample
-} from "./chunk-BPLIXMH7.js";
+} from "./chunk-4XWZNPQ2.js";
 
 // src/layout/walkRows.ts
 function sampleOf(path) {
@@ -150,29 +153,27 @@ function filterSamples(rows, samples) {
     (a, b) => samples.indexOf(a.sample) - samples.indexOf(b.sample) || a.label.localeCompare(b.label)
   ) : rows;
 }
-function walkRows(graph, region, unit) {
-  const paths = graph.paths ?? [];
-  const nameOf = (p) => pathOrigin(p.name).name;
+function referenceWalkName(graph) {
+  const names = (graph.paths ?? []).map((p) => pathOrigin(p.name).name);
+  if (graph.referencePath !== void 0 && names.includes(graph.referencePath)) {
+    return graph.referencePath;
+  }
   const rankZero = new Set(
     graph.nodes.flatMap((n) => n.stable?.rank === 0 ? [n.stable.refName] : [])
   );
-  const names = paths.map(nameOf);
-  const referenceName = graph.referencePath !== void 0 && names.includes(graph.referencePath) ? graph.referencePath : names.find((n) => rankZero.has(n)) ?? names[0];
+  return names.find((n) => rankZero.has(n)) ?? names[0];
+}
+function walkRows(graph, region, unit) {
+  const paths = graph.paths ?? [];
+  const nameOf = (p) => pathOrigin(p.name).name;
+  const referenceName = referenceWalkName(graph);
   const referencePieces = paths.filter((p) => nameOf(p) === referenceName).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
   const first = referencePieces[0];
   const others = paths.filter((p) => !referencePieces.includes(p));
   if (!first || others.length === 0) {
     return void 0;
   }
-  const walks = /* @__PURE__ */ new Map();
-  for (const path of others) {
-    const pieces = walks.get(path.name);
-    if (pieces) {
-      pieces.push(path);
-    } else {
-      walks.set(path.name, [path]);
-    }
-  }
+  const walks = groupBy(others, nameOf);
   const table = new NodeTable(graph);
   const referenceStart = first.start ?? 0;
   const cut = region && region.end > region.start ? region : void 0;
@@ -285,5 +286,6 @@ function walkRows(graph, region, unit) {
 
 export {
   filterSamples,
+  referenceWalkName,
   walkRows
 };

package/dist/chunks/{chunk-EQ2NIFRH.js → chunk-OXRUPNSV.js}

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

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-PNMJFFNB.js}

@@ -1,6 +1,6 @@
 import {
   trimOrigins
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-B5X2RLJG.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-23YFB5BB.js → chunk-QH2MIXBA.js}

@@ -4,37 +4,41 @@ import {
 import {
   facetLifts,
   walkLift
-} from "./chunk-CU6P5RUG.js";
+} from "./chunk-YZQI35UJ.js";
+import {
+  walkKey
+} from "./chunk-CGFPFBT2.js";
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-A4PFFC4Q.js";
+} from "./chunk-SWCULW6S.js";
 import {
   walkRowsExtent
-} from "./chunk-L2HDM2R3.js";
+} from "./chunk-A2TJ5UX6.js";
 import {
   pathLegend,
   walkLabelsOf
-} from "./chunk-3XSM4OZU.js";
+} from "./chunk-3GP3KT5L.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-AUFAPUO4.js";
+} from "./chunk-D7WIYPG3.js";
 import {
   drawingBounds
-} from "./chunk-QXUEF3AJ.js";
+} from "./chunk-KMBE2Q42.js";
 import {
   referenceLabel
-} from "./chunk-RAKOB6IV.js";
+} from "./chunk-234NFZS4.js";
 import {
   resolveColorScheme
 } from "./chunk-JKJWSY4V.js";
 import {
   deletionDrawing,
   deletionEdges
-} from "./chunk-24WITXQY.js";
+} from "./chunk-CGMSKIEO.js";
 import {
+  facetCells,
   facetSettingOf
-} from "./chunk-XV4P5KEQ.js";
+} from "./chunk-TGUFT6KK.js";
 
 // src/figureScene.ts
 function figureScene(graph, layout, o) {
@@ -61,12 +65,24 @@ function figureScene(graph, layout, o) {
   const lift = layers.length > 0 && !layout.tubeMap ? walkLift(graph, layers, walkRamp) : void 0;
   const facet = facetSettingOf(o.facet);
   const panels = facet.field && lift && lift.walks.length > 1 ? facetLifts(graph, lift, layers, walkRamp) : void 0;
+  const facets = facet.field && panels ? {
+    panels,
+    place: facetCells(
+      panels.map((p) => p.walks[0].name),
+      facet.field,
+      facet.domain
+    )
+  } : void 0;
   const labels = walkLabelsOf(
     graph.paths?.length ? pathLegend(graph.paths) : []
   );
   const referenceName = o.referenceName ?? referenceLabel(graph, region);
   const contigThickness = o.contigThickness ?? FIGURE_DEFAULTS.contigThickness;
   const nodeWidth = o.nodeWidth ?? FIGURE_DEFAULTS.nodeWidth;
+  const reference = lift?.referenceDomain && {
+    ...lift.referenceDomain,
+    name: referenceName
+  };
   return {
     bounds,
     nodeById,
@@ -76,12 +92,12 @@ function figureScene(graph, layout, o) {
     layers,
     lift,
     facet,
-    panels,
+    facets,
     labelOf: (name) => labels.get(name) ?? name,
     referenceName,
-    reference: lift?.referenceDomain && {
-      ...lift.referenceDomain,
-      name: referenceName
+    keyText: (walk) => {
+      const key = walkKey(walk, reference);
+      return { note: key.delta + key.outside + key.reversed, scale: key.scale };
     },
     contigThickness,
     nodeWidth,

package/dist/chunks/{chunk-5GMFEPWR.js → chunk-R2PJKD3Y.js}

@@ -1,29 +1,27 @@
 import {
   pathSteps
-} from "./chunk-XI3ZUTWF.js";
+} from "./chunk-FW2R7UDZ.js";
 import {
   pathOrigin
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-B5X2RLJG.js";
+import {
+  pushTo
+} from "./chunk-BSOZW3FC.js";
 
 // src/tubeMap/bundle.ts
 function bundleRoutes(graph, groupOf = () => "", merge = true) {
   const paths = graph.paths ?? [];
   const steps = pathSteps(graph);
-  const routes = /* @__PURE__ */ new Map();
+  const piecesOf = /* @__PURE__ */ new Map();
   paths.forEach((path, i) => {
-    const walk = pathOrigin(path.name).name;
-    const route = steps[i].map((s) => `${s.node.id}${s.strand}`).join(",");
-    const pieces = routes.get(walk);
-    if (pieces) {
-      pieces.push(route);
-    } else {
-      routes.set(walk, [route]);
-    }
+    pushTo(piecesOf, pathOrigin(path.name).name, i);
   });
+  const routeOf = (i) => steps[i].map((s) => `${s.node.id}${s.strand}`).join(",");
+  const recordsOf = (walk) => piecesOf.get(walk).map((i) => paths[i]);
   const routeRank = /* @__PURE__ */ new Map();
   const bundles = /* @__PURE__ */ new Map();
-  for (const [walk, pieces] of routes) {
-    const route = walk === graph.referencePath ? `\0${walk}` : pieces.join("|");
+  for (const [walk, pieces] of piecesOf) {
+    const route = walk === graph.referencePath ? `\0${walk}` : pieces.map(routeOf).join("|");
     const group = groupOf(walk);
     const rank = routeRank.get(route) ?? routeRank.size;
     routeRank.set(route, rank);
@@ -35,32 +33,22 @@ function bundleRoutes(graph, groupOf = () => "", merge = true) {
       bundles.set(key, { rank, group, walks: [walk] });
     }
   }
-  if (merge && bundles.size === routes.size) {
+  if (merge && bundles.size === piecesOf.size) {
     return graph;
   }
   const ordered = [...bundles.values()].sort(
     (a, b) => a.rank - b.rank || a.group.localeCompare(b.group)
   );
-  const recordsOf = /* @__PURE__ */ new Map();
-  for (const path of paths) {
-    const walk = pathOrigin(path.name).name;
-    const records = recordsOf.get(walk);
-    if (records) {
-      records.push(path);
-    } else {
-      recordsOf.set(walk, [path]);
-    }
-  }
   if (!merge) {
     return {
       ...graph,
-      paths: ordered.flatMap(
-        ({ walks }) => walks.flatMap((walk) => recordsOf.get(walk))
-      )
+      paths: ordered.flatMap(({ walks }) => walks.flatMap(recordsOf))
     };
   }
   const kept = ordered.flatMap(
-    ({ walks }) => recordsOf.get(walks[0]).map((path) => walks.length > 1 ? { ...path, members: walks } : path)
+    ({ walks }) => recordsOf(walks[0]).map(
+      (path) => walks.length > 1 ? { ...path, members: walks } : path
+    )
   );
   const keptWalks = new Set(ordered.map((b) => b.walks[0]));
   return {

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;