@jbrowse/core 2.4.2 → 2.5.0

package/PluginManager.d.ts

@@ -99,6 +99,7 @@ export default class PluginManager {
     getElementType(groupName: PluggableElementTypeGroup, typeName: string): PluggableElementBase;
     getElementTypesInGroup(groupName: PluggableElementTypeGroup): PluggableElementBase[];
     getTrackElements(): TrackType[];
+    getConnectionElements(): ConnectionType[];
     getAddTrackWorkflowElements(): AddTrackWorkflowType[];
     getRpcElements(): RpcMethodType[];
     getDisplayElements(): DisplayType[];
@@ -214,11 +215,12 @@ export default class PluginManager {
         mobx: typeof import("mobx");
         'mobx-state-tree': typeof import("mobx-state-tree");
         react: typeof import("react");
+        'react/jsx-runtime': typeof import("react/jsx-runtime");
         'react-dom': typeof import("react-dom");
         'mobx-react': typeof import("mobx-react");
         '@mui/x-data-grid': {
             useGridApiContext: typeof import("@mui/x-data-grid").useGridApiContext;
-            useGridApiRef: <Api extends import("@mui/x-data-grid").GridApiCommon = import("@mui/x-data-grid/models/api/gridApiCommunity").GridApiCommunity>() => import("react").MutableRefObject<Api>;
+            useGridApiRef: <Api extends import("@mui/x-data-grid").GridApiCommon<any, any> = import("@mui/x-data-grid/internals").GridApiCommunity>() => import("react").MutableRefObject<Api>;
             useGridRootProps: () => import("@mui/x-data-grid/models/props/DataGridProps").DataGridProcessedProps<any>;
         };
         '@mui/material/utils': typeof import("@mui/material/utils");
@@ -243,7 +245,8 @@ export default class PluginManager {
             makeStyles: (args: any) => () => Record<string, string>;
         };
         '@mui/material': {
-            [k: string]: (props: any) => JSX.Element;
+            alpha: typeof import("@mui/system").alpha;
+            useTheme: typeof import("@mui/material").useTheme;
         };
         'prop-types': typeof import("prop-types");
         '@mui/material/styles': typeof import("@mui/material/styles");

package/PluginManager.js

@@ -236,6 +236,9 @@ class PluginManager {
     getTrackElements() {
         return this.getElementTypesInGroup('track');
     }
+    getConnectionElements() {
+        return this.getElementTypesInGroup('connection');
+    }
     getAddTrackWorkflowElements() {
         return this.getElementTypesInGroup('add track workflow');
     }

package/ReExports/list.js

@@ -9,6 +9,7 @@ exports.default = [
     'mobx',
     'mobx-state-tree',
     'react',
+    'react/jsx-runtime',
     'react-dom',
     'mobx-react',
     '@mui/x-data-grid',

package/ReExports/modules.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import * as ReactJSXRuntime from 'react/jsx-runtime';
 import * as ReactDom from 'react-dom';
 import * as mobx from 'mobx';
 import * as mst from 'mobx-state-tree';
@@ -131,11 +132,12 @@ declare const libs: {
     mobx: typeof mobx;
     'mobx-state-tree': typeof mst;
     react: typeof React;
+    'react/jsx-runtime': typeof ReactJSXRuntime;
     'react-dom': typeof ReactDom;
     'mobx-react': typeof mxreact;
     '@mui/x-data-grid': {
         useGridApiContext: typeof useGridApiContext;
-        useGridApiRef: <Api extends import("@mui/x-data-grid").GridApiCommon = import("@mui/x-data-grid/models/api/gridApiCommunity").GridApiCommunity>() => React.MutableRefObject<Api>;
+        useGridApiRef: <Api extends import("@mui/x-data-grid").GridApiCommon<any, any> = import("@mui/x-data-grid/internals").GridApiCommunity>() => React.MutableRefObject<Api>;
         useGridRootProps: () => import("@mui/x-data-grid/models/props/DataGridProps").DataGridProcessedProps<any>;
     };
     '@mui/material/utils': typeof MUIUtils;
@@ -160,7 +162,8 @@ declare const libs: {
         makeStyles: (args: any) => () => Record<string, string>;
     };
     '@mui/material': {
-        [k: string]: (props: any) => JSX.Element;
+        alpha: typeof MUIStyles.alpha;
+        useTheme: typeof MUIStyles.useTheme;
     };
     'prop-types': typeof PropTypes;
     '@mui/material/styles': typeof MUIStyles;

package/ReExports/modules.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // this is all the stuff that the pluginManager re-exports for plugins to use
 const react_1 = __importStar(require("react"));
+const ReactJSXRuntime = __importStar(require("react/jsx-runtime"));
 const ReactDom = __importStar(require("react-dom"));
 const mobx = __importStar(require("mobx"));
 const mst = __importStar(require("mobx-state-tree"));
@@ -208,9 +209,6 @@ const DataGridEntries = {
     GridArrowUpwardIcon: (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('@mui/x-data-grid'))).then(module => ({
         default: module.GridArrowUpwardIcon,
     }))),
-    GridAutoSizer: (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('@mui/x-data-grid'))).then(module => ({
-        default: module.GridAutoSizer,
-    }))),
     GridCellCheckboxForwardRef: (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('@mui/x-data-grid'))).then(module => ({
         default: module.GridCellCheckboxForwardRef,
     }))),
@@ -373,6 +371,7 @@ const libs = {
     mobx,
     'mobx-state-tree': mst,
     react: react_1.default,
+    'react/jsx-runtime': ReactJSXRuntime,
     'react-dom': ReactDom,
     'mobx-react': mxreact,
     '@mui/x-data-grid': {
@@ -395,7 +394,11 @@ const libs = {
             return () => useStyles().classes;
         },
     },
-    '@mui/material': LazyMUICore,
+    '@mui/material': {
+        ...LazyMUICore,
+        alpha: MUIStyles.alpha,
+        useTheme: MUIStyles.useTheme,
+    },
     'prop-types': prop_types_1.default,
     // end special case
     // material-ui subcomponents, should get rid of these

package/TextSearch/TextSearchManager.d.ts

@@ -1,15 +1,8 @@
 import BaseResult from './BaseResults';
 import PluginManager from '../PluginManager';
 import QuickLRU from '../util/QuickLRU';
-import { SearchType, BaseTextSearchAdapter } from '../data_adapters/BaseAdapter';
+import { BaseTextSearchAdapter, BaseTextSearchArgs } from '../data_adapters/BaseAdapter';
 import { AnyConfigurationModel } from '../configuration';
-export interface BaseArgs {
-    queryString: string;
-    searchType?: SearchType;
-    signal?: AbortSignal;
-    limit?: number;
-    pageNumber?: number;
-}
 export interface SearchScope {
     includeAggregateIndexes: boolean;
     assemblyName: string;
@@ -36,7 +29,7 @@ export default class TextSearchManager {
      * @param args - search options/arguments include: search query
      * limit of results to return, searchType...prefix | full | exact", etc.
      */
-    search(args: BaseArgs, searchScope: SearchScope, rankFn: (results: BaseResult[]) => BaseResult[]): Promise<BaseResult[]>;
+    search(args: BaseTextSearchArgs, searchScope: SearchScope, rankFn: (results: BaseResult[]) => BaseResult[]): Promise<BaseResult[]>;
     /**
      * Returns array of revelevant and sorted results
      * @param results - array of results from all text search adapters

package/assemblyManager/assembly.d.ts

@@ -1,12 +1,9 @@
 import { Instance, IAnyType } from 'mobx-state-tree';
+import { BaseOptions } from '../data_adapters/BaseAdapter';
 import PluginManager from '../PluginManager';
 import { Region, Feature } from '../util';
-type RefNameAliases = Record<string, string>;
-export interface BaseOptions {
-    signal?: AbortSignal;
-    sessionId: string;
-    statusCallback?: Function;
-}
+import RpcManager from '../rpc/RpcManager';
+type RefNameAliases = Record<string, string | undefined>;
 export interface RefNameMap {
     forwardMap: RefNameAliases;
     reverseMap: RefNameAliases;
@@ -23,7 +20,13 @@ export interface Loading {
     lowerCaseRefNameAliases: RefNameAliases;
     cytobands: Feature[];
 }
+/**
+ * #stateModel Assembly
+ */
 export default function assemblyFactory(assemblyConfigType: IAnyType, pm: PluginManager): import("mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
     configuration: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<IAnyType>>;
 }, {
     error: unknown;
@@ -34,40 +37,120 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pm: Plugin
     lowerCaseRefNameAliases: RefNameAliases | undefined;
     cytobands: Feature[] | undefined;
 } & {
+    /**
+     * #getter
+     */
     readonly initialized: boolean;
+    /**
+     * #getter
+     */
     readonly name: string;
+    /**
+     * #getter
+     */
     readonly regions: BasicRegion[] | undefined;
+    /**
+     * #getter
+     */
     readonly aliases: string[];
+    /**
+     * #getter
+     */
     readonly displayName: string | undefined;
+    /**
+     * #getter
+     */
     hasName(name: string): boolean;
+    /**
+     * #getter
+     */
     readonly allAliases: string[];
+    /**
+     * #getter
+     * note: lowerCaseRefNameAliases not included here: this allows the list
+     * of refnames to be just the "normal casing", but things like
+     * getCanonicalRefName can resolve a lower-case name if needed
+     */
     readonly allRefNames: string[] | undefined;
+    /**
+     * #getter
+     */
     readonly lowerCaseRefNames: string[] | undefined;
+    /**
+     * #getter
+     */
     readonly allRefNamesWithLowerCase: string[] | undefined;
-    readonly rpcManager: any;
+    /**
+     * #getter
+     */
+    readonly rpcManager: RpcManager;
+    /**
+     * #getter
+     */
     readonly refNameColors: string[];
 } & {
+    /**
+     * #getter
+     */
     readonly refNames: string[] | undefined;
 } & {
-    getCanonicalRefName(refName: string): string;
+    /**
+     * #method
+     */
+    getCanonicalRefName(refName: string): string | undefined;
+    /**
+     * #method
+     */
     getRefNameColor(refName: string): string | undefined;
+    /**
+     * #method
+     */
     isValidRefName(refName: string): boolean;
 } & {
+    /**
+     * #action
+     */
     setLoaded({ adapterRegionsWithAssembly, refNameAliases, lowerCaseRefNameAliases, cytobands, }: Loading): void;
+    /**
+     * #action
+     */
     setError(e: unknown): void;
+    /**
+     * #action
+     */
     setRegions(regions: Region[]): void;
+    /**
+     * #action
+     */
     setRefNameAliases(aliases: RefNameAliases, lcAliases: RefNameAliases): void;
+    /**
+     * #action
+     */
     setCytobands(cytobands: Feature[]): void;
+    /**
+     * #action
+     */
     setLoadingP(p?: Promise<void>): void;
+    /**
+     * #action
+     */
     load(): Promise<void>;
+    /**
+     * #action
+     */
     loadPre(): Promise<void>;
 } & {
+    /**
+     * #method
+     */
     getAdapterMapEntry(adapterConf: unknown, options: BaseOptions): Promise<RefNameMap>;
     /**
+     * #method
      * get Map of `canonical-name -> adapter-specific-name`
      */
     getRefNameMapForAdapter(adapterConf: unknown, opts: BaseOptions): Promise<RefNameAliases>;
     /**
+     * #method
      * get Map of `adapter-specific-name -> canonical-name`
      */
     getReverseRefNameMapForAdapter(adapterConf: unknown, opts: BaseOptions): Promise<RefNameAliases>;

package/assemblyManager/assembly.js

@@ -49,7 +49,7 @@ async function loadRefNameMap(assembly, adapterConfig, options, signal) {
         signal,
         name: 'when assembly ready',
     });
-    const refNames = (await assembly.rpcManager.call(sessionId, 'CoreGetRefNames', {
+    const refNames = (await assembly.rpcManager.call(sessionId || 'assemblyRpc', 'CoreGetRefNames', {
         adapterConfig,
         signal,
         ...options,
@@ -81,9 +81,13 @@ function checkRefName(refName) {
 function getAdapterId(adapterConf) {
     return (0, json_stable_stringify_1.default)(adapterConf);
 }
+/**
+ * #stateModel Assembly
+ */
 function assemblyFactory(assemblyConfigType, pm) {
     const adapterLoads = new abortable_promise_cache_1.default({
         cache: new QuickLRU_1.default({ maxSize: 1000 }),
+        // @ts-expect-error
         async fill(args, signal, statusCallback) {
             const { adapterConf, self, options } = args;
             return loadRefNameMap(self, adapterConf, { ...options, statusCallback }, signal);
@@ -91,6 +95,9 @@ function assemblyFactory(assemblyConfigType, pm) {
     });
     return mobx_state_tree_1.types
         .model({
+        /**
+         * #property
+         */
         configuration: mobx_state_tree_1.types.safeReference(assemblyConfigType),
     })
         .volatile(() => ({
@@ -103,71 +110,116 @@ function assemblyFactory(assemblyConfigType, pm) {
         cytobands: undefined,
     }))
         .views(self => ({
+        /**
+         * #getter
+         */
         get initialized() {
             // @ts-expect-error
             self.load();
             return !!self.refNameAliases;
         },
+        /**
+         * #getter
+         */
         get name() {
             return (0, configuration_1.getConf)(self, 'name');
         },
+        /**
+         * #getter
+         */
         get regions() {
             // @ts-expect-error
             self.load();
             return self.volatileRegions;
         },
+        /**
+         * #getter
+         */
         get aliases() {
             return (0, configuration_1.getConf)(self, 'aliases');
         },
+        /**
+         * #getter
+         */
         get displayName() {
             return (0, configuration_1.getConf)(self, 'displayName');
         },
+        /**
+         * #getter
+         */
         hasName(name) {
             return this.allAliases.includes(name);
         },
+        /**
+         * #getter
+         */
         get allAliases() {
             return [this.name, ...this.aliases];
         },
-        // note: lowerCaseRefNameAliases not included here: this allows the list
-        // of refnames to be just the "normal casing", but things like
-        // getCanonicalRefName can resolve a lower-case name if needed
+        /**
+         * #getter
+         * note: lowerCaseRefNameAliases not included here: this allows the list
+         * of refnames to be just the "normal casing", but things like
+         * getCanonicalRefName can resolve a lower-case name if needed
+         */
         get allRefNames() {
             return !self.refNameAliases
                 ? undefined
                 : Object.keys(self.refNameAliases);
         },
+        /**
+         * #getter
+         */
         get lowerCaseRefNames() {
             return !self.lowerCaseRefNameAliases
                 ? undefined
                 : Object.keys(self.lowerCaseRefNameAliases || {});
         },
+        /**
+         * #getter
+         */
         get allRefNamesWithLowerCase() {
             return this.allRefNames && this.lowerCaseRefNames
                 ? [...new Set([...this.allRefNames, ...this.lowerCaseRefNames])]
                 : undefined;
         },
+        /**
+         * #getter
+         */
         get rpcManager() {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             return (0, mobx_state_tree_1.getParent)(self, 2).rpcManager;
         },
+        /**
+         * #getter
+         */
         get refNameColors() {
             const colors = (0, configuration_1.getConf)(self, 'refNameColors');
             return colors.length === 0 ? refNameColors : colors;
         },
     }))
         .views(self => ({
+        /**
+         * #getter
+         */
         get refNames() {
             var _a;
             return (_a = self.regions) === null || _a === void 0 ? void 0 : _a.map(region => region.refName);
         },
     }))
         .views(self => ({
+        /**
+         * #method
+         */
         getCanonicalRefName(refName) {
             if (!self.refNameAliases || !self.lowerCaseRefNameAliases) {
                 throw new Error('aliases not loaded, we expect them to be loaded before getCanonicalRefName can be called');
             }
             return (self.refNameAliases[refName] || self.lowerCaseRefNameAliases[refName]);
         },
+        /**
+         * #method
+         */
         getRefNameColor(refName) {
             if (!self.refNames) {
                 return undefined;
@@ -178,6 +230,9 @@ function assemblyFactory(assemblyConfigType, pm) {
             }
             return self.refNameColors[idx % self.refNameColors.length];
         },
+        /**
+         * #method
+         */
         isValidRefName(refName) {
             if (!self.refNameAliases) {
                 throw new Error('isValidRefName cannot be called yet, the assembly has not finished loading');
@@ -186,29 +241,50 @@ function assemblyFactory(assemblyConfigType, pm) {
         },
     }))
         .actions(self => ({
+        /**
+         * #action
+         */
         setLoaded({ adapterRegionsWithAssembly, refNameAliases, lowerCaseRefNameAliases, cytobands, }) {
             self.loaded = true;
             this.setRegions(adapterRegionsWithAssembly);
             this.setRefNameAliases(refNameAliases, lowerCaseRefNameAliases);
             this.setCytobands(cytobands);
         },
+        /**
+         * #action
+         */
         setError(e) {
             console.error(e);
             self.error = e;
         },
+        /**
+         * #action
+         */
         setRegions(regions) {
             self.volatileRegions = regions;
         },
+        /**
+         * #action
+         */
         setRefNameAliases(aliases, lcAliases) {
             self.refNameAliases = aliases;
             self.lowerCaseRefNameAliases = lcAliases;
         },
+        /**
+         * #action
+         */
         setCytobands(cytobands) {
             self.cytobands = cytobands;
         },
+        /**
+         * #action
+         */
         setLoadingP(p) {
             self.loadingP = p;
         },
+        /**
+         * #action
+         */
         load() {
             if (!self.loadingP) {
                 self.loadingP = this.loadPre().catch(e => {
@@ -218,12 +294,15 @@ function assemblyFactory(assemblyConfigType, pm) {
             }
             return self.loadingP;
         },
+        /**
+         * #action
+         */
         async loadPre() {
             var _a, _b;
             const conf = self.configuration;
-            const refNameAliasesAdapterConf = (_a = conf.refNameAliases) === null || _a === void 0 ? void 0 : _a.adapter;
-            const cytobandAdapterConf = (_b = conf.cytobands) === null || _b === void 0 ? void 0 : _b.adapter;
-            const sequenceAdapterConf = conf.sequence.adapter;
+            const refNameAliasesAdapterConf = (_a = conf === null || conf === void 0 ? void 0 : conf.refNameAliases) === null || _a === void 0 ? void 0 : _a.adapter;
+            const cytobandAdapterConf = (_b = conf === null || conf === void 0 ? void 0 : conf.cytobands) === null || _b === void 0 ? void 0 : _b.adapter;
+            const sequenceAdapterConf = conf === null || conf === void 0 ? void 0 : conf.sequence.adapter;
             const assemblyName = self.name;
             const regions = await getAssemblyRegions(sequenceAdapterConf, pm);
             const adapterRegionsWithAssembly = regions.map(r => {
@@ -256,6 +335,9 @@ function assemblyFactory(assemblyConfigType, pm) {
         },
     }))
         .views(self => ({
+        /**
+         * #method
+         */
         getAdapterMapEntry(adapterConf, options) {
             const { signal, statusCallback, ...rest } = options;
             if (!options.sessionId) {
@@ -272,16 +354,18 @@ function assemblyFactory(assemblyConfigType, pm) {
             undefined, statusCallback);
         },
         /**
+         * #method
          * get Map of `canonical-name -> adapter-specific-name`
          */
         async getRefNameMapForAdapter(adapterConf, opts) {
-            if (!opts || !opts.sessionId) {
+            if (!(opts === null || opts === void 0 ? void 0 : opts.sessionId)) {
                 throw new Error('sessionId is required');
             }
             const map = await this.getAdapterMapEntry(adapterConf, opts);
             return map.forwardMap;
         },
         /**
+         * #method
          * get Map of `adapter-specific-name -> canonical-name`
          */
         async getReverseRefNameMapForAdapter(adapterConf, opts) {

package/assemblyManager/assemblyConfigSchema.d.ts

@@ -3,5 +3,54 @@ import PluginManager from '../PluginManager';
  * #config BaseAssembly
  * This corresponds to the assemblies section of the config
  */
-declare function assemblyConfigSchema(pluginManager: PluginManager): import("../configuration").AnyConfigurationSchemaType;
+declare function assemblyConfigSchema(pluginManager: PluginManager): import("../configuration/configurationSchema").ConfigurationSchemaType<{
+    /**
+     * #slot
+     * aliases are "reference name aliases" e.g. aliases for hg38 might be "GRCh38"
+     */
+    aliases: {
+        type: string;
+        defaultValue: never[];
+        description: string;
+    };
+    /**
+     * #slot
+     * sequence refers to a reference sequence track that has an adapter containing,
+     * importantly, a sequence adapter such as IndexedFastaAdapter
+     */
+    sequence: import("../configuration").AnyConfigurationSchemaType;
+    /**
+     * #slot
+     */
+    refNameColors: {
+        type: string;
+        defaultValue: never[];
+        description: string;
+    };
+    refNameAliases: import("../configuration/configurationSchema").ConfigurationSchemaType<{
+        /**
+         * #slot refNameAliases.adapter
+         * refNameAliases help resolve e.g. chr1 and 1 as the same entity
+         * the data for refNameAliases are fetched from an adapter, that is
+         * commonly a tsv like chromAliases.txt from UCSC or similar
+         */
+        adapter: import("mobx-state-tree").IAnyModelType;
+    }, import("../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    cytobands: import("../configuration/configurationSchema").ConfigurationSchemaType<{
+        /**
+         * #slot cytobands.adapter
+         * cytoband data is fetched from an adapter, and can be displayed by a
+         * view type as ideograms
+         */
+        adapter: import("mobx-state-tree").IAnyModelType;
+    }, import("../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    /**
+     * #slot
+     */
+    displayName: {
+        type: string;
+        defaultValue: string;
+        description: string;
+    };
+}, import("../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "name">>;
 export default assemblyConfigSchema;