@jbrowse/plugin-arc 2.7.1 → 2.8.0

package/dist/LinearPairedArcDisplay/afterAttach.d.ts

@@ -0,0 +1,2 @@
+import { IAnyStateTreeNode } from 'mobx-state-tree';
+export declare function doAfterAttach<T extends IAnyStateTreeNode>(self: T): void;

package/dist/LinearPairedArcDisplay/afterAttach.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doAfterAttach = void 0;
+const util_1 = require("./util");
+const fetchChains_1 = require("./fetchChains");
+function doAfterAttach(self) {
+    (0, util_1.createAutorun)(self, async () => {
+        await (0, fetchChains_1.fetchChains)(self);
+    }, { delay: 1000 });
+}
+exports.doAfterAttach = doAfterAttach;

package/dist/LinearPairedArcDisplay/components/Arcs.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { LinearArcDisplayModel } from '../model';
+declare const Arcs: ({ model, exportSVG, }: {
+    model: LinearArcDisplayModel;
+    exportSVG?: boolean | undefined;
+}) => React.JSX.Element | null;
+export default Arcs;

package/dist/LinearPairedArcDisplay/components/Arcs.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const mobx_react_1 = require("mobx-react");
+const util_1 = require("@jbrowse/core/util");
+const configuration_1 = require("@jbrowse/core/configuration");
+const vcf_1 = require("@gmod/vcf");
+const react_svg_tooltip_1 = require("react-svg-tooltip");
+function f(feature, alt) {
+    var _a, _b, _c, _d, _e;
+    const bnd = alt ? (0, vcf_1.parseBreakend)(alt) : undefined;
+    let start = feature.get('start');
+    let end = feature.get('end');
+    const strand = feature.get('strand');
+    const mate = feature.get('mate');
+    const refName = feature.get('refName');
+    let mateRefName;
+    let mateEnd = 0;
+    let mateStart = 0;
+    // one sided bracket used, because there could be <INS:ME> and we just check
+    // startswith below
+    const symbolicAlleles = ['<TRA', '<DEL', '<INV', '<INS', '<DUP', '<CNV'];
+    if (symbolicAlleles.some(a => alt === null || alt === void 0 ? void 0 : alt.startsWith(a))) {
+        // END is defined to be a single value, not an array. CHR2 not defined in
+        // VCF spec, but should be similar
+        const e = ((_b = (_a = feature.get('INFO')) === null || _a === void 0 ? void 0 : _a.END) === null || _b === void 0 ? void 0 : _b[0]) || feature.get('end');
+        mateEnd = e;
+        mateStart = e - 1;
+        mateRefName = (_e = (_d = (_c = feature.get('INFO')) === null || _c === void 0 ? void 0 : _c.CHR2) === null || _d === void 0 ? void 0 : _d[0]) !== null && _e !== void 0 ? _e : refName;
+        // re-adjust the arc to be from start to end of feature by re-assigning end
+        // to the 'mate'
+        start = feature.get('start');
+        end = feature.get('start') + 1;
+    }
+    else if (bnd === null || bnd === void 0 ? void 0 : bnd.MatePosition) {
+        const matePosition = bnd.MatePosition.split(':');
+        mateEnd = +matePosition[1];
+        mateStart = +matePosition[1] - 1;
+        mateRefName = matePosition[0];
+    }
+    return {
+        k1: { refName, start, end, strand },
+        k2: mate !== null && mate !== void 0 ? mate : { refName: mateRefName, end: mateEnd, start: mateStart },
+    };
+}
+function makeSummary(feature, alt) {
+    var _a;
+    const { k1, k2 } = f(feature, alt);
+    return [
+        feature.get('name'),
+        feature.get('id'),
+        (0, util_1.assembleLocString)(k1),
+        (0, util_1.assembleLocString)(k2),
+        (_a = feature.get('INFO')) === null || _a === void 0 ? void 0 : _a.SVTYPE,
+        alt,
+    ]
+        .filter(f => !!f)
+        .join(' - ');
+}
+// conditionally rendered tooltip only on mouseover, speeds up
+const SvgTooltip = react_1.default.forwardRef(function SvgTooltip2({ feature, alt }, ref) {
+    const caption = makeSummary(feature, alt);
+    const tooltipWidth = 20 + (0, util_1.measureText)(caption);
+    return ref !== null ? (
+    // @ts-expect-error
+    react_1.default.createElement(react_svg_tooltip_1.Tooltip, { triggerRef: ref },
+        react_1.default.createElement("rect", { x: 12, y: 0, width: tooltipWidth, height: 20, rx: 5, ry: 5, fill: "black", fillOpacity: "50%" }),
+        react_1.default.createElement("text", { x: 22, y: 14, fontSize: 10, fill: "white", textLength: tooltipWidth - 20 }, caption))) : null;
+});
+const Arc = (0, mobx_react_1.observer)(function ({ model, feature, alt, assembly, view, }) {
+    var _a, _b;
+    const [mouseOvered, setMouseOvered] = (0, react_1.useState)(false);
+    const { height } = model;
+    const { k1, k2 } = f(feature, alt);
+    const ref = (0, react_1.useRef)(null);
+    const c = (0, configuration_1.getConf)(model, 'color', { feature, alt });
+    const ra1 = assembly.getCanonicalRefName(k1.refName) || k1.refName;
+    const ra2 = assembly.getCanonicalRefName(k2.refName) || k2.refName;
+    const p1 = k1.start;
+    const p2 = k2.start;
+    const r1 = (_a = view.bpToPx({ refName: ra1, coord: p1 })) === null || _a === void 0 ? void 0 : _a.offsetPx;
+    const r2 = (_b = view.bpToPx({ refName: ra2, coord: p2 })) === null || _b === void 0 ? void 0 : _b.offsetPx;
+    if (r1 !== undefined && r2 !== undefined) {
+        const radius = (r2 - r1) / 2;
+        const absrad = Math.abs(radius);
+        const destY = Math.min(height, absrad);
+        const p1 = r1 - view.offsetPx;
+        const p2 = r2 - view.offsetPx;
+        const left = p1;
+        const right = p2;
+        return absrad > 1 ? (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement("path", { d: `M ${left} 0 C ${left} ${destY}, ${right} ${destY}, ${right} 0`, ref: ref, stroke: mouseOvered ? 'black' : c, strokeWidth: 3, onMouseOut: () => setMouseOvered(false), onMouseOver: () => setMouseOvered(true), onClick: () => model.selectFeature(feature), fill: "none", pointerEvents: "stroke" }),
+            mouseOvered ? (react_1.default.createElement(SvgTooltip, { feature: feature, alt: alt, ref: ref })) : null)) : null;
+    }
+    return null;
+});
+const Wrapper = (0, mobx_react_1.observer)(function ({ model, exportSVG, children, }) {
+    const { height } = model;
+    const view = (0, util_1.getContainingView)(model);
+    const width = Math.round(view.dynamicBlocks.totalWidthPx);
+    return exportSVG ? (react_1.default.createElement(react_1.default.Fragment, null, children)) : (react_1.default.createElement("svg", { width: width, height: height }, children));
+});
+const Arcs = (0, mobx_react_1.observer)(function ({ model, exportSVG, }) {
+    const view = (0, util_1.getContainingView)(model);
+    const session = (0, util_1.getSession)(model);
+    const { assemblyManager } = session;
+    const { features } = model;
+    const assembly = assemblyManager.get(view.assemblyNames[0]);
+    return assembly ? (react_1.default.createElement(Wrapper, { model: model, exportSVG: exportSVG }, features === null || features === void 0 ? void 0 : features.map(f => {
+        var _a;
+        const alts = f.get('ALT');
+        return ((_a = alts === null || alts === void 0 ? void 0 : alts.map(a => (react_1.default.createElement(Arc, { key: f.id() + '-' + a, session: session, feature: f, alt: a, view: view, model: model, assembly: assembly })))) !== null && _a !== void 0 ? _a : (react_1.default.createElement(Arc, { key: f.id(), session: session, feature: f, view: view, model: model, assembly: assembly })));
+    }))) : null;
+});
+exports.default = Arcs;

package/dist/LinearPairedArcDisplay/components/BaseDisplayComponent.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { LinearArcDisplayModel } from '../model';
+declare const BaseDisplayComponent: ({ model, children, }: {
+    model: LinearArcDisplayModel;
+    children?: React.ReactNode;
+}) => React.JSX.Element | null;
+export default BaseDisplayComponent;

package/dist/LinearPairedArcDisplay/components/BaseDisplayComponent.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const ui_1 = require("@jbrowse/core/ui");
+const plugin_linear_genome_view_1 = require("@jbrowse/plugin-linear-genome-view");
+const mui_1 = require("tss-react/mui");
+const mobx_react_1 = require("mobx-react");
+const useStyles = (0, mui_1.makeStyles)()(theme => ({
+    loading: {
+        backgroundColor: theme.palette.background.default,
+        backgroundImage: `repeating-linear-gradient(45deg, transparent, transparent 5px, ${theme.palette.action.disabledBackground} 5px, ${theme.palette.action.disabledBackground} 10px)`,
+        position: 'absolute',
+        bottom: 0,
+        height: 50,
+        width: 300,
+        right: 0,
+        pointerEvents: 'none',
+        textAlign: 'center',
+    },
+}));
+const BaseDisplayComponent = (0, mobx_react_1.observer)(function ({ model, children, }) {
+    const { error, regionTooLarge } = model;
+    return error ? (react_1.default.createElement(plugin_linear_genome_view_1.BlockMsg, { message: `${error}`, severity: "error", buttonText: "Reload", action: model.reload })) : regionTooLarge ? (model.regionCannotBeRendered()) : (react_1.default.createElement(DataDisplay, { model: model }, children));
+});
+const DataDisplay = (0, mobx_react_1.observer)(function ({ model, children, }) {
+    const { loading } = model;
+    return (react_1.default.createElement("div", null,
+        children,
+        loading ? react_1.default.createElement(LoadingBar, { model: model }) : null));
+});
+const LoadingBar = (0, mobx_react_1.observer)(function ({ model, }) {
+    const { classes } = useStyles();
+    const { message } = model;
+    return (react_1.default.createElement("div", { className: classes.loading },
+        react_1.default.createElement(ui_1.LoadingEllipses, { message: message })));
+});
+exports.default = BaseDisplayComponent;

package/dist/LinearPairedArcDisplay/components/ReactComponent.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { LinearArcDisplayModel } from '../model';
+declare const LinearArcReactComponent: ({ model, exportSVG, }: {
+    model: LinearArcDisplayModel;
+    exportSVG?: boolean | undefined;
+}) => React.JSX.Element;
+export default LinearArcReactComponent;

package/dist/LinearPairedArcDisplay/components/ReactComponent.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const mobx_react_1 = require("mobx-react");
+const BaseDisplayComponent_1 = __importDefault(require("./BaseDisplayComponent"));
+const Arcs_1 = __importDefault(require("./Arcs"));
+const LinearArcReactComponent = (0, mobx_react_1.observer)(function ({ model, exportSVG, }) {
+    return (react_1.default.createElement(BaseDisplayComponent_1.default, { model: model },
+        react_1.default.createElement(Arcs_1.default, { model: model, exportSVG: exportSVG })));
+});
+exports.default = LinearArcReactComponent;

package/dist/LinearPairedArcDisplay/configSchema.d.ts

@@ -0,0 +1,36 @@
+/**
+ * #config LinearPairedArcDisplay
+ */
+export declare function configSchemaFactory(): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    /**
+     * #slot
+     */
+    color: {
+        type: string;
+        description: string;
+        defaultValue: string;
+        contextVariable: string[];
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    maxFeatureScreenDensity: {
+        type: string;
+        description: string;
+        defaultValue: number;
+    };
+    fetchSizeLimit: {
+        type: string;
+        defaultValue: number;
+        description: string;
+    };
+    height: {
+        type: string;
+        defaultValue: number;
+        description: string;
+    };
+    mouseover: {
+        type: string;
+        description: string;
+        defaultValue: string;
+        contextVariable: string[];
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "displayId">>, undefined>>;

package/dist/LinearPairedArcDisplay/configSchema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchemaFactory = void 0;
+const configuration_1 = require("@jbrowse/core/configuration");
+const plugin_linear_genome_view_1 = require("@jbrowse/plugin-linear-genome-view");
+/**
+ * #config LinearPairedArcDisplay
+ */
+function configSchemaFactory() {
+    return (0, configuration_1.ConfigurationSchema)('LinearPairedArcDisplay', {
+        /**
+         * #slot
+         */
+        color: {
+            type: 'color',
+            description: 'the color of the arcs',
+            defaultValue: 'jexl:defaultPairedArcColor(feature,alt)',
+            contextVariable: ['feature', 'alt'],
+        },
+    }, {
+        /**
+         * #baseConfiguration
+         */
+        baseConfiguration: plugin_linear_genome_view_1.baseLinearDisplayConfigSchema,
+        explicitlyTyped: true,
+    });
+}
+exports.configSchemaFactory = configSchemaFactory;

package/dist/LinearPairedArcDisplay/fetchChains.d.ts

@@ -0,0 +1,27 @@
+import { LinearArcDisplayModel } from './model';
+export interface ReducedFeature {
+    name: string;
+    strand: number;
+    refName: string;
+    start: number;
+    end: number;
+    id: string;
+    flags: number;
+    tlen: number;
+    pair_orientation: string;
+    next_ref?: string;
+    next_pos?: number;
+    clipPos: number;
+    SA?: string;
+}
+export interface ChainStats {
+    max: number;
+    min: number;
+    upper: number;
+    lower: number;
+}
+export interface ChainData {
+    chains: ReducedFeature[][];
+    stats?: ChainStats;
+}
+export declare function fetchChains(self: LinearArcDisplayModel): Promise<void>;

package/dist/LinearPairedArcDisplay/fetchChains.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchChains = void 0;
+const util_1 = require("@jbrowse/core/util");
+async function fetchChains(self) {
+    // @ts-expect-error
+    const { rpcSessionId: sessionId } = (0, util_1.getContainingTrack)(self);
+    const { rpcManager } = (0, util_1.getSession)(self);
+    const view = (0, util_1.getContainingView)(self);
+    if (!view.initialized || self.error || self.regionTooLarge) {
+        return;
+    }
+    self.setLoading(true);
+    const ret = (await rpcManager.call(sessionId, 'CoreGetFeatures', {
+        sessionId,
+        regions: view.staticBlocks.contentBlocks,
+        adapterConfig: self.adapterConfig,
+    }));
+    self.setFeatures(ret);
+    self.setLoading(false);
+}
+exports.fetchChains = fetchChains;

package/dist/LinearPairedArcDisplay/index.d.ts

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

package/dist/LinearPairedArcDisplay/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluggableElementTypes_1 = require("@jbrowse/core/pluggableElementTypes");
+const configSchema_1 = require("./configSchema");
+const model_1 = require("./model");
+const react_1 = require("react");
+function LinearPairedArcDisplayF(pluginManager) {
+    pluginManager.addDisplayType(() => {
+        const configSchema = (0, configSchema_1.configSchemaFactory)();
+        return new pluggableElementTypes_1.DisplayType({
+            name: 'LinearPairedArcDisplay',
+            displayName: 'Arc display',
+            configSchema,
+            stateModel: (0, model_1.stateModelFactory)(configSchema),
+            trackType: 'VariantTrack',
+            viewType: 'LinearGenomeView',
+            ReactComponent: (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('./components/ReactComponent')))),
+        });
+    });
+}
+exports.default = LinearPairedArcDisplayF;

package/dist/LinearPairedArcDisplay/model.d.ts

@@ -0,0 +1,161 @@
+import React from 'react';
+import { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import { Instance } from 'mobx-state-tree';
+import { Feature } from '@jbrowse/core/util';
+/**
+ * #stateModel LinearPairedArcDisplay
+ * extends BaseDisplay, TrackHeightMixin, FeatureDensityMixin
+ */
+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>>;
+} & {
+    heightPreConfig: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    userBpPerPxLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+    userByteSizeLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    /**
+     * #property
+     */
+    type: import("mobx-state-tree").ISimpleType<"LinearPairedArcDisplay">;
+    /**
+     * #property
+     */
+    configuration: AnyConfigurationSchemaType;
+    /**
+     * #property
+     */
+    displayMode: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+}, {
+    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?: Function | undefined;
+        blockState?: Record<string, any> | undefined;
+    }>;
+    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: React.FC<any> | undefined;
+    trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
+    readonly viewMenuActions: import("@jbrowse/core/ui").MenuItem[];
+    regionCannotBeRendered(): null;
+} & {
+    setMessage(arg?: string | undefined): void;
+    setError(error?: unknown): void;
+    setRpcDriverName(rpcDriverName: string): void;
+    reload(): void;
+} & {
+    scrollTop: number;
+} & {
+    readonly height: number;
+} & {
+    setScrollTop(scrollTop: number): void;
+    setHeight(displayHeight: number): number; /**
+     * #property
+     */
+    resizeHeight(distance: number): number;
+} & {
+    featureDensityStatsP: Promise<import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats> | undefined;
+    featureDensityStats: import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats | undefined;
+    currStatsBpPerPx: number;
+} & {
+    readonly currentBytesRequested: number;
+    readonly currentFeatureScreenDensity: number;
+    readonly maxFeatureScreenDensity: any;
+    readonly featureDensityStatsReady: boolean;
+    readonly maxAllowableBytes: number;
+} & {
+    afterAttach(): void;
+} & {
+    setCurrStatsBpPerPx(n: number): void;
+    setFeatureDensityStatsLimit(stats?: import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats | undefined): void;
+    getFeatureDensityStats(): Promise<import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats>;
+    setFeatureDensityStatsP(arg: any): void;
+    setFeatureDensityStats(featureDensityStats?: import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats | undefined): void;
+    clearFeatureDensityStats(): void;
+} & {
+    readonly regionTooLarge: boolean;
+    readonly regionTooLargeReason: string;
+} & {
+    regionCannotBeRenderedText(_region: import("@jbrowse/core/util").Region): "" | "Force load to see features";
+    regionCannotBeRendered(_region: import("@jbrowse/core/util").Region): React.JSX.Element | null;
+} & {
+    lastDrawnOffsetPx: number;
+    features: Feature[] | undefined;
+    loading: boolean;
+    drawn: boolean;
+} & {
+    /**
+     * #getter
+     */
+    readonly displayModeSetting: any;
+} & {
+    /**
+     * #action
+     */
+    selectFeature(feature: Feature): void;
+    /**
+     * #action
+     */
+    setLoading(flag: boolean): void;
+    /**
+     * #action
+     */
+    setFeatures(f: Feature[]): void;
+    /**
+     * #action
+     */
+    setDisplayMode(flag: string): void;
+} & {
+    afterAttach(): void;
+    /**
+     * #action
+     */
+    renderSvg(opts: {
+        rasterizeLayers?: boolean;
+    }): Promise<React.ReactNode>;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export type LinearArcDisplayStateModel = ReturnType<typeof stateModelFactory>;
+export type LinearArcDisplayModel = Instance<LinearArcDisplayStateModel>;