@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/referenceStrip.js

@@ -0,0 +1,35 @@
+import {
+  REFERENCE_STRIP_PX,
+  REFERENCE_STRIP_ZONE_PX,
+  drawReferenceStrip,
+  nodeAnchor,
+  referenceStripBlocks,
+  stripBlockAt,
+  stripOverhang,
+  stripPixels
+} from "./chunks/chunk-EK4HGYO7.js";
+import "./chunks/chunk-PCZ4PTYC.js";
+import "./chunks/chunk-MNUSQCLG.js";
+import "./chunks/chunk-Y3IOTZJA.js";
+import "./chunks/chunk-X5L37W4J.js";
+import "./chunks/chunk-ST2IBUAN.js";
+import "./chunks/chunk-ES2N6V56.js";
+import "./chunks/chunk-N62KBLFC.js";
+import "./chunks/chunk-AB35TJST.js";
+import "./chunks/chunk-TAMCZHLW.js";
+import "./chunks/chunk-PBENCR5L.js";
+import "./chunks/chunk-4EMPBO7S.js";
+import "./chunks/chunk-2CVHXFK7.js";
+import "./chunks/chunk-CPMHA4W5.js";
+import "./chunks/chunk-BPLIXMH7.js";
+import "./chunks/chunk-FYQWPEEY.js";
+export {
+  REFERENCE_STRIP_PX,
+  REFERENCE_STRIP_ZONE_PX,
+  drawReferenceStrip,
+  nodeAnchor,
+  referenceStripBlocks,
+  stripBlockAt,
+  stripOverhang,
+  stripPixels
+};

package/dist/renderer/Canvas2DRenderer.js

@@ -0,0 +1,9 @@
+import {
+  Canvas2DRenderer,
+  arrowheadOutline
+} from "../chunks/chunk-D3M7SBKL.js";
+import "../chunks/chunk-MNUSQCLG.js";
+export {
+  Canvas2DRenderer,
+  arrowheadOutline
+};

package/dist/renderer/GeometryBuilder.js

@@ -0,0 +1,42 @@
+import {
+  FADED_ALPHA,
+  LIFT_BACKDROP_COLOR,
+  LIFT_BACKDROP_CSS,
+  REFERENCE_RAMP_ALT_COLOR,
+  REFERENCE_RAMP_ALT_CSS,
+  REFERENCE_RAMP_MAX_HUE,
+  buildGeometry,
+  computeColorSchemeRange,
+  computeReferenceRamp,
+  endTangent,
+  getNodeColor,
+  hslToRgb
+} from "../chunks/chunk-PCZ4PTYC.js";
+import "../chunks/chunk-MNUSQCLG.js";
+import "../chunks/chunk-Y3IOTZJA.js";
+import "../chunks/chunk-X5L37W4J.js";
+import "../chunks/chunk-ST2IBUAN.js";
+import "../chunks/chunk-ES2N6V56.js";
+import "../chunks/chunk-N62KBLFC.js";
+import "../chunks/chunk-AB35TJST.js";
+import "../chunks/chunk-TAMCZHLW.js";
+import "../chunks/chunk-PBENCR5L.js";
+import "../chunks/chunk-4EMPBO7S.js";
+import "../chunks/chunk-2CVHXFK7.js";
+import "../chunks/chunk-CPMHA4W5.js";
+import "../chunks/chunk-BPLIXMH7.js";
+import "../chunks/chunk-FYQWPEEY.js";
+export {
+  FADED_ALPHA,
+  LIFT_BACKDROP_COLOR,
+  LIFT_BACKDROP_CSS,
+  REFERENCE_RAMP_ALT_COLOR,
+  REFERENCE_RAMP_ALT_CSS,
+  REFERENCE_RAMP_MAX_HUE,
+  buildGeometry,
+  computeColorSchemeRange,
+  computeReferenceRamp,
+  endTangent,
+  getNodeColor,
+  hslToRgb
+};

package/dist/renderer/colorBits.js

@@ -0,0 +1,8 @@
+import {
+  brightenAbgr,
+  fadeAbgr
+} from "../chunks/chunk-MNUSQCLG.js";
+export {
+  brightenAbgr,
+  fadeAbgr
+};

package/dist/renderer/recordingCanvas.js

@@ -0,0 +1,44 @@
+// src/renderer/recordingCanvas.ts
+function recordingCanvas() {
+  const strokes = [];
+  const fills = [];
+  const lineWidths = [];
+  const points = [];
+  const at = (x, y) => {
+    points.push({ x, y });
+  };
+  const ctx = {
+    canvas: { width: 800, height: 600, style: {} },
+    fillStyle: "",
+    strokeStyle: "",
+    lineWidth: 0,
+    lineCap: "",
+    lineJoin: "",
+    beginPath: () => {
+    },
+    moveTo: at,
+    lineTo: at,
+    closePath: () => {
+    },
+    bezierCurveTo: (cx0, cy0, cx1, cy1, x, y) => {
+      at(cx0, cy0);
+      at(cx1, cy1);
+      at(x, y);
+    },
+    fillRect: () => {
+    },
+    stroke: () => {
+      strokes.push(ctx.strokeStyle);
+      lineWidths.push(ctx.lineWidth);
+    },
+    fill: () => {
+      fills.push(ctx.fillStyle);
+    }
+  };
+  const canvas = document.createElement("canvas");
+  canvas.getContext = () => ctx;
+  return { canvas, strokes, fills, lineWidths, points };
+}
+export {
+  recordingCanvas
+};

package/dist/renderer/svgCanvas.js

@@ -0,0 +1,6 @@
+import {
+  svgCanvas
+} from "../chunks/chunk-47DYCZOK.js";
+export {
+  svgCanvas
+};

package/dist/tubeMap/axis.js

@@ -0,0 +1,25 @@
+import {
+  drawTubeMapRuler,
+  referenceBoxes,
+  rulerBoxes,
+  rulerInk,
+  rulerMarks,
+  tubeSpan,
+  tubeX
+} from "../chunks/chunk-CS3E4ETM.js";
+import "../chunks/chunk-N62KBLFC.js";
+import "../chunks/chunk-AB35TJST.js";
+import "../chunks/chunk-TAMCZHLW.js";
+import "../chunks/chunk-4EMPBO7S.js";
+import "../chunks/chunk-2CVHXFK7.js";
+import "../chunks/chunk-CPMHA4W5.js";
+import "../chunks/chunk-FYQWPEEY.js";
+export {
+  drawTubeMapRuler,
+  referenceBoxes,
+  rulerBoxes,
+  rulerInk,
+  rulerMarks,
+  tubeSpan,
+  tubeX
+};

package/dist/tubeMap/coarsen.js

@@ -0,0 +1,361 @@
+import {
+  visitStrands
+} from "../chunks/chunk-R6ZUK4Y3.js";
+import {
+  canonicalStrand
+} from "../chunks/chunk-TEDQJPMI.js";
+import "../chunks/chunk-C44YRP5F.js";
+import "../chunks/chunk-X5L37W4J.js";
+import {
+  pathOrigin
+} from "../chunks/chunk-ST2IBUAN.js";
+import "../chunks/chunk-N62KBLFC.js";
+import "../chunks/chunk-AB35TJST.js";
+import "../chunks/chunk-TAMCZHLW.js";
+import "../chunks/chunk-4EMPBO7S.js";
+import "../chunks/chunk-2CVHXFK7.js";
+import "../chunks/chunk-CPMHA4W5.js";
+import "../chunks/chunk-BPLIXMH7.js";
+import {
+  isBackbone
+} from "../chunks/chunk-FYQWPEEY.js";
+
+// src/tubeMap/coarsen.ts
+function readWalk(path, nodeById, strands) {
+  const visitName = pathOrigin(path.name).name;
+  const seen = /* @__PURE__ */ new Map();
+  const runs = [];
+  const open = () => ({ a: -Infinity, b: Infinity, detour: [], bp: 0 });
+  const gaps = [open()];
+  for (const id of path.nodeIds) {
+    const node = nodeById.get(id);
+    if (!node) {
+      continue;
+    }
+    const k = seen.get(node.name) ?? 0;
+    seen.set(node.name, k + 1);
+    const strand = strands.get(`${visitName}	${node.name}`)?.[k] ?? canonicalStrand(node);
+    const gap = gaps.at(-1);
+    const last = runs.at(-1);
+    if (isBackbone(node)) {
+      const start = node.stable.start;
+      const end = start + node.length;
+      const inverted = strand !== (node.stable.strand ?? "+");
+      const joins = last !== void 0 && gap.detour.length === 0;
+      if (joins && !last.inverted && !inverted && last.end === start) {
+        last.end = end;
+      } else if (joins && last.inverted && inverted && last.start === end) {
+        last.start = start;
+      } else {
+        runs.push({ start, end, inverted });
+        gaps.push(open());
+      }
+    } else {
+      gap.detour.push({ node, strand });
+      gap.bp += node.length;
+    }
+  }
+  runs.forEach((run, i) => {
+    gaps[i].b = run.start;
+    gaps[i + 1].a = run.end;
+  });
+  return { path, runs, gaps };
+}
+function isSmall(gap, sigma) {
+  return Number.isFinite(gap.a) && Number.isFinite(gap.b) && gap.b >= gap.a && Math.max(gap.b - gap.a, gap.bp) < sigma;
+}
+function strictlyInside(cuts, a, b) {
+  let lo = 0;
+  let hi = cuts.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (cuts[mid] <= a) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo < cuts.length && cuts[lo] < b;
+}
+function referenceGaps(backbone) {
+  const cuts = /* @__PURE__ */ new Map();
+  for (let i = 1; i < backbone.length; i++) {
+    const prev = backbone[i - 1];
+    const node = backbone[i];
+    const end = prev.stable.start + prev.length;
+    if (end !== node.stable.start) {
+      cuts.set(end, "reference-gap");
+      cuts.set(node.stable.start, "reference-gap");
+    }
+  }
+  return cuts;
+}
+function findCuts(walks, sigma, cuts) {
+  const cut = (bp, cause) => {
+    if (Number.isFinite(bp) && !cuts.has(bp)) {
+      cuts.set(bp, cause);
+    }
+  };
+  for (const { runs, gaps } of walks) {
+    const first = runs[0];
+    const last = runs.at(-1);
+    if (first && last) {
+      cut(first.start, "walk-end");
+      cut(last.end, "walk-end");
+    }
+    for (const run of runs) {
+      if (run.inverted && run.end - run.start >= sigma) {
+        cut(run.start, "inversion");
+        cut(run.end, "inversion");
+      }
+    }
+    for (const gap of gaps) {
+      if (gap.b < gap.a) {
+        cut(gap.a, "backward");
+        cut(gap.b, "backward");
+      } else if (!isSmall(gap, sigma)) {
+        cut(gap.a, "variant");
+        cut(gap.b, "variant");
+      }
+    }
+  }
+  for (let changed = true; changed; ) {
+    changed = false;
+    const sorted = [...cuts.keys()].sort((x, y) => x - y);
+    const spans = walks.flatMap(({ runs, gaps }) => [
+      ...gaps.filter((g) => isSmall(g, sigma)).map((g) => [g.a, g.b]),
+      ...runs.filter((r) => r.inverted && r.end - r.start < sigma).map((r) => [r.start, r.end])
+    ]);
+    for (const [a, b] of spans) {
+      if (strictlyInside(sorted, a, b)) {
+        changed ||= !cuts.has(a) || !cuts.has(b);
+        cut(a, "overlap");
+        cut(b, "overlap");
+      }
+    }
+  }
+  return cuts;
+}
+function mergeReference(backbone, cuts) {
+  const merged = [];
+  let group = [];
+  const close = () => {
+    const first = group[0];
+    const last = group.at(-1);
+    if (first && last) {
+      const bp0 = first.stable.start;
+      const bp1 = last.stable.start + last.length;
+      const name = `${bp0}-${bp1}`;
+      merged.push({
+        node: {
+          id: `${name}+`,
+          name,
+          length: bp1 - bp0,
+          depth: 0,
+          stable: {
+            refName: first.stable.refName,
+            start: bp0,
+            rank: 0,
+            strand: "+"
+          }
+        },
+        members: group
+      });
+    }
+    group = [];
+  };
+  for (const node of backbone) {
+    if (cuts.has(node.stable.start)) {
+      close();
+    }
+    group.push(node);
+  }
+  close();
+  return merged;
+}
+function coarsenTubeMap(graph, sigma) {
+  const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
+  const paths = graph.paths ?? [];
+  if (backbone.length === 0 || paths.length === 0) {
+    return void 0;
+  }
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const strands = visitStrands(graph);
+  const walks = paths.map((p) => readWalk(p, nodeById, strands));
+  const cuts = findCuts(walks, sigma, referenceGaps(backbone));
+  const sortedCuts = [...cuts.keys()].sort((x, y) => x - y);
+  const merged = mergeReference(backbone, cuts);
+  const starts = merged.map((m) => m.node.stable.start);
+  const mergedAt = (bp) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= bp) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return lo;
+  };
+  const members = /* @__PURE__ */ new Map();
+  const coarseOf = /* @__PURE__ */ new Map();
+  for (const m of merged) {
+    members.set(
+      m.node.id,
+      m.members.map((n) => n.id)
+    );
+    for (const n of m.members) {
+      coarseOf.set(n.id, m.node.id);
+    }
+  }
+  const routes = /* @__PURE__ */ new Map();
+  const routeFor = (gap) => {
+    const key = `${gap.a}	${gap.b}	${gap.detour.map((s) => s.node.id + s.strand).join(",")}`;
+    let node = routes.get(key);
+    if (!node) {
+      const name = `r${routes.size}`;
+      node = {
+        id: `${name}+`,
+        name,
+        length: gap.bp,
+        depth: 0,
+        stable: {
+          refName: backbone[0].stable.refName,
+          start: Number.isFinite(gap.a) ? gap.a : gap.b,
+          rank: 1,
+          strand: "+"
+        }
+      };
+      routes.set(key, node);
+      members.set(
+        node.id,
+        gap.detour.map((s) => s.node.id)
+      );
+      for (const s of gap.detour) {
+        if (!coarseOf.has(s.node.id)) {
+          coarseOf.set(s.node.id, node.id);
+        }
+      }
+    }
+    return node;
+  };
+  const deviations = /* @__PURE__ */ new Map();
+  const coarsePaths = [];
+  const pathVisits = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const depth = /* @__PURE__ */ new Map();
+  for (const { path, runs, gaps } of walks) {
+    const steps = [];
+    const devs = [];
+    let continuing = false;
+    const append = (node, strand) => {
+      const last = steps.at(-1);
+      if (!(continuing && last?.node === node && last.strand === strand)) {
+        steps.push({ node, strand });
+      }
+      continuing = true;
+    };
+    const structural = (gap) => {
+      continuing = false;
+      if (gap.detour.length > 0) {
+        append(routeFor(gap), "+");
+        continuing = false;
+      }
+    };
+    const fold = (gap) => {
+      if (gap.bp > 0 || gap.b > gap.a) {
+        devs.push({ start: gap.a, end: gap.b, bp: gap.bp });
+      }
+      const home = merged[mergedAt(gap.b > gap.a ? gap.a : gap.a - 1)];
+      for (const s of gap.detour) {
+        if (!coarseOf.has(s.node.id)) {
+          coarseOf.set(s.node.id, home.node.id);
+          members.get(home.node.id).push(s.node.id);
+        }
+      }
+    };
+    runs.forEach((run, i) => {
+      const gap = gaps[i];
+      if (isSmall(gap, sigma) && !strictlyInside(sortedCuts, gap.a, gap.b)) {
+        fold(gap);
+      } else {
+        structural(gap);
+      }
+      const i0 = mergedAt(run.start);
+      const i1 = mergedAt(run.end - 1);
+      const small = run.end - run.start < sigma;
+      if (run.inverted && !small) {
+        continuing = false;
+        for (let j = i1; j >= i0; j--) {
+          append(merged[j].node, "-");
+        }
+        continuing = false;
+      } else {
+        if (run.inverted) {
+          devs.push({
+            start: run.start,
+            end: run.end,
+            bp: run.end - run.start,
+            inverted: true
+          });
+        }
+        for (let j = i0; j <= i1; j++) {
+          append(merged[j].node, "+");
+        }
+      }
+    });
+    structural(gaps.at(-1));
+    const visitName = pathOrigin(path.name).name;
+    let pos = 0;
+    steps.forEach(({ node, strand }, i) => {
+      depth.set(node.id, (depth.get(node.id) ?? 0) + 1);
+      const visits = pathVisits.get(node.name) ?? [];
+      visits.push({
+        path: visitName,
+        sample: path.sample ?? visitName,
+        start: pos,
+        strand
+      });
+      pathVisits.set(node.name, visits);
+      pos += node.length;
+      const next = steps[i + 1];
+      if (next) {
+        const key = `${node.id}${strand}	${next.node.id}${next.strand}`;
+        const edge = edges.get(key);
+        if (edge) {
+          edge.pathIds.push(path.name);
+        } else {
+          edges.set(key, {
+            from: node.id,
+            to: next.node.id,
+            fromStrand: strand,
+            toStrand: next.strand,
+            pathIds: [path.name]
+          });
+        }
+      }
+    });
+    coarsePaths.push({ ...path, nodeIds: steps.map((s) => s.node.id) });
+    deviations.set(path.name, devs);
+  }
+  const nodes = [...merged.map((m) => m.node), ...routes.values()].filter((n) => depth.has(n.id)).map((n) => ({ ...n, depth: depth.get(n.id) }));
+  return {
+    graph: {
+      ...graph,
+      nodes,
+      edges: [...edges.values()],
+      paths: coarsePaths,
+      pathVisits,
+      reads: void 0
+    },
+    members,
+    coarseOf,
+    deviations,
+    cuts
+  };
+}
+export {
+  coarsenTubeMap
+};

package/dist/tubeMap/connectors.js

@@ -0,0 +1,13 @@
+import {
+  connectorAt,
+  drawTubeMapConnectors,
+  referenceNodes,
+  tubeMapConnectors
+} from "../chunks/chunk-GQ2AOHU4.js";
+import "../chunks/chunk-FYQWPEEY.js";
+export {
+  connectorAt,
+  drawTubeMapConnectors,
+  referenceNodes,
+  tubeMapConnectors
+};

package/dist/tubeMap/deviations.js

@@ -0,0 +1,85 @@
+import {
+  isBackbone
+} from "../chunks/chunk-FYQWPEEY.js";
+
+// src/tubeMap/deviations.ts
+function boxesOf(graph, layout) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const boxes = [];
+  layout.nodes.forEach((node, index) => {
+    const g = nodeById.get(node.name);
+    if (node.order >= 0 && g && isBackbone(g)) {
+      const bp0 = g.stable.start;
+      boxes.push({ bp0, bp1: bp0 + node.sequenceLength, index, node });
+    }
+  });
+  return boxes.sort((a, b) => a.bp0 - b.bp0);
+}
+function boxAt(boxes, bp, visited) {
+  let lo = 0;
+  let hi = boxes.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (boxes[mid].bp0 <= bp) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return [boxes[lo], boxes[lo - 1]].find(
+    (box) => box && visited.has(box.index) && box.bp0 <= bp && bp <= box.bp1
+  );
+}
+function deviationMarks(graph, layout, deviations) {
+  const boxes = boxesOf(graph, layout);
+  const marks = [];
+  for (const track of layout.tracks) {
+    const devs = track.name ? deviations.get(track.name) : void 0;
+    if (devs?.length) {
+      const visited = /* @__PURE__ */ new Map();
+      for (const segment of track.path) {
+        if (segment.node !== null && segment.y !== void 0 && !visited.has(segment.node)) {
+          visited.set(segment.node, segment.y);
+        }
+      }
+      for (const d of devs) {
+        const box = boxAt(boxes, d.start, visited);
+        if (box) {
+          const { node, bp0, bp1 } = box;
+          const at = (bp) => node.x + (Math.min(bp, bp1) - bp0) / (bp1 - bp0) * node.pixelWidth;
+          marks.push({
+            x0: at(d.start),
+            x1: at(d.end),
+            y: visited.get(box.index),
+            height: track.width
+          });
+        }
+      }
+    }
+  }
+  return marks;
+}
+function deviationInk(darkMode) {
+  return darkMode ? "rgba(255,255,255,0.9)" : "rgba(0,0,0,0.8)";
+}
+function drawDeviationMarks(ctx, marks, { x, y, width, darkMode }) {
+  if (marks.length === 0) {
+    return;
+  }
+  ctx.fillStyle = deviationInk(darkMode);
+  ctx.beginPath();
+  for (const m of marks) {
+    const left = x(m.x0);
+    const right = Math.max(x(m.x1), left + 1);
+    if (right >= 0 && left <= width) {
+      const top = y(m.y);
+      ctx.rect(left, top, right - left, y(m.y + m.height) - top);
+    }
+  }
+  ctx.fill();
+}
+export {
+  deviationInk,
+  deviationMarks,
+  drawDeviationMarks
+};

package/dist/tubeMap/draw.js

@@ -0,0 +1,15 @@
+import {
+  drawTubeMap,
+  mismatchOnScreen,
+  mismatchesLegible,
+  parsePath,
+  tubeMapPicture
+} from "../chunks/chunk-CR7EGAFE.js";
+import "../chunks/chunk-EJ5OZTCK.js";
+export {
+  drawTubeMap,
+  mismatchOnScreen,
+  mismatchesLegible,
+  parsePath,
+  tubeMapPicture
+};

package/dist/tubeMap/frame.js

@@ -0,0 +1,9 @@
+import {
+  tubeMapFrame,
+  tubeMapNodeAt
+} from "../chunks/chunk-VZQ4FKLR.js";
+import "../chunks/chunk-KQFOCDFY.js";
+export {
+  tubeMapFrame,
+  tubeMapNodeAt
+};

package/dist/tubeMap/genes.js

@@ -0,0 +1,20 @@
+import {
+  GENE_ROW_PX,
+  drawTubeMapGenes,
+  tubeMapGeneRows,
+  tubeMapGenes
+} from "../chunks/chunk-CTSBC2O6.js";
+import "../chunks/chunk-CS3E4ETM.js";
+import "../chunks/chunk-N62KBLFC.js";
+import "../chunks/chunk-AB35TJST.js";
+import "../chunks/chunk-TAMCZHLW.js";
+import "../chunks/chunk-4EMPBO7S.js";
+import "../chunks/chunk-2CVHXFK7.js";
+import "../chunks/chunk-CPMHA4W5.js";
+import "../chunks/chunk-FYQWPEEY.js";
+export {
+  GENE_ROW_PX,
+  drawTubeMapGenes,
+  tubeMapGeneRows,
+  tubeMapGenes
+};

package/dist/tubeMap/mismatches.js

@@ -0,0 +1,6 @@
+import {
+  tubeMapMismatches
+} from "../chunks/chunk-EJ5OZTCK.js";
+export {
+  tubeMapMismatches
+};