@jbrowse/plugin-wiggle 2.0.0 → 2.1.2

package/dist/LinearWiggleDisplay/models/model.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -33,565 +22,456 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.YSCALEBAR_LABEL_OFFSET = void 0;
-var react_1 = __importStar(require("react"));
-var configuration_1 = require("@jbrowse/core/configuration");
-var util_1 = require("@jbrowse/core/util");
-var tracks_1 = require("@jbrowse/core/util/tracks");
-var plugin_linear_genome_view_1 = require("@jbrowse/plugin-linear-genome-view");
-var mobx_1 = require("mobx");
-var mobx_state_tree_1 = require("mobx-state-tree");
-var react_d3_axis_mod_1 = require("react-d3-axis-mod");
-var util_2 = require("../../util");
-var Tooltip_1 = __importDefault(require("../components/Tooltip"));
-var WiggleDisplayComponent_1 = require("../components/WiggleDisplayComponent");
-var SetMinMaxDlg = (0, react_1.lazy)(function () { return Promise.resolve().then(function () { return __importStar(require('../components/SetMinMaxDialog')); }); });
-var SetColorDlg = (0, react_1.lazy)(function () { return Promise.resolve().then(function () { return __importStar(require('../components/SetColorDialog')); }); });
-// fudge factor for making all labels on the YScalebar visible
-exports.YSCALEBAR_LABEL_OFFSET = 5;
+const react_1 = __importStar(require("react"));
+const configuration_1 = require("@jbrowse/core/configuration");
+const util_1 = require("@jbrowse/core/util");
+const plugin_linear_genome_view_1 = require("@jbrowse/plugin-linear-genome-view");
+const mobx_1 = require("mobx");
+const mobx_state_tree_1 = require("mobx-state-tree");
+const react_d3_axis_mod_1 = require("react-d3-axis-mod");
+const util_2 = require("../../util");
+const Tooltip_1 = __importDefault(require("../components/Tooltip"));
+const WiggleDisplayComponent_1 = require("../components/WiggleDisplayComponent");
+const SetMinMaxDlg = (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('../components/SetMinMaxDialog'))));
+const SetColorDlg = (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('../components/SetColorDialog'))));
 // using a map because it preserves order
-var rendererTypes = new Map([
+const rendererTypes = new Map([
     ['xyplot', 'XYPlotRenderer'],
     ['density', 'DensityRenderer'],
     ['line', 'LinePlotRenderer'],
 ]);
-var stateModelFactory = function (pluginManager, configSchema) {
-    return mobx_state_tree_1.types
-        .compose('LinearWiggleDisplay', plugin_linear_genome_view_1.BaseLinearDisplay, mobx_state_tree_1.types.model({
-        type: mobx_state_tree_1.types.literal('LinearWiggleDisplay'),
-        configuration: (0, configuration_1.ConfigurationReference)(configSchema),
-        selectedRendering: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.string, ''),
-        resolution: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.number, 1),
-        fill: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.boolean),
-        color: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        posColor: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        negColor: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        summaryScoreMode: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        rendererTypeNameState: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        scale: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        autoscale: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        displayCrossHatches: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.boolean),
-        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),
-        }), {}),
-    }))
-        .volatile(function () { return ({
-        statsReady: false,
-        message: undefined,
-        stats: { scoreMin: 0, scoreMax: 50 },
-        statsFetchInProgress: undefined,
-    }); })
-        .actions(function (self) { return ({
-        updateStats: function (_a) {
-            var scoreMin = _a.scoreMin, scoreMax = _a.scoreMax;
-            if (self.stats.scoreMin !== scoreMin ||
-                self.stats.scoreMax !== scoreMax) {
-                self.stats = { scoreMin: scoreMin, scoreMax: scoreMax };
-            }
+const stateModelFactory = (pluginManager, configSchema) => mobx_state_tree_1.types
+    .compose('LinearWiggleDisplay', plugin_linear_genome_view_1.BaseLinearDisplay, mobx_state_tree_1.types.model({
+    type: mobx_state_tree_1.types.literal('LinearWiggleDisplay'),
+    configuration: (0, configuration_1.ConfigurationReference)(configSchema),
+    selectedRendering: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.string, ''),
+    resolution: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.number, 1),
+    fill: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.boolean),
+    minSize: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.number),
+    color: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    posColor: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    negColor: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    summaryScoreMode: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    rendererTypeNameState: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    scale: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    autoscale: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    displayCrossHatches: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.boolean),
+    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),
+    }), {}),
+}))
+    .volatile(() => ({
+    statsReady: false,
+    message: undefined,
+    stats: { scoreMin: 0, scoreMax: 50 },
+    statsFetchInProgress: undefined,
+}))
+    .actions(self => ({
+    updateStats(stats) {
+        const { scoreMin, scoreMax } = stats;
+        const EPSILON = 0.000001;
+        if (Math.abs(self.stats.scoreMax - scoreMax) > EPSILON ||
+            Math.abs(self.stats.scoreMin - scoreMin) > EPSILON) {
+            self.stats = { scoreMin, scoreMax };
             self.statsReady = true;
+        }
+    },
+    setColor(color) {
+        self.color = color;
+    },
+    setPosColor(color) {
+        self.posColor = color;
+    },
+    setNegColor(color) {
+        self.negColor = color;
+    },
+    setLoading(aborter) {
+        const { statsFetchInProgress: statsFetch } = self;
+        if (statsFetch !== undefined && !statsFetch.signal.aborted) {
+            statsFetch.abort();
+        }
+        self.statsFetchInProgress = aborter;
+    },
+    // 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
+    selectFeature(feature) {
+        const session = (0, util_1.getSession)(self);
+        if ((0, util_1.isSelectionContainer)(session)) {
+            session.setSelection(feature);
+        }
+    },
+    setResolution(res) {
+        self.resolution = res;
+    },
+    setFill(fill) {
+        if (fill === 0) {
+            self.fill = true;
+            self.minSize = 0;
+        }
+        else if (fill === 1) {
+            self.fill = false;
+            self.minSize = 1;
+        }
+        else if (fill === 2) {
+            self.fill = false;
+            self.minSize = 2;
+        }
+    },
+    toggleLogScale() {
+        if (self.scale !== 'log') {
+            self.scale = 'log';
+        }
+        else {
+            self.scale = 'linear';
+        }
+    },
+    setScaleType(scale) {
+        self.scale = scale;
+    },
+    setSummaryScoreMode(val) {
+        self.summaryScoreMode = val;
+    },
+    setAutoscale(val) {
+        self.autoscale = val;
+    },
+    setMaxScore(val) {
+        self.constraints.max = val;
+    },
+    setRendererType(val) {
+        self.rendererTypeNameState = val;
+    },
+    setMinScore(val) {
+        self.constraints.min = val;
+    },
+    toggleCrossHatches() {
+        self.displayCrossHatches = !self.displayCrossHatches;
+    },
+    setCrossHatches(cross) {
+        self.displayCrossHatches = cross;
+    },
+}))
+    .views(self => ({
+    get TooltipComponent() {
+        return Tooltip_1.default;
+    },
+    get adapterTypeName() {
+        return self.adapterConfig.type;
+    },
+    get rendererTypeNameSimple() {
+        return self.rendererTypeNameState || (0, configuration_1.getConf)(self, 'defaultRendering');
+    },
+    get rendererTypeName() {
+        const name = this.rendererTypeNameSimple;
+        const rendererType = rendererTypes.get(name);
+        if (!rendererType) {
+            throw new Error(`unknown renderer ${name}`);
+        }
+        return rendererType;
+    },
+    // subclasses can define these, as snpcoverage track does
+    get filters() {
+        return undefined;
+    },
+    get scaleType() {
+        return self.scale || (0, configuration_1.getConf)(self, 'scaleType');
+    },
+    get maxScore() {
+        var _a;
+        return (_a = self.constraints.max) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'maxScore');
+    },
+    get minScore() {
+        var _a;
+        return (_a = self.constraints.min) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'minScore');
+    },
+}))
+    .views(self => ({
+    get rendererConfig() {
+        const configBlob = (0, configuration_1.getConf)(self, ['renderers', self.rendererTypeName]) || {};
+        const { color, displayCrossHatches, fill, minSize, negColor, posColor, summaryScoreMode, scaleType, } = self;
+        return self.rendererType.configSchema.create({
+            ...configBlob,
+            ...(scaleType ? { scaleType } : {}),
+            ...(fill !== undefined ? { filled: fill } : {}),
+            ...(displayCrossHatches !== undefined
+                ? { displayCrossHatches }
+                : {}),
+            ...(summaryScoreMode !== undefined ? { summaryScoreMode } : {}),
+            ...(color !== undefined ? { color } : {}),
+            ...(negColor !== undefined ? { negColor } : {}),
+            ...(posColor !== undefined ? { posColor } : {}),
+            ...(minSize !== undefined ? { minSize } : {}),
+        }, (0, mobx_state_tree_1.getEnv)(self));
+    },
+}))
+    .views(self => {
+    let oldDomain = [0, 0];
+    return {
+        get filled() {
+            const { fill, rendererConfig: conf } = self;
+            return fill !== null && fill !== void 0 ? fill : (0, configuration_1.readConfObject)(conf, 'filled');
         },
-        setColor: function (color) {
-            self.color = color;
-        },
-        setPosColor: function (color) {
-            self.posColor = color;
-        },
-        setNegColor: function (color) {
-            self.negColor = color;
-        },
-        setLoading: function (aborter) {
-            var statsFetch = self.statsFetchInProgress;
-            if (statsFetch !== undefined && !statsFetch.signal.aborted) {
-                statsFetch.abort();
-            }
-            self.statsFetchInProgress = aborter;
-        },
-        // 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
-        selectFeature: function (feature) {
-            var session = (0, util_1.getSession)(self);
-            if ((0, util_1.isSelectionContainer)(session)) {
-                session.setSelection(feature);
-            }
-        },
-        setResolution: function (res) {
-            self.resolution = res;
-        },
-        setFill: function (fill) {
-            self.fill = fill;
+        get summaryScoreModeSetting() {
+            const { summaryScoreMode, rendererConfig: conf } = self;
+            return summaryScoreMode !== null && summaryScoreMode !== void 0 ? summaryScoreMode : (0, configuration_1.readConfObject)(conf, 'summaryScoreMode');
         },
-        toggleLogScale: function () {
-            if (self.scale !== 'log') {
-                self.scale = 'log';
+        get domain() {
+            const { stats, scaleType, minScore, maxScore } = self;
+            const ret = (0, util_2.getNiceDomain)({
+                domain: [stats.scoreMin, stats.scoreMax],
+                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];
             }
-            else {
-                self.scale = 'linear';
+            // avoid returning a new object if it matches the old value
+            if (JSON.stringify(oldDomain) !== JSON.stringify(ret)) {
+                oldDomain = ret;
             }
+            return oldDomain;
         },
-        setScaleType: function (scale) {
-            self.scale = scale;
-        },
-        setSummaryScoreMode: function (val) {
-            self.summaryScoreMode = val;
+        get needsScalebar() {
+            return (self.rendererTypeName === 'XYPlotRenderer' ||
+                self.rendererTypeName === 'LinePlotRenderer');
         },
-        setAutoscale: function (val) {
-            self.autoscale = val;
-        },
-        setMaxScore: function (val) {
-            self.constraints.max = val;
+        get scaleOpts() {
+            return {
+                domain: this.domain,
+                stats: self.stats,
+                autoscaleType: this.autoscaleType,
+                scaleType: self.scaleType,
+                inverted: (0, configuration_1.getConf)(self, 'inverted'),
+            };
         },
-        setRendererType: function (val) {
-            self.rendererTypeNameState = val;
+        get canHaveFill() {
+            return self.rendererTypeName === 'XYPlotRenderer';
         },
-        setMinScore: function (val) {
-            self.constraints.min = val;
+        get autoscaleType() {
+            var _a;
+            return (_a = self.autoscale) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'autoscale');
         },
-        toggleCrossHatches: function () {
-            self.displayCrossHatches = !self.displayCrossHatches;
+        get displayCrossHatchesSetting() {
+            const { displayCrossHatches: hatches, rendererConfig: conf } = self;
+            return hatches !== null && hatches !== void 0 ? hatches : (0, configuration_1.readConfObject)(conf, 'displayCrossHatches');
         },
-        setCrossHatches: function (cross) {
-            self.displayCrossHatches = cross;
+    };
+})
+    .views(self => ({
+    get ticks() {
+        const { scaleType, domain, height } = self;
+        const minimalTicks = (0, configuration_1.getConf)(self, 'minimalTicks');
+        const inverted = (0, configuration_1.getConf)(self, 'inverted');
+        const range = [height - util_2.YSCALEBAR_LABEL_OFFSET, util_2.YSCALEBAR_LABEL_OFFSET];
+        const scale = (0, util_2.getScale)({
+            scaleType,
+            domain,
+            range,
+            inverted,
+        });
+        const ticks = (0, react_d3_axis_mod_1.axisPropsFromTickScale)(scale, 4);
+        return height < 100 || minimalTicks
+            ? { ...ticks, values: domain }
+            : ticks;
+    },
+    get adapterCapabilities() {
+        return pluginManager.getAdapterType(self.adapterTypeName)
+            .adapterCapabilities;
+    },
+}))
+    .views(self => {
+    const { renderProps: superRenderProps } = self;
+    return {
+        renderProps() {
+            const superProps = superRenderProps();
+            const { filters, ticks, height, resolution, scaleOpts } = self;
+            return {
+                ...superProps,
+                notReady: superProps.notReady || !self.statsReady,
+                rpcDriverName: self.rpcDriverName,
+                displayModel: self,
+                config: self.rendererConfig,
+                displayCrossHatches: self.displayCrossHatchesSetting,
+                scaleOpts,
+                resolution,
+                height,
+                ticks,
+                filters,
+            };
         },
-    }); })
-        .views(function (self) { return ({
-        get TooltipComponent() {
-            return Tooltip_1.default;
+        get hasResolution() {
+            return self.adapterCapabilities.includes('hasResolution');
         },
-        get adapterTypeName() {
-            return self.adapterConfig.type;
+        get hasGlobalStats() {
+            return self.adapterCapabilities.includes('hasGlobalStats');
         },
-        get rendererTypeName() {
-            var viewName = self.rendererTypeNameState || (0, configuration_1.getConf)(self, 'defaultRendering');
-            var rendererType = rendererTypes.get(viewName);
-            if (!rendererType) {
-                throw new Error("unknown alignments view name ".concat(viewName));
+        get fillSetting() {
+            if (self.filled) {
+                return 0;
+            }
+            else if (!self.filled && self.minSize === 1) {
+                return 1;
+            }
+            else {
+                return 2;
             }
-            return rendererType;
-        },
-        // subclasses can define these, as snpcoverage track does
-        get filters() {
-            return undefined;
-        },
-        get scaleType() {
-            return self.scale || (0, configuration_1.getConf)(self, 'scaleType');
-        },
-        get maxScore() {
-            var max = self.constraints.max;
-            return max !== null && max !== void 0 ? max : (0, configuration_1.getConf)(self, 'maxScore');
-        },
-        get minScore() {
-            var min = self.constraints.min;
-            return min !== null && min !== void 0 ? min : (0, configuration_1.getConf)(self, 'minScore');
-        },
-    }); })
-        .views(function (self) { return ({
-        get rendererConfig() {
-            var configBlob = (0, configuration_1.getConf)(self, ['renderers', self.rendererTypeName]) || {};
-            var color = self.color, posColor = self.posColor, negColor = self.negColor, summaryScoreMode = self.summaryScoreMode, scaleType = self.scaleType, displayCrossHatches = self.displayCrossHatches, fill = self.fill;
-            return self.rendererType.configSchema.create(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, configBlob), (scaleType ? { scaleType: scaleType } : {})), (fill ? { filled: fill } : {})), (displayCrossHatches ? { displayCrossHatches: displayCrossHatches } : {})), (summaryScoreMode ? { summaryScoreMode: summaryScoreMode } : {})), (color ? { color: color } : {})), (negColor ? { negColor: negColor } : {})), (posColor ? { posColor: posColor } : {})), (0, mobx_state_tree_1.getEnv)(self));
-        },
-    }); })
-        .views(function (self) {
-        var oldDomain = [0, 0];
-        return {
-            get filled() {
-                var fill = self.fill, conf = self.rendererConfig;
-                return fill !== null && fill !== void 0 ? fill : (0, configuration_1.readConfObject)(conf, 'filled');
-            },
-            get summaryScoreModeSetting() {
-                var summaryScoreMode = self.summaryScoreMode, conf = self.rendererConfig;
-                return summaryScoreMode !== null && summaryScoreMode !== void 0 ? summaryScoreMode : (0, configuration_1.readConfObject)(conf, 'summaryScoreMode');
-            },
-            get domain() {
-                var stats = self.stats, scaleType = self.scaleType, minScore = self.minScore, maxScore = self.maxScore;
-                var ret = (0, util_2.getNiceDomain)({
-                    domain: [stats.scoreMin, stats.scoreMax],
-                    bounds: [minScore, maxScore],
-                    scaleType: 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;
-                }
-                return oldDomain;
-            },
-            get needsScalebar() {
-                return (self.rendererTypeName === 'XYPlotRenderer' ||
-                    self.rendererTypeName === 'LinePlotRenderer');
-            },
-            get scaleOpts() {
-                return {
-                    domain: this.domain,
-                    stats: self.stats,
-                    autoscaleType: this.autoscaleType,
-                    scaleType: self.scaleType,
-                    inverted: (0, configuration_1.getConf)(self, 'inverted'),
-                };
-            },
-            get canHaveFill() {
-                return self.rendererTypeName === 'XYPlotRenderer';
-            },
-            get autoscaleType() {
-                var _a;
-                return (_a = self.autoscale) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'autoscale');
-            },
-            get displayCrossHatchesSetting() {
-                var hatches = self.displayCrossHatches, conf = self.rendererConfig;
-                return hatches !== null && hatches !== void 0 ? hatches : (0, configuration_1.readConfObject)(conf, 'displayCrossHatches');
-            },
-        };
-    })
-        .views(function (self) { return ({
-        get ticks() {
-            var scaleType = self.scaleType, domain = self.domain, height = self.height;
-            var minimalTicks = (0, configuration_1.getConf)(self, 'minimalTicks');
-            var range = [height - exports.YSCALEBAR_LABEL_OFFSET, exports.YSCALEBAR_LABEL_OFFSET];
-            var scale = (0, util_2.getScale)({
-                scaleType: scaleType,
-                domain: domain,
-                range: range,
-                inverted: (0, configuration_1.getConf)(self, 'inverted'),
-            });
-            var ticks = (0, react_d3_axis_mod_1.axisPropsFromTickScale)(scale, 4);
-            return height < 100 || minimalTicks
-                ? __assign(__assign({}, ticks), { values: domain }) : ticks;
         },
-    }); })
-        .views(function (self) {
-        var superRenderProps = self.renderProps;
-        return {
-            renderProps: function () {
-                var superProps = superRenderProps();
-                var filters = self.filters, ticks = self.ticks, height = self.height, resolution = self.resolution, scaleOpts = self.scaleOpts;
-                return __assign(__assign({}, superProps), { notReady: superProps.notReady || !self.statsReady, rpcDriverName: self.rpcDriverName, displayModel: self, config: self.rendererConfig, displayCrossHatches: self.displayCrossHatchesSetting, scaleOpts: scaleOpts, resolution: resolution, height: height, ticks: ticks, filters: filters });
-            },
-            get adapterCapabilities() {
-                return pluginManager.getAdapterType(self.adapterTypeName)
-                    .adapterCapabilities;
-            },
-            get hasResolution() {
-                return this.adapterCapabilities.includes('hasResolution');
-            },
-            get hasGlobalStats() {
-                return this.adapterCapabilities.includes('hasGlobalStats');
-            },
-        };
-    })
-        .views(function (self) {
-        var superTrackMenuItems = self.trackMenuItems;
-        var hasRenderings = (0, configuration_1.getConf)(self, 'defaultRendering');
-        return {
-            trackMenuItems: function () {
-                return __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(superTrackMenuItems()), false), __read((self.hasResolution
+    };
+})
+    .views(self => {
+    const { trackMenuItems: superTrackMenuItems } = self;
+    const hasRenderings = (0, configuration_1.getConf)(self, 'defaultRendering');
+    return {
+        trackMenuItems() {
+            return [
+                ...superTrackMenuItems(),
+                ...(self.hasResolution
                     ? [
                         {
                             label: 'Resolution',
                             subMenu: [
                                 {
                                     label: 'Finer resolution',
-                                    onClick: function () { return self.setResolution(self.resolution * 5); },
+                                    onClick: () => self.setResolution(self.resolution * 5),
                                 },
                                 {
                                     label: 'Coarser resolution',
-                                    onClick: function () { return self.setResolution(self.resolution / 5); },
+                                    onClick: () => self.setResolution(self.resolution / 5),
                                 },
                             ],
                         },
                         {
                             label: 'Summary score mode',
-                            subMenu: ['min', 'max', 'avg', 'whiskers'].map(function (elt) { return ({
+                            subMenu: ['min', 'max', 'avg', 'whiskers'].map(elt => ({
                                 label: elt,
-                                onClick: function () { return self.setSummaryScoreMode(elt); },
-                            }); }),
+                                type: 'radio',
+                                checked: self.summaryScoreModeSetting === elt,
+                                onClick: () => self.setSummaryScoreMode(elt),
+                            })),
                         },
                     ]
-                    : [])), false), __read((self.canHaveFill
+                    : []),
+                ...(self.canHaveFill
                     ? [
                         {
-                            label: self.filled
-                                ? 'Turn off histogram fill'
-                                : 'Turn on histogram fill',
-                            onClick: function () { return self.setFill(!self.filled); },
+                            label: 'Fill mode',
+                            subMenu: ['filled', 'no fill', 'no fill w/ emphasis'].map((elt, idx) => ({
+                                label: elt,
+                                type: 'radio',
+                                checked: self.fillSetting === idx,
+                                onClick: () => self.setFill(idx),
+                            })),
                         },
                     ]
-                    : [])), false), [
-                    {
-                        label: self.scaleType === 'log' ? 'Set linear scale' : 'Set log scale',
-                        onClick: function () { return self.toggleLogScale(); },
-                    },
-                    {
-                        type: 'checkbox',
-                        label: 'Draw cross hatches',
-                        checked: self.displayCrossHatchesSetting,
-                        onClick: function () { return self.toggleCrossHatches(); },
-                    }
-                ], false), __read((hasRenderings
+                    : []),
+                {
+                    label: self.scaleType === 'log' ? 'Set linear scale' : 'Set log scale',
+                    onClick: () => self.toggleLogScale(),
+                },
+                ...(self.needsScalebar
+                    ? [
+                        {
+                            type: 'checkbox',
+                            label: 'Draw cross hatches',
+                            checked: self.displayCrossHatchesSetting,
+                            onClick: () => self.toggleCrossHatches(),
+                        },
+                    ]
+                    : []),
+                ...(hasRenderings
                     ? [
                         {
                             label: 'Renderer type',
-                            subMenu: ['xyplot', 'density', 'line'].map(function (key) { return ({
+                            subMenu: ['xyplot', 'density', 'line'].map(key => ({
                                 label: key,
-                                onClick: function () { return self.setRendererType(key); },
-                            }); }),
+                                type: 'radio',
+                                checked: self.rendererTypeNameSimple === key,
+                                onClick: () => self.setRendererType(key),
+                            })),
                         },
                     ]
-                    : [])), false), [
-                    {
-                        label: 'Autoscale type',
-                        subMenu: __spreadArray(__spreadArray([
-                            ['local', 'Local']
-                        ], __read((self.hasGlobalStats
+                    : []),
+                {
+                    label: 'Autoscale type',
+                    subMenu: [
+                        ['local', 'Local'],
+                        ...(self.hasGlobalStats
                             ? [
                                 ['global', 'Global'],
                                 ['globalsd', 'Global ± 3σ'],
                             ]
-                            : [])), false), [
-                            ['localsd', 'Local ± 3σ'],
-                        ], false).map(function (_a) {
-                            var _b = __read(_a, 2), val = _b[0], label = _b[1];
-                            return ({
-                                label: label,
-                                onClick: function () { return self.setAutoscale(val); },
-                            });
-                        }),
+                            : []),
+                        ['localsd', 'Local ± 3σ'],
+                    ].map(([val, label]) => ({
+                        label,
+                        type: 'radio',
+                        checked: self.autoscaleType === val,
+                        onClick: () => self.setAutoscale(val),
+                    })),
+                },
+                {
+                    label: 'Set min/max score',
+                    onClick: () => {
+                        (0, util_1.getSession)(self).queueDialog(handleClose => [
+                            SetMinMaxDlg,
+                            { model: self, handleClose },
+                        ]);
                     },
-                    {
-                        label: 'Set min/max score',
-                        onClick: function () {
-                            (0, util_1.getSession)(self).queueDialog(function (handleClose) { return [
-                                SetMinMaxDlg,
-                                { model: self, handleClose: handleClose },
-                            ]; });
-                        },
+                },
+                {
+                    label: 'Set color',
+                    onClick: () => {
+                        (0, util_1.getSession)(self).queueDialog(handleClose => [
+                            SetColorDlg,
+                            { model: self, handleClose },
+                        ]);
                     },
-                    {
-                        label: 'Set color',
-                        onClick: function () {
-                            (0, util_1.getSession)(self).queueDialog(function (handleClose) { return [
-                                SetColorDlg,
-                                { model: self, handleClose: handleClose },
-                            ]; });
-                        },
-                    },
-                ], false);
-            },
-        };
-    })
-        .actions(function (self) {
-        var superReload = self.reload, superRenderSvg = self.renderSvg;
-        function getStats(opts) {
-            return __awaiter(this, void 0, void 0, function () {
-                var rpcManager, nd, adapterConfig, autoscaleType, sessionId, params, results, scoreMin, scoreMean, scoreStdDev, _a, dynamicBlocks, bpPerPx, results, scoreMin, scoreMean, scoreStdDev;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            rpcManager = (0, util_1.getSession)(self).rpcManager;
-                            nd = (0, configuration_1.getConf)(self, 'numStdDev') || 3;
-                            adapterConfig = self.adapterConfig, autoscaleType = self.autoscaleType;
-                            sessionId = (0, tracks_1.getRpcSessionId)(self);
-                            params = __assign({ sessionId: sessionId, adapterConfig: adapterConfig, statusCallback: function (message) {
-                                    if ((0, mobx_state_tree_1.isAlive)(self)) {
-                                        self.setMessage(message);
-                                    }
-                                } }, opts);
-                            if (!(autoscaleType === 'global' || autoscaleType === 'globalsd')) return [3 /*break*/, 2];
-                            return [4 /*yield*/, rpcManager.call(sessionId, 'WiggleGetGlobalStats', params)];
-                        case 1:
-                            results = (_b.sent());
-                            scoreMin = results.scoreMin, scoreMean = results.scoreMean, scoreStdDev = results.scoreStdDev;
-                            // 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 [2 /*return*/, autoscaleType === 'globalsd'
-                                    ? __assign(__assign({}, results), { scoreMin: scoreMin >= 0 ? 0 : scoreMean - nd * scoreStdDev, scoreMax: scoreMean + nd * scoreStdDev }) : results];
-                        case 2:
-                            if (!(autoscaleType === 'local' || autoscaleType === 'localsd')) return [3 /*break*/, 4];
-                            _a = (0, util_1.getContainingView)(self), dynamicBlocks = _a.dynamicBlocks, bpPerPx = _a.bpPerPx;
-                            return [4 /*yield*/, rpcManager.call(sessionId, 'WiggleGetMultiRegionStats', __assign(__assign({}, params), { regions: dynamicBlocks.contentBlocks.map(function (region) {
-                                        var start = region.start, end = region.end;
-                                        return __assign(__assign({}, JSON.parse(JSON.stringify(region))), { start: Math.floor(start), end: Math.ceil(end) });
-                                    }), bpPerPx: bpPerPx }))];
-                        case 3:
-                            results = (_b.sent());
-                            scoreMin = results.scoreMin, scoreMean = results.scoreMean, scoreStdDev = results.scoreStdDev;
-                            // 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 [2 /*return*/, autoscaleType === 'localsd'
-                                    ? __assign(__assign({}, results), { scoreMin: scoreMin >= 0 ? 0 : scoreMean - nd * scoreStdDev, scoreMax: scoreMean + nd * scoreStdDev }) : results];
-                        case 4:
-                            if (autoscaleType === 'zscale') {
-                                return [2 /*return*/, rpcManager.call(sessionId, 'WiggleGetGlobalStats', params)];
-                            }
-                            throw new Error("invalid autoscaleType '".concat(autoscaleType, "'"));
-                    }
-                });
-            });
-        }
-        return {
-            // re-runs stats and refresh whole display on reload
-            reload: function () {
-                return __awaiter(this, void 0, void 0, function () {
-                    var aborter, stats, e_1;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                self.setError();
-                                aborter = new AbortController();
-                                self.setLoading(aborter);
-                                _a.label = 1;
-                            case 1:
-                                _a.trys.push([1, 3, , 4]);
-                                return [4 /*yield*/, getStats(__assign({ signal: aborter.signal }, self.renderProps()))];
-                            case 2:
-                                stats = _a.sent();
-                                if ((0, mobx_state_tree_1.isAlive)(self)) {
-                                    self.updateStats(stats);
-                                    superReload();
-                                }
-                                return [3 /*break*/, 4];
-                            case 3:
-                                e_1 = _a.sent();
-                                self.setError(e_1);
-                                return [3 /*break*/, 4];
-                            case 4: return [2 /*return*/];
-                        }
-                    });
-                });
-            },
-            afterAttach: function () {
-                var _this = this;
-                (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(function () { return __awaiter(_this, void 0, void 0, function () {
-                    var view, aborter, wiggleStats, e_2;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                _a.trys.push([0, 2, , 3]);
-                                view = (0, util_1.getContainingView)(self);
-                                if (!view.initialized) {
-                                    return [2 /*return*/];
-                                }
-                                if (!self.estimatedStatsReady) {
-                                    return [2 /*return*/];
-                                }
-                                if (self.regionTooLarge) {
-                                    return [2 /*return*/];
-                                }
-                                aborter = new AbortController();
-                                self.setLoading(aborter);
-                                return [4 /*yield*/, getStats(__assign({ signal: aborter.signal }, self.renderProps()))];
-                            case 1:
-                                wiggleStats = _a.sent();
-                                if ((0, mobx_state_tree_1.isAlive)(self)) {
-                                    self.updateStats(wiggleStats);
-                                }
-                                return [3 /*break*/, 3];
-                            case 2:
-                                e_2 = _a.sent();
-                                if (!(0, util_1.isAbortException)(e_2) && (0, mobx_state_tree_1.isAlive)(self)) {
-                                    console.error(e_2);
-                                    self.setError(e_2);
-                                }
-                                return [3 /*break*/, 3];
-                            case 3: return [2 /*return*/];
-                        }
-                    });
-                }); }, { delay: 1000 }));
-            },
-            renderSvg: function (opts) {
-                return __awaiter(this, void 0, void 0, function () {
-                    var needsScalebar, stats, offsetPx, _a, _b, _c, _d, _e, _f;
-                    return __generator(this, function (_g) {
-                        switch (_g.label) {
-                            case 0: return [4 /*yield*/, (0, mobx_1.when)(function () { return self.statsReady && !!self.regionCannotBeRenderedText; })];
-                            case 1:
-                                _g.sent();
-                                needsScalebar = self.needsScalebar, stats = self.stats;
-                                offsetPx = (0, util_1.getContainingView)(self).offsetPx;
-                                _b = (_a = react_1.default).createElement;
-                                _c = [react_1.default.Fragment, null];
-                                _e = (_d = react_1.default).createElement;
-                                _f = ["g", { id: "snpcov" }];
-                                return [4 /*yield*/, superRenderSvg(opts)];
-                            case 2: return [2 /*return*/, (_b.apply(_a, _c.concat([_e.apply(_d, _f.concat([_g.sent()])), needsScalebar && stats ? (react_1.default.createElement("g", { transform: "translate(".concat(Math.max(-offsetPx, 0), ")") },
-                                        react_1.default.createElement(WiggleDisplayComponent_1.YScaleBar, { model: self, orientation: "left" }))) : null])))];
-                        }
-                    });
+                },
+            ];
+        },
+    };
+})
+    .actions(self => {
+    const { reload: superReload, renderSvg: superRenderSvg } = self;
+    return {
+        // re-runs stats and refresh whole display on reload
+        async reload() {
+            self.setError();
+            const aborter = new AbortController();
+            self.setLoading(aborter);
+            try {
+                const stats = await (0, util_2.getStats)(self, {
+                    signal: aborter.signal,
+                    ...self.renderProps(),
                 });
-            },
-        };
-    });
-};
+                if ((0, mobx_state_tree_1.isAlive)(self)) {
+                    self.updateStats(stats);
+                    superReload();
+                }
+            }
+            catch (e) {
+                self.setError(e);
+            }
+        },
+        afterAttach() {
+            (0, util_2.statsAutorun)(self);
+        },
+        async renderSvg(opts) {
+            await (0, mobx_1.when)(() => self.statsReady && !!self.regionCannotBeRenderedText);
+            const { needsScalebar, stats } = self;
+            const { offsetPx } = (0, util_1.getContainingView)(self);
+            return (react_1.default.createElement(react_1.default.Fragment, null,
+                react_1.default.createElement("g", { id: "snpcov" }, await superRenderSvg(opts)),
+                needsScalebar && stats ? (react_1.default.createElement("g", { transform: `translate(${Math.max(-offsetPx, 0)})` },
+                    react_1.default.createElement(WiggleDisplayComponent_1.YScaleBar, { model: self, orientation: "left" }))) : null));
+        },
+    };
+});
 exports.default = stateModelFactory;
 //# sourceMappingURL=model.js.map