@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-WOO7QYKB.js

@@ -0,0 +1,121 @@
+import {
+  SATURATED_PATH_COUNT
+} from "./chunk-MFKORG3F.js";
+
+// src/bubbles/classifyBubble.ts
+var REPEAT_GROWTH = 10;
+function coveringRepeat(b, repeats) {
+  const span = b.end - b.start;
+  const growth = b.longestAlleleLength - b.shortestAlleleLength;
+  return repeats.find(
+    (r) => growth <= REPEAT_GROWTH * (r.end - r.start) && (span === 0 ? r.start <= b.start && b.start <= r.end : Math.min(b.end, r.end) - Math.max(b.start, r.start) >= span / 2)
+  );
+}
+var SUPERBUBBLE_SEGMENTS = 40;
+function formatBp(bp) {
+  if (bp >= 1e4) {
+    return `${(bp / 1e3).toFixed(0)} kb`;
+  }
+  if (bp >= 1e3) {
+    return `${(bp / 1e3).toFixed(1)} kb`;
+  }
+  return `${bp} bp`;
+}
+function formatBpRange(shortest, longest) {
+  const low = formatBp(shortest);
+  const high = formatBp(longest);
+  const unit = high.slice(high.indexOf(" "));
+  return low.endsWith(unit) ? `${low.slice(0, -unit.length)}\u2013${high}` : `${low}\u2013${high}`;
+}
+function routes(count) {
+  if (count >= SATURATED_PATH_COUNT) {
+    return "\u22652.1B routes";
+  }
+  if (count >= 1e5) {
+    return `${(count / 1e3).toFixed(0)}k routes`;
+  }
+  return `${count} routes`;
+}
+function classifyBubble(b, repeats = []) {
+  const c = classifyShape(b, repeats);
+  return b.partial ? { ...c, label: `${c.label}, partial` } : c;
+}
+function classifyShape(b, repeats) {
+  const refSpan = b.end - b.start;
+  const {
+    shortestAlleleLength: shortest,
+    longestAlleleLength: longest,
+    pathCount,
+    segmentCount,
+    inversion
+  } = b;
+  const range = formatBpRange(shortest, longest);
+  if (segmentCount >= SUPERBUBBLE_SEGMENTS) {
+    return {
+      kind: "superbubble",
+      label: `${range} superbubble, ${segmentCount} segments, ${routes(pathCount)}${inversion ? ", inv" : ""}`
+    };
+  }
+  if (inversion) {
+    return { kind: "inversion", label: `${formatBp(longest)} inv` };
+  }
+  const repeat = longest !== shortest ? coveringRepeat(b, repeats) : void 0;
+  if (repeat) {
+    const name = repeat.name ? ` (${repeat.name})` : "";
+    return {
+      kind: "repeat",
+      label: `${range} repeat array${name}, ${routes(pathCount)}`
+    };
+  }
+  const alleles = pathCount > 2 ? `, ${pathCount} alleles` : "";
+  if (shortest === longest && shortest === refSpan) {
+    return refSpan <= 1 ? { kind: "snp", label: "SNP" } : { kind: "substitution", label: `${formatBp(refSpan)} sub` };
+  }
+  if (refSpan === 0 || shortest === refSpan) {
+    return {
+      kind: "insertion",
+      label: `\u2264${formatBp(longest - refSpan)} ins${alleles}`
+    };
+  }
+  if (longest === refSpan) {
+    return {
+      kind: "deletion",
+      label: `${formatBp(refSpan - shortest)} del${alleles}`
+    };
+  }
+  return {
+    kind: "complex",
+    label: `${formatBp(refSpan)} ref \u2192 ${range}, ${pathCount} alleles`
+  };
+}
+var BUBBLE_KIND_COLORS = {
+  snp: "#5b6b7a",
+  substitution: "#5b6b7a",
+  insertion: "#2f8fd6",
+  deletion: "#c94040",
+  inversion: "#e07b00",
+  repeat: "#8e3fbf",
+  superbubble: "#8e3fbf",
+  complex: "#8e3fbf"
+};
+var BUBBLE_KIND_NAMES = {
+  snp: "SNP",
+  substitution: "substitution",
+  insertion: "insertion",
+  deletion: "deletion",
+  inversion: "inversion",
+  repeat: "repeat array",
+  superbubble: "superbubble",
+  complex: "site"
+};
+function bubbleSegmentIds(b) {
+  return b.segments.split(",").filter(Boolean);
+}
+
+export {
+  formatBp,
+  classifyBubble,
+  BUBBLE_KIND_COLORS,
+  BUBBLE_KIND_NAMES,
+  bubbleSegmentIds
+};

package/dist/chunks/chunk-WSIFAZU7.js

@@ -0,0 +1,132 @@
+// src/gbzJoin.ts
+var UNKNOWN_SAMPLE = "unknown";
+function parseWalk(line) {
+  const fields = line.split("	");
+  return {
+    fields,
+    name: fields.slice(1, 4).join("	"),
+    start: +fields[4],
+    end: +fields[5]
+  };
+}
+var stepsOf = (walk) => walk.fields[6].match(/[<>][^<>]+/g) ?? [];
+function segmentLengths(lines) {
+  const lengths = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.startsWith("S	")) {
+      const [, id, sequence, ...tags] = line.split("	");
+      const ln = tags.find((tag) => tag.startsWith("LN:i:"));
+      lengths.set(
+        id,
+        sequence === "*" && ln ? +ln.slice("LN:i:".length) : sequence.length
+      );
+    }
+  }
+  return lengths;
+}
+function extend(a, b, lengths) {
+  if (b.end <= a.end) {
+    return a;
+  }
+  const steps = stepsOf(b);
+  let pos = b.start;
+  for (const [i, step] of steps.entries()) {
+    if (pos === a.end) {
+      const fields = [...a.fields];
+      fields[5] = String(b.end);
+      fields[6] = a.fields[6] + steps.slice(i).join("");
+      return { ...a, fields, end: b.end };
+    }
+    const length = lengths.get(step.slice(1));
+    if (pos > a.end || length === void 0) {
+      return void 0;
+    }
+    pos += length;
+  }
+  return void 0;
+}
+function joinPieces(pieces, lengths, startsPath) {
+  const joined = [];
+  for (const piece of pieces.sort((a, b) => a.start - b.start)) {
+    const last = joined.at(-1);
+    const [, sample, haplotype, contig] = piece.fields;
+    const joins = last !== void 0 && (piece.start < last.end || piece.start === last.end && !startsPath(sample, +haplotype, contig, piece.start));
+    const extended = joins ? extend(last, piece, lengths) : void 0;
+    if (extended) {
+      joined[joined.length - 1] = extended;
+    } else {
+      joined.push(piece);
+    }
+  }
+  return joined;
+}
+var flip = (sign) => sign === "+" ? "-" : "+";
+function* stepLinks(walk) {
+  const steps = stepsOf(walk).map((step) => ({
+    id: step.slice(1),
+    sign: step.startsWith(">") ? "+" : "-"
+  }));
+  for (let i = 1; i < steps.length; i++) {
+    const a = steps[i - 1];
+    const b = steps[i];
+    yield {
+      forward: `L	${a.id}	${a.sign}	${b.id}	${b.sign}	0M`,
+      reverse: `L	${b.id}	${flip(b.sign)}	${a.id}	${flip(a.sign)}	0M`
+    };
+  }
+}
+function joinCuts(gfas, startsPath) {
+  if (gfas.length <= 1) {
+    return gfas[0] ?? "";
+  }
+  const cuts = gfas.map((gfa) => gfa.split("\n").filter((line) => line !== ""));
+  const ofType = (cut, type) => cut.filter((line) => line.startsWith(`${type}	`));
+  const lengths = segmentLengths(cuts.flat());
+  let unknownOffset = 0;
+  const walksByCut = cuts.map((cut) => {
+    const walks2 = ofType(cut, "W").map(parseWalk);
+    const offset = unknownOffset;
+    for (const walk of walks2.filter((w) => w.fields[1] === UNKNOWN_SAMPLE)) {
+      const haplotype = +walk.fields[2] + offset;
+      walk.fields[2] = String(haplotype);
+      walk.name = walk.fields.slice(1, 4).join("	");
+      unknownOffset = Math.max(unknownOffset, haplotype);
+    }
+    return walks2;
+  });
+  const byName = /* @__PURE__ */ new Map();
+  for (const walk of [
+    ...walksByCut.flatMap((walks2) => walks2.slice(0, 1)),
+    ...walksByCut.flatMap((walks2) => walks2.slice(1))
+  ]) {
+    const pieces = byName.get(walk.name);
+    if (pieces) {
+      pieces.push(walk);
+    } else {
+      byName.set(walk.name, [walk]);
+    }
+  }
+  const walks = [...byName.values()].flatMap(
+    (pieces) => joinPieces(pieces, lengths, startsPath)
+  );
+  const links = new Set(cuts.flatMap((cut) => ofType(cut, "L")));
+  for (const walk of walks) {
+    for (const link of stepLinks(walk)) {
+      if (!links.has(link.forward) && !links.has(link.reverse)) {
+        links.add(link.forward);
+      }
+    }
+  }
+  const lines = /* @__PURE__ */ new Set([
+    ...ofType(cuts[0], "H"),
+    ...cuts.flatMap((cut) => ofType(cut, "S")),
+    ...links,
+    ...walks.map((walk) => walk.fields.join("	"))
+  ]);
+  return `${[...lines].join("\n")}
+`;
+}
+
+export {
+  joinCuts
+};

package/dist/chunks/chunk-X5L37W4J.js

@@ -0,0 +1,82 @@
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  groupDigits
+} from "./chunk-N62KBLFC.js";
+import {
+  isGenericSample
+} from "./chunk-BPLIXMH7.js";
+
+// src/pathColors.ts
+function nameHue(name) {
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = name.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  return Math.abs(hash % 360);
+}
+function pathHueAt(index, count) {
+  return index * 360 / count;
+}
+var PATH_SATURATION = 0.7;
+var PATH_LIGHTNESS = 0.5;
+var MAX_PATH_COLORS = 16;
+function pathColorsLegible(pathCount) {
+  return pathCount > 0 && pathCount <= MAX_PATH_COLORS;
+}
+function pathCssColor(index, count) {
+  return `hsl(${pathHueAt(index, count)}, ${PATH_SATURATION * 100}%, ${PATH_LIGHTNESS * 100}%)`;
+}
+function pathGreyCssColor(index, count) {
+  const lightness = count > 1 ? 25 + 45 * index / (count - 1) : 45;
+  return `hsl(0, 0%, ${lightness}%)`;
+}
+function labelTiers(name) {
+  const parts = pathOrigin(name).name.split("#");
+  const full = parts.join("#");
+  if (parts.length >= 3 && isGenericSample(parts[0])) {
+    const contig = parts.slice(2).join("#");
+    return [contig, contig, full];
+  }
+  return [parts[0], parts.slice(0, 2).join("#"), full];
+}
+function offsetTiers(name, tiers) {
+  const { start } = pathOrigin(name);
+  return tiers.map((t) => `${t} @${groupDigits(start)}`);
+}
+function pathLegend(paths, colors) {
+  const firstOf = /* @__PURE__ */ new Map();
+  paths.forEach((path, i) => {
+    if (!firstOf.has(path.name)) {
+      firstOf.set(path.name, i);
+    }
+  });
+  const entries = [...firstOf].map(([name, i]) => ({ name, i }));
+  const named = entries.map((e) => labelTiers(e.name));
+  const candidates = [0, 1, 2].flatMap((t) => [
+    entries.map((_, k) => named[k][t]),
+    entries.map((e, k) => offsetTiers(e.name, named[k])[t])
+  ]);
+  const distinct = candidates.find(
+    (labels2) => new Set(labels2).size === entries.length
+  );
+  const labels = distinct ?? candidates.at(-1);
+  return entries.map(({ name, i }, k) => ({
+    name,
+    label: labels[k],
+    color: colors?.[i] ?? pathCssColor(i, paths.length)
+  }));
+}
+
+export {
+  nameHue,
+  pathHueAt,
+  PATH_SATURATION,
+  PATH_LIGHTNESS,
+  MAX_PATH_COLORS,
+  pathColorsLegible,
+  pathCssColor,
+  pathGreyCssColor,
+  pathLegend
+};

package/dist/chunks/chunk-Y3IOTZJA.js

@@ -0,0 +1,61 @@
+import {
+  bypassedPoints
+} from "./chunk-4EMPBO7S.js";
+import {
+  computeEdgeCurves,
+  edgeJoinOf,
+  routedEdgeCurves,
+  strandSides
+} from "./chunk-2CVHXFK7.js";
+
+// src/util/edgeCurves.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function baseEdgeCurves(nodePositions, graph, axis, deletions, version, routes, stranded = false) {
+  const { scaleX, scaleY } = axis;
+  const cached = cache.get(nodePositions);
+  if (cached?.graph === graph && cached.scaleX === scaleX && cached.scaleY === scaleY && cached.deletions === deletions && cached.routes === routes && cached.stranded === stranded && cached.version === version) {
+    return cached.curves;
+  }
+  const curves = /* @__PURE__ */ new Map();
+  for (let ei = 0; ei < graph.edges.length; ei++) {
+    const edge = graph.edges[ei];
+    const from = nodePositions[edge.from];
+    const to = nodePositions[edge.to];
+    if (from?.length && to?.length) {
+      const bypassed = deletions?.get(ei);
+      const route = bypassed && routes?.[ei];
+      curves.set(
+        ei,
+        route ? routedEdgeCurves(
+          from,
+          to,
+          route,
+          stranded ? strandSides(edge) : void 0
+        ) : computeEdgeCurves(
+          from,
+          to,
+          edgeJoinOf(edge, stranded),
+          0,
+          0,
+          axis,
+          bypassed ? bypassedPoints(nodePositions, bypassed) : []
+        )
+      );
+    }
+  }
+  cache.set(nodePositions, {
+    graph,
+    scaleX,
+    scaleY,
+    deletions,
+    routes,
+    stranded,
+    version,
+    curves
+  });
+  return curves;
+}
+
+export {
+  baseEdgeCurves
+};

package/dist/chunks/chunk-YMSSF2RK.js

@@ -0,0 +1,257 @@
+import {
+  EdgeSpatialIndex,
+  SpatialIndex
+} from "./chunk-MREQ7GIA.js";
+import {
+  pathRibbonOffsets,
+  translateCurves,
+  yToXOf
+} from "./chunk-2CVHXFK7.js";
+
+// src/util/hitDetection.ts
+function distanceToSegment(px, py, x1, y1, x2, y2) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) {
+    return Math.hypot(px - x1, py - y1);
+  }
+  const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
+  return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
+}
+function distanceToCubicBezier(px, py, x1, y1, cx1, cy1, cx2, cy2, x2, y2) {
+  let minDist = Infinity;
+  const samples = 20;
+  let lastX = x1;
+  let lastY = y1;
+  for (let i = 1; i <= samples; i++) {
+    const t = i / samples;
+    const u = 1 - t;
+    const bx = u * u * u * x1 + 3 * u * u * t * cx1 + 3 * u * t * t * cx2 + t * t * t * x2;
+    const by = u * u * u * y1 + 3 * u * u * t * cy1 + 3 * u * t * t * cy2 + t * t * t * y2;
+    minDist = Math.min(minDist, distanceToSegment(px, py, lastX, lastY, bx, by));
+    lastX = bx;
+    lastY = by;
+  }
+  return minDist;
+}
+function distanceToBezierCurve(px, py, c) {
+  return distanceToCubicBezier(
+    px,
+    py,
+    c.x0,
+    c.y0,
+    c.cx0,
+    c.cy0,
+    c.cx1,
+    c.cy1,
+    c.x1,
+    c.y1
+  );
+}
+function distanceToEdgeCurves(px, py, curves, yToX = 1) {
+  let minDist = Infinity;
+  for (const c of curves) {
+    const d = distanceToBezierCurve(
+      px,
+      py,
+      yToX === 1 ? c : {
+        x0: c.x0,
+        y0: c.y0 * yToX,
+        cx0: c.cx0,
+        cy0: c.cy0 * yToX,
+        cx1: c.cx1,
+        cy1: c.cy1 * yToX,
+        x1: c.x1,
+        y1: c.y1 * yToX
+      }
+    );
+    if (d < minDist) {
+      minDist = d;
+    }
+  }
+  return minDist;
+}
+var nodeCache = /* @__PURE__ */ new WeakMap();
+function getSpatialIndex(nodePositions, version) {
+  const cached = nodeCache.get(nodePositions);
+  if (cached?.version === version) {
+    return cached.index;
+  }
+  const index = new SpatialIndex(nodePositions);
+  nodeCache.set(nodePositions, { version, index });
+  return index;
+}
+var edgeCache = /* @__PURE__ */ new WeakMap();
+function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version, deletions, routes, stranded = false) {
+  const cached = edgeCache.get(nodePositions);
+  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version && cached.deletions === deletions && cached.routes === routes && cached.stranded === stranded) {
+    return cached.index;
+  }
+  const index = new EdgeSpatialIndex(
+    nodePositions,
+    graph,
+    drawPaths,
+    axis,
+    void 0,
+    deletions,
+    version,
+    routes,
+    stranded
+  );
+  edgeCache.set(nodePositions, {
+    graph,
+    drawPaths,
+    scaleX: axis.scaleX,
+    scaleY: axis.scaleY,
+    version,
+    index,
+    deletions,
+    routes,
+    stranded
+  });
+  return index;
+}
+var MIN_NODE_REACH_PX = 5;
+function findHoveredNode(nodePositions, graphX, graphY, axis, version = 0, ink) {
+  const yToX = yToXOf(axis);
+  const index = getSpatialIndex(nodePositions, version);
+  const reach = (px) => Math.max(MIN_NODE_REACH_PX, px) / axis.scaleX;
+  const queryReach = reach(ink?.maxHalfWidthPx ?? 0);
+  const candidates = index.query(graphX, graphY, queryReach, queryReach / yToX);
+  let hovered = null;
+  let best = Infinity;
+  for (const { nodeId, segmentIdx } of candidates) {
+    const segments = nodePositions[nodeId];
+    const dist = distanceToSegment(
+      graphX,
+      graphY * yToX,
+      segments[segmentIdx].x,
+      segments[segmentIdx].y * yToX,
+      segments[segmentIdx + 1].x,
+      segments[segmentIdx + 1].y * yToX
+    );
+    if (dist < best && dist < reach(ink?.halfWidthPx(nodeId) ?? 0)) {
+      best = dist;
+      hovered = nodeId;
+    }
+  }
+  return hovered;
+}
+function segmentMeetsBox(a, b, box) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  let t0 = 0;
+  let t1 = 1;
+  for (const [p, q] of [
+    [-dx, a.x - box.x0],
+    [dx, box.x1 - a.x],
+    [-dy, a.y - box.y0],
+    [dy, box.y1 - a.y]
+  ]) {
+    if (p === 0) {
+      if (q < 0) {
+        return false;
+      }
+    } else if (p < 0) {
+      t0 = Math.max(t0, q / p);
+    } else {
+      t1 = Math.min(t1, q / p);
+    }
+  }
+  return t0 <= t1;
+}
+function nodesUnderBox(nodePositions, t, version = 0) {
+  const index = getSpatialIndex(nodePositions, version);
+  const screen = (p) => ({
+    x: p.x * t.scaleX + t.translateX,
+    y: p.y * t.scaleY + t.translateY
+  });
+  return (box) => {
+    const hits = /* @__PURE__ */ new Set();
+    const candidates = index.query(
+      ((box.x0 + box.x1) / 2 - t.translateX) / t.scaleX,
+      ((box.y0 + box.y1) / 2 - t.translateY) / t.scaleY,
+      Math.abs((box.x1 - box.x0) / 2 / t.scaleX),
+      Math.abs((box.y1 - box.y0) / 2 / t.scaleY)
+    );
+    for (const { nodeId, segmentIdx } of candidates) {
+      const line = nodePositions[nodeId];
+      if (!hits.has(nodeId) && segmentMeetsBox(
+        screen(line[segmentIdx]),
+        screen(line[segmentIdx + 1]),
+        box
+      )) {
+        hits.add(nodeId);
+      }
+    }
+    return hits;
+  };
+}
+function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths, version = 0, deletions, hiddenEdges, deletionRoutes, stranded = false) {
+  const yToX = yToXOf(axis);
+  const edgeThreshold = 10 / axis.scaleX;
+  const edgeIndex = getEdgeSpatialIndex(
+    nodePositions,
+    graph,
+    drawPaths,
+    axis,
+    version,
+    deletions,
+    deletionRoutes,
+    stranded
+  );
+  const candidates = edgeIndex.query(
+    graphX,
+    graphY,
+    edgeThreshold,
+    edgeThreshold / yToX
+  );
+  let hovered = null;
+  let best = edgeThreshold;
+  for (const edgeIdx of candidates) {
+    const edge = graph.edges[edgeIdx];
+    const fromSegments = nodePositions[edge.from];
+    const toSegments = nodePositions[edge.to];
+    if (!fromSegments?.length || !toSegments?.length || hiddenEdges?.has(edgeIdx)) {
+      continue;
+    }
+    const numPaths = edge.pathIds?.length ?? 0;
+    const baseCurves = edgeIndex.getCurves(edgeIdx);
+    if (!baseCurves) {
+      continue;
+    }
+    let dist;
+    if (!drawPaths || numPaths === 0) {
+      dist = distanceToEdgeCurves(graphX, graphY * yToX, baseCurves, yToX);
+    } else {
+      let minDist = Infinity;
+      for (const offset of pathRibbonOffsets(
+        fromSegments,
+        toSegments,
+        numPaths,
+        axis
+      )) {
+        const curves = offset.x === 0 && offset.y === 0 ? baseCurves : translateCurves(baseCurves, offset.x, offset.y);
+        const d = distanceToEdgeCurves(graphX, graphY * yToX, curves, yToX);
+        if (d < minDist) {
+          minDist = d;
+        }
+      }
+      dist = minDist;
+    }
+    if (dist < best) {
+      best = dist;
+      hovered = edgeIdx;
+    }
+  }
+  return hovered;
+}
+
+export {
+  distanceToSegment,
+  distanceToCubicBezier,
+  findHoveredNode,
+  nodesUnderBox,
+  findHoveredEdge
+};