@jbrowse/plugin-dotplot-view 3.6.5 → 4.0.0

package/esm/DotplotDisplay/stateModelFactory.js

@@ -3,15 +3,16 @@ 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
         .model({
         type: types.literal('DotplotDisplay'),
         configuration: ConfigurationReference(configSchema),
+        colorBy: types.optional(types.string, 'default'),
     })
         .volatile(() => ({
         stopToken: undefined,
@@ -22,6 +23,8 @@ export function stateModelFactory(configSchema) {
         message: undefined,
         renderingComponent: undefined,
         ReactComponent2: ServerSideRenderedBlockContent,
+        alpha: 1,
+        minAlignmentLength: 0,
     })))
         .views(self => ({
         get shouldDisplay() {
@@ -36,7 +39,6 @@ export function stateModelFactory(configSchema) {
             return {
                 ...getParentRenderProps(self),
                 rpcDriverName: self.rpcDriverName,
-                displayModel: self,
                 config: self.configuration.renderer,
             };
         },
@@ -47,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,
             });
@@ -77,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) {
@@ -109,5 +106,14 @@ export function stateModelFactory(configSchema) {
             self.renderingComponent = undefined;
             self.stopToken = undefined;
         },
+        setAlpha(value) {
+            self.alpha = value;
+        },
+        setMinAlignmentLength(value) {
+            self.minAlignmentLength = value;
+        },
+        setColorBy(value) {
+            self.colorBy = value;
+        },
     }));
 }

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') {

package/esm/DotplotRenderer/DotplotRenderer.d.ts

@@ -1,8 +1,23 @@
-import ComparativeRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
-import type { Dotplot1DViewModel } from '../DotplotView/model';
+import ServerSideRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType';
+import type { Dotplot1DViewModel } from '../DotplotView/model.ts';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import type { RenderArgs, RenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
+import type { RenderArgs as ServerSideRenderArgs, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderArgsSerialized as ServerSideRenderArgsSerialized, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from '@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType';
+import type SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain';
+import type RpcManager from '@jbrowse/core/rpc/RpcManager';
 import type { Region } from '@jbrowse/core/util';
+export interface RenderArgs extends ServerSideRenderArgs {
+    blockKey: string;
+}
+export interface RenderArgsSerialized extends ServerSideRenderArgsSerialized {
+    blockKey: string;
+}
+export interface RenderArgsDeserialized extends ServerSideRenderArgsDeserialized {
+    blockKey: string;
+}
+export type ResultsSerialized = ServerSideResultsSerialized;
+export interface ResultsDeserialized extends ServerSideResultsDeserialized {
+    blockKey: string;
+}
 export interface DotplotRenderArgsDeserialized extends RenderArgsDeserialized {
     adapterConfig: AnyConfigurationModel;
     height: number;
@@ -13,7 +28,7 @@ export interface DotplotRenderArgsDeserialized extends RenderArgsDeserialized {
         vview: Dotplot1DViewModel;
     };
 }
-interface DotplotRenderArgs extends RenderArgs {
+export interface DotplotRenderArgs extends RenderArgs {
     adapterConfig: AnyConfigurationModel;
     sessionId: string;
     view: {
@@ -25,50 +40,17 @@ interface DotplotRenderArgs extends RenderArgs {
         };
     };
 }
-export default class DotplotRenderer extends ComparativeRenderer {
+export default class DotplotRenderer extends ServerSideRenderer {
     supportsSVG: boolean;
     renameRegionsIfNeeded(args: DotplotRenderArgs): Promise<DotplotRenderArgs>;
-    render(renderProps: DotplotRenderArgsDeserialized): Promise<{
-        height: number;
-        width: number;
-        offsetX: number;
-        offsetY: number;
-        bpPerPxX: number;
-        bpPerPxY: number;
-        warnings: {
-            message: string;
-            effect: string;
-        }[];
-        canvasRecordedData: Record<string, unknown>;
-        reactElement?: React.ReactElement;
-        html?: string;
-    } | {
-        height: number;
-        width: number;
-        offsetX: number;
-        offsetY: number;
-        bpPerPxX: number;
-        bpPerPxY: number;
-        warnings: {
-            message: string;
-            effect: string;
-        }[];
-        imageData: any;
-        reactElement?: React.ReactElement;
-        html?: string;
-    } | {
-        height: number;
-        width: number;
-        offsetX: number;
-        offsetY: number;
-        bpPerPxX: number;
-        bpPerPxY: number;
-        warnings: {
-            message: string;
-            effect: string;
-        }[];
-        reactElement: React.ReactElement;
-        html?: string;
-    }>;
+    serializeArgsInClient(args: RenderArgs): ServerSideRenderArgsSerialized;
+    deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
+    renderInClient(rpcManager: RpcManager, args: RenderArgs): Promise<ServerSideResultsSerialized>;
+    getFeatures(renderArgs: {
+        regions: Region[];
+        sessionId: string;
+        adapterConfig: AnyConfigurationModel;
+        filters?: SerializableFilterChain;
+    }): Promise<import("@jbrowse/core/util").Feature[]>;
+    render(renderProps: DotplotRenderArgsDeserialized): Promise<import("librpc-web-mod").RpcResult>;
 }
-export {};

package/esm/DotplotRenderer/DotplotRenderer.js

@@ -1,15 +1,26 @@
-import ComparativeRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
-import { renameRegionsIfNeeded, renderToAbstractCanvas, } from '@jbrowse/core/util';
-import { Dotplot1DView } from '../DotplotView/model';
-export default class DotplotRenderer extends ComparativeRenderer {
-    constructor() {
-        super(...arguments);
-        this.supportsSVG = true;
-    }
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import ServerSideRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType';
+import { dedupe, getSerializedSvg, renameRegionsIfNeeded, renderToAbstractCanvas, } from '@jbrowse/core/util';
+import { rpcResult } from '@jbrowse/core/util/librpc';
+import { collectTransferables } from '@jbrowse/core/util/offscreenCanvasPonyfill';
+import { firstValueFrom } from 'rxjs';
+import { filter, toArray } from 'rxjs/operators';
+import { Dotplot1DView } from "../DotplotView/model.js";
+function isCanvasRecordedSvgExport(e) {
+    return 'canvasRecordedData' in e;
+}
+function normalizeRegion(r) {
+    return {
+        ...r,
+        start: Math.floor(r.start),
+        end: Math.ceil(r.end),
+    };
+}
+export default class DotplotRenderer extends ServerSideRenderer {
+    supportsSVG = true;
     async renameRegionsIfNeeded(args) {
-        var _a, _b;
         const pm = this.pluginManager;
-        const assemblyManager = (_b = (_a = pm.rootModel) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.assemblyManager;
+        const assemblyManager = pm.rootModel?.session?.assemblyManager;
         const { view, sessionId, adapterConfig } = args;
         async function process(regions) {
             if (!assemblyManager) {
@@ -26,8 +37,36 @@ export default class DotplotRenderer extends ComparativeRenderer {
         view.vview.displayedRegions = await process(view.vview.displayedRegions);
         return args;
     }
+    serializeArgsInClient(args) {
+        const { displayModel, ...serializable } = args;
+        return super.serializeArgsInClient(serializable);
+    }
+    deserializeResultsInClient(result, args) {
+        return {
+            ...super.deserializeResultsInClient(result, args),
+            blockKey: args.blockKey,
+        };
+    }
+    async renderInClient(rpcManager, args) {
+        const results = (await rpcManager.call(args.sessionId, 'ComparativeRender', args));
+        if (isCanvasRecordedSvgExport(results)) {
+            const { reactElement: _, ...rest } = results;
+            return {
+                ...rest,
+                html: await getSerializedSvg(results),
+            };
+        }
+        return results;
+    }
+    async getFeatures(renderArgs) {
+        const { regions, sessionId, adapterConfig, filters } = renderArgs;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
+        const res = await firstValueFrom(dataAdapter
+            .getFeaturesInMultipleRegions(regions.map(r => normalizeRegion(r)), renderArgs)
+            .pipe(filter(f => (filters ? filters.passes(f, renderArgs) : true)), toArray()));
+        return dedupe(res, f => f.id());
+    }
     async render(renderProps) {
-        var _a, _b;
         const { width, height, view: { hview, vview }, } = renderProps;
         const dimensions = [width, height];
         const views = [hview, vview].map((snap, idx) => {
@@ -41,23 +80,17 @@ export default class DotplotRenderer extends ComparativeRenderer {
             regions: target.dynamicBlocks.contentBlocks,
         });
         target.setFeatures(feats);
-        const { drawDotplot } = await import('./drawDotplot');
+        const { drawDotplot } = await import("./drawDotplot.js");
         const ret = await renderToAbstractCanvas(width, height, renderProps, ctx => drawDotplot(ctx, { ...renderProps, views }));
-        const results = await super.render({
-            ...renderProps,
-            ...ret,
-            height,
-            width,
-        });
-        return {
-            ...results,
+        const serialized = {
             ...ret,
             height,
             width,
-            offsetX: ((_a = views[0].dynamicBlocks.blocks[0]) === null || _a === void 0 ? void 0 : _a.offsetPx) || 0,
-            offsetY: ((_b = views[1].dynamicBlocks.blocks[0]) === null || _b === void 0 ? void 0 : _b.offsetPx) || 0,
+            offsetX: views[0].dynamicBlocks.blocks[0]?.offsetPx || 0,
+            offsetY: views[1].dynamicBlocks.blocks[0]?.offsetPx || 0,
             bpPerPxX: views[0].bpPerPx,
             bpPerPxY: views[1].bpPerPx,
         };
+        return rpcResult(serialized, collectTransferables(ret));
     }
 }

package/esm/DotplotRenderer/clamp.d.ts

@@ -0,0 +1,7 @@
+import type { Feature } from '@jbrowse/core/util';
+export declare function clampWithWarnX(num: number, min: number, max: number, feature: Feature, warnings: Warning[]): number;
+export declare function clampWithWarnY(num: number, min: number, max: number, feature: Feature, warnings: Warning[]): number;
+export interface Warning {
+    message: string;
+    effect: string;
+}

package/esm/DotplotRenderer/clamp.js

@@ -0,0 +1,58 @@
+const r = 'fell outside of range due to CIGAR string';
+const lt = '(less than min coordinate of feature)';
+const gt = '(greater than max coordinate of feature)';
+const fudgeFactor = 1;
+export function clampWithWarnX(num, min, max, feature, warnings) {
+    const strand = feature.get('strand') || 1;
+    if (strand === -1) {
+        ;
+        [max, min] = [min, max];
+    }
+    if (num < min - fudgeFactor) {
+        let start = feature.get('start');
+        let end = feature.get('end');
+        const refName = feature.get('refName');
+        if (strand === -1) {
+            ;
+            [end, start] = [start, end];
+        }
+        warnings.push({
+            message: `feature at (X ${refName}:${start}-${end}) ${r} ${lt}`,
+            effect: 'clipped the feature',
+        });
+        return min;
+    }
+    if (num > max + fudgeFactor) {
+        const strand = feature.get('strand') || 1;
+        const start = strand === 1 ? feature.get('start') : feature.get('end');
+        const end = strand === 1 ? feature.get('end') : feature.get('start');
+        const refName = feature.get('refName');
+        warnings.push({
+            message: `feature at (X ${refName}:${start}-${end}) ${r} ${gt}`,
+            effect: 'clipped the feature',
+        });
+        return max;
+    }
+    return num;
+}
+export function clampWithWarnY(num, min, max, feature, warnings) {
+    if (num < min - fudgeFactor) {
+        const mate = feature.get('mate');
+        const { refName, start, end } = mate;
+        warnings.push({
+            message: `feature at (Y ${refName}:${start}-${end}) ${r} ${lt}`,
+            effect: 'clipped the feature',
+        });
+        return min;
+    }
+    if (num > max + fudgeFactor) {
+        const mate = feature.get('mate');
+        const { refName, start, end } = mate;
+        warnings.push({
+            message: `feature at (Y ${refName}:${start}-${end}) ${r} ${gt}`,
+            effect: 'clipped the feature',
+        });
+        return max;
+    }
+    return num;
+}

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

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

package/esm/DotplotRenderer/components/DotplotRendering.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { PrerenderedCanvas } from '@jbrowse/core/ui';
 import { observer } from 'mobx-react';
-const DotplotRendering = observer(function (props) {
+const DotplotRendering = observer(function DotplotRendering(props) {
     return _jsx(PrerenderedCanvas, { ...props });
 });
 export default DotplotRendering;

package/esm/DotplotRenderer/configSchema.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+declare const _default: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{
     color: {
         type: string;
         description: string;
@@ -22,7 +22,7 @@ declare const _default: import("@jbrowse/core/configuration/configurationSchema"
     };
     colorBy: {
         type: string;
-        model: import("mobx-state-tree").ISimpleType<string>;
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
         description: string;
         defaultValue: string;
     };
@@ -36,5 +36,5 @@ declare const _default: import("@jbrowse/core/configuration/configurationSchema"
         defaultValue: string[];
         description: string;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default _default;

package/esm/DotplotRenderer/configSchema.js

@@ -1,5 +1,5 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { types } from 'mobx-state-tree';
+import { types } from '@jbrowse/mobx-state-tree';
 function x() { }
 export default ConfigurationSchema('DotplotRenderer', {
     color: {

package/esm/DotplotRenderer/drawDotplot.d.ts

@@ -1,11 +1,15 @@
-import type { Dotplot1DViewModel } from '../DotplotView/model';
+import { type Warning } from './clamp.ts';
+import type { RenderArgsDeserialized } from './DotplotRenderer.ts';
+import type { Dotplot1DViewModel } from '../DotplotView/model.ts';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
-import type { RenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
 export interface DotplotRenderArgsDeserialized extends RenderArgsDeserialized {
     adapterConfig: AnyConfigurationModel;
     height: number;
     width: number;
     highResolutionScaling: number;
+    alpha?: number;
+    minAlignmentLength?: number;
+    colorBy?: string;
     view: {
         hview: Dotplot1DViewModel;
         vview: Dotplot1DViewModel;
@@ -14,8 +18,5 @@ export interface DotplotRenderArgsDeserialized extends RenderArgsDeserialized {
 export declare function drawDotplot(ctx: CanvasRenderingContext2D, props: DotplotRenderArgsDeserialized & {
     views: Dotplot1DViewModel[];
 }): Promise<{
-    warnings: {
-        message: string;
-        effect: string;
-    }[];
+    warnings: Warning[];
 }>;