@jbrowse/plugin-linear-genome-view 3.7.0 → 4.0.1

package/esm/BaseLinearDisplay/model.js

@@ -4,26 +4,33 @@ import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes/models';
 import { getContainingTrack, getContainingView, getSession, isFeature, isSelectionContainer, isSessionModelWithWidgets, } from '@jbrowse/core/util';
 import CompositeMap from '@jbrowse/core/util/compositeMap';
 import { getParentRenderProps, getRpcSessionId, } from '@jbrowse/core/util/tracks';
+import { addDisposer, flow, isAlive, types } from '@jbrowse/mobx-state-tree';
 import CenterFocusStrongIcon from '@mui/icons-material/CenterFocusStrong';
+import CloseFullscreenIcon from '@mui/icons-material/CloseFullscreen';
 import ContentCopyIcon from '@mui/icons-material/ContentCopy';
 import MenuOpenIcon from '@mui/icons-material/MenuOpen';
-import copy from 'copy-to-clipboard';
 import { autorun } from 'mobx';
-import { addDisposer, isAlive, types } from 'mobx-state-tree';
-import FeatureDensityMixin from './models/FeatureDensityMixin';
-import TrackHeightMixin from './models/TrackHeightMixin';
-import configSchema from './models/configSchema';
-import BlockState from './models/serverSideRenderedBlock';
-const Tooltip = lazy(() => import('./components/Tooltip'));
+import { deduplicateFeatureLabels } from "./components/util.js";
+import { calculateSvgLegendWidth } from "./index.js";
+import FeatureDensityMixin from "./models/FeatureDensityMixin.js";
+import TrackHeightMixin from "./models/TrackHeightMixin.js";
+import configSchema from "./models/configSchema.js";
+import BlockState from "./models/serverSideRenderedBlock.js";
+import { fetchFeatureByIdRpc, findSubfeatureById, getTranscripts, hasExonsOrCDS, } from "./util.js";
+const Tooltip = lazy(() => import("./components/Tooltip.js"));
+const CollapseIntronsDialog = lazy(() => import("./components/CollapseIntronsDialog/CollapseIntronsDialog.js"));
 function stateModelFactory() {
     return types
         .compose('BaseLinearDisplay', BaseDisplay, TrackHeightMixin(), FeatureDensityMixin(), types.model({
         blockState: types.map(BlockState),
         configuration: ConfigurationReference(configSchema),
+        showLegend: types.maybe(types.boolean),
+        showTooltips: types.maybe(types.boolean),
     }))
         .volatile(() => ({
         mouseoverExtraInformation: undefined,
         featureIdUnderMouse: undefined,
+        subfeatureIdUnderMouse: undefined,
         contextMenuFeature: undefined,
     }))
         .views(self => ({
@@ -48,6 +55,14 @@ function stateModelFactory() {
         get TooltipComponent() {
             return Tooltip;
         },
+        legendItems(_theme) {
+            return [];
+        },
+        svgLegendWidth(theme) {
+            return self.showLegend
+                ? calculateSvgLegendWidth(this.legendItems(theme))
+                : 0;
+        },
         get selectedFeatureId() {
             if (isAlive(self)) {
                 const { selection } = getSession(self);
@@ -57,14 +72,17 @@ function stateModelFactory() {
             }
             return undefined;
         },
-        copyInfoToClipboard(feature) {
-            const { uniqueId, ...rest } = feature.toJSON();
-            const session = getSession(self);
-            copy(JSON.stringify(rest, null, 4));
-            session.notify('Copied to clipboard', 'success');
+        get featureWidgetType() {
+            return {
+                type: 'BaseFeatureWidget',
+                id: 'baseFeature',
+            };
         },
     }))
         .views(self => ({
+        get showTooltipsEnabled() {
+            return self.showTooltips ?? true;
+        },
         get features() {
             const featureMaps = [];
             for (const block of self.blockState.values()) {
@@ -78,73 +96,93 @@ function stateModelFactory() {
             const feat = self.featureIdUnderMouse;
             return feat ? this.features.get(feat) : undefined;
         },
+        getFeatureById(featureId, parentFeatureId) {
+            const feature = this.features.get(featureId);
+            if (feature) {
+                return feature;
+            }
+            if (parentFeatureId) {
+                const parent = this.features.get(parentFeatureId);
+                if (parent) {
+                    return findSubfeatureById(parent, featureId);
+                }
+            }
+            return undefined;
+        },
         get layoutFeatures() {
             const featureMaps = [];
             for (const block of self.blockState.values()) {
-                if (block.layout) {
-                    featureMaps.push(block.layout.rectangles);
+                if (block.layout?.getRectangles) {
+                    featureMaps.push(block.layout.getRectangles());
                 }
             }
             return new CompositeMap(featureMaps);
         },
         getFeatureOverlapping(blockKey, x, y) {
-            var _a, _b;
-            return (_b = (_a = self.blockState.get(blockKey)) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.getByCoord(x, y);
+            return self.blockState.get(blockKey)?.layout?.getByCoord(x, y);
         },
         getFeatureByID(blockKey, id) {
-            var _a, _b;
-            return (_b = (_a = self.blockState.get(blockKey)) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.getByID(id);
+            return self.blockState.get(blockKey)?.layout?.getByID(id);
         },
         searchFeatureByID(id) {
-            var _a;
-            let ret;
             for (const block of self.blockState.values()) {
-                const val = (_a = block.layout) === null || _a === void 0 ? void 0 : _a.getByID(id);
+                const val = block.layout?.getByID(id);
                 if (val) {
-                    ret = val;
+                    return val;
                 }
             }
-            return ret;
+            return undefined;
+        },
+        get floatingLabelData() {
+            const view = getContainingView(self);
+            const { assemblyManager } = getSession(self);
+            const assemblyName = view.assemblyNames[0];
+            const assembly = assemblyName
+                ? assemblyManager.get(assemblyName)
+                : undefined;
+            return deduplicateFeatureLabels(this.layoutFeatures, view, assembly, view.bpPerPx);
         },
     }))
         .actions(self => ({
         addBlock(key, block) {
-            self.blockState.set(key, BlockState.create({
+            const blockInstance = BlockState.create({
                 key,
                 region: block.toRegion(),
-            }));
+            });
+            blockInstance.setCachedDisplay(self);
+            self.blockState.set(key, blockInstance);
         },
         deleteBlock(key) {
             self.blockState.delete(key);
         },
         selectFeature(feature) {
             const session = getSession(self);
+            if (isSelectionContainer(session)) {
+                session.setSelection(feature);
+            }
             if (isSessionModelWithWidgets(session)) {
                 const { rpcManager } = session;
                 const sessionId = getRpcSessionId(self);
                 const track = getContainingTrack(self);
                 const view = getContainingView(self);
                 const adapterConfig = getConf(track, 'adapter');
-                (async () => {
-                    try {
-                        const descriptions = await rpcManager.call(sessionId, 'CoreGetMetadata', {
-                            adapterConfig,
-                        });
-                        session.showWidget(session.addWidget('BaseFeatureWidget', 'baseFeature', {
+                const { type, id } = self.featureWidgetType;
+                rpcManager
+                    .call(sessionId, 'CoreGetMetadata', { adapterConfig })
+                    .then(descriptions => {
+                    if (isAlive(self)) {
+                        session.showWidget(session.addWidget(type, id, {
                             featureData: feature.toJSON(),
                             view,
                             track,
                             descriptions,
                         }));
                     }
-                    catch (e) {
-                        console.error(e);
-                        getSession(e).notifyError(`${e}`, e);
-                    }
-                })();
-            }
-            if (isSelectionContainer(session)) {
-                session.setSelection(feature);
+                })
+                    .catch((e) => {
+                    console.error(e);
+                    getSession(self).notifyError(`${e}`, e);
+                });
             }
         },
         navToFeature(feature) {
@@ -161,12 +199,21 @@ function stateModelFactory() {
         setFeatureIdUnderMouse(feature) {
             self.featureIdUnderMouse = feature;
         },
+        setSubfeatureIdUnderMouse(subfeatureId) {
+            self.subfeatureIdUnderMouse = subfeatureId;
+        },
         setContextMenuFeature(feature) {
             self.contextMenuFeature = feature;
         },
         setMouseoverExtraInformation(extra) {
             self.mouseoverExtraInformation = extra;
         },
+        setShowLegend(s) {
+            self.showLegend = s;
+        },
+        setShowTooltips(arg) {
+            self.showTooltips = arg;
+        },
     }))
         .actions(self => {
         const { reload: superReload } = self;
@@ -182,12 +229,71 @@ function stateModelFactory() {
             },
         };
     })
+        .actions(self => ({
+        selectFeatureById: flow(function* (featureId, parentFeatureId, topLevelFeatureId) {
+            const feature = self.getFeatureById(featureId, parentFeatureId);
+            if (feature) {
+                self.selectFeature(feature);
+                return;
+            }
+            const rpcParentId = topLevelFeatureId && topLevelFeatureId !== featureId
+                ? topLevelFeatureId
+                : parentFeatureId;
+            try {
+                const session = getSession(self);
+                const f = yield fetchFeatureByIdRpc({
+                    rpcManager: session.rpcManager,
+                    sessionId: getRpcSessionId(self),
+                    trackId: getContainingTrack(self).id,
+                    rendererType: self.rendererTypeName,
+                    featureId,
+                    parentFeatureId: rpcParentId,
+                });
+                if (f && isAlive(self)) {
+                    self.selectFeature(f);
+                }
+            }
+            catch (e) {
+                console.error(e);
+                getSession(self).notifyError(`${e}`, e);
+            }
+        }),
+        setContextMenuFeatureById: flow(function* (featureId, parentFeatureId, topLevelFeatureId) {
+            const feature = self.getFeatureById(featureId, parentFeatureId);
+            if (feature) {
+                self.setContextMenuFeature(feature);
+                return;
+            }
+            const rpcParentId = topLevelFeatureId && topLevelFeatureId !== featureId
+                ? topLevelFeatureId
+                : parentFeatureId;
+            try {
+                const session = getSession(self);
+                const f = yield fetchFeatureByIdRpc({
+                    rpcManager: session.rpcManager,
+                    sessionId: getRpcSessionId(self),
+                    trackId: getContainingTrack(self).id,
+                    rendererType: self.rendererTypeName,
+                    featureId,
+                    parentFeatureId: rpcParentId,
+                });
+                if (f && isAlive(self)) {
+                    self.setContextMenuFeature(f);
+                }
+            }
+            catch (e) {
+                console.error(e);
+                getSession(self).notifyError(`${e}`, e);
+            }
+        }),
+    }))
         .views(self => ({
         trackMenuItems() {
             return [];
         },
         contextMenuItems() {
             const feat = self.contextMenuFeature;
+            const transcripts = getTranscripts(feat);
             return feat
                 ? [
                     {
@@ -207,81 +313,97 @@ function stateModelFactory() {
                     {
                         label: 'Copy info to clipboard',
                         icon: ContentCopyIcon,
-                        onClick: () => {
-                            self.copyInfoToClipboard(feat);
+                        onClick: async () => {
+                            const { uniqueId, ...rest } = feat.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');
                         },
                     },
+                    ...(hasExonsOrCDS(transcripts)
+                        ? [
+                            {
+                                label: 'Collapse introns',
+                                icon: CloseFullscreenIcon,
+                                onClick: () => {
+                                    const view = getContainingView(self);
+                                    const { assemblyManager } = getSession(self);
+                                    const assembly = assemblyManager.get(view.assemblyNames[0]);
+                                    if (assembly) {
+                                        getSession(self).queueDialog(handleClose => [
+                                            CollapseIntronsDialog,
+                                            {
+                                                view,
+                                                transcripts,
+                                                handleClose,
+                                                assembly,
+                                            },
+                                        ]);
+                                    }
+                                },
+                            },
+                        ]
+                        : []),
                 ]
                 : [];
         },
-        renderProps() {
+        renderingProps() {
             return {
-                ...getParentRenderProps(self),
-                notReady: !self.featureDensityStatsReady,
-                rpcDriverName: self.rpcDriverName,
                 displayModel: self,
-                onFeatureClick(_, featureId) {
-                    const f = featureId || self.featureIdUnderMouse;
-                    if (!f) {
-                        self.clearFeatureSelection();
-                    }
-                    else {
-                        const feature = self.features.get(f);
-                        if (feature) {
-                            self.selectFeature(feature);
-                        }
-                    }
-                },
-                onClick() {
-                    self.clearFeatureSelection();
-                },
-                onFeatureContextMenu(_, featureId) {
-                    const f = featureId || self.featureIdUnderMouse;
-                    if (!f) {
-                        self.clearFeatureSelection();
-                    }
-                    else {
-                        self.setContextMenuFeature(self.features.get(f));
-                    }
-                },
-                onMouseMove(_, featureId, extra) {
+                onMouseMove(_, featureId) {
                     self.setFeatureIdUnderMouse(featureId);
-                    self.setMouseoverExtraInformation(extra);
                 },
                 onMouseLeave(_) {
                     self.setFeatureIdUnderMouse(undefined);
-                    self.setMouseoverExtraInformation(undefined);
                 },
-                onContextMenu() {
+                onContextMenu(_) {
                     self.setContextMenuFeature(undefined);
                     self.clearFeatureSelection();
                 },
             };
         },
+        renderProps() {
+            return {
+                ...getParentRenderProps(self),
+                notReady: !self.featureDensityStatsReady,
+                rpcDriverName: self.effectiveRpcDriverName,
+            };
+        },
     }))
         .actions(self => ({
         async renderSvg(opts) {
-            const { renderBaseLinearDisplaySvg } = await import('./models/renderSvg');
+            const { renderBaseLinearDisplaySvg } = await import("./renderSvg.js");
             return renderBaseLinearDisplaySvg(self, opts);
         },
         afterAttach() {
-            addDisposer(self, autorun(() => {
-                const blocksPresent = {};
-                const view = getContainingView(self);
-                if (!view.initialized) {
-                    return;
-                }
-                for (const block of self.blockDefinitions.contentBlocks) {
-                    blocksPresent[block.key] = true;
-                    if (!self.blockState.has(block.key)) {
-                        self.addBlock(block.key, block);
+            addDisposer(self, autorun(function blockDefinitionsAutorun() {
+                try {
+                    if (!isAlive(self)) {
+                        return;
                     }
-                }
-                for (const key of self.blockState.keys()) {
-                    if (!blocksPresent[key]) {
-                        self.deleteBlock(key);
+                    const view = getContainingView(self);
+                    if (!view.initialized) {
+                        return;
+                    }
+                    const contentBlocks = self.blockDefinitions.contentBlocks;
+                    const newKeys = new Set(contentBlocks.map(b => b.key));
+                    for (const block of contentBlocks) {
+                        if (!self.blockState.has(block.key)) {
+                            self.addBlock(block.key, block);
+                        }
+                    }
+                    for (const key of self.blockState.keys()) {
+                        if (!newKeys.has(key)) {
+                            self.deleteBlock(key);
+                        }
                     }
                 }
+                catch (e) {
+                }
+            }, {
+                name: 'BaseLinearDisplayBlockDefinitions',
+                delay: 60,
             }));
         },
     }))
@@ -299,3 +421,4 @@ function stateModelFactory() {
     });
 }
 export const BaseLinearDisplay = stateModelFactory();
+export {} from "./components/FloatingLegend.js";

package/esm/BaseLinearDisplay/models/FeatureDensityMixin.d.ts

@@ -1,8 +1,8 @@
 import type { FeatureDensityStats } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Region } from '@jbrowse/core/util/types';
-export default function FeatureDensityMixin(): import("mobx-state-tree").IModelType<{
-    userBpPerPxLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
-    userByteSizeLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+export default function FeatureDensityMixin(): import("@jbrowse/mobx-state-tree").IModelType<{
+    userBpPerPxLimit: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
+    userByteSizeLimit: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
 }, {
     featureDensityStatsP: undefined | Promise<FeatureDensityStats>;
     featureDensityStats: undefined | FeatureDensityStats;
@@ -26,7 +26,7 @@ export default function FeatureDensityMixin(): import("mobx-state-tree").IModelT
     readonly regionTooLarge: boolean;
     readonly regionTooLargeReason: string;
 } & {
-    readonly statsReadyAndRegionNotTooLarge: boolean;
+    readonly featureDensityStatsReadyAndRegionNotTooLarge: boolean;
     regionCannotBeRenderedText(_region: Region): "" | "Force load to see features";
     regionCannotBeRendered(_region: Region): import("react/jsx-runtime").JSX.Element | null;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/BaseLinearDisplay/models/FeatureDensityMixin.js

@@ -1,11 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { getConf } from '@jbrowse/core/configuration';
 import { getContainingView } from '@jbrowse/core/util';
+import { addDisposer, isAlive, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
-import { addDisposer, isAlive, types } from 'mobx-state-tree';
-import autorunFeatureDensityStats from './autorunFeatureDensityStats';
-import { getDisplayStr, getFeatureDensityStatsPre } from './util';
-import TooLargeMessage from '../components/TooLargeMessage';
+import autorunFeatureDensityStats from "./autorunFeatureDensityStats.js";
+import { getDisplayStr, getFeatureDensityStatsPre } from "./util.js";
+import TooLargeMessage from "../components/TooLargeMessage.js";
 export default function FeatureDensityMixin() {
     return types
         .model({
@@ -19,13 +19,11 @@ export default function FeatureDensityMixin() {
     }))
         .views(self => ({
         get currentBytesRequested() {
-            var _a;
-            return ((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.bytes) || 0;
+            return self.featureDensityStats?.bytes || 0;
         },
         get currentFeatureScreenDensity() {
-            var _a;
             const view = getContainingView(self);
-            return (((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.featureDensity) || 0) * view.bpPerPx;
+            return (self.featureDensityStats?.featureDensity || 0) * view.bpPerPx;
         },
         get maxFeatureScreenDensity() {
             return getConf(self, 'maxFeatureScreenDensity');
@@ -36,9 +34,8 @@ export default function FeatureDensityMixin() {
                 (!!self.featureDensityStats || !!self.userBpPerPxLimit));
         },
         get maxAllowableBytes() {
-            var _a;
             return (self.userByteSizeLimit ||
-                ((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.fetchSizeLimit) ||
+                self.featureDensityStats?.fetchSizeLimit ||
                 getConf(self, 'fetchSizeLimit'));
         },
     }))
@@ -53,7 +50,7 @@ export default function FeatureDensityMixin() {
         },
         setFeatureDensityStatsLimit(stats) {
             const view = getContainingView(self);
-            if (stats === null || stats === void 0 ? void 0 : stats.bytes) {
+            if (stats?.bytes) {
                 self.userByteSizeLimit = stats.bytes;
             }
             else {
@@ -86,7 +83,7 @@ export default function FeatureDensityMixin() {
         get regionTooLarge() {
             const view = getContainingView(self);
             if (!self.featureDensityStatsReady ||
-                view.dynamicBlocks.totalBp < 20000) {
+                view.dynamicBlocks.totalBp < 20_000) {
                 return false;
             }
             return (self.currentBytesRequested > self.maxAllowableBytes ||
@@ -103,14 +100,14 @@ export default function FeatureDensityMixin() {
         },
     }))
         .views(self => ({
-        get statsReadyAndRegionNotTooLarge() {
+        get featureDensityStatsReadyAndRegionNotTooLarge() {
             return self.featureDensityStatsReady && !self.regionTooLarge;
         },
         regionCannotBeRenderedText(_region) {
             return self.regionTooLarge ? 'Force load to see features' : '';
         },
         regionCannotBeRendered(_region) {
-            return self.regionTooLarge ? (_jsx(TooLargeMessage, { model: self })) : null;
+            return self.regionTooLarge ? _jsx(TooLargeMessage, { model: self }) : null;
         },
     }));
 }

package/esm/BaseLinearDisplay/models/NonBlockCanvasDisplayMixin.d.ts

@@ -0,0 +1,21 @@
+import type { StopToken } from '@jbrowse/core/util/stopToken';
+export default function NonBlockCanvasDisplayMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    loading: boolean;
+    lastDrawnOffsetPx: number | undefined;
+    ref: HTMLCanvasElement | null;
+    renderingImageData: ImageBitmap | undefined;
+    renderingStopToken: StopToken | undefined;
+    statusMessage: string | undefined;
+} & {
+    readonly drawn: boolean;
+} & {
+    setLastDrawnOffsetPx(n: number): void;
+    setLoading(f: boolean): void;
+    setRef(ref: HTMLCanvasElement | null): void;
+    setRenderingImageData(imageData: ImageBitmap | undefined): void;
+    setRenderingStopToken(token?: StopToken): void;
+    setStatusMessage(msg?: string): void;
+} & {
+    beforeDestroy(): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export type NonBlockCanvasDisplayMixinType = ReturnType<typeof NonBlockCanvasDisplayMixin>;

package/esm/BaseLinearDisplay/models/NonBlockCanvasDisplayMixin.js

@@ -0,0 +1,46 @@
+import { stopStopToken } from '@jbrowse/core/util/stopToken';
+import { types } from '@jbrowse/mobx-state-tree';
+export default function NonBlockCanvasDisplayMixin() {
+    return types
+        .model('NonBlockCanvasDisplayMixin', {})
+        .volatile(() => ({
+        loading: false,
+        lastDrawnOffsetPx: undefined,
+        ref: null,
+        renderingImageData: undefined,
+        renderingStopToken: undefined,
+        statusMessage: undefined,
+    }))
+        .views(self => ({
+        get drawn() {
+            return self.lastDrawnOffsetPx !== undefined;
+        },
+    }))
+        .actions(self => ({
+        setLastDrawnOffsetPx(n) {
+            self.lastDrawnOffsetPx = n;
+        },
+        setLoading(f) {
+            self.loading = f;
+        },
+        setRef(ref) {
+            self.ref = ref;
+        },
+        setRenderingImageData(imageData) {
+            self.renderingImageData = imageData;
+        },
+        setRenderingStopToken(token) {
+            self.renderingStopToken = token;
+        },
+        setStatusMessage(msg) {
+            self.statusMessage = msg;
+        },
+    }))
+        .actions(self => ({
+        beforeDestroy() {
+            if (self.renderingStopToken) {
+                stopStopToken(self.renderingStopToken);
+            }
+        },
+    }));
+}

package/esm/BaseLinearDisplay/models/TrackHeightMixin.d.ts

@@ -1,5 +1,5 @@
-export default function TrackHeightMixin(): import("mobx-state-tree").IModelType<{
-    heightPreConfig: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+export default function TrackHeightMixin(): import("@jbrowse/mobx-state-tree").IModelType<{
+    heightPreConfig: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
 }, {
     scrollTop: number;
 } & {
@@ -8,4 +8,4 @@ export default function TrackHeightMixin(): import("mobx-state-tree").IModelType
     setScrollTop(scrollTop: number): void;
     setHeight(displayHeight: number): number;
     resizeHeight(distance: number): number;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/BaseLinearDisplay/models/TrackHeightMixin.js

@@ -1,5 +1,5 @@
 import { getConf } from '@jbrowse/core/configuration';
-import { types } from 'mobx-state-tree';
+import { types } from '@jbrowse/mobx-state-tree';
 const minDisplayHeight = 20;
 export default function TrackHeightMixin() {
     return types
@@ -11,8 +11,7 @@ export default function TrackHeightMixin() {
     }))
         .views(self => ({
         get height() {
-            var _a;
-            return (_a = self.heightPreConfig) !== null && _a !== void 0 ? _a : getConf(self, 'height');
+            return self.heightPreConfig ?? getConf(self, 'height');
         },
     }))
         .actions(self => ({

package/esm/BaseLinearDisplay/models/autorunFeatureDensityStats.d.ts

@@ -1,2 +1,2 @@
-import type { BaseLinearDisplayModel } from '../model';
+import type { BaseLinearDisplayModel } from '../model.ts';
 export default function autorunFeatureDensityStats(self: BaseLinearDisplayModel): Promise<void>;

package/esm/BaseLinearDisplay/models/autorunFeatureDensityStats.js

@@ -1,7 +1,6 @@
 import { getContainingView, isAbortException } from '@jbrowse/core/util';
-import { isAlive } from 'mobx-state-tree';
+import { isAlive } from '@jbrowse/mobx-state-tree';
 export default async function autorunFeatureDensityStats(self) {
-    var _a;
     try {
         const view = getContainingView(self);
         if (!view.initialized ||
@@ -10,7 +9,7 @@ export default async function autorunFeatureDensityStats(self) {
             self.error) {
             return;
         }
-        if (((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.featureDensity) !== undefined) {
+        if (self.featureDensityStats?.featureDensity !== undefined) {
             self.setCurrStatsBpPerPx(view.bpPerPx);
             return;
         }