@jbrowse/bandage-core 6.0.1 → 6.0.2

package/dist/chunks/chunk-47DYCZOK.js

@@ -0,0 +1,115 @@
+// src/renderer/svgCanvas.ts
+var n = (v) => +v.toFixed(1);
+function paint(css) {
+  const m = /^rgba?\(([^,]+),([^,]+),([^,)]+)(?:,([^)]+))?\)$/.exec(
+    css.replaceAll(" ", "")
+  );
+  if (!m) {
+    return { color: css, opacity: 1 };
+  }
+  const opacity = m[4] === void 0 ? 1 : Number(m[4]);
+  return { color: `rgb(${m[1]},${m[2]},${m[3]})`, opacity };
+}
+function paintAttrs(kind, css) {
+  const { color, opacity } = paint(css);
+  return `${kind}="${color}"${opacity < 1 ? ` ${kind}-opacity="${n(opacity)}"` : ""}`;
+}
+var DOT_PX = 0.5;
+var DOT_CELL_PX = 0.25;
+function svgCanvas(width, height) {
+  const out = [];
+  let subpaths = [];
+  const start = (x, y) => {
+    const s = { d: `M${n(x)} ${n(y)}`, segments: 0, x0: x, x1: x, y0: y, y1: y };
+    subpaths.push(s);
+    return s;
+  };
+  const reach = (points) => {
+    const s = subpaths.at(-1) ?? start(points[0], points[1]);
+    for (let i = 0; i < points.length; i += 2) {
+      s.x0 = Math.min(s.x0, points[i]);
+      s.x1 = Math.max(s.x1, points[i]);
+      s.y0 = Math.min(s.y0, points[i + 1]);
+      s.y1 = Math.max(s.y1, points[i + 1]);
+    }
+    s.segments++;
+    return s;
+  };
+  const pathData = (dots) => {
+    const seen = /* @__PURE__ */ new Set();
+    return subpaths.map((s) => {
+      if (!dots || s.x1 - s.x0 >= DOT_PX || s.y1 - s.y0 >= DOT_PX) {
+        return s.d;
+      }
+      const x = (s.x0 + s.x1) / 2;
+      const y = (s.y0 + s.y1) / 2;
+      const cell = `${Math.round(x / DOT_CELL_PX)} ${Math.round(y / DOT_CELL_PX)}`;
+      if (s.segments === 0 || seen.has(cell)) {
+        return "";
+      }
+      seen.add(cell);
+      return `M${n(x)} ${n(y)}h0`;
+    }).join("");
+  };
+  const ctx = {
+    canvas: void 0,
+    fillStyle: "#000",
+    strokeStyle: "#000",
+    lineWidth: 1,
+    lineCap: "butt",
+    lineJoin: "miter",
+    beginPath() {
+      subpaths = [];
+    },
+    moveTo(x, y) {
+      start(x, y);
+    },
+    lineTo(x, y) {
+      reach([x, y]).d += `L${n(x)} ${n(y)}`;
+    },
+    bezierCurveTo(cx0, cy0, cx1, cy1, x, y) {
+      reach([cx0, cy0, cx1, cy1, x, y]).d += `C${n(cx0)} ${n(cy0)} ${n(cx1)} ${n(cy1)} ${n(x)} ${n(y)}`;
+    },
+    closePath() {
+      const s = subpaths.at(-1);
+      if (s) {
+        s.d += "Z";
+      }
+    },
+    stroke() {
+      const d = pathData(ctx.lineCap !== "butt");
+      if (d) {
+        out.push(
+          `<path d="${d}" fill="none" ${paintAttrs("stroke", ctx.strokeStyle)} stroke-width="${n(ctx.lineWidth)}" stroke-linecap="${ctx.lineCap}" stroke-linejoin="${ctx.lineJoin}"/>`
+        );
+      }
+    },
+    fill() {
+      const d = pathData(false);
+      if (d) {
+        out.push(`<path d="${d}" ${paintAttrs("fill", ctx.fillStyle)}/>`);
+      }
+    },
+    fillRect(x, y, w, h) {
+      out.push(
+        `<rect x="${n(x)}" y="${n(y)}" width="${n(w)}" height="${n(h)}" ${paintAttrs("fill", ctx.fillStyle)}/>`
+      );
+    }
+  };
+  const canvas = {
+    width,
+    height,
+    style: {},
+    getContext: () => ctx
+  };
+  ctx.canvas = canvas;
+  return {
+    canvas,
+    // the drawing so far, as SVG elements in canvas pixels
+    markup: () => out.join("")
+  };
+}
+
+export {
+  svgCanvas
+};

package/dist/chunks/chunk-4S47XRYA.js

@@ -0,0 +1,149 @@
+import {
+  SATURATED_PATH_COUNT
+} from "./chunk-MFKORG3F.js";
+import {
+  referenceOrder
+} from "./chunk-HNQPEMYE.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/bubbles/bubblesFromGraph.ts
+function bubblesFromGraph(graph) {
+  if (!graph.nodes.some(isBackbone)) {
+    return [];
+  }
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const order = referenceOrder(graph);
+  const indexOf = new Map(order.map((id, i) => [id, i]));
+  const reach = new Int32Array(order.length + 1);
+  const succ = /* @__PURE__ */ new Map();
+  const linked = /* @__PURE__ */ new Set();
+  for (const e of graph.edges) {
+    const a = indexOf.get(e.from);
+    const b = indexOf.get(e.to);
+    if (a === void 0 || b === void 0 || a === b) {
+      continue;
+    }
+    linked.add(`${e.from}>${e.to}`).add(`${e.to}>${e.from}`);
+    const [lo, hi] = a < b ? [a, b] : [b, a];
+    reach[lo + 1]++;
+    reach[hi]--;
+    const [from, to] = a < b ? [e.from, e.to] : [e.to, e.from];
+    (succ.get(from) ?? succ.set(from, /* @__PURE__ */ new Set()).get(from)).add(to);
+  }
+  for (let i = 1; i < reach.length; i++) {
+    reach[i] += reach[i - 1];
+  }
+  const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
+  const ends = /* @__PURE__ */ new Set([backbone[0].id, backbone.at(-1).id]);
+  const boundaries = backbone.map((node) => [node, indexOf.get(node.id)]).filter(([node, i]) => ends.has(node.id) || reach[i] === 0).sort(([a, ia], [b, ib]) => ia - ib || a.stable.start - b.stable.start);
+  const walkIndex = graph.paths?.map((p) => {
+    const at = /* @__PURE__ */ new Map();
+    p.nodeIds.forEach((id, i) => {
+      if (!at.has(id)) {
+        at.set(id, i);
+      }
+    });
+    return at;
+  });
+  const bubbles = [];
+  for (let i = 0; i + 1 < boundaries.length; i++) {
+    const [start, i0] = boundaries[i];
+    const [end, i1] = boundaries[i + 1];
+    const interior = order.slice(i0 + 1, i1);
+    if (interior.length === 0) {
+      continue;
+    }
+    const best = /* @__PURE__ */ new Map([[start.id, { min: 0, max: 0, n: 1 }]]);
+    for (const id of [start.id, ...interior]) {
+      const cur = best.get(id);
+      if (!cur) {
+        continue;
+      }
+      for (const t of succ.get(id) ?? []) {
+        const ti = indexOf.get(t);
+        if (ti > i1) {
+          continue;
+        }
+        const add = t === end.id ? 0 : byId.get(t).length;
+        const prev = best.get(t);
+        best.set(t, {
+          min: Math.min(prev?.min ?? Infinity, cur.min + add),
+          max: Math.max(prev?.max ?? -Infinity, cur.max + add),
+          n: Math.min(SATURATED_PATH_COUNT, cur.n + (prev?.n ?? 0))
+        });
+      }
+    }
+    const walked = walkIndex && walkRoutes(graph, byId, walkIndex, start.id, end.id);
+    const crossed = walked?.n ? walked : void 0;
+    const routes = crossed ?? best.get(end.id) ?? { min: 0, max: 0, n: 0 };
+    const walksLeave = walked !== void 0 && walked.left > 0;
+    const refStart = start.stable.start + start.length;
+    const refEnd = end.stable.start;
+    const chain = [
+      start.id,
+      ...interior.filter((id) => isBackbone(byId.get(id))),
+      end.id
+    ];
+    const chainBroken = chain.some(
+      (id, k) => k > 0 && !linked.has(`${chain[k - 1]}>${id}`)
+    );
+    const partial = chainBroken || walksLeave;
+    const fallback = chainBroken && !crossed;
+    bubbles.push({
+      refName: start.stable.refName,
+      start: refStart,
+      end: refEnd,
+      segmentCount: interior.length + 2,
+      pathCount: routes.n,
+      // a real inversion test needs each walk's direction relative to the
+      // reference; the first visit's strand is just whichever path anchored the
+      // node
+      inversion: false,
+      shortestAlleleLength: fallback ? refEnd - refStart : routes.min,
+      longestAlleleLength: fallback ? refEnd - refStart : routes.max,
+      segments: [start, ...interior.map((id) => byId.get(id)), end].map((n) => n.name).join(","),
+      shortestAllele: void 0,
+      longestAllele: void 0,
+      partial,
+      routes: crossed?.routes
+    });
+  }
+  return bubbles;
+}
+function walkRoutes(graph, byId, walkIndex, startId, endId) {
+  const seen = /* @__PURE__ */ new Map();
+  let min = Infinity;
+  let max = -Infinity;
+  let left = 0;
+  graph.paths.forEach((p, k) => {
+    const i0 = walkIndex[k].get(startId);
+    const i1 = walkIndex[k].get(endId);
+    if (i0 === void 0 || i1 === void 0) {
+      if (i0 !== void 0 || i1 !== void 0) {
+        left++;
+      }
+      return;
+    }
+    const steps = p.nodeIds.slice(Math.min(i0, i1) + 1, Math.max(i0, i1));
+    if (i1 < i0) {
+      steps.reverse();
+    }
+    let bp = 0;
+    for (const id of steps) {
+      bp += byId.get(id)?.length ?? 0;
+    }
+    const key = steps.join(",");
+    const route = seen.get(key) ?? { steps, bp, walks: [] };
+    route.walks.push(p.name);
+    seen.set(key, route);
+    min = Math.min(min, bp);
+    max = Math.max(max, bp);
+  });
+  return seen.size || left ? { min, max, n: seen.size, left, routes: [...seen.values()] } : void 0;
+}
+
+export {
+  bubblesFromGraph
+};

package/dist/chunks/chunk-527AI7CP.js

@@ -0,0 +1,122 @@
+import {
+  hasTubeMapPaths,
+  tubeMapLayout,
+  tubeMapReferenceLayout
+} from "./chunk-P7B3GDAY.js";
+import {
+  sampleRowLayout
+} from "./chunk-LOEA5IHZ.js";
+import {
+  anchoredLayout
+} from "./chunk-L3O7AWLI.js";
+import {
+  orderedLayout
+} from "./chunk-HNQPEMYE.js";
+import {
+  walkRowLayout
+} from "./chunk-EZPBJPK6.js";
+import {
+  isBackbone,
+  isOffReference
+} from "./chunk-FYQWPEEY.js";
+
+// src/layoutModes.ts
+var FORCE_LAYOUT_LABEL = "Force-directed layout";
+var hasBackbone = (graph) => graph.nodes.some(isBackbone);
+var hasWalks = (graph) => hasBackbone(graph) && (graph.paths?.length ?? 0) > 1;
+var hasTubeMapBackbone = (graph) => hasBackbone(graph) && hasTubeMapPaths(graph);
+var hasAlleles = (graph) => hasBackbone(graph) && graph.nodes.some(isOffReference);
+var LAYOUT_MODES = [
+  {
+    value: "auto",
+    label: "Anchored",
+    description: "x is reference bp, one row per stable rank. Needs rGFA tags or a reference path.",
+    run: anchoredLayout,
+    cutMargins: true,
+    wholeWalks: false,
+    available: hasBackbone,
+    drawsLocally: hasBackbone,
+    drawsNodes: true
+  },
+  {
+    value: "samplerows",
+    label: "Sample rows",
+    description: "x is reference bp, one row per contributing assembly. Needs rGFA tags or a reference path.",
+    run: sampleRowLayout,
+    cutMargins: true,
+    wholeWalks: false,
+    available: hasAlleles,
+    drawsLocally: hasAlleles,
+    drawsNodes: true
+  },
+  {
+    value: "walkrows",
+    label: "Walk rows",
+    description: "x is each walk's own bp: one bar per haplotype, blue on the reference's path and purple off it, so a repeat expansion reads as bar length, and each bar boxes its haplotype's own genes where the session has them. Needs W or P lines.",
+    run: walkRowLayout,
+    cutMargins: false,
+    wholeWalks: true,
+    available: hasWalks,
+    drawsLocally: hasWalks,
+    drawsNodes: false
+  },
+  {
+    value: "ordered",
+    label: "Ordered",
+    description: "x is reference order, not bp: every node gets room, bubbles read as lenses. Needs rGFA tags or a reference path.",
+    run: orderedLayout,
+    cutMargins: false,
+    wholeWalks: false,
+    available: hasBackbone,
+    drawsLocally: hasBackbone,
+    drawsNodes: true
+  },
+  {
+    value: "tubemap",
+    label: "Tube map",
+    description: "sequenceTubeMap: every path a coloured tube through boxed nodes, columns in node order and node widths log-scaled. Needs P or W lines.",
+    run: tubeMapLayout,
+    cutMargins: false,
+    wholeWalks: false,
+    available: hasTubeMapPaths,
+    drawsLocally: hasTubeMapPaths,
+    drawsNodes: false
+  },
+  {
+    value: "tubemapref",
+    label: "Tube map on reference",
+    description: "The tube map with each column at the reference bp it covers, so the tubes line up with the tracks around them. Needs P or W lines and a reference path.",
+    run: tubeMapReferenceLayout,
+    cutMargins: true,
+    wholeWalks: false,
+    available: hasTubeMapBackbone,
+    drawsLocally: hasTubeMapBackbone,
+    drawsNodes: false
+  },
+  {
+    value: "force",
+    label: FORCE_LAYOUT_LABEL,
+    description: "OGDF FMMM, via the external Bandage engine.",
+    run: () => void 0,
+    cutMargins: false,
+    wholeWalks: false,
+    available: () => true,
+    drawsLocally: () => false,
+    drawsNodes: true
+  }
+];
+var LAYOUT_MODE_VALUES = LAYOUT_MODES.map((m) => m.value);
+function modeUsesLayoutEngine(value, graph) {
+  return !layoutModeByValue(value).drawsLocally(graph);
+}
+function layoutModeByValue(value) {
+  return LAYOUT_MODES.find((m) => m.value === value) ?? LAYOUT_MODES[0];
+}
+
+export {
+  FORCE_LAYOUT_LABEL,
+  LAYOUT_MODES,
+  LAYOUT_MODE_VALUES,
+  modeUsesLayoutEngine,
+  layoutModeByValue
+};

package/dist/chunks/chunk-57ZIXHZA.js

@@ -0,0 +1,90 @@
+import {
+  tubeSpan
+} from "./chunk-Q3KCTA4N.js";
+
+// src/tubeMap/genes.ts
+function tubeMapGenes(byRefName, genes) {
+  const out = [];
+  for (const gene of genes) {
+    const boxes = byRefName.get(gene.refName);
+    const first = boxes?.[0];
+    const last = boxes?.at(-1);
+    if (!boxes || !first || !last) {
+      continue;
+    }
+    const start = Math.max(gene.start, first.bp0);
+    const end = Math.min(gene.end, last.bp1);
+    if (end <= start) {
+      continue;
+    }
+    out.push({
+      gene,
+      ...tubeSpan(boxes, start, end),
+      exons: gene.exons.filter((e) => e.end > start && e.start < end).map(
+        (e) => tubeSpan(boxes, Math.max(e.start, start), Math.min(e.end, end))
+      )
+    });
+  }
+  return out;
+}
+var GENE_ROW_PX = 22;
+var MAX_GENE_ROWS = 4;
+var EXON_PX = 8;
+var NAME_FONT = "11px sans-serif";
+var NAME_GAP_PX = 8;
+function tubeMapGeneRows(genes) {
+  const edges = genes.flatMap((g) => [
+    { x: g.x0, step: 1 },
+    { x: g.x1, step: -1 }
+  ]).sort((a, b) => a.x - b.x || a.step - b.step);
+  let depth = 0;
+  let most = 0;
+  for (const { step } of edges) {
+    depth += step;
+    most = Math.max(most, depth);
+  }
+  return Math.min(MAX_GENE_ROWS, most);
+}
+function drawTubeMapGenes(ctx, genes, frame, bottom, top = 0) {
+  const { x, width, darkMode } = frame;
+  const rows = Math.max(1, Math.floor((bottom - top) / GENE_ROW_PX));
+  const rowEnds = [];
+  const ink = darkMode ? "#e0e0e6" : "#1c1c22";
+  ctx.font = NAME_FONT;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "alphabetic";
+  ctx.fillStyle = ink;
+  ctx.strokeStyle = ink;
+  ctx.lineWidth = 1;
+  const placed = genes.map((g) => ({ g, s0: x(g.x0), s1: x(g.x1) })).filter(({ s0, s1 }) => s1 >= 0 && s0 <= width).sort((a, b) => a.s0 - b.s0);
+  for (const { g, s0, s1 } of placed) {
+    const arrow = g.gene.strand > 0 ? " \u2192" : g.gene.strand < 0 ? "\u2190 " : "";
+    const label = g.gene.strand < 0 ? `${arrow}${g.gene.name}` : `${g.gene.name}${arrow}`;
+    const mid = (Math.max(s0, 0) + Math.min(s1, width)) / 2;
+    const half = ctx.measureText(label).width / 2;
+    const left = Math.min(s0, mid - half);
+    const right = Math.max(s1, mid + half);
+    let row = rowEnds.findIndex((end) => end + NAME_GAP_PX <= left);
+    if (row === -1) {
+      row = Math.min(rowEnds.length, rows - 1);
+    }
+    rowEnds[row] = Math.max(rowEnds[row] ?? -Infinity, right);
+    const glyphY = bottom - row * GENE_ROW_PX - EXON_PX / 2;
+    ctx.beginPath();
+    ctx.moveTo(s0, glyphY + 0.5);
+    ctx.lineTo(s1, glyphY + 0.5);
+    ctx.stroke();
+    for (const e of g.exons) {
+      const e0 = x(e.x0);
+      ctx.fillRect(e0, glyphY - EXON_PX / 2, Math.max(1, x(e.x1) - e0), EXON_PX);
+    }
+    ctx.fillText(label, mid, glyphY - EXON_PX / 2 - 2);
+  }
+}
+
+export {
+  tubeMapGenes,
+  GENE_ROW_PX,
+  tubeMapGeneRows,
+  drawTubeMapGenes
+};

package/dist/chunks/chunk-5QT6NPSO.js

@@ -0,0 +1,40 @@
+import {
+  REFERENCE_RAMP_MAX_HUE
+} from "./chunk-3WHKR5TY.js";
+
+// src/referenceRampCss.ts
+function rampHueCss(hue) {
+  return `hsl(${hue}, 70%, 50%)`;
+}
+function rampHue(bp, domain) {
+  const frac = (bp - domain.start) / (domain.end - domain.start);
+  return Math.max(0, Math.min(1, frac)) * REFERENCE_RAMP_MAX_HUE;
+}
+var HUE_STOP_DEG = 30;
+function rampStops({ start, bp, reversed }, domain) {
+  const low = rampHue(start, domain);
+  const high = rampHue(start + bp, domain);
+  if (high - low < 1) {
+    return [(low + high) / 2];
+  }
+  const n = Math.ceil((high - low) / HUE_STOP_DEG);
+  return Array.from(
+    { length: n + 1 },
+    (_, i) => rampHue(start + bp * (reversed ? n - i : i) / n, domain)
+  );
+}
+var RAMP_GRADIENT_STOPS = Array.from({ length: 7 }, (_, i) => ({
+  offset: i / 6,
+  color: rampHueCss(i / 6 * REFERENCE_RAMP_MAX_HUE)
+}));
+var RAMP_GRADIENT_CSS = `linear-gradient(to right, ${RAMP_GRADIENT_STOPS.map(
+  (s) => `${s.color} ${s.offset * 100}%`
+).join(", ")})`;
+
+export {
+  rampHueCss,
+  rampHue,
+  rampStops,
+  RAMP_GRADIENT_STOPS,
+  RAMP_GRADIENT_CSS
+};

package/dist/chunks/chunk-6JEWNXCQ.js

@@ -0,0 +1,90 @@
+// src/layout/drawnScale.ts
+var MEAN_NODE_LENGTH = 40;
+var MIN_TOTAL_GRAPH_LENGTH = 500;
+var BANDAGE_MINIMUM_NODE_LENGTH = 5;
+function drawnNodeLength(opts, length) {
+  return Math.max(
+    opts.nodeLengthPerMegabase * length / 1e6,
+    opts.minimumNodeLength
+  );
+}
+function bandageAutoScale(graph, minNodeLength = BANDAGE_MINIMUM_NODE_LENGTH) {
+  const totalLength = graph.nodes.reduce((sum, n) => sum + n.length, 0);
+  const megabases = totalLength / 1e6;
+  const target = Math.max(
+    graph.nodes.length * MEAN_NODE_LENGTH,
+    MIN_TOTAL_GRAPH_LENGTH
+  );
+  return {
+    nodeLengthPerMegabase: megabases > 0 ? target / megabases : 1e4,
+    minimumNodeLength: Math.max(BANDAGE_MINIMUM_NODE_LENGTH, minNodeLength),
+    edgeLength: 5,
+    nodeSegmentLength: 20
+  };
+}
+var PROPORTIONAL_LENGTH = { power: 1, effect: 1 };
+function isProportional(law) {
+  return law.power === 1 && law.effect === 1;
+}
+function drawnLengthFor(graph, law) {
+  const count = graph.nodes.length;
+  const totalLength = graph.nodes.reduce((sum, n) => sum + n.length, 0);
+  const meanBp = count > 0 ? totalLength / count : 0;
+  const meanDrawn = count > 0 ? Math.max(count * MEAN_NODE_LENGTH, MIN_TOTAL_GRAPH_LENGTH) / count : MEAN_NODE_LENGTH;
+  return (bp) => {
+    if (meanBp <= 0) {
+      return meanDrawn;
+    }
+    const relative = (bp / meanBp) ** law.power;
+    return Math.max(
+      meanDrawn * ((relative - 1) * law.effect + 1),
+      BANDAGE_MINIMUM_NODE_LENGTH
+    );
+  };
+}
+var LAYOUT_LENGTH_PRECISION = 1e3;
+var PROPORTIONAL_SPREAD = {
+  law: PROPORTIONAL_LENGTH,
+  minNodeLength: 0
+};
+function layoutScaling(graph, spread = PROPORTIONAL_SPREAD) {
+  const { law, minNodeLength } = spread;
+  const opts = bandageAutoScale(graph, minNodeLength);
+  if (isProportional(law)) {
+    return { nodes: graph.nodes, opts };
+  }
+  const drawn = drawnLengthFor(graph, law);
+  return {
+    nodes: graph.nodes.map((node) => ({
+      ...node,
+      length: Math.round(drawn(node.length) * LAYOUT_LENGTH_PRECISION)
+    })),
+    opts: {
+      ...opts,
+      nodeLengthPerMegabase: 1e6 / LAYOUT_LENGTH_PRECISION,
+      // Bandage's own floor only. A law and a raised floor are alternatives
+      // rather than a stack: the law has already lifted the small end, and a
+      // floor on top of it would flatten exactly what it just spread.
+      minimumNodeLength: BANDAGE_MINIMUM_NODE_LENGTH
+    }
+  };
+}
+function drawnLengthOf(graph, spread = PROPORTIONAL_SPREAD) {
+  if (isProportional(spread.law)) {
+    const opts = bandageAutoScale(graph, spread.minNodeLength);
+    return (bp) => drawnNodeLength(opts, bp);
+  }
+  return drawnLengthFor(graph, spread.law);
+}
+
+export {
+  MEAN_NODE_LENGTH,
+  drawnNodeLength,
+  bandageAutoScale,
+  PROPORTIONAL_LENGTH,
+  isProportional,
+  drawnLengthFor,
+  PROPORTIONAL_SPREAD,
+  layoutScaling,
+  drawnLengthOf
+};