@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-3S3YVOJ7.js

@@ -0,0 +1,69 @@
+import {
+  el
+} from "./chunk-NNODIW4U.js";
+
+// src/genes/exonOutline.ts
+var EXON_COLOR = "#daa520";
+var EXON_GAP_PX = 1;
+var EXON_LINE_PX = 2;
+var MIN_LANE_PX = 4;
+function exonStretches(pins, halfWidthPx, lift, pathOf = (d) => d) {
+  const inkPx = (nodeId) => {
+    const own = halfWidthPx(nodeId) * 2;
+    return lift?.nodeIds.has(nodeId) ? Math.max(own, lift.walks.length * MIN_LANE_PX) : own;
+  };
+  return pins.flatMap(
+    (pin) => pin.exonsByNode.map(({ nodeId, d }) => ({
+      key: `${pin.gene.name}-${pin.gene.start}-${nodeId}`,
+      d: pathOf(d),
+      inner: inkPx(nodeId) + 2 * EXON_GAP_PX
+    }))
+  );
+}
+function exonOutlineTree(stretches, o) {
+  if (stretches.length === 0) {
+    return void 0;
+  }
+  const stroke = (s, color, width) => el("path", {
+    d: s.d,
+    fill: "none",
+    stroke: color,
+    "stroke-width": width,
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+    "vector-effect": o.transform ? "non-scaling-stroke" : void 0
+  });
+  return el(
+    "g",
+    {},
+    el(
+      "mask",
+      {
+        id: o.id,
+        maskUnits: "userSpaceOnUse",
+        x: 0,
+        y: 0,
+        width: o.width,
+        height: o.height
+      },
+      el(
+        "g",
+        { transform: o.transform },
+        ...stretches.map((s) => stroke(s, "#fff", s.inner + 2 * EXON_LINE_PX)),
+        ...stretches.map((s) => stroke(s, "#000", s.inner))
+      )
+    ),
+    el("rect", {
+      width: o.width,
+      height: o.height,
+      fill: EXON_COLOR,
+      mask: `url(#${o.id})`
+    })
+  );
+}
+
+export {
+  EXON_COLOR,
+  exonStretches,
+  exonOutlineTree
+};

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-4EMPBO7S.js

@@ -0,0 +1,117 @@
+import {
+  computeEdgeCurves,
+  edgeJoinOf,
+  routedEdgeCurves,
+  strandSides
+} from "./chunk-2CVHXFK7.js";
+import {
+  firstNodeAtOrAfter,
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/deletionEdges.ts
+var MIN_DELETION_BP = 1;
+function bypassedPoints(nodePositions, bypassed) {
+  return bypassed.flatMap((id) => nodePositions[id] ?? []);
+}
+function deletionArcCurves(nodePositions, deletion, axis, route, stranded = false) {
+  const from = nodePositions[deletion.from];
+  const to = nodePositions[deletion.to];
+  if (!from?.length || !to?.length) {
+    return void 0;
+  }
+  return route ? routedEdgeCurves(
+    from,
+    to,
+    route,
+    stranded ? strandSides(deletion) : void 0
+  ) : computeEdgeCurves(
+    from,
+    to,
+    edgeJoinOf(deletion, stranded),
+    0,
+    0,
+    axis,
+    bypassedPoints(nodePositions, deletion.bypassed)
+  );
+}
+function backboneBySequence(graph) {
+  const bySequence = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      const list = bySequence.get(node.stable.refName);
+      if (list) {
+        list.push(node);
+      } else {
+        bySequence.set(node.stable.refName, [node]);
+      }
+    }
+  }
+  for (const list of bySequence.values()) {
+    list.sort((a, b) => a.stable.start - b.stable.start);
+  }
+  return bySequence;
+}
+function bypassedNodes(nodes, start, end) {
+  const bypassed = [];
+  if (nodes) {
+    for (let i = firstNodeAtOrAfter(nodes, start); i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.stable.start >= end) {
+        break;
+      }
+      if (node.stable.start + node.length <= end) {
+        bypassed.push(node.id);
+      }
+    }
+  }
+  return bypassed;
+}
+function skipsBetween(edge, from, to, forwards) {
+  const { fromStrand, toStrand } = edge;
+  if (fromStrand === void 0 || toStrand === void 0) {
+    return true;
+  }
+  const leavesRight = fromStrand === (from.stable.strand ?? "+");
+  const arrivesLeft = toStrand === (to.stable.strand ?? "+");
+  return forwards ? leavesRight && arrivesLeft : !leavesRight && !arrivesLeft;
+}
+function deletionEdges(graph) {
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const backbone = backboneBySequence(graph);
+  const found = [];
+  for (let edgeIndex = 0; edgeIndex < graph.edges.length; edgeIndex++) {
+    const edge = graph.edges[edgeIndex];
+    const from = byId.get(edge.from);
+    const to = byId.get(edge.to);
+    if (from !== void 0 && to !== void 0 && isBackbone(from) && isBackbone(to) && from.stable.refName === to.stable.refName) {
+      const forwards = from.stable.start <= to.stable.start;
+      const [left, right] = forwards ? [from, to] : [to, from];
+      const start = left.stable.start + left.length;
+      const end = right.stable.start;
+      const bp = end - start;
+      if (bp >= MIN_DELETION_BP && skipsBetween(edge, from, to, forwards)) {
+        const refName = left.stable.refName;
+        found.push({
+          edgeIndex,
+          from: edge.from,
+          to: edge.to,
+          ...edge.fromStrand ? { fromStrand: edge.fromStrand } : {},
+          ...edge.toStrand ? { toStrand: edge.toStrand } : {},
+          refName,
+          start,
+          end,
+          bp,
+          bypassed: bypassedNodes(backbone.get(refName), start, end)
+        });
+      }
+    }
+  }
+  return found;
+}
+
+export {
+  bypassedPoints,
+  deletionArcCurves,
+  deletionEdges
+};

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