@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-N62KBLFC.js

@@ -0,0 +1,326 @@
+import {
+  occupancy
+} from "./chunk-AB35TJST.js";
+import {
+  polylineMidpoint
+} from "./chunk-TAMCZHLW.js";
+import {
+  deletionArcCurves
+} from "./chunk-4EMPBO7S.js";
+import {
+  curveBounds,
+  curveMidpoint
+} from "./chunk-2CVHXFK7.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-NNODIW4U.js

@@ -0,0 +1,26 @@
+// src/el.ts
+function el(tag, attrs = {}, ...children) {
+  return {
+    tag,
+    attrs,
+    children: children.filter((c) => !!c || c === "")
+  };
+}
+function escapeText(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttr(s) {
+  return escapeText(s).replaceAll('"', "&quot;");
+}
+function serializeEl(node) {
+  if (typeof node === "string") {
+    return escapeText(node);
+  }
+  const attrs = Object.entries(node.attrs).filter(([, v]) => v !== void 0).map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("");
+  return `<${node.tag}${attrs}>${node.children.map(serializeEl).join("")}</${node.tag}>`;
+}
+
+export {
+  el,
+  serializeEl
+};

package/dist/chunks/chunk-PBENCR5L.js

@@ -0,0 +1,60 @@
+// src/nodeWidths.ts
+var NODE_WIDTHS = [
+  {
+    value: "depth",
+    label: "By depth",
+    description: "Thicker the more paths carry a node, on the square root of its depth against the mean. A graph with one depth everywhere draws uniform."
+  },
+  {
+    value: "uniform",
+    label: "Uniform",
+    description: "Every node the same thickness."
+  }
+];
+var NODE_WIDTH_VALUES = NODE_WIDTHS.map((w) => w.value);
+var MIN_FACTOR = 0.3;
+var MAX_FACTOR = 3;
+function meanDepth(graph) {
+  let weighted = 0;
+  let length = 0;
+  for (const node of graph.nodes) {
+    weighted += node.depth * node.length;
+    length += node.length;
+  }
+  return length > 0 ? weighted / length : 0;
+}
+function depthWidthFactor(node, mean) {
+  if (!(mean > 0) || !(node.depth > 0)) {
+    return 1;
+  }
+  return Math.min(
+    MAX_FACTOR,
+    Math.max(MIN_FACTOR, Math.sqrt(node.depth / mean))
+  );
+}
+function nodeWidthPx(node, contigThickness, nodeWidth, mean) {
+  return contigThickness * (nodeWidth === "depth" ? depthWidthFactor(node, mean) : 1);
+}
+function maxNodeWidthPx(contigThickness, nodeWidth) {
+  return contigThickness * (nodeWidth === "depth" ? MAX_FACTOR : 1);
+}
+function nodeInk(graph, nodeById, contigThickness, nodeWidth) {
+  const mean = graph ? meanDepth(graph) : 0;
+  return {
+    maxHalfWidthPx: maxNodeWidthPx(contigThickness, nodeWidth) / 2,
+    halfWidthPx: (id) => {
+      const node = nodeById?.get(id);
+      return node ? nodeWidthPx(node, contigThickness, nodeWidth, mean) / 2 : contigThickness / 2;
+    }
+  };
+}
+
+export {
+  NODE_WIDTHS,
+  NODE_WIDTH_VALUES,
+  meanDepth,
+  depthWidthFactor,
+  nodeWidthPx,
+  maxNodeWidthPx,
+  nodeInk
+};