@jbrowse/plugin-linear-genome-view 2.5.0 → 2.6.2

package/esm/BaseLinearDisplay/models/FeatureDensityMixin.js

@@ -0,0 +1,183 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import React from 'react';
+import { getConf } from '@jbrowse/core/configuration';
+import { getContainingView } from '@jbrowse/core/util';
+import { autorun } from 'mobx';
+import { addDisposer, isAlive, types } from 'mobx-state-tree';
+import TooLargeMessage from '../components/TooLargeMessage';
+import { getDisplayStr, getFeatureDensityStatsPre } from './util';
+import autorunFeatureDensityStats from './autorunFeatureDensityStats';
+/**
+ * #stateModel FeatureDensityMixin
+ * #category display
+ */
+export default function FeatureDensityMixin() {
+    return types
+        .model({
+        /**
+         * #property
+         */
+        userBpPerPxLimit: types.maybe(types.number),
+        /**
+         * #property
+         */
+        userByteSizeLimit: types.maybe(types.number),
+    })
+        .volatile(() => ({
+        featureDensityStatsP: undefined,
+        featureDensityStats: undefined,
+        currStatsBpPerPx: 0,
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get currentBytesRequested() {
+            var _a;
+            return ((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.bytes) || 0;
+        },
+        /**
+         * #getter
+         */
+        get currentFeatureScreenDensity() {
+            var _a;
+            const view = getContainingView(self);
+            return (((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.featureDensity) || 0) * view.bpPerPx;
+        },
+        /**
+         * #getter
+         */
+        get maxFeatureScreenDensity() {
+            // @ts-expect-error
+            return getConf(self, 'maxFeatureScreenDensity');
+        },
+        /**
+         * #getter
+         */
+        get featureDensityStatsReady() {
+            const view = getContainingView(self);
+            return (self.currStatsBpPerPx === view.bpPerPx &&
+                (!!self.featureDensityStats || !!self.userBpPerPxLimit));
+        },
+        /**
+         * #getter
+         */
+        get maxAllowableBytes() {
+            var _a;
+            return (self.userByteSizeLimit ||
+                ((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.fetchSizeLimit) ||
+                // @ts-expect-error
+                getConf(self, 'fetchSizeLimit'));
+        },
+    }))
+        .actions(self => ({
+        afterAttach() {
+            addDisposer(self, autorun(() => autorunFeatureDensityStats(self)));
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setCurrStatsBpPerPx(n) {
+            self.currStatsBpPerPx = n;
+        },
+        /**
+         * #action
+         */
+        setFeatureDensityStatsLimit(stats) {
+            const view = getContainingView(self);
+            if (stats === null || stats === void 0 ? void 0 : stats.bytes) {
+                self.userByteSizeLimit = stats.bytes;
+            }
+            else {
+                self.userBpPerPxLimit = view.bpPerPx;
+            }
+        },
+        /**
+         * #action
+         */
+        async getFeatureDensityStats() {
+            if (!self.featureDensityStatsP) {
+                self.featureDensityStatsP = getFeatureDensityStatsPre(self).catch(e => {
+                    if (isAlive(self)) {
+                        this.setFeatureDensityStatsP(undefined);
+                    }
+                    throw e;
+                });
+            }
+            return self.featureDensityStatsP;
+        },
+        /**
+         * #action
+         */
+        setFeatureDensityStatsP(arg) {
+            self.featureDensityStatsP = arg;
+        },
+        /**
+         * #action
+         */
+        setFeatureDensityStats(featureDensityStats) {
+            self.featureDensityStats = featureDensityStats;
+        },
+        /**
+         * #action
+         */
+        clearFeatureDensityStats() {
+            self.featureDensityStatsP = undefined;
+            self.featureDensityStats = undefined;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * region is too large if:
+         * - stats are ready
+         * - region is greater than 20kb (don't warn when zoomed in less than that)
+         * - and bytes is greater than max allowed bytes or density greater than max
+         *   density
+         */
+        get regionTooLarge() {
+            const view = getContainingView(self);
+            if (!self.featureDensityStatsReady ||
+                view.dynamicBlocks.totalBp < 20000) {
+                return false;
+            }
+            return (self.currentBytesRequested > self.maxAllowableBytes ||
+                (self.userBpPerPxLimit
+                    ? view.bpPerPx > self.userBpPerPxLimit
+                    : self.currentFeatureScreenDensity > self.maxFeatureScreenDensity));
+        },
+        /**
+         * #getter
+         * only shows a message of bytes requested is defined, the feature density
+         * based stats don't produce any helpful message besides to zoom in
+         */
+        get regionTooLargeReason() {
+            const req = self.currentBytesRequested;
+            const max = self.maxAllowableBytes;
+            return req && req > max
+                ? `Requested too much data (${getDisplayStr(req)})`
+                : '';
+        },
+    }))
+        .views(self => ({
+        /**
+         * #method
+         */
+        regionCannotBeRenderedText(_region) {
+            return self.regionTooLarge ? 'Force load to see features' : '';
+        },
+        /**
+         * #method
+         * @param region -
+         * @returns falsy if the region is fine to try rendering. Otherwise,
+         *  return a react node + string of text.
+         *  string of text describes why it cannot be rendered
+         *  react node allows user to force load at current setting
+         */
+        regionCannotBeRendered(_region) {
+            return self.regionTooLarge ? (React.createElement(TooLargeMessage, { model: self })) : null;
+        },
+    }));
+}

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

@@ -0,0 +1,30 @@
+/**
+ * #stateModel TrackHeightMixin
+ * #category display
+ */
+export default function TrackHeightMixin(): import("mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
+    heightPreConfig: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+}, {
+    /**
+     * #property
+     */
+    scrollTop: number;
+} & {
+    readonly height: number;
+} & {
+    /**
+     * #action
+     */
+    setScrollTop(scrollTop: number): void;
+    /**
+     * #action
+     */
+    setHeight(displayHeight: number): number;
+    /**
+     * #action
+     */
+    resizeHeight(distance: number): number;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;

package/esm/BaseLinearDisplay/models/TrackHeightMixin.js

@@ -0,0 +1,52 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { types } from 'mobx-state-tree';
+const minDisplayHeight = 20;
+/**
+ * #stateModel TrackHeightMixin
+ * #category display
+ */
+export default function TrackHeightMixin() {
+    return types
+        .model({
+        /**
+         * #property
+         */
+        heightPreConfig: types.maybe(types.refinement('displayHeight', types.number, n => n >= minDisplayHeight)),
+    })
+        .volatile(() => ({
+        /**
+         * #property
+         */
+        scrollTop: 0,
+    }))
+        .views(self => ({
+        get height() {
+            var _a;
+            // @ts-expect-error
+            return (_a = self.heightPreConfig) !== null && _a !== void 0 ? _a : getConf(self, 'height');
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setScrollTop(scrollTop) {
+            self.scrollTop = scrollTop;
+        },
+        /**
+         * #action
+         */
+        setHeight(displayHeight) {
+            self.heightPreConfig = Math.max(displayHeight, minDisplayHeight);
+            return self.height;
+        },
+        /**
+         * #action
+         */
+        resizeHeight(distance) {
+            const oldHeight = self.height;
+            const newHeight = this.setHeight(self.height + distance);
+            return newHeight - oldHeight;
+        },
+    }));
+}

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

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

package/esm/BaseLinearDisplay/models/autorunFeatureDensityStats.js

@@ -0,0 +1,38 @@
+import { getContainingView, isAbortException } from '@jbrowse/core/util';
+import { isAlive } from 'mobx-state-tree';
+// stats estimation autorun calls getFeatureDensityStats against the data
+// adapter which by default uses featureDensity, but can also respond with a
+// byte size estimate and fetch size limit (data adapter can define what is too
+// much data)
+export default async function autorunFeatureDensityStats(self) {
+    var _a;
+    try {
+        const view = getContainingView(self);
+        // extra check for contentBlocks.length
+        // https://github.com/GMOD/jbrowse-components/issues/2694
+        if (!view.initialized ||
+            !view.staticBlocks.contentBlocks.length ||
+            view.bpPerPx === self.currStatsBpPerPx ||
+            self.error) {
+            return;
+        }
+        // don't re-estimate featureDensity even if zoom level changes,
+        // jbrowse1-style assume it's sort of representative
+        if (((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.featureDensity) !== undefined) {
+            self.setCurrStatsBpPerPx(view.bpPerPx);
+            return;
+        }
+        self.clearFeatureDensityStats();
+        self.setCurrStatsBpPerPx(view.bpPerPx);
+        const stats = await self.getFeatureDensityStats();
+        if (isAlive(self)) {
+            self.setFeatureDensityStats(stats);
+        }
+    }
+    catch (e) {
+        if (!isAbortException(e) && isAlive(self)) {
+            console.error(e);
+            self.setError(e);
+        }
+    }
+}

package/esm/BaseLinearDisplay/models/configSchema.js

@@ -1,6 +1,7 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 /**
  * #config BaseLinearDisplay
+ * #category display
  * `BaseLinearDisplay` is a "base" config that is extended by classes like
  * `LinearBasicDisplay` (used for feature tracks, etc) and `LinearBareDisplay`
  * (more stripped down than even the basic display, not commonly used)
@@ -47,4 +48,3 @@ const baseLinearDisplayConfigSchema = ConfigurationSchema('BaseLinearDisplay', {
     explicitIdentifier: 'displayId',
 });
 export default baseLinearDisplayConfigSchema;
-//# sourceMappingURL=configSchema.js.map

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ThemeOptions } from '@mui/material';
+import { ExportSvgOptions } from '../../LinearGenomeView';
+import { BaseLinearDisplayModel } from './BaseLinearDisplayModel';
+export default function renderBaseLinearDisplaySvg(self: BaseLinearDisplayModel, opts: ExportSvgOptions & {
+    overrideHeight: number;
+    theme: ThemeOptions;
+}): Promise<React.JSX.Element>;

package/esm/BaseLinearDisplay/models/renderSvg.js

@@ -0,0 +1,53 @@
+import React from 'react';
+import { getContainingView, getViewParams, ReactRendering, } from '@jbrowse/core/util';
+import BlockState, { renderBlockData } from './serverSideRenderedBlock';
+import { getId } from './util';
+export default async function renderBaseLinearDisplaySvg(self, opts) {
+    const { height, id } = self;
+    const { overrideHeight } = opts;
+    const view = getContainingView(self);
+    const { offsetPx: viewOffsetPx, roundedDynamicBlocks, width } = view;
+    const renderings = await Promise.all(roundedDynamicBlocks.map(async (block) => {
+        const blockState = BlockState.create({
+            key: block.key,
+            region: block,
+        });
+        // regionCannotBeRendered can return jsx so look for plaintext
+        // version, or just get the default if none available
+        const cannotBeRenderedReason = self.regionCannotBeRenderedText(block) ||
+            self.regionCannotBeRendered(block);
+        if (cannotBeRenderedReason) {
+            return [
+                block,
+                {
+                    reactElement: (React.createElement(React.Fragment, null,
+                        React.createElement("rect", { x: 0, y: 0, width: width, height: 20, fill: "#aaa" }),
+                        React.createElement("text", { x: 0, y: 15 }, cannotBeRenderedReason))),
+                },
+            ];
+        }
+        const { rpcManager, renderArgs, renderProps, rendererType } = renderBlockData(blockState, self);
+        return [
+            block,
+            await rendererType.renderInClient(rpcManager, {
+                ...renderArgs,
+                ...renderProps,
+                viewParams: getViewParams(self, true),
+                exportSVG: opts,
+                theme: opts.theme || renderProps.theme,
+            }),
+        ];
+    }));
+    return (React.createElement(React.Fragment, null, renderings.map(([block, rendering], index) => {
+        const { offsetPx, widthPx } = block;
+        const offset = offsetPx - viewOffsetPx;
+        const clipid = getId(id, index);
+        return (React.createElement(React.Fragment, { key: `frag-${index}` },
+            React.createElement("defs", null,
+                React.createElement("clipPath", { id: clipid },
+                    React.createElement("rect", { x: 0, y: 0, width: widthPx, height: overrideHeight || height }))),
+            React.createElement("g", { transform: `translate(${offset} 0)` },
+                React.createElement("g", { clipPath: `url(#${clipid})` },
+                    React.createElement(ReactRendering, { rendering: rendering })))));
+    })));
+}

package/esm/BaseLinearDisplay/models/serverSideRenderedBlock.js

@@ -128,22 +128,26 @@ const blockState = types
             getParent(self, 2).reload();
         },
         beforeDestroy() {
-            if (renderInProgress && !renderInProgress.signal.aborted) {
-                renderInProgress.abort();
-            }
-            const display = getContainingDisplay(self);
-            const { rpcManager } = getSession(self);
-            const { rendererType } = display;
-            const { renderArgs } = renderBlockData(cast(self));
-            // renderArgs can be undefined if an error occurred in this block
-            if (renderArgs) {
-                rendererType
-                    .freeResourcesInClient(rpcManager, JSON.parse(JSON.stringify(renderArgs)))
-                    .catch((e) => {
-                    // just console.error if it's something while it's being destroyed
-                    console.warn('Error while destroying block', e);
-                });
-            }
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            ;
+            (async () => {
+                try {
+                    if (renderInProgress && !renderInProgress.signal.aborted) {
+                        renderInProgress.abort();
+                    }
+                    const display = getContainingDisplay(self);
+                    const { rpcManager } = getSession(self);
+                    const { rendererType } = display;
+                    const { renderArgs } = renderBlockData(cast(self));
+                    // renderArgs can be undefined if an error occurred in this block
+                    if (renderArgs) {
+                        await rendererType.freeResourcesInClient(rpcManager, JSON.parse(JSON.stringify(renderArgs)));
+                    }
+                }
+                catch (e) {
+                    console.error('Error while destroying block', e);
+                }
+            })();
         },
     };
 });
@@ -230,4 +234,3 @@ async function renderBlockEffect(props, signal, self) {
         renderProps,
     };
 }
-//# sourceMappingURL=serverSideRenderedBlock.js.map

package/esm/BaseLinearDisplay/models/util.js

@@ -41,4 +41,3 @@ export async function getFeatureDensityStatsPre(self) {
         },
     });
 }
-//# sourceMappingURL=util.js.map

package/esm/BasicTrack/configSchema.js

@@ -2,6 +2,7 @@ import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
 /**
  * #config BasicTrack
+ * #category track
  * synonym for FeatureTrack
  */
 function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
@@ -13,4 +14,3 @@ const configSchema = (pluginManager) => ConfigurationSchema('BasicTrack', {}, {
     explicitIdentifier: 'trackId',
 });
 export default configSchema;
-//# sourceMappingURL=configSchema.js.map

package/esm/BasicTrack/index.js

@@ -10,4 +10,3 @@ export default (pm) => {
         });
     });
 };
-//# sourceMappingURL=index.js.map

package/esm/FeatureTrack/configSchema.d.ts

@@ -7,9 +7,7 @@ declare const configSchema: (pluginManager: PluginManager) => import("@jbrowse/c
     };
     assemblyNames: {
         description: string;
-        type: string; /**
-         * #baseConfiguration
-         */
+        type: string;
         defaultValue: string[];
     };
     description: {

package/esm/FeatureTrack/configSchema.js

@@ -2,6 +2,7 @@ import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
 /**
  * #config FeatureTrack
+ * #category track
  * used for basic gene and feature tracks, generally used with LinearBasicDisplay
  */
 function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
@@ -16,4 +17,3 @@ const configSchema = (pluginManager) => ConfigurationSchema('FeatureTrack', {},
     explicitIdentifier: 'trackId',
 });
 export default configSchema;
-//# sourceMappingURL=configSchema.js.map

package/esm/FeatureTrack/index.js

@@ -11,4 +11,3 @@ export default (pm) => {
         });
     });
 };
-//# sourceMappingURL=index.js.map

package/esm/LaunchLinearGenomeView/index.js

@@ -39,4 +39,3 @@ export default (pluginManager) => {
         }
     });
 };
-//# sourceMappingURL=index.js.map

package/esm/LinearBareDisplay/configSchema.d.ts

@@ -1,6 +1,7 @@
 import PluginManager from '@jbrowse/core/PluginManager';
 /**
  * #config LinearBareDisplay
+ * #category display
  */
 declare function configSchemaFactory(pluginManager: PluginManager): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
     /**

package/esm/LinearBareDisplay/configSchema.js

@@ -2,6 +2,7 @@ import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { baseLinearDisplayConfigSchema } from '../BaseLinearDisplay';
 /**
  * #config LinearBareDisplay
+ * #category display
  */
 function configSchemaFactory(pluginManager) {
     return ConfigurationSchema('LinearBareDisplay', {
@@ -18,4 +19,3 @@ function configSchemaFactory(pluginManager) {
     });
 }
 export { configSchemaFactory };
-//# sourceMappingURL=configSchema.js.map

package/esm/LinearBareDisplay/index.js

@@ -19,4 +19,3 @@ export default (pluginManager) => {
 };
 export { configSchemaFactory } from './configSchema';
 export { stateModelFactory } from './model';
-//# sourceMappingURL=index.js.map