@jbrowse/plugin-variants 4.0.3 → 4.1.1

package/esm/LDDisplay/components/LDDisplayComponent.js

@@ -0,0 +1,203 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import BaseTooltip from '@jbrowse/core/ui/BaseTooltip';
+import { getContainingView } from '@jbrowse/core/util';
+import Flatbush from '@jbrowse/core/util/flatbush';
+import { observer } from 'mobx-react';
+import BaseDisplayComponent from "./BaseDisplayComponent.js";
+import LDColorLegend from "./LDColorLegend.js";
+import LinesConnectingMatrixToGenomicPosition, { VariantLabels, Wrapper, } from "./LinesConnectingMatrixToGenomicPosition.js";
+import RecombinationTrack from "../../shared/components/RecombinationTrack.js";
+import RecombinationYScaleBar from "../../shared/components/RecombinationYScaleBar.js";
+const SQRT2 = Math.sqrt(2);
+function LDTooltip({ item, x, y, ldMetric, signedLD, }) {
+    let metricLabel;
+    if (ldMetric === 'dprime') {
+        metricLabel = "D'";
+    }
+    else {
+        metricLabel = signedLD ? 'R' : 'R²';
+    }
+    return (_jsxs(BaseTooltip, { clientPoint: { x: x + 15, y }, children: [_jsx("div", { children: item.snp1.id }), _jsx("div", { children: item.snp2.id }), _jsxs("div", { children: [metricLabel, ": ", item.ldValue.toFixed(3)] })] }));
+}
+function Crosshairs({ hoveredItem, cellWidth, genomicX1, genomicX2, yScalar, lineZoneHeight, tickHeight, width, height, useGenomicPositions, snps, regionStart, bpPerPx, canvasOffset, }) {
+    const { i, j } = hoveredItem;
+    const toScreen = (x, y) => {
+        const rx = (x + y) / SQRT2;
+        const ry = (y - x) / SQRT2;
+        return { x: rx, y: ry * yScalar + lineZoneHeight };
+    };
+    let hoveredCenter;
+    let snpJPos;
+    let snpIPos;
+    if (useGenomicPositions && snps.length > 0) {
+        const getBoundary = (idx) => {
+            const snpPos = snps[idx].start;
+            const prevPos = idx > 0 ? snps[idx - 1].start : regionStart;
+            const boundaryPos = (prevPos + snpPos) / 2;
+            return (boundaryPos - regionStart) / bpPerPx / SQRT2;
+        };
+        const getNextBoundary = (idx) => {
+            if (idx + 1 < snps.length) {
+                const snpPos = snps[idx].start;
+                const nextPos = snps[idx + 1].start;
+                return ((snpPos + nextPos) / 2 - regionStart) / bpPerPx / SQRT2;
+            }
+            const lastSnpPos = snps[snps.length - 1].start;
+            return (lastSnpPos + 50 * bpPerPx - regionStart) / bpPerPx / SQRT2;
+        };
+        const jBoundary = getBoundary(j);
+        const iBoundary = getBoundary(i);
+        const jNextBoundary = getNextBoundary(j);
+        const iNextBoundary = getNextBoundary(i);
+        const cellCenterX = (jBoundary + jNextBoundary) / 2;
+        const cellCenterY = (iBoundary + iNextBoundary) / 2;
+        hoveredCenter = toScreen(cellCenterX, cellCenterY);
+        snpJPos = { x: genomicX1, y: lineZoneHeight };
+        snpIPos = { x: genomicX2, y: lineZoneHeight };
+    }
+    else {
+        const w = cellWidth;
+        hoveredCenter = toScreen((j + 0.5) * w, (i + 0.5) * w);
+        snpJPos = toScreen((j + 0.5) * w, (j + 0.5) * w);
+        snpIPos = toScreen((i + 0.5) * w, (i + 0.5) * w);
+    }
+    return (_jsxs("svg", { style: {
+            position: 'absolute',
+            left: canvasOffset,
+            top: 0,
+            width,
+            height,
+            pointerEvents: 'none',
+        }, children: [_jsx("path", { stroke: "rgba(0, 0, 0, 0.6)", strokeWidth: 1, fill: "none", d: `M ${snpJPos.x} ${snpJPos.y} L ${hoveredCenter.x} ${hoveredCenter.y} L ${snpIPos.x} ${snpIPos.y}` }), _jsxs("g", { stroke: "#e00", strokeWidth: "1.5", fill: "none", children: [!useGenomicPositions ? (_jsxs(_Fragment, { children: [_jsx("path", { d: `M ${snpJPos.x} ${snpJPos.y} L ${genomicX1} ${tickHeight}` }), _jsx("path", { d: `M ${snpIPos.x} ${snpIPos.y} L ${genomicX2} ${tickHeight}` })] })) : null, _jsx("path", { d: `M ${genomicX1} 0 L ${genomicX1} ${tickHeight}` }), _jsx("path", { d: `M ${genomicX2} 0 L ${genomicX2} ${tickHeight}` })] })] }));
+}
+function screenToUnrotated(screenX, screenY, yScalar, lineZoneHeight) {
+    const matrixY = screenY - lineZoneHeight;
+    const scaledY = matrixY / yScalar;
+    const x = (screenX - scaledY) / SQRT2;
+    const y = (screenX + scaledY) / SQRT2;
+    return { x, y };
+}
+const LDCanvas = observer(function LDCanvas({ model, }) {
+    const view = getContainingView(model);
+    const width = Math.round(view.dynamicBlocks.totalWidthPx);
+    const { fullyDrawn, flatbush, flatbushItems, yScalar, cellWidth, showLegend, ldMetric, lineZoneHeight, fitToHeight, ldCanvasHeight, useGenomicPositions, snps, lastDrawnOffsetPx, signedLD, } = model;
+    const triangleHeight = width / 2;
+    const canvasOnlyHeight = fitToHeight ? ldCanvasHeight : triangleHeight;
+    const containerHeight = canvasOnlyHeight + lineZoneHeight;
+    const [hoveredItem, setHoveredItem] = useState();
+    const [mousePosition, setMousePosition] = useState();
+    const containerRef = useRef(null);
+    const region = view.dynamicBlocks.contentBlocks[0];
+    const bpPerPx = view.bpPerPx;
+    const genomicX1 = hoveredItem && region
+        ? (hoveredItem.snp2.start - region.start) / bpPerPx
+        : undefined;
+    const genomicX2 = hoveredItem && region
+        ? (hoveredItem.snp1.start - region.start) / bpPerPx
+        : undefined;
+    const canvasOffset = view.offsetPx >= 0
+        ? (lastDrawnOffsetPx ?? 0) - view.offsetPx
+        : Math.max(0, -view.offsetPx);
+    const guideOffset = canvasOffset;
+    useEffect(() => {
+        if (genomicX1 !== undefined &&
+            genomicX2 !== undefined &&
+            model.showVerticalGuides) {
+            view.setVolatileGuides([
+                { xPos: genomicX1 + guideOffset },
+                { xPos: genomicX2 + guideOffset },
+            ]);
+        }
+        else {
+            view.setVolatileGuides([]);
+        }
+        return () => {
+            view.setVolatileGuides([]);
+        };
+    }, [genomicX1, genomicX2, model.showVerticalGuides, view, guideOffset]);
+    const flatbushIndex = useMemo(() => (flatbush ? Flatbush.from(flatbush) : null), [flatbush]);
+    const cb = useCallback((ref) => {
+        model.setRef(ref);
+    }, [model, width, canvasOnlyHeight]);
+    const onMouseMove = useCallback((event) => {
+        const container = containerRef.current;
+        if (!container || !flatbushIndex || !flatbushItems.length) {
+            setHoveredItem(undefined);
+            setMousePosition(undefined);
+            return;
+        }
+        const rect = container.getBoundingClientRect();
+        const mouseCanvasOffset = canvasOffset;
+        const screenX = event.clientX - rect.left - mouseCanvasOffset;
+        const screenY = event.clientY - rect.top;
+        setMousePosition({ x: event.clientX, y: event.clientY });
+        if (screenY < lineZoneHeight) {
+            setHoveredItem(undefined);
+            return;
+        }
+        const { x, y } = screenToUnrotated(screenX, screenY, yScalar, lineZoneHeight);
+        const results = flatbushIndex.search(x - 1, y - 1, x + 1, y + 1);
+        if (results.length > 0) {
+            const item = flatbushItems[results[0]];
+            setHoveredItem(item);
+        }
+        else {
+            setHoveredItem(undefined);
+        }
+    }, [flatbushIndex, flatbushItems, yScalar, lineZoneHeight, canvasOffset]);
+    const onMouseLeave = useCallback(() => {
+        setHoveredItem(undefined);
+        setMousePosition(undefined);
+    }, []);
+    return (_jsxs("div", { ref: containerRef, style: {
+            cursor: hoveredItem && mousePosition ? 'crosshair' : undefined,
+            position: 'relative',
+            width,
+            height: containerHeight,
+            overflow: 'hidden',
+        }, onMouseMove: onMouseMove, onMouseLeave: onMouseLeave, children: [_jsx("canvas", { "data-testid": `ld_canvas${fullyDrawn ? '_done' : ''}`, ref: cb, style: {
+                    width,
+                    height: canvasOnlyHeight,
+                    position: 'absolute',
+                    left: canvasOffset,
+                    top: lineZoneHeight,
+                }, width: width * 2, height: canvasOnlyHeight * 2 }), hoveredItem && genomicX1 !== undefined && genomicX2 !== undefined ? (_jsx(Crosshairs, { hoveredItem: hoveredItem, cellWidth: cellWidth, genomicX1: genomicX1, genomicX2: genomicX2, yScalar: yScalar, lineZoneHeight: lineZoneHeight, tickHeight: model.tickHeight, width: width, height: containerHeight, useGenomicPositions: useGenomicPositions, snps: snps, regionStart: region?.start ?? 0, bpPerPx: bpPerPx, canvasOffset: canvasOffset })) : null, hoveredItem && mousePosition ? (_jsx(LDTooltip, { item: hoveredItem, x: mousePosition.x, y: mousePosition.y, ldMetric: ldMetric, signedLD: signedLD })) : null, showLegend ? (_jsx(LDColorLegend, { ldMetric: ldMetric, signedLD: signedLD })) : null, useGenomicPositions ? (_jsx(Wrapper, { model: model, children: _jsx(VariantLabels, { model: model }) })) : (_jsx(LinesConnectingMatrixToGenomicPosition, { model: model })), model.showRecombination && model.recombination ? (_jsxs("div", { style: {
+                    position: 'absolute',
+                    left: canvasOffset,
+                    top: lineZoneHeight / 2,
+                    width,
+                    height: lineZoneHeight / 2,
+                    pointerEvents: 'none',
+                }, children: [_jsx(RecombinationTrack, { model: model, width: width, height: lineZoneHeight / 2, useGenomicPositions: useGenomicPositions, regionStart: region?.start, bpPerPx: bpPerPx }), _jsx(RecombinationYScaleBar, { height: lineZoneHeight / 2, maxValue: Math.max(...model.recombination.values, 0.1) })] })) : null] }));
+});
+const LDDisplayContent = observer(function LDDisplayContent({ model, }) {
+    const view = getContainingView(model);
+    const width = Math.round(view.dynamicBlocks.totalWidthPx);
+    const { height, showLDTriangle, showRecombination } = model;
+    if (view.bpPerPx > 1000) {
+        return (_jsx("div", { style: {
+                width,
+                height,
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                color: '#666',
+            }, children: "Zoom in to see LD data" }));
+    }
+    if (!showLDTriangle && !showRecombination) {
+        return (_jsx("div", { style: {
+                width,
+                height,
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                color: '#666',
+            }, children: "Enable LD triangle or recombination track in display settings" }));
+    }
+    return (_jsx("div", { style: { position: 'relative', width, height }, children: showLDTriangle ? _jsx(LDCanvas, { model: model }) : null }));
+});
+const LDDisplayComponent = observer(function LDDisplayComponent({ model, }) {
+    return (_jsx(BaseDisplayComponent, { model: model, children: _jsx(LDDisplayContent, { model: model }) }));
+});
+export default LDDisplayComponent;

package/esm/LDDisplay/components/LinesConnectingMatrixToGenomicPosition.d.ts

@@ -0,0 +1,16 @@
+import type { SharedLDModel } from '../shared.ts';
+export declare const Wrapper: ({ children, model, exportSVG, yOffset, }: {
+    model: SharedLDModel;
+    children: React.ReactNode;
+    exportSVG?: boolean;
+    yOffset?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const VariantLabels: ({ model, }: {
+    model: SharedLDModel;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const LinesConnectingMatrixToGenomicPosition: ({ model, exportSVG, yOffset, }: {
+    model: SharedLDModel;
+    exportSVG?: boolean;
+    yOffset?: number;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default LinesConnectingMatrixToGenomicPosition;

package/esm/LDDisplay/components/LinesConnectingMatrixToGenomicPosition.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, isValidElement, useState } from 'react';
+import { ResizeHandle, SanitizedHTML } from '@jbrowse/core/ui';
+import BaseTooltip from '@jbrowse/core/ui/BaseTooltip';
+import { getContainingView, getSession, getStrokeProps, } from '@jbrowse/core/util';
+import { makeStyles } from '@jbrowse/core/util/tss-react';
+import { alpha, useTheme } from '@mui/material';
+import { observer } from 'mobx-react';
+const useStyles = makeStyles()(theme => ({
+    resizeHandle: {
+        height: 5,
+        boxSizing: 'border-box',
+        background: 'transparent',
+        '&:hover': {
+            background: theme.palette.divider,
+        },
+    },
+}));
+export const Wrapper = observer(function Wrapper({ children, model, exportSVG, yOffset = 0, }) {
+    const { height } = model;
+    const { width, offsetPx } = getContainingView(model);
+    const left = Math.max(0, -offsetPx);
+    return exportSVG ? (_jsx("g", { transform: `translate(${left} ${yOffset})`, children: children })) : (_jsx("svg", { style: {
+            position: 'absolute',
+            top: 0,
+            left,
+            height,
+            width,
+        }, children: children }));
+});
+function getGenomicX(view, assembly, snp, offsetAdjustment) {
+    return ((view.bpToPx({
+        refName: assembly.getCanonicalRefName2(snp.refName),
+        coord: snp.start,
+    })?.offsetPx || 0) - offsetAdjustment);
+}
+const TooltipContents = forwardRef(function TooltipContents2({ message }, ref) {
+    return (_jsx("div", { ref: ref, children: isValidElement(message) ? (message) : message ? (_jsx(SanitizedHTML, { html: String(message) })) : null }));
+});
+const LineTooltip = observer(function LineTooltip({ contents, }) {
+    return contents ? (_jsx(BaseTooltip, { children: _jsx(TooltipContents, { message: contents }) })) : null;
+});
+export const VariantLabels = observer(function VariantLabels({ model, }) {
+    const theme = useTheme();
+    const { assemblyManager } = getSession(model);
+    const view = getContainingView(model);
+    const { snps, showLabels } = model;
+    const { offsetPx, assemblyNames } = view;
+    const assembly = assemblyManager.get(assemblyNames[0]);
+    const offsetAdj = Math.max(offsetPx, 0);
+    if (!assembly || snps.length === 0 || !showLabels) {
+        return null;
+    }
+    return (_jsx(_Fragment, { children: snps.map((snp, i) => {
+            const genomicX = getGenomicX(view, assembly, snp, offsetAdj);
+            return (_jsx("text", { x: genomicX, y: 0, transform: `rotate(-90, ${genomicX}, 0)`, fontSize: 10, textAnchor: "end", dominantBaseline: "middle", fill: theme.palette.text.primary, style: { pointerEvents: 'none' }, children: snp.id || 'NOLABEL' }, `${snp.id}-${i}`));
+        }) }));
+});
+const AllLines = observer(function AllLines({ model, setMouseOverLine, }) {
+    const theme = useTheme();
+    const { assemblyManager } = getSession(model);
+    const view = getContainingView(model);
+    const { lineZoneHeight, snps, tickHeight } = model;
+    const { offsetPx, assemblyNames, dynamicBlocks } = view;
+    const assembly = assemblyManager.get(assemblyNames[0]);
+    const b0 = dynamicBlocks.contentBlocks[0]?.widthPx || 0;
+    const n = snps.length;
+    const offsetAdj = Math.max(offsetPx, 0);
+    const strokeProps = getStrokeProps(alpha(theme.palette.text.primary, 0.4));
+    if (!assembly || n === 0) {
+        return null;
+    }
+    return (_jsxs(_Fragment, { children: [snps.map((snp, i) => {
+                const genomicX = getGenomicX(view, assembly, snp, offsetAdj);
+                const matrixX = ((i + 0.5) * b0) / n;
+                return (_jsxs("g", { onMouseEnter: () => {
+                        setMouseOverLine({ snp, idx: i, genomicX });
+                    }, onMouseLeave: () => {
+                        setMouseOverLine(undefined);
+                    }, children: [_jsx("line", { ...strokeProps, strokeWidth: 1, x1: matrixX, x2: genomicX, y1: lineZoneHeight, y2: tickHeight }), _jsx("line", { ...strokeProps, strokeWidth: 1, x1: genomicX, x2: genomicX, y1: 0, y2: tickHeight })] }, `${snp.id}-${i}`));
+            }), _jsx(VariantLabels, { model: model })] }));
+});
+const LinesConnectingMatrixToGenomicPosition = observer(function LinesConnectingMatrixToGenomicPosition({ model, exportSVG, yOffset = 0, }) {
+    const { classes } = useStyles();
+    const view = getContainingView(model);
+    const [mouseOverLine, setMouseOverLine] = useState();
+    const { lineZoneHeight, snps } = model;
+    const { dynamicBlocks } = view;
+    const b0 = dynamicBlocks.contentBlocks[0]?.widthPx || 0;
+    const n = snps.length;
+    if (n === 0) {
+        return null;
+    }
+    const highlightMatrixX = mouseOverLine
+        ? ((mouseOverLine.idx + 0.5) * b0) / n
+        : 0;
+    return (_jsxs(_Fragment, { children: [_jsxs(Wrapper, { exportSVG: exportSVG, model: model, yOffset: yOffset, children: [_jsx(AllLines, { model: model, setMouseOverLine: setMouseOverLine }), mouseOverLine ? (_jsxs(_Fragment, { children: [_jsx("line", { stroke: "#f00c", strokeWidth: 2, style: {
+                                    pointerEvents: 'none',
+                                }, x1: highlightMatrixX, x2: mouseOverLine.genomicX, y1: lineZoneHeight, y2: model.tickHeight }), _jsx("line", { stroke: "#f00c", strokeWidth: 2, style: {
+                                    pointerEvents: 'none',
+                                }, x1: mouseOverLine.genomicX, x2: mouseOverLine.genomicX, y1: 0, y2: model.tickHeight }), _jsx(LineTooltip, { contents: mouseOverLine.snp.id })] })) : null] }), !exportSVG ? (_jsx(ResizeHandle, { style: {
+                    position: 'absolute',
+                    top: lineZoneHeight - 4,
+                }, onDrag: d => {
+                    model.setLineZoneHeight(lineZoneHeight + d);
+                    return undefined;
+                }, className: classes.resizeHandle })) : null] }));
+});
+export default LinesConnectingMatrixToGenomicPosition;

package/esm/LDDisplay/configSchema1.d.ts

@@ -0,0 +1,115 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+export default function configSchemaF(_pluginManager: PluginManager): import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    renderer: import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        maxHeight: {
+            type: string;
+            description: string;
+            defaultValue: number;
+        };
+    }, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    height: {
+        type: string;
+        defaultValue: number;
+    };
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    minorAlleleFrequencyFilter: {
+        type: string;
+        defaultValue: number;
+    };
+    lengthCutoffFilter: {
+        type: string;
+        defaultValue: number;
+    };
+    lineZoneHeight: {
+        type: string;
+        defaultValue: number;
+    };
+    ldMetric: {
+        type: string;
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+        defaultValue: string;
+    };
+    colorScheme: {
+        type: string;
+        defaultValue: string;
+    };
+    showLegend: {
+        type: string;
+        defaultValue: boolean;
+    };
+    showLDTriangle: {
+        type: string;
+        defaultValue: boolean;
+    };
+    showRecombination: {
+        type: string;
+        defaultValue: boolean;
+    };
+    recombinationZoneHeight: {
+        type: string;
+        defaultValue: number;
+    };
+    fitToHeight: {
+        type: string;
+        defaultValue: boolean;
+    };
+    hweFilterThreshold: {
+        type: string;
+        defaultValue: number;
+    };
+    callRateFilter: {
+        type: string;
+        defaultValue: number;
+    };
+    showVerticalGuides: {
+        type: string;
+        defaultValue: boolean;
+    };
+    showLabels: {
+        type: string;
+        defaultValue: boolean;
+    };
+    tickHeight: {
+        type: string;
+        defaultValue: number;
+    };
+    useGenomicPositions: {
+        type: string;
+        defaultValue: boolean;
+    };
+    signedLD: {
+        type: string;
+        defaultValue: boolean;
+    };
+    jexlFilters: {
+        type: string;
+        defaultValue: never[];
+    };
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    maxFeatureScreenDensity: {
+        type: string;
+        description: string;
+        defaultValue: number;
+    };
+    fetchSizeLimit: {
+        type: string;
+        defaultValue: number;
+        description: string;
+    };
+    height: {
+        type: string;
+        defaultValue: number;
+        description: string;
+    };
+    mouseover: {
+        type: string;
+        description: string;
+        defaultValue: string;
+        contextVariable: string[];
+    };
+    jexlFilters: {
+        type: string;
+        description: string;
+        defaultValue: never[];
+    };
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "displayId">>, undefined>>, undefined>>;

package/esm/LDDisplay/configSchema1.js

@@ -0,0 +1,16 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import sharedLDConfigFactory from "./SharedLDConfigSchema.js";
+import configSchema from "../LDRenderer/configSchema.js";
+function x() { }
+export default function configSchemaF(_pluginManager) {
+    return ConfigurationSchema('LDDisplay', {
+        renderer: configSchema,
+        height: {
+            type: 'number',
+            defaultValue: 400,
+        },
+    }, {
+        baseConfiguration: sharedLDConfigFactory(),
+        explicitlyTyped: true,
+    });
+}

package/esm/LDDisplay/configSchema2.d.ts

@@ -0,0 +1,115 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+export default function configSchemaF(_pluginManager: PluginManager): import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    renderer: import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        maxHeight: {
+            type: string;
+            description: string;
+            defaultValue: number;
+        };
+    }, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    height: {
+        type: string;
+        defaultValue: number;
+    };
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    minorAlleleFrequencyFilter: {
+        type: string;
+        defaultValue: number;
+    };
+    lengthCutoffFilter: {
+        type: string;
+        defaultValue: number;
+    };
+    lineZoneHeight: {
+        type: string;
+        defaultValue: number;
+    };
+    ldMetric: {
+        type: string;
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+        defaultValue: string;
+    };
+    colorScheme: {
+        type: string;
+        defaultValue: string;
+    };
+    showLegend: {
+        type: string;
+        defaultValue: boolean;
+    };
+    showLDTriangle: {
+        type: string;
+        defaultValue: boolean;
+    };
+    showRecombination: {
+        type: string;
+        defaultValue: boolean;
+    };
+    recombinationZoneHeight: {
+        type: string;
+        defaultValue: number;
+    };
+    fitToHeight: {
+        type: string;
+        defaultValue: boolean;
+    };
+    hweFilterThreshold: {
+        type: string;
+        defaultValue: number;
+    };
+    callRateFilter: {
+        type: string;
+        defaultValue: number;
+    };
+    showVerticalGuides: {
+        type: string;
+        defaultValue: boolean;
+    };
+    showLabels: {
+        type: string;
+        defaultValue: boolean;
+    };
+    tickHeight: {
+        type: string;
+        defaultValue: number;
+    };
+    useGenomicPositions: {
+        type: string;
+        defaultValue: boolean;
+    };
+    signedLD: {
+        type: string;
+        defaultValue: boolean;
+    };
+    jexlFilters: {
+        type: string;
+        defaultValue: never[];
+    };
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    maxFeatureScreenDensity: {
+        type: string;
+        description: string;
+        defaultValue: number;
+    };
+    fetchSizeLimit: {
+        type: string;
+        defaultValue: number;
+        description: string;
+    };
+    height: {
+        type: string;
+        defaultValue: number;
+        description: string;
+    };
+    mouseover: {
+        type: string;
+        description: string;
+        defaultValue: string;
+        contextVariable: string[];
+    };
+    jexlFilters: {
+        type: string;
+        description: string;
+        defaultValue: never[];
+    };
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "displayId">>, undefined>>, undefined>>;

package/esm/LDDisplay/configSchema2.js

@@ -0,0 +1,16 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import sharedLDConfigFactory from "./SharedLDConfigSchema.js";
+import configSchema from "../LDRenderer/configSchema.js";
+function x() { }
+export default function configSchemaF(_pluginManager) {
+    return ConfigurationSchema('LDTrackDisplay', {
+        renderer: configSchema,
+        height: {
+            type: 'number',
+            defaultValue: 400,
+        },
+    }, {
+        baseConfiguration: sharedLDConfigFactory(),
+        explicitlyTyped: true,
+    });
+}

package/esm/LDDisplay/index.d.ts

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

package/esm/LDDisplay/index.js

@@ -0,0 +1,35 @@
+import { lazy } from 'react';
+import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
+import configSchemaF1 from "./configSchema1.js";
+import configSchemaF2 from "./configSchema2.js";
+import stateModelFactory1 from "./stateModel1.js";
+import stateModelFactory2 from "./stateModel2.js";
+const LazyLDDisplayComponent = lazy(() => import("./components/LDDisplayComponent.js"));
+export default function LDDisplayF(pluginManager) {
+    pluginManager.addDisplayType(() => {
+        const configSchema = configSchemaF1(pluginManager);
+        return new DisplayType({
+            name: 'LDDisplay',
+            displayName: 'LD heatmap display',
+            helpText: 'Displays a linkage disequilibrium (LD) heatmap showing pairwise R² values between variants computed directly from VCF genotypes',
+            configSchema,
+            stateModel: stateModelFactory1(configSchema),
+            trackType: 'VariantTrack',
+            viewType: 'LinearGenomeView',
+            ReactComponent: LazyLDDisplayComponent,
+        });
+    });
+    pluginManager.addDisplayType(() => {
+        const configSchema = configSchemaF2(pluginManager);
+        return new DisplayType({
+            name: 'LDTrackDisplay',
+            displayName: 'LD heatmap display',
+            helpText: 'Displays a linkage disequilibrium (LD) heatmap from pre-computed LD data (e.g., PLINK --r2 output)',
+            configSchema,
+            stateModel: stateModelFactory2(configSchema),
+            trackType: 'LDTrack',
+            viewType: 'LinearGenomeView',
+            ReactComponent: LazyLDDisplayComponent,
+        });
+    });
+}

package/esm/LDDisplay/renderSvg.d.ts

@@ -0,0 +1,3 @@
+import type { SharedLDModel } from './shared.ts';
+import type { ExportSvgDisplayOptions } from '@jbrowse/plugin-linear-genome-view';
+export declare function renderSvg(self: SharedLDModel, opts: ExportSvgDisplayOptions): Promise<import("react/jsx-runtime").JSX.Element | null>;