@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-ES2N6V56.js

@@ -0,0 +1,83 @@
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/referenceSpan.ts
+var MAX_BACKBONE_HOPS = 4;
+function buildNeighbors(graph) {
+  const neighbors = /* @__PURE__ */ new Map();
+  function add(from, to) {
+    const list = neighbors.get(from);
+    if (list) {
+      list.push(to);
+    } else {
+      neighbors.set(from, [to]);
+    }
+  }
+  for (const edge of graph.edges) {
+    add(edge.from, edge.to);
+    add(edge.to, edge.from);
+  }
+  return neighbors;
+}
+function flankingSpan({
+  nodeId,
+  nodeById,
+  neighbors
+}) {
+  const seen = /* @__PURE__ */ new Set([nodeId]);
+  let frontier = [nodeId];
+  let minEnd = Infinity;
+  let maxStart = -Infinity;
+  for (let hop = 0; hop < MAX_BACKBONE_HOPS && frontier.length > 0; hop++) {
+    const next = [];
+    for (const id of frontier) {
+      const adjacent = neighbors.get(id);
+      if (adjacent) {
+        for (const neighborId of adjacent) {
+          if (!seen.has(neighborId)) {
+            seen.add(neighborId);
+            const neighbor = nodeById.get(neighborId);
+            if (neighbor && isBackbone(neighbor)) {
+              minEnd = Math.min(minEnd, neighbor.stable.start + neighbor.length);
+              maxStart = Math.max(maxStart, neighbor.stable.start);
+            } else {
+              next.push(neighborId);
+            }
+          }
+        }
+      }
+    }
+    frontier = next;
+  }
+  return minEnd === Infinity ? void 0 : {
+    start: Math.min(minEnd, maxStart),
+    end: Math.max(minEnd, maxStart)
+  };
+}
+function nodeReferenceSpan({
+  nodeId,
+  nodeById,
+  neighbors
+}) {
+  const node = nodeById.get(nodeId);
+  return node === void 0 ? void 0 : isBackbone(node) ? { start: node.stable.start, end: node.stable.start + node.length } : flankingSpan({ nodeId, nodeById, neighbors });
+}
+function referenceMidpoints(graph) {
+  const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+  const neighbors = buildNeighbors(graph);
+  const midpoints = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const span = nodeReferenceSpan({ nodeId: node.id, nodeById, neighbors });
+    if (span) {
+      midpoints.set(node.id, (span.start + span.end) / 2);
+    }
+  }
+  return midpoints;
+}
+
+export {
+  buildNeighbors,
+  nodeReferenceSpan,
+  referenceMidpoints
+};

package/dist/chunks/chunk-EZPBJPK6.js

@@ -0,0 +1,54 @@
+import {
+  walkRows
+} from "./chunk-SZNZ2T6D.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  backboneNodes,
+  backbonePositions,
+  overlapsWindow
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/walkRowLayout.ts
+var READOUT_ROOM = 1.3;
+function walkRowsExtent(walks) {
+  let longest = walks.reference.bp;
+  for (const row of walks.rows) {
+    longest = Math.max(longest, row.bp);
+  }
+  return {
+    maxX: walks.origin + longest * READOUT_ROOM,
+    maxY: walks.rows.length * ROW_HEIGHT_PX
+  };
+}
+function walkRowLayout(graph, region) {
+  const backbone = backboneNodes(graph);
+  const walks = walkRows(graph, region);
+  if (backbone.length === 0 || !walks) {
+    return void 0;
+  }
+  const overWindow = region ? backbone.filter((n) => overlapsWindow(n, region)) : backbone;
+  const nodePositions = backbonePositions(
+    overWindow.length > 0 ? overWindow : backbone
+  );
+  const rowLabels = [
+    { label: walks.reference.label, y: 0 },
+    ...walks.rows.map((row, i) => ({
+      label: row.label,
+      y: (i + 1) * ROW_HEIGHT_PX
+    }))
+  ];
+  return {
+    nodePositions,
+    rowLabels,
+    referenceAxis: true,
+    pixelRows: true,
+    extent: walkRowsExtent(walks)
+  };
+}
+
+export {
+  walkRowsExtent,
+  walkRowLayout
+};

package/dist/chunks/chunk-FYQWPEEY.js

@@ -0,0 +1,65 @@
+// src/anchoredNodes.ts
+var REFERENCE_RANK = 0;
+function isAnchored(node) {
+  return node.stable !== void 0;
+}
+function isBackbone(node) {
+  return node.stable?.rank === REFERENCE_RANK;
+}
+function isOffReference(node) {
+  return node.stable !== void 0 && node.stable.rank > REFERENCE_RANK;
+}
+function backboneNodes(graph) {
+  return graph.nodes.filter(isBackbone);
+}
+function overlapsWindow(node, window) {
+  return node.stable.start < window.end && node.stable.start + node.length > window.start;
+}
+function backbonePositions(backbone) {
+  const positions = {};
+  for (const node of backbone) {
+    positions[node.id] = [
+      { x: node.stable.start, y: 0 },
+      { x: node.stable.start + node.length, y: 0 }
+    ];
+  }
+  return positions;
+}
+function firstNodeAtOrAfter(nodes, bp) {
+  let lo = 0;
+  let hi = nodes.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (nodes[mid].stable.start < bp) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo;
+}
+function backboneSpan(backbone) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const node of backbone) {
+    min = Math.min(min, node.stable.start);
+    max = Math.max(max, node.stable.start + node.length);
+  }
+  return max - min;
+}
+function referenceSpan(backbone, region) {
+  return region && region.end > region.start ? region.end - region.start : backboneSpan(backbone);
+}
+
+export {
+  REFERENCE_RANK,
+  isAnchored,
+  isBackbone,
+  isOffReference,
+  backboneNodes,
+  overlapsWindow,
+  backbonePositions,
+  firstNodeAtOrAfter,
+  backboneSpan,
+  referenceSpan
+};

package/dist/chunks/chunk-GGQRADFS.js

@@ -0,0 +1,170 @@
+import {
+  encodedColor,
+  resolveEncoding
+} from "./chunk-WFX3MAKA.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  panSNContig
+} from "./chunk-BPLIXMH7.js";
+
+// src/walkHighlight.ts
+var isReference = (graph, name) => !!graph.referencePath && pathOrigin(name).name === graph.referencePath;
+function piecesOf(graph, name) {
+  return (graph.paths ?? []).filter((p) => p.name === name).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+}
+function walkHighlight(graph, name) {
+  const pieces = piecesOf(graph, name);
+  const first = pieces[0];
+  if (!first) {
+    return void 0;
+  }
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const edgeAt = /* @__PURE__ */ new Map();
+  graph.edges.forEach((e, i) => {
+    edgeAt.set(`${e.from}>${e.to}`, i);
+  });
+  const lengthOf = (id) => byId.get(id)?.length ?? 0;
+  const bpOf = (path) => path.nodeIds.reduce((sum, id) => sum + lengthOf(id), 0);
+  const bp = pieces.reduce((sum, piece) => sum + bpOf(piece), 0);
+  const range = first.start === void 0 ? void 0 : {
+    contig: first.contig ?? panSNContig(pathOrigin(name).name),
+    start: first.start,
+    end: Math.max(...pieces.map((p) => (p.start ?? 0) + bpOf(p)))
+  };
+  const span = range ? range.end - range.start : bp;
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edgeIndexes = /* @__PURE__ */ new Set();
+  const progress = /* @__PURE__ */ new Map();
+  let before = 0;
+  for (const piece of pieces) {
+    if (range) {
+      before = Math.max(before, (piece.start ?? 0) - range.start);
+    }
+    piece.nodeIds.forEach((id, i) => {
+      nodeIds.add(id);
+      if (i > 0) {
+        const a = piece.nodeIds[i - 1];
+        const index = edgeAt.get(`${a}>${id}`) ?? edgeAt.get(`${id}>${a}`);
+        if (index !== void 0) {
+          edgeIndexes.add(index);
+        }
+      }
+      const length = lengthOf(id);
+      if (!progress.has(id)) {
+        progress.set(id, span > 0 ? (before + length / 2) / span : 0);
+      }
+      before += length;
+    });
+  }
+  const reference = isReference(graph, name);
+  const referencePieces = reference ? [] : (graph.paths ?? []).filter((p) => isReference(graph, p.name));
+  return {
+    name,
+    reference,
+    range,
+    nodeIds,
+    edgeIndexes,
+    progress,
+    steps: pieces.reduce((sum, piece) => sum + piece.nodeIds.length, 0),
+    bp,
+    referenceBp: referencePieces.length > 0 ? referencePieces.reduce((sum, piece) => sum + bpOf(piece), 0) : void 0
+  };
+}
+function laneColors(graph, walk, encoding, ramp) {
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const colors = /* @__PURE__ */ new Map();
+  for (const [id, progress] of walk.progress) {
+    const node = byId.get(id);
+    const mid = ramp?.midpoints.get(id);
+    const t = encoding.field === "progress" ? progress : ramp && mid !== void 0 && !(node?.stable && node.stable.rank > 0) ? (mid - ramp.start) / ramp.span : void 0;
+    colors.set(id, encodedColor(encoding, t));
+  }
+  return colors;
+}
+function reversedNodes(graph, walk) {
+  const reversed = /* @__PURE__ */ new Set();
+  let bp = 0;
+  const referencePath = graph.referencePath;
+  if (!referencePath || walk.reference) {
+    return { reversed, bp };
+  }
+  const walkPath = pathOrigin(walk.name).name;
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  for (const id of walk.progress.keys()) {
+    const node = byId.get(id);
+    const visits = node ? graph.pathVisits?.get(node.name) : void 0;
+    const own = visits?.find((v) => v.path === walkPath)?.strand;
+    const theirs = visits?.find((v) => v.path === referencePath)?.strand;
+    if (own && theirs && own !== theirs) {
+      reversed.add(id);
+      bp += node.length;
+    }
+  }
+  return { reversed, bp };
+}
+function walkLift(graph, layers, ramp) {
+  const seen = /* @__PURE__ */ new Set();
+  const lifted = layers.filter((layer) => !seen.has(layer.walk) && seen.add(layer.walk)).flatMap((layer) => {
+    const walk = walkHighlight(graph, layer.walk);
+    return walk ? [{ walk, layer }] : [];
+  }).sort((a, b) => Number(b.walk.reference) - Number(a.walk.reference));
+  if (lifted.length === 0) {
+    return void 0;
+  }
+  let picked = 0;
+  const walks = lifted.map(({ walk, layer }) => {
+    const encoding = resolveEncoding(
+      layer,
+      walk.reference,
+      walk.reference ? 0 : picked++,
+      lifted.length === 1
+    );
+    const { reversed, bp } = reversedNodes(graph, walk);
+    return {
+      ...walk,
+      encoding,
+      colors: laneColors(graph, walk, encoding, ramp),
+      reversed,
+      reversedBp: bp
+    };
+  });
+  return liftOf(walks, ramp);
+}
+var FACET_COLOR = { field: "progress", scheme: "red" };
+function facetLifts(graph, lift, layers, ramp) {
+  return lift.walks.map((walk) => {
+    const stated = layers.find((l) => l.walk === walk.name)?.color;
+    const encoding = resolveEncoding(
+      { walk: walk.name, color: { ...FACET_COLOR, ...stated } },
+      walk.reference,
+      0
+    );
+    return liftOf(
+      [
+        {
+          ...walk,
+          encoding,
+          colors: laneColors(graph, walk, encoding, ramp)
+        }
+      ],
+      ramp
+    );
+  });
+}
+function liftOf(walks, ramp) {
+  return {
+    walks,
+    referenceDomain: ramp ? { start: ramp.start, end: ramp.start + ramp.span } : void 0,
+    nodeIds: new Set(walks.flatMap((w) => [...w.nodeIds])),
+    edgeIndexes: new Set(walks.flatMap((w) => [...w.edgeIndexes])),
+    names: new Set(walks.map((w) => w.name))
+  };
+}
+
+export {
+  walkHighlight,
+  walkLift,
+  facetLifts
+};

package/dist/chunks/chunk-GOY6REMT.js

@@ -0,0 +1,43 @@
+import {
+  formatBp,
+  groupDigits
+} from "./chunk-N62KBLFC.js";
+
+// src/walkKey.ts
+function rangeText(contig, start, end) {
+  const s = Math.round(start);
+  const e = Math.round(end);
+  return `${contig ? `${contig}:` : ""}${groupDigits(s)}-${groupDigits(e)} (${formatBp(e - s)})`;
+}
+function walkKey(walk, reference) {
+  const { field } = walk.encoding;
+  const own = walk.range ? rangeText(walk.range.contig, walk.range.start, walk.range.end) : void 0;
+  const scale = field === "progress" ? own : field === "reference" && reference ? rangeText(reference.name, reference.start, reference.end) : void 0;
+  const spanned = walk.range ? walk.range.end - walk.range.start : walk.bp;
+  const outside = spanned - walk.bp;
+  return {
+    delta: walk.referenceBp === void 0 || spanned === walk.referenceBp ? "" : ` ${spanned > walk.referenceBp ? "+" : "\u2212"}${formatBp(Math.abs(spanned - walk.referenceBp))}`,
+    outside: outside > 0 ? `, ${formatBp(outside)} outside the cut` : "",
+    reversed: walk.reversedBp > 0 ? `, ${formatBp(walk.reversedBp)} reversed` : "",
+    shades: field !== "walk",
+    scale,
+    hover: scale === own ? void 0 : own
+  };
+}
+function walkPosition(walk, nodeId, length) {
+  const progress = walk.progress.get(nodeId);
+  const range = walk.range;
+  if (progress === void 0 || !range) {
+    return void 0;
+  }
+  const start = Math.round(
+    range.start + progress * (range.end - range.start) - length / 2
+  );
+  return `${range.contig}:${groupDigits(start)}-${groupDigits(start + length)}`;
+}
+
+export {
+  rangeText,
+  walkKey,
+  walkPosition
+};

package/dist/chunks/chunk-GQ2AOHU4.js

@@ -0,0 +1,112 @@
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/tubeMap/connectors.ts
+function referenceNodes(graph, layout) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const out = [];
+  layout.nodes.forEach((node) => {
+    const graphNode = nodeById.get(node.name);
+    if (node.order >= 0 && graphNode && isBackbone(graphNode)) {
+      out.push({
+        node: node.name,
+        bp0: graphNode.stable.start,
+        bp1: graphNode.stable.start + node.sequenceLength,
+        x0: node.x,
+        x1: node.x + node.pixelWidth
+      });
+    }
+  });
+  return out;
+}
+function tubeMapConnectors(nodes, bpToScreen, tubeToScreen, width) {
+  const out = [];
+  for (const n of nodes) {
+    const bottom0 = tubeToScreen(n.x0);
+    const bottom1 = tubeToScreen(n.x1);
+    if (bottom1 >= 0 && bottom0 <= width) {
+      out.push({
+        node: n.node,
+        top0: bpToScreen(n.bp0),
+        top1: bpToScreen(n.bp1),
+        bottom0,
+        bottom1
+      });
+    }
+  }
+  return out;
+}
+var HIT_SLOP_PX = 3;
+function connectorAt(connectors, zoneBottom, sx, sy) {
+  if (zoneBottom <= 0 || sy < 0 || sy > zoneBottom) {
+    return void 0;
+  }
+  const t = sy / zoneBottom;
+  let hit;
+  let best = HIT_SLOP_PX;
+  for (const c of connectors) {
+    const a = c.top0 + (c.bottom0 - c.top0) * t;
+    const b = c.top1 + (c.bottom1 - c.top1) * t;
+    const dist = Math.max(0, Math.min(a, b) - sx, sx - Math.max(a, b));
+    if (dist < best) {
+      best = dist;
+      hit = c.node;
+    }
+  }
+  return hit;
+}
+function band(ctx, c, bottom) {
+  ctx.moveTo(c.top0, 0);
+  ctx.lineTo(c.top1, 0);
+  ctx.lineTo(c.bottom1, bottom);
+  ctx.lineTo(c.bottom0, bottom);
+  ctx.closePath();
+}
+function sides(ctx, c, bottom) {
+  ctx.moveTo(c.top0, 0);
+  ctx.lineTo(c.bottom0, bottom);
+  ctx.moveTo(c.top1, 0);
+  ctx.lineTo(c.bottom1, bottom);
+}
+function drawTubeMapConnectors(ctx, connectors, bottom, {
+  highlightNode,
+  darkMode
+}) {
+  if (bottom <= 0 || connectors.length === 0) {
+    return;
+  }
+  const ink = darkMode ? "255,255,255" : "0,0,0";
+  ctx.beginPath();
+  for (const c of connectors) {
+    band(ctx, c, bottom);
+  }
+  ctx.fillStyle = `rgba(${ink},0.07)`;
+  ctx.fill();
+  ctx.beginPath();
+  for (const c of connectors) {
+    sides(ctx, c, bottom);
+  }
+  ctx.strokeStyle = `rgba(${ink},0.35)`;
+  ctx.lineWidth = 0.5;
+  ctx.stroke();
+  const lit = connectors.find((c) => c.node === highlightNode);
+  if (lit) {
+    ctx.beginPath();
+    band(ctx, lit, bottom);
+    ctx.fillStyle = "rgba(255,192,203,0.5)";
+    ctx.fill();
+    ctx.beginPath();
+    sides(ctx, lit, bottom);
+    ctx.strokeStyle = "#ff0000";
+    ctx.lineWidth = 1;
+    ctx.stroke();
+  }
+}
+
+export {
+  referenceNodes,
+  tubeMapConnectors,
+  connectorAt,
+  drawTubeMapConnectors
+};