@jbrowse/plugin-wiggle 2.16.0 → 2.17.0

package/esm/LinearWiggleDisplay/{models/model.js → model.js}

@@ -1,14 +1,14 @@
 import { lazy } from 'react';
 import { getConf, } from '@jbrowse/core/configuration';
-import { getSession } from '@jbrowse/core/util';
+import { getContainingView, getSession, } from '@jbrowse/core/util';
 import { types } from 'mobx-state-tree';
 import { axisPropsFromTickScale } from 'react-d3-axis-mod';
 // locals
-import { getScale, YSCALEBAR_LABEL_OFFSET } from '../../util';
-import SharedWiggleMixin from '../../shared/modelShared';
+import { getScale, YSCALEBAR_LABEL_OFFSET } from '../util';
+import SharedWiggleMixin from '../shared/SharedWiggleMixin';
 // lazies
-const Tooltip = lazy(() => import('../components/Tooltip'));
-const SetColorDialog = lazy(() => import('../components/SetColorDialog'));
+const Tooltip = lazy(() => import('./components/Tooltip'));
+const SetColorDialog = lazy(() => import('./components/SetColorDialog'));
 // using a map because it preserves order
 const rendererTypes = new Map([
     ['xyplot', 'XYPlotRenderer'],
@@ -46,29 +46,14 @@ function stateModelFactory(pluginManager, configSchema) {
             }
             return rendererType;
         },
-    }))
-        .views(self => ({
         /**
          * #getter
+         * unused currently
          */
-        get ticks() {
-            const { scaleType, domain, height } = self;
-            const minimalTicks = getConf(self, 'minimalTicks');
-            const inverted = getConf(self, 'inverted');
-            const range = [height - YSCALEBAR_LABEL_OFFSET, YSCALEBAR_LABEL_OFFSET];
-            if (!domain) {
-                return undefined;
-            }
-            const scale = getScale({
-                scaleType,
-                domain,
-                range,
-                inverted,
-            });
-            const ticks = axisPropsFromTickScale(scale, 4);
-            return height < 100 || minimalTicks
-                ? { ...ticks, values: domain }
-                : ticks;
+        get quantitativeStatsRelevantToCurrentZoom() {
+            var _a;
+            const view = getContainingView(self);
+            return ((_a = self.stats) === null || _a === void 0 ? void 0 : _a.currStatsBpPerPx) === view.bpPerPx;
         },
     }))
         .views(self => {
@@ -77,46 +62,93 @@ function stateModelFactory(pluginManager, configSchema) {
             /**
              * #method
              */
-            renderProps() {
+            adapterProps() {
                 const superProps = superRenderProps();
-                const { filters, ticks, height, resolution, scaleOpts } = self;
+                const { filters, resolution, scaleOpts } = self;
                 return {
                     ...superProps,
-                    notReady: superProps.notReady || !self.stats,
                     rpcDriverName: self.rpcDriverName,
                     displayModel: self,
                     config: self.rendererConfig,
                     displayCrossHatches: self.displayCrossHatchesSetting,
                     scaleOpts,
                     resolution,
-                    height,
-                    ticks,
                     filters,
                 };
             },
             /**
              * #getter
              */
-            get needsScalebar() {
-                const { rendererTypeName: type } = self;
-                return type === 'XYPlotRenderer' || type === 'LinePlotRenderer';
-            },
-            /**
-             * #getter
-             */
-            get fillSetting() {
-                if (self.filled) {
-                    return 0;
-                }
-                else if (self.minSize === 1) {
-                    return 1;
+            get ticks() {
+                const { scaleType, domain, height } = self;
+                const minimalTicks = getConf(self, 'minimalTicks');
+                const inverted = getConf(self, 'inverted');
+                if (domain) {
+                    const ticks = axisPropsFromTickScale(getScale({
+                        scaleType,
+                        domain,
+                        range: [
+                            height - YSCALEBAR_LABEL_OFFSET,
+                            YSCALEBAR_LABEL_OFFSET,
+                        ],
+                        inverted,
+                    }), 4);
+                    return height < 100 || minimalTicks
+                        ? { ...ticks, values: domain }
+                        : ticks;
                 }
                 else {
-                    return 2;
+                    return undefined;
                 }
             },
         };
     })
+        .views(self => ({
+        /**
+         * #method
+         */
+        renderProps() {
+            const { ticks, height } = self;
+            const superProps = self.adapterProps();
+            return {
+                ...self.adapterProps(),
+                notReady: superProps.notReady || !self.stats,
+                height,
+                ticks,
+            };
+        },
+        /**
+         * #getter
+         */
+        get needsScalebar() {
+            return (self.rendererTypeName === 'XYPlotRenderer' ||
+                self.rendererTypeName === 'LinePlotRenderer');
+        },
+        /**
+         * #getter
+         */
+        get fillSetting() {
+            if (self.filled) {
+                return 0;
+            }
+            else if (self.minSize === 1) {
+                return 1;
+            }
+            else {
+                return 2;
+            }
+        },
+        /**
+         * #getter
+         */
+        get quantitativeStatsReady() {
+            const view = getContainingView(self);
+            return (view.initialized &&
+                self.featureDensityStatsReady &&
+                !self.regionTooLarge &&
+                !self.error);
+        },
+    }))
         .views(self => {
         const { trackMenuItems: superTrackMenuItems } = self;
         const hasRenderings = getConf(self, 'defaultRendering');
@@ -178,7 +210,10 @@ function stateModelFactory(pluginManager, configSchema) {
                         onClick: () => {
                             getSession(self).queueDialog(handleClose => [
                                 SetColorDialog,
-                                { model: self, handleClose },
+                                {
+                                    model: self,
+                                    handleClose,
+                                },
                             ]);
                         },
                     },
@@ -193,8 +228,8 @@ function stateModelFactory(pluginManager, configSchema) {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 ;
                 (async () => {
-                    const { quantitativeStatsAutorun } = await import('../../util');
-                    quantitativeStatsAutorun(self);
+                    const { getQuantitativeStatsAutorun } = await import('../getQuantitativeStatsAutorun');
+                    getQuantitativeStatsAutorun(self);
                 })();
             },
             /**

package/esm/LinearWiggleDisplay/{models/renderSvg.js → renderSvg.js}

@@ -1,7 +1,8 @@
 import React from 'react';
 import { getContainingView } from '@jbrowse/core/util';
 import { when } from 'mobx';
-import YScaleBar from '../../shared/YScaleBar';
+// locals
+import YScaleBar from '../shared/YScaleBar';
 export async function renderSvg(self, opts, superRenderSvg) {
     await when(() => !!self.stats && !!self.regionCannotBeRenderedText);
     const { needsScalebar, stats } = self;

package/esm/MultiLinearWiggleDisplay/components/ColorLegend.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 declare const ColorLegend: ({ model, rowHeight, labelWidth, exportSVG, }: {
     model: WiggleDisplayModel;
     rowHeight: number;

package/esm/MultiLinearWiggleDisplay/components/ScoreLegend.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 declare const ScoreLegend: ({ model }: {
     model: WiggleDisplayModel;
 }) => React.JSX.Element;

package/esm/MultiLinearWiggleDisplay/components/WiggleDisplayComponent.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 declare const MultiLinearWiggleDisplayComponent: (props: {
     model: WiggleDisplayModel;
 }) => React.JSX.Element;

package/esm/MultiLinearWiggleDisplay/components/YScaleBars.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 export declare const YScaleBars: (props: {
     model: WiggleDisplayModel;
     orientation?: string;

package/esm/MultiLinearWiggleDisplay/components/util.d.ts

@@ -1,4 +1,4 @@
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 export declare function moveUp(arr: {
     name: string;
 }[], sel: string[], by?: number): {

package/esm/MultiLinearWiggleDisplay/{models/configSchema.js → configSchema.js}

@@ -1,7 +1,7 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { types } from 'mobx-state-tree';
 // locals
-import sharedWiggleConfigFactory from '../../shared/configShared';
+import sharedWiggleConfigFactory from '../shared/SharedWiggleConfigSchema';
 /**
  * #config MultiLinearWiggleDisplay
  * extends

package/esm/MultiLinearWiggleDisplay/index.js

@@ -1,6 +1,6 @@
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
-import configSchemaFactory from './models/configSchema';
-import modelFactory from './models/model';
+import configSchemaFactory from './configSchema';
+import modelFactory from './model';
 import { lazy } from 'react';
 export default function MultiLinearWiggleDisplayF(pluginManager) {
     pluginManager.addDisplayType(() => {

package/esm/MultiLinearWiggleDisplay/{models/model.d.ts → model.d.ts}

@@ -3,11 +3,7 @@ import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
 import { Feature, AnyReactComponentType } from '@jbrowse/core/util';
 import PluginManager from '@jbrowse/core/PluginManager';
 import { ExportSvgDisplayOptions } from '@jbrowse/plugin-linear-genome-view';
-interface Source {
-    name: string;
-    color?: string;
-    group?: string;
-}
+import { Source } from '../util';
 /**
  * #stateModel MultiLinearWiggleDisplay
  * extends
@@ -166,12 +162,12 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
             rendererTypeName: string;
             error: unknown;
             message: string | undefined;
-        } & import("mobx-state-tree" /**
-         * #action
-         */).IStateTreeNode<import("mobx-state-tree").IModelType<{
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
             id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
             type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+            rpcDriverName: import("mobx-state-tree" /**
+             * #getter
+             */).IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
             error: unknown;
@@ -261,19 +257,21 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
 } & {
     message: undefined | string;
     stats: {
+        currStatsBpPerPx: number;
         scoreMin: number;
         scoreMax: number;
     } | undefined;
     statsFetchInProgress: undefined | AbortController;
 } & {
     updateQuantitativeStats(stats: {
+        currStatsBpPerPx: number;
         scoreMin: number;
         scoreMax: number;
     }): void;
     setColor(color?: string): void;
     setPosColor(color?: string): void;
     setNegColor(color?: string): void;
-    setLoading(aborter: AbortController): void;
+    setStatsLoading(aborter: AbortController): void;
     selectFeature(feature: Feature): void;
     setResolution(res: number): void;
     setFill(fill: number): void;
@@ -303,7 +301,9 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
         } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
             setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
                 [x: string]: any;
-            } & import("mobx-state-tree/dist/internal").NonEmptyObject & any & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
+            } & import("mobx-state-tree/dist/internal" /**
+             * #property
+             */).NonEmptyObject & any & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
         } & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
     } & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>;
     readonly autoscaleType: any;
@@ -315,6 +315,7 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
     readonly scaleOpts: {
         domain: number[] | undefined;
         stats: {
+            currStatsBpPerPx: number;
             scoreMin: number;
             scoreMax: number;
         } | undefined;
@@ -402,6 +403,9 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
      * implemented like this yet but flag can be used for this
      */
     readonly needsCustomLegend: boolean;
+    /**
+     * #getter
+     */
     readonly canHaveFill: boolean;
     /**
      * #getter
@@ -421,9 +425,14 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
      */
     readonly sources: {
         color: string;
+        baseUri?: string;
         name: string;
         group?: string;
     }[] | undefined;
+    /**
+     * #getter
+     */
+    readonly quantitativeStatsReady: boolean;
 } & {
     /**
      * #getter
@@ -438,6 +447,10 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
      */
     readonly useMinimalTicks: any;
 } & {
+    /**
+     * #method
+     */
+    adapterProps(): any;
     /**
      * #getter
      */
@@ -451,6 +464,11 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
      * #getter
      */
     readonly colors: string[];
+    /**
+     * #getter
+     * unused currently
+     */
+    readonly quantitativeStatsRelevantToCurrentZoom: boolean;
 } & {
     /**
      * #method
@@ -467,7 +485,7 @@ export declare function stateModelFactory(pluginManager: PluginManager, configSc
     /**
      * #getter
      */
-    readonly fillSetting: 2 | 0 | 1;
+    readonly fillSetting: 2 | 1 | 0;
 } & {
     /**
      * #method

package/esm/MultiLinearWiggleDisplay/{models/model.js → model.js}

@@ -1,20 +1,18 @@
 import { lazy } from 'react';
-import { addDisposer, isAlive, types } from 'mobx-state-tree';
-import { autorun } from 'mobx';
+import { isAlive, types } from 'mobx-state-tree';
 import { axisPropsFromTickScale } from 'react-d3-axis-mod';
 import deepEqual from 'fast-deep-equal';
 // jbrowse imports
 import { getConf, } from '@jbrowse/core/configuration';
-import { getSession } from '@jbrowse/core/util';
-import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { getSession, getContainingView, } from '@jbrowse/core/util';
 import { set1 as colors } from '@jbrowse/core/ui/colors';
 // locals
-import { getScale, YSCALEBAR_LABEL_OFFSET } from '../../util';
-import SharedWiggleMixin from '../../shared/modelShared';
+import { getScale, YSCALEBAR_LABEL_OFFSET } from '../util';
+import SharedWiggleMixin from '../shared/SharedWiggleMixin';
 const randomColor = () => '#000000'.replaceAll('0', () => (~~(Math.random() * 16)).toString(16));
 // lazies
-const Tooltip = lazy(() => import('../components/Tooltip'));
-const SetColorDialog = lazy(() => import('../components/SetColorDialog'));
+const Tooltip = lazy(() => import('./components/Tooltip'));
+const SetColorDialog = lazy(() => import('./components/SetColorDialog'));
 // using a map because it preserves order
 const rendererTypes = new Map([
     ['xyplot', 'MultiXYPlotRenderer'],
@@ -130,6 +128,9 @@ export function stateModelFactory(pluginManager, configSchema) {
         get needsCustomLegend() {
             return self.rendererTypeName === 'MultiDensityRenderer';
         },
+        /**
+         * #getter
+         */
         get canHaveFill() {
             return (self.rendererTypeName === 'MultiXYPlotRenderer' ||
                 self.rendererTypeName === 'MultiRowXYPlotRenderer');
@@ -168,6 +169,16 @@ export function stateModelFactory(pluginManager, configSchema) {
                     (!this.isMultiRow ? colors[i] || randomColor() : 'blue'),
             }));
         },
+        /**
+         * #getter
+         */
+        get quantitativeStatsReady() {
+            const view = getContainingView(self);
+            return (view.initialized &&
+                self.featureDensityStatsReady &&
+                !self.regionTooLarge &&
+                !self.error);
+        },
     }))
         .views(self => ({
         /**
@@ -189,42 +200,6 @@ export function stateModelFactory(pluginManager, configSchema) {
         get useMinimalTicks() {
             return (getConf(self, 'minimalTicks') || this.rowHeightTooSmallForScalebar);
         },
-    }))
-        .views(self => ({
-        /**
-         * #getter
-         */
-        get ticks() {
-            const { scaleType, domain, isMultiRow, rowHeight, useMinimalTicks } = self;
-            if (!domain) {
-                return undefined;
-            }
-            const offset = isMultiRow ? 0 : YSCALEBAR_LABEL_OFFSET;
-            const ticks = axisPropsFromTickScale(getScale({
-                scaleType,
-                domain,
-                range: [rowHeight - offset, offset],
-                inverted: getConf(self, 'inverted'),
-            }), 4);
-            return useMinimalTicks ? { ...ticks, values: domain } : ticks;
-        },
-        /**
-         * #getter
-         */
-        get colors() {
-            return [
-                'red',
-                'blue',
-                'green',
-                'orange',
-                'purple',
-                'cyan',
-                'pink',
-                'darkblue',
-                'darkred',
-                'pink',
-            ];
-        },
     }))
         .views(self => {
         const { renderProps: superRenderProps } = self;
@@ -232,58 +207,114 @@ export function stateModelFactory(pluginManager, configSchema) {
             /**
              * #method
              */
-            renderProps() {
+            adapterProps() {
                 const superProps = superRenderProps();
-                const { displayCrossHatches, filters, height, resolution, rpcDriverName, scaleOpts, stats, sources, ticks, rendererConfig: config, } = self;
                 return {
                     ...superProps,
-                    notReady: superProps.notReady || !sources || !stats,
                     displayModel: self,
-                    config,
-                    displayCrossHatches,
-                    filters,
-                    height,
-                    resolution,
-                    rpcDriverName,
-                    scaleOpts,
-                    sources,
-                    ticks,
-                    onMouseMove: (_, f) => {
-                        self.setFeatureUnderMouse(f);
-                    },
-                    onMouseLeave: () => {
-                        self.setFeatureUnderMouse(undefined);
-                    },
+                    config: self.rendererConfig,
+                    filters: self.filters,
+                    resolution: self.resolution,
+                    rpcDriverName: self.rpcDriverName,
+                    sources: self.sources,
                 };
             },
             /**
              * #getter
              */
-            get hasResolution() {
-                return self.adapterCapabilities.includes('hasResolution');
+            get ticks() {
+                const { scaleType, domain, isMultiRow, rowHeight, useMinimalTicks } = self;
+                if (!domain) {
+                    return undefined;
+                }
+                const offset = isMultiRow ? 0 : YSCALEBAR_LABEL_OFFSET;
+                const ticks = axisPropsFromTickScale(getScale({
+                    scaleType,
+                    domain,
+                    range: [rowHeight - offset, offset],
+                    inverted: getConf(self, 'inverted'),
+                }), 4);
+                return useMinimalTicks ? { ...ticks, values: domain } : ticks;
             },
             /**
              * #getter
              */
-            get hasGlobalStats() {
-                return self.adapterCapabilities.includes('hasGlobalStats');
+            get colors() {
+                return [
+                    'red',
+                    'blue',
+                    'green',
+                    'orange',
+                    'purple',
+                    'cyan',
+                    'pink',
+                    'darkblue',
+                    'darkred',
+                    'pink',
+                ];
             },
             /**
              * #getter
+             * unused currently
              */
-            get fillSetting() {
-                if (self.filled) {
-                    return 0;
-                }
-                else if (self.minSize === 1) {
-                    return 1;
-                }
-                else {
-                    return 2;
-                }
+            get quantitativeStatsRelevantToCurrentZoom() {
+                var _a;
+                const view = getContainingView(self);
+                return ((_a = self.stats) === null || _a === void 0 ? void 0 : _a.currStatsBpPerPx) === view.bpPerPx;
             },
         };
     })
+        .views(self => ({
+        /**
+         * #method
+         */
+        renderProps() {
+            const superProps = self.adapterProps();
+            return {
+                ...superProps,
+                notReady: superProps.notReady || !self.sources || !self.stats,
+                displayModel: self,
+                rpcDriverName: self.rpcDriverName,
+                displayCrossHatches: self.displayCrossHatches,
+                height: self.height,
+                ticks: self.ticks,
+                stats: self.stats,
+                scaleOpts: self.scaleOpts,
+                onMouseMove: (_, f) => {
+                    self.setFeatureUnderMouse(f);
+                },
+                onMouseLeave: () => {
+                    self.setFeatureUnderMouse(undefined);
+                },
+            };
+        },
+        /**
+         * #getter
+         */
+        get hasResolution() {
+            return self.adapterCapabilities.includes('hasResolution');
+        },
+        /**
+         * #getter
+         */
+        get hasGlobalStats() {
+            return self.adapterCapabilities.includes('hasGlobalStats');
+        },
+        /**
+         * #getter
+         */
+        get fillSetting() {
+            if (self.filled) {
+                return 0;
+            }
+            else if (self.minSize === 1) {
+                return 1;
+            }
+            else {
+                return 2;
+            }
+        },
+    }))
         .views(self => {
         const { trackMenuItems: superTrackMenuItems } = self;
         const hasRenderings = getConf(self, 'defaultRendering');
@@ -366,20 +397,20 @@ export function stateModelFactory(pluginManager, configSchema) {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 ;
                 (async () => {
-                    const { quantitativeStatsAutorun } = await import('../../util');
-                    quantitativeStatsAutorun(self);
-                    addDisposer(self, autorun(async () => {
-                        const { rpcManager } = getSession(self);
-                        const { adapterConfig } = self;
-                        const sessionId = getRpcSessionId(self);
-                        const sources = (await rpcManager.call(sessionId, 'MultiWiggleGetSources', {
-                            sessionId,
-                            adapterConfig,
-                        }));
+                    try {
+                        const [{ getMultiWiggleSourcesAutorun }, { getQuantitativeStatsAutorun },] = await Promise.all([
+                            import('../getMultiWiggleSourcesAutorun'),
+                            import('../getQuantitativeStatsAutorun'),
+                        ]);
+                        getQuantitativeStatsAutorun(self);
+                        getMultiWiggleSourcesAutorun(self);
+                    }
+                    catch (e) {
                         if (isAlive(self)) {
-                            self.setSources(sources);
+                            console.error(e);
+                            getSession(self).notifyError(`${e}`, e);
                         }
-                    }));
+                    }
                 })();
             },
             /**

package/esm/MultiLinearWiggleDisplay/{models/renderSvg.js → renderSvg.js}

@@ -1,7 +1,7 @@
 import React from 'react';
 import { getContainingView } from '@jbrowse/core/util';
 import { when } from 'mobx';
-import YScaleBars from '../components/YScaleBars';
+import YScaleBars from './components/YScaleBars';
 export async function renderSvg(self, opts, superRenderSvg) {
     await when(() => !!self.stats && !!self.regionCannotBeRenderedText);
     const { offsetPx } = getContainingView(self);