@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/shared/createRPCRenderingSetup.js

@@ -0,0 +1,82 @@
+import { getContainingView, getSession, isAbortException, } from '@jbrowse/core/util';
+import { createStopToken, stopStopToken } from '@jbrowse/core/util/stopToken';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { getSnapshot, isAlive } from '@jbrowse/mobx-state-tree';
+import { drawCanvasImageData } from '@jbrowse/plugin-linear-genome-view';
+import { untracked } from 'mobx';
+import { createAutorun } from "../util.js";
+export function createRPCRenderFunction({ self, rpcMethodName, getRPCParams, onResult }) {
+    return async () => {
+        const view = getContainingView(self);
+        if (!view.initialized ||
+            self.error ||
+            !self.featureDensityStatsReadyAndRegionNotTooLarge) {
+            return;
+        }
+        const { bpPerPx } = view;
+        try {
+            const session = getSession(self);
+            const { rpcManager, assemblyManager } = session;
+            const assemblyName = view.assemblyNames[0];
+            if (!assemblyName) {
+                return;
+            }
+            const assembly = assemblyManager.get(assemblyName);
+            const sequenceAdapterConfig = assembly?.configuration?.sequence?.adapter;
+            const sequenceAdapter = sequenceAdapterConfig
+                ? getSnapshot(sequenceAdapterConfig)
+                : undefined;
+            const previousToken = untracked(() => self.renderingStopToken);
+            if (previousToken) {
+                stopStopToken(previousToken);
+            }
+            const stopToken = createStopToken();
+            self.setRenderingStopToken(stopToken);
+            self.setLoading(true);
+            const viewSnapshot = structuredClone({
+                ...getSnapshot(view),
+                staticBlocks: view.staticBlocks,
+                width: view.width,
+            });
+            const sessionId = getRpcSessionId(self);
+            const result = (await rpcManager.call(sessionId, rpcMethodName, {
+                sessionId,
+                view: viewSnapshot,
+                adapterConfig: self.adapterConfig,
+                sequenceAdapter,
+                config: getSnapshot(self.configuration),
+                statusCallback: (msg) => {
+                    if (isAlive(self)) {
+                        self.setStatusMessage?.(msg);
+                    }
+                },
+                stopToken,
+                ...getRPCParams({ view, session, sequenceAdapter, stopToken }),
+            }));
+            if (result.imageData) {
+                self.setRenderingImageData(result.imageData);
+                if (result.offsetPx !== undefined) {
+                    self.setLastDrawnOffsetPx(result.offsetPx);
+                }
+                onResult(result);
+            }
+            self.setLastDrawnBpPerPx(bpPerPx);
+        }
+        catch (error) {
+            if (!isAbortException(error)) {
+                self.setError(error);
+            }
+        }
+        finally {
+            self.setRenderingStopToken(undefined);
+            self.setLoading(false);
+        }
+    };
+}
+export function setupCanvasRenderingAutorun(self) {
+    createAutorun(self, async () => {
+        drawCanvasImageData(self.ref, self.renderingImageData);
+    }, {
+        name: 'CanvasRenderAutorun',
+    });
+}

package/esm/shared/decodeSeq.d.ts

@@ -0,0 +1,2 @@
+export declare function decodeSeq(numericSeq: Uint8Array, seqLength: number): string;
+export declare function seqAt(numericSeq: Uint8Array, idx: number, seqLength: number): string | undefined;

package/esm/shared/decodeSeq.js

@@ -0,0 +1,26 @@
+const SEQRET_DECODER = '=ACMGRSVTWYHKDBN'.split('');
+export function decodeSeq(numericSeq, seqLength) {
+    const buf = new Array(seqLength);
+    let i = 0;
+    const fullBytes = seqLength >> 1;
+    for (let j = 0; j < fullBytes; ++j) {
+        const sb = numericSeq[j];
+        buf[i++] = SEQRET_DECODER[(sb & 0xf0) >> 4];
+        buf[i++] = SEQRET_DECODER[sb & 0x0f];
+    }
+    if (i < seqLength) {
+        const sb = numericSeq[fullBytes];
+        buf[i] = SEQRET_DECODER[(sb & 0xf0) >> 4];
+    }
+    return buf.join('');
+}
+export function seqAt(numericSeq, idx, seqLength) {
+    if (idx < seqLength) {
+        const byteIndex = idx >> 1;
+        const sb = numericSeq[byteIndex];
+        return idx % 2 === 0
+            ? SEQRET_DECODER[(sb & 0xf0) >> 4]
+            : SEQRET_DECODER[sb & 0x0f];
+    }
+    return undefined;
+}

package/esm/shared/flatbushType.d.ts

@@ -0,0 +1,25 @@
+export interface ReducedFeatureForFlatbush {
+    name: string;
+    refName: string;
+    start: number;
+    end: number;
+    strand: number;
+    flags: number;
+    id: string;
+    tlen: number;
+    pair_orientation: string;
+    clipLengthAtStartOfRead: number;
+    next_ref?: string;
+}
+export interface FlatbushEntry {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    data: ReducedFeatureForFlatbush;
+    chainId: string;
+    chainMinX: number;
+    chainMaxX: number;
+    chain: ReducedFeatureForFlatbush[];
+    hasSupplementary: boolean;
+}

package/esm/shared/flatbushType.js

@@ -0,0 +1 @@
+export {};

package/esm/shared/forEachMismatchTypes.d.ts

@@ -0,0 +1,18 @@
+export declare const MISMATCH_TYPE = 0;
+export declare const INSERTION_TYPE = 1;
+export declare const DELETION_TYPE = 2;
+export declare const SKIP_TYPE = 3;
+export declare const SOFTCLIP_TYPE = 4;
+export declare const HARDCLIP_TYPE = 5;
+export declare const INTERBASE_MASK = 50;
+export declare const DELSKIP_MASK = 12;
+export declare const MISMATCH_MAP: readonly ["mismatch", "insertion", "deletion", "skip", "softclip", "hardclip"];
+export declare const MISMATCH_REV_MAP: {
+    readonly mismatch: 0;
+    readonly insertion: 1;
+    readonly deletion: 2;
+    readonly skip: 3;
+    readonly softclip: 4;
+    readonly hardclip: 5;
+};
+export type MismatchCallback = (type: number, start: number, length: number, base: string, qual: number | undefined, altbase: number | undefined, cliplen: number | undefined) => void;

package/esm/shared/forEachMismatchTypes.js

@@ -0,0 +1,24 @@
+export const MISMATCH_TYPE = 0;
+export const INSERTION_TYPE = 1;
+export const DELETION_TYPE = 2;
+export const SKIP_TYPE = 3;
+export const SOFTCLIP_TYPE = 4;
+export const HARDCLIP_TYPE = 5;
+export const INTERBASE_MASK = 0b110010;
+export const DELSKIP_MASK = 0b1100;
+export const MISMATCH_MAP = [
+    'mismatch',
+    'insertion',
+    'deletion',
+    'skip',
+    'softclip',
+    'hardclip',
+];
+export const MISMATCH_REV_MAP = {
+    mismatch: 0,
+    insertion: 1,
+    deletion: 2,
+    skip: 3,
+    softclip: 4,
+    hardclip: 5,
+};

package/esm/shared/getMaximumModificationAtEachPosition.d.ts

@@ -4,5 +4,5 @@ interface MaximumProbabilityMod {
     prob: number;
     allProbs: number[];
 }
-export declare function getMaxProbModAtEachPosition(feature: Feature, cigarOps?: string[]): MaximumProbabilityMod[] | undefined;
+export declare function getMaxProbModAtEachPosition(feature: Feature, ops: ArrayLike<number>): MaximumProbabilityMod[] | undefined;
 export {};

package/esm/shared/getMaximumModificationAtEachPosition.js

@@ -1,12 +1,11 @@
-import { getNextRefPos, parseCigar } from '../MismatchParser';
-import { getModPositions } from '../ModificationParser/getModPositions';
-import { getModProbabilities } from '../ModificationParser/getModProbabilities';
-import { getTagAlt } from '../util';
-export function getMaxProbModAtEachPosition(feature, cigarOps) {
+import { getNextRefPos } from "../MismatchParser/index.js";
+import { getModPositions } from "../ModificationParser/getModPositions.js";
+import { getModProbabilities } from "../ModificationParser/getModProbabilities.js";
+import { getTagAlt } from "../util.js";
+export function getMaxProbModAtEachPosition(feature, ops) {
     const fstrand = feature.get('strand');
     const seq = feature.get('seq');
     const mm = getTagAlt(feature, 'MM', 'Mm') || '';
-    const ops = cigarOps || parseCigar(feature.get('CIGAR'));
     if (seq) {
         const modifications = getModPositions(mm, seq, fstrand);
         const probabilities = getModProbabilities(feature);
@@ -14,7 +13,7 @@ export function getMaxProbModAtEachPosition(feature, cigarOps) {
         let probIndex = 0;
         for (const { type, positions } of modifications) {
             for (const { ref, idx } of getNextRefPos(ops, positions)) {
-                const prob = (probabilities === null || probabilities === void 0 ? void 0 : probabilities[probIndex + (fstrand === -1 ? positions.length - 1 - idx : idx)]) || 0;
+                const prob = probabilities?.[probIndex + (fstrand === -1 ? positions.length - 1 - idx : idx)] || 0;
                 if (!maxProbModForPosition[ref]) {
                     maxProbModForPosition[ref] = {
                         type,

package/esm/shared/getUniqueModifications.d.ts

@@ -1,5 +1,4 @@
-import { type IAnyStateTreeNode } from 'mobx-state-tree';
-import type { ModificationType } from './types';
+import type { ModificationType } from './types.ts';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { BlockSet } from '@jbrowse/core/util/blockTypes';
 export interface ModificationOpts {
@@ -8,8 +7,14 @@ export interface ModificationOpts {
     filters: string[];
 }
 export declare function getUniqueModifications({ model, adapterConfig, blocks, opts, }: {
-    model: IAnyStateTreeNode;
+    model: {
+        setStatusMessage: (arg: string) => void;
+        effectiveRpcDriverName?: string;
+    };
     adapterConfig: AnyConfigurationModel;
     blocks: BlockSet;
     opts?: ModificationOpts;
-}): Promise<ModificationType[]>;
+}): Promise<{
+    modifications: ModificationType[];
+    simplexModifications: string[];
+}>;

package/esm/shared/getUniqueModifications.js

@@ -1,6 +1,6 @@
 import { getSession } from '@jbrowse/core/util';
 import { getRpcSessionId } from '@jbrowse/core/util/tracks';
-import { isAlive } from 'mobx-state-tree';
+import { isAlive } from '@jbrowse/mobx-state-tree';
 export async function getUniqueModifications({ model, adapterConfig, blocks, opts, }) {
     const { rpcManager } = getSession(model);
     const sessionId = getRpcSessionId(model);
@@ -8,9 +8,10 @@ export async function getUniqueModifications({ model, adapterConfig, blocks, opt
         adapterConfig,
         sessionId,
         regions: blocks.contentBlocks,
+        rpcDriverName: model.effectiveRpcDriverName,
         statusCallback: (arg) => {
             if (isAlive(model)) {
-                model.setMessage(arg);
+                model.setStatusMessage(arg);
             }
         },
         ...opts,

package/esm/shared/getUniqueTags.d.ts

@@ -1,9 +1,9 @@
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { BlockSet } from '@jbrowse/core/util/blockTypes';
-import type { IAnyStateTreeNode } from 'mobx-state-tree';
 export declare function getUniqueTags({ self, tag, blocks, opts, }: {
-    self: IAnyStateTreeNode & {
+    self: {
         adapterConfig: AnyConfigurationModel;
+        effectiveRpcDriverName?: string;
     };
     tag: string;
     blocks: BlockSet;

package/esm/shared/getUniqueTags.js

@@ -2,12 +2,13 @@ import { getSession } from '@jbrowse/core/util';
 import { getRpcSessionId } from '@jbrowse/core/util/tracks';
 export async function getUniqueTags({ self, tag, blocks, opts, }) {
     const { rpcManager } = getSession(self);
-    const { adapterConfig } = self;
+    const { adapterConfig, effectiveRpcDriverName } = self;
     const sessionId = getRpcSessionId(self);
     const values = await rpcManager.call(getRpcSessionId(self), 'PileupGetGlobalValueForTag', {
         adapterConfig,
         tag,
         sessionId,
+        rpcDriverName: effectiveRpcDriverName,
         regions: blocks.contentBlocks,
         ...opts,
     });

package/{dist/PileupRPC/util.d.ts → esm/shared/insertSizeStats.d.ts}

@@ -1,5 +1,5 @@
-import type { ReducedFeature } from '../shared/fetchChains';
-export declare function getInsertSizeStats(features: ReducedFeature[]): {
+import type { ReducedFeature } from './types.ts';
+export declare function getInsertSizeStats(filtered: number[]): {
     upper: number;
     lower: number;
     avg: number;

package/esm/shared/insertSizeStats.js

@@ -0,0 +1,23 @@
+import { sum } from '@jbrowse/core/util';
+export function getInsertSizeStats(filtered) {
+    const len = filtered.length;
+    const s = sum(filtered);
+    let sumSquared = 0;
+    for (let i = 0; i < len; i++) {
+        const elt = filtered[i];
+        sumSquared += elt * elt;
+    }
+    const avg = s / len;
+    const sd = Math.sqrt((len * sumSquared - s * s) / (len * len));
+    const upper = avg + 3 * sd;
+    const lower = avg - 3 * sd;
+    return {
+        upper,
+        lower,
+        avg,
+        sd,
+    };
+}
+export function filterForPairs(features) {
+    return features.filter(f => f.flags & 2 && !(f.flags & 256) && !(f.flags & 2048));
+}

package/esm/shared/legendUtils.d.ts

@@ -0,0 +1,8 @@
+import type { ColorBy, ModificationTypeWithColor } from './types.ts';
+import type { LegendItem } from '@jbrowse/plugin-linear-genome-view';
+import type { Theme } from '@mui/material';
+export { calculateSvgLegendWidth } from '@jbrowse/plugin-linear-genome-view';
+export type { LegendItem } from '@jbrowse/plugin-linear-genome-view';
+export declare function getPileupLegendItems(colorBy: ColorBy | undefined, theme: Theme): LegendItem[];
+export declare function getSNPCoverageLegendItems(colorBy: ColorBy | undefined, visibleModifications: Map<string, ModificationTypeWithColor>, theme: Theme): LegendItem[];
+export declare function getReadDisplayLegendItems(colorBy: ColorBy | undefined, visibleModifications?: Map<string, ModificationTypeWithColor>): LegendItem[];

package/esm/shared/legendUtils.js

@@ -0,0 +1,123 @@
+import { fillColor } from "./color.js";
+export { calculateSvgLegendWidth } from '@jbrowse/plugin-linear-genome-view';
+const supplementaryItem = {
+    color: fillColor.color_supplementary,
+    label: 'Supplementary/split',
+};
+const unmappedMateItem = {
+    color: fillColor.color_unmapped_mate,
+    label: 'Unmapped mate',
+};
+const orientationItems = [
+    { color: fillColor.color_pair_lr, label: 'Normal pair orientation' },
+    { color: fillColor.color_pair_rr, label: 'Both mates reverse strand' },
+    { color: fillColor.color_pair_rl, label: 'Both mates point outward' },
+    { color: fillColor.color_pair_ll, label: 'Both mates forward strand' },
+];
+const insertSizeItems = [
+    { color: fillColor.color_longinsert, label: 'Long insert' },
+    { color: fillColor.color_shortinsert, label: 'Short insert' },
+    { color: fillColor.color_interchrom, label: 'Inter-chromosomal' },
+];
+const normalInsertItem = {
+    color: fillColor.color_pair_lr,
+    label: 'Normal',
+};
+const orientationLegendItems = [
+    ...orientationItems,
+    unmappedMateItem,
+    supplementaryItem,
+];
+const insertSizeLegendItems = [
+    normalInsertItem,
+    ...insertSizeItems,
+    unmappedMateItem,
+    supplementaryItem,
+];
+const insertSizeAndOrientationLegendItems = [
+    ...orientationItems,
+    ...insertSizeItems,
+    unmappedMateItem,
+    supplementaryItem,
+];
+function getBaseItems(theme) {
+    const { bases, insertion, deletion, hardclip, softclip } = theme.palette;
+    return [
+        { color: bases.A.main, label: 'A' },
+        { color: bases.C.main, label: 'C' },
+        { color: bases.G.main, label: 'G' },
+        { color: bases.T.main, label: 'T' },
+        { color: insertion, label: 'Insertion' },
+        { color: deletion, label: 'Deletion' },
+        { color: hardclip, label: 'Hard clip' },
+        { color: softclip, label: 'Soft clip' },
+    ];
+}
+export function getPileupLegendItems(colorBy, theme) {
+    const colorType = colorBy?.type;
+    if (colorType === 'strand') {
+        return [
+            { color: fillColor.color_fwd_strand, label: 'Forward strand' },
+            { color: fillColor.color_rev_strand, label: 'Reverse strand' },
+            supplementaryItem,
+        ];
+    }
+    else if (colorType === 'stranded') {
+        return [
+            { color: fillColor.color_fwd_strand, label: 'First-of-pair forward' },
+            { color: fillColor.color_rev_strand, label: 'First-of-pair reverse' },
+            supplementaryItem,
+        ];
+    }
+    else if (colorType === 'insertSize') {
+        return insertSizeLegendItems;
+    }
+    else if (colorType === 'pairOrientation') {
+        return orientationLegendItems;
+    }
+    else if (colorType === 'insertSizeAndPairOrientation') {
+        return insertSizeAndOrientationLegendItems;
+    }
+    else {
+        return getBaseItems(theme);
+    }
+}
+export function getSNPCoverageLegendItems(colorBy, visibleModifications, theme) {
+    if (colorBy?.type === 'methylation') {
+        return [
+            { color: 'red', label: 'CpG methylated' },
+            { color: 'blue', label: 'CpG unmethylated' },
+        ];
+    }
+    else if (colorBy?.type === 'modifications') {
+        const items = [];
+        for (const [type, mod] of visibleModifications.entries()) {
+            items.push({ color: mod.color, label: type });
+        }
+        return items;
+    }
+    else {
+        return getBaseItems(theme);
+    }
+}
+export function getReadDisplayLegendItems(colorBy, visibleModifications) {
+    const colorType = colorBy?.type;
+    if (colorType === 'modifications' && visibleModifications) {
+        const items = [];
+        for (const [type, mod] of visibleModifications.entries()) {
+            items.push({ color: mod.color, label: type });
+        }
+        items.push(supplementaryItem);
+        return items;
+    }
+    if (colorType === 'insertSizeAndOrientation') {
+        return insertSizeAndOrientationLegendItems;
+    }
+    if (colorType === 'insertSize') {
+        return insertSizeLegendItems;
+    }
+    if (colorType === 'orientation') {
+        return orientationLegendItems;
+    }
+    return [supplementaryItem];
+}

package/esm/shared/menuItems.d.ts

@@ -0,0 +1,119 @@
+import type { ColorBy } from './types.ts';
+interface LinearReadDisplayModel {
+    setColorScheme: (colorBy: ColorBy) => void;
+}
+export interface ModificationsModel extends LinearReadDisplayModel {
+    modificationsReady: boolean;
+    visibleModificationTypes: string[];
+    modificationThreshold: number;
+    colorBy?: ColorBy;
+}
+export declare function hasModificationsSupport(model: LinearReadDisplayModel): model is ModificationsModel;
+export interface ModificationsMenuOptions {
+    includeMethylation?: boolean;
+}
+export declare function getModificationsSubMenu(model: ModificationsModel, options?: ModificationsMenuOptions): ({
+    label: string;
+    onClick: () => void;
+    type?: undefined;
+} | {
+    type: "divider";
+    label?: undefined;
+    onClick?: undefined;
+})[] | {
+    label: string;
+}[];
+export declare function getModificationsMenuItem(model: ModificationsModel, options?: ModificationsMenuOptions): {
+    label: string;
+    type: "subMenu";
+    subMenu: ({
+        label: string;
+        onClick: () => void;
+        type?: undefined;
+    } | {
+        type: "divider";
+        label?: undefined;
+        onClick?: undefined;
+    })[] | {
+        label: string;
+    }[];
+};
+export declare function getColorSchemeMenuItem(model: LinearReadDisplayModel): {
+    label: string;
+    icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+        muiName: string;
+    };
+    subMenu: ({
+        label: string;
+        type: "subMenu";
+        subMenu: ({
+            label: string;
+            onClick: () => void;
+            type?: undefined;
+        } | {
+            type: "divider";
+            label?: undefined;
+            onClick?: undefined;
+        })[] | {
+            label: string;
+        }[];
+    } | {
+        label: string;
+        onClick: () => void;
+    })[];
+};
+export declare function getFilterByMenuItem(model: unknown): {
+    label: string;
+    icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+        muiName: string;
+    };
+    onClick: () => void;
+};
+interface EditFiltersModel {
+    drawSingletons: boolean;
+    drawProperPairs: boolean;
+    setDrawSingletons: (arg: boolean) => void;
+    setDrawProperPairs: (arg: boolean) => void;
+}
+export declare function getEditFiltersMenuItem(model: EditFiltersModel): {
+    label: string;
+    icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+        muiName: string;
+    };
+    type: "subMenu";
+    subMenu: ({
+        label: string;
+        type: "checkbox";
+        checked: boolean;
+        onClick: () => void;
+    } | {
+        type: "divider";
+        label?: undefined;
+        checked?: undefined;
+        onClick?: undefined;
+    } | {
+        label: string;
+        onClick: () => void;
+        type?: undefined;
+        checked?: undefined;
+    })[];
+};
+interface MismatchDisplayModel {
+    hideMismatches?: boolean;
+    hideSmallIndels?: boolean;
+    hideLargeIndels?: boolean;
+    setHideMismatches: (arg: boolean) => void;
+    setHideSmallIndels: (arg: boolean) => void;
+    setHideLargeIndels: (arg: boolean) => void;
+}
+export declare function getMismatchDisplayMenuItem(model: MismatchDisplayModel): {
+    label: string;
+    type: "subMenu";
+    subMenu: {
+        label: string;
+        type: "radio";
+        checked: boolean | undefined;
+        onClick: () => void;
+    }[];
+};
+export {};