@jbrowse/plugin-linear-genome-view 3.6.5 → 4.0.0

package/esm/BaseLinearDisplay/model.js

@@ -0,0 +1,424 @@
+import { lazy } from 'react';
+import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
+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 { autorun } from 'mobx';
+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 => ({
+        get DisplayMessageComponent() {
+            return undefined;
+        },
+        get blockType() {
+            return 'staticBlocks';
+        },
+        get blockDefinitions() {
+            const view = getContainingView(self);
+            if (!view.initialized) {
+                throw new Error('view not initialized yet');
+            }
+            return view[this.blockType];
+        },
+    }))
+        .views(self => ({
+        get renderDelay() {
+            return 50;
+        },
+        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);
+                if (isFeature(selection)) {
+                    return selection.id();
+                }
+            }
+            return undefined;
+        },
+        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()) {
+                if (block.features) {
+                    featureMaps.push(block.features);
+                }
+            }
+            return new CompositeMap(featureMaps);
+        },
+        get featureUnderMouse() {
+            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?.getRectangles) {
+                    featureMaps.push(block.layout.getRectangles());
+                }
+            }
+            return new CompositeMap(featureMaps);
+        },
+        getFeatureOverlapping(blockKey, x, y) {
+            return self.blockState.get(blockKey)?.layout?.getByCoord(x, y);
+        },
+        getFeatureByID(blockKey, id) {
+            return self.blockState.get(blockKey)?.layout?.getByID(id);
+        },
+        searchFeatureByID(id) {
+            for (const block of self.blockState.values()) {
+                const val = block.layout?.getByID(id);
+                if (val) {
+                    return val;
+                }
+            }
+            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) {
+            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');
+                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(self).notifyError(`${e}`, e);
+                });
+            }
+        },
+        navToFeature(feature) {
+            const view = getContainingView(self);
+            view.navTo({
+                refName: feature.get('refName'),
+                start: feature.get('start'),
+                end: feature.get('end'),
+            });
+        },
+        clearFeatureSelection() {
+            getSession(self).clearSelection();
+        },
+        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;
+        return {
+            async reload() {
+                self.setError();
+                self.setCurrStatsBpPerPx(0);
+                self.clearFeatureDensityStats();
+                for (const val of self.blockState.values()) {
+                    val.doReload();
+                }
+                superReload();
+            },
+        };
+    })
+        .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
+                ? [
+                    {
+                        label: 'Open feature details',
+                        icon: MenuOpenIcon,
+                        onClick: () => {
+                            self.selectFeature(feat);
+                        },
+                    },
+                    {
+                        label: 'Zoom to feature',
+                        icon: CenterFocusStrongIcon,
+                        onClick: () => {
+                            self.navToFeature(feat);
+                        },
+                    },
+                    {
+                        label: 'Copy info to clipboard',
+                        icon: ContentCopyIcon,
+                        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,
+                                            },
+                                        ]);
+                                    }
+                                },
+                            },
+                        ]
+                        : []),
+                ]
+                : [];
+        },
+        renderingProps() {
+            return {
+                displayModel: self,
+                onMouseMove(_, featureId) {
+                    self.setFeatureIdUnderMouse(featureId);
+                },
+                onMouseLeave(_) {
+                    self.setFeatureIdUnderMouse(undefined);
+                },
+                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("./renderSvg.js");
+            return renderBaseLinearDisplaySvg(self, opts);
+        },
+        afterAttach() {
+            addDisposer(self, autorun(function blockDefinitionsAutorun() {
+                try {
+                    if (!isAlive(self)) {
+                        return;
+                    }
+                    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,
+            }));
+        },
+    }))
+        .preProcessSnapshot(snap => {
+        if (!snap) {
+            return snap;
+        }
+        const { height, ...rest } = snap;
+        return { heightPreConfig: height, ...rest };
+    })
+        .postProcessSnapshot(snap => {
+        const r = snap;
+        const { blockState, ...rest } = r;
+        return rest;
+    });
+}
+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 './BaseLinearDisplayModel';
+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;
         }

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

@@ -0,0 +1,24 @@
+import type { LinearGenomeViewModel } from '../../LinearGenomeView/index.ts';
+import type { BaseLinearDisplayModel } from '../model.ts';
+import type { Assembly } from '@jbrowse/core/assemblyManager/assembly';
+export interface RenderProps {
+    rendererType: any;
+    renderArgs: Record<string, any>;
+    renderProps: Record<string, any>;
+    displayError: unknown;
+    rpcManager: {
+        call: (...args: unknown[]) => void;
+    };
+    cannotBeRenderedReason: string;
+}
+export interface LabelData {
+    key: string;
+    label: string;
+    description: string;
+    leftPos: number;
+    topPos: number;
+}
+export interface ErrorProps {
+    displayError: string;
+}
+export declare function calculateLabelPositions(model: BaseLinearDisplayModel, view: LinearGenomeViewModel, assembly: Assembly | undefined, offsetPx: number): LabelData[];