@jbrowse/plugin-alignments 3.6.5 → 4.0.0

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 {};

package/esm/RenderLinearReadCloudDisplayRPC/drawFeatsCommon.js

@@ -0,0 +1,277 @@
+import Flatbush from '@jbrowse/core/util/flatbush';
+import { CLIP_RECT_HEIGHT, chainIsPairedEnd, collectNonSupplementary, } from "./drawChainsUtil.js";
+import { drawLongReadChains } from "./drawLongReadChains.js";
+import { drawPairChains } from "./drawPairChains.js";
+import { PairType, getPairedType } from "../shared/color.js";
+import { SAM_FLAG_PAIRED, SAM_FLAG_SUPPLEMENTARY } from "../shared/samFlags.js";
+import { shouldRenderChevrons } from "../shared/util.js";
+const TLEN_CONSISTENCY_FACTOR = 100;
+export function filterChains(chains, drawSingletons, drawProperPairs, type, chainData) {
+    const filtered = [];
+    for (const chain of chains) {
+        if (!drawSingletons && chain.length === 1) {
+            continue;
+        }
+        const isPairedEnd = chainIsPairedEnd(chain);
+        if (!drawProperPairs && isPairedEnd) {
+            const nonSupplementary = collectNonSupplementary(chain);
+            if (nonSupplementary.length === 2) {
+                const v0 = nonSupplementary[0];
+                const pairType = getPairedType({
+                    type,
+                    f: {
+                        refName: v0.get('refName'),
+                        next_ref: v0.get('next_ref'),
+                        pair_orientation: v0.get('pair_orientation'),
+                        tlen: v0.get('template_length'),
+                        flags: v0.get('flags'),
+                    },
+                    stats: chainData.stats,
+                });
+                if (pairType === PairType.PROPER_PAIR) {
+                    continue;
+                }
+            }
+        }
+        filtered.push(chain);
+    }
+    return filtered;
+}
+export function computeChainBounds(chains, view) {
+    const computedChains = [];
+    const { bpPerPx } = view;
+    for (const chain of chains) {
+        let minX = Number.MAX_VALUE;
+        let maxX = Number.MIN_VALUE;
+        let chainId = '';
+        let tlenDistance = 0;
+        let isPairedEnd = false;
+        const nonSupplementary = [];
+        const chainLength = chain.length;
+        for (let j = 0; j < chainLength; j++) {
+            const elt = chain[j];
+            const start = elt.get('start');
+            const end = elt.get('end');
+            const flags = elt.get('flags');
+            if (flags & SAM_FLAG_PAIRED) {
+                isPairedEnd = true;
+            }
+            if (!(flags & SAM_FLAG_SUPPLEMENTARY)) {
+                nonSupplementary.push(elt);
+            }
+            const rs = view.bpToPx({
+                refName: elt.get('refName'),
+                coord: start,
+            })?.offsetPx;
+            if (rs !== undefined) {
+                const re = rs + (end - start) / bpPerPx;
+                minX = Math.min(minX, rs);
+                maxX = Math.max(maxX, re);
+            }
+            if (!chainId) {
+                chainId = elt.id();
+            }
+            const tlen = elt.get('template_length');
+            if (tlenDistance === 0 && tlen) {
+                tlenDistance = Math.abs(tlen);
+            }
+        }
+        if (minX === Number.MAX_VALUE || maxX === Number.MIN_VALUE) {
+            continue;
+        }
+        let distance = 0;
+        if (tlenDistance > 0) {
+            const bpSpan = (maxX - minX) * bpPerPx;
+            if (tlenDistance <= bpSpan * TLEN_CONSISTENCY_FACTOR) {
+                distance = tlenDistance;
+            }
+        }
+        computedChains.push({
+            distance,
+            minX,
+            maxX,
+            chain,
+            id: chainId,
+            isPairedEnd,
+            nonSupplementary,
+        });
+    }
+    return computedChains;
+}
+export function sortComputedChains(computedChains) {
+    computedChains.sort((a, b) => {
+        const aIsSingleton = a.chain.length === 1 ? 1 : 0;
+        const bIsSingleton = b.chain.length === 1 ? 1 : 0;
+        if (bIsSingleton !== aIsSingleton) {
+            return bIsSingleton - aIsSingleton;
+        }
+        return a.distance - b.distance;
+    });
+}
+export function buildFlatbushIndex(featuresForFlatbush, self) {
+    const finalFlatbush = new Flatbush(Math.max(featuresForFlatbush.length, 1));
+    const length = featuresForFlatbush.length;
+    if (length) {
+        for (let i = 0; i < length; i++) {
+            const { x1, y1, x2, y2 } = featuresForFlatbush[i];
+            finalFlatbush.add(x1, y1, x2, y2);
+        }
+    }
+    else {
+        finalFlatbush.add(0, 0);
+    }
+    finalFlatbush.finish();
+    self.setFeatureLayout(finalFlatbush);
+    self.setFeaturesForFlatbush(featuresForFlatbush);
+}
+export function addChainMouseoverRects(computedChains, chainYOffsets, featureHeight, view, featuresForFlatbush) {
+    for (const computedChain of computedChains) {
+        const { id, chain, minX, maxX, nonSupplementary } = computedChain;
+        const chainY = chainYOffsets.get(id);
+        if (chainY === undefined) {
+            continue;
+        }
+        const chainMinXPx = minX - view.offsetPx;
+        const chainMaxXPx = maxX - view.offsetPx;
+        if (chain.length > 0) {
+            const primaryFeat = nonSupplementary[0] || chain[0];
+            const hasSupplementary = nonSupplementary.length < chain.length;
+            featuresForFlatbush.push({
+                x1: chainMinXPx,
+                y1: chainY,
+                x2: chainMaxXPx,
+                y2: chainY + featureHeight,
+                data: {
+                    name: primaryFeat.get('name'),
+                    refName: primaryFeat.get('refName'),
+                    start: primaryFeat.get('start'),
+                    end: primaryFeat.get('end'),
+                    strand: primaryFeat.get('strand'),
+                    flags: primaryFeat.get('flags'),
+                    id: primaryFeat.id(),
+                    tlen: primaryFeat.get('template_length') || 0,
+                    pair_orientation: primaryFeat.get('pair_orientation') || '',
+                    clipLengthAtStartOfRead: primaryFeat.get('clipLengthAtStartOfRead') || 0,
+                    next_ref: primaryFeat.get('next_ref'),
+                },
+                chainId: id,
+                chainMinX: chainMinXPx,
+                chainMaxX: chainMaxXPx,
+                hasSupplementary,
+                chain: chain.map(f => ({
+                    name: f.get('name'),
+                    refName: f.get('refName'),
+                    start: f.get('start'),
+                    end: f.get('end'),
+                    strand: f.get('strand'),
+                    flags: f.get('flags'),
+                    id: f.id(),
+                    tlen: f.get('template_length') || 0,
+                    pair_orientation: f.get('pair_orientation') || '',
+                    clipLengthAtStartOfRead: f.get('clipLengthAtStartOfRead') || 0,
+                    next_ref: f.get('next_ref'),
+                })),
+            });
+        }
+    }
+}
+export function drawFeatsCore({ ctx, params, view, calculateYOffsets, }) {
+    const { chainData, featureHeight, colorBy, drawSingletons, drawProperPairs, flipStrandLongReadChains, stopToken, } = params;
+    const type = colorBy.type || 'insertSizeAndOrientation';
+    const { chains } = chainData;
+    const filteredChains = filterChains(chains, drawSingletons, drawProperPairs, type, chainData);
+    const computedChains = computeChainBounds(filteredChains, view);
+    sortComputedChains(computedChains);
+    const { chainYOffsets, layoutHeight, cloudMaxDistance } = calculateYOffsets(computedChains);
+    const featuresForFlatbush = [];
+    const renderChevrons = shouldRenderChevrons(view.bpPerPx, featureHeight);
+    const viewOffsetPx = view.offsetPx;
+    const mismatchCoords = [];
+    const mismatchItems = [];
+    for (const region of params.regions) {
+        ctx.save();
+        const regionStartPx = region.offsetPx - viewOffsetPx;
+        ctx.beginPath();
+        ctx.rect(regionStartPx, 0, region.widthPx, CLIP_RECT_HEIGHT);
+        ctx.clip();
+        ctx.translate(regionStartPx, 0);
+        const pairMismatches = drawPairChains({
+            ctx,
+            type,
+            chainData,
+            chainYOffsets,
+            renderChevrons,
+            featureHeight,
+            computedChains,
+            config: params.config,
+            theme: params.theme,
+            region,
+            regionStartPx,
+            bpPerPx: params.bpPerPx,
+            colorBy: params.colorBy,
+            visibleModifications: params.visibleModifications,
+            stopToken,
+            hideSmallIndels: params.hideSmallIndels,
+            hideMismatches: params.hideMismatches,
+            hideLargeIndels: params.hideLargeIndels,
+            showOutline: params.showOutline,
+        });
+        const longReadMismatches = drawLongReadChains({
+            ctx,
+            chainData,
+            chainYOffsets,
+            renderChevrons,
+            featureHeight,
+            computedChains,
+            flipStrandLongReadChains,
+            config: params.config,
+            theme: params.theme,
+            region,
+            regionStartPx,
+            bpPerPx: params.bpPerPx,
+            colorBy: params.colorBy,
+            visibleModifications: params.visibleModifications,
+            stopToken,
+            hideSmallIndels: params.hideSmallIndels,
+            hideMismatches: params.hideMismatches,
+            hideLargeIndels: params.hideLargeIndels,
+            showOutline: params.showOutline,
+        });
+        for (const coord of pairMismatches.coords) {
+            mismatchCoords.push(coord);
+        }
+        for (const coord of longReadMismatches.coords) {
+            mismatchCoords.push(coord);
+        }
+        for (const item of pairMismatches.items) {
+            mismatchItems.push(item);
+        }
+        for (const item of longReadMismatches.items) {
+            mismatchItems.push(item);
+        }
+        ctx.restore();
+    }
+    addChainMouseoverRects(computedChains, chainYOffsets, featureHeight, view, featuresForFlatbush);
+    const mismatchFlatbush = new Flatbush(Math.max(mismatchItems.length, 1));
+    if (mismatchCoords.length) {
+        for (let i = 0; i < mismatchCoords.length; i += 4) {
+            mismatchFlatbush.add(mismatchCoords[i], mismatchCoords[i + 1], mismatchCoords[i + 2], mismatchCoords[i + 3]);
+        }
+    }
+    else {
+        mismatchFlatbush.add(0, 0, 0, 0);
+    }
+    mismatchFlatbush.finish();
+    return {
+        featuresForFlatbush,
+        layoutHeight,
+        cloudMaxDistance,
+        mismatchFlatbush: mismatchFlatbush.data,
+        mismatchItems,
+    };
+}
+export function buildMismatchFlatbushIndex(mismatchFlatbushData, mismatchItems, self) {
+    const mismatchFlatbush = Flatbush.from(mismatchFlatbushData);
+    self.setMismatchLayout(mismatchFlatbush);
+    self.setMismatchItems(mismatchItems);
+}

package/esm/RenderLinearReadCloudDisplayRPC/drawFeatsStack.d.ts

@@ -0,0 +1,5 @@
+import type { ComputedChain } from './drawFeatsCommon.ts';
+export declare function calculateStackYOffsetsUtil(computedChains: ComputedChain[], featureHeight: number, noSpacing: boolean, maxHeight: number): {
+    chainYOffsets: Map<string, number>;
+    layoutHeight: number;
+};

package/esm/RenderLinearReadCloudDisplayRPC/drawFeatsStack.js

@@ -0,0 +1,16 @@
+import { PileupLayout } from '@jbrowse/core/util/layouts';
+export function calculateStackYOffsetsUtil(computedChains, featureHeight, noSpacing, maxHeight) {
+    const layout = new PileupLayout({
+        featureHeight,
+        spacing: noSpacing ? 0 : 2,
+        maxHeight,
+    });
+    const chainYOffsets = new Map();
+    for (const { id, minX, maxX } of computedChains) {
+        const topPx = layout.addRect(id, minX, maxX, featureHeight);
+        if (topPx !== null) {
+            chainYOffsets.set(id, topPx);
+        }
+    }
+    return { chainYOffsets, layoutHeight: layout.getTotalHeight() };
+}

package/esm/RenderLinearReadCloudDisplayRPC/drawLongReadChains.d.ts

@@ -0,0 +1,27 @@
+import type { MismatchData } from './drawChainsUtil.ts';
+import type { ComputedChain } from './drawFeatsCommon.ts';
+import type { ChainData, ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { BaseBlock } from '@jbrowse/core/util/blockTypes';
+import type { ThemeOptions } from '@mui/material';
+export declare function drawLongReadChains({ ctx, chainData, chainYOffsets, renderChevrons, featureHeight, computedChains, flipStrandLongReadChains, config, theme: configTheme, region, regionStartPx, bpPerPx, colorBy, visibleModifications, stopToken, hideSmallIndels, hideMismatches, hideLargeIndels, showOutline, }: {
+    ctx: CanvasRenderingContext2D;
+    chainData: ChainData;
+    chainYOffsets: Map<string, number>;
+    renderChevrons: boolean;
+    featureHeight: number;
+    computedChains: ComputedChain[];
+    flipStrandLongReadChains: boolean;
+    config: AnyConfigurationModel;
+    theme: ThemeOptions;
+    region: BaseBlock;
+    regionStartPx: number;
+    bpPerPx: number;
+    colorBy: ColorBy;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    stopToken?: string;
+    hideSmallIndels?: boolean;
+    hideMismatches?: boolean;
+    hideLargeIndels?: boolean;
+    showOutline?: boolean;
+}): MismatchData;