@jbrowse/plugin-alignments 3.7.0 → 4.0.1

package/esm/RenderLinearReadCloudDisplayRPC/executeRenderLinearReadCloudDisplay.js

@@ -0,0 +1,142 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import { collectTransferables, dedupe, groupBy, max, min, renderToAbstractCanvas, updateStatus, } from '@jbrowse/core/util';
+import { bpToPx } from '@jbrowse/core/util/Base1DUtils';
+import Base1DView from '@jbrowse/core/util/Base1DViewModel';
+import { rpcResult } from '@jbrowse/core/util/librpc';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
+import { firstValueFrom } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+import { calculateCloudYOffsetsUtil } from "./drawFeatsCloud.js";
+import { computeChainBounds, drawFeatsCore, filterChains, sortComputedChains, } from "./drawFeatsCommon.js";
+import { calculateStackYOffsetsUtil } from "./drawFeatsStack.js";
+import { getInsertSizeStats } from "../shared/insertSizeStats.js";
+export async function executeRenderLinearReadCloudDisplay({ pluginManager, args, }) {
+    const { sessionId, view: viewSnapshot, adapterConfig, sequenceAdapter, config, theme, featureHeight, noSpacing, drawCloud, colorBy, drawSingletons, drawProperPairs, flipStrandLongReadChains, trackMaxHeight, cloudModeHeight, cloudDomain, highResolutionScaling, exportSVG, statusCallback = () => { }, stopToken, visibleModifications, hideSmallIndels, hideMismatches, hideLargeIndels, showOutline, } = args;
+    const view = Base1DView.create(viewSnapshot);
+    if (viewSnapshot.width) {
+        view.setVolatileWidth(viewSnapshot.width);
+    }
+    const { bpPerPx, offsetPx } = view;
+    const width = view.staticBlocks.totalWidthPx;
+    const regions = view.staticBlocks.contentBlocks;
+    const assemblyName = view.assemblyNames[0];
+    if (!assemblyName) {
+        throw new Error('No assembly name found in view');
+    }
+    const snap = getSnapshot(view);
+    const viewSnap = {
+        ...snap,
+        width: view.width,
+        staticBlocks: view.staticBlocks,
+        bpToPx(arg) {
+            const res = bpToPx({
+                self: this,
+                refName: arg.refName,
+                coord: arg.coord,
+            });
+            return res !== undefined
+                ? { offsetPx: res.offsetPx, index: res.index }
+                : undefined;
+        },
+    };
+    const dataAdapter = (await getAdapter(pluginManager, sessionId, adapterConfig)).dataAdapter;
+    if (sequenceAdapter && !dataAdapter.sequenceAdapterConfig) {
+        dataAdapter.setSequenceAdapterConfig(sequenceAdapter);
+    }
+    const featuresArray = await updateStatus('Fetching alignments', statusCallback, () => firstValueFrom(dataAdapter.getFeaturesInMultipleRegions(regions, args).pipe(toArray())));
+    checkStopToken(stopToken);
+    const deduped = dedupe(featuresArray, f => f.id());
+    const { chains, stats } = await updateStatus('Processing alignments', statusCallback, async () => {
+        const tlens = [];
+        for (const f of deduped) {
+            const flags = f.get('flags');
+            if (flags & 2 && !(flags & 256) && !(flags & 2048)) {
+                const tlen = f.get('template_length');
+                if (tlen !== 0 && !Number.isNaN(tlen)) {
+                    tlens.push(Math.abs(tlen));
+                }
+            }
+        }
+        let statsResult;
+        if (tlens.length > 0) {
+            const insertSizeStats = getInsertSizeStats(tlens);
+            statsResult = {
+                ...insertSizeStats,
+                max: max(tlens),
+                min: min(tlens),
+            };
+        }
+        const chainsResult = Object.values(groupBy(deduped, f => f.get('name')));
+        return {
+            chains: chainsResult,
+            stats: statsResult,
+        };
+    });
+    const chainData = { chains, stats };
+    checkStopToken(stopToken);
+    const { computedChains } = await updateStatus('Calculating layout', statusCallback, async () => {
+        const filtered = filterChains(chains, drawSingletons, drawProperPairs, colorBy.type || 'insertSizeAndOrientation', chainData);
+        const computed = computeChainBounds(filtered, viewSnap);
+        sortComputedChains(computed);
+        return {
+            filteredChains: filtered,
+            computedChains: computed,
+        };
+    });
+    let actualHeight;
+    if (drawCloud) {
+        if (cloudModeHeight === undefined) {
+            throw new Error('cloudModeHeight is required when drawCloud is true');
+        }
+        actualHeight = cloudModeHeight;
+    }
+    else {
+        actualHeight = calculateStackYOffsetsUtil(computedChains, featureHeight, noSpacing, trackMaxHeight ?? 1200).layoutHeight;
+    }
+    const renderOpts = {
+        highResolutionScaling,
+        exportSVG,
+    };
+    const result = await updateStatus('Rendering alignments', statusCallback, () => renderToAbstractCanvas(width, actualHeight, renderOpts, async (ctx) => {
+        const { layoutHeight, cloudMaxDistance, featuresForFlatbush, mismatchFlatbush, mismatchItems, } = drawFeatsCore({
+            ctx,
+            params: {
+                chainData,
+                featureHeight,
+                canvasWidth: width,
+                noSpacing,
+                colorBy,
+                drawSingletons,
+                drawProperPairs,
+                flipStrandLongReadChains,
+                trackMaxHeight,
+                config,
+                theme,
+                regions,
+                bpPerPx,
+                stopToken,
+                visibleModifications,
+                hideSmallIndels,
+                hideMismatches,
+                hideLargeIndels,
+                showOutline,
+            },
+            view: viewSnap,
+            calculateYOffsets: (chains) => {
+                return drawCloud
+                    ? calculateCloudYOffsetsUtil(chains, actualHeight, cloudDomain)
+                    : calculateStackYOffsetsUtil(chains, featureHeight, noSpacing, trackMaxHeight ?? 1200);
+            },
+        });
+        return {
+            layoutHeight,
+            cloudMaxDistance,
+            featuresForFlatbush,
+            mismatchFlatbush,
+            mismatchItems,
+        };
+    }));
+    const serialized = { ...result, offsetPx };
+    return rpcResult(serialized, collectTransferables(result));
+}

package/esm/RenderLinearReadCloudDisplayRPC/index.d.ts

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

package/esm/RenderLinearReadCloudDisplayRPC/index.js

@@ -0,0 +1,4 @@
+import RenderLinearReadCloudDisplay from "./RenderLinearReadCloudDisplay.js";
+export default function LinearReadCloudDisplayRPCMethodsF(pm) {
+    pm.addRpcMethod(() => new RenderLinearReadCloudDisplay(pm));
+}

package/esm/SNPCoverageAdapter/SNPCoverageAdapter.d.ts

@@ -1,14 +1,29 @@
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { ColorBy, FilterBy } from '../shared/types.ts';
+import type { BaseOptions, BaseSequenceAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Feature } from '@jbrowse/core/util/simpleFeature';
 import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
+interface SNPCoverageOptions extends BaseOptions {
+    filterBy?: FilterBy;
+    colorBy?: ColorBy;
+    staticBlocks?: Region[];
+    statsEstimationMode?: boolean;
+}
 export default class SNPCoverageAdapter extends BaseFeatureDataAdapter {
+    private sequenceAdapterP?;
+    private subadapterRef?;
+    private cache;
+    private lastBpPerPx?;
+    setSequenceAdapterConfig(config: Record<string, unknown>): void;
     protected configure(): Promise<{
         subadapter: BaseFeatureDataAdapter;
-        sequenceAdapter: BaseFeatureDataAdapter | undefined;
     }>;
-    fetchSequence(region: Region): Promise<any>;
+    getSequenceAdapter(): Promise<BaseSequenceAdapter | undefined>;
     getFeatures(region: Region, opts?: BaseOptions): import("rxjs").Observable<Feature>;
+    private getCoverageBins;
     getMultiRegionFeatureDensityStats(regions: Region[], opts?: BaseOptions): Promise<import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats>;
+    getMultiRegionQuantitativeStats(regions?: Region[], opts?: SNPCoverageOptions): Promise<import("@jbrowse/core/util/stats").RectifiedQuantitativeStats>;
     getRefNames(opts?: BaseOptions): Promise<string[]>;
+    freeResources(region: Region): void;
 }
+export {};

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>;