@jbrowse/plugin-alignments 2.1.7 → 2.2.1

package/src/CramAdapter/util.ts

@@ -0,0 +1,251 @@
+import { CramRecord } from '@gmod/cram'
+
+type ReadFeatures = CramRecord['readFeatures']
+
+export interface Mismatch {
+  qual?: number
+  start: number
+  length: number
+  type: string
+  base: string | undefined
+  altbase?: string
+  seq?: string
+  cliplen?: number
+}
+
+export function readFeaturesToMismatches(
+  readFeatures: ReadFeatures,
+  start: number,
+  qual?: number[] | null,
+) {
+  if (!readFeatures) {
+    return []
+  }
+  const mismatches: Mismatch[] = new Array(readFeatures.length)
+  let j = 0
+  let insLen = 0
+  let refPos = 0
+  let sublen = 0
+  let lastPos = start
+
+  for (let i = 0; i < readFeatures.length; i++) {
+    const f = readFeatures[i]
+    const { code, pos, data, sub, ref } = f
+    sublen = refPos - lastPos
+    lastPos = refPos
+
+    if (sublen && insLen > 0) {
+      mismatches[j++] = {
+        start: refPos,
+        type: 'insertion',
+        base: `${insLen}`,
+        length: 0,
+      }
+      insLen = 0
+    }
+    refPos = f.refPos - 1 - start
+
+    if (code === 'X') {
+      // substitution
+      mismatches[j++] = {
+        start: refPos,
+        length: 1,
+        base: sub,
+        qual: qual?.[pos - 1],
+        altbase: ref?.toUpperCase(),
+        type: 'mismatch',
+      }
+    } else if (code === 'I') {
+      // insertion
+      mismatches[j++] = {
+        start: refPos,
+        type: 'insertion',
+        base: `${data.length}`,
+        length: 0,
+      }
+    } else if (code === 'N') {
+      // reference skip
+      mismatches[j++] = {
+        type: 'skip',
+        length: data,
+        start: refPos,
+        base: 'N',
+      }
+    } else if (code === 'S') {
+      // soft clip
+      const len = data.length
+      mismatches[j++] = {
+        start: refPos,
+        type: 'softclip',
+        base: `S${len}`,
+        cliplen: len,
+        length: 1,
+      }
+    } else if (code === 'P') {
+      // padding
+    } else if (code === 'H') {
+      // hard clip
+      const len = data
+      mismatches[j++] = {
+        start: refPos,
+        type: 'hardclip',
+        base: `H${len}`,
+        cliplen: len,
+        length: 1,
+      }
+    } else if (code === 'D') {
+      // deletion
+      mismatches[j++] = {
+        type: 'deletion',
+        length: data,
+        start: refPos,
+        base: '*',
+      }
+    } else if (code === 'b') {
+      // stretch of bases
+    } else if (code === 'q') {
+      // stretch of qual scores
+    } else if (code === 'B') {
+      // a pair of [base, qual]
+    } else if (code === 'i') {
+      // single-base insertion, we collect these if there are multiple in a row
+      // into a single insertion entry
+      insLen++
+    } else if (code === 'Q') {
+      // single quality value
+    }
+  }
+
+  if (sublen && insLen > 0) {
+    mismatches[j++] = {
+      start: refPos,
+      type: 'insertion',
+      base: `${insLen}`,
+      length: 0,
+    }
+    insLen = 0
+  }
+
+  return mismatches.slice(0, j)
+}
+
+export function readFeaturesToCIGAR(
+  readFeatures: ReadFeatures,
+  alignmentStart: number,
+  readLen: number,
+  refRegion?: { seq: string; start: number },
+) {
+  let seq = ''
+  let cigar = ''
+  let op = 'M'
+  let oplen = 0
+  if (!refRegion) {
+    return ''
+  }
+
+  // not sure I should access these, but...
+  const ref = refRegion.seq
+  const refStart = refRegion.start
+  let lastPos = alignmentStart
+  let sublen = 0
+  let insLen = 0
+  if (readFeatures !== undefined) {
+    for (let i = 0; i < readFeatures.length; i++) {
+      const { code, refPos, sub, data } = readFeatures[i]
+      sublen = refPos - lastPos
+      seq += ref.substring(lastPos - refStart, refPos - refStart)
+      lastPos = refPos
+
+      if (insLen > 0 && sublen) {
+        cigar += `${insLen}I`
+        insLen = 0
+      }
+      if (oplen && op !== 'M') {
+        cigar += oplen + op
+        oplen = 0
+      }
+      if (sublen) {
+        op = 'M'
+        oplen += sublen
+      }
+
+      if (code === 'b') {
+        // An array of bases stored verbatim
+        const ret = data.split(',')
+        const added = String.fromCharCode(...ret)
+        seq += added
+        lastPos += added.length
+        oplen += added.length
+      } else if (code === 'B') {
+        // Single base (+ qual score)
+        seq += sub
+        lastPos++
+        oplen++
+      } else if (code === 'X') {
+        // Substitution
+        seq += sub
+        lastPos++
+        oplen++
+      } else if (code === 'D' || code === 'N') {
+        // Deletion or Ref Skip
+        lastPos += data
+        if (oplen) {
+          cigar += oplen + op
+        }
+        cigar += data + code
+        oplen = 0
+      } else if (code === 'I' || code === 'S') {
+        // Insertion or soft-clip
+        seq += data
+        if (oplen) {
+          cigar += oplen + op
+        }
+        cigar += data.length + code
+        oplen = 0
+      } else if (code === 'i') {
+        // Single base insertion
+        // seq += data
+        if (oplen) {
+          cigar += oplen + op
+        }
+        insLen++
+        seq += data
+        oplen = 0
+      } else if (code === 'P') {
+        // Padding
+        if (oplen) {
+          cigar += oplen + op
+        }
+        cigar += `${data}P`
+      } else if (code === 'H') {
+        // Hard clip
+        if (oplen) {
+          cigar += oplen + op
+        }
+        cigar += `${data}H`
+        oplen = 0
+      } // else q or Q
+    }
+  } else {
+    sublen = readLen - seq.length
+  }
+  if (seq.length !== readLen) {
+    sublen = readLen - seq.length
+    seq += ref.substring(lastPos - refStart, lastPos - refStart + sublen)
+
+    if (oplen && op !== 'M') {
+      cigar += oplen + op
+      oplen = 0
+    }
+    op = 'M'
+    oplen += sublen
+  }
+  if (sublen && insLen > 0) {
+    cigar += `${insLen}I`
+  }
+  if (oplen) {
+    cigar += oplen + op
+  }
+
+  return cigar
+}

package/src/HtsgetBamAdapter/HtsgetBamAdapter.ts

@@ -1,31 +1,24 @@
 import { BamFile, HtsgetFile } from '@gmod/bam'
-import { readConfObject } from '@jbrowse/core/configuration'
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter'
 import BamAdapter from '../BamAdapter/BamAdapter'
 
 export default class HtsgetBamAdapter extends BamAdapter {
-  protected async configure() {
-    if (!this.configured) {
-      const htsgetBase = readConfObject(this.config, 'htsgetBase')
-      const htsgetTrackId = readConfObject(this.config, 'htsgetTrackId')
-      const bam = new HtsgetFile({
-        baseUrl: htsgetBase,
-        trackId: htsgetTrackId,
-      }) as unknown as BamFile
+  protected async configurePre() {
+    const htsgetBase = this.getConf('htsgetBase')
+    const htsgetTrackId = this.getConf('htsgetTrackId')
+    const bam = new HtsgetFile({
+      baseUrl: htsgetBase,
+      trackId: htsgetTrackId,
+    }) as unknown as BamFile
 
-      const adapterConfig = readConfObject(this.config, 'sequenceAdapter')
-      if (adapterConfig && this.getSubAdapter) {
-        this.configured = this.getSubAdapter(adapterConfig).then(
-          ({ dataAdapter }) => {
-            return {
-              bam,
-              sequenceAdapter: dataAdapter as BaseFeatureDataAdapter,
-            }
-          },
-        )
+    const adapterConfig = this.getConf('sequenceAdapter')
+    if (adapterConfig && this.getSubAdapter) {
+      const adapter = await this.getSubAdapter(adapterConfig)
+      return {
+        bam,
+        sequenceAdapter: adapter.dataAdapter as BaseFeatureDataAdapter,
       }
-      this.configured = Promise.resolve({ bam })
     }
-    return this.configured
+    return { bam }
   }
 }

package/src/HtsgetBamAdapter/configSchema.ts

@@ -1,23 +1,40 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
-import { types } from 'mobx-state-tree'
+/**
+ * #config HtsgetBamAdapter
+ * Used to fetch data from Htsget endpoints in BAM format, using the gmod/bam library
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
 
-export default types.late(() =>
-  ConfigurationSchema(
-    'HtsgetBamAdapter',
-    {
-      htsgetBase: {
-        type: 'string',
-        defaultValue: '',
-      },
-      htsgetTrackId: {
-        type: 'string',
-        defaultValue: '',
-      },
-      sequenceAdapter: {
-        type: 'frozen',
-        defaultValue: null,
-      },
+const HtsgetBamAdapter = ConfigurationSchema(
+  'HtsgetBamAdapter',
+  {
+    /**
+     * #slot
+     */
+    htsgetBase: {
+      type: 'string',
+      description: 'the base URL to fetch from',
+      defaultValue: '',
     },
-    { explicitlyTyped: true },
-  ),
+    /**
+     * #slot
+     */
+    htsgetTrackId: {
+      type: 'string',
+      description: 'the trackId, which is appended to the base URL',
+      defaultValue: '',
+    },
+    /**
+     * #slot
+     */
+    sequenceAdapter: {
+      type: 'frozen',
+      description:
+        'sequence data adapter, used to calculate SNPs when BAM reads lacking MD tags',
+      defaultValue: null,
+    },
+  },
+  { explicitlyTyped: true },
 )
+
+export default HtsgetBamAdapter

package/src/LinearAlignmentsDisplay/components/AlignmentsDisplay.tsx

@@ -1,8 +1,10 @@
 import React from 'react'
 import { observer } from 'mobx-react'
+import { makeStyles } from 'tss-react/mui'
 import { getConf } from '@jbrowse/core/configuration'
 import { ResizeHandle } from '@jbrowse/core/ui'
-import { makeStyles } from 'tss-react/mui'
+
+// locals
 import { AlignmentsDisplayModel } from '../models/model'
 
 const useStyles = makeStyles()(() => ({

package/src/LinearAlignmentsDisplay/models/configSchema.ts

@@ -2,21 +2,34 @@ import { ConfigurationSchema } from '@jbrowse/core/configuration'
 import { baseLinearDisplayConfigSchema } from '@jbrowse/plugin-linear-genome-view'
 import PluginManager from '@jbrowse/core/PluginManager'
 
-const configModelFactory = (pluginManager: PluginManager) => {
-  const PileupDisplayConfigSchema = pluginManager.getDisplayType(
-    'LinearPileupDisplay',
-  ).configSchema
-  const SNPCoverageDisplayConfigSchema = pluginManager.getDisplayType(
-    'LinearSNPCoverageDisplay',
-  ).configSchema
+/**
+ * #config LinearAlignmentsDisplay
+ * has a "pileup" sub-display, where you can see individual reads and a
+ * quantitative "snpcoverage" sub-display track showing SNP frequencies
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
 
+const configModelFactory = (pm: PluginManager) => {
   return ConfigurationSchema(
     'LinearAlignmentsDisplay',
     {
-      pileupDisplay: PileupDisplayConfigSchema,
-      snpCoverageDisplay: SNPCoverageDisplayConfigSchema,
+      /**
+       * #slot
+       */
+      pileupDisplay: pm.getDisplayType('LinearPileupDisplay').configSchema,
+      /**
+       * #slot
+       */
+      snpCoverageDisplay: pm.getDisplayType('LinearSNPCoverageDisplay')
+        .configSchema,
+    },
+    {
+      /**
+       * #baseConfiguration
+       */
+      baseConfiguration: baseLinearDisplayConfigSchema,
+      explicitlyTyped: true,
     },
-    { baseConfiguration: baseLinearDisplayConfigSchema, explicitlyTyped: true },
   )
 }
 

package/src/LinearAlignmentsDisplay/models/model.tsx

@@ -2,6 +2,7 @@ import React from 'react'
 import {
   ConfigurationReference,
   AnyConfigurationModel,
+  AnyConfigurationSchemaType,
   getConf,
 } from '@jbrowse/core/configuration'
 import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes/models'
@@ -11,30 +12,63 @@ import { autorun, when } from 'mobx'
 import { addDisposer, getSnapshot, Instance, types } from 'mobx-state-tree'
 import { getContainingTrack } from '@jbrowse/core/util'
 import deepEqual from 'fast-deep-equal'
-import { AlignmentsConfigModel } from './configSchema'
 
 const minDisplayHeight = 20
-const stateModelFactory = (
+
+/**
+ * #stateModel LinearAlignmentsDisplay
+ * extends `BaseDisplay`
+ */
+function stateModelFactory(
   pluginManager: PluginManager,
-  configSchema: AlignmentsConfigModel,
-) => {
+  configSchema: AnyConfigurationSchemaType,
+) {
   return types
     .compose(
       'LinearAlignmentsDisplay',
       BaseDisplay,
       types.model({
+        /**
+         * #property
+         * refers to LinearPileupDisplay sub-display model
+         */
         PileupDisplay: types.maybe(
           pluginManager.getDisplayType('LinearPileupDisplay').stateModel,
         ),
+        /**
+         * #property
+         * refers to LinearSNPCoverageDisplay sub-display model
+         */
         SNPCoverageDisplay: types.maybe(
           pluginManager.getDisplayType('LinearSNPCoverageDisplay').stateModel,
         ),
+        /**
+         * #property
+         */
         snpCovHeight: 45,
+        /**
+         * #property
+         */
         type: types.literal('LinearAlignmentsDisplay'),
+        /**
+         * #property
+         */
         configuration: ConfigurationReference(configSchema),
+        /**
+         * #property
+         */
         height: 250,
+        /**
+         * #property
+         */
         showCoverage: true,
+        /**
+         * #property
+         */
         showPileup: true,
+        /**
+         * #property
+         */
         userFeatureScreenDensity: types.maybe(types.number),
       }),
     )
@@ -42,15 +76,28 @@ const stateModelFactory = (
       scrollTop: 0,
     }))
     .actions(self => ({
+      /**
+       * #action
+       */
       toggleCoverage() {
         self.showCoverage = !self.showCoverage
       },
+      /**
+       * #action
+       */
       togglePileup() {
         self.showPileup = !self.showPileup
       },
+      /**
+       * #action
+       */
       setScrollTop(scrollTop: number) {
         self.scrollTop = scrollTop
       },
+
+      /**
+       * #action
+       */
       setSNPCoverageHeight(n: number) {
         self.snpCovHeight = n
       },
@@ -58,6 +105,9 @@ const stateModelFactory = (
     .views(self => {
       const { trackMenuItems: superTrackMenuItems } = self
       return {
+        /**
+         * #getter
+         */
         get pileupDisplayConfig() {
           const conf = getConf(self, 'pileupDisplay')
           const track = getContainingTrack(self)
@@ -69,31 +119,55 @@ const stateModelFactory = (
           }
         },
 
+        /**
+         * #method
+         */
         getFeatureByID(blockKey: string, id: string) {
           return self.PileupDisplay.getFeatureByID(blockKey, id)
         },
+        /**
+         * #method
+         */
         searchFeatureByID(id: string) {
           return self.PileupDisplay.searchFeatureByID(id)
         },
 
+        /**
+         * #getter
+         */
         get features() {
           return self.PileupDisplay.features
         },
 
+        /**
+         * #getter
+         */
         get DisplayBlurb() {
           return self.PileupDisplay?.DisplayBlurb
         },
 
+        /**
+         * #getter
+         */
         get sortedBy() {
           return self.PileupDisplay.sortedBy
         },
+        /**
+         * #getter
+         */
         get sortedByPosition() {
           return self.PileupDisplay.sortedByPosition
         },
+        /**
+         * #getter
+         */
         get sortedByRefName() {
           return self.PileupDisplay.sortedByRefName
         },
 
+        /**
+         * #getter
+         */
         get snpCoverageDisplayConfig() {
           const conf = getConf(self, 'snpCoverageDisplay')
           const track = getContainingTrack(self)
@@ -105,6 +179,9 @@ const stateModelFactory = (
           }
         },
 
+        /**
+         * #method
+         */
         trackMenuItems(): MenuItem[] {
           return [
             ...superTrackMenuItems(),
@@ -123,23 +200,36 @@ const stateModelFactory = (
       }
     })
     .actions(self => ({
-      setSNPCoverageDisplay(displayConfig: AnyConfigurationModel) {
+      /**
+       * #action
+       */
+      setSNPCoverageDisplay(configuration: AnyConfigurationModel) {
         self.SNPCoverageDisplay = {
           type: 'LinearSNPCoverageDisplay',
-          configuration: displayConfig,
+          configuration,
           height: self.snpCovHeight,
         }
       },
-      setUserFeatureScreenDensity(limit: number) {
-        self.PileupDisplay.setUserFeatureScreenDensity(limit)
-        self.SNPCoverageDisplay.setUserFeatureScreenDensity(limit)
+      /**
+       * #action
+       */
+      updateStatsLimit(stats: unknown) {
+        self.PileupDisplay.updateStatsLimit(stats)
+        self.SNPCoverageDisplay.updateStatsLimit(stats)
       },
-      setPileupDisplay(displayConfig: AnyConfigurationModel) {
+
+      /**
+       * #action
+       */
+      setPileupDisplay(configuration: AnyConfigurationModel) {
         self.PileupDisplay = {
           type: 'LinearPileupDisplay',
-          configuration: displayConfig,
+          configuration,
         }
       },
+      /**
+       * #action
+       */
       setHeight(displayHeight: number) {
         if (displayHeight > minDisplayHeight) {
           self.height = displayHeight
@@ -148,6 +238,9 @@ const stateModelFactory = (
         }
         return self.height
       },
+      /**
+       * #action
+       */
       resizeHeight(distance: number) {
         const oldHeight = self.height
         const newHeight = this.setHeight(self.height + distance)
@@ -218,6 +311,9 @@ const stateModelFactory = (
           }),
         )
       },
+      /**
+       * #action
+       */
       async renderSvg(opts: { rasterizeLayers?: boolean }) {
         const pileupHeight = self.height - self.SNPCoverageDisplay.height
         await when(() => self.PileupDisplay.ready)