@jbrowse/plugin-alignments 1.5.0 → 1.5.4

package/src/PileupRenderer/configSchema.ts

@@ -4,13 +4,13 @@ import { types } from 'mobx-state-tree'
 export default ConfigurationSchema(
   'PileupRenderer',
   {
+    // default magenta here is used to detect the user has not customized this
     color: {
       type: 'color',
       description: 'the color of each feature in a pileup alignment',
-      defaultValue: `#c8c8c8`,
+      defaultValue: '#f0f',
       contextVariable: ['feature'],
     },
-
     orientationType: {
       type: 'stringEnum',
       model: types.enumeration('orientationType', ['fr', 'rf', 'ff']),

package/src/PileupRenderer/index.ts

@@ -1,3 +1,16 @@
-export { default as ReactComponent } from './components/PileupRendering'
-export { default as configSchema } from './configSchema'
-export { default } from './PileupRenderer'
+import PluginManager from '@jbrowse/core/PluginManager'
+import PileupRenderer from './PileupRenderer'
+import ReactComponent from './components/PileupRendering'
+import configSchema from './configSchema'
+
+export default function register(pluginManager: PluginManager) {
+  pluginManager.addRendererType(
+    () =>
+      new PileupRenderer({
+        name: 'PileupRenderer',
+        ReactComponent,
+        configSchema,
+        pluginManager,
+      }),
+  )
+}

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,6 +74,7 @@ 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
@@ -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,
+      }),
+  )
+}