@jbrowse/plugin-dotplot-view 3.7.0 → 4.0.1

package/dist/ComparativeRenderer/index.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const RpcMethodType_1 = __importDefault(require("@jbrowse/core/pluggableElementTypes/RpcMethodType"));
-const stopToken_1 = require("@jbrowse/core/util/stopToken");
-class ComparativeRender extends RpcMethodType_1.default {
-    constructor() {
-        super(...arguments);
-        this.name = 'ComparativeRender';
-    }
-    async renameRegionsIfNeeded(args, rend) {
-        return rend.renameRegionsIfNeeded(args);
-    }
-    getRenderer(rendererType) {
-        const pm = this.pluginManager;
-        return pm.getRendererType(rendererType);
-    }
-    async serializeArguments(args, rpcDriver) {
-        const { rendererType } = args;
-        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);
-    }
-    async execute(args, rpcDriver) {
-        let deserializedArgs = args;
-        if (rpcDriver !== 'MainThreadRpcDriver') {
-            deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        }
-        const { sessionId, rendererType, stopToken } = deserializedArgs;
-        if (!sessionId) {
-            throw new Error('must pass a unique session id');
-        }
-        (0, stopToken_1.checkStopToken)(stopToken);
-        const renderer = this.getRenderer(rendererType);
-        return rpcDriver === 'MainThreadRpcDriver'
-            ? renderer.render(deserializedArgs)
-            : 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);
-    }
-}
-exports.default = ComparativeRender;

package/dist/DiagonalizeDotplotRpc.d.ts

@@ -1,30 +0,0 @@
-import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
-import type { Region } from '@jbrowse/core/util';
-interface DiagonalizationResult {
-    newRegions: Region[];
-    stats: {
-        totalAlignments: number;
-        regionsProcessed: number;
-        regionsReordered: number;
-        regionsReversed: number;
-    };
-}
-interface DiagonalizeDotplotArgs {
-    sessionId: string;
-    view: {
-        hview: {
-            displayedRegions: Region[];
-        };
-        vview: {
-            displayedRegions: Region[];
-        };
-    };
-    adapterConfig: Record<string, unknown>;
-    stopToken?: string;
-    statusCallback?: (message: string) => void;
-}
-export default class DiagonalizeDotplotRpc extends RpcMethodTypeWithFiltersAndRenameRegions {
-    name: string;
-    execute(args: DiagonalizeDotplotArgs, rpcDriverClassName: string): Promise<DiagonalizationResult>;
-}
-export {};

package/dist/DiagonalizeDotplotRpc.js

@@ -1,156 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const RpcMethodTypeWithFiltersAndRenameRegions_1 = __importDefault(require("@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions"));
-const stopToken_1 = require("@jbrowse/core/util/stopToken");
-const model_1 = require("./DotplotView/model");
-async function diagonalizeRegions(alignments, currentRegions, progressCallback) {
-    const updateProgress = (progress, message) => {
-        if (progressCallback) {
-            progressCallback(progress, message);
-        }
-    };
-    updateProgress(20, `Grouping ${alignments.length} alignments...`);
-    const queryGroups = new Map();
-    for (const aln of alignments) {
-        const targetRefName = aln.refRefName;
-        if (!queryGroups.has(targetRefName)) {
-            queryGroups.set(targetRefName, {
-                refAlignments: new Map(),
-                strandWeightedSum: 0,
-            });
-        }
-        const group = queryGroups.get(targetRefName);
-        const alnLength = Math.abs(aln.queryEnd - aln.queryStart);
-        if (!group.refAlignments.has(aln.queryRefName)) {
-            group.refAlignments.set(aln.queryRefName, {
-                bases: 0,
-                positions: [],
-            });
-        }
-        const refData = group.refAlignments.get(aln.queryRefName);
-        refData.bases += alnLength;
-        refData.positions.push((aln.queryStart + aln.queryEnd) / 2);
-        const direction = aln.strand >= 0 ? 1 : -1;
-        group.strandWeightedSum += direction * alnLength;
-    }
-    updateProgress(50, 'Determining optimal ordering and orientation...');
-    const queryOrdering = [];
-    for (const [targetRefName, group] of queryGroups) {
-        let bestRefName = '';
-        let maxBases = 0;
-        let bestPositions = [];
-        for (const [firstViewRefName, data] of group.refAlignments) {
-            if (data.bases > maxBases) {
-                maxBases = data.bases;
-                bestRefName = firstViewRefName;
-                bestPositions = data.positions;
-            }
-        }
-        const bestRefPos = bestPositions.reduce((a, b) => a + b, 0) / bestPositions.length;
-        const shouldReverse = group.strandWeightedSum < 0;
-        queryOrdering.push({
-            refName: targetRefName,
-            bestRefName,
-            bestRefPos,
-            shouldReverse,
-        });
-    }
-    updateProgress(70, `Sorting ${queryOrdering.length} query regions...`);
-    queryOrdering.sort((a, b) => {
-        if (a.bestRefName !== b.bestRefName) {
-            return a.bestRefName.localeCompare(b.bestRefName);
-        }
-        return a.bestRefPos - b.bestRefPos;
-    });
-    updateProgress(85, 'Building new region layout...');
-    const newQueryRegions = [];
-    let regionsReversed = 0;
-    for (const { refName, shouldReverse } of queryOrdering) {
-        const region = currentRegions.find(r => r.refName === refName);
-        if (region) {
-            newQueryRegions.push({
-                ...region,
-                reversed: shouldReverse,
-            });
-            if (shouldReverse !== region.reversed) {
-                regionsReversed++;
-            }
-        }
-    }
-    const regionsWithoutAlignments = currentRegions.filter(r => !newQueryRegions.some(nr => nr.refName === r.refName));
-    updateProgress(100, 'Diagonalization complete!');
-    return {
-        newRegions: [...newQueryRegions, ...regionsWithoutAlignments],
-        stats: {
-            totalAlignments: alignments.length,
-            regionsProcessed: queryOrdering.length,
-            regionsReordered: newQueryRegions.length,
-            regionsReversed,
-        },
-    };
-}
-class DiagonalizeDotplotRpc extends RpcMethodTypeWithFiltersAndRenameRegions_1.default {
-    constructor() {
-        super(...arguments);
-        this.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...');
-        const dimensions = [800, 800];
-        const views = [view.hview, view.vview].map((snap, idx) => {
-            const v = model_1.Dotplot1DView.create(snap);
-            v.setVolatileWidth(dimensions[idx]);
-            return v;
-        });
-        const targetView = views[0];
-        (0, stopToken_1.checkStopToken)(stopToken);
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Getting renderer...');
-        const rendererType = this.pluginManager.getRendererType('DotplotRenderer');
-        if (!rendererType) {
-            throw new Error('DotplotRenderer not found');
-        }
-        (0, stopToken_1.checkStopToken)(stopToken);
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Fetching features...');
-        const feats = await rendererType.getFeatures({
-            regions: targetView.dynamicBlocks.contentBlocks,
-            adapterConfig,
-            sessionId,
-        });
-        (0, stopToken_1.checkStopToken)(stopToken);
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Extracting alignment data...');
-        const alignments = [];
-        for (const feat of feats.values()) {
-            const mate = feat.get('mate');
-            if (mate) {
-                alignments.push({
-                    queryRefName: feat.get('refName'),
-                    refRefName: mate.refName,
-                    queryStart: feat.get('start'),
-                    queryEnd: feat.get('end'),
-                    refStart: mate.start,
-                    refEnd: mate.end,
-                    strand: feat.get('strand') || 1,
-                });
-            }
-        }
-        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...`);
-        const result = await diagonalizeRegions(alignments, view.vview.displayedRegions, (progress, message) => {
-            (0, stopToken_1.checkStopToken)(stopToken);
-            statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback(message);
-        });
-        statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback('Diagonalization complete!');
-        return result;
-    }
-}
-exports.default = DiagonalizeDotplotRpc;

package/dist/DotplotDisplay/components/DotplotDisplay.d.ts

@@ -1,6 +0,0 @@
-import type { DotplotDisplayModel } from '../stateModelFactory';
-declare const DotplotDisplay: (props: {
-    model: DotplotDisplayModel;
-    children?: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
-export default DotplotDisplay;

package/dist/DotplotDisplay/components/DotplotDisplay.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsx_runtime_1 = require("react/jsx-runtime");
-const util_1 = require("@jbrowse/core/util");
-const mobx_react_1 = require("mobx-react");
-const DotplotDisplay = (0, mobx_react_1.observer)(function DotplotDisplay(props) {
-    const { model, children } = props;
-    const { offsetX = 0, offsetY = 0 } = model.data || {};
-    const view = (0, util_1.getContainingView)(model);
-    const top = view.vview.offsetPx - offsetY;
-    const left = -(view.hview.offsetPx - offsetX);
-    return ((0, jsx_runtime_1.jsxs)("div", { style: { position: 'relative' }, children: [(0, jsx_runtime_1.jsx)(model.ReactComponent2, { ...props, style: {
-                    position: 'absolute',
-                    top,
-                    left,
-                } }), children] }));
-});
-exports.default = DotplotDisplay;

package/dist/DotplotDisplay/index.d.ts

@@ -1,5 +0,0 @@
-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">>;

package/dist/DotplotDisplay/index.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = DotplotDisplayF;
-exports.configSchemaFactory = configSchemaFactory;
-const configuration_1 = require("@jbrowse/core/configuration");
-const DisplayType_1 = __importDefault(require("@jbrowse/core/pluggableElementTypes/DisplayType"));
-const mobx_state_tree_1 = require("mobx-state-tree");
-const DotplotDisplay_1 = __importDefault(require("./components/DotplotDisplay"));
-const stateModelFactory_1 = require("./stateModelFactory");
-function DotplotDisplayF(pm) {
-    pm.addDisplayType(() => {
-        const configSchema = configSchemaFactory(pm);
-        return new DisplayType_1.default({
-            name: 'DotplotDisplay',
-            displayName: 'Dotplot display',
-            configSchema,
-            stateModel: (0, stateModelFactory_1.stateModelFactory)(configSchema),
-            trackType: 'SyntenyTrack',
-            viewType: 'DotplotView',
-            ReactComponent: DotplotDisplay_1.default,
-        });
-    });
-}
-function configSchemaFactory(pm) {
-    return (0, configuration_1.ConfigurationSchema)('DotplotDisplay', {
-        renderer: mobx_state_tree_1.types.optional(pm.pluggableConfigSchemaType('renderer'), {
-            type: 'DotplotRenderer',
-        }),
-    }, {
-        explicitIdentifier: 'displayId',
-        explicitlyTyped: true,
-    });
-}

package/dist/DotplotDisplay/renderDotplotBlock.d.ts

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

package/dist/DotplotDisplay/renderDotplotBlock.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderBlockData = renderBlockData;
-exports.renderBlockEffect = renderBlockEffect;
-const configuration_1 = require("@jbrowse/core/configuration");
-const util_1 = require("@jbrowse/core/util");
-const tracks_1 = require("@jbrowse/core/util/tracks");
-const mobx_state_tree_1 = require("mobx-state-tree");
-function renderBlockData(self) {
-    const { rpcManager } = (0, util_1.getSession)(self);
-    const { rendererType } = self;
-    const { adapterConfig } = self;
-    const parent = (0, util_1.getContainingView)(self);
-    (0, configuration_1.readConfObject)(self.configuration);
-    (0, mobx_state_tree_1.getSnapshot)(parent);
-    if (parent.initialized) {
-        const { viewWidth, viewHeight, borderSize, borderX, borderY } = parent;
-        return {
-            rendererType,
-            rpcManager,
-            renderProps: {
-                ...self.renderProps(),
-                view: structuredClone((0, mobx_state_tree_1.getSnapshot)(parent)),
-                width: viewWidth,
-                height: viewHeight,
-                borderSize,
-                borderX,
-                borderY,
-                adapterConfig,
-                rendererType: rendererType.name,
-                sessionId: (0, tracks_1.getRpcSessionId)(self),
-                timeout: 1000000,
-                alpha: self.alpha,
-                minAlignmentLength: self.minAlignmentLength,
-                colorBy: self.colorBy,
-            },
-        };
-    }
-    return undefined;
-}
-async function renderBlockEffect(props) {
-    if (!props) {
-        return;
-    }
-    const { rendererType, rpcManager, renderProps } = props;
-    const { reactElement, ...data } = await rendererType.renderInClient(rpcManager, renderProps);
-    return {
-        reactElement,
-        data,
-        renderingComponent: rendererType.ReactComponent,
-    };
-}

package/dist/DotplotDisplay/stateModelFactory.d.ts

@@ -1,108 +0,0 @@
-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>>;
-} & {
-    type: import("mobx-state-tree").ISimpleType<"DotplotDisplay">;
-    configuration: AnyConfigurationSchemaType;
-    colorBy: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-}, {
-    rendererTypeName: string;
-    error: unknown;
-    message: string | undefined;
-} & {
-    readonly RenderingComponent: React.FC<{
-        model: {
-            id: string;
-            type: string;
-            rpcDriverName: string | undefined;
-        } & import("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>>;
-        }, {
-            rendererTypeName: string;
-            error: unknown;
-            message: string | undefined;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-        onHorizontalScroll?: () => void;
-        blockState?: Record<string, any>;
-    }>;
-    readonly DisplayBlurb: React.FC<{
-        model: {
-            id: string;
-            type: string;
-            rpcDriverName: string | undefined;
-        } & import("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>>;
-        }, {
-            rendererTypeName: string;
-            error: unknown;
-            message: string | undefined;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-    }> | null;
-    readonly adapterConfig: any;
-    readonly parentTrack: any;
-    renderProps(): any;
-    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;
-    setError(error?: unknown): void;
-    setRpcDriverName(rpcDriverName: string): void;
-    reload(): void;
-} & {
-    stopToken: string | undefined;
-    warnings: {
-        message: string;
-        effect: string;
-    }[];
-    filled: boolean;
-    data: any;
-    reactElement: React.ReactElement | undefined;
-    message: string | undefined;
-    renderingComponent: any;
-    ReactComponent2: React.FC<any>;
-    alpha: number;
-    minAlignmentLength: number;
-} & {
-    readonly shouldDisplay: boolean;
-    readonly rendererTypeName: any;
-    renderProps(): any;
-} & {
-    renderSvg(opts: ExportSvgOptions & {
-        theme?: ThemeOptions;
-    }): Promise<import("react/jsx-runtime").JSX.Element | null>;
-} & {
-    afterAttach(): void;
-    setLoading(stopToken?: string): void;
-    setMessage(messageText: string): void;
-    setRendered(args?: {
-        data: any;
-        reactElement: React.ReactElement;
-        renderingComponent: React.Component;
-    }): void;
-    setError(error: unknown): void;
-    setAlpha(value: number): void;
-    setMinAlignmentLength(value: number): void;
-    setColorBy(value: string): void;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export type DotplotDisplayStateModel = ReturnType<typeof stateModelFactory>;
-export type DotplotDisplayModel = Instance<DotplotDisplayStateModel>;

package/dist/DotplotDisplay/stateModelFactory.js

@@ -1,134 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stateModelFactory = stateModelFactory;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const configuration_1 = require("@jbrowse/core/configuration");
-const models_1 = require("@jbrowse/core/pluggableElementTypes/models");
-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 ServerSideRenderedBlockContent_1 = __importDefault(require("../ServerSideRenderedBlockContent"));
-const renderDotplotBlock_1 = require("./renderDotplotBlock");
-function stateModelFactory(configSchema) {
-    return mobx_state_tree_1.types
-        .compose('DotplotDisplay', models_1.BaseDisplay, mobx_state_tree_1.types
-        .model({
-        type: mobx_state_tree_1.types.literal('DotplotDisplay'),
-        configuration: (0, configuration_1.ConfigurationReference)(configSchema),
-        colorBy: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.string, 'default'),
-    })
-        .volatile(() => ({
-        stopToken: undefined,
-        warnings: [],
-        filled: false,
-        data: undefined,
-        reactElement: undefined,
-        message: undefined,
-        renderingComponent: undefined,
-        ReactComponent2: ServerSideRenderedBlockContent_1.default,
-        alpha: 1,
-        minAlignmentLength: 0,
-    })))
-        .views(self => ({
-        get shouldDisplay() {
-            const { vview, hview } = (0, util_1.getContainingView)(self);
-            return (vview.bpPerPx === self.data.bpPerPxY &&
-                hview.bpPerPx === self.data.bpPerPxX);
-        },
-        get rendererTypeName() {
-            return (0, configuration_1.getConf)(self, ['renderer', 'type']);
-        },
-        renderProps() {
-            return {
-                ...(0, tracks_1.getParentRenderProps)(self),
-                rpcDriverName: self.rpcDriverName,
-                displayModel: self,
-                config: self.configuration.renderer,
-                statusCallback: (message) => {
-                    self.setMessage(message);
-                },
-            };
-        },
-    }))
-        .views(self => ({
-        async renderSvg(opts) {
-            const props = (0, renderDotplotBlock_1.renderBlockData)(self);
-            if (!props) {
-                return null;
-            }
-            const { rendererType, rpcManager, renderProps } = props;
-            const rendering = await rendererType.renderInClient(rpcManager, {
-                ...renderProps,
-                exportSVG: opts,
-                theme: opts.theme || renderProps.theme,
-            });
-            const { hview, vview } = (0, util_1.getContainingView)(self);
-            const offX = -hview.offsetPx + rendering.offsetX;
-            const offY = -vview.offsetPx + rendering.offsetY;
-            return ((0, jsx_runtime_1.jsx)("g", { transform: `translate(${offX} ${-offY})`, children: (0, jsx_runtime_1.jsx)(util_1.ReactRendering, { rendering: rendering }) }));
-        },
-    }))
-        .actions(self => ({
-        afterAttach() {
-            (0, util_1.makeAbortableReaction)(self, () => (0, renderDotplotBlock_1.renderBlockData)(self), blockData => (0, renderDotplotBlock_1.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;
-        },
-        setAlpha(value) {
-            self.alpha = value;
-        },
-        setMinAlignmentLength(value) {
-            self.minAlignmentLength = value;
-        },
-        setColorBy(value) {
-            self.colorBy = value;
-        },
-    }));
-}

package/dist/DotplotReadVsRef/DotplotReadVsRef.d.ts

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