@jbrowse/bandage-core 4.0.24 → 4.0.26

package/dist/index.js

@@ -8,10 +8,13 @@ import {
   FADED_ALPHA,
   FIT_PADDING,
   FORCE_LAYOUT_LABEL,
+  HALO_FACTOR,
+  HPRC_GBZ,
   LABEL_CHAR_PX,
   LABEL_PAD,
   LABEL_PX,
   LAYOUT_MODES,
+  LEGEND_INSET_PX,
   LIFT_BACKDROP_COLOR,
   NODE_WIDTHS,
   REFERENCE_RAMP_MAX_HUE,
@@ -29,6 +32,7 @@ import {
   computeReferenceRamp,
   contains,
   curveBounds,
+  cutGbzRegion,
   cutWindowGFA,
   deletionEdges,
   drawingBounds,
@@ -42,15 +46,20 @@ import {
   fadeAbgr,
   featuresOnBackbone,
   figureSvg,
-  firstNodeAtOrAfter,
   fitTransform,
   forceLayout,
   formatBp,
+  geneCoverageNote,
+  genePins,
+  genesFromBed,
+  genesFromGff3Lines,
+  genesFromText,
   getNodeColor,
   graphBackbone,
   haplotypeWanted,
   isBackbone,
   layoutExtent,
+  layoutLabels,
   layoutModeByValue,
   loadBandage,
   loadGraph,
@@ -58,19 +67,16 @@ import {
   meanDepth,
   modeUsesLayoutEngine,
   nodeInk,
-  nodeLabelBudget,
   nodeWidthPx,
-  occupancy,
+  openGbz,
   padded,
   panSNContig,
   panSNHaplotype,
   panSNSample,
+  parseRegion,
   pathColorsLegible,
   pathLegend,
   pathRibbonOffsets,
-  placeLabels,
-  placeSizeLabels,
-  polylineSlice,
   rangeText,
   refNameBinding,
   referenceOrder,
@@ -79,23 +85,24 @@ import {
   resolveColorScheme,
   resolveEncoding,
   resolveReferenceSample,
-  rowLabelBox,
   schemeCss,
   screenToLayout,
-  sizeLabelCandidates,
   svgCanvas,
   svgPath,
   translateCurves,
+  trimOrigins,
+  version,
   viewportOf,
   walkHighlight,
   walkKey,
   walkLift,
+  walkPosition,
   walkRows,
   walkRowsExtent,
   wellKnownSample,
   yToXOf,
   zoomAbout
-} from "./chunks/chunk-4AOHEU76.js";
+} from "./chunks/chunk-75KVO2WV.js";
 
 // src/index.ts
 import { getDpr } from "@jbrowse/render-core/canvas2dUtils";
@@ -212,14 +219,14 @@ var SpatialIndex = class {
   }
 };
 var EdgeSpatialIndex = class {
-  constructor(nodePositions, graph, drawPaths, axis, cellSize, deletions, version = 0) {
+  constructor(nodePositions, graph, drawPaths, axis, cellSize, deletions, version2 = 0) {
     this.cells = /* @__PURE__ */ new Map();
     this.edgeCurves = baseEdgeCurves(
       nodePositions,
       graph,
       axis,
       deletions,
-      version
+      version2
     );
     const boxes = [];
     let extentX = 0;
@@ -332,19 +339,19 @@ function distanceToEdgeCurves(px, py, curves, yToX = 1) {
   return minDist;
 }
 var nodeCache = /* @__PURE__ */ new WeakMap();
-function getSpatialIndex(nodePositions, version) {
+function getSpatialIndex(nodePositions, version2) {
   const cached = nodeCache.get(nodePositions);
-  if (cached?.version === version) {
+  if (cached?.version === version2) {
     return cached.index;
   }
   const index = new SpatialIndex(nodePositions);
-  nodeCache.set(nodePositions, { version, index });
+  nodeCache.set(nodePositions, { version: version2, index });
   return index;
 }
 var edgeCache = /* @__PURE__ */ new WeakMap();
-function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version, deletions) {
+function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version2, deletions) {
   const cached = edgeCache.get(nodePositions);
-  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version && cached.deletions === deletions) {
+  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version2 && cached.deletions === deletions) {
     return cached.index;
   }
   const index = new EdgeSpatialIndex(
@@ -354,23 +361,23 @@ function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version, del
     axis,
     void 0,
     deletions,
-    version
+    version2
   );
   edgeCache.set(nodePositions, {
     graph,
     drawPaths,
     scaleX: axis.scaleX,
     scaleY: axis.scaleY,
-    version,
+    version: version2,
     index,
     deletions
   });
   return index;
 }
 var MIN_NODE_REACH_PX = 5;
-function findHoveredNode(nodePositions, graphX, graphY, axis, version = 0, ink) {
+function findHoveredNode(nodePositions, graphX, graphY, axis, version2 = 0, ink) {
   const yToX = yToXOf(axis);
-  const index = getSpatialIndex(nodePositions, version);
+  const index = getSpatialIndex(nodePositions, version2);
   const reach = (px) => Math.max(MIN_NODE_REACH_PX, px) / axis.scaleX;
   const queryReach = reach(ink?.maxHalfWidthPx ?? 0);
   const candidates = index.query(graphX, graphY, queryReach, queryReach / yToX);
@@ -393,7 +400,7 @@ function findHoveredNode(nodePositions, graphX, graphY, axis, version = 0, ink)
   }
   return hovered;
 }
-function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths, version = 0, deletions, hiddenEdges) {
+function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths, version2 = 0, deletions, hiddenEdges) {
   const yToX = yToXOf(axis);
   const edgeThreshold = 10 / axis.scaleX;
   const edgeIndex = getEdgeSpatialIndex(
@@ -401,7 +408,7 @@ function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths,
     graph,
     drawPaths,
     axis,
-    version,
+    version2,
     deletions
   );
   const candidates = edgeIndex.query(
@@ -470,6 +477,7 @@ var REFERENCE_STRIP_PX = 12;
 var REFERENCE_STRIP_ZONE_PX = REFERENCE_STRIP_PX + 8;
 var OVERHANG_PX = 8;
 var OVERHANG_CAP_PX = OVERHANG_PX + 3;
+var MIN_STAGGER_PX = 12;
 var PALE = abgrToCssRgba(fadeAbgr(LIFT_BACKDROP_COLOR, FADED_ALPHA));
 function referenceStripBlocks(graph, {
   colorScheme,
@@ -553,7 +561,8 @@ function stripPixels(blocks, frame, width, dpr) {
       claimed = px1;
     }
   }
-  return out;
+  const covered = out.length > 0 ? out.at(-1).x1 - out[0].x0 : 0;
+  return covered >= out.length * MIN_STAGGER_PX ? out : out.map(({ tier: _, ...b }) => b);
 }
 function drawOverhang(ctx, edgeX, inward, ink) {
   const capX = inward > 0 ? edgeX : edgeX - OVERHANG_CAP_PX;
@@ -580,9 +589,11 @@ function drawReferenceStrip(ctx, blocks, frame, {
   const ink = darkMode ? "#ffffff" : "#18181c";
   ctx.clearRect(0, 0, width, REFERENCE_STRIP_ZONE_PX);
   for (const b of stripPixels(blocks, frame, width, dpr)) {
-    const rows = b.colors.length > 1 ? b.colors.length : 2;
+    const { tier } = b;
+    const staggered = tier !== void 0 && b.colors.length === 1;
+    const rows = staggered ? 2 : b.colors.length;
     b.colors.forEach((color, i) => {
-      const row = b.colors.length > 1 ? i : b.tier;
+      const row = staggered ? tier : i;
       const y0 = rowEdge(row, rows, dpr);
       ctx.fillStyle = color;
       ctx.fillRect(b.x0, y0, b.x1 - b.x0, rowEdge(row + 1, rows, dpr) - y0);
@@ -715,10 +726,11 @@ function shapeOf(d, color, alpha) {
   const commands = parsePath(d);
   return { commands, color, alpha, ...extentOf(commands) };
 }
-function layerOf(layout, type) {
+function layerOf(layout, type, tubes) {
   const { shapes } = layout;
+  const colorOf = (s) => tubes?.[s.id] ?? s.color;
   const rects = [...shapes.rectangles, ...shapes.verticalRectangles].filter((r) => r.type === type).map((r) => ({
-    color: r.color,
+    color: colorOf(r),
     alpha: r.alpha ?? 1,
     x0: r.xStart,
     x1: r.xEnd + 1,
@@ -726,22 +738,30 @@ function layerOf(layout, type) {
     y1: r.yEnd + 1
   }));
   const curves = curvePaths(shapes.curves, type).map(
-    (c) => shapeOf(c.path, c.color, c.alpha ?? 1)
+    (c) => shapeOf(c.path, colorOf(c), c.alpha ?? 1)
   );
-  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, c.color, 1));
+  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, colorOf(c), 1));
   return { rects, shapes: [...curves, ...corners] };
 }
-function tubeMapPicture(layout) {
+function tubeMapPicture(layout, colors = {}) {
   const nodes = [];
   layout.nodes.forEach((node) => {
     if (node.order >= 0) {
       const commands = parsePath(nodeOutlinePath(node));
-      nodes.push({ name: node.name, commands, ...extentOf(commands) });
+      nodes.push({
+        name: node.name,
+        commands,
+        ...extentOf(commands),
+        color: colors.nodes?.get(node.name)
+      });
     }
   });
   return {
     bounds: layout.bounds,
-    layers: [layerOf(layout, "haplotype"), layerOf(layout, "read")],
+    layers: [
+      layerOf(layout, "haplotype", colors.tubes),
+      layerOf(layout, "read")
+    ],
     nodes,
     mismatches: tubeMapMismatches(layout).filter(
       (m) => m.kind !== "insertion" || !m.softClip
@@ -816,6 +836,7 @@ var MIN_OUTLINE_ALPHA = 0.15;
 function outlineAlpha(screenWidth) {
   return Math.max(MIN_OUTLINE_ALPHA, Math.min(1, screenWidth / FULL_OUTLINE_PX));
 }
+var NODE_TINT_ALPHA = 0.55;
 function drawTubeMap(ctx, picture, frame) {
   const { x, y, width } = frame;
   const visible = (item) => x(item.x1) >= 0 && x(item.x0) <= width;
@@ -837,8 +858,10 @@ function drawTubeMap(ctx, picture, frame) {
       const lit = node.name === frame.highlightNode;
       ctx.beginPath();
       trace(ctx, node.commands, x, y);
-      ctx.fillStyle = lit ? "rgba(255,192,203,0.5)" : fill;
+      const tint = lit ? void 0 : node.color;
+      ctx.fillStyle = lit ? "rgba(255,192,203,0.5)" : tint ?? fill;
       ctx.strokeStyle = lit ? "#ff0000" : stroke;
+      ctx.globalAlpha = tint ? NODE_TINT_ALPHA : 1;
       ctx.fill();
       ctx.globalAlpha = lit ? 1 : outlineAlpha(x(node.x1) - x(node.x0));
       ctx.stroke();
@@ -887,6 +910,21 @@ function drawMismatches(ctx, marks, frame) {
   }
 }
 
+// src/tubeMap/nodeColors.ts
+import { abgrToCssRgba as abgrToCssRgba2 } from "@jbrowse/core/util/colorBits";
+function tubeMapNodeColors(graph, colorScheme, referenceRamp) {
+  if (colorScheme === "uniform" || colorScheme === "grey") {
+    return void 0;
+  }
+  const range = { ...computeColorSchemeRange(graph), referenceRamp };
+  return new Map(
+    graph.nodes.map((node, index) => [
+      node.id,
+      abgrToCssRgba2(getNodeColor(node, index, colorScheme, range))
+    ])
+  );
+}
+
 // src/tubeMap/warp.ts
 var MAX_GAP_PX = 24;
 var isReal = (c) => c.bp1 > c.bp0;
@@ -1052,7 +1090,7 @@ function niceStep(raw) {
   const m = raw / pow;
   return (m <= 1 ? 1 : m <= 2 ? 2 : m <= 5 ? 5 : 10) * pow;
 }
-function placeLabels2(candidates) {
+function placeLabels(candidates) {
   const placed = [];
   for (const a of candidates) {
     if (placed.every(
@@ -1089,7 +1127,7 @@ function scaleMarks(boxes, x, width, measure) {
   return {
     spans: [{ x0: from, x1: to }],
     ticks,
-    labels: placeLabels2(positions)
+    labels: placeLabels(positions)
   };
 }
 function boxMarks(boxes, x, width, measure) {
@@ -1130,7 +1168,7 @@ function boxMarks(boxes, x, width, measure) {
   return {
     spans,
     ticks,
-    labels: placeLabels2([...ends, ...lengths, ...boundaries])
+    labels: placeLabels([...ends, ...lengths, ...boundaries])
   };
 }
 function rulerMarks(boxes, x, width, measure, referenceAxis = false) {
@@ -1686,232 +1724,32 @@ function bubbleSubgraph(graph, segmentIds) {
   const keep = new Set(segmentIds);
   const nodes = graph.nodes.filter((n) => keep.has(n.name));
   const ids = new Set(nodes.map((n) => n.id));
-  const paths = graph.paths?.map((p) => ({ ...p, nodeIds: p.nodeIds.filter((id) => ids.has(id)) })).filter((p) => p.nodeIds.length > 0);
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const bpOf = (steps) => steps.reduce((sum, id) => sum + (lengthOf.get(id) ?? 0), 0);
+  const stretches = /* @__PURE__ */ new Map();
+  const paths = graph.paths?.flatMap((p) => {
+    const first = p.nodeIds.findIndex((id) => ids.has(id));
+    if (first < 0) {
+      return [];
+    }
+    const nodeIds = p.nodeIds.filter((id) => ids.has(id));
+    stretches.set(p.name, {
+      dropped: bpOf(p.nodeIds.slice(0, first)),
+      bp: bpOf(nodeIds)
+    });
+    return [{ ...p, nodeIds }];
+  });
   return {
     name: graph.name,
     nodes,
     edges: graph.edges.filter((e) => ids.has(e.from) && ids.has(e.to)),
     ...paths?.length ? { paths } : {},
-    anchorPaths: graph.anchorPaths,
+    anchorPaths: graph.anchorPaths && trimOrigins(graph.anchorPaths, graph.paths ?? [], stretches),
     pathVisits: graph.pathVisits,
     anchoredBy: graph.anchoredBy,
     referencePath: graph.referencePath
   };
 }
-
-// src/labelLayout.ts
-var HALO_FACTOR = 3.4;
-var LEGEND_INSET_PX = 6;
-var ROUTE_STACK = 8;
-var GENE_PIN_DROP_PX = 18;
-var GENE_STACK = 2;
-var TOPMOST_BASELINE = LABEL_PX + LABEL_PAD;
-function geneCoverageNote(pin) {
-  const length = pin.gene.end - pin.gene.start;
-  if (pin.covered >= 0.98) {
-    return void 0;
-  }
-  const [per, unit] = length >= 1e6 ? [1e6, "Mb"] : length >= 1e3 ? [1e3, "kb"] : [1, "bp"];
-  const amount = (bp) => +(bp / per).toFixed(per === 1 ? 0 : 1);
-  return `${amount(pin.covered * length)} of ${amount(length)} ${unit}`;
-}
-function byExtent(items, extent) {
-  return [...items].sort((a, b) => extent(b) - extent(a));
-}
-function layoutLabels(m) {
-  const { paneWidth: width, canvasHeight: height, translateX, translateY } = m;
-  const { scaleX, scaleY } = m.axisScale;
-  const frame = { width, height };
-  const screen = (p) => ({
-    x: p.x * scaleX + translateX,
-    y: p.y * scaleY + translateY
-  });
-  const reserved = m.drawnRowLabels.map(
-    ({ label, y }) => rowLabelBox(label, y * scaleY + translateY)
-  );
-  const stripPx = m.referenceStripZonePx ?? 0;
-  if (stripPx > 0) {
-    reserved.push({ x0: 0, x1: width, y0: 0, y1: stripPx });
-  }
-  if (m.legendSize.width > 0) {
-    reserved.push({
-      x0: width - LEGEND_INSET_PX - m.legendSize.width,
-      x1: width,
-      y0: 0,
-      y1: stripPx + LEGEND_INSET_PX + m.legendSize.height
-    });
-  }
-  if (m.poppedFrom) {
-    reserved.push({
-      x0: 0,
-      x1: 60 + m.poppedFrom.label.length * LABEL_CHAR_PX * 1.2,
-      y0: 0,
-      y1: 44
-    });
-  }
-  const take = occupancy(frame, reserved);
-  const onRows = m.drawnRowLabels.length > 0;
-  const rowsTop = onRows ? Math.min(...m.drawnRowLabels.map((r) => r.y)) : Infinity;
-  const halo = m.contigThickness * HALO_FACTOR;
-  const byBubble = byExtent(m.bubbleHalos, (h) => h.members);
-  const bubbles = placeLabels(
-    byBubble.map((h) => {
-      const { x, y } = screen({
-        x: h.labelAt.x,
-        y: Math.min(h.labelAt.y, rowsTop)
-      });
-      const baseline = y - halo / 2 - 6;
-      return {
-        item: h,
-        x,
-        y: onRows ? Math.max(baseline, TOPMOST_BASELINE) : baseline,
-        text: h.label
-      };
-    }),
-    frame,
-    take
-  );
-  const genes = placeLabels(
-    byExtent(m.genePins, (pin) => pin.gene.end - pin.gene.start).map((pin) => {
-      const { x, y } = screen(pin.at);
-      const note = geneCoverageNote(pin);
-      return {
-        item: pin,
-        x,
-        y: y + m.contigThickness + GENE_PIN_DROP_PX,
-        text: note ? `${pin.gene.name} \xB7 ${note}` : pin.gene.name,
-        fallback: note ? `${pin.gene.name} \u2026` : void 0,
-        stack: GENE_STACK
-      };
-    }),
-    frame,
-    take
-  );
-  const sizeCandidates = m.nodePositions && m.labelsNodeSizes ? sizeLabelCandidates({
-    nodePositions: m.nodePositions,
-    nodeLengths: m.nodeLengths,
-    deletions: m.showDeletionEdges ? m.deletions : [],
-    alleleDeletions: m.alleleDeletions,
-    axis: m.axisScale,
-    translateX,
-    translateY,
-    width,
-    height,
-    version: m.positionsVersion
-  }) : { deletions: [], nodes: [] };
-  const deletionLabels = placeSizeLabels(sizeCandidates.deletions, take);
-  const routes2 = placeLabels(
-    byBubble.flatMap(
-      (h) => h.routes.map((route) => {
-        const { x, y } = screen(route.at);
-        return {
-          item: { halo: h, route },
-          x,
-          y: y + 4,
-          text: route.text,
-          stack: ROUTE_STACK
-        };
-      })
-    ),
-    frame,
-    take
-  );
-  const nodeLabels = placeSizeLabels(
-    sizeCandidates.nodes,
-    take,
-    nodeLabelBudget(width, height)
-  );
-  return {
-    bubbles,
-    genes,
-    routes: routes2,
-    sizes: [...deletionLabels, ...nodeLabels]
-  };
-}
-
-// src/genes/genePins.ts
-function genePins(graph, genes, positions) {
-  const byRefName = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    if (isBackbone(node)) {
-      const { refName } = node.stable;
-      if (positions[node.id]?.length) {
-        const entry = byRefName.get(refName) ?? byRefName.set(refName, { nodes: [], reach: 0 }).get(refName);
-        entry.nodes.push(node);
-        entry.reach = Math.max(entry.reach, node.length);
-      }
-    }
-  }
-  for (const { nodes } of byRefName.values()) {
-    nodes.sort((a, b) => a.stable.start - b.stable.start);
-  }
-  const pins = [];
-  for (const gene of genes) {
-    const backbone = byRefName.get(gene.refName);
-    if (!backbone) {
-      continue;
-    }
-    const parts = [];
-    const exonsByNode = [];
-    let at;
-    let atDistance = Infinity;
-    let covered = 0;
-    const mid = (gene.start + gene.end) / 2;
-    const { nodes, reach } = backbone;
-    for (let i = firstNodeAtOrAfter(nodes, gene.start - reach); i < nodes.length && nodes[i].stable.start < gene.end; i++) {
-      const node = nodes[i];
-      const nodeStart = node.stable.start;
-      const nodeEnd = nodeStart + node.length;
-      if (nodeEnd <= gene.start) {
-        continue;
-      }
-      const line = positions[node.id];
-      covered += Math.min(nodeEnd, gene.end) - Math.max(nodeStart, gene.start);
-      const nodeParts = [];
-      for (const exon of gene.exons) {
-        const a = Math.max(exon.start, nodeStart);
-        const b = Math.min(exon.end, nodeEnd);
-        if (b <= a) {
-          continue;
-        }
-        const stretch = polylineSlice(
-          line,
-          (a - nodeStart) / node.length,
-          (b - nodeStart) / node.length
-        );
-        if (stretch.length === 1) {
-          stretch.push({ ...stretch[0] });
-        }
-        nodeParts.push(svgPath(stretch));
-      }
-      if (nodeParts.length > 0) {
-        parts.push(...nodeParts);
-        exonsByNode.push({ nodeId: node.id, d: nodeParts.join("") });
-      }
-      const pinBp = Math.min(Math.max(mid, nodeStart), nodeEnd);
-      const distance = Math.abs(pinBp - mid);
-      if (distance < atDistance) {
-        atDistance = distance;
-        const [p] = polylineSlice(
-          line,
-          (pinBp - nodeStart) / node.length,
-          (pinBp - nodeStart) / node.length
-        );
-        at = p;
-      }
-    }
-    if (at) {
-      pins.push({
-        gene,
-        exons: parts.join(""),
-        exonsByNode,
-        at,
-        covered: covered / (gene.end - gene.start)
-      });
-    }
-  }
-  return pins;
-}
 export {
   BUBBLE_KIND_COLORS,
   BUBBLE_KIND_NAMES,
@@ -1924,6 +1762,7 @@ export {
   FIT_PADDING,
   FORCE_LAYOUT_LABEL,
   HALO_FACTOR,
+  HPRC_GBZ,
   LABEL_CHAR_PX,
   LABEL_PAD,
   LABEL_PX,
@@ -1949,6 +1788,7 @@ export {
   computeReferenceRamp,
   connectorAt,
   contains,
+  cutGbzRegion,
   cutWindowGFA,
   deletionEdges,
   drawReferenceStrip,
@@ -1973,6 +1813,9 @@ export {
   formatBp,
   geneCoverageNote,
   genePins,
+  genesFromBed,
+  genesFromGff3Lines,
+  genesFromText,
   getDpr,
   graphBackbone,
   haplotypeWanted,
@@ -1986,10 +1829,12 @@ export {
   modeUsesLayoutEngine,
   nodeInk,
   nodeWidthPx,
+  openGbz,
   padded,
   panSNContig,
   panSNHaplotype,
   panSNSample,
+  parseRegion,
   pathColorsLegible,
   pathLegend,
   rangeText,
@@ -2012,12 +1857,15 @@ export {
   tubeMapFrame,
   tubeMapGenes,
   tubeMapNodeAt,
+  tubeMapNodeColors,
   tubeMapPicture,
   tubeX,
+  version,
   viewportOf,
   walkHighlight,
   walkKey,
   walkLift,
+  walkPosition,
   walkRows,
   walkRowsExtent,
   warpX,

package/dist/types/cli/figure.d.ts

@@ -1,20 +1,20 @@
 import type { BubbleSpread } from '../bubbleSpreads.js';
 import type { FigureOptions } from '../figure.js';
+import type { GbzSource } from '../gbzCut.js';
 import type { LayoutModeValue } from '../layoutModes.js';
 import type { WalkLayer } from '../walkEncoding.js';
-export interface FigureSpec extends Omit<FigureOptions, 'walks' | 'region'> {
+export interface FigureSpec extends Omit<FigureOptions, 'walks' | 'region' | 'genes' | 'spec'> {
     gfa?: string;
-    gbz?: {
-        db: string;
-        index?: string;
-        region: string;
-        haplotypes?: string[];
-        referenceSample?: string;
-    };
+    gbz?: GbzSource;
     region?: string;
     referencePath?: string;
     layout?: LayoutModeValue;
     quality?: number;
     bubbleSpread?: BubbleSpread;
     walks?: (string | WalkLayer)[];
+    genes?: {
+        file: string;
+        index?: string;
+        format?: 'gff3' | 'bed';
+    };
 }

package/dist/types/figure.d.ts

@@ -1,5 +1,6 @@
 import type { ColorScheme } from './colorSchemes.js';
 import type { FacetBy } from './facetGrid.js';
+import type { GeneModel } from './genes/genePins.js';
 import type { NodeWidth } from './nodeWidths.js';
 import type { Graph, LayoutResult } from './types.js';
 import type { WalkLayer } from './walkEncoding.js';
@@ -19,6 +20,12 @@ export interface FigureOptions {
         start: number;
         end: number;
     };
-    metadata?: string;
+    colorDomain?: {
+        start: number;
+        end: number;
+    };
+    fitToDrawing?: boolean;
+    genes?: GeneModel[];
+    spec?: unknown;
 }
 export declare function figureSvg(graph: Graph, layout: LayoutResult, o?: FigureOptions): string;