@jbrowse/bandage-core 6.0.1 → 6.0.2

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-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
+};

package/dist/chunks/chunk-HB6PDCOU.js

@@ -0,0 +1,177 @@
+import {
+  nodesUnderBox
+} from "./chunk-BJV2W4KZ.js";
+import {
+  nodeLabelBudget,
+  placeSizeLabels,
+  rowLabelBox,
+  sizeLabelCandidates
+} from "./chunk-HCANBJDD.js";
+import {
+  LABEL_CHAR_PX,
+  LABEL_PAD,
+  LABEL_PX,
+  occupancy,
+  placeLabels
+} from "./chunk-AB35TJST.js";
+
+// src/labelLayout.ts
+var HALO_FACTOR = 3.4;
+var LEGEND_INSET_PX = 6;
+var ROUTE_STACK = 8;
+var GENE_PIN_DROP_PX = 18;
+var GENE_STACK = 2;
+var TOPMOST_BASELINE = LABEL_PX + LABEL_PAD;
+function geneCoverageNote(pin) {
+  const length = pin.gene.end - pin.gene.start;
+  if (pin.covered >= 0.98) {
+    return void 0;
+  }
+  const [per, unit] = length >= 1e6 ? [1e6, "Mb"] : length >= 1e3 ? [1e3, "kb"] : [1, "bp"];
+  const amount = (bp) => +(bp / per).toFixed(per === 1 ? 0 : 1);
+  return `${amount(pin.covered * length)} of ${amount(length)} ${unit}`;
+}
+function geneLabelCandidates(pins, screen, contigThickness, nodesUnder) {
+  const ink = contigThickness / 2;
+  return byExtent(pins, (pin) => pin.gene.end - pin.gene.start).map((pin) => {
+    const { x, y } = screen(pin.at);
+    const note = geneCoverageNote(pin);
+    return {
+      item: pin,
+      x,
+      y: y + contigThickness + GENE_PIN_DROP_PX,
+      text: note ? `${pin.gene.name} \xB7 ${note}` : pin.gene.name,
+      fallback: note ? `${pin.gene.name} \u2026` : void 0,
+      stack: GENE_STACK,
+      fits: (box) => [
+        ...nodesUnder({
+          x0: box.x0 - ink,
+          x1: box.x1 + ink,
+          y0: box.y0 - ink,
+          y1: box.y1 + ink
+        })
+      ].every((id) => pin.nodeIds.has(id))
+    };
+  });
+}
+function byExtent(items, extent) {
+  return [...items].sort((a, b) => extent(b) - extent(a));
+}
+function layoutLabels(m) {
+  const { paneWidth: width, canvasHeight: height, translateX, translateY } = m;
+  const { scaleX, scaleY } = m.axisScale;
+  const frame = { width, height };
+  const screen = (p) => ({
+    x: p.x * scaleX + translateX,
+    y: p.y * scaleY + translateY
+  });
+  const reserved = m.drawnRowLabels.map(
+    ({ label, y }) => rowLabelBox(label, y * scaleY + translateY)
+  );
+  const stripPx = m.referenceStripZonePx ?? 0;
+  if (stripPx > 0) {
+    reserved.push({ x0: 0, x1: width, y0: 0, y1: stripPx });
+  }
+  if (m.legendSize.width > 0) {
+    reserved.push({
+      x0: width - LEGEND_INSET_PX - m.legendSize.width,
+      x1: width,
+      y0: 0,
+      y1: stripPx + LEGEND_INSET_PX + m.legendSize.height
+    });
+  }
+  if (m.poppedFrom) {
+    reserved.push({
+      x0: 0,
+      x1: 60 + m.poppedFrom.label.length * LABEL_CHAR_PX * 1.2,
+      y0: 0,
+      y1: 44
+    });
+  }
+  const take = occupancy(frame, reserved);
+  const onRows = m.drawnRowLabels.length > 0;
+  const rowsTop = onRows ? Math.min(...m.drawnRowLabels.map((r) => r.y)) : Infinity;
+  const halo = m.contigThickness * HALO_FACTOR;
+  const byBubble = byExtent(m.bubbleHalos, (h) => h.members);
+  const bubbles = placeLabels(
+    byBubble.map((h) => {
+      const { x, y } = screen({
+        x: h.labelAt.x,
+        y: Math.min(h.labelAt.y, rowsTop)
+      });
+      const baseline = y - halo / 2 - 6;
+      return {
+        item: h,
+        x,
+        y: onRows ? Math.max(baseline, TOPMOST_BASELINE) : baseline,
+        text: h.label
+      };
+    }),
+    frame,
+    take
+  );
+  const genes = placeLabels(
+    geneLabelCandidates(
+      m.genePins,
+      screen,
+      m.contigThickness,
+      nodesUnderBox(
+        m.nodePositions ?? {},
+        { scaleX, scaleY, translateX, translateY },
+        m.positionsVersion
+      )
+    ),
+    frame,
+    take
+  );
+  const sizeCandidates = m.nodePositions && m.labelsNodeSizes ? sizeLabelCandidates({
+    nodePositions: m.nodePositions,
+    nodeLengths: m.nodeLengths,
+    deletions: m.showDeletionEdges ? m.deletions : [],
+    deletionRoutes: m.deletionRoutes,
+    stranded: m.stranded,
+    alleleDeletions: m.alleleDeletions,
+    axis: m.axisScale,
+    translateX,
+    translateY,
+    width,
+    height,
+    version: m.positionsVersion
+  }) : { deletions: [], nodes: [] };
+  const deletionLabels = placeSizeLabels(sizeCandidates.deletions, take);
+  const routes = placeLabels(
+    byBubble.flatMap(
+      (h) => h.routes.map((route) => {
+        const { x, y } = screen(route.at);
+        return {
+          item: { halo: h, route },
+          x,
+          y: y + 4,
+          text: route.text,
+          stack: ROUTE_STACK
+        };
+      })
+    ),
+    frame,
+    take
+  );
+  const nodeLabels = placeSizeLabels(
+    sizeCandidates.nodes,
+    take,
+    nodeLabelBudget(width, height)
+  );
+  return {
+    bubbles,
+    genes,
+    routes,
+    sizes: [...deletionLabels, ...nodeLabels]
+  };
+}
+
+export {
+  HALO_FACTOR,
+  LEGEND_INSET_PX,
+  geneCoverageNote,
+  geneLabelCandidates,
+  layoutLabels
+};