@jbrowse/plugin-dotplot-view 2.16.1 → 2.18.0

package/esm/ComparativeRenderer/index.js

@@ -1,10 +1,5 @@
-import { checkAbortSignal } from '@jbrowse/core/util';
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
-/**
- * call a synteny renderer with the given args
- * param views: a set of views that each contain a set of regions
- * used instead of passing regions directly as in render()
- */
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
 export default class ComparativeRender extends RpcMethodType {
     constructor() {
         super(...arguments);
@@ -31,11 +26,11 @@ export default class ComparativeRender extends RpcMethodType {
         if (rpcDriver !== 'MainThreadRpcDriver') {
             deserializedArgs = await this.deserializeArguments(args, rpcDriver);
         }
-        const { sessionId, rendererType, signal } = deserializedArgs;
+        const { sessionId, rendererType, stopToken } = deserializedArgs;
         if (!sessionId) {
             throw new Error('must pass a unique session id');
         }
-        checkAbortSignal(signal);
+        checkStopToken(stopToken);
         const renderer = this.getRenderer(rendererType);
         return rpcDriver === 'MainThreadRpcDriver'
             ? renderer.render(deserializedArgs)

package/esm/DotplotDisplay/components/DotplotDisplay.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { DotplotDisplayModel } from '../stateModelFactory';
+import type { DotplotDisplayModel } from '../stateModelFactory';
 declare const DotplotDisplay: (props: {
     model: DotplotDisplayModel;
     children?: React.ReactNode;

package/esm/DotplotDisplay/components/DotplotDisplay.js

@@ -1,6 +1,6 @@
 import React from 'react';
-import { observer } from 'mobx-react';
 import { getContainingView } from '@jbrowse/core/util';
+import { observer } from 'mobx-react';
 const DotplotDisplay = observer(function DotplotDisplay(props) {
     const { model, children } = props;
     const { offsetX = 0, offsetY = 0 } = model.data || {};

package/esm/DotplotDisplay/index.d.ts

@@ -1,11 +1,5 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function DotplotDisplayF(pm: PluginManager): void;
-/**
- * #config DotplotDisplay
- */
 export declare function configSchemaFactory(pm: any): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     renderer: import("mobx-state-tree").IOptionalIType<any, [undefined]>;
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "displayId">>;

package/esm/DotplotDisplay/index.js

@@ -1,9 +1,8 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { types } from 'mobx-state-tree';
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
-// locals
-import { stateModelFactory } from './stateModelFactory';
+import { types } from 'mobx-state-tree';
 import ReactComponent from './components/DotplotDisplay';
+import { stateModelFactory } from './stateModelFactory';
 export default function DotplotDisplayF(pm) {
     pm.addDisplayType(() => {
         const configSchema = configSchemaFactory(pm);
@@ -18,21 +17,12 @@ export default function DotplotDisplayF(pm) {
         });
     });
 }
-/**
- * #config DotplotDisplay
- */
 export function configSchemaFactory(pm) {
     return ConfigurationSchema('DotplotDisplay', {
-        /**
-         * #slot
-         */
         renderer: types.optional(pm.pluggableConfigSchemaType('renderer'), {
             type: 'DotplotRenderer',
         }),
     }, {
-        /**
-         * #identifier
-         */
         explicitIdentifier: 'displayId',
         explicitlyTyped: true,
     });

package/esm/DotplotDisplay/renderDotplotBlock.d.ts

@@ -1,4 +1,4 @@
-import { IAnyStateTreeNode } from 'mobx-state-tree';
+import type { IAnyStateTreeNode } from 'mobx-state-tree';
 export declare function renderBlockData(self: IAnyStateTreeNode): {
     rendererType: any;
     rpcManager: import("@jbrowse/core/rpc/RpcManager").default;

package/esm/DotplotDisplay/renderDotplotBlock.js

@@ -1,15 +1,12 @@
-import clone from 'clone';
 import { readConfObject } from '@jbrowse/core/configuration';
+import { getContainingView, getSession } from '@jbrowse/core/util';
 import { getRpcSessionId } from '@jbrowse/core/util/tracks';
 import { getSnapshot } from 'mobx-state-tree';
-import { getContainingView, getSession } from '@jbrowse/core/util';
 export function renderBlockData(self) {
     const { rpcManager } = getSession(self);
     const { rendererType } = self;
     const { adapterConfig } = self;
     const parent = getContainingView(self);
-    // Alternative to readConfObject(config) is below used because renderProps is
-    // something under our control.  Compare to serverSideRenderedBlock
     readConfObject(self.configuration);
     getSnapshot(parent);
     if (parent.initialized) {
@@ -19,7 +16,7 @@ export function renderBlockData(self) {
             rpcManager,
             renderProps: {
                 ...self.renderProps(),
-                view: clone(getSnapshot(parent)),
+                view: structuredClone(getSnapshot(parent)),
                 width: viewWidth,
                 height: viewHeight,
                 borderSize,
@@ -28,7 +25,7 @@ export function renderBlockData(self) {
                 adapterConfig,
                 rendererType: rendererType.name,
                 sessionId: getRpcSessionId(self),
-                timeout: 1000000, // 10000,
+                timeout: 1000000,
             },
         };
     }

package/esm/DotplotDisplay/stateModelFactory.d.ts

@@ -1,36 +1,21 @@
 import React from 'react';
-import { ThemeOptions } from '@mui/material';
-import { Instance } from 'mobx-state-tree';
-import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
-import { ExportSvgOptions } from '../DotplotView/model';
-/**
- * #stateModel DotplotDisplay
- * #category display
- */
+import type { ExportSvgOptions } from '../DotplotView/model';
+import type { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import type { ThemeOptions } from '@mui/material';
+import type { Instance } from 'mobx-state-tree';
 export declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): 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>;
     rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
 } & {
-    /**
-     * #property
-     */
     type: import("mobx-state-tree").ISimpleType<"DotplotDisplay">;
-    /**
-     * #property
-     */
     configuration: AnyConfigurationSchemaType;
 }, {
     rendererTypeName: string;
     error: unknown;
     message: string | undefined;
 } & {
-    readonly RenderingComponent: React.
-    /**
-     * #stateModel DotplotDisplay
-     * #category display
-     */
-    FC<{
+    readonly RenderingComponent: React.FC<{
         model: {
             id: string;
             type: string;
@@ -84,11 +69,11 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     setRpcDriverName(rpcDriverName: string): void;
     reload(): void;
 } & {
+    stopToken: string | undefined;
     warnings: {
         message: string;
         effect: string;
     }[];
-    renderInProgress: AbortController | undefined;
     filled: boolean;
     data: any;
     reactElement: React.ReactElement | undefined;
@@ -97,42 +82,21 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     ReactComponent2: React.FC<any>;
 } & {
     readonly shouldDisplay: boolean;
-    /**
-     * #getter
-     */
     readonly rendererTypeName: any;
-    /**
-     * #method
-     */
     renderProps(): any;
 } & {
-    /**
-     * #method
-     */
     renderSvg(opts: ExportSvgOptions & {
         theme?: ThemeOptions;
     }): Promise<React.JSX.Element | null>;
 } & {
     afterAttach(): void;
-    /**
-     * #action
-     */
-    setLoading(abortController: AbortController): void;
-    /**
-     * #action
-     */
+    setLoading(stopToken?: string): void;
     setMessage(messageText: string): void;
-    /**
-     * #action
-     */
     setRendered(args?: {
         data: any;
         reactElement: React.ReactElement;
         renderingComponent: React.Component;
     }): void;
-    /**
-     * #action
-     */
     setError(error: unknown): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type DotplotDisplayStateModel = ReturnType<typeof stateModelFactory>;

package/esm/DotplotDisplay/stateModelFactory.js

@@ -1,32 +1,21 @@
 import React from 'react';
-import { types } from 'mobx-state-tree';
-import { getConf, ConfigurationReference, } from '@jbrowse/core/configuration';
-import { getParentRenderProps } from '@jbrowse/core/util/tracks';
-import { getContainingView, makeAbortableReaction, ReactRendering, } from '@jbrowse/core/util';
+import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
 import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes/models';
-// locals
+import { ReactRendering, getContainingView, makeAbortableReaction, } from '@jbrowse/core/util';
+import { getParentRenderProps } from '@jbrowse/core/util/tracks';
+import { types } from 'mobx-state-tree';
 import ServerSideRenderedBlockContent from '../ServerSideRenderedBlockContent';
 import { renderBlockData, renderBlockEffect } from './renderDotplotBlock';
-/**
- * #stateModel DotplotDisplay
- * #category display
- */
 export function stateModelFactory(configSchema) {
     return types
         .compose('DotplotDisplay', BaseDisplay, types
         .model({
-        /**
-         * #property
-         */
         type: types.literal('DotplotDisplay'),
-        /**
-         * #property
-         */
         configuration: ConfigurationReference(configSchema),
     })
         .volatile(() => ({
+        stopToken: undefined,
         warnings: [],
-        renderInProgress: undefined,
         filled: false,
         data: undefined,
         reactElement: undefined,
@@ -40,15 +29,9 @@ export function stateModelFactory(configSchema) {
             return (vview.bpPerPx === self.data.bpPerPxY &&
                 hview.bpPerPx === self.data.bpPerPxX);
         },
-        /**
-         * #getter
-         */
         get rendererTypeName() {
             return getConf(self, ['renderer', 'type']);
         },
-        /**
-         * #method
-         */
         renderProps() {
             return {
                 ...getParentRenderProps(self),
@@ -59,9 +42,6 @@ export function stateModelFactory(configSchema) {
         },
     }))
         .views(self => ({
-        /**
-         * #method
-         */
         async renderSvg(opts) {
             const props = renderBlockData(self);
             if (!props) {
@@ -80,77 +60,55 @@ export function stateModelFactory(configSchema) {
                 React.createElement(ReactRendering, { rendering: rendering })));
         },
     }))
-        .actions(self => {
-        let renderInProgress;
-        return {
-            afterAttach() {
-                makeAbortableReaction(self, () => renderBlockData(self), blockData => renderBlockEffect(blockData), {
-                    name: `${self.type} ${self.id} rendering`,
-                    delay: 500,
-                    fireImmediately: true,
-                }, this.setLoading, this.setRendered, this.setError);
-            },
-            /**
-             * #action
-             */
-            setLoading(abortController) {
-                self.filled = false;
-                self.message = undefined;
-                self.reactElement = undefined;
-                self.data = undefined;
-                self.error = undefined;
-                self.renderingComponent = undefined;
-                renderInProgress = abortController;
-            },
-            /**
-             * #action
-             */
-            setMessage(messageText) {
-                if (renderInProgress && !renderInProgress.signal.aborted) {
-                    renderInProgress.abort();
-                }
-                self.filled = false;
-                self.message = messageText;
-                self.reactElement = undefined;
-                self.data = undefined;
-                self.error = undefined;
-                self.renderingComponent = undefined;
-                renderInProgress = undefined;
-            },
-            /**
-             * #action
-             */
-            setRendered(args) {
-                if (args === undefined) {
-                    return;
-                }
-                const { data, reactElement, renderingComponent } = args;
-                self.warnings = data.warnings;
-                self.filled = true;
-                self.message = undefined;
-                self.reactElement = reactElement;
-                self.data = data;
-                self.error = undefined;
-                self.renderingComponent = renderingComponent;
-                renderInProgress = undefined;
-            },
-            /**
-             * #action
-             */
-            setError(error) {
-                console.error(error);
-                if (renderInProgress && !renderInProgress.signal.aborted) {
-                    renderInProgress.abort();
-                }
-                // the rendering failed for some reason
-                self.filled = false;
-                self.message = undefined;
-                self.reactElement = undefined;
-                self.data = undefined;
-                self.error = error;
-                self.renderingComponent = undefined;
-                renderInProgress = undefined;
-            },
-        };
-    });
+        .actions(self => ({
+        afterAttach() {
+            makeAbortableReaction(self, () => renderBlockData(self), blockData => renderBlockEffect(blockData), {
+                name: `${self.type} ${self.id} rendering`,
+                delay: 500,
+                fireImmediately: true,
+            }, this.setLoading, this.setRendered, this.setError);
+        },
+        setLoading(stopToken) {
+            self.filled = false;
+            self.message = undefined;
+            self.reactElement = undefined;
+            self.data = undefined;
+            self.error = undefined;
+            self.renderingComponent = undefined;
+            self.stopToken = stopToken;
+        },
+        setMessage(messageText) {
+            self.filled = false;
+            self.message = messageText;
+            self.reactElement = undefined;
+            self.data = undefined;
+            self.error = undefined;
+            self.renderingComponent = undefined;
+            self.stopToken = undefined;
+        },
+        setRendered(args) {
+            if (args === undefined) {
+                return;
+            }
+            const { data, reactElement, renderingComponent } = args;
+            self.warnings = data.warnings;
+            self.filled = true;
+            self.message = undefined;
+            self.reactElement = reactElement;
+            self.data = data;
+            self.error = undefined;
+            self.renderingComponent = renderingComponent;
+            self.stopToken = undefined;
+        },
+        setError(error) {
+            console.error(error);
+            self.filled = false;
+            self.message = undefined;
+            self.reactElement = undefined;
+            self.data = undefined;
+            self.error = error;
+            self.renderingComponent = undefined;
+            self.stopToken = undefined;
+        },
+    }));
 }

package/esm/DotplotReadVsRef/DotplotReadVsRef.d.ts

@@ -1,3 +1,3 @@
-import { Feature } from '@jbrowse/core/util';
-import { LinearPileupDisplayModel } from '@jbrowse/plugin-alignments';
+import type { Feature } from '@jbrowse/core/util';
+import type { LinearPileupDisplayModel } from '@jbrowse/plugin-alignments';
 export declare function onClick(feature: Feature, self: LinearPileupDisplayModel): void;

package/esm/DotplotReadVsRef/DotplotReadVsRef.js

@@ -1,8 +1,9 @@
 import { getConf } from '@jbrowse/core/configuration';
-import { getSession, gatherOverlaps } from '@jbrowse/core/util';
-import { MismatchParser, } from '@jbrowse/plugin-alignments';
-const { featurizeSA, getClip, getTag, getLength, getLengthSansClipping } = MismatchParser;
+import { gatherOverlaps, getSession, sum } from '@jbrowse/core/util';
+import { MismatchParser } from '@jbrowse/plugin-alignments';
+const { featurizeSA, getClip, getLength, getLengthSansClipping } = MismatchParser;
 export function onClick(feature, self) {
+    var _a;
     const session = getSession(self);
     try {
         const cigar = feature.get('CIGAR');
@@ -16,27 +17,26 @@ export function onClick(feature, self) {
         const assemblyNames = [trackAssembly, readAssembly];
         const trackId = `track-${Date.now()}`;
         const trackName = `${readName}_vs_${trackAssembly}`;
-        const SA = getTag(feature, 'SA') || '';
+        const SA = (_a = feature.get('tags')) === null || _a === void 0 ? void 0 : _a.SA;
         const SA2 = featurizeSA(SA, feature.id(), strand, readName, true);
-        const feat = feature.toJSON();
-        feat.strand = 1;
-        feat.mate = {
-            refName: readName,
-            start: clipPos,
-            end: clipPos + getLengthSansClipping(cigar),
-        };
-        // if secondary alignment or supplementary, calculate length from SA[0]'s
-        // CIGAR which is the primary alignments. otherwise it is the primary
-        // alignment just use seq.length if primary alignment
         const totalLength = getLength(flags & 2048 ? SA2[0].CIGAR : cigar);
-        const features = [feat, ...SA2];
-        features.sort((a, b) => a.clipPos - b.clipPos);
-        const refLength = features.reduce((a, f) => a + f.end - f.start, 0);
+        const features = [
+            {
+                ...feature.toJSON(),
+                strand: 1,
+                mate: {
+                    refName: readName,
+                    start: clipPos,
+                    end: clipPos + getLengthSansClipping(cigar),
+                },
+            },
+            ...SA2,
+        ].sort((a, b) => a.clipPos - b.clipPos);
         session.addView('DotplotView', {
             type: 'DotplotView',
             hview: {
                 offsetPx: 0,
-                bpPerPx: refLength / 800,
+                bpPerPx: sum(features.map(a => a.end - a.start)) / 800,
                 displayedRegions: gatherOverlaps(features.map((f, index) => {
                     const { start, end, refName } = f;
                     return {

package/esm/DotplotReadVsRef/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function DotplotReadVsRefMenuItem(pluginManager: PluginManager): void;

package/esm/DotplotReadVsRef/index.js

@@ -1,6 +1,4 @@
-// icons
 import AddIcon from '@mui/icons-material/Add';
-// local
 import { onClick } from './DotplotReadVsRef';
 export default function DotplotReadVsRefMenuItem(pluginManager) {
     pluginManager.addToExtensionPoint('Core-extendPluggableElement', (pluggableElement) => {

package/esm/DotplotRenderer/ComparativeRenderRpc.d.ts

@@ -1,6 +1,6 @@
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
-import ComparativeRenderer, { RenderArgs as ComparativeRenderArgs, RenderArgsSerialized as ComparativeRenderArgsSerialized, RenderResults, ResultsSerialized } from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
-import { RemoteAbortSignal } from '@jbrowse/core/rpc/remoteAbortSignals';
+import type { RenderArgs as ComparativeRenderArgs, RenderArgsSerialized as ComparativeRenderArgsSerialized, RenderResults, ResultsSerialized } from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
+import type ComparativeRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
 interface RenderArgs extends ComparativeRenderArgs {
     adapterConfig: Record<string, unknown>;
     rendererType: string;
@@ -9,18 +9,13 @@ interface RenderArgsSerialized extends ComparativeRenderArgsSerialized {
     adapterConfig: Record<string, unknown>;
     rendererType: string;
 }
-/**
- * call a synteny renderer with the given args
- * param views: a set of views that each contain a set of regions
- * used instead of passing regions directly as in render()
- */
 export default class ComparativeRender extends RpcMethodType {
     name: string;
     renameRegionsIfNeeded(args: RenderArgs, rend: ComparativeRenderer): Promise<ComparativeRenderArgs>;
     getRenderer(rendererType: string): ComparativeRenderer;
     serializeArguments(args: RenderArgs, rpcDriver: string): Promise<ComparativeRenderArgs | import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").RenderArgsSerialized>;
     execute(args: RenderArgsSerialized & {
-        signal?: RemoteAbortSignal;
+        stopToken?: string;
     }, rpcDriver: string): Promise<RenderResults | import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").ResultsSerialized>;
     deserializeReturn(val: RenderResults | ResultsSerialized, args: RenderArgs, rpcDriver: string): Promise<unknown>;
 }

package/esm/DotplotRenderer/ComparativeRenderRpc.js

@@ -1,10 +1,5 @@
-import { checkAbortSignal } from '@jbrowse/core/util';
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
-/**
- * call a synteny renderer with the given args
- * param views: a set of views that each contain a set of regions
- * used instead of passing regions directly as in render()
- */
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
 export default class ComparativeRender extends RpcMethodType {
     constructor() {
         super(...arguments);
@@ -31,11 +26,11 @@ export default class ComparativeRender extends RpcMethodType {
         if (rpcDriver !== 'MainThreadRpcDriver') {
             deserializedArgs = await this.deserializeArguments(args, rpcDriver);
         }
-        const { sessionId, rendererType, signal } = deserializedArgs;
+        const { sessionId, rendererType, stopToken } = deserializedArgs;
         if (!sessionId) {
             throw new Error('must pass a unique session id');
         }
-        checkAbortSignal(signal);
+        checkStopToken(stopToken);
         const renderer = this.getRenderer(rendererType);
         return rpcDriver === 'MainThreadRpcDriver'
             ? renderer.render(deserializedArgs)

package/esm/DotplotRenderer/DotplotRenderer.d.ts

@@ -1,7 +1,8 @@
-import { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import { Region } from '@jbrowse/core/util';
-import ComparativeRenderer, { RenderArgsDeserialized, RenderArgs } from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
-import { Dotplot1DViewModel } from '../DotplotView/model';
+import ComparativeRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
+import type { Dotplot1DViewModel } from '../DotplotView/model';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { RenderArgs, RenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
+import type { Region } from '@jbrowse/core/util';
 export interface DotplotRenderArgsDeserialized extends RenderArgsDeserialized {
     adapterConfig: AnyConfigurationModel;
     height: number;

package/esm/DotplotRenderer/DotplotRenderer.js

@@ -1,6 +1,5 @@
-import { renameRegionsIfNeeded, renderToAbstractCanvas, } from '@jbrowse/core/util';
 import ComparativeRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
-// locals
+import { renameRegionsIfNeeded, renderToAbstractCanvas, } from '@jbrowse/core/util';
 import { Dotplot1DView } from '../DotplotView/model';
 export default class DotplotRenderer extends ComparativeRenderer {
     constructor() {

package/esm/DotplotRenderer/components/DotplotRendering.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import { DotplotRenderArgsDeserialized } from '../DotplotRenderer';
+import type { DotplotRenderArgsDeserialized } from '../DotplotRenderer';
 declare const DotplotRendering: (props: DotplotRenderArgsDeserialized) => React.JSX.Element;
 export default DotplotRendering;

package/esm/DotplotRenderer/configSchema.d.ts

@@ -1,57 +1,36 @@
 declare const _default: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     color: {
         type: string;
         description: string;
         defaultValue: string;
         contextVariable: string[];
     };
-    /**
-     * #slot
-     */
     posColor: {
         type: string;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     negColor: {
         type: string;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     lineWidth: {
         type: string;
         description: string;
         defaultValue: number;
     };
-    /**
-     * #slot
-     */
     colorBy: {
         type: string;
         model: import("mobx-state-tree").ISimpleType<string>;
         description: string;
         defaultValue: string;
     };
-    /**
-     * #slot
-     */
     thresholdsPalette: {
         type: string;
         defaultValue: string[];
         description: string;
     };
-    /**
-     * #slot
-     */
     thresholds: {
         type: string;
         defaultValue: string[];