@jbrowse/plugin-wiggle 2.16.0 → 2.17.0

package/esm/MultiRowXYPlotRenderer/configSchema.js

@@ -35,7 +35,7 @@ const configSchema = ConfigurationSchema('MultiRowXYPlotRenderer', {
      */
     minSize: {
         type: 'number',
-        defaultValue: 0,
+        defaultValue: 0.7,
     },
 }, {
     /**

package/esm/MultiWiggleAdapter/MultiWiggleAdapter.d.ts

@@ -21,7 +21,7 @@ export default class MultiWiggleAdapter extends BaseFeatureDataAdapter {
     getMultiRegionFeatureDensityStats(_regions: Region[]): Promise<{
         featureDensity: number;
     }>;
-    getSources(): Promise<{
+    getSources(_regions: Region[]): Promise<{
         name: string;
         __name: unknown;
     }[]>;

package/esm/MultiWiggleAdapter/MultiWiggleAdapter.js

@@ -65,11 +65,13 @@ class MultiWiggleAdapter extends BaseFeatureDataAdapter {
     }
     // always render bigwig instead of calculating a feature density for it
     async getMultiRegionFeatureDensityStats(_regions) {
-        return { featureDensity: 0 };
+        return {
+            featureDensity: 0,
+        };
     }
     // in another adapter type, this could be dynamic depending on region or
     // something, but it is static for this particular multi-wiggle adapter type
-    async getSources() {
+    async getSources(_regions) {
         const adapters = await this.getAdapters();
         return adapters.map(({ dataAdapter, source, name, ...rest }) => ({
             name: source,

package/esm/MultiWiggleAddTrackWorkflow/AddTrackWorkflow.js

@@ -4,9 +4,6 @@ import { makeStyles } from 'tss-react/mui';
 import { getSession, isElectron, isSessionModelWithWidgets, isSessionWithAddTracks, } from '@jbrowse/core/util';
 import { storeBlobLocation } from '@jbrowse/core/util/tracks';
 const useStyles = makeStyles()(theme => ({
-    textbox: {
-        width: '100%',
-    },
     paper: {
         margin: theme.spacing(),
         padding: theme.spacing(),
@@ -17,6 +14,16 @@ const useStyles = makeStyles()(theme => ({
         display: 'block',
     },
 }));
+// on electron, use path to LocalFileLocation, on web, use the BlobLocation
+function makeFileLocation(file) {
+    const { webUtils } = window.require('electron');
+    return isElectron
+        ? {
+            localPath: webUtils.getPathForFile(file),
+            locationType: 'LocalPathLocation',
+        }
+        : storeBlobLocation({ blob: file });
+}
 export default function MultiWiggleWidget({ model }) {
     const { classes } = useStyles();
     const [val, setVal] = useState('');
@@ -25,64 +32,65 @@ export default function MultiWiggleWidget({ model }) {
         React.createElement("ul", null,
             React.createElement("li", null, "Enter list of URLs for bigwig files in the textbox"),
             React.createElement("li", null, "Or, use the button below the text box to select files from your computer")),
-        React.createElement(TextField, { multiline: true, rows: 10, value: val, onChange: event => {
+        React.createElement(TextField, { multiline: true, fullWidth: true, rows: 10, value: val, placeholder: "Paste list of URLs here, or use file selector below", variant: "outlined", onChange: event => {
                 setVal(event.target.value);
-            }, placeholder: 'Paste list of URLs here, or use file selector below', variant: "outlined", className: classes.textbox }),
+            } }),
         React.createElement(Button, { variant: "outlined", component: "label" },
             "Choose Files from your computer",
             React.createElement("input", { type: "file", hidden: true, multiple: true, onChange: ({ target }) => {
                     const res = [...(target.files || [])].map(file => ({
                         type: 'BigWigAdapter',
-                        bigWigLocation: isElectron
-                            ? {
-                                localPath: file.path,
-                                locationType: 'LocalPathLocation',
-                            }
-                            : storeBlobLocation({ blob: file }),
+                        bigWigLocation: makeFileLocation(file),
                         source: file.name,
                     }));
                     setVal(JSON.stringify(res, null, 2));
                 } })),
-        React.createElement(TextField, { value: trackName, onChange: event => {
+        React.createElement(TextField, { value: trackName, helperText: "Track name", onChange: event => {
                 setTrackName(event.target.value);
-            }, helperText: "Track name" }),
+            } }),
         React.createElement(Button, { variant: "contained", className: classes.submit, onClick: () => {
                 var _a;
                 const session = getSession(model);
-                const trackId = [
-                    `${trackName.toLowerCase().replaceAll(' ', '_')}-${Date.now()}`,
-                    session.adminMode ? '' : '-sessionTrack',
-                ].join('');
-                // allow list of bigwigs in JSON format or line-by-line
-                let bigWigs;
                 try {
-                    bigWigs = JSON.parse(val);
+                    const trackId = [
+                        `${trackName.toLowerCase().replaceAll(' ', '_')}-${Date.now()}`,
+                        session.adminMode ? '' : '-sessionTrack',
+                    ].join('');
+                    // allow list of bigwigs in JSON format or line-by-line
+                    let bigWigs;
+                    try {
+                        bigWigs = JSON.parse(val);
+                    }
+                    catch (e) {
+                        bigWigs = val
+                            .split(/\n|\r\n|\r/)
+                            .map(f => f.trim())
+                            .filter(f => !!f);
+                    }
+                    const obj = typeof bigWigs[0] === 'string'
+                        ? { bigWigs }
+                        : { subadapters: bigWigs };
+                    if (isSessionWithAddTracks(session)) {
+                        session.addTrackConf({
+                            trackId,
+                            type: 'MultiQuantitativeTrack',
+                            name: trackName,
+                            assemblyNames: [model.assembly],
+                            adapter: {
+                                type: 'MultiWiggleAdapter',
+                                ...obj,
+                            },
+                        });
+                        (_a = model.view) === null || _a === void 0 ? void 0 : _a.showTrack(trackId);
+                    }
+                    model.clearData();
+                    if (isSessionModelWithWidgets(session)) {
+                        session.hideWidget(model);
+                    }
                 }
                 catch (e) {
-                    bigWigs = val
-                        .split(/\n|\r\n|\r/)
-                        .map(f => f.trim())
-                        .filter(f => !!f);
-                }
-                const obj = typeof bigWigs[0] === 'string'
-                    ? { bigWigs }
-                    : { subadapters: bigWigs };
-                if (isSessionWithAddTracks(session)) {
-                    session.addTrackConf({
-                        trackId,
-                        type: 'MultiQuantitativeTrack',
-                        name: trackName,
-                        assemblyNames: [model.assembly],
-                        adapter: {
-                            type: 'MultiWiggleAdapter',
-                            ...obj,
-                        },
-                    });
-                    (_a = model.view) === null || _a === void 0 ? void 0 : _a.showTrack(trackId);
-                }
-                model.clearData();
-                if (isSessionModelWithWidgets(session)) {
-                    session.hideWidget(model);
+                    console.error(e);
+                    session.notifyError(`${e}`, e);
                 }
             } }, "Submit"),
         React.createElement("p", null, "Additional notes: "),

package/esm/MultiXYPlotRenderer/configSchema.js

@@ -35,7 +35,7 @@ const configSchema = ConfigurationSchema('MultiXYPlotRenderer', {
      */
     minSize: {
         type: 'number',
-        defaultValue: 0,
+        defaultValue: 0.7,
     },
 }, {
     /**

package/esm/WiggleBaseRenderer.d.ts

@@ -54,4 +54,4 @@ export default abstract class WiggleBaseRenderer extends FeatureRendererType {
      */
     abstract draw<T extends RenderArgsDeserializedWithFeatures>(ctx: CanvasRenderingContext2D, props: T): Promise<Record<string, unknown> | undefined>;
 }
-export { type RenderArgsSerialized, type RenderResults, type ResultsDeserialized, type ResultsSerialized, } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
+export type { RenderArgsSerialized, RenderResults, ResultsDeserialized, ResultsSerialized, } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';

package/esm/XYPlotRenderer/configSchema.js

@@ -35,7 +35,7 @@ const configSchema = ConfigurationSchema('XYPlotRenderer', {
      */
     minSize: {
         type: 'number',
-        defaultValue: 0,
+        defaultValue: 0.7,
     },
 }, {
     /**

package/esm/getMultiWiggleSourcesAutorun.d.ts

@@ -0,0 +1,17 @@
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+export interface Source {
+    name: string;
+    color?: string;
+    group?: string;
+}
+export declare function getMultiWiggleSourcesAutorun(self: {
+    quantitativeStatsReady: boolean;
+    configuration: AnyConfigurationModel;
+    adapterConfig: AnyConfigurationModel;
+    autoscaleType: string;
+    adapterProps: () => Record<string, unknown>;
+    setStatsLoading: (aborter: AbortController) => void;
+    setError: (error: unknown) => void;
+    setMessage: (str: string) => void;
+    setSources: (sources: Source[]) => void;
+}): void;

package/esm/getMultiWiggleSourcesAutorun.js

@@ -0,0 +1,32 @@
+import { autorun } from 'mobx';
+import { addDisposer, isAlive } from 'mobx-state-tree';
+// jbrowse
+import { getContainingView, getSession, isAbortException, } from '@jbrowse/core/util';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+export function getMultiWiggleSourcesAutorun(self) {
+    addDisposer(self, autorun(async () => {
+        try {
+            const { rpcManager } = getSession(self);
+            const { adapterConfig } = self;
+            const sessionId = getRpcSessionId(self);
+            const view = getContainingView(self);
+            if (!view.initialized) {
+                return;
+            }
+            const sources = (await rpcManager.call(sessionId, 'MultiWiggleGetSources', {
+                regions: view.staticBlocks.contentBlocks,
+                sessionId,
+                adapterConfig,
+            }));
+            if (isAlive(self)) {
+                self.setSources(sources);
+            }
+        }
+        catch (e) {
+            if (!isAbortException(e) && isAlive(self)) {
+                console.error(e);
+                getSession(self).notifyError(`${e}`, e);
+            }
+        }
+    }));
+}

package/esm/getQuantitativeStats.d.ts

@@ -0,0 +1,13 @@
+import { QuantitativeStats } from '@jbrowse/core/util/stats';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+export declare function getQuantitativeStats(self: {
+    adapterConfig: AnyConfigurationModel;
+    configuration: AnyConfigurationModel;
+    autoscaleType: string;
+    setMessage: (str: string) => void;
+}, opts: {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    filters: string[];
+    currStatsBpPerPx: number;
+}): Promise<QuantitativeStats>;

package/esm/getQuantitativeStats.js

@@ -0,0 +1,75 @@
+import { isAlive } from 'mobx-state-tree';
+// jbrowse
+import { getSession, getContainingView } from '@jbrowse/core/util';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { getConf } from '@jbrowse/core/configuration';
+export async function getQuantitativeStats(self, opts) {
+    const { rpcManager } = getSession(self);
+    const numStdDev = getConf(self, 'numStdDev') || 3;
+    const { adapterConfig, autoscaleType } = self;
+    const sessionId = getRpcSessionId(self);
+    const { currStatsBpPerPx } = opts;
+    const params = {
+        sessionId,
+        adapterConfig,
+        statusCallback: (message) => {
+            if (isAlive(self)) {
+                self.setMessage(message);
+            }
+        },
+        ...opts,
+    };
+    if (autoscaleType === 'global' || autoscaleType === 'globalsd') {
+        const results = (await rpcManager.call(sessionId, 'WiggleGetGlobalQuantitativeStats', params));
+        const { scoreMin, scoreMean, scoreStdDev } = results;
+        // globalsd uses heuristic to avoid unnecessary scoreMin<0
+        //
+        // if the scoreMin is never less than 0 helps with most coverage bigwigs
+        // just being >0
+        return autoscaleType === 'globalsd'
+            ? {
+                ...results,
+                scoreMin: scoreMin >= 0 ? 0 : scoreMean - numStdDev * scoreStdDev,
+                scoreMax: scoreMean + numStdDev * scoreStdDev,
+                currStatsBpPerPx,
+            }
+            : {
+                ...results,
+                currStatsBpPerPx,
+            };
+    }
+    if (autoscaleType === 'local' || autoscaleType === 'localsd') {
+        const { dynamicBlocks, bpPerPx } = getContainingView(self);
+        const results = (await rpcManager.call(sessionId, 'WiggleGetMultiRegionQuantitativeStats', {
+            ...params,
+            regions: dynamicBlocks.contentBlocks.map(region => {
+                const { start, end } = region;
+                return {
+                    ...JSON.parse(JSON.stringify(region)),
+                    start: Math.floor(start),
+                    end: Math.ceil(end),
+                };
+            }),
+            bpPerPx,
+        }));
+        const { scoreMin, scoreMean, scoreStdDev } = results;
+        // localsd uses heuristic to avoid unnecessary scoreMin<0 if the
+        // scoreMin is never less than 0 helps with most coverage bigwigs
+        // just being >0
+        return autoscaleType === 'localsd'
+            ? {
+                ...results,
+                scoreMin: scoreMin >= 0 ? 0 : scoreMean - numStdDev * scoreStdDev,
+                scoreMax: scoreMean + numStdDev * scoreStdDev,
+                currStatsBpPerPx,
+            }
+            : {
+                ...results,
+                currStatsBpPerPx,
+            };
+    }
+    if (autoscaleType === 'zscale') {
+        return rpcManager.call(sessionId, 'WiggleGetGlobalQuantitativeStats', params);
+    }
+    throw new Error(`invalid autoscaleType '${autoscaleType}'`);
+}

package/esm/getQuantitativeStatsAutorun.d.ts

@@ -0,0 +1,13 @@
+import { QuantitativeStats } from '@jbrowse/core/util/stats';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+export declare function getQuantitativeStatsAutorun(self: {
+    quantitativeStatsReady: boolean;
+    configuration: AnyConfigurationModel;
+    adapterConfig: AnyConfigurationModel;
+    autoscaleType: string;
+    adapterProps: () => Record<string, unknown>;
+    setStatsLoading: (aborter: AbortController) => void;
+    setError: (error: unknown) => void;
+    setMessage: (str: string) => void;
+    updateQuantitativeStats: (stats: QuantitativeStats, region: string) => void;
+}): void;

package/esm/getQuantitativeStatsAutorun.js

@@ -0,0 +1,34 @@
+import { autorun } from 'mobx';
+import { addDisposer, isAlive } from 'mobx-state-tree';
+// jbrowse
+import { isAbortException, getContainingView } from '@jbrowse/core/util';
+// locals
+import { getQuantitativeStats } from './getQuantitativeStats';
+export function getQuantitativeStatsAutorun(self) {
+    addDisposer(self, autorun(async () => {
+        try {
+            const view = getContainingView(self);
+            const aborter = new AbortController();
+            self.setStatsLoading(aborter);
+            if (!self.quantitativeStatsReady) {
+                return;
+            }
+            const statsRegion = JSON.stringify(view.dynamicBlocks);
+            const wiggleStats = await getQuantitativeStats(self, {
+                signal: aborter.signal,
+                filters: [],
+                currStatsBpPerPx: view.bpPerPx,
+                ...self.adapterProps(),
+            });
+            if (isAlive(self)) {
+                self.updateQuantitativeStats(wiggleStats, statsRegion);
+            }
+        }
+        catch (e) {
+            console.error(e);
+            if (!isAbortException(e) && isAlive(self)) {
+                self.setError(e);
+            }
+        }
+    }, { delay: 1000 }));
+}

package/esm/index.d.ts

@@ -9,7 +9,7 @@ export default class WigglePlugin extends Plugin {
     install(pm: PluginManager): void;
     exports: {
         LinearWiggleDisplayReactComponent: (props: {
-            model: import("./LinearWiggleDisplay/models/model").WiggleDisplayModel;
+            model: import("./LinearWiggleDisplay/model").WiggleDisplayModel;
         }) => import("react").JSX.Element;
         XYPlotRendererReactComponent: (props: {
             regions: import("@jbrowse/core/util/types").Region[];
@@ -84,5 +84,5 @@ export default class WigglePlugin extends Plugin {
 export * from './util';
 export { default as WiggleRendering } from './WiggleRendering';
 export { Tooltip, ReactComponent as LinearWiggleDisplayReactComponent, modelFactory as linearWiggleDisplayModelFactory, } from './LinearWiggleDisplay';
-export { type TooltipContentsComponent } from './Tooltip';
+export type { TooltipContentsComponent } from './Tooltip';
 export { default as WiggleBaseRenderer } from './WiggleBaseRenderer';

package/{dist/shared/modelShared.d.ts → esm/shared/SharedWiggleMixin.d.ts}

@@ -195,7 +195,9 @@ export default function SharedWiggleMixin(configSchema: AnyConfigurationSchemaTy
             message: string | undefined;
         } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
             id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
+            type: import("mobx-state-tree" /**
+             * #action
+             */).ISimpleType<string>;
             rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
@@ -284,17 +286,28 @@ export default function SharedWiggleMixin(configSchema: AnyConfigurationSchemaTy
     renderSvg(opts: import("@jbrowse/plugin-linear-genome-view").ExportSvgDisplayOptions): Promise<import("react").JSX.Element>;
     afterAttach(): void;
 } & {
+    /**
+     * #volatile
+     */
     message: undefined | string;
+    /**
+     * #volatile
+     */
     stats: {
+        currStatsBpPerPx: number;
         scoreMin: number;
         scoreMax: number;
     } | undefined;
+    /**
+     * #volatile
+     */
     statsFetchInProgress: undefined | AbortController;
 } & {
     /**
      * #action
      */
     updateQuantitativeStats(stats: {
+        currStatsBpPerPx: number;
         scoreMin: number;
         scoreMax: number;
     }): void;
@@ -313,7 +326,7 @@ export default function SharedWiggleMixin(configSchema: AnyConfigurationSchemaTy
     /**
      * #action
      */
-    setLoading(aborter: AbortController): void;
+    setStatsLoading(aborter: AbortController): void;
     /**
      * #action
      * this overrides the BaseLinearDisplayModel to avoid popping up a
@@ -436,6 +449,7 @@ export default function SharedWiggleMixin(configSchema: AnyConfigurationSchemaTy
     readonly scaleOpts: {
         domain: number[] | undefined;
         stats: {
+            currStatsBpPerPx: number;
             scoreMin: number;
             scoreMax: number;
         } | undefined;
@@ -585,8 +599,8 @@ export default function SharedWiggleMixin(configSchema: AnyConfigurationSchemaTy
         };
     }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "displayId">>;
 }>> & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree")._NotCustomized, {
-    type: string;
     id: string;
+    type: string;
     configuration: import("mobx-state-tree").ModelSnapshotType<Record<string, any>>;
     heightPreConfig: number | undefined;
     rpcDriverName: string | undefined;

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

@@ -74,8 +74,17 @@ export default function SharedWiggleMixin(configSchema) {
         configuration: ConfigurationReference(configSchema),
     }))
         .volatile(() => ({
+        /**
+         * #volatile
+         */
         message: undefined,
+        /**
+         * #volatile
+         */
         stats: undefined,
+        /**
+         * #volatile
+         */
         statsFetchInProgress: undefined,
     }))
         .actions(self => ({
@@ -83,14 +92,16 @@ export default function SharedWiggleMixin(configSchema) {
          * #action
          */
         updateQuantitativeStats(stats) {
-            const { scoreMin, scoreMax } = stats;
+            const { currStatsBpPerPx, scoreMin, scoreMax } = stats;
             const EPSILON = 0.000001;
-            if (!self.stats) {
-                self.stats = { scoreMin, scoreMax };
-            }
-            else if (Math.abs(self.stats.scoreMax - scoreMax) > EPSILON ||
+            if (!self.stats ||
+                Math.abs(self.stats.scoreMax - scoreMax) > EPSILON ||
                 Math.abs(self.stats.scoreMin - scoreMin) > EPSILON) {
-                self.stats = { scoreMin, scoreMax };
+                self.stats = {
+                    currStatsBpPerPx,
+                    scoreMin,
+                    scoreMax,
+                };
             }
         },
         /**
@@ -114,10 +125,10 @@ export default function SharedWiggleMixin(configSchema) {
         /**
          * #action
          */
-        setLoading(aborter) {
-            const { statsFetchInProgress: statsFetch } = self;
-            if (statsFetch !== undefined && !statsFetch.signal.aborted) {
-                statsFetch.abort();
+        setStatsLoading(aborter) {
+            if (self.statsFetchInProgress !== undefined &&
+                !self.statsFetchInProgress.signal.aborted) {
+                self.statsFetchInProgress.abort();
             }
             self.statsFetchInProgress = aborter;
         },

package/esm/util.d.ts

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