@jbrowse/plugin-alignments 2.16.1 → 2.18.0

package/esm/PileupRenderer/renderPerBaseQuality.d.ts

@@ -1,9 +1,10 @@
-import { Region } from '@jbrowse/core/util';
-import { LayoutFeature } from './util';
-export declare function renderPerBaseQuality({ ctx, feat, region, bpPerPx, canvasWidth, }: {
+import type { LayoutFeature } from './util';
+import type { Region } from '@jbrowse/core/util';
+export declare function renderPerBaseQuality({ ctx, feat, region, bpPerPx, canvasWidth, cigarOps, }: {
     ctx: CanvasRenderingContext2D;
     feat: LayoutFeature;
     region: Region;
     bpPerPx: number;
     canvasWidth: number;
+    cigarOps: string[];
 }): void;

package/esm/PileupRenderer/renderPerBaseQuality.js

@@ -1,15 +1,13 @@
 import { bpSpanPx } from '@jbrowse/core/util';
-import { parseCigar } from '../MismatchParser';
 import { fillRect } from './util';
-export function renderPerBaseQuality({ ctx, feat, region, bpPerPx, canvasWidth, }) {
+export function renderPerBaseQuality({ ctx, feat, region, bpPerPx, canvasWidth, cigarOps, }) {
     const { feature, topPx, heightPx } = feat;
     const qual = feature.get('qual') || '';
     const scores = qual.split(' ').map(val => +val);
-    const cigarOps = parseCigar(feature.get('CIGAR'));
     const w = 1 / bpPerPx;
     const start = feature.get('start');
-    let soffset = 0; // sequence offset
-    let roffset = 0; // reference offset
+    let soffset = 0;
+    let roffset = 0;
     for (let i = 0; i < cigarOps.length; i += 2) {
         const len = +cigarOps[i];
         const op = cigarOps[i + 1];

package/esm/PileupRenderer/renderSoftClipping.d.ts

@@ -1,11 +1,11 @@
-import { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import { Theme } from '@mui/material';
-import { RenderArgsDeserializedWithFeaturesAndLayout } from './PileupRenderer';
-import { LayoutFeature } from './util';
+import type { ProcessedRenderArgs } from './types';
+import type { LayoutFeature } from './util';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Theme } from '@mui/material';
 export declare function renderSoftClipping({ ctx, feat, renderArgs, config, theme, colorForBase, canvasWidth, }: {
     ctx: CanvasRenderingContext2D;
     feat: LayoutFeature;
-    renderArgs: RenderArgsDeserializedWithFeaturesAndLayout;
+    renderArgs: ProcessedRenderArgs;
     config: AnyConfigurationModel;
     colorForBase: Record<string, string>;
     theme: Theme;

package/esm/PileupRenderer/renderSoftClipping.js

@@ -1,8 +1,7 @@
-import { readConfObject, } from '@jbrowse/core/configuration';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { bpSpanPx } from '@jbrowse/core/util';
-// locals
-import { parseCigar } from '../MismatchParser';
 import { fillRect, getCharWidthHeight } from './util';
+import { parseCigar } from '../MismatchParser';
 export function renderSoftClipping({ ctx, feat, renderArgs, config, theme, colorForBase, canvasWidth, }) {
     const { feature, topPx, heightPx } = feat;
     const { regions, bpPerPx } = renderArgs;
@@ -11,25 +10,23 @@ export function renderSoftClipping({ ctx, feat, renderArgs, config, theme, color
     const mismatches = feature.get('mismatches');
     const seq = feature.get('seq');
     const { charWidth, charHeight } = getCharWidthHeight();
-    // Display all bases softclipped off in lightened colors
     if (!(seq && mismatches)) {
         return;
     }
     const heightLim = charHeight - 2;
-    const CIGAR = parseCigar(feature.get('CIGAR'));
     let seqOffset = 0;
     let refOffset = 0;
-    for (let i = 0; i < CIGAR.length; i += 2) {
-        const op = CIGAR[i + 1];
-        const len = +CIGAR[i];
+    const CIGAR = feature.get('CIGAR');
+    const cigarOps = parseCigar(CIGAR);
+    for (let i = 0; i < cigarOps.length; i += 2) {
+        const op = cigarOps[i + 1];
+        const len = +cigarOps[i];
         if (op === 'S') {
             for (let k = 0; k < len; k++) {
                 const base = seq[seqOffset + k];
                 const s0 = feature.get('start') - (i === 0 ? len : 0) + refOffset + k;
                 const [leftPx, rightPx] = bpSpanPx(s0, s0 + 1, region, bpPerPx);
                 const widthPx = Math.max(minFeatWidth, rightPx - leftPx);
-                // Black accounts for IUPAC ambiguity code bases such as N that
-                // show in soft clipping
                 const baseColor = colorForBase[base] || '#000000';
                 ctx.fillStyle = baseColor;
                 fillRect(ctx, leftPx, topPx, widthPx, heightPx, canvasWidth);
@@ -48,7 +45,6 @@ export function renderSoftClipping({ ctx, feat, renderArgs, config, theme, color
             seqOffset += len;
         }
         if (op === 'H') {
-            // do nothing
         }
         if (op === 'D') {
             refOffset += len;

package/esm/PileupRenderer/sortUtil.d.ts

@@ -1,8 +1,3 @@
-import { Feature } from '@jbrowse/core/util';
-interface SortObject {
-    pos: number;
-    type: string;
-    tag?: string;
-}
-export declare const sortFeature: (features: Map<string, Feature>, sortedBy: SortObject) => Map<string, Feature>;
-export {};
+import type { SortedBy } from '../shared/types';
+import type { Feature } from '@jbrowse/core/util';
+export declare const sortFeature: (features: Map<string, Feature>, sortedBy: SortedBy) => Map<string, Feature>;

package/esm/PileupRenderer/sortUtil.js

@@ -4,7 +4,6 @@ export const sortFeature = (features, sortedBy) => {
     const featuresInCenterLine = [];
     const featuresOutsideCenter = [];
     const { pos, type } = sortedBy;
-    // only sort on features that intersect center line, append those outside post-sort
     featureArray.forEach(innerArray => {
         const feature = innerArray;
         const start = feature.get('start');
@@ -37,36 +36,34 @@ export const sortFeature = (features, sortedBy) => {
             }
             break;
         }
-        // first sort all mismatches, then all reference bases at the end
         case 'Base pair': {
             const baseSortArray = [];
-            featuresInCenterLine.forEach(feature => {
+            for (const feature of featuresInCenterLine) {
                 const mismatches = feature.get('mismatches');
-                mismatches.forEach(mismatch => {
+                for (const m of mismatches) {
                     const start = feature.get('start');
-                    const offset = start + mismatch.start + 1;
-                    const consuming = mismatch.type === 'insertion' || mismatch.type === 'softclip';
-                    const len = consuming ? 0 : mismatch.length;
+                    const offset = start + m.start + 1;
+                    const consuming = m.type === 'insertion' || m.type === 'softclip';
+                    const len = consuming ? 0 : m.length;
                     if (pos >= offset && pos < offset + len) {
-                        baseSortArray.push([feature.id(), mismatch]);
+                        baseSortArray.push([feature.id(), m]);
                     }
-                });
-            });
+                }
+            }
             const baseMap = new Map(baseSortArray);
             featuresInCenterLine.sort((a, b) => {
                 const aMismatch = baseMap.get(a.id());
                 const bMismatch = baseMap.get(b.id());
                 const acode = bMismatch === null || bMismatch === void 0 ? void 0 : bMismatch.base.toUpperCase();
                 const bcode = aMismatch === null || aMismatch === void 0 ? void 0 : aMismatch.base.toUpperCase();
-                if (acode === bcode && acode === '*') {
-                    // @ts-expect-error
-                    return aMismatch.length - bMismatch.length;
-                }
-                return ((acode ? acode.charCodeAt(0) : 0) - (bcode ? bcode.charCodeAt(0) : 0));
+                return acode === bcode && acode === '*'
+                    ?
+                        aMismatch.length - bMismatch.length
+                    : (acode ? acode.charCodeAt(0) : 0) -
+                        (bcode ? bcode.charCodeAt(0) : 0);
             });
             break;
         }
-        // sorts positive strands then negative strands
         case 'Read strand': {
             featuresInCenterLine.sort((a, b) => a.get('strand') <= b.get('strand') ? 1 : -1);
             break;

package/esm/PileupRenderer/types.d.ts

@@ -0,0 +1,26 @@
+import type { ColorBy, ModificationTypeWithColor, SortedBy } from '../shared/types';
+import type { RenderArgsDeserialized as BoxRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/BoxRendererType';
+import type { Feature } from '@jbrowse/core/util';
+import type { BaseLayout } from '@jbrowse/core/util/layouts/BaseLayout';
+export interface LayoutFeature {
+    heightPx: number;
+    topPx: number;
+    feature: Feature;
+}
+export interface RenderArgsDeserialized extends BoxRenderArgsDeserialized {
+    colorBy?: ColorBy;
+    colorTagMap?: Record<string, string>;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    sortedBy?: SortedBy;
+    showSoftClip: boolean;
+    highResolutionScaling: number;
+}
+export interface ProcessedRenderArgs extends RenderArgsDeserialized {
+    features: Map<string, Feature>;
+    layout: BaseLayout<Feature>;
+    regionSequence: string | undefined;
+}
+export interface PreProcessedRenderArgs extends RenderArgsDeserialized {
+    features: Map<string, Feature>;
+    layout: BaseLayout<Feature>;
+}

package/esm/PileupRenderer/types.js

@@ -0,0 +1 @@
+export {};

package/esm/PileupRenderer/util.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '@jbrowse/core/util';
-import { Theme } from '@mui/material';
+import type { Feature } from '@jbrowse/core/util';
+import type { Theme } from '@mui/material';
 export declare function fillRect(ctx: CanvasRenderingContext2D, l: number, t: number, w: number, h: number, cw: number, color?: string): void;
 export declare function getColorBaseMap(theme: Theme): {
     A: string;

package/esm/PileupRenderer/util.js

@@ -15,7 +15,7 @@ export function getColorBaseMap(theme) {
         C: bases.C.main,
         G: bases.G.main,
         T: bases.T.main,
-        deletion: '#808080', // gray
+        deletion: '#808080',
     };
 }
 export function getContrastBaseMap(theme) {
@@ -30,8 +30,6 @@ export function shouldDrawSNPsMuted(type) {
 export function shouldDrawIndels() {
     return true;
 }
-// get width and height of chars the height is an approximation: width letter M
-// is approximately the height
 export function getCharWidthHeight() {
     const charWidth = measureText('A');
     const charHeight = measureText('M') - 2;

package/esm/SNPCoverageAdapter/SNPCoverageAdapter.d.ts

@@ -1,6 +1,7 @@
-import { BaseFeatureDataAdapter, BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { AugmentedRegion as Region } from '@jbrowse/core/util/types';
-import { Feature } from '@jbrowse/core/util/simpleFeature';
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { Feature } from '@jbrowse/core/util/simpleFeature';
+import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
 export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
     protected configure(): Promise<{
         subadapter: BaseFeatureDataAdapter;

package/esm/SNPCoverageAdapter/SNPCoverageAdapter.js

@@ -1,11 +1,10 @@
-import { BaseFeatureDataAdapter, } from '@jbrowse/core/data_adapters/BaseAdapter';
-import SimpleFeature from '@jbrowse/core/util/simpleFeature';
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-import { toArray } from 'rxjs/operators';
+import SimpleFeature from '@jbrowse/core/util/simpleFeature';
 import { firstValueFrom } from 'rxjs';
-// locals
-import generateCoverageBins from './generateCoverageBins';
+import { toArray } from 'rxjs/operators';
 import { fetchSequence } from '../util';
+import { generateCoverageBins } from './generateCoverageBins';
 export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
     async configure() {
         var _a, _b;
@@ -33,14 +32,19 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
     getFeatures(region, opts = {}) {
         return ObservableCreate(async (observer) => {
             const { subadapter } = await this.configure();
-            const feats = await firstValueFrom(subadapter.getFeatures(region, opts).pipe(toArray()));
-            const { bins, skipmap } = await generateCoverageBins(feats, region, opts, arg => this.fetchSequence(arg));
+            const features = await firstValueFrom(subadapter.getFeatures(region, opts).pipe(toArray()));
+            const { bins, skipmap } = await generateCoverageBins({
+                features,
+                region,
+                opts,
+                fetchSequence: (region) => this.fetchSequence(region),
+            });
             bins.forEach((bin, index) => {
                 const start = region.start + index;
                 observer.next(new SimpleFeature({
                     id: `${this.id}-${start}`,
                     data: {
-                        score: bin.total,
+                        score: bin.depth,
                         snpinfo: bin,
                         start,
                         end: start + 1,
@@ -48,7 +52,6 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
                     },
                 }));
             });
-            // make fake features from the coverage
             Object.entries(skipmap).forEach(([key, skip]) => {
                 observer.next(new SimpleFeature({
                     id: key,
@@ -58,12 +61,12 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
                         end: skip.end,
                         strand: skip.strand,
                         score: skip.score,
-                        xs: skip.xs,
+                        effectiveStrand: skip.effectiveStrand,
                     },
                 }));
             });
             observer.complete();
-        }, opts.signal);
+        }, opts.stopToken);
     }
     async getMultiRegionFeatureDensityStats(regions, opts) {
         const { subadapter } = await this.configure();
@@ -73,5 +76,5 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
         const { subadapter } = await this.configure();
         return subadapter.getRefNames(opts);
     }
-    freeResources( /* { region } */) { }
+    freeResources() { }
 }

package/esm/SNPCoverageAdapter/configSchema.d.ts

@@ -1,8 +1,4 @@
 declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * normally refers to a BAM or CRAM adapter
-     */
     subadapter: {
         type: string;
         defaultValue: null;

package/esm/SNPCoverageAdapter/configSchema.js

@@ -1,13 +1,6 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-/**
- * #config SNPCoverageAdapter
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+function x() { }
 const configSchema = ConfigurationSchema('SNPCoverageAdapter', {
-    /**
-     * #slot
-     * normally refers to a BAM or CRAM adapter
-     */
     subadapter: {
         type: 'frozen',
         defaultValue: null,

package/esm/SNPCoverageAdapter/generateCoverageBins.d.ts

@@ -1,13 +1,13 @@
-import { AugmentedRegion as Region } from '@jbrowse/core/util/types';
-import { Feature } from '@jbrowse/core/util/simpleFeature';
-import { Bin, SkipMap } from './util';
-export default function generateCoverageBins(features: Feature[], region: Region, opts: {
-    bpPerPx?: number;
-    colorBy?: {
-        type: string;
-        tag?: string;
-    };
-}, fetchSequence: (arg: Region) => Promise<string>): Promise<{
-    bins: Bin[];
+import type { Opts } from './util';
+import type { PreBaseCoverageBin, SkipMap } from '../shared/types';
+import type { Feature } from '@jbrowse/core/util';
+import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
+export declare function generateCoverageBins({ fetchSequence, features, region, opts, }: {
+    features: Feature[];
+    region: Region;
+    opts: Opts;
+    fetchSequence: (arg: Region) => Promise<string>;
+}): Promise<{
+    bins: PreBaseCoverageBin[];
     skipmap: SkipMap;
 }>;

package/esm/SNPCoverageAdapter/generateCoverageBins.js

@@ -1,202 +1,83 @@
-import { getTag, getTagAlt, shouldFetchReferenceSequence } from '../util';
-import { parseCigar, getNextRefPos, getModificationPositions, getMethBins, } from '../MismatchParser';
-import { doesIntersect2 } from '@jbrowse/core/util';
-function mismatchLen(mismatch) {
-    return !isInterbase(mismatch.type) ? mismatch.length : 1;
-}
-function isInterbase(type) {
-    return type === 'softclip' || type === 'hardclip' || type === 'insertion';
-}
-function inc(bin, strand, type, field) {
-    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, region, opts, fetchSequence) {
-    var _a, _b, _c;
-    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);
+import { sum } from '@jbrowse/core/util';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
+import { processDepth } from './processDepth';
+import { processMismatches } from './processMismatches';
+import { processModifications } from './processModifications';
+import { processReferenceCpGs } from './processReferenceCpGs';
+export async function generateCoverageBins({ fetchSequence, features, region, opts, }) {
+    const { stopToken, colorBy } = opts;
     const skipmap = {};
-    const regionSequence = features.length && shouldFetchReferenceSequence((_a = opts.colorBy) === null || _a === void 0 ? void 0 : _a.type)
-        ? await fetchSequence(region)
-        : undefined;
     const bins = [];
+    const start2 = Math.max(0, region.start - 1);
+    const diff = region.start - start2;
+    let start = performance.now();
     for (const feature of features) {
-        const fstart = feature.get('start');
-        const fend = feature.get('end');
-        const fstrand = feature.get('strand');
-        const mismatches = feature.get('mismatches') || [];
-        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 (performance.now() - start > 400) {
+            checkStopToken(stopToken);
+            start = performance.now();
         }
+        processDepth({
+            feature,
+            bins,
+            region,
+        });
         if ((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'modifications') {
-            const seq = feature.get('seq');
-            const mm = getTagAlt(feature, 'MM', 'Mm') || '';
-            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];
-                            inc(bin, fstrand, 'cov', mod);
-                        }
-                    }
-                }
-            }
+            const regionSequence = (await fetchSequence({
+                ...region,
+                start: start2,
+                end: region.end + 1,
+            })) || '';
+            processModifications({
+                feature,
+                colorBy,
+                bins,
+                region,
+                regionSequence: regionSequence.slice(diff),
+            });
         }
-        if ((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'methylation') {
-            if (!regionSequence) {
-                throw new Error('no region sequence detected, need sequenceAdapter configuration');
-            }
-            const seq = feature.get('seq');
-            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 = (_b = regionSequence[j - region.start + 1]) === null || _b === void 0 ? void 0 : _b.toLowerCase();
-                const l2 = (_c = regionSequence[j - region.start + 2]) === null || _c === void 0 ? void 0 : _c.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]--;
-                            }
-                        }
-                    }
-                }
-            }
+        else if ((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'methylation') {
+            const regionSequence = (await fetchSequence({
+                ...region,
+                start: start2,
+                end: region.end + 1,
+            })) || '';
+            processReferenceCpGs({
+                feature,
+                bins,
+                region,
+                regionSequence,
+            });
         }
-        // normal SNP based coloring
-        const colorSNPs = (colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) !== 'modifications' && (colorBy === null || colorBy === void 0 ? void 0 : 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++;
-            }
+        processMismatches({ feature, skipmap, bins, region });
+    }
+    for (const bin of bins) {
+        if (bin) {
+            bin.mods = Object.fromEntries(Object.entries(bin.mods).map(([key, val]) => {
+                return [
+                    key,
+                    {
+                        ...val,
+                        avgProbability: val.probabilities.length
+                            ? sum(val.probabilities) / val.probabilities.length
+                            : undefined,
+                    },
+                ];
+            }));
+            bin.nonmods = Object.fromEntries(Object.entries(bin.nonmods).map(([key, val]) => {
+                return [
+                    key,
+                    {
+                        ...val,
+                        avgProbability: val.probabilities.length
+                            ? sum(val.probabilities) / val.probabilities.length
+                            : undefined,
+                    },
+                ];
+            }));
         }
     }
-    return { bins, skipmap };
+    return {
+        bins,
+        skipmap,
+    };
 }

package/esm/SNPCoverageAdapter/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function SNPCoverageAdapterF(pluginManager: PluginManager): void;