@jbrowse/bandage-core 11.2.0 → 11.3.0

package/dist/chunks/chunk-M75QPZNJ.js

@@ -0,0 +1,502 @@
+import {
+  tableNodeIds,
+  tablePath
+} from "./chunk-B5ARSBOH.js";
+import {
+  pathOrigin
+} from "./chunk-B5X2RLJG.js";
+import {
+  gapParts
+} from "./chunk-EIY2SKD3.js";
+import {
+  groupBy
+} from "./chunk-BSOZW3FC.js";
+import {
+  panSNContig,
+  panSNSample
+} from "./chunk-4XWZNPQ2.js";
+
+// src/layout/walkRowRuns.ts
+var RUN_ON_REFERENCE = 1;
+var RUN_REVERSED = 2;
+var RUN_GAP = 4;
+var GAP_CAUSES = [void 0, "missing", "elsewhere", "unknown"];
+var CAUSE_SHIFT = 3;
+var causeFlags = (cause) => GAP_CAUSES.indexOf(cause) << CAUSE_SHIFT;
+function referenceOf(names, referencePath, rankZero) {
+  return referencePath !== void 0 && names.includes(referencePath) ? referencePath : names.find((n) => rankZero.has(n)) ?? names[0];
+}
+function referenceWalkName(graph) {
+  return referenceOf(
+    (graph.paths ?? []).map((p) => pathOrigin(p.name).name),
+    graph.referencePath,
+    new Set(
+      graph.nodes.flatMap(
+        (n) => n.stable?.rank === 0 ? [n.stable.refName] : []
+      )
+    )
+  );
+}
+function graphPieces(graph) {
+  const index = /* @__PURE__ */ new Map();
+  const names = [];
+  const lengths = [];
+  const indexOf = (id) => {
+    let i = index.get(id);
+    if (i === void 0) {
+      i = names.length;
+      index.set(id, i);
+      names.push(id);
+      lengths.push(0);
+    }
+    return i;
+  };
+  for (const node of graph.nodes) {
+    lengths[indexOf(node.id)] = node.length;
+  }
+  const heads = graph.paths ?? [];
+  const from = new Int32Array(heads.length);
+  const to = new Int32Array(heads.length);
+  const steps = [];
+  heads.forEach((path, p) => {
+    from[p] = steps.length;
+    for (const id of path.nodeIds) {
+      steps.push(indexOf(id));
+    }
+    to[p] = steps.length;
+  });
+  return {
+    heads,
+    from,
+    to,
+    steps,
+    lengths,
+    names,
+    reference: referenceWalkName(graph)
+  };
+}
+function tablePieces(tables, referencePath, visits) {
+  const { nodes: n, walks: w } = tables;
+  const kept = [];
+  for (let p = 0; p < w.names.length; p++) {
+    if (w.offsets[p + 1] > w.offsets[p]) {
+      kept.push(p);
+    }
+  }
+  const heads = kept.map((p) => tablePath(w, p));
+  const rankZero = /* @__PURE__ */ new Set();
+  for (let i = 0; i < n.lengths.length; i++) {
+    if (n.refs[i] >= 0 && n.ranks[i] === 0) {
+      rankZero.add(n.refNames[n.refs[i]]);
+    }
+  }
+  return {
+    heads,
+    from: kept.map((p) => w.offsets[p]),
+    to: kept.map((p) => w.offsets[p + 1]),
+    steps: w.steps,
+    lengths: n.lengths,
+    // a visit names its node as the Graph does, which costs a pass over the
+    // steps
+    names: visits ? tableNodeIds(tables) : n.names,
+    reference: referenceOf(
+      heads.map((h) => pathOrigin(h.name).name),
+      referencePath,
+      rankZero
+    )
+  };
+}
+function sampleOf(path) {
+  return path.sample ?? panSNSample(path.name);
+}
+function labelOf(path) {
+  return path.haplotype !== void 0 && path.sample !== void 0 ? `${path.sample}#${path.haplotype}` : sampleOf(path);
+}
+var Columns = class {
+  constructor(width) {
+    this.offsets = [0];
+    this.values = Array.from({ length: width }, () => []);
+  }
+  get length() {
+    return this.values[0].length;
+  }
+  push(...row) {
+    row.forEach((v, i) => this.values[i].push(v));
+  }
+  endRow() {
+    this.offsets.push(this.length);
+  }
+  // the rows in `order`, column i in the array `make[i]` makes
+  reorder(order, make) {
+    const columns = make.map((m) => m(this.length));
+    const offsets = new Uint32Array(order.length + 1);
+    let at = 0;
+    order.forEach((row, i) => {
+      for (let k = this.offsets[row]; k < this.offsets[row + 1]; k++, at++) {
+        columns.forEach((column, c) => {
+          column[at] = this.values[c][k];
+        });
+      }
+      offsets[i + 1] = at;
+    });
+    return { offsets, columns };
+  }
+};
+var float64 = (n) => new Float64Array(n);
+function walkRowRuns(source, region, o = {}) {
+  const {
+    heads,
+    from,
+    to,
+    steps: all,
+    lengths,
+    names,
+    reference
+  } = "walks" in source ? tablePieces(source, o.referencePath, o.visits) : graphPieces(source);
+  const declared = lengths.length;
+  const lengthOf = (node) => node < declared ? lengths[node] : 0;
+  const nameOf = (p) => pathOrigin(heads[p].name).name;
+  const startOf = (p) => heads[p].start;
+  const byStart = (a, b) => (startOf(a) ?? 0) - (startOf(b) ?? 0);
+  const pieceIds = heads.map((_, p) => p);
+  const referencePieces = pieceIds.filter((p) => nameOf(p) === reference).sort(byStart);
+  const first = referencePieces[0];
+  const others = pieceIds.filter((p) => nameOf(p) !== reference);
+  if (first === void 0 || others.length === 0) {
+    return void 0;
+  }
+  const walks = groupBy(others, nameOf);
+  const spanStart = new Float64Array(names.length).fill(Number.NaN);
+  const spanEnd = new Float64Array(names.length);
+  let reachesBefore = false;
+  let reachesAfter = false;
+  const cut = region && region.end > region.start ? region : void 0;
+  for (const piece of referencePieces) {
+    let pos = startOf(piece) ?? 0;
+    for (let s = from[piece]; s < to[piece]; s++) {
+      const node = all[s];
+      const len = lengthOf(node);
+      if (Number.isNaN(spanStart[node])) {
+        spanStart[node] = pos;
+        spanEnd[node] = pos + len;
+        if (cut) {
+          reachesBefore ||= pos + len <= cut.start;
+          reachesAfter ||= pos >= cut.end;
+        }
+      }
+      pos += len;
+    }
+  }
+  const flanked = cut === void 0 || reachesBefore && reachesAfter;
+  const runs = new Columns(5);
+  const chunks = [];
+  const chunkIndex = /* @__PURE__ */ new Map();
+  const chunkOf = (chunk2) => {
+    if (!chunk2) {
+      return -1;
+    }
+    const key = `${chunk2.refName}:${chunk2.start}`;
+    let i = chunkIndex.get(key);
+    if (i === void 0) {
+      i = chunks.length;
+      chunkIndex.set(key, i);
+      chunks.push(chunk2);
+    }
+    return i;
+  };
+  const visits = o.visits ? new Columns(4) : void 0;
+  let steps = new Int32Array(0);
+  let stepStart = new Float64Array(0);
+  const rowOf = (pieces) => {
+    const head = heads[pieces[0]];
+    const ordered = [...pieces].sort(byStart);
+    let count = ordered.length - 1;
+    for (const piece of ordered) {
+      count += to[piece] - from[piece];
+    }
+    if (count > steps.length) {
+      steps = new Int32Array(count * 2);
+      stepStart = new Float64Array(count * 2);
+    }
+    let length = 0;
+    let unplaced = false;
+    let end;
+    let previous;
+    const partsAt = /* @__PURE__ */ new Map();
+    for (const piece of ordered) {
+      const start2 = startOf(piece);
+      if (start2 === void 0 || end !== void 0 && start2 < end) {
+        unplaced = true;
+      }
+      if (end !== void 0 && start2 !== void 0 && start2 > end) {
+        partsAt.set(
+          length,
+          gapParts(
+            start2 - end,
+            previous === void 0 ? void 0 : heads[previous].after,
+            heads[piece].before
+          )
+        );
+        steps[length] = -(start2 - end);
+        stepStart[length++] = end;
+      }
+      let pos = start2 ?? 0;
+      for (let s = from[piece]; s < to[piece]; s++) {
+        const node = all[s];
+        steps[length] = node;
+        stepStart[length++] = pos;
+        pos += lengthOf(node);
+      }
+      end = start2 === void 0 ? void 0 : pos;
+      previous = piece;
+    }
+    const onReference = (i) => i >= 0 && i < length && steps[i] >= 0 && !Number.isNaN(spanStart[steps[i]]);
+    const stepEnd = (i) => {
+      const id = steps[i];
+      return stepStart[i] + (id < 0 ? -id : lengthOf(id));
+    };
+    const partialSide = (i0, i1) => {
+      const flank = i0 >= 0 ? i0 : i1;
+      let near = -1;
+      for (let d = 1; near < 0 && d < length; d++) {
+        near = [flank - d, flank + d].find(onReference) ?? -1;
+      }
+      if (near < 0) {
+        return void 0;
+      }
+      const forward = near > flank === spanStart[steps[near]] > spanStart[steps[flank]];
+      const after = forward === (flank === i0);
+      const last2 = after ? length - 1 : 0;
+      const contigEnds = onReference(last2);
+      const stop2 = {
+        contigEnds,
+        shortBp: contigEnds ? Math.max(
+          0,
+          cut.start - spanEnd[steps[last2]],
+          spanStart[steps[last2]] - cut.end
+        ) : 0
+      };
+      return {
+        stop: stop2,
+        lo: after ? flank + 1 : 0,
+        hi: after ? length : flank,
+        backward: !forward,
+        axisStart: forward ? after ? stepEnd(flank) : stepStart[0] : after ? stepEnd(length - 1) : stepStart[flank]
+      };
+    };
+    let lo = 0;
+    let hi = length;
+    let backward = false;
+    let complete = true;
+    let flankFrom = -1;
+    let flankTo = -1;
+    let axisStart;
+    let stop;
+    if (cut && flanked) {
+      let i0 = -1;
+      let i1 = -1;
+      let bestEnd = -Infinity;
+      let bestStart = Infinity;
+      for (let i = 0; i < length; i++) {
+        if (onReference(i)) {
+          const id = steps[i];
+          if (spanEnd[id] <= cut.start && spanEnd[id] > bestEnd) {
+            bestEnd = spanEnd[id];
+            i0 = i;
+          }
+          if (spanStart[id] >= cut.end && spanStart[id] < bestStart) {
+            bestStart = spanStart[id];
+            i1 = i;
+          }
+        }
+      }
+      if (i0 < 0 || i1 < 0) {
+        complete = false;
+        const inside = i0 >= 0 || i1 >= 0 ? partialSide(i0, i1) : void 0;
+        if (inside) {
+          ;
+          ({ lo, hi, backward, axisStart, stop } = inside);
+        }
+      } else {
+        lo = Math.min(i0, i1) + 1;
+        hi = Math.max(i0, i1);
+        backward = i0 > i1;
+        flankFrom = i0;
+        flankTo = i1;
+      }
+    }
+    const contig = head.contig ?? panSNContig(pathOrigin(head.name).name);
+    const axis = unplaced || length === 0 ? void 0 : axisStart !== void 0 ? { contig, start: axisStart, reversed: backward } : flankFrom < 0 ? { contig, start: stepStart[0], reversed: false } : flankFrom < flankTo ? { contig, start: stepEnd(flankFrom), reversed: false } : { contig, start: stepStart[flankFrom], reversed: true };
+    let bp2 = 0;
+    let offReferenceBp = 0;
+    let gapBp = 0;
+    let step = 0;
+    let last = -1;
+    let lastFlags = 0;
+    let lastRef = Number.NaN;
+    const [, runBp, runRef, runFlags] = runs.values;
+    for (let k = lo; k < hi; k++) {
+      const index = backward ? hi - 1 - (k - lo) : k;
+      const id = steps[index];
+      if (id < 0) {
+        const parts = partsAt.get(index);
+        for (const part of backward ? [...parts].reverse() : parts) {
+          runs.push(
+            bp2,
+            part.bp,
+            Number.NaN,
+            RUN_GAP | causeFlags(part.cause),
+            chunkOf(part.chunk)
+          );
+          bp2 += part.bp;
+        }
+        last = runs.length - 1;
+        lastFlags = RUN_GAP;
+        lastRef = Number.NaN;
+        gapBp += -id;
+        step = 0;
+        continue;
+      }
+      const len = lengthOf(id);
+      const at = spanStart[id];
+      const on = !Number.isNaN(at);
+      visits?.push(id, bp2, len, on ? 1 : 0);
+      const placed = last >= 0 && !Number.isNaN(lastRef);
+      const forward = on && placed && step >= 0 && lastRef + (runBp[last] ?? 0) === at;
+      const back = on && placed && step <= 0 && spanEnd[id] === lastRef;
+      if (!on && last >= 0 && !(lastFlags & (RUN_ON_REFERENCE | RUN_GAP))) {
+        runBp[last] += len;
+      } else if (forward || back) {
+        runBp[last] += len;
+        if (!forward) {
+          lastRef = at;
+          runRef[last] = at;
+          lastFlags |= RUN_REVERSED;
+          runFlags[last] = lastFlags;
+        }
+        step = forward ? 1 : -1;
+      } else {
+        lastFlags = on ? RUN_ON_REFERENCE : 0;
+        lastRef = on ? at : Number.NaN;
+        runs.push(bp2, len, lastRef, lastFlags, -1);
+        last = runs.length - 1;
+        step = 0;
+      }
+      bp2 += len;
+      if (!on) {
+        offReferenceBp += len;
+      }
+    }
+    runs.endRow();
+    visits?.endRow();
+    return {
+      name: head.name,
+      label: labelOf(head),
+      sample: sampleOf(head),
+      haplotype: head.haplotype,
+      bp: bp2,
+      offReferenceBp,
+      gapBp,
+      complete,
+      stop,
+      axis
+    };
+  };
+  const referenceRow = rowOf(referencePieces);
+  const rows = [...walks.values()].map((pieces, i) => ({
+    meta: rowOf(pieces),
+    row: i + 1
+  }));
+  rows.sort(
+    (a, b) => Number(b.meta.complete) - Number(a.meta.complete) || b.meta.bp - a.meta.bp || a.meta.label.localeCompare(b.meta.label)
+  );
+  const order = [0, ...rows.map((r) => r.row)];
+  const { offsets, columns } = runs.reorder(order, [
+    float64,
+    float64,
+    float64,
+    (n) => new Uint8Array(n),
+    (n) => new Int32Array(n)
+  ]);
+  const [start, bp, referenceStart, flags, chunk] = columns;
+  return {
+    origin: cut ? cut.start : startOf(first) ?? 0,
+    rows: [referenceRow, ...rows.map((r) => r.meta)],
+    offsets,
+    start,
+    bp,
+    referenceStart,
+    flags,
+    chunk,
+    chunks,
+    visits: visits && visitColumns(visits, order, names)
+  };
+}
+function visitColumns(visits, order, names) {
+  const { offsets, columns } = visits.reorder(order, [
+    (n) => new Int32Array(n),
+    float64,
+    float64,
+    (n) => new Uint8Array(n)
+  ]);
+  const [node, start, bp, onReference] = columns;
+  return { offsets, node, start, bp, onReference, names };
+}
+function runAt(t, k) {
+  const f = t.flags[k];
+  const run = {
+    start: t.start[k],
+    bp: t.bp[k],
+    onReference: (f & RUN_ON_REFERENCE) !== 0
+  };
+  if (f & RUN_GAP) {
+    run.gap = true;
+    const cause = GAP_CAUSES[f >> CAUSE_SHIFT & 3];
+    if (cause) {
+      run.cause = cause;
+    }
+    const chunk = t.chunks[t.chunk[k]];
+    if (chunk) {
+      run.chunk = chunk;
+    }
+  } else {
+    run.referenceStart = Number.isNaN(t.referenceStart[k]) ? void 0 : t.referenceStart[k];
+  }
+  if (f & RUN_REVERSED) {
+    run.reversed = true;
+  }
+  return run;
+}
+function visitsOf(v, row) {
+  const out = [];
+  for (let k = v.offsets[row]; k < v.offsets[row + 1]; k++) {
+    out.push({
+      node: v.names[v.node[k]],
+      start: v.start[k],
+      bp: v.bp[k],
+      onReference: v.onReference[k] === 1
+    });
+  }
+  return out;
+}
+function walkRowsOf(t, unit) {
+  const rows = t.rows.map((meta, i) => {
+    const runs = [];
+    for (let k = t.offsets[i]; k < t.offsets[i + 1]; k++) {
+      runs.push(runAt(t, k));
+    }
+    return {
+      ...meta,
+      runs,
+      visits: t.visits && visitsOf(t.visits, i)
+    };
+  });
+  return { origin: t.origin, unit, reference: rows[0], rows: rows.slice(1) };
+}
+
+export {
+  referenceWalkName,
+  walkRowRuns,
+  runAt,
+  walkRowsOf
+};

package/dist/chunks/{chunk-ZU54STUX.js → chunk-PNM6Z3IE.js}

@@ -10,7 +10,7 @@ import {
 import {
   READOUT_ROOM,
   longestBar
-} from "./chunk-QR5XR5XL.js";
+} from "./chunk-TZLEHZVC.js";
 import {
   pathOrigin
 } from "./chunk-B5X2RLJG.js";

package/dist/chunks/{chunk-KDU4EF66.js → chunk-REOWLPH4.js}

@@ -20,7 +20,7 @@ import {
 } from "./chunk-5I3K4R2G.js";
 import {
   graphFromTables
-} from "./chunk-3XSRT7RQ.js";
+} from "./chunk-B5ARSBOH.js";
 import {
   anchorGraph
 } from "./chunk-B5X2RLJG.js";

package/dist/chunks/{chunk-VWT3WZRQ.js → chunk-RNNYRNDU.js}

@@ -1,3 +1,6 @@
+import {
+  Canvas2DRenderer
+} from "./chunk-EJRJAAN7.js";
 import {
   svgCanvas
 } from "./chunk-V4YML3GR.js";
@@ -5,15 +8,12 @@ import {
   stripGeneGaps,
   walkStripFrame,
   walkStripLabelsTree
-} from "./chunk-ZU54STUX.js";
+} from "./chunk-PNM6Z3IE.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
 } from "./chunk-XZ6PQBU6.js";
-import {
-  Canvas2DRenderer
-} from "./chunk-EJRJAAN7.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
@@ -34,13 +34,13 @@ import {
 } from "./chunk-77EGQQJU.js";
 import {
   version
-} from "./chunk-WAST7UVB.js";
+} from "./chunk-XEWPWCML.js";
 import {
   axisScaleOf
-} from "./chunk-AI5PTOSV.js";
+} from "./chunk-CE6ZIKJX.js";
 import {
   figureScene
-} from "./chunk-S2PUF4SX.js";
+} from "./chunk-T35BSLW5.js";
 import {
   encodingStops
 } from "./chunk-TABI4JEU.js";
@@ -49,17 +49,17 @@ import {
 } from "./chunk-D4ZFRBB4.js";
 import {
   walkRowLabels
-} from "./chunk-QR5XR5XL.js";
+} from "./chunk-TZLEHZVC.js";
 import {
   nodeInk
 } from "./chunk-CRCD3ODN.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-W6EXQDV5.js";
+} from "./chunk-EFD753MS.js";
 import {
   FIT_PADDING,
   fitTransform
-} from "./chunk-KDU4EF66.js";
+} from "./chunk-REOWLPH4.js";
 import {
   LABEL_CHAR_PX,
   LABEL_PAD,

package/dist/chunks/{chunk-TREAOGDV.js → chunk-SLDCKMIP.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-JMABOQWL.js";
 import {
   layoutModeByValue
-} from "./chunk-VQT3A57T.js";
+} from "./chunk-TEXAKEJX.js";
 import {
   parseRegion
 } from "./chunk-TUQKGAK3.js";
@@ -12,13 +12,13 @@ import {
 } from "./chunk-77EGQQJU.js";
 import {
   version
-} from "./chunk-WAST7UVB.js";
+} from "./chunk-XEWPWCML.js";
 import {
   axisScaleOf
-} from "./chunk-AI5PTOSV.js";
+} from "./chunk-CE6ZIKJX.js";
 import {
   figureScene
-} from "./chunk-S2PUF4SX.js";
+} from "./chunk-T35BSLW5.js";
 import {
   encodingStops
 } from "./chunk-TABI4JEU.js";
@@ -30,13 +30,13 @@ import {
 } from "./chunk-G2FD7S3C.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-W6EXQDV5.js";
+} from "./chunk-EFD753MS.js";
 import {
   engineSettingsOf,
   fitTransform,
   forceLayout,
   loadGraph
-} from "./chunk-KDU4EF66.js";
+} from "./chunk-REOWLPH4.js";
 import {
   isBackbone
 } from "./chunk-RJWPJCIB.js";

package/dist/chunks/{chunk-S2PUF4SX.js → chunk-T35BSLW5.js}

@@ -14,17 +14,17 @@ import {
 } from "./chunk-SWCULW6S.js";
 import {
   walkRowsExtent
-} from "./chunk-QR5XR5XL.js";
+} from "./chunk-TZLEHZVC.js";
 import {
   pathLegend,
   walkLabelsOf
 } from "./chunk-3GP3KT5L.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-W6EXQDV5.js";
+} from "./chunk-EFD753MS.js";
 import {
   drawingBounds
-} from "./chunk-KDU4EF66.js";
+} from "./chunk-REOWLPH4.js";
 import {
   referenceLabel
 } from "./chunk-234NFZS4.js";

package/dist/chunks/{chunk-VQT3A57T.js → chunk-TEXAKEJX.js}

@@ -3,7 +3,7 @@ import {
   hasTubeMapPaths,
   tubeMapLayout,
   tubeMapReferenceLayout
-} from "./chunk-A7VSP7MQ.js";
+} from "./chunk-3LZ334X4.js";
 import {
   sampleRowLayout
 } from "./chunk-GJU6BJJA.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-UAFATXYA.js";
 import {
   walkRowLayout
-} from "./chunk-QR5XR5XL.js";
+} from "./chunk-TZLEHZVC.js";
 import {
   isBackbone,
   isOffReference

package/dist/chunks/{chunk-C2TAJTUO.js → chunk-TJOOHTJ6.js}

@@ -1,6 +1,6 @@
 import {
   pathSteps
-} from "./chunk-A7VSP7MQ.js";
+} from "./chunk-3LZ334X4.js";
 import {
   pathOrigin
 } from "./chunk-B5X2RLJG.js";

package/dist/chunks/{chunk-QR5XR5XL.js → chunk-TZLEHZVC.js}

@@ -1,6 +1,6 @@
 import {
   walkRows
-} from "./chunk-5DHOFF4C.js";
+} from "./chunk-JDZ5GTZT.js";
 import {
   ROW_HEIGHT_PX
 } from "./chunk-CPMHA4W5.js";
@@ -37,9 +37,12 @@ function walkRowLabels(rows, layout, pitch) {
   }));
 }
 function walkRowLayout(graph, region) {
-  const backbone = backboneNodes(graph);
   const walks = walkRows(graph, region);
-  if (backbone.length === 0 || !walks) {
+  return walks && walkRowLayoutOf(graph, walks, region);
+}
+function walkRowLayoutOf(graph, walks, region) {
+  const backbone = backboneNodes(graph);
+  if (backbone.length === 0) {
     return void 0;
   }
   const overWindow = region ? backbone.filter((n) => overlapsWindow(n, region)) : backbone;
@@ -60,5 +63,6 @@ export {
   longestBar,
   walkRowsExtent,
   walkRowLabels,
-  walkRowLayout
+  walkRowLayout,
+  walkRowLayoutOf
 };