@jbrowse/bandage-core 4.1.1 → 4.3.0

package/dist/cli/figure.js

@@ -17,7 +17,7 @@ import {
   openGbz,
   parseRegion,
   refNameBinding
-} from "../chunks/chunk-QWZLIWOJ.js";
+} from "../chunks/chunk-IFVLNU7X.js";
 
 // src/cli/figure.ts
 import { access, open, readFile, writeFile } from "node:fs/promises";

package/dist/index.js

@@ -36,6 +36,7 @@ import {
   baseEdgeCurves,
   buildGeometry,
   clampZoom,
+  coalesceRuns,
   computeColorSchemeRange,
   computeReferenceRamp,
   contains,
@@ -86,6 +87,7 @@ import {
   parseRegion,
   pathColorsLegible,
   pathLegend,
+  pathOrigin,
   pathRibbonOffsets,
   placeRowGenes,
   rampHue,
@@ -126,7 +128,7 @@ import {
   wellKnownSample,
   yToXOf,
   zoomAbout
-} from "./chunks/chunk-QWZLIWOJ.js";
+} from "./chunks/chunk-IFVLNU7X.js";
 
 // src/index.ts
 import { getDpr } from "@jbrowse/render-core/canvas2dUtils";
@@ -243,14 +245,15 @@ var SpatialIndex = class {
   }
 };
 var EdgeSpatialIndex = class {
-  constructor(nodePositions, graph, drawPaths, axis, cellSize, deletions, version2 = 0) {
+  constructor(nodePositions, graph, drawPaths, axis, cellSize, deletions, version2 = 0, routes2) {
     this.cells = /* @__PURE__ */ new Map();
     this.edgeCurves = baseEdgeCurves(
       nodePositions,
       graph,
       axis,
       deletions,
-      version2
+      version2,
+      routes2
     );
     const boxes = [];
     let extentX = 0;
@@ -373,9 +376,9 @@ function getSpatialIndex(nodePositions, version2) {
   return index;
 }
 var edgeCache = /* @__PURE__ */ new WeakMap();
-function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version2, deletions) {
+function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version2, deletions, routes2) {
   const cached = edgeCache.get(nodePositions);
-  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version2 && cached.deletions === deletions) {
+  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version2 && cached.deletions === deletions && cached.routes === routes2) {
     return cached.index;
   }
   const index = new EdgeSpatialIndex(
@@ -385,7 +388,8 @@ function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version2, de
     axis,
     void 0,
     deletions,
-    version2
+    version2,
+    routes2
   );
   edgeCache.set(nodePositions, {
     graph,
@@ -394,7 +398,8 @@ function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version2, de
     scaleY: axis.scaleY,
     version: version2,
     index,
-    deletions
+    deletions,
+    routes: routes2
   });
   return index;
 }
@@ -424,7 +429,7 @@ function findHoveredNode(nodePositions, graphX, graphY, axis, version2 = 0, ink)
   }
   return hovered;
 }
-function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths, version2 = 0, deletions, hiddenEdges) {
+function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths, version2 = 0, deletions, hiddenEdges, deletionRoutes) {
   const yToX = yToXOf(axis);
   const edgeThreshold = 10 / axis.scaleX;
   const edgeIndex = getEdgeSpatialIndex(
@@ -433,7 +438,8 @@ function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths,
     drawPaths,
     axis,
     version2,
-    deletions
+    deletions,
+    deletionRoutes
   );
   const candidates = edgeIndex.query(
     graphX,
@@ -1770,6 +1776,155 @@ function bubbleSubgraph(graph, segmentIds) {
     referencePath: graph.referencePath
   };
 }
+
+// src/layout/walkStrip.ts
+var PAD_PX = 6;
+var MIN_ROW_PX = 3;
+var LABELLED_ROW_PX = 12;
+var READOUT_ROOM = 1.3;
+var MARK_INK = "#111";
+var TICK_PX2 = 3;
+function stripMarks(graph, rows, node) {
+  const visits = graph.pathVisits?.get(node.name) ?? [];
+  const marks = [];
+  for (const row of rows) {
+    const axis = row.axis;
+    if (!axis) {
+      continue;
+    }
+    const path = pathOrigin(row.name).name;
+    for (const v of visits) {
+      if (v.path !== path) {
+        continue;
+      }
+      const { start, end } = alongRow(axis, v.start, v.start + node.length);
+      if (end > 0 && start < row.bp) {
+        marks.push({ row: row.name, start, bp: end - start });
+      }
+    }
+  }
+  return marks;
+}
+var spanCache = /* @__PURE__ */ new WeakMap();
+function spansOf(graph, name) {
+  let byName = spanCache.get(graph);
+  if (!byName) {
+    byName = /* @__PURE__ */ new Map();
+    spanCache.set(graph, byName);
+  }
+  if (byName.has(name)) {
+    return byName.get(name);
+  }
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const pieces = (graph.paths ?? []).filter((p) => p.name === name);
+  let spans;
+  if (pieces.every((p) => p.start !== void 0)) {
+    spans = { ids: [], starts: [], ends: [] };
+    for (const piece of [...pieces].sort((a, b) => a.start - b.start)) {
+      let pos = piece.start;
+      for (const id of piece.nodeIds) {
+        const len = lengthOf.get(id) ?? 0;
+        spans.ids.push(id);
+        spans.starts.push(pos);
+        spans.ends.push(pos + len);
+        pos += len;
+      }
+    }
+  }
+  byName.set(name, spans);
+  return spans;
+}
+function segmentAt(graph, row, offset, pxPerBp) {
+  const axis = row.axis;
+  const spans = axis && spansOf(graph, row.name);
+  if (!axis || !spans || offset < 0 || offset > row.bp) {
+    return void 0;
+  }
+  const at = axis.reversed ? axis.start - offset : axis.start + offset;
+  const tol = 0.5 / pxPerBp;
+  const bar = axis.reversed ? { start: axis.start - row.bp, end: axis.start } : { start: axis.start, end: axis.start + row.bp };
+  const from = Math.max(at - tol, bar.start);
+  const to = Math.min(at + tol, bar.end);
+  let lo = 0;
+  let hi = spans.starts.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (spans.ends[mid] <= from) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  let best;
+  let bestLen = -1;
+  let bestHolds = false;
+  for (let i = lo; i < spans.starts.length && spans.starts[i] < to; i++) {
+    const len = spans.ends[i] - spans.starts[i];
+    const holds = spans.starts[i] <= at && at < spans.ends[i];
+    if (len > bestLen || len === bestLen && holds && !bestHolds) {
+      bestLen = len;
+      best = spans.ids[i];
+      bestHolds = holds;
+    }
+  }
+  return best;
+}
+function walkStripFrame(bars, o) {
+  const count = bars.rows.length + 1;
+  const rowPx = Math.max(
+    MIN_ROW_PX,
+    Math.min(ROW_HEIGHT_PX, Math.floor((o.maxHeight - 2 * PAD_PX) / count))
+  );
+  const labelled = rowPx >= LABELLED_ROW_PX;
+  const readouts = rowPx >= 14;
+  const barPx = Math.max(2, Math.round(rowPx * 0.6));
+  const longest = Math.max(bars.reference.bp, ...bars.rows.map((r) => r.bp), 1);
+  const left = labelled ? o.labelPx : PAD_PX;
+  const usable = Math.max(1, o.width - left - PAD_PX);
+  const scaleX = usable / (longest * (readouts ? READOUT_ROOM : 1));
+  return {
+    scaleX,
+    scaleY: 1,
+    translateX: left - bars.origin * scaleX,
+    translateY: PAD_PX + rowPx / 2,
+    width: o.width,
+    height: count * rowPx + 2 * PAD_PX,
+    rowPx,
+    barPx,
+    readouts,
+    labelled
+  };
+}
+function stripRowAt(bars, frame, x, y) {
+  const i = Math.round((y - frame.translateY) / frame.rowPx);
+  const row = [bars.reference, ...bars.rows][i];
+  const offset = (x - frame.translateX) / frame.scaleX - bars.origin;
+  return row && i >= 0 && offset >= 0 && offset <= row.bp ? { index: i, row, offset } : void 0;
+}
+function walkMarksTree(bars, frame, marks) {
+  const index = new Map(
+    [bars.reference, ...bars.rows].map((row, i) => [row.name, i])
+  );
+  const X = (offset) => (bars.origin + offset) * frame.scaleX + frame.translateX;
+  return el(
+    "g",
+    { "data-testid": "graph-walk-marks" },
+    ...marks.flatMap((m) => {
+      const i = index.get(m.row);
+      if (i === void 0) {
+        return [];
+      }
+      const y = i * frame.rowPx + frame.translateY;
+      const x = X(m.start);
+      const w = Math.max(2, m.bp * frame.scaleX);
+      const tick = (top) => el("rect", { x, y: top, width: w, height: TICK_PX2, fill: MARK_INK });
+      return [
+        tick(y - frame.barPx / 2 - TICK_PX2 - 1),
+        tick(y + frame.barPx / 2 + 1)
+      ];
+    })
+  );
+}
 export {
   BUBBLE_KIND_COLORS,
   BUBBLE_KIND_NAMES,
@@ -1783,6 +1938,7 @@ export {
   FORCE_LAYOUT_LABEL,
   HALO_FACTOR,
   HPRC_GBZ,
+  LABELLED_ROW_PX,
   LABEL_CHAR_PX,
   LABEL_PAD,
   LABEL_PX,
@@ -1814,6 +1970,7 @@ export {
   buildGeometry,
   clampZoom,
   classifyBubble,
+  coalesceRuns,
   computeReferenceRamp,
   connectorAt,
   contains,
@@ -1891,8 +2048,11 @@ export {
   runPaint,
   schemeCss,
   screenToLayout,
+  segmentAt,
   serializeEl,
   stripBlockAt,
+  stripMarks,
+  stripRowAt,
   svgCanvas,
   tubeMapConnectors,
   tubeMapFrame,
@@ -1907,6 +2067,7 @@ export {
   walkHighlight,
   walkKey,
   walkLift,
+  walkMarksTree,
   walkPosition,
   walkRowReadout,
   walkRows,
@@ -1914,6 +2075,7 @@ export {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree,
+  walkStripFrame,
   warpX,
   wellKnownSample,
   wheelZoomFactor,

package/dist/types/deletionEdges.d.ts

@@ -1,4 +1,4 @@
-import type { Graph } from './types.js';
+import type { Graph, NodeSegment } from './types.js';
 import type { AxisScale } from './util/geometry.js';
 export interface DeletionEdge {
     edgeIndex: number;
@@ -20,5 +20,5 @@ export declare function bypassedPoints(nodePositions: Record<string, {
 export declare function deletionArcCurves(nodePositions: Record<string, {
     x: number;
     y: number;
-}[]>, deletion: DeletionEdge, axis: AxisScale): import("./util/geometry.js").BezierCurve[] | undefined;
+}[]>, deletion: DeletionEdge, axis: AxisScale, route?: NodeSegment[]): import("./util/geometry.js").BezierCurve[] | undefined;
 export declare function deletionEdges(graph: Graph): DeletionEdge[];

package/dist/types/graphLabels.d.ts

@@ -1,4 +1,5 @@
 import type { DeletionEdge } from './deletionEdges.js';
+import type { DeletionRoutes } from './layout/deletionRoutes.js';
 import type { Box, TakeBox } from './overlayLabels.js';
 import type { AlleleDeletion, NodeSegment } from './types.js';
 import type { AxisScale } from './util/geometry.js';
@@ -23,6 +24,7 @@ interface SizeLabelArgs {
     nodePositions: Record<string, NodeSegment[]>;
     nodeLengths: Map<string, number>;
     deletions: DeletionEdge[];
+    deletionRoutes?: DeletionRoutes;
     alleleDeletions?: AlleleDeletion[];
     axis: AxisScale;
     translateX: number;
@@ -35,7 +37,7 @@ export interface SizeLabelCandidate {
     label: GraphLabel;
     box: Box;
 }
-export declare function sizeLabelCandidates({ nodePositions, nodeLengths, deletions, alleleDeletions, axis, translateX, translateY, width, height, version, }: SizeLabelArgs): {
+export declare function sizeLabelCandidates({ nodePositions, nodeLengths, deletions, deletionRoutes, alleleDeletions, axis, translateX, translateY, width, height, version, }: SizeLabelArgs): {
     deletions: SizeLabelCandidate[];
     nodes: SizeLabelCandidate[];
 };

package/dist/types/index.d.ts

@@ -56,8 +56,10 @@ export { bubbleSubgraph } from './bubbles/popBubble.js';
 export type { MinigraphBubble } from './bubbles/bubbleLine.js';
 export { walkRows } from './layout/walkRows.js';
 export type { WalkAxis, WalkRow, WalkRows, WalkRun } from './layout/walkRows.js';
-export { BAR_PX as WALK_BAR_PX, DISAGREES as WALK_DISAGREES, GAP_PX as WALK_GAP_PX, GENE_INK as WALK_GENE_INK, OFF_REFERENCE as WALK_OFF_REFERENCE, ON_REFERENCE as WALK_ON_REFERENCE, OUTSIDE_CUT as WALK_OUTSIDE_CUT, alongRow, placeRowGenes, readoutPlacement, rowGeneBoxes, rowSpan, runPaint, unitTicks, walkRowReadout, walkRowsKey, walkRowsKeyTree, walkRowsTree, } from './layout/walkRowDraw.js';
+export { BAR_PX as WALK_BAR_PX, DISAGREES as WALK_DISAGREES, GAP_PX as WALK_GAP_PX, GENE_INK as WALK_GENE_INK, OFF_REFERENCE as WALK_OFF_REFERENCE, ON_REFERENCE as WALK_ON_REFERENCE, OUTSIDE_CUT as WALK_OUTSIDE_CUT, alongRow, coalesceRuns, placeRowGenes, readoutPlacement, rowGeneBoxes, rowSpan, runPaint, unitTicks, walkRowReadout, walkRowsKey, walkRowsKeyTree, walkRowsTree, } from './layout/walkRowDraw.js';
 export type { GeneBox, GeneGaps, KeyEntry, KeySwatch, ReadoutCall, RowGene, WalkRowsFrame, WalkRowsWithCalls, } from './layout/walkRowDraw.js';
+export { LABELLED_ROW_PX, segmentAt, stripMarks, stripRowAt, walkMarksTree, walkStripFrame, } from './layout/walkStrip.js';
+export type { StripFrame, StripMark } from './layout/walkStrip.js';
 export { el, serializeEl } from './el.js';
 export type { El, ElAttrs } from './el.js';
 export { RAMP_GRADIENT_CSS, rampHue, rampHueCss, rampStops, } from './referenceRampCss.js';

package/dist/types/labelLayout.d.ts

@@ -2,6 +2,7 @@ import type { BubbleHalo, RouteLabel } from './bubbles/bubbleHalos.js';
 import type { DeletionEdge } from './deletionEdges.js';
 import type { GenePin } from './genes/genePins.js';
 import type { GraphLabel } from './graphLabels.js';
+import type { DeletionRoutes } from './layout/deletionRoutes.js';
 import type { PlacedLabel } from './overlayLabels.js';
 import type { AlleleDeletion, NodeSegment } from './types.js';
 import type { AxisScale } from './util/geometry.js';
@@ -33,6 +34,7 @@ export interface LabelLayoutSource {
     nodeLengths: Map<string, number>;
     showDeletionEdges: boolean;
     deletions: DeletionEdge[];
+    deletionRoutes?: DeletionRoutes;
     alleleDeletions: AlleleDeletion[];
     positionsVersion: number;
 }

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

@@ -0,0 +1,31 @@
+import type { BandageScaleOpts } from './drawnScale.js';
+import type { DeletionEdge } from '../deletionEdges.js';
+import type { Graph, GraphEdge, GraphNode, NodeSegment } from '../types.js';
+export type DeletionRoutes = Record<number, NodeSegment[]>;
+export declare function withDeletionRoutes(graph: Graph, deletions: DeletionEdge[]): {
+    graph: {
+        nodes: {
+            id: string;
+            name: string;
+            length: number;
+            depth: number;
+        }[];
+        edges: GraphEdge[];
+        name: string;
+        paths?: import("../types.js").GraphPath[];
+        anchorPaths?: import("../types.js").PathOrigin[];
+        pathVisits?: Map<string, import("../types.js").PathVisit[]>;
+        anchoredBy?: "tags" | "paths";
+        referencePath?: string;
+        reads?: import("../gaf/parseGaf.js").GafRecord[];
+    };
+    routes: Map<number, string>;
+    ids: Set<string>;
+};
+export declare function routeNodes(graph: Graph, deletions: DeletionEdge[], routes: Map<number, string>, drawnOf: (bp: number) => number, opts: BandageScaleOpts): GraphNode[];
+export declare function takeRoutes(positions: Record<string, NodeSegment[]>, routes: Map<number, string>): {
+    nodePositions: {
+        [x: string]: NodeSegment[];
+    };
+    deletionRoutes: DeletionRoutes;
+};

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

@@ -25,4 +25,5 @@ export interface LayoutScaling {
     opts: BandageScaleOpts;
 }
 export declare function layoutScaling(graph: Graph, spread?: NodeLengthSpread): LayoutScaling;
+export declare function drawnLengthOf(graph: Graph, spread?: NodeLengthSpread): (bp: number) => number;
 export { MEAN_NODE_LENGTH };

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

@@ -3,7 +3,7 @@ export interface MergedRuns {
     graph: Graph;
     runs: Map<string, string[]>;
 }
-export declare function mergeRuns(graph: Graph): MergedRuns;
+export declare function mergeRuns(graph: Graph, alone?: ReadonlySet<string>): MergedRuns;
 export declare function splitRuns(positions: Record<string, NodeSegment[]>, runs: Map<string, string[]>, weightOf: (id: string) => number): Record<string, NodeSegment[]>;
 export declare function polylineSlice(line: NodeSegment[], from: number, to: number): NodeSegment[];
 export declare function polylineMidpoint(line: NodeSegment[]): NodeSegment;

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

@@ -114,7 +114,11 @@ export interface WalkRowsFrame {
     translateY: number;
     width: number;
     height: number;
+    rowPx?: number;
+    barPx?: number;
+    readouts?: boolean;
 }
+export declare function coalesceRuns(runs: WalkRun[], pxPerBp: number): WalkRun[];
 export declare function walkRowsTree(bars: WalkRowsWithCalls, frame: WalkRowsFrame, o?: {
     ramp?: {
         start: number;

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

@@ -0,0 +1,28 @@
+import type { WalkRowsFrame } from './walkRowDraw.js';
+import type { WalkRow, WalkRows } from './walkRows.js';
+import type { Graph, GraphNode } from '../types.js';
+export declare const LABELLED_ROW_PX = 12;
+export interface StripMark {
+    row: string;
+    start: number;
+    bp: number;
+}
+export declare function stripMarks(graph: Graph, rows: WalkRow[], node: GraphNode): StripMark[];
+export declare function segmentAt(graph: Graph, row: WalkRow, offset: number, pxPerBp: number): string | undefined;
+export interface StripFrame extends WalkRowsFrame {
+    rowPx: number;
+    barPx: number;
+    readouts: boolean;
+    labelled: boolean;
+}
+export declare function walkStripFrame(bars: WalkRows, o: {
+    width: number;
+    maxHeight: number;
+    labelPx: number;
+}): StripFrame;
+export declare function stripRowAt(bars: WalkRows, frame: StripFrame, x: number, y: number): {
+    index: number;
+    row: WalkRow;
+    offset: number;
+} | undefined;
+export declare function walkMarksTree(bars: WalkRows, frame: StripFrame, marks: StripMark[]): import("../index.js").El;

package/dist/types/pipeline.d.ts

@@ -32,23 +32,26 @@ export declare function engineRequest(graph: Graph, scaling: LayoutScaling, sett
 export declare function engineKey(graph: Graph, settings: EngineSettings): string;
 export declare function forceLayout(graph: Graph, settings: EngineSettings, engine: LayoutEngine): Promise<{
     result: {
-        nodePositions: Record<string, NodeSegment[]>;
-        rowLabels?: import("./types.js").RowLabel[];
-        sampleRows?: string[];
-        alleleDeletions?: import("./types.js").AlleleDeletion[];
-        referenceAxis?: boolean;
-        pixelRows?: boolean;
+        deletionRoutes?: import("./layout/deletionRoutes.js").DeletionRoutes | undefined;
         extent?: {
             minX?: number;
             minY?: number;
             maxX?: number;
             maxY?: number;
         };
+        nodePositions: {
+            [x: string]: NodeSegment[];
+        };
+        rowLabels?: import("./types.js").RowLabel[];
+        sampleRows?: string[];
+        alleleDeletions?: import("./types.js").AlleleDeletion[];
+        referenceAxis?: boolean;
+        pixelRows?: boolean;
         tubeMap?: import("./index.js").TubeMapDrawing;
     };
     duration: number;
 }>;
-export declare function layoutExtent(nodePositions: Record<string, NodeSegment[]>): Bounds;
+export declare function layoutExtent(nodePositions: Record<string | number, NodeSegment[]>): Bounds;
 export declare const FIT_PADDING = 40;
 export declare function clampZoom(zoom: number): number;
 export declare function fittedTranslateY(bounds: {

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

@@ -1,4 +1,5 @@
 import type { ResolvedColorScheme } from '../colorSchemes.js';
+import type { DeletionRoutes } from '../layout/deletionRoutes.js';
 import type { NodeWidth } from '../nodeWidths.js';
 import type { Graph, GraphNode, NodeSegment } from '../types.js';
 import type { WalkLift } from '../walkHighlight.js';
@@ -27,6 +28,7 @@ export interface BuildOptions {
     };
     referenceRamp?: ReferenceRamp;
     deletions?: Map<number, string[]>;
+    deletionRoutes?: DeletionRoutes;
     hiddenEdges?: ReadonlySet<number>;
     version?: number;
 }

package/dist/types/types.d.ts

@@ -73,4 +73,5 @@ export interface LayoutResult {
         maxY?: number;
     };
     tubeMap?: TubeMapDrawing;
+    deletionRoutes?: Record<number, NodeSegment[]>;
 }

package/dist/types/util/SpatialIndex.d.ts

@@ -1,3 +1,4 @@
+import type { DeletionRoutes } from '../layout/deletionRoutes.js';
 import type { Graph, NodeSegment } from '../types.js';
 import type { AxisScale } from './geometry.js';
 interface CellEntry {
@@ -18,7 +19,7 @@ export declare class EdgeSpatialIndex {
     private cellSize;
     private cells;
     private edgeCurves;
-    constructor(nodePositions: Record<string, NodeSegment[]>, graph: Graph, drawPaths: boolean, axis: AxisScale, cellSize?: number | CellSize, deletions?: Map<number, string[]>, version?: number);
+    constructor(nodePositions: Record<string, NodeSegment[]>, graph: Graph, drawPaths: boolean, axis: AxisScale, cellSize?: number | CellSize, deletions?: Map<number, string[]>, version?: number, routes?: DeletionRoutes);
     getCurves(ei: number): import("./geometry.js").BezierCurve[] | undefined;
     query(x: number, y: number, radiusX: number, radiusY?: number): number[];
 }

package/dist/types/util/edgeCurves.d.ts

@@ -1,4 +1,5 @@
+import type { DeletionRoutes } from '../layout/deletionRoutes.js';
 import type { Graph, NodeSegment } from '../types.js';
 import type { AxisScale, BezierCurve } from './geometry.js';
 export type EdgeCurves = Map<number, BezierCurve[]>;
-export declare function baseEdgeCurves(nodePositions: Record<string, NodeSegment[]>, graph: Graph, axis: AxisScale, deletions: Map<number, string[]> | undefined, version: number): EdgeCurves;
+export declare function baseEdgeCurves(nodePositions: Record<string, NodeSegment[]>, graph: Graph, axis: AxisScale, deletions: Map<number, string[]> | undefined, version: number, routes?: DeletionRoutes): EdgeCurves;

package/dist/types/util/geometry.d.ts

@@ -43,4 +43,5 @@ export declare function pathRibbonOffsets(fromSegments: NodeSegment[], toSegment
 export type SelfLink = boolean | Side;
 export declare function selfLinkOf(edge: GraphEdge): SelfLink;
 export declare function computeEdgeCurves(fromSegments: NodeSegment[], toSegments: NodeSegment[], selfLink: SelfLink, offsetX: number, offsetY: number, axis: AxisScale, bypassed?: NodeSegment[], maxBowIn?: number): BezierCurve[];
+export declare function routedEdgeCurves(fromSegments: NodeSegment[], toSegments: NodeSegment[], route: NodeSegment[]): BezierCurve[];
 export {};

package/dist/types/util/hitDetection.d.ts

@@ -1,3 +1,4 @@
+import type { DeletionRoutes } from '../layout/deletionRoutes.js';
 import type { Graph, NodeSegment } from '../types.js';
 import type { AxisScale } from './geometry.js';
 export declare function distanceToSegment(px: number, py: number, x1: number, y1: number, x2: number, y2: number): number;
@@ -7,4 +8,4 @@ export interface NodeInk {
     maxHalfWidthPx: number;
 }
 export declare function findHoveredNode(nodePositions: Record<string, NodeSegment[]>, graphX: number, graphY: number, axis: AxisScale, version?: number, ink?: NodeInk): string | null;
-export declare function findHoveredEdge(nodePositions: Record<string, NodeSegment[]>, graph: Graph, graphX: number, graphY: number, axis: AxisScale, drawPaths: boolean, version?: number, deletions?: Map<number, string[]>, hiddenEdges?: ReadonlySet<number>): number | null;
+export declare function findHoveredEdge(nodePositions: Record<string, NodeSegment[]>, graph: Graph, graphX: number, graphY: number, axis: AxisScale, drawPaths: boolean, version?: number, deletions?: Map<number, string[]>, hiddenEdges?: ReadonlySet<number>, deletionRoutes?: DeletionRoutes): number | null;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.1.1";
+export declare const version = "4.3.0";

package/package.json

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