@jbrowse/plugin-alignments 3.7.0 → 4.0.0

package/esm/shared/arcUtils.js

@@ -0,0 +1,73 @@
+import { SAM_FLAG_MATE_REVERSE, SAM_FLAG_MATE_UNMAPPED, SAM_FLAG_SECONDARY, SAM_FLAG_SUPPLEMENTARY, } from "./samFlags.js";
+export function jitter(n) {
+    return Math.random() * 2 * n - n;
+}
+export function drawVerticalLine(ctx, x, height, color) {
+    ctx.strokeStyle = color;
+    ctx.beginPath();
+    ctx.moveTo(x, 0);
+    ctx.lineTo(x, height);
+    ctx.stroke();
+}
+export function extractCoreFeat(f) {
+    return {
+        refName: f.get('refName'),
+        start: f.get('start'),
+        end: f.get('end'),
+        strand: f.get('strand'),
+        tlen: f.get('template_length'),
+        pair_orientation: f.get('pair_orientation'),
+        next_ref: f.get('next_ref'),
+    };
+}
+export function extractCoreFeatBasic(f) {
+    return {
+        refName: f.get('refName'),
+        start: f.get('start'),
+        end: f.get('end'),
+        strand: f.get('strand'),
+    };
+}
+export function getStrandRelativeFirstClipLength(f) {
+    return 'get' in f
+        ? f.get('clipLengthAtStartOfRead')
+        : f
+            .clipLengthAtStartOfRead;
+}
+export function toCoreFeat(f) {
+    return 'get' in f ? extractCoreFeat(f) : f;
+}
+export function toCoreFeatBasic(f) {
+    return 'get' in f ? extractCoreFeatBasic(f) : f;
+}
+export function getMateInfo(f) {
+    const flags = f.get('flags') || 0;
+    const mateStrand = flags & SAM_FLAG_MATE_REVERSE ? -1 : 1;
+    return {
+        refName: f.get('next_ref') || '',
+        start: f.get('next_pos') || 0,
+        end: f.get('next_pos') || 0,
+        strand: mateStrand,
+    };
+}
+export function filterPairedChain(chain) {
+    const result = [];
+    for (const f of chain) {
+        const flags = f.get('flags');
+        if (!(flags & SAM_FLAG_SUPPLEMENTARY) &&
+            !(flags & SAM_FLAG_MATE_UNMAPPED)) {
+            result.push(f);
+        }
+    }
+    return result;
+}
+export function filterAndSortLongReadChain(chain) {
+    const filtered = [];
+    for (const f of chain) {
+        if (!(f.get('flags') & SAM_FLAG_SECONDARY)) {
+            filtered.push(f);
+        }
+    }
+    filtered.sort((a, b) => a.get('clipLengthAtStartOfRead') - b.get('clipLengthAtStartOfRead'));
+    return filtered;
+}

package/esm/shared/canvasUtils.d.ts

@@ -1,2 +1,2 @@
-export declare function fillRectCtx(x: number, y: number, width: number, height: number, ctx: CanvasRenderingContext2D, fillColor?: string): void;
 export declare function strokeRectCtx(x: number, y: number, width: number, height: number, ctx: CanvasRenderingContext2D, strokeColor?: string): void;
+export declare function lineToCtx(x1: number, y1: number, x2: number, y2: number, ctx: CanvasRenderingContext2D, strokeColor?: string): void;

package/esm/shared/canvasUtils.js

@@ -1,17 +1,3 @@
-export function fillRectCtx(x, y, width, height, ctx, fillColor) {
-    if (width < 0) {
-        x += width;
-        width = -width;
-    }
-    if (height < 0) {
-        y += height;
-        height = -height;
-    }
-    if (fillColor) {
-        ctx.fillStyle = fillColor;
-    }
-    ctx.fillRect(x, y, width, height);
-}
 export function strokeRectCtx(x, y, width, height, ctx, strokeColor) {
     if (width < 0) {
         x += width;
@@ -26,3 +12,12 @@ export function strokeRectCtx(x, y, width, height, ctx, strokeColor) {
     }
     ctx.strokeRect(x, y, width, height);
 }
+export function lineToCtx(x1, y1, x2, y2, ctx, strokeColor) {
+    if (strokeColor) {
+        ctx.strokeStyle = strokeColor;
+    }
+    ctx.beginPath();
+    ctx.moveTo(x1, y1);
+    ctx.lineTo(x2, y2);
+    ctx.stroke();
+}

package/esm/shared/color.d.ts

@@ -1,4 +1,5 @@
-import type { ChainStats, ReducedFeature } from './fetchChains';
+import type { ChainStats } from './types.ts';
+import type { Feature } from '@jbrowse/core/util';
 export declare const PairType: {
     readonly PROPER_PAIR: 0;
     readonly LONG_INSERT: 1;
@@ -27,6 +28,10 @@ export declare const fillColor: {
     color_shortinsert: string;
     color_unmapped_mate: string;
     color_unknown: string;
+    color_longread_rev_fwd: string;
+    color_longread_fwd_rev: string;
+    color_longread_same: string;
+    color_supplementary: string;
 };
 export declare const strokeColor: {
     color_fwd_strand_not_proper: string;
@@ -47,26 +52,27 @@ export declare const strokeColor: {
     color_shortinsert: string;
     color_unmapped_mate: string;
     color_unknown: string;
+    color_longread_rev_fwd: string;
+    color_longread_fwd_rev: string;
+    color_longread_same: string;
+    color_supplementary: string;
 };
-export declare function getPairedType({ type, f1, f2, stats, }: {
+export declare function getPairedType({ type, f, stats, }: {
     type: string;
-    f1: {
+    f: {
         refName: string;
+        next_ref?: string;
         pair_orientation?: string;
         tlen?: number;
         flags?: number;
     };
-    f2: {
-        refName: string;
-    };
     stats?: ChainStats;
 }): PairTypeValue;
-export declare function getPairedInsertSizeColor(f1: {
+export declare function getPairedInsertSizeColor(f: {
     refName: string;
+    next_ref?: string;
     tlen?: number;
     flags?: number;
-}, f2: {
-    refName: string;
 }, stats?: ChainStats): readonly [string, string] | undefined;
 export declare function getPairedOrientationColorOrDefault(f: {
     pair_orientation?: string;
@@ -76,20 +82,20 @@ export declare function getPairedOrientationColor(f: {
     pair_orientation?: string;
     flags?: number;
 }): readonly [string, string];
-export declare function getPairedInsertSizeAndOrientationColor(f1: {
+export declare function getPairedInsertSizeAndOrientationColor(f: {
     refName: string;
+    next_ref?: string;
     pair_orientation?: string;
     tlen?: number;
     flags?: number;
-}, f2: {
-    refName: string;
 }, stats?: ChainStats): readonly [string, string];
 export declare function getSingletonColor(f: {
     tlen?: number;
+    pair_orientation?: string;
+    flags?: number;
 }, stats?: ChainStats): readonly [string, string];
-export declare function getPairedColor({ type, v0, v1, stats, }: {
+export declare function getPairedColor({ type, v0, stats, }: {
     type: string;
-    v0: ReducedFeature;
-    v1: ReducedFeature;
+    v0: Feature;
     stats?: ChainStats;
 }): readonly [string, string] | undefined;

package/esm/shared/color.js

@@ -1,4 +1,4 @@
-import { orientationTypes, pairMap } from '../util';
+import { orientationTypes, pairMap } from "../util.js";
 export const PairType = {
     PROPER_PAIR: 0,
     LONG_INSERT: 1,
@@ -16,7 +16,7 @@ export const fillColor = {
     color_rev_missing_mate: '#1919D1',
     color_fwd_diff_chr: '#000',
     color_rev_diff_chr: '#969696',
-    color_pair_lr: '#c8c8c8',
+    color_pair_lr: 'lightgrey',
     color_pair_rr: '#3a3a9d',
     color_pair_rl: 'teal',
     color_pair_ll: 'green',
@@ -24,8 +24,12 @@ export const fillColor = {
     color_interchrom: 'purple',
     color_longinsert: 'red',
     color_shortinsert: 'pink',
-    color_unmapped_mate: '#8B008B',
+    color_unmapped_mate: '#8B4513',
     color_unknown: 'grey',
+    color_longread_rev_fwd: 'navy',
+    color_longread_fwd_rev: 'green',
+    color_longread_same: 'grey',
+    color_supplementary: '#f0b878',
 };
 export const strokeColor = {
     color_fwd_strand_not_proper: '#CA6767',
@@ -44,27 +48,31 @@ export const strokeColor = {
     color_interchrom: '#5A005A',
     color_longinsert: '#B30000',
     color_shortinsert: '#FF3A5C',
-    color_unmapped_mate: '#5A005A',
+    color_unmapped_mate: '#5D2E0D',
     color_unknown: '#444',
+    color_longread_rev_fwd: '#00004D',
+    color_longread_fwd_rev: '#005A00',
+    color_longread_same: '#444',
+    color_supplementary: '#c88030',
 };
 const defaultColor = [
     fillColor.color_pair_lr,
     strokeColor.color_pair_lr,
 ];
-export function getPairedType({ type, f1, f2, stats, }) {
-    if (f1.flags !== undefined && f1.flags & 8) {
+export function getPairedType({ type, f, stats, }) {
+    if (f.flags !== undefined && f.flags & 8) {
         return PairType.UNMAPPED_MATE;
     }
     if (type === 'insertSizeAndOrientation' || type === 'orientation') {
         const orientationType = orientationTypes.fr;
-        const r = orientationType[f1.pair_orientation || ''];
+        const r = orientationType[f.pair_orientation || ''];
         if (r && r !== 'LR') {
             return PairType.ABNORMAL_ORIENTATION;
         }
     }
     if (type === 'insertSizeAndOrientation' || type === 'insertSize') {
-        const sameRef = f1.refName === f2.refName;
-        const tlen = Math.abs(f1.tlen || 0);
+        const sameRef = f.refName === f.next_ref;
+        const tlen = Math.abs(f.tlen || 0);
         if (!sameRef) {
             return PairType.INTER_CHROM;
         }
@@ -79,8 +87,12 @@ export function getPairedType({ type, f1, f2, stats, }) {
     }
     return PairType.PROPER_PAIR;
 }
-export function getPairedInsertSizeColor(f1, f2, stats) {
-    const pairType = getPairedType({ type: 'insertSize', f1, f2, stats });
+export function getPairedInsertSizeColor(f, stats) {
+    const pairType = getPairedType({
+        type: 'insertSize',
+        f,
+        stats,
+    });
     switch (pairType) {
         case PairType.UNMAPPED_MATE:
             return [
@@ -111,17 +123,18 @@ export function getPairedOrientationColorOrDefault(f) {
     }
     const type = orientationTypes.fr;
     const r = type[f.pair_orientation || ''];
+    if (!r || r === 'LR') {
+        return undefined;
+    }
     const type2 = pairMap[r];
-    return r === 'LR'
-        ? undefined
-        : [fillColor[type2], strokeColor[type2]];
+    return [fillColor[type2], strokeColor[type2]];
 }
 export function getPairedOrientationColor(f) {
     return getPairedOrientationColorOrDefault(f) || defaultColor;
 }
-export function getPairedInsertSizeAndOrientationColor(f1, f2, stats) {
-    return (getPairedOrientationColorOrDefault(f1) ||
-        getPairedInsertSizeColor(f1, f2, stats) ||
+export function getPairedInsertSizeAndOrientationColor(f, stats) {
+    return (getPairedOrientationColorOrDefault(f) ||
+        getPairedInsertSizeColor(f, stats) ||
         defaultColor);
 }
 export function getSingletonColor(f, stats) {
@@ -134,15 +147,22 @@ export function getSingletonColor(f, stats) {
     }
     return defaultColor;
 }
-export function getPairedColor({ type, v0, v1, stats, }) {
+export function getPairedColor({ type, v0, stats, }) {
+    const f0 = {
+        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'),
+    };
     if (type === 'insertSizeAndOrientation') {
-        return getPairedInsertSizeAndOrientationColor(v0, v1, stats);
+        return getPairedInsertSizeAndOrientationColor(f0, stats);
     }
     if (type === 'orientation') {
-        return getPairedOrientationColor(v0);
+        return getPairedOrientationColor(f0);
     }
     if (type === 'insertSize') {
-        return getPairedInsertSizeColor(v0, v1, stats);
+        return getPairedInsertSizeColor(f0, stats);
     }
     return undefined;
 }

package/esm/shared/components/FilterByTagDialog.d.ts

@@ -1,4 +1,4 @@
-import type { FilterBy } from '../types';
+import type { FilterBy } from '../types.ts';
 declare const FilterByTagDialog: (props: {
     model: {
         filterBy: FilterBy;

package/esm/shared/components/FilterByTagDialog.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Dialog } from '@jbrowse/core/ui';
+import { makeStyles } from '@jbrowse/core/util/tss-react';
 import { Button, DialogActions, DialogContent, Link, Paper, TextField, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
-import { makeStyles } from 'tss-react/mui';
 const useStyles = makeStyles()(theme => ({
     paper: {
         padding: theme.spacing(2),
@@ -44,15 +44,14 @@ function Bitmask(props) {
                             } }), _jsx("label", { htmlFor: key, children: name })] }, key));
             })] }));
 }
-const FilterByTagDialog = observer(function (props) {
-    var _a, _b;
+const FilterByTagDialog = observer(function FilterByTagDialog(props) {
     const { model, handleClose } = props;
     const { classes } = useStyles();
     const { filterBy } = model;
     const [flagInclude, setFlagInclude] = useState(filterBy.flagInclude);
     const [flagExclude, setFlagExclude] = useState(filterBy.flagExclude);
-    const [tag, setTag] = useState(((_a = filterBy.tagFilter) === null || _a === void 0 ? void 0 : _a.tag) || '');
-    const [tagValue, setTagValue] = useState(((_b = filterBy.tagFilter) === null || _b === void 0 ? void 0 : _b.value) || '');
+    const [tag, setTag] = useState(filterBy.tagFilter?.tag || '');
+    const [tagValue, setTagValue] = useState(filterBy.tagFilter?.value || '');
     const [readName, setReadName] = useState(filterBy.readName || '');
     const validTag = /^[A-Za-z][A-Za-z0-9]$/.exec(tag);
     const site = 'https://broadinstitute.github.io/picard/explain-flags.html';

package/esm/shared/components/SetFeatureHeightDialog.js

@@ -3,7 +3,7 @@ import { useState } from 'react';
 import { Dialog } from '@jbrowse/core/ui';
 import { Button, Checkbox, DialogActions, DialogContent, FormControlLabel, TextField, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
-const SetFeatureHeightDialog = observer(function (props) {
+const SetFeatureHeightDialog = observer(function SetFeatureHeightDialog(props) {
     const { model, handleClose } = props;
     const { featureHeightSetting, noSpacing: noSpacingSetting } = model;
     const [height, setHeight] = useState(`${featureHeightSetting}`);

package/esm/shared/components/SetMaxHeightDialog.js

@@ -1,20 +1,20 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Dialog } from '@jbrowse/core/ui';
+import { makeStyles } from '@jbrowse/core/util/tss-react';
 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 SetMaxHeightDialog = observer(function SetMaxHeightDialog(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 => {
+    return (_jsx(Dialog, { open: true, onClose: handleClose, title: "Set max track height", children: _jsxs(DialogContent, { className: classes.root, children: [_jsx(Typography, { children: "Set max layout 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);

package/esm/{LinearPileupDisplay → shared}/components/SetModificationThresholdDialog.d.ts

@@ -1,4 +1,4 @@
-import type { ColorBy } from '../../shared/types';
+import type { ColorBy } from '../types.ts';
 declare const SetModificationThresholdDialog: (props: {
     model: {
         modificationThreshold: number;

package/esm/{LinearPileupDisplay → shared}/components/SetModificationThresholdDialog.js

@@ -3,7 +3,7 @@ import { useState } from 'react';
 import { Dialog } from '@jbrowse/core/ui';
 import { Button, DialogActions, DialogContent, TextField, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
-const SetModificationThresholdDialog = observer(function (props) {
+const SetModificationThresholdDialog = observer(function SetModificationThresholdDialog(props) {
     const { model, handleClose } = props;
     const [threshold, setThreshold] = useState(String(model.modificationThreshold));
     const numThreshold = Number.parseFloat(threshold);

package/esm/shared/createRPCRenderingSetup.d.ts

@@ -0,0 +1,37 @@
+import { getSession } from '@jbrowse/core/util';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { StopToken } from '@jbrowse/core/util/stopToken';
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+type LGV = LinearGenomeViewModel;
+export interface RPCRenderableModel {
+    id: string;
+    error: unknown;
+    featureDensityStatsReadyAndRegionNotTooLarge: boolean;
+    effectiveRpcDriverName: string;
+    adapterConfig: unknown;
+    configuration: AnyConfigurationModel;
+    renderingStopToken?: StopToken;
+    setRenderingStopToken: (token?: StopToken) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: unknown) => void;
+    setRenderingImageData: (imageData: ImageBitmap | undefined) => void;
+    setLastDrawnOffsetPx: (offsetPx: number) => void;
+    setLastDrawnBpPerPx: (bpPerPx: number) => void;
+    ref: HTMLCanvasElement | null;
+    renderingImageData?: ImageBitmap;
+    setStatusMessage?: (msg: string) => void;
+}
+export interface RPCRenderSetupParams<T extends RPCRenderableModel, R = Record<string, unknown>> {
+    self: T;
+    rpcMethodName: string;
+    getRPCParams: (params: {
+        view: LGV;
+        session: ReturnType<typeof getSession>;
+        sequenceAdapter: unknown;
+        stopToken: StopToken;
+    }) => Record<string, unknown>;
+    onResult: (result: R) => void;
+}
+export declare function createRPCRenderFunction<T extends RPCRenderableModel, R = Record<string, unknown>>({ self, rpcMethodName, getRPCParams, onResult }: RPCRenderSetupParams<T, R>): () => Promise<void>;
+export declare function setupCanvasRenderingAutorun<T extends RPCRenderableModel>(self: T): void;
+export {};

package/esm/shared/createRPCRenderingSetup.js

@@ -0,0 +1,82 @@
+import { getContainingView, getSession, isAbortException, } from '@jbrowse/core/util';
+import { createStopToken, stopStopToken } from '@jbrowse/core/util/stopToken';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { getSnapshot, isAlive } from '@jbrowse/mobx-state-tree';
+import { drawCanvasImageData } from '@jbrowse/plugin-linear-genome-view';
+import { untracked } from 'mobx';
+import { createAutorun } from "../util.js";
+export function createRPCRenderFunction({ self, rpcMethodName, getRPCParams, onResult }) {
+    return async () => {
+        const view = getContainingView(self);
+        if (!view.initialized ||
+            self.error ||
+            !self.featureDensityStatsReadyAndRegionNotTooLarge) {
+            return;
+        }
+        const { bpPerPx } = view;
+        try {
+            const session = getSession(self);
+            const { rpcManager, assemblyManager } = session;
+            const assemblyName = view.assemblyNames[0];
+            if (!assemblyName) {
+                return;
+            }
+            const assembly = assemblyManager.get(assemblyName);
+            const sequenceAdapterConfig = assembly?.configuration?.sequence?.adapter;
+            const sequenceAdapter = sequenceAdapterConfig
+                ? getSnapshot(sequenceAdapterConfig)
+                : undefined;
+            const previousToken = untracked(() => self.renderingStopToken);
+            if (previousToken) {
+                stopStopToken(previousToken);
+            }
+            const stopToken = createStopToken();
+            self.setRenderingStopToken(stopToken);
+            self.setLoading(true);
+            const viewSnapshot = structuredClone({
+                ...getSnapshot(view),
+                staticBlocks: view.staticBlocks,
+                width: view.width,
+            });
+            const sessionId = getRpcSessionId(self);
+            const result = (await rpcManager.call(sessionId, rpcMethodName, {
+                sessionId,
+                view: viewSnapshot,
+                adapterConfig: self.adapterConfig,
+                sequenceAdapter,
+                config: getSnapshot(self.configuration),
+                statusCallback: (msg) => {
+                    if (isAlive(self)) {
+                        self.setStatusMessage?.(msg);
+                    }
+                },
+                stopToken,
+                ...getRPCParams({ view, session, sequenceAdapter, stopToken }),
+            }));
+            if (result.imageData) {
+                self.setRenderingImageData(result.imageData);
+                if (result.offsetPx !== undefined) {
+                    self.setLastDrawnOffsetPx(result.offsetPx);
+                }
+                onResult(result);
+            }
+            self.setLastDrawnBpPerPx(bpPerPx);
+        }
+        catch (error) {
+            if (!isAbortException(error)) {
+                self.setError(error);
+            }
+        }
+        finally {
+            self.setRenderingStopToken(undefined);
+            self.setLoading(false);
+        }
+    };
+}
+export function setupCanvasRenderingAutorun(self) {
+    createAutorun(self, async () => {
+        drawCanvasImageData(self.ref, self.renderingImageData);
+    }, {
+        name: 'CanvasRenderAutorun',
+    });
+}

package/esm/shared/decodeSeq.d.ts

@@ -0,0 +1,2 @@
+export declare function decodeSeq(numericSeq: Uint8Array, seqLength: number): string;
+export declare function seqAt(numericSeq: Uint8Array, idx: number, seqLength: number): string | undefined;

package/esm/shared/decodeSeq.js

@@ -0,0 +1,26 @@
+const SEQRET_DECODER = '=ACMGRSVTWYHKDBN'.split('');
+export function decodeSeq(numericSeq, seqLength) {
+    const buf = new Array(seqLength);
+    let i = 0;
+    const fullBytes = seqLength >> 1;
+    for (let j = 0; j < fullBytes; ++j) {
+        const sb = numericSeq[j];
+        buf[i++] = SEQRET_DECODER[(sb & 0xf0) >> 4];
+        buf[i++] = SEQRET_DECODER[sb & 0x0f];
+    }
+    if (i < seqLength) {
+        const sb = numericSeq[fullBytes];
+        buf[i] = SEQRET_DECODER[(sb & 0xf0) >> 4];
+    }
+    return buf.join('');
+}
+export function seqAt(numericSeq, idx, seqLength) {
+    if (idx < seqLength) {
+        const byteIndex = idx >> 1;
+        const sb = numericSeq[byteIndex];
+        return idx % 2 === 0
+            ? SEQRET_DECODER[(sb & 0xf0) >> 4]
+            : SEQRET_DECODER[sb & 0x0f];
+    }
+    return undefined;
+}

package/esm/shared/flatbushType.d.ts

@@ -1,12 +1,25 @@
-import type { ReducedFeature } from './fetchChains';
+export interface ReducedFeatureForFlatbush {
+    name: string;
+    refName: string;
+    start: number;
+    end: number;
+    strand: number;
+    flags: number;
+    id: string;
+    tlen: number;
+    pair_orientation: string;
+    clipLengthAtStartOfRead: number;
+    next_ref?: string;
+}
 export interface FlatbushEntry {
     x1: number;
     y1: number;
     x2: number;
     y2: number;
-    data: ReducedFeature;
+    data: ReducedFeatureForFlatbush;
     chainId: string;
     chainMinX: number;
     chainMaxX: number;
-    chain: ReducedFeature[];
+    chain: ReducedFeatureForFlatbush[];
+    hasSupplementary: boolean;
 }

package/esm/shared/forEachMismatchTypes.d.ts

@@ -0,0 +1,18 @@
+export declare const MISMATCH_TYPE = 0;
+export declare const INSERTION_TYPE = 1;
+export declare const DELETION_TYPE = 2;
+export declare const SKIP_TYPE = 3;
+export declare const SOFTCLIP_TYPE = 4;
+export declare const HARDCLIP_TYPE = 5;
+export declare const INTERBASE_MASK = 50;
+export declare const DELSKIP_MASK = 12;
+export declare const MISMATCH_MAP: readonly ["mismatch", "insertion", "deletion", "skip", "softclip", "hardclip"];
+export declare const MISMATCH_REV_MAP: {
+    readonly mismatch: 0;
+    readonly insertion: 1;
+    readonly deletion: 2;
+    readonly skip: 3;
+    readonly softclip: 4;
+    readonly hardclip: 5;
+};
+export type MismatchCallback = (type: number, start: number, length: number, base: string, qual: number | undefined, altbase: number | undefined, cliplen: number | undefined) => void;

package/esm/shared/forEachMismatchTypes.js

@@ -0,0 +1,24 @@
+export const MISMATCH_TYPE = 0;
+export const INSERTION_TYPE = 1;
+export const DELETION_TYPE = 2;
+export const SKIP_TYPE = 3;
+export const SOFTCLIP_TYPE = 4;
+export const HARDCLIP_TYPE = 5;
+export const INTERBASE_MASK = 0b110010;
+export const DELSKIP_MASK = 0b1100;
+export const MISMATCH_MAP = [
+    'mismatch',
+    'insertion',
+    'deletion',
+    'skip',
+    'softclip',
+    'hardclip',
+];
+export const MISMATCH_REV_MAP = {
+    mismatch: 0,
+    insertion: 1,
+    deletion: 2,
+    skip: 3,
+    softclip: 4,
+    hardclip: 5,
+};

package/esm/shared/getMaximumModificationAtEachPosition.d.ts

@@ -4,5 +4,5 @@ interface MaximumProbabilityMod {
     prob: number;
     allProbs: number[];
 }
-export declare function getMaxProbModAtEachPosition(feature: Feature, cigarOps?: string[]): MaximumProbabilityMod[] | undefined;
+export declare function getMaxProbModAtEachPosition(feature: Feature, ops: ArrayLike<number>): MaximumProbabilityMod[] | undefined;
 export {};