@jbrowse/bandage-core 11.12.0 → 11.13.0

package/dist/chunks/{chunk-5UIYXKTA.js → chunk-7AZ57C5C.js}

@@ -12,21 +12,21 @@ import {
 } from "./chunk-HEYIAMTC.js";
 import {
   version
-} from "./chunk-TOGXPJK7.js";
+} from "./chunk-OCYQIHFA.js";
 import {
   axisScaleOf
 } from "./chunk-OKPSS5PG.js";
 import {
   figureScene
-} from "./chunk-6ROK45LO.js";
+} from "./chunk-HL4U73TC.js";
 import {
   encodingStops
-} from "./chunk-JQYK6GVJ.js";
+} from "./chunk-EOB4Y3EM.js";
 import {
   laneSlideAt,
   passesKey,
   threadsPasses
-} from "./chunk-4KBZ7WPP.js";
+} from "./chunk-YUIKEUKY.js";
 import {
   abgrAlpha,
   abgrBlue,
@@ -247,7 +247,7 @@ function figureData(graph, layout, o = {}) {
             pass: s.pass ?? null,
             nx: s.normals?.[k]?.nx ?? 0,
             ny: s.normals?.[k]?.ny ?? 0,
-            offset: (s.offsetX ?? 0) * axis.scaleX
+            offset: (s.offsets?.[k] ?? s.offsetX ?? 0) * axis.scaleX
           });
         });
       }

package/dist/chunks/{chunk-QOY6SPOS.js → chunk-ANWUCJZB.js}

@@ -2,10 +2,10 @@ import {
   encodedColor,
   resolveEncoding,
   splitFamilies
-} from "./chunk-JQYK6GVJ.js";
+} from "./chunk-EOB4Y3EM.js";
 import {
   rampFraction
-} from "./chunk-EH5OIV2E.js";
+} from "./chunk-JUYPCLF4.js";
 import {
   gapParts
 } from "./chunk-LG2UK4MB.js";

package/dist/chunks/{chunk-Q2AMKXAX.js → chunk-C5FEIJFK.js}

@@ -5,7 +5,7 @@ import {
   stripGeneGaps,
   walkStripFrame,
   walkStripLabelsTree
-} from "./chunk-T2LYWZ5Q.js";
+} from "./chunk-QL673EK5.js";
 import {
   Canvas2DRenderer
 } from "./chunk-4DMSPNYV.js";
@@ -13,7 +13,7 @@ import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-A6ABMJR5.js";
+} from "./chunk-OYBYCF2O.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
@@ -30,21 +30,21 @@ import {
 } from "./chunk-HEYIAMTC.js";
 import {
   version
-} from "./chunk-TOGXPJK7.js";
+} from "./chunk-OCYQIHFA.js";
 import {
   axisScaleOf
 } from "./chunk-OKPSS5PG.js";
 import {
   figureScene
-} from "./chunk-6ROK45LO.js";
+} from "./chunk-HL4U73TC.js";
 import {
   encodingStops
-} from "./chunk-JQYK6GVJ.js";
+} from "./chunk-EOB4Y3EM.js";
 import {
   THREAD_PX,
   passesKey,
   threadsPasses
-} from "./chunk-4KBZ7WPP.js";
+} from "./chunk-YUIKEUKY.js";
 import {
   rangeText
 } from "./chunk-IZKM4NY7.js";

package/dist/chunks/{chunk-JQYK6GVJ.js → chunk-EOB4Y3EM.js}

@@ -1,7 +1,7 @@
 import {
   REFERENCE_RAMP_ALT_COLOR,
   hslToRgb
-} from "./chunk-EH5OIV2E.js";
+} from "./chunk-JUYPCLF4.js";
 import {
   packAbgr
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-6ROK45LO.js → chunk-HL4U73TC.js}

@@ -4,11 +4,11 @@ import {
 import {
   facetLifts,
   walkLift
-} from "./chunk-QOY6SPOS.js";
+} from "./chunk-ANWUCJZB.js";
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-EH5OIV2E.js";
+} from "./chunk-JUYPCLF4.js";
 import {
   walkKey
 } from "./chunk-IZKM4NY7.js";

package/dist/chunks/{chunk-EH5OIV2E.js → chunk-JUYPCLF4.js}

@@ -6,8 +6,9 @@ import {
   laneSlideAt,
   liftLanes,
   slotCentres,
-  threadsPasses
-} from "./chunk-4KBZ7WPP.js";
+  threadsPasses,
+  walkSteps
+} from "./chunk-YUIKEUKY.js";
 import {
   abgrToCssRgba,
   fadeAbgr,
@@ -214,9 +215,10 @@ function pointNormalsOf(rawPoints, yToX = 1) {
 function offsetPolyline(points, normals, distance, yToX = 1) {
   const out = new Array(points.length);
   for (let i = 0; i < points.length; i++) {
+    const d = typeof distance === "number" ? distance : distance[i];
     out[i] = {
-      x: points[i].x + normals[i].nx * distance,
-      y: points[i].y + normals[i].ny * distance / yToX
+      x: points[i].x + normals[i].nx * d,
+      y: points[i].y + normals[i].ny * d / yToX
     };
   }
   return out;
@@ -473,6 +475,7 @@ function pathSlotsOf(graph) {
   return slots;
 }
 var lanesCache = weakMemo();
+var stepsCache = weakMemo();
 var linksCache = /* @__PURE__ */ new WeakMap();
 function linksOf(graph) {
   let links = linksCache.get(graph);
@@ -550,7 +553,20 @@ function buildGeometry(options) {
   const fields = highlight && liftedWalks.length > 1 ? lanesCache(
     highlight,
     [nodePositions, version, axis.scaleX, axis.scaleY],
-    () => liftLanes(liftedWalks, nodePositions, yToX, worldPerScreenPx)
+    () => liftLanes(
+      liftedWalks,
+      nodePositions,
+      yToX,
+      worldPerScreenPx,
+      stepsCache(
+        highlight,
+        [nodePositions, version],
+        () => walkSteps(
+          liftedWalks.map((w) => w.route),
+          nodePositions
+        )
+      )
+    )
   ) : void 0;
   const lines = fields?.lines;
   const threads = fields?.threads;
@@ -567,14 +583,32 @@ function buildGeometry(options) {
     return centres;
   };
   const laneOffset = (nodeId, laneWidth, lane, pass) => threaded ? (centresOf(nodeId)[lane] + pass * THREAD_PITCH_PX) * thinned : (lane - (liftedWalks.length - 1) / 2) * laneWidth;
+  const threadOffsetAt = (frame, at, fallback) => {
+    const eased = frame?.offsets?.[at] ?? frame?.offset;
+    return eased === void 0 ? fallback : eased * 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);
+  const plainNormals = /* @__PURE__ */ new Map();
+  const visitNormals = /* @__PURE__ */ new WeakMap();
+  const visitOf = (lane, nodeId, thread) => threads?.[lane]?.threadPasses.get(nodeId)?.[thread] ?? 0;
+  const plainNormalsOf = (nodeId, segments) => {
+    let normals = plainNormals.get(nodeId);
+    if (!normals) {
+      normals = pointNormalsOf(segments, yToX);
+      plainNormals.set(nodeId, normals);
+    }
+    return normals;
+  };
+  const laneNormalsOf = (nodeId, segments, frame) => {
+    if (!frame) {
+      return plainNormalsOf(nodeId, segments);
+    }
+    let normals = visitNormals.get(frame.normals);
     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);
+      normals = plainNormalsOf(nodeId, segments).map(
+        (n, i) => frame.normals[i] ?? n
+      );
+      visitNormals.set(frame.normals, normals);
     }
     return normals;
   };
@@ -591,14 +625,14 @@ function buildGeometry(options) {
     }
     return width;
   };
-  const laneShiftOf = (nodeId, index) => lines?.shifts.get(nodeId)?.[index] ?? NO_SHIFT;
-  const laneEndOf = (id, segments, atStart) => {
+  const laneEndOf = (id, frames, segments, atStart, lane, thread) => {
     const at = atStart ? 0 : segments.length - 1;
+    const frame = frames?.[lane]?.[visitOf(lane, id, thread)];
+    const eased = frame?.offsets?.[at] ?? frame?.offset;
     return {
-      id,
-      laneWidth: laneWidthOf(id),
-      normal: laneNormalsOf(id, segments)[at] ?? { nx: 0, ny: 0 },
-      shift: laneShiftOf(id, at)
+      normal: frame?.normals[at] ?? plainNormalsOf(id, segments)[at] ?? { nx: 0, ny: 0 },
+      shift: frame?.shifts[at] ?? NO_SHIFT,
+      offset: eased === void 0 ? laneOffset(id, laneWidthOf(id), lane, thread) : eased * thinned
     };
   };
   const lanesMayShow = (curves, fromId) => {
@@ -628,10 +662,22 @@ function buildGeometry(options) {
     return ahead ? [...ahead, ...turned] : turned;
   };
   const threadColor = (lane, nodeId, thread) => liftedWalks[lane]?.passColors.get(nodeId)?.[threads?.[lane]?.threadPasses.get(nodeId)?.[thread] ?? 0];
-  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 visitPoints = /* @__PURE__ */ new WeakMap();
+  const lanePointsOf = (segments, frame) => {
+    if (!frame || !threaded) {
+      return segments;
+    }
+    let points = visitPoints.get(frame.shifts);
+    if (!points) {
+      const { shifts } = frame;
+      points = segments.map((p, i) => {
+        const { dx, dy } = shifts[i] ?? NO_SHIFT;
+        return { ...p, x: p.x + dx, y: p.y + dy };
+      });
+      visitPoints.set(frame.shifts, points);
+    }
+    return points;
+  };
   const showArrows = scale > (linearLayout ? 1 : MIN_ARROW_SCALE);
   for (let ei = 0; ei < graph.edges.length; ei++) {
     const edge = graph.edges[ei];
@@ -718,27 +764,40 @@ function buildGeometry(options) {
       continue;
     }
     if (laneWalks) {
-      const from = laneEndOf(
-        edge.from,
+      const fromAtStart = leavesStart(
+        edge,
         fromSegments,
-        leavesStart(edge, fromSegments, baseCurves[0], stranded, yToX)
+        baseCurves[0],
+        stranded,
+        yToX
       );
       const last = baseCurves.at(-1);
-      const to = threaded ? laneEndOf(
-        edge.to,
+      const toAtStart = nearerStart(
+        { x: last.x1, y: last.y1 },
         toSegments,
-        nearerStart({ x: last.x1, y: last.y1 }, toSegments, yToX)
-      ) : from;
+        yToX
+      );
       const single = laneWalks.length === 1;
-      const thickness = laneHalfWidth(from.laneWidth);
+      const thickness = laneHalfWidth(laneWidthOf(edge.from));
+      const fromFrames = lines?.frames.get(edge.from);
+      const toFrames = lines?.frames.get(edge.to);
       for (let lane = 0; lane < laneWalks.length; lane++) {
         const walk = laneWalks[lane];
         if (!walk.edgeIndexes.has(ei)) {
           continue;
         }
         for (const [pass, toPass] of threadPairs(lane, edge.from, edge.to)) {
-          const offsetX = single ? 0 : laneOffset(from.id, from.laneWidth, lane, pass) * worldPerScreenPx;
-          const endOffsetX = threaded ? laneOffset(to.id, to.laneWidth, lane, toPass) * worldPerScreenPx : offsetX;
+          const from = laneEndOf(
+            edge.from,
+            fromFrames,
+            fromSegments,
+            fromAtStart,
+            lane,
+            pass
+          );
+          const to = threaded ? laneEndOf(edge.to, toFrames, toSegments, toAtStart, lane, toPass) : from;
+          const offsetX = single ? 0 : from.offset * worldPerScreenPx;
+          const endOffsetX = threaded ? to.offset * worldPerScreenPx : offsetX;
           const curves = threaded ? slideCurves(
             baseCurves,
             from.shift.dx + from.normal.nx * offsetX,
@@ -832,9 +891,8 @@ 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 = lanes.length > 1 ? laneNormalsOf(nodeId, segments) : [];
-      const points = lanes.length > 1 ? lanePointsOf(nodeId, segments) : segments;
       const thickness = laneHalfWidth(laneWidth);
+      const frames = lines?.frames.get(nodeId);
       for (let lane = 0; lane < lanes.length; lane++) {
         const laneColor = lanes[lane].colors.get(nodeId);
         if (laneColor === void 0) {
@@ -853,15 +911,23 @@ function buildGeometry(options) {
             });
             continue;
           }
-          const offsetX = laneOffset(nodeId, laneWidth, lane, pass) * worldPerScreenPx;
+          const frame = frames?.[lane]?.[visitOf(lane, nodeId, pass)];
+          const normals = laneNormalsOf(nodeId, segments, frame);
+          const points = lanePointsOf(segments, frame);
+          const plain = laneOffset(nodeId, laneWidth, lane, pass);
+          const offsets = frame?.offsets?.map(
+            (o) => o * thinned * worldPerScreenPx
+          );
+          const offsetX = offsets ? offsets[Math.floor(offsets.length / 2)] : threadOffsetAt(frame, 0, plain) * worldPerScreenPx;
           nodeStrokes.push({
-            points: offsetPolyline(points, normals, offsetX, yToX),
+            points: offsetPolyline(points, normals, offsets ?? offsetX, yToX),
             thickness,
             color: color2,
             walk: lane,
             pass,
             normals,
-            offsetX
+            offsetX,
+            ...offsets && { offsets }
           });
         }
       }

package/dist/chunks/{chunk-GGFR4SYO.js → chunk-K4RGSISK.js}

@@ -2,7 +2,7 @@ import {
   LIFT_BACKDROP_CSS,
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-EH5OIV2E.js";
+} from "./chunk-JUYPCLF4.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-TOGXPJK7.js → chunk-OCYQIHFA.js}

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

package/dist/chunks/{chunk-A6ABMJR5.js → chunk-OYBYCF2O.js}

@@ -1,6 +1,6 @@
 import {
   REFERENCE_RAMP_ALT_CSS
-} from "./chunk-EH5OIV2E.js";
+} from "./chunk-JUYPCLF4.js";
 import {
   RAMP_GRADIENT_CSS,
   RAMP_GRADIENT_STOPS,

package/dist/chunks/{chunk-T2LYWZ5Q.js → chunk-QL673EK5.js}

@@ -3,7 +3,7 @@ import {
   boxesGenes,
   rowPitch,
   rowSpan
-} from "./chunk-A6ABMJR5.js";
+} from "./chunk-OYBYCF2O.js";
 import {
   READOUT_ROOM,
   longestBar