@jbrowse/bandage-core 6.0.0 → 6.0.2

package/dist/chunks/chunk-CZ54VG2H.js

@@ -0,0 +1,431 @@
+import {
+  svgCanvas
+} from "./chunk-47DYCZOK.js";
+import {
+  stripGeneGaps,
+  walkStripFrame,
+  walkStripLabelsTree
+} from "./chunk-MHGHYHTL.js";
+import {
+  walkRowsKey,
+  walkRowsKeyTree,
+  walkRowsTree
+} from "./chunk-QCYM44UL.js";
+import {
+  Canvas2DRenderer
+} from "./chunk-D3M7SBKL.js";
+import {
+  genePins
+} from "./chunk-SV27AJCC.js";
+import {
+  EXON_COLOR,
+  exonOutlineTree,
+  exonStretches
+} from "./chunk-3S3YVOJ7.js";
+import {
+  version
+} from "./chunk-KCW7L3NV.js";
+import {
+  axisScaleOf
+} from "./chunk-L5RYUPZI.js";
+import {
+  facetLifts,
+  walkLift
+} from "./chunk-6Q6HFBJT.js";
+import {
+  encodingStops
+} from "./chunk-IMW3AK27.js";
+import {
+  rangeText,
+  walkKey
+} from "./chunk-AE3UQZY3.js";
+import {
+  FIT_PADDING,
+  drawingBounds,
+  fitTransform
+} from "./chunk-VKB57ZYE.js";
+import {
+  buildGeometry,
+  computeReferenceRamp
+} from "./chunk-3WHKR5TY.js";
+import {
+  geneLabelCandidates
+} from "./chunk-HB6PDCOU.js";
+import {
+  nodesUnderBox
+} from "./chunk-BJV2W4KZ.js";
+import {
+  walkRowsExtent
+} from "./chunk-EZPBJPK6.js";
+import {
+  pathLegend
+} from "./chunk-7CHJKABZ.js";
+import {
+  LABEL_CHAR_PX,
+  LABEL_PAD,
+  LABEL_PX,
+  occupancy,
+  placeLabels
+} from "./chunk-AB35TJST.js";
+import {
+  nodeInk
+} from "./chunk-PBENCR5L.js";
+import {
+  resolveColorScheme
+} from "./chunk-JKJWSY4V.js";
+import {
+  deletionEdges
+} from "./chunk-X32PABB7.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  serializeEl
+} from "./chunk-NNODIW4U.js";
+import {
+  FACET_GAP_PX,
+  FACET_PAD_PX,
+  FACET_TITLE_PX,
+  facetCells,
+  facetGrid,
+  facetSettingOf
+} from "./chunk-6SBUFFTB.js";
+import {
+  referenceLabel
+} from "./chunk-RAKOB6IV.js";
+
+// src/figure.ts
+var FONT = 'font-family="Helvetica, Arial, sans-serif" font-size="11"';
+var BAR_PX = 48;
+var SWATCH_PX = 18;
+var KEY_GAP_PX = 16;
+var STRIP_KEY_PX = 22;
+var FADED = "rgb(160,160,160)";
+var GENE_INK = "#1c1c22";
+function esc(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function keySvg(id, x, y, stops, label, after, under, opacity = 1) {
+  const bar = stops.length > 1 ? BAR_PX : SWATCH_PX;
+  const fill = stops.length > 1 ? `fill="url(#${id})"` : `fill="${stops[0].color}"${opacity < 1 ? ` fill-opacity="${opacity}"` : ""}`;
+  const defs = stops.length > 1 ? `<linearGradient id="${id}">${stops.map((s) => `<stop offset="${s.offset}" stop-color="${s.color}"/>`).join("")}</linearGradient>` : "";
+  const width = Math.max(
+    bar + 5 + (label.length + after.length) * LABEL_CHAR_PX,
+    (under?.length ?? 0) * LABEL_CHAR_PX
+  );
+  return {
+    width,
+    markup: `${defs}<g transform="translate(${x} ${y})" ${FONT}><rect y="5" width="${bar}" height="8" rx="2" ${fill}/><text x="${bar + 5}" y="13"><tspan font-weight="bold">${esc(label)}</tspan>${esc(after)}</text>${under ? `<text y="28">${esc(under)}</text>` : ""}</g>`
+  };
+}
+function exonKeySvg(x, y) {
+  return {
+    width: SWATCH_PX + 5 + 4 * LABEL_CHAR_PX,
+    markup: `<g transform="translate(${x} ${y})" ${FONT}><rect x="1" y="4" width="${SWATCH_PX - 2}" height="10" rx="4" fill="none" stroke="${EXON_COLOR}" stroke-width="2"/><text x="${SWATCH_PX + 5}" y="13">exon</text></g>`
+  };
+}
+function walkKeySvg(id, x, y, walk, label, reference) {
+  const key = walkKey(walk, reference);
+  return keySvg(
+    id,
+    x,
+    y,
+    encodingStops(walk.encoding),
+    label,
+    key.delta + key.outside + key.reversed,
+    key.scale
+  );
+}
+function screenPath(d, t) {
+  return d.replaceAll(
+    /([ML])(-?[\d.e-]+),(-?[\d.e-]+)/g,
+    (_, cmd, x, y) => `${cmd}${+(Number(x) * t.scaleX + t.translateX).toFixed(1)},${+(Number(y) * t.scaleY + t.translateY).toFixed(1)}`
+  );
+}
+function chip(x, y, w, name, note) {
+  return `<rect x="${x - w / 2}" y="${y - LABEL_PX - LABEL_PAD + 2}" width="${w}" height="${LABEL_PX + LABEL_PAD * 2 - 2}" rx="3" fill="#fff" fill-opacity="0.85" stroke="${EXON_COLOR}"/><text x="${x}" y="${y}" font-family="Helvetica, Arial, sans-serif" font-size="${LABEL_PX}" fill="${GENE_INK}" text-anchor="middle"><tspan font-style="italic" font-weight="600">${esc(name)}</tspan>${note ? esc(note) : ""}</text>`;
+}
+function figureSvg(graph, layout, o = {}) {
+  const width = o.width ?? 1200;
+  const room = o.height ?? 800;
+  const region = o.region;
+  const rampDomain = o.colorDomain ?? region;
+  const rows = o.walkRows;
+  const bounds = drawingBounds(layout, {
+    region: o.fitToDrawing ? void 0 : region,
+    extent: rows && layout.extent ? walkRowsExtent(rows) : void 0
+  });
+  const pixelRows = layout.pixelRows ?? false;
+  const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+  const colorScheme = resolveColorScheme(o.colorScheme ?? "auto", graph);
+  const referenceRamp = colorScheme === "reference-position" && !layout.tubeMap ? computeReferenceRamp(graph, rampDomain) : void 0;
+  const rampInterval = referenceRamp && {
+    start: referenceRamp.start,
+    end: referenceRamp.start + referenceRamp.span
+  };
+  const deletions = layout.tubeMap ? [] : deletionEdges(graph);
+  const layers = o.walks ?? [];
+  const walkRamp = layers.some((l) => l.color?.field === "reference") ? referenceRamp ?? computeReferenceRamp(graph, rampDomain) : void 0;
+  const lift = layers.length > 0 && !layout.tubeMap ? walkLift(graph, layers, walkRamp) : void 0;
+  const facet = facetSettingOf(o.facet);
+  const panels = facet.field && lift && lift.walks.length > 1 ? facetLifts(graph, lift, layers, walkRamp) : void 0;
+  const labels = new Map(
+    (graph.paths?.length ? pathLegend(graph.paths) : []).map((p) => [
+      p.name,
+      p.label
+    ])
+  );
+  const labelOf = (name) => labels.get(name) ?? name;
+  const referenceName = o.referenceName ?? referenceLabel(graph, region);
+  const reference = lift?.referenceDomain && {
+    ...lift.referenceDomain,
+    name: referenceName
+  };
+  const contigThickness = o.contigThickness ?? 6;
+  const nodeWidth = o.nodeWidth ?? "depth";
+  const pins = o.genes?.length && !layout.tubeMap && !rows ? genePins(graph, o.genes, layout.nodePositions) : [];
+  const ink = nodeInk(graph, nodeById, contigThickness, nodeWidth);
+  let masks = 0;
+  function overlays(highlight, t, w, h) {
+    const out = [];
+    const outlines = exonOutlineTree(
+      exonStretches(pins, ink.halfWidthPx, highlight, (d) => screenPath(d, t)),
+      { id: `exons${masks++}`, width: w, height: h }
+    );
+    if (outlines) {
+      out.push(serializeEl(outlines));
+    }
+    const screen = (p) => ({
+      x: p.x * t.scaleX + t.translateX,
+      y: p.y * t.scaleY + t.translateY
+    });
+    const frame = { width: w, height: h };
+    for (const { item: pin, x, y, w: cw, text } of placeLabels(
+      geneLabelCandidates(
+        pins,
+        screen,
+        contigThickness,
+        nodesUnderBox(layout.nodePositions, t)
+      ),
+      frame,
+      occupancy(frame)
+    )) {
+      const pinY = screen(pin.at).y + contigThickness / 2;
+      out.push(
+        `<line x1="${x}" x2="${x}" y1="${y - LABEL_PX - 2}" y2="${pinY}" stroke="${GENE_INK}" stroke-width="0.8" stroke-opacity="0.6"/>`,
+        chip(x, y, cw, pin.gene.name, text.slice(pin.gene.name.length))
+      );
+    }
+    if (rows) {
+      out.push(
+        serializeEl(
+          walkRowsTree(
+            rows,
+            { ...t, width: w, height: h },
+            {
+              ramp: rampInterval,
+              rowGenes: o.rowGenes
+            }
+          )
+        )
+      );
+    }
+    const rowLabels = rows ? [rows.reference, ...rows.rows].map((r, i) => ({
+      label: r.label,
+      y: i * ROW_HEIGHT_PX
+    })) : layout.rowLabels ?? [];
+    for (const { label, y } of rowLabels) {
+      const sy = y * t.scaleY + t.translateY;
+      if (sy >= 0 && sy <= h) {
+        out.push(
+          `<text x="6" y="${sy + 4}" ${FONT} stroke="#fff" stroke-width="3" paint-order="stroke">${esc(label)}</text>`
+        );
+      }
+    }
+    return out.join("");
+  }
+  function drawing(highlight, w, h) {
+    const fit = fitTransform(
+      bounds,
+      w,
+      h,
+      pixelRows,
+      panels ? {
+        padLeft: FACET_PAD_PX,
+        padTop: FACET_PAD_PX,
+        padRight: FACET_PAD_PX,
+        padBottom: FACET_PAD_PX
+      } : {}
+    );
+    if (!fit) {
+      return "";
+    }
+    const axis = axisScaleOf(fit.scale, pixelRows);
+    const { canvas, markup } = svgCanvas(w, h);
+    const renderer = new Canvas2DRenderer(canvas);
+    renderer.uploadGeometry(
+      buildGeometry({
+        nodePositions: rows ? {} : layout.nodePositions,
+        graph,
+        nodeById,
+        colorScheme,
+        contigThickness,
+        connectorThickness: o.connectorThickness ?? 2,
+        drawPaths: false,
+        nodeWidth,
+        highlight,
+        axis,
+        referenceRamp,
+        deletions: new Map(deletions.map((d) => [d.edgeIndex, d.bypassed])),
+        deletionRoutes: layout.deletionRoutes,
+        stranded: layout.stranded,
+        hiddenEdges: new Set(
+          o.showDeletionEdges ? [] : deletions.map((d) => d.edgeIndex)
+        )
+      })
+    );
+    const t = {
+      scaleX: axis.scaleX,
+      scaleY: axis.scaleY,
+      translateX: fit.translateX,
+      translateY: fit.translateY
+    };
+    renderer.updateTransform({ ...t, dpr: 1 });
+    renderer.render([1, 1, 1, 1]);
+    return markup() + overlays(highlight, t, w, h);
+  }
+  const parts = [];
+  let height;
+  if (panels) {
+    const place = facetCells(
+      panels.map((p) => p.walks[0].name),
+      facet.field || "walk",
+      facet.domain
+    );
+    const grid = facetGrid({
+      count: place.count,
+      bounds,
+      pixelRows,
+      width,
+      room,
+      columns: place.columns ?? facet.columns
+    });
+    panels.forEach((panel, i) => {
+      const cell = place.cells[i];
+      const x = cell % grid.columns * (grid.width + FACET_GAP_PX);
+      const y = Math.floor(cell / grid.columns) * (grid.height + FACET_TITLE_PX + FACET_GAP_PX);
+      const walk = panel.walks[0];
+      parts.push(
+        walkKeySvg(`key${i}`, x + 6, y + 2, walk, labelOf(walk.name), reference).markup,
+        `<svg x="${x}" y="${y + FACET_TITLE_PX}" width="${grid.width}" height="${grid.height}">${drawing(panel, grid.width, grid.height)}</svg>`
+      );
+    });
+    height = grid.total;
+  } else {
+    let x = 6;
+    const push = (key) => {
+      parts.push(key.markup);
+      x += key.width + KEY_GAP_PX;
+    };
+    if (lift) {
+      lift.walks.forEach((walk, i) => {
+        push(walkKeySvg(`key${i}`, x, 2, walk, labelOf(walk.name), reference));
+      });
+      push(
+        keySvg(
+          "faded",
+          x,
+          2,
+          [{ offset: 0, color: FADED }],
+          "",
+          `not on ${lift.walks.length === 1 ? labelOf(lift.walks[0].name) : "these walks"}`,
+          void 0,
+          0.3
+        )
+      );
+    }
+    if (rows) {
+      const key = walkRowsKeyTree(
+        walkRowsKey(rows, {
+          ramp: rampInterval,
+          genes: o.rowGenes?.size ? o.rowGeneGaps : void 0
+        }),
+        x,
+        2,
+        "rows-key"
+      );
+      push({ width: key.width, markup: serializeEl(key.tree) });
+    } else if (!lift && referenceRamp) {
+      push(
+        keySvg(
+          "ramp",
+          x,
+          2,
+          encodingStops({ field: "reference", scheme: "rainbow" }),
+          referenceName ? `${referenceName} position` : "Reference position",
+          "",
+          rangeText(
+            referenceName,
+            referenceRamp.start,
+            referenceRamp.start + referenceRamp.span
+          )
+        )
+      );
+    }
+    if (pins.some((pin) => pin.exonsByNode.length > 0)) {
+      push(exonKeySvg(x, 2));
+    }
+    const header = parts.length > 0 ? FACET_TITLE_PX : 0;
+    const usable = width - 2 * FIT_PADDING;
+    const drawn = pixelRows || !(bounds.w > 0) ? bounds.h : bounds.h * usable / bounds.w;
+    const h = Math.max(
+      160,
+      Math.min(room - header, Math.ceil(drawn + 2 * FIT_PADDING))
+    );
+    parts.push(
+      `<svg y="${header}" width="${width}" height="${h}">${drawing(lift, width, h)}</svg>`
+    );
+    height = header + h;
+  }
+  const strip = o.walkStrip;
+  if (strip && !rows && !layout.tubeMap) {
+    const frame = walkStripFrame(strip.rows, { width });
+    const key = walkRowsKeyTree(
+      walkRowsKey(strip.rows, {
+        ramp: rampInterval,
+        genes: stripGeneGaps(frame, strip.rowGenes, strip.rowGeneGaps)
+      }),
+      6,
+      height + frame.height,
+      "strip-key"
+    );
+    parts.push(
+      `<line x1="0" x2="${width}" y1="${height + 0.5}" y2="${height + 0.5}" stroke="#ddd"/>`,
+      `<svg y="${height}" width="${width}" height="${frame.height}">${serializeEl(
+        walkRowsTree(strip.rows, frame, {
+          ramp: rampInterval,
+          rowGenes: strip.rowGenes,
+          idPrefix: "strip"
+        })
+      )}${serializeEl(
+        walkStripLabelsTree(
+          strip.rows,
+          frame,
+          new Set(layers.map((l) => l.walk))
+        )
+      )}</svg>`,
+      serializeEl(key.tree)
+    );
+    height += frame.height + STRIP_KEY_PX;
+  }
+  const metadata = JSON.stringify({
+    generator: `@jbrowse/bandage-core@${version}`,
+    ...o.spec === void 0 ? {} : { spec: o.spec }
+  });
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><metadata>${esc(metadata)}</metadata><rect width="${width}" height="${height}" fill="#fff"/>${parts.join("")}</svg>
+`;
+}
+
+export {
+  figureSvg
+};

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