@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/RenderLinearReadArcsDisplayRPC/RenderLinearReadArcsDisplay.js

@@ -0,0 +1,49 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+import { renameRegionsIfNeeded } from '@jbrowse/core/util';
+import configSchema from "../LinearReadArcsDisplay/configSchema.js";
+export default class RenderLinearReadArcsDisplay extends RpcMethodType {
+    name = 'RenderLinearReadArcsDisplay';
+    deserializeArguments(args, _rpcDriver) {
+        return {
+            ...args,
+            config: configSchema(this.pluginManager).create(args.config, {
+                pluginManager: this.pluginManager,
+            }),
+        };
+    }
+    async renameRegionsIfNeeded(args) {
+        const assemblyManager = this.pluginManager.rootModel?.session?.assemblyManager;
+        if (!assemblyManager) {
+            throw new Error('no assembly manager');
+        }
+        const { view, sessionId, adapterConfig } = args;
+        const { displayedRegions } = view;
+        if (!displayedRegions.length) {
+            return args;
+        }
+        const result = await renameRegionsIfNeeded(assemblyManager, {
+            sessionId,
+            adapterConfig,
+            regions: displayedRegions,
+        });
+        return {
+            ...args,
+            view: {
+                ...view,
+                displayedRegions: result.regions,
+            },
+        };
+    }
+    async serializeArguments(args, rpcDriver) {
+        const renamed = await this.renameRegionsIfNeeded(args);
+        return super.serializeArguments(renamed, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { executeRenderLinearReadArcsDisplay } = await import("./executeRenderLinearReadArcsDisplay.js");
+        return executeRenderLinearReadArcsDisplay({
+            pluginManager: this.pluginManager,
+            args: deserializedArgs,
+        });
+    }
+}

package/esm/RenderLinearReadArcsDisplayRPC/drawFeatsRPC.d.ts

@@ -0,0 +1,24 @@
+import type { ChainData, ColorBy } from '../shared/types.ts';
+interface DrawFeatsRPCParams {
+    ctx: CanvasRenderingContext2D;
+    width: number;
+    height: number;
+    chainData: ChainData;
+    colorBy: ColorBy;
+    drawInter: boolean;
+    drawLongRange: boolean;
+    lineWidth: number;
+    jitter: number;
+    view: {
+        bpToPx: (arg: {
+            refName: string;
+            coord: number;
+        }) => {
+            offsetPx: number;
+        } | undefined;
+    };
+    offsetPx: number;
+    stopToken?: string;
+}
+export declare function drawFeatsRPC(params: DrawFeatsRPCParams): void;
+export {};

package/esm/RenderLinearReadArcsDisplayRPC/drawFeatsRPC.js

@@ -0,0 +1,156 @@
+import { checkStopToken2, createStopTokenChecker, } from '@jbrowse/core/util/stopToken';
+import { featurizeSA, getTag } from "../MismatchParser/index.js";
+import { drawVerticalLine, extractCoreFeat, extractCoreFeatBasic, filterAndSortLongReadChain, filterPairedChain, getMateInfo, getStrandRelativeFirstClipLength, jitter, toCoreFeat, toCoreFeatBasic, } from "../shared/arcUtils.js";
+import { getPairedInsertSizeAndOrientationColor, getPairedInsertSizeColor, getPairedOrientationColor, } from "../shared/color.js";
+import { SAM_FLAG_MATE_UNMAPPED } from "../shared/samFlags.js";
+import { hasPairedReads } from "../shared/util.js";
+const ARC_VS_BEZIER_THRESHOLD = 10_000;
+const VERTICAL_LINE_THRESHOLD = 100_000;
+const GRADIENT_HSL_SATURATION = 50;
+const GRADIENT_HSL_LIGHTNESS = 50;
+function getArcEndpoint(feat, isPairedEnd, isMate) {
+    const isReverse = feat.strand === -1;
+    if (isPairedEnd) {
+        return isReverse ? feat.start : feat.end;
+    }
+    return isMate
+        ? isReverse
+            ? feat.end
+            : feat.start
+        : isReverse
+            ? feat.start
+            : feat.end;
+}
+function getArcStrokeColor(params) {
+    const { longRange, drawArcInsteadOfBezier, hasPaired, colorByType, k1, s1, s2, absrad, stats, } = params;
+    if (longRange && drawArcInsteadOfBezier) {
+        return 'red';
+    }
+    if (hasPaired) {
+        if (colorByType === 'insertSizeAndOrientation') {
+            return getPairedInsertSizeAndOrientationColor(k1, stats)[0];
+        }
+        if (colorByType === 'orientation') {
+            return getPairedOrientationColor(k1)[0];
+        }
+        if (colorByType === 'insertSize') {
+            return getPairedInsertSizeColor(k1, stats)?.[0] || 'grey';
+        }
+        if (colorByType === 'gradient') {
+            return `hsl(${Math.log10(absrad) * 10},${GRADIENT_HSL_SATURATION}%,${GRADIENT_HSL_LIGHTNESS}%)`;
+        }
+        return 'grey';
+    }
+    if (colorByType === 'orientation' ||
+        colorByType === 'insertSizeAndOrientation') {
+        if (s1 === -1 && s2 === 1) {
+            return 'navy';
+        }
+        if (s1 === 1 && s2 === -1) {
+            return 'green';
+        }
+        return 'grey';
+    }
+    if (colorByType === 'gradient') {
+        return `hsl(${Math.log10(absrad) * 10},${GRADIENT_HSL_SATURATION}%,${GRADIENT_HSL_LIGHTNESS}%)`;
+    }
+    return 'grey';
+}
+function drawBezierArc(ctx, startX, endX, destY, jitterVal) {
+    ctx.beginPath();
+    ctx.moveTo(startX, 0);
+    ctx.bezierCurveTo(startX + jitter(jitterVal), destY, endX, destY, endX + jitter(jitterVal), 0);
+    ctx.stroke();
+}
+export function drawFeatsRPC(params) {
+    const { ctx, height, chainData, colorBy, drawInter, drawLongRange, lineWidth, jitter: jitterVal, view, offsetPx, stopToken, } = params;
+    const { chains, stats } = chainData;
+    const colorByType = colorBy.type;
+    const hasPaired = hasPairedReads(chainData);
+    ctx.lineWidth = lineWidth;
+    function draw(k1, k2, longRange) {
+        const s1 = k1.strand;
+        const s2 = k2.strand;
+        const p1 = getArcEndpoint(k1, hasPaired, false);
+        const p2 = getArcEndpoint(k2, hasPaired, true);
+        const r1 = view.bpToPx({ refName: k1.refName, coord: p1 })?.offsetPx;
+        const r2 = view.bpToPx({ refName: k2.refName, coord: p2 })?.offsetPx;
+        if (r1 !== undefined && r2 !== undefined) {
+            const radius = (r2 - r1) / 2;
+            const absrad = Math.abs(radius);
+            const p = r1 - offsetPx;
+            const pEnd = r2 - offsetPx;
+            const drawArcInsteadOfBezier = absrad > ARC_VS_BEZIER_THRESHOLD;
+            ctx.strokeStyle = getArcStrokeColor({
+                longRange,
+                drawArcInsteadOfBezier,
+                hasPaired,
+                colorByType,
+                k1,
+                s1,
+                s2,
+                absrad,
+                stats,
+            });
+            const destY = Math.min(height + jitter(jitterVal), absrad);
+            if (absrad < 1) {
+                ctx.fillStyle = ctx.strokeStyle;
+                ctx.fillRect(p, 0, pEnd - p, Math.max(absrad, lineWidth));
+            }
+            else if (longRange && absrad > VERTICAL_LINE_THRESHOLD) {
+                drawVerticalLine(ctx, p + jitter(jitterVal), height, 'red');
+                drawVerticalLine(ctx, pEnd + jitter(jitterVal), height, 'red');
+            }
+            else if (longRange && drawArcInsteadOfBezier) {
+                ctx.moveTo(p, 0);
+                ctx.beginPath();
+                ctx.arc(p + radius + jitter(jitterVal), 0, absrad, 0, Math.PI);
+                ctx.stroke();
+            }
+            else {
+                drawBezierArc(ctx, p, p + radius * 2, destY, jitterVal);
+            }
+        }
+        else if (r1 && drawInter) {
+            drawVerticalLine(ctx, r1 - offsetPx, height, 'purple');
+        }
+    }
+    function drawSingletonPairedEnd(f) {
+        draw(extractCoreFeat(f), getMateInfo(f), true);
+    }
+    function drawSingletonLongRead(f) {
+        const allFeatures = [
+            f,
+            ...featurizeSA(getTag(f, 'SA'), f.id(), f.get('strand'), f.get('name')),
+        ].toSorted((a, b) => getStrandRelativeFirstClipLength(a) -
+            getStrandRelativeFirstClipLength(b));
+        for (let i = 0, len = allFeatures.length; i < len - 1; i++) {
+            draw(toCoreFeat(allFeatures[i]), toCoreFeatBasic(allFeatures[i + 1]), true);
+        }
+    }
+    function drawMultiFeatureChain(chain) {
+        const filtered = hasPaired
+            ? filterPairedChain(chain)
+            : filterAndSortLongReadChain(chain);
+        for (let i = 0, len = filtered.length; i < len - 1; i++) {
+            draw(extractCoreFeat(filtered[i]), extractCoreFeatBasic(filtered[i + 1]), false);
+        }
+    }
+    const lastCheck = createStopTokenChecker(stopToken);
+    for (const chain of chains) {
+        if (chain.length === 1 && drawLongRange) {
+            const f = chain[0];
+            const isMateUnmapped = f.get('flags') & SAM_FLAG_MATE_UNMAPPED;
+            if (hasPaired && !isMateUnmapped) {
+                drawSingletonPairedEnd(f);
+            }
+            else {
+                drawSingletonLongRead(f);
+            }
+        }
+        else {
+            drawMultiFeatureChain(chain);
+        }
+        checkStopToken2(lastCheck);
+    }
+}

package/esm/RenderLinearReadArcsDisplayRPC/executeRenderLinearReadArcsDisplay.d.ts

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

package/esm/RenderLinearReadArcsDisplayRPC/executeRenderLinearReadArcsDisplay.js

@@ -0,0 +1,105 @@
+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 { drawFeatsRPC } from "./drawFeatsRPC.js";
+import { getInsertSizeStats } from "../shared/insertSizeStats.js";
+export async function executeRenderLinearReadArcsDisplay({ pluginManager, args, }) {
+    const { sessionId, view: viewSnapshot, adapterConfig, sequenceAdapter, colorBy, drawInter, drawLongRange, lineWidth, jitter, height, highResolutionScaling, exportSVG, statusCallback = () => { }, stopToken, } = args;
+    const view = Base1DView.create(viewSnapshot);
+    if (viewSnapshot.width) {
+        view.setVolatileWidth(viewSnapshot.width);
+    }
+    const { offsetPx } = view;
+    const width = view.staticBlocks.totalWidthPx;
+    const regions = view.staticBlocks.contentBlocks;
+    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 { chains, stats } = await updateStatus('Processing alignments', statusCallback, async () => {
+        const deduped = dedupe(featuresArray, f => f.id());
+        const filtered = deduped.filter(f => {
+            const flags = f.get('flags');
+            if (!(flags & 2)) {
+                return false;
+            }
+            if (flags & 256 || flags & 2048) {
+                return false;
+            }
+            return true;
+        });
+        let statsResult;
+        if (filtered.length) {
+            const validTlenFeatures = filtered.filter(f => {
+                const tlen = f.get('template_length');
+                return tlen !== 0 && !Number.isNaN(tlen);
+            });
+            if (validTlenFeatures.length > 0) {
+                const tlens = validTlenFeatures.map(f => Math.abs(f.get('template_length')));
+                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 renderOpts = {
+        highResolutionScaling,
+        exportSVG,
+    };
+    const result = await updateStatus('Rendering arcs', statusCallback, () => renderToAbstractCanvas(width, height, renderOpts, ctx => {
+        drawFeatsRPC({
+            ctx,
+            width,
+            height,
+            chainData,
+            colorBy,
+            drawInter,
+            drawLongRange,
+            lineWidth,
+            jitter,
+            view: viewSnap,
+            offsetPx,
+            stopToken,
+        });
+        return undefined;
+    }));
+    const serialized = { ...result, offsetPx };
+    return rpcResult(serialized, collectTransferables(result));
+}

package/{dist/GuessAlignmentsTypes → esm/RenderLinearReadArcsDisplayRPC}/index.d.ts

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

package/esm/RenderLinearReadArcsDisplayRPC/index.js

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

package/esm/RenderLinearReadCloudDisplayRPC/RenderLinearReadCloudDisplay.d.ts

@@ -0,0 +1,43 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+import type { ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Base1DViewModel } from '@jbrowse/core/util/Base1DViewModel';
+import type { ThemeOptions } from '@mui/material';
+export interface RenderLinearReadCloudDisplayArgs {
+    sessionId: string;
+    view: Base1DViewModel;
+    adapterConfig: AnyConfigurationModel;
+    sequenceAdapter?: Record<string, unknown>;
+    config: AnyConfigurationModel;
+    theme: ThemeOptions;
+    filterBy: Record<string, unknown>;
+    featureHeight: number;
+    noSpacing: boolean;
+    drawCloud: boolean;
+    colorBy: ColorBy;
+    drawSingletons: boolean;
+    drawProperPairs: boolean;
+    flipStrandLongReadChains: boolean;
+    trackMaxHeight?: number;
+    cloudModeHeight?: number;
+    cloudDomain?: [number, number];
+    highResolutionScaling?: number;
+    exportSVG?: {
+        rasterizeLayers?: boolean;
+        scale?: number;
+    };
+    statusCallback?: (status: string) => void;
+    stopToken?: string;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    hideSmallIndels?: boolean;
+    hideMismatches?: boolean;
+    hideLargeIndels?: boolean;
+    showOutline?: boolean;
+}
+export default class RenderLinearReadCloudDisplay extends RpcMethodType {
+    name: string;
+    renameRegionsIfNeeded(args: RenderLinearReadCloudDisplayArgs): Promise<RenderLinearReadCloudDisplayArgs>;
+    deserializeArguments(args: any, _rpcDriver: string): any;
+    serializeArguments(args: Record<string, unknown>, rpcDriver: string): Promise<Record<string, unknown>>;
+    execute(args: Record<string, unknown>, rpcDriver: string): Promise<import("librpc-web-mod").RpcResult>;
+}

package/esm/RenderLinearReadCloudDisplayRPC/RenderLinearReadCloudDisplay.js

@@ -0,0 +1,49 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+import { renameRegionsIfNeeded } from '@jbrowse/core/util';
+import configSchema from "../LinearReadCloudDisplay/configSchema.js";
+export default class RenderLinearReadCloudDisplay extends RpcMethodType {
+    name = 'RenderLinearReadCloudDisplay';
+    async renameRegionsIfNeeded(args) {
+        const assemblyManager = this.pluginManager.rootModel?.session?.assemblyManager;
+        if (!assemblyManager) {
+            throw new Error('no assembly manager');
+        }
+        const { view, sessionId, adapterConfig } = args;
+        const { displayedRegions } = view;
+        if (!displayedRegions.length) {
+            return args;
+        }
+        const result = await renameRegionsIfNeeded(assemblyManager, {
+            sessionId,
+            adapterConfig,
+            regions: displayedRegions,
+        });
+        return {
+            ...args,
+            view: {
+                ...view,
+                displayedRegions: result.regions,
+            },
+        };
+    }
+    deserializeArguments(args, _rpcDriver) {
+        return {
+            ...args,
+            config: configSchema(this.pluginManager).create(args.config, {
+                pluginManager: this.pluginManager,
+            }),
+        };
+    }
+    async serializeArguments(args, rpcDriver) {
+        const renamed = await this.renameRegionsIfNeeded(args);
+        return super.serializeArguments(renamed, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { executeRenderLinearReadCloudDisplay } = await import("./executeRenderLinearReadCloudDisplay.js");
+        return executeRenderLinearReadCloudDisplay({
+            pluginManager: this.pluginManager,
+            args: deserializedArgs,
+        });
+    }
+}

package/esm/RenderLinearReadCloudDisplayRPC/drawChainsUtil.d.ts

@@ -0,0 +1,82 @@
+import type { FlatbushItem, LayoutFeature } from '../PileupRenderer/types.ts';
+import type { ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Feature } from '@jbrowse/core/util';
+import type { BaseBlock } from '@jbrowse/core/util/blockTypes';
+import type { ThemeOptions } from '@mui/material';
+export declare function getConnectingLineColor(configTheme: ThemeOptions): "#aaa8" | "#6665";
+export declare const MIN_FEATURE_WIDTH_PX = 3;
+export declare const CLIP_RECT_HEIGHT = 100000;
+export declare function renderFeatureShape({ ctx, xPos, yPos, width, height, strand, fillStyle, strokeStyle, renderChevrons, showOutline, }: {
+    ctx: CanvasRenderingContext2D;
+    xPos: number;
+    yPos: number;
+    width: number;
+    height: number;
+    strand: number;
+    fillStyle: string;
+    strokeStyle: string;
+    renderChevrons: boolean;
+    showOutline?: boolean;
+}): void;
+export interface MismatchData {
+    coords: number[];
+    items: FlatbushItem[];
+}
+export declare function getStrandColorKey(strand: number): "color_rev_strand" | "color_fwd_strand";
+export declare function chainIsPairedEnd(chain: Feature[]): boolean;
+export declare function collectNonSupplementary(chain: Feature[]): Feature[];
+export interface MismatchRenderingConfig {
+    mismatchAlpha: boolean | undefined;
+    minSubfeatureWidth: number;
+    largeInsertionIndicatorScale: number;
+    hideSmallIndels: boolean;
+    hideMismatches: boolean;
+    hideLargeIndels: boolean;
+    colorMap: Record<string, string>;
+    colorContrastMap: Record<string, string>;
+    charWidth: number;
+    charHeight: number;
+    drawSNPsMuted: boolean;
+    drawIndels: boolean;
+}
+export declare function getMismatchRenderingConfig(ctx: CanvasRenderingContext2D, config: AnyConfigurationModel, configTheme: ThemeOptions, colorBy: ColorBy, overrides?: {
+    hideSmallIndels?: boolean;
+    hideMismatches?: boolean;
+    hideLargeIndels?: boolean;
+}): MismatchRenderingConfig;
+export declare function featureOverlapsRegion(featRefName: string, featStart: number, featEnd: number, region: BaseBlock): boolean;
+export declare function calculateFeaturePositionPx(featStart: number, featEnd: number, regionStart: number, regionEnd: number, bpPerPx: number): {
+    xPos: number;
+    width: number;
+};
+export declare function getChainBoundsOnRef(chain: Feature[], refName: string): {
+    minStart: number;
+    maxEnd: number;
+} | undefined;
+export declare function renderFeatureModifications({ ctx, feat, layoutFeat, region, regionStartPx, bpPerPx, colorBy, visibleModifications, allCoords, allItems, }: {
+    ctx: CanvasRenderingContext2D;
+    feat: Feature;
+    layoutFeat: LayoutFeature;
+    region: BaseBlock;
+    regionStartPx: number;
+    bpPerPx: number;
+    colorBy: ColorBy;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    allCoords: number[];
+    allItems: FlatbushItem[];
+}): void;
+export declare function renderFeatureMismatchesAndModifications({ ctx, feat, layoutFeat, region, regionStartPx, bpPerPx, canvasWidth, colorBy, visibleModifications, mismatchConfig, allCoords, allItems, }: {
+    ctx: CanvasRenderingContext2D;
+    feat: Feature;
+    layoutFeat: LayoutFeature;
+    region: BaseBlock;
+    regionStartPx: number;
+    bpPerPx: number;
+    canvasWidth: number;
+    colorBy: ColorBy;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    mismatchConfig: MismatchRenderingConfig;
+    allCoords: number[];
+    allItems: FlatbushItem[];
+}): void;