jbrowse-plugin-graphgenomeviewer 8.3.4 → 8.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "8.3.4",
+  "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": {
@@ -27,7 +27,7 @@
   "dependencies": {
     "@gmod/bgzf-filehandle": "^6.8.2",
     "@gmod/gbz-base": "^7.4.1",
-    "@gmod/tabix": "^3.13.0",
+    "@gmod/tabix": "^3.13.1",
     "@jbrowse/cigar-utils": "5.0.0-beta.18",
     "@jbrowse/core": "5.0.0-beta.18",
     "@jbrowse/display-kit": "5.0.0-beta.18",

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,6 +249,158 @@ test('a window on a haplotype lane answers nothing', async () => {
   expect(found).toEqual([])
 })
 
+// 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({}, name)
+      .getFeaturesInMultipleRegions([skipWindow], opts as never)
+      .pipe(toArray()),
+  )
+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(skipSummary)).toEqual([
+    {
+      lane: 'HG003#1',
+      refName: 'chr1',
+      start: 2000,
+      end: 5000,
+      mate: 'ctg:2000-5000',
+      cigar: '3000=',
+      strand: 1,
+      spansWindow: undefined,
+    },
+    ...crossings,
+  ])
+  expect(found[1]!.get('identity')).toBeUndefined()
+})
+
+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(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 is a deletion of the skipped stretch', async () => {
+  const found = await firstValueFrom(
+    makeAdapter({}, 'walks5_skip')
+      .getFeatures(
+        { ...window, start: 31, end: 60 },
+        { haplotypes: ['HG002#1'] },
+      )
+      .pipe(toArray()),
+  )
+  expect(found.map(skipSummary)).toEqual([
+    {
+      lane: 'HG002#1',
+      refName: 'chr1',
+      start: 20,
+      end: 80,
+      mate: 'ctg:20-20',
+      cigar: undefined,
+      strand: 1,
+      spansWindow: true,
+    },
+  ])
+})
+
 test('clipToRegion cuts a record to the window on both axes', async () => {
   const found = await firstValueFrom(
     makeAdapter()

package/src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.ts

@@ -10,7 +10,13 @@ import { updateStatus } from '@jbrowse/core/util'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { walksKept } from '@jbrowse/graph-walks'
 
-import { anchorAligner, chainFeature, lanePairAligner } from './walkLanes.ts'
+import {
+  anchorAligner,
+  chainFeature,
+  lanePairAligner,
+  skipCrossing,
+  skipFeature,
+} from './walkLanes.ts'
 import { WalkIndex } from '../RgfaTabixAdapter/walkReader.ts'
 import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
 import { ComparativeAdapterBase } from '../synteny/ComparativeAdapterBase.ts'
@@ -22,15 +28,15 @@ 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 { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
 import type { Feature } from '@jbrowse/core/util'
 import type { Region } from '@jbrowse/core/util/types'
-import type { WalkFragment } from '@jbrowse/graph-walks'
+import type { WalkSkip } from '@jbrowse/graph-walks'
 
-const haplotypeOf = (fragment: WalkFragment) =>
-  panSNHaplotype(fragment.name) ?? fragment.name
+const haplotypeOf = ({ name }: { name: string }) => panSNHaplotype(name) ?? name
 
 export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<WalkTabixSyntenyAdapterConfig> {
   private readonly walks: WalkIndex = new WalkIndex(
@@ -135,9 +141,93 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
     )
   }
 
+  /**
+   * 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: 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 { 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 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, at)
+        held.end = Math.max(held.end, at + 1)
+      } else {
+        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)
+        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)
+  }
+
   /**
    * One record per stretch a haplotype's walk shares with the reference's,
-   * on the reference with the haplotype as its mate
+   * on the reference with the haplotype as its mate. A haplotype whose
+   * deletion spans the window, with no walk there on any contig, is one
+   * `spansWindow` record of the skipped stretch.
    */
   private async anchorFeatures(
     refName: string,
@@ -163,41 +253,71 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
       return []
     }
     const { start, end } = region
-    const { graph, fragments } = await this.laneWalks(
+    const status = `Reading walks ${region.refName}:${start.toLocaleString()}-${end.toLocaleString()}`
+    const { graph, fragments, skips } = await this.laneWalks(
       refName,
       region,
       prefixes,
       opts,
-      `Reading walks ${region.refName}:${start.toLocaleString()}-${end.toLocaleString()}`,
+      status,
     )
-    const align = anchorAligner(graph.nodes)
-    const asmByPrefix = assemblyByPanSNPrefix(this)
-    const references = fragments.filter(f => f.name === refName)
     // lanes come back in the order the fetch names them, which is the order
     // the display stacks lanes of equal weight in
-    const rank = (fragment: WalkFragment) =>
+    const rank = ({ name }: { name: string }) =>
       prefixes === undefined
         ? 0
-        : prefixes.findIndex(prefix =>
-            panSNMatchesPrefix(fragment.name, prefix),
-          )
-    const shown = fragments
-      .filter(fragment => fragment.name !== refName && rank(fragment) >= 0)
-      .sort((a, b) => rank(a) - rank(b))
-    return shown.flatMap(query =>
-      references.flatMap(reference =>
-        align(query, reference).map(chain =>
-          chainFeature({
-            chain,
-            target: reference,
-            query,
-            assemblyName: region.assemblyName,
-            refName: region.refName,
-            mateAssemblyName: laneAssemblyName(asmByPrefix, haplotypeOf(query)),
-          }),
+        : 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.filter(
+          skip =>
+            rank(skip) >= 0 &&
+            !walking.has(haplotypeOf(skip)) &&
+            skip.refStart <= start &&
+            skip.refEnd >= end,
         ),
+        opts,
       ),
     )
+    const align = anchorAligner(graph.nodes)
+    const asmByPrefix = assemblyByPanSNPrefix(this)
+    const laneOf = (walk: { name: string }) =>
+      laneAssemblyName(asmByPrefix, haplotypeOf(walk))
+    const references = fragments.filter(f => f.name === refName)
+    const walked = fragments
+      .filter(fragment => fragment.name !== refName && rank(fragment) >= 0)
+      .map(query => ({
+        rank: rank(query),
+        features: references.flatMap(reference =>
+          align(query, reference).map(chain =>
+            chainFeature({
+              chain,
+              target: reference,
+              query,
+              assemblyName: region.assemblyName,
+              refName: region.refName,
+              mateAssemblyName: laneOf(query),
+            }),
+          ),
+        ),
+      }))
+    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)
   }
 
   /**

package/src/WalkTabixSyntenyAdapter/walkLanes.ts

@@ -2,10 +2,16 @@ import { weightedLcs } from '@gmod/gbz-base/lcs'
 import { pairAlignments, pairCigar } from '@gmod/gbz-base/pairAlignment'
 import { panSNContig } from '@jbrowse/bandage-core/pansn'
 
+import SyntenyFeature from '../synteny/SyntenyFeature.ts'
 import { matchFeature } from '../synteny/matchFeature.ts'
 
 import type { PairChain, PairEdit } from '@gmod/gbz-base/pairAlignment'
-import type { WalkFragment, WalkNode } from '@jbrowse/graph-walks'
+import type {
+  WalkFragment,
+  WalkNode,
+  WalkSkip,
+  WalkStop,
+} from '@jbrowse/graph-walks'
 
 // The longest bubble with equal bases on both sides that is written as
 // mismatches; a longer one stays an insertion and a deletion
@@ -294,3 +300,107 @@ export function chainFeature({
     columns: edits.reduce((sum, [, n]) => sum + n, 0),
   })
 }
+
+/** The point on a haplotype's contig where it crosses a skipped stretch */
+export interface SkipCrossing {
+  skip: WalkSkip
+  at: number
+  strand: '+' | '-'
+}
+
+/**
+ * The reference node either side of a skipped stretch: the one a haplotype
+ * leaves, ending at `refStart`, or the one it rejoins, starting at `refEnd`
+ */
+export type SkipSide = 'leave' | 'rejoin'
+
+/**
+ * Where a haplotype that skips the window crosses its deletion, from a cut
+ * over the reference node on one `side` of it. The jump lies on whichever end
+ * of the walk's fragment goes on to a chunk across the stretch; with neither
+ * or both, on the end the fragment's other steps leave free, and failing that
+ * on the end the node's own direction points to. A walk that passes the node
+ * inverted between two forward steps still crosses after it.
+ */
+export function skipCrossing(
+  skip: WalkSkip,
+  refName: string,
+  fragments: WalkFragment[],
+  nodes: Map<number, WalkNode>,
+  side: SkipSide,
+): SkipCrossing | undefined {
+  const leaving = side === 'leave'
+  const across = (stop: WalkStop) =>
+    stop.kind === 'elsewhere' &&
+    (leaving
+      ? stop.chunk.start >= skip.refStart
+      : stop.chunk.start < skip.refStart)
+  for (const fragment of fragments) {
+    const { name, fragStart, hapStart, ids, rev, before, after } = fragment
+    if (name === skip.name && fragStart === skip.fragStart) {
+      let at = hapStart
+      for (let i = 0; i < ids.length; i++) {
+        const node = nodes.get(ids[i]!)
+        const length = node === undefined ? 0 : node.end - node.start
+        if (
+          node?.rank === 0 &&
+          node.refName === refName &&
+          (leaving ? node.end === skip.refStart : node.start === skip.refEnd)
+        ) {
+          const jumpsAfter =
+            across(after) !== across(before)
+              ? across(after)
+              : i > 0 !== i < ids.length - 1
+                ? i > 0
+                : leaving !== (rev[i] === 1)
+          return {
+            skip,
+            at: jumpsAfter ? at + length : at,
+            strand: jumpsAfter === leaving ? '+' : '-',
+          }
+        }
+        at += length
+      }
+    }
+  }
+  return undefined
+}
+
+/**
+ * A haplotype whose deletion spans the whole window, as the record a
+ * multi-way display lifts out as a deletion: `spansWindow`, the skipped
+ * stretch whole so its length heads the lane, and the crossing as its mate.
+ * The record carries no CIGAR and no identity, so no ramp or identity filter
+ * reads it as an alignment.
+ */
+export function skipFeature({
+  crossing,
+  refName,
+  assemblyName,
+  mateAssemblyName,
+}: {
+  crossing: SkipCrossing
+  refName: string
+  assemblyName: string
+  mateAssemblyName: string
+}) {
+  const { skip, at, strand } = crossing
+  const id = `${skip.name}:${skip.fragStart}:${skip.piece}:skip`
+  return new SyntenyFeature({
+    uniqueId: id,
+    assemblyName,
+    refName,
+    start: skip.refStart,
+    end: skip.refEnd,
+    type: 'deletion',
+    strand: strand === '-' ? -1 : 1,
+    syntenyId: id,
+    spansWindow: true,
+    mate: {
+      refName: panSNContig(skip.name),
+      start: at,
+      end: at,
+      assemblyName: mateAssemblyName,
+    },
+  })
+}

package/src/readinessConformance.test.ts

@@ -0,0 +1,66 @@
+import PluginManager from '@jbrowse/core/PluginManager'
+import LinearGenomeViewPlugin from '@jbrowse/plugin-linear-genome-view'
+import { expect, test } from 'vitest'
+
+import GraphGenomeViewPlugin from './index'
+
+import type DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType'
+import type ViewType from '@jbrowse/core/pluggableElementTypes/ViewType'
+
+// jb.waitReady, the app's ready marker, screenshot tools and the session
+// thumbnail read an absent displayPhase or showLoading as finished, so a type
+// without one reads ready while it loads. The same check for jbrowse-components'
+// own types is products/jbrowse-web/src/schemaTests/ElementsReportLoading.test.ts
+// there.
+
+async function setup() {
+  const pluginManager = new PluginManager([
+    new LinearGenomeViewPlugin(),
+    new GraphGenomeViewPlugin(),
+  ])
+  pluginManager.createPluggableElements()
+  pluginManager.configure()
+  const displays = pluginManager.getElementTypesInGroup(
+    'display',
+  ) as DisplayType[]
+  const views = pluginManager.getElementTypesInGroup('view') as ViewType[]
+  await Promise.all([...displays, ...views].map(t => t.loadStateModel()))
+  return { pluginManager, displays, views }
+}
+
+function missing(instance: object, keys: string[]) {
+  return keys.filter(k => !(k in instance))
+}
+
+test('every display type publishes displayPhase and svgReady', async () => {
+  const { pluginManager, displays } = await setup()
+  expect(displays.length).toBeGreaterThan(0)
+  const gaps = displays.flatMap(t => {
+    const display = t.stateModel.create(
+      {
+        type: t.name,
+        configuration: t.configSchema.create({ displayId: 'x', type: t.name }),
+      },
+      { pluginManager },
+    )
+    const keys = missing(display, ['displayPhase', 'svgReady'])
+    return keys.length ? [`${t.name}: ${keys.join(', ')}`] : []
+  })
+  expect(gaps).toEqual([])
+})
+
+test('every view type publishes showLoading, and an exporting one its init state', async () => {
+  const { pluginManager, views } = await setup()
+  expect(views.length).toBeGreaterThan(0)
+  const gaps = views.flatMap(t => {
+    const view = t.stateModel.create({ type: t.name }, { pluginManager })
+    const keys = missing(
+      view,
+      'exportSvg' in view
+        ? ['showLoading', 'initialized', 'error']
+        : ['showLoading'],
+    )
+    return keys.length ? [`${t.name}: ${keys.join(', ')}`] : []
+  })
+  expect(gaps).toEqual([])
+})

package/src/synteny/clipFeatureToRegion.ts

@@ -151,7 +151,8 @@ function clippedFeature(
  * record the piece was cut from, so a display can tell two runs of one record
  * from two records; `keepAlignment` hands back its
  * own stretch of them as packed ops in `alignmentOps`. A feature with no
- * `mate` is not a pairwise record and passes through whole.
+ * `mate` is not a pairwise record, and a `spansWindow` one is a deletion
+ * whose length the display reads off its extent; both pass through whole.
  *
  * A copy of `@jbrowse/plugin-comparative-adapters`' own, which a runtime plugin
  * cannot import: the worker serves that package as a stub too.
@@ -163,7 +164,7 @@ export function clipFeatureToRegion(
   keepAlignment = false,
 ): Feature[] {
   const mate = mateOf(feature)
-  if (mate === undefined) {
+  if (mate === undefined || feature.get('spansWindow')) {
     return [feature]
   } else {
     const pieces = clipIntervals(

package/src/version.ts

@@ -1 +1 @@
-export const version = '8.3.4'
+export const version = '8.3.6'

package/dist/chunks/WalkTabixSyntenyAdapter-I3MGWUQ5.js

@@ -1,2 +0,0 @@
-import{a as K}from"./chunk-OXU7F4BR.js";import{b as $,d as U,e as X,f as O,g as z,h as G}from"./chunk-WANYNRGU.js";import"./chunk-SYKOZDP6.js";import{a as q}from"./chunk-KOB7YIMR.js";import{p as M,q as _,r as T}from"./chunk-M2D7NUOY.js";import"./chunk-YBLNN5FU.js";import"./chunk-3HS6N7WB.js";import"./chunk-HICKAMKK.js";import{E as D,F as H,i as j}from"./chunk-EENENDGZ.js";import"./chunk-YBLNN5FU.js";import"./chunk-ROZPEXN4.js";import{a as S,c as I,d as W,g as F,h as w,i as x}from"./chunk-L372SDUG.js";import"./chunk-OTBDKJEA.js";import"./chunk-3VGXCEMQ.js";import"./chunk-OGQ6OQDN.js";import"./chunk-3WG3GF2A.js";import{o as R}from"./chunk-J5RMHLFJ.js";var se=50;function re(r){let i=[];for(let e=0;e<r.length;e++){let[t,a]=r[e],[s,n]=r[e+1]??[];a===n&&a<=se&&(t==="I"&&s==="D"||t==="D"&&s==="I")?(i.push(["X",a]),e++):i.push([t,a])}return i}function E(r){return Array.from(r.ids,(i,e)=>2*i+r.rev[e])}function A(r,i){let e=r.get(i);return e===void 0?0:e.end-e.start}function V(r){let i=new Map,e=s=>{let n=A(r,s),o=i.get(n);return o===void 0&&(o="N".repeat(n),i.set(n,o)),o},t=new Map,a=s=>{let n=t.get(s);return n===void 0&&(n=E(s),t.set(s,n)),n};return(s,n)=>_({query:a(s),target:a(n),sequenceOf:e,bases:!1})}var B=100;function v(r,i,e){let t=r.at(-1);e>0&&(t?.[0]===i?t[1]+=e:r.push([i,e]))}function Z(r){let i=t=>A(r,t>>1),e=t=>{let a=new Float64Array(t.length+1);return t.forEach((s,n)=>{a[n+1]=a[n]+i(s)}),a};return(t,a)=>{let s=E(a),n=E(t),[o,l]=M(n,s,i),[u,f]=M(n.map(g=>g^1).reverse(),s,i),c=f>l,p=c?u:o,N=Math.max(l,f);if(N<B)return[];let h=e(s),d=e(n),y=g=>c?n.length-1-p[g][0]:p[g][0],m=[];p.forEach(([,g],k)=>{if(k>0){let[ee,te]=[y(k-1),y(k)].sort((ae,ne)=>ae-ne);v(m,"I",d[te]-d[ee+1]),v(m,"D",h[g]-h[p[k-1][1]+1])}v(m,"=",i(s[g]))});let[b,P]=[y(0),y(p.length-1)].sort((g,k)=>g-k);return[{queryStart:d[b],queryEnd:d[P+1],targetStart:h[p[0][1]],targetEnd:h[p.at(-1)[1]+1],strand:c?"-":"+",edits:m,sharedBases:N}]}}function oe(r){let i=new Map,e=new Set;r.ids.forEach((t,a)=>{i.has(t)?e.add(t):i.set(t,r.rev[a])});for(let t of e)i.delete(t);return i}function J(r){let i=new Map,e=t=>{let a=i.get(t);return a===void 0&&(a=oe(t),i.set(t,a)),a};return(t,a)=>{let s=e(a),n=0,o=0;for(let[l,u]of e(t)){let f=s.get(l);f===u?n+=A(r,l):f!==void 0&&(o+=A(r,l))}return{same:n,opposite:o}}}function Q(r){let i=Z(r),e=V(r),t=J(r);return(a,s)=>{let{same:n,opposite:o}=t(a,s);return n>=B&&o>=B?e(a,s):i(a,s)}}var ie=1e4;function Y(r){let i=Z(r),e=V(r),t=J(r);return(a,s)=>{let n=i(a,s),o=n[0]?.strand,{same:l,opposite:u}=t(a,s);return o===void 0||Math.min(l,u)<ie?n:[...n,...e(a,s).filter(f=>f.strand!==o)]}}function C({chain:r,target:i,query:e,assemblyName:t,refName:a,mateAssemblyName:s}){let n=re(r.edits);return G({target:{name:i.name,assemblyName:t,refName:a,start:i.hapStart+r.targetStart,end:i.hapStart+r.targetEnd},query:{name:e.name,assemblyName:s,refName:W(e.name),start:e.hapStart+r.queryStart,end:e.hapStart+r.queryEnd},strand:r.strand,cigar:T(n),matches:n.reduce((o,[l,u])=>o+(l==="="?u:0),0),columns:n.reduce((o,[,l])=>o+l,0)})}var me=r=>I(r.name)??r.name,L=class extends ${constructor(){super(...arguments);this.walks=new K(D(this,["walksLocation"],["walksIndex"]),this);this.refNames=new H(this.walks.file,this)}get anchor(){let e=this.getConf("assemblyNames")[0];if(e===void 0)throw new Error("WalkTabixSyntenyAdapter needs assemblyNames: its first entry is the assembly the reference sample is loaded as");return e}async getHaplotypeNames(e={}){return this.walks.haplotypeNames(e)}async getHeader(e={}){let{haplotypes:t}=await this.walks.reader.header(e),{anchor:a}=this,s=w(this,a),n=x(this);return{hasCoarseTier:!1,anchorAssemblyName:a,lanes:t.filter(o=>o!==s&&S(o)!==s).map(o=>({name:O(n,o),label:o,group:S(o)}))}}async getRefNames(e={}){let{assemblyName:t}=e;return t===void 0||t===this.anchor?this.refNames.assemblyRefNames({...e,assemblyName:this.anchor}):[]}async getSubgraph(e,t={}){let a=await this.refNames.resolveForCut(e,{signal:t.signal});return this.walks.subgraph(a,e,t)}async laneWalks(e,t,a,s,n){let o=j(a,e);return R(n,s.statusCallback,()=>this.walks.reader.cut(e,t,{...this.walks.budgets(),signal:s.signal,keep:o,expand:o,links:!1}).catch(l=>{throw z(l,t.end-t.start)}))}async anchorFeatures(e,t,a){let s=a.haplotypes?.length?a.haplotypes.map(m=>w(this,m)):void 0,n=w(this,a.targetAssemblyName),o=n===void 0?s:s===void 0||s.some(m=>F(n,m)||F(m,n))?[n]:[];if(o?.length===0)return[];let{start:l,end:u}=t,{graph:f,fragments:c}=await this.laneWalks(e,t,o,a,`Reading walks ${t.refName}:${l.toLocaleString()}-${u.toLocaleString()}`),p=Y(f.nodes),N=x(this),h=c.filter(m=>m.name===e),d=m=>o===void 0?0:o.findIndex(b=>F(m.name,b));return c.filter(m=>m.name!==e&&d(m)>=0).sort((m,b)=>d(m)-d(b)).flatMap(m=>h.flatMap(b=>p(m,b).map(P=>C({chain:P,target:b,query:m,assemblyName:t.assemblyName,refName:t.refName,mateAssemblyName:O(N,me(m))}))))}async pairFeatures(e,t,a,s){let n=a.map(c=>({pair:c,featurePrefix:w(this,c.queryAssemblyName),matePrefix:w(this,c.targetAssemblyName)})),{graph:o,fragments:l}=await this.laneWalks(e,t,n.flatMap(c=>[c.featurePrefix,c.matePrefix]),s,X(a)),u=Q(o.nodes),f=c=>l.filter(p=>F(p.name,c));return n.flatMap(({pair:c,featurePrefix:p,matePrefix:N})=>f(p).flatMap(h=>f(N).flatMap(d=>u(d,h).map(y=>C({chain:y,target:h,query:d,assemblyName:c.queryAssemblyName,refName:W(h.name),mateAssemblyName:c.targetAssemblyName})))))}getFeatures(e,t={}){return q(async a=>{let s=e.assemblyName===this.anchor?await this.refNames.resolve(e,t):void 0;if(s!==void 0){let n=U(t),o=n.length>0?await this.pairFeatures(s,e,n,t):await this.anchorFeatures(s,e,t);for(let l of o)a.next(l)}a.complete()},t.signal)}};export{L as default};
-//# sourceMappingURL=WalkTabixSyntenyAdapter-I3MGWUQ5.js.map