@jbrowse/plugin-wiggle 2.16.1 → 2.18.0

package/esm/XYPlotRenderer/XYPlotRenderer.d.ts

@@ -1,5 +1,6 @@
-import { Feature } from '@jbrowse/core/util';
-import WiggleBaseRenderer, { RenderArgsDeserializedWithFeatures } from '../WiggleBaseRenderer';
+import WiggleBaseRenderer from '../WiggleBaseRenderer';
+import type { RenderArgsDeserializedWithFeatures } from '../WiggleBaseRenderer';
+import type { Feature } from '@jbrowse/core/util';
 export default class XYPlotRenderer extends WiggleBaseRenderer {
     draw(ctx: CanvasRenderingContext2D, props: RenderArgsDeserializedWithFeatures): Promise<{
         reducedFeatures: Feature[];

package/esm/XYPlotRenderer/XYPlotRenderer.js

@@ -1,13 +1,10 @@
 import { readConfObject } from '@jbrowse/core/configuration';
-import { drawXY } from '../drawXY';
 import WiggleBaseRenderer from '../WiggleBaseRenderer';
+import { drawXY } from '../drawXY';
 import { YSCALEBAR_LABEL_OFFSET } from '../util';
 export default class XYPlotRenderer extends WiggleBaseRenderer {
     async draw(ctx, props) {
-        const { features, config } = props;
-        // the adjusted height takes into account YSCALEBAR_LABEL_OFFSET from the
-        // wiggle display, and makes the height of the actual drawn area add
-        // "padding" to the top and bottom of the display
+        const { stopToken, features, config } = props;
         const pivotValue = readConfObject(config, 'bicolorPivotValue');
         const negColor = readConfObject(config, 'negColor');
         const posColor = readConfObject(config, 'posColor');
@@ -18,6 +15,7 @@ export default class XYPlotRenderer extends WiggleBaseRenderer {
                 : (feature, _score) => readConfObject(config, 'color', { feature }),
             offset: YSCALEBAR_LABEL_OFFSET,
             features: [...features.values()],
+            stopToken,
         });
     }
 }

package/esm/XYPlotRenderer/configSchema.d.ts

@@ -1,31 +1,19 @@
 declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     filled: {
         type: string;
         defaultValue: boolean;
     };
-    /**
-     * #slot
-     */
     displayCrossHatches: {
         type: string;
         description: string;
         defaultValue: boolean;
     };
-    /**
-     * #slot
-     */
     summaryScoreMode: {
         type: string;
         model: import("mobx-state-tree").ISimpleType<string>;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     minSize: {
         type: string;
         defaultValue: number;

package/esm/XYPlotRenderer/configSchema.js

@@ -1,46 +1,28 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import baseWiggleRendererConfigSchema from '../configSchema';
 import { types } from 'mobx-state-tree';
-/**
- * #config XYPlotRenderer
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+import baseWiggleRendererConfigSchema from '../configSchema';
+function x() { }
 const configSchema = ConfigurationSchema('XYPlotRenderer', {
-    /**
-     * #slot
-     */
     filled: {
         type: 'boolean',
         defaultValue: true,
     },
-    /**
-     * #slot
-     */
     displayCrossHatches: {
         type: 'boolean',
         description: 'choose to draw cross hatches (sideways lines)',
         defaultValue: false,
     },
-    /**
-     * #slot
-     */
     summaryScoreMode: {
         type: 'stringEnum',
         model: types.enumeration('Score type', ['max', 'min', 'avg', 'whiskers']),
         description: 'choose whether to use max/min/average or whiskers which combines all three into the same rendering',
         defaultValue: 'whiskers',
     },
-    /**
-     * #slot
-     */
     minSize: {
         type: 'number',
-        defaultValue: 0,
+        defaultValue: 0.7,
     },
 }, {
-    /**
-     * #baseConfiguration
-     */
     baseConfiguration: baseWiggleRendererConfigSchema,
     explicitlyTyped: true,
 });

package/esm/XYPlotRenderer/index.d.ts

@@ -1,4 +1,4 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function XYPlotRendererF(pluginManager: PluginManager): void;
 export { default as XYPlotRenderer } from './XYPlotRenderer';
 export { default as ReactComponent } from '../WiggleRendering';

package/esm/configSchema.d.ts

@@ -1,48 +1,30 @@
 declare const WiggleRenderer: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     color: {
         type: string;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     posColor: {
         type: string;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     negColor: {
         type: string;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     clipColor: {
         type: string;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     bicolorPivot: {
         type: string;
         model: import("mobx-state-tree").ISimpleType<string>;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     bicolorPivotValue: {
         type: string;
         defaultValue: number;

package/esm/configSchema.js

@@ -1,46 +1,27 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { types } from 'mobx-state-tree';
-/**
- * #config WiggleRenderer
- * this is the "base wiggle renderer config schema"
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+function x() { }
 const WiggleRenderer = ConfigurationSchema('WiggleRenderer', {
-    /**
-     * #slot
-     */
     color: {
         type: 'color',
         description: 'the color of track, overrides posColor and negColor',
         defaultValue: '#f0f',
     },
-    /**
-     * #slot
-     */
     posColor: {
         type: 'color',
         description: 'the color to use when the score is positive',
         defaultValue: 'blue',
     },
-    /**
-     * #slot
-     */
     negColor: {
         type: 'color',
         description: 'the color to use when the score is negative',
         defaultValue: 'red',
     },
-    /**
-     * #slot
-     */
     clipColor: {
         type: 'color',
         description: 'the color of the clipping marker',
         defaultValue: 'red',
     },
-    /**
-     * #slot
-     */
     bicolorPivot: {
         type: 'stringEnum',
         model: types.enumeration('Scale type', [
@@ -52,9 +33,6 @@ const WiggleRenderer = ConfigurationSchema('WiggleRenderer', {
         description: 'type of bicolor pivot',
         defaultValue: 'numeric',
     },
-    /**
-     * #slot
-     */
     bicolorPivotValue: {
         type: 'number',
         defaultValue: 0,

package/esm/drawDensity.d.ts

@@ -1,6 +1,6 @@
-import { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import { Feature, Region } from '@jbrowse/core/util';
-import { ScaleOpts } from './util';
+import type { ScaleOpts } from './util';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Feature, Region } from '@jbrowse/core/util';
 export declare function drawDensity(ctx: CanvasRenderingContext2D, props: {
     features: Map<string, Feature> | Feature[];
     regions: Region[];

package/esm/drawDensity.js

@@ -1,6 +1,5 @@
-import { readConfObject, } from '@jbrowse/core/configuration';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { featureSpanPx } from '@jbrowse/core/util';
-// locals
 import { fillRectCtx, getScale } from './util';
 const fudgeFactor = 0.3;
 const clipHeight = 2;
@@ -31,7 +30,6 @@ export function drawDensity(ctx, props) {
     const reducedFeatures = [];
     for (const feature of features.values()) {
         const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
-        // create reduced features, avoiding multiple features per px
         if (Math.floor(leftPx) !== Math.floor(prevLeftPx)) {
             reducedFeatures.push(feature);
             prevLeftPx = leftPx;
@@ -42,8 +40,6 @@ export function drawDensity(ctx, props) {
         ctx.fillStyle = cb(feature, score);
         ctx.fillRect(leftPx, 0, w, height);
     }
-    // second pass: draw clipping
-    // avoid persisting the red fillstyle with save/restore
     ctx.save();
     if (hasClipping) {
         ctx.fillStyle = clipColor;

package/esm/drawLine.d.ts

@@ -1,6 +1,6 @@
-import { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import { Feature, Region } from '@jbrowse/core/util';
-import { ScaleOpts } from './util';
+import type { ScaleOpts } from './util';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Feature, Region } from '@jbrowse/core/util';
 export declare function drawLine(ctx: CanvasRenderingContext2D, props: {
     features: Map<string, Feature> | Feature[];
     regions: Region[];

package/esm/drawLine.js

@@ -1,6 +1,5 @@
-import { readConfObject, } from '@jbrowse/core/configuration';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { clamp, featureSpanPx } from '@jbrowse/core/util';
-// locals
 import { getScale } from './util';
 const fudgeFactor = 0.3;
 const clipHeight = 2;
@@ -8,9 +7,6 @@ export function drawLine(ctx, props) {
     const { features, regions, bpPerPx, scaleOpts, height: unadjustedHeight, ticks: { values }, displayCrossHatches, colorCallback, config, offset = 0, } = props;
     const region = regions[0];
     const width = (region.end - region.start) / bpPerPx;
-    // the adjusted height takes into account YSCALEBAR_LABEL_OFFSET from the
-    // wiggle display, and makes the height of the actual drawn area add
-    // "padding" to the top and bottom of the display
     const height = unadjustedHeight - offset * 2;
     const clipColor = readConfObject(config, 'clipColor');
     const scale = getScale({ ...scaleOpts, range: [0, height] });
@@ -23,7 +19,6 @@ export function drawLine(ctx, props) {
     const reducedFeatures = [];
     for (const feature of features.values()) {
         const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
-        // create reduced features, avoiding multiple features per px
         if (Math.floor(leftPx) !== Math.floor(prevLeftPx)) {
             reducedFeatures.push(feature);
             prevLeftPx = leftPx;

package/esm/drawXY.d.ts

@@ -1,7 +1,8 @@
-import { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import { Feature, Region } from '@jbrowse/core/util';
-import { ScaleOpts } from './util';
+import type { ScaleOpts } from './util';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Feature, Region } from '@jbrowse/core/util';
 export declare function drawXY(ctx: CanvasRenderingContext2D, props: {
+    stopToken?: string;
     features: Map<string, Feature> | Feature[];
     bpPerPx: number;
     regions: Region[];

package/esm/drawXY.js

@@ -1,7 +1,7 @@
-import { readConfObject, } from '@jbrowse/core/configuration';
-import { colord } from '@jbrowse/core/util/colord';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { clamp, featureSpanPx } from '@jbrowse/core/util';
-// locals
+import { colord } from '@jbrowse/core/util/colord';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
 import { fillRectCtx, getOrigin, getScale } from './util';
 function lighten(color, amount) {
     const hslColor = color.toHsl();
@@ -19,9 +19,6 @@ export function drawXY(ctx, props) {
     const { features, bpPerPx, regions, scaleOpts, height: unadjustedHeight, config, ticks, displayCrossHatches, offset = 0, colorCallback, } = props;
     const region = regions[0];
     const width = (region.end - region.start) / bpPerPx;
-    // the adjusted height takes into account YSCALEBAR_LABEL_OFFSET from the
-    // wiggle display, and makes the height of the actual drawn area add
-    // "padding" to the top and bottom of the display
     const height = unadjustedHeight - offset * 2;
     const filled = readConfObject(config, 'filled');
     const clipColor = readConfObject(config, 'clipColor');
@@ -40,13 +37,16 @@ export function drawXY(ctx, props) {
     let prevLeftPx = Number.NEGATIVE_INFINITY;
     const reducedFeatures = [];
     const crossingOrigin = niceMin < pivotValue && niceMax > pivotValue;
-    // we handle whiskers separately to render max row, min row, and avg in three
-    // passes. this reduces subpixel rendering issues. note: for stylistic
-    // reasons, clipping indicator is only drawn for score, not min/max score
+    let start = performance.now();
     if (summaryScoreMode === 'whiskers') {
         let lastCol;
         let lastMix;
+        start = performance.now();
         for (const feature of features.values()) {
+            if (performance.now() - start > 400) {
+                checkStopToken();
+                start = performance.now();
+            }
             const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
             if (feature.get('summary')) {
                 const w = Math.max(rightPx - leftPx + fudgeFactor, minSize);
@@ -63,7 +63,12 @@ export function drawXY(ctx, props) {
         }
         lastMix = undefined;
         lastCol = undefined;
+        start = performance.now();
         for (const feature of features.values()) {
+            if (performance.now() - start > 400) {
+                checkStopToken();
+                start = performance.now();
+            }
             const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
             const score = feature.get('score');
             const max = feature.get('maxScore');
@@ -78,7 +83,6 @@ export function drawXY(ctx, props) {
                         .toString())
                 : c;
             const w = Math.max(rightPx - leftPx + fudgeFactor, minSize);
-            // create reduced features, avoiding multiple features per px
             if (Math.floor(leftPx) !== Math.floor(prevLeftPx)) {
                 reducedFeatures.push(feature);
                 prevLeftPx = leftPx;
@@ -89,7 +93,12 @@ export function drawXY(ctx, props) {
         }
         lastMix = undefined;
         lastCol = undefined;
+        start = performance.now();
         for (const feature of features.values()) {
+            if (performance.now() - start > 400) {
+                checkStopToken();
+                start = performance.now();
+            }
             const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
             if (feature.get('summary')) {
                 const min = feature.get('minScore');
@@ -106,9 +115,13 @@ export function drawXY(ctx, props) {
         }
     }
     else {
+        start = performance.now();
         for (const feature of features.values()) {
+            if (performance.now() - start > 400) {
+                checkStopToken();
+                start = performance.now();
+            }
             const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
-            // create reduced features, avoiding multiple features per px
             if (Math.floor(leftPx) !== Math.floor(prevLeftPx)) {
                 reducedFeatures.push(feature);
                 prevLeftPx = leftPx;
@@ -130,12 +143,15 @@ export function drawXY(ctx, props) {
             }
         }
     }
-    // second pass: draw clipping
-    // avoid persisting the red fillstyle with save/restore
     ctx.save();
     if (hasClipping) {
         ctx.fillStyle = clipColor;
+        start = performance.now();
         for (const feature of features.values()) {
+            if (performance.now() - start > 400) {
+                checkStopToken();
+                start = performance.now();
+            }
             const [leftPx, rightPx] = featureSpanPx(feature, region, bpPerPx);
             const w = rightPx - leftPx + fudgeFactor;
             const score = feature.get('score');

package/esm/getMultiWiggleSourcesAutorun.d.ts

@@ -0,0 +1,17 @@
+import type { 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>;
+    setSourcesLoading: (aborter: string) => void;
+    setError: (error: unknown) => void;
+    setMessage: (str: string) => void;
+    setSources: (sources: Source[]) => void;
+}): void;

package/esm/getMultiWiggleSourcesAutorun.js

@@ -0,0 +1,35 @@
+import { getContainingView, getSession } from '@jbrowse/core/util';
+import { isAbortException } from '@jbrowse/core/util/aborting';
+import { createStopToken } from '@jbrowse/core/util/stopToken';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { autorun } from 'mobx';
+import { addDisposer, isAlive } from 'mobx-state-tree';
+export function getMultiWiggleSourcesAutorun(self) {
+    addDisposer(self, autorun(async () => {
+        try {
+            const view = getContainingView(self);
+            if (!view.initialized) {
+                return;
+            }
+            const { rpcManager } = getSession(self);
+            const { adapterConfig } = self;
+            const token = createStopToken();
+            self.setSourcesLoading(token);
+            const sessionId = getRpcSessionId(self);
+            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 type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { QuantitativeStats } from '@jbrowse/core/util/stats';
+export declare function getQuantitativeStats(self: {
+    adapterConfig: AnyConfigurationModel;
+    configuration: AnyConfigurationModel;
+    autoscaleType: string;
+    setMessage: (str: string) => void;
+}, opts: {
+    headers?: Record<string, string>;
+    stopToken?: string;
+    filters: string[];
+    currStatsBpPerPx: number;
+}): Promise<QuantitativeStats>;

package/esm/getQuantitativeStats.js

@@ -0,0 +1,67 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { getContainingView, getSession } from '@jbrowse/core/util';
+import { getRpcSessionId } from '@jbrowse/core/util/tracks';
+import { isAlive } from 'mobx-state-tree';
+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;
+        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;
+        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 type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { QuantitativeStats } from '@jbrowse/core/util/stats';
+export declare function getQuantitativeStatsAutorun(self: {
+    quantitativeStatsReady: boolean;
+    configuration: AnyConfigurationModel;
+    adapterConfig: AnyConfigurationModel;
+    autoscaleType: string;
+    adapterProps: () => Record<string, unknown>;
+    setStatsLoading: (token: string) => void;
+    setError: (error: unknown) => void;
+    setMessage: (str: string) => void;
+    updateQuantitativeStats: (stats: QuantitativeStats, region: string) => void;
+}): void;

package/esm/getQuantitativeStatsAutorun.js

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

package/esm/index.d.ts

@@ -1,15 +1,15 @@
 import Plugin from '@jbrowse/core/Plugin';
-import PluginManager from '@jbrowse/core/PluginManager';
-import WiggleBaseRenderer from './WiggleBaseRenderer';
-import * as utils from './util';
 import { modelFactory as linearWiggleDisplayModelFactory } from './LinearWiggleDisplay';
+import WiggleBaseRenderer from './WiggleBaseRenderer';
 import { XYPlotRenderer } from './XYPlotRenderer';
+import * as utils from './util';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default class WigglePlugin extends Plugin {
     name: string;
     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[];
@@ -83,6 +83,6 @@ 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 { ReactComponent as LinearWiggleDisplayReactComponent, Tooltip, modelFactory as linearWiggleDisplayModelFactory, } from './LinearWiggleDisplay';
+export type { TooltipContentsComponent } from './Tooltip';
 export { default as WiggleBaseRenderer } from './WiggleBaseRenderer';