@jbrowse/bandage-core 11.7.1 → 11.8.0

package/dist/chunks/{chunk-VB4IXIPM.js → chunk-2H3ALI6L.js}

@@ -1,3 +1,19 @@
+import {
+  LANE_SMOOTHING_PX,
+  THREAD_PITCH_PX,
+  THREAD_PX,
+  THREAD_REACH_PX,
+  THREAD_TAPER_PX,
+  bandScale,
+  bandSpans,
+  bandWidthPx,
+  laneLines,
+  laneRuns,
+  laneSlideAt,
+  slotCentres,
+  threadsPasses,
+  walkThreads
+} from "./chunk-7GDNDQD7.js";
 import {
   abgrToCssRgba,
   fadeAbgr,
@@ -10,13 +26,13 @@ import {
 } from "./chunk-GQZVR5DW.js";
 import {
   baseEdgeCurves
-} from "./chunk-XTF2VWJN.js";
+} from "./chunk-VSRRIFRF.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-3UGWYQNY.js";
+} from "./chunk-JKIAHYAW.js";
 import {
   meanDepth,
   nodeWidthPx,
@@ -26,13 +42,14 @@ import {
   referenceMidpoints
 } from "./chunk-VX656OAZ.js";
 import {
-  dashCurves,
+  dashSpans,
   pathRibbonOffsets,
   polylinePx,
+  slideCurves,
   strandSides,
   translateCurves,
   yToXOf
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";
@@ -149,13 +166,16 @@ function arrowheadFor({
     color
   };
 }
-function leavesStart(edge, segments, first, stranded, yToX) {
-  if (stranded) {
-    return strandSides(edge).from === "start";
-  }
-  const gap = (p) => Math.hypot(p.x - first.x0, (p.y - first.y0) * yToX);
+var FIRST_THREADS = [[0, 0]];
+var ONE_PASS = [0];
+var NO_SHIFT = { dx: 0, dy: 0 };
+function nearerStart(at, segments, yToX) {
+  const gap = (p) => Math.hypot(p.x - at.x, (p.y - at.y) * yToX);
   return gap(segments[0]) < gap(segments.at(-1));
 }
+function leavesStart(edge, segments, first, stranded, yToX) {
+  return stranded ? strandSides(edge).from === "start" : nearerStart({ x: first.x0, y: first.y0 }, segments, yToX);
+}
 function intoDirection(last, toSegments) {
   if (toSegments.length < 2) {
     return void 0;
@@ -496,6 +516,74 @@ function buildGeometry(options) {
   const { pathColorByIndex, pathIndexByName } = pathPaletteOf(graph);
   const pathColorByName = (name) => pathColorByIndex[pathIndexByName.get(name) ?? -1] ?? EDGE_PATH_FALLBACK_COLOR;
   const nodePathSlots = drawPaths && pathCount > 1 ? pathSlotsOf(graph) : NO_SLOTS;
+  const liftedWalks = highlight?.walks ?? [];
+  const threaded = threadsPasses(liftedWalks);
+  const lanePasses = liftedWalks.map((w) => w.mostPasses);
+  const thinned = threaded ? bandScale(lanePasses) : 1;
+  const runs = liftedWalks.length > 1 ? laneRuns(
+    liftedWalks.flatMap((w) => w.route),
+    nodePositions,
+    yToX,
+    LANE_SMOOTHING_PX * worldPerScreenPx
+  ) : void 0;
+  const lines = runs ? laneLines(
+    runs,
+    nodePositions,
+    yToX,
+    LANE_SMOOTHING_PX * worldPerScreenPx,
+    bandWidthPx(lanePasses) * thinned * worldPerScreenPx,
+    threaded
+  ) : void 0;
+  const threads = threaded ? liftedWalks.map(
+    (w) => walkThreads(
+      w.route,
+      w.passes,
+      nodePositions,
+      yToX,
+      THREAD_REACH_PX * worldPerScreenPx
+    )
+  ) : void 0;
+  const spanField = runs && threads ? bandSpans(
+    runs,
+    threads.map((t) => t.span),
+    {
+      reach: THREAD_REACH_PX * worldPerScreenPx,
+      taper: THREAD_TAPER_PX * worldPerScreenPx
+    }
+  ) : void 0;
+  const edgeKeys = new Set(
+    threads ? graph.edges.map((e) => `${e.from}>${e.to}`) : []
+  );
+  const centresByNode = /* @__PURE__ */ new Map();
+  const laneOffset = (nodeId, laneWidth, lane, pass) => {
+    if (!threaded) {
+      return (lane - (liftedWalks.length - 1) / 2) * laneWidth;
+    }
+    let centres = centresByNode.get(nodeId);
+    if (!centres) {
+      const spans = spanField?.get(nodeId);
+      centres = slotCentres(spans?.slot ?? lanePasses, lanePasses, spans?.held);
+      centresByNode.set(nodeId, centres);
+    }
+    return (centres[lane] + pass * THREAD_PITCH_PX) * thinned;
+  };
+  const laneHalfWidth = (laneWidth) => threaded ? THREAD_PX / 2 * thinned : laneWidth / 2;
+  const laneNormals = /* @__PURE__ */ new Map();
+  const laneNormalsOf = (nodeId, segments) => {
+    let normals = laneNormals.get(nodeId);
+    if (!normals) {
+      const smoothed = lines?.normals.get(nodeId);
+      normals = smoothed ? pointNormalsOf(segments, yToX).map((n, i) => smoothed[i] ?? n) : pointNormalsOf(segments, yToX);
+      laneNormals.set(nodeId, normals);
+    }
+    return normals;
+  };
+  const laneWidths = /* @__PURE__ */ new Map();
+  const laneShiftOf = (nodeId, index) => lines?.shifts.get(nodeId)?.[index] ?? NO_SHIFT;
+  const lanePointsOf = (nodeId, segments) => lines?.shifts.has(nodeId) ? segments.map((p, i) => {
+    const { dx, dy } = laneShiftOf(nodeId, i);
+    return { ...p, x: p.x + dx, y: p.y + dy };
+  }) : segments;
   const showArrows = scale > (linearLayout ? 1 : MIN_ARROW_SCALE);
   for (let ei = 0; ei < graph.edges.length; ei++) {
     const edge = graph.edges[ei];
@@ -516,18 +604,37 @@ function buildGeometry(options) {
     const toNode = nodeById.get(edge.to);
     const intoHalfWidth = (toNode ? nodeWidthPx(toNode, contigThickness, nodeWidth, depthNorm) : contigThickness) / 2;
     const inView = (curves) => !viewportBounds || isBezierInBounds(curves, viewportBounds);
-    const stroke = (curves, thickness, color) => {
-      if (isDeletion) {
-        for (const dash of dashCurves(
-          curves,
-          DELETION_DASH_PX / scale,
-          yToX,
-          viewportBounds
-        )) {
-          edgeCurves.push({ curves: dash, thickness, color });
+    const stroke = (curves, thickness, color, lane) => {
+      const push = (pieces, from = 0, to = 1) => {
+        if (!lane) {
+          edgeCurves.push({ curves: pieces, thickness, color });
+          return;
         }
-      } else {
-        edgeCurves.push({ curves, thickness, color });
+        const start = from === 0 ? lane.start : laneSlideAt(lane.start, lane.end, from);
+        const end = to === 1 ? lane.end : laneSlideAt(lane.start, lane.end, to);
+        edgeCurves.push({
+          curves: pieces,
+          thickness,
+          color,
+          walk: lane.walk,
+          pass: lane.pass,
+          normal: start.normal,
+          offsetX: start.offsetX,
+          endNormal: end.normal,
+          endOffsetX: end.offsetX
+        });
+      };
+      if (!isDeletion) {
+        push(curves);
+        return;
+      }
+      for (const dash of dashSpans(
+        curves,
+        DELETION_DASH_PX / scale,
+        yToX,
+        viewportBounds
+      )) {
+        push(dash.curves, dash.startAlong, dash.endAlong);
       }
     };
     const arrowOn = (curves) => {
@@ -549,32 +656,86 @@ function buildGeometry(options) {
     const arrowStart = arrows.length;
     const laneWalks = highlight?.walks.length && onWalk && !ribbons ? highlight.walks : void 0;
     if (laneWalks) {
-      const fromNode = nodeById.get(edge.from);
-      const width = fromNode ? nodeWidthPx(fromNode, contigThickness, nodeWidth, depthNorm) : contigThickness;
-      const laneWidth = walkLaneWidthPx(width, laneWalks.length);
-      const normals = pointNormalsOf(fromSegments, yToX);
-      const { nx, ny } = (leavesStart(
-        edge,
+      const laneWidthOf = (id) => {
+        let width = laneWidths.get(id);
+        if (width === void 0) {
+          const node = nodeById.get(id);
+          width = walkLaneWidthPx(
+            node ? nodeWidthPx(node, contigThickness, nodeWidth, depthNorm) : contigThickness,
+            laneWalks.length
+          );
+          laneWidths.set(id, width);
+        }
+        return width;
+      };
+      const endOf = (id, segments, atStart) => {
+        const at = atStart ? 0 : segments.length - 1;
+        return {
+          id,
+          laneWidth: laneWidthOf(id),
+          normal: laneNormalsOf(id, segments)[at] ?? { nx: 0, ny: 0 },
+          shift: laneShiftOf(id, at)
+        };
+      };
+      const from = endOf(
+        edge.from,
         fromSegments,
-        baseCurves[0],
-        stranded,
-        yToX
-      ) ? normals[0] : normals.at(-1)) ?? {
-        nx: 0,
-        ny: 0
+        leavesStart(edge, fromSegments, baseCurves[0], stranded, yToX)
+      );
+      const last = baseCurves.at(-1);
+      const to = threaded ? endOf(
+        edge.to,
+        toSegments,
+        nearerStart({ x: last.x1, y: last.y1 }, toSegments, yToX)
+      ) : from;
+      const slideOf = (end, offsetX) => ({
+        dx: end.shift.dx + end.normal.nx * offsetX,
+        dy: end.shift.dy + end.normal.ny * offsetX / yToX
+      });
+      const aheadKey = threads ? `${edge.from}>${edge.to}` : "";
+      const backKey = threads ? `${edge.to}>${edge.from}` : "";
+      const pairsOf = (lane) => {
+        const own = threads?.[lane]?.linkThreads;
+        if (!own?.size) {
+          return FIRST_THREADS;
+        }
+        const ahead = own.get(aheadKey);
+        const back = edgeKeys.has(backKey) ? void 0 : own.get(backKey);
+        if (!back) {
+          return ahead ?? FIRST_THREADS;
+        }
+        const turned = back.map(([a, b]) => [b, a]);
+        return ahead ? [...ahead, ...turned] : turned;
       };
+      const single = laneWalks.length === 1;
       laneWalks.forEach((walk, lane) => {
         if (!walk.edgeIndexes.has(ei)) {
           return;
         }
-        const offset = (lane - (laneWalks.length - 1) / 2) * laneWidth * worldPerScreenPx;
-        const curves = offset === 0 ? baseCurves : translateCurves(baseCurves, nx * offset, ny * offset / yToX);
-        if (inView(curves)) {
-          stroke(
-            curves,
-            laneWidth / 2,
-            walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor
+        for (const [pass, toPass] of pairsOf(lane)) {
+          const offsetX = single ? 0 : laneOffset(from.id, from.laneWidth, lane, pass) * worldPerScreenPx;
+          const start = { normal: from.normal, offsetX };
+          const end = threaded ? {
+            normal: to.normal,
+            offsetX: laneOffset(to.id, to.laneWidth, lane, toPass) * worldPerScreenPx
+          } : start;
+          const curves = threaded ? slideCurves(
+            baseCurves,
+            slideOf(from, start.offsetX),
+            slideOf(to, end.offsetX)
+          ) : offsetX === 0 ? baseCurves : translateCurves(
+            baseCurves,
+            from.normal.nx * offsetX,
+            from.normal.ny * offsetX / yToX
           );
+          if (inView(curves)) {
+            stroke(
+              curves,
+              laneHalfWidth(from.laneWidth),
+              walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor,
+              { walk: lane, pass, start, end }
+            );
+          }
         }
       });
       if (edgeCurves.length > edgeCurveStart) {
@@ -644,17 +805,34 @@ function buildGeometry(options) {
     const lanes = highlight?.walks.length && !faded && !slots?.length ? highlight.walks : void 0;
     if (drawable && lanes) {
       const laneWidth = walkLaneWidthPx(width, lanes.length);
-      const normals = pointNormalsOf(segments, yToX);
+      const normals = lanes.length > 1 ? laneNormalsOf(nodeId, segments) : [];
+      const points = lanes.length > 1 ? lanePointsOf(nodeId, segments) : segments;
       lanes.forEach((walk, lane) => {
         const laneColor = walk.colors.get(nodeId);
         if (laneColor === void 0) {
           return;
         }
-        const offset = (lane - (lanes.length - 1) / 2) * laneWidth * worldPerScreenPx;
-        nodeStrokes.push({
-          points: lanes.length === 1 ? segments : offsetPolyline(segments, normals, offset, yToX),
-          thickness: laneWidth / 2,
-          color: laneColor
+        const onThreads = threads?.[lane]?.nodeThreads.get(nodeId) ?? ONE_PASS;
+        const thickness = laneHalfWidth(laneWidth);
+        onThreads.forEach((pass) => {
+          const offsetX = lanes.length === 1 ? 0 : laneOffset(nodeId, laneWidth, lane, pass) * worldPerScreenPx;
+          nodeStrokes.push(
+            lanes.length === 1 ? {
+              points: segments,
+              thickness,
+              color: laneColor,
+              walk: lane,
+              pass
+            } : {
+              points: offsetPolyline(points, normals, offsetX, yToX),
+              thickness,
+              color: laneColor,
+              walk: lane,
+              pass,
+              normals,
+              offsetX
+            }
+          );
         });
       });
     } else if (drawable && slots?.length && slotWidth >= MIN_PATH_STRIPE_PX) {

package/dist/chunks/{chunk-FBPAX5K6.js → chunk-2RCKHCF7.js}

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

package/dist/chunks/{chunk-5NZRT7GL.js → chunk-3CXZUC2Y.js}

@@ -9,7 +9,7 @@ import {
   edgeJoinOf,
   routedEdgeCurves,
   strandSides
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";
@@ -131,7 +131,7 @@ function deletionEdges(cut) {
     const edge = graph.edges[edgeIndex];
     const from = byId.get(edge.from);
     const to = byId.get(edge.to);
-    if (from !== void 0 && to !== void 0 && isBackbone(from) && isBackbone(to) && from.stable.refName === to.stable.refName) {
+    if (!edge.foldBridge && from !== void 0 && to !== void 0 && isBackbone(from) && isBackbone(to) && from.stable.refName === to.stable.refName) {
       const span = skippedSpan(edge, from, to, startsOf);
       const refName = from.stable.refName;
       const bp = span ? span.end - span.start : 0;

package/dist/chunks/{chunk-WUZH2OJ6.js → chunk-3XYLEK4H.js}

@@ -3,7 +3,7 @@ import {
   hasTubeMapPaths,
   tubeMapLayout,
   tubeMapReferenceLayout
-} from "./chunk-RB2MDFQU.js";
+} from "./chunk-G4WQBRDS.js";
 import {
   sampleRowLayout
 } from "./chunk-XR2HMGAS.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-UAFATXYA.js";
 import {
   walkRowLayout
-} from "./chunk-SENPGW4O.js";
+} from "./chunk-VCUOYVLC.js";
 import {
   isBackbone,
   isOffReference

package/dist/chunks/{chunk-F7O56DVR.js → chunk-4OVIUCSB.js}

@@ -3,14 +3,14 @@ import {
   boxesGenes,
   rowPitch,
   rowSpan
-} from "./chunk-6XDTAKO7.js";
+} from "./chunk-LA6JHEVV.js";
 import {
   el
 } from "./chunk-H2H4Y3TV.js";
 import {
   READOUT_ROOM,
   longestBar
-} from "./chunk-SENPGW4O.js";
+} from "./chunk-VCUOYVLC.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/chunks/{chunk-JGH2V54E.js → chunk-4YPCUVMC.js}

@@ -1,10 +1,10 @@
 import {
   bubbleSegmentIds,
   classifyBubble
-} from "./chunk-3Y2EFDID.js";
+} from "./chunk-OIOAK7BS.js";
 import {
   svgPath
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   isBackbone
 } from "./chunk-RJWPJCIB.js";

package/dist/chunks/{chunk-FU57ZNRQ.js → chunk-6CXLLJ2C.js}

@@ -7,15 +7,15 @@ import {
 } from "./chunk-AB35TJST.js";
 import {
   polylineMidpoint
-} from "./chunk-2VMKQKVO.js";
+} from "./chunk-YIWN32ZX.js";
 import {
   edgeCurvesOf
-} from "./chunk-5NZRT7GL.js";
+} from "./chunk-3CXZUC2Y.js";
 import {
   curveBounds,
   curveMidpoint,
   polylinePx
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 
 // src/graphLabels.ts
 var MIN_DELETION_LABEL_PX = 26;

package/dist/chunks/{chunk-SACSQ45G.js → chunk-6MD4VS2F.js}

@@ -1,6 +1,6 @@
 import {
   ENGINE_DEFAULTS
-} from "./chunk-HTF32WSW.js";
+} from "./chunk-S3ICPPXC.js";
 
 // src/figureSettings.ts
 var FIGURE_DEFAULTS = {

package/dist/chunks/{chunk-VACK24HF.js → chunk-735MPLUL.js}

@@ -97,7 +97,8 @@ function visibleStretches(curves, lengths, bounds, yToX) {
   });
   return stretches;
 }
-function dashCurves(curves, dashWorld, yToX = 1, bounds) {
+var dashCurves = (curves, dashWorld, yToX = 1, bounds) => dashSpans(curves, dashWorld, yToX, bounds).map((d) => d.curves);
+function dashSpans(curves, dashWorld, yToX = 1, bounds) {
   const lengths = curves.map(
     (c) => Math.hypot(c.cx0 - c.x0, (c.cy0 - c.y0) * yToX) + Math.hypot(c.cx1 - c.cx0, (c.cy1 - c.cy0) * yToX) + Math.hypot(c.x1 - c.cx1, (c.y1 - c.cy1) * yToX)
   );
@@ -122,27 +123,49 @@ function dashCurves(curves, dashWorld, yToX = 1, bounds) {
       }
     }
     const dash = [];
+    const along = [];
     let start = 0;
     curves.forEach((c, k) => {
       const length = lengths[k];
       const end = start + length;
       if (length > 0 && end > from && start < to) {
-        dash.push(
-          subCurve(
-            c,
-            Math.max(0, (from - start) / length),
-            Math.min(1, (to - start) / length)
-          )
-        );
+        const t0 = Math.max(0, (from - start) / length);
+        const t1 = Math.min(1, (to - start) / length);
+        dash.push(subCurve(c, t0, t1));
+        along.push((k + t0) / curves.length, (k + t1) / curves.length);
       }
       start = end;
     });
     if (dash.length) {
-      out.push(dash);
+      out.push({
+        curves: dash,
+        startAlong: along[0],
+        endAlong: along.at(-1)
+      });
     }
   }
   return out;
 }
+var slideAt = (from, to, along) => ({
+  dx: from.dx + (to.dx - from.dx) * along,
+  dy: from.dy + (to.dy - from.dy) * along
+});
+function slideCurves(curves, from, to) {
+  return curves.map((c, i) => {
+    const a = slideAt(from, to, i / curves.length);
+    const b = slideAt(from, to, (i + 1) / curves.length);
+    return {
+      x0: c.x0 + a.dx,
+      y0: c.y0 + a.dy,
+      cx0: c.cx0 + a.dx,
+      cy0: c.cy0 + a.dy,
+      cx1: c.cx1 + b.dx,
+      cy1: c.cy1 + b.dy,
+      x1: c.x1 + b.dx,
+      y1: c.y1 + b.dy
+    };
+  });
+}
 function translateCurves(curves, dx, dy) {
   const out = new Array(curves.length);
   for (let i = 0; i < curves.length; i++) {
@@ -555,6 +578,9 @@ export {
   curveMidpoint,
   curveBounds,
   dashCurves,
+  dashSpans,
+  slideAt,
+  slideCurves,
   translateCurves,
   ownStrand,
   strandSides,