@jbrowse/plugin-wiggle 2.5.0 → 2.6.2

package/dist/shared/modelShared.js

@@ -0,0 +1,479 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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_state_tree_1 = require("mobx-state-tree");
+// locals
+const util_2 = require("../util");
+const react_1 = require("react");
+// lazies
+const SetMinMaxDlg = (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(() => ({
+        message: undefined,
+        stats: undefined,
+        statsFetchInProgress: undefined,
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        updateQuantitativeStats(stats) {
+            const { scoreMin, scoreMax } = stats;
+            const EPSILON = 0.000001;
+            if (!self.stats) {
+                self.stats = { scoreMin, scoreMax };
+            }
+            else if (Math.abs(self.stats.scoreMax - scoreMax) > EPSILON ||
+                Math.abs(self.stats.scoreMin - scoreMin) > EPSILON) {
+                self.stats = { 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();
+            }
+            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 = (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;
+                self.minSize = 0;
+            }
+            else if (fill === 1) {
+                self.fill = false;
+                self.minSize = 1;
+            }
+            else if (fill === 2) {
+                self.fill = false;
+                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]) || {};
+            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, util_1.getEnv)(self));
+        },
+        /**
+         * #getter
+         */
+        get autoscaleType() {
+            var _a;
+            return (_a = self.autoscale) !== null && _a !== void 0 ? _a : (0, configuration_1.getConf)(self, 'autoscale');
+        },
+    }))
+        .views(self => {
+        let oldDomain = [0, 0];
+        return {
+            /**
+             * #getter
+             */
+            get domain() {
+                const { stats, scaleType, minScore, maxScore } = self;
+                if (!stats) {
+                    return undefined;
+                }
+                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];
+                }
+                // avoid returning a new object if it matches the old value
+                if (JSON.stringify(oldDomain) !== JSON.stringify(ret)) {
+                    oldDomain = ret;
+                }
+                return oldDomain;
+            },
+        };
+    })
+        .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,
+                stats: self.stats,
+                autoscaleType: self.autoscaleType,
+                scaleType: self.scaleType,
+                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
+                    ? [
+                        {
+                            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),
+                            })),
+                        },
+                    ]
+                    : []),
+                {
+                    label: self.scaleType === 'log' ? 'Set linear scale' : 'Set log scale',
+                    onClick: () => self.toggleLogScale(),
+                },
+                {
+                    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: () => {
+                        (0, util_1.getSession)(self).queueDialog(handleClose => [
+                            SetMinMaxDlg,
+                            { model: self, handleClose },
+                        ]);
+                    },
+                },
+            ];
+        },
+    }))
+        .actions(self => {
+        const { reload: superReload } = self;
+        return {
+            /**
+             * #action
+             */
+            async reload() {
+                self.setError();
+                superReload();
+            },
+        };
+    });
+}
+exports.default = SharedWiggleMixin;

package/dist/util.d.ts

@@ -47,9 +47,6 @@ export declare function getNiceDomain({ scaleType, domain, bounds, }: {
     domain: readonly [number, number];
     bounds: readonly [number | undefined, number | undefined];
 }): [number, number];
-export declare function groupBy<T>(array: T[], predicate: (v: T) => string): {
-    [key: string]: T[];
-};
 export declare function getQuantitativeStats(self: {
     adapterConfig: AnyConfigurationModel;
     configuration: AnyConfigurationModel;

package/dist/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.round = exports.toP = exports.quantitativeStatsAutorun = exports.getQuantitativeStats = exports.groupBy = exports.getNiceDomain = exports.getOrigin = exports.getScale = exports.YSCALEBAR_LABEL_OFFSET = void 0;
+exports.round = exports.toP = exports.quantitativeStatsAutorun = exports.getQuantitativeStats = exports.getNiceDomain = exports.getOrigin = exports.getScale = exports.YSCALEBAR_LABEL_OFFSET = void 0;
 const d3_scale_1 = require("d3-scale");
 const mobx_1 = require("mobx");
 const util_1 = require("@jbrowse/core/util");
@@ -132,16 +132,6 @@ function getNiceDomain({ scaleType, domain, bounds, }) {
     return scale.domain();
 }
 exports.getNiceDomain = getNiceDomain;
-function groupBy(array, predicate) {
-    var _a;
-    const result = {};
-    for (const value of array) {
-        const entry = (result[_a = predicate(value)] || (result[_a] = []));
-        entry.push(value);
-    }
-    return result;
-}
-exports.groupBy = groupBy;
 async function getQuantitativeStats(self, opts) {
     const { rpcManager } = (0, util_1.getSession)(self);
     const nd = (0, configuration_1.getConf)(self, 'numStdDev') || 3;
@@ -241,4 +231,3 @@ function round(value) {
     return Math.round(value * 1e5) / 1e5;
 }
 exports.round = round;
-//# sourceMappingURL=util.js.map

package/esm/BigWigAdapter/BigWigAdapter.js

@@ -7,8 +7,9 @@ import { rectifyStats, } from '@jbrowse/core/util/stats';
 class BigWigAdapter extends BaseFeatureDataAdapter {
     async setupPre(opts) {
         const { statusCallback = () => { } } = opts || {};
+        const pm = this.pluginManager;
         const bigwig = new BigWig({
-            filehandle: openLocation(this.getConf('bigWigLocation'), this.pluginManager),
+            filehandle: openLocation(this.getConf('bigWigLocation'), pm),
         });
         const header = await updateStatus('Downloading bigwig header', statusCallback, () => bigwig.getHeader(opts));
         return { bigwig, header };
@@ -78,4 +79,3 @@ BigWigAdapter.capabilities = [
     'hasGlobalStats',
 ];
 export default BigWigAdapter;
-//# sourceMappingURL=BigWigAdapter.js.map

package/esm/BigWigAdapter/configSchema.js

@@ -24,4 +24,3 @@ const BigWigAdapter = ConfigurationSchema('BigWigAdapter', {
     },
 }, { explicitlyTyped: true });
 export default BigWigAdapter;
-//# sourceMappingURL=configSchema.js.map

package/esm/BigWigAdapter/index.js

@@ -13,4 +13,3 @@ export default (pluginManager) => {
         getAdapterClass: () => import('./BigWigAdapter').then(r => r.default),
     }));
 };
-//# sourceMappingURL=index.js.map

package/esm/CreateMultiWiggleExtension/ConfirmDialog.d.ts

@@ -1,8 +1,9 @@
+import React from 'react';
 import { AnyConfigurationModel } from '@jbrowse/core/configuration';
 declare const ConfirmDialog: ({ tracks, onClose, }: {
     tracks: AnyConfigurationModel[];
     onClose: (arg: boolean, arg1?: {
         name: string;
     }) => void;
-}) => JSX.Element;
+}) => React.JSX.Element;
 export default ConfirmDialog;

package/esm/CreateMultiWiggleExtension/ConfirmDialog.js

@@ -23,4 +23,3 @@ const ConfirmDialog = ({ tracks, onClose, }) => {
             React.createElement(Button, { onClick: () => onClose(true, { name: val }), color: "primary", variant: "contained", autoFocus: true }, "Submit"))));
 };
 export default ConfirmDialog;
-//# sourceMappingURL=ConfirmDialog.js.map

package/esm/CreateMultiWiggleExtension/index.js

@@ -54,4 +54,3 @@ export default function (pm) {
         ];
     });
 }
-//# sourceMappingURL=index.js.map

package/esm/DensityRenderer/DensityRenderer.js

@@ -5,4 +5,3 @@ export default class DensityRenderer extends WiggleBaseRenderer {
         return drawDensity(ctx, props);
     }
 }
-//# sourceMappingURL=DensityRenderer.js.map

package/esm/DensityRenderer/configSchema.js

@@ -12,4 +12,3 @@ const configSchema = ConfigurationSchema('DensityRenderer', {}, {
     explicitlyTyped: true,
 });
 export default configSchema;
-//# sourceMappingURL=configSchema.js.map

package/esm/DensityRenderer/index.js

@@ -9,4 +9,3 @@ export default (pluginManager) => {
         pluginManager,
     }));
 };
-//# sourceMappingURL=index.js.map

package/esm/LinePlotRenderer/LinePlotRenderer.js

@@ -10,4 +10,3 @@ export default class LinePlotRenderer extends WiggleBaseRenderer {
         });
     }
 }
-//# sourceMappingURL=LinePlotRenderer.js.map

package/esm/LinePlotRenderer/configSchema.js

@@ -21,4 +21,3 @@ const configSchema = ConfigurationSchema('LinePlotRenderer', {
     explicitlyTyped: true,
 });
 export default configSchema;
-//# sourceMappingURL=configSchema.js.map

package/esm/LinePlotRenderer/index.js

@@ -9,4 +9,3 @@ export default (pluginManager) => {
         pluginManager,
     }));
 };
-//# sourceMappingURL=index.js.map

package/esm/LinearWiggleDisplay/components/SetColorDialog.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 declare function SetColorDialog({ model, handleClose, }: {
     model: {
         color?: string;
@@ -8,6 +9,6 @@ declare function SetColorDialog({ model, handleClose, }: {
         setNegColor: (arg?: string) => void;
     };
     handleClose: () => void;
-}): JSX.Element;
+}): React.JSX.Element;
 declare const _default: typeof SetColorDialog;
 export default _default;

package/esm/LinearWiggleDisplay/components/SetColorDialog.js

@@ -32,4 +32,3 @@ function SetColorDialog({ model, handleClose, }) {
             React.createElement(Button, { variant: "contained", color: "primary", type: "submit", onClick: () => handleClose() }, "Submit"))));
 }
 export default observer(SetColorDialog);
-//# sourceMappingURL=SetColorDialog.js.map

package/esm/LinearWiggleDisplay/components/Tooltip.d.ts

@@ -15,6 +15,6 @@ declare const WiggleTooltip: (props: {
     clientMouseCoord: Coord;
     clientRect?: DOMRect;
     TooltipContents?: TooltipContentsComponent;
-}) => JSX.Element;
+}) => React.JSX.Element;
 export default WiggleTooltip;
 export { default as Tooltip } from '../../Tooltip';

package/esm/LinearWiggleDisplay/components/Tooltip.js

@@ -31,4 +31,3 @@ const WiggleTooltip = observer(function (props) {
 });
 export default WiggleTooltip;
 export { default as Tooltip } from '../../Tooltip';
-//# sourceMappingURL=Tooltip.js.map

package/esm/LinearWiggleDisplay/components/WiggleDisplayComponent.d.ts

@@ -1,6 +1,7 @@
+import React from 'react';
 import { WiggleDisplayModel } from '../models/model';
 declare const LinearWiggleDisplay: (props: {
     model: WiggleDisplayModel;
-}) => JSX.Element;
+}) => React.JSX.Element;
 export default LinearWiggleDisplay;
 export { default as YScaleBar } from '../../shared/YScaleBar';

package/esm/LinearWiggleDisplay/components/WiggleDisplayComponent.js

@@ -26,4 +26,3 @@ const LinearWiggleDisplay = observer((props) => {
 });
 export default LinearWiggleDisplay;
 export { default as YScaleBar } from '../../shared/YScaleBar';
-//# sourceMappingURL=WiggleDisplayComponent.js.map

package/esm/LinearWiggleDisplay/index.js

@@ -1,7 +1,7 @@
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
 import configSchemaFactory from './models/configSchema';
 import modelFactory from './models/model';
-import ReactComponent from './components/WiggleDisplayComponent';
+import { lazy } from 'react';
 export default (pluginManager) => {
     pluginManager.addDisplayType(() => {
         const configSchema = configSchemaFactory(pluginManager);
@@ -13,11 +13,10 @@ export default (pluginManager) => {
             stateModel,
             trackType: 'QuantitativeTrack',
             viewType: 'LinearGenomeView',
-            ReactComponent,
+            ReactComponent: lazy(() => import('./components/WiggleDisplayComponent')),
         });
     });
 };
 export { default as Tooltip } from './components/Tooltip';
 export { default as ReactComponent } from './components/WiggleDisplayComponent';
 export { default as modelFactory } from './models/model';
-//# sourceMappingURL=index.js.map