@jbrowse/core 2.2.0 → 2.2.1

package/BaseFeatureWidget/BaseFeatureDetail.d.ts

@@ -34,6 +34,7 @@ export declare const BaseCoreDetails: (props: BaseProps) => JSX.Element;
 interface AttributeProps {
     attributes: Record<string, any>;
     omit?: string[];
+    omitSingleLevel?: string[];
     formatter?: (val: unknown, key: string) => React.ReactNode;
     descriptions?: Record<string, React.ReactNode>;
     prefix?: string[];

package/BaseFeatureWidget/BaseFeatureDetail.js

@@ -156,35 +156,41 @@ const ArrayValue = ({ name, value, description, prefix = [], }) => {
     }
 };
 const toLocale = (n) => n.toLocaleString('en-US');
-function CoreDetails(props) {
+function Position(props) {
     const { feature } = props;
-    const obj = feature;
-    // eslint-disable-next-line no-underscore-dangle
-    const formattedFeat = { ...obj, ...obj.__jbrowsefmt };
-    const { start, strand, end, refName } = formattedFeat;
+    const strand = feature.strand;
     const strandMap = {
         '-1': '-',
         '0': '',
         '1': '+',
     };
     const str = strandMap[strand] ? `(${strandMap[strand]})` : '';
+    // @ts-ignore
+    const loc = (0, util_1.assembleLocString)(feature);
+    return react_1.default.createElement(react_1.default.Fragment, null, `${loc} ${str}`);
+}
+function CoreDetails(props) {
+    const { feature } = props;
+    const obj = feature;
+    // eslint-disable-next-line no-underscore-dangle
+    const formattedFeat = { ...obj, ...obj.__jbrowsefmt };
+    const { start, end } = formattedFeat;
     const displayedDetails = {
         ...formattedFeat,
         length: toLocale(end - start),
-        position: `${refName}:${toLocale(start + 1)}..${toLocale(end)} ${str}`,
     };
     const coreRenderedDetails = {
-        position: 'Position',
         description: 'Description',
         name: 'Name',
         length: 'Length',
         type: 'Type',
-        assemblyName: 'Assembly name',
     };
-    return (react_1.default.createElement(react_1.default.Fragment, null, Object.entries(coreRenderedDetails)
-        .map(([key, name]) => [name, displayedDetails[key]])
-        .filter(([, value]) => value !== null && value !== undefined)
-        .map(([name, value]) => (react_1.default.createElement(exports.SimpleValue, { key: name, name: name, value: value })))));
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(exports.SimpleValue, { name: "Position", value: react_1.default.createElement(Position, { ...props, feature: formattedFeat }) }),
+        Object.entries(coreRenderedDetails)
+            .map(([key, name]) => [name, displayedDetails[key]])
+            .filter(([, value]) => value != null)
+            .map(([name, value]) => (react_1.default.createElement(exports.SimpleValue, { key: name, name: name, value: value })))));
 }
 const BaseCoreDetails = (props) => {
     return (react_1.default.createElement(BaseCard, { ...props, title: "Primary data" },
@@ -229,23 +235,25 @@ const DataGridDetails = ({ value, prefix, name, }) => {
             width: (0, util_1.measureGridWidth)(rows.map(r => r[val])),
         }));
         const rowHeight = 25;
-        const hideFooter = rows.length < 100;
-        const headerHeight = 80;
+        const hideFoot = rows.length < 100;
+        const headHeight = 80;
+        const height = Math.min(rows.length, 100) * rowHeight + headHeight + (hideFoot ? 0 : 50);
         // disableSelection on click helps avoid
         // https://github.com/mui-org/material-ui-x/issues/1197
         return (react_1.default.createElement(react_1.default.Fragment, null,
             react_1.default.createElement(exports.FieldName, { prefix: prefix, name: name }),
             react_1.default.createElement("div", { style: {
-                    height: Math.min(rows.length, 100) * rowHeight +
-                        headerHeight +
-                        (hideFooter ? 0 : 50),
+                    height,
                     width: '100%',
                 } },
-                react_1.default.createElement(x_data_grid_1.DataGrid, { disableSelectionOnClick: true, rowHeight: rowHeight, rows: rows, rowsPerPageOptions: [], hideFooterSelectedRowCount: true, columns: columns, hideFooter: hideFooter }))));
+                react_1.default.createElement(x_data_grid_1.DataGrid, { disableSelectionOnClick: true, rowHeight: rowHeight, rows: rows, hideFooterSelectedRowCount: true, columns: columns, hideFooter: hideFoot }))));
     }
     return null;
 };
-// arr = ['a','b'], obj = {a:{b:'hello}}, returns hello (with special addition to grab description also)
+// pick using a path from an object, similar to _.get from lodash with special logic
+// for Descriptions from e.g. VCF headers
+// @param arr  example ['a','b'], obj = {a:{b:'hello}}
+// @returns hello (with special addition to grab description also)
 function accessNested(arr, obj = {}) {
     arr.forEach(elt => {
         if (obj) {
@@ -259,13 +267,11 @@ function accessNested(arr, obj = {}) {
             : undefined;
 }
 function generateMaxWidth(array, prefix) {
-    // @ts-ignore
     const arr = [];
-    array.forEach((key, value) => {
+    array.forEach(key => {
         const val = [...prefix, key[0]].join('.');
         arr.push((0, util_1.measureText)(val, 12));
     });
-    // @ts-ignore
     return Math.ceil(Math.max(...arr)) + 10;
 }
 function UriAttribute({ value, prefix, name, }) {
@@ -283,8 +289,8 @@ function UriAttribute({ value, prefix, name, }) {
         react_1.default.createElement(exports.BasicValue, { value: href })));
 }
 function Attributes(props) {
-    const { attributes, omit = [], descriptions, formatter = val => val, hideUris, prefix = [], } = props;
-    const omits = [...omit, ...globalOmit];
+    const { attributes, omit = [], omitSingleLevel = [], descriptions, formatter = val => val, hideUris, prefix = [], } = props;
+    const omits = [...omit, ...globalOmit, ...omitSingleLevel];
     const { __jbrowsefmt, ...rest } = attributes;
     const formattedAttributes = { ...rest, ...__jbrowsefmt };
     const maxLabelWidth = generateMaxWidth(Object.entries(formattedAttributes).filter(([k, v]) => v !== undefined && !omits.includes(k)), prefix);
@@ -298,7 +304,8 @@ function Attributes(props) {
             return value.length > 1 && value.every(val => (0, is_object_1.default)(val)) ? (react_1.default.createElement(DataGridDetails, { key: key, name: key, prefix: prefix, value: value })) : (react_1.default.createElement(ArrayValue, { key: key, name: key, value: value, description: description, prefix: prefix }));
         }
         else if ((0, is_object_1.default)(value)) {
-            return (0, util_1.isUriLocation)(value) ? (hideUris ? null : (react_1.default.createElement(UriAttribute, { key: key, name: key, prefix: prefix, value: value }))) : (react_1.default.createElement(Attributes, { ...props, omit: omits, key: key, attributes: value, descriptions: descriptions, prefix: [...prefix, key] }));
+            const { omitSingleLevel, ...rest } = props;
+            return (0, util_1.isUriLocation)(value) ? (hideUris ? null : (react_1.default.createElement(UriAttribute, { key: key, name: key, prefix: prefix, value: value }))) : (react_1.default.createElement(Attributes, { ...rest, key: key, attributes: value, descriptions: descriptions, prefix: [...prefix, key] }));
         }
         else {
             return (react_1.default.createElement(exports.SimpleValue, { key: key, name: key, value: formatter(value, key), description: description, prefix: prefix, width: Math.min(maxLabelWidth, MAX_FIELD_NAME_WIDTH) }));
@@ -323,15 +330,23 @@ function generateTitle(name, id, type) {
 const FeatureDetails = (props) => {
     const { omit = [], model, feature, depth = 0 } = props;
     const { name = '', id = '', type = '', subfeatures } = feature;
-    const { pluginManager } = (0, util_1.getEnv)(model);
+    const pm = (0, util_1.getEnv)(model).pluginManager;
     const session = (0, util_1.getSession)(model);
-    const ExtraPanel = pluginManager === null || pluginManager === void 0 ? void 0 : pluginManager.evaluateExtensionPoint('Core-extraFeaturePanel', null, { session, feature, model });
+    const ExtraPanel = pm.evaluateExtensionPoint('Core-extraFeaturePanel', null, {
+        session,
+        feature,
+        model,
+    });
     return (react_1.default.createElement(BaseCard, { title: generateTitle(name, id, type) },
         react_1.default.createElement(material_1.Typography, null, "Core details"),
         react_1.default.createElement(CoreDetails, { ...props }),
+        feature.mate ? (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement(material_1.Divider, null),
+            react_1.default.createElement(material_1.Typography, null, "Mate details"),
+            react_1.default.createElement(CoreDetails, { ...props, feature: feature.mate }))) : null,
         react_1.default.createElement(material_1.Divider, null),
         react_1.default.createElement(material_1.Typography, null, "Attributes"),
-        react_1.default.createElement(Attributes, { attributes: feature, ...props, omit: [...omit, ...coreDetails] }),
+        react_1.default.createElement(Attributes, { attributes: feature, ...props, omit: omit, omitSingleLevel: coreDetails }),
         react_1.default.createElement(react_error_boundary_1.ErrorBoundary, { FallbackComponent: ({ error }) => react_1.default.createElement(ui_1.ErrorMessage, { error: error }) },
             react_1.default.createElement(SequenceFeatureDetails_1.default, { ...props })),
         ExtraPanel ? (react_1.default.createElement(react_1.default.Fragment, null,

package/BaseFeatureWidget/SequenceBox.js

@@ -29,21 +29,17 @@ function GeneProtein({ cds, sequence, codonTable, }) {
 }
 exports.GeneProtein = GeneProtein;
 function GenecDNA({ utr, cds, exons, sequence, upstream, downstream, includeIntrons, collapseIntron, intronBp, }) {
-    const chunks = cds.length
-        ? [...cds, ...utr].sort((a, b) => a.start - b.start)
-        : exons;
+    const chunks = (cds.length ? [...cds, ...utr].sort((a, b) => a.start - b.start) : exons).filter(f => f.start !== f.end);
     return (react_1.default.createElement(react_1.default.Fragment, null,
         upstream ? (react_1.default.createElement("span", { style: { background: updownstreamColor } }, upstream)) : null,
-        chunks
-            .filter(f => f.start !== f.end)
-            .map((chunk, index) => {
+        chunks.map((chunk, idx) => {
             var _a;
-            const intron = sequence.slice(chunk.end, (_a = chunks[index + 1]) === null || _a === void 0 ? void 0 : _a.start);
+            const intron = sequence.slice(chunk.end, (_a = chunks[idx + 1]) === null || _a === void 0 ? void 0 : _a.start);
             return (react_1.default.createElement(react_1.default.Fragment, { key: JSON.stringify(chunk) },
                 react_1.default.createElement("span", { style: {
                         background: chunk.type === 'CDS' ? cdsColor : utrColor,
                     } }, sequence.slice(chunk.start, chunk.end)),
-                includeIntrons && index < chunks.length - 1 ? (react_1.default.createElement("span", { style: { background: intronColor } }, collapseIntron && intron.length > intronBp * 2
+                includeIntrons && idx < chunks.length - 1 ? (react_1.default.createElement("span", { style: { background: intronColor } }, collapseIntron && intron.length > intronBp * 2
                     ? `${intron.slice(0, intronBp)}...${intron.slice(-intronBp)}`
                     : intron)) : null));
         }),

package/Plugin.d.ts

@@ -11,4 +11,4 @@ export default abstract class Plugin {
     configure(_pluginManager: PluginManager): void;
     configurationSchema: AnyConfigurationSchemaType | undefined;
 }
-export declare type PluginConstructor = new (...args: unknown[]) => Plugin;
+export type PluginConstructor = new (...args: unknown[]) => Plugin;

package/PluginLoader.d.ts

@@ -14,7 +14,7 @@ export interface LegacyUMDPluginDefinition {
     url: string;
     name: string;
 }
-declare type UMDPluginDefinition = UMDLocPluginDefinition | UMDUrlPluginDefinition;
+type UMDPluginDefinition = UMDLocPluginDefinition | UMDUrlPluginDefinition;
 export declare function isUMDPluginDefinition(def: PluginDefinition): def is UMDPluginDefinition | LegacyUMDPluginDefinition;
 export interface ESMLocPluginDefinition {
     esmLoc: {
@@ -25,7 +25,7 @@ export interface ESMLocPluginDefinition {
 export interface ESMUrlPluginDefinition {
     esmUrl: string;
 }
-export declare type ESMPluginDefinition = ESMLocPluginDefinition | ESMUrlPluginDefinition;
+export type ESMPluginDefinition = ESMLocPluginDefinition | ESMUrlPluginDefinition;
 export declare function isESMPluginDefinition(def: PluginDefinition): def is ESMPluginDefinition;
 export interface CJSPluginDefinition {
     cjsUrl: string;

package/PluginManager.d.ts

@@ -26,7 +26,7 @@ declare class PhasedScheduler<PhaseName extends string> {
     add(phase: PhaseName, callback: Function): void;
     run(): void;
 }
-declare type PluggableElementTypeGroup = 'renderer' | 'adapter' | 'display' | 'track' | 'connection' | 'view' | 'widget' | 'rpc method' | 'internet account' | 'text search adapter' | 'add track workflow';
+type PluggableElementTypeGroup = 'renderer' | 'adapter' | 'display' | 'track' | 'connection' | 'view' | 'widget' | 'rpc method' | 'internet account' | 'text search adapter' | 'add track workflow';
 /** internal class that holds the info for a certain element type */
 declare class TypeRecord<ElementClass extends PluggableElementBase> {
     typeName: string;
@@ -48,7 +48,7 @@ declare class TypeRecord<ElementClass extends PluggableElementBase> {
     get(name: string): ElementClass;
     all(): ElementClass[];
 }
-declare type AnyFunction = (...args: any) => any;
+type AnyFunction = (...args: any) => any;
 /**
  * free-form string-to-unknown mapping of metadata related to the instance
  * of this plugin. `isCore` is typically set to `Boolean(true)` if the plugin was
@@ -56,7 +56,7 @@ declare type AnyFunction = (...args: any) => any;
  * Can also use this metadata to stash other things about why the plugin is
  * loaded, such as where it came from, what plugin depends on it, etc.
  */
-export declare type PluginMetadata = Record<string, unknown>;
+export type PluginMetadata = Record<string, unknown>;
 export interface PluginLoadRecord {
     metadata?: PluginMetadata;
     plugin: Plugin;

package/assemblyManager/assembly.d.ts

@@ -1,7 +1,7 @@
 import { Instance, IAnyType } from 'mobx-state-tree';
 import PluginManager from '../PluginManager';
 import { Region, Feature } from '../util';
-declare type RefNameAliases = Record<string, string>;
+type RefNameAliases = Record<string, string>;
 export interface BaseOptions {
     signal?: AbortSignal;
     sessionId: string;
@@ -72,6 +72,6 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pm: Plugin
      */
     getReverseRefNameMapForAdapter(adapterConf: unknown, opts: BaseOptions): Promise<RefNameAliases>;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export declare type AssemblyModel = ReturnType<typeof assemblyFactory>;
-export declare type Assembly = Instance<AssemblyModel>;
+export type AssemblyModel = ReturnType<typeof assemblyFactory>;
+export type Assembly = Instance<AssemblyModel>;
 export {};

package/assemblyManager/assembly.js

@@ -45,7 +45,7 @@ const refNameColors = [
 ];
 async function loadRefNameMap(assembly, adapterConfig, options, signal) {
     const { sessionId } = options;
-    await (0, util_1.when)(() => Boolean(assembly.regions && assembly.refNameAliases), {
+    await (0, util_1.when)(() => !!(assembly.regions && assembly.refNameAliases), {
         signal,
         name: 'when assembly ready',
     });

package/configuration/configurationSchema.d.ts

@@ -22,8 +22,8 @@ export interface AnyConfigurationSchemaType extends ReturnType<typeof makeConfig
     jbrowseSchemaOptions: ConfigurationSchemaOptions;
     type: string;
 }
-export declare type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
-export declare type ConfigurationModel<SCHEMA extends AnyConfigurationSchemaType> = Instance<SCHEMA>;
+export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
+export type ConfigurationModel<SCHEMA extends AnyConfigurationSchemaType> = Instance<SCHEMA>;
 export declare function ConfigurationSchema<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends ConfigurationSchemaOptions>(modelName: string, inputSchemaDefinition: DEFINITION, inputOptions?: OPTIONS): AnyConfigurationSchemaType;
 export declare function ConfigurationReference(schemaType: IAnyType): import("mobx-state-tree").ITypeUnion<any, any, any>;
 export {};

package/data_adapters/BaseAdapter.d.ts

@@ -13,7 +13,7 @@ export interface BaseOptions {
     headers?: Record<string, string>;
     [key: string]: unknown;
 }
-export declare type SearchType = 'full' | 'prefix' | 'exact';
+export type SearchType = 'full' | 'prefix' | 'exact';
 export interface BaseArgs {
     searchType?: SearchType;
     queryString: string;
@@ -24,7 +24,7 @@ export interface BaseArgs {
 export interface AnyAdapter {
     new (config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager | undefined): AnyDataAdapter;
 }
-export declare type AnyDataAdapter = BaseAdapter | BaseFeatureDataAdapter | BaseRefNameAliasAdapter | BaseTextSearchAdapter | RegionsAdapter | BaseSequenceAdapter;
+export type AnyDataAdapter = BaseAdapter | BaseFeatureDataAdapter | BaseRefNameAliasAdapter | BaseTextSearchAdapter | RegionsAdapter | BaseSequenceAdapter;
 export interface SequenceAdapter extends BaseFeatureDataAdapter, RegionsAdapter {
 }
 export declare abstract class BaseAdapter {

package/data_adapters/dataAdapterCache.d.ts

@@ -21,7 +21,7 @@ export declare function getAdapter(pluginManager: PluginManager, sessionId: stri
  * allows them to get any sub-adapters that they need
  * internally, staying with the same worker session ID
  */
-export declare type getSubAdapterType = (adapterConfigSnapshot: SnapshotIn<AnyConfigurationSchemaType>) => ReturnType<typeof getAdapter>;
+export type getSubAdapterType = (adapterConfigSnapshot: SnapshotIn<AnyConfigurationSchemaType>) => ReturnType<typeof getAdapter>;
 export declare function freeAdapterResources(specification: Record<string, any>): number;
 export declare function clearAdapterCache(): void;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
     "jbrowse",
@@ -73,5 +73,5 @@
     "access": "public",
     "directory": "dist"
   },
-  "gitHead": "cf31db8d833117f8822510340664fb3f045975cb"
+  "gitHead": "896d175c5d9345049faea8e1155f243c912aac42"
 }

package/pluggableElementTypes/AdapterType.d.ts

@@ -1,7 +1,7 @@
 import PluggableElementBase from './PluggableElementBase';
 import { AnyConfigurationSchemaType } from '../configuration/configurationSchema';
 import { AnyAdapter } from '../data_adapters/BaseAdapter';
-export declare type AdapterMetadata = {
+export type AdapterMetadata = {
     category: string | null;
     hiddenFromGUI: boolean | null;
     displayName: string | null;

package/pluggableElementTypes/AddTrackWorkflowType.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-declare type BasicComponent = React.ComponentType<{
+type BasicComponent = React.ComponentType<{
     model: any;
 }>;
-declare type AddTrackWorkflowComponent = React.LazyExoticComponent<BasicComponent> | BasicComponent;
+type AddTrackWorkflowComponent = React.LazyExoticComponent<BasicComponent> | BasicComponent;
 export default class AddTrackWorkflow extends PluggableElementBase {
     ReactComponent: AddTrackWorkflowComponent;
     stateModel: IAnyModelType;

package/pluggableElementTypes/RpcMethodType.d.ts

@@ -2,7 +2,7 @@ import PluginManager from '../PluginManager';
 import PluggableElementBase from './PluggableElementBase';
 import { UriLocation } from '../util/types';
 import { RemoteAbortSignal } from '../rpc/remoteAbortSignals';
-export declare type RpcMethodConstructor = new (pm: PluginManager) => RpcMethodType;
+export type RpcMethodConstructor = new (pm: PluginManager) => RpcMethodType;
 export default abstract class RpcMethodType extends PluggableElementBase {
     pluginManager: PluginManager;
     name: string;

package/pluggableElementTypes/ViewType.d.ts

@@ -2,11 +2,11 @@ import React from 'react';
 import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
 import DisplayType from './DisplayType';
-declare type BasicView = React.ComponentType<{
+type BasicView = React.ComponentType<{
     model: any;
     session?: IAnyStateTreeNode;
 }>;
-declare type ViewReactComponent = React.LazyExoticComponent<BasicView> | BasicView;
+type ViewReactComponent = React.LazyExoticComponent<BasicView> | BasicView;
 export default class ViewType extends PluggableElementBase {
     ReactComponent: ViewReactComponent;
     stateModel: IAnyModelType;

package/pluggableElementTypes/index.d.ts

@@ -12,5 +12,5 @@ import AddTrackWorkflowType from './AddTrackWorkflowType';
 export * from './renderers';
 export * from './models';
 export { AdapterType, ConnectionType, RendererType, WidgetType, TrackType, DisplayType, ViewType, RpcMethodType, InternetAccountType, TextSearchAdapterType, AddTrackWorkflowType, };
-export declare type PluggableElementType = AdapterType | ConnectionType | RendererType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | InternetAccountType | TextSearchAdapterType | AddTrackWorkflowType;
-export declare type PluggableElementMember = keyof AdapterType | keyof ConnectionType | keyof RendererType | keyof WidgetType | keyof TrackType | keyof DisplayType | keyof ViewType | keyof RpcMethodType | keyof InternetAccountType | keyof TextSearchAdapterType | keyof AddTrackWorkflowType;
+export type PluggableElementType = AdapterType | ConnectionType | RendererType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | InternetAccountType | TextSearchAdapterType | AddTrackWorkflowType;
+export type PluggableElementMember = keyof AdapterType | keyof ConnectionType | keyof RendererType | keyof WidgetType | keyof TrackType | keyof DisplayType | keyof ViewType | keyof RpcMethodType | keyof InternetAccountType | keyof TextSearchAdapterType | keyof AddTrackWorkflowType;

package/pluggableElementTypes/models/BaseConnectionModelFactory.d.ts

@@ -1,13 +1,34 @@
 import { AnyConfigurationModel } from '../../configuration';
 import PluginManager from '../../PluginManager';
-declare const _default: (pluginManager: PluginManager) => import("mobx-state-tree").IModelType<{
+/**
+ * #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>;
 }, {
     afterAttach(): void;
+    /**
+     * #action
+     */
     addTrackConf(trackConf: AnyConfigurationModel): any;
+    /**
+     * #action
+     */
     addTrackConfs(trackConfs: AnyConfigurationModel[]): any[];
+    /**
+     * #action
+     */
     setTrackConfs(trackConfs: AnyConfigurationModel[]): import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IAnyModelType> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>>;
+    /**
+     * #action
+     */
     clear(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export default _default;
+export default stateModelFactory;

package/pluggableElementTypes/models/BaseConnectionModelFactory.js

@@ -1,10 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const mobx_state_tree_1 = require("mobx-state-tree");
-exports.default = (pluginManager) => {
+/**
+ * #stateModel BaseConnectionModel
+ */
+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')),
     })
         .actions(self => ({
@@ -14,18 +23,31 @@ exports.default = (pluginManager) => {
                 self.connect(self.configuration);
             }
         },
+        /**
+         * #action
+         */
         addTrackConf(trackConf) {
             const length = self.tracks.push(trackConf);
             return self.tracks[length - 1];
         },
+        /**
+         * #action
+         */
         addTrackConfs(trackConfs) {
             const length = self.tracks.push(...trackConfs);
             return self.tracks.slice(length - 1 - trackConfs.length, length - 1);
         },
+        /**
+         * #action
+         */
         setTrackConfs(trackConfs) {
             self.tracks = (0, mobx_state_tree_1.cast)(trackConfs);
             return self.tracks;
         },
+        /**
+         * #action
+         */
         clear() { },
     }));
-};
+}
+exports.default = stateModelFactory;

package/pluggableElementTypes/models/BaseDisplayModel.d.ts

@@ -136,5 +136,5 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
      */
     reload(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export declare type BaseDisplayStateModel = typeof BaseDisplay;
-export declare type BaseDisplayModel = Instance<BaseDisplayStateModel>;
+export type BaseDisplayStateModel = typeof BaseDisplay;
+export type BaseDisplayModel = Instance<BaseDisplayStateModel>;

package/pluggableElementTypes/models/BaseTrackModel.d.ts

@@ -2,28 +2,73 @@ import { Instance } from 'mobx-state-tree';
 import { AnyConfigurationSchemaType } from '../../configuration';
 import PluginManager from '../../PluginManager';
 import { MenuItem } from '../../ui';
-export declare function createBaseTrackModel(pluginManager: PluginManager, trackType: string, baseTrackConfig: AnyConfigurationSchemaType): import("mobx-state-tree").IModelType<{
+/**
+ * #stateModel BaseTrackModel
+ * these MST models only exist for tracks that are *shown*.
+ * they should contain only UI state for the track, and have
+ * a reference to a track configuration (stored under
+ * session.configuration.assemblies.get(assemblyName).tracks).
+ * note that multiple displayed tracks could use the same
+ * configuration.
+ */
+export declare function createBaseTrackModel(pm: PluginManager, trackType: string, baseTrackConfig: 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>;
     configuration: import("mobx-state-tree").ITypeUnion<any, any, any>;
+    minimized: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     displays: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyType>;
 }, {
+    /**
+     * #getter
+     * determines which webworker to send the track to, currently based on trackId
+     */
     readonly rpcSessionId: any;
+    /**
+     * #getter
+     */
     readonly name: any;
+    /**
+     * #getter
+     */
     readonly textSearchAdapter: any;
     /**
-     * the PluggableElementType for the currently defined adapter
+     * #getter
      */
     readonly adapterType: import("..").AdapterType;
+    /**
+     * #getter
+     */
     readonly viewMenuActions: MenuItem[];
+    /**
+     * #getter
+     */
     readonly canConfigure: any;
 } & {
+    /**
+     * #action
+     */
+    setMinimized(flag: boolean): void;
+    /**
+     * #action
+     */
     activateConfigurationUI(): void;
+    /**
+     * #action
+     */
     showDisplay(displayId: string, initialSnapshot?: {}): void;
+    /**
+     * #action
+     */
     hideDisplay(displayId: string): number;
+    /**
+     * #action
+     */
     replaceDisplay(oldId: string, newId: string, initialSnapshot?: {}): void;
 } & {
+    /**
+     * #method
+     */
     trackMenuItems(): MenuItem[];
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export declare type BaseTrackStateModel = ReturnType<typeof createBaseTrackModel>;
-export declare type BaseTrackModel = Instance<BaseTrackStateModel>;
+export type BaseTrackStateModel = ReturnType<typeof createBaseTrackModel>;
+export type BaseTrackModel = Instance<BaseTrackStateModel>;