@jbrowse/bandage-core 8.2.0 → 9.1.0

package/dist/types/layoutModes.d.ts

@@ -1,7 +1,7 @@
 import { anchoredLayout } from './layout/anchoredLayout.js';
 import { orderedLayout } from './layout/orderedLayout.js';
 import { sampleRowLayout } from './layout/sampleRowLayout.js';
-import { hasTubeMapPaths, tubeMapLayout, tubeMapReferenceLayout } from './layout/tubeMapLayout.js';
+import { hasTubeMapBackbone, hasTubeMapPaths, tubeMapLayout, tubeMapReferenceLayout } from './layout/tubeMapLayout.js';
 import { walkRowLayout } from './layout/walkRowLayout.js';
 import type { Graph, LayoutResult } from './types.js';
 export declare const FORCE_LAYOUT_LABEL = "Force-directed layout";
@@ -76,8 +76,8 @@ export declare const LAYOUT_MODES: readonly [{
     readonly run: typeof tubeMapReferenceLayout;
     readonly cutMargins: true;
     readonly wholeWalks: false;
-    readonly available: (graph: Graph) => boolean;
-    readonly drawsLocally: (graph: Graph) => boolean;
+    readonly available: typeof hasTubeMapBackbone;
+    readonly drawsLocally: typeof hasTubeMapBackbone;
     readonly drawsNodes: false;
 }, {
     readonly value: "force";
@@ -150,8 +150,8 @@ export declare function layoutModeByValue(value: string): {
     readonly run: typeof tubeMapReferenceLayout;
     readonly cutMargins: true;
     readonly wholeWalks: false;
-    readonly available: (graph: Graph) => boolean;
-    readonly drawsLocally: (graph: Graph) => boolean;
+    readonly available: typeof hasTubeMapBackbone;
+    readonly drawsLocally: typeof hasTubeMapBackbone;
     readonly drawsNodes: false;
 } | {
     readonly value: "force";

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

@@ -16,9 +16,12 @@ export declare class Canvas2DRenderer implements Renderer {
     setEdgeHighlight(edgeIndex: number | null, factor: number): void;
     updateTransform(transform: TransformUniform): void;
     render(clearColor: [number, number, number, number]): void;
-    private renderEdges;
-    private renderNodes;
-    private renderArrows;
+    renderHighlights(): void;
+    private edgeRun;
+    private liftedStrokes;
+    private strokeCurves;
+    private strokeNodes;
+    private fillArrows;
     dispose(): void;
 }
 export declare function arrowheadOutline(a: Arrowhead, t: TransformUniform): readonly [{

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

@@ -1,13 +1,16 @@
 import type { TubeMapFrame } from './draw.js';
-import type { Graph } from '../types.js';
-import type { TubeMapLayout } from '@jbrowse/tubemap-core';
+import type { TubeMapDrawing } from '../layout/tubeMapLayout.js';
 export interface Box {
     bp0: number;
     bp1: number;
     x0: number;
     x1: number;
 }
-export declare function referenceBoxes(graph: Graph, layout: TubeMapLayout): Map<string, Box[]>;
+export interface ReferenceBox extends Box {
+    name: string;
+    index: number;
+}
+export declare function referenceBoxes({ graph, layout, }: Pick<TubeMapDrawing, 'graph' | 'layout'>): Map<string, ReferenceBox[]>;
 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): {

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

@@ -1,12 +1,4 @@
-import type { Graph } from '../types.js';
-import type { TubeMapLayout } from '@jbrowse/tubemap-core';
-export interface ReferenceNode {
-    node: string;
-    bp0: number;
-    bp1: number;
-    x0: number;
-    x1: number;
-}
+import type { ReferenceBox } from './axis.js';
 export interface Connector {
     node: string;
     top0: number;
@@ -14,10 +6,10 @@ export interface Connector {
     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 tubeMapConnectors(boxes: readonly ReferenceBox[], 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;
+export declare function drawLitConnector(ctx: CanvasRenderingContext2D, connectors: readonly Connector[], bottom: number, node: string | null | undefined): void;

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

@@ -1,13 +1,12 @@
 import type { Deviation } from './coarsen.js';
 import type { TubeMapFrame } from './draw.js';
-import type { Graph } from '../types.js';
-import type { TubeMapLayout } from '@jbrowse/tubemap-core';
+import type { TubeMapDrawing } from '../layout/tubeMapLayout.js';
 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 deviationMarks(drawing: Pick<TubeMapDrawing, 'graph' | 'layout'>, 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

@@ -32,7 +32,8 @@ type Command = {
 export declare function parsePath(d: string): Command[];
 interface Filled {
     color: string;
-    track?: number;
+    id: number;
+    haplotype: boolean;
     x0: number;
     x1: number;
 }
@@ -68,6 +69,9 @@ export interface TubeMapFrame extends TubeMapTransform {
     nodeColors?: ReadonlyMap<string, string>;
 }
 export declare function drawTubeMap(ctx: CanvasRenderingContext2D, picture: TubeMapPicture, frame: TubeMapFrame): void;
+export declare function drawTubeMapHighlight(ctx: CanvasRenderingContext2D, picture: TubeMapPicture, frame: TubeMapFrame): void;
 export declare function mismatchesLegible(yScale: number): boolean;
 export declare function mismatchOnScreen(m: TubeMapMismatch, { x, width }: Pick<TubeMapFrame, 'x' | 'width'>): boolean;
+export declare function tubeMapTrackAt(picture: TubeMapPicture, { x, y }: TubeMapTransform, sx: number, sy: number): number | undefined;
+export declare function tubeMapMismatchAt(picture: TubeMapPicture, frame: TubeMapTransform, sx: number, sy: number): TubeMapMismatch | undefined;
 export {};

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

@@ -3,7 +3,6 @@ interface MarkBase {
     readId: number;
     y: number;
     height: number;
-    nodeY: number;
 }
 export type TubeMapMismatch = (MarkBase & {
     kind: 'insertion';
@@ -14,6 +13,7 @@ export type TubeMapMismatch = (MarkBase & {
     kind: 'deletion';
     x0: number;
     x1: number;
+    length: number;
 }) | (MarkBase & {
     kind: 'substitution';
     x0: number;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "8.2.0";
+export declare const version = "9.1.0";

package/dist/version.js

@@ -1,6 +1,6 @@
 import {
   version
-} from "./chunks/chunk-3FXPFVKJ.js";
+} from "./chunks/chunk-UID3QBWH.js";
 export {
   version
 };

package/dist/viewport.js

@@ -5,14 +5,14 @@ import {
   screenToLayout,
   viewportOf,
   zoomAbout
-} from "./chunks/chunk-TL4B342F.js";
-import "./chunks/chunk-5OIVTEF7.js";
+} from "./chunks/chunk-MXDQGA7A.js";
+import "./chunks/chunk-OOXIMURX.js";
 import "./chunks/chunk-PUG7LXDF.js";
 import "./chunks/chunk-IGVV37VI.js";
+import "./chunks/chunk-OA7RIMZ2.js";
 import "./chunks/chunk-OCMBULGN.js";
 import "./chunks/chunk-QYBZZI5H.js";
 import "./chunks/chunk-CDLPYR5O.js";
-import "./chunks/chunk-OA7RIMZ2.js";
 import "./chunks/chunk-ES2N6V56.js";
 import "./chunks/chunk-ST2IBUAN.js";
 import "./chunks/chunk-BPLIXMH7.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/bandage-core",
-  "version": "8.2.0",
+  "version": "9.1.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-W2I4DOL4.js

@@ -1,230 +0,0 @@
-import {
-  canonicalStrand,
-  stepName,
-  tubeMapReads
-} from "./chunk-TEDQJPMI.js";
-import {
-  pathCssColor,
-  pathGreyCssColor
-} from "./chunk-7GBL7SJY.js";
-import {
-  pathOrigin
-} from "./chunk-ST2IBUAN.js";
-import {
-  isBackbone
-} from "./chunk-FYQWPEEY.js";
-
-// src/layout/tubeMapLayout.ts
-import { layoutTubeMap } from "@jbrowse/tubemap-core";
-function visitStrands(graph) {
-  const strands = /* @__PURE__ */ new Map();
-  for (const [segment, visits] of graph.pathVisits ?? []) {
-    for (const visit of visits) {
-      const key = `${visit.path}	${segment}`;
-      const list = strands.get(key);
-      if (list) {
-        list.push(visit.strand);
-      } else {
-        strands.set(key, [visit.strand]);
-      }
-    }
-  }
-  return strands;
-}
-function tubeMapTracks(graph) {
-  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
-  const strands = visitStrands(graph);
-  const paths = (graph.paths ?? []).map((path, index) => ({ path, index }));
-  const reference = paths.findIndex(
-    (p) => pathOrigin(p.path.name).name === graph.referencePath
-  );
-  if (reference > 0) {
-    paths.unshift(...paths.splice(reference, 1));
-  }
-  return paths.flatMap(({ path, index }) => {
-    const visitName = pathOrigin(path.name).name;
-    const seen = /* @__PURE__ */ new Map();
-    const sequence = path.nodeIds.flatMap((id) => {
-      const node = nodeById.get(id);
-      if (!node) {
-        return [];
-      }
-      const k = seen.get(node.name) ?? 0;
-      seen.set(node.name, k + 1);
-      const strand = strands.get(`${visitName}	${node.name}`)?.[k] ?? canonicalStrand(node);
-      return [stepName(node, strand)];
-    });
-    return sequence.length > 0 ? [
-      {
-        id: index,
-        name: path.name,
-        sequence,
-        sourceTrackID: 0,
-        type: "haplotype"
-      }
-    ] : [];
-  });
-}
-function tubeMapNodes(graph) {
-  return graph.nodes.map((n) => ({
-    name: n.id,
-    seq: "",
-    sequenceLength: Math.max(1, n.length)
-  }));
-}
-function hasTubeMapPaths(graph) {
-  return (graph.paths?.length ?? 0) > 0;
-}
-var STACK_PX = 600;
-var MIN_TUBE_PX = 3;
-var MAX_TUBE_PX = 15;
-function tubeWidth(trackCount) {
-  return Math.max(
-    MIN_TUBE_PX,
-    Math.min(MAX_TUBE_PX, Math.floor(STACK_PX / Math.max(1, trackCount)))
-  );
-}
-function runTubeMap(graph) {
-  const paths = graph.paths ?? [];
-  const tracks = tubeMapTracks(graph);
-  const reads = graph.reads ? tubeMapReads(graph, graph.reads, paths.length) : [];
-  const tubeColor = reads.length > 0 ? pathGreyCssColor : pathCssColor;
-  const pathColors = paths.map((_, i) => tubeColor(i, paths.length));
-  const layout = layoutTubeMap(tubeMapNodes(graph), tracks, reads, {
-    nodeWidthOption: "compressed",
-    trackWidth: tubeWidth(tracks.length)
-  });
-  return layout ? { layout, pathColors } : void 0;
-}
-function drawnNodes(layout) {
-  const nodes = [];
-  layout.nodes.forEach((node) => {
-    if (node.order >= 0) {
-      nodes.push(node);
-    }
-  });
-  return nodes;
-}
-function centreline(node, yOffset, x0, x1) {
-  const y = node.y + node.contentHeight / 2 - yOffset;
-  return [
-    { x: x0, y },
-    { x: x1, y }
-  ];
-}
-function extentOf(layout, yOffset) {
-  return {
-    minY: layout.bounds.minY - yOffset,
-    maxY: layout.bounds.maxY - yOffset
-  };
-}
-function tubeMapLayout(graph) {
-  const run = hasTubeMapPaths(graph) ? runTubeMap(graph) : void 0;
-  if (!run) {
-    return void 0;
-  }
-  const { layout, pathColors } = run;
-  const yOffset = layout.bounds.minY;
-  const nodePositions = {};
-  for (const node of drawnNodes(layout)) {
-    nodePositions[node.name] = centreline(
-      node,
-      yOffset,
-      node.x,
-      node.x + node.pixelWidth
-    );
-  }
-  const { minY, maxY } = extentOf(layout, yOffset);
-  return {
-    nodePositions,
-    tubeMap: { layout, yOffset, pathColors },
-    extent: {
-      minX: layout.bounds.minX,
-      maxX: layout.bounds.maxX,
-      minY,
-      maxY
-    }
-  };
-}
-function tubeMapColumns(graph, layout) {
-  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
-  const byOrder = /* @__PURE__ */ new Map();
-  for (const node of drawnNodes(layout)) {
-    const list = byOrder.get(node.order);
-    if (list) {
-      list.push(node);
-    } else {
-      byOrder.set(node.order, [node]);
-    }
-  }
-  const columns = [];
-  let end = -Infinity;
-  for (const order of [...byOrder.keys()].sort((a, b) => a - b)) {
-    const nodes = byOrder.get(order);
-    let bp0 = Infinity;
-    let bp1 = -Infinity;
-    for (const node of nodes) {
-      const graphNode = nodeById.get(node.name);
-      if (graphNode && isBackbone(graphNode)) {
-        bp0 = Math.min(bp0, graphNode.stable.start);
-        bp1 = Math.max(bp1, graphNode.stable.start + node.sequenceLength);
-      }
-    }
-    if (bp0 === Infinity) {
-      bp0 = bp1 = end;
-    }
-    if (bp0 < end) {
-      bp0 = end;
-      bp1 = Math.max(end, bp1);
-    }
-    end = Math.max(end, bp1);
-    columns.push({
-      order,
-      x0: Math.min(...nodes.map((n) => n.x)),
-      x1: Math.max(...nodes.map((n) => n.x + n.pixelWidth)),
-      bp0,
-      bp1
-    });
-  }
-  const first = columns.find((c) => c.bp0 !== -Infinity);
-  for (const column of columns) {
-    if (column.bp0 === -Infinity) {
-      column.bp0 = column.bp1 = first?.bp0 ?? 0;
-    }
-  }
-  return columns;
-}
-function pathsReachBackbone(graph) {
-  return graph.nodes.some(isBackbone) && hasTubeMapPaths(graph);
-}
-function tubeMapReferenceLayout(graph) {
-  const run = pathsReachBackbone(graph) ? runTubeMap(graph) : void 0;
-  if (!run) {
-    return void 0;
-  }
-  const { layout, pathColors } = run;
-  const columns = tubeMapColumns(graph, layout);
-  const byOrder = new Map(columns.map((c) => [c.order, c]));
-  const yOffset = layout.bounds.minY;
-  const nodePositions = {};
-  for (const node of drawnNodes(layout)) {
-    const column = byOrder.get(node.order);
-    nodePositions[node.name] = centreline(node, yOffset, column.bp0, column.bp1);
-  }
-  return {
-    nodePositions,
-    tubeMap: { layout, yOffset, columns, pathColors },
-    referenceAxis: true,
-    pixelRows: true,
-    extent: extentOf(layout, yOffset)
-  };
-}
-
-export {
-  visitStrands,
-  tubeMapTracks,
-  hasTubeMapPaths,
-  tubeWidth,
-  tubeMapLayout,
-  tubeMapReferenceLayout
-};

package/dist/chunks/{chunk-5OIVTEF7.js → chunk-OOXIMURX.js}

@@ -4,15 +4,15 @@ import {
 import {
   seededNodes
 } from "./chunk-IGVV37VI.js";
+import {
+  graphFromTables
+} from "./chunk-OA7RIMZ2.js";
 import {
   convertGFAToGraph
 } from "./chunk-OCMBULGN.js";
 import {
   parseGFA
 } from "./chunk-CDLPYR5O.js";
-import {
-  graphFromTables
-} from "./chunk-OA7RIMZ2.js";
 import {
   anchorGraph
 } from "./chunk-ST2IBUAN.js";