@jbrowse/bandage-core 6.0.1 → 6.0.2

package/dist/chunks/chunk-RVS2QCOX.js

@@ -0,0 +1,135 @@
+import {
+  buildNeighbors
+} from "./chunk-ES2N6V56.js";
+import {
+  REFERENCE_RANK,
+  isAnchored
+} from "./chunk-FYQWPEEY.js";
+
+// src/alleleProjection/projectAlleles.ts
+function parsePanSN(refName) {
+  const parts = refName.split("#");
+  const haplotype = parts.length >= 2 ? Number(parts[1]) : Number.NaN;
+  return {
+    sample: parts[0] ?? refName,
+    haplotype: Number.isFinite(haplotype) ? haplotype : void 0
+  };
+}
+function collectRun(seed, byId, adj, claimed) {
+  const members = [];
+  const anchors = [];
+  const queue = [seed];
+  claimed.add(seed);
+  while (queue.length > 0) {
+    const id = queue.pop();
+    const node = byId.get(id);
+    if (node) {
+      members.push(node);
+      for (const neighborId of adj.get(id) ?? []) {
+        const neighbor = byId.get(neighborId);
+        if (neighbor) {
+          if (neighbor.stable.rank === REFERENCE_RANK) {
+            anchors.push(neighbor);
+          } else if (!claimed.has(neighborId)) {
+            claimed.add(neighborId);
+            queue.push(neighborId);
+          }
+        }
+      }
+    }
+  }
+  return { members, anchors };
+}
+function anchorSpan(anchors) {
+  const refNames = new Set(anchors.map((a) => a.stable.refName));
+  if (refNames.size !== 1 || anchors.length < 2) {
+    return void 0;
+  }
+  const sorted = [...anchors].sort((a, b) => a.stable.start - b.stable.start);
+  const first = sorted[0];
+  const last = sorted.at(-1);
+  const start = first.stable.start + first.length;
+  const end = last.stable.start;
+  return end >= start ? { start, end, entry: first } : void 0;
+}
+function runDistances(members, entry, adj) {
+  const byId = new Map(members.map((m) => [m.id, m]));
+  const dist = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const neighborId of adj.get(entry.id) ?? []) {
+    if (byId.has(neighborId)) {
+      dist.set(neighborId, 0);
+      queue.push(neighborId);
+    }
+  }
+  if (queue.length === 0) {
+    for (const member of members) {
+      dist.set(member.id, 0);
+      queue.push(member.id);
+    }
+  }
+  for (const id of queue) {
+    const reach = dist.get(id) + byId.get(id).length;
+    for (const neighborId of adj.get(id) ?? []) {
+      if (byId.has(neighborId)) {
+        const known = dist.get(neighborId);
+        if (known === void 0 || reach < known) {
+          dist.set(neighborId, reach);
+          queue.push(neighborId);
+        }
+      }
+    }
+  }
+  return dist;
+}
+function runOffsets(members, entry, adj) {
+  const dist = runDistances(members, entry, adj);
+  const ordered = [...members].sort((a, b) => dist.get(a.id) - dist.get(b.id));
+  const rank = new Map(ordered.map((m, i) => [m.id, i]));
+  const byId = new Map(members.map((m) => [m.id, m]));
+  const offsets = /* @__PURE__ */ new Map();
+  for (const [i, member] of ordered.entries()) {
+    let offset = 0;
+    for (const neighborId of adj.get(member.id) ?? []) {
+      const neighbor = byId.get(neighborId);
+      if (neighbor && rank.get(neighborId) < i) {
+        offset = Math.max(offset, offsets.get(neighborId) + neighbor.length);
+      }
+    }
+    offsets.set(member.id, offset);
+  }
+  return { offsets, ordered };
+}
+function projectAlleles(graph) {
+  const byId = new Map(
+    graph.nodes.filter(isAnchored).map((n) => [n.id, n])
+  );
+  const adj = buildNeighbors(graph);
+  const claimed = /* @__PURE__ */ new Set();
+  const alleles = [];
+  for (const node of byId.values()) {
+    if (node.stable.rank !== REFERENCE_RANK && !claimed.has(node.id)) {
+      const { members, anchors } = collectRun(node.id, byId, adj, claimed);
+      const span = anchorSpan(anchors);
+      if (span) {
+        const { offsets, ordered } = runOffsets(members, span.entry, adj);
+        alleles.push({
+          start: span.start,
+          refSpan: span.end - span.start,
+          nodeIds: ordered.map((m) => m.id),
+          nodeOffsets: ordered.map((m) => offsets.get(m.id)),
+          pathLength: ordered.reduce(
+            (max, m) => Math.max(max, offsets.get(m.id) + m.length),
+            0
+          )
+        });
+      }
+    }
+  }
+  return alleles.sort((a, b) => a.start - b.start);
+}
+
+export {
+  parsePanSN,
+  projectAlleles
+};

package/dist/chunks/chunk-SDGM243E.js

@@ -0,0 +1,190 @@
+import {
+  ownStrand,
+  strandSides
+} from "./chunk-3PLYZLYV.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/mergeRuns.ts
+function flip(strand) {
+  return strand === "+" ? "-" : "+";
+}
+function mergeRuns(graph, alone = /* @__PURE__ */ new Set()) {
+  const sides = graph.edges.map(strandSides);
+  const at = /* @__PURE__ */ new Map();
+  const attach = (id, side, ei) => {
+    const key = `${id}|${side}`;
+    const list = at.get(key);
+    if (list) {
+      list.push(ei);
+    } else {
+      at.set(key, [ei]);
+    }
+  };
+  graph.edges.forEach((edge, ei) => {
+    attach(edge.from, sides[ei].from, ei);
+    attach(edge.to, sides[ei].to, ei);
+  });
+  const joinAfter = (a) => {
+    const out = at.get(`${a}|end`);
+    if (out?.length !== 1) {
+      return void 0;
+    }
+    const ei = out[0];
+    const edge = graph.edges[ei];
+    return edge.from === a && edge.to !== a && !alone.has(a) && !alone.has(edge.to) && sides[ei].from === "end" && sides[ei].to === "start" && at.get(`${edge.to}|start`)?.length === 1 ? ei : void 0;
+  };
+  const joined = /* @__PURE__ */ new Set();
+  const runOf = /* @__PURE__ */ new Map();
+  const runs = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const into = at.get(`${node.id}|start`);
+    const pred = into?.length === 1 ? graph.edges[into[0]].from : void 0;
+    if (runOf.has(node.id) || pred !== void 0 && joinAfter(pred) === into[0]) {
+      continue;
+    }
+    const run = [node.id];
+    for (; ; ) {
+      const ei = joinAfter(run.at(-1));
+      const next = ei === void 0 ? void 0 : graph.edges[ei].to;
+      if (next === void 0 || runOf.has(next)) {
+        break;
+      }
+      joined.add(ei);
+      run.push(next);
+    }
+    for (const id of run) {
+      runOf.set(id, node.id);
+    }
+    if (run.length > 1) {
+      runs.set(node.id, run);
+    }
+  }
+  for (const node of graph.nodes) {
+    if (!runOf.has(node.id)) {
+      runOf.set(node.id, node.id);
+    }
+  }
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const nodes = [];
+  for (const node of graph.nodes) {
+    if (runOf.get(node.id) !== node.id) {
+      continue;
+    }
+    const run = runs.get(node.id);
+    if (!run) {
+      nodes.push(node);
+      continue;
+    }
+    const members = run.map((id) => byId.get(id));
+    const backbone = members.filter(isBackbone);
+    const first = backbone.length ? backbone.reduce((a, b) => a.stable.start <= b.stable.start ? a : b) : members[0];
+    nodes.push({
+      id: node.id,
+      name: node.name,
+      length: members.reduce((sum, n) => sum + n.length, 0),
+      depth: node.depth,
+      stable: first.stable
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  graph.edges.forEach((edge, ei) => {
+    const from = runOf.get(edge.from);
+    const to = runOf.get(edge.to);
+    const side = sides[ei];
+    const key = `${from}|${side.from}>${to}|${side.to}`;
+    if (joined.has(ei) || seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    edges.push({
+      from,
+      to,
+      ...side.from === "start" ? { fromStrand: flip(ownStrand(from)) } : {},
+      ...side.to === "end" ? { toStrand: flip(ownStrand(to)) } : {}
+    });
+  });
+  return {
+    graph: { ...graph, nodes, edges, paths: void 0, pathVisits: void 0 },
+    runs
+  };
+}
+function splitRuns(positions, runs, weightOf) {
+  const out = { ...positions };
+  for (const [id, members] of runs) {
+    const line = positions[id];
+    if (!line?.length) {
+      continue;
+    }
+    delete out[id];
+    const arc = arcPrefix(line);
+    const total = arc.at(-1);
+    const weights = members.map((m) => Math.max(weightOf(m), 0));
+    const weightSum = weights.reduce((a, b) => a + b, 0) || members.length;
+    let from = 0;
+    members.forEach((member, k) => {
+      const share = weightSum ? weights[k] / weightSum * total : total / members.length;
+      const to = k === members.length - 1 ? total : from + share;
+      out[member] = slice(line, arc, from, to);
+      from = to;
+    });
+  }
+  return out;
+}
+function polylineSlice(line, from, to) {
+  if (line.length === 0) {
+    return [];
+  }
+  const arc = arcPrefix(line);
+  const total = arc.at(-1);
+  return slice(line, arc, from * total, to * total);
+}
+function polylineMidpoint(line) {
+  const arc = arcPrefix(line);
+  return pointAt(line, arc, arc.at(-1) / 2);
+}
+function arcPrefix(line) {
+  const arc = [0];
+  for (let i = 1; i < line.length; i++) {
+    arc.push(
+      arc[i - 1] + Math.hypot(line[i].x - line[i - 1].x, line[i].y - line[i - 1].y)
+    );
+  }
+  return arc;
+}
+function pointAt(line, arc, s) {
+  if (s <= 0) {
+    return { ...line[0] };
+  }
+  let i = 1;
+  while (i < arc.length && arc[i] < s) {
+    i++;
+  }
+  if (i >= arc.length) {
+    return { ...line.at(-1) };
+  }
+  const span = arc[i] - arc[i - 1];
+  const t = span > 0 ? (s - arc[i - 1]) / span : 0;
+  const a = line[i - 1];
+  const b = line[i];
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function slice(line, arc, from, to) {
+  const points = [pointAt(line, arc, from)];
+  for (let i = 0; i < line.length; i++) {
+    if (arc[i] > from && arc[i] < to) {
+      points.push({ ...line[i] });
+    }
+  }
+  points.push(pointAt(line, arc, to));
+  return points;
+}
+
+export {
+  mergeRuns,
+  splitRuns,
+  polylineSlice,
+  polylineMidpoint
+};

package/dist/chunks/chunk-ST2IBUAN.js

@@ -0,0 +1,119 @@
+import {
+  panSNSample
+} from "./chunk-BPLIXMH7.js";
+import {
+  REFERENCE_RANK
+} from "./chunk-FYQWPEEY.js";
+
+// src/pathAnchoring.ts
+var RANGE_SUFFIX = /:(\d+)-\d+$/;
+function pathOrigin(pathName) {
+  const match = RANGE_SUFFIX.exec(pathName);
+  return match ? { name: pathName.slice(0, match.index), start: +match[1] } : { name: pathName, start: 0 };
+}
+function surveyPaths(paths, lengthOf) {
+  const anchorPaths = [];
+  const pathVisits = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    const sample = panSNSample(path.name);
+    let pos = path.start;
+    for (const step of path.steps) {
+      const visit = {
+        path: path.name,
+        sample,
+        start: pos,
+        strand: step.strand
+      };
+      const existing = pathVisits.get(step.id);
+      if (existing) {
+        existing.push(visit);
+      } else {
+        pathVisits.set(step.id, [visit]);
+      }
+      pos += lengthOf(step.id);
+    }
+    anchorPaths.push({
+      name: path.name,
+      sample,
+      start: path.start,
+      length: pos - path.start
+    });
+  }
+  return { anchorPaths, pathVisits };
+}
+function chooseReferencePath(anchorPaths, preferred) {
+  const named = anchorPaths.find(
+    (p) => p.sample === preferred || p.name === preferred
+  );
+  return named ?? anchorPaths[0];
+}
+var OFF_REFERENCE_RANK = 1;
+function anchorNode(node, visits, reference) {
+  let anchored = node;
+  if (visits && visits.length > 0) {
+    const anchor = visits.find((v) => v.path === reference) ?? visits[0];
+    anchored = {
+      ...node,
+      stable: {
+        refName: anchor.path,
+        start: anchor.start,
+        rank: anchor.path === reference ? REFERENCE_RANK : OFF_REFERENCE_RANK,
+        strand: anchor.strand
+      },
+      samples: [...new Set(visits.map((v) => v.sample))].sort()
+    };
+  }
+  return anchored;
+}
+function anchorFromPaths(graph, preferred) {
+  const { anchorPaths, pathVisits } = graph;
+  const reference = anchorPaths && pathVisits ? chooseReferencePath(anchorPaths, preferred) : void 0;
+  return reference && pathVisits ? {
+    ...graph,
+    nodes: graph.nodes.map(
+      (node) => anchorNode(node, pathVisits.get(node.name), reference.name)
+    ),
+    anchoredBy: "paths",
+    referencePath: reference.name
+  } : graph;
+}
+function anchorGraph(graph, preferred) {
+  return graph.anchoredBy === "tags" ? graph : anchorFromPaths(graph, preferred);
+}
+function trimOrigins(graph, kept) {
+  if (!graph.anchorPaths) {
+    return void 0;
+  }
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const bp = (ids, end = ids.length) => {
+    let sum = 0;
+    for (let i = 0; i < end; i++) {
+      sum += lengthOf.get(ids[i]) ?? 0;
+    }
+    return sum;
+  };
+  const byOrigin = /* @__PURE__ */ new Map();
+  for (const path of graph.paths ?? []) {
+    const origin = pathOrigin(path.name).name;
+    byOrigin.set(origin, [...byOrigin.get(origin) ?? [], path]);
+  }
+  return graph.anchorPaths.map((o) => {
+    const pieces = byOrigin.get(o.name);
+    const path = pieces?.length === 1 ? pieces[0] : void 0;
+    const stretch = path && kept.get(path.name);
+    return path && stretch ? {
+      ...o,
+      start: o.start + bp(path.nodeIds, stretch.first),
+      length: bp(stretch.nodeIds)
+    } : o;
+  });
+}
+
+export {
+  pathOrigin,
+  surveyPaths,
+  chooseReferencePath,
+  anchorFromPaths,
+  anchorGraph,
+  trimOrigins
+};

package/dist/chunks/chunk-SV27AJCC.js

@@ -0,0 +1,101 @@
+import {
+  polylineSlice
+} from "./chunk-SDGM243E.js";
+import {
+  svgPath
+} from "./chunk-3PLYZLYV.js";
+import {
+  firstNodeAtOrAfter,
+  isAnchored
+} from "./chunk-FYQWPEEY.js";
+
+// src/genes/genePins.ts
+function genePins(graph, genes, positions) {
+  const byRefName = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isAnchored(node)) {
+      const { refName } = node.stable;
+      if (positions[node.id]?.length) {
+        const entry = byRefName.get(refName) ?? byRefName.set(refName, { nodes: [], reach: 0 }).get(refName);
+        entry.nodes.push(node);
+        entry.reach = Math.max(entry.reach, node.length);
+      }
+    }
+  }
+  for (const { nodes } of byRefName.values()) {
+    nodes.sort((a, b) => a.stable.start - b.stable.start);
+  }
+  const pins = [];
+  for (const gene of genes) {
+    const onRefName = byRefName.get(gene.refName);
+    if (!onRefName) {
+      continue;
+    }
+    const parts = [];
+    const exonsByNode = [];
+    const nodeIds = /* @__PURE__ */ new Set();
+    let at;
+    let atDistance = Infinity;
+    let covered = 0;
+    const mid = (gene.start + gene.end) / 2;
+    const { nodes, reach } = onRefName;
+    for (let i = firstNodeAtOrAfter(nodes, gene.start - reach); i < nodes.length && nodes[i].stable.start < gene.end; i++) {
+      const node = nodes[i];
+      const nodeStart = node.stable.start;
+      const nodeEnd = nodeStart + node.length;
+      if (nodeEnd <= gene.start) {
+        continue;
+      }
+      const line = positions[node.id];
+      nodeIds.add(node.id);
+      covered += Math.min(nodeEnd, gene.end) - Math.max(nodeStart, gene.start);
+      const nodeParts = [];
+      for (const exon of gene.exons) {
+        const a = Math.max(exon.start, nodeStart);
+        const b = Math.min(exon.end, nodeEnd);
+        if (b <= a) {
+          continue;
+        }
+        const stretch = polylineSlice(
+          line,
+          (a - nodeStart) / node.length,
+          (b - nodeStart) / node.length
+        );
+        if (stretch.length === 1) {
+          stretch.push({ ...stretch[0] });
+        }
+        nodeParts.push(svgPath(stretch));
+      }
+      if (nodeParts.length > 0) {
+        parts.push(...nodeParts);
+        exonsByNode.push({ nodeId: node.id, d: nodeParts.join("") });
+      }
+      const pinBp = Math.min(Math.max(mid, nodeStart), nodeEnd);
+      const distance = Math.abs(pinBp - mid);
+      if (distance < atDistance) {
+        atDistance = distance;
+        const [p] = polylineSlice(
+          line,
+          (pinBp - nodeStart) / node.length,
+          (pinBp - nodeStart) / node.length
+        );
+        at = p;
+      }
+    }
+    if (at) {
+      pins.push({
+        gene,
+        exons: parts.join(""),
+        exonsByNode,
+        nodeIds,
+        at,
+        covered: covered / (gene.end - gene.start)
+      });
+    }
+  }
+  return pins;
+}
+
+export {
+  genePins
+};