@jbrowse/plugin-wiggle 2.16.1 → 2.18.0

package/esm/shared/{modelShared.js → SharedWiggleMixin.js}

@@ -1,76 +1,30 @@
+import { lazy } from 'react';
 import { ConfigurationReference, getConf, readConfObject, } from '@jbrowse/core/configuration';
-import { getEnv, getSession, isSelectionContainer, } from '@jbrowse/core/util';
+import { getEnv, getSession, isSelectionContainer } from '@jbrowse/core/util';
+import { stopStopToken } from '@jbrowse/core/util/stopToken';
 import { BaseLinearDisplay } from '@jbrowse/plugin-linear-genome-view';
 import { types } from 'mobx-state-tree';
-// locals
 import { getNiceDomain } from '../util';
-import { lazy } from 'react';
-// lazies
 const SetMinMaxDialog = lazy(() => import('./SetMinMaxDialog'));
-/**
- * #stateModel SharedWiggleMixin
- */
 export default function SharedWiggleMixin(configSchema) {
     return types
         .compose(BaseLinearDisplay, types.model({
-        /**
-         * #property
-         */
         selectedRendering: types.optional(types.string, ''),
-        /**
-         * #property
-         */
         resolution: types.optional(types.number, 1),
-        /**
-         * #property
-         */
         fill: types.maybe(types.boolean),
-        /**
-         * #property
-         */
         minSize: types.maybe(types.number),
-        /**
-         * #property
-         */
         color: types.maybe(types.string),
-        /**
-         * #property
-         */
         posColor: types.maybe(types.string),
-        /**
-         * #property
-         */
         negColor: types.maybe(types.string),
-        /**
-         * #property
-         */
         summaryScoreMode: types.maybe(types.string),
-        /**
-         * #property
-         */
         rendererTypeNameState: types.maybe(types.string),
-        /**
-         * #property
-         */
         scale: types.maybe(types.string),
-        /**
-         * #property
-         */
         autoscale: types.maybe(types.string),
-        /**
-         * #property
-         */
         displayCrossHatches: types.maybe(types.boolean),
-        /**
-         * #property
-         */
         constraints: types.optional(types.model({
             max: types.maybe(types.number),
             min: types.maybe(types.number),
         }), {}),
-        /**
-         * #property
-         */
         configuration: ConfigurationReference(configSchema),
     }))
         .volatile(() => ({
@@ -79,69 +33,43 @@ export default function SharedWiggleMixin(configSchema) {
         statsFetchInProgress: undefined,
     }))
         .actions(self => ({
-        /**
-         * #action
-         */
         updateQuantitativeStats(stats) {
-            const { scoreMin, scoreMax } = stats;
+            const { currStatsBpPerPx, scoreMin, scoreMax } = stats;
             const EPSILON = 0.000001;
-            if (!self.stats) {
-                self.stats = { scoreMin, scoreMax };
-            }
-            else if (Math.abs(self.stats.scoreMax - scoreMax) > EPSILON ||
+            if (!self.stats ||
+                Math.abs(self.stats.scoreMax - scoreMax) > EPSILON ||
                 Math.abs(self.stats.scoreMin - scoreMin) > EPSILON) {
-                self.stats = { scoreMin, scoreMax };
+                self.stats = {
+                    currStatsBpPerPx,
+                    scoreMin,
+                    scoreMax,
+                };
             }
         },
-        /**
-         * #action
-         */
         setColor(color) {
             self.color = color;
         },
-        /**
-         * #action
-         */
         setPosColor(color) {
             self.posColor = color;
         },
-        /**
-         * #action
-         */
         setNegColor(color) {
             self.negColor = color;
         },
-        /**
-         * #action
-         */
-        setLoading(aborter) {
-            const { statsFetchInProgress: statsFetch } = self;
-            if (statsFetch !== undefined && !statsFetch.signal.aborted) {
-                statsFetch.abort();
+        setStatsLoading(arg) {
+            if (self.statsFetchInProgress) {
+                stopStopToken(self.statsFetchInProgress);
             }
-            self.statsFetchInProgress = aborter;
-        },
-        /**
-         * #action
-         * this overrides the BaseLinearDisplayModel to avoid popping up a
-         * feature detail display, but still sets the feature selection on the
-         * model so listeners can detect a click
-         */
+            self.statsFetchInProgress = arg;
+        },
         selectFeature(feature) {
             const session = getSession(self);
             if (isSelectionContainer(session)) {
                 session.setSelection(feature);
             }
         },
-        /**
-         * #action
-         */
         setResolution(res) {
             self.resolution = res;
         },
-        /**
-         * #action
-         */
         setFill(fill) {
             if (fill === 0) {
                 self.fill = true;
@@ -156,116 +84,64 @@ export default function SharedWiggleMixin(configSchema) {
                 self.minSize = 2;
             }
         },
-        /**
-         * #action
-         */
         toggleLogScale() {
             self.scale = self.scale === 'log' ? 'linear' : 'log';
         },
-        /**
-         * #action
-         */
         setScaleType(scale) {
             self.scale = scale;
         },
-        /**
-         * #action
-         */
         setSummaryScoreMode(val) {
             self.summaryScoreMode = val;
         },
-        /**
-         * #action
-         */
         setAutoscale(val) {
             self.autoscale = val;
         },
-        /**
-         * #action
-         */
         setMaxScore(val) {
             self.constraints.max = val;
         },
-        /**
-         * #action
-         */
         setRendererType(val) {
             self.rendererTypeNameState = val;
         },
-        /**
-         * #action
-         */
         setMinScore(val) {
             self.constraints.min = val;
         },
-        /**
-         * #action
-         */
         toggleCrossHatches() {
             self.displayCrossHatches = !self.displayCrossHatches;
         },
-        /**
-         * #action
-         */
         setCrossHatches(cross) {
             self.displayCrossHatches = cross;
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get adapterTypeName() {
             return self.adapterConfig.type;
         },
-        /**
-         * #getter
-         */
         get rendererTypeNameSimple() {
             var _a;
             return (_a = self.rendererTypeNameState) !== null && _a !== void 0 ? _a : getConf(self, 'defaultRendering');
         },
-        /**
-         * #getter
-         * subclasses can define these, as snpcoverage track does
-         */
         get filters() {
             return undefined;
         },
-        /**
-         * #getter
-         */
         get scaleType() {
             var _a;
             return (_a = self.scale) !== null && _a !== void 0 ? _a : getConf(self, 'scaleType');
         },
-        /**
-         * #getter
-         */
         get maxScore() {
             var _a;
             return (_a = self.constraints.max) !== null && _a !== void 0 ? _a : getConf(self, 'maxScore');
         },
-        /**
-         * #getter
-         */
         get minScore() {
             var _a;
             return (_a = self.constraints.min) !== null && _a !== void 0 ? _a : getConf(self, 'minScore');
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get adapterCapabilities() {
             const type = self.adapterTypeName;
             const { pluginManager } = getEnv(self);
             return pluginManager.getAdapterType(type).adapterCapabilities;
         },
-        /**
-         * #getter
-         */
         get rendererConfig() {
             const { color, displayCrossHatches, fill, minSize, negColor, posColor, summaryScoreMode, scaleType, rendererTypeName, } = self;
             const configBlob = getConf(self, ['renderers', rendererTypeName]) || {};
@@ -283,9 +159,6 @@ export default function SharedWiggleMixin(configSchema) {
                 ...(minSize !== undefined ? { minSize } : {}),
             }, getEnv(self));
         },
-        /**
-         * #getter
-         */
         get autoscaleType() {
             var _a;
             return (_a = self.autoscale) !== null && _a !== void 0 ? _a : getConf(self, 'autoscale');
@@ -294,9 +167,6 @@ export default function SharedWiggleMixin(configSchema) {
         .views(self => {
         let oldDomain = [0, 0];
         return {
-            /**
-             * #getter
-             */
             get domain() {
                 const { stats, scaleType, minScore, maxScore } = self;
                 if (!stats) {
@@ -307,11 +177,9 @@ export default function SharedWiggleMixin(configSchema) {
                     bounds: [minScore, maxScore],
                     scaleType,
                 });
-                // avoid weird scalebar if log value and empty region displayed
                 if (scaleType === 'log' && ret[1] === Number.MIN_VALUE) {
                     return [0, Number.MIN_VALUE];
                 }
-                // avoid returning a new object if it matches the old value
                 if (JSON.stringify(oldDomain) !== JSON.stringify(ret)) {
                     oldDomain = ret;
                 }
@@ -320,23 +188,14 @@ export default function SharedWiggleMixin(configSchema) {
         };
     })
         .views(self => ({
-        /**
-         * #getter
-         */
         get filled() {
             const { fill, rendererConfig } = self;
             return fill !== null && fill !== void 0 ? fill : readConfObject(rendererConfig, 'filled');
         },
-        /**
-         * #getter
-         */
         get summaryScoreModeSetting() {
             const { summaryScoreMode: mode, rendererConfig } = self;
             return mode !== null && mode !== void 0 ? mode : readConfObject(rendererConfig, 'summaryScoreMode');
         },
-        /**
-         * #getter
-         */
         get scaleOpts() {
             return {
                 domain: self.domain,
@@ -346,36 +205,21 @@ export default function SharedWiggleMixin(configSchema) {
                 inverted: getConf(self, 'inverted'),
             };
         },
-        /**
-         * #getter
-         */
         get canHaveFill() {
             return self.rendererTypeName === 'XYPlotRenderer';
         },
-        /**
-         * #getter
-         */
         get displayCrossHatchesSetting() {
             const { displayCrossHatches: hatches, rendererConfig } = self;
             return hatches !== null && hatches !== void 0 ? hatches : readConfObject(rendererConfig, 'displayCrossHatches');
         },
-        /**
-         * #getter
-         */
         get hasResolution() {
             return self.adapterCapabilities.includes('hasResolution');
         },
-        /**
-         * #getter
-         */
         get hasGlobalStats() {
             return self.adapterCapabilities.includes('hasGlobalStats');
         },
     }))
         .views(self => ({
-        /**
-         * #method
-         */
         scoreTrackMenuItems() {
             return [
                 ...(self.hasResolution
@@ -451,9 +295,6 @@ export default function SharedWiggleMixin(configSchema) {
         .actions(self => {
         const { reload: superReload } = self;
         return {
-            /**
-             * #action
-             */
             async reload() {
                 self.setError();
                 superReload();

package/esm/util.d.ts

@@ -1,5 +1,3 @@
-import { QuantitativeStats } from '@jbrowse/core/util/stats';
-import { AnyConfigurationModel } from '@jbrowse/core/configuration';
 export declare const YSCALEBAR_LABEL_OFFSET = 5;
 export interface ScaleOpts {
     domain: number[];
@@ -14,63 +12,13 @@ export interface Source {
     color?: string;
     group?: string;
 }
-/**
- * produces a d3-scale from arguments. applies a "nice domain" adjustment
- *
- * @param object - containing attributes
- *   - domain [min,max]
- *   - range [min,max]
- *   - bounds [min,max]
- *   - scaleType (linear or log)
- *   - pivotValue (number)
- *   - inverted (boolean)
- */
 export declare function getScale({ domain, range, scaleType, pivotValue, inverted, }: ScaleOpts): import("d3-scale").ScaleLinear<number, number, never> | import("d3-scale").ScaleLogarithmic<number, number, never> | import("d3-scale").ScaleQuantize<number, never>;
-/**
- * gets the origin for drawing the graph. for linear this is 0, for log this is arbitrarily set to log(1)==0
- *
- * @param scaleType -
- */
-export declare function getOrigin(scaleType: string): 0 | 1;
-/**
- * produces a "nice" domain that actually rounds down to 0 for the min
- * or 0 to the max depending on if all values are positive or negative
- *
- * @param object - containing attributes
- *   - domain [min,max]
- *   - bounds [min,max]
- *   - mean
- *   - stddev
- *   - scaleType (linear or log)
- */
+export declare function getOrigin(scaleType: string): 1 | 0;
 export declare function getNiceDomain({ scaleType, domain, bounds, }: {
     scaleType: string;
     domain: readonly [number, number];
     bounds: readonly [number | undefined, number | undefined];
 }): [number, number];
-export declare function getQuantitativeStats(self: {
-    adapterConfig: AnyConfigurationModel;
-    configuration: AnyConfigurationModel;
-    autoscaleType: string;
-    setMessage: (str: string) => void;
-}, opts: {
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-    filters: string[];
-}): Promise<QuantitativeStats>;
-export declare function quantitativeStatsAutorun(self: {
-    featureDensityStatsReady: boolean;
-    regionTooLarge: boolean;
-    error: unknown;
-    setLoading: (aborter: AbortController) => void;
-    setError: (error: unknown) => void;
-    updateQuantitativeStats: (stats: QuantitativeStats, statsRegion: string) => void;
-    renderProps: () => Record<string, unknown>;
-    configuration: AnyConfigurationModel;
-    adapterConfig: AnyConfigurationModel;
-    autoscaleType: string;
-    setMessage: (str: string) => void;
-}): void;
 export declare function toP(s?: number): number;
 export declare function round(value: number): number;
 export declare function fillRectCtx(x: number, y: number, width: number, height: number, ctx: CanvasRenderingContext2D, color?: string): void;

package/esm/util.js

@@ -1,21 +1,5 @@
 import { scaleLinear, scaleLog, scaleQuantize, } from '@mui/x-charts-vendor/d3-scale';
-import { autorun } from 'mobx';
-import { isAbortException, getSession, getContainingView, } from '@jbrowse/core/util';
-import { getRpcSessionId } from '@jbrowse/core/util/tracks';
-import { addDisposer, isAlive } from 'mobx-state-tree';
-import { getConf } from '@jbrowse/core/configuration';
 export const YSCALEBAR_LABEL_OFFSET = 5;
-/**
- * produces a d3-scale from arguments. applies a "nice domain" adjustment
- *
- * @param object - containing attributes
- *   - domain [min,max]
- *   - range [min,max]
- *   - bounds [min,max]
- *   - scaleType (linear or log)
- *   - pivotValue (number)
- *   - inverted (boolean)
- */
 export function getScale({ domain = [], range = [], scaleType, pivotValue, inverted, }) {
     let scale;
     const [min, max] = domain;
@@ -43,40 +27,12 @@ export function getScale({ domain = [], range = [], scaleType, pivotValue, inver
     scale.range(inverted ? range.slice().reverse() : range);
     return scale;
 }
-/**
- * gets the origin for drawing the graph. for linear this is 0, for log this is arbitrarily set to log(1)==0
- *
- * @param scaleType -
- */
-export function getOrigin(scaleType /* , pivot, stats */) {
-    // if (pivot) {
-    //   if (pivot === 'mean') {
-    //     return stats.scoreMean || 0
-    //   }
-    //   if (pivot === 'zero') {
-    //     return 0
-    //   }
-    //   return parseFloat()
-    // }
-    // if (scaleType === 'z_score') {
-    //   return stats.scoreMean || 0
-    // }
+export function getOrigin(scaleType) {
     if (scaleType === 'log') {
         return 1;
     }
     return 0;
 }
-/**
- * produces a "nice" domain that actually rounds down to 0 for the min
- * or 0 to the max depending on if all values are positive or negative
- *
- * @param object - containing attributes
- *   - domain [min,max]
- *   - bounds [min,max]
- *   - mean
- *   - stddev
- *   - scaleType (linear or log)
- */
 export function getNiceDomain({ scaleType, domain, bounds, }) {
     const [minScore, maxScore] = bounds;
     let [min, max] = domain;
@@ -89,9 +45,6 @@ export function getNiceDomain({ scaleType, domain, bounds, }) {
         }
     }
     if (scaleType === 'log') {
-        // for min>0 and max>1, set log min to 1, which works for most coverage
-        // types tracks. if max is not >1, might be like raw p-values so then it'll
-        // display negative values
         if (min >= 0 && max > 1) {
             min = 1;
         }
@@ -121,103 +74,12 @@ export function getNiceDomain({ scaleType, domain, bounds, }) {
     scale.nice();
     return scale.domain();
 }
-export async function getQuantitativeStats(self, opts) {
-    const { rpcManager } = getSession(self);
-    const numStdDev = getConf(self, 'numStdDev') || 3;
-    const { adapterConfig, autoscaleType } = self;
-    const sessionId = getRpcSessionId(self);
-    const params = {
-        sessionId,
-        adapterConfig,
-        statusCallback: (message) => {
-            if (isAlive(self)) {
-                self.setMessage(message);
-            }
-        },
-        ...opts,
-    };
-    if (autoscaleType === 'global' || autoscaleType === 'globalsd') {
-        const results = (await rpcManager.call(sessionId, 'WiggleGetGlobalQuantitativeStats', params));
-        const { scoreMin, scoreMean, scoreStdDev } = results;
-        // globalsd uses heuristic to avoid unnecessary scoreMin<0
-        // if the scoreMin is never less than 0
-        // helps with most coverage bigwigs just being >0
-        return autoscaleType === 'globalsd'
-            ? {
-                ...results,
-                scoreMin: scoreMin >= 0 ? 0 : scoreMean - numStdDev * scoreStdDev,
-                scoreMax: scoreMean + numStdDev * scoreStdDev,
-            }
-            : results;
-    }
-    if (autoscaleType === 'local' || autoscaleType === 'localsd') {
-        const { dynamicBlocks, bpPerPx } = getContainingView(self);
-        const results = (await rpcManager.call(sessionId, 'WiggleGetMultiRegionQuantitativeStats', {
-            ...params,
-            regions: dynamicBlocks.contentBlocks.map(region => {
-                const { start, end } = region;
-                return {
-                    ...JSON.parse(JSON.stringify(region)),
-                    start: Math.floor(start),
-                    end: Math.ceil(end),
-                };
-            }),
-            bpPerPx,
-        }));
-        const { scoreMin, scoreMean, scoreStdDev } = results;
-        // localsd uses heuristic to avoid unnecessary scoreMin<0 if the
-        // scoreMin is never less than 0 helps with most coverage bigwigs
-        // just being >0
-        return autoscaleType === 'localsd'
-            ? {
-                ...results,
-                scoreMin: scoreMin >= 0 ? 0 : scoreMean - numStdDev * scoreStdDev,
-                scoreMax: scoreMean + numStdDev * scoreStdDev,
-            }
-            : results;
-    }
-    if (autoscaleType === 'zscale') {
-        return rpcManager.call(sessionId, 'WiggleGetGlobalQuantitativeStats', params);
-    }
-    throw new Error(`invalid autoscaleType '${autoscaleType}'`);
-}
-export function quantitativeStatsAutorun(self) {
-    addDisposer(self, autorun(async () => {
-        try {
-            const aborter = new AbortController();
-            const view = getContainingView(self);
-            self.setLoading(aborter);
-            if (!view.initialized ||
-                !self.featureDensityStatsReady ||
-                self.regionTooLarge ||
-                self.error) {
-                return;
-            }
-            const statsRegion = JSON.stringify(view.dynamicBlocks);
-            const wiggleStats = await getQuantitativeStats(self, {
-                signal: aborter.signal,
-                filters: [],
-                ...self.renderProps(),
-            });
-            if (isAlive(self)) {
-                self.updateQuantitativeStats(wiggleStats, statsRegion);
-            }
-        }
-        catch (e) {
-            if (!isAbortException(e) && isAlive(self)) {
-                console.error(e);
-                self.setError(e);
-            }
-        }
-    }, { delay: 1000 }));
-}
 export function toP(s = 0) {
     return +(+s).toPrecision(6);
 }
 export function round(value) {
     return Math.round(value * 1e5) / 1e5;
 }
-// avoid drawing negative width features for SVG exports
 export function fillRectCtx(x, y, width, height, ctx, color) {
     if (width < 0) {
         x += width;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-wiggle",
-  "version": "2.16.1",
+  "version": "2.18.0",
   "description": "JBrowse 2 wiggle adapters, tracks, etc.",
   "keywords": [
     "jbrowse",
@@ -36,12 +36,10 @@
     "clean": "rimraf dist esm *.tsbuildinfo"
   },
   "dependencies": {
-    "@floating-ui/react": "^0.26.3",
     "@gmod/bbi": "^5.0.0",
     "@mui/icons-material": "^6.0.0",
     "@mui/x-charts-vendor": "^7.12.0",
     "@mui/x-data-grid": "^7.0.0",
-    "clone": "^2.1.2",
     "fast-deep-equal": "^3.1.3",
     "is-object": "^1.0.1",
     "react-d3-axis-mod": "^0.1.9",
@@ -65,5 +63,5 @@
   "distModule": "esm/index.js",
   "srcModule": "src/index.ts",
   "module": "esm/index.js",
-  "gitHead": "c6a658d2344989895543f0456b1cf7dd3b937769"
+  "gitHead": "c344ea60099cb7e460b77f15808946b24a7eee74"
 }