@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/RenderLinearReadCloudDisplayRPC/drawLongReadChains.js

@@ -0,0 +1,101 @@
+import { checkStopToken2, createStopTokenChecker, } from '@jbrowse/core/util/stopToken';
+import { calculateFeaturePositionPx, featureOverlapsRegion, getChainBoundsOnRef, getConnectingLineColor, getMismatchRenderingConfig, getStrandColorKey, renderFeatureMismatchesAndModifications, renderFeatureShape, } from "./drawChainsUtil.js";
+import { lineToCtx } from "../shared/canvasUtils.js";
+import { fillColor, getSingletonColor, strokeColor } from "../shared/color.js";
+import { getPrimaryStrandFromFlags } from "../shared/primaryStrand.js";
+export function drawLongReadChains({ ctx, chainData, chainYOffsets, renderChevrons, featureHeight, computedChains, flipStrandLongReadChains, config, theme: configTheme, region, regionStartPx, bpPerPx, colorBy, visibleModifications, stopToken, hideSmallIndels, hideMismatches, hideLargeIndels, showOutline, }) {
+    const mismatchConfig = getMismatchRenderingConfig(ctx, config, configTheme, colorBy, { hideSmallIndels, hideMismatches, hideLargeIndels });
+    const canvasWidth = region.widthPx;
+    const regionStart = region.start;
+    const allCoords = [];
+    const allItems = [];
+    const lastCheck = createStopTokenChecker(stopToken);
+    for (const computedChain of computedChains) {
+        checkStopToken2(lastCheck);
+        const { id, chain, isPairedEnd, nonSupplementary } = computedChain;
+        if (isPairedEnd) {
+            continue;
+        }
+        const chainY = chainYOffsets.get(id);
+        if (chainY === undefined) {
+            continue;
+        }
+        const isSingleton = chain.length === 1;
+        const c1 = nonSupplementary[0] || chain[0];
+        const primaryStrand = getPrimaryStrandFromFlags(c1);
+        if (!isSingleton) {
+            const bounds = getChainBoundsOnRef(chain, region.refName);
+            if (bounds &&
+                bounds.minStart < region.end &&
+                bounds.maxEnd > region.start) {
+                const firstPx = (bounds.minStart - regionStart) / bpPerPx;
+                const lastPx = (bounds.maxEnd - regionStart) / bpPerPx;
+                const lineY = chainY + featureHeight / 2;
+                lineToCtx(firstPx, lineY, lastPx, lineY, ctx, getConnectingLineColor(configTheme));
+            }
+        }
+        const layoutFeats = [];
+        for (let i = 0, l = chain.length; i < l; i++) {
+            const feat = chain[i];
+            const featRefName = feat.get('refName');
+            const featStart = feat.get('start');
+            const featEnd = feat.get('end');
+            if (!featureOverlapsRegion(featRefName, featStart, featEnd, region)) {
+                continue;
+            }
+            const featStrand = feat.get('strand');
+            const effectiveStrand = isSingleton || !flipStrandLongReadChains
+                ? featStrand
+                : featStrand * primaryStrand;
+            const [featureFill, featureStroke] = isSingleton
+                ? getSingletonColor({
+                    tlen: feat.get('template_length'),
+                    pair_orientation: feat.get('pair_orientation'),
+                    flags: feat.get('flags'),
+                }, chainData.stats)
+                : [
+                    fillColor[getStrandColorKey(effectiveStrand)],
+                    strokeColor[getStrandColorKey(effectiveStrand)],
+                ];
+            const { xPos, width } = calculateFeaturePositionPx(featStart, featEnd, regionStart, region.end, bpPerPx);
+            layoutFeats.push(feat);
+            renderFeatureShape({
+                ctx,
+                xPos,
+                yPos: chainY,
+                width,
+                height: featureHeight,
+                strand: effectiveStrand,
+                fillStyle: featureFill,
+                strokeStyle: featureStroke,
+                renderChevrons,
+                showOutline,
+            });
+        }
+        for (const feat of layoutFeats) {
+            const layoutFeat = {
+                feature: feat,
+                heightPx: featureHeight,
+                topPx: chainY,
+            };
+            renderFeatureMismatchesAndModifications({
+                ctx,
+                feat,
+                layoutFeat,
+                region,
+                regionStartPx,
+                bpPerPx,
+                canvasWidth,
+                colorBy,
+                visibleModifications,
+                mismatchConfig,
+                allCoords,
+                allItems,
+            });
+        }
+    }
+    return {
+        coords: allCoords,
+        items: allItems,
+    };
+}

package/esm/RenderLinearReadCloudDisplayRPC/drawPairChains.d.ts

@@ -0,0 +1,27 @@
+import type { MismatchData } from './drawChainsUtil.ts';
+import type { ComputedChain } from './drawFeatsCommon.ts';
+import type { ChainData, ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { BaseBlock } from '@jbrowse/core/util/blockTypes';
+import type { ThemeOptions } from '@mui/material';
+export declare function drawPairChains({ ctx, type, chainData, chainYOffsets, renderChevrons, featureHeight, computedChains, config, theme: configTheme, region, regionStartPx, bpPerPx, colorBy, visibleModifications, stopToken, hideSmallIndels, hideMismatches, hideLargeIndels, showOutline, }: {
+    ctx: CanvasRenderingContext2D;
+    type: string;
+    chainData: ChainData;
+    chainYOffsets: Map<string, number>;
+    renderChevrons: boolean;
+    featureHeight: number;
+    computedChains: ComputedChain[];
+    config: AnyConfigurationModel;
+    theme: ThemeOptions;
+    region: BaseBlock;
+    regionStartPx: number;
+    bpPerPx: number;
+    colorBy: ColorBy;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    stopToken?: string;
+    hideSmallIndels?: boolean;
+    hideMismatches?: boolean;
+    hideLargeIndels?: boolean;
+    showOutline?: boolean;
+}): MismatchData;

package/esm/RenderLinearReadCloudDisplayRPC/drawPairChains.js

@@ -0,0 +1,95 @@
+import { checkStopToken2, createStopTokenChecker, } from '@jbrowse/core/util/stopToken';
+import { calculateFeaturePositionPx, featureOverlapsRegion, getChainBoundsOnRef, getConnectingLineColor, getMismatchRenderingConfig, renderFeatureMismatchesAndModifications, renderFeatureShape, } from "./drawChainsUtil.js";
+import { lineToCtx } from "../shared/canvasUtils.js";
+import { fillColor, getPairedColor, strokeColor } from "../shared/color.js";
+export function drawPairChains({ ctx, type, chainData, chainYOffsets, renderChevrons, featureHeight, computedChains, config, theme: configTheme, region, regionStartPx, bpPerPx, colorBy, visibleModifications, stopToken, hideSmallIndels, hideMismatches, hideLargeIndels, showOutline, }) {
+    const mismatchConfig = getMismatchRenderingConfig(ctx, config, configTheme, colorBy, { hideSmallIndels, hideMismatches, hideLargeIndels });
+    const canvasWidth = region.widthPx;
+    const regionStart = region.start;
+    const allCoords = [];
+    const allItems = [];
+    const lastCheck = createStopTokenChecker(stopToken);
+    for (const computedChain of computedChains) {
+        checkStopToken2(lastCheck);
+        const { id, chain, isPairedEnd, nonSupplementary } = computedChain;
+        if (!isPairedEnd) {
+            continue;
+        }
+        const chainY = chainYOffsets.get(id);
+        if (chainY === undefined) {
+            continue;
+        }
+        const hasBothMates = nonSupplementary.length === 2;
+        const feat = nonSupplementary[0] || chain[0];
+        const [pairedFill, pairedStroke] = getPairedColor({
+            type,
+            v0: feat,
+            stats: chainData.stats,
+        }) || ['lightgrey', '#888'];
+        const lineY = chainY + featureHeight / 2;
+        const hasSupplementary = chain.length > nonSupplementary.length;
+        if (hasBothMates) {
+            const bounds = getChainBoundsOnRef(chain, region.refName);
+            if (bounds &&
+                bounds.minStart < region.end &&
+                bounds.maxEnd > region.start) {
+                const r1s = (bounds.minStart - regionStart) / bpPerPx;
+                const r2s = (bounds.maxEnd - regionStart) / bpPerPx;
+                const lineColor = hasSupplementary
+                    ? fillColor.color_supplementary
+                    : getConnectingLineColor(configTheme);
+                lineToCtx(r1s, lineY, r2s, lineY, ctx, lineColor);
+            }
+        }
+        const layoutFeats = [];
+        for (let i = 0, l = chain.length; i < l; i++) {
+            const feat = chain[i];
+            const featRefName = feat.get('refName');
+            const featStart = feat.get('start');
+            const featEnd = feat.get('end');
+            if (!featureOverlapsRegion(featRefName, featStart, featEnd, region)) {
+                continue;
+            }
+            const { xPos, width } = calculateFeaturePositionPx(featStart, featEnd, regionStart, region.end, bpPerPx);
+            layoutFeats.push(feat);
+            const [featFill, featStroke] = hasSupplementary
+                ? [fillColor.color_supplementary, strokeColor.color_supplementary]
+                : [pairedFill, pairedStroke];
+            renderFeatureShape({
+                ctx,
+                xPos,
+                yPos: chainY,
+                width,
+                height: featureHeight,
+                strand: feat.get('strand'),
+                fillStyle: featFill,
+                strokeStyle: featStroke,
+                renderChevrons,
+                showOutline,
+            });
+        }
+        for (const feat of layoutFeats) {
+            const layoutFeat = {
+                feature: feat,
+                heightPx: featureHeight,
+                topPx: chainY,
+            };
+            renderFeatureMismatchesAndModifications({
+                ctx,
+                feat,
+                layoutFeat,
+                region,
+                regionStartPx,
+                bpPerPx,
+                canvasWidth,
+                colorBy,
+                visibleModifications,
+                mismatchConfig,
+                allCoords,
+                allItems,
+            });
+        }
+        checkStopToken2(lastCheck);
+    }
+    return { coords: allCoords, items: allItems };
+}

package/esm/RenderLinearReadCloudDisplayRPC/executeRenderLinearReadCloudDisplay.d.ts

@@ -0,0 +1,6 @@
+import type { RenderLinearReadCloudDisplayArgs } from './RenderLinearReadCloudDisplay.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+export declare function executeRenderLinearReadCloudDisplay({ pluginManager, args, }: {
+    pluginManager: PluginManager;
+    args: RenderLinearReadCloudDisplayArgs;
+}): Promise<import("librpc-web-mod").RpcResult>;

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