jbrowse-plugin-graphgenomeviewer 3.0.4 → 3.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "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": {
@@ -93,7 +93,6 @@
     "bench:layout": "node scripts/bench-layout.mjs",
     "layout-digest": "node scripts/layout-digest.mjs",
     "build:bundle": "NODE_ENV=production node esbuild.mjs",
-    "betabuild": "bash scripts/betabuild.sh",
     "typecheck": "node node_modules/typescript7/bin/tsc --noEmit",
     "host-compat": "node scripts/host-compat-probe.mjs",
     "lint": "eslint --report-unused-disable-directives --max-warnings 0",

package/src/GbzBaseSyntenyAdapter/GbzBaseSyntenyAdapter.test.ts

@@ -3,7 +3,6 @@ import { toArray } from 'rxjs/operators'
 
 import Adapter, {
   NoReferenceSampleError,
-  PairTargetError,
   laneAssemblyName,
 } from './GbzBaseSyntenyAdapter.ts'
 import configSchema from './configSchema.ts'
@@ -421,265 +420,6 @@ test('getSubgraph refuses a window on a haplotype lane with a message naming the
   ).rejects.toThrow(/cut on its reference, hg38; a window on HG01106#1/)
 })
 
-// the bases each side of a record walks, in JBrowse's convention: the feature
-// side takes D, the mate side I
-function cigarSpans(cigar: string) {
-  let feature = 0
-  let mate = 0
-  for (const [, n, op] of cigar.matchAll(/(\d+)([MIDX=])/g)) {
-    feature += op === 'I' ? 0 : +n
-    mate += op === 'D' ? 0 : +n
-  }
-  return { feature, mate }
-}
-
-const largestGap = (cigar: string) =>
-  Math.max(0, ...[...cigar.matchAll(/(\d+)[ID]/g)].map(([, n]) => Number(n)))
-
-// HG01361#2 and HG02145#2 each carry a ~170 bp insertion against GRCh38 at
-// 31,498,602, which a band composed through GRCh38 draws as nothing
-const insertionWindow = { ...window, start: 31498400, end: 31498900 }
-const pair = {
-  queryAssemblyName: 'HG01361#2',
-  targetAssemblyName: 'HG02145#2',
-}
-
-// the companion carries anchor rows, the one cut that holds a walk whole
-const anchoredAdapter = (conf: Record<string, unknown> = {}) =>
-  makeAdapter({
-    haplotypeIndexLocation: {
-      localPath: require.resolve('./test_data/micb-kir3dl1.haplotype-index.db'),
-      locationType: 'LocalPathLocation',
-    },
-    ...conf,
-  })
-
-const spanOf = (intervals: { start: number; end: number }[]) => ({
-  start: Math.min(...intervals.map(i => i.start)),
-  end: Math.max(...intervals.map(i => i.end)),
-})
-
-// HG00673#1's insertion is 16 bp longer than HG01361#2's, so that pair holds
-// an indel, which pins which side of the record its CIGAR walks. HG00438#1 is
-// assembled reverse to GRCh38. Each pair covers the stretch of each haplotype
-// that its own alignment to GRCh38 does, which pairAlignments never reads
-test.each(['HG02145#2', 'HG00673#1', 'HG00438#1'])(
-  'a lane pair on an anchor window answers HG01361#2 aligned to %s, on HG01361#2',
-  async lower => {
-    const adapter = anchoredAdapter()
-    const records = await feats(adapter, insertionWindow, {
-      queryAssemblyName: 'HG01361#2',
-      targetAssemblyName: lower,
-    })
-    expect(records.length).toBeGreaterThan(0)
-    for (const f of records) {
-      expect(f.get('assemblyName')).toBe('HG01361#2')
-      const mate = mateOf(f)
-      expect(mate.assemblyName).toBe(lower)
-      expect(cigarSpans(f.get('CIGAR'))).toEqual({
-        feature: f.get('end') - f.get('start'),
-        mate: mate.end - mate.start,
-      })
-    }
-    const onReference = async (lane: string) =>
-      (await feats(adapter, insertionWindow, { targetAssemblyName: lane })).map(
-        f => mateOf(f),
-      )
-    const [upper] = await onReference('HG01361#2')
-    const [mate] = await onReference(lower)
-    expect(new Set(records.map(f => f.get('refName')))).toEqual(
-      new Set([upper!.refName]),
-    )
-    expect(
-      spanOf(records.map(f => ({ start: f.get('start'), end: f.get('end') }))),
-    ).toEqual(spanOf([upper!]))
-    expect(new Set(records.map(f => mateOf(f).refName))).toEqual(
-      new Set([mate!.refName]),
-    )
-    expect(spanOf(records.map(f => mateOf(f)))).toEqual(spanOf([mate!]))
-  },
-)
-
-// the same 179 bp allele assembled forward (HG01928#2) and reverse
-// (HG00438#1): a `-` record's CIGAR reads along the query lane, as a `+`
-// record's does, so the one difference from HG01361#2 sits at the same place
-test('a reverse-strand pair writes its CIGAR along the query lane', async () => {
-  const adapter = anchoredAdapter()
-  const pairWith = async (lower: string) =>
-    (
-      await feats(adapter, insertionWindow, {
-        queryAssemblyName: 'HG01361#2',
-        targetAssemblyName: lower,
-      })
-    )[0]!
-  const reverse = await pairWith('HG00438#1')
-  const forward = await pairWith('HG01928#2')
-  expect(reverse.get('strand')).toBe(-1)
-  expect(forward.get('strand')).toBe(1)
-  expect(largestGap(forward.get('CIGAR'))).toBeGreaterThan(0)
-  expect(reverse.get('CIGAR')).toBe(forward.get('CIGAR'))
-})
-
-test('the pair with an indel between its lanes writes it', async () => {
-  const records = await feats(anchoredAdapter(), insertionWindow, {
-    queryAssemblyName: 'HG01361#2',
-    targetAssemblyName: 'HG00673#1',
-  })
-  expect(records.some(f => largestGap(f.get('CIGAR')) > 0)).toBe(true)
-})
-
-test('sequence both lanes carry and GRCh38 lacks aligns inside the pair record', async () => {
-  const adapter = anchoredAdapter()
-  const againstReference = await feats(adapter, insertionWindow, {
-    targetAssemblyName: 'HG01361#2',
-  })
-  expect(
-    Math.max(...againstReference.map(f => largestGap(f.get('CIGAR')))),
-  ).toBeGreaterThan(150)
-  const records = await feats(adapter, insertionWindow, pair)
-  for (const f of records) {
-    expect(largestGap(f.get('CIGAR'))).toBeLessThan(50)
-  }
-  const aligned = records.reduce(
-    (sum, f) => sum + f.get('end') - f.get('start'),
-    0,
-  )
-  expect(aligned).toBeGreaterThan(
-    insertionWindow.end - insertionWindow.start + 150,
-  )
-})
-
-test('a lane pair walks only its two lanes', async () => {
-  const adapter = anchoredAdapter()
-  const { db } = await (
-    adapter as unknown as {
-      graph: () => Promise<{ db: { getSubgraphForRange: unknown } }>
-    }
-  ).graph()
-  const cut = vi.spyOn(db, 'getSubgraphForRange')
-  await feats(adapter, insertionWindow, pair)
-  const { keep } = cut.mock.calls.at(-1)![3] as {
-    keep: (name: { sample: string; haplotype: number }) => boolean
-  }
-  const named = (sample: string, haplotype: number) => ({
-    sample,
-    haplotype,
-    contig: '',
-    fragment: 0,
-  })
-  expect(keep(named('HG01361', 2))).toBe(true)
-  expect(keep(named('HG02145', 2))).toBe(true)
-  expect(keep(named('HG01361', 1))).toBe(false)
-  expect(keep(named('HG00438', 1))).toBe(false)
-  cut.mockRestore()
-})
-
-test('lane pair ids are the same across two fetches of one window', async () => {
-  const adapter = anchoredAdapter()
-  const ids = async () =>
-    (await feats(adapter, insertionWindow, pair)).map(f => f.id()).sort()
-  const a = await ids()
-  expect(new Set(a).size).toBe(a.length)
-  expect(await ids()).toEqual(a)
-})
-
-test('a lane pair names its lanes the way the header does, through assemblyNameToPanSN', async () => {
-  const adapter = anchoredAdapter({
-    assemblyNameToPanSN: {
-      hg38: 'GRCh38#0',
-      'HG01361.2': 'HG01361#2',
-      'HG02145.2': 'HG02145#2',
-    },
-  })
-  const records = await feats(adapter, insertionWindow, {
-    queryAssemblyName: 'HG01361.2',
-    targetAssemblyName: 'HG02145.2',
-  })
-  expect(records.length).toBeGreaterThan(0)
-  for (const f of records) {
-    expect(f.get('assemblyName')).toBe('HG01361.2')
-    expect(mateOf(f).assemblyName).toBe('HG02145.2')
-  }
-})
-
-// the anchor window's numbers are no coordinates on a lane's contig, so a
-// clip against them would cut the records to nothing
-test('clipToRegion keeps a lane pair whole and drops its CIGAR', async () => {
-  const adapter = anchoredAdapter()
-  const whole = await feats(adapter, insertionWindow, pair)
-  const clippedPairs = await firstValueFrom(
-    adapter
-      .getFeaturesInMultipleRegions([insertionWindow] as never, {
-        ...pair,
-        clipToRegion: true,
-        splitAtGapBp: 10_000,
-      })
-      .pipe(toArray()),
-  )
-  expect(clippedPairs.map(f => [f.get('start'), f.get('end')])).toEqual(
-    whole.map(f => [f.get('start'), f.get('end')]),
-  )
-  for (const f of clippedPairs) {
-    expect(f.get('CIGAR')).toBeUndefined()
-  }
-})
-
-// CHM13's contigs are several fragments each in HPRC v2.1, and a cut takes the
-// fragment its window starts in alone; this fixture's are whole, so a second
-// GRCh38 chr6 fragment is reported starting mid-window
-test('a lane pair across a reference fragment boundary is cut once per fragment', async () => {
-  const adapter = anchoredAdapter()
-  const { db } = await (
-    adapter as unknown as {
-      graph: () => Promise<{
-        db: {
-          paths: () => Promise<
-            {
-              isIndexed: boolean
-              name: { sample: string; contig: string; fragment: number }
-            }[]
-          >
-          getSubgraphForRange: unknown
-        }
-      }>
-    }
-  ).graph()
-  const paths = await db.paths()
-  const grch38 = paths.find(
-    p => p.isIndexed && p.name.sample === 'GRCh38' && p.name.contig === 'chr6',
-  )!
-  const boundary = 31498700
-  const listed = vi
-    .spyOn(db, 'paths')
-    .mockResolvedValue([
-      ...paths,
-      { ...grch38, name: { ...grch38.name, fragment: boundary } },
-    ])
-  const cut = vi.spyOn(db, 'getSubgraphForRange')
-  const records = await feats(adapter, insertionWindow, pair)
-  expect(cut.mock.calls.map(([, start, end]) => [start, end]).sort()).toEqual([
-    [insertionWindow.start, boundary],
-    [boundary, insertionWindow.end],
-  ])
-  expect(records.length).toBeGreaterThan(1)
-  cut.mockRestore()
-  listed.mockRestore()
-})
-
-test('a lane pair without its target lane is refused', async () => {
-  await expect(
-    feats(anchoredAdapter(), insertionWindow, {
-      queryAssemblyName: 'HG01361#2',
-    }),
-  ).rejects.toThrow(PairTargetError)
-})
-
-// the micb database's own side tables hold no anchor rows, and at context 0
-// its sampled cut leaves both walks in pieces around the insertion
-test('without anchor rows a lane pair answers nothing, which the display composes through the reference', async () => {
-  expect(await feats(makeAdapter(), insertionWindow, pair)).toEqual([])
-})
-
 test('getSubgraph outside every reference fragment is empty', async () => {
   expect(
     await makeAdapter().getSubgraph({ ...window, start: 100, end: 200 }),

package/src/GbzBaseSyntenyAdapter/GbzBaseSyntenyAdapter.ts

@@ -15,13 +15,7 @@ import SyntenyFeature from '../synteny/SyntenyFeature.ts'
 
 import type { GbzBaseSyntenyAdapterConfig } from './configSchema.ts'
 import type { SubgraphAdapterOptions } from '../GetSubgraph.ts'
-import type {
-  HaplotypeAlignment,
-  HaplotypeRef,
-  PairAlignment,
-  PathName,
-  PathQuery,
-} from '@gmod/gbz-base'
+import type { HaplotypeAlignment, PathName, PathQuery } from '@gmod/gbz-base'
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
 import type { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util'
 import type { FileLocation, Region } from '@jbrowse/core/util/types'
@@ -77,23 +71,9 @@ export interface GbzHeaderLane {
  * `haplotypes` narrows a fetch to the lanes listed: PanSN prefixes at sample
  * (`HG002`) or haplotype (`HG002#1`) depth, or assembly names the config maps
  * to one; undefined is every haplotype.
- *
- * `queryAssemblyName` with `targetAssemblyName`, on a window of the anchor,
- * asks for that pair of lanes aligned to each other inside the window.
  */
 export interface GbzFeatureOptions extends ComparativeOptions {
   haplotypes?: string[]
-  queryAssemblyName?: string
-}
-
-export class PairTargetError extends Error {
-  override name = 'PairTargetError'
-
-  constructor(queryAssemblyName: string) {
-    super(
-      `a pair query names both lanes: queryAssemblyName ${queryAssemblyName} came without a targetAssemblyName`,
-    )
-  }
 }
 
 function haplotypeWanted(name: PathName, wanted: string[] | undefined) {
@@ -233,44 +213,6 @@ export function fragmentFeature({
   }
 }
 
-/**
- * One record of a lane pair, on the target walk's own contig with the query
- * walk as its mate. gbz-base writes the CIGAR along the target, a `D` being
- * target bases the query lacks, which is the side a JBrowse feature is, so it
- * passes through unchanged.
- */
-export function pairFeature({
-  pair,
-  lane,
-  mateLane,
-}: {
-  pair: PairAlignment
-  lane: string
-  mateLane: string
-}) {
-  const id = `${haplotypePrefix(pair.target)}#${pair.target.contig}:${pair.targetStart}-${pair.targetEnd}|${haplotypePrefix(pair.query)}#${pair.query.contig}:${pair.queryStart}-${pair.queryEnd}`
-  return new SyntenyFeature({
-    uniqueId: id,
-    assemblyName: lane,
-    refName: pair.target.contig,
-    start: pair.targetStart,
-    end: pair.targetEnd,
-    type: 'match',
-    strand: pair.strand === '-' ? -1 : 1,
-    CIGAR: pair.cigar,
-    syntenyId: id,
-    identity: pair.matches / Math.max(pair.columns, 1),
-    numMatches: pair.matches,
-    blockLen: pair.columns,
-    mate: {
-      refName: pair.query.contig,
-      start: pair.queryStart,
-      end: pair.queryEnd,
-      assemblyName: mateLane,
-    },
-  })
-}
-
 export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBaseSyntenyAdapterConfig> {
   private graph = cachedSetup({
     label: 'Opening pangenome database',
@@ -466,45 +408,6 @@ export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBas
     return subgraph ? subgraph.toGFA({ names: 'resolved' }) : ''
   }
 
-  private async laneHaplotypes(
-    assemblyName: string,
-    opts: BaseOptions,
-  ): Promise<HaplotypeRef[]> {
-    const prefix = resolvePanSNPrefix(this, assemblyName)
-    return (await this.getHaplotypes(opts)).filter(haplotype =>
-      panSNMatchesPrefix(haplotype.prefix, prefix),
-    )
-  }
-
-  /**
-   * The window split wherever the reference sample's contig starts another
-   * fragment, so each piece lies inside one: getSubgraphForRange cuts the
-   * first fragment alone, where getAlignmentsForRange walks them all
-   */
-  private async referencePieces(
-    refName: string,
-    start: number,
-    end: number,
-    opts: BaseOptions,
-  ) {
-    const { db, referenceSample } = await this.graph(opts)
-    const inside = (await db.paths())
-      .filter(
-        path =>
-          path.isIndexed &&
-          path.name.sample === referenceSample &&
-          path.name.contig === refName &&
-          path.name.fragment > start &&
-          path.name.fragment < end,
-      )
-      .map(path => path.name.fragment)
-    const bounds = [start, ...[...new Set(inside)].sort((a, b) => a - b), end]
-    return bounds.slice(1).map((pieceEnd, i) => ({
-      start: bounds[i]!,
-      end: pieceEnd,
-    }))
-  }
-
   private async anchorFeatures(region: Region, opts: GbzFeatureOptions) {
     const { db } = await this.graph(opts)
     const { assemblyName, refName, start, end } = region
@@ -544,87 +447,6 @@ export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBas
     })
   }
 
-  /**
-   * The two lanes' walks cut out of the anchor window alone, and each walk
-   * of the query lane aligned to each walk of the target lane. The records
-   * sit on the query lane's contigs, the lane the display draws on top.
-   *
-   * Only a cut walked from the haplotype index's anchor rows holds each walk
-   * whole. The sampled cut leaves a walk in pieces wherever it strays past the
-   * context, and pieces align only in part, so without anchor rows, or when
-   * the anchor walk of any reference fragment in the window fell back, the
-   * pair answers nothing and the display composes it through the reference.
-   */
-  private async pairFeatures(
-    region: Region,
-    queryAssemblyName: string,
-    opts: GbzFeatureOptions,
-  ) {
-    const { targetAssemblyName } = opts
-    if (targetAssemblyName === undefined) {
-      throw new PairTargetError(queryAssemblyName)
-    }
-    const { db } = await this.graph(opts)
-    const { refName, start, end } = region
-    const featureSide = await this.laneHaplotypes(queryAssemblyName, opts)
-    const mateSide = await this.laneHaplotypes(targetAssemblyName, opts)
-    const kept = [...featureSide, ...mateSide]
-    const query = await this.referenceQuery(refName, opts)
-    const nodeLimit: number = this.getConf('nodeLimit')
-    const anchored = (await db.haplotypeAnchorSpacing()) !== undefined
-    const cut = (reference: PathQuery, piece: { start: number; end: number }) =>
-      db
-        .getSubgraphForRange(reference, piece.start, piece.end, {
-          context: this.getConf('context'),
-          haplotypes: 'all',
-          limit: nodeLimit,
-          signal: opts.signal,
-          keep: name =>
-            kept.some(
-              haplotype =>
-                haplotype.sample === name.sample &&
-                haplotype.haplotype === name.haplotype,
-            ),
-        })
-        .catch((error: unknown) => {
-          throw nodeLimitError(error, nodeLimit, end - start) ?? error
-        })
-    const subgraphs =
-      query && anchored && featureSide.length > 0 && mateSide.length > 0
-        ? (
-            await updateStatus(
-              `Aligning ${queryAssemblyName} to ${targetAssemblyName}`,
-              opts.statusCallback,
-              async () =>
-                Promise.all(
-                  (await this.referencePieces(refName, start, end, opts)).map(
-                    piece => cut(query, piece),
-                  ),
-                ),
-            )
-          ).filter(subgraph => subgraph !== undefined)
-        : []
-    const whole = subgraphs.every(subgraph => {
-      const walk = subgraph.stats.anchorWalk
-      return walk !== undefined && walk.fallback === undefined
-    })
-    return whole
-      ? subgraphs.flatMap(subgraph =>
-          featureSide.flatMap(target =>
-            mateSide.flatMap(mate =>
-              subgraph.pairAlignments({ target, query: mate }).map(pair =>
-                pairFeature({
-                  pair,
-                  lane: queryAssemblyName,
-                  mateLane: targetAssemblyName,
-                }),
-              ),
-            ),
-          ),
-        )
-      : []
-  }
-
   getFeatures(region: Region, opts: GbzFeatureOptions = {}) {
     return ObservableCreate<Feature>(async observer => {
       const { db, anchor } = await this.graph(opts)
@@ -632,12 +454,9 @@ export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBas
         throw new NoHaplotypeIndexError()
       }
       // the graph is indexed on its reference alone, so a window on a
-      // haplotype lane has no answer: a lane pair is read inside the anchor's
+      // haplotype lane has no answer
       if (region.assemblyName === anchor) {
-        const features =
-          opts.queryAssemblyName === undefined
-            ? await this.anchorFeatures(region, opts)
-            : await this.pairFeatures(region, opts.queryAssemblyName, opts)
+        const features = await this.anchorFeatures(region, opts)
         for (const feature of features) {
           observer.next(feature)
         }

package/src/GbzBaseSyntenyAdapter/index.ts

@@ -16,14 +16,7 @@ export default function GbzBaseSyntenyAdapterF(pluginManager: PluginManager) {
         // headerLanes: getHeader declares every haplotype as a lane, which is
         // what makes MultiWaySyntenyDisplay read the header of an untiered
         // adapter and offer its lane picker over the whole graph.
-        // lanePairsOnAnchor: a window of the anchor answers any two lanes'
-        // alignment to each other, so the display fetches each adjacent pair
-        // rather than composing it through the reference
-        adapterCapabilities: [
-          'getSubgraph',
-          'headerLanes',
-          'lanePairsOnAnchor',
-        ],
+        adapterCapabilities: ['getSubgraph', 'headerLanes'],
         adapterMetadata: {
           category: 'Synteny adapters',
         },

package/src/version.ts

@@ -1 +1 @@
-export const version = '3.0.4'
+export const version = '3.0.5'