@jbrowse/bandage-core 6.0.1 → 6.0.2

package/dist/chunks/chunk-SZNZ2T6D.js

@@ -0,0 +1,198 @@
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  panSNContig,
+  panSNSample
+} from "./chunk-BPLIXMH7.js";
+
+// src/layout/walkRows.ts
+function sampleOf(path) {
+  return path.sample ?? panSNSample(path.name);
+}
+function labelOf(path) {
+  return path.haplotype !== void 0 && path.sample !== void 0 ? `${path.sample}#${path.haplotype}` : sampleOf(path);
+}
+function stepsOf(pieces, lengthOf) {
+  const steps = [];
+  let end;
+  for (const piece of pieces) {
+    if (end !== void 0 && piece.start !== void 0 && piece.start > end) {
+      steps.push(piece.start - end);
+    }
+    steps.push(...piece.nodeIds);
+    const bp = piece.nodeIds.reduce(
+      (sum, id) => sum + (lengthOf.get(id) ?? 0),
+      0
+    );
+    end = piece.start === void 0 ? void 0 : piece.start + bp;
+  }
+  return steps;
+}
+function stepSpans(pieces, lengthOf) {
+  const spans = [];
+  let end;
+  for (const piece of pieces) {
+    if (piece.start === void 0 || end !== void 0 && piece.start < end) {
+      return void 0;
+    }
+    if (end !== void 0 && piece.start > end) {
+      spans.push({ start: end, end: piece.start });
+    }
+    let pos = piece.start;
+    for (const id of piece.nodeIds) {
+      const len = lengthOf.get(id) ?? 0;
+      spans.push({ start: pos, end: pos + len });
+      pos += len;
+    }
+    end = pos;
+  }
+  return spans;
+}
+function sliceBetween(steps, span, region, flanked = true) {
+  if (!region || !flanked) {
+    return { ids: steps, complete: true, from: -1, to: -1 };
+  }
+  let i0 = -1;
+  let i1 = -1;
+  let bestEnd = -Infinity;
+  let bestStart = Infinity;
+  steps.forEach((id, i) => {
+    const s = typeof id === "string" ? span.get(id) : void 0;
+    if (s) {
+      if (s.end <= region.start && s.end > bestEnd) {
+        bestEnd = s.end;
+        i0 = i;
+      }
+      if (s.start >= region.end && s.start < bestStart) {
+        bestStart = s.start;
+        i1 = i;
+      }
+    }
+  });
+  if (i0 < 0 || i1 < 0) {
+    return { ids: steps, complete: false, from: -1, to: -1 };
+  }
+  const ids = steps.slice(Math.min(i0, i1) + 1, Math.max(i0, i1));
+  return {
+    ids: i0 < i1 ? ids : ids.reverse(),
+    complete: true,
+    from: i0,
+    to: i1
+  };
+}
+function filterSamples(rows, samples) {
+  return samples ? rows.filter((r) => samples.includes(r.sample)).sort(
+    (a, b) => samples.indexOf(a.sample) - samples.indexOf(b.sample) || a.label.localeCompare(b.label)
+  ) : rows;
+}
+function walkRows(graph, region, unit) {
+  const paths = graph.paths ?? [];
+  const isReference = (p) => pathOrigin(p.name).name === graph.referencePath;
+  const referencePieces = paths.some(isReference) ? paths.filter(isReference).sort((a, b) => (a.start ?? 0) - (b.start ?? 0)) : paths.slice(0, 1);
+  const first = referencePieces[0];
+  const others = paths.filter((p) => !referencePieces.includes(p));
+  if (!first || others.length === 0) {
+    return void 0;
+  }
+  const walks = /* @__PURE__ */ new Map();
+  for (const path of others) {
+    walks.set(path.name, [...walks.get(path.name) ?? [], path]);
+  }
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const referenceStart = first.start ?? 0;
+  const cut = region && region.end > region.start ? region : void 0;
+  const span = /* @__PURE__ */ new Map();
+  for (const piece of referencePieces) {
+    let pos = piece.start ?? 0;
+    for (const id of piece.nodeIds) {
+      const len = lengthOf.get(id) ?? 0;
+      if (!span.has(id)) {
+        span.set(id, { start: pos, end: pos + len });
+      }
+      pos += len;
+    }
+  }
+  const flanked = cut === void 0 || [...span.values()].some((s) => s.end <= cut.start) && [...span.values()].some((s) => s.start >= cut.end);
+  const rowOf = (pieces) => {
+    const path = pieces[0];
+    const ordered = [...pieces].sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+    const { ids, complete, from, to } = sliceBetween(
+      stepsOf(ordered, lengthOf),
+      span,
+      cut,
+      flanked
+    );
+    const spans = stepSpans(ordered, lengthOf);
+    const contig = path.contig ?? panSNContig(pathOrigin(path.name).name);
+    const axis = !spans?.length ? void 0 : from < 0 ? { contig, start: spans[0].start, reversed: false } : from < to ? { contig, start: spans[from].end, reversed: false } : { contig, start: spans[from].start, reversed: true };
+    const runs = [];
+    let bp = 0;
+    let offReferenceBp = 0;
+    let gapBp = 0;
+    let step = 0;
+    for (const id of ids) {
+      if (typeof id === "number") {
+        runs.push({ start: bp, bp: id, onReference: false, gap: true });
+        bp += id;
+        gapBp += id;
+        step = 0;
+        continue;
+      }
+      const len = lengthOf.get(id) ?? 0;
+      const s = span.get(id);
+      const last = runs.at(-1);
+      const at = last?.referenceStart;
+      const forward = s && at !== void 0 && step >= 0 && at + last.bp === s.start;
+      const backward = s && at !== void 0 && step <= 0 && s.end === at;
+      if (!s && last && !last.onReference && !last.gap) {
+        last.bp += len;
+      } else if (forward || backward) {
+        last.bp += len;
+        if (!forward) {
+          last.referenceStart = s.start;
+          last.reversed = true;
+        }
+        step = forward ? 1 : -1;
+      } else {
+        runs.push({
+          start: bp,
+          bp: len,
+          onReference: s !== void 0,
+          referenceStart: s?.start
+        });
+        step = 0;
+      }
+      bp += len;
+      if (!s) {
+        offReferenceBp += len;
+      }
+    }
+    return {
+      name: path.name,
+      label: labelOf(path),
+      sample: sampleOf(path),
+      haplotype: path.haplotype,
+      bp,
+      offReferenceBp,
+      gapBp,
+      complete,
+      runs,
+      axis
+    };
+  };
+  const origin = cut ? cut.start : referenceStart;
+  return {
+    origin,
+    unit,
+    reference: rowOf(referencePieces),
+    rows: [...walks.values()].map(rowOf).sort(
+      (a, b) => Number(b.complete) - Number(a.complete) || b.bp - a.bp || a.label.localeCompare(b.label)
+    )
+  };
+}
+
+export {
+  filterSamples,
+  walkRows
+};

package/dist/chunks/chunk-TDQLINVI.js

@@ -0,0 +1,16 @@
+// src/util/wheelZoom.ts
+var ZOOM_PER_NOTCH = 1.1;
+var NOTCH_PX = 100;
+var LINE_PX = 40;
+var PAGE_PX = 800;
+var PINCH_GAIN = 10;
+var MAX_NOTCHES_PER_EVENT = 2;
+function wheelZoomFactor(e) {
+  const px = e.deltaY * (e.deltaMode === 1 ? LINE_PX : e.deltaMode === 2 ? PAGE_PX : 1);
+  const notches = (e.ctrlKey ? PINCH_GAIN : 1) * px / NOTCH_PX;
+  return ZOOM_PER_NOTCH ** -Math.max(-MAX_NOTCHES_PER_EVENT, Math.min(MAX_NOTCHES_PER_EVENT, notches));
+}
+
+export {
+  wheelZoomFactor
+};

package/dist/chunks/chunk-TEDQJPMI.js

@@ -0,0 +1,131 @@
+import {
+  parseCs
+} from "./chunk-C44YRP5F.js";
+
+// src/tubeMap/reads.ts
+function canonicalStrand(node) {
+  return node.id.endsWith("-") ? "-" : "+";
+}
+function stepName(node, strand) {
+  return strand === canonicalStrand(node) ? node.id : `-${node.id}`;
+}
+function stepStarts(lengths, total) {
+  const starts = lengths.map(() => void 0);
+  let head = 0;
+  let i = 0;
+  for (; i < lengths.length && lengths[i] !== void 0; i++) {
+    starts[i] = head;
+    head += lengths[i];
+  }
+  let tail = total;
+  for (let j = lengths.length - 1; j > i && lengths[j] !== void 0; j--) {
+    tail -= lengths[j];
+    starts[j] = tail;
+  }
+  return starts;
+}
+function mismatchesByStep(record, lengths) {
+  const byStep = record.path.map(() => []);
+  if (record.cs === void 0) {
+    return byStep;
+  }
+  const starts = stepStarts(lengths, record.pathLength);
+  const stepAt = (pos2, atEnd = false) => {
+    for (let s = 0; s < starts.length; s++) {
+      const start = starts[s];
+      const length = lengths[s];
+      if (start !== void 0 && length !== void 0 && start <= pos2 && (pos2 < start + length || atEnd && pos2 === start + length)) {
+        return { s, local: pos2 - start, room: start + length - pos2 };
+      }
+    }
+    return void 0;
+  };
+  const add = (s, mismatch) => {
+    const list = byStep[s];
+    const last = list.at(-1);
+    if (mismatch.type === "substitution" && last?.type === "substitution" && last.pos + last.seq.length === mismatch.pos) {
+      last.seq += mismatch.seq;
+    } else {
+      list.push(mismatch);
+    }
+  };
+  let pos = record.pathStart;
+  for (const op of parseCs(record.cs)) {
+    if (op.op === "match") {
+      pos += op.length;
+    } else if (op.op === "substitution") {
+      const at = stepAt(pos);
+      if (at) {
+        add(at.s, { type: "substitution", pos: at.local, seq: op.seq });
+      }
+      pos += 1;
+    } else if (op.op === "insertion") {
+      const at = stepAt(pos, pos === record.pathEnd);
+      if (at) {
+        add(at.s, { type: "insertion", pos: at.local, seq: op.seq });
+      }
+    } else {
+      let left = op.length;
+      while (left > 0) {
+        const at = stepAt(pos);
+        const take = at ? Math.min(left, at.room) : left;
+        if (at) {
+          add(at.s, { type: "deletion", pos: at.local, length: take });
+        }
+        pos += take;
+        left -= take;
+      }
+    }
+  }
+  return byStep;
+}
+function tubeMapReads(graph, records, firstId) {
+  const nodeByName = new Map(graph.nodes.map((n) => [n.name, n]));
+  const reads = [];
+  for (const record of records) {
+    const nodes = record.path.map((step) => nodeByName.get(step.name));
+    const kept = nodes.flatMap((node, i) => node ? [i] : []);
+    const first = kept[0];
+    const last = kept.at(-1);
+    if (first !== void 0 && last !== void 0) {
+      const mismatches = mismatchesByStep(
+        record,
+        nodes.map((n) => n?.length)
+      );
+      const names = kept.map((i) => stepName(nodes[i], record.path[i].strand));
+      const lastLength = nodes[last].length;
+      reads.push({
+        id: firstId + reads.length,
+        name: record.name,
+        type: "read",
+        sourceTrackID: 1,
+        sequence: names,
+        sequenceNew: kept.map((i, k) => ({
+          nodeName: names[k],
+          mismatches: mismatches[i]
+        })),
+        firstNodeOffset: first === 0 ? record.pathStart : 0,
+        finalNodeCoverLength: last === record.path.length - 1 ? lastLength - (record.pathLength - record.pathEnd) : lastLength,
+        mapping_quality: record.mappingQuality === 255 ? 0 : record.mappingQuality,
+        is_secondary: record.secondary,
+        is_reverse: record.strand === "-"
+      });
+    }
+  }
+  return reads;
+}
+var FORWARD_READ_COLORS = ["#6baed6", "#4292c6", "#2171b5", "#08519c"];
+var REVERSE_READ_COLORS = ["#fb6a4a", "#ef3b2c", "#cb181d", "#a50f15"];
+function readColor(read) {
+  const colors = read.is_reverse ? REVERSE_READ_COLORS : FORWARD_READ_COLORS;
+  return colors[read.id % colors.length];
+}
+
+export {
+  canonicalStrand,
+  stepName,
+  tubeMapReads,
+  FORWARD_READ_COLORS,
+  REVERSE_READ_COLORS,
+  readColor
+};

package/dist/chunks/chunk-TZFWUT2C.js

@@ -0,0 +1,66 @@
+import {
+  projectAlleles
+} from "./chunk-RVS2QCOX.js";
+import {
+  buildNeighbors
+} from "./chunk-ES2N6V56.js";
+
+// src/layout/placeOffReference.ts
+var MIN_DELETION_BP = 1;
+var MIN_ALLELE_SPAN_FRACTION = 0.015;
+function placeOffReference({
+  graph,
+  span,
+  rowY,
+  positions
+}) {
+  const minSpan = span * MIN_ALLELE_SPAN_FRACTION;
+  const alleles = projectAlleles(graph);
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const alleleDeletions = [];
+  for (const allele of alleles) {
+    const skipped = allele.refSpan - allele.pathLength;
+    if (skipped >= MIN_DELETION_BP) {
+      alleleDeletions.push({ nodeIds: allele.nodeIds, bp: skipped });
+    }
+    const drawn = Math.max(allele.refSpan, minSpan);
+    const scale = allele.pathLength > 0 ? drawn / allele.pathLength : 0;
+    allele.nodeIds.forEach((nodeId, i) => {
+      const node = byId.get(nodeId);
+      if (node) {
+        const offset = allele.nodeOffsets[i];
+        const even = drawn / allele.nodeIds.length;
+        const at = (bp) => allele.start + bp * scale;
+        const y = rowY(node);
+        positions[nodeId] = scale ? [
+          { x: at(offset), y },
+          { x: at(offset + node.length), y }
+        ] : [
+          { x: allele.start + i * even, y },
+          { x: allele.start + (i + 1) * even, y }
+        ];
+      }
+    });
+  }
+  const neighbors = buildNeighbors(graph);
+  const queue = Object.keys(positions);
+  for (const fromId of queue) {
+    const fromEnd = positions[fromId].at(-1).x;
+    for (const nextId of neighbors.get(fromId) ?? []) {
+      const next = byId.get(nextId);
+      if (next && !(nextId in positions)) {
+        const y = rowY(next);
+        positions[nextId] = [
+          { x: fromEnd, y },
+          { x: fromEnd + minSpan, y }
+        ];
+        queue.push(nextId);
+      }
+    }
+  }
+  return alleleDeletions;
+}
+
+export {
+  placeOffReference
+};

package/dist/chunks/chunk-UVBGRJQX.js

@@ -0,0 +1,50 @@
+import {
+  MEAN_NODE_LENGTH,
+  PROPORTIONAL_LENGTH
+} from "./chunk-6JEWNXCQ.js";
+
+// src/bubbleSpreads.ts
+var BUBBLE_SPREADS = [
+  {
+    value: "auto",
+    label: "Proportional",
+    description: "Bandage's own scale: a node draws proportional to its length, so a 1 bp allele is a speck.",
+    law: PROPORTIONAL_LENGTH,
+    minNodeFactor: 0
+  },
+  {
+    value: "open",
+    label: "Open bubbles",
+    description: "Give every allele a drawn length, so a bubble reads as two arms rather than a knot.",
+    law: PROPORTIONAL_LENGTH,
+    minNodeFactor: 2.5
+  },
+  {
+    value: "wide",
+    label: "Wide bubbles",
+    description: "As open, spread further. Best on a window of a dozen bubbles.",
+    law: PROPORTIONAL_LENGTH,
+    minNodeFactor: 10
+  },
+  {
+    value: "compress",
+    label: "Compress lengths",
+    description: "Pull the longest and shortest nodes towards the graph\u2019s mean, so a cut spanning kb and bp fits one pane.",
+    law: { power: 0.5, effect: 0.5 },
+    minNodeFactor: 0
+  }
+];
+var BUBBLE_SPREAD_VALUES = BUBBLE_SPREADS.map((s) => s.value);
+function spreadFor(spread) {
+  const entry = BUBBLE_SPREADS.find((s) => s.value === spread);
+  return {
+    law: entry?.law ?? PROPORTIONAL_LENGTH,
+    minNodeLength: (entry?.minNodeFactor ?? 0) * MEAN_NODE_LENGTH
+  };
+}
+
+export {
+  BUBBLE_SPREADS,
+  BUBBLE_SPREAD_VALUES,
+  spreadFor
+};

package/dist/chunks/chunk-VHW7FDHU.js

@@ -0,0 +1,42 @@
+import {
+  trimOrigins
+} from "./chunk-ST2IBUAN.js";
+
+// src/bubbles/popBubble.ts
+function bubbleSubgraph(graph, segmentIds) {
+  const keep = new Set(segmentIds);
+  const nodes = graph.nodes.filter((n) => keep.has(n.name));
+  const ids = new Set(nodes.map((n) => n.id));
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const kept = /* @__PURE__ */ new Map();
+  const paths = graph.paths?.flatMap((p) => {
+    const first = p.nodeIds.findIndex((id) => ids.has(id));
+    if (first < 0) {
+      return [];
+    }
+    const nodeIds = p.nodeIds.filter((id) => ids.has(id));
+    kept.set(p.name, { first, nodeIds });
+    const before = p.nodeIds.slice(0, first).reduce((sum, id) => sum + (lengthOf.get(id) ?? 0), 0);
+    return [
+      {
+        ...p,
+        nodeIds,
+        ...p.start === void 0 ? {} : { start: p.start + before }
+      }
+    ];
+  });
+  return {
+    name: graph.name,
+    nodes,
+    edges: graph.edges.filter((e) => ids.has(e.from) && ids.has(e.to)),
+    ...paths?.length ? { paths } : {},
+    anchorPaths: trimOrigins(graph, kept),
+    pathVisits: graph.pathVisits,
+    anchoredBy: graph.anchoredBy,
+    referencePath: graph.referencePath
+  };
+}
+
+export {
+  bubbleSubgraph
+};