@jbrowse/plugin-wiggle 2.16.1 → 2.18.0

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

@@ -1,21 +1,16 @@
 import { lazy } from 'react';
-import { addDisposer, isAlive, types } from 'mobx-state-tree';
-import { autorun } from 'mobx';
-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 { getConf } from '@jbrowse/core/configuration';
 import { set1 as colors } from '@jbrowse/core/ui/colors';
-// locals
-import { getScale, YSCALEBAR_LABEL_OFFSET } from '../../util';
-import SharedWiggleMixin from '../../shared/modelShared';
+import { getContainingView, getSession } from '@jbrowse/core/util';
+import { stopStopToken } from '@jbrowse/core/util/stopToken';
+import deepEqual from 'fast-deep-equal';
+import { isAlive, types } from 'mobx-state-tree';
+import { axisPropsFromTickScale } from 'react-d3-axis-mod';
+import SharedWiggleMixin from '../shared/SharedWiggleMixin';
+import { YSCALEBAR_LABEL_OFFSET, getScale } from '../util';
 const randomColor = () => '#000000'.replaceAll('0', () => (~~(Math.random() * 16)).toString(16));
-// lazies
-const Tooltip = lazy(() => import('../components/Tooltip'));
-const SetColorDialog = lazy(() => import('../components/SetColorDialog'));
-// using a map because it preserves order
+const Tooltip = lazy(() => import('./components/Tooltip'));
+const SetColorDialog = lazy(() => import('./components/SetColorDialog'));
 const rendererTypes = new Map([
     ['xyplot', 'MultiXYPlotRenderer'],
     ['multirowxy', 'MultiRowXYPlotRenderer'],
@@ -23,71 +18,46 @@ const rendererTypes = new Map([
     ['multiline', 'MultiLineRenderer'],
     ['multirowline', 'MultiRowLineRenderer'],
 ]);
-/**
- * #stateModel MultiLinearWiggleDisplay
- * extends
- * - [SharedWiggleMixin](../sharedwigglemixin)
- */
 export function stateModelFactory(pluginManager, configSchema) {
     return types
         .compose('MultiLinearWiggleDisplay', SharedWiggleMixin(configSchema), types.model({
-        /**
-         * #property
-         */
         type: types.literal('MultiLinearWiggleDisplay'),
-        /**
-         * #property
-         */
         layout: types.optional(types.frozen(), []),
     }))
         .volatile(() => ({
+        sourcesLoadingStopToken: undefined,
         featureUnderMouseVolatile: undefined,
         sourcesVolatile: undefined,
     }))
         .actions(self => ({
-        /**
-         * #action
-         */
+        setSourcesLoading(str) {
+            if (self.sourcesLoadingStopToken) {
+                stopStopToken(self.sourcesLoadingStopToken);
+            }
+            self.sourcesLoadingStopToken = str;
+        },
         setLayout(layout) {
             self.layout = layout;
         },
-        /**
-         * #action
-         */
         clearLayout() {
             self.layout = [];
         },
-        /**
-         * #action
-         */
         setSources(sources) {
             if (!deepEqual(sources, self.sourcesVolatile)) {
                 self.sourcesVolatile = sources;
             }
         },
-        /**
-         * #action
-         */
         setFeatureUnderMouse(f) {
             self.featureUnderMouseVolatile = f;
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get featureUnderMouse() {
             return self.featureUnderMouseVolatile;
         },
-        /**
-         * #getter
-         */
         get TooltipComponent() {
             return Tooltip;
         },
-        /**
-         * #getter
-         */
         get rendererTypeName() {
             const name = self.rendererTypeNameSimple;
             const rendererType = rendererTypes.get(name);
@@ -98,35 +68,21 @@ export function stateModelFactory(pluginManager, configSchema) {
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get needsScalebar() {
             return (self.rendererTypeName === 'MultiXYPlotRenderer' ||
                 self.rendererTypeName === 'MultiRowXYPlotRenderer' ||
                 self.rendererTypeName === 'MultiLineRenderer' ||
                 self.rendererTypeName === 'MultiRowLineRenderer');
         },
-        /**
-         * #getter
-         */
         get needsFullHeightScalebar() {
             return (self.rendererTypeName === 'MultiXYPlotRenderer' ||
                 self.rendererTypeName === 'MultiLineRenderer');
         },
-        /**
-         * #getter
-         */
         get isMultiRow() {
             return (self.rendererTypeName === 'MultiRowXYPlotRenderer' ||
                 self.rendererTypeName === 'MultiRowLineRenderer' ||
                 self.rendererTypeName === 'MultiDensityRenderer');
         },
-        /**
-         * #getter
-         * can be used to give it a "color scale" like a R heatmap, not
-         * implemented like this yet but flag can be used for this
-         */
         get needsCustomLegend() {
             return self.rendererTypeName === 'MultiDensityRenderer';
         },
@@ -134,27 +90,13 @@ export function stateModelFactory(pluginManager, configSchema) {
             return (self.rendererTypeName === 'MultiXYPlotRenderer' ||
                 self.rendererTypeName === 'MultiRowXYPlotRenderer');
         },
-        /**
-         * #getter
-         * the multirowxy and multiline don't need to use colors on the legend
-         * boxes since their track is drawn with the color. sort of a stylistic
-         * choice
-         */
         get renderColorBoxes() {
             return !(self.rendererTypeName === 'MultiRowLineRenderer' ||
                 self.rendererTypeName === 'MultiRowXYPlotRenderer');
         },
-        /**
-         * #getter
-         * positions multi-row below the tracklabel even if using overlap
-         * tracklabels for everything else
-         */
         get prefersOffset() {
             return this.isMultiRow;
         },
-        /**
-         * #getter
-         */
         get sources() {
             var _a;
             const sources = Object.fromEntries(((_a = self.sourcesVolatile) === null || _a === void 0 ? void 0 : _a.map(s => [s.name, s])) || []);
@@ -168,129 +110,116 @@ export function stateModelFactory(pluginManager, configSchema) {
                     (!this.isMultiRow ? colors[i] || randomColor() : 'blue'),
             }));
         },
+        get quantitativeStatsReady() {
+            const view = getContainingView(self);
+            return (view.initialized && self.statsReadyAndRegionNotTooLarge && !self.error);
+        },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get rowHeight() {
             const { sources, height, isMultiRow } = self;
             return isMultiRow ? height / ((sources === null || sources === void 0 ? void 0 : sources.length) || 1) : height;
         },
-        /**
-         * #getter
-         */
         get rowHeightTooSmallForScalebar() {
             return this.rowHeight < 70;
         },
-        /**
-         * #getter
-         */
         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;
         return {
-            /**
-             * #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
-             */
-            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 => ({
+        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);
+                },
+            };
+        },
+        get hasResolution() {
+            return self.adapterCapabilities.includes('hasResolution');
+        },
+        get hasGlobalStats() {
+            return self.adapterCapabilities.includes('hasGlobalStats');
+        },
+        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');
         return {
-            /**
-             * #method
-             */
             trackMenuItems() {
                 return [
                     ...superTrackMenuItems(),
@@ -363,28 +292,24 @@ export function stateModelFactory(pluginManager, configSchema) {
         const { renderSvg: superRenderSvg } = self;
         return {
             afterAttach() {
-                // 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);
                         }
-                    }));
+                    }
                 })();
             },
-            /**
-             * #action
-             */
             async renderSvg(opts) {
                 const { renderSvg } = await import('./renderSvg');
                 return renderSvg(self, opts, superRenderSvg);

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

@@ -1,4 +1,4 @@
 import React from 'react';
-import { ExportSvgDisplayOptions } from '@jbrowse/plugin-linear-genome-view';
-import { WiggleDisplayModel } from './model';
+import type { WiggleDisplayModel } from './model';
+import type { ExportSvgDisplayOptions } from '@jbrowse/plugin-linear-genome-view';
 export declare function renderSvg(self: WiggleDisplayModel, opts: ExportSvgDisplayOptions, superRenderSvg: (opts: ExportSvgDisplayOptions) => Promise<React.ReactNode>): Promise<React.JSX.Element>;

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

@@ -1,12 +1,12 @@
 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);
     return (React.createElement(React.Fragment, null,
-        React.createElement("g", { id: "snpcov" }, await superRenderSvg(opts)),
+        React.createElement("g", null, await superRenderSvg(opts)),
         React.createElement("g", { transform: `translate(${Math.max(-offsetPx, 0)})` },
             React.createElement(YScaleBars, { model: self, orientation: "left", exportSVG: true }))));
 }

package/esm/MultiQuantitativeTrack/configSchema.d.ts

@@ -1,4 +1,4 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 declare const configSchema: (pluginManager: PluginManager) => import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
     name: {
         description: string;

package/esm/MultiQuantitativeTrack/configSchema.js

@@ -1,14 +1,8 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes/models';
-/**
- * #config MultiQuantitativeTrack
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+function x() { }
 const configSchema = (pluginManager) => {
     return ConfigurationSchema('MultiQuantitativeTrack', {}, {
-        /**
-         * #baseConfiguration
-         */
         baseConfiguration: createBaseTrackConfig(pluginManager),
     });
 };

package/esm/MultiQuantitativeTrack/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function MultiQuantitativeTrackF(pluginManager: PluginManager): void;

package/esm/MultiQuantitativeTrack/index.js

@@ -1,5 +1,5 @@
-import { createBaseTrackModel } from '@jbrowse/core/pluggableElementTypes/models';
 import TrackType from '@jbrowse/core/pluggableElementTypes/TrackType';
+import { createBaseTrackModel } from '@jbrowse/core/pluggableElementTypes/models';
 import configSchemaF from './configSchema';
 export default function MultiQuantitativeTrackF(pluginManager) {
     pluginManager.addTrackType(() => {

package/esm/MultiRowLineRenderer/MultiRowLineRenderer.d.ts

@@ -1,5 +1,6 @@
-import { Feature } from '@jbrowse/core/util';
-import WiggleBaseRenderer, { MultiRenderArgsDeserialized as MultiArgs } from '../WiggleBaseRenderer';
+import WiggleBaseRenderer from '../WiggleBaseRenderer';
+import type { MultiRenderArgsDeserialized as MultiArgs } from '../WiggleBaseRenderer';
+import type { Feature } from '@jbrowse/core/util';
 export default class MultiRowLineRenderer extends WiggleBaseRenderer {
     draw(ctx: CanvasRenderingContext2D, props: MultiArgs): Promise<{
         reducedFeatures: Feature[];

package/esm/MultiRowLineRenderer/MultiRowLineRenderer.js

@@ -1,8 +1,7 @@
 import { groupBy } from '@jbrowse/core/util';
-import { drawLine } from '../drawLine';
 import WiggleBaseRenderer from '../WiggleBaseRenderer';
+import { drawLine } from '../drawLine';
 export default class MultiRowLineRenderer extends WiggleBaseRenderer {
-    // @ts-expect-error
     async draw(ctx, props) {
         const { bpPerPx, sources, regions, features } = props;
         const region = regions[0];

package/esm/MultiRowLineRenderer/configSchema.d.ts

@@ -1,15 +1,9 @@
 declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     displayCrossHatches: {
         type: string;
         description: string;
         defaultValue: boolean;
     };
-    /**
-     * #slot
-     */
     summaryScoreMode: {
         type: string;
         model: import("mobx-state-tree").ISimpleType<string>;

package/esm/MultiRowLineRenderer/configSchema.js

@@ -1,22 +1,13 @@
-import { types } from 'mobx-state-tree';
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { types } from 'mobx-state-tree';
 import baseWiggleRendererConfigSchema from '../configSchema';
-/**
- * #config MultiRowLineRenderer
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+function x() { }
 const configSchema = ConfigurationSchema('MultiRowLineRenderer', {
-    /**
-     * #slot
-     */
     displayCrossHatches: {
         type: 'boolean',
         description: 'choose to draw cross hatches (sideways lines)',
         defaultValue: false,
     },
-    /**
-     * #slot
-     */
     summaryScoreMode: {
         type: 'stringEnum',
         model: types.enumeration('Score type', ['max', 'min', 'avg', 'whiskers']),
@@ -24,9 +15,6 @@ const configSchema = ConfigurationSchema('MultiRowLineRenderer', {
         defaultValue: 'avg',
     },
 }, {
-    /**
-     * #baseConfiguration
-     */
     baseConfiguration: baseWiggleRendererConfigSchema,
     explicitlyTyped: true,
 });

package/esm/MultiRowLineRenderer/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function MultiRowLineRendererF(pluginManager: PluginManager): void;

package/esm/MultiRowXYPlotRenderer/MultiRowXYPlotRenderer.d.ts

@@ -1,5 +1,6 @@
-import { Feature } from '@jbrowse/core/util';
-import WiggleBaseRenderer, { MultiRenderArgsDeserialized as MultiArgs } from '../WiggleBaseRenderer';
+import WiggleBaseRenderer from '../WiggleBaseRenderer';
+import type { MultiRenderArgsDeserialized as MultiArgs } from '../WiggleBaseRenderer';
+import type { Feature } from '@jbrowse/core/util';
 export default class MultiXYPlotRenderer extends WiggleBaseRenderer {
     draw(ctx: CanvasRenderingContext2D, props: MultiArgs): Promise<{
         reducedFeatures: Feature[];

package/esm/MultiRowXYPlotRenderer/MultiRowXYPlotRenderer.js

@@ -1,8 +1,7 @@
 import { groupBy } from '@jbrowse/core/util';
-import { drawXY } from '../drawXY';
 import WiggleBaseRenderer from '../WiggleBaseRenderer';
+import { drawXY } from '../drawXY';
 export default class MultiXYPlotRenderer extends WiggleBaseRenderer {
-    // @ts-expect-error
     async draw(ctx, props) {
         const { bpPerPx, sources, regions, features } = props;
         const region = regions[0];

package/esm/MultiRowXYPlotRenderer/configSchema.d.ts

@@ -1,31 +1,19 @@
 declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     filled: {
         type: string;
         defaultValue: boolean;
     };
-    /**
-     * #slot
-     */
     displayCrossHatches: {
         type: string;
         description: string;
         defaultValue: boolean;
     };
-    /**
-     * #slot
-     */
     summaryScoreMode: {
         type: string;
         model: import("mobx-state-tree").ISimpleType<string>;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     minSize: {
         type: string;
         defaultValue: number;

package/esm/MultiRowXYPlotRenderer/configSchema.js

@@ -1,46 +1,28 @@
-import { types } from 'mobx-state-tree';
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { types } from 'mobx-state-tree';
 import baseWiggleRendererConfigSchema from '../configSchema';
-/**
- * #config MultiRowXYPlotRenderer
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+function x() { }
 const configSchema = ConfigurationSchema('MultiRowXYPlotRenderer', {
-    /**
-     * #slot
-     */
     filled: {
         type: 'boolean',
         defaultValue: true,
     },
-    /**
-     * #slot
-     */
     displayCrossHatches: {
         type: 'boolean',
         description: 'choose to draw cross hatches (sideways lines)',
         defaultValue: false,
     },
-    /**
-     * #slot
-     */
     summaryScoreMode: {
         type: 'stringEnum',
         model: types.enumeration('Score type', ['max', 'min', 'avg', 'whiskers']),
         description: 'choose whether to use max/min/average or whiskers which combines all three into the same rendering',
         defaultValue: 'whiskers',
     },
-    /**
-     * #slot
-     */
     minSize: {
         type: 'number',
-        defaultValue: 0,
+        defaultValue: 0.7,
     },
 }, {
-    /**
-     * #baseConfiguration
-     */
     baseConfiguration: baseWiggleRendererConfigSchema,
     explicitlyTyped: true,
 });

package/esm/MultiRowXYPlotRenderer/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function MultiRowXYPlotRendererF(pluginManager: PluginManager): void;