@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/SNPCoverageAdapter/SNPCoverageAdapter.js

@@ -1,66 +1,148 @@
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { aggregateQuantitativeStats, blankStats, } from '@jbrowse/core/data_adapters/BaseAdapter/stats';
+import QuickLRU from '@jbrowse/core/util/QuickLRU';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
+import { rectifyStats } from '@jbrowse/core/util/stats';
 import { firstValueFrom } from 'rxjs';
 import { toArray } from 'rxjs/operators';
-import { fetchSequence } from '../util';
-import { generateCoverageBins } from './generateCoverageBins';
+import { fetchSequence } from "../util.js";
+import { finalizeLazyBin, generateCoverageBinsPrefixSum, } from "./generateCoverageBinsPrefixSum.js";
+function makeFilterByKey(filterBy) {
+    return filterBy
+        ? `${filterBy.flagExclude}|${filterBy.flagInclude}|${filterBy.readName ?? ''}|${filterBy.tagFilter?.tag ?? ''}|${filterBy.tagFilter?.value ?? ''}`
+        : '';
+}
+function makeRegionFilterKey(region, opts) {
+    return `${region.refName}:${region.start}-${region.end}|${makeFilterByKey(opts.filterBy)}|${opts.trackInstanceId || ''}`;
+}
+function makeCacheKey(region, opts) {
+    const { colorBy } = opts;
+    const colorByKey = colorBy
+        ? `${colorBy.type}|${colorBy.tag ?? ''}|${colorBy.modifications?.twoColor ?? ''}|${colorBy.modifications?.isolatedModification ?? ''}|${colorBy.modifications?.threshold ?? ''}`
+        : '';
+    return `${makeRegionFilterKey(region, opts)}|${colorByKey}`;
+}
+function computeStatsFromBins(result, targetStart, targetEnd) {
+    const { bins, regionStart } = result;
+    let scoreMin = Number.MAX_VALUE;
+    let scoreMax = Number.MIN_VALUE;
+    let scoreSum = 0;
+    let scoreSumSquares = 0;
+    let featureCount = 0;
+    for (let i = 0, l = bins.length; i < l; i++) {
+        const bin = bins[i];
+        if (bin) {
+            const pos = regionStart + i;
+            if (pos >= targetStart && pos < targetEnd) {
+                const score = bin.depth;
+                scoreMin = Math.min(scoreMin, score);
+                scoreMax = Math.max(scoreMax, score);
+                scoreSum += score;
+                scoreSumSquares += score * score;
+                featureCount++;
+            }
+        }
+    }
+    return {
+        scoreMin: featureCount > 0 ? scoreMin : 0,
+        scoreMax: featureCount > 0 ? scoreMax : 0,
+        scoreSum,
+        scoreSumSquares,
+        featureCount,
+        basesCovered: featureCount,
+    };
+}
 export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
+    sequenceAdapterP;
+    subadapterRef;
+    cache = new QuickLRU({
+        maxSize: 50,
+        maxAge: 5 * 60 * 1000,
+    });
+    lastBpPerPx;
+    setSequenceAdapterConfig(config) {
+        super.setSequenceAdapterConfig(config);
+        if (this.subadapterRef) {
+            this.subadapterRef.setSequenceAdapterConfig(config);
+        }
+    }
     async configure() {
-        var _a, _b;
-        const subadapterConfig = this.getConf('subadapter');
-        const sequenceConf = subadapterConfig.sequenceAdapter;
-        const dataAdapter = await ((_a = this.getSubAdapter) === null || _a === void 0 ? void 0 : _a.call(this, subadapterConfig));
-        const sequenceAdapter = sequenceConf
-            ? await ((_b = this.getSubAdapter) === null || _b === void 0 ? void 0 : _b.call(this, sequenceConf))
-            : undefined;
+        const subadapterConfigBase = this.getConf('subadapter');
+        this.sequenceAdapterConfig ??= this.getConf('sequenceAdapter');
+        const dataAdapter = await this.getSubAdapter?.(subadapterConfigBase);
         if (!dataAdapter) {
             throw new Error('Failed to get subadapter');
         }
-        return {
-            subadapter: dataAdapter.dataAdapter,
-            sequenceAdapter: sequenceAdapter === null || sequenceAdapter === void 0 ? void 0 : sequenceAdapter.dataAdapter,
-        };
+        const subadapter = dataAdapter.dataAdapter;
+        this.subadapterRef = subadapter;
+        if (this.sequenceAdapterConfig) {
+            subadapter.setSequenceAdapterConfig(this.sequenceAdapterConfig);
+        }
+        return { subadapter };
     }
-    async fetchSequence(region) {
-        const { sequenceAdapter } = await this.configure();
-        if (!sequenceAdapter) {
+    async getSequenceAdapter() {
+        const config = this.sequenceAdapterConfig ?? this.getConf('sequenceAdapter');
+        if (!config || !this.getSubAdapter) {
             return undefined;
         }
-        return fetchSequence(region, sequenceAdapter);
+        this.sequenceAdapterP ??= this.getSubAdapter(config)
+            .then(r => {
+            const adapter = r.dataAdapter;
+            return 'getSequence' in adapter ? adapter : undefined;
+        })
+            .catch((e) => {
+            this.sequenceAdapterP = undefined;
+            throw e;
+        });
+        return this.sequenceAdapterP;
     }
     getFeatures(region, opts = {}) {
         return ObservableCreate(async (observer) => {
-            const { subadapter } = await this.configure();
-            const features = await firstValueFrom(subadapter.getFeatures(region, opts).pipe(toArray()));
-            const { bins, skipmap } = await generateCoverageBins({
-                features,
-                region,
-                opts,
-                fetchSequence: (region) => this.fetchSequence(region),
-            });
-            let index = 0;
-            for (const bin of bins) {
+            const { bins, regionStart, skipmap } = await this.getCoverageBins(region, opts);
+            const { refName } = region;
+            const adapterId = this.id;
+            for (let i = 0, l = bins.length; i < l; i++) {
+                const bin = bins[i];
                 if (bin) {
-                    const start = region.start + index;
-                    observer.next(new SimpleFeature({
-                        id: `${this.id}-${start}`,
-                        data: {
-                            score: bin.depth,
-                            snpinfo: bin,
+                    const start = regionStart + i;
+                    const snpinfo = finalizeLazyBin(bin);
+                    const score = bin.depth;
+                    observer.next({
+                        get: (field) => {
+                            switch (field) {
+                                case 'start':
+                                    return start;
+                                case 'end':
+                                    return start + 1;
+                                case 'score':
+                                    return score;
+                                case 'snpinfo':
+                                    return snpinfo;
+                                case 'refName':
+                                    return refName;
+                                default:
+                                    return undefined;
+                            }
+                        },
+                        id: () => `${adapterId}-${start}`,
+                        toJSON: () => ({
+                            uniqueId: `${adapterId}-${start}`,
                             start,
                             end: start + 1,
-                            refName: region.refName,
-                        },
-                    }));
+                            score,
+                            snpinfo,
+                            refName,
+                        }),
+                    });
                 }
-                index++;
             }
             for (const [key, skip] of Object.entries(skipmap)) {
                 observer.next(new SimpleFeature({
                     id: key,
                     data: {
                         type: 'skip',
+                        refName,
                         start: skip.start,
                         end: skip.end,
                         strand: skip.strand,
@@ -72,12 +154,98 @@ export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
             observer.complete();
         }, opts.stopToken);
     }
+    async getCoverageBins(region, opts = {}) {
+        const { bpPerPx, statsEstimationMode } = opts;
+        if (this.lastBpPerPx !== undefined && this.lastBpPerPx !== bpPerPx) {
+            this.cache.clear();
+        }
+        this.lastBpPerPx = bpPerPx;
+        if (statsEstimationMode) {
+            const regionFilterKey = makeRegionFilterKey(region, opts);
+            for (const key of this.cache.keys()) {
+                if (key.startsWith(`${regionFilterKey}|`)) {
+                    const cached = this.cache.get(key);
+                    if (cached) {
+                        return cached;
+                    }
+                }
+            }
+            const { subadapter } = await this.configure();
+            const features = await firstValueFrom(subadapter.getFeatures(region, opts).pipe(toArray()));
+            const result = await generateCoverageBinsPrefixSum({
+                features: features,
+                region,
+                opts,
+            });
+            const statsKey = `${regionFilterKey}|`;
+            this.cache.set(statsKey, result);
+            return result;
+        }
+        const cacheKey = makeCacheKey(region, opts);
+        const cached = this.cache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const { subadapter } = await this.configure();
+        const sequenceAdapter = await this.getSequenceAdapter();
+        const features = await firstValueFrom(subadapter.getFeatures(region, opts).pipe(toArray()));
+        const result = await generateCoverageBinsPrefixSum({
+            features: features,
+            region,
+            opts,
+            fetchSequence: sequenceAdapter
+                ? (region) => fetchSequence(region, sequenceAdapter)
+                : undefined,
+        });
+        this.cache.set(cacheKey, result);
+        return result;
+    }
     async getMultiRegionFeatureDensityStats(regions, opts) {
         const { subadapter } = await this.configure();
         return subadapter.getMultiRegionFeatureDensityStats(regions, opts);
     }
+    async getMultiRegionQuantitativeStats(regions = [], opts = {}) {
+        if (!regions.length) {
+            return blankStats();
+        }
+        const { staticBlocks } = opts;
+        if (staticBlocks?.length) {
+            const staticBlockData = await Promise.all(staticBlocks.map(block => this.getCoverageBins(block, {
+                ...opts,
+                statsEstimationMode: true,
+            }).then(bins => ({ block, bins }))));
+            const regionStats = regions.map(region => {
+                const overlappingBlocks = staticBlockData.filter(({ block }) => block.refName === region.refName &&
+                    block.start < region.end &&
+                    block.end > region.start);
+                if (overlappingBlocks.length === 0) {
+                    return rectifyStats({
+                        scoreMin: 0,
+                        scoreMax: 0,
+                        scoreSum: 0,
+                        scoreSumSquares: 0,
+                        featureCount: 0,
+                        basesCovered: 0,
+                    });
+                }
+                const blockStats = overlappingBlocks.map(({ bins }) => rectifyStats(computeStatsFromBins(bins, region.start, region.end)));
+                return aggregateQuantitativeStats(blockStats);
+            });
+            return aggregateQuantitativeStats(regionStats);
+        }
+        const stats = await Promise.all(regions.map(region => this.getRegionQuantitativeStats(region, opts)));
+        return aggregateQuantitativeStats(stats);
+    }
     async getRefNames(opts = {}) {
         const { subadapter } = await this.configure();
         return subadapter.getRefNames(opts);
     }
+    freeResources(region) {
+        const prefix = `${region.refName}:`;
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(prefix)) {
+                this.cache.delete(key);
+            }
+        }
+    }
 }

package/esm/SNPCoverageAdapter/configSchema.d.ts

@@ -1,7 +1,11 @@
-declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+declare const configSchema: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{
     subadapter: {
         type: string;
         defaultValue: null;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    sequenceAdapter: {
+        type: string;
+        defaultValue: null;
+    };
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default configSchema;

package/esm/SNPCoverageAdapter/configSchema.js

@@ -5,5 +5,9 @@ const configSchema = ConfigurationSchema('SNPCoverageAdapter', {
         type: 'frozen',
         defaultValue: null,
     },
+    sequenceAdapter: {
+        type: 'frozen',
+        defaultValue: null,
+    },
 }, { explicitlyTyped: true });
 export default configSchema;

package/esm/SNPCoverageAdapter/generateCoverageBinsPrefixSum.d.ts

@@ -0,0 +1,26 @@
+import type { Opts } from './util.ts';
+import type { FeatureWithMismatchIterator, PreBaseCoverageBin, PreBinEntry, SkipMap } from '../shared/types.ts';
+import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
+export interface LazyBin {
+    refbase?: string;
+    depth: number;
+    readsCounted: number;
+    ref: PreBinEntry;
+    snps?: Record<string, PreBinEntry>;
+    mods?: Record<string, PreBinEntry>;
+    nonmods?: Record<string, PreBinEntry>;
+    delskips?: Record<string, PreBinEntry>;
+    noncov?: Record<string, PreBinEntry>;
+}
+export interface CoverageBinsResult {
+    bins: (LazyBin | undefined)[];
+    regionStart: number;
+    skipmap: SkipMap;
+}
+export declare function finalizeLazyBin(bin: LazyBin): PreBaseCoverageBin;
+export declare function generateCoverageBinsPrefixSum({ fetchSequence, features, region, opts, }: {
+    features: FeatureWithMismatchIterator[];
+    region: Region;
+    opts: Opts;
+    fetchSequence?: (arg: Region) => Promise<string | undefined>;
+}): Promise<CoverageBinsResult>;