@jbrowse/plugin-variants 3.7.0 → 4.0.0

package/esm/MultiLinearVariantMatrixRenderer/makeImageData.js

@@ -1,151 +1,171 @@
-import { forEachWithStopTokenCheck, updateStatus } from '@jbrowse/core/util';
-import { checkStopToken } from '@jbrowse/core/util/stopToken';
-import { f2 } from '../shared/constants';
-import { drawColorAlleleCount, getColorAlleleCount, } from '../shared/drawAlleleCount';
-import { drawPhased } from '../shared/drawPhased';
-import { getFeaturesThatPassMinorAlleleFrequencyFilter } from '../shared/minorAlleleFrequencyUtils';
-export async function makeImageData({ ctx, canvasWidth, canvasHeight, renderArgs, }) {
-    const { renderingMode, minorAlleleFrequencyFilter, sources, features, stopToken, lengthCutoffFilter, } = renderArgs;
-    const { statusCallback = () => { } } = renderArgs;
-    const h = canvasHeight / sources.length;
-    checkStopToken(stopToken);
-    const mafs = await updateStatus('Calculating stats', statusCallback, () => getFeaturesThatPassMinorAlleleFrequencyFilter({
-        stopToken,
-        features: features.values(),
-        minorAlleleFrequencyFilter,
-        lengthCutoffFilter,
-    }));
-    checkStopToken(stopToken);
+import { updateStatus } from '@jbrowse/core/util';
+import { checkStopToken2, createStopTokenChecker, } from '@jbrowse/core/util/stopToken';
+import { f2 } from "../shared/constants.js";
+import { drawColorAlleleCount, getAlleleColor, } from "../shared/drawAlleleCount.js";
+import { drawPhased } from "../shared/drawPhased.js";
+import { getFeaturesThatPassMinorAlleleFrequencyFilter } from "../shared/minorAlleleFrequencyUtils.js";
+function drawPhasedMode(drawCtx, mafs) {
+    const { ctx, sources, startRow, endRow, h, w, scrollTop, splitCache, genotypesCache, stopToken, } = drawCtx;
     const arr = [];
-    const m = mafs.length;
-    const w = canvasWidth / m;
-    await updateStatus('Drawing variant matrix', statusCallback, () => {
-        const colorCache = {};
-        forEachWithStopTokenCheck(mafs, stopToken, ({ feature, mostFrequentAlt }, idx) => {
-            var _a, _b, _c;
-            const arr2 = [];
-            const hasPhaseSet = (_a = feature.get('FORMAT')) === null || _a === void 0 ? void 0 : _a.includes('PS');
-            if (hasPhaseSet) {
-                const samp = feature.get('samples');
-                const x = (idx / mafs.length) * canvasWidth;
-                const sln = sources.length;
-                for (let j = 0; j < sln; j++) {
-                    const y = (j / sln) * canvasHeight;
-                    const { name, HP } = sources[j];
-                    const s = samp[name];
-                    if (s) {
-                        const genotype = (_b = s.GT) === null || _b === void 0 ? void 0 : _b[0];
-                        if (genotype) {
-                            arr2.push(genotype);
-                            const isPhased = genotype.includes('|');
-                            if (renderingMode === 'phased') {
-                                if (isPhased) {
-                                    const PS = (_c = s.PS) === null || _c === void 0 ? void 0 : _c[0];
-                                    const alleles = genotype.split('|');
-                                    drawPhased(alleles, ctx, x, y, w, h, HP, PS);
-                                }
-                                else {
-                                    ctx.fillStyle = 'black';
-                                    ctx.fillRect(x - f2, y - f2, w + f2, h + f2);
-                                }
-                            }
-                            else {
-                                const cacheKey = `${genotype}:${mostFrequentAlt}`;
-                                let c = colorCache[cacheKey];
-                                if (c === undefined) {
-                                    let alt = 0;
-                                    let uncalled = 0;
-                                    let alt2 = 0;
-                                    let ref = 0;
-                                    const alleles = genotype.split(/[/|]/);
-                                    const total = alleles.length;
-                                    for (let i = 0; i < total; i++) {
-                                        const allele = alleles[i];
-                                        if (allele === mostFrequentAlt) {
-                                            alt++;
-                                        }
-                                        else if (allele === '0') {
-                                            ref++;
-                                        }
-                                        else if (allele === '.') {
-                                            uncalled++;
-                                        }
-                                        else {
-                                            alt2++;
-                                        }
-                                    }
-                                    c = getColorAlleleCount(ref, alt, alt2, uncalled, total, true);
-                                    colorCache[cacheKey] = c;
-                                }
-                                if (c) {
-                                    drawColorAlleleCount(c, ctx, x, y, w, h);
-                                }
-                            }
+    const lastCheck = createStopTokenChecker(stopToken);
+    for (let idx = 0, l = mafs.length; idx < l; idx++) {
+        const { feature } = mafs[idx];
+        const arr2 = [];
+        const hasPhaseSet = feature.get('FORMAT')?.includes('PS');
+        const x = idx * w;
+        if (hasPhaseSet) {
+            const samp = feature.get('samples');
+            for (let j = startRow; j < endRow; j++) {
+                const y = j * h - scrollTop;
+                const { name, HP } = sources[j];
+                const s = samp[name];
+                if (s) {
+                    const genotype = s.GT?.[0];
+                    if (genotype) {
+                        arr2.push(genotype);
+                        const isPhased = genotype.includes('|');
+                        if (isPhased) {
+                            const PS = s.PS?.[0];
+                            const alleles = splitCache[genotype] ??
+                                (splitCache[genotype] = genotype.split('|'));
+                            drawPhased(alleles, ctx, x, y, w, h, HP, PS);
                         }
+                        else {
+                            ctx.fillStyle = 'black';
+                            ctx.fillRect(x - f2, y - f2, w + f2, h + f2);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const featureId = feature.id();
+            let samp = genotypesCache.get(featureId);
+            if (!samp) {
+                samp = feature.get('genotypes');
+                genotypesCache.set(featureId, samp);
+            }
+            for (let j = startRow; j < endRow; j++) {
+                const y = j * h - scrollTop;
+                const { name, HP } = sources[j];
+                const genotype = samp[name];
+                if (genotype) {
+                    arr2.push(genotype);
+                    const isPhased = genotype.includes('|');
+                    if (isPhased) {
+                        const alleles = splitCache[genotype] ??
+                            (splitCache[genotype] = genotype.split('|'));
+                        drawPhased(alleles, ctx, x, y, w, h, HP);
+                    }
+                    else {
+                        ctx.fillStyle = 'black';
+                        ctx.fillRect(x - f2, y - f2, w + f2, h + f2);
                     }
                 }
             }
-            else {
-                const samp = feature.get('genotypes');
-                const x = (idx / mafs.length) * canvasWidth;
-                const sln = sources.length;
-                for (let j = 0; j < sln; j++) {
-                    const y = (j / sln) * canvasHeight;
-                    const { name, HP } = sources[j];
-                    const genotype = samp[name];
+        }
+        arr.push(arr2);
+        checkStopToken2(lastCheck);
+    }
+    return arr;
+}
+function drawAlleleCountMode(drawCtx, mafs) {
+    const { ctx, sources, startRow, endRow, h, w, scrollTop, splitCache, stopToken, colorCache, genotypesCache, } = drawCtx;
+    const arr = [];
+    const lastCheck = createStopTokenChecker(stopToken);
+    for (let idx = 0, l = mafs.length; idx < l; idx++) {
+        const { feature, mostFrequentAlt } = mafs[idx];
+        const arr2 = [];
+        const hasPhaseSet = feature.get('FORMAT')?.includes('PS');
+        const x = idx * w;
+        if (hasPhaseSet) {
+            const samp = feature.get('samples');
+            for (let j = startRow; j < endRow; j++) {
+                const y = j * h - scrollTop;
+                const { name } = sources[j];
+                const s = samp[name];
+                if (s) {
+                    const genotype = s.GT?.[0];
                     if (genotype) {
                         arr2.push(genotype);
-                        const isPhased = genotype.includes('|');
-                        if (renderingMode === 'phased') {
-                            if (isPhased) {
-                                const alleles = genotype.split('|');
-                                drawPhased(alleles, ctx, x, y, w, h, HP);
-                            }
-                            else {
-                                ctx.fillStyle = 'black';
-                                ctx.fillRect(x - f2, y - f2, w + f2, h + f2);
-                            }
-                        }
-                        else {
-                            const cacheKey = `${genotype}:${mostFrequentAlt}`;
-                            let c = colorCache[cacheKey];
-                            if (c === undefined) {
-                                let alt = 0;
-                                let uncalled = 0;
-                                let alt2 = 0;
-                                let ref = 0;
-                                const alleles = genotype.split(/[/|]/);
-                                const total = alleles.length;
-                                for (let i = 0; i < total; i++) {
-                                    const allele = alleles[i];
-                                    if (allele === mostFrequentAlt) {
-                                        alt++;
-                                    }
-                                    else if (allele === '0') {
-                                        ref++;
-                                    }
-                                    else if (allele === '.') {
-                                        uncalled++;
-                                    }
-                                    else {
-                                        alt2++;
-                                    }
-                                }
-                                c = getColorAlleleCount(ref, alt, alt2, uncalled, total, true);
-                                colorCache[cacheKey] = c;
-                            }
-                            if (c) {
-                                drawColorAlleleCount(c, ctx, x, y, w, h);
-                            }
+                        const c = getAlleleColor(genotype, mostFrequentAlt, colorCache, splitCache, true);
+                        if (c) {
+                            drawColorAlleleCount(c, ctx, x, y, w, h);
                         }
                     }
                 }
             }
-            arr.push(arr2);
-        });
-    });
+        }
+        else {
+            const featureId = feature.id();
+            let samp = genotypesCache.get(featureId);
+            if (!samp) {
+                samp = feature.get('genotypes');
+                genotypesCache.set(featureId, samp);
+            }
+            for (let j = startRow; j < endRow; j++) {
+                const y = j * h - scrollTop;
+                const { name } = sources[j];
+                const genotype = samp[name];
+                if (genotype) {
+                    arr2.push(genotype);
+                    const c = getAlleleColor(genotype, mostFrequentAlt, colorCache, splitCache, true);
+                    if (c) {
+                        drawColorAlleleCount(c, ctx, x, y, w, h);
+                    }
+                }
+            }
+        }
+        arr.push(arr2);
+        checkStopToken2(lastCheck);
+    }
+    return arr;
+}
+export async function makeImageData({ ctx, canvasWidth, canvasHeight, renderArgs, }) {
+    const { renderingMode, minorAlleleFrequencyFilter, sources, features, stopToken, lengthCutoffFilter, rowHeight, scrollTop, statusCallback = () => { }, } = renderArgs;
+    const h = rowHeight;
+    const startRow = Math.floor(scrollTop / h);
+    const endRow = Math.min(sources.length, Math.ceil((scrollTop + canvasHeight) / h));
+    const lastCheck = createStopTokenChecker(stopToken);
+    const genotypesCache = new Map();
+    const colorCache = {};
+    const splitCache = {};
+    const mafs = await updateStatus('Calculating stats', statusCallback, () => getFeaturesThatPassMinorAlleleFrequencyFilter({
+        lastCheck,
+        features: features.values(),
+        minorAlleleFrequencyFilter,
+        lengthCutoffFilter,
+        genotypesCache,
+        splitCache,
+    }));
+    const m = mafs.length;
+    const w = canvasWidth / m;
+    const drawCtx = {
+        ctx,
+        sources,
+        startRow,
+        endRow,
+        h,
+        w,
+        scrollTop,
+        splitCache,
+        colorCache,
+        genotypesCache,
+        stopToken,
+    };
+    const arr = await updateStatus('Drawing variant matrix', statusCallback, () => renderingMode === 'phased'
+        ? drawPhasedMode(drawCtx, mafs)
+        : drawAlleleCountMode(drawCtx, mafs));
+    const featureData = mafs.map(({ feature }) => ({
+        alt: feature.get('ALT'),
+        ref: feature.get('REF'),
+        name: feature.get('name'),
+        description: feature.get('description'),
+        length: feature.get('end') - feature.get('start'),
+    }));
     return {
         mafs,
         arr,
+        featureData,
     };
 }

package/esm/MultiLinearVariantMatrixRenderer/types.d.ts

@@ -1,14 +1,2 @@
-import type { Source } from '../shared/types';
-import type { RenderArgsDeserialized as BoxRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/BoxRendererType';
-import type { Feature } from '@jbrowse/core/util';
-export interface RenderArgsDeserialized extends BoxRenderArgsDeserialized {
-    sources: Source[];
-    minorAlleleFrequencyFilter: number;
-    highResolutionScaling: number;
-    height: number;
-    features: Map<string, Feature>;
-    renderingMode: string;
-    statusCallback?: (arg: string) => void;
-    lengthCutoffFilter: number;
-    stopToken: string;
-}
+import type { MultiVariantRenderArgsBase } from '../shared/types.ts';
+export type RenderArgsDeserialized = MultiVariantRenderArgsBase;

package/esm/MultiLinearVariantRenderer/MultiVariantRenderer.d.ts

@@ -1,63 +1,6 @@
 import FeatureRendererType from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
-import type { MultiRenderArgsDeserialized } from './types';
-import type { Feature } from '@jbrowse/core/util';
-export default class MultiVariantBaseRenderer extends FeatureRendererType {
+import type { MultiRenderArgsDeserialized } from './types.ts';
+export default class MultiVariantRenderer extends FeatureRendererType {
     supportsSVG: boolean;
-    render(renderProps: MultiRenderArgsDeserialized): Promise<{
-        features: Map<string, Feature>;
-        height: number;
-        width: number;
-        containsNoTransferables: boolean;
-        flatbush: ArrayBufferLike;
-        items: any[];
-        featureGenotypeMap: {
-            [k: string]: {
-                alt: any;
-                ref: any;
-                name: any;
-                description: any;
-                length: number;
-            };
-        };
-        canvasRecordedData: Record<string, unknown>;
-        reactElement?: React.ReactElement;
-        html?: string;
-    } | {
-        features: Map<string, Feature>;
-        height: number;
-        width: number;
-        containsNoTransferables: boolean;
-        flatbush: ArrayBufferLike;
-        items: any[];
-        featureGenotypeMap: {
-            [k: string]: {
-                alt: any;
-                ref: any;
-                name: any;
-                description: any;
-                length: number;
-            };
-        };
-        imageData: any;
-        reactElement?: React.ReactElement;
-        html?: string;
-    } | {
-        features: Map<string, Feature>;
-        height: number;
-        width: number;
-        containsNoTransferables: boolean;
-        flatbush: ArrayBufferLike;
-        items: any[];
-        featureGenotypeMap: {
-            [k: string]: {
-                alt: any;
-                ref: any;
-                name: any;
-                description: any;
-                length: number;
-            };
-        };
-        reactElement: React.ReactElement;
-        html?: string;
-    }>;
+    render(renderProps: MultiRenderArgsDeserialized): Promise<import("librpc-web-mod").RpcResult>;
 }

package/esm/MultiLinearVariantRenderer/MultiVariantRenderer.js

@@ -1,16 +1,15 @@
 import FeatureRendererType from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
 import { renderToAbstractCanvas } from '@jbrowse/core/util';
-export default class MultiVariantBaseRenderer extends FeatureRendererType {
-    constructor() {
-        super(...arguments);
-        this.supportsSVG = true;
-    }
+import { rpcResult } from '@jbrowse/core/util/librpc';
+import { collectTransferables } from '@jbrowse/core/util/offscreenCanvasPonyfill';
+export default class MultiVariantRenderer extends FeatureRendererType {
+    supportsSVG = true;
     async render(renderProps) {
         const features = await this.getFeatures(renderProps);
-        const { height, referenceDrawingMode, regions, bpPerPx } = renderProps;
+        const { height, referenceDrawingMode, regions, bpPerPx, scrollTop } = renderProps;
         const region = regions[0];
         const width = (region.end - region.start) / bpPerPx;
-        const { makeImageData } = await import('./makeImageData');
+        const { makeImageData } = await import("./makeImageData.js");
         const ret = await renderToAbstractCanvas(width, height, renderProps, ctx => {
             if (referenceDrawingMode === 'skip') {
                 ctx.fillStyle = '#ccc';
@@ -21,20 +20,12 @@ export default class MultiVariantBaseRenderer extends FeatureRendererType {
                 features,
             });
         });
-        const results = await super.render({
-            ...renderProps,
-            ...ret,
-            features,
-            height,
-            width,
-        });
-        return {
-            ...results,
+        const serialized = {
             ...ret,
-            features: new Map(),
             height,
             width,
-            containsNoTransferables: true,
+            origScrollTop: scrollTop,
         };
+        return rpcResult(serialized, collectTransferables(ret));
     }
 }

package/esm/MultiLinearVariantRenderer/components/MultiLinearVariantRendering.d.ts

@@ -1,7 +1,8 @@
-import type { Source } from '../../shared/types';
+import type { Source } from '../../shared/types.ts';
 import type { Feature } from '@jbrowse/core/util';
 import type { Region } from '@jbrowse/core/util/types';
 interface Item {
+    name: string;
     genotype: string;
     featureId: string;
     bpLen: number;
@@ -13,6 +14,9 @@ interface MinimizedVariantRecord {
     description: string;
     length: number;
 }
+interface MultiVariantDisplayModel {
+    setHoveredGenotype?: (genotype?: Record<string, unknown>) => void;
+}
 declare const MultiVariantRendering: (props: {
     regions: Region[];
     features: Map<string, Feature>;
@@ -20,14 +24,11 @@ declare const MultiVariantRendering: (props: {
     width: number;
     height: number;
     sources: Source[];
-    scrollTop: number;
+    origScrollTop: number;
     featureGenotypeMap: Record<string, MinimizedVariantRecord>;
     totalHeight: number;
     flatbush: any;
     items: Item[];
-    displayModel: any;
-    onMouseLeave?: (event: React.MouseEvent) => void;
-    onMouseMove?: (event: React.MouseEvent, arg?: Feature) => void;
-    onFeatureClick?: (event: React.MouseEvent, arg?: Feature) => void;
+    displayModel: MultiVariantDisplayModel;
 }) => import("react/jsx-runtime").JSX.Element;
 export default MultiVariantRendering;

package/esm/MultiLinearVariantRenderer/components/MultiLinearVariantRendering.js

@@ -1,29 +1,28 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useMemo, useRef } from 'react';
+import { useCallback, useMemo, useRef } from 'react';
 import { PrerenderedCanvas } from '@jbrowse/core/ui';
 import { getBpDisplayStr } from '@jbrowse/core/util';
 import Flatbush from '@jbrowse/core/util/flatbush';
 import { observer } from 'mobx-react';
-import { minElt } from './util';
-import { makeSimpleAltString } from '../../VcfFeature/util';
-const MultiVariantRendering = observer(function (props) {
-    const { flatbush, items, displayModel, featureGenotypeMap, totalHeight, scrollTop, } = props;
+import { minElt } from "./util.js";
+import { makeSimpleAltString } from "../../VcfFeature/util.js";
+const MultiVariantRendering = observer(function MultiVariantRendering(props) {
+    const { flatbush, items, displayModel, featureGenotypeMap, totalHeight, origScrollTop, } = props;
     const ref = useRef(null);
+    const lastHoveredRef = useRef(undefined);
     const flatbush2 = useMemo(() => Flatbush.from(flatbush), [flatbush]);
-    function getFeatureUnderMouse(eventClientX, eventClientY) {
-        var _a;
-        let offsetX = 0;
-        let offsetY = 0;
+    const getFeatureUnderMouse = useCallback((eventClientX, eventClientY) => {
         if (!ref.current) {
             return;
         }
         const rect = ref.current.getBoundingClientRect();
-        offsetX = eventClientX - rect.left;
-        offsetY = eventClientY - rect.top - ((displayModel === null || displayModel === void 0 ? void 0 : displayModel.scrollTop) || 0);
-        const x = flatbush2.search(offsetX, offsetY, offsetX + 1, offsetY + 1);
+        const offsetX = eventClientX - rect.left;
+        const offsetY = eventClientY - rect.top;
+        const canvasOffsetY = offsetY - origScrollTop;
+        const x = flatbush2.search(offsetX, canvasOffsetY, offsetX + 1, canvasOffsetY + 1);
         if (x.length) {
-            const res = minElt(x, idx => { var _a, _b; return (_b = (_a = items[idx]) === null || _a === void 0 ? void 0 : _a.bpLen) !== null && _b !== void 0 ? _b : 0; });
-            const { bpLen, genotype, featureId, ...rest } = (_a = items[res]) !== null && _a !== void 0 ? _a : {};
+            const res = minElt(x, idx => items[idx]?.bpLen ?? 0);
+            const { bpLen, genotype, featureId, ...rest } = items[res] ?? {};
             const ret = featureId !== undefined ? featureGenotypeMap[featureId] : undefined;
             if (ret && genotype) {
                 const { ref, alt, name, description, length } = ret;
@@ -39,24 +38,29 @@ const MultiVariantRendering = observer(function (props) {
             }
         }
         return undefined;
-    }
-    return (_jsx("div", { ref: ref, onMouseMove: e => {
-            var _a;
-            return (_a = displayModel.setHoveredGenotype) === null || _a === void 0 ? void 0 : _a.call(displayModel, getFeatureUnderMouse(e.clientX, e.clientY));
-        }, onMouseLeave: () => {
-            var _a;
-            (_a = displayModel.setHoveredGenotype) === null || _a === void 0 ? void 0 : _a.call(displayModel, undefined);
-        }, onMouseOut: () => {
-            var _a;
-            (_a = displayModel.setHoveredGenotype) === null || _a === void 0 ? void 0 : _a.call(displayModel, undefined);
-        }, style: {
+    }, [flatbush2, items, featureGenotypeMap, origScrollTop]);
+    const handleMouseMove = useCallback((e) => {
+        const result = getFeatureUnderMouse(e.clientX, e.clientY);
+        const key = result ? `${result.name}:${result.genotype}` : undefined;
+        if (key !== lastHoveredRef.current) {
+            lastHoveredRef.current = key;
+            displayModel.setHoveredGenotype?.(result);
+        }
+    }, [getFeatureUnderMouse, displayModel]);
+    const handleMouseLeave = useCallback(() => {
+        if (lastHoveredRef.current !== undefined) {
+            lastHoveredRef.current = undefined;
+            displayModel.setHoveredGenotype?.(undefined);
+        }
+    }, [displayModel]);
+    return (_jsx("div", { ref: ref, onMouseMove: handleMouseMove, onMouseLeave: handleMouseLeave, onMouseOut: handleMouseLeave, style: {
             overflow: 'visible',
             position: 'relative',
             height: totalHeight,
         }, children: _jsx(PrerenderedCanvas, { ...props, style: {
                 position: 'absolute',
                 left: 0,
-                top: scrollTop,
+                top: origScrollTop,
             } }) }));
 });
 export default MultiVariantRendering;

package/esm/MultiLinearVariantRenderer/configSchema.d.ts

@@ -1,2 +1,2 @@
-declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+declare const configSchema: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default configSchema;

package/esm/MultiLinearVariantRenderer/index.js

@@ -1,11 +1,11 @@
-import MultiVariantRenderer from './MultiVariantRenderer';
-import ReactComponent from './components/MultiLinearVariantRendering';
-import configSchema from './configSchema';
+import { lazy } from 'react';
+import MultiVariantRenderer from "./MultiVariantRenderer.js";
+import configSchema from "./configSchema.js";
 export default function MultiVariantRendererF(pluginManager) {
     pluginManager.addRendererType(() => {
         return new MultiVariantRenderer({
             name: 'MultiVariantRenderer',
-            ReactComponent,
+            ReactComponent: lazy(() => import("./components/MultiLinearVariantRendering.js")),
             configSchema,
             pluginManager,
         });

package/esm/MultiLinearVariantRenderer/makeImageData.d.ts

@@ -1,14 +1,17 @@
-import type { MultiRenderArgsDeserialized } from './types';
+import type { MultiRenderArgsDeserialized } from './types.ts';
 export declare function makeImageData(ctx: CanvasRenderingContext2D, props: MultiRenderArgsDeserialized): Promise<{
     flatbush: ArrayBufferLike;
-    items: any[];
-    featureGenotypeMap: {
-        [k: string]: {
-            alt: any;
-            ref: any;
-            name: any;
-            description: any;
-            length: number;
-        };
-    };
+    items: {
+        name: string;
+        genotype: string;
+        featureId: string;
+        bpLen: number;
+    }[];
+    featureGenotypeMap: Record<string, {
+        alt: unknown;
+        ref: unknown;
+        name: unknown;
+        description: unknown;
+        length: number;
+    }>;
 }>;