@jbrowse/bandage-core 11.8.0 → 11.10.0

package/dist/bubbles/bubbleHalos.js

@@ -1,17 +1,17 @@
 import {
   bubbleHalos,
   coversGraph
-} from "../chunks/chunk-4YPCUVMC.js";
-import "../chunks/chunk-OIOAK7BS.js";
+} from "../chunks/chunk-SZYFZNCO.js";
+import "../chunks/chunk-NWEVR2OQ.js";
 import "../chunks/chunk-FX4RDMDN.js";
-import "../chunks/chunk-6CXLLJ2C.js";
+import "../chunks/chunk-AURNOR27.js";
 import "../chunks/chunk-HMXCN6PG.js";
 import "../chunks/chunk-AB35TJST.js";
-import "../chunks/chunk-YIWN32ZX.js";
-import "../chunks/chunk-3CXZUC2Y.js";
+import "../chunks/chunk-HNNP5QUN.js";
+import "../chunks/chunk-3GORESBG.js";
 import "../chunks/chunk-TLWXLNLY.js";
 import "../chunks/chunk-3YBP46PB.js";
-import "../chunks/chunk-735MPLUL.js";
+import "../chunks/chunk-JJV2GT2Z.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-ZPZ7GNBT.js";
 import "../chunks/chunk-BSOZW3FC.js";

package/dist/bubbles/classifyBubble.js

@@ -3,16 +3,16 @@ import {
   BUBBLE_KIND_NAMES,
   bubbleSegmentIds,
   classifyBubble
-} from "../chunks/chunk-OIOAK7BS.js";
+} from "../chunks/chunk-NWEVR2OQ.js";
 import "../chunks/chunk-FX4RDMDN.js";
-import "../chunks/chunk-6CXLLJ2C.js";
+import "../chunks/chunk-AURNOR27.js";
 import "../chunks/chunk-HMXCN6PG.js";
 import "../chunks/chunk-AB35TJST.js";
-import "../chunks/chunk-YIWN32ZX.js";
-import "../chunks/chunk-3CXZUC2Y.js";
+import "../chunks/chunk-HNNP5QUN.js";
+import "../chunks/chunk-3GORESBG.js";
 import "../chunks/chunk-TLWXLNLY.js";
 import "../chunks/chunk-3YBP46PB.js";
-import "../chunks/chunk-735MPLUL.js";
+import "../chunks/chunk-JJV2GT2Z.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-ZPZ7GNBT.js";
 import "../chunks/chunk-BSOZW3FC.js";

package/dist/bubbles/superbubbles.js

@@ -1,22 +1,22 @@
 import {
   graphBubbles,
   superbubblesFromGraph
-} from "../chunks/chunk-SIXFXXRI.js";
-import "../chunks/chunk-4YPCUVMC.js";
+} from "../chunks/chunk-J7RNXBXA.js";
+import "../chunks/chunk-SZYFZNCO.js";
 import "../chunks/chunk-RFG42VIO.js";
-import "../chunks/chunk-OIOAK7BS.js";
+import "../chunks/chunk-NWEVR2OQ.js";
 import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-MHZTTLBU.js";
 import "../chunks/chunk-UAFATXYA.js";
 import "../chunks/chunk-VX656OAZ.js";
-import "../chunks/chunk-6CXLLJ2C.js";
+import "../chunks/chunk-AURNOR27.js";
 import "../chunks/chunk-HMXCN6PG.js";
 import "../chunks/chunk-AB35TJST.js";
-import "../chunks/chunk-YIWN32ZX.js";
-import "../chunks/chunk-3CXZUC2Y.js";
+import "../chunks/chunk-HNNP5QUN.js";
+import "../chunks/chunk-3GORESBG.js";
 import "../chunks/chunk-TLWXLNLY.js";
 import "../chunks/chunk-3YBP46PB.js";
-import "../chunks/chunk-735MPLUL.js";
+import "../chunks/chunk-JJV2GT2Z.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-ZPZ7GNBT.js";
 import "../chunks/chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-S4CH434Z.js → chunk-2A6Z2DHF.js}

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

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

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

package/dist/chunks/{chunk-L2RQV23D.js → chunk-2NCZ5YYN.js}

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

package/dist/chunks/{chunk-ZKIH2USC.js → chunk-337LZP7C.js}

@@ -1,7 +1,7 @@
 import {
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-2H3ALI6L.js";
+} from "./chunk-53DZE3SA.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

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

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

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

@@ -9,7 +9,7 @@ import {
   edgeJoinOf,
   routedEdgeCurves,
   strandSides
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-R4XCTRIU.js → chunk-4BYGFDQB.js}

@@ -1,6 +1,6 @@
 import {
   ownStrand
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-NHOXLUIL.js → chunk-4JDO7ZLN.js}

@@ -1,7 +1,7 @@
 import {
   EdgeSpatialIndex,
   SpatialIndex
-} from "./chunk-7PEYA3NA.js";
+} from "./chunk-7YSIP3O2.js";
 import {
   weakMemo
 } from "./chunk-HMXCN6PG.js";
@@ -9,7 +9,7 @@ import {
   pathRibbonOffsets,
   translateCurves,
   yToXOf
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 
 // src/util/hitDetection.ts
 function distanceToSegment(px, py, x1, y1, x2, y2) {

package/dist/chunks/{chunk-7GDNDQD7.js → chunk-4KBZ7WPP.js}

@@ -1,6 +1,6 @@
 import {
   slideAt
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 
 // src/renderer/walkLanes.ts
 var THREAD_PX = 2;
@@ -53,9 +53,9 @@ function laneSlideAt(start, end, along) {
 }
 var gapOf = (a, b) => Math.hypot(b.x - a.x, b.y - a.y);
 function arcOf(run) {
-  const s = [0];
+  const s = new Float64Array(run.length);
   for (let i = 1; i < run.length; i++) {
-    s.push(s[i - 1] + gapOf(run[i - 1], run[i]));
+    s[i] = s[i - 1] + gapOf(run[i - 1], run[i]);
   }
   return s;
 }
@@ -63,9 +63,11 @@ function laneRuns(routes, nodePositions, yToX, jump) {
   const seen = /* @__PURE__ */ new Set();
   const owns = routes.map(
     (route) => route.map((id) => {
-      const first = !!nodePositions[id]?.length && !seen.has(id);
+      if (seen.has(id)) {
+        return false;
+      }
       seen.add(id);
-      return first;
+      return !!nodePositions[id]?.length;
     })
   );
   const gap = (a, b) => Math.hypot(b.x - a.x, b.y * yToX - a.y);
@@ -221,43 +223,46 @@ function cutCurls(run, close, length) {
   return out;
 }
 function rounded(run, half) {
+  const n = run.length;
   const s = arcOf(run);
-  const end = s.at(-1);
-  const sums = [{ w: 0, x: 0, y: 0 }];
-  run.forEach((p, i) => {
-    const w = (s[Math.min(i + 1, run.length - 1)] - s[Math.max(i - 1, 0)]) / 2;
-    const last = sums[i];
-    sums.push({ w: last.w + w, x: last.x + w * p.x, y: last.y + w * p.y });
-  });
-  const firstAtOrAfter = (at) => {
-    let lo = 0;
-    let hi = s.length;
-    while (lo < hi) {
-      const mid = lo + hi >> 1;
-      if (s[mid] < at) {
-        lo = mid + 1;
-      } else {
-        hi = mid;
-      }
-    }
-    return lo;
-  };
-  return run.map((p, i) => {
+  const end = s[n - 1];
+  const sumW = new Float64Array(n + 1);
+  const sumX = new Float64Array(n + 1);
+  const sumY = new Float64Array(n + 1);
+  for (let i = 0; i < n; i++) {
+    const p = run[i];
+    const w = (s[Math.min(i + 1, n - 1)] - s[Math.max(i - 1, 0)]) / 2;
+    sumW[i + 1] = sumW[i] + w;
+    sumX[i + 1] = sumX[i] + w * p.x;
+    sumY[i + 1] = sumY[i] + w * p.y;
+  }
+  const out = new Array(n);
+  let lo = 0;
+  let hi = 0;
+  for (let i = 0; i < n; i++) {
+    const p = run[i];
     const reach = Math.min(half, s[i], end - s[i]);
-    const lo = firstAtOrAfter(s[i] - reach);
-    const hi = firstAtOrAfter(s[i] + reach + 1e-9 * (1 + end));
-    const w = sums[hi].w - sums[lo].w;
-    return w > 0 ? {
-      x: (sums[hi].x - sums[lo].x) / w,
-      y: (sums[hi].y - sums[lo].y) / w
-    } : { x: p.x, y: p.y };
-  });
+    const from = s[i] - reach;
+    const to = s[i] + reach + 1e-9 * (1 + end);
+    while (lo < n && s[lo] < from) {
+      lo++;
+    }
+    while (hi < n && s[hi] < to) {
+      hi++;
+    }
+    const w = sumW[hi] - sumW[lo];
+    out[i] = w > 0 ? { x: (sumX[hi] - sumX[lo]) / w, y: (sumY[hi] - sumY[lo]) / w } : { x: p.x, y: p.y };
+  }
+  return out;
 }
 function fieldSetter(field, nodePositions) {
   return ({ id, index }, value) => {
-    const own = field.get(id) ?? new Array(nodePositions[id].length);
+    let own = field.get(id);
+    if (!own) {
+      own = new Array(nodePositions[id].length);
+      field.set(id, own);
+    }
     own[index] = value;
-    field.set(id, own);
   };
 }
 function laneLines(lanes, nodePositions, yToX, reach, band, smooth = true) {
@@ -351,17 +356,44 @@ function windowMean(s, v, half, counted = () => true) {
     return w > 0 ? (sumWV[hi] - sumWV[lo]) / w : value;
   });
 }
+var ONE_THREAD = [0];
+function repeats(passes) {
+  for (const p of passes.values()) {
+    if (p > 1) {
+      return true;
+    }
+  }
+  return false;
+}
 function walkThreads(route, passes, nodePositions, yToX, reach) {
-  if (![...passes.values()].some((p) => p > 1)) {
-    return { span: passes, nodeThreads: /* @__PURE__ */ new Map(), linkThreads: /* @__PURE__ */ new Map() };
+  if (!repeats(passes)) {
+    return {
+      span: passes,
+      nodeThreads: /* @__PURE__ */ new Map(),
+      threadPasses: /* @__PURE__ */ new Map(),
+      linkThreads: /* @__PURE__ */ new Map()
+    };
   }
-  const span = /* @__PURE__ */ new Map();
-  const visits = /* @__PURE__ */ new Map();
-  const wanted = /* @__PURE__ */ new Map();
+  const index = /* @__PURE__ */ new Map();
+  const ids = [];
+  const widths = [];
+  const visits = [];
   const steps = [];
+  const stepVisits = [];
+  const stepWants = [];
   for (const piece of route) {
     const points = [];
+    const nodes = [];
     for (const id of piece) {
+      let k = index.get(id);
+      if (k === void 0) {
+        k = ids.length;
+        index.set(id, k);
+        ids.push(id);
+        widths.push(0);
+        visits.push(0);
+      }
+      nodes.push(k);
       const segments = nodePositions[id];
       const mid = segments?.[Math.floor(segments.length / 2)];
       points.push(
@@ -371,85 +403,94 @@ function walkThreads(route, passes, nodePositions, yToX, reach) {
     const s = arcOf(points);
     const p = piece.map((id) => passes.get(id) ?? 1);
     const most = windowed(s, p, reach / 2, 1);
-    const copy = piece.map((id) => {
-      const visit = (visits.get(id) ?? 0) + 1;
-      visits.set(id, visit);
-      return visit;
-    });
-    const full = p.map((v, i) => v === most[i]);
-    const before = [];
+    const copy = nodes.map((k) => ++visits[k]);
+    const n = piece.length;
+    const before = new Int32Array(n);
     let last = -1;
-    for (let i = 0; i < piece.length; i++) {
-      last = full[i] ? i : last;
-      before.push(last);
+    for (let i = 0; i < n; i++) {
+      last = p[i] === most[i] ? i : last;
+      before[i] = last;
     }
-    const after = new Array(piece.length);
+    const after = new Int32Array(n);
     last = -1;
-    for (let i = piece.length - 1; i >= 0; i--) {
-      last = full[i] ? i : last;
+    for (let i = n - 1; i >= 0; i--) {
+      last = p[i] === most[i] ? i : last;
       after[i] = last;
     }
-    const own = [];
-    piece.forEach((id, i) => {
+    const wants = new Array(n);
+    for (let i = 0; i < n; i++) {
       const b = before[i];
       const a = after[i];
       const nearest = b < 0 ? a : a < 0 ? b : s[i] - s[b] <= s[a] - s[i] ? b : a;
-      const thread = Math.min(copy[nearest], most[i]) - 1;
-      span.set(id, Math.max(span.get(id) ?? 0, most[i]));
-      const list = wanted.get(id) ?? [];
-      list.push({ visit: copy[i], thread });
-      wanted.set(id, list);
-      own.push({ id, visit: copy[i] });
-    });
-    steps.push(own);
+      wants[i] = Math.min(copy[nearest], most[i]) - 1;
+      widths[nodes[i]] = Math.max(widths[nodes[i]], most[i]);
+    }
+    steps.push(nodes);
+    stepVisits.push(copy);
+    stepWants.push(wants);
   }
-  const threadOf = /* @__PURE__ */ new Map();
-  const nodeThreads = /* @__PURE__ */ new Map();
-  for (const [id, list] of wanted) {
-    const width = span.get(id);
-    const taken = /* @__PURE__ */ new Set();
-    const free = (want) => {
-      for (let d = 0; d < width; d++) {
-        for (const c of [want - d, want + d]) {
-          if (c >= 0 && c < width && !taken.has(c)) {
-            return c;
-          }
+  const taken = [];
+  const threadOf = [];
+  const free = (k, want) => {
+    const width = widths[k];
+    const own = taken[k] ??= /* @__PURE__ */ new Set();
+    for (let d = 0; d < width; d++) {
+      for (const c of [want - d, want + d]) {
+        if (c >= 0 && c < width && !own.has(c)) {
+          return c;
         }
       }
-      return want;
-    };
-    const byVisit = [];
-    for (const { visit, thread } of list) {
-      const t = free(thread);
-      taken.add(t);
-      byVisit[visit] = t;
     }
-    threadOf.set(id, byVisit);
+    return want;
+  };
+  steps.forEach((nodes, piece) => {
+    nodes.forEach((k, i) => {
+      if (widths[k] > 1) {
+        const t = free(k, stepWants[piece][i]);
+        taken[k].add(t);
+        (threadOf[k] ??= [])[stepVisits[piece][i]] = t;
+      }
+    });
+  });
+  const span = /* @__PURE__ */ new Map();
+  const nodeThreads = /* @__PURE__ */ new Map();
+  const threadPasses = /* @__PURE__ */ new Map();
+  ids.forEach((id, k) => {
+    span.set(id, widths[k]);
     nodeThreads.set(
       id,
-      [...taken].sort((a, b) => a - b)
+      taken[k] ? [...taken[k]].sort((a, b) => a - b) : ONE_THREAD
     );
-  }
+    const passOf = [];
+    threadOf[k]?.forEach((thread, visit) => {
+      passOf[thread] = visit - 1;
+    });
+    threadPasses.set(id, passOf);
+  });
   const linkThreads = /* @__PURE__ */ new Map();
-  for (const own of steps) {
-    own.forEach((cur, i) => {
-      const prev = own[i - 1];
-      if (!prev) {
-        return;
-      }
-      const key = `${prev.id}>${cur.id}`;
+  steps.forEach((nodes, piece) => {
+    const visit = stepVisits[piece];
+    for (let i = 1; i < nodes.length; i++) {
+      const from = nodes[i - 1];
+      const to = nodes[i];
       const pair = [
-        threadOf.get(prev.id)[prev.visit],
-        threadOf.get(cur.id)[cur.visit]
+        threadOf[from]?.[visit[i - 1]] ?? 0,
+        threadOf[to]?.[visit[i]] ?? 0
       ];
-      const list = linkThreads.get(key) ?? [];
-      if (!list.some(([a, b]) => a === pair[0] && b === pair[1])) {
+      let ahead = linkThreads.get(ids[from]);
+      if (!ahead) {
+        ahead = /* @__PURE__ */ new Map();
+        linkThreads.set(ids[from], ahead);
+      }
+      const list = ahead.get(ids[to]);
+      if (!list) {
+        ahead.set(ids[to], [pair]);
+      } else if (!list.some(([a, b]) => a === pair[0] && b === pair[1])) {
         list.push(pair);
       }
-      linkThreads.set(key, list);
-    });
-  }
-  return { span, nodeThreads, linkThreads };
+    }
+  });
+  return { span, nodeThreads, threadPasses, linkThreads };
 }
 function bandSpans(lanes, spans, { reach, taper }) {
   const out = /* @__PURE__ */ new Map();
@@ -480,6 +521,39 @@ function bandSpans(lanes, spans, { reach, taper }) {
   });
   return out;
 }
+function liftLanes(walks, nodePositions, yToX, worldPerScreenPx) {
+  const threaded = threadsPasses(walks);
+  const passes = walks.map((w) => w.mostPasses);
+  const reach = THREAD_REACH_PX * worldPerScreenPx;
+  const runs = laneRuns(
+    walks.flatMap((w) => w.route),
+    nodePositions,
+    yToX,
+    LANE_SMOOTHING_PX * worldPerScreenPx
+  );
+  const lines = laneLines(
+    runs,
+    nodePositions,
+    yToX,
+    LANE_SMOOTHING_PX * worldPerScreenPx,
+    bandWidthPx(passes) * (threaded ? bandScale(passes) : 1) * worldPerScreenPx,
+    threaded
+  );
+  const threads = threaded ? walks.map((w) => walkThreads(w.route, w.passes, nodePositions, yToX, reach)) : void 0;
+  const spans = threads ? bandSpans(
+    runs,
+    threads.map((t) => t.span),
+    { reach, taper: THREAD_TAPER_PX * worldPerScreenPx }
+  ) : void 0;
+  const furthestShift = { dx: 0, dy: 0 };
+  for (const own of lines.shifts.values()) {
+    for (const shift of own) {
+      furthestShift.dx = Math.max(furthestShift.dx, Math.abs(shift?.dx ?? 0));
+      furthestShift.dy = Math.max(furthestShift.dy, Math.abs(shift?.dy ?? 0));
+    }
+  }
+  return { lines, threads, spans, furthestShift };
+}
 
 export {
   THREAD_PX,
@@ -500,5 +574,6 @@ export {
   laneRuns,
   laneLines,
   walkThreads,
-  bandSpans
+  bandSpans,
+  liftLanes
 };