@jbrowse/bandage-core 0.1.6 → 0.1.8

package/README.md

@@ -14,8 +14,9 @@ npm install @jbrowse/bandage-core
 - A Canvas2D renderer (`buildGeometry`, `Canvas2DRenderer`), hit testing and
   label placement
 - Bubbles, deletion edges, path colors, gbz-base windows cut to GFA
-- Which assembly a backbone lies on (`graphBackbone`, `backboneAssembly`), and
-  the genes on it (`featuresOnBackbone`, `genePins`)
+- Which assembly a backbone lies on (`graphBackbone`, `backboneAssembly`,
+  `assemblyWalk`), and the genes on it: `featuresOnBackbone` renames an
+  assembly's genes onto the backbone's refNames, and `genePins` pins only those
 
 Nothing here imports React, MobX or a JBrowse host. BandageJS's
 [`src/main.ts`](https://github.com/cmdcolin/BandageJS/blob/main/src/main.ts) is

package/dist/index.js

@@ -971,13 +971,13 @@ var MAX_ZOOM = 100;
 function clampZoom(zoom) {
   return Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoom));
 }
-function fittedTranslateY(bounds, usableHeight, yScale) {
+function fittedTranslateY(bounds, usableHeight, yScale, padTop = FIT_PADDING) {
   const leftoverY = usableHeight - bounds.h * yScale;
-  return FIT_PADDING - bounds.minY * yScale + Math.max(0, leftoverY) / 2;
+  return padTop - bounds.minY * yScale + Math.max(0, leftoverY) / 2;
 }
-function fitTransform(bounds, paneWidth, paneHeight, pixelRows, { minScale = 0, padLeft = FIT_PADDING } = {}) {
+function fitTransform(bounds, paneWidth, paneHeight, pixelRows, { minScale = 0, padLeft = FIT_PADDING, padTop = FIT_PADDING } = {}) {
   const usableWidth = paneWidth - padLeft - FIT_PADDING;
-  const usableHeight = paneHeight - FIT_PADDING * 2;
+  const usableHeight = paneHeight - padTop - FIT_PADDING;
   if (usableWidth <= 0 || usableHeight <= 0 || !(bounds.w > 0 || !pixelRows && bounds.h > 0)) {
     return void 0;
   }
@@ -990,7 +990,12 @@ function fitTransform(bounds, paneWidth, paneHeight, pixelRows, { minScale = 0,
   return {
     scale,
     translateX: padLeft - bounds.minX * scale + Math.max(0, leftoverX) / 2,
-    translateY: fittedTranslateY(bounds, usableHeight, pixelRows ? 1 : scale)
+    translateY: fittedTranslateY(
+      bounds,
+      usableHeight,
+      pixelRows ? 1 : scale,
+      padTop
+    )
   };
 }
 function drawingBounds(layout, opts = {}) {
@@ -2065,6 +2070,7 @@ function walkRows(graph, region, unit) {
       name: path.name,
       label: labelOf(path),
       sample: sampleOf(path),
+      haplotype: path.haplotype,
       bp,
       offReferenceBp,
       complete,
@@ -4748,9 +4754,9 @@ function tubeSpan(boxes, start, end) {
   const b = tubeX(boxes, end, true);
   return { x0: Math.min(a, b), x1: Math.max(a, b) };
 }
-function rulerBoxes(byContig) {
+function rulerBoxes(byRefName) {
   let best;
-  for (const boxes of byContig.values()) {
+  for (const boxes of byRefName.values()) {
     if (!best || boxes.length > best.length) {
       best = boxes;
     }
@@ -4762,6 +4768,9 @@ var LABEL_GAP_PX2 = 10;
 var TARGET_TICK_PX = 110;
 var ZIGZAG_PX = 4;
 var ZIGZAG_AMPLITUDE_PX = 2.5;
+function rulerInk(darkMode) {
+  return darkMode ? "#b0b0b8" : "#55555c";
+}
 function niceStep(raw) {
   const pow = 10 ** Math.floor(Math.log10(raw));
   const m = raw / pow;
@@ -4844,7 +4853,7 @@ function drawTubeMapRuler(ctx, boxes, frame, top) {
   if (!marks) {
     return;
   }
-  const ink = darkMode ? "#b0b0b8" : "#55555c";
+  const ink = rulerInk(darkMode);
   const y = top + 0.5;
   ctx.strokeStyle = ink;
   ctx.fillStyle = ink;
@@ -4868,79 +4877,11 @@ function drawTubeMapRuler(ctx, boxes, frame, top) {
   }
 }
 
-// src/reference.ts
-var WELL_KNOWN_SAMPLES = /* @__PURE__ */ new Map([
-  ["hg38", "GRCh38"],
-  ["hg19", "GRCh37"],
-  ["hs1", "CHM13"],
-  ["t2t-chm13", "CHM13"],
-  ["chm13v2", "CHM13"]
-]);
-function wellKnownSample(assemblyName) {
-  return WELL_KNOWN_SAMPLES.get(assemblyName.toLowerCase());
-}
-function sharedPrefixes(refNames) {
-  return [panSNSample, panSNHaplotype].flatMap((prefixOf) => {
-    const prefixes = new Set(
-      refNames.map((n) => n.includes("#") ? prefixOf(n) : void 0)
-    );
-    const [only] = prefixes;
-    return prefixes.size === 1 && only ? [only] : [];
-  });
-}
-function graphBackbone(graph) {
-  const spans = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    if (isBackbone(node)) {
-      const { refName, start } = node.stable;
-      const end = start + node.length;
-      const span = spans.get(refName);
-      if (span) {
-        span.start = Math.min(span.start, start);
-        span.end = Math.max(span.end, end);
-      } else {
-        spans.set(refName, {
-          refName,
-          contig: panSNContig(refName),
-          start,
-          end
-        });
-      }
-    }
-  }
-  const contigs = [...spans.values()];
-  return contigs.length ? { contigs, prefixes: sharedPrefixes(contigs.map((c) => c.refName)) } : void 0;
-}
-function backboneAssembly(backbone, assemblies) {
-  const prefixes = new Set(backbone?.prefixes.map((p) => p.toLowerCase()));
-  const names = (a) => [a.name, ...a.aliases ?? []];
-  const named = (candidates) => candidates.some((n) => n !== void 0 && prefixes.has(n.toLowerCase()));
-  return assemblies.find((a) => named(names(a))) ?? assemblies.find((a) => named(names(a).map(wellKnownSample)));
-}
-function refNameBinding(refNames) {
-  const exact = new Set(refNames);
-  const byContig = /* @__PURE__ */ new Map();
-  for (const refName of exact) {
-    const contig = panSNContig(refName);
-    byContig.set(contig, byContig.has(contig) ? void 0 : refName);
-  }
-  return (name) => exact.has(name) ? name : byContig.get(name);
-}
-function featuresOnBackbone(features, backbone) {
-  const bind = refNameBinding(backbone.contigs.map((c) => c.refName));
-  return features.flatMap((f) => {
-    const refName = bind(f.refName);
-    return refName === void 0 ? [] : [refName === f.refName ? f : { ...f, refName }];
-  });
-}
-
 // src/tubeMap/genes.ts
 function tubeMapGenes(byRefName, genes) {
   const out = [];
-  const bind = refNameBinding(byRefName.keys());
   for (const gene of genes) {
-    const refName = bind(gene.refName);
-    const boxes = refName === void 0 ? void 0 : byRefName.get(refName);
+    const boxes = byRefName.get(gene.refName);
     const first = boxes?.[0];
     const last = boxes?.at(-1);
     if (!boxes || !first || !last) {
@@ -4961,13 +4902,13 @@ function tubeMapGenes(byRefName, genes) {
   }
   return out;
 }
-var ROW_PX = 22;
+var GENE_ROW_PX = 22;
 var EXON_PX = 8;
 var NAME_FONT = "11px sans-serif";
 var NAME_GAP_PX = 8;
 function drawTubeMapGenes(ctx, genes, frame, bottom, top = 0) {
   const { x, width, darkMode } = frame;
-  const rows = Math.max(1, Math.floor((bottom - top) / ROW_PX));
+  const rows = Math.max(1, Math.floor((bottom - top) / GENE_ROW_PX));
   const rowEnds = [];
   const ink = darkMode ? "#e0e0e6" : "#1c1c22";
   ctx.font = NAME_FONT;
@@ -4989,7 +4930,7 @@ function drawTubeMapGenes(ctx, genes, frame, bottom, top = 0) {
       row = Math.min(rowEnds.length, rows - 1);
     }
     rowEnds[row] = Math.max(rowEnds[row] ?? -Infinity, right);
-    const glyphY = bottom - row * ROW_PX - EXON_PX / 2;
+    const glyphY = bottom - row * GENE_ROW_PX - EXON_PX / 2;
     ctx.beginPath();
     ctx.moveTo(s0, glyphY + 0.5);
     ctx.lineTo(s1, glyphY + 0.5);
@@ -5644,11 +5585,9 @@ function layoutLabels(m) {
 // src/genes/genePins.ts
 function genePins(graph, genes, positions) {
   const byRefName = /* @__PURE__ */ new Map();
-  const refNames = /* @__PURE__ */ new Set();
   for (const node of graph.nodes) {
     if (isBackbone(node)) {
       const { refName } = node.stable;
-      refNames.add(refName);
       if (positions[node.id]?.length) {
         const entry = byRefName.get(refName) ?? byRefName.set(refName, { nodes: [], reach: 0 }).get(refName);
         entry.nodes.push(node);
@@ -5659,11 +5598,9 @@ function genePins(graph, genes, positions) {
   for (const { nodes } of byRefName.values()) {
     nodes.sort((a, b) => a.stable.start - b.stable.start);
   }
-  const bind = refNameBinding(refNames);
   const pins = [];
   for (const gene of genes) {
-    const refName = bind(gene.refName);
-    const backbone = refName === void 0 ? void 0 : byRefName.get(refName);
+    const backbone = byRefName.get(gene.refName);
     if (!backbone) {
       continue;
     }
@@ -5722,6 +5659,135 @@ function genePins(graph, genes, positions) {
   return pins;
 }
 
+// src/reference.ts
+var WELL_KNOWN_SAMPLES = /* @__PURE__ */ new Map([
+  ["hg38", "GRCh38"],
+  ["hg19", "GRCh37"],
+  ["hs1", "CHM13"],
+  ["t2t-chm13", "CHM13"],
+  ["chm13v2", "CHM13"]
+]);
+function wellKnownSample(assemblyName) {
+  return WELL_KNOWN_SAMPLES.get(assemblyName.toLowerCase());
+}
+var GENERIC_SAMPLES = /* @__PURE__ */ new Set(["_gbwt_ref"]);
+function sampleOf2(refName) {
+  const sample = refName.includes("#") ? panSNSample(refName) : void 0;
+  return sample === void 0 || GENERIC_SAMPLES.has(sample) ? void 0 : sample;
+}
+function haplotypeOf(refName) {
+  return panSNHaplotype(refName) ?? panSNSample(refName);
+}
+function graphHaplotypes(graph) {
+  const refNames = new Set((graph.anchorPaths ?? []).map((p) => p.name));
+  for (const node of graph.nodes) {
+    if (node.stable) {
+      refNames.add(node.stable.refName);
+    }
+  }
+  const bySample = /* @__PURE__ */ new Map();
+  for (const refName of refNames) {
+    const sample = sampleOf2(refName);
+    if (sample !== void 0) {
+      const haplotypes = bySample.get(sample) ?? bySample.set(sample, /* @__PURE__ */ new Set()).get(sample);
+      haplotypes.add(haplotypeOf(refName));
+    }
+  }
+  return bySample;
+}
+function backboneFrom(contigs, haplotypes) {
+  const samples = new Set(contigs.map((c) => sampleOf2(c.refName)));
+  const [sample] = samples;
+  if (samples.size !== 1 || sample === void 0) {
+    return { contigs, prefixes: [], named: false };
+  }
+  const own = new Set(contigs.map((c) => haplotypeOf(c.refName)));
+  const unique = [...haplotypes.get(sample) ?? []].every((h) => own.has(h));
+  const shared = new Set(contigs.map((c) => panSNHaplotype(c.refName)));
+  const [haplotype] = shared;
+  return {
+    contigs,
+    prefixes: [
+      ...unique ? [sample] : [],
+      ...shared.size === 1 && haplotype ? [haplotype] : []
+    ],
+    named: true
+  };
+}
+function graphBackbone(graph) {
+  const spans = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      const { refName, start } = node.stable;
+      const end = start + node.length;
+      const span = spans.get(refName);
+      if (span) {
+        span.start = Math.min(span.start, start);
+        span.end = Math.max(span.end, end);
+      } else {
+        spans.set(refName, {
+          refName,
+          contig: panSNContig(refName),
+          start,
+          end
+        });
+      }
+    }
+  }
+  const contigs = [...spans.values()];
+  return contigs.length ? backboneFrom(contigs, graphHaplotypes(graph)) : void 0;
+}
+function backboneAssembly(backbone, assemblies) {
+  const names = (a) => [a.name, ...a.aliases ?? []];
+  const naming = (prefix) => (a) => names(a).some((n) => n.toLowerCase() === prefix.toLowerCase());
+  const prefixes = [...backbone?.prefixes ?? []].reverse();
+  const sample = backbone?.prefixes.find((p) => !p.includes("#"))?.toLowerCase();
+  for (const prefix of prefixes) {
+    const assembly = assemblies.find(naming(prefix));
+    if (assembly) {
+      return assembly;
+    }
+  }
+  return sample === void 0 ? void 0 : assemblies.find(
+    (a) => names(a).some((n) => wellKnownSample(n)?.toLowerCase() === sample)
+  );
+}
+function assemblyWalk(graph, assembly) {
+  const haplotypes = graphHaplotypes(graph);
+  return graph.anchorPaths?.find(
+    (walk) => backboneAssembly(
+      backboneFrom(
+        [
+          {
+            refName: walk.name,
+            contig: panSNContig(walk.name),
+            start: walk.start,
+            end: walk.start + walk.length
+          }
+        ],
+        haplotypes
+      ),
+      [assembly]
+    )
+  );
+}
+function refNameBinding(refNames) {
+  const exact = new Set(refNames);
+  const byContig = /* @__PURE__ */ new Map();
+  for (const refName of exact) {
+    const contig = panSNContig(refName);
+    byContig.set(contig, byContig.has(contig) ? void 0 : refName);
+  }
+  return (name) => exact.has(name) ? name : byContig.get(name);
+}
+function featuresOnBackbone(features, backbone) {
+  const bind = refNameBinding(backbone.contigs.map((c) => c.refName));
+  return features.flatMap((f) => {
+    const refName = bind(f.refName);
+    return refName === void 0 ? [] : [refName === f.refName ? f : { ...f, refName }];
+  });
+}
+
 // src/gbzWindow.ts
 var NoReferenceSampleError = class extends Error {
   constructor(anchor, referenceSamples) {
@@ -5867,6 +5933,7 @@ export {
   REFERENCE_RAMP_MAX_HUE,
   ROW_HEIGHT_PX,
   WELL_KNOWN_SAMPLES,
+  assemblyWalk,
   axisScaleOf,
   backboneAssembly,
   bubbleHalos,

package/dist/types/colorSchemes.d.ts

@@ -29,5 +29,5 @@ export declare const COLOR_SCHEMES: readonly [{
 }];
 export type ColorScheme = (typeof COLOR_SCHEMES)[number]['value'];
 export type ResolvedColorScheme = Exclude<ColorScheme, 'auto'>;
-export declare const COLOR_SCHEME_VALUES: ("auto" | "uniform" | "random" | "rainbow" | "depth" | "node-length" | "stable-rank" | "reference-position" | "grey")[];
+export declare const COLOR_SCHEME_VALUES: ("depth" | "auto" | "uniform" | "random" | "rainbow" | "node-length" | "stable-rank" | "reference-position" | "grey")[];
 export declare function resolveColorScheme(scheme: ColorScheme, graph: Graph | undefined): ResolvedColorScheme;

package/dist/types/index.d.ts

@@ -47,7 +47,7 @@ export type { BubbleGlyph, LabelLayout, LabelLayoutSource } from './labelLayout.
 export { formatBp } from './graphLabels.js';
 export { genePins } from './genes/genePins.js';
 export type { GeneModel, GenePin } from './genes/genePins.js';
-export { WELL_KNOWN_SAMPLES, backboneAssembly, featuresOnBackbone, graphBackbone, refNameBinding, wellKnownSample, } from './reference.js';
+export { WELL_KNOWN_SAMPLES, assemblyWalk, backboneAssembly, featuresOnBackbone, graphBackbone, refNameBinding, wellKnownSample, } from './reference.js';
 export type { AssemblyNames, Backbone, BackboneContig } from './reference.js';
 export { LABEL_CHAR_PX, LABEL_PAD, LABEL_PX } from './overlayLabels.js';
 export type { Graph, GraphEdge, GraphNode, LayoutResult, NodeSegment, } from './types.js';

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

@@ -1,3 +1,4 @@
+import type { Coarsened } from '../tubeMap/coarsen.js';
 import type { Graph, LayoutResult } from '../types.js';
 import type { InputTrack, TubeMapLayout } from '@gmod/tubemap-core';
 export interface TubeMapColumn {
@@ -11,7 +12,9 @@ export interface TubeMapDrawing {
     layout: TubeMapLayout;
     yOffset: number;
     columns?: TubeMapColumn[];
+    coarse?: Coarsened;
 }
+export declare function visitStrands(graph: Graph): Map<string, ("+" | "-")[]>;
 export declare function tubeMapTracks(graph: Graph): InputTrack[];
 export declare function hasTubeMapPaths(graph: Graph): boolean;
 export declare function tubeWidth(trackCount: number): number;

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

@@ -10,6 +10,7 @@ export interface WalkRow {
     name: string;
     label: string;
     sample: string;
+    haplotype?: number;
     bp: number;
     offReferenceBp: number;
     complete: boolean;

package/dist/types/nodeWidths.d.ts

@@ -10,7 +10,7 @@ export declare const NODE_WIDTHS: readonly [{
     readonly description: "Every node the same thickness.";
 }];
 export type NodeWidth = (typeof NODE_WIDTHS)[number]['value'];
-export declare const NODE_WIDTH_VALUES: ("uniform" | "depth")[];
+export declare const NODE_WIDTH_VALUES: ("depth" | "uniform")[];
 export declare function meanDepth(graph: Graph): number;
 export declare function depthWidthFactor(node: GraphNode, mean: number): number;
 export declare function nodeWidthPx(node: GraphNode, contigThickness: number, nodeWidth: NodeWidth, mean: number): number;

package/dist/types/pipeline.d.ts

@@ -54,15 +54,16 @@ export declare function clampZoom(zoom: number): number;
 export declare function fittedTranslateY(bounds: {
     minY: number;
     h: number;
-}, usableHeight: number, yScale: number): number;
+}, usableHeight: number, yScale: number, padTop?: number): number;
 export declare function fitTransform(bounds: {
     minX: number;
     minY: number;
     w: number;
     h: number;
-}, paneWidth: number, paneHeight: number, pixelRows: boolean, { minScale, padLeft }?: {
+}, paneWidth: number, paneHeight: number, pixelRows: boolean, { minScale, padLeft, padTop }?: {
     minScale?: number | undefined;
     padLeft?: number | undefined;
+    padTop?: number | undefined;
 }): {
     scale: number;
     translateX: number;

package/dist/types/reference.d.ts

@@ -1,4 +1,4 @@
-import type { Graph } from './types.js';
+import type { Graph, PathOrigin } from './types.js';
 export interface BackboneContig {
     refName: string;
     contig: string;
@@ -8,6 +8,7 @@ export interface BackboneContig {
 export interface Backbone {
     contigs: BackboneContig[];
     prefixes: string[];
+    named: boolean;
 }
 export interface AssemblyNames {
     name: string;
@@ -17,6 +18,7 @@ export declare const WELL_KNOWN_SAMPLES: ReadonlyMap<string, string>;
 export declare function wellKnownSample(assemblyName: string): string | undefined;
 export declare function graphBackbone(graph: Graph): Backbone | undefined;
 export declare function backboneAssembly<T extends AssemblyNames>(backbone: Backbone | undefined, assemblies: T[]): T | undefined;
+export declare function assemblyWalk(graph: Graph, assembly: AssemblyNames): PathOrigin | undefined;
 export declare function refNameBinding(refNames: Iterable<string>): (name: string) => string | undefined;
 export declare function featuresOnBackbone<T extends {
     refName: string;

package/dist/types/tubeMap/axis.d.ts

@@ -14,7 +14,10 @@ export declare function tubeSpan(boxes: readonly Box[], start: number, end: numb
     x0: number;
     x1: number;
 };
-export declare function rulerBoxes(byContig: ReferenceBoxes): Box[] | undefined;
+export declare function rulerBoxes(byRefName: ReferenceBoxes): Box[] | undefined;
+export declare const ZIGZAG_PX = 4;
+export declare const ZIGZAG_AMPLITUDE_PX = 2.5;
+export declare function rulerInk(darkMode?: boolean): "#b0b0b8" | "#55555c";
 export interface RulerMarks {
     from: number;
     to: number;

package/dist/types/tubeMap/coarsen.d.ts

@@ -0,0 +1,16 @@
+import type { Graph } from '../types.js';
+export interface Deviation {
+    start: number;
+    end: number;
+    bp: number;
+    inverted?: true;
+}
+export type CutCause = 'variant' | 'backward' | 'inversion' | 'walk-end' | 'overlap' | 'reference-gap';
+export interface Coarsened {
+    graph: Graph;
+    members: Map<string, string[]>;
+    coarseOf: Map<string, string>;
+    deviations: Map<string, Deviation[]>;
+    cuts: Map<number, CutCause>;
+}
+export declare function coarsenTubeMap(graph: Graph, sigma: number): Coarsened | undefined;

package/dist/types/tubeMap/deviations.d.ts

@@ -0,0 +1,13 @@
+import type { Deviation } from './coarsen.js';
+import type { TubeMapFrame } from './draw.js';
+import type { Graph } from '../types.js';
+import type { TubeMapLayout } from '@gmod/tubemap-core';
+export interface DeviationMark {
+    x0: number;
+    x1: number;
+    y: number;
+    height: number;
+}
+export declare function deviationMarks(graph: Graph, layout: TubeMapLayout, deviations: Map<string, Deviation[]>): DeviationMark[];
+export declare function deviationInk(darkMode?: boolean): "rgba(255,255,255,0.9)" | "rgba(0,0,0,0.8)";
+export declare function drawDeviationMarks(ctx: CanvasRenderingContext2D, marks: readonly DeviationMark[], { x, y, width, darkMode }: TubeMapFrame): void;

package/dist/types/tubeMap/genes.d.ts

@@ -11,4 +11,6 @@ export interface TubeMapGene {
     }[];
 }
 export declare function tubeMapGenes(byRefName: ReferenceBoxes, genes: readonly GeneModel[]): TubeMapGene[];
+export declare const GENE_ROW_PX = 22;
+export declare function tubeMapGeneRows(genes: readonly TubeMapGene[]): number;
 export declare function drawTubeMapGenes(ctx: CanvasRenderingContext2D, genes: readonly TubeMapGene[], frame: TubeMapFrame, bottom: number, top?: number): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/bandage-core",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "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": {