@jbrowse/core 2.4.2 → 2.6.0

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

@@ -1,7 +1,58 @@
 import PluginManager from '../PluginManager';
 /**
  * #config BaseAssembly
+ * #category assemblyManagement
  * 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;
+export type BaseAssemblyConfigSchema = ReturnType<typeof assemblyConfigSchema>;

package/assemblyManager/assemblyConfigSchema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("../configuration");
 /**
  * #config BaseAssembly
+ * #category assemblyManagement
  * This corresponds to the assemblies section of the config
  */
 function assemblyConfigSchema(pluginManager) {