@jbrowse/bandage-core 6.0.1 → 6.0.2

package/dist/chunks/chunk-CDLPYR5O.js

@@ -0,0 +1,135 @@
+// src/gfa-core/gfaParser.ts
+function parseTag(tag, tags) {
+  const nameEnd = tag.indexOf(":");
+  const typeEnd = tag.indexOf(":", nameEnd + 1);
+  if (nameEnd !== -1 && typeEnd !== -1) {
+    const name = tag.slice(0, nameEnd);
+    const type = tag.slice(nameEnd + 1, typeEnd);
+    const val = tag.slice(typeEnd + 1);
+    if (type === "i" || type === "f") {
+      tags[name] = +val;
+    } else if (type === "Z") {
+      tags[name] = val;
+    }
+  }
+}
+function parseTags(fields) {
+  const tags = {};
+  for (const field of fields) {
+    parseTag(field, tags);
+  }
+  return tags;
+}
+function stableCoordinate(node) {
+  const { SN, SO, SR } = node.tags;
+  return typeof SN === "string" && typeof SO === "number" && typeof SR === "number" ? { refName: SN, start: SO, rank: SR } : void 0;
+}
+var GT = 62;
+var LT = 60;
+function parseWalkBody(body) {
+  const segments = [];
+  let strand = "+";
+  let start = 0;
+  function push(end) {
+    if (end > start) {
+      segments.push({ id: body.slice(start, end), strand });
+    }
+  }
+  for (let i = 0; i < body.length; i++) {
+    const ch = body.charCodeAt(i);
+    if (ch === GT || ch === LT) {
+      push(i);
+      strand = ch === GT ? "+" : "-";
+      start = i + 1;
+    }
+  }
+  push(body.length);
+  return segments;
+}
+function parseGFA(file) {
+  const graph = {
+    nodes: [],
+    links: [],
+    paths: [],
+    walks: [],
+    header: [],
+    id: ""
+  };
+  for (const rawLine of file.split("\n")) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line.startsWith("H")) {
+      const [, ...rest] = line.split("	");
+      graph.header.push(parseTags(rest));
+    } else if (line.startsWith("S")) {
+      const [, name, ...rest] = line.split("	");
+      let len;
+      let seq;
+      let tagfields;
+      let gfa1 = false;
+      const first = rest[0] ?? "*";
+      if (/^\d+$/.test(first)) {
+        len = +first;
+        seq = rest[1] ?? "*";
+        tagfields = rest.slice(2);
+      } else {
+        gfa1 = true;
+        seq = first;
+        len = seq === "*" ? 0 : seq.length;
+        tagfields = rest.slice(1);
+      }
+      const tags = parseTags(tagfields);
+      if (gfa1 && "LN" in tags) {
+        len = +tags.LN;
+      }
+      graph.nodes.push({ id: name, length: len, sequence: seq, tags });
+    } else if (line.startsWith("E")) {
+      const [, , source, target, , , , , cigar, ...rest] = line.split("	");
+      if (source && target) {
+        graph.links.push({
+          source: source.slice(0, -1),
+          target: target.slice(0, -1),
+          strand1: source.at(-1),
+          strand2: target.at(-1),
+          cigar: cigar ?? "*",
+          tags: parseTags(rest)
+        });
+      }
+    } else if (line.startsWith("L")) {
+      const [, source, strand1, target, strand2, cigar, ...rest] = line.split("	");
+      if (source && target && strand2) {
+        graph.links.push({
+          source,
+          target,
+          strand1,
+          strand2,
+          cigar: cigar ?? "*",
+          tags: parseTags(rest)
+        });
+      }
+    } else if (line.startsWith("W")) {
+      const [, sample, hap, contig, start, end, body, ...rest] = line.split("	");
+      if (sample && hap && contig && start && end && body) {
+        graph.walks.push({
+          sample,
+          haplotype: +hap,
+          contig,
+          start: start === "*" ? -1 : +start,
+          end: end === "*" ? -1 : +end,
+          segments: parseWalkBody(body),
+          tags: parseTags(rest)
+        });
+      }
+    } else if (line.startsWith("P")) {
+      const [, name, path, ...rest] = line.split("	");
+      if (name && path) {
+        graph.paths.push({ name, path, rest });
+      }
+    }
+  }
+  return graph;
+}
+
+export {
+  stableCoordinate,
+  parseGFA
+};

package/dist/chunks/chunk-CPMHA4W5.js

@@ -0,0 +1,6 @@
+// src/layout/rowSpacing.ts
+var ROW_HEIGHT_PX = 20;
+
+export {
+  ROW_HEIGHT_PX
+};

package/dist/chunks/chunk-CR7EGAFE.js

@@ -0,0 +1,241 @@
+import {
+  tubeMapMismatches
+} from "./chunk-EJ5OZTCK.js";
+
+// src/tubeMap/draw.ts
+import { curvePaths, nodeOutlinePath } from "@gmod/tubemap-core";
+function parsePath(d) {
+  const tokens = d.trim().split(/[\s,]+/);
+  const commands = [];
+  let i = 0;
+  const num = () => Number(tokens[i++]);
+  while (i < tokens.length) {
+    const op = tokens[i++];
+    if (op === "M" || op === "L") {
+      commands.push({ op, x: num(), y: num() });
+    } else if (op === "H") {
+      commands.push({ op, x: num() });
+    } else if (op === "V") {
+      commands.push({ op, y: num() });
+    } else if (op === "Q") {
+      commands.push({ op, x1: num(), y1: num(), x: num(), y: num() });
+    } else if (op === "C") {
+      commands.push({
+        op,
+        x1: num(),
+        y1: num(),
+        x2: num(),
+        y2: num(),
+        x: num(),
+        y: num()
+      });
+    } else if (op === "Z") {
+      commands.push({ op });
+    }
+  }
+  return commands;
+}
+function extentOf(commands) {
+  let x0 = Infinity;
+  let x1 = -Infinity;
+  for (const c of commands) {
+    if ("x" in c) {
+      x0 = Math.min(x0, c.x);
+      x1 = Math.max(x1, c.x);
+    }
+    if ("x1" in c) {
+      x0 = Math.min(x0, c.x1);
+      x1 = Math.max(x1, c.x1);
+    }
+  }
+  return { x0, x1 };
+}
+function shapeOf(d, color, alpha, track) {
+  const commands = parsePath(d);
+  return { commands, color, track, alpha, ...extentOf(commands) };
+}
+function layerOf(layout, type) {
+  const { shapes } = layout;
+  const trackOf = (s) => type === "haplotype" ? s.id : void 0;
+  const rects = [...shapes.rectangles, ...shapes.verticalRectangles].filter((r) => r.type === type).map((r) => ({
+    color: r.color,
+    track: trackOf(r),
+    alpha: r.alpha ?? 1,
+    x0: r.xStart,
+    x1: r.xEnd + 1,
+    y0: r.yStart,
+    y1: r.yEnd + 1
+  }));
+  const curves = curvePaths(shapes.curves, type).map(
+    (c) => shapeOf(c.path, c.color, c.alpha ?? 1, trackOf(c))
+  );
+  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, c.color, 1, trackOf(c)));
+  return { rects, shapes: [...curves, ...corners] };
+}
+function tubeMapPicture(layout) {
+  const nodes = [];
+  layout.nodes.forEach((node) => {
+    if (node.order >= 0) {
+      const commands = parsePath(nodeOutlinePath(node));
+      nodes.push({ name: node.name, commands, ...extentOf(commands) });
+    }
+  });
+  return {
+    bounds: layout.bounds,
+    layers: [layerOf(layout, "haplotype"), layerOf(layout, "read")],
+    nodes,
+    mismatches: tubeMapMismatches(layout).filter(
+      (m) => m.kind !== "insertion" || !m.softClip
+    )
+  };
+}
+function trace(ctx, commands, x, y) {
+  let cx = 0;
+  let cy = 0;
+  for (const c of commands) {
+    switch (c.op) {
+      case "M":
+        cx = c.x;
+        cy = c.y;
+        ctx.moveTo(x(cx), y(cy));
+        break;
+      case "L":
+        cx = c.x;
+        cy = c.y;
+        ctx.lineTo(x(cx), y(cy));
+        break;
+      case "H":
+        cx = c.x;
+        ctx.lineTo(x(cx), y(cy));
+        break;
+      case "V":
+        cy = c.y;
+        ctx.lineTo(x(cx), y(cy));
+        break;
+      case "Q":
+        cx = c.x;
+        cy = c.y;
+        ctx.quadraticCurveTo(x(c.x1), y(c.y1), x(cx), y(cy));
+        break;
+      case "C":
+        cx = c.x;
+        cy = c.y;
+        ctx.bezierCurveTo(x(c.x1), y(c.y1), x(c.x2), y(c.y2), x(cx), y(cy));
+        break;
+      case "Z":
+        ctx.closePath();
+        break;
+    }
+  }
+}
+function fillByColor(ctx, items, visible, colorOf, addTo) {
+  const byColor = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (visible(item)) {
+      const key = `${colorOf(item)}|${item.alpha}`;
+      const list = byColor.get(key);
+      if (list) {
+        list.push(item);
+      } else {
+        byColor.set(key, [item]);
+      }
+    }
+  }
+  for (const list of byColor.values()) {
+    ctx.fillStyle = colorOf(list[0]);
+    ctx.globalAlpha = list[0].alpha;
+    ctx.beginPath();
+    for (const item of list) {
+      addTo(item);
+    }
+    ctx.fill();
+  }
+  ctx.globalAlpha = 1;
+}
+var FULL_OUTLINE_PX = 12;
+var MIN_OUTLINE_ALPHA = 0.15;
+function outlineAlpha(screenWidth) {
+  return Math.max(MIN_OUTLINE_ALPHA, Math.min(1, screenWidth / FULL_OUTLINE_PX));
+}
+var NODE_TINT_ALPHA = 0.55;
+function drawTubeMap(ctx, picture, frame) {
+  const { x, y, width } = frame;
+  const visible = (item) => x(item.x1) >= 0 && x(item.x0) <= width;
+  const colorOf = (item) => item.track !== void 0 && frame.tubeColors?.[item.track] || item.color;
+  for (const layer of picture.layers) {
+    fillByColor(ctx, layer.rects, visible, colorOf, (r) => {
+      const left = x(r.x0);
+      const top = y(r.y0);
+      ctx.rect(left, top, x(r.x1) - left, y(r.y1) - top);
+    });
+    fillByColor(ctx, layer.shapes, visible, colorOf, (s) => {
+      trace(ctx, s.commands, x, y);
+    });
+  }
+  const stroke = frame.darkMode ? "#d0d0d0" : "#000000";
+  const fill = frame.darkMode ? "rgba(40,40,40,0.4)" : "rgba(255,255,255,0.4)";
+  ctx.lineWidth = 2 * Math.max(0.25, Math.min(1, frame.yScale));
+  for (const node of picture.nodes) {
+    if (visible(node)) {
+      const lit = node.name === frame.highlightNode;
+      ctx.beginPath();
+      trace(ctx, node.commands, x, y);
+      const tint = lit ? void 0 : frame.nodeColors?.get(node.name);
+      ctx.fillStyle = lit ? "rgba(255,192,203,0.5)" : tint ?? fill;
+      ctx.strokeStyle = lit ? "#ff0000" : stroke;
+      ctx.globalAlpha = tint ? NODE_TINT_ALPHA : 1;
+      ctx.fill();
+      ctx.globalAlpha = lit ? 1 : outlineAlpha(x(node.x1) - x(node.x0));
+      ctx.stroke();
+      ctx.globalAlpha = 1;
+    }
+  }
+  drawMismatches(ctx, picture.mismatches, frame);
+}
+var MISMATCH_FONT_PX = 12;
+var MIN_MISMATCH_FONT_PX = 6;
+function mismatchesLegible(yScale) {
+  return MISMATCH_FONT_PX * yScale >= MIN_MISMATCH_FONT_PX;
+}
+function mismatchOnScreen(m, { x, width }) {
+  const [x0, x1] = m.kind === "insertion" ? [m.x, m.x] : [m.x0, m.x1];
+  return x(x1) >= 0 && x(x0) <= width;
+}
+function drawMismatches(ctx, marks, frame) {
+  const { x, y, yScale, darkMode } = frame;
+  if (!mismatchesLegible(yScale) || marks.length === 0) {
+    return;
+  }
+  const fontPx = MISMATCH_FONT_PX * yScale;
+  ctx.fillStyle = "grey";
+  ctx.beginPath();
+  for (const m of marks) {
+    if (m.kind === "deletion" && mismatchOnScreen(m, frame)) {
+      const left = x(m.x0);
+      const top = y(m.y);
+      ctx.rect(left, top, x(m.x1) - left, y(m.y + m.height) - top);
+    }
+  }
+  ctx.fill();
+  ctx.font = `${fontPx}px monospace`;
+  ctx.textBaseline = "alphabetic";
+  ctx.fillStyle = darkMode ? "#ffffff" : "#000000";
+  for (const m of marks) {
+    if (!mismatchOnScreen(m, frame)) {
+      continue;
+    }
+    if (m.kind === "substitution") {
+      ctx.fillText(m.seq, x(m.x0) + 1, y(m.y + m.height));
+    } else if (m.kind === "insertion") {
+      ctx.fillText("*", x(m.x) - 3, y(m.y + m.height));
+    }
+  }
+}
+
+export {
+  parsePath,
+  tubeMapPicture,
+  drawTubeMap,
+  mismatchesLegible,
+  mismatchOnScreen
+};