@jbrowse/plugin-alignments 3.7.0 → 4.0.0

package/esm/LinearPileupDisplay/SharedLinearPileupDisplayMixin.js

@@ -1,22 +1,23 @@
 import { lazy } from 'react';
 import { ConfigurationReference, getConf, readConfObject, } from '@jbrowse/core/configuration';
 import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain';
-import { SimpleFeature, getContainingTrack, getContainingView, getEnv, getSession, isSessionModelWithWidgets, } from '@jbrowse/core/util';
+import { SimpleFeature, getContainingTrack, getContainingView, getSession, isSessionModelWithWidgets, } from '@jbrowse/core/util';
 import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { cast, isAlive, types } from '@jbrowse/mobx-state-tree';
 import { BaseLinearDisplay } from '@jbrowse/plugin-linear-genome-view';
 import FilterListIcon from '@mui/icons-material/ClearAll';
 import ContentCopyIcon from '@mui/icons-material/ContentCopy';
 import MenuOpenIcon from '@mui/icons-material/MenuOpen';
-import copy from 'copy-to-clipboard';
-import { autorun, observable } from 'mobx';
-import { addDisposer, cast, isAlive, types } from 'mobx-state-tree';
-import { createAutorun } from '../util';
-import LinearPileupDisplayBlurb from './components/LinearPileupDisplayBlurb';
-import { getUniqueTags } from '../shared/getUniqueTags';
-const FilterByTagDialog = lazy(() => import('../shared/components/FilterByTagDialog'));
-const ColorByTagDialog = lazy(() => import('./components/ColorByTagDialog'));
-const SetFeatureHeightDialog = lazy(() => import('../shared/components/SetFeatureHeightDialog'));
-const SetMaxHeightDialog = lazy(() => import('../shared/components/SetMaxHeightDialog'));
+import VisibilityIcon from '@mui/icons-material/Visibility';
+import { observable } from 'mobx';
+import LinearPileupDisplayBlurb from "./components/LinearPileupDisplayBlurb.js";
+import { getPileupLegendItems } from "../shared/legendUtils.js";
+import { getMismatchDisplayMenuItem } from "../shared/menuItems.js";
+import { isDefaultFilterFlags } from "../shared/util.js";
+const FilterByTagDialog = lazy(() => import("../shared/components/FilterByTagDialog.js"));
+const ColorByTagDialog = lazy(() => import("./components/ColorByTagDialog.js"));
+const SetFeatureHeightDialog = lazy(() => import("../shared/components/SetFeatureHeightDialog.js"));
+const SetMaxHeightDialog = lazy(() => import("../shared/components/SetMaxHeightDialog.js"));
 const rendererTypes = new Map([
     ['pileup', 'PileupRenderer'],
     ['svg', 'SvgFeatureRenderer'],
@@ -33,6 +34,8 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
         filterBySetting: types.frozen(),
         jexlFilters: types.optional(types.array(types.string), []),
         hideSmallIndelsSetting: types.maybe(types.boolean),
+        hideMismatchesSetting: types.maybe(types.boolean),
+        hideLargeIndelsSetting: types.maybe(types.boolean),
     }))
         .volatile(() => ({
         colorTagMap: observable.map({}),
@@ -41,22 +44,26 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
     }))
         .views(self => ({
         get colorBy() {
-            var _a;
-            return (_a = self.colorBySetting) !== null && _a !== void 0 ? _a : getConf(self, 'colorBy');
+            return self.colorBySetting ?? getConf(self, 'colorBy');
         },
         get filterBy() {
-            var _a;
-            return (_a = self.filterBySetting) !== null && _a !== void 0 ? _a : getConf(self, 'filterBy');
+            return self.filterBySetting ?? getConf(self, 'filterBy');
         },
     }))
         .views(self => ({
         get autorunReady() {
             const view = getContainingView(self);
-            return view.initialized && self.statsReadyAndRegionNotTooLarge;
+            return (view.initialized && self.featureDensityStatsReadyAndRegionNotTooLarge);
         },
         get hideSmallIndels() {
             return self.hideSmallIndelsSetting;
         },
+        get hideMismatches() {
+            return self.hideMismatchesSetting;
+        },
+        get hideLargeIndels() {
+            return self.hideLargeIndelsSetting;
+        },
     }))
         .actions(self => ({
         setTagsReady(flag) {
@@ -129,24 +136,33 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
         setHideSmallIndels(arg) {
             self.hideSmallIndelsSetting = arg;
         },
+        setHideMismatches(arg) {
+            self.hideMismatchesSetting = arg;
+        },
+        setHideLargeIndels(arg) {
+            self.hideLargeIndelsSetting = arg;
+        },
     }))
         .views(self => ({
-        copyFeatureToClipboard(feature) {
+        async copyFeatureToClipboard(feature) {
             const { uniqueId, ...rest } = feature.toJSON();
             const session = getSession(self);
+            const { default: copy } = await import('copy-to-clipboard');
             copy(JSON.stringify(rest, null, 4));
             session.notify('Copied to clipboard', 'success');
         },
         get rendererConfig() {
-            const { featureHeight: height, noSpacing, hideSmallIndels, trackMaxHeight: maxHeight, rendererTypeName, } = self;
+            const { featureHeight: height, noSpacing, hideSmallIndels, hideMismatches, hideLargeIndels, trackMaxHeight: maxHeight, rendererTypeName, } = self;
             const configBlob = getConf(self, ['renderers', rendererTypeName]) || {};
-            return self.rendererType.configSchema.create({
+            return {
                 ...configBlob,
                 ...(hideSmallIndels !== undefined ? { hideSmallIndels } : {}),
+                ...(hideMismatches !== undefined ? { hideMismatches } : {}),
+                ...(hideLargeIndels !== undefined ? { hideLargeIndels } : {}),
                 ...(height !== undefined ? { height } : {}),
                 ...(noSpacing !== undefined ? { noSpacing } : {}),
                 ...(maxHeight !== undefined ? { maxHeight } : {}),
-            }, getEnv(self));
+            };
         },
     }))
         .views(self => ({
@@ -165,9 +181,33 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
         get filters() {
             return new SerializableFilterChain({ filters: self.jexlFilters });
         },
+        legendItems(theme) {
+            return getPileupLegendItems(self.colorBy, theme);
+        },
+        showSubMenuItems() {
+            return [
+                {
+                    label: 'Show tooltips',
+                    type: 'checkbox',
+                    checked: self.showTooltipsEnabled,
+                    onClick: () => {
+                        self.setShowTooltips(!self.showTooltipsEnabled);
+                    },
+                },
+                {
+                    label: 'Show legend',
+                    type: 'checkbox',
+                    checked: self.showLegend,
+                    onClick: () => {
+                        self.setShowLegend(!self.showLegend);
+                    },
+                },
+                getMismatchDisplayMenuItem(self),
+            ];
+        },
     }))
         .views(self => {
-        const { trackMenuItems: superTrackMenuItems, renderProps: superRenderProps, } = self;
+        const { trackMenuItems: superTrackMenuItems, renderProps: superRenderProps, renderingProps: superRenderingProps, } = self;
         return {
             get rendererTypeName() {
                 const viewName = getConf(self, 'defaultRendering');
@@ -202,19 +242,22 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
             get DisplayBlurb() {
                 return LinearPileupDisplayBlurb;
             },
-            renderPropsPre() {
-                const { colorTagMap, colorBy, filterBy, rpcDriverName } = self;
+            adapterRenderProps() {
+                const { colorTagMap, colorBy, filterBy } = self;
                 const superProps = superRenderProps();
                 return {
                     ...superProps,
                     notReady: superProps.notReady || !self.renderReady(),
-                    rpcDriverName,
-                    displayModel: self,
                     colorBy,
                     filterBy,
                     filters: self.filters,
                     colorTagMap: Object.fromEntries(colorTagMap.toJSON()),
                     config: self.rendererConfig,
+                };
+            },
+            renderingProps() {
+                return {
+                    ...superRenderingProps(),
                     async onFeatureClick(_, featureId) {
                         const session = getSession(self);
                         const { rpcManager } = session;
@@ -228,8 +271,9 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                                 const { feature } = (await rpcManager.call(sessionId, 'CoreGetFeatureDetails', {
                                     featureId: f,
                                     sessionId,
-                                    layoutId: getContainingTrack(self).id,
+                                    trackInstanceId: getContainingTrack(self).id,
                                     rendererType: 'PileupRenderer',
+                                    rpcDriverName: self.effectiveRpcDriverName,
                                 }));
                                 if (isAlive(self) && feature) {
                                     self.selectFeature(new SimpleFeature(feature));
@@ -257,8 +301,9 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                                 const { feature } = (await rpcManager.call(sessionId, 'CoreGetFeatureDetails', {
                                     featureId: f,
                                     sessionId,
-                                    layoutId: getContainingTrack(self).id,
+                                    trackInstanceId: getContainingTrack(self).id,
                                     rendererType: 'PileupRenderer',
+                                    rpcDriverName: self.effectiveRpcDriverName,
                                 }));
                                 if (feature) {
                                     self.setContextMenuFeature(new SimpleFeature(feature));
@@ -341,10 +386,12 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                     ...superTrackMenuItems(),
                     {
                         label: 'Set feature height...',
-                        priority: 1,
+                        priority: 0,
                         subMenu: [
                             {
                                 label: 'Normal',
+                                type: 'radio',
+                                checked: self.featureHeight === 7 && self.noSpacing === false,
                                 onClick: () => {
                                     self.setFeatureHeight(7);
                                     self.setNoSpacing(false);
@@ -352,13 +399,24 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                             },
                             {
                                 label: 'Compact',
+                                type: 'radio',
+                                checked: self.featureHeight === 2 && self.noSpacing === true,
                                 onClick: () => {
                                     self.setFeatureHeight(2);
                                     self.setNoSpacing(true);
                                 },
                             },
                             {
-                                label: 'Manually set height',
+                                label: 'Super-compact',
+                                type: 'radio',
+                                checked: self.featureHeight === 1 && self.noSpacing === true,
+                                onClick: () => {
+                                    self.setFeatureHeight(1);
+                                    self.setNoSpacing(true);
+                                },
+                            },
+                            {
+                                label: 'Custom',
                                 onClick: () => {
                                     getSession(self).queueDialog(handleClose => [
                                         SetFeatureHeightDialog,
@@ -372,16 +430,14 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                         ],
                     },
                     {
-                        label: 'Hide small indels (<10bp)',
+                        label: 'Show...',
+                        icon: VisibilityIcon,
                         priority: -1,
-                        type: 'checkbox',
-                        checked: self.hideSmallIndels,
-                        onClick: () => {
-                            self.setHideSmallIndels(!self.hideSmallIndels);
-                        },
+                        type: 'subMenu',
+                        subMenu: self.showSubMenuItems(),
                     },
                     {
-                        label: 'Set max height...',
+                        label: 'Set max track height...',
                         priority: -1,
                         onClick: () => {
                             getSession(self).queueDialog(handleClose => [
@@ -412,63 +468,16 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
     })
         .views(self => ({
         renderProps() {
-            return self.renderPropsPre();
+            return self.adapterRenderProps();
         },
     }))
         .actions(self => ({
         afterAttach() {
-            createAutorun(self, async () => {
-                const view = getContainingView(self);
-                if (!self.autorunReady) {
-                    return;
-                }
-                const { colorBy, tagsReady } = self;
-                const { staticBlocks } = view;
-                if ((colorBy === null || colorBy === void 0 ? void 0 : colorBy.tag) && !tagsReady) {
-                    const vals = await getUniqueTags({
-                        self,
-                        tag: colorBy.tag,
-                        blocks: staticBlocks,
-                    });
-                    if (isAlive(self)) {
-                        self.updateColorTagMap(vals);
-                        self.setTagsReady(true);
-                    }
-                }
-                else {
-                    self.setTagsReady(true);
-                }
-            }, { delay: 1000 });
-            addDisposer(self, autorun(async () => {
-                var _a;
-                const session = getSession(self);
-                try {
-                    const featureId = self.featureIdUnderMouse;
-                    if (((_a = self.featureUnderMouse) === null || _a === void 0 ? void 0 : _a.id()) !== featureId) {
-                        if (!featureId) {
-                            self.setFeatureUnderMouse(undefined);
-                        }
-                        else {
-                            const sessionId = getRpcSessionId(self);
-                            const { feature } = (await session.rpcManager.call(sessionId, 'CoreGetFeatureDetails', {
-                                featureId,
-                                sessionId,
-                                layoutId: getContainingTrack(self).id,
-                                rendererType: 'PileupRenderer',
-                            }));
-                            if (isAlive(self) &&
-                                feature &&
-                                self.featureIdUnderMouse === feature.uniqueId) {
-                                self.setFeatureUnderMouse(new SimpleFeature(feature));
-                            }
-                        }
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                    session.notifyError(`${e}`, e);
-                }
-            }));
+            ;
+            (async () => {
+                const { sharedDoAfterAttach } = await import("./sharedDoAfterAttach.js");
+                sharedDoAfterAttach(self);
+            })();
         },
     }))
         .preProcessSnapshot(snap => {
@@ -481,5 +490,27 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
             };
         }
         return snap;
+    })
+        .postProcessSnapshot(snap => {
+        if (!snap) {
+            return snap;
+        }
+        const { trackMaxHeight, colorBySetting, filterBySetting, jexlFilters, hideSmallIndelsSetting, hideMismatchesSetting, hideLargeIndelsSetting, ...rest } = snap;
+        return {
+            ...rest,
+            ...(trackMaxHeight !== undefined ? { trackMaxHeight } : {}),
+            ...(colorBySetting !== undefined ? { colorBySetting } : {}),
+            ...(!isDefaultFilterFlags(filterBySetting) ? { filterBySetting } : {}),
+            ...(jexlFilters?.length ? { jexlFilters } : {}),
+            ...(hideSmallIndelsSetting !== undefined
+                ? { hideSmallIndelsSetting }
+                : {}),
+            ...(hideMismatchesSetting !== undefined
+                ? { hideMismatchesSetting }
+                : {}),
+            ...(hideLargeIndelsSetting !== undefined
+                ? { hideLargeIndelsSetting }
+                : {}),
+        };
     });
 }

package/esm/LinearPileupDisplay/components/ColorByTagDialog.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 ColorByTagDialog = observer(function ({ model, handleClose, }) {
+const ColorByTagDialog = observer(function ColorByTagDialog({ model, handleClose, }) {
     const [tag, setTag] = useState('');
     const validTag = /^[A-Za-z][A-Za-z0-9]$/.exec(tag);
     return (_jsx(Dialog, { open: true, onClose: handleClose, title: "Color by tag", children: _jsxs(DialogContent, { style: { overflowX: 'hidden' }, children: [_jsx(Typography, { children: "Enter tag to color by: " }), _jsx(Typography, { color: "textSecondary", children: "Examples: XS or TS for RNA-seq inferred read strand, ts (lower-case) for minimap2 read strand, HP for haplotype, RG for read group, etc." }), _jsx(TextField, { value: tag, onChange: event => {

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

@@ -1,5 +1,5 @@
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import type { IAnyStateTreeNode } from 'mobx-state-tree';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
 declare const GroupByTagDialog: (props: {
     model: {
         adapterConfig: AnyConfigurationModel;

package/esm/LinearPileupDisplay/components/GroupByDialog.js

@@ -2,12 +2,12 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useState } from 'react';
 import { Dialog, ErrorMessage, LoadingEllipses } from '@jbrowse/core/ui';
 import { getContainingTrack, getContainingView, getSession, useDebounce, } from '@jbrowse/core/util';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
 import { Button, DialogActions, DialogContent, MenuItem, TextField, Typography, } from '@mui/material';
 import { observer } from 'mobx-react';
-import { getSnapshot } from 'mobx-state-tree';
-import { getUniqueTags } from '../../shared/getUniqueTags';
-import { defaultFilterFlags, negFlags, posFlags } from '../../shared/util';
-const GroupByTagDialog = observer(function (props) {
+import { getUniqueTags } from "../../shared/getUniqueTags.js";
+import { defaultFilterFlags, negFlags, posFlags } from "../../shared/util.js";
+const GroupByTagDialog = observer(function GroupByTagDialog(props) {
     const { model, handleClose } = props;
     const [tag, setGroupByTag] = useState('');
     const [tagSet, setGroupByTagSet] = useState();

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

@@ -1,4 +1,4 @@
-import type { SortedBy } from '../../shared/types';
+import type { SortedBy } from '../../shared/types.ts';
 declare const LinearPileupDisplayBlurb: ({ model, }: {
     model: {
         sortedBy?: SortedBy;

package/esm/LinearPileupDisplay/components/LinearPileupDisplayBlurb.js

@@ -1,9 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Typography } from '@mui/material';
 import { observer } from 'mobx-react';
-const LinearPileupDisplayBlurb = observer(function ({ model, }) {
-    var _a;
+const LinearPileupDisplayBlurb = observer(function LinearPileupDisplayBlurb({ model, }) {
     const { sortedBy } = model;
-    return sortedBy ? (_jsx("div", { "data-testid": `blurb-${sortedBy}`, children: _jsx(Typography, { color: "secondary", variant: "caption", children: `Sorted by ${(_a = sortedBy.tag) !== null && _a !== void 0 ? _a : sortedBy.type} at ${sortedBy.refName}:${sortedBy.pos}` }) })) : null;
+    return sortedBy ? (_jsx("div", { "data-testid": `blurb-${sortedBy}`, children: _jsx(Typography, { color: "secondary", variant: "caption", children: `Sorted by ${sortedBy.tag ?? sortedBy.type} at ${sortedBy.refName}:${sortedBy.pos}` }) })) : null;
 });
 export default LinearPileupDisplayBlurb;

package/esm/LinearPileupDisplay/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/LinearPileupDisplay/components/SortByTagDialog.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 SortByTagDialog = observer(function (props) {
+const SortByTagDialog = observer(function SortByTagDialog(props) {
     const { model, handleClose } = props;
     const [tag, setTag] = useState('');
     const validTag = /^[A-Za-z][A-Za-z0-9]$/.exec(tag);

package/esm/LinearPileupDisplay/configSchema.d.ts

@@ -1,13 +1,13 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
-declare function configSchemaF(pluginManager: PluginManager): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+declare function configSchemaF(pluginManager: PluginManager): import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
     defaultRendering: {
         type: string;
-        model: import("mobx-state-tree").ISimpleType<string>;
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
         defaultValue: string;
     };
-    renderers: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    renderers: import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
         PileupRenderer: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    }, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
     maxFeatureScreenDensity: {
         type: string;
         description: string;
@@ -28,9 +28,9 @@ declare function configSchemaF(pluginManager: PluginManager): import("@jbrowse/c
             flagExclude: number;
         };
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    renderer: import("mobx-state-tree").IAnyModelType;
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    renderer: import("@jbrowse/mobx-state-tree").IAnyModelType;
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
     maxFeatureScreenDensity: {
         type: string;
         description: string;
@@ -57,5 +57,5 @@ declare function configSchemaF(pluginManager: PluginManager): import("@jbrowse/c
         description: string;
         defaultValue: never[];
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "displayId">>, undefined>>, undefined>>;
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "displayId">>, undefined>>, undefined>>;
 export default configSchemaF;

package/esm/LinearPileupDisplay/configSchema.js

@@ -1,7 +1,7 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
 import { linearBasicDisplayConfigSchemaFactory } from '@jbrowse/plugin-linear-genome-view';
-import { types } from 'mobx-state-tree';
-import { defaultFilterFlags } from '../shared/util';
+import { defaultFilterFlags } from "../shared/util.js";
 function x() { }
 function configSchemaF(pluginManager) {
     return ConfigurationSchema('LinearPileupDisplay', {

package/esm/LinearPileupDisplay/doAfterAttach.d.ts

@@ -1,4 +1,4 @@
-import type { ModificationType, SortedBy } from '../shared/types';
+import type { ModificationType, SortedBy } from '../shared/types.ts';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 export declare function doAfterAttach(model: {
     autorunReady: boolean;
@@ -10,12 +10,13 @@ export declare function doAfterAttach(model: {
     sortReady: boolean;
     currSortBpPerPx: number;
     parentTrack: any;
-    renderPropsPre: () => Record<string, unknown>;
+    adapterRenderProps: () => Record<string, unknown>;
+    renderingProps: () => Record<string, unknown>;
     setCurrSortBpPerPx: (arg: number) => void;
     setError: (arg: unknown) => void;
     updateVisibleModifications: (arg: ModificationType[]) => void;
     setSimplexModifications: (arg: string[]) => void;
     setModificationsReady: (arg: boolean) => void;
     setSortReady: (arg: boolean) => void;
-    setMessage: (arg: string) => void;
+    setStatusMessage: (arg: string) => void;
 }): void;

package/esm/LinearPileupDisplay/doAfterAttach.js

@@ -1,8 +1,8 @@
 import { getContainingTrack, getContainingView, getSession, } from '@jbrowse/core/util';
 import { getRpcSessionId } from '@jbrowse/core/util/tracks';
-import { isAlive } from 'mobx-state-tree';
-import { getUniqueModifications } from '../shared/getUniqueModifications';
-import { createAutorun } from '../util';
+import { isAlive } from '@jbrowse/mobx-state-tree';
+import { setupModificationsAutorun } from "../shared/setupModificationsAutorun.js";
+import { createAutorun } from "../util.js";
 export function doAfterAttach(model) {
     createAutorun(model, async () => {
         const view = getContainingView(model);
@@ -10,7 +10,10 @@ export function doAfterAttach(model) {
             return;
         }
         model.setCurrSortBpPerPx(view.bpPerPx);
-    }, { delay: 1000 });
+    }, {
+        delay: 1000,
+        name: 'CurrBpPerPx',
+    });
     createAutorun(model, async () => {
         const { rpcManager } = getSession(model);
         const view = getContainingView(model);
@@ -34,36 +37,24 @@ export function doAfterAttach(model) {
                 adapterConfig,
                 rendererType: rendererType.name,
                 sessionId: getRpcSessionId(model),
-                layoutId: getContainingTrack(model).id,
-                timeout: 1000000,
+                trackInstanceId: getContainingTrack(model).id,
+                timeout: 1_000_000,
                 statusCallback: (arg) => {
                     if (isAlive(model)) {
-                        model.setMessage(arg);
+                        model.setStatusMessage(arg);
                     }
                 },
-                ...model.renderPropsPre(),
+                ...model.adapterRenderProps(),
+                renderingProps: model.renderingProps(),
             });
         }
         if (isAlive(model)) {
             model.setCurrSortBpPerPx(bpPerPx);
             model.setSortReady(true);
         }
-    }, { delay: 1000 });
-    createAutorun(model, async () => {
-        if (!model.autorunReady) {
-            return;
-        }
-        const { adapterConfig } = model;
-        const { staticBlocks } = getContainingView(model);
-        const { modifications, simplexModifications } = await getUniqueModifications({
-            model,
-            adapterConfig,
-            blocks: staticBlocks,
-        });
-        if (isAlive(model)) {
-            model.updateVisibleModifications(modifications);
-            model.setSimplexModifications(simplexModifications);
-            model.setModificationsReady(true);
-        }
-    }, { delay: 1000 });
+    }, {
+        delay: 1000,
+        name: 'SortReads',
+    });
+    setupModificationsAutorun(model, () => model.autorunReady);
 }

package/esm/LinearPileupDisplay/index.d.ts

@@ -1,5 +1,5 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
 export default function register(pluginManager: PluginManager): void;
-export { default as linearPileupDisplayStateModelFactory } from './model';
-export { default as linearPileupDisplayConfigSchemaFactory } from './configSchema';
-export { SharedLinearPileupDisplayMixin } from './SharedLinearPileupDisplayMixin';
+export { default as linearPileupDisplayStateModelFactory } from './model.ts';
+export { default as linearPileupDisplayConfigSchemaFactory } from './configSchema.ts';
+export { SharedLinearPileupDisplayMixin } from './SharedLinearPileupDisplayMixin.ts';

package/esm/LinearPileupDisplay/index.js

@@ -1,13 +1,14 @@
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
 import { BaseLinearDisplayComponent } from '@jbrowse/plugin-linear-genome-view';
-import configSchemaFactory from './configSchema';
-import modelFactory from './model';
+import configSchemaFactory from "./configSchema.js";
+import modelFactory from "./model.js";
 export default function register(pluginManager) {
     pluginManager.addDisplayType(() => {
         const configSchema = configSchemaFactory(pluginManager);
         return new DisplayType({
             name: 'LinearPileupDisplay',
             displayName: 'Pileup display',
+            helpText: 'Display stacked aligned reads showing exact placement and sequences relative to the reference genome',
             configSchema,
             stateModel: modelFactory(configSchema),
             subDisplay: { type: 'LinearAlignmentsDisplay', lowerPanel: true },
@@ -17,6 +18,6 @@ export default function register(pluginManager) {
         });
     });
 }
-export { default as linearPileupDisplayStateModelFactory } from './model';
-export { default as linearPileupDisplayConfigSchemaFactory } from './configSchema';
-export { SharedLinearPileupDisplayMixin } from './SharedLinearPileupDisplayMixin';
+export { default as linearPileupDisplayStateModelFactory } from "./model.js";
+export { default as linearPileupDisplayConfigSchemaFactory } from "./configSchema.js";
+export { SharedLinearPileupDisplayMixin } from "./SharedLinearPileupDisplayMixin.js";