@jbrowse/plugin-variants 4.0.3 → 4.1.1

package/esm/PlinkLDAdapter/configSchema.js

@@ -0,0 +1,25 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+function x() { }
+const PlinkLDAdapter = ConfigurationSchema('PlinkLDAdapter', {
+    ldLocation: {
+        type: 'fileLocation',
+        defaultValue: {
+            uri: '/path/to/plink.ld',
+            locationType: 'UriLocation',
+        },
+    },
+}, {
+    explicitlyTyped: true,
+    preProcessSnapshot: snap => {
+        return snap.uri
+            ? {
+                ...snap,
+                ldLocation: {
+                    uri: snap.uri,
+                    baseUri: snap.baseUri,
+                },
+            }
+            : snap;
+    },
+});
+export default PlinkLDAdapter;

package/esm/PlinkLDAdapter/configSchemaTabix.d.ts

@@ -0,0 +1,24 @@
+declare const PlinkLDTabixAdapter: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{
+    ldLocation: {
+        type: string;
+        defaultValue: {
+            uri: string;
+            locationType: string;
+        };
+    };
+    index: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{
+        indexType: {
+            model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            type: string;
+            defaultValue: string;
+        };
+        location: {
+            type: string;
+            defaultValue: {
+                uri: string;
+                locationType: string;
+            };
+        };
+    }, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+export default PlinkLDTabixAdapter;

package/esm/PlinkLDAdapter/configSchemaTabix.js

@@ -0,0 +1,46 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+function x() { }
+const PlinkLDTabixAdapter = ConfigurationSchema('PlinkLDTabixAdapter', {
+    ldLocation: {
+        type: 'fileLocation',
+        defaultValue: {
+            uri: '/path/to/plink.ld.gz',
+            locationType: 'UriLocation',
+        },
+    },
+    index: ConfigurationSchema('PlinkLDTabixIndex', {
+        indexType: {
+            model: types.enumeration('IndexType', ['TBI', 'CSI']),
+            type: 'stringEnum',
+            defaultValue: 'TBI',
+        },
+        location: {
+            type: 'fileLocation',
+            defaultValue: {
+                uri: '/path/to/plink.ld.gz.tbi',
+                locationType: 'UriLocation',
+            },
+        },
+    }),
+}, {
+    explicitlyTyped: true,
+    preProcessSnapshot: snap => {
+        return snap.uri
+            ? {
+                ...snap,
+                ldLocation: {
+                    uri: snap.uri,
+                    baseUri: snap.baseUri,
+                },
+                index: {
+                    location: {
+                        uri: `${snap.uri}.tbi`,
+                        baseUri: snap.baseUri,
+                    },
+                },
+            }
+            : snap;
+    },
+});
+export default PlinkLDTabixAdapter;

package/esm/PlinkLDAdapter/index.d.ts

@@ -0,0 +1,2 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+export default function PlinkLDAdapterF(pluginManager: PluginManager): void;

package/esm/PlinkLDAdapter/index.js

@@ -0,0 +1,25 @@
+import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
+import configSchema from "./configSchema.js";
+import configSchemaTabix from "./configSchemaTabix.js";
+export default function PlinkLDAdapterF(pluginManager) {
+    pluginManager.addAdapterType(() => new AdapterType({
+        name: 'PlinkLDAdapter',
+        displayName: 'PLINK LD adapter',
+        configSchema,
+        adapterMetadata: {
+            category: 'Linkage disequilibrium',
+            description: 'Adapter for pre-computed LD data from PLINK --r2 output (loads into memory)',
+        },
+        getAdapterClass: () => import("./PlinkLDAdapter.js").then(r => r.default),
+    }));
+    pluginManager.addAdapterType(() => new AdapterType({
+        name: 'PlinkLDTabixAdapter',
+        displayName: 'PLINK LD tabix adapter',
+        configSchema: configSchemaTabix,
+        adapterMetadata: {
+            category: 'Linkage disequilibrium',
+            description: 'Adapter for pre-computed LD data from PLINK --r2 output (tabix-indexed)',
+        },
+        getAdapterClass: () => import("./PlinkLDTabixAdapter.js").then(r => r.default),
+    }));
+}

package/esm/PlinkLDAdapter/types.d.ts

@@ -0,0 +1,29 @@
+export interface PlinkLDRecord {
+    chrA: string;
+    bpA: number;
+    snpA: string;
+    chrB: string;
+    bpB: number;
+    snpB: string;
+    r2: number;
+    dprime?: number;
+    mafA?: number;
+    mafB?: number;
+}
+export interface PlinkLDHeader {
+    columns: string[];
+    hasR2: boolean;
+    hasDprime: boolean;
+    hasMafA: boolean;
+    hasMafB: boolean;
+    chrAIdx: number;
+    bpAIdx: number;
+    snpAIdx: number;
+    chrBIdx: number;
+    bpBIdx: number;
+    snpBIdx: number;
+    r2Idx: number;
+    dprimeIdx: number;
+    mafAIdx: number;
+    mafBIdx: number;
+}

package/esm/PlinkLDAdapter/types.js

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

package/esm/VariantFeatureWidget/VariantSampleGrid/VariantSampleGrid.js

@@ -43,7 +43,7 @@ export default function VariantSampleGrid(props) {
     }, [rows, filteredRows, descriptions]);
     return !rows.length ? null : (_jsxs(BaseCard, { ...props, title: "Samples", children: [error ? _jsx(Typography, { color: "error", children: `${error}` }) : null, _jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 8 }, children: [_jsx(CascadingMenuButton, { menuItems: [
                             {
-                                label: 'Show allele counts ("dosage") instead of exact GT',
+                                label: 'Show allele counts ("dosage")',
                                 helpText: 'This converts a genotype like 1/1 into 1:2 which says there were two occurrences of the ALT allele 1 in the genotype',
                                 type: 'checkbox',
                                 checked: useCounts,

package/esm/VariantRPC/MultiVariantGetFeatureDetails.d.ts

@@ -0,0 +1,14 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+interface GetFeatureArgs {
+    featureId: string;
+    sessionId: string;
+    trackInstanceId: string;
+    rendererType: string;
+}
+export declare class MultiVariantGetFeatureDetails extends RpcMethodType {
+    name: string;
+    execute(args: GetFeatureArgs): Promise<{
+        feature: import("@jbrowse/core/util").SimpleFeatureSerialized | undefined;
+    }>;
+}
+export {};

package/esm/VariantRPC/MultiVariantGetFeatureDetails.js

@@ -0,0 +1,15 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+export class MultiVariantGetFeatureDetails extends RpcMethodType {
+    name = 'MultiVariantGetFeatureDetails';
+    async execute(args) {
+        const { featureId, sessionId, trackInstanceId, rendererType } = args;
+        const RendererType = this.pluginManager.getRendererType(rendererType);
+        const feature = RendererType.getFeatureById(featureId, {
+            sessionId,
+            trackInstanceId,
+        });
+        return {
+            feature: feature?.toJSON(),
+        };
+    }
+}

package/esm/VariantRPC/executeClusterGenotypeMatrix.d.ts

@@ -1,4 +1,4 @@
-import type { Source } from '../shared/types.ts';
+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, StopToken } from '@jbrowse/core/util';
@@ -15,6 +15,8 @@ export declare function executeClusterGenotypeMatrix({ pluginManager, args, }: {
         lengthCutoffFilter: number;
         statusCallback: (arg: string) => void;
         sources: Source[];
+        renderingMode?: string;
+        sampleInfo?: Record<string, SampleInfo>;
     };
 }): Promise<{
     order: number[];

package/esm/VariantRPC/executeClusterGenotypeMatrix.js

@@ -1,10 +1,14 @@
 import { clusterData, toNewick } from '@gmod/hclust';
 import { getGenotypeMatrix } from "./getGenotypeMatrix.js";
+import { getPhasedGenotypeMatrix } from "./getPhasedGenotypeMatrix.js";
 export async function executeClusterGenotypeMatrix({ pluginManager, args, }) {
-    const matrix = await getGenotypeMatrix({
-        pluginManager,
-        args,
-    });
+    const { renderingMode, sampleInfo } = args;
+    const matrix = renderingMode === 'phased' && sampleInfo
+        ? await getPhasedGenotypeMatrix({
+            pluginManager,
+            args: { ...args, sampleInfo },
+        })
+        : await getGenotypeMatrix({ pluginManager, args });
     const sampleLabels = Object.keys(matrix);
     const result = await clusterData({
         data: Object.values(matrix),

package/esm/VariantRPC/getLDMatrix.d.ts

@@ -0,0 +1,48 @@
+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 type LDMetric = 'r2' | 'dprime';
+export interface FilterStats {
+    totalVariants: number;
+    passedVariants: number;
+    filteredByMaf: number;
+    filteredByLength: number;
+    filteredByMultiallelic: number;
+    filteredByHwe: number;
+    filteredByCallRate: number;
+}
+export interface RecombinationData {
+    values: Float32Array;
+    positions: number[];
+}
+export interface LDMatrixResult {
+    snps: {
+        id: string;
+        refName: string;
+        start: number;
+        end: number;
+    }[];
+    ldValues: Float32Array;
+    metric: LDMetric;
+    filterStats: FilterStats;
+    recombination: RecombinationData;
+}
+export declare function getLDMatrix({ pluginManager, args, }: {
+    pluginManager: PluginManager;
+    args: {
+        adapterConfig: AnyConfigurationModel;
+        stopToken?: StopToken;
+        sessionId: string;
+        headers?: Record<string, string>;
+        regions: Region[];
+        bpPerPx: number;
+        minorAlleleFrequencyFilter: number;
+        lengthCutoffFilter: number;
+        hweFilterThreshold?: number;
+        callRateFilter?: number;
+        jexlFilters?: string[];
+        ldMetric?: LDMetric;
+        signedLD?: boolean;
+    };
+}): Promise<LDMatrixResult>;

package/esm/VariantRPC/getLDMatrix.js

@@ -0,0 +1,388 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain';
+import { checkStopToken2, createStopTokenChecker, } 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 = [], stopToken, ldMetric = 'r2', signedLD = false, } = args;
+    const lastCheck = createStopTokenChecker(stopToken);
+    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,
+        lastCheck,
+        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(lastCheck);
+    }
+    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(lastCheck);
+    }
+    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 };
+}