@jbrowse/bandage-core 6.0.1 → 6.0.2

package/dist/chunks/chunk-MNUSQCLG.js

@@ -0,0 +1,29 @@
+// src/renderer/colorBits.ts
+import {
+  abgrAlpha,
+  abgrBlue,
+  abgrGreen,
+  abgrRed,
+  packAbgr
+} from "@jbrowse/core/util/colorBits";
+function fadeAbgr(c, alpha) {
+  return packAbgr(
+    abgrRed(c),
+    abgrGreen(c),
+    abgrBlue(c),
+    Math.round(abgrAlpha(c) * alpha)
+  );
+}
+function brightenAbgr(c, factor) {
+  return packAbgr(
+    Math.min(255, Math.round(abgrRed(c) * factor)),
+    Math.min(255, Math.round(abgrGreen(c) * factor)),
+    Math.min(255, Math.round(abgrBlue(c) * factor)),
+    abgrAlpha(c)
+  );
+}
+
+export {
+  fadeAbgr,
+  brightenAbgr
+};

package/dist/chunks/chunk-NNODIW4U.js

@@ -0,0 +1,26 @@
+// src/el.ts
+function el(tag, attrs = {}, ...children) {
+  return {
+    tag,
+    attrs,
+    children: children.filter((c) => !!c || c === "")
+  };
+}
+function escapeText(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttr(s) {
+  return escapeText(s).replaceAll('"', "&quot;");
+}
+function serializeEl(node) {
+  if (typeof node === "string") {
+    return escapeText(node);
+  }
+  const attrs = Object.entries(node.attrs).filter(([, v]) => v !== void 0).map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("");
+  return `<${node.tag}${attrs}>${node.children.map(serializeEl).join("")}</${node.tag}>`;
+}
+
+export {
+  el,
+  serializeEl
+};

package/dist/chunks/chunk-P7B3GDAY.js

@@ -0,0 +1,232 @@
+import {
+  canonicalStrand,
+  readColor,
+  stepName,
+  tubeMapReads
+} from "./chunk-TEDQJPMI.js";
+import {
+  pathCssColor,
+  pathGreyCssColor
+} from "./chunk-7CHJKABZ.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/tubeMapLayout.ts
+import { layoutTubeMap } from "@gmod/tubemap-core";
+function visitStrands(graph) {
+  const strands = /* @__PURE__ */ new Map();
+  for (const [segment, visits] of graph.pathVisits ?? []) {
+    for (const visit of visits) {
+      const key = `${visit.path}	${segment}`;
+      const list = strands.get(key);
+      if (list) {
+        list.push(visit.strand);
+      } else {
+        strands.set(key, [visit.strand]);
+      }
+    }
+  }
+  return strands;
+}
+function tubeMapTracks(graph) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const strands = visitStrands(graph);
+  const paths = (graph.paths ?? []).map((path, index) => ({ path, index }));
+  const reference = paths.findIndex(
+    (p) => pathOrigin(p.path.name).name === graph.referencePath
+  );
+  if (reference > 0) {
+    paths.unshift(...paths.splice(reference, 1));
+  }
+  return paths.flatMap(({ path, index }) => {
+    const visitName = pathOrigin(path.name).name;
+    const seen = /* @__PURE__ */ new Map();
+    const sequence = path.nodeIds.flatMap((id) => {
+      const node = nodeById.get(id);
+      if (!node) {
+        return [];
+      }
+      const k = seen.get(node.name) ?? 0;
+      seen.set(node.name, k + 1);
+      const strand = strands.get(`${visitName}	${node.name}`)?.[k] ?? canonicalStrand(node);
+      return [stepName(node, strand)];
+    });
+    return sequence.length > 0 ? [
+      {
+        id: index,
+        name: path.name,
+        sequence,
+        sourceTrackID: 0,
+        type: "haplotype"
+      }
+    ] : [];
+  });
+}
+function tubeMapNodes(graph) {
+  return graph.nodes.map((n) => ({
+    name: n.id,
+    seq: "",
+    sequenceLength: Math.max(1, n.length)
+  }));
+}
+function hasTubeMapPaths(graph) {
+  return (graph.paths?.length ?? 0) > 0;
+}
+var STACK_PX = 600;
+var MIN_TUBE_PX = 3;
+var MAX_TUBE_PX = 15;
+function tubeWidth(trackCount) {
+  return Math.max(
+    MIN_TUBE_PX,
+    Math.min(MAX_TUBE_PX, Math.floor(STACK_PX / Math.max(1, trackCount)))
+  );
+}
+function runTubeMap(graph) {
+  const paths = graph.paths ?? [];
+  const tracks = tubeMapTracks(graph);
+  const reads = graph.reads ? tubeMapReads(graph, graph.reads, paths.length) : [];
+  const tubeColor = reads.length > 0 ? pathGreyCssColor : pathCssColor;
+  const pathColors = paths.map((_, i) => tubeColor(i, paths.length));
+  const layout = layoutTubeMap(tubeMapNodes(graph), tracks, reads, {
+    nodeWidthOption: "compressed",
+    trackWidth: tubeWidth(tracks.length),
+    trackColor: (track) => track.type === "read" ? readColor(track) : pathColors[track.id]
+  });
+  return layout ? { layout, pathColors } : void 0;
+}
+function drawnNodes(layout) {
+  const nodes = [];
+  layout.nodes.forEach((node) => {
+    if (node.order >= 0) {
+      nodes.push(node);
+    }
+  });
+  return nodes;
+}
+function centreline(node, yOffset, x0, x1) {
+  const y = node.y + node.contentHeight / 2 - yOffset;
+  return [
+    { x: x0, y },
+    { x: x1, y }
+  ];
+}
+function extentOf(layout, yOffset) {
+  return {
+    minY: layout.bounds.minY - yOffset,
+    maxY: layout.bounds.maxY - yOffset
+  };
+}
+function tubeMapLayout(graph) {
+  const run = hasTubeMapPaths(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, pathColors } = run;
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    nodePositions[node.name] = centreline(
+      node,
+      yOffset,
+      node.x,
+      node.x + node.pixelWidth
+    );
+  }
+  const { minY, maxY } = extentOf(layout, yOffset);
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, pathColors },
+    extent: {
+      minX: layout.bounds.minX,
+      maxX: layout.bounds.maxX,
+      minY,
+      maxY
+    }
+  };
+}
+function tubeMapColumns(graph, layout) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const byOrder = /* @__PURE__ */ new Map();
+  for (const node of drawnNodes(layout)) {
+    const list = byOrder.get(node.order);
+    if (list) {
+      list.push(node);
+    } else {
+      byOrder.set(node.order, [node]);
+    }
+  }
+  const columns = [];
+  let end = -Infinity;
+  for (const order of [...byOrder.keys()].sort((a, b) => a - b)) {
+    const nodes = byOrder.get(order);
+    let bp0 = Infinity;
+    let bp1 = -Infinity;
+    for (const node of nodes) {
+      const graphNode = nodeById.get(node.name);
+      if (graphNode && isBackbone(graphNode)) {
+        bp0 = Math.min(bp0, graphNode.stable.start);
+        bp1 = Math.max(bp1, graphNode.stable.start + node.sequenceLength);
+      }
+    }
+    if (bp0 === Infinity) {
+      bp0 = bp1 = end;
+    }
+    if (bp0 < end) {
+      bp0 = end;
+      bp1 = Math.max(end, bp1);
+    }
+    end = Math.max(end, bp1);
+    columns.push({
+      order,
+      x0: Math.min(...nodes.map((n) => n.x)),
+      x1: Math.max(...nodes.map((n) => n.x + n.pixelWidth)),
+      bp0,
+      bp1
+    });
+  }
+  const first = columns.find((c) => c.bp0 !== -Infinity);
+  for (const column of columns) {
+    if (column.bp0 === -Infinity) {
+      column.bp0 = column.bp1 = first?.bp0 ?? 0;
+    }
+  }
+  return columns;
+}
+function pathsReachBackbone(graph) {
+  return graph.nodes.some(isBackbone) && hasTubeMapPaths(graph);
+}
+function tubeMapReferenceLayout(graph) {
+  const run = pathsReachBackbone(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, pathColors } = run;
+  const columns = tubeMapColumns(graph, layout);
+  const byOrder = new Map(columns.map((c) => [c.order, c]));
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    const column = byOrder.get(node.order);
+    nodePositions[node.name] = centreline(node, yOffset, column.bp0, column.bp1);
+  }
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, columns, pathColors },
+    referenceAxis: true,
+    pixelRows: true,
+    extent: extentOf(layout, yOffset)
+  };
+}
+
+export {
+  visitStrands,
+  tubeMapTracks,
+  hasTubeMapPaths,
+  tubeWidth,
+  tubeMapLayout,
+  tubeMapReferenceLayout
+};

package/dist/chunks/chunk-PBENCR5L.js

@@ -0,0 +1,60 @@
+// src/nodeWidths.ts
+var NODE_WIDTHS = [
+  {
+    value: "depth",
+    label: "By depth",
+    description: "Thicker the more paths carry a node, on the square root of its depth against the mean. A graph with one depth everywhere draws uniform."
+  },
+  {
+    value: "uniform",
+    label: "Uniform",
+    description: "Every node the same thickness."
+  }
+];
+var NODE_WIDTH_VALUES = NODE_WIDTHS.map((w) => w.value);
+var MIN_FACTOR = 0.3;
+var MAX_FACTOR = 3;
+function meanDepth(graph) {
+  let weighted = 0;
+  let length = 0;
+  for (const node of graph.nodes) {
+    weighted += node.depth * node.length;
+    length += node.length;
+  }
+  return length > 0 ? weighted / length : 0;
+}
+function depthWidthFactor(node, mean) {
+  if (!(mean > 0) || !(node.depth > 0)) {
+    return 1;
+  }
+  return Math.min(
+    MAX_FACTOR,
+    Math.max(MIN_FACTOR, Math.sqrt(node.depth / mean))
+  );
+}
+function nodeWidthPx(node, contigThickness, nodeWidth, mean) {
+  return contigThickness * (nodeWidth === "depth" ? depthWidthFactor(node, mean) : 1);
+}
+function maxNodeWidthPx(contigThickness, nodeWidth) {
+  return contigThickness * (nodeWidth === "depth" ? MAX_FACTOR : 1);
+}
+function nodeInk(graph, nodeById, contigThickness, nodeWidth) {
+  const mean = graph ? meanDepth(graph) : 0;
+  return {
+    maxHalfWidthPx: maxNodeWidthPx(contigThickness, nodeWidth) / 2,
+    halfWidthPx: (id) => {
+      const node = nodeById?.get(id);
+      return node ? nodeWidthPx(node, contigThickness, nodeWidth, mean) / 2 : contigThickness / 2;
+    }
+  };
+}
+
+export {
+  NODE_WIDTHS,
+  NODE_WIDTH_VALUES,
+  meanDepth,
+  depthWidthFactor,
+  nodeWidthPx,
+  maxNodeWidthPx,
+  nodeInk
+};

package/dist/chunks/chunk-PUG7LXDF.js

@@ -0,0 +1,70 @@
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/orientToReference.ts
+function orientToReference(graph, positions) {
+  const backbone = graph.nodes.filter(
+    (node) => isBackbone(node) && (positions[node.id]?.length ?? 0) > 0
+  );
+  if (backbone.length < 2) {
+    return positions;
+  }
+  const points = backbone.map((node) => {
+    const segments = positions[node.id];
+    const mid = segments[Math.floor(segments.length / 2)];
+    return {
+      x: mid.x,
+      y: mid.y,
+      r: node.stable.start + node.length / 2,
+      w: node.length
+    };
+  });
+  const weight = points.reduce((sum, p) => sum + p.w, 0);
+  const cx = points.reduce((sum, p) => sum + p.x * p.w, 0) / weight;
+  const cy = points.reduce((sum, p) => sum + p.y * p.w, 0) / weight;
+  const cr = points.reduce((sum, p) => sum + p.r * p.w, 0) / weight;
+  let sxr = 0;
+  let syr = 0;
+  for (const p of points) {
+    sxr += p.w * (p.x - cx) * (p.r - cr);
+    syr += p.w * (p.y - cy) * (p.r - cr);
+  }
+  const angle = -Math.atan2(syr, sxr);
+  const c = Math.cos(angle);
+  const s = Math.sin(angle);
+  const out = {};
+  for (const [id, segments] of Object.entries(positions)) {
+    out[id] = segments.map((p) => {
+      const x = p.x - cx;
+      const y = p.y - cy;
+      return { x: cx + c * x - s * y, y: cy + s * x + c * y };
+    });
+  }
+  let below = 0;
+  let above = 0;
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      continue;
+    }
+    for (const p of out[node.id] ?? []) {
+      if (p.y > cy) {
+        below++;
+      } else {
+        above++;
+      }
+    }
+  }
+  if (above > below) {
+    for (const segments of Object.values(out)) {
+      for (const p of segments) {
+        p.y = 2 * cy - p.y;
+      }
+    }
+  }
+  return out;
+}
+
+export {
+  orientToReference
+};

package/dist/chunks/chunk-Q3KCTA4N.js

@@ -0,0 +1,202 @@
+import {
+  formatBp
+} from "./chunk-HCANBJDD.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/tubeMap/axis.ts
+function referenceBoxes(graph, layout) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const byRefName = /* @__PURE__ */ new Map();
+  layout.nodes.forEach((node) => {
+    const graphNode = nodeById.get(node.name);
+    if (node.order >= 0 && graphNode && isBackbone(graphNode)) {
+      const { refName, start } = graphNode.stable;
+      const boxes = byRefName.get(refName) ?? byRefName.set(refName, []).get(refName);
+      boxes.push({
+        bp0: start,
+        bp1: start + node.sequenceLength,
+        x0: node.x,
+        x1: node.x + node.pixelWidth
+      });
+    }
+  });
+  for (const boxes of byRefName.values()) {
+    boxes.sort((a, b) => a.bp0 - b.bp0);
+  }
+  return byRefName;
+}
+function tubeX(boxes, bp, isEnd = false) {
+  let lo = 0;
+  let hi = boxes.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const bp1 = boxes[mid].bp1;
+    if (isEnd ? bp1 < bp : bp1 <= bp) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  const box = boxes[lo];
+  if (bp <= box.bp0) {
+    return box.x0;
+  }
+  const span = box.bp1 - box.bp0;
+  return span > 0 ? box.x0 + (Math.min(bp, box.bp1) - box.bp0) / span * (box.x1 - box.x0) : box.x0;
+}
+function tubeSpan(boxes, start, end) {
+  const a = tubeX(boxes, start);
+  const b = tubeX(boxes, end, true);
+  return { x0: Math.min(a, b), x1: Math.max(a, b) };
+}
+function rulerBoxes(byRefName) {
+  let best;
+  for (const boxes of byRefName.values()) {
+    if (!best || boxes.length > best.length) {
+      best = boxes;
+    }
+  }
+  return best;
+}
+var TICK_PX = 5;
+var LABEL_GAP_PX = 10;
+var TARGET_TICK_PX = 110;
+var MIN_BRACKET_PX = 3;
+function rulerInk(darkMode) {
+  return darkMode ? "#b0b0b8" : "#55555c";
+}
+function niceStep(raw) {
+  const pow = 10 ** Math.floor(Math.log10(raw));
+  const m = raw / pow;
+  return (m <= 1 ? 1 : m <= 2 ? 2 : m <= 5 ? 5 : 10) * pow;
+}
+function placeLabels(candidates) {
+  const placed = [];
+  for (const a of candidates) {
+    if (placed.every(
+      (b) => Math.abs(a.at - b.at) >= (a.width + b.width) / 2 + LABEL_GAP_PX
+    )) {
+      placed.push(a);
+    }
+  }
+  return placed.map(({ text, at }) => ({ text, at }));
+}
+function scaleMarks(boxes, x, width, measure) {
+  const first = boxes[0];
+  const last = boxes.at(-1);
+  if (!first || !last) {
+    return void 0;
+  }
+  const from = x(first.x0);
+  const to = x(last.x1);
+  const bpSpan = last.bp1 - first.bp0;
+  if (to <= from || bpSpan <= 0) {
+    return void 0;
+  }
+  const step = niceStep(bpSpan / (to - from) * TARGET_TICK_PX);
+  const ticks = [];
+  const positions = [];
+  for (let bp = Math.ceil(first.bp0 / step) * step; bp <= last.bp1; bp += step) {
+    const sx = Math.round(x(tubeX(boxes, bp))) + 0.5;
+    if (sx >= 0 && sx <= width) {
+      ticks.push(sx);
+      const text = bp.toLocaleString("en-US");
+      positions.push({ text, at: sx, width: measure(text) });
+    }
+  }
+  return {
+    spans: [{ x0: from, x1: to }],
+    ticks,
+    labels: placeLabels(positions)
+  };
+}
+function boxMarks(boxes, x, width, measure) {
+  const shown = boxes.map((box) => ({ box, s0: x(box.x0), s1: x(box.x1) })).filter(({ s0, s1 }) => s1 >= 0 && s0 <= width);
+  const first = shown[0];
+  const last = shown.at(-1);
+  if (!first || !last) {
+    return void 0;
+  }
+  const label = (text, at) => ({
+    text,
+    at,
+    width: measure(text)
+  });
+  const position = (bp, at) => label(bp.toLocaleString("en-US"), at);
+  const spans = [];
+  const ticks = [];
+  const lengths = [];
+  const boundaries = [];
+  for (const { box, s0, s1 } of shown) {
+    spans.push({ x0: s0, x1: s1 });
+    ticks.push(Math.round(s0) + 0.5);
+    if (s1 - s0 >= MIN_BRACKET_PX) {
+      ticks.push(Math.round(s1) + 0.5);
+    }
+    const length = label(formatBp(box.bp1 - box.bp0), (s0 + s1) / 2);
+    if (length.width <= s1 - s0) {
+      lengths.push(length);
+    }
+    if (box !== first.box) {
+      boundaries.push(position(box.bp0, s0));
+    }
+  }
+  const ends = [
+    position(first.box.bp0, first.s0),
+    position(last.box.bp1, last.s1)
+  ];
+  return {
+    spans,
+    ticks,
+    labels: placeLabels([...ends, ...lengths, ...boundaries])
+  };
+}
+function rulerMarks(boxes, x, width, measure, referenceAxis = false) {
+  return (referenceAxis ? scaleMarks : boxMarks)(boxes, x, width, measure);
+}
+function drawTubeMapRuler(ctx, boxes, frame, top, referenceAxis = false) {
+  const { x, width, darkMode } = frame;
+  ctx.font = "10px sans-serif";
+  const marks = rulerMarks(
+    boxes,
+    x,
+    width,
+    (text) => ctx.measureText(text).width,
+    referenceAxis
+  );
+  if (!marks) {
+    return;
+  }
+  const ink = rulerInk(darkMode);
+  const y = top + 0.5;
+  ctx.strokeStyle = ink;
+  ctx.fillStyle = ink;
+  ctx.lineWidth = 1;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "top";
+  ctx.beginPath();
+  for (const { x0, x1 } of marks.spans) {
+    ctx.moveTo(Math.max(0, x0), y);
+    ctx.lineTo(Math.min(width, x1), y);
+  }
+  for (const sx of marks.ticks) {
+    ctx.moveTo(sx, top);
+    ctx.lineTo(sx, top + TICK_PX);
+  }
+  ctx.stroke();
+  for (const { text, at } of marks.labels) {
+    ctx.fillText(text, at, top + TICK_PX + 2);
+  }
+}
+
+export {
+  referenceBoxes,
+  tubeX,
+  tubeSpan,
+  rulerBoxes,
+  rulerInk,
+  rulerMarks,
+  drawTubeMapRuler
+};