@jbrowse/plugin-wiggle 2.16.1 → 2.18.0

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

@@ -24,79 +24,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = SharedWiggleMixin;
+const react_1 = require("react");
 const configuration_1 = require("@jbrowse/core/configuration");
 const util_1 = require("@jbrowse/core/util");
+const stopToken_1 = require("@jbrowse/core/util/stopToken");
 const plugin_linear_genome_view_1 = require("@jbrowse/plugin-linear-genome-view");
 const mobx_state_tree_1 = require("mobx-state-tree");
-// locals
 const util_2 = require("../util");
-const react_1 = require("react");
-// lazies
 const SetMinMaxDialog = (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('./SetMinMaxDialog'))));
-/**
- * #stateModel SharedWiggleMixin
- */
 function SharedWiggleMixin(configSchema) {
     return mobx_state_tree_1.types
         .compose(plugin_linear_genome_view_1.BaseLinearDisplay, mobx_state_tree_1.types.model({
-        /**
-         * #property
-         */
         selectedRendering: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.string, ''),
-        /**
-         * #property
-         */
         resolution: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.number, 1),
-        /**
-         * #property
-         */
         fill: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.boolean),
-        /**
-         * #property
-         */
         minSize: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.number),
-        /**
-         * #property
-         */
         color: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         posColor: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         negColor: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         summaryScoreMode: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         rendererTypeNameState: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         scale: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         autoscale: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         displayCrossHatches: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.boolean),
-        /**
-         * #property
-         */
         constraints: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.model({
             max: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.number),
             min: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.number),
         }), {}),
-        /**
-         * #property
-         */
         configuration: (0, configuration_1.ConfigurationReference)(configSchema),
     }))
         .volatile(() => ({
@@ -105,69 +59,43 @@ 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) {
+                (0, stopToken_1.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 = (0, util_1.getSession)(self);
             if ((0, util_1.isSelectionContainer)(session)) {
                 session.setSelection(feature);
             }
         },
-        /**
-         * #action
-         */
         setResolution(res) {
             self.resolution = res;
         },
-        /**
-         * #action
-         */
         setFill(fill) {
             if (fill === 0) {
                 self.fill = true;
@@ -182,116 +110,64 @@ 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 : (0, configuration_1.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 : (0, configuration_1.getConf)(self, 'scaleType');
         },
-        /**
-         * #getter
-         */
         get maxScore() {
             var _a;
             return (_a = self.constraints.max) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'maxScore');
         },
-        /**
-         * #getter
-         */
         get minScore() {
             var _a;
             return (_a = self.constraints.min) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'minScore');
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get adapterCapabilities() {
             const type = self.adapterTypeName;
             const { pluginManager } = (0, util_1.getEnv)(self);
             return pluginManager.getAdapterType(type).adapterCapabilities;
         },
-        /**
-         * #getter
-         */
         get rendererConfig() {
             const { color, displayCrossHatches, fill, minSize, negColor, posColor, summaryScoreMode, scaleType, rendererTypeName, } = self;
             const configBlob = (0, configuration_1.getConf)(self, ['renderers', rendererTypeName]) || {};
@@ -309,9 +185,6 @@ function SharedWiggleMixin(configSchema) {
                 ...(minSize !== undefined ? { minSize } : {}),
             }, (0, util_1.getEnv)(self));
         },
-        /**
-         * #getter
-         */
         get autoscaleType() {
             var _a;
             return (_a = self.autoscale) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'autoscale');
@@ -320,9 +193,6 @@ function SharedWiggleMixin(configSchema) {
         .views(self => {
         let oldDomain = [0, 0];
         return {
-            /**
-             * #getter
-             */
             get domain() {
                 const { stats, scaleType, minScore, maxScore } = self;
                 if (!stats) {
@@ -333,11 +203,9 @@ 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;
                 }
@@ -346,23 +214,14 @@ function SharedWiggleMixin(configSchema) {
         };
     })
         .views(self => ({
-        /**
-         * #getter
-         */
         get filled() {
             const { fill, rendererConfig } = self;
             return fill !== null && fill !== void 0 ? fill : (0, configuration_1.readConfObject)(rendererConfig, 'filled');
         },
-        /**
-         * #getter
-         */
         get summaryScoreModeSetting() {
             const { summaryScoreMode: mode, rendererConfig } = self;
             return mode !== null && mode !== void 0 ? mode : (0, configuration_1.readConfObject)(rendererConfig, 'summaryScoreMode');
         },
-        /**
-         * #getter
-         */
         get scaleOpts() {
             return {
                 domain: self.domain,
@@ -372,36 +231,21 @@ function SharedWiggleMixin(configSchema) {
                 inverted: (0, configuration_1.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 : (0, configuration_1.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
@@ -477,9 +321,6 @@ function SharedWiggleMixin(configSchema) {
         .actions(self => {
         const { reload: superReload } = self;
         return {
-            /**
-             * #action
-             */
             async reload() {
                 self.setError();
                 superReload();

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

@@ -4,29 +4,11 @@ exports.YSCALEBAR_LABEL_OFFSET = void 0;
 exports.getScale = getScale;
 exports.getOrigin = getOrigin;
 exports.getNiceDomain = getNiceDomain;
-exports.getQuantitativeStats = getQuantitativeStats;
-exports.quantitativeStatsAutorun = quantitativeStatsAutorun;
 exports.toP = toP;
 exports.round = round;
 exports.fillRectCtx = fillRectCtx;
 const d3_scale_1 = require("@mui/x-charts-vendor/d3-scale");
-const mobx_1 = require("mobx");
-const util_1 = require("@jbrowse/core/util");
-const tracks_1 = require("@jbrowse/core/util/tracks");
-const mobx_state_tree_1 = require("mobx-state-tree");
-const configuration_1 = require("@jbrowse/core/configuration");
 exports.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)
- */
 function getScale({ domain = [], range = [], scaleType, pivotValue, inverted, }) {
     let scale;
     const [min, max] = domain;
@@ -54,40 +36,12 @@ function getScale({ domain = [], range = [], scaleType, pivotValue, inverted, })
     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 -
- */
-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
-    // }
+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)
- */
 function getNiceDomain({ scaleType, domain, bounds, }) {
     const [minScore, maxScore] = bounds;
     let [min, max] = domain;
@@ -100,9 +54,6 @@ 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;
         }
@@ -132,103 +83,12 @@ function getNiceDomain({ scaleType, domain, bounds, }) {
     scale.nice();
     return scale.domain();
 }
-async function getQuantitativeStats(self, opts) {
-    const { rpcManager } = (0, util_1.getSession)(self);
-    const numStdDev = (0, configuration_1.getConf)(self, 'numStdDev') || 3;
-    const { adapterConfig, autoscaleType } = self;
-    const sessionId = (0, tracks_1.getRpcSessionId)(self);
-    const params = {
-        sessionId,
-        adapterConfig,
-        statusCallback: (message) => {
-            if ((0, mobx_state_tree_1.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 } = (0, util_1.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}'`);
-}
-function quantitativeStatsAutorun(self) {
-    (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(async () => {
-        try {
-            const aborter = new AbortController();
-            const view = (0, util_1.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 ((0, mobx_state_tree_1.isAlive)(self)) {
-                self.updateQuantitativeStats(wiggleStats, statsRegion);
-            }
-        }
-        catch (e) {
-            if (!(0, util_1.isAbortException)(e) && (0, mobx_state_tree_1.isAlive)(self)) {
-                console.error(e);
-                self.setError(e);
-            }
-        }
-    }, { delay: 1000 }));
-}
 function toP(s = 0) {
     return +(+s).toPrecision(6);
 }
 function round(value) {
     return Math.round(value * 1e5) / 1e5;
 }
-// avoid drawing negative width features for SVG exports
 function fillRectCtx(x, y, width, height, ctx, color) {
     if (width < 0) {
         x += width;

package/esm/BigWigAdapter/BigWigAdapter.d.ts

@@ -1,7 +1,8 @@
 import { BigWig } from '@gmod/bbi';
-import { BaseFeatureDataAdapter, BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { AugmentedRegion as Region } from '@jbrowse/core/util/types';
-import { Feature } from '@jbrowse/core/util';
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { Feature } from '@jbrowse/core/util';
+import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
 interface WiggleOptions extends BaseOptions {
     resolution?: number;
 }

package/esm/BigWigAdapter/BigWigAdapter.js

@@ -1,9 +1,9 @@
 import { BigWig } from '@gmod/bbi';
-import { BaseFeatureDataAdapter, } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { openLocation } from '@jbrowse/core/util/io';
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { updateStatus } from '@jbrowse/core/util';
+import { openLocation } from '@jbrowse/core/util/io';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-import { rectifyStats, } from '@jbrowse/core/util/stats';
+import { rectifyStats } from '@jbrowse/core/util/stats';
 class BigWigAdapter extends BaseFeatureDataAdapter {
     async setupPre(opts) {
         const { statusCallback = () => { } } = opts || {};
@@ -38,7 +38,7 @@ class BigWigAdapter extends BaseFeatureDataAdapter {
     }
     getFeatures(region, opts = {}) {
         const { refName, start, end } = region;
-        const { bpPerPx = 0, signal, resolution = 1, statusCallback = () => { }, } = opts;
+        const { bpPerPx = 0, stopToken, resolution = 1, statusCallback = () => { }, } = opts;
         return ObservableCreate(async (observer) => {
             statusCallback('Downloading bigwig data');
             const source = this.getConf('source');
@@ -50,25 +50,20 @@ class BigWigAdapter extends BaseFeatureDataAdapter {
             });
             for (const data of feats) {
                 if (source) {
-                    // @ts-expect-error
                     data.source = source;
                 }
                 const uniqueId = `${source}:${region.refName}:${data.start}-${data.end}`;
-                // @ts-expect-error
                 data.refName = refName;
                 data.uniqueId = uniqueId;
                 observer.next({
-                    // @ts-expect-error
                     get: (str) => data[str],
                     id: () => uniqueId,
-                    // @ts-expect-error
                     toJSON: () => data,
                 });
             }
             observer.complete();
-        }, signal);
+        }, stopToken);
     }
-    // always render bigwig instead of calculating a feature density for it
     async getMultiRegionFeatureDensityStats(_regions) {
         return { featureDensity: 0 };
     }