@jbrowse/bandage-core 6.0.1 → 6.0.3

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-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-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-T43W7NKK.js

@@ -0,0 +1,122 @@
+import {
+  hasTubeMapPaths,
+  tubeMapLayout,
+  tubeMapReferenceLayout
+} from "./chunk-R6ZUK4Y3.js";
+import {
+  sampleRowLayout
+} from "./chunk-LOEA5IHZ.js";
+import {
+  anchoredLayout
+} from "./chunk-L3O7AWLI.js";
+import {
+  orderedLayout
+} from "./chunk-HNQPEMYE.js";
+import {
+  walkRowLayout
+} from "./chunk-EZPBJPK6.js";
+import {
+  isBackbone,
+  isOffReference
+} from "./chunk-FYQWPEEY.js";
+
+// src/layoutModes.ts
+var FORCE_LAYOUT_LABEL = "Force-directed layout";
+var hasBackbone = (graph) => graph.nodes.some(isBackbone);
+var hasWalks = (graph) => hasBackbone(graph) && (graph.paths?.length ?? 0) > 1;
+var hasTubeMapBackbone = (graph) => hasBackbone(graph) && hasTubeMapPaths(graph);
+var hasAlleles = (graph) => hasBackbone(graph) && graph.nodes.some(isOffReference);
+var LAYOUT_MODES = [
+  {
+    value: "auto",
+    label: "Anchored",
+    description: "x is reference bp, one row per stable rank. Needs rGFA tags or a reference path.",
+    run: anchoredLayout,
+    cutMargins: true,
+    wholeWalks: false,
+    available: hasBackbone,
+    drawsLocally: hasBackbone,
+    drawsNodes: true
+  },
+  {
+    value: "samplerows",
+    label: "Sample rows",
+    description: "x is reference bp, one row per contributing assembly. Needs rGFA tags or a reference path.",
+    run: sampleRowLayout,
+    cutMargins: true,
+    wholeWalks: false,
+    available: hasAlleles,
+    drawsLocally: hasAlleles,
+    drawsNodes: true
+  },
+  {
+    value: "walkrows",
+    label: "Walk rows",
+    description: "x is each walk's own bp: one bar per haplotype, blue on the reference's path and purple off it, so a repeat expansion reads as bar length, and each bar boxes its haplotype's own genes where the session has them. Needs W or P lines.",
+    run: walkRowLayout,
+    cutMargins: false,
+    wholeWalks: true,
+    available: hasWalks,
+    drawsLocally: hasWalks,
+    drawsNodes: false
+  },
+  {
+    value: "ordered",
+    label: "Ordered",
+    description: "x is reference order, not bp: every node gets room, bubbles read as lenses. Needs rGFA tags or a reference path.",
+    run: orderedLayout,
+    cutMargins: false,
+    wholeWalks: false,
+    available: hasBackbone,
+    drawsLocally: hasBackbone,
+    drawsNodes: true
+  },
+  {
+    value: "tubemap",
+    label: "Tube map",
+    description: "sequenceTubeMap: every path a coloured tube through boxed nodes, columns in node order and node widths log-scaled. Needs P or W lines.",
+    run: tubeMapLayout,
+    cutMargins: false,
+    wholeWalks: false,
+    available: hasTubeMapPaths,
+    drawsLocally: hasTubeMapPaths,
+    drawsNodes: false
+  },
+  {
+    value: "tubemapref",
+    label: "Tube map on reference",
+    description: "The tube map with each column at the reference bp it covers, so the tubes line up with the tracks around them. Needs P or W lines and a reference path.",
+    run: tubeMapReferenceLayout,
+    cutMargins: true,
+    wholeWalks: false,
+    available: hasTubeMapBackbone,
+    drawsLocally: hasTubeMapBackbone,
+    drawsNodes: false
+  },
+  {
+    value: "force",
+    label: FORCE_LAYOUT_LABEL,
+    description: "OGDF FMMM, via the external Bandage engine.",
+    run: () => void 0,
+    cutMargins: false,
+    wholeWalks: false,
+    available: () => true,
+    drawsLocally: () => false,
+    drawsNodes: true
+  }
+];
+var LAYOUT_MODE_VALUES = LAYOUT_MODES.map((m) => m.value);
+function modeUsesLayoutEngine(value, graph) {
+  return !layoutModeByValue(value).drawsLocally(graph);
+}
+function layoutModeByValue(value) {
+  return LAYOUT_MODES.find((m) => m.value === value) ?? LAYOUT_MODES[0];
+}
+
+export {
+  FORCE_LAYOUT_LABEL,
+  LAYOUT_MODES,
+  LAYOUT_MODE_VALUES,
+  modeUsesLayoutEngine,
+  layoutModeByValue
+};