@jbrowse/plugin-variants 4.0.4 → 4.1.3

package/esm/VariantRPC/getLDMatrix.js

@@ -0,0 +1,387 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain';
+import { checkStopToken2 } from '@jbrowse/core/util/stopToken';
+import { firstValueFrom, toArray } from 'rxjs';
+import { getFeaturesThatPassMinorAlleleFrequencyFilter } from "../shared/minorAlleleFrequencyUtils.js";
+const SPLITTER = /[/|]/;
+function isPhased(genotypes) {
+    const firstVal = Object.values(genotypes)[0];
+    return firstVal?.includes('|') ?? false;
+}
+function calculateDprime(D, pA, pB, signedLD) {
+    const qA = 1 - pA;
+    const qB = 1 - pB;
+    if (D > 0) {
+        const Dmax = Math.min(pA * qB, qA * pB);
+        if (Dmax > 0) {
+            return Math.min(1, D / Dmax);
+        }
+    }
+    else if (D < 0) {
+        const absDmin = Math.min(pA * pB, qA * qB);
+        if (absDmin > 0) {
+            return signedLD
+                ? Math.max(-1, D / absDmin)
+                : Math.min(1, Math.abs(D) / absDmin);
+        }
+    }
+    return 0;
+}
+function getChiSquareCritical(pValue) {
+    if (pValue <= 0) {
+        return Number.POSITIVE_INFINITY;
+    }
+    if (pValue >= 1) {
+        return 0;
+    }
+    if (pValue === 0.05) {
+        return 3.841;
+    }
+    if (pValue === 0.01) {
+        return 6.635;
+    }
+    if (pValue === 0.001) {
+        return 10.828;
+    }
+    if (pValue === 0.0001) {
+        return 15.137;
+    }
+    return -2 * Math.log(pValue);
+}
+function encodeGenotypes(genotypes, samples, splitCache) {
+    const encoded = new Int8Array(samples.length);
+    for (const [i, sample] of samples.entries()) {
+        const val = genotypes[sample];
+        const alleles = splitCache[val] ?? (splitCache[val] = val.split(SPLITTER));
+        let nonRefCount = 0;
+        let uncalledCount = 0;
+        for (const allele of alleles) {
+            if (allele === '.') {
+                uncalledCount++;
+            }
+            else if (allele !== '0') {
+                nonRefCount++;
+            }
+        }
+        if (uncalledCount === alleles.length) {
+            encoded[i] = -1;
+        }
+        else if (nonRefCount === 0) {
+            encoded[i] = 0;
+        }
+        else if (nonRefCount === alleles.length) {
+            encoded[i] = 2;
+        }
+        else {
+            encoded[i] = 1;
+        }
+    }
+    return encoded;
+}
+function encodePhasedHaplotypes(genotypes, samples) {
+    const hap1 = new Int8Array(samples.length);
+    const hap2 = new Int8Array(samples.length);
+    for (const [i, sample] of samples.entries()) {
+        const val = genotypes[sample];
+        const alleles = val.split('|');
+        if (alleles.length !== 2) {
+            hap1[i] = -1;
+            hap2[i] = -1;
+            continue;
+        }
+        if (alleles[0] === '.') {
+            hap1[i] = -1;
+        }
+        else {
+            hap1[i] = alleles[0] === '0' ? 0 : 1;
+        }
+        if (alleles[1] === '.') {
+            hap2[i] = -1;
+        }
+        else {
+            hap2[i] = alleles[1] === '0' ? 0 : 1;
+        }
+    }
+    return { hap1, hap2 };
+}
+function calculateLDStatsPhased(haps1, haps2, signedLD = false) {
+    let n01 = 0;
+    let n10 = 0;
+    let n11 = 0;
+    let total = 0;
+    const numSamples = haps1.hap1.length;
+    for (let i = 0; i < numSamples; i++) {
+        const a1 = haps1.hap1[i];
+        const b1 = haps2.hap1[i];
+        if (a1 >= 0 && b1 >= 0) {
+            if (a1 === 0 && b1 === 1) {
+                n01++;
+            }
+            else if (a1 === 1 && b1 === 0) {
+                n10++;
+            }
+            else if (a1 === 1 && b1 === 1) {
+                n11++;
+            }
+            total++;
+        }
+    }
+    for (let i = 0; i < numSamples; i++) {
+        const a2 = haps1.hap2[i];
+        const b2 = haps2.hap2[i];
+        if (a2 >= 0 && b2 >= 0) {
+            if (a2 === 0 && b2 === 1) {
+                n01++;
+            }
+            else if (a2 === 1 && b2 === 0) {
+                n10++;
+            }
+            else if (a2 === 1 && b2 === 1) {
+                n11++;
+            }
+            total++;
+        }
+    }
+    if (total < 4) {
+        return { r2: 0, dprime: 0 };
+    }
+    const p01 = n01 / total;
+    const p10 = n10 / total;
+    const p11 = n11 / total;
+    const pA = p10 + p11;
+    const pB = p01 + p11;
+    const qA = 1 - pA;
+    const qB = 1 - pB;
+    if (pA <= 0 || pA >= 1 || pB <= 0 || pB >= 1) {
+        return { r2: 0, dprime: 0 };
+    }
+    const D = p11 - pA * pB;
+    const denom = pA * qA * pB * qB;
+    const r = denom > 0 ? D / Math.sqrt(denom) : 0;
+    const r2 = Math.min(1, Math.max(0, r * r));
+    const dprime = calculateDprime(D, pA, pB, signedLD);
+    return { r2: signedLD ? r : r2, dprime };
+}
+function calculateLDStats(geno1, geno2, signedLD = false) {
+    let n = 0;
+    let sumG1 = 0;
+    let sumG2 = 0;
+    let sumG1sq = 0;
+    let sumG2sq = 0;
+    let sumProd = 0;
+    for (const [i, element] of geno1.entries()) {
+        const g1 = element;
+        const g2 = geno2[i];
+        if (g1 >= 0 && g2 >= 0) {
+            n++;
+            sumG1 += g1;
+            sumG2 += g2;
+            sumG1sq += g1 * g1;
+            sumG2sq += g2 * g2;
+            sumProd += g1 * g2;
+        }
+    }
+    if (n < 2) {
+        return { r2: 0, dprime: 0 };
+    }
+    const pA = sumG1 / (2 * n);
+    const pB = sumG2 / (2 * n);
+    if (pA <= 0 || pA >= 1 || pB <= 0 || pB >= 1) {
+        return { r2: 0, dprime: 0 };
+    }
+    const mean1 = sumG1 / n;
+    const mean2 = sumG2 / n;
+    const var1 = sumG1sq / n - mean1 * mean1;
+    const var2 = sumG2sq / n - mean2 * mean2;
+    let r = 0;
+    let r2 = 0;
+    if (var1 > 0 && var2 > 0) {
+        const cov = sumProd / n - mean1 * mean2;
+        r = cov / Math.sqrt(var1 * var2);
+        r2 = Math.min(1, Math.max(0, r * r));
+    }
+    const covG = sumProd / n - mean1 * mean2;
+    const D = covG / 2;
+    const dprime = calculateDprime(D, pA, pB, signedLD);
+    return { r2: signedLD ? r : r2, dprime };
+}
+export async function getLDMatrix({ pluginManager, args, }) {
+    const { minorAlleleFrequencyFilter, regions, adapterConfig, sessionId, lengthCutoffFilter, hweFilterThreshold = 0.001, callRateFilter = 0, jexlFilters = [], stopTokenCheck, ldMetric = 'r2', signedLD = false, } = args;
+    const adapter = await getAdapter(pluginManager, sessionId, adapterConfig);
+    const dataAdapter = adapter.dataAdapter;
+    const sources = await dataAdapter.getSources(regions);
+    const samples = sources.map(s => s.name);
+    if (samples.length === 0) {
+        return {
+            snps: [],
+            ldValues: new Float32Array(0),
+            metric: ldMetric,
+            filterStats: {
+                totalVariants: 0,
+                passedVariants: 0,
+                filteredByMaf: 0,
+                filteredByLength: 0,
+                filteredByMultiallelic: 0,
+                filteredByHwe: 0,
+                filteredByCallRate: 0,
+            },
+            recombination: {
+                values: new Float32Array(0),
+                positions: [],
+            },
+        };
+    }
+    const splitCache = {};
+    const rawFeatures = await firstValueFrom(dataAdapter.getFeaturesInMultipleRegions(regions, args).pipe(toArray()));
+    const totalVariants = rawFeatures.length;
+    const filteredFeatures = getFeaturesThatPassMinorAlleleFrequencyFilter({
+        minorAlleleFrequencyFilter,
+        lengthCutoffFilter,
+        stopTokenCheck,
+        splitCache,
+        features: rawFeatures,
+    });
+    let filteredByLength = 0;
+    let filteredByMaf = 0;
+    for (const feature of rawFeatures) {
+        if (feature.get('end') - feature.get('start') > lengthCutoffFilter) {
+            filteredByLength++;
+        }
+        else {
+            const featureId = feature.id();
+            const wasPassed = filteredFeatures.some(f => f.feature.id() === featureId);
+            if (!wasPassed) {
+                filteredByMaf++;
+            }
+        }
+    }
+    let featuresAfterJexl = filteredFeatures;
+    if (jexlFilters.length > 0) {
+        const filterChain = new SerializableFilterChain({ filters: jexlFilters });
+        featuresAfterJexl = filteredFeatures.filter(({ feature }) => filterChain.passes(feature, undefined, undefined));
+    }
+    const snps = [];
+    const encodedGenotypes = [];
+    const phasedHaplotypes = [];
+    let filteredByMultiallelic = 0;
+    let filteredByHwe = 0;
+    let filteredByCallRate = 0;
+    const callRateFilterEnabled = callRateFilter > 0;
+    let dataIsPhased = false;
+    if (featuresAfterJexl.length > 0) {
+        const firstGenotypes = featuresAfterJexl[0].feature.get('genotypes');
+        dataIsPhased = isPhased(firstGenotypes);
+    }
+    const chiSqCritical = getChiSquareCritical(hweFilterThreshold);
+    const hweFilterEnabled = hweFilterThreshold > 0;
+    for (const { feature } of featuresAfterJexl) {
+        const alt = feature.get('ALT');
+        if (alt && alt.length > 1) {
+            filteredByMultiallelic++;
+            continue;
+        }
+        const genotypes = feature.get('genotypes');
+        const encoded = encodeGenotypes(genotypes, samples, splitCache);
+        let nHomRef = 0;
+        let nHet = 0;
+        let nHomAlt = 0;
+        let nValid = 0;
+        for (const g of encoded) {
+            if (g === 0) {
+                nHomRef++;
+                nValid++;
+            }
+            else if (g === 1) {
+                nHet++;
+                nValid++;
+            }
+            else if (g === 2) {
+                nHomAlt++;
+                nValid++;
+            }
+        }
+        if (callRateFilterEnabled) {
+            const callRate = nValid / samples.length;
+            if (callRate < callRateFilter) {
+                filteredByCallRate++;
+                continue;
+            }
+        }
+        if (hweFilterEnabled && nValid > 0) {
+            const p = (2 * nHomRef + nHet) / (2 * nValid);
+            const q = 1 - p;
+            const expectedHomRef = p * p * nValid;
+            const expectedHet = 2 * p * q * nValid;
+            const expectedHomAlt = q * q * nValid;
+            let chiSq = 0;
+            if (expectedHomRef > 0) {
+                chiSq += (nHomRef - expectedHomRef) ** 2 / expectedHomRef;
+            }
+            if (expectedHet > 0) {
+                chiSq += (nHet - expectedHet) ** 2 / expectedHet;
+            }
+            if (expectedHomAlt > 0) {
+                chiSq += (nHomAlt - expectedHomAlt) ** 2 / expectedHomAlt;
+            }
+            if (chiSq > chiSqCritical) {
+                filteredByHwe++;
+                continue;
+            }
+        }
+        snps.push({
+            id: feature.get('name') || feature.id(),
+            refName: feature.get('refName'),
+            start: feature.get('start'),
+            end: feature.get('end'),
+        });
+        encodedGenotypes.push(encoded);
+        if (dataIsPhased) {
+            phasedHaplotypes.push(encodePhasedHaplotypes(genotypes, samples));
+        }
+        checkStopToken2(stopTokenCheck);
+    }
+    const n = snps.length;
+    const ldSize = (n * (n - 1)) / 2;
+    const ldValues = new Float32Array(ldSize);
+    let idx = 0;
+    for (let i = 1; i < n; i++) {
+        for (let j = 0; j < i; j++) {
+            const stats = dataIsPhased
+                ? calculateLDStatsPhased(phasedHaplotypes[i], phasedHaplotypes[j], signedLD)
+                : calculateLDStats(encodedGenotypes[i], encodedGenotypes[j], signedLD);
+            ldValues[idx++] = ldMetric === 'dprime' ? stats.dprime : stats.r2;
+        }
+        checkStopToken2(stopTokenCheck);
+    }
+    const filterStats = {
+        totalVariants,
+        passedVariants: snps.length,
+        filteredByMaf,
+        filteredByLength,
+        filteredByMultiallelic,
+        filteredByHwe,
+        filteredByCallRate,
+    };
+    const recombValues = new Float32Array(Math.max(0, n - 1));
+    const recombPositions = [];
+    for (let i = 0; i < n - 1; i++) {
+        let r2;
+        if (dataIsPhased) {
+            const stats = calculateLDStatsPhased(phasedHaplotypes[i], phasedHaplotypes[i + 1]);
+            r2 = stats.r2;
+        }
+        else {
+            const stats = calculateLDStats(encodedGenotypes[i], encodedGenotypes[i + 1]);
+            r2 = stats.r2;
+        }
+        recombValues[i] = 1 - r2;
+        const pos1 = snps[i].start;
+        const pos2 = snps[i + 1].start;
+        recombPositions.push((pos1 + pos2) / 2);
+    }
+    const recombination = {
+        values: recombValues,
+        positions: recombPositions,
+    };
+    return { snps, ldValues, metric: ldMetric, filterStats, recombination };
+}

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

@@ -1,13 +1,12 @@
 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';
+import type { LastStopTokenCheck, Region } from '@jbrowse/core/util';
 export declare function getPhasedGenotypeMatrix({ pluginManager, args, }: {
     pluginManager: PluginManager;
     args: {
         adapterConfig: AnyConfigurationModel;
-        stopToken?: StopToken;
+        stopTokenCheck?: LastStopTokenCheck;
         sessionId: string;
         headers?: Record<string, string>;
         regions: Region[];

package/esm/VariantRPC/getPhasedGenotypeMatrix.js

@@ -1,10 +1,9 @@
 import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
-import { checkStopToken2, createStopTokenChecker, } from '@jbrowse/core/util/stopToken';
+import { checkStopToken2 } 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 { sources, minorAlleleFrequencyFilter, regions, adapterConfig, sessionId, lengthCutoffFilter, stopTokenCheck, sampleInfo, } = args;
     const adapter = await getAdapter(pluginManager, sessionId, adapterConfig);
     const dataAdapter = adapter.dataAdapter;
     const rows = {};
@@ -19,7 +18,7 @@ export async function getPhasedGenotypeMatrix({ pluginManager, args, }) {
     const mafs = getFeaturesThatPassMinorAlleleFrequencyFilter({
         minorAlleleFrequencyFilter,
         lengthCutoffFilter,
-        lastCheck,
+        stopTokenCheck,
         splitCache,
         features: await firstValueFrom(dataAdapter.getFeaturesInMultipleRegions(regions, args).pipe(toArray())),
     });
@@ -44,7 +43,7 @@ export async function getPhasedGenotypeMatrix({ pluginManager, args, }) {
                 }
             }
         }
-        checkStopToken2(lastCheck);
+        checkStopToken2(stopTokenCheck);
     }
     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';