@jbrowse/plugin-wiggle 2.1.7 → 2.2.1

package/esm/LinearWiggleDisplay/models/model.js

@@ -16,434 +16,614 @@ const rendererTypes = new Map([
     ['density', 'DensityRenderer'],
     ['line', 'LinePlotRenderer'],
 ]);
-const stateModelFactory = (pluginManager, configSchema) => types
-    .compose('LinearWiggleDisplay', BaseLinearDisplay, types.model({
-    type: types.literal('LinearWiggleDisplay'),
-    configuration: ConfigurationReference(configSchema),
-    selectedRendering: types.optional(types.string, ''),
-    resolution: types.optional(types.number, 1),
-    fill: types.maybe(types.boolean),
-    minSize: types.maybe(types.number),
-    color: types.maybe(types.string),
-    posColor: types.maybe(types.string),
-    negColor: types.maybe(types.string),
-    summaryScoreMode: types.maybe(types.string),
-    rendererTypeNameState: types.maybe(types.string),
-    scale: types.maybe(types.string),
-    autoscale: types.maybe(types.string),
-    displayCrossHatches: types.maybe(types.boolean),
-    constraints: types.optional(types.model({
-        max: types.maybe(types.number),
-        min: types.maybe(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 };
+/**
+ * #stateModel LinearWiggleDisplay
+ * Extends `BaseLinearDisplay`
+ */
+function stateModelFactory(pluginManager, configSchema) {
+    return types
+        .compose('LinearWiggleDisplay', BaseLinearDisplay, types.model({
+        /**
+         * #property
+         */
+        type: types.literal('LinearWiggleDisplay'),
+        /**
+         * #property
+         */
+        configuration: ConfigurationReference(configSchema),
+        /**
+         * #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),
+        }), {}),
+    }))
+        .volatile(() => ({
+        statsReady: false,
+        message: undefined,
+        stats: { scoreMin: 0, scoreMax: 50 },
+        statsFetchInProgress: undefined,
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        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 = getSession(self);
-        if (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;
-    },
-    get adapterTypeName() {
-        return self.adapterConfig.type;
-    },
-    get rendererTypeNameSimple() {
-        return self.rendererTypeNameState || 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 || getConf(self, 'scaleType');
-    },
-    get maxScore() {
-        var _a;
-        return (_a = self.constraints.max) !== null && _a !== void 0 ? _a : getConf(self, 'maxScore');
-    },
-    get minScore() {
-        var _a;
-        return (_a = self.constraints.min) !== null && _a !== void 0 ? _a : getConf(self, 'minScore');
-    },
-}))
-    .views(self => ({
-    get rendererConfig() {
-        const configBlob = 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 } : {}),
-        }, getEnv(self));
-    },
-}))
-    .views(self => {
-    let oldDomain = [0, 0];
-    return {
-        get filled() {
-            const { fill, rendererConfig: conf } = self;
-            return fill !== null && fill !== void 0 ? fill : readConfObject(conf, 'filled');
         },
-        get summaryScoreModeSetting() {
-            const { summaryScoreMode, rendererConfig: conf } = self;
-            return summaryScoreMode !== null && summaryScoreMode !== void 0 ? summaryScoreMode : readConfObject(conf, 'summaryScoreMode');
+        /**
+         * #action
+         */
+        setColor(color) {
+            self.color = color;
         },
-        get domain() {
-            const { stats, scaleType, minScore, maxScore } = self;
-            const ret = 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];
+        /**
+         * #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();
             }
-            // avoid returning a new object if it matches the old value
-            if (JSON.stringify(oldDomain) !== JSON.stringify(ret)) {
-                oldDomain = ret;
+            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
+         */
+        selectFeature(feature) {
+            const session = getSession(self);
+            if (isSelectionContainer(session)) {
+                session.setSelection(feature);
             }
-            return oldDomain;
         },
-        get needsScalebar() {
-            return (self.rendererTypeName === 'XYPlotRenderer' ||
-                self.rendererTypeName === 'LinePlotRenderer');
+        /**
+         * #action
+         */
+        setResolution(res) {
+            self.resolution = res;
         },
-        get scaleOpts() {
-            return {
-                domain: this.domain,
-                stats: self.stats,
-                autoscaleType: this.autoscaleType,
-                scaleType: self.scaleType,
-                inverted: getConf(self, 'inverted'),
-            };
+        /**
+         * #action
+         */
+        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;
+            }
         },
-        get canHaveFill() {
-            return self.rendererTypeName === 'XYPlotRenderer';
+        /**
+         * #action
+         */
+        toggleLogScale() {
+            if (self.scale !== 'log') {
+                self.scale = 'log';
+            }
+            else {
+                self.scale = 'linear';
+            }
         },
-        get autoscaleType() {
-            var _a;
-            return (_a = self.autoscale) !== null && _a !== void 0 ? _a : getConf(self, 'autoscale');
+        /**
+         * #action
+         */
+        setScaleType(scale) {
+            self.scale = scale;
         },
-        get displayCrossHatchesSetting() {
-            const { displayCrossHatches: hatches, rendererConfig: conf } = self;
-            return hatches !== null && hatches !== void 0 ? hatches : readConfObject(conf, 'displayCrossHatches');
+        /**
+         * #action
+         */
+        setSummaryScoreMode(val) {
+            self.summaryScoreMode = val;
         },
-    };
-})
-    .views(self => ({
-    get ticks() {
-        const { scaleType, domain, height } = self;
-        const minimalTicks = getConf(self, 'minimalTicks');
-        const inverted = getConf(self, 'inverted');
-        const range = [height - YSCALEBAR_LABEL_OFFSET, YSCALEBAR_LABEL_OFFSET];
-        const scale = getScale({
-            scaleType,
-            domain,
-            range,
-            inverted,
-        });
-        const ticks = 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,
-            };
+        /**
+         * #action
+         */
+        setAutoscale(val) {
+            self.autoscale = val;
         },
-        get hasResolution() {
-            return self.adapterCapabilities.includes('hasResolution');
+        /**
+         * #action
+         */
+        setMaxScore(val) {
+            self.constraints.max = val;
         },
-        get hasGlobalStats() {
-            return self.adapterCapabilities.includes('hasGlobalStats');
+        /**
+         * #action
+         */
+        setRendererType(val) {
+            self.rendererTypeNameState = val;
         },
-        get fillSetting() {
-            if (self.filled) {
-                return 0;
-            }
-            else if (!self.filled && self.minSize === 1) {
-                return 1;
-            }
-            else {
-                return 2;
+        /**
+         * #action
+         */
+        setMinScore(val) {
+            self.constraints.min = val;
+        },
+        /**
+         * #action
+         */
+        toggleCrossHatches() {
+            self.displayCrossHatches = !self.displayCrossHatches;
+        },
+        /**
+         * #action
+         */
+        setCrossHatches(cross) {
+            self.displayCrossHatches = cross;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get TooltipComponent() {
+            return Tooltip;
+        },
+        /**
+         * #getter
+         */
+        get adapterTypeName() {
+            return self.adapterConfig.type;
+        },
+        /**
+         * #getter
+         */
+        get rendererTypeNameSimple() {
+            return self.rendererTypeNameState || getConf(self, 'defaultRendering');
+        },
+        /**
+         * #getter
+         */
+        get rendererTypeName() {
+            const name = this.rendererTypeNameSimple;
+            const rendererType = rendererTypes.get(name);
+            if (!rendererType) {
+                throw new Error(`unknown renderer ${name}`);
             }
+            return rendererType;
         },
-    };
-})
-    .views(self => {
-    const { trackMenuItems: superTrackMenuItems } = self;
-    const hasRenderings = getConf(self, 'defaultRendering');
-    return {
-        trackMenuItems() {
-            return [
-                ...superTrackMenuItems(),
-                ...(self.hasResolution
-                    ? [
-                        {
-                            label: 'Resolution',
-                            subMenu: [
-                                {
-                                    label: 'Finer resolution',
-                                    onClick: () => self.setResolution(self.resolution * 5),
-                                },
-                                {
-                                    label: 'Coarser resolution',
-                                    onClick: () => self.setResolution(self.resolution / 5),
-                                },
-                            ],
-                        },
-                        {
-                            label: 'Summary score mode',
-                            subMenu: ['min', 'max', 'avg', 'whiskers'].map(elt => ({
-                                label: elt,
-                                type: 'radio',
-                                checked: self.summaryScoreModeSetting === elt,
-                                onClick: () => self.setSummaryScoreMode(elt),
-                            })),
-                        },
-                    ]
-                    : []),
-                ...(self.canHaveFill
-                    ? [
-                        {
-                            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),
-                            })),
-                        },
-                    ]
-                    : []),
-                {
-                    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(key => ({
-                                label: key,
-                                type: 'radio',
-                                checked: self.rendererTypeNameSimple === key,
-                                onClick: () => self.setRendererType(key),
-                            })),
-                        },
-                    ]
-                    : []),
-                {
-                    label: 'Autoscale type',
-                    subMenu: [
-                        ['local', 'Local'],
-                        ...(self.hasGlobalStats
-                            ? [
-                                ['global', 'Global'],
-                                ['globalsd', 'Global ± 3σ'],
-                            ]
-                            : []),
-                        ['localsd', 'Local ± 3σ'],
-                    ].map(([val, label]) => ({
-                        label,
-                        type: 'radio',
-                        checked: self.autoscaleType === val,
-                        onClick: () => self.setAutoscale(val),
-                    })),
-                },
-                {
-                    label: 'Set min/max score',
-                    onClick: () => {
-                        getSession(self).queueDialog(handleClose => [
-                            SetMinMaxDlg,
-                            { model: self, handleClose },
-                        ]);
-                    },
-                },
-                {
-                    label: 'Set color',
-                    onClick: () => {
-                        getSession(self).queueDialog(handleClose => [
-                            SetColorDlg,
-                            { model: self, handleClose },
-                        ]);
-                    },
-                },
-            ];
+        /**
+         * #getter
+         * subclasses can define these, as snpcoverage track does
+         */
+        get filters() {
+            return undefined;
+        },
+        /**
+         * #getter
+         */
+        get scaleType() {
+            return self.scale || getConf(self, 'scaleType');
         },
-    };
-})
-    .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 getStats(self, {
-                    signal: aborter.signal,
-                    ...self.renderProps(),
+        /**
+         * #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 rendererConfig() {
+            const configBlob = 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 } : {}),
+            }, getEnv(self));
+        },
+    }))
+        .views(self => {
+        let oldDomain = [0, 0];
+        return {
+            /**
+             * #getter
+             */
+            get filled() {
+                const { fill, rendererConfig: conf } = self;
+                return fill !== null && fill !== void 0 ? fill : readConfObject(conf, 'filled');
+            },
+            /**
+             * #getter
+             */
+            get summaryScoreModeSetting() {
+                const { summaryScoreMode, rendererConfig: conf } = self;
+                return summaryScoreMode !== null && summaryScoreMode !== void 0 ? summaryScoreMode : readConfObject(conf, 'summaryScoreMode');
+            },
+            /**
+             * #getter
+             */
+            get domain() {
+                const { stats, scaleType, minScore, maxScore } = self;
+                const ret = getNiceDomain({
+                    domain: [stats.scoreMin, stats.scoreMax],
+                    bounds: [minScore, maxScore],
+                    scaleType,
                 });
-                if (isAlive(self)) {
-                    self.updateStats(stats);
-                    superReload();
+                // avoid weird scalebar if log value and empty region displayed
+                if (scaleType === 'log' && ret[1] === Number.MIN_VALUE) {
+                    return [0, Number.MIN_VALUE];
                 }
-            }
-            catch (e) {
-                self.setError(e);
-            }
-        },
-        afterAttach() {
-            statsAutorun(self);
+                // avoid returning a new object if it matches the old value
+                if (JSON.stringify(oldDomain) !== JSON.stringify(ret)) {
+                    oldDomain = ret;
+                }
+                return oldDomain;
+            },
+            /**
+             * #getter
+             */
+            get needsScalebar() {
+                return (self.rendererTypeName === 'XYPlotRenderer' ||
+                    self.rendererTypeName === 'LinePlotRenderer');
+            },
+            /**
+             * #getter
+             */
+            get scaleOpts() {
+                return {
+                    domain: this.domain,
+                    stats: self.stats,
+                    autoscaleType: this.autoscaleType,
+                    scaleType: self.scaleType,
+                    inverted: getConf(self, 'inverted'),
+                };
+            },
+            /**
+             * #getter
+             */
+            get canHaveFill() {
+                return self.rendererTypeName === 'XYPlotRenderer';
+            },
+            /**
+             * #getter
+             */
+            get autoscaleType() {
+                var _a;
+                return (_a = self.autoscale) !== null && _a !== void 0 ? _a : getConf(self, 'autoscale');
+            },
+            /**
+             * #getter
+             */
+            get displayCrossHatchesSetting() {
+                const { displayCrossHatches: hatches, rendererConfig: conf } = self;
+                return hatches !== null && hatches !== void 0 ? hatches : readConfObject(conf, 'displayCrossHatches');
+            },
+        };
+    })
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get ticks() {
+            const { scaleType, domain, height } = self;
+            const minimalTicks = getConf(self, 'minimalTicks');
+            const inverted = getConf(self, 'inverted');
+            const range = [height - YSCALEBAR_LABEL_OFFSET, YSCALEBAR_LABEL_OFFSET];
+            const scale = getScale({
+                scaleType,
+                domain,
+                range,
+                inverted,
+            });
+            const ticks = axisPropsFromTickScale(scale, 4);
+            return height < 100 || minimalTicks
+                ? { ...ticks, values: domain }
+                : ticks;
         },
-        async renderSvg(opts) {
-            await when(() => self.statsReady && !!self.regionCannotBeRenderedText);
-            const { needsScalebar, stats } = self;
-            const { offsetPx } = getContainingView(self);
-            return (React.createElement(React.Fragment, null,
-                React.createElement("g", { id: "snpcov" }, await superRenderSvg(opts)),
-                needsScalebar && stats ? (React.createElement("g", { transform: `translate(${Math.max(-offsetPx, 0)})` },
-                    React.createElement(YScaleBar, { model: self, orientation: "left" }))) : null));
+        /**
+         * #getter
+         */
+        get adapterCapabilities() {
+            const type = self.adapterTypeName;
+            return pluginManager.getAdapterType(type).adapterCapabilities;
         },
-    };
-});
+    }))
+        .views(self => {
+        const { renderProps: superRenderProps } = self;
+        return {
+            /**
+             * #method
+             */
+            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,
+                };
+            },
+            /**
+             * #getter
+             */
+            get hasResolution() {
+                return self.adapterCapabilities.includes('hasResolution');
+            },
+            /**
+             * #getter
+             */
+            get hasGlobalStats() {
+                return self.adapterCapabilities.includes('hasGlobalStats');
+            },
+            /**
+             * #getter
+             */
+            get fillSetting() {
+                if (self.filled) {
+                    return 0;
+                }
+                else if (!self.filled && self.minSize === 1) {
+                    return 1;
+                }
+                else {
+                    return 2;
+                }
+            },
+        };
+    })
+        .views(self => {
+        const { trackMenuItems: superTrackMenuItems } = self;
+        const hasRenderings = getConf(self, 'defaultRendering');
+        return {
+            /**
+             * #method
+             */
+            trackMenuItems() {
+                return [
+                    ...superTrackMenuItems(),
+                    ...(self.hasResolution
+                        ? [
+                            {
+                                label: 'Resolution',
+                                subMenu: [
+                                    {
+                                        label: 'Finer resolution',
+                                        onClick: () => self.setResolution(self.resolution * 5),
+                                    },
+                                    {
+                                        label: 'Coarser resolution',
+                                        onClick: () => self.setResolution(self.resolution / 5),
+                                    },
+                                ],
+                            },
+                            {
+                                label: 'Summary score mode',
+                                subMenu: ['min', 'max', 'avg', 'whiskers'].map(elt => ({
+                                    label: elt,
+                                    type: 'radio',
+                                    checked: self.summaryScoreModeSetting === elt,
+                                    onClick: () => self.setSummaryScoreMode(elt),
+                                })),
+                            },
+                        ]
+                        : []),
+                    ...(self.canHaveFill
+                        ? [
+                            {
+                                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),
+                                })),
+                            },
+                        ]
+                        : []),
+                    {
+                        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(key => ({
+                                    label: key,
+                                    type: 'radio',
+                                    checked: self.rendererTypeNameSimple === key,
+                                    onClick: () => self.setRendererType(key),
+                                })),
+                            },
+                        ]
+                        : []),
+                    {
+                        label: 'Autoscale type',
+                        subMenu: [
+                            ['local', 'Local'],
+                            ...(self.hasGlobalStats
+                                ? [
+                                    ['global', 'Global'],
+                                    ['globalsd', 'Global ± 3σ'],
+                                ]
+                                : []),
+                            ['localsd', 'Local ± 3σ'],
+                        ].map(([val, label]) => ({
+                            label,
+                            type: 'radio',
+                            checked: self.autoscaleType === val,
+                            onClick: () => self.setAutoscale(val),
+                        })),
+                    },
+                    {
+                        label: 'Set min/max score',
+                        onClick: () => {
+                            getSession(self).queueDialog(handleClose => [
+                                SetMinMaxDlg,
+                                { model: self, handleClose },
+                            ]);
+                        },
+                    },
+                    {
+                        label: 'Set color',
+                        onClick: () => {
+                            getSession(self).queueDialog(handleClose => [
+                                SetColorDlg,
+                                { model: self, handleClose },
+                            ]);
+                        },
+                    },
+                ];
+            },
+        };
+    })
+        .actions(self => {
+        const { reload: superReload, renderSvg: superRenderSvg } = self;
+        return {
+            /**
+             * #action
+             * re-runs stats and refresh whole display on reload
+             */
+            async reload() {
+                self.setError();
+                const aborter = new AbortController();
+                self.setLoading(aborter);
+                try {
+                    const stats = await getStats(self, {
+                        signal: aborter.signal,
+                        ...self.renderProps(),
+                    });
+                    if (isAlive(self)) {
+                        self.updateStats(stats);
+                        superReload();
+                    }
+                }
+                catch (e) {
+                    self.setError(e);
+                }
+            },
+            afterAttach() {
+                statsAutorun(self);
+            },
+            /**
+             * #action
+             */
+            async renderSvg(opts) {
+                await when(() => self.statsReady && !!self.regionCannotBeRenderedText);
+                const { needsScalebar, stats } = self;
+                const { offsetPx } = getContainingView(self);
+                return (React.createElement(React.Fragment, null,
+                    React.createElement("g", { id: "snpcov" }, await superRenderSvg(opts)),
+                    needsScalebar && stats ? (React.createElement("g", { transform: `translate(${Math.max(-offsetPx, 0)})` },
+                        React.createElement(YScaleBar, { model: self, orientation: "left" }))) : null));
+            },
+        };
+    });
+}
 export default stateModelFactory;
 //# sourceMappingURL=model.js.map