@jbrowse/plugin-alignments 1.6.1 → 1.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-alignments",
-  "version": "1.6.1",
+  "version": "1.6.5",
   "description": "JBrowse 2 alignments adapters, tracks, etc.",
   "keywords": [
     "jbrowse",
@@ -35,10 +35,10 @@
     "useSrc": "node ../../scripts/useSrc.js"
   },
   "dependencies": {
-    "@gmod/bam": "^1.1.11",
-    "@gmod/cram": "^1.5.9",
+    "@gmod/bam": "^1.1.12",
+    "@gmod/cram": "^1.6.1",
     "@material-ui/icons": "^4.9.1",
-    "abortable-promise-cache": "^1.1.3",
+    "abortable-promise-cache": "^1.5.0",
     "color": "^3.1.2",
     "copy-to-clipboard": "^3.3.1",
     "fast-deep-equal": "^3.1.3",
@@ -61,5 +61,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d6ad1b8e7fbb00000f2ac87f463c82e9db12ea01"
+  "gitHead": "ab41f017840ffef09f5d60b008281cedaa5abe26"
 }

package/src/BamAdapter/BamAdapter.ts

@@ -197,11 +197,10 @@ export default class BamAdapter extends BaseFeatureDataAdapter {
 
   async estimateRegionsStats(regions: Region[], opts?: BaseOptions) {
     const { bam } = await this.configure()
-    // @ts-ignore
-    const index = bam.index
     // this is a method to avoid calling on htsget adapters
-    if (index.filehandle !== '?') {
-      const bytes = await bytesForRegions(regions, index)
+    // @ts-ignore
+    if (bam.index.filehandle !== '?') {
+      const bytes = await bytesForRegions(regions, bam)
       const fetchSizeLimit = readConfObject(this.config, 'fetchSizeLimit')
       return { bytes, fetchSizeLimit }
     } else {

package/src/PileupRenderer/PileupRenderer.tsx

@@ -716,20 +716,21 @@ export default class PileupRenderer extends BoxRendererType {
           ctx.fillText(`(${mismatch.base})`, leftPx + 2, topPx + heightPx)
         }
       } else if (mismatch.type === 'skip') {
-        // fix to avoid bad rendering
-        // note that this was also related to chrome bug https://bugs.chromium.org/p/chro>
-        // ref #1236
+        // fix to avoid bad rendering note that this was also related to chrome
+        // bug https://bugs.chromium.org/p/chromium/issues/detail?id=1131528
+        // also affected firefox ref #1236 #2750
         if (leftPx + widthPx > 0) {
           // make small exons more visible when zoomed far out
-          ctx.clearRect(
-            leftPx,
-            topPx,
-            widthPx - (bpPerPx > 10 ? 1.5 : 0),
-            heightPx,
+          const adjustPx = widthPx - (bpPerPx > 10 ? 1.5 : 0)
+          ctx.clearRect(leftPx, topPx, adjustPx, heightPx)
+          ctx.fillStyle = '#333'
+          ctx.fillRect(
+            Math.max(0, leftPx),
+            topPx + heightPx / 2 - 1,
+            adjustPx + (leftPx < 0 ? leftPx : 0),
+            2,
           )
         }
-        ctx.fillStyle = '#333'
-        ctx.fillRect(leftPx, topPx + heightPx / 2, widthPx, 2)
       }
     }
 

package/src/SNPCoverageAdapter/SNPCoverageAdapter.ts

@@ -9,7 +9,7 @@ import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/rendere
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { reduce, filter, toArray } from 'rxjs/operators'
 import { Observable } from 'rxjs'
-import { getTagAlt } from '../util'
+import { getTag, getTagAlt } from '../util'
 import {
   parseCigar,
   getNextRefPos,
@@ -171,14 +171,6 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
     // delskips are elements that don't contribute to coverage, but should be
     // reported also (and are not interbase)
     type BinType = { total: number; strands: { [key: string]: number } }
-    const initBins = Array.from({ length: binMax }, () => ({
-      total: 0,
-      lowqual: {} as BinType,
-      cov: {} as BinType,
-      delskips: {} as BinType,
-      noncov: {} as BinType,
-      ref: {} as BinType,
-    }))
 
     // request an extra +1 on the end to get CpG crossing region boundary
     let regionSeq: string | undefined
@@ -189,7 +181,7 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
           refName: originalRefName || refName,
           start,
           end: end + 1,
-          assemblyName: 'na',
+          assemblyName: region.assemblyName,
         })
         .pipe(toArray())
         .toPromise()
@@ -198,172 +190,195 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
 
     const bins = await features
       .pipe(
-        reduce((bins, feature) => {
-          const cigar = feature.get('CIGAR')
-          const fstart = feature.get('start')
-          const fend = feature.get('end')
-          const fstrand = feature.get('strand')
-          const cigarOps = parseCigar(cigar)
-
-          for (let j = fstart; j < fend; j++) {
-            const i = j - region.start
-            if (i >= 0 && i < bins.length) {
-              const bin = bins[i]
-              bin.total++
-              inc(bin, fstrand, 'ref', 'ref')
-            }
-          }
-
-          if (colorBy?.type === 'modifications') {
-            const seq = feature.get('seq')
-            const mm = getTagAlt(feature, 'MM', 'Mm') || ''
+        reduce(
+          (bins, feature) => {
+            const cigar = feature.get('CIGAR')
+            const fstart = feature.get('start')
+            const fend = feature.get('end')
+            const fstrand = feature.get('strand')
+            const cigarOps = parseCigar(cigar)
 
-            const ml =
-              (getTagAlt(feature, 'ML', 'Ml') as number[] | string) || []
+            for (let j = fstart; j < fend; j++) {
+              const i = j - region.start
+              if (i >= 0 && i < binMax) {
+                const bin = bins[i] || {
+                  total: 0,
+                  lowqual: {} as BinType,
+                  cov: {} as BinType,
+                  delskips: {} as BinType,
+                  noncov: {} as BinType,
+                  ref: {} as BinType,
+                }
+                bin.total++
+                inc(bin, fstrand, 'ref', 'ref')
+                bins[i] = bin
+              }
+            }
 
-            const probabilities = ml
-              ? (typeof ml === 'string' ? ml.split(',').map(e => +e) : ml).map(
-                  e => e / 255,
-                )
-              : (getTagAlt(feature, 'MP', 'Mp') as string)
-                  .split('')
-                  .map(s => s.charCodeAt(0) - 33)
-                  .map(elt => Math.min(1, elt / 50))
-
-            let probIndex = 0
-            getModificationPositions(mm, seq, fstrand).forEach(
-              ({ type, positions }) => {
-                const mod = `mod_${type}`
-                for (const pos of getNextRefPos(cigarOps, positions)) {
-                  const epos = pos + fstart - region.start
-                  if (epos >= 0 && epos < bins.length && pos + fstart < fend) {
-                    const bin = bins[epos]
-                    if (probabilities[probIndex] > 0.5) {
-                      inc(bin, fstrand, 'cov', mod)
-                    } else {
-                      inc(bin, fstrand, 'lowqual', mod)
+            if (colorBy?.type === 'modifications') {
+              const seq = feature.get('seq')
+              const mm = getTagAlt(feature, 'MM', 'Mm') || ''
+
+              const ml =
+                (getTagAlt(feature, 'ML', 'Ml') as number[] | string) || []
+
+              const probabilities = ml
+                ? (typeof ml === 'string'
+                    ? ml.split(',').map(e => +e)
+                    : ml
+                  ).map(e => e / 255)
+                : (getTagAlt(feature, 'MP', 'Mp') as string)
+                    .split('')
+                    .map(s => s.charCodeAt(0) - 33)
+                    .map(elt => Math.min(1, elt / 50))
+
+              let probIndex = 0
+              getModificationPositions(mm, seq, fstrand).forEach(
+                ({ type, positions }) => {
+                  const mod = `mod_${type}`
+                  for (const pos of getNextRefPos(cigarOps, positions)) {
+                    const epos = pos + fstart - region.start
+                    if (
+                      epos >= 0 &&
+                      epos < bins.length &&
+                      pos + fstart < fend
+                    ) {
+                      const bin = bins[epos]
+                      if (probabilities[probIndex] > 0.5) {
+                        inc(bin, fstrand, 'cov', mod)
+                      } else {
+                        inc(bin, fstrand, 'lowqual', mod)
+                      }
                     }
+                    probIndex++
                   }
-                  probIndex++
-                }
-              },
-            )
-          }
-
-          // 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)
-
-            getModificationPositions(mm, seq, fstrand).forEach(
-              ({ type, positions }) => {
-                // we are processing methylation
-                if (type === 'm') {
-                  for (const pos of getNextRefPos(cigarOps, positions)) {
-                    const epos = pos + fstart - region.start
-                    if (epos >= 0 && epos < methBins.length) {
-                      methBins[epos] = 1
+
+            // 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)
+
+              getModificationPositions(mm, seq, fstrand).forEach(
+                ({ type, positions }) => {
+                  // we are processing methylation
+                  if (type === 'm') {
+                    for (const pos of getNextRefPos(cigarOps, 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')
-                    dec(bin, fstrand, 'ref', 'ref')
-                    dec(bin1, fstrand, 'ref', 'ref')
-                  } else {
-                    inc(bin, fstrand, 'cov', 'unmeth')
-                    inc(bin1, fstrand, 'cov', 'unmeth')
-                    dec(bin, fstrand, 'ref', 'ref')
-                    dec(bin1, fstrand, 'ref', 'ref')
+              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')
+                      dec(bin, fstrand, 'ref', 'ref')
+                      dec(bin1, fstrand, 'ref', 'ref')
+                    } else {
+                      inc(bin, fstrand, 'cov', 'unmeth')
+                      inc(bin1, fstrand, 'cov', 'unmeth')
+                      dec(bin, fstrand, 'ref', 'ref')
+                      dec(bin1, fstrand, 'ref', 'ref')
+                    }
                   }
                 }
               }
             }
-          }
-
-          // normal SNP based coloring
-          else {
-            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)
+            // normal SNP based coloring
+            else {
+              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)
+                      }
                     }
                   }
                 }
-              }
 
-              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,
+                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: getTag(feature, 'XS') || getTag(feature, 'TS'),
+                        score: 1,
+                      }
+                    } else {
+                      skipmap[hash].score++
                     }
-                  } else {
-                    skipmap[hash].score++
-                  }
-                })
+                  })
+              }
             }
-          }
 
-          return bins
-        }, initBins),
+            return bins
+          },
+          [] as {
+            total: number
+            lowqual: BinType
+            cov: BinType
+            delskips: BinType
+            noncov: BinType
+            ref: BinType
+          }[],
+        ),
       )
       .toPromise()