@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-AB35TJST.js

@@ -0,0 +1,67 @@
+// src/overlayLabels.ts
+var LABEL_PX = 11;
+var LABEL_CHAR_PX = 6.2;
+var LABEL_PAD = 4;
+function labelWidth(text) {
+  return text.length * LABEL_CHAR_PX + LABEL_PAD * 2;
+}
+function overlaps(a, b) {
+  return a.x0 < b.x1 && a.x1 > b.x0 && a.y0 < b.y1 && a.y1 > b.y0;
+}
+function offFrame(box, frame) {
+  return box.x1 <= 0 || box.x0 >= frame.width || box.y1 <= 0 || box.y0 >= frame.height;
+}
+function insideFrame(box, frame) {
+  return box.x0 >= 0 && box.x1 <= frame.width && box.y0 >= 0 && box.y1 <= frame.height;
+}
+function occupancy(frame, reserved = []) {
+  const placed = [...reserved];
+  return (box) => {
+    if (offFrame(box, frame) || placed.some((p) => overlaps(p, box))) {
+      return false;
+    }
+    placed.push(box);
+    return true;
+  };
+}
+function placeLabels(candidates, frame, take) {
+  const out = [];
+  const row = LABEL_PX + LABEL_PAD * 2;
+  const place = (c, text) => {
+    const w = labelWidth(text);
+    const direction = c.y > frame.height / 2 ? -1 : 1;
+    for (let tries = 0; tries <= (c.stack ?? 0); tries++) {
+      const y = c.y + direction * tries * row;
+      const box = {
+        x0: c.x - w / 2,
+        x1: c.x + w / 2,
+        y0: y - LABEL_PX - LABEL_PAD,
+        y1: y + LABEL_PAD
+      };
+      if (offFrame(box, frame)) {
+        return void 0;
+      }
+      if (insideFrame(box, frame) && (c.fits?.(box) ?? true) && take(box)) {
+        return { ...c, text, y, w };
+      }
+    }
+    return void 0;
+  };
+  for (const c of candidates) {
+    const placed = place(c, c.text) ?? (c.fallback === void 0 ? void 0 : place(c, c.fallback));
+    if (placed) {
+      out.push(placed);
+    }
+  }
+  return out;
+}
+
+export {
+  LABEL_PX,
+  LABEL_CHAR_PX,
+  LABEL_PAD,
+  labelWidth,
+  overlaps,
+  occupancy,
+  placeLabels
+};

package/dist/chunks/chunk-BPLIXMH7.js

@@ -0,0 +1,52 @@
+// src/pansn.ts
+var SEP = "#";
+function panSNSample(refName) {
+  return refName.split(SEP)[0];
+}
+var GENERIC_SAMPLES = /* @__PURE__ */ new Set(["_gbwt_ref"]);
+function isGenericSample(sample) {
+  return GENERIC_SAMPLES.has(sample);
+}
+function panSNHaplotype(refName) {
+  const parts = refName.split(SEP);
+  return parts.length >= 3 ? `${parts[0]}${SEP}${parts[1]}` : void 0;
+}
+function panSNContig(refName) {
+  const parts = refName.split(SEP);
+  return parts.length >= 3 ? parts.slice(2).join(SEP) : parts.length === 2 ? parts[1] : refName;
+}
+function panSNMatchesPrefix(refName, prefix) {
+  return prefix !== void 0 && (refName === prefix || refName.startsWith(prefix + SEP));
+}
+function assemblyNameToPanSN(adapter) {
+  return adapter.getConf("assemblyNameToPanSN") ?? {};
+}
+function resolvePanSNPrefix(adapter, name) {
+  return name === void 0 ? void 0 : assemblyNameToPanSN(adapter)[name] ?? name;
+}
+var asmByPrefixCache = /* @__PURE__ */ new WeakMap();
+function assemblyByPanSNPrefix(adapter) {
+  let out = asmByPrefixCache.get(adapter);
+  if (out === void 0) {
+    const map = assemblyNameToPanSN(adapter);
+    out = {};
+    for (const asm of /* @__PURE__ */ new Set([
+      ...Object.keys(map),
+      ...adapter.getConf("assemblyNames")
+    ])) {
+      out[map[asm] ?? asm] = asm;
+    }
+    asmByPrefixCache.set(adapter, out);
+  }
+  return out;
+}
+
+export {
+  panSNSample,
+  isGenericSample,
+  panSNHaplotype,
+  panSNContig,
+  panSNMatchesPrefix,
+  resolvePanSNPrefix,
+  assemblyByPanSNPrefix
+};

package/dist/chunks/chunk-BUBZ32IC.js

@@ -0,0 +1,101 @@
+import {
+  polylineSlice
+} from "./chunk-TAMCZHLW.js";
+import {
+  svgPath
+} from "./chunk-2CVHXFK7.js";
+import {
+  firstNodeAtOrAfter,
+  isAnchored
+} from "./chunk-FYQWPEEY.js";
+
+// src/genes/genePins.ts
+function genePins(graph, genes, positions) {
+  const byRefName = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isAnchored(node)) {
+      const { refName } = node.stable;
+      if (positions[node.id]?.length) {
+        const entry = byRefName.get(refName) ?? byRefName.set(refName, { nodes: [], reach: 0 }).get(refName);
+        entry.nodes.push(node);
+        entry.reach = Math.max(entry.reach, node.length);
+      }
+    }
+  }
+  for (const { nodes } of byRefName.values()) {
+    nodes.sort((a, b) => a.stable.start - b.stable.start);
+  }
+  const pins = [];
+  for (const gene of genes) {
+    const onRefName = byRefName.get(gene.refName);
+    if (!onRefName) {
+      continue;
+    }
+    const parts = [];
+    const exonsByNode = [];
+    const nodeIds = /* @__PURE__ */ new Set();
+    let at;
+    let atDistance = Infinity;
+    let covered = 0;
+    const mid = (gene.start + gene.end) / 2;
+    const { nodes, reach } = onRefName;
+    for (let i = firstNodeAtOrAfter(nodes, gene.start - reach); i < nodes.length && nodes[i].stable.start < gene.end; i++) {
+      const node = nodes[i];
+      const nodeStart = node.stable.start;
+      const nodeEnd = nodeStart + node.length;
+      if (nodeEnd <= gene.start) {
+        continue;
+      }
+      const line = positions[node.id];
+      nodeIds.add(node.id);
+      covered += Math.min(nodeEnd, gene.end) - Math.max(nodeStart, gene.start);
+      const nodeParts = [];
+      for (const exon of gene.exons) {
+        const a = Math.max(exon.start, nodeStart);
+        const b = Math.min(exon.end, nodeEnd);
+        if (b <= a) {
+          continue;
+        }
+        const stretch = polylineSlice(
+          line,
+          (a - nodeStart) / node.length,
+          (b - nodeStart) / node.length
+        );
+        if (stretch.length === 1) {
+          stretch.push({ ...stretch[0] });
+        }
+        nodeParts.push(svgPath(stretch));
+      }
+      if (nodeParts.length > 0) {
+        parts.push(...nodeParts);
+        exonsByNode.push({ nodeId: node.id, d: nodeParts.join("") });
+      }
+      const pinBp = Math.min(Math.max(mid, nodeStart), nodeEnd);
+      const distance = Math.abs(pinBp - mid);
+      if (distance < atDistance) {
+        atDistance = distance;
+        const [p] = polylineSlice(
+          line,
+          (pinBp - nodeStart) / node.length,
+          (pinBp - nodeStart) / node.length
+        );
+        at = p;
+      }
+    }
+    if (at) {
+      pins.push({
+        gene,
+        exons: parts.join(""),
+        exonsByNode,
+        nodeIds,
+        at,
+        covered: covered / (gene.end - gene.start)
+      });
+    }
+  }
+  return pins;
+}
+
+export {
+  genePins
+};

package/dist/chunks/chunk-BXEPA4KS.js

@@ -0,0 +1,179 @@
+// src/genes/geneFiles.ts
+var GENE_TYPE = /(gene|gene_segment|RNA|transcript)$/i;
+var isGene = (type) => GENE_TYPE.test(type) || type === "CDS" || type === "exon";
+function mergedIntervals(intervals) {
+  const out = [];
+  for (const iv of [...intervals].sort((a, b) => a.start - b.start)) {
+    const last = out.at(-1);
+    if (last && iv.start <= last.end) {
+      last.end = Math.max(last.end, iv.end);
+    } else {
+      out.push({ ...iv });
+    }
+  }
+  return out;
+}
+function strandOf(s) {
+  return s === "+" ? 1 : s === "-" ? -1 : 0;
+}
+function unescape(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function attributes(column) {
+  const out = /* @__PURE__ */ new Map();
+  for (const pair of column.split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) {
+      out.set(pair.slice(0, eq).trim(), unescape(pair.slice(eq + 1).trim()));
+    }
+  }
+  return out;
+}
+function gff3Row(line) {
+  const cols = line.split("	");
+  const start = Number(cols[3]);
+  const end = Number(cols[4]);
+  if (cols.length < 9 || !Number.isInteger(start) || !Number.isInteger(end)) {
+    return void 0;
+  }
+  return {
+    refName: cols[0],
+    type: cols[2],
+    start: start - 1,
+    end,
+    strand: strandOf(cols[6]),
+    attrs: attributes(cols[8])
+  };
+}
+function genesFromGff3Lines(lines) {
+  const rows = [];
+  for (const line of lines) {
+    if (line.startsWith("##FASTA")) {
+      break;
+    }
+    const row = line.startsWith("#") ? void 0 : gff3Row(line);
+    if (row) {
+      rows.push(row);
+    }
+  }
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const { attrs } of rows) {
+    const id = attrs.get("ID");
+    const parent = attrs.get("Parent")?.split(",")[0];
+    if (id && parent) {
+      parentOf.set(id, parent);
+    }
+  }
+  const rootOf = (row) => {
+    let id = row.attrs.get("Parent")?.split(",")[0] ?? row.attrs.get("ID");
+    if (!id) {
+      return row.attrs.get("gene_id");
+    }
+    const seen = /* @__PURE__ */ new Set();
+    while (id && parentOf.has(id) && !seen.has(id)) {
+      seen.add(id);
+      id = parentOf.get(id);
+    }
+    return id;
+  };
+  const groups = /* @__PURE__ */ new Map();
+  rows.forEach((row, i) => {
+    const root = rootOf(row) ?? `#${i}`;
+    const key = `${row.refName}	${root}`;
+    const group = groups.get(key) ?? groups.set(key, { rows: [] }).get(key);
+    group.rows.push(row);
+    if (!row.attrs.has("Parent") && !group.top) {
+      group.top = row;
+    }
+  });
+  const genes = [];
+  for (const [key, { top, rows: rows2 }] of groups) {
+    if (top && !isGene(top.type)) {
+      continue;
+    }
+    const first = top ?? rows2[0];
+    const start = top?.start ?? Math.min(...rows2.map((r) => r.start));
+    const end = top?.end ?? Math.max(...rows2.map((r) => r.end));
+    const a = first.attrs;
+    const spans = (type) => rows2.filter((r) => r.type === type).map((r) => ({ start: r.start, end: r.end }));
+    const exons = spans("exon");
+    const coding = spans("CDS");
+    const transcribed = rows2.some(
+      (r) => r !== top && r.type !== "exon" && r.type !== "CDS"
+    );
+    genes.push({
+      name: a.get("Name") ?? a.get("gene_name") ?? a.get("gene") ?? a.get("gene_id") ?? key.split("	")[1],
+      refName: first.refName,
+      start,
+      end,
+      strand: first.strand,
+      // A range read holds only the rows over its window, so a gene with
+      // transcripts but no exon or CDS there is intronic in it. Only a gene
+      // with no transcripts, as a bacterium's gene and CDS, is one exon.
+      exons: exons.length ? mergedIntervals(exons) : transcribed ? mergedIntervals(coding) : [{ start, end }]
+    });
+  }
+  return genes;
+}
+function mergeOverlappingByName(genes) {
+  const out = [];
+  const open = /* @__PURE__ */ new Map();
+  for (const g of [...genes].sort((a, b) => a.start - b.start)) {
+    const key = `${g.refName}	${g.strand}	${g.name}`;
+    const last = open.get(key);
+    if (last && g.start < last.end) {
+      last.end = Math.max(last.end, g.end);
+      last.exons = mergedIntervals([...last.exons, ...g.exons]);
+    } else {
+      const gene = { ...g, exons: mergedIntervals(g.exons) };
+      out.push(gene);
+      open.set(key, gene);
+    }
+  }
+  return out;
+}
+function genesFromBed(text) {
+  const rows = [];
+  for (const line of text.split("\n")) {
+    const cols = line.replace(/\r$/, "").split("	");
+    const start = Number(cols[1]);
+    const end = Number(cols[2]);
+    if (/^(#|track|browser)/.test(line) || cols.length < 3 || !Number.isInteger(start) || !(end > start)) {
+      continue;
+    }
+    const refName = cols[0];
+    const name = cols[3] && cols[3] !== "." ? cols[3] : `${refName}:${start + 1}-${end}`;
+    const sizes = cols[10]?.split(",").filter((s) => s !== "").map(Number);
+    const starts = cols[11]?.split(",").filter((s) => s !== "").map(Number);
+    const blocks = sizes?.length && sizes.length === starts?.length ? sizes.map((size, i) => ({
+      start: start + starts[i],
+      end: start + starts[i] + size
+    })) : [{ start, end }];
+    rows.push({
+      name,
+      refName,
+      start,
+      end,
+      strand: strandOf(cols[5]),
+      exons: blocks
+    });
+  }
+  return mergeOverlappingByName(rows);
+}
+function genesFromText(text) {
+  const first = text.split("\n", 1e3).find((l) => l.trim() !== "" && !/^(#|track|browser)/.test(l));
+  const cols = first?.split("	") ?? [];
+  return /^\d+$/.test(cols[1] ?? "") && /^\d+$/.test(cols[2] ?? "") ? genesFromBed(text) : genesFromGff3Lines(text.split(/\r?\n/));
+}
+
+export {
+  mergedIntervals,
+  genesFromGff3Lines,
+  mergeOverlappingByName,
+  genesFromBed,
+  genesFromText
+};

package/dist/chunks/chunk-C44YRP5F.js

@@ -0,0 +1,85 @@
+// src/gaf/parseGaf.ts
+var STEP = /([><])([^><]+)/g;
+function parseGafPath(column) {
+  if (!column.startsWith(">") && !column.startsWith("<")) {
+    return void 0;
+  }
+  const steps = [];
+  for (const [, arrow, name] of column.matchAll(STEP)) {
+    steps.push({ name, strand: arrow === ">" ? "+" : "-" });
+  }
+  return steps;
+}
+function parseGafLine(line) {
+  const columns = line.split("	");
+  if (columns.length < 12 || line.startsWith("#")) {
+    return void 0;
+  }
+  const path = parseGafPath(columns[5]);
+  if (!path) {
+    return void 0;
+  }
+  let cs;
+  let secondary = false;
+  for (let i = 12; i < columns.length; i++) {
+    const tag = columns[i];
+    if (tag.startsWith("cs:Z:")) {
+      cs = tag.slice(5);
+    } else if (tag === "tp:A:S") {
+      secondary = true;
+    }
+  }
+  return {
+    name: columns[0],
+    queryLength: +columns[1],
+    queryStart: +columns[2],
+    queryEnd: +columns[3],
+    strand: columns[4] === "-" ? "-" : "+",
+    path,
+    pathLength: +columns[6],
+    pathStart: +columns[7],
+    pathEnd: +columns[8],
+    matches: +columns[9],
+    blockLength: +columns[10],
+    mappingQuality: +columns[11],
+    secondary,
+    ...cs === void 0 ? {} : { cs }
+  };
+}
+function parseGaf(text) {
+  const records = [];
+  for (const line of text.split("\n")) {
+    const record = parseGafLine(line.trimEnd());
+    if (record) {
+      records.push(record);
+    }
+  }
+  return records;
+}
+var CS_OP = /:(\d+)|=([A-Za-z]+)|\*[a-zA-Z]([a-zA-Z])|\+([A-Za-z]+)|-([A-Za-z]+)|~[a-z]{2}(\d+)[a-z]{2}/g;
+function parseCs(cs) {
+  const ops = [];
+  for (const m of cs.matchAll(CS_OP)) {
+    if (m[1] !== void 0) {
+      ops.push({ op: "match", length: +m[1] });
+    } else if (m[2] !== void 0) {
+      ops.push({ op: "match", length: m[2].length });
+    } else if (m[3] !== void 0) {
+      ops.push({ op: "substitution", seq: m[3].toUpperCase() });
+    } else if (m[4] !== void 0) {
+      ops.push({ op: "insertion", seq: m[4].toUpperCase() });
+    } else if (m[5] !== void 0) {
+      ops.push({ op: "deletion", length: m[5].length });
+    } else if (m[6] !== void 0) {
+      ops.push({ op: "match", length: +m[6] });
+    }
+  }
+  return ops;
+}
+
+export {
+  parseGafPath,
+  parseGafLine,
+  parseGaf,
+  parseCs
+};

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-CJ2EE4AF.js

@@ -0,0 +1,40 @@
+import {
+  REFERENCE_RAMP_MAX_HUE
+} from "./chunk-PCZ4PTYC.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-CPMHA4W5.js

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