@jbrowse/plugin-variants 4.0.3 → 4.1.1

package/esm/VariantRPC/getLDMatrixFromPlink.d.ts

@@ -0,0 +1,16 @@
+import type { LDMatrixResult, LDMetric } from './getLDMatrix.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Region } from '@jbrowse/core/util';
+import type { StopToken } from '@jbrowse/core/util/stopToken';
+export declare function getLDMatrixFromPlink({ pluginManager, args, }: {
+    pluginManager: PluginManager;
+    args: {
+        adapterConfig: AnyConfigurationModel;
+        stopToken?: StopToken;
+        sessionId: string;
+        headers?: Record<string, string>;
+        regions: Region[];
+        ldMetric?: LDMetric;
+    };
+}): Promise<LDMatrixResult>;

package/esm/VariantRPC/getLDMatrixFromPlink.js

@@ -0,0 +1,105 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+export async function getLDMatrixFromPlink({ pluginManager, args, }) {
+    const { regions, adapterConfig, sessionId, ldMetric = 'r2' } = args;
+    const adapter = await getAdapter(pluginManager, sessionId, adapterConfig);
+    const dataAdapter = adapter.dataAdapter;
+    const allRecords = [];
+    for (const region of regions) {
+        const records = await dataAdapter.getLDRecordsInRegion({
+            refName: region.refName,
+            start: region.start,
+            end: region.end,
+        });
+        for (const r of records) {
+            allRecords.push(r);
+        }
+    }
+    const snpMap = new Map();
+    for (const record of allRecords) {
+        const keyA = `${record.chrA}:${record.bpA}`;
+        if (!snpMap.has(keyA)) {
+            snpMap.set(keyA, {
+                id: record.snpA,
+                refName: record.chrA,
+                start: record.bpA,
+                end: record.bpA + 1,
+            });
+        }
+        const keyB = `${record.chrB}:${record.bpB}`;
+        if (!snpMap.has(keyB)) {
+            snpMap.set(keyB, {
+                id: record.snpB,
+                refName: record.chrB,
+                start: record.bpB,
+                end: record.bpB + 1,
+            });
+        }
+    }
+    const snps = [...snpMap.values()].sort((a, b) => {
+        if (a.refName !== b.refName) {
+            return a.refName.localeCompare(b.refName);
+        }
+        return a.start - b.start;
+    });
+    const snpToIndex = new Map();
+    for (const [idx, snp] of snps.entries()) {
+        snpToIndex.set(`${snp.refName}:${snp.start}`, idx);
+    }
+    const n = snps.length;
+    const ldSize = (n * (n - 1)) / 2;
+    const ldValues = new Float32Array(ldSize);
+    ldValues.fill(Number.NaN);
+    const getLowerTriIndex = (i, j) => {
+        if (i <= j) {
+            ;
+            [i, j] = [j, i];
+        }
+        return (i * (i - 1)) / 2 + j;
+    };
+    for (const record of allRecords) {
+        const keyA = `${record.chrA}:${record.bpA}`;
+        const keyB = `${record.chrB}:${record.bpB}`;
+        const idxA = snpToIndex.get(keyA);
+        const idxB = snpToIndex.get(keyB);
+        if (idxA !== undefined && idxB !== undefined && idxA !== idxB) {
+            const matrixIdx = getLowerTriIndex(idxA, idxB);
+            const value = ldMetric === 'dprime' ? (record.dprime ?? record.r2) : record.r2;
+            ldValues[matrixIdx] = value;
+        }
+    }
+    for (let i = 0; i < ldValues.length; i++) {
+        if (Number.isNaN(ldValues[i])) {
+            ldValues[i] = 0;
+        }
+    }
+    const recombValues = new Float32Array(Math.max(0, n - 1));
+    const recombPositions = [];
+    for (let i = 0; i < n - 1; i++) {
+        const snp1 = snps[i];
+        const snp2 = snps[i + 1];
+        const matrixIdx = getLowerTriIndex(i + 1, i);
+        const r2 = ldValues[matrixIdx] ?? 0;
+        recombValues[i] = 1 - r2;
+        recombPositions.push((snp1.start + snp2.start) / 2);
+    }
+    const recombination = {
+        values: recombValues,
+        positions: recombPositions,
+    };
+    const filterStats = {
+        filteredByCallRate: 0,
+        totalVariants: snps.length,
+        passedVariants: snps.length,
+        filteredByMaf: 0,
+        filteredByLength: 0,
+        filteredByMultiallelic: 0,
+        filteredByHwe: 0,
+    };
+    return {
+        snps,
+        ldValues,
+        metric: ldMetric,
+        filterStats,
+        recombination,
+    };
+}

package/esm/VariantRPC/getPhasedGenotypeMatrix.d.ts

@@ -0,0 +1,20 @@
+import type { SampleInfo, Source } from '../shared/types.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Region } from '@jbrowse/core/util';
+import type { StopToken } from '@jbrowse/core/util/stopToken';
+export declare function getPhasedGenotypeMatrix({ pluginManager, args, }: {
+    pluginManager: PluginManager;
+    args: {
+        adapterConfig: AnyConfigurationModel;
+        stopToken?: StopToken;
+        sessionId: string;
+        headers?: Record<string, string>;
+        regions: Region[];
+        sources: Source[];
+        bpPerPx: number;
+        minorAlleleFrequencyFilter: number;
+        lengthCutoffFilter: number;
+        sampleInfo: Record<string, SampleInfo>;
+    };
+}): Promise<Record<string, number[]>>;

package/esm/VariantRPC/getPhasedGenotypeMatrix.js

@@ -0,0 +1,50 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import { checkStopToken2, createStopTokenChecker, } from '@jbrowse/core/util/stopToken';
+import { firstValueFrom, toArray } from 'rxjs';
+import { getFeaturesThatPassMinorAlleleFrequencyFilter } from "../shared/minorAlleleFrequencyUtils.js";
+export async function getPhasedGenotypeMatrix({ pluginManager, args, }) {
+    const { sources, minorAlleleFrequencyFilter, regions, adapterConfig, sessionId, lengthCutoffFilter, stopToken, sampleInfo, } = args;
+    const lastCheck = createStopTokenChecker(stopToken);
+    const adapter = await getAdapter(pluginManager, sessionId, adapterConfig);
+    const dataAdapter = adapter.dataAdapter;
+    const rows = {};
+    const splitCache = {};
+    for (const { name } of sources) {
+        const info = sampleInfo[name];
+        const ploidy = info?.maxPloidy ?? 2;
+        for (let hp = 0; hp < ploidy; hp++) {
+            rows[`${name} HP${hp}`] = [];
+        }
+    }
+    const mafs = getFeaturesThatPassMinorAlleleFrequencyFilter({
+        minorAlleleFrequencyFilter,
+        lengthCutoffFilter,
+        lastCheck,
+        splitCache,
+        features: await firstValueFrom(dataAdapter.getFeaturesInMultipleRegions(regions, args).pipe(toArray())),
+    });
+    for (const { feature } of mafs) {
+        const genotypes = feature.get('genotypes');
+        for (const { name } of sources) {
+            const val = genotypes[name];
+            const info = sampleInfo[name];
+            const ploidy = info?.maxPloidy ?? 2;
+            const isPhased = val.includes('|');
+            if (isPhased) {
+                const alleles = splitCache[val] ?? (splitCache[val] = val.split('|'));
+                for (let hp = 0; hp < ploidy; hp++) {
+                    const allele = alleles[hp];
+                    const value = allele === '.' || allele === undefined ? -1 : +allele;
+                    rows[`${name} HP${hp}`].push(value);
+                }
+            }
+            else {
+                for (let hp = 0; hp < ploidy; hp++) {
+                    rows[`${name} HP${hp}`].push(-1);
+                }
+            }
+        }
+        checkStopToken2(lastCheck);
+    }
+    return rows;
+}

package/esm/VariantRPC/types.d.ts

@@ -19,4 +19,7 @@ export interface ClusterGenotypeMatrixArgs extends BaseVariantRpcArgs {
     statusCallback: (arg: string) => void;
     sources: Source[];
 }
+export interface GetLDMatrixArgs extends BaseVariantRpcArgs {
+    ldMetric?: 'r2' | 'dprime';
+}
 export {};

package/esm/VcfAdapter/VcfAdapter.d.ts

@@ -1,6 +1,6 @@
-import { IntervalTree } from '@flatten-js/interval-tree';
 import VcfParser from '@gmod/vcf';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { IntervalTree } from '@jbrowse/core/util';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Feature, Region } from '@jbrowse/core/util';
 import type { StatusCallback } from '@jbrowse/core/util/parseLineByLine';

package/esm/VcfAdapter/VcfAdapter.js

@@ -1,7 +1,6 @@
-import { IntervalTree } from '@flatten-js/interval-tree';
 import VcfParser from '@gmod/vcf';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { fetchAndMaybeUnzip } from '@jbrowse/core/util';
+import { IntervalTree, fetchAndMaybeUnzip } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import { parseVcfBuffer } from "./vcfParser.js";

package/esm/VcfExtensionPoints/index.js

@@ -21,6 +21,28 @@ export default function VcfExtensionPointsF(pluginManager) {
                     vcfLocation: file,
                 };
             }
+            else if (testAdapter(fileName, /\.ld\.b?gz$/i, adapterHint, 'PlinkLDTabixAdapter')) {
+                return {
+                    type: 'PlinkLDTabixAdapter',
+                    ldLocation: file,
+                    index: {
+                        location: index || makeIndex(file, '.tbi'),
+                        indexType: makeIndexType(indexName, 'CSI', 'TBI'),
+                    },
+                };
+            }
+            else if (testAdapter(fileName, /\.ld$/i, adapterHint, 'PlinkLDAdapter')) {
+                return {
+                    type: 'PlinkLDAdapter',
+                    ldLocation: file,
+                };
+            }
+            else if (testAdapter(fileName, /\.h5$/i, adapterHint, 'LdmatAdapter')) {
+                return {
+                    type: 'LdmatAdapter',
+                    ldmatLocation: file,
+                };
+            }
             else {
                 return adapterGuesser(file, index, adapterHint);
             }
@@ -28,9 +50,13 @@ export default function VcfExtensionPointsF(pluginManager) {
     });
     pluginManager.addToExtensionPoint('Core-guessTrackTypeForLocation', (trackTypeGuesser) => {
         return (adapterName) => {
-            return ['VcfTabixAdapter', 'VcfAdapter'].includes(adapterName)
-                ? 'VariantTrack'
-                : trackTypeGuesser(adapterName);
+            if (['VcfTabixAdapter', 'VcfAdapter'].includes(adapterName)) {
+                return 'VariantTrack';
+            }
+            if (['PlinkLDAdapter', 'PlinkLDTabixAdapter', 'LdmatAdapter'].includes(adapterName)) {
+                return 'LDTrack';
+            }
+            return trackTypeGuesser(adapterName);
         };
     });
 }

package/esm/VcfFeature/index.d.ts

@@ -1,6 +1,6 @@
 import { type Feature } from '@jbrowse/core/util';
 import type VCFParser from '@gmod/vcf';
-import type { Variant } from '@gmod/vcf';
+import type { GenotypeCallback, Variant } from '@gmod/vcf';
 export default class VCFFeature implements Feature {
     private variant;
     private parser;
@@ -15,5 +15,6 @@ export default class VCFFeature implements Feature {
     parent(): undefined;
     children(): undefined;
     id(): string;
+    processGenotypes(callback: GenotypeCallback): void;
     toJSON(): any;
 }

package/esm/VcfFeature/index.js

@@ -77,11 +77,13 @@ export default class VCFFeature {
     id() {
         return this._id;
     }
+    processGenotypes(callback) {
+        this.variant.processGenotypes(callback);
+    }
     toJSON() {
-        const { SAMPLES, GENOTYPES, ...rest } = this.variant;
         return {
             uniqueId: this._id,
-            ...rest,
+            ...this.variant.toJSON(),
             ...this.data,
             samples: this.variant.SAMPLES(),
         };

package/esm/index.d.ts

@@ -3,5 +3,6 @@ import type PluginManager from '@jbrowse/core/PluginManager';
 export default class VariantsPlugin extends Plugin {
     name: string;
     install(pluginManager: PluginManager): void;
+    configure(pluginManager: PluginManager): void;
 }
 export { default as VcfFeature } from './VcfFeature/index.ts';

package/esm/index.js

@@ -1,14 +1,19 @@
 import Plugin from '@jbrowse/core/Plugin';
 import ChordVariantDisplayF from "./ChordVariantDisplay/index.js";
+import LDDisplayF from "./LDDisplay/index.js";
+import LDRendererF from "./LDRenderer/index.js";
+import LDTrackF from "./LDTrack/index.js";
 import LinearVariantDisplayF from "./LinearVariantDisplay/index.js";
 import MultiLinearVariantDisplayF from "./MultiLinearVariantDisplay/index.js";
 import LinearVariantMatrixDisplayF from "./MultiLinearVariantMatrixDisplay/index.js";
 import LinearVariantMatrixRendererF from "./MultiLinearVariantMatrixRenderer/index.js";
 import MultiVariantRendererF from "./MultiLinearVariantRenderer/index.js";
+import PlinkLDAdapterF from "./PlinkLDAdapter/index.js";
 import SplitVcfTabixAdapterF from "./SplitVcfTabixAdapter/index.js";
 import StructuralVariantChordRendererF from "./StructuralVariantChordRenderer/index.js";
 import VariantFeatureWidgetF from "./VariantFeatureWidget/index.js";
 import { MultiVariantClusterGenotypeMatrix } from "./VariantRPC/MultiVariantClusterGenotypeMatrix.js";
+import { MultiVariantGetFeatureDetails } from "./VariantRPC/MultiVariantGetFeatureDetails.js";
 import { MultiVariantGetGenotypeMatrix } from "./VariantRPC/MultiVariantGetGenotypeMatrix.js";
 import { MultiVariantGetSimplifiedFeatures } from "./VariantRPC/MultiVariantGetSimplifiedFeatures.js";
 import { MultiVariantGetSources } from "./VariantRPC/MultiVariantGetSources.js";
@@ -16,18 +21,23 @@ import VariantTrackF from "./VariantTrack/index.js";
 import VcfAdapterF from "./VcfAdapter/index.js";
 import ExtensionPointsF from "./VcfExtensionPoints/index.js";
 import VcfTabixAdapterF from "./VcfTabixAdapter/index.js";
+import { calculateAlleleCounts, calculateMinorAlleleFrequency, } from "./shared/minorAlleleFrequencyUtils.js";
 export default class VariantsPlugin extends Plugin {
     name = 'VariantsPlugin';
     install(pluginManager) {
         VcfAdapterF(pluginManager);
         VcfTabixAdapterF(pluginManager);
         SplitVcfTabixAdapterF(pluginManager);
+        PlinkLDAdapterF(pluginManager);
         VariantFeatureWidgetF(pluginManager);
         VariantTrackF(pluginManager);
+        LDTrackF(pluginManager);
         ExtensionPointsF(pluginManager);
         LinearVariantDisplayF(pluginManager);
         LinearVariantMatrixDisplayF(pluginManager);
         MultiLinearVariantDisplayF(pluginManager);
+        LDDisplayF(pluginManager);
+        LDRendererF(pluginManager);
         MultiVariantRendererF(pluginManager);
         LinearVariantMatrixRendererF(pluginManager);
         StructuralVariantChordRendererF(pluginManager);
@@ -36,6 +46,19 @@ export default class VariantsPlugin extends Plugin {
         pluginManager.addRpcMethod(() => new MultiVariantGetGenotypeMatrix(pluginManager));
         pluginManager.addRpcMethod(() => new MultiVariantClusterGenotypeMatrix(pluginManager));
         pluginManager.addRpcMethod(() => new MultiVariantGetSimplifiedFeatures(pluginManager));
+        pluginManager.addRpcMethod(() => new MultiVariantGetFeatureDetails(pluginManager));
+    }
+    configure(pluginManager) {
+        const { jexl } = pluginManager;
+        const splitCache = {};
+        jexl.addFunction('maf', (feature) => {
+            const genotypes = feature.get('genotypes');
+            if (!genotypes) {
+                return 0;
+            }
+            const alleleCounts = calculateAlleleCounts(genotypes, splitCache);
+            return calculateMinorAlleleFrequency(alleleCounts);
+        });
     }
 }
 export { default as VcfFeature } from "./VcfFeature/index.js";