@jbrowse/plugin-alignments 3.7.0 → 4.0.0

package/esm/SNPCoverageRenderer/types.d.ts

@@ -1,21 +1,70 @@
-import type { ColorBy, ModificationTypeWithColor } from '../shared/types';
+import type { BaseCoverageBin, ColorBy, ModificationTypeWithColor } from '../shared/types.ts';
 import type { RenderArgsDeserialized as FeatureRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
 import type { Feature } from '@jbrowse/core/util';
 import type { ScaleOpts } from '@jbrowse/plugin-wiggle';
+export interface InterbaseIndicatorItem {
+    type: 'insertion' | 'softclip' | 'hardclip';
+    base: string;
+    count: number;
+    total: number;
+    avgLength?: number;
+    minLength?: number;
+    maxLength?: number;
+    topSequence?: string;
+    start: number;
+}
+export interface SNPItem {
+    type: 'snp';
+    base: string;
+    count: number;
+    total: number;
+    refbase?: string;
+    avgQual?: number;
+    fwdCount: number;
+    revCount: number;
+    bin?: BaseCoverageBin;
+    start: number;
+    end: number;
+}
+export interface ModificationItem {
+    type: 'modification';
+    modType: string;
+    base: string;
+    count: number;
+    total: number;
+    avgProb?: number;
+    fwdCount: number;
+    revCount: number;
+    isUnmodified: boolean;
+    start: number;
+}
+export type ClickMapItem = InterbaseIndicatorItem | SNPItem | ModificationItem;
+export declare function getInterbaseTypeLabel(type: string): string;
+interface TableRow {
+    base: string;
+    count: number;
+    percent: string;
+    strands: string;
+    prob?: string;
+}
+export declare function formatBinAsTableRows(bin: BaseCoverageBin): TableRow[];
+export declare function clickMapItemToFeatureData(item: ClickMapItem, refName?: string): Record<string, unknown>;
 export interface RenderArgsDeserialized extends FeatureRenderArgsDeserialized {
     bpPerPx: number;
     height: number;
     highResolutionScaling: number;
     scaleOpts: ScaleOpts;
-}
-export interface RenderArgsDeserializedWithFeatures extends RenderArgsDeserialized {
-    features: Map<string, Feature>;
     ticks: {
         values: number[];
     };
     displayCrossHatches: boolean;
     visibleModifications?: Record<string, ModificationTypeWithColor>;
     simplexModifications?: string[];
-    statusCallback?: (arg: string) => void;
     colorBy: ColorBy;
+    statusCallback?: (arg: string) => void;
+    offset?: number;
+}
+export interface RenderArgsDeserializedWithFeatures extends RenderArgsDeserialized {
+    features: Map<string, Feature>;
 }
+export {};

package/esm/SNPCoverageRenderer/types.js

@@ -1 +1,103 @@
-export {};
+import { reducePrecision } from '@jbrowse/core/util';
+const typeLabels = {
+    insertion: 'Insertion',
+    softclip: 'Soft clip',
+    hardclip: 'Hard clip',
+    snp: 'SNP',
+    modification: 'Modification',
+};
+export function getInterbaseTypeLabel(type) {
+    return typeLabels[type] ?? type;
+}
+function formatStrandCounts(entry) {
+    const neg = entry['-1'] ? `${entry['-1']}(-)` : '';
+    const pos = entry['1'] ? `${entry['1']}(+)` : '';
+    return neg + pos || '-';
+}
+function pct(n, total = 1) {
+    return `${((n / (total || 1)) * 100).toFixed(1)}%`;
+}
+export function formatBinAsTableRows(bin) {
+    const { readsCounted, ref, refbase, snps, mods } = bin;
+    const rows = [
+        {
+            base: 'Total',
+            count: readsCounted,
+            percent: '-',
+            strands: '-',
+        },
+        {
+            base: refbase ? `REF (${refbase.toUpperCase()})` : 'REF',
+            count: ref.entryDepth,
+            percent: pct(ref.entryDepth, readsCounted),
+            strands: formatStrandCounts(ref),
+        },
+    ];
+    for (const [snpBase, entry] of Object.entries(snps)) {
+        rows.push({
+            base: snpBase.toUpperCase(),
+            count: entry.entryDepth,
+            percent: pct(entry.entryDepth, readsCounted),
+            strands: formatStrandCounts(entry),
+            prob: entry.avgProbability !== undefined
+                ? `qual:${reducePrecision(entry.avgProbability)}`
+                : undefined,
+        });
+    }
+    for (const [modKey, entry] of Object.entries(mods)) {
+        rows.push({
+            base: modKey,
+            count: entry.entryDepth,
+            percent: pct(entry.entryDepth, readsCounted),
+            strands: formatStrandCounts(entry),
+            prob: entry.avgProbability !== undefined
+                ? `${(entry.avgProbability * 100).toFixed(1)}%`
+                : undefined,
+        });
+    }
+    return rows;
+}
+export function clickMapItemToFeatureData(item, refName) {
+    if (item.type === 'snp') {
+        return {
+            uniqueId: `snp-${item.base}-${item.start}`,
+            type: 'snp',
+            refName,
+            start: item.start,
+            end: item.end,
+            details: item.bin ? formatBinAsTableRows(item.bin) : undefined,
+        };
+    }
+    if (item.type === 'modification') {
+        const pctVal = item.total > 0 ? ((item.count / item.total) * 100).toFixed(1) : '0';
+        const label = item.isUnmodified
+            ? `Unmodified ${item.base}`
+            : `${item.modType} (${item.base})`;
+        return {
+            uniqueId: `mod-${item.modType}-${item.base}`,
+            type: 'modification',
+            refName,
+            start: item.start,
+            end: item.start + 1,
+            label,
+            count: `${item.count}/${item.total} (${pctVal}%)`,
+            strands: `${item.fwdCount}(+) ${item.revCount}(-)`,
+            probability: item.avgProb !== undefined
+                ? `${(item.avgProb * 100).toFixed(1)}%`
+                : undefined,
+        };
+    }
+    const pctVal = item.total > 0 ? ((item.count / item.total) * 100).toFixed(1) : '0';
+    return {
+        uniqueId: `${item.type}-${item.base}`,
+        type: item.type,
+        refName,
+        start: item.start,
+        end: item.start + 1,
+        count: `${item.count}/${item.total} (${pctVal}%)`,
+        size: item.minLength === item.maxLength
+            ? `${item.minLength}bp`
+            : `${item.minLength}-${item.maxLength}bp (avg ${item.avgLength?.toFixed(1)}bp)`,
+        sequence: item.topSequence,
+    };
+}

package/esm/SVGErrorBox.d.ts

@@ -0,0 +1,5 @@
+export declare function ErrorBox({ error, width, height, }: {
+    error: unknown;
+    width: number;
+    height: number;
+}): import("react/jsx-runtime").JSX.Element;

package/esm/SVGErrorBox.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+export function ErrorBox({ error, width, height, }) {
+    return (_jsxs(_Fragment, { children: [_jsx("rect", { x: 0, y: 0, width: width, height: height, fill: "#ffdddd" }), _jsx("text", { x: 10, y: height / 2, fill: "#cc0000", fontSize: 14, children: `${error}` })] }));
+}

package/esm/index.d.ts

@@ -4,6 +4,6 @@ export default class AlignmentsPlugin extends Plugin {
     name: string;
     install(pluginManager: PluginManager): void;
 }
-export { SharedLinearPileupDisplayMixin, linearPileupDisplayConfigSchemaFactory, linearPileupDisplayStateModelFactory, } from './LinearPileupDisplay';
-export { type LinearPileupDisplayModel } from './LinearPileupDisplay/model';
-export * as MismatchParser from './MismatchParser';
+export { SharedLinearPileupDisplayMixin, linearPileupDisplayConfigSchemaFactory, linearPileupDisplayStateModelFactory, } from './LinearPileupDisplay/index.ts';
+export { type LinearPileupDisplayModel } from './LinearPileupDisplay/model.ts';
+export * as MismatchParser from './MismatchParser/index.ts';

package/esm/index.js

@@ -1,24 +1,23 @@
 import Plugin from '@jbrowse/core/Plugin';
-import AlignmentsFeatureWidgetF from './AlignmentsFeatureDetail';
-import AlignmentsTrackF from './AlignmentsTrack';
-import CramAdapterF from './BamAdapter';
-import BamAdapterF from './CramAdapter';
-import GuessAlignmentsTypesF from './GuessAlignmentsTypes';
-import HtsgetBamAdapterF from './HtsgetBamAdapter';
-import LinearAlignmentsDisplayF from './LinearAlignmentsDisplay';
-import LinearPileupDisplayF from './LinearPileupDisplay';
-import LinearReadArcsDisplayF from './LinearReadArcsDisplay';
-import LinearReadCloudDisplayF from './LinearReadCloudDisplay';
-import LinearSNPCoverageDisplayF from './LinearSNPCoverageDisplay';
-import PileupRPCMethodsF from './PileupRPC';
-import PileupRendererF from './PileupRenderer';
-import SNPCoverageAdapterF from './SNPCoverageAdapter';
-import SNPCoverageRendererF from './SNPCoverageRenderer';
+import AlignmentsFeatureWidgetF from "./AlignmentsFeatureDetail/index.js";
+import AlignmentsTrackF from "./AlignmentsTrack/index.js";
+import CramAdapterF from "./BamAdapter/index.js";
+import BamAdapterF from "./CramAdapter/index.js";
+import GuessAlignmentsTypesF from "./GuessAlignmentsTypes/index.js";
+import HtsgetBamAdapterF from "./HtsgetBamAdapter/index.js";
+import LinearAlignmentsDisplayF from "./LinearAlignmentsDisplay/index.js";
+import LinearPileupDisplayF from "./LinearPileupDisplay/index.js";
+import LinearReadArcsDisplayF from "./LinearReadArcsDisplay/index.js";
+import LinearReadCloudDisplayF from "./LinearReadCloudDisplay/index.js";
+import LinearSNPCoverageDisplayF from "./LinearSNPCoverageDisplay/index.js";
+import PileupRPCMethodsF from "./PileupRPC/index.js";
+import PileupRendererF from "./PileupRenderer/index.js";
+import LinearReadArcsDisplayRPCMethodsF from "./RenderLinearReadArcsDisplayRPC/index.js";
+import LinearReadCloudDisplayRPCMethodsF from "./RenderLinearReadCloudDisplayRPC/index.js";
+import SNPCoverageAdapterF from "./SNPCoverageAdapter/index.js";
+import SNPCoverageRendererF from "./SNPCoverageRenderer/index.js";
 export default class AlignmentsPlugin extends Plugin {
-    constructor() {
-        super(...arguments);
-        this.name = 'AlignmentsPlugin';
-    }
+    name = 'AlignmentsPlugin';
     install(pluginManager) {
         ;
         [
@@ -31,6 +30,8 @@ export default class AlignmentsPlugin extends Plugin {
             HtsgetBamAdapterF,
             PileupRendererF,
             PileupRPCMethodsF,
+            LinearReadArcsDisplayRPCMethodsF,
+            LinearReadCloudDisplayRPCMethodsF,
             SNPCoverageRendererF,
             LinearReadArcsDisplayF,
             LinearReadCloudDisplayF,
@@ -42,5 +43,6 @@ export default class AlignmentsPlugin extends Plugin {
         });
     }
 }
-export { SharedLinearPileupDisplayMixin, linearPileupDisplayConfigSchemaFactory, linearPileupDisplayStateModelFactory, } from './LinearPileupDisplay';
-export * as MismatchParser from './MismatchParser';
+export { SharedLinearPileupDisplayMixin, linearPileupDisplayConfigSchemaFactory, linearPileupDisplayStateModelFactory, } from "./LinearPileupDisplay/index.js";
+export {} from "./LinearPileupDisplay/model.js";
+export * as MismatchParser from "./MismatchParser/index.js";

package/esm/saveTrackFormats/sam.d.ts

@@ -0,0 +1,6 @@
+import type { AbstractSessionModel, Feature } from '@jbrowse/core/util';
+export declare function stringifySAM({ features, session, assemblyName, }: {
+    features: Feature[];
+    session: AbstractSessionModel;
+    assemblyName: string;
+}): string;

package/esm/saveTrackFormats/sam.js

@@ -0,0 +1,42 @@
+function qualToPhred(qual) {
+    if (!qual) {
+        return '*';
+    }
+    return qual
+        .split(' ')
+        .map(q => String.fromCharCode(+q + 33))
+        .join('');
+}
+export function stringifySAM({ features, session, assemblyName, }) {
+    const lines = ['@HD\tVN:1.6\tSO:unsorted'];
+    const { assemblyManager } = session;
+    const assembly = assemblyManager.get(assemblyName);
+    if (assembly) {
+        const regions = assembly.regions;
+        if (regions) {
+            for (const region of regions) {
+                const length = region.end - region.start;
+                lines.push(`@SQ\tSN:${region.refName}\tLN:${length}`);
+            }
+        }
+    }
+    lines.push('@PG\tID:jbrowse\tPN:JBrowse\tVN:2');
+    for (const feature of features) {
+        const start = feature.get('start');
+        const fields = [
+            feature.get('name') || feature.get('id') || '*',
+            feature.get('flag') ?? '0',
+            feature.get('refName') || '*',
+            String(start + 1),
+            feature.get('mapq') ?? '255',
+            feature.get('CIGAR') || '*',
+            feature.get('next_ref') || '*',
+            feature.get('next_pos') ?? '0',
+            feature.get('template_len') ?? '0',
+            feature.get('seq') || '*',
+            qualToPhred(feature.get('qual')),
+        ];
+        lines.push(fields.join('\t'));
+    }
+    return lines.join('\n');
+}

package/esm/shared/LinearReadArcsDisplaySettingsMixin.d.ts

@@ -0,0 +1,14 @@
+export declare function LinearReadArcsDisplaySettingsMixin(): import("@jbrowse/mobx-state-tree").IModelType<{
+    lineWidth: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
+    jitter: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
+    drawInter: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    drawLongRange: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+}, {
+    setDrawInter(f: boolean): void;
+    setDrawLongRange(f: boolean): void;
+    setLineWidth(n: number): void;
+    setJitter(n: number): void;
+} & {
+    readonly lineWidthSetting: any;
+    readonly jitterVal: number;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/shared/LinearReadArcsDisplaySettingsMixin.js

@@ -0,0 +1,33 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+export function LinearReadArcsDisplaySettingsMixin() {
+    return types
+        .model('LinearReadArcsDisplaySettingsMixin', {
+        lineWidth: types.maybe(types.number),
+        jitter: types.maybe(types.number),
+        drawInter: true,
+        drawLongRange: true,
+    })
+        .actions(self => ({
+        setDrawInter(f) {
+            self.drawInter = f;
+        },
+        setDrawLongRange(f) {
+            self.drawLongRange = f;
+        },
+        setLineWidth(n) {
+            self.lineWidth = n;
+        },
+        setJitter(n) {
+            self.jitter = n;
+        },
+    }))
+        .views(self => ({
+        get lineWidthSetting() {
+            return self.lineWidth ?? getConf(self, 'lineWidth');
+        },
+        get jitterVal() {
+            return self.jitter ?? getConf(self, 'jitter');
+        },
+    }));
+}

package/esm/shared/LinearReadDisplayBaseMixin.d.ts

@@ -1,24 +1,33 @@
-import type { ChainData } from './fetchChains';
-import type { ColorBy, FilterBy } from './types';
-export declare function LinearReadDisplayBaseMixin(): import("mobx-state-tree").IModelType<{
-    filterBySetting: import("mobx-state-tree").IType<FilterBy | undefined, FilterBy | undefined, FilterBy | undefined>;
-    colorBySetting: import("mobx-state-tree").IType<ColorBy | undefined, ColorBy | undefined, ColorBy | undefined>;
+import type { ChainData, ColorBy, FilterBy } from './types.ts';
+export declare function LinearReadDisplayBaseMixin(): import("@jbrowse/mobx-state-tree").IModelType<{
+    filterBySetting: import("@jbrowse/mobx-state-tree").IType<FilterBy | undefined, FilterBy | undefined, FilterBy | undefined>;
+    colorBySetting: import("@jbrowse/mobx-state-tree").IType<ColorBy | undefined, ColorBy | undefined, ColorBy | undefined>;
 }, {
     loading: boolean;
-    chainData: ChainData | undefined;
     lastDrawnOffsetPx: number | undefined;
-    lastDrawnBpPerPx: number;
     ref: HTMLCanvasElement | null;
+    renderingImageData: ImageBitmap | undefined;
+    renderingStopToken: import("@jbrowse/core/util").StopToken | undefined;
+    statusMessage: string | undefined;
+} & {
+    readonly drawn: boolean;
 } & {
     setLastDrawnOffsetPx(n: number): void;
-    setLastDrawnBpPerPx(n: number): void;
     setLoading(f: boolean): void;
     setRef(ref: HTMLCanvasElement | null): void;
+    setRenderingImageData(imageData: ImageBitmap | undefined): void;
+    setRenderingStopToken(token?: import("@jbrowse/core/util").StopToken): void;
+    setStatusMessage(msg?: string): void;
+} & {
+    beforeDestroy(): void;
+} & {
+    chainData: ChainData | undefined;
+    lastDrawnBpPerPx: number;
+} & {
+    setLastDrawnBpPerPx(n: number): void;
     setColorScheme(colorBy: {
         type: string;
     }): void;
     setChainData(args: ChainData): void;
     setFilterBy(filter: FilterBy): void;
-} & {
-    readonly drawn: boolean;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/shared/LinearReadDisplayBaseMixin.js

@@ -1,30 +1,19 @@
-import { types } from 'mobx-state-tree';
+import { types } from '@jbrowse/mobx-state-tree';
+import { NonBlockCanvasDisplayMixin } from '@jbrowse/plugin-linear-genome-view';
 export function LinearReadDisplayBaseMixin() {
-    return types
-        .model('LinearReadDisplayBaseMixin', {
+    return types.compose('LinearReadDisplayBaseMixin', NonBlockCanvasDisplayMixin(), types
+        .model({
         filterBySetting: types.frozen(),
         colorBySetting: types.frozen(),
     })
         .volatile(() => ({
-        loading: false,
         chainData: undefined,
-        lastDrawnOffsetPx: undefined,
         lastDrawnBpPerPx: 0,
-        ref: null,
     }))
         .actions(self => ({
-        setLastDrawnOffsetPx(n) {
-            self.lastDrawnOffsetPx = n;
-        },
         setLastDrawnBpPerPx(n) {
             self.lastDrawnBpPerPx = n;
         },
-        setLoading(f) {
-            self.loading = f;
-        },
-        setRef(ref) {
-            self.ref = ref;
-        },
         setColorScheme(colorBy) {
             self.colorBySetting = {
                 ...colorBy,
@@ -38,10 +27,5 @@ export function LinearReadDisplayBaseMixin() {
                 ...filter,
             };
         },
-    }))
-        .views(self => ({
-        get drawn() {
-            return self.lastDrawnOffsetPx !== undefined;
-        },
-    }));
+    })));
 }

package/esm/shared/LinearReadDisplayWithLayoutMixin.d.ts

@@ -1,11 +1,16 @@
-import type { FlatbushEntry } from './flatbushType';
+import type { FlatbushEntry } from './flatbushType.ts';
+import type { FlatbushItem } from '../PileupRenderer/types.ts';
 import type Flatbush from '@jbrowse/core/util/flatbush';
-export declare function LinearReadDisplayWithLayoutMixin(): import("mobx-state-tree").IModelType<{}, {
+export declare function LinearReadDisplayWithLayoutMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
     featureLayout: Flatbush | undefined;
     mouseoverRef: HTMLCanvasElement | null;
     featuresForFlatbush: FlatbushEntry[];
+    mismatchLayout: Flatbush | undefined;
+    mismatchItems: FlatbushItem[];
 } & {
     setFeatureLayout(layout: Flatbush): void;
     setMouseoverRef(ref: HTMLCanvasElement | null): void;
     setFeaturesForFlatbush(features: FlatbushEntry[]): void;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+    setMismatchLayout(layout: Flatbush): void;
+    setMismatchItems(items: FlatbushItem[]): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/shared/LinearReadDisplayWithLayoutMixin.js

@@ -1,4 +1,4 @@
-import { types } from 'mobx-state-tree';
+import { types } from '@jbrowse/mobx-state-tree';
 export function LinearReadDisplayWithLayoutMixin() {
     return types
         .model('LinearReadDisplayWithLayoutMixin', {})
@@ -6,6 +6,8 @@ export function LinearReadDisplayWithLayoutMixin() {
         featureLayout: undefined,
         mouseoverRef: null,
         featuresForFlatbush: [],
+        mismatchLayout: undefined,
+        mismatchItems: [],
     }))
         .actions(self => ({
         setFeatureLayout(layout) {
@@ -17,5 +19,11 @@ export function LinearReadDisplayWithLayoutMixin() {
         setFeaturesForFlatbush(features) {
             self.featuresForFlatbush = features;
         },
+        setMismatchLayout(layout) {
+            self.mismatchLayout = layout;
+        },
+        setMismatchItems(items) {
+            self.mismatchItems = items;
+        },
     }));
 }

package/esm/shared/LinearReadDisplayWithPairFiltersMixin.d.ts

@@ -1,11 +1,11 @@
-export declare function LinearReadDisplayWithPairFiltersMixin(): import("mobx-state-tree").IModelType<{
-    drawSingletons: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    drawProperPairs: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    flipStrandLongReadChains: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
-    featureHeight: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+export declare function LinearReadDisplayWithPairFiltersMixin(): import("@jbrowse/mobx-state-tree").IModelType<{
+    drawSingletons: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    drawProperPairs: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    flipStrandLongReadChains: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    featureHeight: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
 }, {
     setDrawSingletons(f: boolean): void;
     setDrawProperPairs(f: boolean): void;
     setFlipStrandLongReadChains(f: boolean): void;
     setFeatureHeight(n?: number): void;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/shared/LinearReadDisplayWithPairFiltersMixin.js

@@ -1,4 +1,4 @@
-import { types } from 'mobx-state-tree';
+import { types } from '@jbrowse/mobx-state-tree';
 export function LinearReadDisplayWithPairFiltersMixin() {
     return types
         .model('LinearReadDisplayWithPairFiltersMixin', {

package/esm/shared/SharedModificationsMixin.d.ts

@@ -0,0 +1,12 @@
+import type { ModificationType, ModificationTypeWithColor } from './types.ts';
+export declare function SharedModificationsMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    visibleModifications: import("mobx").ObservableMap<string, ModificationTypeWithColor>;
+    simplexModifications: Set<string>;
+    modificationsReady: boolean;
+} & {
+    readonly visibleModificationTypes: string[];
+} & {
+    updateVisibleModifications(uniqueModifications: ModificationType[]): void;
+    setSimplexModifications(simplex: string[]): void;
+    setModificationsReady(flag: boolean): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/shared/SharedModificationsMixin.js

@@ -0,0 +1,40 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { observable } from 'mobx';
+import { getColorForModification } from "../util.js";
+export function SharedModificationsMixin() {
+    return types
+        .model({})
+        .volatile(() => ({
+        visibleModifications: observable.map({}),
+        simplexModifications: new Set(),
+        modificationsReady: false,
+    }))
+        .views(self => ({
+        get visibleModificationTypes() {
+            return [...self.visibleModifications.keys()];
+        },
+    }))
+        .actions(self => ({
+        updateVisibleModifications(uniqueModifications) {
+            for (const modification of uniqueModifications) {
+                if (!self.visibleModifications.has(modification.type)) {
+                    self.visibleModifications.set(modification.type, {
+                        ...modification,
+                        color: getColorForModification(modification.type),
+                    });
+                }
+            }
+        },
+        setSimplexModifications(simplex) {
+            const currentSet = self.simplexModifications;
+            if (simplex.length === currentSet.size &&
+                simplex.every(s => currentSet.has(s))) {
+                return;
+            }
+            self.simplexModifications = new Set(simplex);
+        },
+        setModificationsReady(flag) {
+            self.modificationsReady = flag;
+        },
+    }));
+}

package/esm/shared/afterAttach.d.ts

@@ -1,2 +1,2 @@
-import type { IAnyStateTreeNode } from 'mobx-state-tree';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
 export declare function doAfterAttach<T extends IAnyStateTreeNode>(self: T, cb: (self: T, ctx: CanvasRenderingContext2D, width: number, height: number) => void): void;

package/esm/shared/afterAttach.js

@@ -1,10 +1,6 @@
 import { getContainingView } from '@jbrowse/core/util';
-import { createAutorun } from '../util';
-import { fetchChains } from './fetchChains';
+import { createAutorun } from "../util.js";
 export function doAfterAttach(self, cb) {
-    createAutorun(self, async () => {
-        await fetchChains(self);
-    }, { delay: 1000 });
     function draw(view) {
         const canvas = self.ref;
         if (!canvas) {

package/esm/shared/arcUtils.d.ts

@@ -0,0 +1,20 @@
+import type { Feature } from '@jbrowse/core/util';
+export interface CoreFeat {
+    strand: number;
+    refName: string;
+    start: number;
+    end: number;
+    tlen?: number;
+    pair_orientation?: string;
+    next_ref?: string;
+}
+export declare function jitter(n: number): number;
+export declare function drawVerticalLine(ctx: CanvasRenderingContext2D, x: number, height: number, color: string): void;
+export declare function extractCoreFeat(f: Feature): CoreFeat;
+export declare function extractCoreFeatBasic(f: Feature): CoreFeat;
+export declare function getStrandRelativeFirstClipLength(f: Feature | CoreFeat): any;
+export declare function toCoreFeat(f: Feature | CoreFeat): CoreFeat;
+export declare function toCoreFeatBasic(f: Feature | CoreFeat): CoreFeat;
+export declare function getMateInfo(f: Feature): CoreFeat;
+export declare function filterPairedChain(chain: Feature[]): Feature[];
+export declare function filterAndSortLongReadChain(chain: Feature[]): Feature[];