@jbrowse/plugin-alignments 2.16.1 → 2.18.0

package/dist/SNPCoverageAdapter/generateCoverageBins.js

@@ -1,205 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = generateCoverageBins;
-const util_1 = require("../util");
-const MismatchParser_1 = require("../MismatchParser");
-const util_2 = require("@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]++;
-}
-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);
+exports.generateCoverageBins = generateCoverageBins;
+const util_1 = require("@jbrowse/core/util");
+const stopToken_1 = require("@jbrowse/core/util/stopToken");
+const processDepth_1 = require("./processDepth");
+const processMismatches_1 = require("./processMismatches");
+const processModifications_1 = require("./processModifications");
+const processReferenceCpGs_1 = require("./processReferenceCpGs");
+async function generateCoverageBins({ fetchSequence, features, region, opts, }) {
+    const { stopToken, colorBy } = opts;
     const skipmap = {};
-    const regionSequence = features.length && (0, util_1.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) {
+            (0, stopToken_1.checkStopToken)(stopToken);
+            start = performance.now();
         }
+        (0, processDepth_1.processDepth)({
+            feature,
+            bins,
+            region,
+        });
         if ((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'modifications') {
-            const seq = feature.get('seq');
-            const mm = (0, util_1.getTagAlt)(feature, 'MM', 'Mm') || '';
-            const ops = (0, MismatchParser_1.parseCigar)(feature.get('CIGAR'));
-            const fend = feature.get('end');
-            if (seq) {
-                const modifications = (0, MismatchParser_1.getModificationPositions)(mm, seq, fstrand);
-                for (const { type, positions } of modifications) {
-                    const mod = `mod_${type}`;
-                    for (const pos of (0, MismatchParser_1.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,
+            })) || '';
+            (0, processModifications_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 } = (0, MismatchParser_1.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 => (0, util_2.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 => (0, util_2.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,
+            })) || '';
+            (0, processReferenceCpGs_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: (0, util_1.getTag)(feature, 'XS') || (0, util_1.getTag)(feature, 'TS'),
-                        score: 0,
-                    };
-                }
-                skipmap[hash].score++;
-            }
+        (0, processMismatches_1.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
+                            ? (0, util_1.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
+                            ? (0, util_1.sum)(val.probabilities) / val.probabilities.length
+                            : undefined,
+                    },
+                ];
+            }));
         }
     }
-    return { bins, skipmap };
+    return {
+        bins,
+        skipmap,
+    };
 }

package/dist/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;

package/dist/SNPCoverageAdapter/processDepth.d.ts

@@ -0,0 +1,8 @@
+import type { PreBaseCoverageBin } from '../shared/types';
+import type { Feature } from '@jbrowse/core/util';
+import type { AugmentedRegion } from '@jbrowse/core/util/types';
+export declare function processDepth({ feature, bins, region, }: {
+    feature: Feature;
+    bins: PreBaseCoverageBin[];
+    region: AugmentedRegion;
+}): void;

package/dist/SNPCoverageAdapter/processDepth.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDepth = processDepth;
+function processDepth({ feature, bins, region, }) {
+    const fstart = feature.get('start');
+    const fend = feature.get('end');
+    const fstrand = feature.get('strand');
+    const regionLength = region.end - region.start;
+    for (let j = fstart; j < fend + 1; j++) {
+        const i = j - region.start;
+        if (i >= 0 && i < regionLength) {
+            if (bins[i] === undefined) {
+                bins[i] = {
+                    depth: 0,
+                    readsCounted: 0,
+                    ref: {
+                        probabilities: [],
+                        entryDepth: 0,
+                        '-1': 0,
+                        0: 0,
+                        1: 0,
+                    },
+                    snps: {},
+                    mods: {},
+                    nonmods: {},
+                    delskips: {},
+                    noncov: {},
+                };
+            }
+            if (j !== fend) {
+                bins[i].depth++;
+                bins[i].readsCounted++;
+                bins[i].ref.entryDepth++;
+                bins[i].ref[fstrand]++;
+            }
+        }
+    }
+}

package/dist/SNPCoverageAdapter/processMismatches.d.ts

@@ -0,0 +1,9 @@
+import type { PreBaseCoverageBin, SkipMap } from '../shared/types';
+import type { Feature } from '@jbrowse/core/util';
+import type { AugmentedRegion } from '@jbrowse/core/util/types';
+export declare function processMismatches({ feature, region, bins, skipmap, }: {
+    region: AugmentedRegion;
+    bins: PreBaseCoverageBin[];
+    feature: Feature;
+    skipmap: SkipMap;
+}): void;

package/dist/SNPCoverageAdapter/processMismatches.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMismatches = processMismatches;
+const util_1 = require("./util");
+function processMismatches({ feature, region, bins, skipmap, }) {
+    var _a;
+    const fstart = feature.get('start');
+    const fstrand = feature.get('strand');
+    const mismatches = (_a = feature.get('mismatches')) !== null && _a !== void 0 ? _a : [];
+    for (const mismatch of mismatches) {
+        const mstart = fstart + mismatch.start;
+        const mlen = (0, util_1.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, altbase, type } = mismatch;
+                const interbase = (0, util_1.isInterbase)(type);
+                if (type === 'deletion' || type === 'skip') {
+                    (0, util_1.inc)(bin, fstrand, 'delskips', type);
+                    bin.depth--;
+                }
+                else if (!interbase) {
+                    (0, util_1.inc)(bin, fstrand, 'snps', base);
+                    bin.ref.entryDepth--;
+                    bin.ref[fstrand]--;
+                    bin.refbase = altbase;
+                }
+                else {
+                    (0, util_1.inc)(bin, fstrand, 'noncov', type);
+                }
+            }
+        }
+        if (mismatch.type === 'skip') {
+            const tags = feature.get('tags');
+            const xs = (tags === null || tags === void 0 ? void 0 : tags.XS) || (tags === null || tags === void 0 ? void 0 : tags.TS);
+            const ts = tags === null || tags === void 0 ? void 0 : tags.ts;
+            const effectiveStrand = xs === '+'
+                ? 1
+                : xs === '-'
+                    ? -1
+                    : (ts === '+' ? 1 : xs === '-' ? -1 : 0) * fstrand;
+            const hash = `${mstart}_${mend}_${effectiveStrand}`;
+            if (skipmap[hash] === undefined) {
+                skipmap[hash] = {
+                    feature: feature,
+                    start: mstart,
+                    end: mend,
+                    strand: fstrand,
+                    effectiveStrand,
+                    score: 0,
+                };
+            }
+            skipmap[hash].score++;
+        }
+    }
+}

package/dist/SNPCoverageAdapter/processModifications.d.ts

@@ -0,0 +1,10 @@
+import type { ColorBy, PreBaseCoverageBin } from '../shared/types';
+import type { Feature } from '@jbrowse/core/util';
+import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
+export declare function processModifications({ feature, colorBy, region, bins, regionSequence, }: {
+    bins: PreBaseCoverageBin[];
+    feature: Feature;
+    region: Region;
+    colorBy?: ColorBy;
+    regionSequence: string;
+}): void;

package/dist/SNPCoverageAdapter/processModifications.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processModifications = processModifications;
+const util_1 = require("@jbrowse/core/util");
+const util_2 = require("./util");
+const getMaximumModificationAtEachPosition_1 = require("../shared/getMaximumModificationAtEachPosition");
+function processModifications({ feature, colorBy, region, bins, regionSequence, }) {
+    var _a, _b, _c;
+    const fstart = feature.get('start');
+    const fstrand = feature.get('strand');
+    const fend = feature.get('end');
+    const twoColor = (_a = colorBy === null || colorBy === void 0 ? void 0 : colorBy.modifications) === null || _a === void 0 ? void 0 : _a.twoColor;
+    const isolatedModification = (_b = colorBy === null || colorBy === void 0 ? void 0 : colorBy.modifications) === null || _b === void 0 ? void 0 : _b.isolatedModification;
+    (_c = (0, getMaximumModificationAtEachPosition_1.getMaxProbModAtEachPosition)(feature)) === null || _c === void 0 ? void 0 : _c.forEach(({ type, prob, allProbs }, pos) => {
+        if (isolatedModification && type !== isolatedModification) {
+            return;
+        }
+        const epos = pos + fstart - region.start;
+        if (epos >= 0 && epos < bins.length && pos + fstart < fend) {
+            if (bins[epos] === undefined) {
+                bins[epos] = {
+                    depth: 0,
+                    readsCounted: 0,
+                    refbase: regionSequence[epos],
+                    snps: {},
+                    ref: {
+                        probabilities: [],
+                        entryDepth: 0,
+                        '-1': 0,
+                        0: 0,
+                        1: 0,
+                    },
+                    mods: {},
+                    nonmods: {},
+                    delskips: {},
+                    noncov: {},
+                };
+            }
+            const s = 1 - (0, util_1.sum)(allProbs);
+            const bin = bins[epos];
+            if (twoColor && s > (0, util_1.max)(allProbs)) {
+                (0, util_2.incWithProbabilities)(bin, fstrand, 'nonmods', `nonmod_${type}`, s);
+            }
+            else {
+                (0, util_2.incWithProbabilities)(bin, fstrand, 'mods', `mod_${type}`, prob);
+            }
+        }
+    });
+}

package/dist/SNPCoverageAdapter/processReferenceCpGs.d.ts

@@ -0,0 +1,9 @@
+import type { PreBaseCoverageBin } from '../shared/types';
+import type { Feature } from '@jbrowse/core/util';
+import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
+export declare function processReferenceCpGs({ feature, region, bins, regionSequence, }: {
+    bins: PreBaseCoverageBin[];
+    feature: Feature;
+    region: Region;
+    regionSequence: string;
+}): void;

package/dist/SNPCoverageAdapter/processReferenceCpGs.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processReferenceCpGs = processReferenceCpGs;
+const util_1 = require("@jbrowse/core/util");
+const MismatchParser_1 = require("../MismatchParser");
+const ModificationParser_1 = require("../ModificationParser");
+const util_2 = require("./util");
+function processReferenceCpGs({ feature, region, bins, regionSequence, }) {
+    var _a;
+    const fstart = feature.get('start');
+    const fend = feature.get('end');
+    const fstrand = feature.get('strand');
+    const seq = feature.get('seq');
+    const mismatches = (_a = feature.get('mismatches')) !== null && _a !== void 0 ? _a : [];
+    const r = regionSequence.toLowerCase();
+    if (seq) {
+        const cigarOps = (0, MismatchParser_1.parseCigar)(feature.get('CIGAR'));
+        const { methBins, methProbs } = (0, ModificationParser_1.getMethBins)(feature, cigarOps);
+        const dels = mismatches.filter(f => f.type === 'deletion');
+        for (let i = 0; i < fend - fstart; i++) {
+            const j = i + fstart;
+            const l1 = r[j - region.start + 1];
+            const l2 = r[j - region.start + 2];
+            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];
+                if ((b0 && (p0 !== undefined ? p0 > 0.5 : true)) ||
+                    (b1 && (p1 !== undefined ? p1 > 0.5 : true))) {
+                    if (bin0) {
+                        (0, util_2.incWithProbabilities)(bin0, fstrand, 'mods', 'cpg_meth', p0 || 0);
+                        bin0.ref.entryDepth--;
+                        bin0.ref[fstrand]--;
+                    }
+                    if (bin1) {
+                        (0, util_2.incWithProbabilities)(bin1, fstrand, 'mods', 'cpg_meth', p1 || 0);
+                        bin1.ref.entryDepth--;
+                        bin1.ref[fstrand]--;
+                    }
+                }
+                else {
+                    if (bin0) {
+                        if (!dels.some(d => (0, util_1.doesIntersect2)(j, j + 1, d.start + fstart, d.start + fstart + d.length))) {
+                            (0, util_2.incWithProbabilities)(bin0, fstrand, 'nonmods', 'cpg_unmeth', 1 - (p0 || 0));
+                            bin0.ref.entryDepth--;
+                            bin0.ref[fstrand]--;
+                        }
+                    }
+                    if (bin1) {
+                        if (!dels.some(d => (0, util_1.doesIntersect2)(j + 1, j + 2, d.start + fstart, d.start + fstart + d.length))) {
+                            (0, util_2.incWithProbabilities)(bin1, fstrand, 'nonmods', 'cpg_unmeth', 1 - (p1 || 0));
+                            bin1.ref.entryDepth--;
+                            bin1.ref[fstrand]--;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/SNPCoverageAdapter/util.d.ts

@@ -1,25 +1,10 @@
-export type SkipMap = Record<string, {
-    score: number;
-    feature: unknown;
-    start: number;
-    end: number;
-    strand: number;
-    xs: string;
-}>;
-export interface BinType {
-    total?: number;
-    strands?: Record<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;
+import type { ColorBy, Mismatch, PreBaseCoverageBin, PreBaseCoverageBinSubtypes } from '../shared/types';
+export interface Opts {
+    bpPerPx?: number;
+    colorBy?: ColorBy;
+    stopToken?: string;
 }
+export declare function mismatchLen(mismatch: Mismatch): number;
+export declare function isInterbase(type: string): type is "insertion" | "hardclip" | "softclip";
+export declare function inc(bin: PreBaseCoverageBin, strand: -1 | 0 | 1, type: keyof PreBaseCoverageBinSubtypes, field: string): void;
+export declare function incWithProbabilities(bin: PreBaseCoverageBin, strand: -1 | 0 | 1, type: keyof PreBaseCoverageBinSubtypes, field: string, probability: number): void;

package/dist/SNPCoverageAdapter/util.js

@@ -1,2 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mismatchLen = mismatchLen;
+exports.isInterbase = isInterbase;
+exports.inc = inc;
+exports.incWithProbabilities = incWithProbabilities;
+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] = {
+            entryDepth: 0,
+            probabilities: [],
+            '-1': 0,
+            '0': 0,
+            '1': 0,
+        };
+    }
+    thisBin.entryDepth++;
+    thisBin[strand]++;
+}
+function incWithProbabilities(bin, strand, type, field, probability) {
+    let thisBin = bin[type][field];
+    if (thisBin === undefined) {
+        thisBin = bin[type][field] = {
+            entryDepth: 0,
+            probabilities: [],
+            '-1': 0,
+            '0': 0,
+            '1': 0,
+        };
+    }
+    thisBin.entryDepth++;
+    thisBin.probabilities.push(probability);
+    thisBin[strand]++;
+}

package/dist/SNPCoverageRenderer/SNPCoverageRenderer.d.ts

@@ -1,6 +1,8 @@
-import { Feature } from '@jbrowse/core/util';
-import { RenderArgsDeserialized as FeatureRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
-import { ScaleOpts, WiggleBaseRenderer } from '@jbrowse/plugin-wiggle';
+import { WiggleBaseRenderer } from '@jbrowse/plugin-wiggle';
+import type { ModificationTypeWithColor } from '../shared/types';
+import type { RenderArgsDeserialized as FeatureRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
+import type { Feature } from '@jbrowse/core/util';
+import type { ScaleOpts } from '@jbrowse/plugin-wiggle';
 export interface RenderArgsDeserialized extends FeatureRenderArgsDeserialized {
     bpPerPx: number;
     height: number;
@@ -13,7 +15,7 @@ export interface RenderArgsDeserializedWithFeatures extends RenderArgsDeserializ
         values: number[];
     };
     displayCrossHatches: boolean;
-    modificationTagMap?: Record<string, string>;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
 }
 export default class SNPCoverageRenderer extends WiggleBaseRenderer {
     draw(ctx: CanvasRenderingContext2D, props: RenderArgsDeserializedWithFeatures): Promise<undefined>;