@jbrowse/plugin-wiggle 3.1.0 → 3.3.0

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/WiggleClusterDialog.d.ts

@@ -0,0 +1,6 @@
+import type { ReducedModel } from './types';
+declare const WiggleClusterDialog: ({ model, handleClose, }: {
+    model: ReducedModel;
+    handleClose: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export default WiggleClusterDialog;

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/WiggleClusterDialog.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Dialog } from '@jbrowse/core/ui';
+import { FormControlLabel, Radio, RadioGroup } from '@mui/material';
+import { observer } from 'mobx-react';
+import WiggleClusterDialogAuto from './WiggleClusterDialogAuto';
+import WiggleClusterDialogManual from './WiggleClusterDialogManual';
+function Header({ activeMode, setActiveMode, }) {
+    return (_jsx("div", { children: _jsx(RadioGroup, { children: Object.entries({
+                auto: (_jsx("div", { children: "Run in-app clustering (slower, particularly for large numbers of samples, uses JS implementation of hclust)" })),
+                manual: (_jsx("div", { children: "Download R script to run clustering (faster, uses R implementation of hclust)" })),
+            }).map(([key, val]) => (_jsx(FormControlLabel, { control: _jsx(Radio, { checked: activeMode === key, onChange: () => {
+                        setActiveMode(key);
+                    } }), label: val }, key))) }) }));
+}
+const WiggleClusterDialog = observer(function ({ model, handleClose, }) {
+    const [activeMode, setActiveMode] = useState('auto');
+    return (_jsx(Dialog, { open: true, title: "Cluster by score", maxWidth: "xl", onClose: (_, reason) => {
+            if (reason !== 'backdropClick') {
+                handleClose();
+            }
+        }, children: activeMode === 'auto' ? (_jsx(WiggleClusterDialogAuto, { model: model, handleClose: handleClose, children: _jsx(Header, { activeMode: activeMode, setActiveMode: setActiveMode }) })) : (_jsx(WiggleClusterDialogManual, { model: model, handleClose: handleClose, children: _jsx(Header, { activeMode: activeMode, setActiveMode: setActiveMode }) })) }));
+});
+export default WiggleClusterDialog;

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/WiggleClusterDialogAuto.d.ts

@@ -0,0 +1,7 @@
+import type { ReducedModel } from './types';
+declare const WiggleClusterDialogAuto: ({ model, children, handleClose, }: {
+    model: ReducedModel;
+    children: React.ReactNode;
+    handleClose: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export default WiggleClusterDialogAuto;

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/WiggleClusterDialogAuto.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { ErrorMessage } from '@jbrowse/core/ui';
+import { getContainingView, getSession, isAbortException, useLocalStorage, } from '@jbrowse/core/util';
+import { createStopToken, stopStopToken } from '@jbrowse/core/util/stopToken';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { Button, DialogActions, DialogContent, TextField, Typography, } from '@mui/material';
+import { observer } from 'mobx-react';
+import { isAlive } from 'mobx-state-tree';
+const WiggleClusterDialogAuto = observer(function ({ model, children, handleClose, }) {
+    const [progress, setProgress] = useState('');
+    const [error, setError] = useState();
+    const [loading, setLoading] = useState(false);
+    const [stopToken, setStopToken] = useState('');
+    const [showAdvanced, setShowAdvanced] = useState(false);
+    const [samplesPerPixel, setSamplesPerPixel] = useLocalStorage('cluster-samplesPerPixel', '1');
+    return (_jsxs(_Fragment, { children: [_jsxs(DialogContent, { children: [children, _jsxs("div", { style: { marginTop: 50 }, children: [_jsx(Button, { variant: "contained", onClick: () => {
+                                    setShowAdvanced(!showAdvanced);
+                                }, children: showAdvanced ? 'Hide advanced options' : 'Show advanced options' }), showAdvanced ? (_jsxs("div", { style: { marginTop: 20 }, children: [_jsx(Typography, { children: "This procedure samples the data at each 'pixel' across the visible by default" }), _jsx(TextField, { label: "Samples per pixel (>1 for denser sampling, between 0-1 for sparser sampling)", variant: "outlined", size: "small", value: samplesPerPixel, onChange: event => {
+                                            setSamplesPerPixel(event.target.value);
+                                        } })] })) : null] }), _jsxs("div", { children: [loading ? (_jsxs("div", { style: { padding: 50 }, children: [_jsx("span", { children: progress || 'Loading...' }), _jsx(Button, { onClick: () => {
+                                            stopStopToken(stopToken);
+                                        }, children: "Stop" })] })) : null, error ? _jsx(ErrorMessage, { error: error }) : null] })] }), _jsxs(DialogActions, { children: [_jsx(Button, { variant: "contained", disabled: loading, onClick: async () => {
+                            try {
+                                setError(undefined);
+                                setProgress('Initializing');
+                                setLoading(true);
+                                const view = getContainingView(model);
+                                if (!view.initialized) {
+                                    return;
+                                }
+                                const { rpcManager } = getSession(model);
+                                const { sourcesWithoutLayout, adapterConfig } = model;
+                                if (sourcesWithoutLayout) {
+                                    const sessionId = getRpcSessionId(model);
+                                    const stopToken = createStopToken();
+                                    setStopToken(stopToken);
+                                    const ret = (await rpcManager.call(sessionId, 'MultiWiggleClusterScoreMatrix', {
+                                        regions: view.dynamicBlocks.contentBlocks,
+                                        sources: sourcesWithoutLayout,
+                                        sessionId,
+                                        adapterConfig,
+                                        stopToken,
+                                        bpPerPx: view.bpPerPx / +samplesPerPixel,
+                                        statusCallback: (arg) => {
+                                            setProgress(arg);
+                                        },
+                                    }));
+                                    model.setLayout(ret.order.map(idx => {
+                                        const ret = sourcesWithoutLayout[idx];
+                                        if (!ret) {
+                                            throw new Error(`out of bounds at ${idx}`);
+                                        }
+                                        return ret;
+                                    }));
+                                }
+                                handleClose();
+                            }
+                            catch (e) {
+                                if (!isAbortException(e) && isAlive(model)) {
+                                    console.error(e);
+                                    setError(e);
+                                }
+                            }
+                            finally {
+                                setLoading(false);
+                                setProgress('');
+                                setStopToken('');
+                            }
+                        }, children: "Run clustering" }), _jsx(Button, { variant: "contained", color: "secondary", onClick: () => {
+                            handleClose();
+                            if (stopToken) {
+                                stopStopToken(stopToken);
+                            }
+                        }, children: "Cancel" })] })] }));
+});
+export default WiggleClusterDialogAuto;

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/WiggleClusterDialogManual.d.ts

@@ -0,0 +1,7 @@
+import type { ReducedModel } from './types';
+declare const WiggleClusterDialogManuals: ({ model, handleClose, children, }: {
+    model: ReducedModel;
+    handleClose: () => void;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default WiggleClusterDialogManuals;

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/WiggleClusterDialogManual.js

@@ -0,0 +1,140 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { ErrorMessage, LoadingEllipses } from '@jbrowse/core/ui';
+import { getContainingView, getSession, isAbortException, useLocalStorage, } from '@jbrowse/core/util';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { Button, DialogActions, DialogContent, FormControlLabel, Radio, RadioGroup, TextField, Typography, } from '@mui/material';
+import copy from 'copy-to-clipboard';
+import { saveAs } from 'file-saver';
+import { observer } from 'mobx-react';
+import { isAlive } from 'mobx-state-tree';
+import { makeStyles } from 'tss-react/mui';
+const useStyles = makeStyles()(theme => ({
+    textAreaFont: {
+        fontFamily: 'Courier New',
+    },
+    mgap: {
+        display: 'flex',
+        flexDirection: 'column',
+        gap: theme.spacing(4),
+    },
+}));
+const WiggleClusterDialogManuals = observer(function ({ model, handleClose, children, }) {
+    const { classes } = useStyles();
+    const [paste, setPaste] = useState('');
+    const [ret, setRet] = useState();
+    const [error, setError] = useState();
+    const [loading, setLoading] = useState(false);
+    const [showAdvanced, setShowAdvanced] = useLocalStorage('cluster-showAdvanced', false);
+    const [clusterMethod, setClusterMethod] = useState('single');
+    const [samplesPerPixel, setSamplesPerPixel] = useState('1');
+    useEffect(() => {
+        ;
+        (async () => {
+            try {
+                setError(undefined);
+                setRet(undefined);
+                setLoading(true);
+                const view = getContainingView(model);
+                const { dynamicBlocks, bpPerPx } = view;
+                const { rpcManager } = getSession(model);
+                const { sourcesWithoutLayout, adapterConfig } = model;
+                const sessionId = getRpcSessionId(model);
+                const ret = (await rpcManager.call(sessionId, 'MultiWiggleGetScoreMatrix', {
+                    regions: dynamicBlocks.contentBlocks,
+                    sources: sourcesWithoutLayout,
+                    sessionId,
+                    adapterConfig,
+                    bpPerPx: bpPerPx / +samplesPerPixel,
+                }));
+                setRet(ret);
+            }
+            catch (e) {
+                if (!isAbortException(e) && isAlive(model)) {
+                    console.error(e);
+                    setError(e);
+                }
+            }
+            finally {
+                setLoading(false);
+            }
+        })();
+    }, [model, samplesPerPixel]);
+    const results = ret
+        ? `inputMatrix<-matrix(c(${Object.values(ret)
+            .map(val => val.join(','))
+            .join(',\n')}
+),nrow=${Object.values(ret).length},byrow=TRUE)
+rownames(inputMatrix)<-c(${Object.keys(ret)
+            .map(key => `'${key}'`)
+            .join(',')})
+resultClusters<-hclust(dist(inputMatrix), method='${clusterMethod}')
+cat(resultClusters$order,sep='\\n')`
+        : undefined;
+    const resultsTsv = ret
+        ? Object.entries(ret)
+            .map(([key, val]) => [key, ...val].join('\t'))
+            .join('\n')
+        : undefined;
+    return (_jsxs(_Fragment, { children: [_jsxs(DialogContent, { children: [children, _jsxs("div", { style: { marginTop: 50 }, children: [_jsxs("div", { children: [_jsxs("div", { style: {
+                                            display: 'flex',
+                                            gap: '8px',
+                                            flexWrap: 'wrap',
+                                            marginBottom: '16px',
+                                        }, children: [_jsx(Button, { variant: "contained", onClick: () => {
+                                                    saveAs(new Blob([results || ''], {
+                                                        type: 'text/plain;charset=utf-8',
+                                                    }), 'cluster.R');
+                                                }, children: "Download Rscript" }), ' ', "or", ' ', _jsx(Button, { variant: "contained", onClick: () => {
+                                                    copy(results || '');
+                                                }, children: "Copy Rscript to clipboard" }), ' ', "or", ' ', _jsx(Button, { variant: "contained", onClick: () => {
+                                                    saveAs(new Blob([resultsTsv || ''], {
+                                                        type: 'text/plain;charset=utf-8',
+                                                    }), 'scores.tsv');
+                                                }, children: "Download TSV" })] }), _jsx("div", { children: _jsx(Button, { variant: "contained", onClick: () => {
+                                                setShowAdvanced(!showAdvanced);
+                                            }, children: showAdvanced
+                                                ? 'Hide advanced options'
+                                                : 'Show advanced options' }) }), showAdvanced ? (_jsxs("div", { children: [_jsx(Typography, { variant: "h6", children: "Advanced options" }), _jsx(RadioGroup, { children: Object.entries({
+                                                    single: 'Single',
+                                                    complete: 'Complete',
+                                                }).map(([key, val]) => (_jsx(FormControlLabel, { control: _jsx(Radio, { checked: clusterMethod === key, onChange: () => {
+                                                            setClusterMethod(key);
+                                                        } }), label: val }, key))) }), _jsxs("div", { style: { marginTop: 20 }, children: [_jsx(Typography, { children: "This procedure samples the data at each 'pixel' across the visible by default" }), _jsx(TextField, { label: "Samples per pixel (>1 for denser sampling, between 0-1 for sparser sampling)", variant: "outlined", size: "small", value: samplesPerPixel, onChange: event => {
+                                                            setSamplesPerPixel(event.target.value);
+                                                        } })] })] })) : null, results ? (_jsx("div", {})) : loading ? (_jsx(LoadingEllipses, { variant: "h6", title: "Generating score matrix" })) : error ? (_jsx(ErrorMessage, { error: error })) : null] }), _jsxs("div", { children: [_jsx(Typography, { variant: "subtitle2", gutterBottom: true, style: { marginTop: '16px' }, children: "Clustering Results:" }), _jsx(TextField, { multiline: true, fullWidth: true, variant: "outlined", placeholder: "Paste results from Rscript here (sequence of numbers, one per line, specifying the new ordering)", rows: 10, value: paste, onChange: event => {
+                                            setPaste(event.target.value);
+                                        }, slotProps: {
+                                            input: {
+                                                classes: {
+                                                    input: classes.textAreaFont,
+                                                },
+                                            },
+                                        } })] })] })] }), _jsxs(DialogActions, { children: [_jsx(Button, { variant: "contained", onClick: () => {
+                            const { sourcesWithoutLayout } = model;
+                            if (sourcesWithoutLayout) {
+                                try {
+                                    model.setLayout(paste
+                                        .split('\n')
+                                        .map(t => t.trim())
+                                        .filter(f => !!f)
+                                        .map(r => +r)
+                                        .map(idx => {
+                                        const ret = sourcesWithoutLayout[idx - 1];
+                                        if (!ret) {
+                                            throw new Error(`out of bounds at ${idx}`);
+                                        }
+                                        return ret;
+                                    }));
+                                }
+                                catch (e) {
+                                    console.error(e);
+                                    getSession(model).notifyError(`${e}`, e);
+                                }
+                            }
+                            handleClose();
+                        }, children: "Apply clustering" }), _jsx(Button, { variant: "contained", color: "secondary", onClick: () => {
+                            handleClose();
+                        }, children: "Cancel" })] })] }));
+});
+export default WiggleClusterDialogManuals;

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/types.d.ts

@@ -0,0 +1,7 @@
+import type { Source } from '../../types';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+export interface ReducedModel {
+    sourcesWithoutLayout?: Source[];
+    adapterConfig: AnyConfigurationModel;
+    setLayout: (arg: Source[]) => void;
+}

package/esm/MultiLinearWiggleDisplay/components/WiggleClusterDialog/types.js

@@ -0,0 +1 @@
+export {};

package/esm/MultiLinearWiggleDisplay/components/util.d.ts

@@ -1,12 +1,13 @@
 import type { WiggleDisplayModel } from '../model';
+import type { GridRowId } from '@mui/x-data-grid';
 export declare function moveUp(arr: {
     name: string;
-}[], sel: string[], by?: number): {
+}[], sel: GridRowId[], by?: number): {
     name: string;
 }[];
 export declare function moveDown(arr: {
     name: string;
-}[], sel: string[], by?: number): {
+}[], sel: GridRowId[], by?: number): {
     name: string;
 }[];
 export declare function getOffset(model: WiggleDisplayModel): number;

package/esm/MultiLinearWiggleDisplay/model.d.ts

@@ -259,11 +259,11 @@ export declare function stateModelFactory(_pluginManager: PluginManager, configS
     setCrossHatches(cross: boolean): void;
 } & {
     readonly adapterTypeName: any;
-    readonly rendererTypeNameSimple: any;
+    readonly rendererTypeNameSimple: string;
     readonly filters: undefined;
-    readonly scaleType: any;
-    readonly maxScore: any;
-    readonly minScore: any;
+    readonly scaleType: string;
+    readonly maxScore: number;
+    readonly minScore: number;
 } & {
     readonly adapterCapabilities: string[];
     readonly rendererConfig: {
@@ -277,7 +277,7 @@ export declare function stateModelFactory(_pluginManager: PluginManager, configS
             } & import("mobx-state-tree/dist/internal").NonEmptyObject & any & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
         } & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>);
     } & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>;
-    readonly autoscaleType: any;
+    readonly autoscaleType: string;
 } & {
     readonly domain: number[] | undefined;
 } & {
@@ -290,9 +290,9 @@ export declare function stateModelFactory(_pluginManager: PluginManager, configS
             scoreMin: number;
             scoreMax: number;
         } | undefined;
-        autoscaleType: any;
-        scaleType: any;
-        inverted: any;
+        autoscaleType: string;
+        scaleType: string;
+        inverted: boolean;
     };
     readonly canHaveFill: boolean;
     readonly displayCrossHatchesSetting: boolean;
@@ -344,6 +344,12 @@ export declare function stateModelFactory(_pluginManager: PluginManager, configS
     readonly canHaveFill: boolean;
     readonly renderColorBoxes: boolean;
     readonly prefersOffset: boolean;
+    readonly sourcesWithoutLayout: {
+        color: string;
+        baseUri?: string;
+        name: string;
+        group?: string;
+    }[] | undefined;
     readonly sources: {
         color: string;
         baseUri?: string;
@@ -354,7 +360,7 @@ export declare function stateModelFactory(_pluginManager: PluginManager, configS
 } & {
     readonly rowHeight: number;
     readonly rowHeightTooSmallForScalebar: boolean;
-    readonly useMinimalTicks: any;
+    readonly useMinimalTicks: boolean;
 } & {
     adapterProps(): any;
     readonly ticks: {

package/esm/MultiLinearWiggleDisplay/model.js

@@ -11,7 +11,7 @@ import { YSCALEBAR_LABEL_OFFSET, getScale } from '../util';
 const randomColor = () => '#000000'.replaceAll('0', () => (~~(Math.random() * 16)).toString(16));
 const Tooltip = lazy(() => import('./components/Tooltip'));
 const SetColorDialog = lazy(() => import('./components/SetColorDialog'));
-const ClusterDialog = lazy(() => import('./components/ClusterDialog'));
+const WiggleClusterDialog = lazy(() => import('./components/WiggleClusterDialog/WiggleClusterDialog'));
 const rendererTypes = new Map([
     ['xyplot', 'MultiXYPlotRenderer'],
     ['multirowxy', 'MultiRowXYPlotRenderer'],
@@ -98,6 +98,19 @@ export function stateModelFactory(_pluginManager, configSchema) {
         get prefersOffset() {
             return this.isMultiRow;
         },
+        get sourcesWithoutLayout() {
+            var _a;
+            const sources = Object.fromEntries(((_a = self.sourcesVolatile) === null || _a === void 0 ? void 0 : _a.map(s => [s.name, s])) || []);
+            const iter = self.sourcesVolatile;
+            return iter === null || iter === void 0 ? void 0 : iter.map(s => ({
+                ...sources[s.name],
+                ...s,
+            })).map((s, i) => ({
+                ...s,
+                color: s.color ||
+                    (!this.isMultiRow ? colors[i] || randomColor() : 'blue'),
+            }));
+        },
         get sources() {
             var _a;
             const sources = Object.fromEntries(((_a = self.sourcesVolatile) === null || _a === void 0 ? void 0 : _a.map(s => [s.name, s])) || []);
@@ -125,7 +138,8 @@ export function stateModelFactory(_pluginManager, configSchema) {
             return this.rowHeight < 70;
         },
         get useMinimalTicks() {
-            return (getConf(self, 'minimalTicks') || this.rowHeightTooSmallForScalebar);
+            return (getConf(self, 'minimalTicks') ||
+                this.rowHeightTooSmallForScalebar);
         },
     }))
         .views(self => {
@@ -255,18 +269,6 @@ export function stateModelFactory(_pluginManager, configSchema) {
                             },
                         ]
                         : []),
-                    ...(self.graphType
-                        ? [
-                            {
-                                type: 'checkbox',
-                                label: 'Draw cross hatches',
-                                checked: self.displayCrossHatchesSetting,
-                                onClick: () => {
-                                    self.toggleCrossHatches();
-                                },
-                            },
-                        ]
-                        : []),
                     ...(hasRenderings
                         ? [
                             {
@@ -288,11 +290,23 @@ export function stateModelFactory(_pluginManager, configSchema) {
                             },
                         ]
                         : []),
+                    ...(self.graphType
+                        ? [
+                            {
+                                type: 'checkbox',
+                                label: 'Draw cross hatches',
+                                checked: self.displayCrossHatchesSetting,
+                                onClick: () => {
+                                    self.toggleCrossHatches();
+                                },
+                            },
+                        ]
+                        : []),
                     {
                         label: 'Cluster by score',
                         onClick: () => {
                             getSession(self).queueDialog(handleClose => [
-                                ClusterDialog,
+                                WiggleClusterDialog,
                                 {
                                     model: self,
                                     handleClose,

package/esm/MultiRowLineRenderer/MultiRowLineRenderer.js

@@ -1,8 +1,8 @@
-import { groupBy } from '@jbrowse/core/util';
+import { forEachWithStopTokenCheck, groupBy } from '@jbrowse/core/util';
 import WiggleBaseRenderer from '../WiggleBaseRenderer';
 export default class MultiRowLineRenderer extends WiggleBaseRenderer {
     async draw(ctx, props) {
-        const { bpPerPx, sources, regions, features } = props;
+        const { stopToken, bpPerPx, sources, regions, features } = props;
         const region = regions[0];
         const groups = groupBy(features.values(), f => f.get('source'));
         const height = props.height / sources.length;
@@ -10,7 +10,7 @@ export default class MultiRowLineRenderer extends WiggleBaseRenderer {
         const { drawLine } = await import('../drawLine');
         let feats = [];
         ctx.save();
-        sources.forEach(source => {
+        forEachWithStopTokenCheck(sources, stopToken, source => {
             const { reducedFeatures } = drawLine(ctx, {
                 ...props,
                 features: groups[source.name] || [],

package/esm/MultiRowXYPlotRenderer/MultiRowXYPlotRenderer.js

@@ -1,8 +1,8 @@
-import { groupBy } from '@jbrowse/core/util';
+import { forEachWithStopTokenCheck, groupBy } from '@jbrowse/core/util';
 import WiggleBaseRenderer from '../WiggleBaseRenderer';
 export default class MultiXYPlotRenderer extends WiggleBaseRenderer {
     async draw(ctx, props) {
-        const { bpPerPx, sources, regions, features } = props;
+        const { stopToken, bpPerPx, sources, regions, features } = props;
         const region = regions[0];
         const groups = groupBy(features.values(), f => f.get('source'));
         const height = props.height / sources.length;
@@ -10,7 +10,7 @@ export default class MultiXYPlotRenderer extends WiggleBaseRenderer {
         const { drawXY } = await import('../drawXY');
         let feats = [];
         ctx.save();
-        sources.forEach(source => {
+        forEachWithStopTokenCheck(sources, stopToken, source => {
             const { reducedFeatures } = drawXY(ctx, {
                 ...props,
                 features: groups[source.name] || [],

package/esm/MultiXYPlotRenderer/MultiXYPlotRenderer.js

@@ -1,13 +1,13 @@
-import { groupBy } from '@jbrowse/core/util';
+import { forEachWithStopTokenCheck, groupBy } from '@jbrowse/core/util';
 import WiggleBaseRenderer from '../WiggleBaseRenderer';
 import { YSCALEBAR_LABEL_OFFSET } from '../util';
 export default class MultiXYPlotRenderer extends WiggleBaseRenderer {
     async draw(ctx, props) {
-        const { sources, features } = props;
+        const { stopToken, sources, features } = props;
         const groups = groupBy(features.values(), f => f.get('source'));
         const { drawXY } = await import('../drawXY');
         let feats = [];
-        for (const source of sources) {
+        forEachWithStopTokenCheck(sources, stopToken, source => {
             const features = groups[source.name] || [];
             const { reducedFeatures } = drawXY(ctx, {
                 ...props,
@@ -16,7 +16,7 @@ export default class MultiXYPlotRenderer extends WiggleBaseRenderer {
                 colorCallback: () => source.color || 'blue',
             });
             feats = feats.concat(reducedFeatures);
-        }
+        });
         return { reducedFeatures: feats };
     }
 }

package/esm/WiggleBaseRenderer.d.ts

@@ -17,6 +17,7 @@ export interface RenderArgsDeserialized extends FeatureRenderArgsDeserialized {
     };
     inverted: boolean;
     themeOptions: ThemeOptions;
+    statusCallback?: (arg: string) => void;
 }
 export interface RenderArgsDeserializedWithFeatures extends RenderArgsDeserialized {
     features: Map<string, Feature>;

package/esm/WiggleBaseRenderer.js

@@ -1,5 +1,5 @@
 import FeatureRendererType from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
-import { renderToAbstractCanvas } from '@jbrowse/core/util';
+import { renderToAbstractCanvas, updateStatus } from '@jbrowse/core/util';
 export default class WiggleBaseRenderer extends FeatureRendererType {
     constructor() {
         super(...arguments);
@@ -7,14 +7,14 @@ export default class WiggleBaseRenderer extends FeatureRendererType {
     }
     async render(renderProps) {
         const features = await this.getFeatures(renderProps);
-        const { inverted, height, regions, bpPerPx } = renderProps;
+        const { inverted, height, regions, bpPerPx, statusCallback = () => { }, } = renderProps;
         const region = regions[0];
         const width = (region.end - region.start) / bpPerPx;
-        const { reducedFeatures, ...rest } = await renderToAbstractCanvas(width, height, renderProps, ctx => this.draw(ctx, {
+        const { reducedFeatures, ...rest } = await updateStatus('Rendering plot', statusCallback, () => renderToAbstractCanvas(width, height, renderProps, ctx => this.draw(ctx, {
             ...renderProps,
             features,
             inverted,
-        }));
+        })));
         const results = await super.render({
             ...renderProps,
             ...rest,
@@ -26,7 +26,7 @@ export default class WiggleBaseRenderer extends FeatureRendererType {
             ...results,
             ...rest,
             features: reducedFeatures
-                ? new Map(reducedFeatures.map((r) => [r.id(), r]))
+                ? new Map(reducedFeatures.map(r => [r.id(), r]))
                 : results.features,
             height,
             width,

package/esm/WiggleRPC/MultiWiggleClusterScoreMatrix.d.ts

@@ -0,0 +1,14 @@
+import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
+import type { GetScoreMatrixArgs } from './types';
+export declare class MultiWiggleClusterScoreMatrix extends RpcMethodTypeWithFiltersAndRenameRegions {
+    name: string;
+    execute(args: GetScoreMatrixArgs, rpcDriverClassName: string): Promise<{
+        clusters: {
+            height: number;
+            indexes: number[];
+        } | undefined;
+        distances: number[][];
+        order: number[];
+        clustersGivenK: number[][][];
+    }>;
+}

package/esm/WiggleRPC/MultiWiggleClusterScoreMatrix.js

@@ -0,0 +1,24 @@
+import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
+import { clusterData } from '@jbrowse/core/util/cluster';
+import { getScoreMatrix } from './getScoreMatrix';
+export class MultiWiggleClusterScoreMatrix extends RpcMethodTypeWithFiltersAndRenameRegions {
+    constructor() {
+        super(...arguments);
+        this.name = 'MultiWiggleClusterScoreMatrix';
+    }
+    async execute(args, rpcDriverClassName) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriverClassName);
+        const matrix = await getScoreMatrix({
+            pluginManager: this.pluginManager,
+            args: deserializedArgs,
+        });
+        return clusterData({
+            data: Object.values(matrix),
+            stopToken: deserializedArgs.stopToken,
+            onProgress: a => {
+                var _a;
+                (_a = deserializedArgs.statusCallback) === null || _a === void 0 ? void 0 : _a.call(deserializedArgs, a);
+            },
+        });
+    }
+}

package/esm/WiggleRPC/MultiWiggleGetScoreMatrix.d.ts

@@ -1,17 +1,6 @@
 import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
-import { type Region } from '@jbrowse/core/util';
-import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { GetScoreMatrixArgs } from './types';
 export declare class MultiWiggleGetScoreMatrix extends RpcMethodTypeWithFiltersAndRenameRegions {
     name: string;
-    execute(args: {
-        adapterConfig: AnyConfigurationModel;
-        stopToken?: string;
-        sessionId: string;
-        headers?: Record<string, string>;
-        regions: Region[];
-        bpPerPx: number;
-    }, rpcDriverClassName: string): Promise<Record<string, {
-        name: string;
-        scores: string[];
-    }>>;
+    execute(args: GetScoreMatrixArgs, rpcDriverClassName: string): Promise<Record<string, number[]>>;
 }