@jbrowse/bandage-core 9.1.0 → 9.2.0

package/dist/bubbles/superbubbles.js

@@ -2,11 +2,11 @@ import {
   MAX_SUPERBUBBLES,
   graphBubbles,
   superbubblesFromGraph
-} from "../chunks/chunk-FUVI4WQP.js";
+} from "../chunks/chunk-ZDJDM77V.js";
 import "../chunks/chunk-VHW7FDHU.js";
 import "../chunks/chunk-2AWUWGAD.js";
-import "../chunks/chunk-GOZYKNQ2.js";
 import "../chunks/chunk-XKWD2RY3.js";
+import "../chunks/chunk-GOZYKNQ2.js";
 import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-HNQPEMYE.js";
 import "../chunks/chunk-ST2IBUAN.js";

package/dist/chunks/{chunk-FFFQNQUI.js → chunk-A4MYLGKG.js}

@@ -1,7 +1,7 @@
 import {
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/chunk-B4645SM2.js

@@ -0,0 +1,358 @@
+import {
+  ownStrand
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/foldVariants.ts
+function foldVariants(graph, belowBp) {
+  if (!(belowBp > 0) || graph.paths?.length || !graph.nodes.some((node) => isBackbone(node))) {
+    return graph;
+  }
+  const { nodes, edges } = graph;
+  const index = new Map(nodes.map((node, i) => [node.id, i]));
+  const sides = edges.map(forwardSides);
+  const links = linksAt(nodes.length, edges, sides, index);
+  const allele = alleleOf(nodes, edges, sides, index);
+  const members = groupBy(allele);
+  const kept = new Uint8Array(nodes.length);
+  const big = [];
+  for (const group of members.values()) {
+    if (alleleContent(group, nodes, links, allele) >= belowBp) {
+      for (const i of group) {
+        kept[i] = 1;
+      }
+      if (!isBackbone(nodes[group[0]])) {
+        big.push(group);
+      }
+    }
+  }
+  const { dist, pred } = distancesFromBackbone(nodes, links);
+  for (const group of big) {
+    for (const [i, side] of alleleEnds(group, nodes, links, allele)) {
+      let next = nearestOutside(i, side, links, allele, dist, nodes);
+      while (next !== void 0 && !kept[next]) {
+        kept[next] = 1;
+        next = isBackbone(nodes[next]) ? void 0 : pred[next];
+      }
+    }
+  }
+  const keptEdges = edges.filter((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a === void 0 || b === void 0) {
+      return false;
+    }
+    const skip = skipped(nodes[a], sides[k].from, nodes[b], sides[k].to);
+    return kept[a] && kept[b] && !(skip > 0 && skip < belowBp);
+  });
+  return mergeAlleleRuns({ ...graph, edges: keptEdges }, kept, allele);
+}
+function forwardSides(edge) {
+  return {
+    from: (edge.fromStrand ?? ownStrand(edge.from)) === "+" ? "e" : "s",
+    to: (edge.toStrand ?? ownStrand(edge.to)) === "+" ? "s" : "e"
+  };
+}
+function linksAt(count, edges, sides, index) {
+  const links = Array.from({ length: count }, () => []);
+  edges.forEach((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a !== void 0 && b !== void 0) {
+      links[a].push({ other: b, side: sides[k].from });
+      links[b].push({ other: a, side: sides[k].to });
+    }
+  });
+  return links;
+}
+function onOneSequence(a, b) {
+  const sa = a.stable;
+  const sb = b.stable;
+  return sa && sb?.refName === sa.refName && sb.rank === sa.rank ? [sa, sb] : void 0;
+}
+function continues(a, aSide, b, bSide) {
+  const pair = onOneSequence(a, b);
+  if (!pair || aSide === bSide) {
+    return false;
+  }
+  const [sa, sb] = pair;
+  return sa.start + a.length === sb.start || sb.start + b.length === sa.start;
+}
+function skipped(a, aSide, b, bSide) {
+  const pair = onOneSequence(a, b);
+  if (!pair || continues(a, aSide, b, bSide)) {
+    return 0;
+  }
+  const [sa, sb] = pair;
+  return Math.max(
+    sb.start - (sa.start + a.length),
+    sa.start - (sb.start + b.length)
+  );
+}
+function alleleOf(nodes, edges, sides, index) {
+  const parent = nodes.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  edges.forEach((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a !== void 0 && b !== void 0 && continues(nodes[a], sides[k].from, nodes[b], sides[k].to)) {
+      parent[find(a)] = find(b);
+    }
+  });
+  return nodes.map((_, i) => find(i));
+}
+function groupBy(allele) {
+  const groups = /* @__PURE__ */ new Map();
+  allele.forEach((root, i) => {
+    const group = groups.get(root);
+    if (group) {
+      group.push(i);
+    } else {
+      groups.set(root, [i]);
+    }
+  });
+  return groups;
+}
+function alleleContent(group, nodes, links, allele) {
+  if (isBackbone(nodes[group[0]])) {
+    return Infinity;
+  }
+  let length = 0;
+  let refName;
+  let lo = Infinity;
+  let hi = -Infinity;
+  let oneSequence = true;
+  for (const i of group) {
+    length += nodes[i].length;
+    for (const { other } of links[i]) {
+      const node = nodes[other];
+      if (allele[other] !== allele[i] && isBackbone(node)) {
+        refName ??= node.stable.refName;
+        oneSequence &&= node.stable.refName === refName;
+        lo = Math.min(lo, node.stable.start + node.length);
+        hi = Math.max(hi, node.stable.start);
+      }
+    }
+  }
+  return oneSequence && hi > lo ? Math.max(length, hi - lo) : length;
+}
+function alleleEnds(group, nodes, links, allele) {
+  const start = (i) => nodes[i].stable?.start ?? 0;
+  const end = (i) => start(i) + nodes[i].length;
+  let first = group[0];
+  let last = group[0];
+  for (const i of group) {
+    if (start(i) < start(first)) {
+      first = i;
+    }
+    if (end(i) > end(last)) {
+      last = i;
+    }
+  }
+  const ends = [];
+  for (const i of /* @__PURE__ */ new Set([first, last])) {
+    for (const side of ["s", "e"]) {
+      if (!links[i].some(
+        (link) => link.side === side && allele[link.other] === allele[i]
+      )) {
+        ends.push([i, side]);
+      }
+    }
+  }
+  return ends;
+}
+function nearestOutside(i, side, links, allele, dist, nodes) {
+  let best;
+  for (const link of links[i]) {
+    const j = link.other;
+    if (link.side === side && allele[j] !== allele[i] && Number.isFinite(dist[j]) && (best === void 0 || dist[j] < dist[best] || dist[j] === dist[best] && nodes[j].id < nodes[best].id)) {
+      best = j;
+    }
+  }
+  return best;
+}
+function distancesFromBackbone(nodes, links) {
+  const dist = new Float64Array(nodes.length).fill(Infinity);
+  const pred = new Int32Array(nodes.length).fill(-1);
+  const heap = new MinHeap(
+    ([da, a], [db, b]) => da - db || cmp(nodes[a].id, nodes[b].id)
+  );
+  nodes.forEach((node, i) => {
+    if (isBackbone(node)) {
+      dist[i] = 0;
+      heap.push([0, i]);
+    }
+  });
+  for (let top = heap.pop(); top !== void 0; top = heap.pop()) {
+    const [d0, i] = top;
+    if (d0 > dist[i]) {
+      continue;
+    }
+    for (const { other } of links[i]) {
+      if (isBackbone(nodes[other])) {
+        continue;
+      }
+      const d = d0 + nodes[other].length;
+      if (d < dist[other]) {
+        dist[other] = d;
+        pred[other] = i;
+        heap.push([d, other]);
+      } else if (d === dist[other] && cmp(nodes[i].id, nodes[pred[other]].id) < 0) {
+        pred[other] = i;
+      }
+    }
+  }
+  return { dist, pred: Array.from(pred, (p) => p < 0 ? void 0 : p) };
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var MinHeap = class {
+  constructor(order) {
+    this.order = order;
+    this.items = [];
+  }
+  push(item) {
+    const { items } = this;
+    items.push(item);
+    let i = items.length - 1;
+    while (i > 0) {
+      const up = i - 1 >> 1;
+      if (this.order(items[i], items[up]) >= 0) {
+        break;
+      }
+      ;
+      [items[i], items[up]] = [items[up], items[i]];
+      i = up;
+    }
+  }
+  pop() {
+    const { items } = this;
+    const top = items[0];
+    const last = items.pop();
+    if (items.length > 0 && last !== void 0) {
+      items[0] = last;
+      let i = 0;
+      for (; ; ) {
+        const l = 2 * i + 1;
+        const r = l + 1;
+        let m = i;
+        if (l < items.length && this.order(items[l], items[m]) < 0) {
+          m = l;
+        }
+        if (r < items.length && this.order(items[r], items[m]) < 0) {
+          m = r;
+        }
+        if (m === i) {
+          break;
+        }
+        ;
+        [items[i], items[m]] = [items[m], items[i]];
+        i = m;
+      }
+    }
+    return top;
+  }
+};
+function mergeAlleleRuns(graph, kept, allele) {
+  const { nodes, edges } = graph;
+  const index = new Map(nodes.map((node, i) => [node.id, i]));
+  const sides = edges.map(forwardSides);
+  const ends = edges.map((edge, k) => [
+    { i: index.get(edge.from), side: sides[k].from },
+    { i: index.get(edge.to), side: sides[k].to }
+  ]);
+  const degree = /* @__PURE__ */ new Map();
+  const sideKey = (i, side) => `${i}${side}`;
+  for (const pair of ends) {
+    for (const { i, side } of pair) {
+      degree.set(sideKey(i, side), (degree.get(sideKey(i, side)) ?? 0) + 1);
+    }
+  }
+  const next = /* @__PURE__ */ new Map();
+  const hasPrev = /* @__PURE__ */ new Set();
+  const internal = /* @__PURE__ */ new Set();
+  ends.forEach(([a, b], k) => {
+    if (a.i !== b.i && allele[a.i] === allele[b.i] && continues(nodes[a.i], a.side, nodes[b.i], b.side) && degree.get(sideKey(a.i, a.side)) === 1 && degree.get(sideKey(b.i, b.side)) === 1) {
+      const [left, right] = nodes[a.i].stable.start < nodes[b.i].stable.start ? [a, b] : [b, a];
+      next.set(left.i, { j: right.i, out: left.side, in: right.side });
+      hasPrev.add(right.i);
+      internal.add(k);
+    }
+  });
+  const headOf = nodes.map((_, i) => i);
+  const outer = /* @__PURE__ */ new Map();
+  const merged = /* @__PURE__ */ new Map();
+  nodes.forEach((_, i) => {
+    if (!kept[i] || hasPrev.has(i) || !next.has(i)) {
+      return;
+    }
+    const run = [i];
+    let into = flip(next.get(i).out);
+    outer.set(sideKey(i, into), "s");
+    for (let step = next.get(i); step; step = next.get(step.j)) {
+      run.push(step.j);
+      into = step.in;
+    }
+    outer.set(sideKey(run.at(-1), flip(into)), "e");
+    for (const j of run) {
+      headOf[j] = i;
+    }
+    merged.set(i, mergedNode(run.map((j) => nodes[j])));
+  });
+  const endpoint = ({ i, side }) => ({
+    id: nodes[headOf[i]].id,
+    side: headOf[i] === i && !merged.has(i) ? side : outer.get(sideKey(i, side))
+  });
+  return {
+    ...graph,
+    nodes: nodes.flatMap(
+      (node, i) => !kept[i] || headOf[i] !== i ? [] : [merged.get(i) ?? node]
+    ),
+    edges: edges.flatMap((edge, k) => {
+      if (internal.has(k)) {
+        return [];
+      }
+      const [a, b] = ends[k];
+      if (!merged.has(headOf[a.i]) && !merged.has(headOf[b.i])) {
+        return [edge];
+      }
+      const from = endpoint(a);
+      const to = endpoint(b);
+      return [
+        {
+          ...edge,
+          from: from.id,
+          to: to.id,
+          fromStrand: from.side === "e" ? "+" : "-",
+          toStrand: to.side === "s" ? "+" : "-"
+        }
+      ];
+    })
+  };
+}
+function flip(side) {
+  return side === "s" ? "e" : "s";
+}
+function mergedNode(run) {
+  const { samples: firstSamples, ...first } = run[0];
+  const length = run.reduce((sum, node) => sum + node.length, 0);
+  const depth = length > 0 ? run.reduce((sum, node) => sum + node.depth * node.length, 0) / length : first.depth;
+  const samples = run.every((node) => node.samples) ? run.reduce(
+    (common, node) => common.filter((s) => node.samples.includes(s)),
+    firstSamples
+  ) : void 0;
+  return samples ? { ...first, length, depth, samples } : { ...first, length, depth };
+}
+
+export {
+  foldVariants
+};

package/dist/chunks/chunk-B4YH42OP.js

@@ -0,0 +1,24 @@
+// src/gfa/writeRgfa.ts
+function writeRgfa(graph) {
+  const nameOf = new Map(graph.nodes.map((n) => [n.id, n.name]));
+  return [
+    "H	VN:Z:1.0",
+    ...graph.nodes.map(segmentLine),
+    ...graph.edges.map(
+      (e) => `L	${nameOf.get(e.from)}	${e.fromStrand ?? "+"}	${nameOf.get(e.to)}	${e.toStrand ?? "+"}	0M`
+    ),
+    ""
+  ].join("\n");
+}
+function segmentLine(node) {
+  const { stable } = node;
+  if (!stable) {
+    throw new Error(`segment ${node.name} has no stable coordinate to file`);
+  }
+  const samples = node.samples?.length ? `	SM:Z:${node.samples.join(",")}` : "";
+  return `S	${node.name}	*	LN:i:${node.length}	SN:Z:${stable.refName}	SO:i:${stable.start}	SR:i:${stable.rank}${samples}`;
+}
+
+export {
+  writeRgfa
+};

package/dist/chunks/{chunk-XLCTQHBE.js → chunk-BLRJ6IGK.js}

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

package/dist/chunks/{chunk-RRZMMYBG.js → chunk-BV64PQ2C.js}

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

package/dist/chunks/{chunk-W253V6RR.js → chunk-CVYDR2OP.js}

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

package/dist/chunks/{chunk-UID3QBWH.js → chunk-FM6XRXPX.js}

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

package/dist/chunks/{chunk-MIW3HYPE.js → chunk-GFRPX6M2.js}

@@ -3,10 +3,10 @@ import {
   RAMP_GRADIENT_STOPS,
   rampHueCss,
   rampStops
-} from "./chunk-6ZNQJ5ZD.js";
+} from "./chunk-OXTR3BVF.js";
 import {
   REFERENCE_RAMP_ALT_CSS
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/chunks/{chunk-3TGUKQWQ.js → chunk-HOOVOF2Y.js}

@@ -1,37 +1,40 @@
+import {
+  stripGeneGaps,
+  walkStripFrame,
+  walkStripLabelsTree
+} from "./chunk-UD5FOCI2.js";
+import {
+  Canvas2DRenderer
+} from "./chunk-WBCOREDZ.js";
 import {
   layoutGeometryInputs
 } from "./chunk-LOCJN3BZ.js";
 import {
   svgCanvas
 } from "./chunk-47DYCZOK.js";
-import {
-  stripGeneGaps,
-  walkStripFrame,
-  walkStripLabelsTree
-} from "./chunk-WDTXW7T2.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-MIW3HYPE.js";
+} from "./chunk-GFRPX6M2.js";
 import {
-  Canvas2DRenderer
-} from "./chunk-WBCOREDZ.js";
+  genePins
+} from "./chunk-BUBZ32IC.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
   exonStretches
 } from "./chunk-3S3YVOJ7.js";
 import {
-  genePins
-} from "./chunk-BUBZ32IC.js";
+  axisScaleOf
+} from "./chunk-XKM5OHQQ.js";
 import {
   facetLifts,
   walkLift
-} from "./chunk-MBB7ATM6.js";
+} from "./chunk-LFKMASER.js";
 import {
   encodingStops
-} from "./chunk-DPV2CUIE.js";
+} from "./chunk-XPT66H6H.js";
 import {
   rangeText,
   walkKey
@@ -39,24 +42,21 @@ import {
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   version
-} from "./chunk-UID3QBWH.js";
-import {
-  axisScaleOf
-} from "./chunk-MXDQGA7A.js";
+} from "./chunk-FM6XRXPX.js";
 import {
   walkRowLabels,
   walkRowsExtent
 } from "./chunk-3C5UXR2U.js";
-import {
-  nodeInk
-} from "./chunk-PBENCR5L.js";
 import {
   pathLegend,
   walkLabelsOf
 } from "./chunk-7GBL7SJY.js";
+import {
+  nodeInk
+} from "./chunk-PBENCR5L.js";
 import {
   referenceLabel
 } from "./chunk-RAKOB6IV.js";
@@ -91,7 +91,7 @@ import {
   FIT_PADDING,
   drawingBounds,
   fitTransform
-} from "./chunk-OOXIMURX.js";
+} from "./chunk-ZGRYFUXE.js";
 import {
   deletionDrawing,
   deletionEdges

package/dist/chunks/{chunk-MBB7ATM6.js → chunk-LFKMASER.js}

@@ -1,7 +1,7 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-DPV2CUIE.js";
+} from "./chunk-XPT66H6H.js";
 import {
   pathOrigin
 } from "./chunk-ST2IBUAN.js";

package/dist/chunks/{chunk-6ZNQJ5ZD.js → chunk-OXTR3BVF.js}

@@ -1,6 +1,6 @@
 import {
   REFERENCE_RAMP_MAX_HUE
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 
 // src/referenceRampCss.ts
 function rampHueCss(hue) {

package/dist/chunks/{chunk-WDTXW7T2.js → chunk-UD5FOCI2.js}

@@ -2,7 +2,7 @@ import {
   alongRow,
   boxesGenes,
   rowPitch
-} from "./chunk-MIW3HYPE.js";
+} from "./chunk-GFRPX6M2.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/chunks/{chunk-MXDQGA7A.js → chunk-XKM5OHQQ.js}

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

package/dist/chunks/{chunk-DPV2CUIE.js → chunk-XPT66H6H.js}

@@ -2,7 +2,7 @@ import {
   REFERENCE_RAMP_ALT_COLOR,
   REFERENCE_RAMP_MAX_HUE,
   hslToRgb
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   packAbgr
 } from "./chunk-G2FD7S3C.js";