@jbrowse/bandage-core 0.1.5 → 0.1.7

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

@@ -21,6 +21,12 @@ export type { TubeMapFrame, TubeMapPicture } from './tubeMap/draw.js';
 export { referenceKnots, warpX } from './tubeMap/warp.js';
 export { tubeMapFrame, tubeMapNodeAt } from './tubeMap/frame.js';
 export type { TubeMapTransform, TubeMapView } from './tubeMap/frame.js';
+export { drawTubeMapRuler, referenceBoxes, rulerBoxes, tubeX, } from './tubeMap/axis.js';
+export type { Box as TubeMapBox, ReferenceBoxes } from './tubeMap/axis.js';
+export { drawTubeMapGenes, tubeMapGenes } from './tubeMap/genes.js';
+export type { TubeMapGene } from './tubeMap/genes.js';
+export { connectorAt, drawTubeMapConnectors, referenceNodes, tubeMapConnectors, } from './tubeMap/connectors.js';
+export type { Connector, ReferenceNode } from './tubeMap/connectors.js';
 export type { TubeMapColumn, TubeMapDrawing } from './layout/tubeMapLayout.js';
 export { deletionEdges } from './deletionEdges.js';
 export type { DeletionEdge } from './deletionEdges.js';
@@ -41,6 +47,8 @@ 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, 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';
 export { cutWindowGFA, haplotypeWanted, referencePathQuery, referenceSamplesOf, resolveReferenceSample, } from './gbzWindow.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

@@ -3,11 +3,14 @@ export interface WalkRun {
     start: number;
     bp: number;
     onReference: boolean;
+    referenceStart?: number;
+    reversed?: true;
 }
 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,13 +54,17 @@ 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): {
+}, paneWidth: number, paneHeight: number, pixelRows: boolean, { minScale, padLeft, padTop }?: {
+    minScale?: number | undefined;
+    padLeft?: number | undefined;
+    padTop?: number | undefined;
+}): {
     scale: number;
     translateX: number;
     translateY: number;

package/dist/types/reference.d.ts

@@ -0,0 +1,25 @@
+import type { Graph, PathOrigin } from './types.js';
+export interface BackboneContig {
+    refName: string;
+    contig: string;
+    start: number;
+    end: number;
+}
+export interface Backbone {
+    contigs: BackboneContig[];
+    prefixes: string[];
+    named: boolean;
+}
+export interface AssemblyNames {
+    name: string;
+    aliases?: string[];
+}
+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;
+}>(features: readonly T[], backbone: Backbone): T[];

package/dist/types/renderer/GeometryBuilder.d.ts

@@ -29,6 +29,7 @@ export interface BuildOptions {
 }
 export declare function hslToRgb(h: number, s: number, l: number): [number, number, number];
 export declare const REFERENCE_RAMP_MAX_HUE = 300;
+export declare const REFERENCE_RAMP_ALT_CSS: string;
 export interface ReferenceRamp {
     start: number;
     span: number;

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

@@ -0,0 +1,35 @@
+import type { TubeMapFrame } from './draw.js';
+import type { Graph } from '../types.js';
+import type { TubeMapLayout } from '@gmod/tubemap-core';
+export interface Box {
+    bp0: number;
+    bp1: number;
+    x0: number;
+    x1: number;
+}
+export declare function referenceBoxes(graph: Graph, layout: TubeMapLayout): Map<string, Box[]>;
+export type ReferenceBoxes = ReturnType<typeof referenceBoxes>;
+export declare function tubeX(boxes: readonly Box[], bp: number, isEnd?: boolean): number;
+export declare function tubeSpan(boxes: readonly Box[], start: number, end: number): {
+    x0: number;
+    x1: number;
+};
+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;
+    ticks: number[];
+    squeezed: {
+        x0: number;
+        x1: number;
+    }[];
+    labels: {
+        text: string;
+        at: number;
+    }[];
+}
+export declare function rulerMarks(boxes: readonly Box[], x: (tx: number) => number, width: number, measure: (text: string) => number): RulerMarks | undefined;
+export declare function drawTubeMapRuler(ctx: CanvasRenderingContext2D, boxes: readonly Box[], frame: TubeMapFrame, top: number): void;

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/connectors.d.ts

@@ -0,0 +1,23 @@
+import type { Graph } from '../types.js';
+import type { TubeMapLayout } from '@gmod/tubemap-core';
+export interface ReferenceNode {
+    node: string;
+    bp0: number;
+    bp1: number;
+    x0: number;
+    x1: number;
+}
+export interface Connector {
+    node: string;
+    top0: number;
+    top1: number;
+    bottom0: number;
+    bottom1: number;
+}
+export declare function referenceNodes(graph: Graph, layout: TubeMapLayout): ReferenceNode[];
+export declare function tubeMapConnectors(nodes: readonly ReferenceNode[], bpToScreen: (bp: number) => number, tubeToScreen: (tx: number) => number, width: number): Connector[];
+export declare function connectorAt(connectors: readonly Connector[], zoneBottom: number, sx: number, sy: number): string | undefined;
+export declare function drawTubeMapConnectors(ctx: CanvasRenderingContext2D, connectors: readonly Connector[], bottom: number, { highlightNode, darkMode, }: {
+    highlightNode?: string | null;
+    darkMode?: boolean;
+}): void;

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/draw.d.ts

@@ -47,6 +47,7 @@ interface Layer {
     shapes: Shape[];
 }
 export interface TubeMapPicture {
+    bounds: TubeMapLayout['bounds'];
     layers: Layer[];
     nodes: {
         name: string;

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

@@ -12,4 +12,4 @@ export interface TubeMapTransform {
     yScale: number;
 }
 export declare function tubeMapFrame(drawing: TubeMapDrawing, view: TubeMapView): TubeMapTransform;
-export declare function tubeMapNodeAt(drawing: TubeMapDrawing, { x, y }: TubeMapTransform, sx: number, sy: number): null;
+export declare function tubeMapNodeAt(drawing: TubeMapDrawing, { x, y }: TubeMapTransform, sx: number, sy: number): string | null;

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

@@ -0,0 +1,16 @@
+import type { ReferenceBoxes } from './axis.js';
+import type { TubeMapFrame } from './draw.js';
+import type { GeneModel } from '../genes/genePins.js';
+export interface TubeMapGene {
+    gene: GeneModel;
+    x0: number;
+    x1: number;
+    exons: {
+        x0: number;
+        x1: number;
+    }[];
+}
+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.5",
+  "version": "0.1.7",
   "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": {