@jbrowse/plugin-alignments 2.16.0 → 2.17.0

package/dist/SNPCoverageRenderer/SNPCoverageRenderer.js

@@ -4,12 +4,26 @@ const ui_1 = require("@jbrowse/core/ui");
 const util_1 = require("@jbrowse/core/util");
 const configuration_1 = require("@jbrowse/core/configuration");
 const plugin_wiggle_1 = require("@jbrowse/plugin-wiggle");
+const util_2 = require("../shared/util");
+// width/height of the triangle above e.g. insertion indicators
+const INTERBASE_INDICATOR_WIDTH = 7;
+const INTERBASE_INDICATOR_HEIGHT = 4.5;
+// minimum read depth to draw the insertion indicators, below this the
+// 'statistical significance' is low
+const MINIMUM_INTERBASE_INDICATOR_READ_DEPTH = 7;
+const complementBase = {
+    C: 'G',
+    G: 'C',
+    A: 'T',
+    T: 'A',
+};
 const fudgeFactor = 0.6;
 class SNPCoverageRenderer extends plugin_wiggle_1.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, props) {
-        const { features, regions, bpPerPx, displayCrossHatches, modificationTagMap = {}, scaleOpts, height: unadjustedHeight, theme: configTheme, config: cfg, ticks, } = props;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const { features, regions, bpPerPx, colorBy, displayCrossHatches, visibleModifications = {}, scaleOpts, height: unadjustedHeight, theme: configTheme, config: cfg, ticks, } = props;
         const theme = (0, ui_1.createJBrowseTheme)(configTheme);
         const region = regions[0];
         const width = (region.end - region.start) / bpPerPx;
@@ -48,16 +62,18 @@ class SNPCoverageRenderer extends plugin_wiggle_1.WiggleBaseRenderer {
             softclip: 'blue',
             hardclip: 'red',
             total: (0, configuration_1.readConfObject)(cfg, 'color'),
-            meth: 'red',
-            unmeth: 'blue',
+            mod_NONE: 'blue',
+            cpg_meth: 'red',
+            cpg_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 (const feature of coverage) {
+        for (const feature of feats) {
+            if (feature.get('type') === 'skip') {
+                continue;
+            }
             const [leftPx, rightPx] = (0, util_1.featureSpanPx)(feature, region, bpPerPx);
             const w = rightPx - leftPx + fudgeFactor;
             const score = feature.get('score');
@@ -65,45 +81,148 @@ class SNPCoverageRenderer extends plugin_wiggle_1.WiggleBaseRenderer {
         }
         // 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"
+        // 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;
+        // @ts-expect-error
+        const drawingModifications = (colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'modifications';
+        // @ts-expect-error
+        const drawingMethylation = (colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'methylation';
+        const isolatedModification = 
+        // @ts-expect-error
+        (_a = colorBy === null || colorBy === void 0 ? void 0 : colorBy.modifications) === null || _a === void 0 ? void 0 : _a.isolatedModification;
         // 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 (const feature of coverage) {
+        for (const feature of feats) {
+            if (feature.get('type') === 'skip') {
+                continue;
+            }
             const [leftPx, rightPx] = (0, util_1.featureSpanPx)(feature, region, bpPerPx);
-            const score = feature.get('score');
             const snpinfo = feature.get('snpinfo');
             const w = Math.max(rightPx - leftPx, 1);
-            const totalScore = snpinfo.total;
-            const keys = Object.keys(snpinfo.cov).sort();
-            let curr = 0;
-            for (const base of keys) {
-                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 score0 = feature.get('score');
+            if (drawingModifications) {
+                let curr = 0;
+                const refbase = (_b = snpinfo.refbase) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+                const { nonmods, mods, snps, ref } = snpinfo;
+                for (const m of Object.keys(nonmods).sort().reverse()) {
+                    const mod = visibleModifications[m.replace('nonmod_', '')] ||
+                        visibleModifications[m.replace('mod_', '')];
+                    if (!mod) {
+                        console.warn(`${m} not known yet`);
+                        continue;
+                    }
+                    if (isolatedModification && mod.type !== isolatedModification) {
+                        continue;
+                    }
+                    const cmp = complementBase[mod.base];
+                    // this approach is inspired from the 'simplex' approach in igv
+                    // https://github.com/igvteam/igv/blob/af07c3b1be8806cfd77343ee04982aeff17d2beb/src/main/java/org/broad/igv/sam/mods/BaseModificationCoverageRenderer.java#L51
+                    const detectable = mod.base === 'N'
+                        ? score0
+                        : (((_c = snps[mod.base]) === null || _c === void 0 ? void 0 : _c.entryDepth) || 0) +
+                            (((_d = snps[cmp]) === null || _d === void 0 ? void 0 : _d.entryDepth) || 0) +
+                            (refbase === mod.base ? ref['1'] : 0) +
+                            (refbase === cmp ? ref['-1'] : 0);
+                    const modifiable = mod.base === 'N'
+                        ? score0
+                        : (((_e = snps[mod.base]) === null || _e === void 0 ? void 0 : _e.entryDepth) || 0) +
+                            (((_f = snps[cmp]) === null || _f === void 0 ? void 0 : _f.entryDepth) || 0) +
+                            (refbase === mod.base ? ref.entryDepth : 0) +
+                            (refbase === cmp ? ref.entryDepth : 0);
+                    const { entryDepth, avgProbability = 0 } = snpinfo.nonmods[m];
+                    const modFraction = (modifiable / score0) * (entryDepth / detectable);
+                    const nonModColor = 'blue';
+                    const c = (0, util_2.alphaColor)(nonModColor, avgProbability);
+                    const height = toHeight(score0);
+                    const bottom = toY(score0) + height;
+                    ctx.fillStyle = c;
+                    ctx.fillRect(Math.round(leftPx), bottom - (curr + modFraction * height), w, modFraction * height);
+                    curr += modFraction * height;
+                }
+                for (const m of Object.keys(mods).sort().reverse()) {
+                    const mod = visibleModifications[m.replace('mod_', '')];
+                    if (!mod) {
+                        console.warn(`${m} not known yet`);
+                        continue;
+                    }
+                    if (isolatedModification && mod.type !== isolatedModification) {
+                        continue;
+                    }
+                    const cmp = complementBase[mod.base];
+                    // this approach is inspired from the 'simplex' approach in igv
+                    // https://github.com/igvteam/igv/blob/af07c3b1be8806cfd77343ee04982aeff17d2beb/src/main/java/org/broad/igv/sam/mods/BaseModificationCoverageRenderer.java#L51
+                    const detectable = mod.base === 'N'
+                        ? score0
+                        : (((_g = snps[mod.base]) === null || _g === void 0 ? void 0 : _g.entryDepth) || 0) +
+                            (((_h = snps[cmp]) === null || _h === void 0 ? void 0 : _h.entryDepth) || 0) +
+                            (refbase === mod.base ? ref['1'] : 0) +
+                            (refbase === cmp ? ref['-1'] : 0);
+                    const modifiable = mod.base === 'N'
+                        ? score0
+                        : (((_j = snps[mod.base]) === null || _j === void 0 ? void 0 : _j.entryDepth) || 0) +
+                            (((_k = snps[cmp]) === null || _k === void 0 ? void 0 : _k.entryDepth) || 0) +
+                            (refbase === mod.base ? ref.entryDepth : 0) +
+                            (refbase === cmp ? ref.entryDepth : 0);
+                    const { entryDepth, avgProbability = 0 } = mods[m];
+                    const modFraction = (modifiable / score0) * (entryDepth / detectable);
+                    const baseColor = mod.color || 'black';
+                    const c = (0, util_2.alphaColor)(baseColor, avgProbability);
+                    const height = toHeight(score0);
+                    const bottom = toY(score0) + height;
+                    ctx.fillStyle = c;
+                    ctx.fillRect(Math.round(leftPx), bottom - (curr + modFraction * height), w, modFraction * height);
+                    curr += modFraction * height;
+                }
+            }
+            else if (drawingMethylation) {
+                const { depth, nonmods, mods } = snpinfo;
+                let curr = 0;
+                for (const base of Object.keys(mods).sort().reverse()) {
+                    const { entryDepth } = mods[base];
+                    const height = toHeight(score0);
+                    const bottom = toY(score0) + height;
+                    ctx.fillStyle = colorForBase[base] || 'black';
+                    ctx.fillRect(Math.round(leftPx), bottom - ((entryDepth + curr) / depth) * height, w, (entryDepth / depth) * height);
+                    curr += entryDepth;
+                }
+                for (const base of Object.keys(nonmods).sort().reverse()) {
+                    const { entryDepth } = nonmods[base];
+                    const height = toHeight(score0);
+                    const bottom = toY(score0) + height;
+                    ctx.fillStyle = colorForBase[base] || 'black';
+                    ctx.fillRect(Math.round(leftPx), bottom - ((entryDepth + curr) / depth) * height, w, (entryDepth / depth) * height);
+                    curr += entryDepth;
+                }
+            }
+            else {
+                const { depth, snps } = snpinfo;
+                let curr = 0;
+                for (const base of Object.keys(snps).sort().reverse()) {
+                    const { entryDepth } = snps[base];
+                    const height = toHeight(score0);
+                    const bottom = toY(score0) + height;
+                    ctx.fillStyle = colorForBase[base] || 'black';
+                    ctx.fillRect(Math.round(leftPx), bottom - ((entryDepth + curr) / depth) * height, w, (entryDepth / depth) * height);
+                    curr += entryDepth;
+                }
             }
             const interbaseEvents = Object.keys(snpinfo.noncov);
-            const indicatorHeight = 4.5;
             if (drawInterbaseCounts) {
                 let curr = 0;
                 for (const base of interbaseEvents) {
-                    const { total } = snpinfo.noncov[base];
+                    const { entryDepth } = 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;
+                    ctx.fillRect(leftPx - r + extraHorizontallyFlippedOffset, INTERBASE_INDICATOR_HEIGHT + toHeight2(curr), r * 2, toHeight2(entryDepth));
+                    curr += entryDepth;
                 }
             }
             if (drawIndicators) {
@@ -111,48 +230,46 @@ class SNPCoverageRenderer extends plugin_wiggle_1.WiggleBaseRenderer {
                 let max = 0;
                 let maxBase = '';
                 for (const base of interbaseEvents) {
-                    const { total } = snpinfo.noncov[base];
-                    accum += total;
-                    if (total > max) {
-                        max = total;
+                    const { entryDepth } = snpinfo.noncov[base];
+                    accum += entryDepth;
+                    if (entryDepth > max) {
+                        max = entryDepth;
                         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);
+                // avoid drawing a bunch of indicators if coverage is very low. note:
+                // also uses the prev total in the case of the "cliff"
+                const indicatorComparatorScore = Math.max(score0, prevTotal);
                 if (accum > indicatorComparatorScore * indicatorThreshold &&
-                    indicatorComparatorScore > 7) {
+                    indicatorComparatorScore > MINIMUM_INTERBASE_INDICATOR_READ_DEPTH) {
                     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.moveTo(l - INTERBASE_INDICATOR_WIDTH / 2, 0);
+                    ctx.lineTo(l + INTERBASE_INDICATOR_WIDTH / 2, 0);
+                    ctx.lineTo(l, INTERBASE_INDICATOR_HEIGHT);
                     ctx.fill();
                 }
             }
-            prevTotal = totalScore;
+            prevTotal = score0;
         }
         if (drawArcs) {
-            for (const f of skips) {
-                const [left, right] = (0, util_1.bpSpanPx)(f.get('start'), f.get('end'), region, bpPerPx);
+            for (const f of feats) {
+                if (f.get('type') !== 'skip') {
+                    continue;
+                }
+                const s = f.get('start');
+                const e = f.get('end');
+                const [left, right] = (0, util_1.bpSpanPx)(s, e, region, bpPerPx);
                 ctx.beginPath();
-                const str = f.get('strand');
-                const xs = f.get('xs');
+                const effectiveStrand = f.get('effectiveStrand');
                 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 === '+') {
+                if (effectiveStrand === 1) {
                     ctx.strokeStyle = pos;
                 }
-                else if (xs === '-') {
-                    ctx.strokeStyle = neg;
-                }
-                else if (str === 1) {
-                    ctx.strokeStyle = pos;
-                }
-                else if (str === -1) {
+                else if (effectiveStrand === -1) {
                     ctx.strokeStyle = neg;
                 }
                 else {
@@ -167,12 +284,12 @@ class SNPCoverageRenderer extends plugin_wiggle_1.WiggleBaseRenderer {
         if (displayCrossHatches) {
             ctx.lineWidth = 1;
             ctx.strokeStyle = 'rgba(140,140,140,0.8)';
-            ticks.values.forEach(tick => {
+            for (const tick of ticks.values) {
                 ctx.beginPath();
                 ctx.moveTo(0, Math.round(toY(tick)));
                 ctx.lineTo(width, Math.round(toY(tick)));
                 ctx.stroke();
-            });
+            }
         }
         return undefined;
     }

package/dist/shared/color.d.ts

@@ -1,4 +1,3 @@
-import { Instance } from 'mobx-state-tree';
 import { ChainStats } from './fetchChains';
 export declare const fillColor: {
     color_fwd_strand_not_proper: string;
@@ -57,12 +56,3 @@ export declare function getPairedOrientationColorOrDefault(f: {
 export declare function getPairedOrientationColor(f: {
     pair_orientation?: string;
 }): readonly [string, string];
-export interface ExtraColorBy {
-    custom?: Record<string, string>;
-}
-export declare const ColorByModel: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IModelType<{
-    type: import("mobx-state-tree").ISimpleType<string>;
-    tag: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    extra: import("mobx-state-tree").IType<any, any, any>;
-}, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-export type IColorByModel = Instance<typeof ColorByModel>;

package/dist/shared/color.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColorByModel = exports.strokeColor = exports.fillColor = void 0;
+exports.strokeColor = exports.fillColor = void 0;
 exports.getPairedInsertSizeColor = getPairedInsertSizeColor;
 exports.getPairedInsertSizeAndOrientationColor = getPairedInsertSizeAndOrientationColor;
 exports.getPairedOrientationColorOrDefault = getPairedOrientationColorOrDefault;
 exports.getPairedOrientationColor = getPairedOrientationColor;
-const mobx_state_tree_1 = require("mobx-state-tree");
 const util_1 = require("../util");
 exports.fillColor = {
     color_fwd_strand_not_proper: '#ECC8C8',
@@ -86,8 +85,3 @@ function getPairedOrientationColorOrDefault(f) {
 function getPairedOrientationColor(f) {
     return getPairedOrientationColorOrDefault(f) || defaultColor;
 }
-exports.ColorByModel = mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.model({
-    type: mobx_state_tree_1.types.string,
-    tag: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-    extra: mobx_state_tree_1.types.frozen(),
-}));

package/{esm/shared → dist/shared/components}/BaseDisplayComponent.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { LinearReadCloudDisplayModel } from '../LinearReadCloudDisplay/model';
-import { LinearReadArcsDisplayModel } from '../LinearReadArcsDisplay/model';
+import { LinearReadCloudDisplayModel } from '../../LinearReadCloudDisplay/model';
+import { LinearReadArcsDisplayModel } from '../../LinearReadArcsDisplay/model';
 declare const BaseDisplayComponent: ({ model, children, }: {
     model: LinearReadArcsDisplayModel | LinearReadCloudDisplayModel;
     children?: React.ReactNode;

package/{esm/shared → dist/shared/components}/FilterByTagDialog.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import { IFilter } from '.';
+import { FilterBy } from '../types';
 declare const FilterByTagDialog: (props: {
     model: {
-        filterBy: IFilter;
-        setFilterBy: (arg: IFilter) => void;
+        filterBy: FilterBy;
+        setFilterBy: (arg: FilterBy) => void;
     };
     handleClose: () => void;
 }) => React.JSX.Element;

package/dist/shared/{FilterByTagDialog.js → components/FilterByTagDialog.js}

@@ -103,7 +103,11 @@ const FilterByTagDialog = (0, mobx_react_1.observer)(function (props) {
                 react_1.default.createElement(material_1.Typography, null, "Filter by tag name and value. Use * in the value field to get all reads containing any value for that tag. Example: filter tag name SA with value * to get all split/supplementary reads. Other examples include HP for haplotype, or RG for read group"),
                 react_1.default.createElement(material_1.TextField, { className: classes.field, value: tag, onChange: event => {
                         setTag(event.target.value);
-                    }, placeholder: "Enter tag name", inputProps: { maxLength: 2 }, error: tag.length === 2 && !validTag, helperText: tag.length === 2 && !validTag ? 'Not a valid tag' : '' }),
+                    }, placeholder: "Enter tag name", error: tag.length === 2 && !validTag, helperText: tag.length === 2 && !validTag ? 'Not a valid tag' : '', slotProps: {
+                        htmlInput: {
+                            maxLength: 2,
+                        },
+                    } }),
                 react_1.default.createElement(material_1.TextField, { className: classes.field, value: tagValue, onChange: event => {
                         setTagValue(event.target.value);
                     }, placeholder: "Enter tag value" })),

package/dist/shared/fetchChains.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchChains = fetchChains;
 const util_1 = require("@jbrowse/core/util");
-const mobx_state_tree_1 = require("mobx-state-tree");
 async function fetchChains(self) {
     // @ts-expect-error
     const { rpcSessionId: sessionId } = (0, util_1.getContainingTrack)(self);
@@ -15,7 +14,7 @@ async function fetchChains(self) {
     const ret = (await rpcManager.call(sessionId, 'PileupGetReducedFeatures', {
         sessionId,
         regions: view.staticBlocks.contentBlocks,
-        filterBy: (0, mobx_state_tree_1.getSnapshot)(self.filterBy),
+        filterBy: self.filterBy,
         adapterConfig: self.adapterConfig,
     }));
     self.setChainData(ret);

package/dist/shared/getMaximumModificationAtEachPosition.d.ts

@@ -0,0 +1,8 @@
+import { Feature } from '@jbrowse/core/util';
+interface MaximumProbabilityMod {
+    type: string;
+    prob: number;
+    allProbs: number[];
+}
+export declare function getMaxProbModAtEachPosition(feature: Feature, cigarOps?: string[]): MaximumProbabilityMod[] | undefined;
+export {};

package/dist/shared/getMaximumModificationAtEachPosition.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxProbModAtEachPosition = getMaxProbModAtEachPosition;
+// locals
+const ModificationParser_1 = require("../ModificationParser");
+const MismatchParser_1 = require("../MismatchParser");
+const util_1 = require("../util");
+function getMaxProbModAtEachPosition(feature, cigarOps) {
+    const fstrand = feature.get('strand');
+    const seq = feature.get('seq');
+    const mm = (0, util_1.getTagAlt)(feature, 'MM', 'Mm') || '';
+    const ops = cigarOps || (0, MismatchParser_1.parseCigar)(feature.get('CIGAR'));
+    if (seq) {
+        const modifications = (0, ModificationParser_1.getModPositions)(mm, seq, fstrand);
+        const probabilities = (0, ModificationParser_1.getModProbabilities)(feature);
+        const maxProbModForPosition = [];
+        let probIndex = 0;
+        for (const { type, positions } of modifications) {
+            for (const { ref, idx } of (0, MismatchParser_1.getNextRefPos)(ops, positions)) {
+                const prob = (probabilities === null || probabilities === void 0 ? void 0 : probabilities[probIndex + (fstrand === -1 ? positions.length - 1 - idx : idx)]) || 0;
+                if (!maxProbModForPosition[ref]) {
+                    maxProbModForPosition[ref] = {
+                        type,
+                        prob,
+                        allProbs: [prob],
+                    };
+                }
+                else {
+                    const old = maxProbModForPosition[ref];
+                    maxProbModForPosition[ref] = {
+                        allProbs: [...old.allProbs, prob],
+                        prob: Math.max(old.prob, prob),
+                        type: old.prob > prob ? old.type : type,
+                    };
+                }
+            }
+            probIndex += positions.length;
+        }
+        return maxProbModForPosition;
+    }
+    return undefined;
+}

package/dist/shared/getUniqueModifications.d.ts

@@ -0,0 +1,14 @@
+import { IAnyStateTreeNode } from 'mobx-state-tree';
+import { BlockSet } from '@jbrowse/core/util/blockTypes';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import { ModificationType } from './types';
+export declare function getUniqueModifications({ self, adapterConfig, blocks, opts, }: {
+    self: IAnyStateTreeNode;
+    adapterConfig: AnyConfigurationModel;
+    blocks: BlockSet;
+    opts?: {
+        headers?: Record<string, string>;
+        signal?: AbortSignal;
+        filters: string[];
+    };
+}): Promise<ModificationType[]>;

package/dist/shared/getUniqueModifications.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueModifications = getUniqueModifications;
+const util_1 = require("@jbrowse/core/util");
+const tracks_1 = require("@jbrowse/core/util/tracks");
+async function getUniqueModifications({ self, adapterConfig, blocks, opts, }) {
+    const { rpcManager } = (0, util_1.getSession)(self);
+    const sessionId = (0, tracks_1.getRpcSessionId)(self);
+    const values = await rpcManager.call(sessionId, 'PileupGetVisibleModifications', {
+        adapterConfig,
+        sessionId,
+        regions: blocks.contentBlocks,
+        ...opts,
+    });
+    return values;
+}

package/dist/shared/getUniqueTags.d.ts

@@ -0,0 +1,15 @@
+import { IAnyStateTreeNode } from 'mobx-state-tree';
+import { BlockSet } from '@jbrowse/core/util/blockTypes';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+export declare function getUniqueTags({ self, tag, blocks, opts, }: {
+    self: IAnyStateTreeNode & {
+        adapterConfig: AnyConfigurationModel;
+    };
+    tag: string;
+    blocks: BlockSet;
+    opts?: {
+        headers?: Record<string, string>;
+        signal?: AbortSignal;
+        filters: string[];
+    };
+}): Promise<string[]>;

package/dist/shared/getUniqueTags.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueTags = getUniqueTags;
+const util_1 = require("@jbrowse/core/util");
+const tracks_1 = require("@jbrowse/core/util/tracks");
+async function getUniqueTags({ self, tag, blocks, opts, }) {
+    const { rpcManager } = (0, util_1.getSession)(self);
+    const { adapterConfig } = self;
+    const sessionId = (0, tracks_1.getRpcSessionId)(self);
+    const values = await rpcManager.call((0, tracks_1.getRpcSessionId)(self), 'PileupGetGlobalValueForTag', {
+        adapterConfig,
+        tag,
+        sessionId,
+        regions: blocks.contentBlocks,
+        ...opts,
+    });
+    return values;
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,94 @@
+export type SkipMap = Record<string, {
+    score: number;
+    feature: unknown;
+    start: number;
+    end: number;
+    strand: number;
+    effectiveStrand: number;
+}>;
+export interface BinEntry {
+    entryDepth: number;
+    '-1': number;
+    '0': number;
+    '1': number;
+    avgProbability?: number;
+}
+type BinType = Record<string, BinEntry>;
+export interface BaseCoverageBin {
+    refbase?: string;
+    depth: number;
+    readsCounted: number;
+    ref: BinEntry;
+    snps: BinType;
+    mods: BinType;
+    nonmods: BinType;
+    delskips: BinType;
+    noncov: BinType;
+}
+export interface PreBinEntry {
+    entryDepth: number;
+    '-1': number;
+    '0': number;
+    '1': number;
+    probabilities: number[];
+}
+type PreBinType = Record<string, PreBinEntry>;
+export interface PreBaseCoverageBin extends PreBaseCoverageBinSubtypes {
+    refbase?: string;
+    depth: number;
+    readsCounted: number;
+    ref: PreBinEntry;
+}
+export interface PreBaseCoverageBinSubtypes {
+    snps: PreBinType;
+    mods: PreBinType;
+    nonmods: PreBinType;
+    delskips: PreBinType;
+    noncov: PreBinType;
+}
+export interface ModificationType {
+    type: string;
+    base: string;
+    strand: string;
+}
+export interface ModificationTypeWithColor {
+    color: string;
+    type: string;
+    base: string;
+    strand: string;
+}
+export interface ColorBy {
+    type: string;
+    tag?: string;
+    modifications?: {
+        twoColor?: boolean;
+        isolatedModification?: string;
+    };
+}
+export interface FilterBy {
+    flagExclude: number;
+    flagInclude: number;
+    readName?: string;
+    tagFilter?: {
+        tag: string;
+        value?: string;
+    };
+}
+export interface SortedBy {
+    type: string;
+    pos: number;
+    refName: string;
+    assemblyName: string;
+    tag?: string;
+}
+export interface Mismatch {
+    qual?: number;
+    start: number;
+    length: number;
+    type: string;
+    base: string;
+    altbase?: string;
+    seq?: string;
+    cliplen?: number;
+}
+export {};

package/dist/shared/util.d.ts

@@ -1,2 +1,10 @@
 import { ChainData } from './fetchChains';
 export declare function hasPairedReads(features: ChainData): boolean;
+export declare function alphaColor(baseColor: string, p: number): string;
+export declare const defaultFilterFlags: {
+    flagInclude: number;
+    flagExclude: number;
+};
+export declare function cacheGetter<T>(ctor: {
+    prototype: T;
+}, prop: keyof T): void;