@jbrowse/plugin-alignments 2.2.1 → 2.3.0

package/src/SNPCoverageAdapter/SNPCoverageAdapter.ts

@@ -6,46 +6,13 @@ import { AugmentedRegion as Region } from '@jbrowse/core/util/types'
 import SimpleFeature, { Feature } from '@jbrowse/core/util/simpleFeature'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { toArray } from 'rxjs/operators'
-import {
-  getTag,
-  getTagAlt,
-  fetchSequence,
-  shouldFetchReferenceSequence,
-} from '../util'
-import {
-  parseCigar,
-  getNextRefPos,
-  getModificationPositions,
-  Mismatch,
-} from '../BamAdapter/MismatchParser'
-
-function mismatchLen(mismatch: Mismatch) {
-  return !isInterbase(mismatch.type) ? mismatch.length : 1
-}
-
-function isInterbase(type: string) {
-  return type === 'softclip' || type === 'hardclip' || type === 'insertion'
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function inc(bin: any, strand: number, type: string, field: string) {
-  let thisBin = bin[type][field]
-  if (thisBin === undefined) {
-    thisBin = bin[type][field] = {
-      total: 0,
-      '-1': 0,
-      '0': 0,
-      '1': 0,
-    }
-  }
-  thisBin.total++
-  thisBin[strand]++
-}
+import generateCoverageBins from './generateCoverageBins'
+import { fetchSequence } from '../util'
 
 export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
   protected async configure() {
     const subadapterConfig = this.getConf('subadapter')
-    const sequenceConf = this.getConf(['subadapter', 'sequenceAdapter'])
+    const sequenceConf = subadapterConfig.sequenceAdapter
     const dataAdapter = await this.getSubAdapter?.(subadapterConfig)
 
     const sequenceAdapter = sequenceConf
@@ -81,10 +48,11 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
         .pipe(toArray())
         .toPromise()
 
-      const { bins, skipmap } = await this.generateCoverageBins(
+      const { bins, skipmap } = await generateCoverageBins(
         feats,
         region,
         opts,
+        arg => this.fetchSequence(arg),
       )
 
       bins.forEach((bin, index) => {
@@ -135,218 +103,6 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
   }
 
   freeResources(/* { region } */): void {}
-
-  async generateCoverageBins(
-    features: Feature[],
-    region: Region,
-    opts: { bpPerPx?: number; colorBy?: { type: string; tag?: string } },
-  ) {
-    const { colorBy } = opts
-    const binMax = Math.ceil(region.end - region.start)
-
-    const skipmap = {} as {
-      [key: string]: {
-        score: number
-        feature: unknown
-        start: number
-        end: number
-        strand: number
-        xs: string
-      }
-    }
-
-    // bins contain:
-    // - cov feature if they contribute to coverage
-    // - noncov are insertions/clip features that don't contribute to coverage
-    // - delskips deletions or introns that don't contribute to coverage
-    type BinType = { total: number; strands: { [key: string]: number } }
-
-    const regionSeq =
-      features.length && shouldFetchReferenceSequence(opts.colorBy?.type)
-        ? await this.fetchSequence(region)
-        : undefined
-
-    const bins = [] as {
-      refbase?: string
-      total: number
-      all: number
-      ref: number
-      '-1': 0
-      '0': 0
-      '1': 0
-      lowqual: BinType
-      cov: BinType
-      delskips: BinType
-      noncov: BinType
-    }[]
-
-    for (let i = 0; i < features.length; i++) {
-      const feature = features[i]
-      const fstart = feature.get('start')
-      const fend = feature.get('end')
-      const fstrand = feature.get('strand') as -1 | 0 | 1
-
-      for (let j = fstart; j < fend + 1; j++) {
-        const i = j - region.start
-        if (i >= 0 && i < binMax) {
-          if (bins[i] === undefined) {
-            bins[i] = {
-              total: 0,
-              all: 0,
-              ref: 0,
-              '-1': 0,
-              '0': 0,
-              '1': 0,
-              lowqual: {} as BinType,
-              cov: {} as BinType,
-              delskips: {} as BinType,
-              noncov: {} as BinType,
-            }
-          }
-          if (j !== fend) {
-            bins[i].total++
-            bins[i].all++
-            bins[i].ref++
-            bins[i][fstrand]++
-          }
-        }
-      }
-
-      if (colorBy?.type === 'modifications') {
-        const seq = feature.get('seq') as string
-        const mm = (getTagAlt(feature, 'MM', 'Mm') as string) || ''
-        const ops = parseCigar(feature.get('CIGAR'))
-        const fend = feature.get('end')
-
-        getModificationPositions(mm, seq, fstrand).forEach(
-          ({ type, positions }) => {
-            const mod = `mod_${type}`
-            for (const pos of getNextRefPos(ops, positions)) {
-              const epos = pos + fstart - region.start
-              if (epos >= 0 && epos < bins.length && pos + fstart < fend) {
-                const bin = bins[epos]
-                if (bin) {
-                  inc(bin, fstrand, 'cov', mod)
-                } else {
-                  console.warn(
-                    'Undefined position in modifications snpcoverage encountered',
-                  )
-                }
-              }
-            }
-          },
-        )
-      }
-
-      // methylation based coloring takes into account both reference
-      // sequence CpG detection and reads
-      else if (colorBy?.type === 'methylation') {
-        if (!regionSeq) {
-          throw new Error(
-            'no region sequence detected, need sequenceAdapter configuration',
-          )
-        }
-        const seq = feature.get('seq')
-        const mm = getTagAlt(feature, 'MM', 'Mm') || ''
-        const methBins = new Array(region.end - region.start).fill(0)
-        const ops = parseCigar(feature.get('CIGAR'))
-
-        getModificationPositions(mm, seq, fstrand).forEach(
-          ({ type, positions }) => {
-            // we are processing methylation
-            if (type === 'm') {
-              for (const pos of getNextRefPos(ops, positions)) {
-                const epos = pos + fstart - region.start
-                if (epos >= 0 && epos < methBins.length) {
-                  methBins[epos] = 1
-                }
-              }
-            }
-          },
-        )
-
-        for (let j = fstart; j < fend; j++) {
-          const i = j - region.start
-          if (i >= 0 && i < bins.length - 1) {
-            const l1 = regionSeq[i].toLowerCase()
-            const l2 = regionSeq[i + 1].toLowerCase()
-            const bin = bins[i]
-            const bin1 = bins[i + 1]
-
-            // color
-            if (l1 === 'c' && l2 === 'g') {
-              if (methBins[i] || methBins[i + 1]) {
-                inc(bin, fstrand, 'cov', 'meth')
-                inc(bin1, fstrand, 'cov', 'meth')
-                bins[i].ref--
-                bins[i][fstrand]--
-                bins[i + 1].ref--
-                bins[i + 1][fstrand]--
-              } else {
-                inc(bin, fstrand, 'cov', 'unmeth')
-                inc(bin1, fstrand, 'cov', 'unmeth')
-                bins[i].ref--
-                bins[i][fstrand]--
-                bins[i + 1].ref--
-                bins[i + 1][fstrand]--
-              }
-            }
-          }
-        }
-      }
-
-      // normal SNP based coloring
-      const mismatches = (feature.get('mismatches') as Mismatch[]) || []
-      const colorSNPs =
-        colorBy?.type !== 'modifications' && colorBy?.type !== 'methylation'
-
-      for (let i = 0; i < mismatches.length; i++) {
-        const mismatch = mismatches[i]
-        const mstart = fstart + mismatch.start
-        const mlen = mismatchLen(mismatch)
-        const mend = mstart + mlen
-        for (let j = mstart; j < mstart + mlen; j++) {
-          const epos = j - region.start
-          if (epos >= 0 && epos < bins.length) {
-            const bin = bins[epos]
-            const { base, type } = mismatch
-            const interbase = isInterbase(type)
-            if (!interbase) {
-              bin.ref--
-              bin[fstrand]--
-            } else {
-              inc(bin, fstrand, 'noncov', type)
-            }
-
-            if (type === 'deletion' || type === 'skip') {
-              inc(bin, fstrand, 'delskips', type)
-              bin.total--
-            } else if (!interbase && colorSNPs) {
-              inc(bin, fstrand, 'cov', base)
-              bin.refbase = mismatch.altbase
-            }
-          }
-        }
-
-        if (mismatch.type === 'skip') {
-          const hash = `${mstart}_${mend}_${fstrand}`
-          if (skipmap[hash] === undefined) {
-            skipmap[hash] = {
-              feature: feature,
-              start: mstart,
-              end: mend,
-              strand: fstrand,
-              xs: getTag(feature, 'XS') || getTag(feature, 'TS'),
-              score: 0,
-            }
-          }
-          skipmap[hash].score++
-        }
-      }
-    }
-
-    return { bins, skipmap }
-  }
 }
 
 const { capabilities } = SNPCoverageAdapter

package/src/SNPCoverageAdapter/generateCoverageBins.ts

@@ -0,0 +1,245 @@
+import { AugmentedRegion as Region } from '@jbrowse/core/util/types'
+import { Feature } from '@jbrowse/core/util/simpleFeature'
+import { getTag, getTagAlt, shouldFetchReferenceSequence } from '../util'
+import {
+  parseCigar,
+  getNextRefPos,
+  getModificationPositions,
+  Mismatch,
+} from '../MismatchParser'
+
+function mismatchLen(mismatch: Mismatch) {
+  return !isInterbase(mismatch.type) ? mismatch.length : 1
+}
+
+function isInterbase(type: string) {
+  return type === 'softclip' || type === 'hardclip' || type === 'insertion'
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function inc(bin: any, strand: number, type: string, field: string) {
+  let thisBin = bin[type][field]
+  if (thisBin === undefined) {
+    thisBin = bin[type][field] = {
+      total: 0,
+      '-1': 0,
+      '0': 0,
+      '1': 0,
+    }
+  }
+  thisBin.total++
+  thisBin[strand]++
+}
+
+export default async function generateCoverageBins(
+  features: Feature[],
+  region: Region,
+  opts: { bpPerPx?: number; colorBy?: { type: string; tag?: string } },
+  fetchSequence: (arg: Region) => Promise<string>,
+) {
+  const { colorBy } = opts
+  const binMax = Math.ceil(region.end - region.start)
+
+  const skipmap = {} as {
+    [key: string]: {
+      score: number
+      feature: unknown
+      start: number
+      end: number
+      strand: number
+      xs: string
+    }
+  }
+
+  // bins contain:
+  // - cov feature if they contribute to coverage
+  // - noncov are insertions/clip features that don't contribute to coverage
+  // - delskips deletions or introns that don't contribute to coverage
+  type BinType = { total: number; strands: { [key: string]: number } }
+
+  const regionSeq =
+    features.length && shouldFetchReferenceSequence(opts.colorBy?.type)
+      ? await fetchSequence(region)
+      : undefined
+
+  const bins = [] as {
+    refbase?: string
+    total: number
+    all: number
+    ref: number
+    '-1': 0
+    '0': 0
+    '1': 0
+    lowqual: BinType
+    cov: BinType
+    delskips: BinType
+    noncov: BinType
+  }[]
+
+  for (let i = 0; i < features.length; i++) {
+    const feature = features[i]
+    const fstart = feature.get('start')
+    const fend = feature.get('end')
+    const fstrand = feature.get('strand') as -1 | 0 | 1
+
+    for (let j = fstart; j < fend + 1; j++) {
+      const i = j - region.start
+      if (i >= 0 && i < binMax) {
+        if (bins[i] === undefined) {
+          bins[i] = {
+            total: 0,
+            all: 0,
+            ref: 0,
+            '-1': 0,
+            '0': 0,
+            '1': 0,
+            lowqual: {} as BinType,
+            cov: {} as BinType,
+            delskips: {} as BinType,
+            noncov: {} as BinType,
+          }
+        }
+        if (j !== fend) {
+          bins[i].total++
+          bins[i].all++
+          bins[i].ref++
+          bins[i][fstrand]++
+        }
+      }
+    }
+
+    if (colorBy?.type === 'modifications') {
+      const seq = feature.get('seq') as string
+      const mm = (getTagAlt(feature, 'MM', 'Mm') as string) || ''
+      const ops = parseCigar(feature.get('CIGAR'))
+      const fend = feature.get('end')
+
+      getModificationPositions(mm, seq, fstrand).forEach(
+        ({ type, positions }) => {
+          const mod = `mod_${type}`
+          for (const pos of getNextRefPos(ops, positions)) {
+            const epos = pos + fstart - region.start
+            if (epos >= 0 && epos < bins.length && pos + fstart < fend) {
+              const bin = bins[epos]
+              if (bin) {
+                inc(bin, fstrand, 'cov', mod)
+              } else {
+                console.warn(
+                  'Undefined position in modifications snpcoverage encountered',
+                )
+              }
+            }
+          }
+        },
+      )
+    }
+
+    // methylation based coloring takes into account both reference
+    // sequence CpG detection and reads
+    else if (colorBy?.type === 'methylation') {
+      if (!regionSeq) {
+        throw new Error(
+          'no region sequence detected, need sequenceAdapter configuration',
+        )
+      }
+      const seq = feature.get('seq')
+      const mm = getTagAlt(feature, 'MM', 'Mm') || ''
+      const methBins = new Array(region.end - region.start).fill(0)
+      const ops = parseCigar(feature.get('CIGAR'))
+
+      getModificationPositions(mm, seq, fstrand).forEach(
+        ({ type, positions }) => {
+          // we are processing methylation
+          if (type === 'm') {
+            for (const pos of getNextRefPos(ops, positions)) {
+              const epos = pos + fstart - region.start
+              if (epos >= 0 && epos < methBins.length) {
+                methBins[epos] = 1
+              }
+            }
+          }
+        },
+      )
+
+      for (let j = fstart; j < fend; j++) {
+        const i = j - region.start
+        if (i >= 0 && i < bins.length - 1) {
+          const l1 = regionSeq[i].toLowerCase()
+          const l2 = regionSeq[i + 1].toLowerCase()
+          const bin = bins[i]
+          const bin1 = bins[i + 1]
+
+          // color
+          if (l1 === 'c' && l2 === 'g') {
+            if (methBins[i] || methBins[i + 1]) {
+              inc(bin, fstrand, 'cov', 'meth')
+              inc(bin1, fstrand, 'cov', 'meth')
+              bins[i].ref--
+              bins[i][fstrand]--
+              bins[i + 1].ref--
+              bins[i + 1][fstrand]--
+            } else {
+              inc(bin, fstrand, 'cov', 'unmeth')
+              inc(bin1, fstrand, 'cov', 'unmeth')
+              bins[i].ref--
+              bins[i][fstrand]--
+              bins[i + 1].ref--
+              bins[i + 1][fstrand]--
+            }
+          }
+        }
+      }
+    }
+
+    // normal SNP based coloring
+    const mismatches = (feature.get('mismatches') as Mismatch[]) || []
+    const colorSNPs =
+      colorBy?.type !== 'modifications' && colorBy?.type !== 'methylation'
+
+    for (let i = 0; i < mismatches.length; i++) {
+      const mismatch = mismatches[i]
+      const mstart = fstart + mismatch.start
+      const mlen = mismatchLen(mismatch)
+      const mend = mstart + mlen
+      for (let j = mstart; j < mstart + mlen; j++) {
+        const epos = j - region.start
+        if (epos >= 0 && epos < bins.length) {
+          const bin = bins[epos]
+          const { base, type } = mismatch
+          const interbase = isInterbase(type)
+          if (!interbase) {
+            bin.ref--
+            bin[fstrand]--
+          } else {
+            inc(bin, fstrand, 'noncov', type)
+          }
+
+          if (type === 'deletion' || type === 'skip') {
+            inc(bin, fstrand, 'delskips', type)
+            bin.total--
+          } else if (!interbase && colorSNPs) {
+            inc(bin, fstrand, 'cov', base)
+            bin.refbase = mismatch.altbase
+          }
+        }
+      }
+
+      if (mismatch.type === 'skip') {
+        const hash = `${mstart}_${mend}_${fstrand}`
+        if (skipmap[hash] === undefined) {
+          skipmap[hash] = {
+            feature: feature,
+            start: mstart,
+            end: mend,
+            strand: fstrand,
+            xs: getTag(feature, 'XS') || getTag(feature, 'TS'),
+            score: 0,
+          }
+        }
+        skipmap[hash].score++
+      }
+    }
+  }
+
+  return { bins, skipmap }
+}

package/src/SNPCoverageAdapter/index.ts

@@ -7,11 +7,9 @@ export default function (pluginManager: PluginManager) {
   pluginManager.addAdapterType(() => {
     return new AdapterType({
       name: 'SNPCoverageAdapter',
+      displayName: 'SNPCoverage adapter',
       adapterMetadata: {
-        category: null,
-        displayName: null,
         hiddenFromGUI: true,
-        description: null,
       },
       getAdapterClass: () =>
         import('./SNPCoverageAdapter').then(r => r.default),

package/src/index.ts

@@ -1,9 +1,5 @@
-import { FileLocation } from '@jbrowse/core/util/types'
 import Plugin from '@jbrowse/core/Plugin'
 import PluginManager from '@jbrowse/core/PluginManager'
-import * as MismatchParser from './BamAdapter/MismatchParser'
-import { LinearPileupDisplayModel } from './LinearPileupDisplay/model'
-
 import BamAdapterF from './CramAdapter'
 import CramAdapterF from './BamAdapter'
 import HtsgetBamAdapterF from './HtsgetBamAdapter'
@@ -12,24 +8,18 @@ import SNPCoverageRendererF from './SNPCoverageRenderer'
 import PileupRendererF from './PileupRenderer'
 import LinearAlignmentsDisplayF from './LinearAlignmentsDisplay'
 import LinearSNPCoverageDisplayF from './LinearSNPCoverageDisplay'
+import LinearReadArcsDisplayF from './LinearReadArcsDisplay'
+import LinearReadCloudDisplayF from './LinearReadCloudDisplay'
+import AlignmentsTrackF from './AlignmentsTrack'
+import AlignmentsFeatureWidgetF from './AlignmentsFeatureDetail'
+import PileupRPCMethodsF from './PileupRPC'
+import GuessAlignmentsTypesF from './GuessAlignmentsTypes'
 import LinearPileupDisplayF, {
   linearPileupDisplayStateModelFactory,
   linearPileupDisplayConfigSchemaFactory,
 } from './LinearPileupDisplay'
-import AlignmentsTrackF from './AlignmentsTrack'
-import AlignmentsFeatureWidgetF from './AlignmentsFeatureDetail'
-
-import {
-  PileupGetGlobalValueForTag,
-  PileupGetVisibleModifications,
-} from './PileupRPC/rpcMethods'
-import {
-  makeIndex,
-  makeIndexType,
-  getFileName,
-  AdapterGuesser,
-  TrackTypeGuesser,
-} from '@jbrowse/core/util/tracks'
+import { LinearPileupDisplayModel } from './LinearPileupDisplay/model'
+import * as MismatchParser from './MismatchParser'
 
 export default class AlignmentsPlugin extends Plugin {
   name = 'AlignmentsPlugin'
@@ -44,85 +34,14 @@ export default class AlignmentsPlugin extends Plugin {
       SNPCoverageAdapterF,
       HtsgetBamAdapterF,
       PileupRendererF,
+      PileupRPCMethodsF,
       SNPCoverageRendererF,
+      LinearReadArcsDisplayF,
+      LinearReadCloudDisplayF,
       LinearAlignmentsDisplayF,
       AlignmentsFeatureWidgetF,
+      GuessAlignmentsTypesF,
     ].map(f => f(pluginManager))
-
-    pluginManager.addToExtensionPoint(
-      'Core-guessAdapterForLocation',
-      (adapterGuesser: AdapterGuesser) => {
-        return (
-          file: FileLocation,
-          index?: FileLocation,
-          adapterHint?: string,
-        ) => {
-          const regexGuess = /\.cram$/i
-          const adapterName = 'CramAdapter'
-          const fileName = getFileName(file)
-          const obj = {
-            type: adapterName,
-            cramLocation: file,
-            craiLocation: index || makeIndex(file, '.crai'),
-          }
-          if (regexGuess.test(fileName) && !adapterHint) {
-            return obj
-          } else if (adapterHint === adapterName) {
-            return obj
-          }
-          return adapterGuesser(file, index, adapterHint)
-        }
-      },
-    )
-
-    pluginManager.addToExtensionPoint(
-      'Core-guessAdapterForLocation',
-      (adapterGuesser: AdapterGuesser) => {
-        return (
-          file: FileLocation,
-          index?: FileLocation,
-          adapterHint?: string,
-        ) => {
-          const regexGuess = /\.bam$/i
-          const adapterName = 'BamAdapter'
-          const fileName = getFileName(file)
-          const indexName = index && getFileName(index)
-
-          const obj = {
-            type: adapterName,
-            bamLocation: file,
-            index: {
-              location: index || makeIndex(file, '.bai'),
-              indexType: makeIndexType(indexName, 'CSI', 'BAI'),
-            },
-          }
-          if (regexGuess.test(fileName) && !adapterHint) {
-            return obj
-          } else if (adapterHint === adapterName) {
-            return obj
-          }
-          return adapterGuesser(file, index, adapterHint)
-        }
-      },
-    )
-    pluginManager.addToExtensionPoint(
-      'Core-guessTrackTypeForLocation',
-      (trackTypeGuesser: TrackTypeGuesser) => {
-        return (adapterName: string) => {
-          if (adapterName === 'BamAdapter' || adapterName === 'CramAdapter') {
-            return 'AlignmentsTrack'
-          }
-          return trackTypeGuesser(adapterName)
-        }
-      },
-    )
-
-    pluginManager.addRpcMethod(
-      () => new PileupGetGlobalValueForTag(pluginManager),
-    )
-    pluginManager.addRpcMethod(
-      () => new PileupGetVisibleModifications(pluginManager),
-    )
   }
 }