@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-PUG7LXDF.js

@@ -0,0 +1,70 @@
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/orientToReference.ts
+function orientToReference(graph, positions) {
+  const backbone = graph.nodes.filter(
+    (node) => isBackbone(node) && (positions[node.id]?.length ?? 0) > 0
+  );
+  if (backbone.length < 2) {
+    return positions;
+  }
+  const points = backbone.map((node) => {
+    const segments = positions[node.id];
+    const mid = segments[Math.floor(segments.length / 2)];
+    return {
+      x: mid.x,
+      y: mid.y,
+      r: node.stable.start + node.length / 2,
+      w: node.length
+    };
+  });
+  const weight = points.reduce((sum, p) => sum + p.w, 0);
+  const cx = points.reduce((sum, p) => sum + p.x * p.w, 0) / weight;
+  const cy = points.reduce((sum, p) => sum + p.y * p.w, 0) / weight;
+  const cr = points.reduce((sum, p) => sum + p.r * p.w, 0) / weight;
+  let sxr = 0;
+  let syr = 0;
+  for (const p of points) {
+    sxr += p.w * (p.x - cx) * (p.r - cr);
+    syr += p.w * (p.y - cy) * (p.r - cr);
+  }
+  const angle = -Math.atan2(syr, sxr);
+  const c = Math.cos(angle);
+  const s = Math.sin(angle);
+  const out = {};
+  for (const [id, segments] of Object.entries(positions)) {
+    out[id] = segments.map((p) => {
+      const x = p.x - cx;
+      const y = p.y - cy;
+      return { x: cx + c * x - s * y, y: cy + s * x + c * y };
+    });
+  }
+  let below = 0;
+  let above = 0;
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      continue;
+    }
+    for (const p of out[node.id] ?? []) {
+      if (p.y > cy) {
+        below++;
+      } else {
+        above++;
+      }
+    }
+  }
+  if (above > below) {
+    for (const segments of Object.values(out)) {
+      for (const p of segments) {
+        p.y = 2 * cy - p.y;
+      }
+    }
+  }
+  return out;
+}
+
+export {
+  orientToReference
+};

package/dist/chunks/chunk-R6ZUK4Y3.js

@@ -0,0 +1,232 @@
+import {
+  canonicalStrand,
+  readColor,
+  stepName,
+  tubeMapReads
+} from "./chunk-TEDQJPMI.js";
+import {
+  pathCssColor,
+  pathGreyCssColor
+} from "./chunk-X5L37W4J.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/tubeMapLayout.ts
+import { layoutTubeMap } from "@gmod/tubemap-core";
+function visitStrands(graph) {
+  const strands = /* @__PURE__ */ new Map();
+  for (const [segment, visits] of graph.pathVisits ?? []) {
+    for (const visit of visits) {
+      const key = `${visit.path}	${segment}`;
+      const list = strands.get(key);
+      if (list) {
+        list.push(visit.strand);
+      } else {
+        strands.set(key, [visit.strand]);
+      }
+    }
+  }
+  return strands;
+}
+function tubeMapTracks(graph) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const strands = visitStrands(graph);
+  const paths = (graph.paths ?? []).map((path, index) => ({ path, index }));
+  const reference = paths.findIndex(
+    (p) => pathOrigin(p.path.name).name === graph.referencePath
+  );
+  if (reference > 0) {
+    paths.unshift(...paths.splice(reference, 1));
+  }
+  return paths.flatMap(({ path, index }) => {
+    const visitName = pathOrigin(path.name).name;
+    const seen = /* @__PURE__ */ new Map();
+    const sequence = path.nodeIds.flatMap((id) => {
+      const node = nodeById.get(id);
+      if (!node) {
+        return [];
+      }
+      const k = seen.get(node.name) ?? 0;
+      seen.set(node.name, k + 1);
+      const strand = strands.get(`${visitName}	${node.name}`)?.[k] ?? canonicalStrand(node);
+      return [stepName(node, strand)];
+    });
+    return sequence.length > 0 ? [
+      {
+        id: index,
+        name: path.name,
+        sequence,
+        sourceTrackID: 0,
+        type: "haplotype"
+      }
+    ] : [];
+  });
+}
+function tubeMapNodes(graph) {
+  return graph.nodes.map((n) => ({
+    name: n.id,
+    seq: "",
+    sequenceLength: Math.max(1, n.length)
+  }));
+}
+function hasTubeMapPaths(graph) {
+  return (graph.paths?.length ?? 0) > 0;
+}
+var STACK_PX = 600;
+var MIN_TUBE_PX = 3;
+var MAX_TUBE_PX = 15;
+function tubeWidth(trackCount) {
+  return Math.max(
+    MIN_TUBE_PX,
+    Math.min(MAX_TUBE_PX, Math.floor(STACK_PX / Math.max(1, trackCount)))
+  );
+}
+function runTubeMap(graph) {
+  const paths = graph.paths ?? [];
+  const tracks = tubeMapTracks(graph);
+  const reads = graph.reads ? tubeMapReads(graph, graph.reads, paths.length) : [];
+  const tubeColor = reads.length > 0 ? pathGreyCssColor : pathCssColor;
+  const pathColors = paths.map((_, i) => tubeColor(i, paths.length));
+  const layout = layoutTubeMap(tubeMapNodes(graph), tracks, reads, {
+    nodeWidthOption: "compressed",
+    trackWidth: tubeWidth(tracks.length),
+    trackColor: (track) => track.type === "read" ? readColor(track) : pathColors[track.id]
+  });
+  return layout ? { layout, pathColors } : void 0;
+}
+function drawnNodes(layout) {
+  const nodes = [];
+  layout.nodes.forEach((node) => {
+    if (node.order >= 0) {
+      nodes.push(node);
+    }
+  });
+  return nodes;
+}
+function centreline(node, yOffset, x0, x1) {
+  const y = node.y + node.contentHeight / 2 - yOffset;
+  return [
+    { x: x0, y },
+    { x: x1, y }
+  ];
+}
+function extentOf(layout, yOffset) {
+  return {
+    minY: layout.bounds.minY - yOffset,
+    maxY: layout.bounds.maxY - yOffset
+  };
+}
+function tubeMapLayout(graph) {
+  const run = hasTubeMapPaths(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, pathColors } = run;
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    nodePositions[node.name] = centreline(
+      node,
+      yOffset,
+      node.x,
+      node.x + node.pixelWidth
+    );
+  }
+  const { minY, maxY } = extentOf(layout, yOffset);
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, pathColors },
+    extent: {
+      minX: layout.bounds.minX,
+      maxX: layout.bounds.maxX,
+      minY,
+      maxY
+    }
+  };
+}
+function tubeMapColumns(graph, layout) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const byOrder = /* @__PURE__ */ new Map();
+  for (const node of drawnNodes(layout)) {
+    const list = byOrder.get(node.order);
+    if (list) {
+      list.push(node);
+    } else {
+      byOrder.set(node.order, [node]);
+    }
+  }
+  const columns = [];
+  let end = -Infinity;
+  for (const order of [...byOrder.keys()].sort((a, b) => a - b)) {
+    const nodes = byOrder.get(order);
+    let bp0 = Infinity;
+    let bp1 = -Infinity;
+    for (const node of nodes) {
+      const graphNode = nodeById.get(node.name);
+      if (graphNode && isBackbone(graphNode)) {
+        bp0 = Math.min(bp0, graphNode.stable.start);
+        bp1 = Math.max(bp1, graphNode.stable.start + node.sequenceLength);
+      }
+    }
+    if (bp0 === Infinity) {
+      bp0 = bp1 = end;
+    }
+    if (bp0 < end) {
+      bp0 = end;
+      bp1 = Math.max(end, bp1);
+    }
+    end = Math.max(end, bp1);
+    columns.push({
+      order,
+      x0: Math.min(...nodes.map((n) => n.x)),
+      x1: Math.max(...nodes.map((n) => n.x + n.pixelWidth)),
+      bp0,
+      bp1
+    });
+  }
+  const first = columns.find((c) => c.bp0 !== -Infinity);
+  for (const column of columns) {
+    if (column.bp0 === -Infinity) {
+      column.bp0 = column.bp1 = first?.bp0 ?? 0;
+    }
+  }
+  return columns;
+}
+function pathsReachBackbone(graph) {
+  return graph.nodes.some(isBackbone) && hasTubeMapPaths(graph);
+}
+function tubeMapReferenceLayout(graph) {
+  const run = pathsReachBackbone(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, pathColors } = run;
+  const columns = tubeMapColumns(graph, layout);
+  const byOrder = new Map(columns.map((c) => [c.order, c]));
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    const column = byOrder.get(node.order);
+    nodePositions[node.name] = centreline(node, yOffset, column.bp0, column.bp1);
+  }
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, columns, pathColors },
+    referenceAxis: true,
+    pixelRows: true,
+    extent: extentOf(layout, yOffset)
+  };
+}
+
+export {
+  visitStrands,
+  tubeMapTracks,
+  hasTubeMapPaths,
+  tubeWidth,
+  tubeMapLayout,
+  tubeMapReferenceLayout
+};

package/dist/chunks/chunk-RAKOB6IV.js

@@ -0,0 +1,169 @@
+import {
+  isGenericSample,
+  panSNContig,
+  panSNHaplotype,
+  panSNSample
+} from "./chunk-BPLIXMH7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/reference.ts
+var WELL_KNOWN_SAMPLES = /* @__PURE__ */ new Map([
+  ["hg38", "GRCh38"],
+  ["hg19", "GRCh37"],
+  ["hs1", "CHM13"],
+  ["t2t-chm13", "CHM13"],
+  ["chm13v2", "CHM13"]
+]);
+function wellKnownSample(assemblyName) {
+  return WELL_KNOWN_SAMPLES.get(assemblyName.toLowerCase());
+}
+function sampleOf(refName) {
+  const sample = refName.includes("#") ? panSNSample(refName) : void 0;
+  return sample === void 0 || isGenericSample(sample) ? void 0 : sample;
+}
+function haplotypeOf(refName) {
+  return panSNHaplotype(refName) ?? panSNSample(refName);
+}
+function graphHaplotypes(graph) {
+  const refNames = new Set((graph.anchorPaths ?? []).map((p) => p.name));
+  for (const node of graph.nodes) {
+    if (node.stable) {
+      refNames.add(node.stable.refName);
+    }
+  }
+  const bySample = /* @__PURE__ */ new Map();
+  for (const refName of refNames) {
+    const sample = sampleOf(refName);
+    if (sample !== void 0) {
+      const haplotypes = bySample.get(sample) ?? bySample.set(sample, /* @__PURE__ */ new Set()).get(sample);
+      haplotypes.add(haplotypeOf(refName));
+    }
+  }
+  return bySample;
+}
+function backboneFrom(contigs, haplotypes) {
+  const samples = new Set(contigs.map((c) => sampleOf(c.refName)));
+  const [sample] = samples;
+  if (samples.size !== 1 || sample === void 0) {
+    return { contigs, prefixes: [], named: false };
+  }
+  const own = new Set(contigs.map((c) => haplotypeOf(c.refName)));
+  const unique = [...haplotypes.get(sample) ?? []].every((h) => own.has(h));
+  const shared = new Set(contigs.map((c) => panSNHaplotype(c.refName)));
+  const [haplotype] = shared;
+  return {
+    contigs,
+    prefixes: [
+      ...unique ? [sample] : [],
+      ...shared.size === 1 && haplotype ? [haplotype] : []
+    ],
+    named: true
+  };
+}
+function graphBackbone(graph) {
+  const spans = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      const { refName, start } = node.stable;
+      const end = start + node.length;
+      const span = spans.get(refName);
+      if (span) {
+        span.start = Math.min(span.start, start);
+        span.end = Math.max(span.end, end);
+      } else {
+        spans.set(refName, {
+          refName,
+          contig: panSNContig(refName),
+          start,
+          end
+        });
+      }
+    }
+  }
+  const contigs = [...spans.values()];
+  return contigs.length ? backboneFrom(contigs, graphHaplotypes(graph)) : void 0;
+}
+function referenceLabel(graph, region) {
+  const backbone = graphBackbone(graph);
+  const contig = region ? panSNContig(region.refName) : backbone?.contigs.length === 1 ? backbone.contigs[0].contig : void 0;
+  const sample = backbone?.named ? panSNSample(backbone.contigs[0].refName) : void 0;
+  return contig && (sample ? `${sample} ${contig}` : contig);
+}
+function backboneAssembly(backbone, assemblies) {
+  const names = (a) => [a.name, ...a.aliases ?? []];
+  const naming = (prefix) => (a) => names(a).some((n) => n.toLowerCase() === prefix.toLowerCase());
+  const prefixes = [...backbone?.prefixes ?? []].reverse();
+  const sample = backbone?.prefixes.find((p) => !p.includes("#"))?.toLowerCase();
+  for (const prefix of prefixes) {
+    const assembly = assemblies.find(naming(prefix));
+    if (assembly) {
+      return assembly;
+    }
+  }
+  return sample === void 0 ? void 0 : assemblies.find(
+    (a) => names(a).some((n) => wellKnownSample(n)?.toLowerCase() === sample)
+  );
+}
+function assemblyWalk(graph, assembly) {
+  const haplotypes = graphHaplotypes(graph);
+  return graph.anchorPaths?.find(
+    (walk) => backboneAssembly(
+      backboneFrom(
+        [
+          {
+            refName: walk.name,
+            contig: panSNContig(walk.name),
+            start: walk.start,
+            end: walk.start + walk.length
+          }
+        ],
+        haplotypes
+      ),
+      [assembly]
+    )
+  );
+}
+function contigNames(contig) {
+  const bare = contig.replace(/^chr/i, "");
+  const forms = !bare ? [] : /^(M|MT)$/i.test(bare) ? ["M", "MT"] : [bare];
+  return [.../* @__PURE__ */ new Set([contig, ...forms.flatMap((f) => [f, `chr${f}`])])];
+}
+function refNameBinding(refNames, aliases = {}) {
+  const exact = new Set(refNames);
+  const byName = /* @__PURE__ */ new Map();
+  for (const refName of exact) {
+    const contig = panSNContig(refName);
+    const alias = aliases[contig];
+    for (const name of /* @__PURE__ */ new Set([
+      ...contigNames(contig),
+      ...alias ? [alias] : []
+    ])) {
+      byName.set(name, byName.has(name) ? void 0 : refName);
+    }
+  }
+  return (name) => exact.has(name) ? name : byName.get(name);
+}
+function featuresOnBackbone(features, backbone, aliases) {
+  const bind = refNameBinding(
+    backbone.contigs.map((c) => c.refName),
+    aliases
+  );
+  return features.flatMap((f) => {
+    const refName = bind(f.refName);
+    return refName === void 0 ? [] : [refName === f.refName ? f : { ...f, refName }];
+  });
+}
+
+export {
+  WELL_KNOWN_SAMPLES,
+  wellKnownSample,
+  graphBackbone,
+  referenceLabel,
+  backboneAssembly,
+  assemblyWalk,
+  contigNames,
+  refNameBinding,
+  featuresOnBackbone
+};

package/dist/chunks/chunk-ROF2R3RF.js

@@ -0,0 +1,205 @@
+import {
+  alongRow,
+  boxesGenes
+} from "./chunk-6SXMCK6I.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  LABEL_CHAR_PX
+} from "./chunk-AB35TJST.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  el
+} from "./chunk-NNODIW4U.js";
+
+// src/layout/walkStrip.ts
+var PAD_PX = 6;
+var WALK_STRIP_CEILING_PX = 260;
+var LABEL_FONT_PX = 11;
+var MIN_ROW_PX = 3;
+var LABELLED_ROW_PX = 12;
+var READOUT_ROOM = 1.3;
+var MARK_INK = "#111";
+var TICK_PX = 3;
+function stripMarks(graph, rows, node) {
+  const visits = graph.pathVisits?.get(node.name) ?? [];
+  const marks = [];
+  for (const row of rows) {
+    const axis = row.axis;
+    if (!axis) {
+      continue;
+    }
+    const path = pathOrigin(row.name).name;
+    for (const v of visits) {
+      if (v.path !== path) {
+        continue;
+      }
+      const { start, end } = alongRow(axis, v.start, v.start + node.length);
+      if (end > 0 && start < row.bp) {
+        marks.push({ row: row.name, start, bp: end - start });
+      }
+    }
+  }
+  return marks;
+}
+var spanCache = /* @__PURE__ */ new WeakMap();
+function spansOf(graph, name) {
+  let byName = spanCache.get(graph);
+  if (!byName) {
+    byName = /* @__PURE__ */ new Map();
+    spanCache.set(graph, byName);
+  }
+  if (byName.has(name)) {
+    return byName.get(name);
+  }
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const pieces = (graph.paths ?? []).filter((p) => p.name === name);
+  let spans;
+  if (pieces.every((p) => p.start !== void 0)) {
+    spans = { ids: [], starts: [], ends: [] };
+    for (const piece of [...pieces].sort((a, b) => a.start - b.start)) {
+      let pos = piece.start;
+      for (const id of piece.nodeIds) {
+        const len = lengthOf.get(id) ?? 0;
+        spans.ids.push(id);
+        spans.starts.push(pos);
+        spans.ends.push(pos + len);
+        pos += len;
+      }
+    }
+  }
+  byName.set(name, spans);
+  return spans;
+}
+function segmentAt(graph, row, offset, pxPerBp) {
+  const axis = row.axis;
+  const spans = axis && spansOf(graph, row.name);
+  if (!axis || !spans || offset < 0 || offset > row.bp) {
+    return void 0;
+  }
+  const at = axis.reversed ? axis.start - offset : axis.start + offset;
+  const tol = 0.5 / pxPerBp;
+  const bar = axis.reversed ? { start: axis.start - row.bp, end: axis.start } : { start: axis.start, end: axis.start + row.bp };
+  const from = Math.max(at - tol, bar.start);
+  const to = Math.min(at + tol, bar.end);
+  let lo = 0;
+  let hi = spans.starts.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (spans.ends[mid] <= from) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  let best;
+  let bestLen = -1;
+  let bestHolds = false;
+  for (let i = lo; i < spans.starts.length && spans.starts[i] < to; i++) {
+    const len = spans.ends[i] - spans.starts[i];
+    const holds = spans.starts[i] <= at && at < spans.ends[i];
+    if (len > bestLen || len === bestLen && holds && !bestHolds) {
+      bestLen = len;
+      best = spans.ids[i];
+      bestHolds = holds;
+    }
+  }
+  return best;
+}
+function walkStripFrame(bars, o) {
+  const maxHeight = o.maxHeight ?? WALK_STRIP_CEILING_PX;
+  const labelPx = o.labelPx ?? Math.max(...[bars.reference, ...bars.rows].map((r) => r.label.length)) * LABEL_CHAR_PX + 16;
+  const count = bars.rows.length + 1;
+  const rowPx = Math.max(
+    MIN_ROW_PX,
+    Math.min(ROW_HEIGHT_PX, Math.floor((maxHeight - 2 * PAD_PX) / count))
+  );
+  const labelled = rowPx >= LABELLED_ROW_PX;
+  const readouts = rowPx >= 14;
+  const barPx = Math.max(2, Math.round(rowPx * 0.6));
+  const longest = Math.max(bars.reference.bp, ...bars.rows.map((r) => r.bp), 1);
+  const left = labelled ? labelPx : PAD_PX;
+  const usable = Math.max(1, o.width - left - PAD_PX);
+  const scaleX = usable / (longest * (readouts ? READOUT_ROOM : 1));
+  return {
+    scaleX,
+    scaleY: 1,
+    translateX: left - bars.origin * scaleX,
+    translateY: PAD_PX + rowPx / 2,
+    width: o.width,
+    height: count * rowPx + 2 * PAD_PX,
+    rowPx,
+    barPx,
+    readouts,
+    labelled,
+    boxesGenes: boxesGenes(rowPx, barPx)
+  };
+}
+function stripRowAt(bars, frame, x, y) {
+  const i = Math.round((y - frame.translateY) / frame.rowPx);
+  const row = [bars.reference, ...bars.rows][i];
+  const offset = (x - frame.translateX) / frame.scaleX - bars.origin;
+  return row && i >= 0 && offset >= 0 && offset <= row.bp ? { index: i, row, offset } : void 0;
+}
+function walkMarksTree(bars, frame, marks) {
+  const index = new Map(
+    [bars.reference, ...bars.rows].map((row, i) => [row.name, i])
+  );
+  const X = (offset) => (bars.origin + offset) * frame.scaleX + frame.translateX;
+  return el(
+    "g",
+    { "data-testid": "graph-walk-marks" },
+    ...marks.flatMap((m) => {
+      const i = index.get(m.row);
+      if (i === void 0) {
+        return [];
+      }
+      const y = i * frame.rowPx + frame.translateY;
+      const x = X(m.start);
+      const w = Math.max(2, m.bp * frame.scaleX);
+      const tick = (top) => el("rect", { x, y: top, width: w, height: TICK_PX, fill: MARK_INK });
+      return [
+        tick(y - frame.barPx / 2 - TICK_PX - 1),
+        tick(y + frame.barPx / 2 + 1)
+      ];
+    })
+  );
+}
+function walkStripLabelsTree(bars, frame, bold = /* @__PURE__ */ new Set()) {
+  return el(
+    "g",
+    { "font-family": "sans-serif", "font-size": LABEL_FONT_PX, fill: "#333" },
+    ...(frame.labelled ? [bars.reference, ...bars.rows] : []).map(
+      (row, i) => el(
+        "text",
+        {
+          x: 6,
+          y: i * frame.rowPx + frame.translateY + 4,
+          "font-weight": bold.has(row.name) ? 600 : void 0
+        },
+        row.label
+      )
+    )
+  );
+}
+function stripGeneGaps(frame, rowGenes, gaps) {
+  if (!rowGenes?.size) {
+    return void 0;
+  }
+  return frame.boxesGenes ? gaps : { untracked: 0, unread: 0, ...gaps, crowded: true };
+}
+
+export {
+  WALK_STRIP_CEILING_PX,
+  LABELLED_ROW_PX,
+  stripMarks,
+  segmentAt,
+  walkStripFrame,
+  stripRowAt,
+  walkMarksTree,
+  walkStripLabelsTree,
+  stripGeneGaps
+};