@jbrowse/plugin-dotplot-view 3.7.0 → 4.0.0

package/esm/ComparativeRenderer/index.d.ts

@@ -1,22 +1,22 @@
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
-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>;
+import type { DotplotRenderArgs, RenderArgsSerialized, ResultsSerialized } from '../DotplotRenderer/DotplotRenderer.ts';
+import type DotplotRenderer from '../DotplotRenderer/DotplotRenderer.ts';
+import type { RenderResults } from '@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType';
+interface RenderArgs extends DotplotRenderArgs {
     rendererType: string;
 }
-interface RenderArgsSerialized extends ComparativeRenderArgsSerialized {
+interface RenderArgsSerializedWithRenderer extends RenderArgsSerialized {
     adapterConfig: Record<string, unknown>;
     rendererType: string;
 }
 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 & {
+    renameRegionsIfNeeded(args: RenderArgs, rend: DotplotRenderer): Promise<DotplotRenderArgs>;
+    getRenderer(rendererType: string): DotplotRenderer;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").RenderArgsSerialized>;
+    execute(args: RenderArgsSerializedWithRenderer & {
         stopToken?: string;
-    }, rpcDriver: string): Promise<RenderResults | import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").ResultsSerialized>;
+    }, rpcDriver: string): Promise<import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").ResultsSerialized>;
     deserializeReturn(val: RenderResults | ResultsSerialized, args: RenderArgs, rpcDriver: string): Promise<unknown>;
 }
 export {};

package/esm/ComparativeRenderer/index.js

@@ -1,10 +1,7 @@
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
 import { checkStopToken } from '@jbrowse/core/util/stopToken';
 export default class ComparativeRender extends RpcMethodType {
-    constructor() {
-        super(...arguments);
-        this.name = 'ComparativeRender';
-    }
+    name = 'ComparativeRender';
     async renameRegionsIfNeeded(args, rend) {
         return rend.renameRegionsIfNeeded(args);
     }
@@ -17,30 +14,20 @@ export default class ComparativeRender extends RpcMethodType {
         const renderer = this.getRenderer(rendererType);
         const n = (await super.serializeArguments(args, rpcDriver));
         const result = await this.renameRegionsIfNeeded(n, renderer);
-        return rpcDriver === 'MainThreadRpcDriver'
-            ? result
-            : renderer.serializeArgsInClient(result);
+        return renderer.serializeArgsInClient(result);
     }
     async execute(args, rpcDriver) {
-        let deserializedArgs = args;
-        if (rpcDriver !== 'MainThreadRpcDriver') {
-            deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        }
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
         const { sessionId, rendererType, stopToken } = deserializedArgs;
         if (!sessionId) {
             throw new Error('must pass a unique session id');
         }
         checkStopToken(stopToken);
         const renderer = this.getRenderer(rendererType);
-        return rpcDriver === 'MainThreadRpcDriver'
-            ? renderer.render(deserializedArgs)
-            : renderer.renderInWorker(deserializedArgs);
+        return renderer.renderInWorker(deserializedArgs);
     }
     async deserializeReturn(val, args, rpcDriver) {
         const ret = (await super.deserializeReturn(val, args, rpcDriver));
-        if (rpcDriver === 'MainThreadRpcDriver') {
-            return ret;
-        }
         const renderer = this.getRenderer(args.rendererType);
         return renderer.deserializeResultsInClient(ret, args);
     }

package/esm/DiagonalizeDotplotRpc.js

@@ -1,6 +1,6 @@
 import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
 import { checkStopToken } from '@jbrowse/core/util/stopToken';
-import { Dotplot1DView } from './DotplotView/model';
+import { Dotplot1DView } from "./DotplotView/model.js";
 async function diagonalizeRegions(alignments, currentRegions, progressCallback) {
     const updateProgress = (progress, message) => {
         if (progressCallback) {
@@ -88,17 +88,14 @@ async function diagonalizeRegions(alignments, currentRegions, progressCallback)
     };
 }
 export default class DiagonalizeDotplotRpc extends RpcMethodTypeWithFiltersAndRenameRegions {
-    constructor() {
-        super(...arguments);
-        this.name = 'DiagonalizeDotplot';
-    }
+    name = 'DiagonalizeDotplot';
     async execute(args, rpcDriverClassName) {
         const deserializedArgs = await this.deserializeArguments(args, rpcDriverClassName);
         const { view, sessionId, adapterConfig, stopToken, statusCallback } = deserializedArgs;
         if (!sessionId) {
             throw new Error('must pass a unique session id');
         }
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Initializing diagonalization...');
+        statusCallback?.('Initializing diagonalization...');
         const dimensions = [800, 800];
         const views = [view.hview, view.vview].map((snap, idx) => {
             const v = Dotplot1DView.create(snap);
@@ -107,20 +104,20 @@ export default class DiagonalizeDotplotRpc extends RpcMethodTypeWithFiltersAndRe
         });
         const targetView = views[0];
         checkStopToken(stopToken);
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Getting renderer...');
+        statusCallback?.('Getting renderer...');
         const rendererType = this.pluginManager.getRendererType('DotplotRenderer');
         if (!rendererType) {
             throw new Error('DotplotRenderer not found');
         }
         checkStopToken(stopToken);
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Fetching features...');
+        statusCallback?.('Fetching features...');
         const feats = await rendererType.getFeatures({
             regions: targetView.dynamicBlocks.contentBlocks,
             adapterConfig,
             sessionId,
         });
         checkStopToken(stopToken);
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Extracting alignment data...');
+        statusCallback?.('Extracting alignment data...');
         const alignments = [];
         for (const feat of feats.values()) {
             const mate = feat.get('mate');
@@ -139,12 +136,12 @@ export default class DiagonalizeDotplotRpc extends RpcMethodTypeWithFiltersAndRe
         if (alignments.length === 0) {
             throw new Error('No alignments found to diagonalize');
         }
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback(`Running diagonalization on ${alignments.length} alignments...`);
+        statusCallback?.(`Running diagonalization on ${alignments.length} alignments...`);
         const result = await diagonalizeRegions(alignments, view.vview.displayedRegions, (progress, message) => {
             checkStopToken(stopToken);
-            statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback(message);
+            statusCallback?.(message);
         });
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Diagonalization complete!');
+        statusCallback?.('Diagonalization complete!');
         return result;
     }
 }

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

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

package/esm/DotplotDisplay/index.d.ts

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

package/esm/DotplotDisplay/index.js

@@ -1,8 +1,8 @@
+import { lazy } from 'react';
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
-import { types } from 'mobx-state-tree';
-import ReactComponent from './components/DotplotDisplay';
-import { stateModelFactory } from './stateModelFactory';
+import { types } from '@jbrowse/mobx-state-tree';
+import { stateModelFactory } from "./stateModelFactory.js";
 export default function DotplotDisplayF(pm) {
     pm.addDisplayType(() => {
         const configSchema = configSchemaFactory(pm);
@@ -13,7 +13,7 @@ export default function DotplotDisplayF(pm) {
             stateModel: stateModelFactory(configSchema),
             trackType: 'SyntenyTrack',
             viewType: 'DotplotView',
-            ReactComponent,
+            ReactComponent: lazy(() => import("./components/DotplotDisplay.js")),
         });
     });
 }

package/esm/DotplotDisplay/renderDotplotBlock.d.ts

@@ -1,8 +1,9 @@
-import type { IAnyStateTreeNode } from 'mobx-state-tree';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
 export declare function renderBlockData(self: IAnyStateTreeNode): {
     rendererType: any;
     rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
     renderProps: any;
+    renderingProps: Record<string, unknown> | undefined;
 } | undefined;
 export declare function renderBlockEffect(props?: ReturnType<typeof renderBlockData>): Promise<{
     reactElement: any;

package/esm/DotplotDisplay/renderDotplotBlock.js

@@ -1,7 +1,7 @@
 import { readConfObject } from '@jbrowse/core/configuration';
-import { getContainingView, getSession } from '@jbrowse/core/util';
+import { getContainingTrack, getContainingView, getSession, } from '@jbrowse/core/util';
 import { getRpcSessionId } from '@jbrowse/core/util/tracks';
-import { getSnapshot } from 'mobx-state-tree';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
 export function renderBlockData(self) {
     const { rpcManager } = getSession(self);
     const { rendererType } = self;
@@ -25,11 +25,13 @@ export function renderBlockData(self) {
                 adapterConfig,
                 rendererType: rendererType.name,
                 sessionId: getRpcSessionId(self),
+                trackInstanceId: getContainingTrack(self).id,
                 timeout: 1000000,
                 alpha: self.alpha,
                 minAlignmentLength: self.minAlignmentLength,
                 colorBy: self.colorBy,
             },
+            renderingProps: self.renderingProps?.(),
         };
     }
     return undefined;
@@ -38,8 +40,8 @@ export async function renderBlockEffect(props) {
     if (!props) {
         return;
     }
-    const { rendererType, rpcManager, renderProps } = props;
-    const { reactElement, ...data } = await rendererType.renderInClient(rpcManager, renderProps);
+    const { rendererType, rpcManager, renderProps, renderingProps } = props;
+    const { reactElement, ...data } = await rendererType.renderInClient(rpcManager, { ...renderProps, renderingProps });
     return {
         reactElement,
         data,

package/esm/DotplotDisplay/stateModelFactory.d.ts

@@ -1,38 +1,39 @@
-import type { ExportSvgOptions } from '../DotplotView/model';
+import type { ExportSvgOptions } from '../DotplotView/model.ts';
 import type { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import type { StopToken } from '@jbrowse/core/util/stopToken';
+import type { Instance } from '@jbrowse/mobx-state-tree';
 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>>;
+export declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
 } & {
-    type: import("mobx-state-tree").ISimpleType<"DotplotDisplay">;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<"DotplotDisplay">;
     configuration: AnyConfigurationSchemaType;
-    colorBy: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    colorBy: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
 }, {
     rendererTypeName: string;
     error: unknown;
-    message: string | undefined;
+    statusMessage: string | undefined;
 } & {
     readonly RenderingComponent: React.FC<{
         model: {
             id: string;
             type: string;
             rpcDriverName: string | undefined;
-        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+            statusMessage: string | undefined;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+            statusMessage: string | undefined;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
         onHorizontalScroll?: () => void;
         blockState?: Record<string, any>;
     }>;
@@ -41,35 +42,147 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
             id: string;
             type: string;
             rpcDriverName: string | undefined;
-        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+            statusMessage: string | undefined;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+            statusMessage: string | undefined;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
     }> | null;
     readonly adapterConfig: any;
-    readonly parentTrack: any;
+    readonly parentTrack: import("@jbrowse/core/util").AbstractTrackModel;
+    readonly parentDisplay: any;
+    readonly effectiveRpcDriverName: any;
+} & {
     renderProps(): any;
+    renderingProps(): {
+        displayModel: {
+            id: string;
+            type: string;
+            rpcDriverName: string | undefined;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & {
+            readonly RenderingComponent: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+                onHorizontalScroll?: () => void;
+                blockState?: Record<string, any>;
+            }>;
+            readonly DisplayBlurb: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+            }> | null;
+            readonly adapterConfig: any;
+            readonly parentTrack: import("@jbrowse/core/util").AbstractTrackModel;
+            readonly parentDisplay: any;
+            readonly effectiveRpcDriverName: any;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & {
+            readonly RenderingComponent: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+                onHorizontalScroll?: () => void;
+                blockState?: Record<string, any>;
+            }>;
+            readonly DisplayBlurb: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+            }> | null;
+            readonly adapterConfig: any;
+            readonly parentTrack: import("@jbrowse/core/util").AbstractTrackModel;
+            readonly parentDisplay: any;
+            readonly effectiveRpcDriverName: any;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+    };
     readonly rendererType: import("@jbrowse/core/pluggableElementTypes").RendererType;
     readonly DisplayMessageComponent: undefined | React.FC<any>;
     trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
     readonly viewMenuActions: import("@jbrowse/core/ui").MenuItem[];
     regionCannotBeRendered(): null;
 } & {
-    setMessage(arg?: string): void;
+    setStatusMessage(arg?: string): void;
     setError(error?: unknown): void;
     setRpcDriverName(rpcDriverName: string): void;
     reload(): void;
 } & {
-    stopToken: string | undefined;
+    stopToken: StopToken | undefined;
     warnings: {
         message: string;
         effect: string;
@@ -92,7 +205,7 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     }): Promise<import("react/jsx-runtime").JSX.Element | null>;
 } & {
     afterAttach(): void;
-    setLoading(stopToken?: string): void;
+    setLoading(stopToken?: StopToken): void;
     setMessage(messageText: string): void;
     setRendered(args?: {
         data: any;
@@ -103,6 +216,6 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     setAlpha(value: number): void;
     setMinAlignmentLength(value: number): void;
     setColorBy(value: string): void;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
 export type DotplotDisplayStateModel = ReturnType<typeof stateModelFactory>;
 export type DotplotDisplayModel = Instance<DotplotDisplayStateModel>;

package/esm/DotplotDisplay/stateModelFactory.js

@@ -3,9 +3,9 @@ import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
 import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes/models';
 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';
+import { types } from '@jbrowse/mobx-state-tree';
+import ServerSideRenderedBlockContent from "../ServerSideRenderedBlockContent.js";
+import { renderBlockData, renderBlockEffect } from "./renderDotplotBlock.js";
 export function stateModelFactory(configSchema) {
     return types
         .compose('DotplotDisplay', BaseDisplay, types
@@ -39,11 +39,7 @@ export function stateModelFactory(configSchema) {
             return {
                 ...getParentRenderProps(self),
                 rpcDriverName: self.rpcDriverName,
-                displayModel: self,
                 config: self.configuration.renderer,
-                statusCallback: (message) => {
-                    self.setMessage(message);
-                },
             };
         },
     }))
@@ -53,9 +49,10 @@ export function stateModelFactory(configSchema) {
             if (!props) {
                 return null;
             }
-            const { rendererType, rpcManager, renderProps } = props;
+            const { rendererType, rpcManager, renderProps, renderingProps } = props;
             const rendering = await rendererType.renderInClient(rpcManager, {
                 ...renderProps,
+                renderingProps,
                 exportSVG: opts,
                 theme: opts.theme || renderProps.theme,
             });
@@ -83,13 +80,7 @@ export function stateModelFactory(configSchema) {
             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) {

package/esm/DotplotReadVsRef/DotplotReadVsRef.js

@@ -3,11 +3,10 @@ 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');
-        const clipPos = getClip(cigar, 1);
+        const clipLengthAtStartOfRead = getClip(cigar, 1);
         const flags = feature.get('flags');
         const strand = feature.get('strand');
         const readName = feature.get('name');
@@ -17,7 +16,7 @@ export function onClick(feature, self) {
         const assemblyNames = [trackAssembly, readAssembly];
         const trackId = `track-${Date.now()}`;
         const trackName = `${readName}_vs_${trackAssembly}`;
-        const SA = (_a = feature.get('tags')) === null || _a === void 0 ? void 0 : _a.SA;
+        const SA = feature.get('tags')?.SA;
         const SA2 = featurizeSA(SA, feature.id(), strand, readName, true);
         const totalLength = getLength(flags & 2048 ? SA2[0].CIGAR : cigar);
         const features = [
@@ -26,12 +25,12 @@ export function onClick(feature, self) {
                 strand: 1,
                 mate: {
                     refName: readName,
-                    start: clipPos,
-                    end: clipPos + getLengthSansClipping(cigar),
+                    start: clipLengthAtStartOfRead,
+                    end: clipLengthAtStartOfRead + getLengthSansClipping(cigar),
                 },
             },
             ...SA2,
-        ].sort((a, b) => a.clipPos - b.clipPos);
+        ].sort((a, b) => a.clipLengthAtStartOfRead - b.clipLengthAtStartOfRead);
         session.addView('DotplotView', {
             type: 'DotplotView',
             hview: {

package/esm/DotplotReadVsRef/index.js

@@ -1,5 +1,5 @@
 import AddIcon from '@mui/icons-material/Add';
-import { onClick } from './DotplotReadVsRef';
+import { onClick } from "./DotplotReadVsRef.js";
 export default function DotplotReadVsRefMenuItem(pluginManager) {
     pluginManager.addToExtensionPoint('Core-extendPluggableElement', (pluggableElement) => {
         if (pluggableElement.name === 'LinearPileupDisplay') {