@jbrowse/plugin-alignments 3.7.0 → 4.0.1

package/esm/CramAdapter/readFeaturesToMismatches.js

@@ -1,103 +0,0 @@
-export function readFeaturesToMismatches(readFeatures = [], start, qual) {
-    const mismatches = new Array(readFeatures.length);
-    let j = 0;
-    let refPos = 0;
-    let sublen = 0;
-    let lastPos = start;
-    let insertedBases = '';
-    for (const ret of readFeatures) {
-        const { refPos: p, code, pos, data, sub, ref } = ret;
-        sublen = refPos - lastPos;
-        lastPos = refPos;
-        if (sublen && insertedBases.length > 0) {
-            mismatches[j++] = {
-                start: refPos,
-                type: 'insertion',
-                base: `${insertedBases.length}`,
-                insertedBases,
-                length: 0,
-            };
-            insertedBases = '';
-        }
-        refPos = p - 1 - start;
-        if (code === 'X') {
-            mismatches[j++] = {
-                start: refPos,
-                length: 1,
-                base: sub,
-                qual: qual === null || qual === void 0 ? void 0 : qual[pos - 1],
-                altbase: ref === null || ref === void 0 ? void 0 : ref.toUpperCase(),
-                type: 'mismatch',
-            };
-        }
-        else if (code === 'I') {
-            mismatches[j++] = {
-                start: refPos,
-                type: 'insertion',
-                base: `${data.length}`,
-                insertedBases: data,
-                length: 0,
-            };
-        }
-        else if (code === 'N') {
-            mismatches[j++] = {
-                type: 'skip',
-                length: data,
-                start: refPos,
-                base: 'N',
-            };
-        }
-        else if (code === 'S') {
-            const len = data.length;
-            mismatches[j++] = {
-                start: refPos,
-                type: 'softclip',
-                base: `S${len}`,
-                cliplen: len,
-                length: 1,
-            };
-        }
-        else if (code === 'P') {
-        }
-        else if (code === 'H') {
-            const len = data;
-            mismatches[j++] = {
-                start: refPos,
-                type: 'hardclip',
-                base: `H${len}`,
-                cliplen: len,
-                length: 1,
-            };
-        }
-        else if (code === 'D') {
-            mismatches[j++] = {
-                type: 'deletion',
-                length: data,
-                start: refPos,
-                base: '*',
-            };
-        }
-        else if (code === 'b') {
-        }
-        else if (code === 'q') {
-        }
-        else if (code === 'B') {
-        }
-        else if (code === 'i') {
-            insertedBases += data;
-        }
-        else if (code === 'Q') {
-        }
-    }
-    if (sublen && insertedBases.length > 0) {
-        mismatches[j++] = {
-            start: refPos,
-            type: 'insertion',
-            base: `${insertedBases.length}`,
-            insertedBases,
-            length: 0,
-        };
-        insertedBases = '';
-    }
-    return mismatches.slice(0, j);
-}

package/esm/LinearPileupDisplay/components/SetMaxHeightDialog.d.ts

@@ -1,8 +0,0 @@
-declare const SetMaxHeightDialog: (props: {
-    model: {
-        maxHeight?: number;
-        setMaxHeight: (arg?: number) => void;
-    };
-    handleClose: () => void;
-}) => import("react/jsx-runtime").JSX.Element;
-export default SetMaxHeightDialog;

package/esm/LinearPileupDisplay/components/SetMaxHeightDialog.js

@@ -1,26 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
-import { Dialog } from '@jbrowse/core/ui';
-import { Button, DialogActions, DialogContent, TextField, Typography, } from '@mui/material';
-import { observer } from 'mobx-react';
-import { makeStyles } from 'tss-react/mui';
-const useStyles = makeStyles()({
-    root: {
-        width: 500,
-    },
-});
-const SetMaxHeightDialog = observer(function (props) {
-    const { model, handleClose } = props;
-    const { classes } = useStyles();
-    const { maxHeight = '' } = model;
-    const [max, setMax] = useState(`${maxHeight}`);
-    return (_jsx(Dialog, { open: true, onClose: handleClose, title: "Set max height", children: _jsxs(DialogContent, { className: classes.root, children: [_jsx(Typography, { children: "Set max height for the track. For example, you can increase this if the layout says \"Max height reached\"" }), _jsx(TextField, { value: max, autoFocus: true, onChange: event => {
-                        setMax(event.target.value);
-                    }, placeholder: "Enter max height for layout" }), _jsxs(DialogActions, { children: [_jsx(Button, { variant: "contained", color: "primary", type: "submit", autoFocus: true, onClick: () => {
-                                model.setMaxHeight(max !== '' && !Number.isNaN(+max) ? +max : undefined);
-                                handleClose();
-                            }, children: "Submit" }), _jsx(Button, { variant: "contained", color: "secondary", onClick: () => {
-                                handleClose();
-                            }, children: "Cancel" })] })] }) }));
-});
-export default SetMaxHeightDialog;

package/esm/LinearReadArcsDisplay/drawFeats.d.ts

@@ -1,2 +0,0 @@
-import type { LinearReadArcsDisplayModel } from './model';
-export declare function drawFeats(self: LinearReadArcsDisplayModel, ctx: CanvasRenderingContext2D, width: number, height: number): void;

package/esm/LinearReadArcsDisplay/drawFeats.js

@@ -1,149 +0,0 @@
-import { getContainingView, getSession } from '@jbrowse/core/util';
-import { featurizeSA } from '../MismatchParser';
-import { getPairedInsertSizeAndOrientationColor, getPairedInsertSizeColor, getPairedOrientationColor, } from '../shared/color';
-import { hasPairedReads } from '../shared/util';
-function jitter(n) {
-    return Math.random() * 2 * n - n;
-}
-function drawLineAtOffset(ctx, offset, height, color) {
-    ctx.strokeStyle = color;
-    ctx.beginPath();
-    ctx.moveTo(offset, 0);
-    ctx.lineTo(offset, height);
-    ctx.stroke();
-}
-export function drawFeats(self, ctx, width, height) {
-    const { chainData, colorBy, drawInter, drawLongRange, lineWidthSetting, jitterVal, } = self;
-    if (!chainData) {
-        return;
-    }
-    const view = getContainingView(self);
-    const { assemblyManager } = getSession(self);
-    const { chains, stats } = chainData;
-    const hasPaired = hasPairedReads(chainData);
-    const asm = assemblyManager.get(view.assemblyNames[0]);
-    const type = (colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) || 'insertSizeAndOrientation';
-    if (!asm) {
-        return;
-    }
-    ctx.lineWidth = lineWidthSetting;
-    function draw(k1, k2, assembly, longRange) {
-        var _a, _b, _c;
-        const s1 = k1.strand;
-        const s2 = k2.strand;
-        const f1 = s1 === -1;
-        const f2 = s2 === -1;
-        const p1 = f1 ? k1.start : k1.end;
-        const p2 = hasPaired ? (f2 ? k2.start : k2.end) : f2 ? k2.end : k2.start;
-        const ra1 = assembly.getCanonicalRefName(k1.refName) || k1.refName;
-        const ra2 = assembly.getCanonicalRefName(k2.refName) || k2.refName;
-        const r1 = (_a = view.bpToPx({ refName: ra1, coord: p1 })) === null || _a === void 0 ? void 0 : _a.offsetPx;
-        const r2 = (_b = view.bpToPx({ refName: ra2, coord: p2 })) === null || _b === void 0 ? void 0 : _b.offsetPx;
-        if (r1 !== undefined && r2 !== undefined) {
-            const radius = (r2 - r1) / 2;
-            const absrad = Math.abs(radius);
-            const p = r1 - view.offsetPx;
-            const p2 = r2 - view.offsetPx;
-            const drawArcInsteadOfBezier = absrad > 10000;
-            if (longRange && drawArcInsteadOfBezier) {
-                ctx.moveTo(p, 0);
-                ctx.beginPath();
-            }
-            else {
-                ctx.beginPath();
-                ctx.moveTo(p, 0);
-            }
-            if (longRange && drawArcInsteadOfBezier) {
-                ctx.strokeStyle = 'red';
-            }
-            else {
-                if (hasPaired) {
-                    if (type === 'insertSizeAndOrientation') {
-                        ctx.strokeStyle = getPairedInsertSizeAndOrientationColor(k1, k2, stats)[0];
-                    }
-                    else if (type === 'orientation') {
-                        ctx.strokeStyle = getPairedOrientationColor(k1)[0];
-                    }
-                    else if (type === 'insertSize') {
-                        ctx.strokeStyle =
-                            ((_c = getPairedInsertSizeColor(k1, k2, stats)) === null || _c === void 0 ? void 0 : _c[0]) || 'grey';
-                    }
-                    else if (type === 'gradient') {
-                        ctx.strokeStyle = `hsl(${Math.log10(absrad) * 10},50%,50%)`;
-                    }
-                }
-                else {
-                    if (type === 'orientation' || type === 'insertSizeAndOrientation') {
-                        if (s1 === -1 && s2 === 1) {
-                            ctx.strokeStyle = 'navy';
-                        }
-                        else if (s1 === 1 && s2 === -1) {
-                            ctx.strokeStyle = 'green';
-                        }
-                        else {
-                            ctx.strokeStyle = 'grey';
-                        }
-                    }
-                    else if (type === 'gradient') {
-                        ctx.strokeStyle = `hsl(${Math.log10(absrad) * 10},50%,50%)`;
-                    }
-                }
-            }
-            const destX = p + radius * 2;
-            const destY = Math.min(height + jitter(jitterVal), absrad);
-            if (longRange) {
-                if (absrad > 100000) {
-                    drawLineAtOffset(ctx, p + jitter(jitterVal), height, 'red');
-                    drawLineAtOffset(ctx, p2 + jitter(jitterVal), height, 'red');
-                }
-                else if (drawArcInsteadOfBezier) {
-                    ctx.arc(p + radius + jitter(jitterVal), 0, absrad, 0, Math.PI);
-                    ctx.stroke();
-                }
-                else {
-                    ctx.bezierCurveTo(p + jitter(jitterVal), destY, destX, destY, destX + jitter(jitterVal), 0);
-                    ctx.stroke();
-                }
-            }
-            else {
-                ctx.bezierCurveTo(p + jitter(jitterVal), destY, destX, destY, destX + jitter(jitterVal), 0);
-                ctx.stroke();
-            }
-        }
-        else if (r1 && drawInter) {
-            drawLineAtOffset(ctx, r1 - view.offsetPx, height, 'purple');
-        }
-    }
-    for (const chain of chains) {
-        if (chain.length === 1 && drawLongRange) {
-            const f = chain[0];
-            if (hasPaired && !(f.flags & 8)) {
-                const mate = {
-                    refName: f.next_ref || '',
-                    start: f.next_pos || 0,
-                    end: f.next_pos || 0,
-                    strand: f.strand,
-                };
-                draw(f, mate, asm, true);
-            }
-            else {
-                const features = [f, ...featurizeSA(f.SA, f.id, f.strand, f.name)].sort((a, b) => a.clipPos - b.clipPos);
-                for (let i = 0; i < features.length - 1; i++) {
-                    const f = features[i];
-                    const v1 = features[i + 1];
-                    draw(f, v1, asm, true);
-                }
-            }
-        }
-        else {
-            const res = hasPaired
-                ? chain.filter(f => !(f.flags & 2048) && !(f.flags & 8))
-                : chain
-                    .sort((a, b) => a.clipPos - b.clipPos)
-                    .filter(f => !(f.flags & 256));
-            for (let i = 0; i < res.length - 1; i++) {
-                draw(res[i], res[i + 1], asm, false);
-            }
-        }
-    }
-}

package/esm/LinearReadArcsDisplay/util.d.ts

@@ -1,2 +0,0 @@
-import type { ChainData } from '../shared/fetchChains';
-export declare function hasPairedReads(features: ChainData): boolean;

package/esm/LinearReadArcsDisplay/util.js

@@ -1,8 +0,0 @@
-export function hasPairedReads(features) {
-    for (const f of features.chains.values()) {
-        if (f[0].flags & 1) {
-            return true;
-        }
-    }
-    return false;
-}

package/esm/LinearReadCloudDisplay/components/ReactComponent.d.ts

@@ -1,5 +0,0 @@
-import type { LinearReadCloudDisplayModel } from '../model';
-declare const LinearReadCloudReactComponent: ({ model, }: {
-    model: LinearReadCloudDisplayModel;
-}) => import("react/jsx-runtime").JSX.Element;
-export default LinearReadCloudReactComponent;

package/esm/LinearReadCloudDisplay/components/ReactComponent.js

@@ -1,100 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, 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 '../../shared/components/BaseDisplayComponent';
-const Cloud = observer(function ({ model, }) {
-    const view = getContainingView(model);
-    const width = Math.round(view.dynamicBlocks.totalWidthPx);
-    const height = model.drawCloud ? model.height : model.layoutHeight;
-    const containerRef = useRef(null);
-    const [hoveredFeature, setHoveredFeature] = useState(null);
-    const [hoveredFeatureData, setHoveredFeatureData] = useState(null);
-    const [mousePosition, setMousePosition] = useState(null);
-    const flatbushIndex = useMemo(() => {
-        return model.featureLayout ? Flatbush.from(model.featureLayout.data) : null;
-    }, [model.featureLayout]);
-    const cb = useCallback((ref) => {
-        model.setRef(ref);
-    }, [model, width, height]);
-    const mouseoverCb = useCallback((ref) => {
-        model.setMouseoverRef(ref);
-    }, [model, width, height]);
-    const onMouseMove = useCallback((event) => {
-        if (!containerRef.current || !flatbushIndex) {
-            setHoveredFeature(null);
-            setHoveredFeatureData(null);
-            setMousePosition(null);
-            return;
-        }
-        const rect = containerRef.current.getBoundingClientRect();
-        const offsetX = event.clientX - rect.left;
-        const offsetY = event.clientY - rect.top;
-        setMousePosition({ x: event.clientX, y: event.clientY });
-        const results = flatbushIndex.search(offsetX, offsetY, offsetX + 1, offsetY + 1);
-        if (results.length > 0) {
-            const featureIndex = results[0];
-            const feature = model.featuresForFlatbush[featureIndex];
-            if (feature) {
-                setHoveredFeature({
-                    x: feature.chainMinX,
-                    y: feature.y1,
-                    width: feature.chainMaxX - feature.chainMinX,
-                    height: feature.y2 - feature.y1,
-                });
-                setHoveredFeatureData(feature.data);
-            }
-            else {
-                setHoveredFeature(null);
-                setHoveredFeatureData(null);
-            }
-        }
-        else {
-            setHoveredFeature(null);
-            setHoveredFeatureData(null);
-        }
-    }, [flatbushIndex, model.featuresForFlatbush]);
-    const onMouseLeave = useCallback(() => {
-        setHoveredFeature(null);
-        setHoveredFeatureData(null);
-        setMousePosition(null);
-    }, []);
-    const onClick = useCallback((event) => {
-        if (!containerRef.current || !flatbushIndex) {
-            return;
-        }
-        const rect = containerRef.current.getBoundingClientRect();
-        const offsetX = event.clientX - rect.left;
-        const offsetY = event.clientY - rect.top;
-        const results = flatbushIndex.search(offsetX, offsetY, offsetX + 1, offsetY + 1);
-        if (results.length > 0) {
-            const featureIndex = results[0];
-            const feature = model.featuresForFlatbush[featureIndex];
-            if (feature) {
-                model.selectFeature(feature.chain);
-            }
-        }
-    }, [flatbushIndex, model]);
-    return (_jsxs("div", { ref: containerRef, style: { position: 'relative', width, height }, onMouseMove: onMouseMove, onMouseLeave: onMouseLeave, onClick: onClick, children: [_jsx("canvas", { "data-testid": model.drawCloud ? 'cloud-canvas' : 'stack-canvas', ref: cb, style: { width, height, position: 'absolute', left: 0, top: 0 }, width: width * 2, height: height * 2 }), _jsx("canvas", { "data-testid": "cloud-mouseover-canvas", ref: mouseoverCb, style: {
-                    width,
-                    height,
-                    position: 'absolute',
-                    left: 0,
-                    top: 0,
-                    pointerEvents: 'none',
-                }, width: width * 2, height: height * 2 }), hoveredFeature ? (_jsx("div", { style: {
-                    position: 'absolute',
-                    left: hoveredFeature.x,
-                    top: hoveredFeature.y,
-                    width: hoveredFeature.width,
-                    height: hoveredFeature.height,
-                    backgroundColor: 'rgba(0, 0, 0, 0.2)',
-                    pointerEvents: 'none',
-                } })) : null, hoveredFeatureData && mousePosition ? (_jsx(BaseTooltip, { clientPoint: { x: mousePosition.x, y: mousePosition.y + 20 }, placement: "bottom-start", children: _jsxs("div", { children: [_jsx("div", { children: _jsx("strong", { children: hoveredFeatureData.name }) }), _jsxs("div", { children: [hoveredFeatureData.refName, ":", hoveredFeatureData.start.toLocaleString(), "-", hoveredFeatureData.end.toLocaleString()] }), hoveredFeatureData.tlen !== 0 ? (_jsxs("div", { children: ["Template length: ", hoveredFeatureData.tlen] })) : null] }) })) : null] }));
-});
-const LinearReadCloudReactComponent = observer(function ({ model, }) {
-    return (_jsx(BaseDisplayComponent, { model: model, children: _jsx(Cloud, { model: model }) }));
-});
-export default LinearReadCloudReactComponent;

package/esm/LinearReadCloudDisplay/drawFeatsAbstract.d.ts

@@ -1,2 +0,0 @@
-import type { LinearReadCloudDisplayModel } from './model';
-export declare function drawFeats(self: LinearReadCloudDisplayModel, ctx: CanvasRenderingContext2D): void;

package/esm/LinearReadCloudDisplay/drawFeatsAbstract.js

@@ -1,10 +0,0 @@
-import { drawFeats as drawFeats1 } from './drawFeatsCloud';
-import { drawFeats as drawFeats2 } from './drawFeatsStack';
-export function drawFeats(self, ctx) {
-    if (self.drawCloud) {
-        drawFeats1(self, ctx);
-    }
-    else {
-        drawFeats2(self, ctx);
-    }
-}

package/esm/LinearReadCloudDisplay/drawFeatsCloud.d.ts

@@ -1,2 +0,0 @@
-import type { LinearReadCloudDisplayModel } from './model';
-export declare function drawFeats(self: LinearReadCloudDisplayModel, ctx: CanvasRenderingContext2D): void;

package/esm/LinearReadCloudDisplay/drawFeatsCloud.js

@@ -1,21 +0,0 @@
-import { max, min } from '@jbrowse/core/util';
-import { drawFeatsCommon } from './drawFeatsCommon';
-function calculateCloudYOffsets(computedChains, self, _view, _featureHeight) {
-    const distances = computedChains.map(c => c.distance).filter(d => d > 0);
-    if (distances.length === 0) {
-        return { chainYOffsets: new Map() };
-    }
-    const logOffset = 10;
-    const maxD = Math.log(max(distances) + logOffset);
-    const minD = Math.log(min(distances) + logOffset);
-    const scaler = (self.height - 20) / (maxD - minD || 1);
-    const chainYOffsets = new Map();
-    for (const { id, distance } of computedChains) {
-        const top = distance > 0 ? (Math.log(distance + logOffset) - minD) * scaler : 0;
-        chainYOffsets.set(id, top);
-    }
-    return { chainYOffsets };
-}
-export function drawFeats(self, ctx) {
-    drawFeatsCommon(self, ctx, calculateCloudYOffsets);
-}

package/esm/LinearReadCloudDisplay/drawFeatsCommon.d.ts

@@ -1,23 +0,0 @@
-import type { LinearReadCloudDisplayModel } from './model';
-import type { ChainData, ReducedFeature } from '../shared/fetchChains';
-import type { FlatbushEntry } from '../shared/flatbushType';
-import type { Assembly } from '@jbrowse/core/assemblyManager/assembly';
-import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
-type LGV = LinearGenomeViewModel;
-export interface ComputedChain {
-    distance: number;
-    minX: number;
-    maxX: number;
-    chain: ReducedFeature[];
-    id: string;
-}
-export declare function filterChains(chains: ReducedFeature[][], drawSingletons: boolean, drawProperPairs: boolean, type: string, chainData: ChainData): ReducedFeature[][];
-export declare function computeChainBounds(chains: ReducedFeature[][], view: LGV, asm: Assembly): 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: LGV, featuresForFlatbush: FlatbushEntry[]): void;
-export declare function drawFeatsCommon(self: LinearReadCloudDisplayModel, ctx: CanvasRenderingContext2D, calculateYOffsets: (computedChains: ComputedChain[], self: LinearReadCloudDisplayModel, view: LGV, featureHeight: number) => {
-    chainYOffsets: Map<string, number>;
-    layoutHeight?: number;
-}): void;
-export {};

package/esm/LinearReadCloudDisplay/drawFeatsCommon.js

@@ -1,187 +0,0 @@
-import { getConf } from '@jbrowse/core/configuration';
-import { getContainingView, getSession } from '@jbrowse/core/util';
-import Flatbush from '@jbrowse/core/util/flatbush';
-import { PairType, getPairedType } from '../shared/color';
-import { drawLongReadChains } from '../shared/drawLongReadChains';
-import { drawPairChains } from '../shared/drawPairChains';
-import { shouldRenderChevrons } from '../shared/util';
-export function filterChains(chains, drawSingletons, drawProperPairs, type, chainData) {
-    const filtered = [];
-    for (const chain_ of chains) {
-        const chain = chain_;
-        if (!drawSingletons && chain.length === 1) {
-            continue;
-        }
-        let isPairedEnd = false;
-        for (const element of chain) {
-            if (element.flags & 1) {
-                isPairedEnd = true;
-                break;
-            }
-        }
-        if (!drawProperPairs && isPairedEnd) {
-            const nonSupplementary = [];
-            for (const element of chain) {
-                if (!(element.flags & 2048)) {
-                    nonSupplementary.push(element);
-                }
-            }
-            if (nonSupplementary.length === 2) {
-                const v0 = nonSupplementary[0];
-                const v1 = nonSupplementary[1];
-                const pairType = getPairedType({
-                    type,
-                    f1: v0,
-                    f2: v1,
-                    stats: chainData.stats,
-                });
-                if (pairType === PairType.PROPER_PAIR) {
-                    continue;
-                }
-            }
-        }
-        filtered.push(chain);
-    }
-    return filtered;
-}
-export function computeChainBounds(chains, view, asm) {
-    var _a, _b;
-    const computedChains = [];
-    for (const chain_ of chains) {
-        const chain = chain_;
-        let minX = Number.MAX_VALUE;
-        let maxX = Number.MIN_VALUE;
-        let chainId = '';
-        let tlenDistance = 0;
-        const chainLength = chain.length;
-        for (let j = 0; j < chainLength; j++) {
-            const elt = chain[j];
-            const refName = asm.getCanonicalRefName(elt.refName) || elt.refName;
-            const rs = (_a = view.bpToPx({ refName, coord: elt.start })) === null || _a === void 0 ? void 0 : _a.offsetPx;
-            const re = (_b = view.bpToPx({ refName, coord: elt.end })) === null || _b === void 0 ? void 0 : _b.offsetPx;
-            if (rs !== undefined && re !== undefined) {
-                minX = Math.min(minX, rs);
-                maxX = Math.max(maxX, re);
-            }
-            if (!chainId) {
-                chainId = elt.id;
-            }
-            if (chainLength > 1 && tlenDistance === 0 && elt.tlen) {
-                tlenDistance = Math.abs(elt.tlen);
-            }
-        }
-        const distance = tlenDistance > 0 ? tlenDistance : Math.abs(maxX - minX);
-        computedChains.push({
-            distance,
-            minX,
-            maxX,
-            chain,
-            id: chainId,
-        });
-    }
-    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 } = computedChain;
-        const chainY = chainYOffsets.get(id);
-        if (chainY === undefined) {
-            continue;
-        }
-        const chainMinXPx = minX - view.offsetPx;
-        const chainMaxXPx = maxX - view.offsetPx;
-        if (chain.length > 0) {
-            featuresForFlatbush.push({
-                x1: chainMinXPx,
-                y1: chainY,
-                x2: chainMaxXPx,
-                y2: chainY + featureHeight,
-                data: chain[0],
-                chainId: id,
-                chainMinX: chainMinXPx,
-                chainMaxX: chainMaxXPx,
-                chain,
-            });
-        }
-    }
-}
-export function drawFeatsCommon(self, ctx, calculateYOffsets) {
-    var _a, _b;
-    const { chainData } = self;
-    if (!chainData) {
-        return;
-    }
-    const { assemblyManager } = getSession(self);
-    const view = getContainingView(self);
-    const assemblyName = view.assemblyNames[0];
-    const asm = assemblyManager.get(assemblyName);
-    if (!asm) {
-        return;
-    }
-    const featureHeight = (_a = self.featureHeight) !== null && _a !== void 0 ? _a : getConf(self, 'featureHeight');
-    const type = ((_b = self.colorBy) === null || _b === void 0 ? void 0 : _b.type) || 'insertSizeAndOrientation';
-    const drawSingletons = self.drawSingletons;
-    const drawProperPairs = self.drawProperPairs;
-    const { chains } = chainData;
-    const filteredChains = filterChains(chains, drawSingletons, drawProperPairs, type, chainData);
-    const computedChains = computeChainBounds(filteredChains, view, asm);
-    sortComputedChains(computedChains);
-    const { chainYOffsets, layoutHeight } = calculateYOffsets(computedChains, self, view, featureHeight);
-    const featuresForFlatbush = [];
-    const renderChevrons = shouldRenderChevrons(view.bpPerPx, featureHeight);
-    drawPairChains({
-        ctx,
-        type,
-        chainData,
-        view,
-        asm,
-        chainYOffsets,
-        renderChevrons,
-        featureHeight,
-        featuresForFlatbush,
-        computedChains,
-    });
-    drawLongReadChains({
-        ctx,
-        chainData,
-        view,
-        asm,
-        chainYOffsets,
-        renderChevrons,
-        featureHeight,
-        featuresForFlatbush,
-        computedChains,
-        flipStrandLongReadChains: self.flipStrandLongReadChains,
-    });
-    addChainMouseoverRects(computedChains, chainYOffsets, featureHeight, view, featuresForFlatbush);
-    buildFlatbushIndex(featuresForFlatbush, self);
-    if (layoutHeight !== undefined) {
-        self.setLayoutHeight(layoutHeight);
-    }
-}

package/esm/LinearReadCloudDisplay/drawFeatsStack.d.ts

@@ -1,2 +0,0 @@
-import type { LinearReadCloudDisplayModel } from './model';
-export declare function drawFeats(self: LinearReadCloudDisplayModel, ctx: CanvasRenderingContext2D): void;