@jbrowse/core 2.2.0 → 2.2.2

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

package/pluggableElementTypes/models/BaseTrackModel.js

@@ -7,35 +7,64 @@ const configuration_1 = require("../../configuration");
 const util_1 = require("../../util");
 const types_1 = require("../../util/types");
 const mst_1 = require("../../util/types/mst");
-// 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.
-function createBaseTrackModel(pluginManager, trackType, baseTrackConfig) {
+/**
+ * #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.
+ */
+function createBaseTrackModel(pm, trackType, baseTrackConfig) {
     return mobx_state_tree_1.types
         .model(trackType, {
+        /**
+         * #property
+         */
         id: mst_1.ElementId,
+        /**
+         * #property
+         */
         type: mobx_state_tree_1.types.literal(trackType),
+        /**
+         * #property
+         */
         configuration: (0, configuration_1.ConfigurationReference)(baseTrackConfig),
-        displays: mobx_state_tree_1.types.array(pluginManager.pluggableMstType('display', 'stateModel')),
+        /**
+         * #property
+         */
+        minimized: false,
+        /**
+         * #property
+         */
+        displays: mobx_state_tree_1.types.array(pm.pluggableMstType('display', 'stateModel')),
     })
         .views(self => ({
+        /**
+         * #getter
+         * determines which webworker to send the track to, currently based on trackId
+         */
         get rpcSessionId() {
             return self.configuration.trackId;
         },
+        /**
+         * #getter
+         */
         get name() {
             return (0, configuration_1.getConf)(self, 'name');
         },
+        /**
+         * #getter
+         */
         get textSearchAdapter() {
             return (0, configuration_1.getConf)(self, 'textSearchAdapter');
         },
         /**
-         * the PluggableElementType for the currently defined adapter
+         * #getter
          */
         get adapterType() {
             const adapterConfig = (0, configuration_1.getConf)(self, 'adapter');
-            const { pluginManager: pm } = (0, util_1.getEnv)(self);
             if (!adapterConfig) {
                 throw new Error(`no adapter configuration provided for ${self.type}`);
             }
@@ -45,13 +74,15 @@ function createBaseTrackModel(pluginManager, trackType, baseTrackConfig) {
             }
             return adapterType;
         },
+        /**
+         * #getter
+         */
         get viewMenuActions() {
-            const menuItems = [];
-            self.displays.forEach(display => {
-                menuItems.push(...display.viewMenuActions);
-            });
-            return menuItems;
+            return self.displays.map(d => d.viewMenuActions).flat();
         },
+        /**
+         * #getter
+         */
         get canConfigure() {
             const session = (0, util_1.getSession)(self);
             return ((0, types_1.isSessionModelWithConfigEditing)(session) &&
@@ -64,6 +95,15 @@ function createBaseTrackModel(pluginManager, trackType, baseTrackConfig) {
         },
     }))
         .actions(self => ({
+        /**
+         * #action
+         */
+        setMinimized(flag) {
+            self.minimized = flag;
+        },
+        /**
+         * #action
+         */
         activateConfigurationUI() {
             const session = (0, util_1.getSession)(self);
             const view = (0, util_1.getContainingView)(self);
@@ -78,10 +118,13 @@ function createBaseTrackModel(pluginManager, trackType, baseTrackConfig) {
                 }
             }
         },
+        /**
+         * #action
+         */
         showDisplay(displayId, initialSnapshot = {}) {
-            const schema = pluginManager.pluggableConfigSchemaType('display');
+            const schema = pm.pluggableConfigSchemaType('display');
             const conf = (0, mobx_state_tree_1.resolveIdentifier)(schema, (0, mobx_state_tree_1.getRoot)(self), displayId);
-            const displayType = pluginManager.getDisplayType(conf.type);
+            const displayType = pm.getDisplayType(conf.type);
             if (!displayType) {
                 throw new Error(`unknown display type ${conf.type}`);
             }
@@ -92,21 +135,27 @@ function createBaseTrackModel(pluginManager, trackType, baseTrackConfig) {
             });
             self.displays.push(display);
         },
+        /**
+         * #action
+         */
         hideDisplay(displayId) {
-            const schema = pluginManager.pluggableConfigSchemaType('display');
+            const schema = pm.pluggableConfigSchemaType('display');
             const conf = (0, mobx_state_tree_1.resolveIdentifier)(schema, (0, mobx_state_tree_1.getRoot)(self), displayId);
             const t = self.displays.filter(d => d.configuration === conf);
             (0, mobx_1.transaction)(() => t.forEach(d => self.displays.remove(d)));
             return t.length;
         },
+        /**
+         * #action
+         */
         replaceDisplay(oldId, newId, initialSnapshot = {}) {
             const idx = self.displays.findIndex(d => d.configuration.displayId === oldId);
             if (idx === -1) {
                 throw new Error(`could not find display id ${oldId} to replace`);
             }
-            const schema = pluginManager.pluggableConfigSchemaType('display');
+            const schema = pm.pluggableConfigSchemaType('display');
             const conf = (0, mobx_state_tree_1.resolveIdentifier)(schema, (0, mobx_state_tree_1.getRoot)(self), newId);
-            const displayType = pluginManager.getDisplayType(conf.type);
+            const displayType = pm.getDisplayType(conf.type);
             if (!displayType) {
                 throw new Error(`unknown display type ${conf.type}`);
             }
@@ -118,16 +167,18 @@ function createBaseTrackModel(pluginManager, trackType, baseTrackConfig) {
         },
     }))
         .views(self => ({
+        /**
+         * #method
+         */
         trackMenuItems() {
-            const menuItems = [];
-            self.displays.forEach(display => {
-                menuItems.push(...display.trackMenuItems());
-            });
+            const menuItems = self.displays
+                .map(d => d.trackMenuItems())
+                .flat();
             const displayChoices = [];
             const view = (0, util_1.getContainingView)(self);
-            const viewType = pluginManager.getViewType(view.type);
-            const compatibleDisplayTypes = viewType.displayTypes.map(displayType => displayType.name);
-            const compatibleDisplays = self.configuration.displays.filter((displayConf) => compatibleDisplayTypes.includes(displayConf.type));
+            const viewType = pm.getViewType(view.type);
+            const compatibleDisplayTypes = viewType.displayTypes.map(d => d.name);
+            const compatibleDisplays = self.configuration.displays.filter((d) => compatibleDisplayTypes.includes(d.type));
             const shownId = self.displays[0].configuration.displayId;
             if (compatibleDisplays.length > 1) {
                 displayChoices.push({ type: 'divider' }, { type: 'subHeader', label: 'Display types' });

package/pluggableElementTypes/models/BaseViewModel.d.ts

@@ -3,13 +3,35 @@ import { MenuItem } from '../../ui';
 declare const BaseViewModel: import("mobx-state-tree").IModelType<{
     id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
     displayName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    minimized: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
 }, {
     width: number;
 } & {
+    /**
+     * #getter
+     */
     menuItems(): MenuItem[];
 } & {
+    /**
+     * #action
+     */
     setDisplayName(name: string): void;
+    /**
+     * #action
+     * width is an important attribute of the view model, when it becomes set, it
+     * often indicates when the app can start drawing to it. certain views like
+     * lgv are strict about this because if it tries to draw before it knows the
+     * width it should draw to, it may start fetching data for regions it doesn't
+     * need to
+     *
+     * setWidth is updated by a ResizeObserver generally, the views often need
+     * to know how wide they are to properly draw genomic regions
+     */
     setWidth(newWidth: number): void;
+    /**
+     * #action
+     */
+    setMinimized(flag: boolean): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export default BaseViewModel;
 export interface IBaseViewModel extends Instance<typeof BaseViewModel> {

package/pluggableElementTypes/models/BaseViewModel.js

@@ -2,25 +2,64 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const mobx_state_tree_1 = require("mobx-state-tree");
 const mst_1 = require("../../util/types/mst");
+/**
+ * #stateModel BaseViewModel
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 const BaseViewModel = mobx_state_tree_1.types
     .model('BaseView', {
+    /**
+     * #property
+     */
     id: mst_1.ElementId,
+    /**
+     * #property
+     * displayName is displayed in the header of the view, or assembly names
+     * being used if none is specified
+     */
     displayName: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+    /**
+     * #property
+     */
+    minimized: false,
 })
-    .volatile(( /* self */) => ({
+    .volatile(() => ({
     width: 800,
 }))
-    .views(( /* self */) => ({
+    .views(() => ({
+    /**
+     * #getter
+     */
     menuItems() {
         return [];
     },
 }))
     .actions(self => ({
+    /**
+     * #action
+     */
     setDisplayName(name) {
         self.displayName = name;
     },
+    /**
+     * #action
+     * width is an important attribute of the view model, when it becomes set, it
+     * often indicates when the app can start drawing to it. certain views like
+     * lgv are strict about this because if it tries to draw before it knows the
+     * width it should draw to, it may start fetching data for regions it doesn't
+     * need to
+     *
+     * setWidth is updated by a ResizeObserver generally, the views often need
+     * to know how wide they are to properly draw genomic regions
+     */
     setWidth(newWidth) {
         self.width = newWidth;
     },
+    /**
+     * #action
+     */
+    setMinimized(flag) {
+        self.minimized = flag;
+    },
 }));
 exports.default = BaseViewModel;

package/pluggableElementTypes/models/InternetAccountModel.d.ts

@@ -3,52 +3,92 @@ import { Instance } from 'mobx-state-tree';
 import { RemoteFileWithRangeCache } from '../../util/io';
 import { UriLocation, AnyReactComponentType } from '../../util/types';
 export declare const InternetAccount: 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>;
 }, {
+    /**
+     * #getter
+     */
     readonly name: string;
+    /**
+     * #getter
+     */
     readonly description: string;
+    /**
+     * #getter
+     */
     readonly internetAccountId: string;
+    /**
+     * #getter
+     */
     readonly authHeader: string;
+    /**
+     * #getter
+     */
     readonly tokenType: string;
+    /**
+     * #getter
+     */
     readonly domains: string[];
     /**
+     * #getter
      * Can use this to customize what is displayed in fileSelector's toggle box
      */
     readonly toggleContents: React.ReactNode;
     /**
+     * #getter
      * Can use this to customize what the fileSelector. It takes a prop called
      * `setLocation` that should be used to set a UriLocation
      */
     readonly SelectorComponent: AnyReactComponentType | undefined;
     /**
+     * #getter
      * Can use this to add a label to the UrlChooser. Has no effect if a custom
      * SelectorComponent is supplied
      */
     readonly selectorLabel: string | undefined;
 } & {
     /**
+     * #method
      * Determine whether this internetAccount provides credentials for a URL
      * @param location  - UriLocation of resource
      * @returns true or false
      */
     handlesLocation(location: UriLocation): boolean;
     /**
+     * #getter
      * The key used to store this internetAccount's token in sessionStorage
      */
     readonly tokenKey: string;
 } & {
     /**
+     * #action
      * Must be implemented by a model extending or composing this one. Pass the
      * user's token to `resolve`.
      * @param resolve - Pass the token to this function
      * @param reject - If there is an error getting the token, call this function
      */
     getTokenFromUser(resolve: (token: string) => void, reject: (error: Error) => void): void;
+    /**
+     * #action
+     */
     storeToken(token: string): void;
+    /**
+     * #action
+     */
     removeToken(): void;
+    /**
+     * #action
+     */
     retrieveToken(): string | null;
     /**
+     * #action
      * This can be used by an internetAccount to validate a token works before
      * it is used. This is run when preAuthorizationInformation is requested, so
      * it can be used to check that a token is valid before sending it to a
@@ -57,12 +97,13 @@ export declare const InternetAccount: import("mobx-state-tree").IModelType<{
      * if the original one was invalid. Should throw an error if a token is
      * invalid.
      * @param token - Auth token
-     * @param location - UriLocation of the resource
+     * @param loc - UriLocation of the resource
      * @returns - Valid auth token
      */
-    validateToken(token: string, location: UriLocation): Promise<string>;
+    validateToken(token: string, loc: UriLocation): Promise<string>;
 } & {
     /**
+     * #action
      * Try to get the token from the location pre-auth, from local storage,
      * or from a previously cached promise. If token is not available, uses
      * `getTokenFromUser`.
@@ -71,6 +112,9 @@ export declare const InternetAccount: import("mobx-state-tree").IModelType<{
      */
     getToken(location?: UriLocation): Promise<string>;
 } & {
+    /**
+     * #action
+     */
     addAuthHeaderToInit(init: RequestInit | undefined, token: string): {
         headers: Headers;
         body?: BodyInit | null | undefined;
@@ -87,6 +131,7 @@ export declare const InternetAccount: import("mobx-state-tree").IModelType<{
         window?: null | undefined;
     };
     /**
+     * #action
      * Gets the token and returns it along with the information needed to
      * create a new internetAccount.
      * @param location - UriLocation of the resource
@@ -101,20 +146,22 @@ export declare const InternetAccount: import("mobx-state-tree").IModelType<{
     }>;
 } & {
     /**
+     * #action
      * Get a fetch method that will add any needed authentication headers to
      * the request before sending it. If location is provided, it will be
      * checked to see if it includes a token in it pre-auth information.
-     * @param location - UriLocation of the resource
+     * @param loc - UriLocation of the resource
      * @returns A function that can be used to fetch
      */
-    getFetcher(location?: UriLocation): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+    getFetcher(loc?: UriLocation): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
 } & {
     /**
+     * #action
      * Gets a filehandle that uses a fetch that adds auth headers
      * @param location - UriLocation of the resource
      * @returns A filehandle
      */
     openLocation(location: UriLocation): RemoteFileWithRangeCache;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export declare type BaseInternetAccountStateModel = typeof InternetAccount;
-export declare type BaseInternetAccountModel = Instance<BaseInternetAccountStateModel>;
+export type BaseInternetAccountStateModel = typeof InternetAccount;
+export type BaseInternetAccountModel = Instance<BaseInternetAccountStateModel>;