@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-D3M7SBKL.js

@@ -0,0 +1,210 @@
+import {
+  brightenAbgr
+} from "./chunk-MNUSQCLG.js";
+
+// src/renderer/Canvas2DRenderer.ts
+import {
+  abgrToCssRgba,
+  normalizedRgbToCssRgba
+} from "@jbrowse/core/util/colorBits";
+import { syncCanvasSize } from "@jbrowse/render-core/canvas2dUtils";
+import { Canvas2DRenderingBackendBase } from "@jbrowse/render-core/renderingBackendBase";
+var Canvas2DRenderer = class extends Canvas2DRenderingBackendBase {
+  constructor() {
+    super(...arguments);
+    this.transform = null;
+    this.batch = null;
+    this.nodeHighlights = /* @__PURE__ */ new Map();
+    this.highlightedEdge = null;
+    this.highlightFactor = 1;
+  }
+  // render-core's, not a local `width * devicePixelRatio`: it clamps the
+  // backing store at MAX_CANVAS_DIM_PX, reads the ratio through `getDpr()` so
+  // this agrees with the transform the model builds, and writes the css size
+  // independently of the backing size.
+  resize(width, height) {
+    syncCanvasSize(this.ctx.canvas, width, height);
+  }
+  uploadGeometry(batch) {
+    this.batch = batch;
+    this.highlightedEdge = null;
+  }
+  setNodeHighlights(factors) {
+    this.nodeHighlights = factors;
+  }
+  setEdgeHighlight(edgeIndex, factor) {
+    this.highlightedEdge = edgeIndex;
+    this.highlightFactor = factor;
+  }
+  updateTransform(transform) {
+    this.transform = transform;
+  }
+  render(clearColor) {
+    const t = this.transform;
+    if (!t) {
+      return;
+    }
+    const ctx = this.ctx;
+    const { width, height } = ctx.canvas;
+    if (clearColor[3] < 1) {
+      ctx.clearRect(0, 0, width, height);
+    }
+    ctx.fillStyle = normalizedRgbToCssRgba(
+      [clearColor[0], clearColor[1], clearColor[2]],
+      clearColor[3]
+    );
+    ctx.fillRect(0, 0, width, height);
+    const batch = this.batch;
+    if (!batch) {
+      return;
+    }
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    this.renderEdges(batch);
+    this.renderNodes(batch);
+    this.renderArrows(batch);
+  }
+  renderEdges(batch) {
+    const t = this.transform;
+    const ctx = this.ctx;
+    const hl = this.highlightedEdge === null ? void 0 : batch.edgeCurveRuns.get(this.highlightedEdge);
+    for (const { color, items } of groupByPaint(batch.edgeCurves, (e, i) => ({
+      color: inRun(hl, i) ? brightenAbgr(e.color, this.highlightFactor) : e.color,
+      weight: e.thickness,
+      last: inRun(hl, i)
+    }))) {
+      ctx.strokeStyle = abgrToCssRgba(color);
+      ctx.lineWidth = items[0].thickness * 2 * t.dpr;
+      ctx.beginPath();
+      for (const e of items) {
+        const first = e.curves[0];
+        ctx.moveTo(
+          first.x0 * t.scaleX + t.translateX,
+          first.y0 * t.scaleY + t.translateY
+        );
+        for (const c of e.curves) {
+          ctx.bezierCurveTo(
+            c.cx0 * t.scaleX + t.translateX,
+            c.cy0 * t.scaleY + t.translateY,
+            c.cx1 * t.scaleX + t.translateX,
+            c.cy1 * t.scaleY + t.translateY,
+            c.x1 * t.scaleX + t.translateX,
+            c.y1 * t.scaleY + t.translateY
+          );
+        }
+      }
+      ctx.stroke();
+    }
+  }
+  renderNodes(batch) {
+    const t = this.transform;
+    const ctx = this.ctx;
+    const lifted = /* @__PURE__ */ new Map();
+    for (const [nodeId, factor] of this.nodeHighlights) {
+      const run = batch.nodeStrokeRuns.get(nodeId);
+      if (run) {
+        for (let i = run.start; i < run.start + run.count; i++) {
+          lifted.set(i, factor);
+        }
+      }
+    }
+    for (const { color, items } of groupByPaint(batch.nodeStrokes, (s, i) => {
+      const factor = lifted.get(i);
+      return {
+        color: factor === void 0 ? s.color : brightenAbgr(s.color, factor),
+        weight: s.thickness,
+        last: factor !== void 0
+      };
+    })) {
+      ctx.strokeStyle = abgrToCssRgba(color);
+      ctx.lineWidth = items[0].thickness * 2 * t.dpr;
+      ctx.beginPath();
+      for (const s of items) {
+        const p0 = s.points[0];
+        ctx.moveTo(
+          p0.x * t.scaleX + t.translateX,
+          p0.y * t.scaleY + t.translateY
+        );
+        for (let i = 1, l = s.points.length; i < l; i++) {
+          const p = s.points[i];
+          ctx.lineTo(
+            p.x * t.scaleX + t.translateX,
+            p.y * t.scaleY + t.translateY
+          );
+        }
+      }
+      ctx.stroke();
+    }
+  }
+  renderArrows(batch) {
+    const t = this.transform;
+    const ctx = this.ctx;
+    const hl = this.highlightedEdge === null ? void 0 : batch.arrowRuns.get(this.highlightedEdge);
+    for (const { color, items } of groupByPaint(batch.arrows, (a, i) => ({
+      color: inRun(hl, i) ? brightenAbgr(a.color, this.highlightFactor) : a.color,
+      weight: 0,
+      last: inRun(hl, i)
+    }))) {
+      ctx.fillStyle = abgrToCssRgba(color);
+      ctx.beginPath();
+      for (const a of items) {
+        const [tip, left, notch, right] = arrowheadOutline(a, t);
+        ctx.moveTo(tip.x, tip.y);
+        ctx.lineTo(left.x, left.y);
+        ctx.lineTo(notch.x, notch.y);
+        ctx.lineTo(right.x, right.y);
+        ctx.closePath();
+      }
+      ctx.fill();
+    }
+  }
+  dispose() {
+    super.dispose();
+    this.batch = null;
+    this.nodeHighlights = /* @__PURE__ */ new Map();
+    this.highlightedEdge = null;
+  }
+};
+var ARROW_NOTCH = 0.25;
+function arrowheadOutline(a, t) {
+  const ux = Math.cos(a.angle);
+  const uy = Math.sin(a.angle);
+  const tipX = a.x * t.scaleX + t.translateX;
+  const tipY = a.y * t.scaleY + t.translateY;
+  const length = a.length * t.dpr;
+  const halfWidth = a.halfWidth * t.dpr;
+  const backX = tipX - ux * length;
+  const backY = tipY - uy * length;
+  const notchBack = length * (1 - ARROW_NOTCH);
+  return [
+    { x: tipX, y: tipY },
+    { x: backX - uy * halfWidth, y: backY + ux * halfWidth },
+    { x: tipX - ux * notchBack, y: tipY - uy * notchBack },
+    { x: backX + uy * halfWidth, y: backY - ux * halfWidth }
+  ];
+}
+function inRun(run, i) {
+  return run !== void 0 && i >= run.start && i < run.start + run.count;
+}
+function groupByPaint(items, paintOf) {
+  const groups = /* @__PURE__ */ new Map();
+  const deferred = /* @__PURE__ */ new Map();
+  for (let i = 0, l = items.length; i < l; i++) {
+    const item = items[i];
+    const { color, weight, last } = paintOf(item, i);
+    const into = last ? deferred : groups;
+    const key = `${color}:${weight}`;
+    const group = into.get(key);
+    if (group) {
+      group.items.push(item);
+    } else {
+      into.set(key, { color, items: [item] });
+    }
+  }
+  return [...groups.values(), ...deferred.values()];
+}
+
+export {
+  Canvas2DRenderer,
+  arrowheadOutline
+};

package/dist/chunks/chunk-DKOB2OPC.js

@@ -0,0 +1,177 @@
+import {
+  nodesUnderBox
+} from "./chunk-YMSSF2RK.js";
+import {
+  nodeLabelBudget,
+  placeSizeLabels,
+  rowLabelBox,
+  sizeLabelCandidates
+} from "./chunk-N62KBLFC.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
+};

package/dist/chunks/chunk-EJ5OZTCK.js

@@ -0,0 +1,52 @@
+// src/tubeMap/mismatches.ts
+import { forward, getXCoordinateOfBaseWithinNode } from "@gmod/tubemap-core";
+function readMismatches(read, layout) {
+  const marks = [];
+  const entries = read.sequenceNew ?? [];
+  entries.forEach((entry, i) => {
+    const nodeIndex = layout.nodeMap.get(forward(entry.nodeName));
+    const node = nodeIndex === void 0 ? void 0 : layout.nodes[nodeIndex];
+    let pathIndex = i;
+    while (pathIndex < read.path.length && read.path[pathIndex].node !== nodeIndex) {
+      pathIndex += 1;
+    }
+    const y = read.path[pathIndex]?.y;
+    if (node && y !== void 0) {
+      const base = { readId: read.id, y, height: read.width, nodeY: node.y };
+      const at = (pos) => getXCoordinateOfBaseWithinNode(node, pos);
+      for (const mm of entry.mismatches) {
+        const x0 = at(mm.pos);
+        if (x0 !== null) {
+          if (mm.type === "insertion") {
+            const softClip = i === 0 && mm.pos === read.firstNodeOffset || i === entries.length - 1 && mm.pos === read.finalNodeCoverLength;
+            marks.push({
+              ...base,
+              kind: "insertion",
+              x: x0,
+              seq: mm.seq,
+              softClip
+            });
+          } else if (mm.type === "deletion" && mm.length !== void 0) {
+            const x1 = at(mm.pos + mm.length);
+            if (x1 !== null) {
+              marks.push({ ...base, kind: "deletion", x0, x1 });
+            }
+          } else if (mm.type === "substitution" && mm.seq !== void 0) {
+            const x1 = at(mm.pos + mm.seq.length);
+            if (x1 !== null) {
+              marks.push({ ...base, kind: "substitution", x0, x1, seq: mm.seq });
+            }
+          }
+        }
+      }
+    }
+  });
+  return marks;
+}
+function tubeMapMismatches(layout) {
+  return layout.reads.flatMap((read) => readMismatches(read, layout));
+}
+
+export {
+  tubeMapMismatches
+};

package/dist/chunks/chunk-EK4HGYO7.js

@@ -0,0 +1,174 @@
+import {
+  LIFT_BACKDROP_CSS,
+  computeColorSchemeRange,
+  getNodeColor
+} from "./chunk-PCZ4PTYC.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
+};

package/dist/chunks/chunk-EPZORFTI.js

@@ -0,0 +1,23 @@
+import {
+  computeColorSchemeRange,
+  getNodeColor
+} from "./chunk-PCZ4PTYC.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
+};