@jbrowse/plugin-variants 4.0.4 → 4.1.3

package/esm/LDDisplay/shared.js

@@ -0,0 +1,467 @@
+import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
+import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes';
+import { getSession } from '@jbrowse/core/util';
+import { cast, types } from '@jbrowse/mobx-state-tree';
+import { NonBlockCanvasDisplayMixin, TrackHeightMixin, } from '@jbrowse/plugin-linear-genome-view';
+import AddFiltersDialog from "../shared/components/AddFiltersDialog.js";
+import LDFilterDialog from "../shared/components/LDFilterDialog.js";
+export default function sharedModelFactory(configSchema) {
+    return types
+        .compose('SharedLDModel', BaseDisplay, TrackHeightMixin(), NonBlockCanvasDisplayMixin(), types.model({
+        configuration: ConfigurationReference(configSchema),
+        minorAlleleFrequencyFilterSetting: types.maybe(types.number),
+        lengthCutoffFilterSetting: types.maybe(types.number),
+        lineZoneHeightSetting: types.maybe(types.number),
+        ldMetricSetting: types.maybe(types.string),
+        colorSchemeSetting: types.maybe(types.string),
+        showLegendSetting: types.maybe(types.boolean),
+        showLDTriangleSetting: types.maybe(types.boolean),
+        showRecombinationSetting: types.maybe(types.boolean),
+        recombinationZoneHeightSetting: types.maybe(types.number),
+        fitToHeightSetting: types.maybe(types.boolean),
+        hweFilterThresholdSetting: types.maybe(types.number),
+        callRateFilterSetting: types.maybe(types.number),
+        showVerticalGuidesSetting: types.maybe(types.boolean),
+        showLabelsSetting: types.maybe(types.boolean),
+        tickHeightSetting: types.maybe(types.number),
+        useGenomicPositionsSetting: types.maybe(types.boolean),
+        signedLDSetting: types.maybe(types.boolean),
+        jexlFiltersSetting: types.maybe(types.array(types.string)),
+    }))
+        .volatile(() => ({
+        flatbush: undefined,
+        flatbushItems: [],
+        snps: [],
+        maxScore: 1,
+        yScalar: 1,
+        cellWidth: 0,
+        error: undefined,
+        filterStats: undefined,
+        recombination: undefined,
+    }))
+        .actions(self => ({
+        setFlatbushData(flatbush, items, snps, maxScore, yScalar, cellWidth) {
+            self.flatbush = flatbush;
+            self.flatbushItems = items;
+            self.snps = snps;
+            self.maxScore = maxScore;
+            self.yScalar = yScalar;
+            self.cellWidth = cellWidth;
+        },
+        setLineZoneHeight(n) {
+            self.lineZoneHeightSetting = Math.max(0, n);
+        },
+        setError(error) {
+            self.error = error;
+        },
+        reload() {
+            self.error = undefined;
+        },
+        setMafFilter(arg) {
+            self.minorAlleleFrequencyFilterSetting = arg;
+        },
+        setLengthCutoffFilter(arg) {
+            self.lengthCutoffFilterSetting = arg;
+        },
+        setLDMetric(metric) {
+            self.ldMetricSetting = metric;
+        },
+        setColorScheme(scheme) {
+            self.colorSchemeSetting = scheme;
+        },
+        setShowLegend(show) {
+            self.showLegendSetting = show;
+        },
+        setShowLDTriangle(show) {
+            self.showLDTriangleSetting = show;
+        },
+        setShowRecombination(show) {
+            self.showRecombinationSetting = show;
+        },
+        setRecombinationZoneHeight(n) {
+            self.recombinationZoneHeightSetting = Math.max(20, n);
+        },
+        setFitToHeight(value) {
+            self.fitToHeightSetting = value;
+        },
+        setHweFilter(threshold) {
+            self.hweFilterThresholdSetting = threshold;
+        },
+        setCallRateFilter(threshold) {
+            self.callRateFilterSetting = threshold;
+        },
+        setFilterStats(stats) {
+            self.filterStats = stats;
+        },
+        setRecombination(data) {
+            self.recombination = data;
+        },
+        setShowVerticalGuides(show) {
+            self.showVerticalGuidesSetting = show;
+        },
+        setShowLabels(show) {
+            self.showLabelsSetting = show;
+        },
+        setTickHeight(height) {
+            self.tickHeightSetting = Math.max(0, height);
+        },
+        setUseGenomicPositions(value) {
+            self.useGenomicPositionsSetting = value;
+        },
+        setSignedLD(value) {
+            self.signedLDSetting = value;
+        },
+        setJexlFilters(filters) {
+            self.jexlFiltersSetting = cast(filters);
+        },
+    }))
+        .views(self => ({
+        get blockType() {
+            return 'dynamicBlocks';
+        },
+        get prefersOffset() {
+            return true;
+        },
+        get rendererTypeName() {
+            return 'LDRenderer';
+        },
+        get rendererConfig() {
+            return getConf(self, 'renderer');
+        },
+        get regionTooLarge() {
+            return false;
+        },
+        get minorAlleleFrequencyFilter() {
+            return (self.minorAlleleFrequencyFilterSetting ??
+                getConf(self, 'minorAlleleFrequencyFilter'));
+        },
+        get lengthCutoffFilter() {
+            return (self.lengthCutoffFilterSetting ?? getConf(self, 'lengthCutoffFilter'));
+        },
+        get lineZoneHeight() {
+            return self.lineZoneHeightSetting ?? getConf(self, 'lineZoneHeight');
+        },
+        get ldMetric() {
+            return self.ldMetricSetting ?? getConf(self, 'ldMetric');
+        },
+        get colorScheme() {
+            const setting = self.colorSchemeSetting;
+            if (setting !== undefined) {
+                return setting || undefined;
+            }
+            const conf = getConf(self, 'colorScheme');
+            return conf || undefined;
+        },
+        get showLegend() {
+            return self.showLegendSetting ?? getConf(self, 'showLegend');
+        },
+        get showLDTriangle() {
+            return self.showLDTriangleSetting ?? getConf(self, 'showLDTriangle');
+        },
+        get showRecombination() {
+            return (self.showRecombinationSetting ?? getConf(self, 'showRecombination'));
+        },
+        get recombinationZoneHeight() {
+            return (self.recombinationZoneHeightSetting ??
+                getConf(self, 'recombinationZoneHeight'));
+        },
+        get fitToHeight() {
+            return self.fitToHeightSetting ?? getConf(self, 'fitToHeight');
+        },
+        get hweFilterThreshold() {
+            return (self.hweFilterThresholdSetting ?? getConf(self, 'hweFilterThreshold'));
+        },
+        get callRateFilter() {
+            return self.callRateFilterSetting ?? getConf(self, 'callRateFilter');
+        },
+        get showVerticalGuides() {
+            return (self.showVerticalGuidesSetting ?? getConf(self, 'showVerticalGuides'));
+        },
+        get showLabels() {
+            return self.showLabelsSetting ?? getConf(self, 'showLabels');
+        },
+        get tickHeight() {
+            return self.tickHeightSetting ?? getConf(self, 'tickHeight');
+        },
+        get useGenomicPositions() {
+            return (self.useGenomicPositionsSetting ??
+                getConf(self, 'useGenomicPositions'));
+        },
+        get signedLD() {
+            return self.signedLDSetting ?? getConf(self, 'signedLD');
+        },
+        get jexlFilters() {
+            return self.jexlFiltersSetting ?? getConf(self, 'jexlFilters');
+        },
+        get isPrecomputedLD() {
+            const adapterType = self.adapterConfig?.type;
+            return (adapterType === 'PlinkLDAdapter' ||
+                adapterType === 'PlinkLDTabixAdapter' ||
+                adapterType === 'LdmatAdapter');
+        },
+        regionCannotBeRendered() {
+            return null;
+        },
+    }))
+        .views(self => ({
+        get ldCanvasHeight() {
+            return Math.max(50, self.height - self.lineZoneHeight);
+        },
+    }))
+        .views(self => {
+        const { renderProps: superRenderProps } = self;
+        return {
+            filterMenuItems() {
+                if (self.isPrecomputedLD) {
+                    return [];
+                }
+                return [
+                    {
+                        label: 'LD-specific filters...',
+                        onClick: () => {
+                            getSession(self).queueDialog(handleClose => [
+                                LDFilterDialog,
+                                {
+                                    model: self,
+                                    handleClose,
+                                },
+                            ]);
+                        },
+                    },
+                    {
+                        label: 'General JEXL filters...',
+                        onClick: () => {
+                            getSession(self).queueDialog(handleClose => [
+                                AddFiltersDialog,
+                                {
+                                    model: self,
+                                    handleClose,
+                                },
+                            ]);
+                        },
+                    },
+                ];
+            },
+            renderProps() {
+                return {
+                    ...superRenderProps(),
+                    config: self.rendererConfig,
+                    ...(self.fitToHeight ? { displayHeight: self.ldCanvasHeight } : {}),
+                    minorAlleleFrequencyFilter: self.minorAlleleFrequencyFilter,
+                    lengthCutoffFilter: self.lengthCutoffFilter,
+                    hweFilterThreshold: self.hweFilterThreshold,
+                    callRateFilter: self.callRateFilter,
+                    jexlFilters: self.jexlFilters,
+                    ldMetric: self.ldMetric,
+                    colorScheme: self.colorScheme,
+                    fitToHeight: self.fitToHeight,
+                    useGenomicPositions: self.useGenomicPositions,
+                    signedLD: self.signedLD,
+                };
+            },
+        };
+    })
+        .views(self => {
+        const { trackMenuItems: superTrackMenuItems } = self;
+        return {
+            trackMenuItems() {
+                return [
+                    ...superTrackMenuItems(),
+                    {
+                        label: 'LD metric',
+                        type: 'subMenu',
+                        subMenu: [
+                            {
+                                label: 'R² (squared correlation)',
+                                type: 'radio',
+                                checked: self.ldMetric === 'r2',
+                                onClick: () => {
+                                    self.setLDMetric('r2');
+                                },
+                            },
+                            {
+                                label: "D' (normalized D)",
+                                type: 'radio',
+                                checked: self.ldMetric === 'dprime',
+                                onClick: () => {
+                                    self.setLDMetric('dprime');
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        label: 'Show...',
+                        type: 'subMenu',
+                        subMenu: [
+                            {
+                                label: 'Show LD triangle',
+                                type: 'checkbox',
+                                checked: self.showLDTriangle,
+                                onClick: () => {
+                                    self.setShowLDTriangle(!self.showLDTriangle);
+                                },
+                            },
+                            {
+                                label: 'Show recombination track',
+                                helpText: 'Displays 1-r² between neighboring SNPs only (not all pairwise comparisons). Peaks indicate haplotype block boundaries where historical recombination has broken down LD between adjacent variants.',
+                                type: 'checkbox',
+                                checked: self.showRecombination,
+                                onClick: () => {
+                                    self.setShowRecombination(!self.showRecombination);
+                                },
+                            },
+                            {
+                                label: 'Show legend',
+                                type: 'checkbox',
+                                checked: self.showLegend,
+                                onClick: () => {
+                                    self.setShowLegend(!self.showLegend);
+                                },
+                            },
+                            {
+                                label: 'LD triangle adjusted to display height',
+                                type: 'checkbox',
+                                checked: self.fitToHeight,
+                                onClick: () => {
+                                    self.setFitToHeight(!self.fitToHeight);
+                                },
+                            },
+                            {
+                                label: 'Vertical guides on hover',
+                                type: 'checkbox',
+                                checked: self.showVerticalGuides,
+                                onClick: () => {
+                                    self.setShowVerticalGuides(!self.showVerticalGuides);
+                                },
+                            },
+                            {
+                                label: 'Variant labels',
+                                type: 'checkbox',
+                                checked: self.showLabels,
+                                onClick: () => {
+                                    self.setShowLabels(!self.showLabels);
+                                },
+                            },
+                            {
+                                label: 'Use genomic positions for cell sizes',
+                                type: 'checkbox',
+                                checked: self.useGenomicPositions,
+                                onClick: () => {
+                                    self.setUseGenomicPositions(!self.useGenomicPositions);
+                                },
+                            },
+                            ...(self.isPrecomputedLD
+                                ? []
+                                : [
+                                    {
+                                        label: 'Show signed LD values (-1 to 1)',
+                                        helpText: "When enabled, shows R (correlation) instead of R², and preserves the sign of D'. Positive values indicate alleles tend to co-occur (coupling), negative values indicate alleles tend to be on different haplotypes (repulsion).",
+                                        type: 'checkbox',
+                                        checked: self.signedLD,
+                                        onClick: () => {
+                                            self.setSignedLD(!self.signedLD);
+                                        },
+                                    },
+                                ]),
+                        ],
+                    },
+                    ...(self.isPrecomputedLD
+                        ? []
+                        : [
+                            {
+                                label: 'Filter by...',
+                                type: 'subMenu',
+                                subMenu: self.filterMenuItems(),
+                            },
+                        ]),
+                ];
+            },
+            async renderSvg(opts) {
+                const { renderSvg } = await import("./renderSvg.js");
+                return renderSvg(self, opts);
+            },
+        };
+    })
+        .actions(self => ({
+        afterAttach() {
+            ;
+            (async () => {
+                try {
+                    const { doAfterAttach } = await import("./afterAttach.js");
+                    doAfterAttach(self);
+                }
+                catch (e) {
+                    console.error(e);
+                    getSession(self).notifyError(`${e}`, e);
+                }
+            })();
+        },
+    }))
+        .postProcessSnapshot(snap => {
+        if (!snap) {
+            return snap;
+        }
+        const { minorAlleleFrequencyFilterSetting, lengthCutoffFilterSetting, lineZoneHeightSetting, ldMetricSetting, colorSchemeSetting, showLegendSetting, showLDTriangleSetting, showRecombinationSetting, recombinationZoneHeightSetting, fitToHeightSetting, hweFilterThresholdSetting, callRateFilterSetting, showVerticalGuidesSetting, showLabelsSetting, tickHeightSetting, useGenomicPositionsSetting, signedLDSetting, jexlFiltersSetting, ...rest } = snap;
+        return {
+            ...rest,
+            ...(minorAlleleFrequencyFilterSetting !== undefined &&
+                minorAlleleFrequencyFilterSetting !== 0.1
+                ? { minorAlleleFrequencyFilterSetting }
+                : {}),
+            ...(lengthCutoffFilterSetting !== undefined &&
+                lengthCutoffFilterSetting !== Number.MAX_SAFE_INTEGER
+                ? { lengthCutoffFilterSetting }
+                : {}),
+            ...(lineZoneHeightSetting !== undefined && lineZoneHeightSetting !== 100
+                ? { lineZoneHeightSetting }
+                : {}),
+            ...(ldMetricSetting !== undefined && ldMetricSetting !== 'r2'
+                ? { ldMetricSetting }
+                : {}),
+            ...(colorSchemeSetting !== undefined && colorSchemeSetting !== ''
+                ? { colorSchemeSetting }
+                : {}),
+            ...(showLegendSetting !== undefined && showLegendSetting
+                ? { showLegendSetting }
+                : {}),
+            ...(showLDTriangleSetting !== undefined && !showLDTriangleSetting
+                ? { showLDTriangleSetting }
+                : {}),
+            ...(showRecombinationSetting !== undefined && showRecombinationSetting
+                ? { showRecombinationSetting }
+                : {}),
+            ...(recombinationZoneHeightSetting !== undefined &&
+                recombinationZoneHeightSetting !== 50
+                ? { recombinationZoneHeightSetting }
+                : {}),
+            ...(fitToHeightSetting !== undefined && fitToHeightSetting
+                ? { fitToHeightSetting }
+                : {}),
+            ...(hweFilterThresholdSetting !== undefined &&
+                hweFilterThresholdSetting !== 0.001
+                ? { hweFilterThresholdSetting }
+                : {}),
+            ...(callRateFilterSetting !== undefined && callRateFilterSetting !== 0
+                ? { callRateFilterSetting }
+                : {}),
+            ...(showVerticalGuidesSetting !== undefined &&
+                !showVerticalGuidesSetting
+                ? { showVerticalGuidesSetting }
+                : {}),
+            ...(showLabelsSetting !== undefined && showLabelsSetting
+                ? { showLabelsSetting }
+                : {}),
+            ...(tickHeightSetting !== undefined && tickHeightSetting !== 6
+                ? { tickHeightSetting }
+                : {}),
+            ...(useGenomicPositionsSetting !== undefined &&
+                useGenomicPositionsSetting
+                ? { useGenomicPositionsSetting }
+                : {}),
+            ...(signedLDSetting !== undefined && signedLDSetting
+                ? { signedLDSetting }
+                : {}),
+            ...(jexlFiltersSetting?.length ? { jexlFiltersSetting } : {}),
+        };
+    });
+}