@jbrowse/bandage-core 6.0.0 → 6.0.2

package/dist/chunks/chunk-QCYM44UL.js

@@ -0,0 +1,476 @@
+import {
+  RAMP_GRADIENT_CSS,
+  RAMP_GRADIENT_STOPS,
+  rampHueCss,
+  rampStops
+} from "./chunk-5QT6NPSO.js";
+import {
+  REFERENCE_RAMP_ALT_CSS
+} from "./chunk-3WHKR5TY.js";
+import {
+  LABEL_CHAR_PX
+} from "./chunk-AB35TJST.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  el
+} from "./chunk-NNODIW4U.js";
+
+// src/layout/walkRowDraw.ts
+var ON_REFERENCE = "#2f8fd6";
+var OFF_REFERENCE = "#8e3fbf";
+var OUTSIDE_CUT = "#bdbdbd";
+var GENE_INK = "#1c1c22";
+var BAR_PX = 12;
+var GAP_PX = 4;
+var MIN_TILE_PX = 3;
+function kb(bp) {
+  return `${(bp / 1e3).toFixed(bp < 1e4 ? 1 : 0)} kb`;
+}
+function units(bp, unit) {
+  return unit ? ` \u2248 ${Math.round(bp / unit)} units` : "";
+}
+function walkRowReadout(row, reference, unit, call) {
+  const { bp, gapBp, complete } = row;
+  if (!reference) {
+    return `${kb(bp)}${units(bp, unit)}`;
+  }
+  const delta = bp - reference.bp;
+  const against = delta === 0 ? "" : ` (${delta > 0 ? "+" : "\u2212"}${kb(Math.abs(delta))})`;
+  const outside = gapBp > 0 ? ` \xB7 ${kb(gapBp)} outside the cut` : "";
+  const called = call ? ` \xB7 called ${kb(call.bp)}${call.spanningReads === 0 ? " \xB7 no spanning read" : ""}` : "";
+  return `${kb(bp)}${units(bp, unit)}${against}${outside}${complete ? "" : " \xB7 partial walk"}${called}`;
+}
+function readoutPlacement(text, endX, width) {
+  const x = endX + 6;
+  const fits = x + text.length * LABEL_CHAR_PX < width;
+  return fits ? { x, anchor: "start", halo: false } : { x: endX - 6, anchor: "end", halo: true };
+}
+function unitTicks(bp, unit, pxPerBp) {
+  if (unit * pxPerBp < MIN_TILE_PX) {
+    return [];
+  }
+  const ticks = [];
+  for (let k = unit; k < bp; k += unit) {
+    ticks.push(k);
+  }
+  return ticks;
+}
+function runPaint(run, ramp) {
+  if (run.gap) {
+    return { fill: OUTSIDE_CUT };
+  }
+  if (!ramp) {
+    return { fill: run.onReference ? ON_REFERENCE : OFF_REFERENCE };
+  }
+  if (run.referenceStart === void 0) {
+    return { fill: REFERENCE_RAMP_ALT_CSS };
+  }
+  const stops = rampStops({ ...run, start: run.referenceStart }, ramp);
+  return stops.length === 1 ? { fill: rampHueCss(stops[0]) } : { stops: stops.map(rampHueCss) };
+}
+function alongRow(axis, start, end) {
+  return axis.reversed ? { start: axis.start - end, end: axis.start - start } : { start: start - axis.start, end: end - axis.start };
+}
+function rowSpan(axis, bp) {
+  return axis.reversed ? { start: axis.start - bp, end: axis.start } : { start: axis.start, end: axis.start + bp };
+}
+function genesOnRow(row, genes) {
+  const contig = row.axis?.contig;
+  return genes.filter(
+    (g) => g.refName === contig || g.refName.endsWith(`#${contig}`)
+  );
+}
+function placeRowGenes(rows, byRow) {
+  const placed = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const genes = byRow.get(row.name);
+    if (!row.axis || !genes) {
+      continue;
+    }
+    const axis = row.axis;
+    const clip = ({ start, end }) => ({
+      start: Math.max(0, start),
+      end: Math.min(row.bp, end)
+    });
+    placed.set(
+      row.name,
+      genes.map((g) => ({
+        name: g.name,
+        ...clip(alongRow(axis, g.start, g.end)),
+        exons: g.exons.map((e) => clip(alongRow(axis, e.start, e.end))).filter((e) => e.end > e.start)
+      })).filter((g) => g.end > g.start).sort((a, b) => a.start - b.start)
+    );
+  }
+  return placed;
+}
+var GENE_FONT_PX = 9;
+var GENE_CHAR_PX = 5.2;
+var MIN_LETTERED_BAR_PX = 8;
+var genePad = (rowPx, barPx) => Math.min(2, (rowPx - barPx) / 2 - 1);
+function boxesGenes(rowPx, barPx) {
+  return genePad(rowPx, barPx) >= 1;
+}
+function rowGeneBoxes(genes, X, y, { rowPx = ROW_HEIGHT_PX, barPx = BAR_PX } = {}) {
+  if (!boxesGenes(rowPx, barPx)) {
+    return [];
+  }
+  const pad = genePad(rowPx, barPx);
+  const boxes = genes.map((g) => {
+    const x = X(g.start);
+    return {
+      g,
+      x,
+      w: Math.max(2, X(g.end) - x)
+    };
+  });
+  const taken = [];
+  const named = new Set(
+    (barPx >= MIN_LETTERED_BAR_PX ? [...boxes] : []).sort((a, b) => a.w - b.w).filter(({ g, x, w }) => {
+      const half = g.name.length * GENE_CHAR_PX / 2;
+      const at = [x + w / 2 - half, x + w / 2 + half];
+      if (2 * half > w + 6 || taken.some(([a, b]) => at[0] < b + 2 && at[1] > a - 2)) {
+        return false;
+      }
+      taken.push(at);
+      return true;
+    })
+  );
+  return boxes.map((box) => ({
+    name: box.g.name,
+    x: box.x,
+    y: y - barPx / 2 - pad,
+    w: box.w,
+    h: barPx + 2 * pad,
+    exons: box.g.exons.map((e) => ({
+      x: X(e.start),
+      w: Math.max(1, X(e.end) - X(e.start))
+    })),
+    label: named.has(box) ? { x: box.x + box.w / 2, y: y + 3, size: GENE_FONT_PX } : void 0
+  }));
+}
+var rowsText = (n) => `${n} row${n === 1 ? "" : "s"}`;
+function walkRowsKey(bars, o = {}) {
+  const entries = [
+    {
+      swatch: o.ramp ? { kind: "bar", fill: o.rampCss ?? RAMP_GRADIENT_CSS, ramp: true } : { kind: "bar", fill: ON_REFERENCE },
+      label: `on ${bars.reference.label}'s path`
+    },
+    {
+      swatch: {
+        kind: "bar",
+        fill: o.ramp ? REFERENCE_RAMP_ALT_CSS : OFF_REFERENCE
+      },
+      label: `off ${bars.reference.label}'s path`
+    }
+  ];
+  if ([bars.reference, ...bars.rows].some((row) => row.gapBp > 0)) {
+    entries.push({
+      swatch: { kind: "gap", fill: OUTSIDE_CUT },
+      label: "walked outside the cut"
+    });
+  }
+  if (o.genes?.crowded) {
+    entries.push({
+      swatch: { kind: "gene" },
+      label: "genes left out: too many rows to box them in",
+      note: true
+    });
+  } else if (o.genes) {
+    entries.push({
+      swatch: { kind: "gene" },
+      label: "genes, each row's own annotation"
+    });
+    if (o.genes.untracked) {
+      entries.push({
+        swatch: { kind: "gene" },
+        label: `no gene track for ${rowsText(o.genes.untracked)}`,
+        note: true
+      });
+    }
+    if (o.genes.unplaced) {
+      entries.push({
+        swatch: { kind: "gene" },
+        label: `no contig coordinates for ${rowsText(o.genes.unplaced)}`,
+        note: true
+      });
+    }
+    if (o.genes.unread) {
+      entries.push({
+        swatch: { kind: "gene" },
+        label: `genes not read for the last ${rowsText(o.genes.unread)}`,
+        note: true
+      });
+    }
+  }
+  return entries;
+}
+var CALL_TICK = "#111";
+var UNBACKED_TICK = "#9e9e9e";
+var DISAGREES = "#c62828";
+function walkRowsKeyTree(entries, x, y, idPrefix = "walk-key") {
+  let at = 0;
+  const parts = entries.flatMap((e, i) => {
+    const rampId = `${idPrefix}-ramp-${i}`;
+    const ramp = !e.note && e.swatch.kind === "bar" && e.swatch.ramp ? el(
+      "linearGradient",
+      { id: rampId },
+      ...RAMP_GRADIENT_STOPS.map(
+        (s) => el("stop", { offset: s.offset, "stop-color": s.color })
+      )
+    ) : void 0;
+    const swatch = e.note ? void 0 : e.swatch.kind === "gene" ? el("rect", {
+      x: at,
+      y: 5,
+      width: 18,
+      height: 8,
+      fill: "none",
+      stroke: GENE_INK,
+      "stroke-width": 1.5
+    }) : el("rect", {
+      x: at,
+      y: e.swatch.kind === "gap" ? 7 : 5,
+      width: 18,
+      height: e.swatch.kind === "gap" ? GAP_PX : 8,
+      rx: 2,
+      fill: ramp ? `url(#${rampId})` : e.swatch.fill
+    });
+    const text = el(
+      "text",
+      {
+        x: e.note ? at : at + 23,
+        y: 13,
+        "font-style": e.note ? "italic" : void 0,
+        fill: e.note ? "#666" : void 0
+      },
+      e.label
+    );
+    at += (e.note ? 0 : 23) + e.label.length * LABEL_CHAR_PX + 16;
+    return [ramp, swatch, text].filter((p) => p !== void 0);
+  });
+  return {
+    width: at,
+    tree: el(
+      "g",
+      {
+        transform: `translate(${x} ${y})`,
+        "font-family": "Helvetica, Arial, sans-serif",
+        "font-size": 11
+      },
+      ...parts
+    )
+  };
+}
+function coalesceRuns(runs, pxPerBp) {
+  const minBp = 1 / pxPerBp;
+  const out = [];
+  let bucket = [];
+  const flush = () => {
+    if (bucket.length === 0) {
+      return;
+    }
+    if (bucket.length === 1) {
+      out.push(bucket[0]);
+    } else {
+      let on = 0;
+      let off = 0;
+      for (const r of bucket) {
+        if (r.onReference) {
+          on += r.bp;
+        } else {
+          off += r.bp;
+        }
+      }
+      const onReference = on >= off;
+      const lead = bucket.find((r) => r.onReference === onReference);
+      out.push({
+        start: bucket[0].start,
+        bp: on + off,
+        onReference,
+        referenceStart: onReference ? lead.referenceStart : void 0,
+        ...lead.reversed ? { reversed: true } : {}
+      });
+    }
+    bucket = [];
+  };
+  let held = 0;
+  for (const run of runs) {
+    if (run.gap || run.bp >= minBp) {
+      flush();
+      held = 0;
+      out.push(run);
+      continue;
+    }
+    bucket.push(run);
+    held += run.bp;
+    if (held >= minBp) {
+      flush();
+      held = 0;
+    }
+  }
+  flush();
+  return out;
+}
+function geneTree(box, y, barPx) {
+  return el(
+    "g",
+    { class: "row-gene", "data-testid": "graph-walk-gene" },
+    el("title", {}, box.name),
+    ...box.exons.map(
+      (e) => el("rect", {
+        x: e.x,
+        y: y - barPx / 2,
+        width: e.w,
+        height: barPx,
+        fill: GENE_INK,
+        opacity: 0.35
+      })
+    ),
+    el("rect", {
+      x: box.x,
+      y: box.y,
+      width: box.w,
+      height: box.h,
+      fill: "none",
+      stroke: GENE_INK,
+      "stroke-width": 1.5
+    }),
+    box.label && el(
+      "text",
+      {
+        x: box.label.x,
+        y: box.label.y,
+        "font-family": "sans-serif",
+        "font-size": box.label.size,
+        "font-weight": 600,
+        "text-anchor": "middle",
+        fill: GENE_INK,
+        stroke: "white",
+        "stroke-width": 2.5,
+        "paint-order": "stroke"
+      },
+      box.name
+    )
+  );
+}
+function walkRowsTree(bars, frame, o = {}) {
+  const X = (bp) => bp * frame.scaleX + frame.translateX;
+  const rowPx = frame.rowPx ?? ROW_HEIGHT_PX;
+  const barPx = frame.barPx ?? BAR_PX;
+  const Y = (row) => row * rowPx * frame.scaleY + frame.translateY;
+  const { origin, unit, reference, rows } = bars;
+  const along = (offset) => X(origin + offset);
+  const prefix = o.idPrefix ?? "walkrow";
+  const rowTree = (row, i) => {
+    const y = Y(i);
+    if (y < -barPx || y > frame.height + barPx) {
+      return void 0;
+    }
+    const runs = coalesceRuns(row.runs, frame.scaleX).flatMap((run) => {
+      const paint = runPaint(run, o.ramp);
+      const h = run.gap ? Math.min(GAP_PX, barPx) : barPx;
+      const id = `${prefix}-${i}-${run.start}`;
+      const rect = el("rect", {
+        x: along(run.start),
+        y: y - h / 2,
+        width: Math.max(1, run.bp * frame.scaleX),
+        height: h,
+        fill: "stops" in paint ? `url(#${id})` : paint.fill
+      });
+      return "stops" in paint ? [
+        el(
+          "linearGradient",
+          { id },
+          ...paint.stops.map(
+            (color, k) => el("stop", {
+              offset: k / (paint.stops.length - 1),
+              "stop-color": color
+            })
+          )
+        ),
+        rect
+      ] : [rect];
+    });
+    const ticks = unit ? unitTicks(row.bp, unit, frame.scaleX).map(
+      (k) => el("line", {
+        x1: along(k),
+        x2: along(k),
+        y1: y - barPx / 2,
+        y2: y + barPx / 2,
+        stroke: "white",
+        "stroke-width": 1
+      })
+    ) : [];
+    const { call } = row;
+    const text = walkRowReadout(
+      row,
+      i === 0 ? void 0 : reference,
+      unit,
+      call
+    );
+    const at = readoutPlacement(text, along(row.bp), frame.width);
+    const readouts = frame.readouts ?? true;
+    return el(
+      "g",
+      {
+        "data-testid": i === 0 ? "graph-walk-reference" : "graph-walk-row"
+      },
+      ...runs,
+      ...ticks,
+      ...rowGeneBoxes(o.rowGenes?.get(row.name) ?? [], along, y, {
+        rowPx,
+        barPx
+      }).map((box) => geneTree(box, y, barPx)),
+      call && el("rect", {
+        "data-testid": "graph-walk-call",
+        x: along(call.bp) - 1,
+        y: y - barPx / 2 - 3,
+        width: 2,
+        height: barPx + 6,
+        fill: call.spanningReads === 0 ? UNBACKED_TICK : CALL_TICK
+      }),
+      readouts && el(
+        "text",
+        {
+          x: at.x,
+          y: y + 4,
+          "font-family": "sans-serif",
+          "font-size": 11,
+          fill: call?.agrees === false ? DISAGREES : "#333",
+          stroke: at.halo ? "white" : void 0,
+          "stroke-width": at.halo ? 3 : void 0,
+          "paint-order": "stroke",
+          "text-anchor": at.anchor
+        },
+        text
+      )
+    );
+  };
+  return el("g", {}, ...[reference, ...rows].map(rowTree));
+}
+
+export {
+  ON_REFERENCE,
+  OFF_REFERENCE,
+  OUTSIDE_CUT,
+  GENE_INK,
+  BAR_PX,
+  GAP_PX,
+  kb,
+  walkRowReadout,
+  readoutPlacement,
+  unitTicks,
+  runPaint,
+  alongRow,
+  rowSpan,
+  genesOnRow,
+  placeRowGenes,
+  boxesGenes,
+  rowGeneBoxes,
+  walkRowsKey,
+  DISAGREES,
+  walkRowsKeyTree,
+  coalesceRuns,
+  walkRowsTree
+};

package/dist/chunks/chunk-RAKOB6IV.js

@@ -0,0 +1,169 @@
+import {
+  isGenericSample,
+  panSNContig,
+  panSNHaplotype,
+  panSNSample
+} from "./chunk-BPLIXMH7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/reference.ts
+var WELL_KNOWN_SAMPLES = /* @__PURE__ */ new Map([
+  ["hg38", "GRCh38"],
+  ["hg19", "GRCh37"],
+  ["hs1", "CHM13"],
+  ["t2t-chm13", "CHM13"],
+  ["chm13v2", "CHM13"]
+]);
+function wellKnownSample(assemblyName) {
+  return WELL_KNOWN_SAMPLES.get(assemblyName.toLowerCase());
+}
+function sampleOf(refName) {
+  const sample = refName.includes("#") ? panSNSample(refName) : void 0;
+  return sample === void 0 || isGenericSample(sample) ? void 0 : sample;
+}
+function haplotypeOf(refName) {
+  return panSNHaplotype(refName) ?? panSNSample(refName);
+}
+function graphHaplotypes(graph) {
+  const refNames = new Set((graph.anchorPaths ?? []).map((p) => p.name));
+  for (const node of graph.nodes) {
+    if (node.stable) {
+      refNames.add(node.stable.refName);
+    }
+  }
+  const bySample = /* @__PURE__ */ new Map();
+  for (const refName of refNames) {
+    const sample = sampleOf(refName);
+    if (sample !== void 0) {
+      const haplotypes = bySample.get(sample) ?? bySample.set(sample, /* @__PURE__ */ new Set()).get(sample);
+      haplotypes.add(haplotypeOf(refName));
+    }
+  }
+  return bySample;
+}
+function backboneFrom(contigs, haplotypes) {
+  const samples = new Set(contigs.map((c) => sampleOf(c.refName)));
+  const [sample] = samples;
+  if (samples.size !== 1 || sample === void 0) {
+    return { contigs, prefixes: [], named: false };
+  }
+  const own = new Set(contigs.map((c) => haplotypeOf(c.refName)));
+  const unique = [...haplotypes.get(sample) ?? []].every((h) => own.has(h));
+  const shared = new Set(contigs.map((c) => panSNHaplotype(c.refName)));
+  const [haplotype] = shared;
+  return {
+    contigs,
+    prefixes: [
+      ...unique ? [sample] : [],
+      ...shared.size === 1 && haplotype ? [haplotype] : []
+    ],
+    named: true
+  };
+}
+function graphBackbone(graph) {
+  const spans = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      const { refName, start } = node.stable;
+      const end = start + node.length;
+      const span = spans.get(refName);
+      if (span) {
+        span.start = Math.min(span.start, start);
+        span.end = Math.max(span.end, end);
+      } else {
+        spans.set(refName, {
+          refName,
+          contig: panSNContig(refName),
+          start,
+          end
+        });
+      }
+    }
+  }
+  const contigs = [...spans.values()];
+  return contigs.length ? backboneFrom(contigs, graphHaplotypes(graph)) : void 0;
+}
+function referenceLabel(graph, region) {
+  const backbone = graphBackbone(graph);
+  const contig = region ? panSNContig(region.refName) : backbone?.contigs.length === 1 ? backbone.contigs[0].contig : void 0;
+  const sample = backbone?.named ? panSNSample(backbone.contigs[0].refName) : void 0;
+  return contig && (sample ? `${sample} ${contig}` : contig);
+}
+function backboneAssembly(backbone, assemblies) {
+  const names = (a) => [a.name, ...a.aliases ?? []];
+  const naming = (prefix) => (a) => names(a).some((n) => n.toLowerCase() === prefix.toLowerCase());
+  const prefixes = [...backbone?.prefixes ?? []].reverse();
+  const sample = backbone?.prefixes.find((p) => !p.includes("#"))?.toLowerCase();
+  for (const prefix of prefixes) {
+    const assembly = assemblies.find(naming(prefix));
+    if (assembly) {
+      return assembly;
+    }
+  }
+  return sample === void 0 ? void 0 : assemblies.find(
+    (a) => names(a).some((n) => wellKnownSample(n)?.toLowerCase() === sample)
+  );
+}
+function assemblyWalk(graph, assembly) {
+  const haplotypes = graphHaplotypes(graph);
+  return graph.anchorPaths?.find(
+    (walk) => backboneAssembly(
+      backboneFrom(
+        [
+          {
+            refName: walk.name,
+            contig: panSNContig(walk.name),
+            start: walk.start,
+            end: walk.start + walk.length
+          }
+        ],
+        haplotypes
+      ),
+      [assembly]
+    )
+  );
+}
+function contigNames(contig) {
+  const bare = contig.replace(/^chr/i, "");
+  const forms = !bare ? [] : /^(M|MT)$/i.test(bare) ? ["M", "MT"] : [bare];
+  return [.../* @__PURE__ */ new Set([contig, ...forms.flatMap((f) => [f, `chr${f}`])])];
+}
+function refNameBinding(refNames, aliases = {}) {
+  const exact = new Set(refNames);
+  const byName = /* @__PURE__ */ new Map();
+  for (const refName of exact) {
+    const contig = panSNContig(refName);
+    const alias = aliases[contig];
+    for (const name of /* @__PURE__ */ new Set([
+      ...contigNames(contig),
+      ...alias ? [alias] : []
+    ])) {
+      byName.set(name, byName.has(name) ? void 0 : refName);
+    }
+  }
+  return (name) => exact.has(name) ? name : byName.get(name);
+}
+function featuresOnBackbone(features, backbone, aliases) {
+  const bind = refNameBinding(
+    backbone.contigs.map((c) => c.refName),
+    aliases
+  );
+  return features.flatMap((f) => {
+    const refName = bind(f.refName);
+    return refName === void 0 ? [] : [refName === f.refName ? f : { ...f, refName }];
+  });
+}
+
+export {
+  WELL_KNOWN_SAMPLES,
+  wellKnownSample,
+  graphBackbone,
+  referenceLabel,
+  backboneAssembly,
+  assemblyWalk,
+  contigNames,
+  refNameBinding,
+  featuresOnBackbone
+};