@jbrowse/plugin-alignments 2.16.0 → 2.17.0

package/esm/LinearReadCloudDisplay/components/ReactComponent.js

@@ -1,7 +1,7 @@
 import React, { useCallback } from 'react';
 import { observer } from 'mobx-react';
 import { getContainingView } from '@jbrowse/core/util';
-import BaseDisplayComponent from '../../shared/BaseDisplayComponent';
+import BaseDisplayComponent from '../../shared/components/BaseDisplayComponent';
 const Cloud = observer(function ({ model, }) {
     const view = getContainingView(model);
     const width = Math.round(view.dynamicBlocks.totalWidthPx);

package/esm/LinearReadCloudDisplay/model.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { Instance } from 'mobx-state-tree';
 import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
-import { IFilter } from '../shared';
+import { ColorBy, FilterBy } from '../shared/types';
 import { ChainData } from '../shared/fetchChains';
 /**
  * #stateModel LinearReadCloudDisplay
@@ -23,20 +23,8 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
 } & {
     type: import("mobx-state-tree").ISimpleType<"LinearReadCloudDisplay">;
     configuration: AnyConfigurationSchemaType;
-    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]>;
-    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>>;
-        extra: import("mobx-state-tree").IType<any, any, any>;
-    }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    filterBy: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<FilterBy, FilterBy, FilterBy>, [undefined]>;
+    colorBy: import("mobx-state-tree").IType<ColorBy | undefined, ColorBy | undefined, ColorBy | undefined>;
     drawSingletons: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
 }, {
     rendererTypeName: string;
@@ -55,9 +43,7 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
         } & import("mobx-state-tree").IStateTreeNode<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>;
-            rpcDriverName: import("mobx-state-tree" /**
-             * #property
-             */).IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
             error: unknown;
@@ -76,14 +62,20 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
             error: unknown;
             message: string | undefined;
         } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+            id: import(
+            /**
+             * #action
+             */
+            "mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
             type: import("mobx-state-tree").ISimpleType<string>;
             rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
             error: unknown;
             message: string | undefined;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+        }, import("mobx-state-tree" /**
+         * #action
+         */)._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
     }> | null;
     readonly adapterConfig: any;
     readonly parentTrack: any;
@@ -164,7 +156,7 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
      * the canvas
      */
     setRef(ref: HTMLCanvasElement | null): void;
-    setColorScheme(s: {
+    setColorScheme(colorBy: {
         type: string;
     }): void;
     /**
@@ -174,7 +166,7 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
     /**
      * #action
      */
-    setFilterBy(filter: IFilter): void;
+    setFilterBy(filter: FilterBy): void;
 } & {
     readonly drawn: boolean;
 } & {

package/esm/LinearReadCloudDisplay/model.js

@@ -1,5 +1,5 @@
 import { lazy } from 'react';
-import { cast, types } from 'mobx-state-tree';
+import { types } from 'mobx-state-tree';
 import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes';
 import { ConfigurationReference, } from '@jbrowse/core/configuration';
 import { getSession } from '@jbrowse/core/util';
@@ -7,10 +7,9 @@ import { FeatureDensityMixin, TrackHeightMixin, } from '@jbrowse/plugin-linear-g
 // icons
 import PaletteIcon from '@mui/icons-material/Palette';
 import FilterListIcon from '@mui/icons-material/ClearAll';
-// locals
-import { FilterModel } from '../shared';
+import { defaultFilterFlags } from '../shared/util';
 // async
-const FilterByTagDialog = lazy(() => import('../shared/FilterByTagDialog'));
+const FilterByTagDialog = lazy(() => import('../shared/components/FilterByTagDialog'));
 /**
  * #stateModel LinearReadCloudDisplay
  * it is not a block based track, hence not BaseLinearDisplay
@@ -33,15 +32,11 @@ function stateModelFactory(configSchema) {
         /**
          * #property
          */
-        filterBy: types.optional(FilterModel, {}),
+        filterBy: types.optional(types.frozen(), defaultFilterFlags),
         /**
          * #property
          */
-        colorBy: types.maybe(types.model({
-            type: types.string,
-            tag: types.maybe(types.string),
-            extra: types.frozen(),
-        })),
+        colorBy: types.frozen(),
         /**
          * #property
          */
@@ -93,8 +88,10 @@ function stateModelFactory(configSchema) {
         setRef(ref) {
             self.ref = ref;
         },
-        setColorScheme(s) {
-            self.colorBy = cast(s);
+        setColorScheme(colorBy) {
+            self.colorBy = {
+                ...colorBy,
+            };
         },
         /**
          * #action
@@ -106,7 +103,9 @@ function stateModelFactory(configSchema) {
          * #action
          */
         setFilterBy(filter) {
-            self.filterBy = cast(filter);
+            self.filterBy = {
+                ...filter,
+            };
         },
     }))
         .views(self => ({
@@ -185,7 +184,7 @@ function stateModelFactory(configSchema) {
              * #method
              */
             async renderSvg(opts) {
-                const { renderSvg } = await import('../shared/renderSvg');
+                const { renderSvg } = await import('../shared/renderSvgUtil');
                 const { drawFeats } = await import('./drawFeats');
                 return renderSvg(self, opts, drawFeats);
             },

package/esm/LinearSNPCoverageDisplay/components/Tooltip.js

@@ -2,13 +2,21 @@ import React from 'react';
 import { observer } from 'mobx-react';
 import { toLocale } from '@jbrowse/core/util';
 import { Tooltip } from '@jbrowse/plugin-wiggle';
+import { makeStyles } from 'tss-react/mui';
+const useStyles = makeStyles()(() => ({
+    td: {
+        whiteSpace: 'nowrap',
+    },
+}));
 const toP = (s = 0) => +(+s).toFixed(1);
-const pct = (n, total) => `${toP((n / (total || 1)) * 100)}%`;
-const TooltipContents = React.forwardRef(function TooltipContents2({ feature }, reactRef) {
-    const start = feature.get('start');
+const pct = (n, total = 1) => `${toP((n / (total || 1)) * 100)}%`;
+const TooltipContents = React.forwardRef(function TooltipContents2(props, reactRef) {
+    const { feature, model } = props;
+    const { classes } = useStyles();
+    const start = feature.get('start') + 1;
     const end = feature.get('end');
     const name = feature.get('refName');
-    const { refbase, all, total, ref, '-1': rn1, '1': r1, '0': r0, ...info } = feature.get('snpinfo');
+    const { refbase, readsCounted, depth, ref, ...info } = feature.get('snpinfo');
     const loc = [
         name,
         start === end ? toLocale(start) : `${toLocale(start)}..${toLocale(end)}`,
@@ -20,36 +28,58 @@ const TooltipContents = React.forwardRef(function TooltipContents2({ feature },
             React.createElement("caption", null, loc),
             React.createElement("thead", null,
                 React.createElement("tr", null,
+                    React.createElement("th", null),
                     React.createElement("th", null, "Base"),
                     React.createElement("th", null, "Count"),
                     React.createElement("th", null, "% of Total"),
-                    React.createElement("th", null, "Strands"),
-                    React.createElement("th", null, "Source"))),
+                    React.createElement("th", null, "Strands"))),
             React.createElement("tbody", null,
                 React.createElement("tr", null,
+                    React.createElement("td", null),
                     React.createElement("td", null, "Total"),
-                    React.createElement("td", null, all)),
+                    React.createElement("td", null, readsCounted),
+                    React.createElement("td", null, " "),
+                    React.createElement("td", null, " ")),
                 React.createElement("tr", null,
+                    React.createElement("td", null),
                     React.createElement("td", null,
                         "REF ",
                         refbase ? `(${refbase.toUpperCase()})` : ''),
-                    React.createElement("td", null, ref),
-                    React.createElement("td", null, pct(ref, all)),
+                    React.createElement("td", null, ref.entryDepth),
+                    React.createElement("td", null, pct(ref.entryDepth, readsCounted)),
                     React.createElement("td", null,
-                        rn1 ? `${rn1}(-)` : '',
-                        r1 ? `${r1}(+)` : ''),
-                    React.createElement("td", null)),
-                Object.entries(info).map(([key, entry]) => Object.entries(entry).map(([base, score]) => (React.createElement("tr", { key: base },
-                    React.createElement("td", null, base.toUpperCase()),
-                    React.createElement("td", null, score.total),
-                    React.createElement("td", null, base === 'total' || base === 'skip'
+                        ref['-1'] ? `${ref['-1']}(-)` : '',
+                        ref['1'] ? `${ref['1']}(+)` : '')),
+                Object.entries(info).map(([key, entry]) => Object.entries(entry).map(([base, score]) => (React.createElement("tr", { key: `${key}_${base}` },
+                    React.createElement("td", null,
+                        React.createElement(ColorSquare, { model: model, base: base })),
+                    React.createElement("td", null,
+                        base.toUpperCase(),
+                        " "),
+                    React.createElement("td", { className: classes.td }, [
+                        score.entryDepth,
+                        score.avgProbability !== undefined
+                            ? `(avg. ${pct(score.avgProbability)} prob.)`
+                            : '',
+                    ]
+                        .filter(f => !!f)
+                        .join(' ')),
+                    React.createElement("td", null, base === 'depth' || base === 'skip'
                         ? '---'
-                        : pct(score.total, all)),
+                        : pct(score.entryDepth, readsCounted)),
                     React.createElement("td", null,
                         score['-1'] ? `${score['-1']}(-)` : '',
-                        score['1'] ? `${score['1']}(+)` : ''),
-                    React.createElement("td", null, key)))))))));
+                        score['1'] ? `${score['1']}(+)` : '')))))))));
 });
+function ColorSquare({ base, model, }) {
+    var _a;
+    const { visibleModifications } = model;
+    return base.startsWith('mod_') ? (React.createElement("div", { style: {
+            width: 10,
+            height: 10,
+            background: (_a = visibleModifications.get(base.replace('mod_', ''))) === null || _a === void 0 ? void 0 : _a.color,
+        } })) : null;
+}
 const SNPCoverageTooltip = observer(function (props) {
     const { model } = props;
     const { featureUnderMouse: feat } = model;

package/esm/LinearSNPCoverageDisplay/index.js

@@ -1,7 +1,8 @@
-import configSchemaFactory from './models/configSchema';
-import modelFactory from './models/model';
 import { LinearWiggleDisplayReactComponent } from '@jbrowse/plugin-wiggle';
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
+// locals
+import configSchemaFactory from './configSchema';
+import modelFactory from './model';
 export default function register(pluginManager) {
     pluginManager.addDisplayType(() => {
         const configSchema = configSchemaFactory(pluginManager);

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

@@ -1,5 +1,6 @@
 import PluginManager from '@jbrowse/core/PluginManager';
 import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import { ColorBy, FilterBy } from '../shared/types';
 /**
  * #stateModel LinearSNPCoverageDisplay
  * extends
@@ -136,22 +137,11 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
     /**
      * #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]>;
+    filterBy: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<FilterBy, FilterBy, FilterBy>, [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>>;
+    colorBy: import("mobx-state-tree").IType<ColorBy | undefined, ColorBy | undefined, ColorBy | undefined>;
     /**
      * #property
      */

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

@@ -1,16 +1,15 @@
 import { lazy } from 'react';
-import { types, cast, getEnv, getSnapshot, isAlive } from 'mobx-state-tree';
+import { types, cast, getEnv, 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 SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain';
 // locals
-import { FilterModel, getUniqueModificationValues } from '../../shared';
-import { createAutorun, modificationColors } from '../../util';
-import { randomColor } from '../../util';
+import { createAutorun, getColorForModification } from '../util';
+import { getUniqueModifications } from '../shared/getUniqueModifications';
 // lazies
-const Tooltip = lazy(() => import('../components/Tooltip'));
+const Tooltip = lazy(() => import('./components/Tooltip'));
 // using a map because it preserves order
 const rendererTypes = new Map([['snpcoverage', 'SNPCoverageRenderer']]);
 /**
@@ -40,21 +39,27 @@ function stateModelFactory(pluginManager, configSchema) {
         /**
          * #property
          */
-        filterBy: types.optional(FilterModel, {}),
+        filterBy: types.optional(types.frozen(), {
+            flagInclude: 0,
+            flagExclude: 1540,
+        }),
         /**
          * #property
          */
-        colorBy: types.maybe(types.model({
-            type: types.string,
-            tag: types.maybe(types.string),
-        })),
+        colorBy: types.frozen(),
         /**
          * #property
          */
         jexlFilters: types.optional(types.array(types.string), []),
     }))
         .volatile(() => ({
-        modificationTagMap: observable.map({}),
+        /**
+         * #volatile
+         */
+        visibleModifications: observable.map({}),
+        /**
+         * #volatile
+         */
         modificationsReady: false,
     }))
         .actions(self => ({
@@ -68,13 +73,19 @@ function stateModelFactory(pluginManager, configSchema) {
          * #action
          */
         setFilterBy(filter) {
-            self.filterBy = cast(filter);
+            self.filterBy = {
+                ...filter,
+            };
         },
         /**
          * #action
          */
-        setColorBy(colorBy) {
-            self.colorBy = cast(colorBy);
+        setColorScheme(colorBy) {
+            self.colorBy = colorBy
+                ? {
+                    ...colorBy,
+                }
+                : undefined;
         },
         /**
          * #action
@@ -85,28 +96,31 @@ function stateModelFactory(pluginManager, configSchema) {
         /**
          * #action
          */
-        updateModificationColorMap(uniqueModifications) {
-            uniqueModifications.forEach(value => {
-                if (!self.modificationTagMap.has(value)) {
-                    self.modificationTagMap.set(value, modificationColors[value] || randomColor());
+        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));
             },
             /**
@@ -140,28 +154,16 @@ function stateModelFactory(pluginManager, configSchema) {
                     !self.regionTooLarge &&
                     !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,
                 };
             },
         };
@@ -203,14 +205,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,8 +222,33 @@ 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;
+            },
+            /**
+             * #getter
+             */
+            get ready() {
+                return this.renderReady;
+            },
+            /**
+             * #method
+             */
+            renderProps() {
+                const { colorBy, visibleModifications } = self;
+                return {
+                    ...superRenderProps(),
+                    notReady: !this.ready,
+                    colorBy,
+                    visibleModifications: Object.fromEntries(visibleModifications.toJSON()),
+                };
+            },
             /**
              * #getter
              */

package/esm/MismatchParser/cigarToMismatches.d.ts

@@ -0,0 +1,3 @@
+import { 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,91 @@
+export function cigarToMismatches(ops, seq, ref, qual) {
+    let roffset = 0; // reference offset
+    let soffset = 0; // seq offset
+    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 (
+                    // @ts-ignore in the full yarn build of the repo, this says that
+                    // object is possibly undefined for some reason, ignored
+                    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],
+                    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,37 @@
+// get relative reference sequence positions for positions given relative to
+// the read sequence
+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;
+}