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

package/dist/BaseLinearDisplay/models/FeatureDensityMixin.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const react_1 = __importDefault(require("react"));
+const configuration_1 = require("@jbrowse/core/configuration");
+const util_1 = require("@jbrowse/core/util");
+const mobx_1 = require("mobx");
+const mobx_state_tree_1 = require("mobx-state-tree");
+const TooLargeMessage_1 = __importDefault(require("../components/TooLargeMessage"));
+const util_2 = require("./util");
+const autorunFeatureDensityStats_1 = __importDefault(require("./autorunFeatureDensityStats"));
+/**
+ * #stateModel FeatureDensityMixin
+ * #category display
+ */
+function FeatureDensityMixin() {
+    return mobx_state_tree_1.types
+        .model({
+        /**
+         * #property
+         */
+        userBpPerPxLimit: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.number),
+        /**
+         * #property
+         */
+        userByteSizeLimit: mobx_state_tree_1.types.maybe(mobx_state_tree_1.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 = (0, util_1.getContainingView)(self);
+            return (((_a = self.featureDensityStats) === null || _a === void 0 ? void 0 : _a.featureDensity) || 0) * view.bpPerPx;
+        },
+        /**
+         * #getter
+         */
+        get maxFeatureScreenDensity() {
+            // @ts-expect-error
+            return (0, configuration_1.getConf)(self, 'maxFeatureScreenDensity');
+        },
+        /**
+         * #getter
+         */
+        get featureDensityStatsReady() {
+            const view = (0, util_1.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
+                (0, configuration_1.getConf)(self, 'fetchSizeLimit'));
+        },
+    }))
+        .actions(self => ({
+        afterAttach() {
+            (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(() => (0, autorunFeatureDensityStats_1.default)(self)));
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setCurrStatsBpPerPx(n) {
+            self.currStatsBpPerPx = n;
+        },
+        /**
+         * #action
+         */
+        setFeatureDensityStatsLimit(stats) {
+            const view = (0, util_1.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 = (0, util_2.getFeatureDensityStatsPre)(self).catch(e => {
+                    if ((0, mobx_state_tree_1.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 = (0, util_1.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 (${(0, util_2.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_1.default.createElement(TooLargeMessage_1.default, { model: self })) : null;
+        },
+    }));
+}
+exports.default = FeatureDensityMixin;

package/dist/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/dist/BaseLinearDisplay/models/TrackHeightMixin.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const configuration_1 = require("@jbrowse/core/configuration");
+const mobx_state_tree_1 = require("mobx-state-tree");
+const minDisplayHeight = 20;
+/**
+ * #stateModel TrackHeightMixin
+ * #category display
+ */
+function TrackHeightMixin() {
+    return mobx_state_tree_1.types
+        .model({
+        /**
+         * #property
+         */
+        heightPreConfig: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.refinement('displayHeight', mobx_state_tree_1.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 : (0, configuration_1.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;
+        },
+    }));
+}
+exports.default = TrackHeightMixin;

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

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

package/dist/BaseLinearDisplay/models/autorunFeatureDensityStats.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("@jbrowse/core/util");
+const mobx_state_tree_1 = require("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)
+async function autorunFeatureDensityStats(self) {
+    var _a;
+    try {
+        const view = (0, util_1.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 ((0, mobx_state_tree_1.isAlive)(self)) {
+            self.setFeatureDensityStats(stats);
+        }
+    }
+    catch (e) {
+        if (!(0, util_1.isAbortException)(e) && (0, mobx_state_tree_1.isAlive)(self)) {
+            console.error(e);
+            self.setError(e);
+        }
+    }
+}
+exports.default = autorunFeatureDensityStats;

package/dist/BaseLinearDisplay/models/configSchema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("@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)
@@ -49,4 +50,3 @@ const baseLinearDisplayConfigSchema = (0, configuration_1.ConfigurationSchema)('
     explicitIdentifier: 'displayId',
 });
 exports.default = baseLinearDisplayConfigSchema;
-//# sourceMappingURL=configSchema.js.map

package/dist/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/dist/BaseLinearDisplay/models/renderSvg.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const util_1 = require("@jbrowse/core/util");
+const serverSideRenderedBlock_1 = __importStar(require("./serverSideRenderedBlock"));
+const util_2 = require("./util");
+async function renderBaseLinearDisplaySvg(self, opts) {
+    const { height, id } = self;
+    const { overrideHeight } = opts;
+    const view = (0, util_1.getContainingView)(self);
+    const { offsetPx: viewOffsetPx, roundedDynamicBlocks, width } = view;
+    const renderings = await Promise.all(roundedDynamicBlocks.map(async (block) => {
+        const blockState = serverSideRenderedBlock_1.default.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_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement("rect", { x: 0, y: 0, width: width, height: 20, fill: "#aaa" }),
+                        react_1.default.createElement("text", { x: 0, y: 15 }, cannotBeRenderedReason))),
+                },
+            ];
+        }
+        const { rpcManager, renderArgs, renderProps, rendererType } = (0, serverSideRenderedBlock_1.renderBlockData)(blockState, self);
+        return [
+            block,
+            await rendererType.renderInClient(rpcManager, {
+                ...renderArgs,
+                ...renderProps,
+                viewParams: (0, util_1.getViewParams)(self, true),
+                exportSVG: opts,
+                theme: opts.theme || renderProps.theme,
+            }),
+        ];
+    }));
+    return (react_1.default.createElement(react_1.default.Fragment, null, renderings.map(([block, rendering], index) => {
+        const { offsetPx, widthPx } = block;
+        const offset = offsetPx - viewOffsetPx;
+        const clipid = (0, util_2.getId)(id, index);
+        return (react_1.default.createElement(react_1.default.Fragment, { key: `frag-${index}` },
+            react_1.default.createElement("defs", null,
+                react_1.default.createElement("clipPath", { id: clipid },
+                    react_1.default.createElement("rect", { x: 0, y: 0, width: widthPx, height: overrideHeight || height }))),
+            react_1.default.createElement("g", { transform: `translate(${offset} 0)` },
+                react_1.default.createElement("g", { clipPath: `url(#${clipid})` },
+                    react_1.default.createElement(util_1.ReactRendering, { rendering: rendering })))));
+    })));
+}
+exports.default = renderBaseLinearDisplaySvg;

package/dist/BaseLinearDisplay/models/serverSideRenderedBlock.js

@@ -134,22 +134,26 @@ const blockState = mobx_state_tree_1.types
             (0, mobx_state_tree_1.getParent)(self, 2).reload();
         },
         beforeDestroy() {
-            if (renderInProgress && !renderInProgress.signal.aborted) {
-                renderInProgress.abort();
-            }
-            const display = (0, util_1.getContainingDisplay)(self);
-            const { rpcManager } = (0, util_1.getSession)(self);
-            const { rendererType } = display;
-            const { renderArgs } = renderBlockData((0, mobx_state_tree_1.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 = (0, util_1.getContainingDisplay)(self);
+                    const { rpcManager } = (0, util_1.getSession)(self);
+                    const { rendererType } = display;
+                    const { renderArgs } = renderBlockData((0, mobx_state_tree_1.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);
+                }
+            })();
         },
     };
 });
@@ -237,4 +241,3 @@ async function renderBlockEffect(props, signal, self) {
         renderProps,
     };
 }
-//# sourceMappingURL=serverSideRenderedBlock.js.map

package/dist/BaseLinearDisplay/models/util.js

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

package/dist/BasicTrack/configSchema.js

@@ -4,6 +4,7 @@ const configuration_1 = require("@jbrowse/core/configuration");
 const pluggableElementTypes_1 = require("@jbrowse/core/pluggableElementTypes");
 /**
  * #config BasicTrack
+ * #category track
  * synonym for FeatureTrack
  */
 function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
@@ -15,4 +16,3 @@ const configSchema = (pluginManager) => (0, configuration_1.ConfigurationSchema)
     explicitIdentifier: 'trackId',
 });
 exports.default = configSchema;
-//# sourceMappingURL=configSchema.js.map

package/dist/BasicTrack/index.js

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

package/dist/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/dist/FeatureTrack/configSchema.js

@@ -4,6 +4,7 @@ const configuration_1 = require("@jbrowse/core/configuration");
 const pluggableElementTypes_1 = require("@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
@@ -18,4 +19,3 @@ const configSchema = (pluginManager) => (0, configuration_1.ConfigurationSchema)
     explicitIdentifier: 'trackId',
 });
 exports.default = configSchema;
-//# sourceMappingURL=configSchema.js.map

package/dist/FeatureTrack/index.js

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

package/dist/LaunchLinearGenomeView/index.js

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

package/dist/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/dist/LinearBareDisplay/configSchema.js

@@ -5,6 +5,7 @@ const configuration_1 = require("@jbrowse/core/configuration");
 const BaseLinearDisplay_1 = require("../BaseLinearDisplay");
 /**
  * #config LinearBareDisplay
+ * #category display
  */
 function configSchemaFactory(pluginManager) {
     return (0, configuration_1.ConfigurationSchema)('LinearBareDisplay', {
@@ -21,4 +22,3 @@ function configSchemaFactory(pluginManager) {
     });
 }
 exports.configSchemaFactory = configSchemaFactory;
-//# sourceMappingURL=configSchema.js.map

package/dist/LinearBareDisplay/index.js

@@ -24,4 +24,3 @@ var configSchema_2 = require("./configSchema");
 Object.defineProperty(exports, "configSchemaFactory", { enumerable: true, get: function () { return configSchema_2.configSchemaFactory; } });
 var model_2 = require("./model");
 Object.defineProperty(exports, "stateModelFactory", { enumerable: true, get: function () { return model_2.stateModelFactory; } });
-//# sourceMappingURL=index.js.map