@jbrowse/plugin-alignments 2.6.1 → 2.6.2

package/src/SNPCoverageAdapter/generateCoverageBins.ts

@@ -1,259 +0,0 @@
-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,
-  getMethBins,
-  Mismatch,
-} from '../MismatchParser'
-import { doesIntersect2 } from '@jbrowse/core/util'
-import { Bin, SkipMap } from './util'
-
-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 extendedRegion = {
-    ...region,
-    start: Math.max(0, region.start - 1),
-    end: region.end + 1,
-  }
-  const binMax = Math.ceil(extendedRegion.end - extendedRegion.start)
-  const skipmap = {} as SkipMap
-  const regionSequence =
-    features.length && shouldFetchReferenceSequence(opts.colorBy?.type)
-      ? await fetchSequence(region)
-      : undefined
-
-  const bins = [] as Bin[]
-
-  for (const feature of features) {
-    const fstart = feature.get('start')
-    const fend = feature.get('end')
-    const fstrand = feature.get('strand') as -1 | 0 | 1
-    const mismatches = (feature.get('mismatches') as Mismatch[]) || []
-
-    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: {},
-            cov: {},
-            delskips: {},
-            noncov: {},
-          }
-        }
-        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 | undefined
-      const mm = (getTagAlt(feature, 'MM', 'Mm') as string) || ''
-      const ops = parseCigar(feature.get('CIGAR'))
-      const fend = feature.get('end')
-      if (seq) {
-        const modifications = getModificationPositions(mm, seq, fstrand)
-        for (const { type, positions } of modifications) {
-          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) {
-              if (bins[epos] === undefined) {
-                bins[epos] = {
-                  total: 0,
-                  all: 0,
-                  ref: 0,
-                  '-1': 0,
-                  '0': 0,
-                  '1': 0,
-                  lowqual: {},
-                  cov: {},
-                  delskips: {},
-                  noncov: {},
-                }
-              }
-              const bin = bins[epos]
-              if (bin) {
-                inc(bin, fstrand, 'cov', mod)
-              } else {
-                console.warn(
-                  'Undefined position in modifications snpcoverage encountered',
-                )
-              }
-            }
-          }
-        }
-      }
-    }
-
-    if (colorBy?.type === 'methylation') {
-      if (!regionSequence) {
-        throw new Error(
-          'no region sequence detected, need sequenceAdapter configuration',
-        )
-      }
-      const seq = feature.get('seq') as string | undefined
-      if (!seq) {
-        continue
-      }
-      const { methBins, methProbs } = getMethBins(feature)
-      const dels = mismatches.filter(f => f.type === 'deletion')
-
-      // methylation based coloring takes into account both reference sequence
-      // CpG detection and reads
-      for (let i = 0; i < fend - fstart; i++) {
-        const j = i + fstart
-        const l1 = regionSequence[j - region.start + 1]?.toLowerCase()
-        const l2 = regionSequence[j - region.start + 2]?.toLowerCase()
-        if (l1 === 'c' && l2 === 'g') {
-          const bin0 = bins[j - region.start]
-          const bin1 = bins[j - region.start + 1]
-          const b0 = methBins[i]
-          const b1 = methBins[i + 1]
-          const p0 = methProbs[i]
-          const p1 = methProbs[i + 1]
-
-          // color
-          if (
-            (b0 && (p0 !== undefined ? p0 > 0.5 : true)) ||
-            (b1 && (p1 !== undefined ? p1 > 0.5 : true))
-          ) {
-            if (bin0) {
-              inc(bin0, fstrand, 'cov', 'meth')
-              bin0.ref--
-              bin0[fstrand]--
-            }
-            if (bin1) {
-              inc(bin1, fstrand, 'cov', 'meth')
-              bin1.ref--
-              bin1[fstrand]--
-            }
-          } else {
-            if (bin0) {
-              if (
-                !dels?.some(d =>
-                  doesIntersect2(
-                    j,
-                    j + 1,
-                    d.start + fstart,
-                    d.start + fstart + d.length,
-                  ),
-                )
-              ) {
-                inc(bin0, fstrand, 'cov', 'unmeth')
-                bin0.ref--
-                bin0[fstrand]
-              }
-            }
-            if (bin1) {
-              if (
-                !dels?.some(d =>
-                  doesIntersect2(
-                    j + 1,
-                    j + 2,
-                    d.start + fstart,
-                    d.start + fstart + d.length,
-                  ),
-                )
-              ) {
-                inc(bin1, fstrand, 'cov', 'unmeth')
-                bin1.ref--
-                bin1[fstrand]--
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // normal SNP based coloring
-    const colorSNPs =
-      colorBy?.type !== 'modifications' && colorBy?.type !== 'methylation'
-
-    for (const mismatch of mismatches) {
-      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

@@ -1,18 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
-import configSchema from './configSchema'
-
-export default function (pluginManager: PluginManager) {
-  pluginManager.addAdapterType(() => {
-    return new AdapterType({
-      name: 'SNPCoverageAdapter',
-      displayName: 'SNPCoverage adapter',
-      adapterMetadata: {
-        hiddenFromGUI: true,
-      },
-      getAdapterClass: () =>
-        import('./SNPCoverageAdapter').then(r => r.default),
-      configSchema,
-    })
-  })
-}

package/src/SNPCoverageAdapter/util.ts

@@ -1,33 +0,0 @@
-export interface SkipMap {
-  [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
-export interface BinType {
-  total?: number
-  strands?: { [key: string]: number }
-}
-
-export interface Bin {
-  refbase?: string
-  total: number
-  all: number
-  ref: number
-  '-1': number
-  '0': number
-  '1': number
-  lowqual: BinType
-  cov: BinType
-  delskips: BinType
-  noncov: BinType
-}

package/src/SNPCoverageRenderer/SNPCoverageRenderer.ts

@@ -1,270 +0,0 @@
-import { createJBrowseTheme } from '@jbrowse/core/ui'
-import { featureSpanPx, bpSpanPx, Feature } from '@jbrowse/core/util'
-import { readConfObject } from '@jbrowse/core/configuration'
-import { RenderArgsDeserialized as FeatureRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType'
-import {
-  getOrigin,
-  getScale,
-  ScaleOpts,
-  WiggleBaseRenderer,
-  YSCALEBAR_LABEL_OFFSET,
-} from '@jbrowse/plugin-wiggle'
-
-export interface RenderArgsDeserialized extends FeatureRenderArgsDeserialized {
-  bpPerPx: number
-  height: number
-  highResolutionScaling: number
-  scaleOpts: ScaleOpts
-}
-
-export interface RenderArgsDeserializedWithFeatures
-  extends RenderArgsDeserialized {
-  features: Map<string, Feature>
-  ticks: { values: number[] }
-  displayCrossHatches: boolean
-  modificationTagMap?: Record<string, string | undefined>
-}
-
-type Counts = {
-  [key: string]: { total: number; strands: { [key: string]: number } }
-}
-
-interface SNPInfo {
-  cov: Counts
-  noncov: Counts
-  total: number
-}
-
-const fudgeFactor = 0.6
-
-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
-  async draw(
-    ctx: CanvasRenderingContext2D,
-    props: RenderArgsDeserializedWithFeatures,
-  ) {
-    const {
-      features,
-      regions,
-      bpPerPx,
-      displayCrossHatches,
-      modificationTagMap = {},
-      scaleOpts,
-      height: unadjustedHeight,
-      theme: configTheme,
-      config: cfg,
-      ticks,
-    } = props
-    const theme = createJBrowseTheme(configTheme)
-    const [region] = regions
-    const width = (region.end - region.start) / bpPerPx
-
-    // the adjusted height takes into account YSCALEBAR_LABEL_OFFSET from the
-    // wiggle display, and makes the height of the actual drawn area add
-    // "padding" to the top and bottom of the display
-    const offset = YSCALEBAR_LABEL_OFFSET
-    const height = unadjustedHeight - offset * 2
-
-    const { domain } = scaleOpts
-    if (!domain) {
-      return
-    }
-    const opts = { ...scaleOpts, range: [0, height] }
-    const viewScale = getScale(opts)
-
-    // clipping and insertion indicators, uses a smaller height/2 scale
-    const indicatorViewScale = getScale({
-      ...opts,
-      range: [0, height / 2],
-      scaleType: 'linear',
-    })
-    const originY = getOrigin(scaleOpts.scaleType)
-    const originLinear = getOrigin('linear')
-
-    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) || 0) + offset
-    const toHeight = (n: number) => toY(originY) - toY(n)
-    // used specifically for indicator
-    const toY2 = (n: number) => height - (indicatorViewScale(n) || 0) + offset
-    const toHeight2 = (n: number) => toY2(originLinear) - toY2(n)
-
-    const { bases } = theme.palette
-    const colorForBase: { [key: string]: string } = {
-      A: bases.A.main,
-      C: bases.C.main,
-      G: bases.G.main,
-      T: bases.T.main,
-      insertion: 'purple',
-      softclip: 'blue',
-      hardclip: 'red',
-      total: readConfObject(cfg, 'color'),
-      meth: 'red',
-      unmeth: 'blue',
-    }
-
-    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 (let i = 0; i < coverage.length; i++) {
-      const feature = coverage[i]
-      const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx)
-      const w = rightPx - leftPx + fudgeFactor
-      const score = feature.get('score') as number
-      ctx.fillRect(leftPx, toY(score), w, toHeight(score))
-    }
-
-    // Keep track of previous total which we will use it to draw the interbase
-    // indicator (if there is a sudden clip, there will be no read coverage but
-    // there will be "clip" coverage) at that position beyond the read. if the
-    // clip is right at a block boundary then prevTotal will not be available,
-    // so this is a best attempt to plot interbase indicator at the "cliffs"
-    let prevTotal = 0
-
-    // extraHorizontallyFlippedOffset is used to draw interbase items, which
-    // are located to the left when forward and right when reversed
-    const extraHorizontallyFlippedOffset = region.reversed ? 1 / bpPerPx : 0
-
-    // 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 (let i = 0; i < coverage.length; i++) {
-      const feature = coverage[i]
-      const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx)
-
-      const score = feature.get('score') as number
-      const snpinfo = feature.get('snpinfo') as SNPInfo
-      const w = Math.max(rightPx - leftPx, 1)
-      const totalScore = snpinfo.total
-      const keys = Object.keys(snpinfo.cov).sort()
-
-      let curr = 0
-      for (let i = 0; i < keys.length; i++) {
-        const base = keys[i]
-        const { total } = snpinfo.cov[base]
-        ctx.fillStyle =
-          colorForBase[base] ||
-          modificationTagMap[base.replace('mod_', '')] ||
-          'black'
-
-        const height = toHeight(score)
-        const bottom = toY(score) + height
-        ctx.fillRect(
-          Math.round(leftPx),
-          bottom - ((total + curr) / score) * height,
-          w,
-          (total / score) * height,
-        )
-        curr += total
-      }
-
-      const interbaseEvents = Object.keys(snpinfo.noncov)
-      const indicatorHeight = 4.5
-      if (drawInterbaseCounts) {
-        let curr = 0
-        for (let i = 0; i < interbaseEvents.length; i++) {
-          const base = interbaseEvents[i]
-          const { total } = snpinfo.noncov[base]
-          const r = 0.6
-          ctx.fillStyle = colorForBase[base]
-          ctx.fillRect(
-            leftPx - r + extraHorizontallyFlippedOffset,
-            indicatorHeight + toHeight2(curr),
-            r * 2,
-            toHeight2(total),
-          )
-          curr += total
-        }
-      }
-
-      if (drawIndicators) {
-        let accum = 0
-        let max = 0
-        let maxBase = ''
-        for (let i = 0; i < interbaseEvents.length; i++) {
-          const base = interbaseEvents[i]
-          const { total } = snpinfo.noncov[base]
-          accum += total
-          if (total > max) {
-            max = total
-            maxBase = base
-          }
-        }
-
-        // avoid drawing a bunch of indicators if coverage is very low e.g.
-        // less than 7, uses the prev total in the case of the "cliff"
-        const indicatorComparatorScore = Math.max(totalScore, prevTotal)
-        if (
-          accum > indicatorComparatorScore * indicatorThreshold &&
-          indicatorComparatorScore > 7
-        ) {
-          ctx.fillStyle = colorForBase[maxBase]
-          ctx.beginPath()
-          const l = leftPx + extraHorizontallyFlippedOffset
-          ctx.moveTo(l - 3.5, 0)
-          ctx.lineTo(l + 3.5, 0)
-          ctx.lineTo(l, indicatorHeight)
-          ctx.fill()
-        }
-      }
-      prevTotal = totalScore
-    }
-
-    if (drawArcs) {
-      for (let i = 0; i < skips.length; i++) {
-        const f = skips[i]
-        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 = 'rgba(255,200,200,0.7)'
-        const neg = 'rgba(200,200,255,0.7)'
-        const neutral = 'rgba(200,200,200,0.7)'
-
-        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) {
-      ctx.lineWidth = 1
-      ctx.strokeStyle = 'rgba(140,140,140,0.8)'
-      ticks.values.forEach(tick => {
-        ctx.beginPath()
-        ctx.moveTo(0, Math.round(toY(tick)))
-        ctx.lineTo(width, Math.round(toY(tick)))
-        ctx.stroke()
-      })
-    }
-  }
-}

package/src/SNPCoverageRenderer/configSchema.ts

@@ -1,64 +0,0 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration'
-
-/**
- * #config SNPCoverageRenderer
- */
-function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
-
-const SNPCoverageRenderer = ConfigurationSchema(
-  'SNPCoverageRenderer',
-  {
-    /**
-     * #slot
-     */
-    clipColor: {
-      type: 'color',
-      description: 'the color of the clipping marker',
-      defaultValue: 'red',
-    },
-    /**
-     * #slot
-     */
-    indicatorThreshold: {
-      type: 'number',
-      description:
-        'the proportion of reads containing a insertion/clip indicator',
-      defaultValue: 0.4,
-    },
-    /**
-     * #slot
-     */
-    drawArcs: {
-      type: 'boolean',
-      description: 'Draw sashimi-style arcs for intron features',
-      defaultValue: true,
-    },
-    /**
-     * #slot
-     */
-    drawInterbaseCounts: {
-      type: 'boolean',
-      description:
-        'draw count "upsidedown histogram" of the interbase events that don\'t contribute to the coverage count so are not drawn in the normal histogram',
-      defaultValue: true,
-    },
-    /**
-     * #slot
-     */
-    drawIndicators: {
-      type: 'boolean',
-      description:
-        'draw a triangular indicator where an event has been detected',
-      defaultValue: true,
-    },
-
-    color: {
-      type: 'color',
-      description: 'Background color for the SNPCoverage renderer',
-      defaultValue: '#d3d3d3',
-    },
-  },
-  { explicitlyTyped: true },
-)
-
-export default SNPCoverageRenderer

package/src/SNPCoverageRenderer/index.ts

@@ -1,17 +0,0 @@
-import configSchema from './configSchema'
-import PluginManager from '@jbrowse/core/PluginManager'
-import SNPCoverageRenderer from './SNPCoverageRenderer'
-
-import { WiggleRendering } from '@jbrowse/plugin-wiggle'
-
-export default function register(pluginManager: PluginManager) {
-  pluginManager.addRendererType(
-    () =>
-      new SNPCoverageRenderer({
-        name: 'SNPCoverageRenderer',
-        ReactComponent: WiggleRendering,
-        configSchema,
-        pluginManager,
-      }),
-  )
-}

package/src/__snapshots__/index.test.ts.snap

@@ -1,3 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`plugin in a stock JBrowse 1`] = `{}`;

package/src/index.test.ts

@@ -1,17 +0,0 @@
-import PluginManager from '@jbrowse/core/PluginManager'
-import SVG from '@jbrowse/plugin-svg'
-import { getSnapshot } from 'mobx-state-tree'
-import ThisPlugin from '.'
-
-test('plugin in a stock JBrowse', () => {
-  const pluginManager = new PluginManager([new ThisPlugin(), new SVG()])
-  pluginManager.createPluggableElements()
-  pluginManager.configure()
-  expect(() => pluginManager.addPlugin(new ThisPlugin())).toThrow(
-    /JBrowse already configured, cannot add plugins/,
-  )
-
-  const BamAdapter = pluginManager.getAdapterType('BamAdapter')
-  const config = BamAdapter.configSchema.create({ type: 'BamAdapter' })
-  expect(getSnapshot(config)).toMatchSnapshot()
-})