jbrowse-plugin-graphgenomeviewer 7.1.12 → 7.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "7.1.12",
+  "version": "7.2.0",
   "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/GbzBaseSyntenyAdapter/GbzBaseSyntenyAdapter.test.ts

@@ -366,15 +366,13 @@ test('the graph lists its haplotypes with their contigs, and a fetch can be narr
   )
 })
 
-test('the node limit fails lanes and a graph cut as a zoom-in notice naming a span that fits', async () => {
+test('the node limit fails lanes as a zoom-in notice naming how far to zoom, and a graph cut naming a span that fits', async () => {
   const adapter = makeAdapter({ nodeLimit: 2 })
   const lanes: unknown = await feats(adapter, window).catch((e: unknown) => e)
   expect(lanes).toMatchObject({
     name: 'NodeLimitError',
     regionTooLarge: true,
-    message: expect.stringMatching(
-      /^Zoom in to about [\d.]+[KM]?bp to see lanes$/,
-    ),
+    message: expect.stringMatching(/^Zoom in about [\d.]+× to see lanes$/),
   })
   const graph: unknown = await adapter
     .getSubgraph(window)

package/src/GbzBaseSyntenyAdapter/GbzBaseSyntenyAdapter.ts

@@ -31,6 +31,7 @@ import {
   lanePairsStatus,
   requestedPairs,
 } from '../synteny/lanePairs.ts'
+import { laneZoomNotice } from '../synteny/laneZoomNotice.ts'
 import { matchFeature } from '../synteny/matchFeature.ts'
 
 import type { GbzBaseSyntenyAdapterConfig } from './configSchema.ts'
@@ -223,6 +224,12 @@ function zoomInNotice(error: unknown, what: string) {
   return error
 }
 
+const laneLimitNotice = (error: unknown, nodeLimit: number, windowBp: number) =>
+  laneZoomNotice(
+    zoomInNotice(nodeLimitError(error, nodeLimit, windowBp) ?? error, 'lanes'),
+    windowBp,
+  )
+
 // gbz-base reads whole bp; a view asks at fractional ones
 const wholeBp = (region: Region) => ({
   ...region,
@@ -489,10 +496,7 @@ export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBas
                 keep,
               })
               .catch((error: unknown) => {
-                throw zoomInNotice(
-                  nodeLimitError(error, nodeLimit, end - start) ?? error,
-                  'lanes',
-                )
+                throw laneLimitNotice(error, nodeLimit, end - start)
               }),
         )
       : []
@@ -562,10 +566,7 @@ export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBas
     // a cut past the node limit for the wider context keeps the first one
     const bridged = async (path: PathQuery) => {
       const subgraphs = await cut(path, baseContext).catch((error: unknown) => {
-        throw zoomInNotice(
-          nodeLimitError(error, nodeLimit, end - start) ?? error,
-          'lanes',
-        )
+        throw laneLimitNotice(error, nodeLimit, end - start)
       })
       const gap = widestWalkGap(subgraphs, kept)
       const context = Math.ceil(gap / 2) + 2000

package/src/GraphGenomeView/pane/renderingActions.ts

@@ -107,12 +107,14 @@ export const withRenderingActions = withLoadActions
             { fireImmediately: true },
           ),
         )
-        // A host fits the rows once, when it takes the pane over, which is
-        // before the legend measures the room it needs above them
+        // A host fits the rows when it takes the pane over, which is before
+        // the legend measures the room it needs above them and before a split
+        // into panels changes how tall the drawing is
         addDisposer(
           self,
           reaction(
-            () => self.fitPadTop,
+            () =>
+              `${self.fitPadTop} ${self.layoutBounds?.h} ${self.usableHeight}`,
             () => {
               if (self.viewportOwner === 'host') {
                 self.zoomToFit()

package/src/LinearGraphDisplay/LinearGraphDisplay.test.ts

@@ -1,3 +1,4 @@
+import { fittedTranslateY } from '@jbrowse/bandage-core/pipeline'
 import PluginManager from '@jbrowse/core/PluginManager'
 import {
   ConfigurationReference,
@@ -770,6 +771,20 @@ test('a tube map on its own axis ties each reference box to its bp in the linear
   expect(pane.tubeMapConnectors).toEqual([])
 })
 
+test('a hosted drawing whose height changes after the host took the pane is placed again', async () => {
+  const { pane } = await shownGraph({ paths: true })
+  await pane.switchLayout('tubemapref')
+  await wait(SETTLE_MS)
+  const expected = fittedTranslateY(
+    pane.layoutBounds!,
+    pane.usableHeight,
+    pane.scaleY,
+    pane.fitPads.top,
+  )
+  expect(pane.viewportOwner).toBe('host')
+  expect(pane.translateY).toBeCloseTo(expected, 6)
+})
+
 test("a folded tube map draws the cut's reference as merged nodes, and the rest as ticks or routes", async () => {
   const { pane } = await shownGraph({ paths: true })
   const labels = () =>

package/src/LinearGraphDisplay/configSchema.ts

@@ -38,6 +38,7 @@ export function configSchemaFactory() {
       color: {
         type: 'frozen',
         defaultValue: {},
+        plot: true,
       },
       /**
        * #slot
@@ -48,6 +49,7 @@ export function configSchemaFactory() {
       size: {
         type: 'frozen',
         defaultValue: { field: 'depth', value: 6 },
+        plot: true,
       },
       /**
        * #slot
@@ -61,6 +63,7 @@ export function configSchemaFactory() {
       layers: {
         type: 'frozen',
         defaultValue: {},
+        plot: true,
       },
       /**
        * #slot
@@ -71,6 +74,7 @@ export function configSchemaFactory() {
       facet: {
         type: 'frozen',
         defaultValue: {},
+        plot: true,
       },
       /**
        * #slot
@@ -79,6 +83,7 @@ export function configSchemaFactory() {
       rows: {
         type: 'frozen',
         defaultValue: {},
+        plot: true,
       },
       /**
        * #slot

package/src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.test.ts

@@ -9,10 +9,15 @@ import { toArray } from 'rxjs/operators'
 import Adapter from './WalkTabixSyntenyAdapter.ts'
 import configSchema from './configSchema.ts'
 import WalkTabixSyntenyAdapterF from './index.ts'
-import { bubblesAsMismatches, referenceAligner } from './walkLanes.ts'
+import {
+  bubblesAsMismatches,
+  referenceAligner,
+  walkAligner,
+} from './walkLanes.ts'
 import { walkRowsOf } from '../RgfaTabixAdapter/walkRowRuns.ts'
 import { PairTargetError } from '../synteny/lanePairs.ts'
 
+import type { PairChain } from '@gmod/gbz-base/pairAlignment'
 import type { SyntenyMate } from '@jbrowse/synteny-core'
 
 // Four walks over a 3.6 kb reference of six 600 bp nodes, in 1 kb chunks
@@ -166,6 +171,66 @@ test('a batch of lane pairs answers each pair what it answers alone', async () =
   expect(batch).toHaveLength(2)
 })
 
+// walks3_lanepairs, a 5.5 kb reference of 2 kb flanks around three 500 bp
+// nodes, in 1 kb chunks:
+//   W GRCh38  0 chr1 >1>2>3>4>5
+//   W HG002   1 chr1 >1>2>3>4>5
+//   W HG002   2 chr1 >1<4<3<2>5           the middle three inverted
+//   W HG00097 1 chr1 >1>2>6>2>6>2>3>4>5   2 three times, 6 a 30 bp spacer
+test('a lane pair matches through a copy-number array, and draws an inversion between the lanes as a reverse-strand record', async () => {
+  const found = await firstValueFrom(
+    makeAdapter({}, 'walks3_lanepairs')
+      .getFeatures(
+        { ...window, end: 5500 },
+        {
+          lanePairs: [
+            { queryAssemblyName: 'HG002#1', targetAssemblyName: 'HG002#2' },
+            { queryAssemblyName: 'HG002#1', targetAssemblyName: 'HG00097#1' },
+          ],
+        },
+      )
+      .pipe(toArray()),
+  )
+  expect(
+    found.map(f => ({
+      ...summary(f),
+      strand: f.get('strand'),
+      matches: f.get('numMatches'),
+    })),
+  ).toEqual([
+    {
+      lane: 'HG002#2',
+      refName: 'chr1',
+      start: 0,
+      end: 5500,
+      mate: 'chr1:0-5500',
+      cigar: '2000=1500I1500D2000=',
+      strand: 1,
+      matches: 4000,
+    },
+    {
+      lane: 'HG002#2',
+      refName: 'chr1',
+      start: 2000,
+      end: 3500,
+      mate: 'chr1:2000-3500',
+      cigar: '1500=',
+      strand: -1,
+      matches: 1500,
+    },
+    {
+      lane: 'HG00097#1',
+      refName: 'chr1',
+      start: 0,
+      end: 5500,
+      mate: 'chr1:0-6560',
+      cigar: '2500=1060I3000=',
+      strand: 1,
+      matches: 5500,
+    },
+  ])
+})
+
 test('a lane pair without its target lane is refused', async () => {
   await expect(
     feats(makeAdapter(), { queryAssemblyName: 'HG002#1' }),
@@ -228,12 +293,12 @@ test('getSubgraph cuts the window with the reference walk first', async () => {
   expect(walks).toEqual(['GRCh38#0#chr1', 'HG002#1#chr1'])
 })
 
-test('a window past the step budget fails as a zoom-in notice for lanes', async () => {
+test('a window past the step budget fails as a zoom-in notice for lanes naming how far to zoom', async () => {
   await expect(
     feats(makeAdapter({ walkStepBudget: 20 })),
   ).rejects.toMatchObject({
     name: 'NodeLimitError',
-    message: expect.stringMatching(/to see lanes$/),
+    message: expect.stringMatching(/^Zoom in about [\d.]+×.* to see lanes$/),
   })
 })
 
@@ -387,6 +452,66 @@ test('a haplotype running against the reference is a reverse-strand record', ()
   expect(cigar(chain!.edits)).toBe('1000=30I500=')
 })
 
+// Two lanes over 2 kb flanks and three 500 bp nodes, the second lane running
+// the middle three backwards: >1>2>3>4>5 against >1<4<3<2>5
+const inversionNodes = new Map(
+  [1, 2, 3, 4, 5].map(id => [
+    id,
+    {
+      refName: 'ref',
+      start: id * 10_000,
+      end: id * 10_000 + (id === 1 || id === 5 ? 2000 : 500),
+      rank: 0,
+      onWindow: true,
+    },
+  ]),
+)
+const upperLane = fragment('HG002#1#chr1', [
+  [1, 0],
+  [2, 0],
+  [3, 0],
+  [4, 0],
+  [5, 0],
+])
+const invertedLane = fragment('HG002#2#chr1', [
+  [1, 0],
+  [4, 1],
+  [3, 1],
+  [2, 1],
+  [5, 0],
+])
+const drawn = (chains: PairChain[]) =>
+  chains.map(
+    ({ queryStart, queryEnd, targetStart, targetEnd, strand, edits }) => ({
+      query: `${queryStart}-${queryEnd}`,
+      target: `${targetStart}-${targetEnd}`,
+      strand,
+      cigar: cigar(edits),
+    }),
+  )
+
+test('an inversion between two lanes is a reverse-strand record of its own when chained, and an insertion beside a deletion in the subsequence', () => {
+  expect(drawn(walkAligner(inversionNodes)(invertedLane, upperLane))).toEqual([
+    {
+      query: '0-5500',
+      target: '0-5500',
+      strand: '+',
+      cigar: '2000=1500I1500D2000=',
+    },
+    { query: '2000-3500', target: '2000-3500', strand: '-', cigar: '1500=' },
+  ])
+  expect(
+    drawn(referenceAligner(inversionNodes)(invertedLane, upperLane)),
+  ).toEqual([
+    {
+      query: '0-5500',
+      target: '0-5500',
+      strand: '+',
+      cigar: '2000=1500I1500D2000=',
+    },
+  ])
+})
+
 test.each([
   ['the whole reference', window],
   ['a window inside it', { ...window, start: 1300, end: 2300 }],

package/src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.ts

@@ -10,9 +10,8 @@ import { updateStatus } from '@jbrowse/core/util'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { walksKept } from '@jbrowse/graph-walks'
 
-import { chainFeature, referenceAligner, walkAligner } from './walkLanes.ts'
+import { chainFeature, lanePairAligner, referenceAligner } from './walkLanes.ts'
 import { WalkIndex } from '../RgfaTabixAdapter/walkReader.ts'
-import { isNodeLimitError } from '../nodeLimitError.ts'
 import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
 import { ComparativeAdapterBase } from '../synteny/ComparativeAdapterBase.ts'
 import {
@@ -20,6 +19,7 @@ import {
   lanePairsStatus,
   requestedPairs,
 } from '../synteny/lanePairs.ts'
+import { laneZoomNotice } from '../synteny/laneZoomNotice.ts'
 
 import type { WalkTabixSyntenyAdapterConfig } from './configSchema.ts'
 import type { SubgraphAdapterOptions } from '../GetSubgraph.ts'
@@ -128,13 +128,7 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
           links: false,
         })
         .catch((error: unknown) => {
-          if (isNodeLimitError(error) && error instanceof Error) {
-            error.message = error.message.replace(
-              'to see the graph',
-              'to see lanes',
-            )
-          }
-          throw error
+          throw laneZoomNotice(error, region.end - region.start)
         }),
     )
   }
@@ -228,7 +222,7 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
       opts,
       lanePairsStatus(pairs),
     )
-    const align = walkAligner(graph.nodes)
+    const align = lanePairAligner(graph.nodes)
     const walksOf = (prefix: string) =>
       fragments.filter(f => panSNMatchesPrefix(f.name, prefix))
     return sides.flatMap(({ pair, featurePrefix, matePrefix }) =>

package/src/WalkTabixSyntenyAdapter/walkLanes.ts

@@ -156,6 +156,66 @@ export function referenceAligner(nodes: Map<number, WalkNode>) {
   }
 }
 
+// Each node a walk visits once, with the direction it passes it
+function singleVisits(fragment: WalkFragment) {
+  const rev = new Map<number, number>()
+  const twice = new Set<number>()
+  fragment.ids.forEach((id, i) => {
+    if (rev.has(id)) {
+      twice.add(id)
+    } else {
+      rev.set(id, fragment.rev[i]!)
+    }
+  })
+  for (const id of twice) {
+    rev.delete(id)
+  }
+  return rev
+}
+
+/**
+ * Aligns one lane's walk fragment to another's. The weighted subsequence
+ * (`referenceAligner`) is the fast route and matches through copy-number
+ * arrays, but it reads one direction per pair, so an inversion between the
+ * lanes comes out as an insertion beside a deletion. A pair sharing 100 bp
+ * (MIN_MATCH_BP) or more of singly visited nodes in each direction goes to
+ * pair chaining (`walkAligner`) instead, which answers the inverted stretch as
+ * a reverse-strand record of its own. Chaining leaves out every node a walk
+ * passes twice, so counting singly visited nodes misses no inversion it could
+ * draw.
+ */
+export function lanePairAligner(nodes: Map<number, WalkNode>) {
+  const subsequence = referenceAligner(nodes)
+  const chained = walkAligner(nodes)
+  const visits = new Map<WalkFragment, Map<number, number>>()
+  const visitsOf = (fragment: WalkFragment) => {
+    let found = visits.get(fragment)
+    if (found === undefined) {
+      found = singleVisits(fragment)
+      visits.set(fragment, found)
+    }
+    return found
+  }
+  const inverted = (query: WalkFragment, target: WalkFragment) => {
+    const theirs = visitsOf(target)
+    let same = 0
+    let opposite = 0
+    for (const [id, rev] of visitsOf(query)) {
+      const other = theirs.get(id)
+      if (other === rev) {
+        same += nodeLength(nodes, id)
+      } else if (other !== undefined) {
+        opposite += nodeLength(nodes, id)
+      }
+    }
+    return same >= MIN_MATCH_BP && opposite >= MIN_MATCH_BP
+  }
+  return (query: WalkFragment, target: WalkFragment) =>
+    inverted(query, target)
+      ? chained(query, target)
+      : subsequence(query, target)
+}
+
 /**
  * One record of a walk aligned to another, with its short balanced bubbles as
  * mismatches

package/src/synteny/laneZoomNotice.test.ts

@@ -0,0 +1,55 @@
+import { keptStepsError } from '@jbrowse/graph-walks'
+
+import { laneZoomFold, laneZoomNotice } from './laneZoomNotice.ts'
+
+const BUDGET = 4_000_000
+
+// A lane fetch over `fetchBp` keeping steps at a density whose fitting span
+// is `fitsBp`, refused as @jbrowse/graph-walks refuses it
+function refusal(fetchBp: number, fitsBp: number) {
+  const kept = Math.round((BUDGET * fetchBp) / fitsBp)
+  const fragment = { ids: new Int32Array(kept) }
+  return keptStepsError(
+    [fragment] as never,
+    BUDGET,
+    { start: 0, end: fetchBp },
+    false,
+  )
+}
+
+// On a 1,000 px canvas the display fetches the 800 px blocks the view touches:
+// a 5 Mb view three 4 Mb blocks, a 500 kb view three 400 kb ones
+test.each([
+  ['5 Mb', 12_000_000, 7_290_000, '7.29Mbp', '1.7'],
+  ['500 kb', 1_200_000, 762_000, '762Kbp', '1.6'],
+])(
+  'a %s view over the step budget is told how far to zoom in, not a span wider than it',
+  (_, fetchBp, fitsBp, span, fold) => {
+    const error = refusal(fetchBp, fitsBp)!
+    expect(error.message).toBe(
+      `Zoom in to about ${span}, or choose fewer haplotypes, to see the graph`,
+    )
+    expect(laneZoomNotice(error, fetchBp)).toMatchObject({
+      name: 'NodeLimitError',
+      message: `Zoom in about ${fold}×, or choose fewer haplotypes, to see lanes`,
+    })
+  },
+)
+
+test('the fold rounds up, to a tenth below 10 and a whole number above, and asks for at least 1.1', () => {
+  expect(laneZoomFold(1_010, 1_000)).toBe(1.1)
+  expect(laneZoomFold(1_100, 1_000)).toBe(1.1)
+  expect(laneZoomFold(9_910, 1_000)).toBe(10)
+  expect(laneZoomFold(32_100, 1_000)).toBe(33)
+  expect(laneZoomFold(1_000, 1_200)).toBe(1.1)
+})
+
+test('a refusal naming no span keeps its message', () => {
+  const error = Object.assign(new Error('Too many haplotype steps here'), {
+    name: 'NodeLimitError',
+    fitsBp: 1,
+  })
+  expect(laneZoomNotice(error, 1000)).toMatchObject({
+    message: 'Too many haplotype steps here',
+  })
+})

package/src/synteny/laneZoomNotice.ts

@@ -0,0 +1,34 @@
+import { isNodeLimitError } from '../nodeLimitError.ts'
+
+/**
+ * How many times over the view must zoom in for a lane fetch of `windowBp`
+ * to fit, where `fitsBp` is the widest fetch that would: rounded up to a
+ * tenth, to a whole number past 10, and never under 1.1.
+ */
+export function laneZoomFold(windowBp: number, fitsBp: number) {
+  const fits = Math.max(1, fitsBp)
+  return windowBp >= 10 * fits
+    ? Math.ceil(windowBp / fits)
+    : Math.max(11, Math.ceil((10 * windowBp) / fits)) / 10
+}
+
+/**
+ * A budget refusal for lanes, naming how far to zoom rather than a span. The
+ * display fetches lanes over the 800 px static blocks its view touches, up to
+ * a block past each edge, and never tells the adapter the view, so a span that
+ * fits the fetch can be wider than the view. The fetch narrows with the view,
+ * so a fold holds for both.
+ */
+export function laneZoomNotice(error: unknown, windowBp: number) {
+  if (isNodeLimitError(error) && error instanceof Error) {
+    const { fitsBp } = error as { fitsBp?: unknown }
+    error.message = error.message.replace('to see the graph', 'to see lanes')
+    if (typeof fitsBp === 'number') {
+      error.message = error.message.replace(
+        /^Zoom in to about [\d.,]*\d[KM]?bp/,
+        `Zoom in about ${laneZoomFold(windowBp, fitsBp)}×`,
+      )
+    }
+  }
+  return error
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = '7.1.12'
+export const version = '7.2.0'

package/dist/chunks/GbzBaseSyntenyAdapter-RYGR6L75.js

@@ -1,2 +0,0 @@
-import{a as ae,b as re,c as de,d as oe,e as ie,f as H,g as se}from"./chunk-IJJZC7A4.js";import{a as te}from"./chunk-KOB7YIMR.js";import{a as j,b as W,c as Z,d as u,e as M,f as $,g as U,h as k,i as z,k as X}from"./chunk-OBQFV4NL.js";import"./chunk-O7Y7LYN6.js";import{b as E,c as O}from"./chunk-N4WBX2OS.js";import"./chunk-BWP3XYKD.js";import"./chunk-T4HOC6O3.js";import{a as ne}from"./chunk-PFAHNHMM.js";import"./chunk-VDHDEEMF.js";import{a as V,c as L,m as ee}from"./chunk-EDSIYH4H.js";import"./chunk-YBLNN5FU.js";import"./chunk-MVVXRZXV.js";import{g as F,h as P,i as C}from"./chunk-GUXZESDR.js";import"./chunk-T4R3ZVEM.js";import{d as G,g as Y,h as J,i as K}from"./chunk-IKJZPPOA.js";import"./chunk-7WIBGKBU.js";import{a as N}from"./chunk-OGQ6OQDN.js";import"./chunk-NDRLCGPC.js";import{e as D,o as I}from"./chunk-TENPGIPX.js";function A(n){let i=/\.gbz\.db$/i;return i.test(n)?n.replace(i,".haplotype-index.db"):void 0}function he(n){return J(n)&&A(Y(n))?K(n,i=>A(i)):void 0}function ue(n){return n instanceof Error&&(/\bHTTP 40[34]\b/.test(n.message)||n.code==="ENOENT")}async function ce(n,i){let t=he(n);if(!t)return{};try{return await N(t,i).stat(),{location:t}}catch(e){return ue(e)?{}:{unreadable:String(e)}}}var ge=5e3,ye=50*2**20,q=class extends Error{constructor(t){super(`this GAF is ${(t/2**20).toFixed(0)} MB without an index; bgzip it and index it with tabix -p gaf`);this.name="UnindexedGafTooLargeError"}};function be(n,i){if(n.length<=i)return n;let t=n.length/i;return Array.from({length:i},(e,a)=>n[Math.floor(a*t)])}var pe=(n,i)=>n.path.some(t=>i.has(t.name)),v=class{constructor(i,t){this.file=i;this.tabix=t;this.whole=L({setup:async({signal:i})=>{let{size:t}=await this.file.stat();if(t>ye)throw new q(t);let e=await this.file.readFile({signal:i}),a=new TextDecoder().decode(e[0]===31&&e[1]===139?await V(e):e);return O(a)}})}async readIndexed(i,t,e){let a=1/0,r=-1/0;for(let s of t){let c=Number(s);Number.isInteger(c)&&(a=Math.min(a,c),r=Math.max(r,c))}let o=[];return a<=r&&await i.getLines("{node}",a,r+1,{signal:e,lineCallback:s=>{let c=E(s);c&&pe(c,t)&&o.push(c)}}),o}async readsOver(i,{signal:t}={}){let e=this.tabix?await this.readIndexed(this.tabix,i,t):(await this.whole({signal:t})).filter(a=>pe(a,i));return{records:be(e,ge),total:e.length}}};var B=class extends Error{constructor(t){super(t===void 0?"no haplotype index is set, so the walks cannot be named; build one with gbz-haplotype-index (cargo install gbz-haplotype-index) and set it as haplotypeIndexLocation":`the haplotype index beside the graph database could not be checked (${t}), so the walks cannot be named; if it is there, reload to try again, or set haplotypeIndexLocation`);this.name="NoHaplotypeIndexError"}},_=class extends Error{constructor(t,e){super(`the graph is cut on its reference, ${e}; a window on ${t} has no reference coordinates to cut at. Open the graph from a ${e} view, and find this haplotype's lane there`);this.name="HaplotypeWindowError"}};function we(n,i){return`${u(n)}#${n.contig}@${i.start.node}.${i.start.offset}`}function xe({alignment:n,assemblyName:i,refName:t,lane:e}){let{refStart:a,refEnd:r,strand:o,cigar:s}=n;if(!(r<=a)){let{name:c,hapStart:p,hapEnd:l}=n,d=we(c,n),g={uniqueId:d,assemblyName:i,refName:t,start:a,end:r,type:"match",strand:o==="-"?-1:1,CIGAR:s,syntenyId:d,mate:{refName:c.contig,start:p,end:l,assemblyName:e}};return new ae(g)}}function Se({pair:n,lane:i,mateLane:t}){return se({target:{name:`${u(n.target)}#${n.target.contig}`,assemblyName:i,refName:n.target.contig,start:n.targetStart,end:n.targetEnd},query:{name:`${u(n.query)}#${n.query.contig}`,assemblyName:t,refName:n.query.contig,start:n.queryStart,end:n.queryEnd},strand:n.strand,cigar:n.cigar,matches:n.matches,columns:n.columns})}var Pe=12e4;function Ne(n,i){let t=new Map;for(let a of n)for(let{name:r,start:o,end:s}of a.walkSpans()){let c=u(r);if(i.has(c)){let p=`${c}#${r.contig}`,l=t.get(p);l?l.push([o,s]):t.set(p,[[o,s]])}}let e=0;for(let a of t.values()){a.sort((r,o)=>r[0]-o[0]);for(let r=1;r<a.length;r++){let o=a[r][0]-a[r-1][1];o>0&&o<=Pe&&(e=Math.max(e,o))}}return e}function T(n,i){return n instanceof Z&&(n.message=`Zoom in to about ${D(n.fitsBp)} to see ${i}`),n}var le=n=>({...n,start:Math.floor(n.start),end:Math.ceil(n.end)}),Q=class extends re{constructor(){super(...arguments);this.graph=L({label:"Opening pangenome database",setup:async()=>{let t=this.getConf("gbzDbLocation"),e=this.getConf("haplotypeIndexLocation"),a=G(e)?{location:e}:await ce(t,this.pluginManager),r=a.location,o=await W.open({source:N(t,this.pluginManager),haplotypeIndex:r?N(r,this.pluginManager):void 0}),s=this.getConf("assemblyNames")[0];if(s===void 0)throw new Error("GbzBaseSyntenyAdapter needs assemblyNames: its first entry is the assembly the reference sample is loaded as");let c=await $(o),p=U({configured:this.getConf("referenceSample"),anchorPrefix:P(this,s),referenceSamples:c});return{db:o,anchor:s,referenceSample:p,referenceSamples:c,unreadableIndex:a.unreadable}}});this.gaf=L({label:"Opening reads",setup:async()=>{let t=this.getConf("readsLocation"),e=this.getConf(["readsIndex","location"]);return G(t)?new v(N(t,this.pluginManager),G(e)?ee(this,["readsLocation"],["readsIndex"]):void 0):void 0}})}async referenceQuery(t,e){let{db:a,referenceSample:r}=await this.graph(e);return k(a,r,t)}async getHaplotypes(t={}){let{db:e,referenceSamples:a}=await this.graph(t),r=new Map;for(let o of await e.paths()){let s=u(o.name),c=r.get(s);c?c.contigs.includes(o.name.contig)||c.contigs.push(o.name.contig):r.set(s,{prefix:s,sample:o.name.sample,haplotype:o.name.haplotype,contigs:[o.name.contig],isReference:a.includes(o.name.sample)})}return[...r.values()]}async getHeader(t={}){let{anchor:e,referenceSample:a}=await this.graph(t),r=C(this),o=[];for(let s of await this.getHaplotypes(t))s.sample!==a&&o.push({name:H(r,s.prefix),label:s.prefix,group:s.sample});return{hasCoarseTier:!1,anchorAssemblyName:e,lanes:o}}async getRefNames(t={}){let{db:e,anchor:a,referenceSample:r}=await this.graph(t),{assemblyName:o}=t,s=o===a?void 0:P(this,o),c=(await e.paths()).filter(p=>o===a?p.isIndexed&&p.name.sample===r:F(u(p.name),s)).map(p=>p.name.contig);return[...new Set(c)]}keepPredicate(t,e){let a=t===void 0||t.length===0?void 0:t.map(r=>P(this,r));return a===void 0&&e===void 0?void 0:r=>M(r,a)&&(e===void 0||F(u(r),e))}async getSubgraph(t,e={}){let{signal:a}=e,{db:r,anchor:o,referenceSample:s,unreadableIndex:c}=await this.graph({signal:a}),{assemblyName:p,refName:l,start:d,end:g}=le(t);if(p!==o)throw new _(p,o);let y=await this.referenceQuery(l,{signal:a});if(!y)throw new Error(`${s} has no indexed path ${l} in this graph`);let w=this.keepPredicate(e.haplotypes);if(w!==void 0&&!r.hasHaplotypeIndex)throw new B(c);let f=await X(r,y,d,g,{context:this.getConf("context"),snarls:e.snarls??this.getConf("subgraphSnarls"),limit:this.getConf("nodeLimit"),signal:e.signal,keep:w}).catch(x=>{throw T(x,"the graph")});return typeof f=="string"?f:ne(f,{start:d,end:g},e.walkRows)}async getReads(t,e={}){let a=await this.gaf(e);return a?a.readsOver(new Set(t),e):{records:[],total:0}}async laneHaplotypes(t,e){let a=P(this,t);return(await this.getHaplotypes(e)).filter(r=>F(r.prefix,a))}async anchorFeatures(t,e){let{db:a}=await this.graph(e),{assemblyName:r,refName:o,start:s,end:c}=t,p=P(this,e.targetAssemblyName),l=C(this),d=this.keepPredicate(e.haplotypes,p),g=await this.referenceQuery(o,e),y=this.getConf("nodeLimit");return(g?await I(`Reading graph ${o}:${s.toLocaleString()}-${c.toLocaleString()}`,e.statusCallback,()=>a.getAlignments({path:g,start:s,end:c,context:this.getConf("context"),haplotypes:"all",limit:y,signal:e.signal,keep:d}).catch(f=>{throw T(z(f,y,c-s)??f,"lanes")})):[]).flatMap(f=>{let x=f.resolved?xe({alignment:f,assemblyName:r,refName:o,lane:H(l,u(f.name))}):void 0;return x===void 0?[]:[x]})}async pairFeatures(t,e,a){let{db:r}=await this.graph(a),{refName:o,start:s,end:c}=t,l=(await Promise.all(e.map(async m=>({pair:m,featureSide:await this.laneHaplotypes(m.queryAssemblyName,a),mateSide:await this.laneHaplotypes(m.targetAssemblyName,a)})))).filter(({featureSide:m,mateSide:h})=>m.length>0&&h.length>0),d=new Set(l.flatMap(({featureSide:m,mateSide:h})=>[...m,...h].map(u))),g=await this.referenceQuery(o,a),y=this.getConf("nodeLimit"),w=this.getConf("context"),f=(m,h)=>r.getSubgraphs({path:m,start:s,end:c,context:h,snarls:this.getConf("subgraphSnarls"),haplotypes:"all",limit:y,signal:a.signal,keep:S=>d.has(u(S))}),x=async m=>{let h=await f(m,w).catch(b=>{throw T(z(b,y,c-s)??b,"lanes")}),S=Ne(h,d),R=Math.ceil(S/2)+2e3;return S>0&&R>w?f(m,R).catch(b=>{if(b instanceof j)return h;throw b}):h};return(g&&l.length>0?await I(ie(e),a.statusCallback,()=>x(g)):[]).flatMap(m=>l.flatMap(({pair:h,featureSide:S,mateSide:R})=>S.flatMap(b=>R.flatMap(me=>m.pairAlignments({target:b,query:me,bases:!1}).map(fe=>Se({pair:fe,lane:h.queryAssemblyName,mateLane:h.targetAssemblyName}))))))}getFeatures(t,e={}){let a=le(t);return te(async r=>{let{db:o,anchor:s,unreadableIndex:c}=await this.graph(e);if(!o.hasHaplotypeIndex)throw new B(c);if(a.assemblyName===s){let p=oe(e),l=p.length>0?await this.pairFeatures(a,p,e):await this.anchorFeatures(a,e);for(let d of l)r.next(d)}r.complete()},e.signal)}};export{B as NoHaplotypeIndexError,de as PairTargetError,Q as default,Ne as widestWalkGap};
-//# sourceMappingURL=GbzBaseSyntenyAdapter-RYGR6L75.js.map