@jbrowse/core 2.17.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "2.17.0",
+  "version": "3.0.0",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
     "jbrowse",
@@ -30,16 +30,14 @@
     "build": "tsc -b tsconfig.build.json && cp package.json README.md ../../LICENSE dist/"
   },
   "dependencies": {
-    "@babel/runtime": "^7.17.9",
+    "@floating-ui/react": "^0.27.0",
     "@gmod/abortable-promise-cache": "^2.0.0",
-    "@gmod/bgzf-filehandle": "^1.4.3",
-    "@gmod/http-range-fetcher": "^3.0.4",
+    "@gmod/bgzf-filehandle": "^2.0.1",
+    "@gmod/http-range-fetcher": "^4.0.0",
     "@mui/icons-material": "^6.0.0",
     "@mui/x-data-grid": "^7.0.0",
-    "@types/clone": "^2.0.0",
     "canvas-sequencer": "^3.1.0",
     "canvas2svg": "^1.0.16",
-    "clone": "^2.1.2",
     "colord": "^2.9.3",
     "copy-to-clipboard": "^3.3.1",
     "deepmerge": "^4.2.2",
@@ -47,16 +45,15 @@
     "dompurify": "^3.2.0",
     "escape-html": "^1.0.3",
     "fast-deep-equal": "^3.1.3",
-    "generic-filehandle": "^3.0.0",
-    "is-object": "^1.0.1",
+    "generic-filehandle2": "^1.0.0",
     "jexl": "^2.3.0",
     "librpc-web-mod": "^1.1.5",
     "load-script": "^2.0.0",
     "material-ui-popup-state": "^5.0.0",
     "rbush": "^3.0.1",
+    "react-draggable": "^4.4.5",
     "serialize-error": "^8.0.0",
-    "source-map-js": "^1.0.2",
-    "svg-path-generator": "^1.1.0"
+    "source-map-js": "^1.0.2"
   },
   "peerDependencies": {
     "@mui/material": "^6.0.0",
@@ -72,5 +69,5 @@
     "access": "public",
     "directory": "dist"
   },
-  "gitHead": "eed30b5e671f8f7823652d7cecc51aa89226de46"
+  "gitHead": "2c6897f1fa732b1db5b094d1dca197e333e95319"
 }

package/pluggableElementTypes/AdapterType.d.ts

@@ -1,6 +1,6 @@
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import { AnyAdapter } from '../data_adapters/BaseAdapter';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyAdapter } from '../data_adapters/BaseAdapter';
 export interface AdapterMetadata {
     category?: string;
     hiddenFromGUI?: boolean;

package/pluggableElementTypes/AddTrackWorkflowType.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
-import { IAnyModelType } from 'mobx-state-tree';
+import type React from 'react';
 import PluggableElementBase from './PluggableElementBase';
+import type { IAnyModelType } from 'mobx-state-tree';
 type BasicComponent = React.ComponentType<{
     model: any;
 }>;

package/pluggableElementTypes/ConnectionType.d.ts

@@ -1,7 +1,7 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import { AnyReactComponentType } from '../util';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyReactComponentType } from '../util';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class ConnectionType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/DisplayType.d.ts

@@ -1,22 +1,16 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyReactComponentType } from '../util';
-import { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyReactComponentType } from '../util';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class DisplayType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;
     ReactComponent: AnyReactComponentType;
-    /**
-     * The track type the display is associated with
-     */
     trackType: string;
     subDisplay?: {
         type: string;
         [key: string]: unknown;
     };
-    /**
-     * The view type the display is associated with
-     */
     viewType: string;
     constructor(stuff: {
         name: string;

package/pluggableElementTypes/InternetAccountType.d.ts

@@ -1,6 +1,6 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration/types';
+import type { AnyConfigurationSchemaType } from '../configuration/types';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class InternetAccountType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/PluggableElementBase.d.ts

@@ -1,7 +1,7 @@
 export default abstract class PluggableElementBase {
     name: string;
     maybeDisplayName?: string;
-    constructor(args: {
+    constructor(args?: {
         name?: string;
         displayName?: string;
     });

package/pluggableElementTypes/PluggableElementBase.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 class PluggableElementBase {
     constructor(args) {
-        this.name = args.name || 'UNKNOWN';
-        this.maybeDisplayName = args.displayName;
+        this.name = (args === null || args === void 0 ? void 0 : args.name) || 'UNKNOWN';
+        this.maybeDisplayName = args === null || args === void 0 ? void 0 : args.displayName;
     }
     get displayName() {
         return this.maybeDisplayName || this.name;

package/pluggableElementTypes/RpcMethodType.d.ts

@@ -1,23 +1,17 @@
-import PluginManager from '../PluginManager';
 import PluggableElementBase from './PluggableElementBase';
-import { UriLocation } from '../util/types';
-import { RemoteAbortSignal } from '../rpc/remoteAbortSignals';
-interface SerializedArgs {
-    signal?: RemoteAbortSignal;
-    blobMap?: Record<string, File>;
-}
+import type PluginManager from '../PluginManager';
+import type { UriLocation } from '../util/types';
 export type RpcMethodConstructor = new (pm: PluginManager) => RpcMethodType;
 export default abstract class RpcMethodType extends PluggableElementBase {
     pluginManager: PluginManager;
     constructor(pluginManager: PluginManager);
     serializeArguments(args: Record<string, unknown>, rpcDriverClassName: string): Promise<Record<string, unknown>>;
     serializeNewAuthArguments(loc: UriLocation, rpcDriverClassName: string): Promise<UriLocation>;
-    deserializeArguments<T extends SerializedArgs>(serializedArgs: T, _rpcDriverClassName: string): Promise<T & {
-        signal: AbortSignal | undefined;
-    }>;
+    deserializeArguments<T>(args: T & {
+        blobMap?: Record<string, File>;
+    }, _rpcDriverClassName: string): Promise<T>;
     abstract execute(serializedArgs: unknown, rpcDriverClassName: string): Promise<unknown>;
     serializeReturn(originalReturn: unknown, _args: unknown, _rpcDriverClassName: string): Promise<unknown>;
     deserializeReturn(serializedReturn: unknown, _args: unknown, _rpcDriverClassName: string): Promise<unknown>;
     private augmentLocationObjects;
 }
-export {};

package/pluggableElementTypes/RpcMethodType.js

@@ -3,14 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const map_obj_1 = __importDefault(require("../util/map-obj"));
 const PluggableElementBase_1 = __importDefault(require("./PluggableElementBase"));
+const map_obj_1 = __importDefault(require("../util/map-obj"));
 const tracks_1 = require("../util/tracks");
 const types_1 = require("../util/types");
-const remoteAbortSignals_1 = require("../rpc/remoteAbortSignals");
 class RpcMethodType extends PluggableElementBase_1.default {
     constructor(pluginManager) {
-        super({});
+        super();
         this.pluginManager = pluginManager;
     }
     async serializeArguments(args, rpcDriverClassName) {
@@ -20,30 +19,21 @@ class RpcMethodType extends PluggableElementBase_1.default {
     }
     async serializeNewAuthArguments(loc, rpcDriverClassName) {
         const rootModel = this.pluginManager.rootModel;
-        // args dont need auth or already have auth
         if (!(0, types_1.isAppRootModel)(rootModel) || loc.internetAccountPreAuthorization) {
             return loc;
         }
         const account = rootModel.findAppropriateInternetAccount(loc);
-        // mutating loc object is not allowed in MainThreadRpcDriver, and is only
-        // needed for web worker RPC
         if (account && rpcDriverClassName !== 'MainThreadRpcDriver') {
             loc.internetAccountPreAuthorization =
                 await account.getPreAuthorizationInformation(loc);
         }
         return loc;
     }
-    async deserializeArguments(serializedArgs, _rpcDriverClassName) {
-        if (serializedArgs.blobMap) {
-            (0, tracks_1.setBlobMap)(serializedArgs.blobMap);
+    async deserializeArguments(args, _rpcDriverClassName) {
+        if (args.blobMap) {
+            (0, tracks_1.setBlobMap)(args.blobMap);
         }
-        const { signal } = serializedArgs;
-        return {
-            ...serializedArgs,
-            signal: (0, remoteAbortSignals_1.isRemoteAbortSignal)(signal)
-                ? (0, remoteAbortSignals_1.deserializeAbortSignal)(signal)
-                : undefined,
-        };
+        return args;
     }
     async serializeReturn(originalReturn, _args, _rpcDriverClassName) {
         return originalReturn;
@@ -56,8 +46,7 @@ class RpcMethodType extends PluggableElementBase_1.default {
         }
         catch (error) {
             if ((0, types_1.isAuthNeededException)(error)) {
-                const retryAccount = // @ts-expect-error
-                 (_a = this.pluginManager.rootModel) === null || _a === void 0 ? void 0 : _a.createEphemeralInternetAccount(`HTTPBasicInternetAccount-${new URL(error.url).origin}`, {}, error.url);
+                const retryAccount = (_a = this.pluginManager.rootModel) === null || _a === void 0 ? void 0 : _a.createEphemeralInternetAccount(`HTTPBasicInternetAccount-${new URL(error.url).origin}`, {}, error.url);
                 throw new types_1.RetryError('Retrying with created internet account', retryAccount.internetAccountId);
             }
             throw error;
@@ -66,7 +55,6 @@ class RpcMethodType extends PluggableElementBase_1.default {
     }
     async augmentLocationObjects(thing, rpcDriverClassName) {
         const uris = [];
-        // using map-obj avoids cycles, seen in circular view svg export
         (0, map_obj_1.default)(thing, val => {
             if ((0, types_1.isUriLocation)(val)) {
                 uris.push(val);

package/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions.d.ts

@@ -0,0 +1,9 @@
+import RpcMethodType from './RpcMethodType';
+import type { RenderArgs } from '@jbrowse/core/rpc/coreRpcMethods';
+export default abstract class RpcMethodTypeWithFiltersAndRenameRegions extends RpcMethodType {
+    deserializeArguments(args: any, rpcDriverClassName: string): Promise<any>;
+    serializeArguments(args: RenderArgs & {
+        stopToken?: string;
+        statusCallback?: (arg: string) => void;
+    }, rpcDriverClassName: string): Promise<Record<string, unknown>>;
+}

package/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions.js

@@ -0,0 +1,35 @@
+"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("./RpcMethodType"));
+const util_1 = require("../util");
+const serializableFilterChain_1 = __importDefault(require("./renderers/util/serializableFilterChain"));
+class RpcMethodTypeWithFiltersAndRenameRegions extends RpcMethodType_1.default {
+    async deserializeArguments(args, rpcDriverClassName) {
+        const l = await super.deserializeArguments(args, rpcDriverClassName);
+        return {
+            ...l,
+            filters: args.filters
+                ? new serializableFilterChain_1.default({
+                    filters: args.filters,
+                })
+                : undefined,
+        };
+    }
+    async serializeArguments(args, rpcDriverClassName) {
+        var _a, _b, _c;
+        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;
+        if (!assemblyManager) {
+            throw new Error('no assembly manager');
+        }
+        const renamedArgs = await (0, util_1.renameRegionsIfNeeded)(assemblyManager, {
+            ...args,
+            filters: (_c = args.filters) === null || _c === void 0 ? void 0 : _c.toJSON().filters,
+        });
+        return super.serializeArguments(renamedArgs, rpcDriverClassName);
+    }
+}
+exports.default = RpcMethodTypeWithFiltersAndRenameRegions;

package/pluggableElementTypes/TextSearchAdapterType.d.ts

@@ -1,6 +1,6 @@
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import { AnyAdapter } from '../data_adapters/BaseAdapter';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyAdapter } from '../data_adapters/BaseAdapter';
 export default class TextSearchAdapterType extends PluggableElementBase {
     getAdapterClass: () => Promise<AnyAdapter>;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/TrackType.d.ts

@@ -1,7 +1,7 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import DisplayType from './DisplayType';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type DisplayType from './DisplayType';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class TrackType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/ViewType.d.ts

@@ -1,7 +1,7 @@
-import React from 'react';
-import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
+import type React from 'react';
 import PluggableElementBase from './PluggableElementBase';
-import DisplayType from './DisplayType';
+import type DisplayType from './DisplayType';
+import type { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 type BasicView = React.ComponentType<{
     model: any;
     session?: IAnyStateTreeNode;

package/pluggableElementTypes/WidgetType.d.ts

@@ -1,7 +1,8 @@
-import React, { ComponentType, LazyExoticComponent } from 'react';
-import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
+import type { ComponentType, LazyExoticComponent } from 'react';
+import type React from 'react';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 type WidgetComponentType = LazyExoticComponent<React.FC<any>> | React.FC<any>;
 type HeadingComponentType = ComponentType<{
     model: IAnyStateTreeNode;

package/pluggableElementTypes/index.d.ts

@@ -1,14 +1,14 @@
-import AdapterType from './AdapterType';
-import ConnectionType from './ConnectionType';
-import RendererType from './renderers/RendererType';
-import WidgetType from './WidgetType';
-import TrackType from './TrackType';
-import DisplayType from './DisplayType';
-import ViewType from './ViewType';
-import RpcMethodType from './RpcMethodType';
-import InternetAccountType from './InternetAccountType';
-import TextSearchAdapterType from './TextSearchAdapterType';
-import AddTrackWorkflowType from './AddTrackWorkflowType';
+import type AdapterType from './AdapterType';
+import type AddTrackWorkflowType from './AddTrackWorkflowType';
+import type ConnectionType from './ConnectionType';
+import type DisplayType from './DisplayType';
+import type InternetAccountType from './InternetAccountType';
+import type RpcMethodType from './RpcMethodType';
+import type TextSearchAdapterType from './TextSearchAdapterType';
+import type TrackType from './TrackType';
+import type ViewType from './ViewType';
+import type WidgetType from './WidgetType';
+import type RendererType from './renderers/RendererType';
 export * from './renderers';
 export * from './models';
 export type PluggableElementType = AdapterType | ConnectionType | RendererType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | InternetAccountType | TextSearchAdapterType | AddTrackWorkflowType;

package/pluggableElementTypes/models/BaseConnectionModelFactory.d.ts

@@ -1,21 +1,9 @@
-import { AnyConfigurationModel } from '../../configuration';
-import PluginManager from '../../PluginManager';
+import type PluginManager from '../../PluginManager';
+import type { AnyConfigurationModel } from '../../configuration';
 type TrackConf = AnyConfigurationModel | Record<string, unknown>;
-/**
- * #stateModel BaseConnectionModel
- */
 declare function stateModelFactory(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
-    /**
-     * #property
-     */
     name: import("mobx-state-tree").ISimpleType<string>;
-    /**
-     * #property
-     */
     tracks: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>;
-    /**
-     * #property
-     */
     configuration: import("../../configuration/configurationSchema").ConfigurationSchemaType<{
         name: {
             type: string;
@@ -29,27 +17,12 @@ declare function stateModelFactory(pluginManager: PluginManager): import("mobx-s
         };
     }, import("../../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>;
 }, {
-    /**
-     * #action
-     */
     connect(_arg: AnyConfigurationModel): void;
 } & {
     afterAttach(): void;
-    /**
-     * #action
-     */
     addTrackConf(trackConf: TrackConf): any;
-    /**
-     * #action
-     */
     addTrackConfs(trackConfs: TrackConf[]): void;
-    /**
-     * #action
-     */
     setTrackConfs(trackConfs: AnyConfigurationModel[]): void;
-    /**
-     * #action
-     */
     clear(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type BaseConnectionModel = ReturnType<typeof stateModelFactory>;

package/pluggableElementTypes/models/BaseConnectionModelFactory.js

@@ -4,31 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mobx_state_tree_1 = require("mobx-state-tree");
-const configuration_1 = require("../../configuration");
 const baseConnectionConfig_1 = __importDefault(require("./baseConnectionConfig"));
-/**
- * #stateModel BaseConnectionModel
- */
+const configuration_1 = require("../../configuration");
 function stateModelFactory(pluginManager) {
     return mobx_state_tree_1.types
         .model('Connection', {
-        /**
-         * #property
-         */
         name: mobx_state_tree_1.types.identifier,
-        /**
-         * #property
-         */
         tracks: mobx_state_tree_1.types.array(pluginManager.pluggableConfigSchemaType('track')),
-        /**
-         * #property
-         */
         configuration: (0, configuration_1.ConfigurationReference)(baseConnectionConfig_1.default),
     })
         .actions(() => ({
-        /**
-         * #action
-         */
         connect(_arg) { },
     }))
         .actions(self => ({
@@ -37,28 +22,16 @@ function stateModelFactory(pluginManager) {
                 self.connect(self.configuration);
             }
         },
-        /**
-         * #action
-         */
         addTrackConf(trackConf) {
             const length = self.tracks.push(trackConf);
             return self.tracks[length - 1];
         },
-        /**
-         * #action
-         */
         addTrackConfs(trackConfs) {
             self.tracks.push(...trackConfs);
         },
-        /**
-         * #action
-         */
         setTrackConfs(trackConfs) {
             self.tracks = (0, mobx_state_tree_1.cast)(trackConfs);
         },
-        /**
-         * #action
-         */
         clear() { },
     }));
 }

package/pluggableElementTypes/models/BaseDisplayModel.d.ts

@@ -1,27 +1,15 @@
-import React from 'react';
-import { Instance } from 'mobx-state-tree';
-import { MenuItem } from '../../ui';
+import type React from 'react';
+import type { MenuItem } from '../../ui';
+import type { Instance } from 'mobx-state-tree';
 export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
-    /**
-     * #property
-     */
     id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    /**
-     * #property
-     */
     type: import("mobx-state-tree").ISimpleType<string>;
-    /**
-     * #property
-     */
     rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
 }, {
     rendererTypeName: string;
     error: unknown;
     message: string | undefined;
 } & {
-    /**
-     * #getter
-     */
     readonly RenderingComponent: React.FC<{
         model: {
             id: string;
@@ -32,17 +20,8 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
             error: unknown;
             message: string | undefined;
         } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            /**
-             * #property
-             */
             id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            /**
-             * #property
-             */
             type: import("mobx-state-tree").ISimpleType<string>;
-            /**
-             * #property
-             */
             rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
@@ -52,9 +31,6 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
         onHorizontalScroll?: () => void;
         blockState?: Record<string, any>;
     }>;
-    /**
-     * #getter
-     */
     readonly DisplayBlurb: React.FC<{
         model: {
             id: string;
@@ -65,17 +41,8 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
             error: unknown;
             message: string | undefined;
         } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            /**
-             * #property
-             */
             id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            /**
-             * #property
-             */
             type: import("mobx-state-tree").ISimpleType<string>;
-            /**
-             * #property
-             */
             rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
@@ -83,65 +50,18 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
             message: string | undefined;
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
     }> | null;
-    /**
-     * #getter
-     */
     readonly adapterConfig: any;
-    /**
-     * #getter
-     */
     readonly parentTrack: any;
-    /**
-     * #method
-     * the react props that are passed to the Renderer when data
-     * is rendered in this display
-     */
     renderProps(): any;
-    /**
-     * #getter
-     * the pluggable element type object for this display's renderer
-     */
     readonly rendererType: import("..").RendererType;
-    /**
-     * #getter
-     * if a display-level message should be displayed instead, make this
-     * return a react component
-     */
     readonly DisplayMessageComponent: undefined | React.FC<any>;
-    /**
-     * #method
-     */
     trackMenuItems(): MenuItem[];
-    /**
-     * #getter
-     */
     readonly viewMenuActions: MenuItem[];
-    /**
-     * #method
-     * @param region -
-     * @returns falsy if the region is fine to try rendering. Otherwise,
-     * return a react node + string of text. string of text describes why it
-     * cannot be rendered react node allows user to force load at current
-     * setting
-     */
     regionCannotBeRendered(): null;
 } & {
-    /**
-     * #action
-     */
     setMessage(arg?: string): void;
-    /**
-     * #action
-     */
     setError(error?: unknown): void;
-    /**
-     * #action
-     */
     setRpcDriverName(rpcDriverName: string): void;
-    /**
-     * #action
-     * base display reload does nothing, see specialized displays for details
-     */
     reload(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type BaseDisplayStateModel = typeof BaseDisplay;