jbrowse-plugin-graphgenomeviewer 7.4.4 → 7.5.0

package/src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.ts

@@ -101,12 +101,9 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
    * asks for, and the nodes and links they visit
    */
   async getSubgraph(region: Region, opts: SubgraphAdapterOptions = {}) {
-    const refName = await this.refNames.resolve(region, { signal: opts.signal })
-    if (refName === undefined) {
-      throw new Error(
-        `${region.assemblyName} ${region.refName} is not in this graph's index; the graph is cut on ${this.anchor}, mapped to its PanSN prefix in assemblyNameToPanSN`,
-      )
-    }
+    const refName = await this.refNames.resolveForCut(region, {
+      signal: opts.signal,
+    })
     return this.walks.subgraph(refName, region, opts)
   }
 

package/src/hoverSync/graphViewHighlights.test.ts

@@ -200,3 +200,56 @@ describe("the drawing view has to be on the highlight's assembly", () => {
     expect(graphViewHighlights(noAssembly, 'lgv1', ['Sakai'])).toHaveLength(1)
   })
 })
+
+describe("a hovered node's span on a haplotype's own assembly", () => {
+  const onHap = {
+    refName: 'CM094351.1',
+    start: 1200,
+    end: 1500,
+    assemblyName: 'HG002.1',
+  }
+
+  // the stack's rows and a view opened beside are not the graph's pair
+  test('draws in a view of that assembly, paired or not', () => {
+    const views = [
+      graphView({
+        connectedViewId: 'lgv-ref',
+        assemblyHoverHighlights: [onHap],
+      }),
+      linearView('lgv-ref'),
+      linearView('lgv-hap'),
+    ]
+    expect(graphViewHighlights(views, 'lgv-hap', ['HG002.1'])).toEqual([
+      { key: 'graph1-0', region: onHap },
+    ])
+  })
+
+  test('draws nowhere else, nor where the view states no assemblies', () => {
+    const views = [graphView({ assemblyHoverHighlights: [onHap] })]
+    expect(graphViewHighlights(views, 'lgv1', ['hg38'])).toEqual([])
+    expect(graphViewHighlights(views, 'lgv1')).toEqual([])
+  })
+
+  test("comes from a graph track's display too", () => {
+    const views = [
+      {
+        ...linearView('lgv-ref'),
+        tracks: [
+          {
+            displays: [
+              {
+                id: 'display1',
+                type: 'LinearGraphDisplay',
+                assemblyHoverHighlights: [onHap],
+              },
+            ],
+          },
+        ],
+      },
+      linearView('lgv-hap'),
+    ]
+    expect(graphViewHighlights(views, 'lgv-hap', ['HG002.1'])).toEqual([
+      { key: 'display1-0', region: onHap },
+    ])
+  })
+})

package/src/hoverSync/graphViewHighlights.ts

@@ -124,6 +124,31 @@ export function graphViewHighlights(
         }
       }
     }
+    // A hovered node's span on each haplotype's own assembly goes to any
+    // view of that assembly, paired or not: the assembly name says where it
+    // belongs, and those views are a synteny stack's rows or opened beside
+    for (const graph of isRecord(view)
+      ? [
+          ...trackGraphs(view),
+          ...(view.type === 'GraphGenomeView' ? [view] : []),
+        ]
+      : []) {
+      const spans = Array.isArray(graph.assemblyHoverHighlights)
+        ? graph.assemblyHoverHighlights
+        : []
+      spans.forEach((value: unknown, i) => {
+        const region = readRegion(value)
+        if (
+          region?.assemblyName !== undefined &&
+          linearAssemblyNames?.includes(region.assemblyName)
+        ) {
+          highlights.push({
+            key: `${typeof graph.id === 'string' ? graph.id : 'graph'}-${i}`,
+            region,
+          })
+        }
+      })
+    }
     if (
       isRecord(view) &&
       view.type === 'GraphGenomeView' &&

package/src/hoverSync/lgvHover.test.ts

@@ -1,5 +1,13 @@
-import { hoverInRegion, nodeForLgvHover, readLgvHover } from './lgvHover'
+import {
+  bubbleForLgvHover,
+  hoverFromPair,
+  hoverInRegion,
+  nodeForLgvHover,
+  readLgvHover,
+  readSelectedFeature,
+} from './lgvHover'
 
+import type { MinigraphBubble } from '@jbrowse/bandage-core/bubbles/bubbleLine'
 import type { GraphNode } from '@jbrowse/bandage-core/types'
 
 // The shape LinearGenomeViewContainer writes on mousemove: `hoverPosition` is a
@@ -200,3 +208,94 @@ test('a coordinate past the graph resolves to nothing', () => {
     nodeForLgvHover({ hover: { refName: 'chr1', coord: 9999 }, nodes: NODES }),
   ).toBeNull()
 })
+
+describe('the bubble a linear-view feature names', () => {
+  const bubble = (over: Partial<MinigraphBubble>): MinigraphBubble => ({
+    refName: 'chr1',
+    start: 5,
+    end: 8,
+    segmentCount: 3,
+    pathCount: 2,
+    inversion: false,
+    shortestAlleleLength: 0,
+    longestAlleleLength: 2,
+    segments: '',
+    shortestAllele: undefined,
+    longestAllele: undefined,
+    ...over,
+  })
+  const indexed = bubble({ segments: 's10,s11,s12' })
+  const derived = bubble({ segments: 's21,s20,s22', key: 's20>s22' })
+  const bubbles = [indexed, derived]
+  const at = { refName: 'chr1', coord: 6 }
+
+  test("is the indexed bubble with a bubble feature's segments", () => {
+    expect(
+      bubbleForLgvHover(
+        { ...at, featureSegments: 's10,s11,s12', featureName: '2 bp' },
+        bubbles,
+      ),
+    ).toBe(indexed)
+  })
+
+  // vg deconstruct writes the snarl's ends as the record ID
+  test('is the bubble a graph-derived VCF record names, either way round', () => {
+    expect(bubbleForLgvHover({ ...at, featureName: '>s20>s22' }, bubbles)).toBe(
+      derived,
+    )
+    expect(bubbleForLgvHover({ ...at, featureName: '<s22<s20' }, bubbles)).toBe(
+      derived,
+    )
+    expect(bubbleForLgvHover({ ...at, featureName: '>s10>s12' }, bubbles)).toBe(
+      indexed,
+    )
+  })
+
+  test('is nothing for a feature that names no bubble', () => {
+    expect(bubbleForLgvHover({ ...at, featureName: 'rs123' }, bubbles)).toBe(
+      undefined,
+    )
+    expect(bubbleForLgvHover({ ...at, featureName: '>s20>s99' }, bubbles)).toBe(
+      undefined,
+    )
+  })
+
+  test('a selected feature reads as a hover at its start', () => {
+    const fields: Record<string, unknown> = {
+      refName: 'chr1',
+      start: 5,
+      name: '>s20>s22',
+    }
+    expect(
+      readSelectedFeature({ get: (key: string) => fields[key] }),
+    ).toMatchObject({ refName: 'chr1', coord: 5, featureName: '>s20>s22' })
+    expect(readSelectedFeature(undefined)).toBeUndefined()
+  })
+})
+
+// Two linear views on one locus: the graph paired with A must not light for
+// a hover in B
+describe('a hover from another linear view', () => {
+  const at = (viewId?: string) => ({ refName: 'chr1', coord: 3, viewId })
+  const live = new Set(['lgvA', 'lgvB'])
+
+  test('is read off the hover payload', () => {
+    expect(
+      readLgvHover({
+        hoverPosition: { refName: 'chr1', coord: 4 },
+        viewId: 'lgvB',
+      })?.viewId,
+    ).toBe('lgvB')
+  })
+
+  test('is ignored by a graph paired with an open view', () => {
+    expect(hoverFromPair(at('lgvA'), 'lgvA', live)).toBe(true)
+    expect(hoverFromPair(at('lgvB'), 'lgvA', live)).toBe(false)
+  })
+
+  test('reaches an unpaired graph, one whose pair closed, or from an older host', () => {
+    expect(hoverFromPair(at('lgvB'), undefined, live)).toBe(true)
+    expect(hoverFromPair(at('lgvB'), 'gone', live)).toBe(true)
+    expect(hoverFromPair(at(), 'lgvA', live)).toBe(true)
+  })
+})

package/src/hoverSync/lgvHover.ts

@@ -3,6 +3,7 @@ import { isBackbone } from '@jbrowse/bandage-core/anchoredNodes'
 import { isRecord } from '../isRecord'
 
 import type { SubgraphRegion } from '../GetSubgraph'
+import type { MinigraphBubble } from '@jbrowse/bandage-core/bubbles/bubbleLine'
 import type { GraphNode } from '@jbrowse/bandage-core/types'
 
 // What a LinearGenomeView writes to `session.hovered` on every mousemove (see
@@ -33,6 +34,11 @@ export interface LgvHover {
   // hover that states no assembly is taken at its word rather than dropped.
   assemblyName?: string
   featureName?: string
+  // a bubble feature's comma-separated segment names (MinigraphBubbleAdapter)
+  featureSegments?: string
+  // the linear view hovered, which hosts from jbrowse-components b49f05f438
+  // state
+  viewId?: string
 }
 
 interface FeatureLike {
@@ -46,13 +52,13 @@ function isFeatureLike(value: unknown): value is FeatureLike {
 // A display hovers either a Feature, read with `get`, or a plain hit item with
 // a `name` of its own, which is what the canvas feature display hands over.
 // Reading only the first left the exact segment match dead on that display.
-function hoveredName(feature: unknown) {
-  const name = isFeatureLike(feature)
-    ? feature.get('name')
+function hoveredField(feature: unknown, key: string) {
+  const value = isFeatureLike(feature)
+    ? feature.get(key)
     : isRecord(feature)
-      ? feature.name
+      ? feature[key]
       : undefined
-  return typeof name === 'string' ? name : undefined
+  return typeof value === 'string' ? value : undefined
 }
 
 // `hovered` is typed `unknown` on the session by design — it is a shared channel
@@ -71,13 +77,49 @@ export function readLgvHover(hovered: unknown): LgvHover | undefined {
         coord: typeof coord0 === 'number' ? coord0 : coord - 1,
         assemblyName:
           typeof assemblyName === 'string' ? assemblyName : undefined,
-        featureName: hoveredName(hovered.hoverFeature),
+        featureName: hoveredField(hovered.hoverFeature, 'name'),
+        featureSegments: hoveredField(hovered.hoverFeature, 'segments'),
+        viewId: typeof hovered.viewId === 'string' ? hovered.viewId : undefined,
       }
     }
   }
   return result
 }
 
+// Whether a hover may reach a graph paired with `paired`: one naming another
+// view does not, while the paired view is still open. A hover naming no view,
+// from an older host, and a graph whose pair has closed take any.
+export function hoverFromPair(
+  hover: LgvHover,
+  paired: string | undefined,
+  liveViewIds: ReadonlySet<string>,
+) {
+  return (
+    hover.viewId === undefined ||
+    paired === undefined ||
+    !liveViewIds.has(paired) ||
+    hover.viewId === paired
+  )
+}
+
+// The feature a click in a linear view selected (`session.selection`, which
+// core's feature widget sets), read as a hover at its start
+export function readSelectedFeature(selection: unknown): LgvHover | undefined {
+  if (!isFeatureLike(selection)) {
+    return undefined
+  }
+  const refName = selection.get('refName')
+  const start = selection.get('start')
+  return typeof refName === 'string' && typeof start === 'number'
+    ? {
+        refName,
+        coord: start,
+        featureName: hoveredField(selection, 'name'),
+        featureSegments: hoveredField(selection, 'segments'),
+      }
+    : undefined
+}
+
 // Whether a hover is one this graph can answer: the same assembly, the same
 // stable sequence, and inside the window the cut was made for.
 //
@@ -130,3 +172,32 @@ export function nodeForLgvHover({
   // An exact segment match wins over the coordinate it happens to sit at.
   return byName ?? byCoord ?? null
 }
+
+// A bubble's two end segments, unordered: a derived bubble's key is
+// `source>sink`, and an indexed one lists its segments source first
+function bubbleEnds(b: Pick<MinigraphBubble, 'key' | 'segments'>) {
+  const ids = b.key?.split('>') ?? b.segments.split(',').filter(Boolean)
+  return ids.length >= 2 ? [ids[0]!, ids.at(-1)!].sort().join('\t') : undefined
+}
+
+// The ends a hovered feature names: a bubble feature's segments, or a vg
+// deconstruct record's ID, `>source>sink` (`<sink<source` on the reverse)
+function featureEnds(hover: LgvHover) {
+  if (hover.featureSegments) {
+    return bubbleEnds({ segments: hover.featureSegments })
+  }
+  const ids = /^([<>][^<>]+){2}$/.test(hover.featureName ?? '')
+    ? hover.featureName!.split(/[<>]/).filter(Boolean)
+    : []
+  return ids.length === 2 ? ids.sort().join('\t') : undefined
+}
+
+// The graph's bubble a linear-view feature names, so a bubble track or a
+// graph-derived VCF lights the whole bubble rather than the backbone node at
+// the pointer's bp
+export function bubbleForLgvHover(hover: LgvHover, bubbles: MinigraphBubble[]) {
+  const ends = featureEnds(hover)
+  return ends === undefined
+    ? undefined
+    : bubbles.find(b => bubbleEnds(b) === ends)
+}

package/src/launchFromGraph/contributors.test.ts

@@ -1,8 +1,10 @@
+import { PathVisits } from '@jbrowse/bandage-core/pathVisits'
 import { expect, test } from 'vitest'
 
 import {
   contributingAssemblies,
   locString,
+  nodeAssemblySpans,
   nodeOwnLocation,
   resolveContributors,
   resolveLocationAssembly,
@@ -141,6 +143,27 @@ test('a contributor resolves through an assembly alias, under its own name', ()
   ).toMatchObject({ refName: 'chr17', start: 83899576, end: 84041803 })
 })
 
+test('two haplotypes on one contig name do not share a bare-sample assembly', () => {
+  const contributors = contributingAssemblies(
+    graph([
+      node('s1', 'GRCh38#0#chr6', 31000000, 5000, 0),
+      node('s2', 'HG002#1#chr6', 31100000, 300, 1),
+      node('s3', 'HG002#2#chr6', 31050000, 300, 1),
+    ]),
+  )
+  const bySample = (sample: string) =>
+    ({ HG002: 'HG002', 'HG002#2': 'HG002.2', GRCh38: 'hg38' })[sample]
+  expect(
+    resolveContributors(contributors, bySample).map(c => [
+      c.sample,
+      c.haplotype,
+    ]),
+  ).toEqual([
+    ['hg38', 'GRCh38#0'],
+    ['HG002.2', 'HG002#2'],
+  ])
+})
+
 test('a locstring is 1-based inclusive', () => {
   expect(
     locString({
@@ -201,3 +224,32 @@ test('a haplotype-named graph contributes per haplotype, resolved at that depth
     resolveLocationAssembly(bySample, { sample: 'K12', haplotype: undefined }),
   ).toBeUndefined()
 })
+
+test("a node's spans are where each walk through it passes it, on loaded assemblies", () => {
+  const allele = node('s7', 'HG002#1#CM1', 500, 300, 1)
+  const g = {
+    ...graph([allele]),
+    pathVisits: PathVisits.from([
+      [
+        's7',
+        [
+          {
+            path: 'GRCh38#0#chr6',
+            sample: 'GRCh38',
+            start: 31000,
+            strand: '+',
+          },
+          { path: 'HG002#1#CM1', sample: 'HG002', start: 500, strand: '+' },
+          { path: 'HG002#2#CM2', sample: 'HG002', start: 9100, strand: '-' },
+          { path: 'NA1#1#chr6', sample: 'NA1', start: 40, strand: '+' },
+        ],
+      ],
+    ]),
+  }
+  const resolve = (sample: string) =>
+    ({ GRCh38: 'hg38', 'HG002#1': 'HG002.1', 'HG002#2': 'HG002.2' })[sample]
+  expect(nodeAssemblySpans(g, allele, resolve, 'hg38')).toEqual([
+    { assemblyName: 'HG002.1', refName: 'CM1', start: 500, end: 800 },
+    { assemblyName: 'HG002.2', refName: 'CM2', start: 9100, end: 9400 },
+  ])
+})

package/src/launchFromGraph/contributors.ts

@@ -44,6 +44,94 @@ function anchoredNodeLocation(node: AnchoredNode): GraphLocation {
   }
 }
 
+export interface AssemblySpan {
+  assemblyName: string
+  refName: string
+  start: number
+  end: number
+}
+
+// Where a node's sequence sits on each loaded assembly: its own rGFA
+// location, and where every walk through it passes it on that walk's contig.
+// `except` is the assembly the reference band is already drawn on.
+export function nodeAssemblySpans(
+  graph: Graph,
+  node: GraphNode,
+  resolve: (sample: string) => string | undefined,
+  except?: string,
+) {
+  const spans = new Map<string, AssemblySpan>()
+  const add = (loc: GraphLocation) => {
+    const assemblyName = resolveLocationAssembly(resolve, loc)
+    const key = `${assemblyName}\t${loc.refName}\t${loc.start}`
+    if (assemblyName !== undefined && assemblyName !== except) {
+      spans.set(key, {
+        assemblyName,
+        refName: loc.refName,
+        start: loc.start,
+        end: loc.end,
+      })
+    }
+  }
+  const own = nodeOwnLocation(node)
+  if (own) {
+    add(own)
+  }
+  for (const visit of graph.pathVisits?.get(node.name) ?? []) {
+    add({
+      sample: panSNSample(visit.path),
+      haplotype: panSNHaplotype(visit.path),
+      refName: panSNContig(visit.path),
+      start: visit.start,
+      end: visit.start + node.length,
+    })
+  }
+  return [...spans.values()]
+}
+
+// Each stable sequence off the reference that the cut's nodes lie on, with
+// the loaded assembly holding it and the span its nodes cover there. A gene
+// read over that span, renamed to `stableRefName`, lands on those nodes the
+// way the reference's genes land on the backbone.
+export function offReferenceContigs(
+  graph: Graph,
+  resolve: (sample: string) => string | undefined,
+  except?: string,
+) {
+  const contigs = new Map<string, AssemblySpan & { stableRefName: string }>()
+  // an HPRC cut names hundreds of haplotypes no session loads
+  const unloaded = new Set<string>()
+  for (const node of graph.nodes) {
+    if (!isAnchored(node) || node.stable.rank === 0) {
+      continue
+    }
+    const stableRefName = node.stable.refName
+    if (unloaded.has(stableRefName)) {
+      continue
+    }
+    const loc = anchoredNodeLocation(node)
+    const seen = contigs.get(stableRefName)
+    if (seen) {
+      seen.start = Math.min(seen.start, loc.start)
+      seen.end = Math.max(seen.end, loc.end)
+      continue
+    }
+    const assemblyName = resolveLocationAssembly(resolve, loc)
+    if (assemblyName === undefined || assemblyName === except) {
+      unloaded.add(stableRefName)
+    } else {
+      contigs.set(stableRefName, {
+        stableRefName,
+        assemblyName,
+        refName: loc.refName,
+        start: loc.start,
+        end: loc.end,
+      })
+    }
+  }
+  return [...contigs.values()]
+}
+
 export interface Contributor extends GraphLocation {
   // lowest rank this assembly holds here: 0 means it is the reference backbone
   rank: number
@@ -188,12 +276,28 @@ export function resolveLocationAssembly(
 // among its aliases; matching on names alone leaves that donor unopenable unless
 // the reader renames their assembly after the graph. The resolved (canonical)
 // name replaces the sample, so a launch opens the assembly the session knows.
+//
+// A bare sample stands in for a haplotype unless two haplotypes of it share a
+// contig name. HPRC's GenBank contigs differ per haplotype, so an `NA20809`
+// assembly can hold both; two haplotypes each on `chr6` cannot both be it, and
+// opening hap 2's coordinates on hap 1's sequence lands somewhere plausible
+// and wrong.
 export function resolveContributors(
   contributors: Contributor[],
   resolve: (sample: string) => string | undefined,
 ) {
+  const haplotypesOn = new Map<string, number>()
+  const contig = (c: Contributor) => `${c.sample}\t${c.refName}`
+  for (const c of contributors) {
+    if (c.haplotype !== undefined) {
+      haplotypesOn.set(contig(c), (haplotypesOn.get(contig(c)) ?? 0) + 1)
+    }
+  }
   return contributors.flatMap(c => {
-    const sample = resolveLocationAssembly(resolve, c)
+    const sample =
+      (haplotypesOn.get(contig(c)) ?? 0) > 1
+        ? resolve(c.haplotype!)
+        : resolveLocationAssembly(resolve, c)
     return sample === undefined ? [] : [{ ...c, sample }]
   })
 }

package/src/launchFromGraph/launchFromGraph.ts

@@ -253,8 +253,8 @@ function assemblyNamesOfTrack(
 // point of launching from the graph instead of from a linear view.
 //
 // Panels carry THE GRAPH'S OWN TRACK and nothing else, which is a narrower rule
-// than the single-view launch's (see launchTracks, which scans the session for
-// the assembly's annotation). Tried that here: a gene track per panel takes
+// than the single-view launch's (see showInLinearView, which adds the
+// assembly's gene track). Tried that here: a gene track per panel takes
 // about 160px of a row that is otherwise a ruler, so on five strains the
 // annotation is most of the viewport and the ribbons — the thing the launch
 // exists to draw — are squeezed into the gaps, and `collapseEmptyRows` is here

package/src/panSNTabix.test.ts

@@ -66,4 +66,32 @@ describe('a region the file holds no name for', () => {
       refNamesOf(['chr1', 'HG002#1#chr1']).resolveMapped(chrM),
     ).resolves.toBeUndefined()
   })
+
+  // an assemblyNameToPanSN hint would send the user to fix a config that is
+  // already right
+  test('fails a cut by saying the graph has nothing there', async () => {
+    await expect(
+      refNamesOf(['chr1', 'HG002#1#chr1']).resolveForCut(chrM),
+    ).rejects.toThrow('This graph has nothing on hg38 chrM')
+  })
+})
+
+// A walk file indexes `chr1~851968`-style detail sequences beside its contigs
+test("a walk file's detail sequences are not contigs", async () => {
+  const refNames = new PanSNRefNames(
+    {
+      getReferenceSequenceNames: () =>
+        Promise.resolve(['chr1', 'chr1~851968', 'chr2', 'chr2~65536']),
+    } as never,
+    { getConf: () => undefined } as never,
+  )
+  expect(await refNames.assemblyRefNames()).toEqual(['chr1', 'chr2'])
+  expect(
+    await refNames.resolve({
+      assemblyName: 'hg38',
+      refName: 'chr1~851968',
+      start: 0,
+      end: 1,
+    }),
+  ).toBeUndefined()
 })

package/src/panSNTabix.ts

@@ -96,24 +96,23 @@ export function openTabixSlot(
   })
 }
 
+export function unmappedRegionMessage(region: Region) {
+  return `${region.assemblyName} ${region.refName} is not in this graph's index; a graph with PanSN names (GRCh38#0#chr1) needs ${region.assemblyName} mapped to its prefix in assemblyNameToPanSN`
+}
+
 /**
  * The reference-name half of a tabix graph track, against one indexed file.
  *
  * Constructed with the file the adapter's own slots opened, so this never reads
  * a slot whose name it cannot prove.
  */
-export function unmappedRegionMessage(region: Region) {
-  return `${region.assemblyName} ${region.refName} is not in this graph's index; a graph with PanSN names (GRCh38#0#chr1) needs ${region.assemblyName} mapped to its prefix in assemblyNameToPanSN`
-}
-
 export class PanSNRefNames {
   // Read once and shared by every query, so it takes on no caller's signal: a
   // track fetch the user panned away from once aborted the read a graph cut
   // was waiting on. cachedSetup rejects only the caller that aborts, keeps the
   // read going for the rest, and retries a failed read.
   private lookup = cachedSetup({
-    setup: async opts =>
-      refNameLookup(await this.file.getReferenceSequenceNames(opts)),
+    setup: async opts => refNameLookup(await this.names(opts)),
   })
 
   constructor(
@@ -121,6 +120,13 @@ export class PanSNRefNames {
     private adapter: BaseFeatureDataAdapter,
   ) {}
 
+  // A walk file also indexes `<seq>~<chunkStart>` detail sequences, which name
+  // no contig
+  private async names(opts?: BaseOptions) {
+    const names = await this.file.getReferenceSequenceNames(opts)
+    return names.filter(n => !n.includes('~'))
+  }
+
   /**
    * The names the ASSEMBLY uses, not the graph's own.
    *
@@ -132,7 +138,7 @@ export class PanSNRefNames {
    * were spotted.
    */
   async assemblyRefNames(opts: BaseOptions = {}) {
-    const names = await this.file.getReferenceSequenceNames(opts)
+    const names = await this.names(opts)
     const prefix = resolvePanSNPrefix(this.adapter, opts.assemblyName)
     const contigs = names
       .filter(n => panSNMatchesPrefix(n, prefix))
@@ -167,7 +173,7 @@ export class PanSNRefNames {
   async resolveMapped(region: Region, opts?: BaseOptions) {
     const refName = await this.resolve(region, opts)
     if (refName === undefined && region.assemblyName) {
-      const names = await this.file.getReferenceSequenceNames(opts)
+      const names = await this.names(opts)
       const prefix = resolvePanSNPrefix(this.adapter, region.assemblyName)
       if (
         names.every(n => n.includes('#')) &&
@@ -179,6 +185,18 @@ export class PanSNRefNames {
     return refName
   }
 
+  // The name a graph cut reads, failing with what is actually wrong: an
+  // unmapped assembly, or a contig such as chrM the graph has nothing on
+  async resolveForCut(region: Region, opts?: BaseOptions) {
+    const refName = await this.resolveMapped(region, opts)
+    if (refName === undefined) {
+      throw new Error(
+        `This graph has nothing on ${region.assemblyName} ${region.refName}`,
+      )
+    }
+    return refName
+  }
+
   /**
    * The compressed bytes a read of `regions` fetches from the file, as its
    * index estimates them, for the display's byte gate. `queryStart` moves a

package/src/version.ts

@@ -1 +1 @@
-export const version = '7.4.4'
+export const version = '7.5.0'

package/dist/chunks/GraphTrackSettingsDialog-EVIIGC5G.js

@@ -1,6 +0,0 @@
-import{a as G,b as L}from"./chunk-6VNU7SD4.js";import{b as v,c as x,n as d}from"./chunk-7RJMG6I2.js";import"./chunk-2KVE7YAS.js";import"./chunk-S333HOG5.js";import"./chunk-LE7FZM6Y.js";import"./chunk-JRJHXLGP.js";import"./chunk-6SWXMRAV.js";import"./chunk-IKJZPPOA.js";import{g,h}from"./chunk-YU7T5WOQ.js";import{F as m,H as u,n as C}from"./chunk-UGCNPRKC.js";import{b as r,c as i,d as c}from"./chunk-JMBDTNUR.js";var P=d()({section:{marginBottom:24}}),T=[{value:"0",label:"None"},{value:"1",label:"1 hop"},{value:"2",label:"2 hops"}],w=c(function({model:t}){let{classes:l}=P(),o=t.sourceAdapter;return o?.type==="RgfaTabixAdapter"&&!v(o)?i("div",{className:l.section,children:[r(G,{label:"Graph context",sx:{minWidth:200},value:String(t.subgraphContext),options:T,testId:"graph-context-select",onChange:a=>{t.setSubgraphContext(Number(a)),t.recut()}}),r(u,{variant:"caption",component:"div",color:"text.secondary",children:"How far the cut follows links out of the region. At none, a detour that leaves the window draws as two stubs. No effect on gfa-to-tabix's default anchored index."})]}):null}),k=w;var F=d()({section:{marginBottom:24}});function M(n){return n.split(/[\s,]+/).filter(t=>t!=="")}var I=c(function({model:t}){let[l,o]=h(t.cutHaplotypes?.join(", ")??""),a=()=>{let e=M(l);e.join(`
-`)===(t.cutHaplotypes??[]).join(`
-`)||(t.setSubgraphHaplotypes(e),t.recut())};return r(m,{fullWidth:!0,label:"Haplotypes",placeholder:"every haplotype",value:l,slotProps:{htmlInput:{"data-testid":"graph-haplotypes-field"}},onChange:e=>{o(e.target.value)},onBlur:()=>{a()},onKeyDown:e=>{e.key==="Enter"&&a()}})}),A=c(function({model:t,names:l}){let[o,a]=h(t.cutHaplotypes??[]),e=g(o),f=g(""),[b,S]=h(!1),H=p=>{p.join(`
-`)!==(t.cutHaplotypes??[]).join(`
-`)&&(t.setSubgraphHaplotypes(p),t.recut())};return r(C,{multiple:!0,freeSolo:!0,disableCloseOnSelect:!0,options:l,value:o,open:b,onOpen:()=>{S(!0)},onInputChange:(p,s)=>{f.current=s},onClose:(p,s)=>{S(!1);let y=f.current.trim();s==="blur"&&y&&!e.current.includes(y)&&(e.current=[...e.current,y],a(e.current)),H(e.current)},onChange:(p,s)=>{e.current=s,a(s),b||H(s)},renderInput:p=>r(m,{...p,label:"Haplotypes",placeholder:o.length===0?"every haplotype":void 0,slotProps:{...p.slotProps,htmlInput:{...p.slotProps.htmlInput,"data-testid":"graph-haplotypes-field"}}})})}),D=c(function({model:t}){let{classes:l}=F(),o=t.haplotypeNames,a=t.cutHaplotypes?.join(",")??"",e=t.sourceAdapter;return e&&x(e)?i("div",{className:l.section,children:[o?r(A,{model:t,names:o},a):r(I,{model:t},a),i(u,{variant:"caption",component:"div",color:"text.secondary",children:[o?`Which of the graph's ${o.length.toLocaleString()} haplotypes to cut, or a PanSN prefix (HG002 for both).`:"Which haplotypes to cut, as lane assembly names or PanSN prefixes (HG002#1, or HG002 for both) separated by commas."," ","Empty is every haplotype."]})]}):null}),N=D;function B({model:n,onClose:t}){return i(L,{model:n,onClose:t,children:[r(k,{model:n}),r(N,{model:n})]})}export{B as default};
-//# sourceMappingURL=GraphTrackSettingsDialog-EVIIGC5G.js.map