jbrowse-plugin-graphgenomeviewer 8.3.4 → 8.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "8.3.4",
+  "version": "8.3.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": {
@@ -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

@@ -247,6 +247,133 @@ 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> = {}) =>
+  firstValueFrom(
+    makeAdapter({}, 'walks5_skippair')
+      .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 found = await skipFeats()
+  expect(found.map(f => ({ ...summary(f), strand: f.get('strand') }))).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,
+      strand: 1,
+    },
+    {
+      lane: 'HG004#1',
+      refName: 'chr1',
+      start: 2000,
+      end: 8000,
+      mate: 'ctg:2000-2000',
+      cigar: undefined,
+      strand: -1,
+    },
+  ])
+})
+
+test("the display's clip maps the whole window onto a skipping haplotype's crossing", 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,
+    },
+  ])
+})
+
+// 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 () => {
+  const found = await firstValueFrom(
+    makeAdapter({}, 'walks5_skip')
+      .getFeatures(
+        { ...window, start: 31, end: 60 },
+        { haplotypes: ['HG002#1'] },
+      )
+      .pipe(toArray()),
+  )
+  expect(found.map(summary)).toEqual([
+    {
+      lane: 'HG002#1',
+      refName: 'chr1',
+      start: 20,
+      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,
+    },
+  ])
+})
+
 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,15 @@ 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,
+  crossingFeature,
+  crossingSide,
+  lanePairAligner,
+  skipCrossing,
+  walkSide,
+} from './walkLanes.ts'
 import { WalkIndex } from '../RgfaTabixAdapter/walkReader.ts'
 import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
 import { ComparativeAdapterBase } from '../synteny/ComparativeAdapterBase.ts'
@@ -24,13 +32,13 @@ import { laneZoomNotice } from '../synteny/laneZoomNotice.ts'
 import type { WalkTabixSyntenyAdapterConfig } from './configSchema.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'
-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 +143,62 @@ 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.
+   */
+  private async skipCrossings(
+    refName: string,
+    { skips, fragments }: { skips: WalkSkip[]; fragments: { name: string }[] },
+    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 byChunk = new Map<
+      number,
+      { group: WalkSkip[]; start: number; end: number }
+    >()
+    for (const skip of crossing) {
+      const cs = Math.floor((skip.refStart - 1) / 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)
+      } else {
+        byChunk.set(cs, {
+          group: [skip],
+          start: skip.refStart - 1,
+          end: skip.refStart,
+        })
+      }
+    }
+    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),
+        )
+      }),
+    )
+    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 is one record of the skipped stretch, its mate
+   * the point where the haplotype crosses the deletion.
    */
   private async anchorFeatures(
     refName: string,
@@ -163,48 +224,79 @@ 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))
+    const crossings = await updateStatus(status, opts.statusCallback, () =>
+      this.skipCrossings(
+        refName,
+        { skips: skips.filter(skip => rank(skip) >= 0), fragments },
+        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 => {
+      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,
+          }),
+        ],
+      }
+    })
+    return [...walked, ...skipped]
+      .sort((a, b) => a.rank - b.rank)
+      .flatMap(lane => lane.features)
   }
 
   /**
    * 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.
+   * the display draws on top. A lane that skips the window pairs as the
+   * point where it crosses its deletion.
    */
   private async pairFeatures(
     refName: string,
@@ -217,32 +309,57 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
       featurePrefix: resolvePanSNPrefix(this, pair.queryAssemblyName),
       matePrefix: resolvePanSNPrefix(this, pair.targetAssemblyName),
     }))
-    const { graph, fragments } = await this.laneWalks(
+    const status = lanePairsStatus(pairs)
+    const { graph, fragments, skips } = await this.laneWalks(
       refName,
       region,
       sides.flatMap(side => [side.featurePrefix, side.matePrefix]),
       opts,
-      lanePairsStatus(pairs),
+      status,
+    )
+    const crossings = await updateStatus(status, opts.statusCallback, () =>
+      this.skipCrossings(refName, { skips, fragments }, opts),
     )
     const align = lanePairAligner(graph.nodes)
     const walksOf = (prefix: string) =>
       fragments.filter(f => panSNMatchesPrefix(f.name, prefix))
-    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,
-            }),
+    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,
+              }),
+            ),
           ),
         ),
-      ),
-    )
+        ...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

package/src/WalkTabixSyntenyAdapter/walkLanes.ts

@@ -4,8 +4,9 @@ import { panSNContig } from '@jbrowse/bandage-core/pansn'
 
 import { matchFeature } from '../synteny/matchFeature.ts'
 
+import type { MatchSide } 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 } 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 +295,89 @@ 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: '+' | '-'
+}
+
+/**
+ * Where a haplotype that skips the window crosses its deletion, from a cut
+ * over the reference node it leaves at `skip.refStart`: past that node, or
+ * where it enters the node when it passes it backwards, arriving across the
+ * deletion
+ */
+export function skipCrossing(
+  skip: WalkSkip,
+  refName: string,
+  fragments: WalkFragment[],
+  nodes: Map<number, WalkNode>,
+): SkipCrossing | undefined {
+  for (const { name, fragStart, hapStart, ids, rev } of fragments) {
+    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 &&
+          node.end === skip.refStart
+        ) {
+          return rev[i]
+            ? { skip, at, strand: '-' }
+            : { skip, at: at + length, strand: '+' }
+        }
+        at += length
+      }
+    }
+  }
+  return undefined
+}
+
+/** One side of a record: a walk fragment's extent on its contig */
+export function walkSide(fragment: WalkFragment, assemblyName: string) {
+  return {
+    name: fragment.name,
+    assemblyName,
+    refName: panSNContig(fragment.name),
+    start: fragment.hapStart,
+    end: fragment.hapEnd,
+  }
+}
+
+/** One side of a record: the point where a haplotype crosses its deletion */
+export function crossingSide({ skip, at }: SkipCrossing, assemblyName: string) {
+  return {
+    name: skip.name,
+    assemblyName,
+    refName: panSNContig(skip.name),
+    start: at,
+    end: at,
+  }
+}
+
+/**
+ * A record with one side a haplotype's deletion crossing. With no CIGAR, a
+ * display clipping it to a window maps the window onto that point, so the
+ * haplotype gets a lane that the window's ribbon narrows to.
+ */
+export function crossingFeature({
+  target,
+  query,
+  strand,
+}: {
+  target: MatchSide
+  query: MatchSide
+  strand: string
+}) {
+  return matchFeature({
+    target,
+    query,
+    strand,
+    matches: 0,
+    columns: Math.max(target.end - target.start, query.end - query.start),
+  })
+}

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/matchFeature.ts

@@ -12,6 +12,7 @@ export interface MatchSide {
  * One record of a walk aligned to another, on the target walk's contig with
  * the query walk as its mate and the CIGAR read along the target, a `D` being
  * target bases the query lacks. Each side's walk name and extent make the id.
+ * A record without a CIGAR maps its two extents onto each other in proportion.
  */
 export function matchFeature({
   target,
@@ -24,7 +25,7 @@ export function matchFeature({
   target: MatchSide
   query: MatchSide
   strand: string
-  cigar: string
+  cigar?: string
   matches: number
   columns: number
 }) {
@@ -37,7 +38,7 @@ export function matchFeature({
     end: target.end,
     type: 'match',
     strand: strand === '-' ? -1 : 1,
-    CIGAR: cigar,
+    ...(cigar === undefined ? {} : { CIGAR: cigar }),
     syntenyId: id,
     identity: matches / Math.max(columns, 1),
     numMatches: matches,

package/src/version.ts

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

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