jbrowse-plugin-graphgenomeviewer 8.3.5 → 8.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "8.3.5",
+  "version": "8.3.6",
   "description": "JBrowse 2 graph genome (pangenome) view: rGFA reference-anchored layouts, the Bandage force-directed engine, and haplotype lanes read from a gbz-base database",
   "license": "GPL-3.0-or-later",
   "repository": {

package/src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.test.ts

@@ -1,9 +1,11 @@
+import { TabixIndexedFile } from '@gmod/tabix'
 import { graphTablesGFA } from '@jbrowse/bandage-core/gfa/graphTables'
 import { walkRowsOf } from '@jbrowse/bandage-core/layout/walkRowRuns'
 import { walkRows } from '@jbrowse/bandage-core/layout/walkRows'
 import { loadGraph } from '@jbrowse/bandage-core/pipeline'
 import PluginManager from '@jbrowse/core/PluginManager'
 import { readConfObject } from '@jbrowse/core/configuration'
+import { WalkReader } from '@jbrowse/graph-walks'
 import { firstValueFrom } from 'rxjs'
 import { toArray } from 'rxjs/operators'
 
@@ -247,74 +249,136 @@ test('a window on a haplotype lane answers nothing', async () => {
   expect(found).toEqual([])
 })
 
-// gfa-to-tabix --walks --chunk 1000 of ten 1 kb reference nodes, whose chunks
-// over 2000-8000 hold skip rows for HG002#1 and HG004#1:
-//   W GRCh38 0 chr1 >1>2>3>4>5>6>7>8>9>10
-//   W HG002  1 ctg  >1>2>9>10    a deletion of 2000-8000
-//   W HG003  1 ctg  >1>2>3>4>5>6>7>8>9>10
-//   W HG004  1 ctg  <10<9<2<1    the same deletion, walked backwards
-const skipWindow = { ...window, start: 3100, end: 6000 }
-const skipFeats = (opts: Record<string, unknown> = {}) =>
+// gfa-to-tabix --walks --chunk 1000 of twenty 1 kb reference nodes; every
+// haplotype but HG003 skips 2000-5000, so chunks 2000-4000 hold skip rows:
+//   W GRCh38 0      chr1 >1>2>3>...>20
+//   W HG002  1      ctg  >1>2>6>...>20
+//   W HG004  1      ctg  <20<...<6<2<1     the same walk backwards
+//   W HG003  1      ctg  >1>2>3>...>20
+//   W HG007  1      ctg  >1>2>6>...>20     a W line starting at 100,000
+//   W HG005  1      ctg  >1>2>99>6>...>20  500 bp of node 99 in the gap
+const skipWindow = { ...window, start: 3100, end: 3900 }
+const skipFeats = (
+  opts: Record<string, unknown> = {},
+  name = 'walks5_skipfollow',
+) =>
   firstValueFrom(
-    makeAdapter({}, 'walks5_skippair')
+    makeAdapter({}, name)
       .getFeaturesInMultipleRegions([skipWindow], opts as never)
       .pipe(toArray()),
   )
-
-test('a haplotype whose deletion spans the window is a lane, its record the skipped stretch with the point it crosses the deletion as its mate', async () => {
+const skipSummary = (f: { get: (k: string) => unknown }) => ({
+  ...summary(f),
+  strand: f.get('strand'),
+  spansWindow: f.get('spansWindow'),
+})
+const deletion = (lane: string, mate: string, strand: number) => ({
+  lane,
+  refName: 'chr1',
+  start: 2000,
+  end: 5000,
+  mate,
+  cigar: undefined,
+  strand,
+  spansWindow: true,
+})
+const crossings = [
+  deletion('HG002#1', 'ctg:2000-2000', 1),
+  deletion('HG004#1', 'ctg:15000-15000', -1),
+  deletion('HG005#1', 'ctg:2000-2000', 1),
+  deletion('HG007#1', 'ctg:102000-102000', 1),
+]
+
+test('a haplotype whose deletion spans the window is one spansWindow record of the whole deletion, its mate where it crosses', async () => {
   const found = await skipFeats()
-  expect(found.map(f => ({ ...summary(f), strand: f.get('strand') }))).toEqual([
+  expect(found.map(skipSummary)).toEqual([
     {
       lane: 'HG003#1',
       refName: 'chr1',
       start: 2000,
-      end: 7000,
-      mate: 'ctg:2000-7000',
-      cigar: '5000=',
-      strand: 1,
-    },
-    {
-      lane: 'HG002#1',
-      refName: 'chr1',
-      start: 2000,
-      end: 8000,
-      mate: 'ctg:2000-2000',
-      cigar: undefined,
+      end: 5000,
+      mate: 'ctg:2000-5000',
+      cigar: '3000=',
       strand: 1,
+      spansWindow: undefined,
     },
-    {
-      lane: 'HG004#1',
-      refName: 'chr1',
-      start: 2000,
-      end: 8000,
-      mate: 'ctg:2000-2000',
-      cigar: undefined,
-      strand: -1,
-    },
+    ...crossings,
   ])
+  expect(found[1]!.get('identity')).toBeUndefined()
 })
 
-test("the display's clip maps the whole window onto a skipping haplotype's crossing", async () => {
+test("the display's clip passes a deletion through whole, so its extent is the deletion's length", async () => {
   const found = await skipFeats({
     haplotypes: ['HG002'],
     clipToRegion: true,
     splitAtGapBp: 10_000,
   })
-  expect(found.map(summary)).toEqual([
-    {
-      lane: 'HG002#1',
-      refName: 'chr1',
-      start: 3100,
-      end: 6000,
-      mate: 'ctg:2000-2000',
-      cigar: undefined,
-    },
+  expect(found.map(skipSummary)).toEqual([crossings[0]])
+})
+
+test('a walk passing the node it leaves at inverted still crosses after it', async () => {
+  const found = await skipFeats({ haplotypes: ['HG008'] }, 'walks5_skipinv')
+  expect(found.map(skipSummary)).toEqual([
+    deletion('HG008#1', 'ctg:2000-2000', 1),
+  ])
+})
+
+test('a skipping haplotype outside the lanes asked for opens no lane', async () => {
+  const found = await skipFeats({ haplotypes: ['HG003'] })
+  expect(found.map(f => mateOf(f).assemblyName)).toEqual(['HG003#1'])
+})
+
+test('the crossing cut reads only the chunks before the node a haplotype leaves', async () => {
+  const getLines = vi.spyOn(TabixIndexedFile.prototype, 'getLines')
+  await skipFeats({ haplotypes: ['HG002'] })
+  const reads = getLines.mock.calls.map(call => `${call[1]}-${call[2]}`)
+  getLines.mockRestore()
+  expect(reads.at(-1)).toBe('0-2000')
+})
+
+test('a haplotype whose leaving node the cut lacks is crossed from the node it rejoins', async () => {
+  const cut = WalkReader.prototype.cut
+  const spy = vi
+    .spyOn(WalkReader.prototype, 'cut')
+    .mockImplementation(async function (
+      this: WalkReader,
+      refName,
+      region,
+      opts,
+    ) {
+      const found = await cut.call(this, refName, region, opts)
+      return opts?.contained && region.end === 2000
+        ? { ...found, fragments: [] }
+        : found
+    })
+  const found = await skipFeats()
+  spy.mockRestore()
+  // HG005 rejoins past the 500 bp it carries in the gap
+  expect(found.slice(1).map(skipSummary)).toEqual([
+    crossings[0],
+    crossings[1],
+    deletion('HG005#1', 'ctg:2500-2500', 1),
+    crossings[3],
   ])
 })
 
+test('a failed crossing cut drops only its own lanes', async () => {
+  const cut = WalkReader.prototype.cut
+  const spy = vi
+    .spyOn(WalkReader.prototype, 'cut')
+    .mockImplementation(function (this: WalkReader, refName, region, opts) {
+      return opts?.contained
+        ? Promise.reject(new Error('no such chunk'))
+        : cut.call(this, refName, region, opts)
+    })
+  const found = await skipFeats()
+  spy.mockRestore()
+  expect(found.map(f => mateOf(f).assemblyName)).toEqual(['HG003#1'])
+})
+
 // RgfaTabixAdapter/walkFiles.test.ts's walks5_skip: HG002#1 >1>2>9>10 over
 // ten 10 bp reference nodes in 10 bp chunks
-test('a named haplotype skipping the window opens its lane at the crossing', async () => {
+test('a named haplotype skipping the window is a deletion of the skipped stretch', async () => {
   const found = await firstValueFrom(
     makeAdapter({}, 'walks5_skip')
       .getFeatures(
@@ -323,7 +387,7 @@ test('a named haplotype skipping the window opens its lane at the crossing', asy
       )
       .pipe(toArray()),
   )
-  expect(found.map(summary)).toEqual([
+  expect(found.map(skipSummary)).toEqual([
     {
       lane: 'HG002#1',
       refName: 'chr1',
@@ -331,45 +395,8 @@ test('a named haplotype skipping the window opens its lane at the crossing', asy
       end: 80,
       mate: 'ctg:20-20',
       cigar: undefined,
-    },
-  ])
-})
-
-test('a skipping haplotype outside the lanes asked for opens no lane', async () => {
-  const found = await skipFeats({ haplotypes: ['HG003'] })
-  expect(found.map(f => mateOf(f).assemblyName)).toEqual(['HG003#1'])
-})
-
-test('a lane pair with one lane skipping the window joins the other lane to the crossing, either way round', async () => {
-  const found = await skipFeats({
-    lanePairs: [
-      { queryAssemblyName: 'HG003#1', targetAssemblyName: 'HG002#1' },
-      { queryAssemblyName: 'HG002#1', targetAssemblyName: 'HG003#1' },
-      { queryAssemblyName: 'HG002#1', targetAssemblyName: 'HG004#1' },
-    ],
-    clipToRegion: true,
-    splitAtGapBp: 10_000,
-  })
-  expect(
-    found.map(f => ({ assemblyName: f.get('assemblyName'), ...summary(f) })),
-  ).toEqual([
-    {
-      assemblyName: 'HG003#1',
-      lane: 'HG002#1',
-      refName: 'ctg',
-      start: 2000,
-      end: 7000,
-      mate: 'ctg:2000-2000',
-      cigar: undefined,
-    },
-    {
-      assemblyName: 'HG002#1',
-      lane: 'HG003#1',
-      refName: 'ctg',
-      start: 2000,
-      end: 2000,
-      mate: 'ctg:2000-7000',
-      cigar: undefined,
+      strand: 1,
+      spansWindow: true,
     },
   ])
 })

package/src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.ts

@@ -13,11 +13,9 @@ import { walksKept } from '@jbrowse/graph-walks'
 import {
   anchorAligner,
   chainFeature,
-  crossingFeature,
-  crossingSide,
   lanePairAligner,
   skipCrossing,
-  walkSide,
+  skipFeature,
 } from './walkLanes.ts'
 import { WalkIndex } from '../RgfaTabixAdapter/walkReader.ts'
 import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
@@ -30,9 +28,9 @@ import {
 import { laneZoomNotice } from '../synteny/laneZoomNotice.ts'
 
 import type { WalkTabixSyntenyAdapterConfig } from './configSchema.ts'
+import type { SkipCrossing, SkipSide } from './walkLanes.ts'
 import type { SubgraphAdapterOptions } from '../GetSubgraph.ts'
 import type { LaneFeatureOptions, LanePair } from '../synteny/lanePairs.ts'
-import type { MatchSide } from '../synteny/matchFeature.ts'
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
 import type { Feature } from '@jbrowse/core/util'
 import type { Region } from '@jbrowse/core/util/types'
@@ -144,51 +142,82 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
   }
 
   /**
-   * Where each haplotype that skips the window crosses its deletion, read
-   * from cuts over the reference nodes they leave at, one cut per chunk those
-   * nodes fall in. A haplotype with a walk in the window draws that instead:
-   * NA19036#1 skips the IGL locus on one contig and walks it on another.
+   * Where each skipping haplotype crosses its deletion, read from contained
+   * cuts over the reference node it leaves, one cut per chunk those nodes
+   * fall in, and for any that cut misses, over the node it rejoins. A cut
+   * that fails drops only its own haplotypes' crossings.
    */
   private async skipCrossings(
     refName: string,
-    { skips, fragments }: { skips: WalkSkip[]; fragments: { name: string }[] },
+    skips: WalkSkip[],
+    opts: LaneFeatureOptions,
+  ) {
+    const found: SkipCrossing[] = []
+    let missed = skips
+    for (const side of ['leave', 'rejoin'] as const) {
+      const crossings = await this.sideCrossings(refName, missed, side, opts)
+      for (const crossing of crossings) {
+        found.push(crossing)
+      }
+      const placed = new Set(crossings.map(crossing => crossing.skip))
+      missed = missed.filter(skip => !placed.has(skip))
+    }
+    return found
+  }
+
+  private async sideCrossings(
+    refName: string,
+    skips: WalkSkip[],
+    side: SkipSide,
     opts: LaneFeatureOptions,
   ) {
     const { signal } = opts
-    const walked = new Set(fragments.map(haplotypeOf))
-    const crossing = skips.filter(skip => !walked.has(haplotypeOf(skip)))
     const { chunk } = await this.walks.reader.header({ signal })
+    const boundary = (skip: WalkSkip) =>
+      side === 'leave' ? skip.refStart - 1 : skip.refEnd
     const byChunk = new Map<
       number,
       { group: WalkSkip[]; start: number; end: number }
     >()
-    for (const skip of crossing) {
-      const cs = Math.floor((skip.refStart - 1) / chunk)
+    for (const skip of skips) {
+      const at = boundary(skip)
+      const cs = Math.floor(at / chunk)
       const held = byChunk.get(cs)
       if (held) {
         held.group.push(skip)
-        held.start = Math.min(held.start, skip.refStart - 1)
-        held.end = Math.max(held.end, skip.refStart)
+        held.start = Math.min(held.start, at)
+        held.end = Math.max(held.end, at + 1)
       } else {
-        byChunk.set(cs, {
-          group: [skip],
-          start: skip.refStart - 1,
-          end: skip.refStart,
-        })
+        byChunk.set(cs, { group: [skip], start: at, end: at + 1 })
       }
     }
     const found = await Promise.all(
       [...byChunk.values()].map(async ({ group, start, end }) => {
         const names = new Set(group.map(skip => skip.name))
         const keep = (name: string) => names.has(name)
-        const { graph, fragments } = await this.walks.reader.cut(
-          refName,
-          { start, end },
-          { signal, keep, expand: keep, context: 0, links: false },
-        )
-        return group.map(skip =>
-          skipCrossing(skip, refName, fragments, graph.nodes),
-        )
+        try {
+          const { graph, fragments } = await this.walks.reader.cut(
+            refName,
+            { start, end },
+            {
+              ...this.walks.budgets(),
+              signal,
+              keep,
+              expand: keep,
+              context: 0,
+              contained: true,
+              links: false,
+            },
+          )
+          return group.map(skip =>
+            skipCrossing(skip, refName, fragments, graph.nodes, side),
+          )
+        } catch (error) {
+          if (signal?.aborted) {
+            throw error
+          }
+          return []
+        }
       }),
     )
     return found.flat().filter(crossing => crossing !== undefined)
@@ -197,8 +226,8 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
   /**
    * One record per stretch a haplotype's walk shares with the reference's,
    * on the reference with the haplotype as its mate. A haplotype whose
-   * deletion spans the window is one record of the skipped stretch, its mate
-   * the point where the haplotype crosses the deletion.
+   * deletion spans the window, with no walk there on any contig, is one
+   * `spansWindow` record of the skipped stretch.
    */
   private async anchorFeatures(
     refName: string,
@@ -238,10 +267,18 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
       prefixes === undefined
         ? 0
         : prefixes.findIndex(prefix => panSNMatchesPrefix(name, prefix))
+    // NA19036#1 skips the IGL locus on one contig and walks it on another
+    const walking = new Set(fragments.map(haplotypeOf))
     const crossings = await updateStatus(status, opts.statusCallback, () =>
       this.skipCrossings(
         refName,
-        { skips: skips.filter(skip => rank(skip) >= 0), fragments },
+        skips.filter(
+          skip =>
+            rank(skip) >= 0 &&
+            !walking.has(haplotypeOf(skip)) &&
+            skip.refStart <= start &&
+            skip.refEnd >= end,
+        ),
         opts,
       ),
     )
@@ -267,25 +304,17 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
           ),
         ),
       }))
-    const skipped = crossings.map(crossing => {
-      const { skip } = crossing
-      return {
-        rank: rank(skip),
-        features: [
-          crossingFeature({
-            target: {
-              name: refName,
-              assemblyName: region.assemblyName,
-              refName: region.refName,
-              start: skip.refStart,
-              end: skip.refEnd,
-            },
-            query: crossingSide(crossing, laneOf(skip)),
-            strand: crossing.strand,
-          }),
-        ],
-      }
-    })
+    const skipped = crossings.map(crossing => ({
+      rank: rank(crossing.skip),
+      features: [
+        skipFeature({
+          crossing,
+          refName: region.refName,
+          assemblyName: region.assemblyName,
+          mateAssemblyName: laneOf(crossing.skip),
+        }),
+      ],
+    }))
     return [...walked, ...skipped]
       .sort((a, b) => a.rank - b.rank)
       .flatMap(lane => lane.features)
@@ -295,8 +324,7 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
    * Each pair's two lanes read out of the anchor window, all pairs in one
    * read, and each walk of a pair's query lane aligned to each walk of its
    * target lane. A pair's records sit on its query lane's contigs, the lane
-   * the display draws on top. A lane that skips the window pairs as the
-   * point where it crosses its deletion.
+   * the display draws on top.
    */
   private async pairFeatures(
     refName: string,
@@ -309,57 +337,32 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
       featurePrefix: resolvePanSNPrefix(this, pair.queryAssemblyName),
       matePrefix: resolvePanSNPrefix(this, pair.targetAssemblyName),
     }))
-    const status = lanePairsStatus(pairs)
-    const { graph, fragments, skips } = await this.laneWalks(
+    const { graph, fragments } = await this.laneWalks(
       refName,
       region,
       sides.flatMap(side => [side.featurePrefix, side.matePrefix]),
       opts,
-      status,
-    )
-    const crossings = await updateStatus(status, opts.statusCallback, () =>
-      this.skipCrossings(refName, { skips, fragments }, opts),
+      lanePairsStatus(pairs),
     )
     const align = lanePairAligner(graph.nodes)
     const walksOf = (prefix: string) =>
       fragments.filter(f => panSNMatchesPrefix(f.name, prefix))
-    const walkSides = (prefix: string, assemblyName: string) =>
-      walksOf(prefix).map(walk => walkSide(walk, assemblyName))
-    const crossingSides = (prefix: string, assemblyName: string) =>
-      crossings
-        .filter(({ skip }) => panSNMatchesPrefix(skip.name, prefix))
-        .map(crossing => crossingSide(crossing, assemblyName))
-    const crossed = (own: MatchSide[], mates: MatchSide[]) =>
-      own.flatMap(target =>
-        mates.map(query => crossingFeature({ target, query, strand: '+' })),
-      )
-    return sides.flatMap(({ pair, featurePrefix, matePrefix }) => {
-      const { queryAssemblyName, targetAssemblyName } = pair
-      return [
-        ...walksOf(featurePrefix).flatMap(target =>
-          walksOf(matePrefix).flatMap(query =>
-            align(query, target).map(chain =>
-              chainFeature({
-                chain,
-                target,
-                query,
-                assemblyName: queryAssemblyName,
-                refName: panSNContig(target.name),
-                mateAssemblyName: targetAssemblyName,
-              }),
-            ),
+    return sides.flatMap(({ pair, featurePrefix, matePrefix }) =>
+      walksOf(featurePrefix).flatMap(target =>
+        walksOf(matePrefix).flatMap(query =>
+          align(query, target).map(chain =>
+            chainFeature({
+              chain,
+              target,
+              query,
+              assemblyName: pair.queryAssemblyName,
+              refName: panSNContig(target.name),
+              mateAssemblyName: pair.targetAssemblyName,
+            }),
           ),
         ),
-        ...crossed(
-          walkSides(featurePrefix, queryAssemblyName),
-          crossingSides(matePrefix, targetAssemblyName),
-        ),
-        ...crossed(
-          crossingSides(featurePrefix, queryAssemblyName),
-          walkSides(matePrefix, targetAssemblyName),
-        ),
-      ]
-    })
+      ),
+    )
   }
 
   // The files are filed under the reference alone, so a window on a