@jbrowse/core 2.1.7 → 2.2.1

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/CytobandAdapter.js

@@ -8,7 +8,14 @@ const simpleFeature_1 = __importDefault(require("../util/simpleFeature"));
 const configuration_1 = require("../configuration");
 const io_1 = require("../util/io");
 const BaseAdapter_1 = require("./BaseAdapter");
+/**
+ * #config CytobandAdapter
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 const configSchema = (0, configuration_1.ConfigurationSchema)('CytobandAdapter', {
+    /**
+     * #slot
+     */
     cytobandLocation: {
         type: 'fileLocation',
         defaultValue: { uri: '/path/to/cytoband.txt.gz' },

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.1.7",
+  "version": "2.2.1",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
     "jbrowse",
@@ -73,5 +73,5 @@
     "access": "public",
     "directory": "dist"
   },
-  "gitHead": "a1344081f61e22e0f597517efa7386023eef9f33"
+  "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

@@ -1,14 +1,26 @@
-import { Instance } from 'mobx-state-tree';
 import React from 'react';
+import { Instance } from 'mobx-state-tree';
 import { MenuItem } from '../../ui';
 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;
 } & {
+    /**
+     * #getter
+     */
     readonly RenderingComponent: React.FC<{
         model: {
             id: string;
@@ -18,8 +30,17 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
             rendererTypeName: string;
             error: unknown;
         } & 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;
@@ -28,6 +49,9 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
         onHorizontalScroll?: Function | undefined;
         blockState?: Record<string, any> | undefined;
     }>;
+    /**
+     * #getter
+     */
     readonly DisplayBlurb: React.FC<{
         model: {
             id: string;
@@ -37,34 +61,59 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
             rendererTypeName: string;
             error: unknown;
         } & 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;
             error: unknown;
         }, 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: React.FC<any> | undefined;
+    /**
+     * #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.
@@ -73,9 +122,19 @@ export declare const BaseDisplay: import("mobx-state-tree").IModelType<{
      */
     regionCannotBeRendered(): undefined;
 } & {
+    /**
+     * #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 declare type BaseDisplayStateModel = typeof BaseDisplay;
-export declare type BaseDisplayModel = Instance<BaseDisplayStateModel>;
+export type BaseDisplayStateModel = typeof BaseDisplay;
+export type BaseDisplayModel = Instance<BaseDisplayStateModel>;

package/pluggableElementTypes/models/BaseDisplayModel.js

@@ -1,101 +1,147 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseDisplay = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
 const mobx_state_tree_1 = require("mobx-state-tree");
+// locals
 const configuration_1 = require("../../configuration");
 const tracks_1 = require("../../util/tracks");
 const util_1 = require("../../util");
 const mst_1 = require("../../util/types/mst");
-exports.BaseDisplay = mobx_state_tree_1.types
-    .model('BaseDisplay', {
-    id: mst_1.ElementId,
-    type: mobx_state_tree_1.types.string,
-    rpcDriverName: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-})
-    .volatile(() => ({
-    rendererTypeName: '',
-    error: undefined,
-}))
-    .views(self => ({
-    get RenderingComponent() {
-        const { pluginManager } = (0, util_1.getEnv)(self);
-        const displayType = pluginManager.getDisplayType(self.type);
-        return displayType.ReactComponent;
-    },
-    get DisplayBlurb() {
-        return null;
-    },
-    get adapterConfig() {
-        return (0, configuration_1.getConf)(this.parentTrack, 'adapter');
-    },
-    get parentTrack() {
-        let track = (0, mobx_state_tree_1.getParent)(self);
-        while (!(track.configuration && (0, configuration_1.getConf)(track, 'trackId'))) {
-            if ((0, mobx_state_tree_1.isRoot)(track)) {
-                throw new Error(`No parent track found for ${self.type} ${self.id}`);
+/**
+ * #stateModel BaseDisplay
+ */
+function stateModelFactory() {
+    return mobx_state_tree_1.types
+        .model('BaseDisplay', {
+        /**
+         * #property
+         */
+        id: mst_1.ElementId,
+        /**
+         * #property
+         */
+        type: mobx_state_tree_1.types.string,
+        /**
+         * #property
+         */
+        rpcDriverName: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    })
+        .volatile(() => ({
+        rendererTypeName: '',
+        error: undefined,
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get RenderingComponent() {
+            const { pluginManager } = (0, util_1.getEnv)(self);
+            const displayType = pluginManager.getDisplayType(self.type);
+            return displayType.ReactComponent;
+        },
+        /**
+         * #getter
+         */
+        get DisplayBlurb() {
+            return null;
+        },
+        /**
+         * #getter
+         */
+        get adapterConfig() {
+            return (0, configuration_1.getConf)(this.parentTrack, 'adapter');
+        },
+        /**
+         * #getter
+         */
+        get parentTrack() {
+            let track = (0, mobx_state_tree_1.getParent)(self);
+            while (!(track.configuration && (0, configuration_1.getConf)(track, 'trackId'))) {
+                if ((0, mobx_state_tree_1.isRoot)(track)) {
+                    throw new Error(`No parent track found for ${self.type} ${self.id}`);
+                }
+                track = (0, mobx_state_tree_1.getParent)(track);
             }
-            track = (0, mobx_state_tree_1.getParent)(track);
-        }
-        return track;
-    },
-    /**
-     * the react props that are passed to the Renderer when data
-     * is rendered in this display
-     */
-    renderProps() {
-        return {
-            ...(0, tracks_1.getParentRenderProps)(self),
-            rpcDriverName: self.rpcDriverName,
-            displayModel: self,
-        };
-    },
-    /**
-     * the pluggable element type object for this display's
-     * renderer
-     */
-    get rendererType() {
-        const { pluginManager } = (0, util_1.getEnv)(self);
-        const RendererType = pluginManager.getRendererType(self.rendererTypeName);
-        if (!RendererType) {
-            throw new Error(`renderer "${self.rendererTypeName}" not found`);
-        }
-        if (!RendererType.ReactComponent) {
-            throw new Error(`renderer ${self.rendererTypeName} has no ReactComponent, it may not be completely implemented yet`);
-        }
-        return RendererType;
-    },
-    /**
-     * if a display-level message should be displayed instead,
-     * make this return a react component
-     */
-    get DisplayMessageComponent() {
-        return undefined;
-    },
-    trackMenuItems() {
-        return [];
-    },
-    get viewMenuActions() {
-        return [];
-    },
-    /**
-     * @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( /* region */) {
-        return undefined;
-    },
-}))
-    .actions(self => ({
-    setError(error) {
-        self.error = error;
-    },
-    setRpcDriverName(rpcDriverName) {
-        self.rpcDriverName = rpcDriverName;
-    },
-    // base display reload does nothing, see specialized displays for details
-    reload() { },
-}));
+            return track;
+        },
+        /**
+         * #method
+         * the react props that are passed to the Renderer when data
+         * is rendered in this display
+         */
+        renderProps() {
+            return {
+                ...(0, tracks_1.getParentRenderProps)(self),
+                rpcDriverName: self.rpcDriverName,
+                displayModel: self,
+            };
+        },
+        /**
+         * #getter
+         * the pluggable element type object for this display's
+         * renderer
+         */
+        get rendererType() {
+            const { pluginManager } = (0, util_1.getEnv)(self);
+            const RendererType = pluginManager.getRendererType(self.rendererTypeName);
+            if (!RendererType) {
+                throw new Error(`renderer "${self.rendererTypeName}" not found`);
+            }
+            if (!RendererType.ReactComponent) {
+                throw new Error(`renderer ${self.rendererTypeName} has no ReactComponent, it may not be completely implemented yet`);
+            }
+            return RendererType;
+        },
+        /**
+         * #getter
+         * if a display-level message should be displayed instead,
+         * make this return a react component
+         */
+        get DisplayMessageComponent() {
+            return undefined;
+        },
+        /**
+         * #method
+         */
+        trackMenuItems() {
+            return [];
+        },
+        /**
+         * #getter
+         */
+        get viewMenuActions() {
+            return [];
+        },
+        /**
+         * #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( /* region */) {
+            return undefined;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setError(error) {
+            self.error = error;
+        },
+        /**
+         * #action
+         */
+        setRpcDriverName(rpcDriverName) {
+            self.rpcDriverName = rpcDriverName;
+        },
+        /**
+         * #action
+         * base display reload does nothing, see specialized displays for details
+         */
+        reload() { },
+    }));
+}
+exports.BaseDisplay = stateModelFactory();