@jbrowse/bandage-core 11.2.0 → 11.4.0

package/dist/types/layout/walkRowRuns.d.ts

@@ -0,0 +1,56 @@
+import type { WalkRow, WalkRows, WalkRun } from './walkRows.js';
+import type { GraphTables } from '../gfa/graphTables.js';
+import type { Graph, StopChunk } from '../types.js';
+export type WalkRowMeta = Omit<WalkRow, 'runs' | 'visits'>;
+/**
+ * Each row's visits, row i's at `offsets[i]` up to `offsets[i + 1]`: the
+ * node as an index into `names`, its bp offset from the bar's start, its bp,
+ * and 1 where the reference walk visits it anywhere in the cut
+ */
+export interface WalkVisitColumns {
+    offsets: Uint32Array;
+    node: Int32Array;
+    start: Float64Array;
+    bp: Float64Array;
+    onReference: Uint8Array;
+    names: ArrayLike<string>;
+}
+/**
+ * `walkRows` with each row's runs as typed arrays, which cross from a worker
+ * without an object per run. Row 0 is the reference; row i's runs are
+ * `offsets[i]` up to `offsets[i + 1]`.
+ */
+export interface WalkRowRuns {
+    origin: number;
+    rows: WalkRowMeta[];
+    offsets: Uint32Array;
+    start: Float64Array;
+    bp: Float64Array;
+    referenceStart: Float64Array;
+    flags: Uint8Array;
+    chunk: Int32Array;
+    chunks: StopChunk[];
+    visits?: WalkVisitColumns;
+}
+export declare function referenceWalkName(graph: Pick<Graph, 'nodes' | 'paths' | 'referencePath'>): string | undefined;
+/**
+ * The walk rows of a Graph, or of a cut's tables without the Graph of their
+ * steps, as `walkRows` reads them. Tables name their reference by
+ * `referencePath`, as loadGraph does.
+ *
+ * Each walk is cut at the nearest reference nodes IT visits on either side of
+ * the region, so a walk that skips one flanking node at a SNP is still
+ * measured between flanks rather than whole. A walk with one flank, whose
+ * contig ends inside the window, is the steps past that flank read in the
+ * reference's direction, a lower bound.
+ */
+export declare function walkRowRuns(source: Graph | GraphTables, region?: {
+    start: number;
+    end: number;
+}, o?: {
+    visits?: boolean;
+    referencePath?: string;
+}): WalkRowRuns | undefined;
+export declare function runAt(t: WalkRowRuns, k: number): WalkRun;
+/** The rows as `WalkRows`, an object per run, and per visit where it has them */
+export declare function walkRowsOf(t: WalkRowRuns, unit?: number): WalkRows;

package/dist/types/layout/walkRows.d.ts

@@ -1,5 +1,6 @@
 import type { GapCause } from '../gfa/walkStops.js';
 import type { Graph, StopChunk } from '../types.js';
+export { referenceWalkName } from './walkRowRuns.js';
 export interface WalkRun {
     start: number;
     bp: number;
@@ -22,6 +23,7 @@ export interface WalkStop {
 export interface WalkVisit {
     node: string;
     start: number;
+    bp: number;
     onReference: boolean;
 }
 export interface WalkRow {
@@ -48,7 +50,6 @@ export declare function filterSamples<R extends {
     sample: string;
     label: string;
 }>(rows: R[], samples: string[] | undefined): R[];
-export declare function referenceWalkName(graph: Pick<Graph, 'nodes' | 'paths' | 'referencePath'>): string | undefined;
 export declare function walkRows(graph: Graph, region?: {
     start: number;
     end: number;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "11.2.0";
+export declare const version = "11.4.0";

package/dist/version.js

@@ -1,6 +1,6 @@
 import {
   version
-} from "./chunks/chunk-WAST7UVB.js";
+} from "./chunks/chunk-QM7KEWWT.js";
 export {
   version
 };

package/dist/viewport.js

@@ -5,8 +5,8 @@ import {
   screenToLayout,
   viewportOf,
   zoomAbout
-} from "./chunks/chunk-AI5PTOSV.js";
-import "./chunks/chunk-KDU4EF66.js";
+} from "./chunks/chunk-CE6ZIKJX.js";
+import "./chunks/chunk-REOWLPH4.js";
 import "./chunks/chunk-3PZSBNLI.js";
 import "./chunks/chunk-CKUVEHSS.js";
 import "./chunks/chunk-OPPVSPEF.js";
@@ -14,7 +14,7 @@ import "./chunks/chunk-VPE4AYP7.js";
 import "./chunks/chunk-FFHJGWDK.js";
 import "./chunks/chunk-QYBZZI5H.js";
 import "./chunks/chunk-5I3K4R2G.js";
-import "./chunks/chunk-3XSRT7RQ.js";
+import "./chunks/chunk-B5ARSBOH.js";
 import "./chunks/chunk-B5X2RLJG.js";
 import "./chunks/chunk-VX656OAZ.js";
 import "./chunks/chunk-DZR37KXT.js";

package/dist/walkEncoding.js

@@ -9,8 +9,8 @@ import {
   schemeColor,
   schemeCss,
   schemeRgb
-} from "./chunks/chunk-TABI4JEU.js";
-import "./chunks/chunk-SWCULW6S.js";
+} from "./chunks/chunk-GM7M25NW.js";
+import "./chunks/chunk-XSF4RQRP.js";
 import "./chunks/chunk-G2FD7S3C.js";
 import "./chunks/chunk-GQZVR5DW.js";
 import "./chunks/chunk-WA5WNP6V.js";

package/dist/walkHighlight.js

@@ -2,9 +2,9 @@ import {
   facetLifts,
   walkHighlight,
   walkLift
-} from "./chunks/chunk-DR24UTRS.js";
-import "./chunks/chunk-TABI4JEU.js";
-import "./chunks/chunk-SWCULW6S.js";
+} from "./chunks/chunk-FRTYQQDI.js";
+import "./chunks/chunk-GM7M25NW.js";
+import "./chunks/chunk-XSF4RQRP.js";
 import "./chunks/chunk-G2FD7S3C.js";
 import "./chunks/chunk-GQZVR5DW.js";
 import "./chunks/chunk-WA5WNP6V.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/bandage-core",
-  "version": "11.2.0",
+  "version": "11.4.0",
   "description": "Pangenome graph layout and drawing with no host: GFA in, the Bandage force-directed engine and reference-anchored layouts, a Canvas2D renderer, hit testing and labels out",
   "license": "GPL-3.0-or-later",
   "repository": {

package/dist/chunks/chunk-5DHOFF4C.js

@@ -1,322 +0,0 @@
-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/walkRows.ts
-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 NodeTable = class {
-  constructor(graph) {
-    this.index = /* @__PURE__ */ new Map();
-    this.ids = [];
-    this.lengths = [];
-    this.onReference = new Uint8Array(0);
-    this.referenceStart = new Float64Array(0);
-    this.referenceEnd = new Float64Array(0);
-    for (const node of graph.nodes) {
-      this.lengths[this.indexOf(node.id)] = node.length;
-    }
-  }
-  indexOf(id) {
-    let i = this.index.get(id);
-    if (i === void 0) {
-      i = this.lengths.length;
-      this.index.set(id, i);
-      this.ids.push(id);
-      this.lengths.push(0);
-    }
-    return i;
-  }
-  nodesOf(path) {
-    const nodes = new Int32Array(path.nodeIds.length);
-    path.nodeIds.forEach((id, k) => {
-      nodes[k] = this.indexOf(id);
-    });
-    return nodes;
-  }
-  spanAt(steps, k) {
-    const node = k >= 0 && k < steps.length ? steps[k] : -1;
-    return node >= 0 && this.onReference[node] ? { start: this.referenceStart[node], end: this.referenceEnd[node] } : void 0;
-  }
-};
-function stepsOf(pieces, table) {
-  const out = [];
-  const gaps = [];
-  let end;
-  let previous;
-  for (const piece of pieces) {
-    if (end !== void 0 && piece.start !== void 0 && piece.start > end) {
-      gaps.push(gapParts(piece.start - end, previous?.after, piece.before));
-      out.push(-gaps.length);
-    }
-    let bp = 0;
-    for (const node of piece.nodes) {
-      out.push(node);
-      bp += table.lengths[node];
-    }
-    end = piece.start === void 0 ? void 0 : piece.start + bp;
-    previous = piece;
-  }
-  return { steps: Float64Array.from(out), gaps };
-}
-function stepSpan(pieces, table, k) {
-  let end;
-  let at = 0;
-  let found;
-  for (const piece of pieces) {
-    if (piece.start === void 0 || end !== void 0 && piece.start < end) {
-      return void 0;
-    }
-    if (end !== void 0 && piece.start > end) {
-      if (at++ === k) {
-        found = { start: end, end: piece.start };
-      }
-    }
-    let pos = piece.start;
-    for (const node of piece.nodes) {
-      const len = table.lengths[node];
-      if (at++ === k) {
-        found = { start: pos, end: pos + len };
-      }
-      pos += len;
-    }
-    end = pos;
-  }
-  return found;
-}
-function sliceBetween(steps, table, region, flanked = true) {
-  if (!region || !flanked) {
-    return { ids: steps, complete: true, from: -1, to: -1 };
-  }
-  const { onReference, referenceStart, referenceEnd } = table;
-  let i0 = -1;
-  let i1 = -1;
-  let bestEnd = -Infinity;
-  let bestStart = Infinity;
-  for (let i = 0; i < steps.length; i++) {
-    const node = steps[i];
-    if (node >= 0 && onReference[node]) {
-      const end2 = referenceEnd[node];
-      const start = referenceStart[node];
-      if (end2 <= region.start && end2 > bestEnd) {
-        bestEnd = end2;
-        i0 = i;
-      }
-      if (start >= region.end && start < bestStart) {
-        bestStart = start;
-        i1 = i;
-      }
-    }
-  }
-  if (i0 >= 0 && i1 >= 0) {
-    const ids2 = steps.slice(Math.min(i0, i1) + 1, Math.max(i0, i1));
-    return {
-      ids: i0 < i1 ? ids2 : ids2.reverse(),
-      complete: true,
-      from: i0,
-      to: i1
-    };
-  }
-  const spanAt = (k) => table.spanAt(steps, k);
-  const flank = i0 >= 0 ? i0 : i1;
-  let near = -1;
-  for (let d = 1; flank >= 0 && near < 0 && d < steps.length; d++) {
-    near = [flank - d, flank + d].find((j) => spanAt(j) !== void 0) ?? -1;
-  }
-  if (near < 0) {
-    return { ids: steps, complete: false, from: -1, to: -1 };
-  }
-  const forward = near > flank === spanAt(near).start > spanAt(flank).start;
-  const after = forward === (flank === i0);
-  const ids = after ? steps.slice(flank + 1) : steps.slice(0, flank).reverse();
-  const last = ids.length > 0 ? ids.length - 1 : -1;
-  const end = last < 0 ? spanAt(flank) : spanAt(after ? flank + 1 + last : 0);
-  const stop = {
-    contigEnds: end !== void 0,
-    shortBp: !end ? 0 : Math.max(0, region.start - end.end, end.start - region.end)
-  };
-  return {
-    ids,
-    complete: false,
-    from: flank,
-    to: after ? steps.length : -1,
-    stop
-  };
-}
-function filterSamples(rows, samples) {
-  return samples ? rows.filter((r) => samples.includes(r.sample)).sort(
-    (a, b) => samples.indexOf(a.sample) - samples.indexOf(b.sample) || a.label.localeCompare(b.label)
-  ) : rows;
-}
-function referenceWalkName(graph) {
-  const names = (graph.paths ?? []).map((p) => pathOrigin(p.name).name);
-  if (graph.referencePath !== void 0 && names.includes(graph.referencePath)) {
-    return graph.referencePath;
-  }
-  const rankZero = new Set(
-    graph.nodes.flatMap((n) => n.stable?.rank === 0 ? [n.stable.refName] : [])
-  );
-  return names.find((n) => rankZero.has(n)) ?? names[0];
-}
-function walkRows(graph, region, unit, o = {}) {
-  const paths = graph.paths ?? [];
-  const nameOf = (p) => pathOrigin(p.name).name;
-  const referenceName = referenceWalkName(graph);
-  const referencePieces = paths.filter((p) => nameOf(p) === referenceName).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
-  const first = referencePieces[0];
-  const others = paths.filter((p) => !referencePieces.includes(p));
-  if (!first || others.length === 0) {
-    return void 0;
-  }
-  const walks = groupBy(others, nameOf);
-  const table = new NodeTable(graph);
-  const referenceStart = first.start ?? 0;
-  const cut = region && region.end > region.start ? region : void 0;
-  const referenceNodes = referencePieces.map((piece) => table.nodesOf(piece));
-  const nodeCount = table.lengths.length;
-  table.onReference = new Uint8Array(nodeCount);
-  table.referenceStart = new Float64Array(nodeCount);
-  table.referenceEnd = new Float64Array(nodeCount);
-  let reachesBefore = false;
-  let reachesAfter = false;
-  for (const [p, piece] of referencePieces.entries()) {
-    let pos = piece.start ?? 0;
-    for (const node of referenceNodes[p]) {
-      const len = table.lengths[node];
-      if (!table.onReference[node]) {
-        table.onReference[node] = 1;
-        table.referenceStart[node] = pos;
-        table.referenceEnd[node] = pos + len;
-        reachesBefore ||= cut !== void 0 && pos + len <= cut.start;
-        reachesAfter ||= cut !== void 0 && pos >= cut.end;
-      }
-      pos += len;
-    }
-  }
-  const flanked = cut === void 0 || reachesBefore && reachesAfter;
-  const rowOf = (paths2, nodes) => {
-    const path = paths2[0];
-    const pieces = paths2.map((piece, p) => ({
-      start: piece.start,
-      nodes: nodes?.[p] ?? table.nodesOf(piece),
-      before: piece.before,
-      after: piece.after
-    })).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
-    const { steps, gaps } = stepsOf(pieces, table);
-    const { ids, complete, from, to, stop } = sliceBetween(
-      steps,
-      table,
-      cut,
-      flanked
-    );
-    const contig = path.contig ?? panSNContig(pathOrigin(path.name).name);
-    const axisSpan = stepSpan(pieces, table, from < 0 ? 0 : from);
-    const axis = !axisSpan ? void 0 : from < 0 ? { contig, start: axisSpan.start, reversed: false } : from < to ? { contig, start: axisSpan.end, reversed: false } : { contig, start: axisSpan.start, reversed: true };
-    const {
-      ids: nodeIds,
-      lengths,
-      onReference,
-      referenceStart: referenceStart2,
-      referenceEnd
-    } = table;
-    const runs = [];
-    const visits = o.visits ? [] : void 0;
-    let last;
-    let bp = 0;
-    let offReferenceBp = 0;
-    let gapBp = 0;
-    let step = 0;
-    const backwards = from >= 0 && from > to;
-    for (const node of ids) {
-      if (node < 0) {
-        const parts = gaps[-node - 1];
-        for (const { bp: partBp, ...why } of backwards ? [...parts].reverse() : parts) {
-          last = {
-            start: bp,
-            bp: partBp,
-            onReference: false,
-            gap: true,
-            ...why
-          };
-          runs.push(last);
-          bp += partBp;
-          gapBp += partBp;
-        }
-        step = 0;
-        continue;
-      }
-      const len = lengths[node];
-      const on = onReference[node] === 1;
-      visits?.push({ node: nodeIds[node], start: bp, onReference: on });
-      const at = last?.referenceStart;
-      const forward = on && at !== void 0 && step >= 0 && at + last.bp === referenceStart2[node];
-      const backward = on && at !== void 0 && step <= 0 && referenceEnd[node] === at;
-      if (!on && last && !last.onReference && !last.gap) {
-        last.bp += len;
-      } else if (forward || backward) {
-        last.bp += len;
-        if (!forward) {
-          last.referenceStart = referenceStart2[node];
-          last.reversed = true;
-        }
-        step = forward ? 1 : -1;
-      } else {
-        last = {
-          start: bp,
-          bp: len,
-          onReference: on,
-          referenceStart: on ? referenceStart2[node] : void 0
-        };
-        runs.push(last);
-        step = 0;
-      }
-      bp += len;
-      if (!on) {
-        offReferenceBp += len;
-      }
-    }
-    return {
-      name: path.name,
-      label: labelOf(path),
-      sample: sampleOf(path),
-      haplotype: path.haplotype,
-      bp,
-      offReferenceBp,
-      gapBp,
-      complete,
-      stop,
-      runs,
-      visits,
-      axis
-    };
-  };
-  const origin = cut ? cut.start : referenceStart;
-  return {
-    origin,
-    unit,
-    reference: rowOf(referencePieces, referenceNodes),
-    rows: [...walks.values()].map((paths2) => rowOf(paths2)).sort(
-      (a, b) => Number(b.complete) - Number(a.complete) || b.bp - a.bp || a.label.localeCompare(b.label)
-    )
-  };
-}
-
-export {
-  filterSamples,
-  referenceWalkName,
-  walkRows
-};