@jbrowse/plugin-alignments 1.7.7 → 1.7.10

package/src/PileupRenderer/configSchema.ts

@@ -31,8 +31,8 @@ export default ConfigurationSchema(
     minSubfeatureWidth: {
       type: 'number',
       description:
-        'the minimum width in px for a pileup mismatch feature. use for increasing mismatch marker widths when zoomed out to e.g. 1px or 0.5px',
-      defaultValue: 0,
+        'the minimum width in px for a pileup mismatch feature. use for increasing/decreasing mismatch marker widths when zoomed out, e.g. 0 or 1',
+      defaultValue: 0.7,
     },
     maxHeight: {
       type: 'integer',

package/src/SNPCoverageAdapter/SNPCoverageAdapter.ts

@@ -30,22 +30,16 @@ function isInterbase(type: string) {
 // 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) {
+  if (thisBin === undefined) {
     thisBin = bin[type][field] = {
       total: 0,
-      strands: { '-1': 0, '0': 0, '1': 0 },
+      '-1': 0,
+      '0': 0,
+      '1': 0,
     }
   }
   thisBin.total++
-  thisBin.strands[strand]++
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function dec(bin: any, strand: number, type: string, field: string) {
-  if (!bin[type][field]) {
-    bin[type][field] = { total: 0, strands: { '-1': 0, '0': 0, '1': 0 } }
-  }
-  bin[type][field].total--
-  bin[type][field].strands[strand]--
+  thisBin[strand]++
 }
 
 export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
@@ -172,43 +166,56 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
         : undefined
 
     const bins = [] as {
+      refbase?: string
       total: number
+      all: number
+      ref: number
+      '-1': 0
+      '0': 0
+      '1': 0
       lowqual: BinType
       cov: BinType
       delskips: BinType
       noncov: BinType
-      ref: BinType
     }[]
 
     for (let i = 0; i < features.length; i++) {
       const feature = features[i]
-      const ops = parseCigar(feature.get('CIGAR'))
       const fstart = feature.get('start')
       const fend = feature.get('end')
-      const fstrand = feature.get('strand')
+      const fstrand = feature.get('strand') as -1 | 0 | 1
 
-      for (let j = fstart; j < fend; j++) {
+      for (let j = fstart; j < fend + 1; 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,
+          if (bins[i] === undefined) {
+            bins[i] = {
+              total: 0,
+              all: 0,
+              ref: 0,
+              '-1': 0,
+              '0': 0,
+              '1': 0,
+              lowqual: {} as BinType,
+              cov: {} as BinType,
+              delskips: {} as BinType,
+              noncov: {} as BinType,
+            }
           }
           if (j !== fend) {
-            bin.total++
-            inc(bin, fstrand, 'ref', 'ref')
+            bins[i].total++
+            bins[i].all++
+            bins[i].ref++
+            bins[i][fstrand]++
           }
-          bins[i] = bin
         }
       }
 
       if (colorBy?.type === 'modifications') {
         const seq = feature.get('seq') as string
         const mm = (getTagAlt(feature, 'MM', 'Mm') as string) || ''
+        const ops = parseCigar(feature.get('CIGAR'))
+        const fend = feature.get('end')
 
         getModificationPositions(mm, seq, fstrand).forEach(
           ({ type, positions }) => {
@@ -217,7 +224,13 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
               const epos = pos + fstart - region.start
               if (epos >= 0 && epos < bins.length && pos + fstart < fend) {
                 const bin = bins[epos]
-                inc(bin, fstrand, 'cov', mod)
+                if (bin) {
+                  inc(bin, fstrand, 'cov', mod)
+                } else {
+                  console.warn(
+                    'Undefined position in modifications snpcoverage encountered',
+                  )
+                }
               }
             }
           },
@@ -235,6 +248,7 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
         const seq = feature.get('seq')
         const mm = getTagAlt(feature, 'MM', 'Mm') || ''
         const methBins = new Array(region.end - region.start).fill(0)
+        const ops = parseCigar(feature.get('CIGAR'))
 
         getModificationPositions(mm, seq, fstrand).forEach(
           ({ type, positions }) => {
@@ -263,13 +277,17 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
               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')
+                bins[i].ref--
+                bins[i][fstrand]--
+                bins[i + 1].ref--
+                bins[i + 1][fstrand]--
               } else {
                 inc(bin, fstrand, 'cov', 'unmeth')
                 inc(bin1, fstrand, 'cov', 'unmeth')
-                dec(bin, fstrand, 'ref', 'ref')
-                dec(bin1, fstrand, 'ref', 'ref')
+                bins[i].ref--
+                bins[i][fstrand]--
+                bins[i + 1].ref--
+                bins[i + 1][fstrand]--
               }
             }
           }
@@ -277,56 +295,51 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
       }
 
       // 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)
-                }
+      const mismatches = (feature.get('mismatches') as Mismatch[]) || []
+      const colorSNPs =
+        colorBy?.type !== 'modifications' && colorBy?.type !== 'methylation'
+
+      for (let i = 0; i < mismatches.length; i++) {
+        const mismatch = mismatches[i]
+        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) {
-                  inc(bin, fstrand, 'cov', base)
-                }
-              }
+            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
             }
           }
+        }
 
-          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++
-              }
-            })
+        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++
         }
       }
     }