@jbrowse/core 2.1.7 → 2.2.0

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,8 +122,18 @@ 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;

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();

package/pluggableElementTypes/models/baseConnectionConfig.js

@@ -1,15 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("../../configuration");
+/**
+ * #config BaseConnection
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 exports.default = (0, configuration_1.ConfigurationSchema)('BaseConnection', {
+    /**
+     * #slot
+     */
     name: {
         type: 'string',
         defaultValue: 'nameOfConnection',
         description: 'a unique name for this connection',
     },
+    /**
+     * #slot
+     */
     assemblyNames: {
         type: 'stringArray',
         defaultValue: [],
         description: 'optional list of names of assemblies in this connection',
     },
-}, { explicitlyTyped: true, explicitIdentifier: 'connectionId' });
+}, {
+    explicitlyTyped: true,
+    /**
+     * #identifier
+     */
+    explicitIdentifier: 'connectionId',
+});

package/pluggableElementTypes/models/baseInternetAccountConfig.js

@@ -2,30 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseInternetAccountConfig = void 0;
 const configuration_1 = require("../../configuration");
+/**
+ * #config InternetAccount
+ * the "base" internet account type
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 exports.BaseInternetAccountConfig = (0, configuration_1.ConfigurationSchema)('InternetAccount', {
+    /**
+     * #slot
+     */
     name: {
         description: 'descriptive name of the internet account',
         type: 'string',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     description: {
         description: 'a description of the internet account',
         type: 'string',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     authHeader: {
         description: 'request header for credentials',
         type: 'string',
         defaultValue: 'Authorization',
     },
+    /**
+     * #slot
+     */
     tokenType: {
         description: 'a custom name for a token to include in the header',
         type: 'string',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     domains: {
         description: 'array of valid domains the url can contain to use this account',
         type: 'stringArray',
         defaultValue: [],
     },
-}, { explicitIdentifier: 'internetAccountId', explicitlyTyped: true });
+}, {
+    /**
+     * #identifier
+     */
+    explicitIdentifier: 'internetAccountId',
+    explicitlyTyped: true,
+});

package/pluggableElementTypes/models/baseTrackConfig.d.ts

@@ -1,5 +1,8 @@
 import { Instance } from 'mobx-state-tree';
 import PluginManager from '../../PluginManager';
+/**
+ * #config BaseTrack
+ */
 export declare function createBaseTrackConfig(pluginManager: PluginManager): import("../../configuration").AnyConfigurationSchemaType;
 export declare type BaseTrackConfigModel = ReturnType<typeof createBaseTrackConfig>;
 export declare type BaseTrackConfig = Instance<BaseTrackConfigModel>;

package/pluggableElementTypes/models/baseTrackConfig.js

@@ -4,65 +4,107 @@ exports.createBaseTrackConfig = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const mobx_state_tree_1 = require("mobx-state-tree");
 const configuration_1 = require("../../configuration");
+/**
+ * #config BaseTrack
+ */
 function createBaseTrackConfig(pluginManager) {
     return (0, configuration_1.ConfigurationSchema)('BaseTrack', {
+        /**
+         * #slot
+         */
         name: {
             description: 'descriptive name of the track',
             type: 'string',
             defaultValue: 'Track',
         },
+        /**
+         * #slot
+         */
         assemblyNames: {
             description: 'name of the assembly (or assemblies) track belongs to',
             type: 'stringArray',
             defaultValue: ['assemblyName'],
         },
+        /**
+         * #slot
+         */
         description: {
             description: 'a description of the track',
             type: 'string',
             defaultValue: '',
         },
+        /**
+         * #slot
+         */
         category: {
             description: 'the category and sub-categories of a track',
             type: 'stringArray',
             defaultValue: [],
         },
+        /**
+         * #slot
+         */
         metadata: {
             type: 'frozen',
             description: 'anything to add about this track',
             defaultValue: {},
         },
+        /**
+         * #slot
+         */
         adapter: pluginManager.pluggableConfigSchemaType('adapter'),
         textSearching: (0, configuration_1.ConfigurationSchema)('textSearching', {
+            /**
+             * #slot textSearching.indexedAttributes
+             */
             indexingAttributes: {
                 type: 'stringArray',
                 description: 'list of which feature attributes to index for text searching',
                 defaultValue: ['Name', 'ID'],
             },
+            /**
+             * #slot textSearching.indexingFeatureTypesToExclude
+             */
             indexingFeatureTypesToExclude: {
                 type: 'stringArray',
                 description: 'list of feature types to exclude in text search index',
                 defaultValue: ['CDS', 'exon'],
             },
+            /**
+             * #slot textSearching.textSearchAdapter
+             */
             textSearchAdapter: pluginManager.pluggableConfigSchemaType('text search adapter'),
         }),
+        /**
+         * #slot
+         */
         displays: mobx_state_tree_1.types.array(pluginManager.pluggableConfigSchemaType('display')),
         formatDetails: (0, configuration_1.ConfigurationSchema)('FormatDetails', {
+            /**
+             * #slot formatDetails.feature
+             */
             feature: {
                 type: 'frozen',
                 description: 'adds extra fields to the feature details',
                 defaultValue: {},
                 contextVariable: ['feature'],
             },
+            /**
+             * #slot formatDetails.subfeatures
+             */
             subfeatures: {
                 type: 'frozen',
                 description: 'adds extra fields to the subfeatures of a feature',
                 defaultValue: {},
                 contextVariable: ['feature'],
             },
+            /**
+             * #slot formatDetails.depth
+             */
             depth: {
                 type: 'number',
                 defaultValue: 2,
-                description: 'depth to iterate on subfeatures',
+                description: 'depth of subfeatures to iterate the formatter on formatDetails.subfeatures (e.g. you may not want to format the exon/cds subfeatures, so limited to 2',
             },
         }),
         formatAbout: (0, configuration_1.ConfigurationSchema)('FormatAbout', {

package/pluggableElementTypes/renderers/BoxRendererType.d.ts

@@ -1,9 +1,9 @@
 import GranularRectLayout from '../../util/layouts/GranularRectLayout';
 import MultiLayout from '../../util/layouts/MultiLayout';
+import { SerializedLayout, BaseLayout } from '../../util/layouts/BaseLayout';
 import PrecomputedLayout from '../../util/layouts/PrecomputedLayout';
 import FeatureRendererType, { RenderArgs as FeatureRenderArgs, RenderArgsSerialized as FeatureRenderArgsSerialized, RenderArgsDeserialized as FeatureRenderArgsDeserialized, RenderResults as FeatureRenderResults, ResultsSerialized as FeatureResultsSerialized, ResultsDeserialized as FeatureResultsDeserialized } from './FeatureRendererType';
 import { Region, Feature } from '../../util';
-import { SerializedLayout, BaseLayout } from '../../util/layouts/BaseLayout';
 import { AnyConfigurationModel } from '../../configuration';
 import SerializableFilterChain from './util/serializableFilterChain';
 import RpcManager from '../../rpc/RpcManager';

package/pluggableElementTypes/renderers/BoxRendererType.js

@@ -5,9 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayoutSession = void 0;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+// layouts
 const GranularRectLayout_1 = __importDefault(require("../../util/layouts/GranularRectLayout"));
 const MultiLayout_1 = __importDefault(require("../../util/layouts/MultiLayout"));
 const PrecomputedLayout_1 = __importDefault(require("../../util/layouts/PrecomputedLayout"));
+// other
 const FeatureRendererType_1 = __importDefault(require("./FeatureRendererType"));
 const util_1 = require("../../util");
 const configuration_1 = require("../../configuration");

package/rpc/MainThreadRpcDriver.d.ts

@@ -13,6 +13,6 @@ export default class MainThreadRpcDriver extends BaseRpcDriver {
     name: string;
     makeWorker: () => Promise<DummyHandle>;
     constructor(args: RpcDriverConstructorArgs);
-    call(pluginManager: PluginManager, sessionId: string, functionName: string, args: {}): Promise<unknown>;
+    call(pm: PluginManager, sessionId: string, funcName: string, args: {}): Promise<unknown>;
 }
 export {};

package/rpc/MainThreadRpcDriver.js

@@ -21,11 +21,11 @@ class MainThreadRpcDriver extends BaseRpcDriver_1.default {
         this.name = 'MainThreadRpcDriver';
         this.makeWorker = async () => new DummyHandle();
     }
-    async call(pluginManager, sessionId, functionName, args) {
+    async call(pm, sessionId, funcName, args) {
         if (!sessionId) {
             throw new TypeError('sessionId is required');
         }
-        const rpcMethod = pluginManager.getRpcMethodType(functionName);
+        const rpcMethod = pm.getRpcMethodType(funcName);
         const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
         const result = await rpcMethod.execute(serializedArgs, this.name);
         return rpcMethod.deserializeReturn(result, args, this.name);

package/rpc/WebWorkerRpcDriver.d.ts

@@ -4,12 +4,13 @@ import { PluginDefinition } from '../PluginLoader';
 interface WebWorkerRpcDriverConstructorArgs extends RpcDriverConstructorArgs {
     makeWorkerInstance: () => Worker;
 }
+interface Options {
+    statusCallback?: (arg0: string) => void;
+    rpcDriverClassName: string;
+}
 declare class WebWorkerHandle extends Rpc.Client {
     destroy(): void;
-    call(functionName: string, args: Record<string, unknown>, opts: {
-        statusCallback?: (arg0: string) => void;
-        rpcDriverClassName: string;
-    }): Promise<any>;
+    call(funcName: string, args: Record<string, unknown>, opts: Options): Promise<any>;
 }
 export default class WebWorkerRpcDriver extends BaseRpcDriver {
     workerBootConfiguration: {

package/rpc/WebWorkerRpcDriver.js

@@ -12,14 +12,14 @@ class WebWorkerHandle extends librpc_web_mod_1.default.Client {
     destroy() {
         this.workers[0].terminate();
     }
-    async call(functionName, args, opts) {
+    async call(funcName, args, opts) {
         const { statusCallback, rpcDriverClassName } = opts;
         const channel = `message-${shortid_1.default.generate()}`;
         const listener = (message) => {
             statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback(message);
         };
         this.on(channel, listener);
-        const result = await super.call(functionName, { ...args, channel, rpcDriverClassName }, opts);
+        const result = await super.call(funcName, { ...args, channel, rpcDriverClassName }, opts);
         this.off(channel, listener);
         return result;
     }