@jbrowse/plugin-variants 4.0.3 → 4.1.1

package/esm/shared/getMultiVariantSourcesAutorun.d.ts

@@ -4,6 +4,7 @@ import type { StopToken } from '@jbrowse/core/util/stopToken';
 export declare function getMultiVariantSourcesAutorun(self: {
     configuration: AnyConfigurationModel;
     adapterConfig: AnyConfigurationModel;
+    isMinimized: boolean;
     adapterProps: () => Record<string, unknown>;
     setSourcesLoading: (aborter: StopToken) => void;
     setError: (error: unknown) => void;

package/esm/shared/getMultiVariantSourcesAutorun.js

@@ -7,6 +7,9 @@ import { autorun } from 'mobx';
 export function getMultiVariantSourcesAutorun(self) {
     addDisposer(self, autorun(async () => {
         try {
+            if (!isAlive(self) || self.isMinimized) {
+                return;
+            }
             const view = getContainingView(self);
             if (!view.initialized) {
                 return;

package/esm/shared/getSources.d.ts

@@ -1,15 +1,11 @@
 import type { SampleInfo, Source } from './types.ts';
+export declare function expandSourcesToHaplotypes({ sources, sampleInfo, }: {
+    sources: Source[];
+    sampleInfo: Record<string, SampleInfo>;
+}): Source[];
 export declare function getSources({ sources, layout, renderingMode, sampleInfo, }: {
     sources: Source[];
     layout?: Source[];
     renderingMode: string;
     sampleInfo?: Record<string, SampleInfo>;
-}): {
-    label: string;
-    id: string;
-    baseUri?: string;
-    name: string;
-    color?: string;
-    group?: string;
-    HP?: number;
-}[];
+}): Source[];

package/esm/shared/getSources.js

@@ -1,31 +1,36 @@
+function makeHaplotypeSources(source, ploidy) {
+    const results = [];
+    for (let i = 0; i < ploidy; i++) {
+        const name = `${source.name} HP${i}`;
+        results.push({ ...source, name, baseName: source.name, HP: i });
+    }
+    return results;
+}
+export function expandSourcesToHaplotypes({ sources, sampleInfo, }) {
+    return sources.flatMap(source => {
+        const ploidy = sampleInfo[source.name]?.maxPloidy ?? 2;
+        return makeHaplotypeSources(source, ploidy);
+    });
+}
 export function getSources({ sources, layout = sources, renderingMode, sampleInfo, }) {
-    const rows = [];
     const sourceMap = Object.fromEntries(sources.map(s => [s.name, s]));
-    for (const row of layout) {
+    return layout.flatMap(row => {
+        const sampleName = row.baseName ?? row.name;
+        const baseSource = sourceMap[sampleName];
+        if (!baseSource) {
+            return [];
+        }
+        const merged = { ...baseSource, ...row };
         if (renderingMode === 'phased') {
-            const info = sampleInfo?.[row.name];
-            if (info?.isPhased) {
-                const ploidy = info.maxPloidy;
-                for (let i = 0; i < ploidy; i++) {
-                    const id = `${row.name} HP${i}`;
-                    rows.push({
-                        ...sourceMap[row.name],
-                        ...row,
-                        label: id,
-                        HP: i,
-                        id: id,
-                    });
-                }
+            if (row.HP !== undefined) {
+                return [{ ...merged, baseName: sampleName }];
             }
+            const ploidy = sampleInfo?.[row.name]?.maxPloidy;
+            if (ploidy) {
+                return makeHaplotypeSources(merged, ploidy);
+            }
+            return [];
         }
-        else {
-            rows.push({
-                ...sourceMap[row.name],
-                ...row,
-                label: row.name,
-                id: row.name,
-            });
-        }
-    }
-    return rows;
+        return [merged];
+    });
 }

package/esm/shared/mafFilterUtils.d.ts

@@ -0,0 +1,5 @@
+import type { MenuItem } from '@jbrowse/core/ui';
+export declare function createMAFFilterMenuItem(model: {
+    minorAlleleFrequencyFilter?: number;
+    setMafFilter: (arg: number) => void;
+}): MenuItem;

package/esm/shared/mafFilterUtils.js

@@ -0,0 +1,17 @@
+import { lazy } from 'react';
+import { getSession } from '@jbrowse/core/util';
+const MAFFilterDialog = lazy(() => import("./components/MAFFilterDialog.js"));
+export function createMAFFilterMenuItem(model) {
+    return {
+        label: 'Minor allele frequency',
+        onClick: () => {
+            getSession(model).queueDialog(handleClose => [
+                MAFFilterDialog,
+                {
+                    model,
+                    handleClose,
+                },
+            ]);
+        },
+    };
+}

package/esm/shared/minorAlleleFrequencyUtils.d.ts

@@ -1,4 +1,6 @@
+import type VcfFeature from '../VcfFeature/index.ts';
 import type { Feature, LastStopTokenCheck } from '@jbrowse/core/util';
+export declare function calculateAlleleCountsFast(feature: VcfFeature): Record<string, number>;
 export declare function calculateAlleleCounts(genotypes: Record<string, string>, cacheSplit: Record<string, string[]>): Record<string, number>;
 export declare function calculateMinorAlleleFrequency(alleleCounts: Record<string, number>): number;
 export declare function getFeaturesThatPassMinorAlleleFrequencyFilter({ features, minorAlleleFrequencyFilter, lengthCutoffFilter, lastCheck, genotypesCache, splitCache, }: {

package/esm/shared/minorAlleleFrequencyUtils.js

@@ -1,28 +1,263 @@
 import { checkStopToken2 } from '@jbrowse/core/util/stopToken';
+const GENOTYPE_SPLIT_REGEX = /[/|]/;
+const SLASH = 47;
+const PIPE = 124;
+export function calculateAlleleCountsFast(feature) {
+    let count0 = 0;
+    let count1 = 0;
+    let count2 = 0;
+    let count3 = 0;
+    let countDot = 0;
+    const otherCounts = {};
+    feature.processGenotypes((str, start, end) => {
+        const len = end - start;
+        if (len === 3) {
+            const sep = str.charCodeAt(start + 1);
+            if (sep === SLASH || sep === PIPE) {
+                const c0 = str.charCodeAt(start);
+                const c1 = str.charCodeAt(start + 2);
+                if (c0 === 48) {
+                    count0++;
+                }
+                else if (c0 === 49) {
+                    count1++;
+                }
+                else if (c0 === 50) {
+                    count2++;
+                }
+                else if (c0 === 51) {
+                    count3++;
+                }
+                else if (c0 === 46) {
+                    countDot++;
+                }
+                else {
+                    const a0 = str[start];
+                    otherCounts[a0] = (otherCounts[a0] || 0) + 1;
+                }
+                if (c1 === 48) {
+                    count0++;
+                }
+                else if (c1 === 49) {
+                    count1++;
+                }
+                else if (c1 === 50) {
+                    count2++;
+                }
+                else if (c1 === 51) {
+                    count3++;
+                }
+                else if (c1 === 46) {
+                    countDot++;
+                }
+                else {
+                    const a1 = str[start + 2];
+                    otherCounts[a1] = (otherCounts[a1] || 0) + 1;
+                }
+                return;
+            }
+        }
+        if (len === 1) {
+            const c = str.charCodeAt(start);
+            if (c === 48) {
+                count0++;
+            }
+            else if (c === 49) {
+                count1++;
+            }
+            else if (c === 50) {
+                count2++;
+            }
+            else if (c === 51) {
+                count3++;
+            }
+            else if (c === 46) {
+                countDot++;
+            }
+            else {
+                const a = str[start];
+                otherCounts[a] = (otherCounts[a] || 0) + 1;
+            }
+            return;
+        }
+        const gt = str.slice(start, end);
+        const alleles = gt.split(GENOTYPE_SPLIT_REGEX);
+        for (const allele of alleles) {
+            if (allele === '0') {
+                count0++;
+            }
+            else if (allele === '1') {
+                count1++;
+            }
+            else if (allele === '2') {
+                count2++;
+            }
+            else if (allele === '3') {
+                count3++;
+            }
+            else if (allele === '.') {
+                countDot++;
+            }
+            else {
+                otherCounts[allele] = (otherCounts[allele] || 0) + 1;
+            }
+        }
+    });
+    const result = {};
+    if (count0 > 0) {
+        result['0'] = count0;
+    }
+    if (count1 > 0) {
+        result['1'] = count1;
+    }
+    if (count2 > 0) {
+        result['2'] = count2;
+    }
+    if (count3 > 0) {
+        result['3'] = count3;
+    }
+    if (countDot > 0) {
+        result['.'] = countDot;
+    }
+    for (const key in otherCounts) {
+        result[key] = otherCounts[key];
+    }
+    return result;
+}
 export function calculateAlleleCounts(genotypes, cacheSplit) {
-    const alleleCounts = {};
-    const vals = Object.values(genotypes);
-    for (const val of vals) {
-        const genotype = val;
-        const alleles = cacheSplit[genotype] ?? (cacheSplit[genotype] = genotype.split(/[/|]/));
+    let count0 = 0;
+    let count1 = 0;
+    let count2 = 0;
+    let count3 = 0;
+    let countDot = 0;
+    const otherCounts = {};
+    for (const key in genotypes) {
+        const genotype = genotypes[key];
+        const len = genotype.length;
+        if (len === 3) {
+            const sep = genotype[1];
+            if (sep === '/' || sep === '|') {
+                const a0 = genotype[0];
+                const a1 = genotype[2];
+                if (a0 === '0') {
+                    count0++;
+                }
+                else if (a0 === '1') {
+                    count1++;
+                }
+                else if (a0 === '2') {
+                    count2++;
+                }
+                else if (a0 === '3') {
+                    count3++;
+                }
+                else if (a0 === '.') {
+                    countDot++;
+                }
+                else {
+                    otherCounts[a0] = (otherCounts[a0] || 0) + 1;
+                }
+                if (a1 === '0') {
+                    count0++;
+                }
+                else if (a1 === '1') {
+                    count1++;
+                }
+                else if (a1 === '2') {
+                    count2++;
+                }
+                else if (a1 === '3') {
+                    count3++;
+                }
+                else if (a1 === '.') {
+                    countDot++;
+                }
+                else {
+                    otherCounts[a1] = (otherCounts[a1] || 0) + 1;
+                }
+                continue;
+            }
+        }
+        if (len === 1) {
+            if (genotype === '0') {
+                count0++;
+            }
+            else if (genotype === '1') {
+                count1++;
+            }
+            else if (genotype === '2') {
+                count2++;
+            }
+            else if (genotype === '3') {
+                count3++;
+            }
+            else if (genotype === '.') {
+                countDot++;
+            }
+            else {
+                otherCounts[genotype] = (otherCounts[genotype] || 0) + 1;
+            }
+            continue;
+        }
+        let alleles = cacheSplit[genotype];
+        if (!alleles) {
+            alleles = genotype.split(GENOTYPE_SPLIT_REGEX);
+            cacheSplit[genotype] = alleles;
+        }
         for (const allele of alleles) {
-            const a = allele;
-            alleleCounts[a] = (alleleCounts[a] || 0) + 1;
+            if (allele === '0') {
+                count0++;
+            }
+            else if (allele === '1') {
+                count1++;
+            }
+            else if (allele === '2') {
+                count2++;
+            }
+            else if (allele === '3') {
+                count3++;
+            }
+            else if (allele === '.') {
+                countDot++;
+            }
+            else {
+                otherCounts[allele] = (otherCounts[allele] || 0) + 1;
+            }
         }
     }
-    return alleleCounts;
+    const result = {};
+    if (count0 > 0) {
+        result['0'] = count0;
+    }
+    if (count1 > 0) {
+        result['1'] = count1;
+    }
+    if (count2 > 0) {
+        result['2'] = count2;
+    }
+    if (count3 > 0) {
+        result['3'] = count3;
+    }
+    if (countDot > 0) {
+        result['.'] = countDot;
+    }
+    for (const key in otherCounts) {
+        result[key] = otherCounts[key];
+    }
+    return result;
 }
 export function calculateMinorAlleleFrequency(alleleCounts) {
     let firstMax = 0;
     let secondMax = 0;
     let total = 0;
-    for (const count of Object.values(alleleCounts)) {
+    for (const key in alleleCounts) {
+        const count = alleleCounts[key];
         total += count;
         if (count > firstMax) {
             secondMax = firstMax;
             firstMax = count;
         }
-        else if (count > secondMax && count !== firstMax) {
+        else if (count > secondMax) {
             secondMax = count;
         }
     }
@@ -31,7 +266,8 @@ export function calculateMinorAlleleFrequency(alleleCounts) {
 function getMostFrequentAlt(alleleCounts) {
     let mostFrequentAlt;
     let max = 0;
-    for (const [alt, altCount] of Object.entries(alleleCounts)) {
+    for (const alt in alleleCounts) {
+        const altCount = alleleCounts[alt];
         if (alt !== '.' && alt !== '0' && altCount > max) {
             mostFrequentAlt = alt;
             max = altCount;
@@ -43,13 +279,19 @@ export function getFeaturesThatPassMinorAlleleFrequencyFilter({ features, minorA
     const results = [];
     for (const feature of features) {
         if (feature.get('end') - feature.get('start') <= lengthCutoffFilter) {
-            const featureId = feature.id();
-            let genotypes = genotypesCache?.get(featureId);
-            if (!genotypes) {
-                genotypes = feature.get('genotypes');
-                genotypesCache?.set(featureId, genotypes);
+            let alleleCounts;
+            if ('processGenotypes' in feature) {
+                alleleCounts = calculateAlleleCountsFast(feature);
+            }
+            else {
+                const featureId = feature.id();
+                let genotypes = genotypesCache?.get(featureId);
+                if (!genotypes) {
+                    genotypes = feature.get('genotypes');
+                    genotypesCache?.set(featureId, genotypes);
+                }
+                alleleCounts = calculateAlleleCounts(genotypes, splitCache);
             }
-            const alleleCounts = calculateAlleleCounts(genotypes, splitCache);
             if (calculateMinorAlleleFrequency(alleleCounts) >=
                 minorAlleleFrequencyFilter) {
                 results.push({

package/esm/shared/setupMultiVariantAutoruns.js

@@ -1,3 +1,4 @@
+import { setupColorByAutorun } from "./colorByAutorun.js";
 import { getMultiVariantFeaturesAutorun } from "./getMultiVariantFeaturesAutorun.js";
 import { getMultiVariantSourcesAutorun } from "./getMultiVariantSourcesAutorun.js";
 import { setupTreeDrawingAutorun } from "./treeDrawingAutorun.js";
@@ -5,4 +6,5 @@ export function setupMultiVariantAutoruns(self) {
     getMultiVariantSourcesAutorun(self);
     getMultiVariantFeaturesAutorun(self);
     setupTreeDrawingAutorun(self);
+    setupColorByAutorun(self);
 }

package/esm/shared/treeDrawingAutorun.d.ts

@@ -11,6 +11,7 @@ interface TreeDrawingModel {
     totalHeight: number;
     hoveredTreeNode?: HoveredTreeNode;
     sources?: Source[];
+    isMinimized: boolean;
 }
 export declare function setupTreeDrawingAutorun(self: TreeDrawingModel): void;
 export {};

package/esm/shared/treeDrawingAutorun.js

@@ -1,8 +1,11 @@
 import { getContainingView } from '@jbrowse/core/util';
-import { addDisposer } from '@jbrowse/mobx-state-tree';
+import { addDisposer, isAlive } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
 export function setupTreeDrawingAutorun(self) {
     addDisposer(self, autorun(function treeDrawAutorun() {
+        if (!isAlive(self) || self.isMinimized) {
+            return;
+        }
         const { treeCanvas, hierarchy, treeAreaWidth, height, scrollTop, totalHeight: _totalHeight, } = self;
         if (!treeCanvas || !hierarchy) {
             return;
@@ -34,6 +37,9 @@ export function setupTreeDrawingAutorun(self) {
         name: 'TreeDraw',
     }));
     addDisposer(self, autorun(function treeHoverAutorun() {
+        if (!isAlive(self) || self.isMinimized) {
+            return;
+        }
         const { mouseoverCanvas, hierarchy, rowHeight, hoveredTreeNode, height, scrollTop, sources, totalHeight, } = self;
         if (!mouseoverCanvas) {
             return;

package/esm/shared/types.d.ts

@@ -3,11 +3,10 @@ import type { Feature } from '@jbrowse/core/util';
 export interface Source {
     baseUri?: string;
     name: string;
-    label?: string;
+    baseName?: string;
     color?: string;
     group?: string;
     HP?: number;
-    id?: string;
     [key: string]: unknown;
 }
 export interface SampleInfo {

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@jbrowse/plugin-variants",
-  "version": "4.0.3",
+  "version": "4.1.1",
+  "type": "module",
   "description": "JBrowse 2 variant adapters, tracks, etc.",
   "keywords": [
     "jbrowse",
@@ -23,24 +24,24 @@
     "@flatten-js/interval-tree": "^2.0.3",
     "@gmod/hclust": "^1.0.7",
     "@gmod/tabix": "^3.2.2",
-    "@gmod/vcf": "^6.1.0",
+    "@gmod/vcf": "^7.0.0",
     "@jbrowse/mobx-state-tree": "^5.5.0",
-    "@mui/icons-material": "^7.3.6",
-    "@mui/material": "^7.3.6",
-    "@mui/x-charts-vendor": "^8.23.0",
-    "@mui/x-data-grid": "^8.23.0",
+    "@mui/icons-material": "^7.3.7",
+    "@mui/material": "^7.3.7",
+    "@mui/x-charts-vendor": "^8.26.0",
+    "@mui/x-data-grid": "^8.26.0",
+    "@types/file-saver-es": "^2.0.3",
     "copy-to-clipboard": "^3.3.3",
     "escape-html": "^1.0.3",
     "fast-deep-equal": "^3.1.3",
-    "@types/file-saver-es": "^2.0.3",
     "file-saver-es": "^2.0.5",
     "mobx": "^6.15.0",
     "mobx-react": "^9.2.1",
     "rxjs": "^7.8.2",
-    "@jbrowse/plugin-circular-view": "^4.0.3",
-    "@jbrowse/core": "^4.0.3",
-    "@jbrowse/plugin-linear-genome-view": "^4.0.3",
-    "@jbrowse/sv-core": "^4.0.3"
+    "@jbrowse/core": "^4.1.1",
+    "@jbrowse/plugin-linear-genome-view": "^4.1.1",
+    "@jbrowse/sv-core": "^4.1.1",
+    "@jbrowse/plugin-circular-view": "^4.1.1"
   },
   "peerDependencies": {
     "react": ">=18.0.0"