@jbrowse/plugin-wiggle 2.16.1 → 2.17.0

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

@@ -100,8 +100,17 @@ function SharedWiggleMixin(configSchema) {
         configuration: (0, configuration_1.ConfigurationReference)(configSchema),
     }))
         .volatile(() => ({
+        /**
+         * #volatile
+         */
         message: undefined,
+        /**
+         * #volatile
+         */
         stats: undefined,
+        /**
+         * #volatile
+         */
         statsFetchInProgress: undefined,
     }))
         .actions(self => ({
@@ -109,14 +118,16 @@ 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,
+                };
             }
         },
         /**
@@ -140,10 +151,10 @@ 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/dist/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;

package/dist/util.js

@@ -4,17 +4,10 @@ exports.YSCALEBAR_LABEL_OFFSET = void 0;
 exports.getScale = getScale;
 exports.getOrigin = getOrigin;
 exports.getNiceDomain = getNiceDomain;
-exports.getQuantitativeStats = getQuantitativeStats;
-exports.quantitativeStatsAutorun = quantitativeStatsAutorun;
 exports.toP = toP;
 exports.round = round;
 exports.fillRectCtx = fillRectCtx;
 const d3_scale_1 = require("@mui/x-charts-vendor/d3-scale");
-const mobx_1 = require("mobx");
-const util_1 = require("@jbrowse/core/util");
-const tracks_1 = require("@jbrowse/core/util/tracks");
-const mobx_state_tree_1 = require("mobx-state-tree");
-const configuration_1 = require("@jbrowse/core/configuration");
 exports.YSCALEBAR_LABEL_OFFSET = 5;
 /**
  * produces a d3-scale from arguments. applies a "nice domain" adjustment
@@ -55,7 +48,8 @@ function getScale({ domain = [], range = [], scaleType, pivotValue, inverted, })
     return scale;
 }
 /**
- * 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 -
  */
@@ -78,8 +72,8 @@ function getOrigin(scaleType /* , pivot, stats */) {
     return 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]
@@ -132,96 +126,6 @@ function getNiceDomain({ scaleType, domain, bounds, }) {
     scale.nice();
     return scale.domain();
 }
-async function getQuantitativeStats(self, opts) {
-    const { rpcManager } = (0, util_1.getSession)(self);
-    const numStdDev = (0, configuration_1.getConf)(self, 'numStdDev') || 3;
-    const { adapterConfig, autoscaleType } = self;
-    const sessionId = (0, tracks_1.getRpcSessionId)(self);
-    const params = {
-        sessionId,
-        adapterConfig,
-        statusCallback: (message) => {
-            if ((0, mobx_state_tree_1.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,
-            }
-            : results;
-    }
-    if (autoscaleType === 'local' || autoscaleType === 'localsd') {
-        const { dynamicBlocks, bpPerPx } = (0, util_1.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,
-            }
-            : results;
-    }
-    if (autoscaleType === 'zscale') {
-        return rpcManager.call(sessionId, 'WiggleGetGlobalQuantitativeStats', params);
-    }
-    throw new Error(`invalid autoscaleType '${autoscaleType}'`);
-}
-function quantitativeStatsAutorun(self) {
-    (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(async () => {
-        try {
-            const aborter = new AbortController();
-            const view = (0, util_1.getContainingView)(self);
-            self.setLoading(aborter);
-            if (!view.initialized ||
-                !self.featureDensityStatsReady ||
-                self.regionTooLarge ||
-                self.error) {
-                return;
-            }
-            const statsRegion = JSON.stringify(view.dynamicBlocks);
-            const wiggleStats = await getQuantitativeStats(self, {
-                signal: aborter.signal,
-                filters: [],
-                ...self.renderProps(),
-            });
-            if ((0, mobx_state_tree_1.isAlive)(self)) {
-                self.updateQuantitativeStats(wiggleStats, statsRegion);
-            }
-        }
-        catch (e) {
-            if (!(0, util_1.isAbortException)(e) && (0, mobx_state_tree_1.isAlive)(self)) {
-                console.error(e);
-                self.setError(e);
-            }
-        }
-    }, { delay: 1000 }));
-}
 function toP(s = 0) {
     return +(+s).toPrecision(6);
 }

package/esm/LinearWiggleDisplay/components/Tooltip.js

@@ -5,7 +5,7 @@ import Tooltip from '../../Tooltip';
 import { toP } from '../../util';
 const en = (n) => n.toLocaleString('en-US');
 const TooltipContents = React.forwardRef(function TooltipContents2({ feature }, ref) {
-    const start = feature.get('start');
+    const start = feature.get('start') + 1;
     const end = feature.get('end');
     const refName = feature.get('refName');
     const name = feature.get('name');

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 declare const LinearWiggleDisplay: (props: {
     model: WiggleDisplayModel;
 }) => React.JSX.Element;

package/esm/LinearWiggleDisplay/{models/configSchema.js → configSchema.js}

@@ -1,7 +1,7 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { types } from 'mobx-state-tree';
 // locals
-import sharedWiggleConfigFactory from '../../shared/configShared';
+import sharedWiggleConfigFactory from '../shared/SharedWiggleConfigSchema';
 /**
  * #config LinearWiggleDisplay
  * extends

package/esm/LinearWiggleDisplay/index.d.ts

@@ -2,4 +2,4 @@ import PluginManager from '@jbrowse/core/PluginManager';
 export default function LinearWiggleDisplayF(pluginManager: PluginManager): void;
 export { default as Tooltip } from './components/Tooltip';
 export { default as ReactComponent } from './components/WiggleDisplayComponent';
-export { default as modelFactory } from './models/model';
+export { default as modelFactory } from './model';

package/esm/LinearWiggleDisplay/index.js

@@ -1,6 +1,6 @@
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
-import configSchemaFactory from './models/configSchema';
-import modelFactory from './models/model';
+import configSchemaFactory from './configSchema';
+import modelFactory from './model';
 import { lazy } from 'react';
 export default function LinearWiggleDisplayF(pluginManager) {
     pluginManager.addDisplayType(() => {
@@ -19,4 +19,4 @@ export default function LinearWiggleDisplayF(pluginManager) {
 }
 export { default as Tooltip } from './components/Tooltip';
 export { default as ReactComponent } from './components/WiggleDisplayComponent';
-export { default as modelFactory } from './models/model';
+export { default as modelFactory } from './model';

package/{dist/LinearWiggleDisplay/models → esm/LinearWiggleDisplay}/model.d.ts

@@ -49,7 +49,9 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
                 reload: () => void;
                 message: React.ReactNode;
                 filled?: boolean;
-                status?: string;
+                status? /**
+                 * #getter
+                 */: string;
                 reactElement?: React.ReactElement;
             };
         }) => import("react").JSX.Element | undefined;
@@ -145,9 +147,7 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
             error: unknown;
             message: string | undefined;
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-        onHorizontalScroll? /**
-         * #getter
-         */: () => void;
+        onHorizontalScroll?: () => void;
         blockState?: Record<string, any>;
     }>;
     readonly DisplayBlurb: React.FC<{
@@ -252,19 +252,21 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
 } & {
     message: undefined | string;
     stats: {
+        currStatsBpPerPx: number;
         scoreMin: number;
         scoreMax: number;
     } | undefined;
     statsFetchInProgress: undefined | AbortController;
 } & {
     updateQuantitativeStats(stats: {
+        currStatsBpPerPx: number;
         scoreMin: number;
         scoreMax: number;
     }): void;
     setColor(color?: string): void;
     setPosColor(color?: string): void;
     setNegColor(color?: string): void;
-    setLoading(aborter: AbortController): void;
+    setStatsLoading(aborter: AbortController): void;
     selectFeature(feature: import("@jbrowse/core/util").Feature): void;
     setResolution(res: number): void;
     setFill(fill: number): void;
@@ -306,6 +308,7 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
     readonly scaleOpts: {
         domain: number[] | undefined;
         stats: {
+            currStatsBpPerPx: number;
             scoreMin: number;
             scoreMax: number;
         } | undefined;
@@ -350,7 +353,16 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
      * #getter
      */
     readonly rendererTypeName: string;
+    /**
+     * #getter
+     * unused currently
+     */
+    readonly quantitativeStatsRelevantToCurrentZoom: boolean;
 } & {
+    /**
+     * #method
+     */
+    adapterProps(): any;
     /**
      * #getter
      */
@@ -372,7 +384,11 @@ declare function stateModelFactory(pluginManager: PluginManager, configSchema: A
     /**
      * #getter
      */
-    readonly fillSetting: 2 | 0 | 1;
+    readonly fillSetting: 2 | 1 | 0;
+    /**
+     * #getter
+     */
+    readonly quantitativeStatsReady: boolean;
 } & {
     /**
      * #method

package/esm/LinearWiggleDisplay/{models/model.js → model.js}

@@ -1,14 +1,14 @@
 import { lazy } from 'react';
 import { getConf, } from '@jbrowse/core/configuration';
-import { getSession } from '@jbrowse/core/util';
+import { getContainingView, getSession, } from '@jbrowse/core/util';
 import { types } from 'mobx-state-tree';
 import { axisPropsFromTickScale } from 'react-d3-axis-mod';
 // locals
-import { getScale, YSCALEBAR_LABEL_OFFSET } from '../../util';
-import SharedWiggleMixin from '../../shared/modelShared';
+import { getScale, YSCALEBAR_LABEL_OFFSET } from '../util';
+import SharedWiggleMixin from '../shared/SharedWiggleMixin';
 // lazies
-const Tooltip = lazy(() => import('../components/Tooltip'));
-const SetColorDialog = lazy(() => import('../components/SetColorDialog'));
+const Tooltip = lazy(() => import('./components/Tooltip'));
+const SetColorDialog = lazy(() => import('./components/SetColorDialog'));
 // using a map because it preserves order
 const rendererTypes = new Map([
     ['xyplot', 'XYPlotRenderer'],
@@ -46,29 +46,14 @@ function stateModelFactory(pluginManager, configSchema) {
             }
             return rendererType;
         },
-    }))
-        .views(self => ({
         /**
          * #getter
+         * unused currently
          */
-        get ticks() {
-            const { scaleType, domain, height } = self;
-            const minimalTicks = getConf(self, 'minimalTicks');
-            const inverted = getConf(self, 'inverted');
-            const range = [height - YSCALEBAR_LABEL_OFFSET, YSCALEBAR_LABEL_OFFSET];
-            if (!domain) {
-                return undefined;
-            }
-            const scale = getScale({
-                scaleType,
-                domain,
-                range,
-                inverted,
-            });
-            const ticks = axisPropsFromTickScale(scale, 4);
-            return height < 100 || minimalTicks
-                ? { ...ticks, values: domain }
-                : ticks;
+        get quantitativeStatsRelevantToCurrentZoom() {
+            var _a;
+            const view = getContainingView(self);
+            return ((_a = self.stats) === null || _a === void 0 ? void 0 : _a.currStatsBpPerPx) === view.bpPerPx;
         },
     }))
         .views(self => {
@@ -77,46 +62,93 @@ function stateModelFactory(pluginManager, configSchema) {
             /**
              * #method
              */
-            renderProps() {
+            adapterProps() {
                 const superProps = superRenderProps();
-                const { filters, ticks, height, resolution, scaleOpts } = self;
+                const { filters, resolution, scaleOpts } = self;
                 return {
                     ...superProps,
-                    notReady: superProps.notReady || !self.stats,
                     rpcDriverName: self.rpcDriverName,
                     displayModel: self,
                     config: self.rendererConfig,
                     displayCrossHatches: self.displayCrossHatchesSetting,
                     scaleOpts,
                     resolution,
-                    height,
-                    ticks,
                     filters,
                 };
             },
             /**
              * #getter
              */
-            get needsScalebar() {
-                const { rendererTypeName: type } = self;
-                return type === 'XYPlotRenderer' || type === 'LinePlotRenderer';
-            },
-            /**
-             * #getter
-             */
-            get fillSetting() {
-                if (self.filled) {
-                    return 0;
-                }
-                else if (self.minSize === 1) {
-                    return 1;
+            get ticks() {
+                const { scaleType, domain, height } = self;
+                const minimalTicks = getConf(self, 'minimalTicks');
+                const inverted = getConf(self, 'inverted');
+                if (domain) {
+                    const ticks = axisPropsFromTickScale(getScale({
+                        scaleType,
+                        domain,
+                        range: [
+                            height - YSCALEBAR_LABEL_OFFSET,
+                            YSCALEBAR_LABEL_OFFSET,
+                        ],
+                        inverted,
+                    }), 4);
+                    return height < 100 || minimalTicks
+                        ? { ...ticks, values: domain }
+                        : ticks;
                 }
                 else {
-                    return 2;
+                    return undefined;
                 }
             },
         };
     })
+        .views(self => ({
+        /**
+         * #method
+         */
+        renderProps() {
+            const { ticks, height } = self;
+            const superProps = self.adapterProps();
+            return {
+                ...self.adapterProps(),
+                notReady: superProps.notReady || !self.stats,
+                height,
+                ticks,
+            };
+        },
+        /**
+         * #getter
+         */
+        get needsScalebar() {
+            return (self.rendererTypeName === 'XYPlotRenderer' ||
+                self.rendererTypeName === 'LinePlotRenderer');
+        },
+        /**
+         * #getter
+         */
+        get fillSetting() {
+            if (self.filled) {
+                return 0;
+            }
+            else if (self.minSize === 1) {
+                return 1;
+            }
+            else {
+                return 2;
+            }
+        },
+        /**
+         * #getter
+         */
+        get quantitativeStatsReady() {
+            const view = getContainingView(self);
+            return (view.initialized &&
+                self.featureDensityStatsReady &&
+                !self.regionTooLarge &&
+                !self.error);
+        },
+    }))
         .views(self => {
         const { trackMenuItems: superTrackMenuItems } = self;
         const hasRenderings = getConf(self, 'defaultRendering');
@@ -178,7 +210,10 @@ function stateModelFactory(pluginManager, configSchema) {
                         onClick: () => {
                             getSession(self).queueDialog(handleClose => [
                                 SetColorDialog,
-                                { model: self, handleClose },
+                                {
+                                    model: self,
+                                    handleClose,
+                                },
                             ]);
                         },
                     },
@@ -193,8 +228,8 @@ function stateModelFactory(pluginManager, configSchema) {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 ;
                 (async () => {
-                    const { quantitativeStatsAutorun } = await import('../../util');
-                    quantitativeStatsAutorun(self);
+                    const { getQuantitativeStatsAutorun } = await import('../getQuantitativeStatsAutorun');
+                    getQuantitativeStatsAutorun(self);
                 })();
             },
             /**

package/esm/LinearWiggleDisplay/{models/renderSvg.js → renderSvg.js}

@@ -1,7 +1,8 @@
 import React from 'react';
 import { getContainingView } from '@jbrowse/core/util';
 import { when } from 'mobx';
-import YScaleBar from '../../shared/YScaleBar';
+// locals
+import YScaleBar from '../shared/YScaleBar';
 export async function renderSvg(self, opts, superRenderSvg) {
     await when(() => !!self.stats && !!self.regionCannotBeRenderedText);
     const { needsScalebar, stats } = self;

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 declare const ColorLegend: ({ model, rowHeight, labelWidth, exportSVG, }: {
     model: WiggleDisplayModel;
     rowHeight: number;

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 declare const ScoreLegend: ({ model }: {
     model: WiggleDisplayModel;
 }) => React.JSX.Element;

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 declare const MultiLinearWiggleDisplayComponent: (props: {
     model: WiggleDisplayModel;
 }) => React.JSX.Element;

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 export declare const YScaleBars: (props: {
     model: WiggleDisplayModel;
     orientation?: string;

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

@@ -1,4 +1,4 @@
-import { WiggleDisplayModel } from '../models/model';
+import { WiggleDisplayModel } from '../model';
 export declare function moveUp(arr: {
     name: string;
 }[], sel: string[], by?: number): {

package/esm/MultiLinearWiggleDisplay/{models/configSchema.js → configSchema.js}

@@ -1,7 +1,7 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { types } from 'mobx-state-tree';
 // locals
-import sharedWiggleConfigFactory from '../../shared/configShared';
+import sharedWiggleConfigFactory from '../shared/SharedWiggleConfigSchema';
 /**
  * #config MultiLinearWiggleDisplay
  * extends

package/esm/MultiLinearWiggleDisplay/index.js

@@ -1,6 +1,6 @@
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
-import configSchemaFactory from './models/configSchema';
-import modelFactory from './models/model';
+import configSchemaFactory from './configSchema';
+import modelFactory from './model';
 import { lazy } from 'react';
 export default function MultiLinearWiggleDisplayF(pluginManager) {
     pluginManager.addDisplayType(() => {