@jbrowse/plugin-variants 3.0.5 → 3.2.0

package/dist/shared/getSources.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSources = getSources;
+function getSources({ sources, layout = sources, renderingMode, sampleInfo, }) {
+    const rows = [];
+    const sourceMap = Object.fromEntries(sources.map(s => [s.name, s]));
+    for (const row of layout) {
+        if (renderingMode === 'phased') {
+            const info = sampleInfo === null || sampleInfo === void 0 ? void 0 : sampleInfo[row.name];
+            if (info === null || info === void 0 ? void 0 : 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,
+                    });
+                }
+            }
+        }
+        else {
+            rows.push({
+                ...sourceMap[row.name],
+                ...row,
+                label: row.name,
+                id: row.name,
+            });
+        }
+    }
+    return rows;
+}

package/dist/shared/minorAlleleFrequencyUtils.d.ts

@@ -1,11 +1,9 @@
 import type { Feature } from '@jbrowse/core/util';
 export declare function findSecondLargestNumber(arr: Iterable<number>): number;
-export declare function calculateAlleleCounts(feat: Feature): {
-    alleleCounts: Map<any, any>;
-    mostFrequentAlt: any;
-};
+export declare function calculateAlleleCounts(feat: Feature): Map<any, any>;
 export declare function calculateMinorAlleleFrequency(alleleCounts: Map<string, number>): number;
-export declare function getFeaturesThatPassMinorAlleleFrequencyFilter(feats: Iterable<Feature>, minorAlleleFrequencyFilter: number): {
+export declare function getFeaturesThatPassMinorAlleleFrequencyFilter(feats: Iterable<Feature>, minorAlleleFrequencyFilter: number, lengthCutoffFilter?: number): {
     feature: Feature;
     mostFrequentAlt: string;
+    alleleCounts: Map<string, number>;
 }[];

package/dist/shared/minorAlleleFrequencyUtils.js

@@ -28,6 +28,13 @@ function calculateAlleleCounts(feat) {
             alleleCounts.set(allele, (alleleCounts.get(allele) || 0) + 1);
         }
     }
+    return alleleCounts;
+}
+function calculateMinorAlleleFrequency(alleleCounts) {
+    return (findSecondLargestNumber(alleleCounts.values()) /
+        ((0, util_1.sum)(alleleCounts.values()) || 1));
+}
+function getMostFrequentAlt(alleleCounts) {
     let mostFrequentAlt;
     let max = 0;
     for (const [alt, altCount] of alleleCounts.entries()) {
@@ -38,22 +45,20 @@ function calculateAlleleCounts(feat) {
             }
         }
     }
-    return { alleleCounts, mostFrequentAlt };
-}
-function calculateMinorAlleleFrequency(alleleCounts) {
-    return (findSecondLargestNumber(alleleCounts.values()) /
-        ((0, util_1.sum)(alleleCounts.values()) || 1));
+    return mostFrequentAlt;
 }
-function getFeaturesThatPassMinorAlleleFrequencyFilter(feats, minorAlleleFrequencyFilter) {
+function getFeaturesThatPassMinorAlleleFrequencyFilter(feats, minorAlleleFrequencyFilter, lengthCutoffFilter = 10) {
     const results = [];
     for (const feature of feats) {
-        if (feature.get('end') - feature.get('start') <= 10) {
-            const { mostFrequentAlt, alleleCounts } = calculateAlleleCounts(feature);
+        if (feature.get('end') - feature.get('start') <= lengthCutoffFilter) {
+            const alleleCounts = calculateAlleleCounts(feature);
             if (calculateMinorAlleleFrequency(alleleCounts) >=
                 minorAlleleFrequencyFilter) {
+                const mostFrequentAlt = getMostFrequentAlt(alleleCounts);
                 results.push({
                     feature,
                     mostFrequentAlt,
+                    alleleCounts,
                 });
             }
         }

package/esm/MultiLinearVariantDisplay/components/Crosshair.js

@@ -9,7 +9,7 @@ const useStyles = makeStyles()({
     },
     cursor: {
         pointerEvents: 'none',
-        zIndex: 1000,
+        zIndex: 800,
         position: 'absolute',
     },
     color: {

package/esm/MultiLinearVariantDisplay/model.d.ts

@@ -259,6 +259,15 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     setSampleInfo(arg: Record<string, import("../shared/types").SampleInfo>): void;
 } & {
     readonly preSources: import("../shared/types").Source[] | undefined;
+    readonly sourcesWithoutLayout: {
+        label: string;
+        id: string;
+        baseUri?: string;
+        name: string;
+        color?: string;
+        group?: string;
+        HP?: number;
+    }[] | undefined;
     readonly sources: {
         label: string;
         id: string;
@@ -334,10 +343,20 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
         type?: undefined;
         checked?: undefined;
         onClick?: undefined;
+    } | {
+        label: string;
+        icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+            muiName: string;
+        };
+        onClick: () => void;
+        type?: undefined;
+        checked?: undefined;
+        subMenu?: undefined;
     })[];
 } & {
     readonly canDisplayLabels: boolean;
     readonly totalHeight: number;
+    readonly featuresReady: boolean;
 } & {
     renderProps(): any;
 } & {

package/esm/MultiLinearVariantMatrixDisplay/components/Crosshair.js

@@ -6,7 +6,7 @@ import MultiVariantTooltip from '../../shared/components/MultiVariantTooltip';
 const useStyles = makeStyles()({
     cursor: {
         pointerEvents: 'none',
-        zIndex: 1000,
+        zIndex: 800,
         position: 'relative',
     },
 });

package/esm/MultiLinearVariantMatrixDisplay/model.d.ts

@@ -258,6 +258,15 @@ export default function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     setSampleInfo(arg: Record<string, import("../shared/types").SampleInfo>): void;
 } & {
     readonly preSources: import("../shared/types").Source[] | undefined;
+    readonly sourcesWithoutLayout: {
+        label: string;
+        id: string;
+        baseUri?: string;
+        name: string;
+        color?: string;
+        group?: string;
+        HP?: number;
+    }[] | undefined;
     readonly sources: {
         label: string;
         id: string;
@@ -333,10 +342,20 @@ export default function stateModelFactory(configSchema: AnyConfigurationSchemaTy
         type?: undefined;
         checked?: undefined;
         onClick?: undefined;
+    } | {
+        label: string;
+        icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+            muiName: string;
+        };
+        onClick: () => void;
+        type?: undefined;
+        checked?: undefined;
+        subMenu?: undefined;
     })[];
 } & {
     readonly canDisplayLabels: boolean;
     readonly totalHeight: number;
+    readonly featuresReady: boolean;
 } & {
     renderProps(): any;
 } & {
@@ -344,6 +363,7 @@ export default function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     readonly blockType: string;
     readonly totalHeight: number;
     readonly rowHeight: number;
+    readonly featuresReady: boolean;
 } & {
     renderProps(): any;
     readonly canDisplayLabels: boolean;

package/esm/MultiLinearVariantMatrixDisplay/model.js

@@ -26,13 +26,16 @@ export default function stateModelFactory(configSchema) {
                 ? self.totalHeight / this.nrow
                 : self.rowHeightSetting;
         },
+        get featuresReady() {
+            return !!self.featuresVolatile;
+        },
     }))
         .views(self => ({
         renderProps() {
             const superProps = self.adapterProps();
             return {
                 ...superProps,
-                notReady: superProps.notReady || !self.sources || !self.featuresVolatile,
+                notReady: superProps.notReady || !self.sources || !self.featuresReady,
                 renderingMode: self.renderingMode,
                 minorAlleleFrequencyFilter: self.minorAlleleFrequencyFilter,
                 height: self.totalHeight,

package/esm/MultiLinearVariantMatrixRenderer/makeImageData.d.ts

@@ -8,6 +8,7 @@ export declare function makeImageData({ ctx, canvasWidth, canvasHeight, renderAr
     mafs: {
         feature: import("@jbrowse/core/util").Feature;
         mostFrequentAlt: string;
+        alleleCounts: Map<string, number>;
     }[];
     arr: string[][];
 }>;

package/esm/MultiLinearVariantMatrixRenderer/makeImageData.js

@@ -1,19 +1,27 @@
 import { updateStatus } from '@jbrowse/core/util';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
 import { f2 } from '../shared/constants';
 import { drawColorAlleleCount } from '../shared/drawAlleleCount';
 import { drawPhased } from '../shared/drawPhased';
 import { getFeaturesThatPassMinorAlleleFrequencyFilter } from '../shared/minorAlleleFrequencyUtils';
 export async function makeImageData({ ctx, canvasWidth, canvasHeight, renderArgs, }) {
-    const { renderingMode: renderingMode, minorAlleleFrequencyFilter, sources, features, } = renderArgs;
+    const { renderingMode: renderingMode, minorAlleleFrequencyFilter, sources, features, stopToken, } = renderArgs;
     const { statusCallback = () => { } } = renderArgs;
     const h = canvasHeight / sources.length;
+    checkStopToken(stopToken);
     const mafs = getFeaturesThatPassMinorAlleleFrequencyFilter(features.values(), minorAlleleFrequencyFilter);
+    checkStopToken(stopToken);
     const arr = [];
     const m = mafs.length;
     const w = canvasWidth / m;
     await updateStatus('Drawing variant matrix', statusCallback, () => {
         var _a, _b, _c;
+        let start = performance.now();
         for (let i = 0; i < m; i++) {
+            if (performance.now() - start > 400) {
+                checkStopToken(stopToken);
+                start = performance.now();
+            }
             const arr2 = [];
             const { feature, mostFrequentAlt } = mafs[i];
             const hasPhaseSet = (_a = feature.get('FORMAT')) === null || _a === void 0 ? void 0 : _a.includes('PS');

package/esm/MultiLinearVariantRenderer/makeImageData.js

@@ -1,15 +1,23 @@
 import { featureSpanPx } from '@jbrowse/core/util';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
 import RBush from 'rbush';
 import { f2 } from '../shared/constants';
 import { drawColorAlleleCount } from '../shared/drawAlleleCount';
 import { drawPhased } from '../shared/drawPhased';
 import { getFeaturesThatPassMinorAlleleFrequencyFilter } from '../shared/minorAlleleFrequencyUtils';
 export async function makeImageData(ctx, props) {
-    const { scrollTop, minorAlleleFrequencyFilter, sources, rowHeight, features, regions, bpPerPx, renderingMode, } = props;
+    const { scrollTop, minorAlleleFrequencyFilter, sources, rowHeight, features, regions, bpPerPx, renderingMode, stopToken, } = props;
     const region = regions[0];
+    checkStopToken(stopToken);
     const mafs = getFeaturesThatPassMinorAlleleFrequencyFilter(features.values(), minorAlleleFrequencyFilter);
+    checkStopToken(stopToken);
     const rbush = new RBush();
+    let start = performance.now();
     for (const { mostFrequentAlt, feature } of mafs) {
+        if (performance.now() - start > 400) {
+            checkStopToken(stopToken);
+            start = performance.now();
+        }
         const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
         const w = Math.max(Math.round(rightPx - leftPx), 2);
         const samp = feature.get('genotypes');

package/esm/VariantRPC/MultiVariantClusterGenotypeMatrix.d.ts

@@ -0,0 +1,28 @@
+import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
+import type { Source } from '../shared/types';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Region } from '@jbrowse/core/util';
+interface Args {
+    adapterConfig: AnyConfigurationModel;
+    stopToken?: string;
+    statusCallback: (arg: string) => void;
+    sessionId: string;
+    headers?: Record<string, string>;
+    regions: Region[];
+    bpPerPx: number;
+    sources: Source[];
+    minorAlleleFrequencyFilter: number;
+}
+export declare class MultiVariantClusterGenotypeMatrix extends RpcMethodTypeWithFiltersAndRenameRegions {
+    name: string;
+    execute(args: Args, rpcDriverClassName: string): Promise<{
+        clusters: {
+            height: number;
+            indexes: number[];
+        } | undefined;
+        distances: number[][];
+        order: number[];
+        clustersGivenK: number[][][];
+    }>;
+}
+export {};

package/esm/VariantRPC/MultiVariantClusterGenotypeMatrix.js

@@ -0,0 +1,26 @@
+import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
+import { clusterData } from './cluster';
+import { getGenotypeMatrix } from './getGenotypeMatrix';
+export class MultiVariantClusterGenotypeMatrix extends RpcMethodTypeWithFiltersAndRenameRegions {
+    constructor() {
+        super(...arguments);
+        this.name = 'MultiVariantClusterGenotypeMatrix';
+    }
+    async execute(args, rpcDriverClassName) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriverClassName);
+        const matrix = await getGenotypeMatrix({
+            pluginManager: this.pluginManager,
+            args: deserializedArgs,
+        });
+        return clusterData({
+            data: Object.values(matrix),
+            onProgress: a => {
+                deserializedArgs.statusCallback(`${toP(a * 100)}%`);
+            },
+            stopToken: deserializedArgs.stopToken,
+        });
+    }
+}
+function toP(n) {
+    return Number.parseFloat(n.toPrecision(3));
+}

package/esm/VariantRPC/MultiVariantGetGenotypeMatrix.d.ts

@@ -1,17 +1,19 @@
 import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
+import type { Source } from '../shared/types';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { Region } from '@jbrowse/core/util';
+interface Args {
+    adapterConfig: AnyConfigurationModel;
+    stopToken?: string;
+    sessionId: string;
+    headers?: Record<string, string>;
+    regions: Region[];
+    bpPerPx: number;
+    sources: Source[];
+    minorAlleleFrequencyFilter: number;
+}
 export declare class MultiVariantGetGenotypeMatrix extends RpcMethodTypeWithFiltersAndRenameRegions {
     name: string;
-    execute(args: {
-        adapterConfig: AnyConfigurationModel;
-        stopToken?: string;
-        sessionId: string;
-        headers?: Record<string, string>;
-        regions: Region[];
-        bpPerPx: number;
-    }, rpcDriverClassName: string): Promise<Record<string, {
-        name: string;
-        genotypes: number[];
-    }>>;
+    execute(args: Args, rpcDriverClassName: string): Promise<Record<string, number[]>>;
 }
+export {};

package/esm/VariantRPC/MultiVariantGetGenotypeMatrix.js

@@ -1,43 +1,14 @@
-import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
 import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
-import { firstValueFrom, toArray } from 'rxjs';
-import { getFeaturesThatPassMinorAlleleFrequencyFilter } from '../shared/minorAlleleFrequencyUtils';
+import { getGenotypeMatrix } from './getGenotypeMatrix';
 export class MultiVariantGetGenotypeMatrix extends RpcMethodTypeWithFiltersAndRenameRegions {
     constructor() {
         super(...arguments);
         this.name = 'MultiVariantGetGenotypeMatrix';
     }
     async execute(args, rpcDriverClassName) {
-        const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriverClassName);
-        const { sources, minorAlleleFrequencyFilter, regions, adapterConfig, sessionId, } = deserializedArgs;
-        const adapter = await getAdapter(pm, sessionId, adapterConfig);
-        const dataAdapter = adapter.dataAdapter;
-        const region = regions[0];
-        const feats = await firstValueFrom(dataAdapter.getFeatures(region, deserializedArgs).pipe(toArray()));
-        const genotypeFactor = new Set();
-        const mafs = getFeaturesThatPassMinorAlleleFrequencyFilter(feats, minorAlleleFrequencyFilter);
-        for (const feat of feats) {
-            const samp = feat.get('genotypes');
-            for (const { name } of sources) {
-                const s = samp[name];
-                genotypeFactor.add(s);
-            }
-        }
-        const genotypeFactorMap = Object.fromEntries([...genotypeFactor].map((type, idx) => [type, idx]));
-        const rows = {};
-        for (const { feature } of mafs) {
-            const samp = feature.get('genotypes');
-            for (const { name } of sources) {
-                if (!rows[name]) {
-                    rows[name] = {
-                        name,
-                        genotypes: [],
-                    };
-                }
-                rows[name].genotypes.push(genotypeFactorMap[samp[name]]);
-            }
-        }
-        return rows;
+        return getGenotypeMatrix({
+            pluginManager: this.pluginManager,
+            args: await this.deserializeArguments(args, rpcDriverClassName),
+        });
     }
 }

package/esm/VariantRPC/MultiVariantGetSimplifiedFeatures.d.ts

@@ -2,16 +2,18 @@ import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableEle
 import type { SampleInfo } from '../shared/types';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { Region } from '@jbrowse/core/util';
+interface Args {
+    adapterConfig: AnyConfigurationModel;
+    stopToken?: string;
+    sessionId: string;
+    headers?: Record<string, string>;
+    regions: Region[];
+    bpPerPx: number;
+    minorAlleleFrequencyFilter: number;
+}
 export declare class MultiVariantGetSimplifiedFeatures extends RpcMethodTypeWithFiltersAndRenameRegions {
     name: string;
-    execute(args: {
-        adapterConfig: AnyConfigurationModel;
-        stopToken?: string;
-        sessionId: string;
-        headers?: Record<string, string>;
-        regions: Region[];
-        bpPerPx: number;
-    }, rpcDriverClassName: string): Promise<{
+    execute(args: Args, rpcDriverClassName: string): Promise<{
         hasPhased: boolean;
         sampleInfo: Record<string, SampleInfo>;
         features: {
@@ -24,3 +26,4 @@ export declare class MultiVariantGetSimplifiedFeatures extends RpcMethodTypeWith
         }[];
     }>;
 }
+export {};

package/esm/VariantRPC/MultiVariantGetSimplifiedFeatures.js

@@ -9,10 +9,9 @@ export class MultiVariantGetSimplifiedFeatures extends RpcMethodTypeWithFiltersA
     }
     async execute(args, rpcDriverClassName) {
         var _a, _b;
-        const pm = this.pluginManager;
         const deserializedArgs = await this.deserializeArguments(args, rpcDriverClassName);
         const { minorAlleleFrequencyFilter, regions, adapterConfig, sessionId } = deserializedArgs;
-        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
         const feats = await firstValueFrom(dataAdapter
             .getFeaturesInMultipleRegions(regions, deserializedArgs)
             .pipe(toArray()));

package/esm/VariantRPC/cluster.d.ts

@@ -0,0 +1,17 @@
+export declare function euclideanDistance(a: number[], b: number[]): number;
+export declare function averageDistance(setA: number[], setB: number[], distances: number[][]): number;
+export declare function clusterData({ data, distance, linkage, onProgress, stopToken, }: {
+    data: number[][];
+    distance?: (a: number[], b: number[]) => number;
+    linkage?: (a: number[], b: number[], distances: number[][]) => number;
+    onProgress?: (a: number) => void;
+    stopToken?: string;
+}): {
+    clusters: {
+        height: number;
+        indexes: number[];
+    } | undefined;
+    distances: number[][];
+    order: number[];
+    clustersGivenK: number[][][];
+};

package/esm/VariantRPC/cluster.js

@@ -0,0 +1,79 @@
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
+export function euclideanDistance(a, b) {
+    const size = Math.min(a.length, b.length);
+    let sum = 0;
+    for (let index = 0; index < size; index++) {
+        sum += (a[index] - b[index]) * (a[index] - b[index]);
+    }
+    return Math.sqrt(sum);
+}
+export function averageDistance(setA, setB, distances) {
+    let distance = 0;
+    for (const a of setA) {
+        for (const b of setB) {
+            distance += distances[a][b];
+        }
+    }
+    return distance / setA.length / setB.length;
+}
+function updateProgress(stepNumber, stepProgress, onProgress) {
+    onProgress(stepNumber / 2 + stepProgress / 2);
+}
+export function clusterData({ data, distance = euclideanDistance, linkage = averageDistance, onProgress, stopToken, }) {
+    const distances = data.map((datum, index) => {
+        if (onProgress) {
+            updateProgress(0, index / (data.length - 1), onProgress);
+        }
+        return data.map(otherDatum => distance(datum, otherDatum));
+    });
+    const clusters = data.map((_datum, index) => ({
+        height: 0,
+        indexes: [Number(index)],
+    }));
+    let clustersGivenK = [];
+    let start = performance.now();
+    for (let iteration = 0; iteration < data.length; iteration++) {
+        if (performance.now() - start > 2000) {
+            checkStopToken(stopToken);
+            start = performance.now();
+        }
+        if (onProgress) {
+            updateProgress(1, (iteration + 1) / data.length, onProgress);
+        }
+        clustersGivenK.push(clusters.map(cluster => cluster.indexes));
+        if (iteration >= data.length - 1) {
+            break;
+        }
+        let nearestDistance = Infinity;
+        let nearestRow = 0;
+        let nearestCol = 0;
+        for (let row = 0; row < clusters.length; row++) {
+            for (let col = row + 1; col < clusters.length; col++) {
+                const distance = linkage(clusters[row].indexes, clusters[col].indexes, distances);
+                if (distance < nearestDistance) {
+                    nearestDistance = distance;
+                    nearestRow = row;
+                    nearestCol = col;
+                }
+            }
+        }
+        const newCluster = {
+            indexes: [
+                ...clusters[nearestRow].indexes,
+                ...clusters[nearestCol].indexes,
+            ],
+            height: nearestDistance,
+            children: [clusters[nearestRow], clusters[nearestCol]],
+        };
+        clusters.splice(Math.max(nearestRow, nearestCol), 1);
+        clusters.splice(Math.min(nearestRow, nearestCol), 1);
+        clusters.push(newCluster);
+    }
+    clustersGivenK = [[], ...clustersGivenK.reverse()];
+    return {
+        clusters: clusters[0],
+        distances: distances,
+        order: clusters[0].indexes,
+        clustersGivenK: clustersGivenK,
+    };
+}

package/esm/VariantRPC/getGenotypeMatrix.d.ts

@@ -0,0 +1,6 @@
+import type { GetGenotypeMatrixArgs } from './types';
+import type PluginManager from '@jbrowse/core/PluginManager';
+export declare function getGenotypeMatrix({ pluginManager, args, }: {
+    pluginManager: PluginManager;
+    args: GetGenotypeMatrixArgs;
+}): Promise<Record<string, number[]>>;

package/esm/VariantRPC/getGenotypeMatrix.js

@@ -0,0 +1,52 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import { firstValueFrom, toArray } from 'rxjs';
+import { getFeaturesThatPassMinorAlleleFrequencyFilter } from '../shared/minorAlleleFrequencyUtils';
+export async function getGenotypeMatrix({ pluginManager, args, }) {
+    const { sources, minorAlleleFrequencyFilter, regions, adapterConfig, sessionId, } = args;
+    const adapter = await getAdapter(pluginManager, sessionId, adapterConfig);
+    const dataAdapter = adapter.dataAdapter;
+    const feats = await firstValueFrom(dataAdapter.getFeaturesInMultipleRegions(regions, args).pipe(toArray()));
+    const genotypeFactor = new Set();
+    const mafs = getFeaturesThatPassMinorAlleleFrequencyFilter(feats, minorAlleleFrequencyFilter);
+    for (const { alleleCounts } of mafs) {
+        for (const alt of alleleCounts.keys()) {
+            genotypeFactor.add(alt);
+        }
+    }
+    const rows = {};
+    for (const { feature } of mafs) {
+        const genotypes = feature.get('genotypes');
+        for (const { name } of sources) {
+            if (!rows[name]) {
+                rows[name] = [];
+            }
+            const val = genotypes[name];
+            const alleles = val.split(/[/|]/);
+            let genotypeStatus = 0;
+            let nonRefCount = 0;
+            let uncalledCount = 0;
+            for (const l of alleles) {
+                if (l === '.') {
+                    uncalledCount++;
+                }
+                else if (l !== '0') {
+                    nonRefCount++;
+                }
+            }
+            if (uncalledCount === alleles.length) {
+                genotypeStatus = -1;
+            }
+            else if (nonRefCount === 0) {
+                genotypeStatus = 0;
+            }
+            else if (nonRefCount === alleles.length) {
+                genotypeStatus = 2;
+            }
+            else {
+                genotypeStatus = 1;
+            }
+            rows[name].push(genotypeStatus);
+        }
+    }
+    return rows;
+}

package/esm/VariantRPC/types.d.ts

@@ -0,0 +1,13 @@
+import type { Source } from '../shared/types';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Region } from '@jbrowse/core/util';
+export interface GetGenotypeMatrixArgs {
+    sources: Source[];
+    minorAlleleFrequencyFilter: number;
+    adapterConfig: AnyConfigurationModel;
+    stopToken?: string;
+    sessionId: string;
+    headers?: Record<string, string>;
+    regions: Region[];
+    bpPerPx: number;
+}

package/esm/VariantRPC/types.js

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