@jbrowse/plugin-alignments 1.4.1 → 1.5.2

package/src/SNPCoverageAdapter/SNPCoverageAdapter.ts

@@ -2,7 +2,7 @@ import {
   BaseFeatureDataAdapter,
   BaseOptions,
 } from '@jbrowse/core/data_adapters/BaseAdapter'
-import { Region } from '@jbrowse/core/util/types'
+import { AugmentedRegion as Region } from '@jbrowse/core/util/types'
 import SimpleFeature, { Feature } from '@jbrowse/core/util/simpleFeature'
 import { readConfObject } from '@jbrowse/core/configuration'
 import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain'
@@ -81,7 +81,11 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
         stream = stream.pipe(filter(f => filters.passes(f, opts)))
       }
 
-      const bins = await this.generateCoverageBins(stream, region, opts)
+      const { bins, skipmap } = await this.generateCoverageBins(
+        stream,
+        region,
+        opts,
+      )
 
       bins.forEach((bin, index) => {
         if (bin.total) {
@@ -100,6 +104,23 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
         }
       })
 
+      // make fake features from the coverage
+      Object.entries(skipmap).forEach(([key, skip]) => {
+        observer.next(
+          new SimpleFeature({
+            id: key,
+            data: {
+              type: 'skip',
+              start: skip.start,
+              end: skip.end,
+              strand: skip.strand,
+              score: skip.score,
+              xs: skip.xs,
+            },
+          }),
+        )
+      })
+
       observer.complete()
     }, opts.signal)
   }
@@ -126,9 +147,20 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
   ) {
     const { colorBy } = opts
     const { sequenceAdapter } = await this.configure()
-    const { refName, start, end } = region
+    const { originalRefName, refName, start, end } = region
     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, or noncov which
     // are interbase or other features that don't contribute to coverage.
     // delskips are elements that don't contribute to coverage, but should be
@@ -148,13 +180,18 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
 
     if (sequenceAdapter) {
       const [feat] = await sequenceAdapter
-        .getFeatures({ refName, start, end: end + 1, assemblyName: 'na' })
+        .getFeatures({
+          refName: originalRefName || refName,
+          start,
+          end: end + 1,
+          assemblyName: 'na',
+        })
         .pipe(toArray())
         .toPromise()
       regionSeq = feat?.get('seq')
     }
 
-    return features
+    const bins = await features
       .pipe(
         reduce((bins, feature) => {
           const cigar = feature.get('CIGAR')
@@ -262,30 +299,61 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
 
           // normal SNP based coloring
           else {
-            const mismatches = feature.get('mismatches')
-            for (let i = 0; i < mismatches?.length; i++) {
-              const mismatch = mismatches[i] as Mismatch
-              const mstart = fstart + mismatch.start
-              for (let j = mstart; j < mstart + mismatchLen(mismatch); 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) {
-                    dec(bin, fstrand, 'ref', 'ref')
-                  } else {
-                    inc(bin, fstrand, 'noncov', type)
-                  }
+            const mismatches = feature.get('mismatches') as
+              | Mismatch[]
+              | undefined
+
+            if (mismatches) {
+              for (let i = 0; i < mismatches.length; i++) {
+                const mismatch = mismatches[i]
+                const mstart = fstart + mismatch.start
+                for (let j = mstart; j < mstart + mismatchLen(mismatch); 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) {
+                      dec(bin, fstrand, 'ref', 'ref')
+                    } else {
+                      inc(bin, fstrand, 'noncov', type)
+                    }
 
-                  if (type === 'deletion' || type === 'skip') {
-                    inc(bin, fstrand, 'delskips', type)
-                    bin.total--
-                  } else if (!interbase) {
-                    inc(bin, fstrand, 'cov', base)
+                    if (type === 'deletion' || type === 'skip') {
+                      inc(bin, fstrand, 'delskips', type)
+                      bin.total--
+                    } else if (!interbase) {
+                      inc(bin, fstrand, 'cov', base)
+                    }
                   }
                 }
               }
+
+              mismatches
+                .filter(mismatch => mismatch.type === 'skip')
+                .forEach(mismatch => {
+                  const mstart = feature.get('start') + mismatch.start
+                  const start = mstart
+                  const end = mstart + mismatch.length
+                  const strand = feature.get('strand')
+                  const hash = `${start}_${end}_${strand}`
+                  if (!skipmap[hash]) {
+                    skipmap[hash] = {
+                      feature: feature,
+                      start,
+                      end,
+                      strand,
+                      xs:
+                        feature.get('xs') ||
+                        feature.get('ts') ||
+                        feature.get('tags').XS ||
+                        feature.get('tags').TS,
+                      score: 1,
+                    }
+                  } else {
+                    skipmap[hash].score++
+                  }
+                })
             }
           }
 
@@ -293,6 +361,8 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
         }, initBins),
       )
       .toPromise()
+
+    return { bins, skipmap }
   }
 }
 

package/src/SNPCoverageAdapter/index.ts

@@ -1,11 +1,23 @@
 import PluginManager from '@jbrowse/core/PluginManager'
+import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
 import configSchemaFactory from './configSchema'
 import { capabilities } from './SNPCoverageAdapter'
 
 export default (pluginManager: PluginManager) => {
-  return {
-    getAdapterClass: () => import('./SNPCoverageAdapter').then(r => r.default),
-    configSchema: configSchemaFactory(pluginManager),
-    adapterCapabilities: capabilities,
-  }
+  pluginManager.addAdapterType(
+    () =>
+      new AdapterType({
+        name: 'SNPCoverageAdapter',
+        adapterMetadata: {
+          category: null,
+          displayName: null,
+          hiddenFromGUI: true,
+          description: null,
+        },
+        getAdapterClass: () =>
+          import('./SNPCoverageAdapter').then(r => r.default),
+        configSchema: configSchemaFactory(pluginManager),
+        adapterCapabilities: capabilities,
+      }),
+  )
 }

package/src/SNPCoverageRenderer/SNPCoverageRenderer.ts

@@ -2,6 +2,7 @@ import { createJBrowseTheme } from '@jbrowse/core/ui'
 import { featureSpanPx } from '@jbrowse/core/util'
 import { Feature } from '@jbrowse/core/util/simpleFeature'
 import { readConfObject } from '@jbrowse/core/configuration'
+import { bpSpanPx } from '@jbrowse/core/util'
 import { RenderArgsDeserialized as FeatureRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType'
 import {
   getOrigin,
@@ -26,6 +27,16 @@ export interface RenderArgsDeserializedWithFeatures
   modificationTagMap: Record<string, string>
 }
 
+type Counts = {
+  [key: string]: { total: number; strands: { [key: string]: number } }
+}
+
+interface SNPInfo {
+  cov: Counts
+  noncov: Counts
+  total: number
+}
+
 export default class SNPCoverageRenderer extends WiggleBaseRenderer {
   // note: the snps are drawn on linear scale even if the data is drawn in log
   // scape hence the two different scales being used
@@ -37,13 +48,13 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
       features,
       regions,
       bpPerPx,
+      displayCrossHatches,
+      modificationTagMap,
       scaleOpts,
       height: unadjustedHeight,
       theme: configTheme,
       config: cfg,
-      displayCrossHatches,
       ticks: { values },
-      modificationTagMap,
     } = props
     const theme = createJBrowseTheme(configTheme)
     const [region] = regions
@@ -63,14 +74,15 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
 
     const indicatorThreshold = readConfObject(cfg, 'indicatorThreshold')
     const drawInterbaseCounts = readConfObject(cfg, 'drawInterbaseCounts')
+    const drawArcs = readConfObject(cfg, 'drawArcs')
     const drawIndicators = readConfObject(cfg, 'drawIndicators')
 
     // get the y coordinate that we are plotting at, this can be log scale
-    const toY = (n: number) => height - viewScale(n) + offset
+    const toY = (n: number) => height - (viewScale(n) || 0) + offset
     const toHeight = (n: number) => toY(originY) - toY(n)
 
     // this is always linear scale, even when plotted on top of log scale
-    const snpToY = (n: number) => height - snpViewScale(n) + offset
+    const snpToY = (n: number) => height - (snpViewScale(n) || 0) + offset
     const snpToHeight = (n: number) => snpToY(snpOriginY) - snpToY(n)
 
     const colorForBase: { [key: string]: string } = {
@@ -87,15 +99,19 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
       ref: 'lightgrey',
     }
 
+    const feats = [...features.values()]
+    const coverage = feats.filter(f => f.get('type') !== 'skip')
+    const skips = feats.filter(f => f.get('type') === 'skip')
+
     // Use two pass rendering, which helps in visualizing the SNPs at higher
     // bpPerPx First pass: draw the gray background
     ctx.fillStyle = colorForBase.total
-    for (const feature of features.values()) {
+    coverage.forEach(feature => {
       const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx)
       const w = rightPx - leftPx + 0.3
       const score = feature.get('score') as number
       ctx.fillRect(leftPx, toY(score), w, toHeight(score))
-    }
+    })
     ctx.fillStyle = 'grey'
     ctx.beginPath()
     ctx.lineTo(0, 0)
@@ -105,16 +121,10 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
     // Second pass: draw the SNP data, and add a minimum feature width of 1px
     // which can be wider than the actual bpPerPx This reduces overdrawing of
     // the grey background over the SNPs
-    for (const feature of features.values()) {
+    coverage.forEach(feature => {
       const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx)
-      type Counts = {
-        [key: string]: { total: number; strands: { [key: string]: number } }
-      }
-      const snpinfo = feature.get('snpinfo') as {
-        cov: Counts
-        noncov: Counts
-        total: number
-      }
+
+      const snpinfo = feature.get('snpinfo') as SNPInfo
       const w = Math.max(rightPx - leftPx + 0.3, 1)
       const totalScore = snpinfo.total
 
@@ -175,6 +185,43 @@ export default class SNPCoverageRenderer extends WiggleBaseRenderer {
           ctx.fill()
         }
       }
+    })
+
+    ctx.globalAlpha = 0.7
+
+    if (drawArcs) {
+      skips.forEach(f => {
+        const [left, right] = bpSpanPx(
+          f.get('start'),
+          f.get('end'),
+          region,
+          bpPerPx,
+        )
+
+        ctx.beginPath()
+        const str = f.get('strand') as number
+        const xs = f.get('xs') as string
+        const pos = 'rgb(255,200,200)'
+        const neg = 'rgb(200,200,255)'
+        const neutral = 'rgb(200,200,200)'
+
+        if (xs === '+') {
+          ctx.strokeStyle = pos
+        } else if (xs === '-') {
+          ctx.strokeStyle = neg
+        } else if (str === 1) {
+          ctx.strokeStyle = pos
+        } else if (str === -1) {
+          ctx.strokeStyle = neg
+        } else {
+          ctx.strokeStyle = neutral
+        }
+
+        ctx.lineWidth = Math.log(f.get('score') + 1)
+        ctx.moveTo(left, height - offset * 2)
+        ctx.bezierCurveTo(left, 0, right, 0, right, height - offset * 2)
+        ctx.stroke()
+      })
     }
 
     if (displayCrossHatches) {

package/src/SNPCoverageRenderer/configSchema.js

@@ -14,6 +14,11 @@ export default ConfigurationSchema(
         'the proportion of reads containing a insertion/clip indicator',
       defaultValue: 0.3,
     },
+    drawArcs: {
+      type: 'boolean',
+      description: 'Draw sashimi-style arcs for intron features',
+      defaultValue: true,
+    },
     drawInterbaseCounts: {
       type: 'boolean',
       description:

package/src/SNPCoverageRenderer/index.ts

@@ -0,0 +1,24 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+import ConfigSchema from './configSchema'
+import PluginManager from '@jbrowse/core/PluginManager'
+import SNPCoverageRenderer from './SNPCoverageRenderer'
+
+import { WiggleRendering } from '@jbrowse/plugin-wiggle'
+
+export const configSchema = ConfigurationSchema(
+  'SNPCoverageRenderer',
+  {},
+  { baseConfiguration: ConfigSchema, explicitlyTyped: true },
+)
+
+export default function register(pluginManager: PluginManager) {
+  pluginManager.addRendererType(
+    () =>
+      new SNPCoverageRenderer({
+        name: 'SNPCoverageRenderer',
+        ReactComponent: WiggleRendering,
+        configSchema,
+        pluginManager,
+      }),
+  )
+}

package/src/index.ts

@@ -1,52 +1,32 @@
-import { lazy } from 'react'
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
-import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType'
-import {
-  createBaseTrackConfig,
-  createBaseTrackModel,
-} from '@jbrowse/core/pluggableElementTypes/models'
-import TrackType from '@jbrowse/core/pluggableElementTypes/TrackType'
-import WidgetType from '@jbrowse/core/pluggableElementTypes/WidgetType'
+import { FileLocation } from '@jbrowse/core/util/types'
 import Plugin from '@jbrowse/core/Plugin'
 import PluginManager from '@jbrowse/core/PluginManager'
-import { BaseLinearDisplayComponent } from '@jbrowse/plugin-linear-genome-view'
-import { LinearWiggleDisplayReactComponent } from '@jbrowse/plugin-wiggle'
-import {
-  configSchema as alignmentsFeatureDetailConfigSchema,
-  stateModelFactory as alignmentsFeatureDetailStateModelFactory,
-} from './AlignmentsFeatureDetail'
-import BamAdapterF from './BamAdapter'
 import * as MismatchParser from './BamAdapter/MismatchParser'
-import CramAdapterF from './CramAdapter'
-import HtsgetBamAdapterF from './HtsgetBamAdapter'
-import {
-  configSchemaFactory as linearAligmentsDisplayConfigSchemaFactory,
-  modelFactory as linearAlignmentsDisplayModelFactory,
-  ReactComponent as LinearAlignmentsDisplayReactComponent,
-} from './LinearAlignmentsDisplay'
-import {
-  configSchemaFactory as linearPileupDisplayConfigSchemaFactory,
-  modelFactory as linearPileupDisplayModelFactory,
-} from './LinearPileupDisplay'
 import { LinearPileupDisplayModel } from './LinearPileupDisplay/model'
-import {
-  configSchemaFactory as linearSNPCoverageDisplayConfigSchemaFactory,
-  modelFactory as linearSNPCoverageDisplayModelFactory,
-} from './LinearSNPCoverageDisplay'
-import PileupRenderer, {
-  configSchema as pileupRendererConfigSchema,
-  ReactComponent as PileupRendererReactComponent,
-} from './PileupRenderer'
+
+import BamAdapterF from './CramAdapter'
+import CramAdapterF from './BamAdapter'
+import HtsgetBamAdapterF from './HtsgetBamAdapter'
 import SNPCoverageAdapterF from './SNPCoverageAdapter'
-import SNPCoverageRenderer, {
-  configSchema as SNPCoverageRendererConfigSchema,
-  ReactComponent as SNPCoverageRendererReactComponent,
-} from './SNPCoverageRenderer'
+import SNPCoverageRendererF from './SNPCoverageRenderer'
+import PileupRendererF from './PileupRenderer'
+import LinearAlignmentsDisplayF from './LinearAlignmentsDisplay'
+import LinearSNPCoverageDisplayF from './LinearSNPCoverageDisplay'
+import LinearPileupDisplayF 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'
 
 export { MismatchParser }
 export type { LinearPileupDisplayModel }
@@ -55,133 +35,79 @@ export default class AlignmentsPlugin extends Plugin {
   name = 'AlignmentsPlugin'
 
   install(pluginManager: PluginManager) {
-    pluginManager.addTrackType(() => {
-      const configSchema = ConfigurationSchema(
-        'AlignmentsTrack',
-        {},
-        { baseConfiguration: createBaseTrackConfig(pluginManager) },
-      )
-      const track = new TrackType({
-        name: 'AlignmentsTrack',
-        configSchema,
-        stateModel: createBaseTrackModel(
-          pluginManager,
-          'AlignmentsTrack',
-          configSchema,
-        ),
-      })
-      const linearAlignmentsDisplay = pluginManager.getDisplayType(
-        'LinearAlignmentsDisplay',
-      )
-      // Add LinearAlignmentsDisplay here so that it has priority over the other
-      // linear displays (defaults to order the displays are added, but we have
-      // to add the Pileup and SNPCoverage displays first).
-      track.addDisplayType(linearAlignmentsDisplay)
-      return track
-    })
-    pluginManager.addDisplayType(() => {
-      const configSchema = linearPileupDisplayConfigSchemaFactory(pluginManager)
-      return new DisplayType({
-        name: 'LinearPileupDisplay',
-        configSchema,
-        stateModel: linearPileupDisplayModelFactory(
-          pluginManager,
-          configSchema,
-        ),
-        trackType: 'AlignmentsTrack',
-        viewType: 'LinearGenomeView',
-        ReactComponent: BaseLinearDisplayComponent,
-      })
-    })
-    pluginManager.addDisplayType(() => {
-      const configSchema = linearSNPCoverageDisplayConfigSchemaFactory(
-        pluginManager,
-      )
-      return new DisplayType({
-        name: 'LinearSNPCoverageDisplay',
-        configSchema,
-        stateModel: linearSNPCoverageDisplayModelFactory(
-          pluginManager,
-          configSchema,
-        ),
-        trackType: 'AlignmentsTrack',
-        viewType: 'LinearGenomeView',
-        ReactComponent: LinearWiggleDisplayReactComponent,
-      })
-    })
-    pluginManager.addDisplayType(() => {
-      const configSchema = linearAligmentsDisplayConfigSchemaFactory(
-        pluginManager,
-      )
-      return new DisplayType({
-        name: 'LinearAlignmentsDisplay',
-        configSchema,
-        stateModel: linearAlignmentsDisplayModelFactory(
-          pluginManager,
-          configSchema,
-        ),
-        trackType: 'AlignmentsTrack',
-        viewType: 'LinearGenomeView',
-        ReactComponent: LinearAlignmentsDisplayReactComponent,
-      })
-    })
-    pluginManager.addWidgetType(
-      () =>
-        new WidgetType({
-          name: 'AlignmentsFeatureWidget',
-          heading: 'Feature details',
-          configSchema: alignmentsFeatureDetailConfigSchema,
-          stateModel: alignmentsFeatureDetailStateModelFactory(pluginManager),
-          ReactComponent: lazy(
-            () => import('./AlignmentsFeatureDetail/AlignmentsFeatureDetail'),
-          ),
-        }),
-    )
-    pluginManager.addAdapterType(
-      () =>
-        new AdapterType({
-          name: 'BamAdapter',
-          ...pluginManager.load(BamAdapterF),
-        }),
-    )
-    pluginManager.addAdapterType(
-      () =>
-        new AdapterType({
-          name: 'SNPCoverageAdapter',
-          ...pluginManager.load(SNPCoverageAdapterF),
-        }),
-    )
-    pluginManager.addAdapterType(
-      () =>
-        new AdapterType({
-          name: 'CramAdapter',
-          ...pluginManager.load(CramAdapterF),
-        }),
-    )
-    pluginManager.addAdapterType(
-      () =>
-        new AdapterType({
-          name: 'HtsgetBamAdapter',
-          ...pluginManager.load(HtsgetBamAdapterF),
-        }),
+    ;[
+      CramAdapterF,
+      BamAdapterF,
+      LinearPileupDisplayF,
+      LinearSNPCoverageDisplayF,
+      AlignmentsTrackF,
+      SNPCoverageAdapterF,
+      HtsgetBamAdapterF,
+      PileupRendererF,
+      SNPCoverageRendererF,
+      LinearAlignmentsDisplayF,
+      AlignmentsFeatureWidgetF,
+    ].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)
+          if (regexGuess.test(fileName) || adapterHint === adapterName) {
+            return {
+              type: adapterName,
+              cramLocation: file,
+              craiLocation: index || makeIndex(file, '.crai'),
+            }
+          }
+          return adapterGuesser(file, index, adapterHint)
+        }
+      },
     )
-    pluginManager.addRendererType(
-      () =>
-        new PileupRenderer({
-          name: 'PileupRenderer',
-          ReactComponent: PileupRendererReactComponent,
-          configSchema: pileupRendererConfigSchema,
-          pluginManager,
-        }),
+
+    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)
+          if (regexGuess.test(fileName) || adapterHint === adapterName) {
+            return {
+              type: adapterName,
+              bamLocation: file,
+              index: {
+                location: index || makeIndex(file, '.bai'),
+                indexType: makeIndexType(indexName, 'CSI', 'BAI'),
+              },
+            }
+          }
+          return adapterGuesser(file, index, adapterHint)
+        }
+      },
     )
-    pluginManager.addRendererType(
-      () =>
-        new SNPCoverageRenderer({
-          name: 'SNPCoverageRenderer',
-          ReactComponent: SNPCoverageRendererReactComponent,
-          configSchema: SNPCoverageRendererConfigSchema,
-          pluginManager,
-        }),
+    pluginManager.addToExtensionPoint(
+      'Core-guessTrackTypeForLocation',
+      (trackTypeGuesser: TrackTypeGuesser) => {
+        return (adapterName: string) => {
+          if (adapterName === 'BamAdapter' || adapterName === 'CramAdapter') {
+            return 'AlignmentsTrack'
+          }
+          return trackTypeGuesser(adapterName)
+        }
+      },
     )
 
     pluginManager.addRpcMethod(