@jbrowse/plugin-alignments 2.16.1 → 2.18.0

package/{dist/LinearSNPCoverageDisplay/models → esm/LinearSNPCoverageDisplay}/model.d.ts

@@ -1,10 +1,6 @@
-import PluginManager from '@jbrowse/core/PluginManager';
-import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
-/**
- * #stateModel LinearSNPCoverageDisplay
- * extends
- * - [LinearWiggleDisplay](../linearwiggledisplay)
- */
+import type { ColorBy, FilterBy } from '../shared/types';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
 declare function stateModelFactory(pluginManager: PluginManager, configSchema: AnyConfigurationSchemaType): import("mobx-state-tree").IModelType<{
     id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
     type: import("mobx-state-tree").ISimpleType<string>;
@@ -17,21 +13,12 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
 } & {
     blockState: import("mobx-state-tree").IMapType<import("mobx-state-tree").IModelType<{
         key: import("mobx-state-tree").ISimpleType<string>;
-        region: import("mobx-state-tree").IModelType<{
-            refName: import("mobx-state-tree").ISimpleType<string>;
-            start: import("mobx-state-tree").ISimpleType<number>;
-            end: import("mobx-state-tree").ISimpleType<number>;
-            reversed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
-        } & {
-            assemblyName: import("mobx-state-tree").ISimpleType<string>;
-        }, {
-            setRefName(newRefName: string): void;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+        region: import("mobx-state-tree").IType<import("@jbrowse/core/util").Region, import("@jbrowse/core/util").Region, import("@jbrowse/core/util").Region>;
         reloadFlag: import("mobx-state-tree").IType<number | undefined, number, number>;
         isLeftEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
         isRightEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     }, {
-        renderInProgress: AbortController | undefined;
+        stopToken: string | undefined;
         filled: boolean;
         reactElement: React.ReactElement | undefined;
         features: Map<string, import("@jbrowse/core/util").Feature> | undefined;
@@ -55,15 +42,9 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
         doReload(): void;
         afterAttach(): void;
         setStatus(message: string): void;
-        setLoading(abortController: AbortController): void;
+        setLoading(newStopToken: string): void;
         setMessage(messageText: string): void;
-        setRendered(props: {
-            reactElement: React.ReactElement;
-            features: Map<string, import("@jbrowse/core/util").Feature>;
-            layout: any;
-            maxHeightReached: boolean;
-            renderProps: any;
-        } | undefined): void;
+        setRendered(props: import("@jbrowse/plugin-linear-genome-view/src/BaseLinearDisplay/models/serverSideRenderedBlock").RenderedProps | undefined): void;
         setError(error: unknown): void;
         reload(): void;
         beforeDestroy(): void;
@@ -117,44 +98,12 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
 } & {
     type: import("mobx-state-tree").ISimpleType<"LinearWiggleDisplay">;
 } & {
-    /**
-     * #property
-     */
     type: import("mobx-state-tree").ISimpleType<"LinearSNPCoverageDisplay">;
-    /**
-     * #property
-     */
     drawInterbaseCounts: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<boolean>>;
-    /**
-     * #property
-     */
     drawIndicators: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<boolean>>;
-    /**
-     * #property
-     */
     drawArcs: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<boolean>>;
-    /**
-     * #property
-     */
-    filterBy: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IModelType<{
-        flagInclude: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>;
-        flagExclude: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>;
-        readName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-        tagFilter: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IModelType<{
-            tag: import("mobx-state-tree").ISimpleType<string>;
-            value: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-        }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-    }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>, [undefined]>;
-    /**
-     * #property
-     */
-    colorBy: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IModelType<{
-        type: import("mobx-state-tree").ISimpleType<string>;
-        tag: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-    /**
-     * #property
-     */
+    filterBySetting: import("mobx-state-tree").IType<FilterBy | undefined, FilterBy | undefined, FilterBy | undefined>;
+    colorBySetting: import("mobx-state-tree").IType<ColorBy | undefined, ColorBy | undefined, ColorBy | undefined>;
     jexlFilters: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
 }, never, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type SNPCoverageDisplayModel = ReturnType<typeof stateModelFactory>;

package/esm/LinearSNPCoverageDisplay/{models/model.js → model.js}

@@ -1,193 +1,121 @@
 import { lazy } from 'react';
-import { types, cast, getEnv, getSnapshot, isAlive } from 'mobx-state-tree';
-import { observable } from 'mobx';
-import { getConf, readConfObject, } from '@jbrowse/core/configuration';
-import { linearWiggleDisplayModelFactory } from '@jbrowse/plugin-wiggle';
-import { getContainingView } from '@jbrowse/core/util';
+import { getConf, readConfObject } from '@jbrowse/core/configuration';
 import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain';
-// locals
-import { FilterModel, getUniqueModificationValues } from '../../shared';
-import { createAutorun, modificationColors } from '../../util';
-import { randomColor } from '../../util';
-// lazies
-const Tooltip = lazy(() => import('../components/Tooltip'));
-// using a map because it preserves order
+import { getContainingView } from '@jbrowse/core/util';
+import { linearWiggleDisplayModelFactory } from '@jbrowse/plugin-wiggle';
+import { observable } from 'mobx';
+import { cast, getEnv, isAlive, types } from 'mobx-state-tree';
+import { getUniqueModifications } from '../shared/getUniqueModifications';
+import { createAutorun, getColorForModification } from '../util';
+const Tooltip = lazy(() => import('./components/Tooltip'));
 const rendererTypes = new Map([['snpcoverage', 'SNPCoverageRenderer']]);
-/**
- * #stateModel LinearSNPCoverageDisplay
- * extends
- * - [LinearWiggleDisplay](../linearwiggledisplay)
- */
 function stateModelFactory(pluginManager, configSchema) {
     return types
         .compose('LinearSNPCoverageDisplay', linearWiggleDisplayModelFactory(pluginManager, configSchema), types.model({
-        /**
-         * #property
-         */
         type: types.literal('LinearSNPCoverageDisplay'),
-        /**
-         * #property
-         */
         drawInterbaseCounts: types.maybe(types.boolean),
-        /**
-         * #property
-         */
         drawIndicators: types.maybe(types.boolean),
-        /**
-         * #property
-         */
         drawArcs: types.maybe(types.boolean),
-        /**
-         * #property
-         */
-        filterBy: types.optional(FilterModel, {}),
-        /**
-         * #property
-         */
-        colorBy: types.maybe(types.model({
-            type: types.string,
-            tag: types.maybe(types.string),
-        })),
-        /**
-         * #property
-         */
+        filterBySetting: types.frozen(),
+        colorBySetting: types.frozen(),
         jexlFilters: types.optional(types.array(types.string), []),
     }))
         .volatile(() => ({
-        modificationTagMap: observable.map({}),
+        visibleModifications: observable.map({}),
         modificationsReady: false,
+    }))
+        .views(self => ({
+        get colorBy() {
+            var _a;
+            return (_a = self.colorBySetting) !== null && _a !== void 0 ? _a : getConf(self, 'colorBy');
+        },
+        get filterBy() {
+            var _a;
+            return (_a = self.filterBySetting) !== null && _a !== void 0 ? _a : getConf(self, 'filterBy');
+        },
     }))
         .actions(self => ({
-        /**
-         * #action
-         */
         setConfig(configuration) {
             self.configuration = configuration;
         },
-        /**
-         * #action
-         */
         setFilterBy(filter) {
-            self.filterBy = cast(filter);
+            self.filterBySetting = {
+                ...filter,
+            };
         },
-        /**
-         * #action
-         */
-        setColorBy(colorBy) {
-            self.colorBy = cast(colorBy);
+        setColorScheme(colorBy) {
+            self.colorBySetting = colorBy
+                ? {
+                    ...colorBy,
+                }
+                : undefined;
         },
-        /**
-         * #action
-         */
         setJexlFilters(filters) {
             self.jexlFilters = cast(filters);
         },
-        /**
-         * #action
-         */
-        updateModificationColorMap(uniqueModifications) {
-            uniqueModifications.forEach(value => {
-                if (!self.modificationTagMap.has(value)) {
-                    self.modificationTagMap.set(value, modificationColors[value] || randomColor(value));
+        updateVisibleModifications(uniqueModifications) {
+            for (const modification of uniqueModifications) {
+                if (!self.visibleModifications.has(modification.type)) {
+                    self.visibleModifications.set(modification.type, {
+                        ...modification,
+                        color: getColorForModification(modification.type),
+                    });
                 }
-            });
+            }
         },
     }))
         .views(self => {
-        const { renderProps: superRenderProps } = self;
+        const { adapterProps: superAdapterProps } = self;
         return {
-            /**
-             * #getter
-             */
             get rendererConfig() {
-                var _a, _b, _c;
                 const configBlob = getConf(self, ['renderers', self.rendererTypeName]) || {};
+                const { drawArcs, drawInterbaseCounts, drawIndicators } = self;
                 return self.rendererType.configSchema.create({
                     ...configBlob,
-                    drawInterbaseCounts: (_a = self.drawInterbaseCounts) !== null && _a !== void 0 ? _a : configBlob.drawInterbaseCounts,
-                    drawIndicators: (_b = self.drawIndicators) !== null && _b !== void 0 ? _b : configBlob.drawIndicators,
-                    drawArcs: (_c = self.drawArcs) !== null && _c !== void 0 ? _c : configBlob.drawArcs,
+                    drawInterbaseCounts: drawInterbaseCounts !== null && drawInterbaseCounts !== void 0 ? drawInterbaseCounts : configBlob.drawInterbaseCounts,
+                    drawIndicators: drawIndicators !== null && drawIndicators !== void 0 ? drawIndicators : configBlob.drawIndicators,
+                    drawArcs: drawArcs !== null && drawArcs !== void 0 ? drawArcs : configBlob.drawArcs,
                 }, getEnv(self));
             },
-            /**
-             * #getter
-             */
             get drawArcsSetting() {
                 var _a;
                 return ((_a = self.drawArcs) !== null && _a !== void 0 ? _a : readConfObject(this.rendererConfig, 'drawArcs'));
             },
-            /**
-             * #getter
-             */
             get drawInterbaseCountsSetting() {
                 var _a;
                 return ((_a = self.drawInterbaseCounts) !== null && _a !== void 0 ? _a : readConfObject(this.rendererConfig, 'drawInterbaseCounts'));
             },
-            /**
-             * #getter
-             */
             get drawIndicatorsSetting() {
                 var _a;
                 return ((_a = self.drawIndicators) !== null && _a !== void 0 ? _a : readConfObject(this.rendererConfig, 'drawIndicators'));
             },
-            /**
-             * #getter
-             */
             get autorunReady() {
                 const view = getContainingView(self);
                 return (view.initialized &&
-                    self.featureDensityStatsReady &&
-                    !self.regionTooLarge &&
+                    self.statsReadyAndRegionNotTooLarge &&
                     !self.error);
             },
-            get renderReady() {
-                const superProps = superRenderProps();
-                return !superProps.notReady && self.modificationsReady;
-            },
-            get ready() {
-                return this.renderReady;
-            },
-            /**
-             * #method
-             */
-            renderProps() {
-                const superProps = superRenderProps();
-                const { colorBy, filterBy, modificationTagMap } = self;
+            adapterProps() {
+                const superProps = superAdapterProps();
+                const { filters, filterBy } = self;
                 return {
                     ...superProps,
-                    notReady: !this.ready,
-                    filters: self.filters,
-                    modificationTagMap: Object.fromEntries(modificationTagMap.toJSON()),
-                    // must use getSnapshot because otherwise changes to e.g. just the
-                    // colorBy.type are not read
-                    colorBy: colorBy ? getSnapshot(colorBy) : undefined,
-                    filterBy: getSnapshot(filterBy),
+                    filters,
+                    filterBy,
                 };
             },
         };
     })
         .actions(self => ({
-        /**
-         * #action
-         */
         setModificationsReady(flag) {
             self.modificationsReady = flag;
         },
-        /**
-         * #action
-         */
         toggleDrawIndicators() {
             self.drawIndicators = !self.drawIndicatorsSetting;
         },
-        /**
-         * #action
-         */
         toggleDrawInterbaseCounts() {
             self.drawInterbaseCounts = !self.drawInterbaseCountsSetting;
         },
-        /**
-         * #action
-         */
         toggleDrawArcs() {
             self.drawArcs = !self.drawArcsSetting;
         },
@@ -203,14 +131,13 @@ function stateModelFactory(pluginManager, configSchema) {
                 const { staticBlocks } = view;
                 const { colorBy } = self;
                 if ((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'modifications') {
-                    const adapter = getConf(self.parentTrack, 'adapter');
-                    const vals = await getUniqueModificationValues({
+                    const vals = await getUniqueModifications({
                         self,
-                        adapterConfig: adapter,
+                        adapterConfig: getConf(self.parentTrack, 'adapter'),
                         blocks: staticBlocks,
                     });
                     if (isAlive(self)) {
-                        self.updateModificationColorMap(vals);
+                        self.updateVisibleModifications(vals);
                         self.setModificationsReady(true);
                     }
                 }
@@ -221,17 +148,27 @@ function stateModelFactory(pluginManager, configSchema) {
         },
     }))
         .views(self => {
-        const { trackMenuItems: superTrackMenuItems } = self;
+        const { renderProps: superRenderProps, trackMenuItems: superTrackMenuItems, } = self;
         return {
-            /**
-             * #getter
-             */
+            get renderReady() {
+                const superProps = superRenderProps();
+                return !superProps.notReady && self.modificationsReady;
+            },
+            get ready() {
+                return this.renderReady;
+            },
+            renderProps() {
+                const { colorBy, visibleModifications } = self;
+                return {
+                    ...superRenderProps(),
+                    notReady: !this.ready,
+                    colorBy,
+                    visibleModifications: Object.fromEntries(visibleModifications.toJSON()),
+                };
+            },
             get TooltipComponent() {
                 return Tooltip;
             },
-            /**
-             * #getter
-             */
             get adapterConfig() {
                 const subadapter = getConf(self.parentTrack, 'adapter');
                 return {
@@ -239,27 +176,15 @@ function stateModelFactory(pluginManager, configSchema) {
                     subadapter,
                 };
             },
-            /**
-             * #getter
-             */
             get rendererTypeName() {
                 return rendererTypes.get('snpcoverage');
             },
-            /**
-             * #getter
-             */
             get needsScalebar() {
                 return true;
             },
-            /**
-             * #method
-             */
             contextMenuItems() {
                 return [];
             },
-            /**
-             * #method
-             */
             trackMenuItems() {
                 return [
                     ...superTrackMenuItems(),
@@ -289,9 +214,6 @@ function stateModelFactory(pluginManager, configSchema) {
                     },
                 ];
             },
-            /**
-             * #getter
-             */
             get filters() {
                 return new SerializableFilterChain({ filters: self.jexlFilters });
             },

package/esm/MismatchParser/cigarToMismatches.d.ts

@@ -0,0 +1,3 @@
+import type { Mismatch } from '../shared/types';
+import type { Buffer } from 'buffer';
+export declare function cigarToMismatches(ops: string[], seq?: string, ref?: string, qual?: Buffer): Mismatch[];

package/esm/MismatchParser/cigarToMismatches.js

@@ -0,0 +1,88 @@
+export function cigarToMismatches(ops, seq, ref, qual) {
+    let roffset = 0;
+    let soffset = 0;
+    const mismatches = [];
+    const hasRefAndSeq = ref && seq;
+    for (let i = 0; i < ops.length; i += 2) {
+        const len = +ops[i];
+        const op = ops[i + 1];
+        if (op === 'M' || op === '=' || op === 'E') {
+            if (hasRefAndSeq) {
+                for (let j = 0; j < len; j++) {
+                    if (seq[soffset + j].toUpperCase() !== ref[roffset + j].toUpperCase()) {
+                        mismatches.push({
+                            start: roffset + j,
+                            type: 'mismatch',
+                            base: seq[soffset + j],
+                            altbase: ref[roffset + j],
+                            length: 1,
+                        });
+                    }
+                }
+            }
+            soffset += len;
+        }
+        if (op === 'I') {
+            mismatches.push({
+                start: roffset,
+                type: 'insertion',
+                base: `${len}`,
+                length: 0,
+            });
+            soffset += len;
+        }
+        else if (op === 'D') {
+            mismatches.push({
+                start: roffset,
+                type: 'deletion',
+                base: '*',
+                length: len,
+            });
+        }
+        else if (op === 'N') {
+            mismatches.push({
+                start: roffset,
+                type: 'skip',
+                base: 'N',
+                length: len,
+            });
+        }
+        else if (op === 'X') {
+            const r = (seq === null || seq === void 0 ? void 0 : seq.slice(soffset, soffset + len)) || [];
+            const q = (qual === null || qual === void 0 ? void 0 : qual.subarray(soffset, soffset + len)) || [];
+            for (let j = 0; j < len; j++) {
+                mismatches.push({
+                    start: roffset + j,
+                    type: 'mismatch',
+                    base: r[j] || 'X',
+                    qual: q[j],
+                    length: 1,
+                });
+            }
+            soffset += len;
+        }
+        else if (op === 'H') {
+            mismatches.push({
+                start: roffset,
+                type: 'hardclip',
+                base: `H${len}`,
+                cliplen: len,
+                length: 1,
+            });
+        }
+        else if (op === 'S') {
+            mismatches.push({
+                start: roffset,
+                type: 'softclip',
+                base: `S${len}`,
+                cliplen: len,
+                length: 1,
+            });
+            soffset += len;
+        }
+        if (op !== 'I' && op !== 'S' && op !== 'H') {
+            roffset += len;
+        }
+    }
+    return mismatches;
+}

package/esm/MismatchParser/getNextRefPos.d.ts

@@ -0,0 +1,4 @@
+export declare function getNextRefPos(cigarOps: string[], positions: number[]): {
+    ref: number;
+    idx: number;
+}[];

package/esm/MismatchParser/getNextRefPos.js

@@ -0,0 +1,35 @@
+export function getNextRefPos(cigarOps, positions) {
+    let readPos = 0;
+    let refPos = 0;
+    let currPos = 0;
+    const ret = [];
+    for (let i = 0; i < cigarOps.length && currPos < positions.length; i += 2) {
+        const len = +cigarOps[i];
+        const op = cigarOps[i + 1];
+        if (op === 'S' || op === 'I') {
+            for (let i = 0; i < len && currPos < positions.length; i++) {
+                if (positions[currPos] === readPos + i) {
+                    currPos++;
+                }
+            }
+            readPos += len;
+        }
+        else if (op === 'D' || op === 'N') {
+            refPos += len;
+        }
+        else if (op === 'M' || op === 'X' || op === '=') {
+            for (let i = 0; i < len && currPos < positions.length; i++) {
+                if (positions[currPos] === readPos + i) {
+                    ret.push({
+                        ref: refPos + i,
+                        idx: currPos,
+                    });
+                    currPos++;
+                }
+            }
+            readPos += len;
+            refPos += len;
+        }
+    }
+    return ret;
+}

package/esm/MismatchParser/index.d.ts

@@ -1,41 +1,15 @@
-import { Feature } from '@jbrowse/core/util';
+import type { Mismatch } from '../shared/types';
+import type { Feature } from '@jbrowse/core/util';
 import type { Buffer } from 'buffer';
-export interface Mismatch {
-    qual?: number;
-    start: number;
-    length: number;
-    type: string;
-    base: string;
-    altbase?: string;
-    seq?: string;
-    cliplen?: number;
-}
 export declare function parseCigar(cigar?: string): string[];
-export declare function cigarToMismatches(ops: string[], seq?: string, ref?: string, qual?: Buffer): Mismatch[];
-/**
- * parse a SAM MD tag to find mismatching bases of the template versus the
- * reference @returns array of mismatches and their positions
- */
-export declare function mdToMismatches(mdstring: string, ops: string[], cigarMismatches: Mismatch[], seq: string, qual?: Buffer): Mismatch[];
-export declare function getMismatches(cigar: string, md?: string, seq?: string, ref?: string, qual?: Buffer): Mismatch[];
-export declare function getNextRefPos(cigarOps: string[], positions: number[]): Generator<number, void, unknown>;
-export declare function getModificationProbabilities(feature: Feature): number[] | undefined;
-export declare function getMethBins(feature: Feature): {
-    methBins: number[];
-    methProbs: number[];
-};
-export declare function getModificationPositions(mm: string, fseq: string, fstrand: number): {
-    type: string;
-    positions: number[];
-}[];
-export declare function getModificationTypes(mm: string): string[];
+export declare function getMismatches(cigar?: string, md?: string, seq?: string, ref?: string, qual?: Buffer): Mismatch[];
 export declare function getOrientedCigar(flip: boolean, cigar: string[]): string[];
 export declare function getOrientedMismatches(flip: boolean, cigar: string): Mismatch[];
 export declare function getLengthOnRef(cigar: string): number;
 export declare function getLength(cigar: string): number;
 export declare function getLengthSansClipping(cigar: string): number;
 export declare function getClip(cigar: string, strand: number): number;
-export declare function getTag(f: Feature, tag: string): any;
+export declare function getTag(feature: Feature, tag: string): any;
 export declare function featurizeSA(SA: string | undefined, id: string, strand: number, readName: string, normalize?: boolean): {
     refName: string;
     start: number;
@@ -51,3 +25,4 @@ export declare function featurizeSA(SA: string | undefined, id: string, strand:
         refName: string;
     };
 }[];
+export { getNextRefPos } from './getNextRefPos';