@jbrowse/plugin-alignments 3.7.0 → 4.0.0

package/esm/RenderLinearReadArcsDisplayRPC/executeRenderLinearReadArcsDisplay.d.ts

@@ -0,0 +1,6 @@
+import type { RenderLinearReadArcsDisplayArgs } from './RenderLinearReadArcsDisplay.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+export declare function executeRenderLinearReadArcsDisplay({ pluginManager, args, }: {
+    pluginManager: PluginManager;
+    args: RenderLinearReadArcsDisplayArgs;
+}): Promise<import("librpc-web-mod").RpcResult>;

package/esm/RenderLinearReadArcsDisplayRPC/executeRenderLinearReadArcsDisplay.js

@@ -0,0 +1,105 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import { collectTransferables, dedupe, groupBy, max, min, renderToAbstractCanvas, updateStatus, } from '@jbrowse/core/util';
+import { bpToPx } from '@jbrowse/core/util/Base1DUtils';
+import Base1DView from '@jbrowse/core/util/Base1DViewModel';
+import { rpcResult } from '@jbrowse/core/util/librpc';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
+import { firstValueFrom } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+import { drawFeatsRPC } from "./drawFeatsRPC.js";
+import { getInsertSizeStats } from "../shared/insertSizeStats.js";
+export async function executeRenderLinearReadArcsDisplay({ pluginManager, args, }) {
+    const { sessionId, view: viewSnapshot, adapterConfig, sequenceAdapter, colorBy, drawInter, drawLongRange, lineWidth, jitter, height, highResolutionScaling, exportSVG, statusCallback = () => { }, stopToken, } = args;
+    const view = Base1DView.create(viewSnapshot);
+    if (viewSnapshot.width) {
+        view.setVolatileWidth(viewSnapshot.width);
+    }
+    const { offsetPx } = view;
+    const width = view.staticBlocks.totalWidthPx;
+    const regions = view.staticBlocks.contentBlocks;
+    const snap = getSnapshot(view);
+    const viewSnap = {
+        ...snap,
+        width: view.width,
+        staticBlocks: view.staticBlocks,
+        bpToPx(arg) {
+            const res = bpToPx({
+                self: this,
+                refName: arg.refName,
+                coord: arg.coord,
+            });
+            return res !== undefined
+                ? { offsetPx: res.offsetPx, index: res.index }
+                : undefined;
+        },
+    };
+    const dataAdapter = (await getAdapter(pluginManager, sessionId, adapterConfig)).dataAdapter;
+    if (sequenceAdapter && !dataAdapter.sequenceAdapterConfig) {
+        dataAdapter.setSequenceAdapterConfig(sequenceAdapter);
+    }
+    const featuresArray = await updateStatus('Fetching alignments', statusCallback, () => firstValueFrom(dataAdapter.getFeaturesInMultipleRegions(regions, args).pipe(toArray())));
+    checkStopToken(stopToken);
+    const { chains, stats } = await updateStatus('Processing alignments', statusCallback, async () => {
+        const deduped = dedupe(featuresArray, f => f.id());
+        const filtered = deduped.filter(f => {
+            const flags = f.get('flags');
+            if (!(flags & 2)) {
+                return false;
+            }
+            if (flags & 256 || flags & 2048) {
+                return false;
+            }
+            return true;
+        });
+        let statsResult;
+        if (filtered.length) {
+            const validTlenFeatures = filtered.filter(f => {
+                const tlen = f.get('template_length');
+                return tlen !== 0 && !Number.isNaN(tlen);
+            });
+            if (validTlenFeatures.length > 0) {
+                const tlens = validTlenFeatures.map(f => Math.abs(f.get('template_length')));
+                const insertSizeStats = getInsertSizeStats(tlens);
+                statsResult = {
+                    ...insertSizeStats,
+                    max: max(tlens),
+                    min: min(tlens),
+                };
+            }
+        }
+        const chainsResult = Object.values(groupBy(deduped, f => f.get('name')));
+        return {
+            chains: chainsResult,
+            stats: statsResult,
+        };
+    });
+    const chainData = {
+        chains,
+        stats,
+    };
+    checkStopToken(stopToken);
+    const renderOpts = {
+        highResolutionScaling,
+        exportSVG,
+    };
+    const result = await updateStatus('Rendering arcs', statusCallback, () => renderToAbstractCanvas(width, height, renderOpts, ctx => {
+        drawFeatsRPC({
+            ctx,
+            width,
+            height,
+            chainData,
+            colorBy,
+            drawInter,
+            drawLongRange,
+            lineWidth,
+            jitter,
+            view: viewSnap,
+            offsetPx,
+            stopToken,
+        });
+        return undefined;
+    }));
+    const serialized = { ...result, offsetPx };
+    return rpcResult(serialized, collectTransferables(result));
+}

package/{dist/GuessAlignmentsTypes → esm/RenderLinearReadArcsDisplayRPC}/index.d.ts

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

package/esm/RenderLinearReadArcsDisplayRPC/index.js

@@ -0,0 +1,4 @@
+import RenderLinearReadArcsDisplay from "./RenderLinearReadArcsDisplay.js";
+export default function LinearReadArcsDisplayRPCMethodsF(pm) {
+    pm.addRpcMethod(() => new RenderLinearReadArcsDisplay(pm));
+}

package/esm/RenderLinearReadCloudDisplayRPC/RenderLinearReadCloudDisplay.d.ts

@@ -0,0 +1,43 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+import type { ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Base1DViewModel } from '@jbrowse/core/util/Base1DViewModel';
+import type { ThemeOptions } from '@mui/material';
+export interface RenderLinearReadCloudDisplayArgs {
+    sessionId: string;
+    view: Base1DViewModel;
+    adapterConfig: AnyConfigurationModel;
+    sequenceAdapter?: Record<string, unknown>;
+    config: AnyConfigurationModel;
+    theme: ThemeOptions;
+    filterBy: Record<string, unknown>;
+    featureHeight: number;
+    noSpacing: boolean;
+    drawCloud: boolean;
+    colorBy: ColorBy;
+    drawSingletons: boolean;
+    drawProperPairs: boolean;
+    flipStrandLongReadChains: boolean;
+    trackMaxHeight?: number;
+    cloudModeHeight?: number;
+    cloudDomain?: [number, number];
+    highResolutionScaling?: number;
+    exportSVG?: {
+        rasterizeLayers?: boolean;
+        scale?: number;
+    };
+    statusCallback?: (status: string) => void;
+    stopToken?: string;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    hideSmallIndels?: boolean;
+    hideMismatches?: boolean;
+    hideLargeIndels?: boolean;
+    showOutline?: boolean;
+}
+export default class RenderLinearReadCloudDisplay extends RpcMethodType {
+    name: string;
+    renameRegionsIfNeeded(args: RenderLinearReadCloudDisplayArgs): Promise<RenderLinearReadCloudDisplayArgs>;
+    deserializeArguments(args: any, _rpcDriver: string): any;
+    serializeArguments(args: Record<string, unknown>, rpcDriver: string): Promise<Record<string, unknown>>;
+    execute(args: Record<string, unknown>, rpcDriver: string): Promise<import("librpc-web-mod").RpcResult>;
+}

package/esm/RenderLinearReadCloudDisplayRPC/RenderLinearReadCloudDisplay.js

@@ -0,0 +1,49 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+import { renameRegionsIfNeeded } from '@jbrowse/core/util';
+import configSchema from "../LinearReadCloudDisplay/configSchema.js";
+export default class RenderLinearReadCloudDisplay extends RpcMethodType {
+    name = 'RenderLinearReadCloudDisplay';
+    async renameRegionsIfNeeded(args) {
+        const assemblyManager = this.pluginManager.rootModel?.session?.assemblyManager;
+        if (!assemblyManager) {
+            throw new Error('no assembly manager');
+        }
+        const { view, sessionId, adapterConfig } = args;
+        const { displayedRegions } = view;
+        if (!displayedRegions.length) {
+            return args;
+        }
+        const result = await renameRegionsIfNeeded(assemblyManager, {
+            sessionId,
+            adapterConfig,
+            regions: displayedRegions,
+        });
+        return {
+            ...args,
+            view: {
+                ...view,
+                displayedRegions: result.regions,
+            },
+        };
+    }
+    deserializeArguments(args, _rpcDriver) {
+        return {
+            ...args,
+            config: configSchema(this.pluginManager).create(args.config, {
+                pluginManager: this.pluginManager,
+            }),
+        };
+    }
+    async serializeArguments(args, rpcDriver) {
+        const renamed = await this.renameRegionsIfNeeded(args);
+        return super.serializeArguments(renamed, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { executeRenderLinearReadCloudDisplay } = await import("./executeRenderLinearReadCloudDisplay.js");
+        return executeRenderLinearReadCloudDisplay({
+            pluginManager: this.pluginManager,
+            args: deserializedArgs,
+        });
+    }
+}

package/esm/RenderLinearReadCloudDisplayRPC/drawChainsUtil.d.ts

@@ -0,0 +1,82 @@
+import type { FlatbushItem, LayoutFeature } from '../PileupRenderer/types.ts';
+import type { ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Feature } from '@jbrowse/core/util';
+import type { BaseBlock } from '@jbrowse/core/util/blockTypes';
+import type { ThemeOptions } from '@mui/material';
+export declare function getConnectingLineColor(configTheme: ThemeOptions): "#aaa8" | "#6665";
+export declare const MIN_FEATURE_WIDTH_PX = 3;
+export declare const CLIP_RECT_HEIGHT = 100000;
+export declare function renderFeatureShape({ ctx, xPos, yPos, width, height, strand, fillStyle, strokeStyle, renderChevrons, showOutline, }: {
+    ctx: CanvasRenderingContext2D;
+    xPos: number;
+    yPos: number;
+    width: number;
+    height: number;
+    strand: number;
+    fillStyle: string;
+    strokeStyle: string;
+    renderChevrons: boolean;
+    showOutline?: boolean;
+}): void;
+export interface MismatchData {
+    coords: number[];
+    items: FlatbushItem[];
+}
+export declare function getStrandColorKey(strand: number): "color_rev_strand" | "color_fwd_strand";
+export declare function chainIsPairedEnd(chain: Feature[]): boolean;
+export declare function collectNonSupplementary(chain: Feature[]): Feature[];
+export interface MismatchRenderingConfig {
+    mismatchAlpha: boolean | undefined;
+    minSubfeatureWidth: number;
+    largeInsertionIndicatorScale: number;
+    hideSmallIndels: boolean;
+    hideMismatches: boolean;
+    hideLargeIndels: boolean;
+    colorMap: Record<string, string>;
+    colorContrastMap: Record<string, string>;
+    charWidth: number;
+    charHeight: number;
+    drawSNPsMuted: boolean;
+    drawIndels: boolean;
+}
+export declare function getMismatchRenderingConfig(ctx: CanvasRenderingContext2D, config: AnyConfigurationModel, configTheme: ThemeOptions, colorBy: ColorBy, overrides?: {
+    hideSmallIndels?: boolean;
+    hideMismatches?: boolean;
+    hideLargeIndels?: boolean;
+}): MismatchRenderingConfig;
+export declare function featureOverlapsRegion(featRefName: string, featStart: number, featEnd: number, region: BaseBlock): boolean;
+export declare function calculateFeaturePositionPx(featStart: number, featEnd: number, regionStart: number, regionEnd: number, bpPerPx: number): {
+    xPos: number;
+    width: number;
+};
+export declare function getChainBoundsOnRef(chain: Feature[], refName: string): {
+    minStart: number;
+    maxEnd: number;
+} | undefined;
+export declare function renderFeatureModifications({ ctx, feat, layoutFeat, region, regionStartPx, bpPerPx, colorBy, visibleModifications, allCoords, allItems, }: {
+    ctx: CanvasRenderingContext2D;
+    feat: Feature;
+    layoutFeat: LayoutFeature;
+    region: BaseBlock;
+    regionStartPx: number;
+    bpPerPx: number;
+    colorBy: ColorBy;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    allCoords: number[];
+    allItems: FlatbushItem[];
+}): void;
+export declare function renderFeatureMismatchesAndModifications({ ctx, feat, layoutFeat, region, regionStartPx, bpPerPx, canvasWidth, colorBy, visibleModifications, mismatchConfig, allCoords, allItems, }: {
+    ctx: CanvasRenderingContext2D;
+    feat: Feature;
+    layoutFeat: LayoutFeature;
+    region: BaseBlock;
+    regionStartPx: number;
+    bpPerPx: number;
+    canvasWidth: number;
+    colorBy: ColorBy;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    mismatchConfig: MismatchRenderingConfig;
+    allCoords: number[];
+    allItems: FlatbushItem[];
+}): void;

package/esm/RenderLinearReadCloudDisplayRPC/drawChainsUtil.js

@@ -0,0 +1,164 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+import { createJBrowseTheme } from '@jbrowse/core/ui';
+import { getCigarOps } from "../PileupRenderer/renderers/cigarUtil.js";
+import { renderMismatchesCallback } from "../PileupRenderer/renderers/renderMismatchesCallback.js";
+import { renderModifications } from "../PileupRenderer/renderers/renderModifications.js";
+import { strokeRectCtx } from "../shared/canvasUtils.js";
+import { drawChevron } from "../shared/chevron.js";
+import { SAM_FLAG_PAIRED, SAM_FLAG_SUPPLEMENTARY } from "../shared/samFlags.js";
+import { CHEVRON_WIDTH, getCharWidthHeight, getColorBaseMap, getContrastBaseMap, setAlignmentFont, shouldDrawIndels, shouldDrawSNPsMuted, } from "../shared/util.js";
+export function getConnectingLineColor(configTheme) {
+    const theme = createJBrowseTheme(configTheme);
+    return theme.palette.mode === 'dark' ? '#aaa8' : '#6665';
+}
+export const MIN_FEATURE_WIDTH_PX = 3;
+export const CLIP_RECT_HEIGHT = 100000;
+export function renderFeatureShape({ ctx, xPos, yPos, width, height, strand, fillStyle, strokeStyle, renderChevrons, showOutline = true, }) {
+    if (renderChevrons) {
+        drawChevron(ctx, xPos, yPos, width, height, strand, fillStyle, CHEVRON_WIDTH, showOutline ? strokeStyle : undefined);
+    }
+    else {
+        let drawX = xPos;
+        let drawY = yPos;
+        let drawWidth = width;
+        if (drawWidth < 0) {
+            drawX += drawWidth;
+            drawWidth = -drawWidth;
+        }
+        if (height < 0) {
+            drawY += height;
+        }
+        ctx.fillStyle = fillStyle;
+        ctx.fillRect(drawX, drawY, drawWidth, height);
+        if (showOutline) {
+            strokeRectCtx(drawX, drawY, drawWidth, height, ctx, strokeStyle);
+        }
+    }
+}
+export function getStrandColorKey(strand) {
+    return strand === -1 ? 'color_rev_strand' : 'color_fwd_strand';
+}
+export function chainIsPairedEnd(chain) {
+    for (const element of chain) {
+        if (element.get('flags') & SAM_FLAG_PAIRED) {
+            return true;
+        }
+    }
+    return false;
+}
+export function collectNonSupplementary(chain) {
+    const result = [];
+    for (const element of chain) {
+        if (!(element.get('flags') & SAM_FLAG_SUPPLEMENTARY)) {
+            result.push(element);
+        }
+    }
+    return result;
+}
+export function getMismatchRenderingConfig(ctx, config, configTheme, colorBy, overrides) {
+    const mismatchAlpha = readConfObject(config, 'mismatchAlpha');
+    const minSubfeatureWidth = readConfObject(config, 'minSubfeatureWidth') ?? 1;
+    const largeInsertionIndicatorScale = readConfObject(config, 'largeInsertionIndicatorScale');
+    const hideSmallIndels = overrides?.hideSmallIndels ??
+        readConfObject(config, 'hideSmallIndels');
+    const hideMismatches = overrides?.hideMismatches ??
+        readConfObject(config, 'hideMismatches');
+    const hideLargeIndels = overrides?.hideLargeIndels ??
+        readConfObject(config, 'hideLargeIndels') ??
+        false;
+    const theme = createJBrowseTheme(configTheme);
+    const colorMap = getColorBaseMap(theme);
+    const colorContrastMap = getContrastBaseMap(theme);
+    setAlignmentFont(ctx);
+    const { charWidth, charHeight } = getCharWidthHeight();
+    const drawSNPsMuted = shouldDrawSNPsMuted(colorBy.type);
+    const drawIndels = shouldDrawIndels();
+    return {
+        mismatchAlpha,
+        minSubfeatureWidth,
+        largeInsertionIndicatorScale,
+        hideSmallIndels,
+        hideMismatches,
+        hideLargeIndels,
+        colorMap,
+        colorContrastMap,
+        charWidth,
+        charHeight,
+        drawSNPsMuted,
+        drawIndels,
+    };
+}
+export function featureOverlapsRegion(featRefName, featStart, featEnd, region) {
+    return (featRefName === region.refName &&
+        featStart < region.end &&
+        featEnd > region.start);
+}
+export function calculateFeaturePositionPx(featStart, featEnd, regionStart, regionEnd, bpPerPx) {
+    const clippedStart = Math.max(featStart, regionStart);
+    const clippedEnd = Math.min(featEnd, regionEnd);
+    const xPos = (clippedStart - regionStart) / bpPerPx;
+    const width = Math.max((clippedEnd - clippedStart) / bpPerPx, MIN_FEATURE_WIDTH_PX);
+    return { xPos, width };
+}
+export function getChainBoundsOnRef(chain, refName) {
+    let minStart = Number.MAX_VALUE;
+    let maxEnd = Number.MIN_VALUE;
+    for (const element of chain) {
+        const f = element;
+        if (f.get('refName') === refName) {
+            minStart = Math.min(minStart, f.get('start'));
+            maxEnd = Math.max(maxEnd, f.get('end'));
+        }
+    }
+    return minStart !== Number.MAX_VALUE ? { minStart, maxEnd } : undefined;
+}
+function aggregateMismatchData(ret, regionStartPx, allCoords, allItems) {
+    for (let i = 0; i < ret.coords.length; i += 4) {
+        allCoords.push(ret.coords[i] + regionStartPx, ret.coords[i + 1], ret.coords[i + 2] + regionStartPx, ret.coords[i + 3]);
+    }
+    for (const item of ret.items) {
+        allItems.push(item);
+    }
+}
+export function renderFeatureModifications({ ctx, feat, layoutFeat, region, regionStartPx, bpPerPx, colorBy, visibleModifications, allCoords, allItems, }) {
+    if (colorBy.type !== 'modifications' || !visibleModifications) {
+        return;
+    }
+    const cigarOps = getCigarOps(feat.get('NUMERIC_CIGAR') || feat.get('CIGAR'));
+    const modRet = renderModifications({
+        ctx,
+        feat: layoutFeat,
+        region,
+        bpPerPx,
+        renderArgs: {
+            colorBy,
+            visibleModifications,
+        },
+        cigarOps,
+    });
+    aggregateMismatchData(modRet, regionStartPx, allCoords, allItems);
+}
+export function renderFeatureMismatchesAndModifications({ ctx, feat, layoutFeat, region, regionStartPx, bpPerPx, canvasWidth, colorBy, visibleModifications, mismatchConfig, allCoords, allItems, }) {
+    const ret = renderMismatchesCallback({
+        ctx,
+        feat: layoutFeat,
+        checkRef: true,
+        bpPerPx,
+        regions: [region],
+        canvasWidth,
+        ...mismatchConfig,
+    });
+    aggregateMismatchData(ret, regionStartPx, allCoords, allItems);
+    renderFeatureModifications({
+        ctx,
+        feat,
+        layoutFeat,
+        region,
+        regionStartPx,
+        bpPerPx,
+        colorBy,
+        visibleModifications,
+        allCoords,
+        allItems,
+    });
+}

package/esm/RenderLinearReadCloudDisplayRPC/drawFeatsCloud.d.ts

@@ -0,0 +1,17 @@
+import type { ComputedChain } from './drawFeatsCommon.ts';
+export declare const CLOUD_HEIGHT_PADDING = 20;
+export interface CloudTicks {
+    ticks: {
+        value: number;
+        y: number;
+    }[];
+    height: number;
+    minDistance: number;
+    maxDistance: number;
+}
+export declare function createCloudScale(minDistance: number, maxDistance: number, height: number): import("d3-scale").ScaleLogarithmic<number, number, never>;
+export declare function calculateCloudTicks(domain: [number, number], height: number): CloudTicks;
+export declare function calculateCloudYOffsetsUtil(computedChains: ComputedChain[], height: number, cloudDomain?: [number, number]): {
+    chainYOffsets: Map<string, number>;
+    cloudMaxDistance: number;
+};

package/esm/RenderLinearReadCloudDisplayRPC/drawFeatsCloud.js

@@ -0,0 +1,53 @@
+import { scaleLog } from '@mui/x-charts-vendor/d3-scale';
+export const CLOUD_HEIGHT_PADDING = 20;
+const DEFAULT_MAX_DISTANCE = 1000;
+export function createCloudScale(minDistance, maxDistance, height) {
+    return scaleLog()
+        .base(2)
+        .domain([Math.max(1, minDistance), Math.max(2, maxDistance)])
+        .range([0, height - CLOUD_HEIGHT_PADDING])
+        .clamp(true);
+}
+export function calculateCloudTicks(domain, height) {
+    const [minDistance, maxDistance] = domain;
+    const scale = createCloudScale(minDistance, maxDistance, height);
+    const tickValues = scale.ticks(6);
+    const ticks = tickValues.map(value => ({
+        value,
+        y: scale(value),
+    }));
+    return { ticks, height, minDistance, maxDistance };
+}
+export function calculateCloudYOffsetsUtil(computedChains, height, cloudDomain) {
+    const chainYOffsets = new Map();
+    if (cloudDomain) {
+        const [, maxDistance] = cloudDomain;
+        const scale = createCloudScale(1, maxDistance, height);
+        for (const { id, distance } of computedChains) {
+            const top = distance > 0 ? scale(distance) : 0;
+            chainYOffsets.set(id, top);
+        }
+        return {
+            chainYOffsets,
+            cloudMaxDistance: maxDistance,
+        };
+    }
+    let maxDistance = Number.MIN_VALUE;
+    for (const { distance } of computedChains) {
+        if (distance > 0) {
+            maxDistance = Math.max(maxDistance, distance);
+        }
+    }
+    if (maxDistance === Number.MIN_VALUE) {
+        maxDistance = DEFAULT_MAX_DISTANCE;
+    }
+    const scale = createCloudScale(1, maxDistance, height);
+    for (const { id, distance } of computedChains) {
+        const top = distance > 0 ? scale(distance) : 0;
+        chainYOffsets.set(id, top);
+    }
+    return {
+        chainYOffsets,
+        cloudMaxDistance: maxDistance,
+    };
+}

package/esm/RenderLinearReadCloudDisplayRPC/drawFeatsCommon.d.ts

@@ -0,0 +1,72 @@
+import type { LinearReadCloudDisplayModel } from '../LinearReadCloudDisplay/model.ts';
+import type { FlatbushItem } from '../PileupRenderer/types.ts';
+import type { FlatbushEntry } from '../shared/flatbushType.ts';
+import type { ChainData, ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Feature } from '@jbrowse/core/util';
+import type { BaseBlock } from '@jbrowse/core/util/blockTypes';
+import type { ThemeOptions } from '@mui/material';
+interface ViewForDrawing {
+    bpPerPx: number;
+    offsetPx: number;
+    bpToPx: (arg: {
+        refName: string;
+        coord: number;
+    }) => {
+        offsetPx: number;
+    } | undefined;
+}
+export interface ComputedChain {
+    distance: number;
+    minX: number;
+    maxX: number;
+    chain: Feature[];
+    id: string;
+    isPairedEnd: boolean;
+    nonSupplementary: Feature[];
+}
+export declare function filterChains(chains: Feature[][], drawSingletons: boolean, drawProperPairs: boolean, type: string, chainData: ChainData): Feature[][];
+export declare function computeChainBounds(chains: Feature[][], view: ViewForDrawing): ComputedChain[];
+export declare function sortComputedChains(computedChains: ComputedChain[]): void;
+export declare function buildFlatbushIndex(featuresForFlatbush: FlatbushEntry[], self: LinearReadCloudDisplayModel): void;
+export declare function addChainMouseoverRects(computedChains: ComputedChain[], chainYOffsets: Map<string, number>, featureHeight: number, view: ViewForDrawing, featuresForFlatbush: FlatbushEntry[]): void;
+export interface DrawFeatsParams {
+    chainData: ChainData;
+    featureHeight: number;
+    colorBy: ColorBy;
+    drawSingletons: boolean;
+    drawProperPairs: boolean;
+    flipStrandLongReadChains: boolean;
+    noSpacing?: boolean;
+    trackMaxHeight?: number;
+    config: AnyConfigurationModel;
+    theme: ThemeOptions;
+    regions: BaseBlock[];
+    bpPerPx: number;
+    canvasWidth: number;
+    stopToken?: string;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    hideSmallIndels?: boolean;
+    hideMismatches?: boolean;
+    hideLargeIndels?: boolean;
+    showOutline?: boolean;
+}
+export interface DrawFeatsResult {
+    featuresForFlatbush: FlatbushEntry[];
+    layoutHeight?: number;
+    cloudMaxDistance?: number;
+    mismatchFlatbush: ArrayBufferLike;
+    mismatchItems: FlatbushItem[];
+}
+export declare function drawFeatsCore({ ctx, params, view, calculateYOffsets, }: {
+    ctx: CanvasRenderingContext2D;
+    params: DrawFeatsParams;
+    view: any;
+    calculateYOffsets: (computedChains: ComputedChain[]) => {
+        chainYOffsets: Map<string, number>;
+        layoutHeight?: number;
+        cloudMaxDistance?: number;
+    };
+}): DrawFeatsResult;
+export declare function buildMismatchFlatbushIndex(mismatchFlatbushData: ArrayBuffer, mismatchItems: FlatbushItem[], self: LinearReadCloudDisplayModel): void;
+export {};