@jbrowse/bandage-core 6.0.1 → 6.0.2

package/dist/chunks/chunk-VKB57ZYE.js

@@ -0,0 +1,218 @@
+import {
+  orientToReference
+} from "./chunk-PUG7LXDF.js";
+import {
+  seededNodes
+} from "./chunk-IGVV37VI.js";
+import {
+  convertGFAToGraph
+} from "./chunk-72N5DJHZ.js";
+import {
+  parseGFA
+} from "./chunk-CDLPYR5O.js";
+import {
+  routeNodes,
+  takeRoutes,
+  withDeletionRoutes
+} from "./chunk-MI35EUIE.js";
+import {
+  anchorGraph
+} from "./chunk-ST2IBUAN.js";
+import {
+  mergeRuns,
+  splitRuns
+} from "./chunk-SDGM243E.js";
+import {
+  spreadFor
+} from "./chunk-UVBGRJQX.js";
+import {
+  drawnLengthOf,
+  drawnNodeLength,
+  layoutScaling
+} from "./chunk-6JEWNXCQ.js";
+import {
+  deletionEdges
+} from "./chunk-X32PABB7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/pipeline.ts
+function loadGraph(text, name, opts = {}) {
+  const graph = anchorGraph(
+    convertGFAToGraph(parseGFA(text), name),
+    opts.referencePath
+  );
+  if (graph.nodes.length === 0) {
+    throw new Error(`No graph segments in ${name}`);
+  }
+  if (opts.maxNodes !== void 0 && graph.nodes.length > opts.maxNodes) {
+    throw new Error(
+      `Graph too large to draw: ${graph.nodes.length.toLocaleString()} nodes (limit ${opts.maxNodes.toLocaleString()}). Zoom in to a smaller region, or raise maxGraphNodes on this view.`
+    );
+  }
+  return graph;
+}
+var COMPONENT_SEPARATION = 15;
+function engineRequest(graph, scaling, settings) {
+  const anchored = graph.nodes.some(isBackbone);
+  const spaced = {
+    ...scaling,
+    opts: {
+      ...scaling.opts,
+      edgeLength: scaling.opts.edgeLength * (settings.spacing ?? 1)
+    }
+  };
+  return {
+    graph: {
+      nodes: anchored ? seededNodes(graph, spaced) : spaced.nodes,
+      edges: graph.edges
+    },
+    options: {
+      quality: settings.quality,
+      linearLayout: settings.linearLayout,
+      ...spaced.opts,
+      componentSeparation: COMPONENT_SEPARATION * (settings.componentSeparation ?? 1),
+      ...anchored ? { rotateComponents: false } : {}
+    }
+  };
+}
+function engineKey(graph, settings) {
+  const anchored = graph.nodes.some(isBackbone);
+  return `${settings.quality}|${settings.linearLayout}|${settings.bubbleSpread}|${settings.spacing ?? 1}|${settings.componentSeparation ?? 1}|${anchored}|${graph.referencePath ?? ""}`;
+}
+async function forceLayout(graph, settings, engine) {
+  const spread = spreadFor(settings.bubbleSpread);
+  const deletions = deletionEdges(graph);
+  const routed = withDeletionRoutes(graph, deletions);
+  const merged = mergeRuns(routed.graph, routed.ids);
+  const runs = {
+    ...merged.graph,
+    nodes: merged.graph.nodes.filter((n) => !routed.ids.has(n.id))
+  };
+  const engineScaling = layoutScaling(runs, spread);
+  const { result, duration } = await engine(
+    engineRequest(
+      merged.graph,
+      {
+        ...engineScaling,
+        nodes: [
+          ...engineScaling.nodes,
+          ...routeNodes(
+            graph,
+            deletions,
+            routed.routes,
+            drawnLengthOf(runs, spread),
+            engineScaling.opts
+          )
+        ]
+      },
+      settings
+    )
+  );
+  const scaling = layoutScaling(graph, spread);
+  const drawn = new Map(
+    scaling.nodes.map((n) => [n.id, drawnNodeLength(scaling.opts, n.length)])
+  );
+  const positions = splitRuns(
+    result.nodePositions,
+    merged.runs,
+    (id) => drawn.get(id) ?? 0
+  );
+  const { nodePositions, deletionRoutes } = takeRoutes(
+    graph.nodes.some(isBackbone) ? orientToReference(graph, positions) : positions,
+    routed.routes
+  );
+  return {
+    result: {
+      ...result,
+      nodePositions,
+      stranded: true,
+      ...deletions.length ? { deletionRoutes, extent: layoutExtent(deletionRoutes) } : {}
+    },
+    duration
+  };
+}
+function layoutExtent(nodePositions) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const segments of Object.values(nodePositions)) {
+    for (const seg of segments) {
+      minX = Math.min(minX, seg.x);
+      minY = Math.min(minY, seg.y);
+      maxX = Math.max(maxX, seg.x);
+      maxY = Math.max(maxY, seg.y);
+    }
+  }
+  return { minX, minY, maxX, maxY };
+}
+var FIT_PADDING = 40;
+var MIN_ZOOM = 1e-6;
+var MAX_ZOOM = 100;
+function clampZoom(zoom) {
+  return Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoom));
+}
+function fittedTranslateY(bounds, usableHeight, yScale, padTop = FIT_PADDING) {
+  const leftoverY = usableHeight - bounds.h * yScale;
+  return padTop - bounds.minY * yScale + Math.max(0, leftoverY) / 2;
+}
+function fitTransform(bounds, paneWidth, paneHeight, pixelRows, {
+  minScale = 0,
+  padLeft = FIT_PADDING,
+  padTop = FIT_PADDING,
+  padRight = FIT_PADDING,
+  padBottom = FIT_PADDING
+} = {}) {
+  const usableWidth = paneWidth - padLeft - padRight;
+  const usableHeight = paneHeight - padTop - padBottom;
+  if (usableWidth <= 0 || usableHeight <= 0 || !(bounds.w > 0 || !pixelRows && bounds.h > 0)) {
+    return void 0;
+  }
+  const fitX = bounds.w > 0 ? usableWidth / bounds.w : Infinity;
+  const fitY = bounds.h > 0 ? usableHeight / bounds.h : Infinity;
+  const scale = clampZoom(
+    Math.max(minScale, pixelRows ? fitX : Math.min(fitX, fitY))
+  );
+  const leftoverX = usableWidth - bounds.w * scale;
+  return {
+    scale,
+    translateX: padLeft - bounds.minX * scale + Math.max(0, leftoverX) / 2,
+    translateY: fittedTranslateY(
+      bounds,
+      usableHeight,
+      pixelRows ? 1 : scale,
+      padTop
+    )
+  };
+}
+function drawingBounds(layout, opts = {}) {
+  let { minX, minY, maxX, maxY } = layoutExtent(layout.nodePositions);
+  const { region } = opts;
+  if (layout.referenceAxis && region && region.end > region.start) {
+    minX = region.start;
+    maxX = region.end;
+  }
+  const extent = opts.extent ?? layout.extent;
+  if (extent) {
+    minX = Math.min(minX, extent.minX ?? minX);
+    minY = Math.min(minY, extent.minY ?? minY);
+    maxX = Math.max(maxX, extent.maxX ?? maxX);
+    maxY = Math.max(maxY, extent.maxY ?? maxY);
+  }
+  return { minX, minY, w: maxX - minX, h: maxY - minY };
+}
+
+export {
+  loadGraph,
+  engineRequest,
+  engineKey,
+  forceLayout,
+  layoutExtent,
+  FIT_PADDING,
+  clampZoom,
+  fittedTranslateY,
+  fitTransform,
+  drawingBounds
+};

package/dist/chunks/chunk-VZQ4FKLR.js

@@ -0,0 +1,38 @@
+import {
+  referenceKnots,
+  warpX
+} from "./chunk-KQFOCDFY.js";
+
+// src/tubeMap/frame.ts
+var MIN_TUBE_Y_SCALE = 0.05;
+var NODE_BOX_PAD = 9;
+function squeeze(drawing, usableHeight) {
+  const { minY, maxY } = drawing.layout.bounds;
+  const h = maxY - minY;
+  return drawing.columns && h > 0 ? Math.max(MIN_TUBE_Y_SCALE, Math.min(1, usableHeight / h)) : 1;
+}
+function tubeMapFrame(drawing, view) {
+  const { scaleX, translateX, translateY } = view;
+  const yScale = view.scaleY * squeeze(drawing, view.usableHeight);
+  const y = (ty) => (ty - drawing.yOffset) * yScale + translateY;
+  const { columns } = drawing;
+  if (columns) {
+    const knots = referenceKnots(columns, (bp) => bp * scaleX + translateX);
+    return { x: (tx) => warpX(knots, tx), y, yScale };
+  }
+  return { x: (tx) => tx * scaleX + translateX, y, yScale };
+}
+function tubeMapNodeAt(drawing, { x, y }, sx, sy) {
+  let hit = null;
+  drawing.layout.nodes.forEach((node) => {
+    if (node.order >= 0 && x(node.x - NODE_BOX_PAD) <= sx && sx <= x(node.x + node.pixelWidth + NODE_BOX_PAD) && y(node.y - NODE_BOX_PAD) <= sy && sy <= y(node.y + node.contentHeight + NODE_BOX_PAD)) {
+      hit = node.name;
+    }
+  });
+  return hit;
+}
+
+export {
+  tubeMapFrame,
+  tubeMapNodeAt
+};

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

@@ -0,0 +1,117 @@
+import {
+  computeEdgeCurves,
+  edgeJoinOf,
+  routedEdgeCurves,
+  strandSides
+} from "./chunk-3PLYZLYV.js";
+import {
+  firstNodeAtOrAfter,
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/deletionEdges.ts
+var MIN_DELETION_BP = 1;
+function bypassedPoints(nodePositions, bypassed) {
+  return bypassed.flatMap((id) => nodePositions[id] ?? []);
+}
+function deletionArcCurves(nodePositions, deletion, axis, route, stranded = false) {
+  const from = nodePositions[deletion.from];
+  const to = nodePositions[deletion.to];
+  if (!from?.length || !to?.length) {
+    return void 0;
+  }
+  return route ? routedEdgeCurves(
+    from,
+    to,
+    route,
+    stranded ? strandSides(deletion) : void 0
+  ) : computeEdgeCurves(
+    from,
+    to,
+    edgeJoinOf(deletion, stranded),
+    0,
+    0,
+    axis,
+    bypassedPoints(nodePositions, deletion.bypassed)
+  );
+}
+function backboneBySequence(graph) {
+  const bySequence = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      const list = bySequence.get(node.stable.refName);
+      if (list) {
+        list.push(node);
+      } else {
+        bySequence.set(node.stable.refName, [node]);
+      }
+    }
+  }
+  for (const list of bySequence.values()) {
+    list.sort((a, b) => a.stable.start - b.stable.start);
+  }
+  return bySequence;
+}
+function bypassedNodes(nodes, start, end) {
+  const bypassed = [];
+  if (nodes) {
+    for (let i = firstNodeAtOrAfter(nodes, start); i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.stable.start >= end) {
+        break;
+      }
+      if (node.stable.start + node.length <= end) {
+        bypassed.push(node.id);
+      }
+    }
+  }
+  return bypassed;
+}
+function skipsBetween(edge, from, to, forwards) {
+  const { fromStrand, toStrand } = edge;
+  if (fromStrand === void 0 || toStrand === void 0) {
+    return true;
+  }
+  const leavesRight = fromStrand === (from.stable.strand ?? "+");
+  const arrivesLeft = toStrand === (to.stable.strand ?? "+");
+  return forwards ? leavesRight && arrivesLeft : !leavesRight && !arrivesLeft;
+}
+function deletionEdges(graph) {
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const backbone = backboneBySequence(graph);
+  const found = [];
+  for (let edgeIndex = 0; edgeIndex < graph.edges.length; edgeIndex++) {
+    const edge = graph.edges[edgeIndex];
+    const from = byId.get(edge.from);
+    const to = byId.get(edge.to);
+    if (from !== void 0 && to !== void 0 && isBackbone(from) && isBackbone(to) && from.stable.refName === to.stable.refName) {
+      const forwards = from.stable.start <= to.stable.start;
+      const [left, right] = forwards ? [from, to] : [to, from];
+      const start = left.stable.start + left.length;
+      const end = right.stable.start;
+      const bp = end - start;
+      if (bp >= MIN_DELETION_BP && skipsBetween(edge, from, to, forwards)) {
+        const refName = left.stable.refName;
+        found.push({
+          edgeIndex,
+          from: edge.from,
+          to: edge.to,
+          ...edge.fromStrand ? { fromStrand: edge.fromStrand } : {},
+          ...edge.toStrand ? { toStrand: edge.toStrand } : {},
+          refName,
+          start,
+          end,
+          bp,
+          bypassed: bypassedNodes(backbone.get(refName), start, end)
+        });
+      }
+    }
+  }
+  return found;
+}
+
+export {
+  bypassedPoints,
+  deletionArcCurves,
+  deletionEdges
+};

package/dist/chunks/chunk-YJQ7CT7F.js

@@ -0,0 +1,23 @@
+import {
+  computeColorSchemeRange,
+  getNodeColor
+} from "./chunk-3WHKR5TY.js";
+
+// src/tubeMap/nodeColors.ts
+import { abgrToCssRgba } from "@jbrowse/core/util/colorBits";
+function tubeMapNodeColors(graph, colorScheme, referenceRamp) {
+  if (colorScheme === "uniform" || colorScheme === "grey") {
+    return void 0;
+  }
+  const range = { ...computeColorSchemeRange(graph), referenceRamp };
+  return new Map(
+    graph.nodes.map((node, index) => [
+      node.id,
+      abgrToCssRgba(getNodeColor(node, index, colorScheme, range))
+    ])
+  );
+}
+
+export {
+  tubeMapNodeColors
+};