@jbrowse/bandage-core 6.0.0 → 6.0.2

package/dist/chunks/chunk-HCANBJDD.js

@@ -0,0 +1,326 @@
+import {
+  occupancy
+} from "./chunk-AB35TJST.js";
+import {
+  polylineMidpoint
+} from "./chunk-SDGM243E.js";
+import {
+  deletionArcCurves
+} from "./chunk-X32PABB7.js";
+import {
+  curveBounds,
+  curveMidpoint
+} from "./chunk-3PLYZLYV.js";
+
+// src/graphLabels.ts
+var MIN_DELETION_LABEL_PX = 26;
+var PX_PER_NODE_LABEL = 4e4;
+var MIN_NODE_LABELS = 8;
+var LEADER_GAP_PX = 8;
+var LABEL_CHAR_PX = 5.7;
+var LABEL_PAD_PX = 6;
+var LABEL_HEIGHT_PX = 13;
+var LABEL_GAP_PX = 3;
+var MAX_LABEL_OVERHANG = 2;
+function labelHalfWidth(text) {
+  return (text.length * LABEL_CHAR_PX + LABEL_PAD_PX + LABEL_GAP_PX) / 2;
+}
+var LABEL_HALF_HEIGHT = (LABEL_HEIGHT_PX + LABEL_GAP_PX) / 2;
+var MIN_LABEL_HALF_WIDTH = labelHalfWidth("1 bp");
+function boxAt(halfW, x, y) {
+  return {
+    x0: x - halfW,
+    x1: x + halfW,
+    y0: y - LABEL_HALF_HEIGHT,
+    y1: y + LABEL_HALF_HEIGHT
+  };
+}
+function rowLabelBox(text, screenY) {
+  return {
+    x0: 6,
+    x1: 6 + text.length * 6.2 + 8 + LABEL_GAP_PX,
+    y0: screenY - 8 - LABEL_GAP_PX / 2,
+    y1: screenY + 8 + LABEL_GAP_PX / 2
+  };
+}
+function clamp(v, lo, hi) {
+  return hi < lo ? v : Math.min(Math.max(v, lo), hi);
+}
+function groupDigits(n) {
+  return String(n).replace(/\B(?=(\d{3})+$)/g, ",");
+}
+function formatBp(bp) {
+  if (bp >= 1e6) {
+    return `${+(bp / 1e6).toFixed(1)} Mb`;
+  }
+  return bp >= 1e3 ? `${+(bp / 1e3).toFixed(1)} kb` : `${bp} bp`;
+}
+function deletionText(bp) {
+  return `${formatBp(bp)} del`;
+}
+function arcOutward(curves, apex, scaleX, scaleY) {
+  const first = curves[0];
+  const last = curves[curves.length - 1];
+  const dx = (apex.x - (first.x0 + last.x1) / 2) * scaleX;
+  const dy = (apex.y - (first.y0 + last.y1) / 2) * scaleY;
+  const len = Math.hypot(dx, dy);
+  return len === 0 ? { x: 0, y: -1 } : { x: dx / len, y: dy / len };
+}
+function boxSupport(box, dir) {
+  return Math.abs(dir.x) * (box.x1 - box.x0) / 2 + Math.abs(dir.y) * (box.y1 - box.y0) / 2;
+}
+function boxRayCrossing(box, dir) {
+  const halfW = (box.x1 - box.x0) / 2;
+  const halfH = (box.y1 - box.y0) / 2;
+  return Math.min(
+    dir.x === 0 ? Infinity : halfW / Math.abs(dir.x),
+    dir.y === 0 ? Infinity : halfH / Math.abs(dir.y)
+  );
+}
+function drawnLength(segments, scaleX, scaleY) {
+  let total = 0;
+  for (let i = 1; i < segments.length; i++) {
+    const a = segments[i - 1];
+    const b = segments[i];
+    total += Math.hypot((b.x - a.x) * scaleX, (b.y - a.y) * scaleY);
+  }
+  return total;
+}
+function runBounds(nodeIds, nodePositions) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const id of nodeIds) {
+    for (const p of nodePositions[id] ?? []) {
+      minX = Math.min(minX, p.x);
+      maxX = Math.max(maxX, p.x);
+      minY = Math.min(minY, p.y);
+      maxY = Math.max(maxY, p.y);
+    }
+  }
+  return minX === Infinity ? void 0 : { minX, minY, maxX, maxY };
+}
+var nodeOrderCache = /* @__PURE__ */ new WeakMap();
+function labelOrder(nodePositions, nodeLengths) {
+  const cached = nodeOrderCache.get(nodePositions);
+  if (cached?.nodeLengths === nodeLengths) {
+    return cached.order;
+  }
+  const order = Object.entries(nodePositions).filter(([id, segments]) => segments.length > 0 && nodeLengths.has(id)).sort(([a], [b]) => nodeLengths.get(b) - nodeLengths.get(a));
+  nodeOrderCache.set(nodePositions, { nodeLengths, order });
+  return order;
+}
+var arcCache = /* @__PURE__ */ new WeakMap();
+function arcPlacements(nodePositions, deletions, axis, version, routes, stranded) {
+  const { scaleX, scaleY } = axis;
+  const cached = arcCache.get(nodePositions);
+  if (cached?.deletions === deletions && cached.routes === routes && cached.stranded === stranded && cached.scaleX === scaleX && cached.scaleY === scaleY && cached.version === version) {
+    return cached.arcs;
+  }
+  const arcs = [];
+  for (const deletion of [...deletions].sort((a, b) => b.bp - a.bp)) {
+    const curves = deletionArcCurves(
+      nodePositions,
+      deletion,
+      axis,
+      routes?.[deletion.edgeIndex],
+      stranded
+    );
+    const apex = curves ? curveMidpoint(curves) : void 0;
+    if (curves && apex) {
+      const { minX, minY, maxX, maxY } = curveBounds(curves);
+      arcs.push({
+        deletion,
+        curves,
+        apex,
+        // in screen px, so the two axes' units cannot be added by accident
+        extent: Math.max((maxX - minX) * scaleX, (maxY - minY) * scaleY)
+      });
+    }
+  }
+  arcCache.set(nodePositions, {
+    deletions,
+    routes,
+    stranded,
+    scaleX,
+    scaleY,
+    version,
+    arcs
+  });
+  return arcs;
+}
+function sizeLabelCandidates({
+  nodePositions,
+  nodeLengths,
+  deletions,
+  deletionRoutes,
+  stranded = false,
+  alleleDeletions,
+  axis,
+  translateX,
+  translateY,
+  width,
+  height,
+  version = 0
+}) {
+  const { scaleX, scaleY } = axis;
+  const deletionCandidates = [];
+  const nodeCandidates = [];
+  for (const { deletion, curves, apex, extent } of arcPlacements(
+    nodePositions,
+    deletions,
+    axis,
+    version,
+    deletionRoutes,
+    stranded
+  )) {
+    if (extent >= MIN_DELETION_LABEL_PX) {
+      const text = deletionText(deletion.bp);
+      const halfW = labelHalfWidth(text);
+      const box = boxAt(halfW, 0, 0);
+      const arcX = apex.x * scaleX + translateX;
+      const arcY = apex.y * scaleY + translateY;
+      const fits = extent >= halfW * 2 / MAX_LABEL_OVERHANG;
+      const bow = arcOutward(curves, apex, scaleX, scaleY);
+      const offset = boxSupport(box, bow) + LEADER_GAP_PX;
+      const x = fits ? arcX : clamp(arcX + bow.x * offset, halfW, width - halfW);
+      const y = fits ? arcY : clamp(
+        arcY + bow.y * offset,
+        LABEL_HALF_HEIGHT,
+        height - LABEL_HALF_HEIGHT
+      );
+      const away = Math.hypot(x - arcX, y - arcY);
+      let leader;
+      if (away > 0) {
+        const dir = { x: (x - arcX) / away, y: (y - arcY) / away };
+        const crossing = boxRayCrossing(box, dir);
+        leader = {
+          arcX,
+          arcY,
+          labelX: x - dir.x * crossing,
+          labelY: y - dir.y * crossing
+        };
+      }
+      deletionCandidates.push({
+        label: {
+          key: `del:${deletion.edgeIndex}`,
+          text,
+          x,
+          y,
+          kind: "deletion",
+          leader
+        },
+        box: boxAt(halfW, x, y)
+      });
+    }
+  }
+  const labelledByDeletion = /* @__PURE__ */ new Set();
+  const alleleRuns = [...alleleDeletions ?? []].sort((a, b) => b.bp - a.bp);
+  for (const run of alleleRuns) {
+    const drawn = runBounds(run.nodeIds, nodePositions);
+    if (!drawn) {
+      continue;
+    }
+    const shownLeft = Math.max(drawn.minX * scaleX + translateX, 0);
+    const shownRight = Math.min(drawn.maxX * scaleX + translateX, width);
+    const shownTop = Math.max(drawn.minY * scaleY + translateY, 0);
+    const shownBottom = Math.min(drawn.maxY * scaleY + translateY, height);
+    if (shownRight < shownLeft || shownBottom < shownTop) {
+      continue;
+    }
+    const extent = Math.max(shownRight - shownLeft, shownBottom - shownTop);
+    const text = deletionText(run.bp);
+    const halfW = labelHalfWidth(text);
+    if (extent >= halfW * 2 / MAX_LABEL_OVERHANG) {
+      for (const id of run.nodeIds) {
+        labelledByDeletion.add(id);
+      }
+      const x = clamp((shownLeft + shownRight) / 2, halfW, width - halfW);
+      const y = clamp(
+        (shownTop + shownBottom) / 2,
+        LABEL_HALF_HEIGHT,
+        height - LABEL_HALF_HEIGHT
+      );
+      deletionCandidates.push({
+        label: {
+          key: `alleledel:${run.nodeIds.join(",")}`,
+          text,
+          x,
+          y,
+          kind: "deletion"
+        },
+        box: boxAt(halfW, x, y)
+      });
+    }
+  }
+  for (const [id, segments] of labelOrder(nodePositions, nodeLengths)) {
+    if (labelledByDeletion.has(id)) {
+      continue;
+    }
+    const { x, y } = polylineMidpoint(segments);
+    const screenY = y * scaleY + translateY;
+    if (screenY + LABEL_HALF_HEIGHT <= 0 || screenY - LABEL_HALF_HEIGHT >= height) {
+      continue;
+    }
+    const drawn = drawnLength(segments, scaleX, scaleY);
+    if (drawn < MIN_LABEL_HALF_WIDTH * 2 / MAX_LABEL_OVERHANG) {
+      continue;
+    }
+    const text = formatBp(nodeLengths.get(id));
+    const halfW = labelHalfWidth(text);
+    if (drawn >= halfW * 2 / MAX_LABEL_OVERHANG) {
+      const screenX = x * scaleX + translateX;
+      nodeCandidates.push({
+        label: {
+          key: `node:${id}`,
+          text,
+          x: screenX,
+          y: screenY,
+          kind: "node"
+        },
+        box: boxAt(halfW, screenX, screenY)
+      });
+    }
+  }
+  return { deletions: deletionCandidates, nodes: nodeCandidates };
+}
+function nodeLabelBudget(width, height) {
+  return Math.max(
+    MIN_NODE_LABELS,
+    Math.floor(width * height / PX_PER_NODE_LABEL)
+  );
+}
+function placeSizeLabels(candidates, take, budget = Infinity) {
+  const labels = [];
+  for (const { label, box } of candidates) {
+    if (labels.length >= budget) {
+      break;
+    }
+    if (take(box)) {
+      labels.push(label);
+    }
+  }
+  return labels;
+}
+function graphLabels({
+  reserved,
+  ...args
+}) {
+  const take = occupancy(args, reserved);
+  const { deletions, nodes } = sizeLabelCandidates(args);
+  return [
+    ...placeSizeLabels(deletions, take),
+    ...placeSizeLabels(nodes, take, nodeLabelBudget(args.width, args.height))
+  ];
+}
+
+export {
+  rowLabelBox,
+  groupDigits,
+  formatBp,
+  sizeLabelCandidates,
+  nodeLabelBudget,
+  placeSizeLabels,
+  graphLabels
+};

package/dist/chunks/chunk-HIJVRRYE.js

@@ -0,0 +1,174 @@
+import {
+  LIFT_BACKDROP_CSS,
+  computeColorSchemeRange,
+  getNodeColor
+} from "./chunk-3WHKR5TY.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/referenceStrip.ts
+import { abgrToCssRgba } from "@jbrowse/core/util/colorBits";
+var REFERENCE_STRIP_PX = 12;
+var REFERENCE_STRIP_ZONE_PX = REFERENCE_STRIP_PX + 8;
+var OVERHANG_PX = 8;
+var OVERHANG_CAP_PX = OVERHANG_PX + 3;
+var MIN_STAGGER_PX = 12;
+function referenceStripBlocks(graph, {
+  colorScheme,
+  referenceRamp,
+  walks
+}) {
+  const range = { ...computeColorSchemeRange(graph), referenceRamp };
+  const out = [];
+  graph.nodes.forEach((node, index) => {
+    if (isBackbone(node)) {
+      const colors = walks ? walks.map((w) => {
+        const lane = w.colors.get(node.id);
+        return lane === void 0 ? LIFT_BACKDROP_CSS : abgrToCssRgba(lane);
+      }) : [abgrToCssRgba(getNodeColor(node, index, colorScheme, range))];
+      out.push({
+        node: node.id,
+        bp0: node.stable.start,
+        bp1: node.stable.start + node.length,
+        colors,
+        faded: colors.includes(LIFT_BACKDROP_CSS)
+      });
+    }
+  });
+  return out.sort((a, b) => a.bp0 - b.bp0);
+}
+function span(frame, bp0, bp1) {
+  const a = bp0 * frame.scale + frame.translateX;
+  const b = bp1 * frame.scale + frame.translateX;
+  return a < b ? [a, b] : [b, a];
+}
+var HIT_SLOP_PX = 2;
+function stripOverhang(blocks, frame, width) {
+  const a = -frame.translateX / frame.scale;
+  const b = (width - frame.translateX) / frame.scale;
+  const lo = Math.min(a, b);
+  const hi = Math.max(a, b);
+  let below = 0;
+  let above = 0;
+  for (const block of blocks) {
+    below += Math.max(0, Math.min(block.bp1, lo) - block.bp0);
+    above += Math.max(0, block.bp1 - Math.max(block.bp0, hi));
+  }
+  return frame.scale >= 0 ? { left: Math.round(below), right: Math.round(above) } : { left: Math.round(above), right: Math.round(below) };
+}
+function stripBlockAt(blocks, frame, sx, sy) {
+  if (sy < 0 || sy > REFERENCE_STRIP_PX + HIT_SLOP_PX) {
+    return void 0;
+  }
+  let hit;
+  let best = HIT_SLOP_PX;
+  for (const b of blocks) {
+    const [x0, x1] = span(frame, b.bp0, b.bp1);
+    const dist = Math.max(0, x0 - sx, sx - x1);
+    if (dist <= best) {
+      best = dist;
+      hit = b.node;
+    }
+  }
+  return hit;
+}
+function nodeAnchor(segments, toScreen) {
+  const p = segments?.[Math.floor(segments.length / 2)];
+  return p ? toScreen(p) : void 0;
+}
+function stripPixels(blocks, frame, width, dpr) {
+  const placed = blocks.map((b) => {
+    const [x0, x1] = span(frame, b.bp0, b.bp1);
+    const px0 = Math.round(x0 * dpr);
+    return {
+      colors: b.colors,
+      x0,
+      px0,
+      px1: Math.max(Math.round(x1 * dpr), px0 + 1)
+    };
+  }).filter((b) => b.px1 > 0 && b.px0 < width * dpr).sort((a, b) => a.x0 - b.x0);
+  const out = [];
+  let claimed = -Infinity;
+  const tierEnds = [-Infinity, -Infinity];
+  for (const { colors, px0, px1 } of placed) {
+    const start = Math.max(px0, claimed);
+    if (px1 > start) {
+      const tier = tierEnds[0] < start ? 0 : 1;
+      tierEnds[tier] = px1;
+      out.push({ colors, x0: start / dpr, x1: px1 / dpr, tier });
+      claimed = px1;
+    }
+  }
+  const covered = out.length > 0 ? out.at(-1).x1 - out[0].x0 : 0;
+  return covered >= out.length * MIN_STAGGER_PX ? out : out.map(({ tier: _, ...b }) => b);
+}
+function drawOverhang(ctx, edgeX, inward, ink) {
+  const capX = inward > 0 ? edgeX : edgeX - OVERHANG_CAP_PX;
+  ctx.clearRect(capX, 0, OVERHANG_CAP_PX, REFERENCE_STRIP_PX);
+  const tipX = edgeX + inward;
+  const baseX = tipX + inward * OVERHANG_PX;
+  ctx.beginPath();
+  ctx.moveTo(tipX, REFERENCE_STRIP_PX / 2);
+  ctx.lineTo(baseX, 0);
+  ctx.lineTo(baseX, REFERENCE_STRIP_PX);
+  ctx.closePath();
+  ctx.fillStyle = ink;
+  ctx.fill();
+}
+function rowEdge(row, rows, dpr) {
+  return Math.round(row * REFERENCE_STRIP_PX * dpr / rows) / dpr;
+}
+function drawReferenceStrip(ctx, blocks, frame, {
+  width,
+  lit,
+  darkMode,
+  dpr = 1
+}) {
+  const ink = darkMode ? "#ffffff" : "#18181c";
+  ctx.clearRect(0, 0, width, REFERENCE_STRIP_ZONE_PX);
+  for (const b of stripPixels(blocks, frame, width, dpr)) {
+    const { tier } = b;
+    const staggered = tier !== void 0 && b.colors.length === 1;
+    const rows = staggered ? 2 : b.colors.length;
+    b.colors.forEach((color, i) => {
+      const row = staggered ? tier : i;
+      const y0 = rowEdge(row, rows, dpr);
+      ctx.fillStyle = color;
+      ctx.fillRect(b.x0, y0, b.x1 - b.x0, rowEdge(row + 1, rows, dpr) - y0);
+    });
+  }
+  const overhang = stripOverhang(blocks, frame, width);
+  if (overhang.left > 0) {
+    drawOverhang(ctx, 0, 1, ink);
+  }
+  if (overhang.right > 0) {
+    drawOverhang(ctx, width, -1, ink);
+  }
+  if (lit) {
+    const [x0, x1] = span(frame, lit.start, lit.end);
+    const w = Math.max(x1 - x0, 3);
+    const left = (x0 + x1) / 2 - w / 2;
+    ctx.strokeStyle = ink;
+    ctx.lineWidth = 1.5;
+    ctx.strokeRect(left, 0.75, w, REFERENCE_STRIP_PX - 1.5);
+    if (lit.anchor) {
+      ctx.beginPath();
+      ctx.moveTo(left + w / 2, REFERENCE_STRIP_PX);
+      ctx.lineTo(lit.anchor.x, lit.anchor.y);
+      ctx.lineWidth = 1;
+      ctx.stroke();
+    }
+  }
+}
+
+export {
+  REFERENCE_STRIP_PX,
+  REFERENCE_STRIP_ZONE_PX,
+  referenceStripBlocks,
+  stripOverhang,
+  stripBlockAt,
+  nodeAnchor,
+  stripPixels,
+  drawReferenceStrip
+};