@jbrowse/core 2.17.0 → 3.0.0

package/assemblyManager/assembly.js

@@ -4,19 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = assemblyFactory;
-const mobx_state_tree_1 = require("mobx-state-tree");
 const abortable_promise_cache_1 = __importDefault(require("@gmod/abortable-promise-cache"));
-// locals
+const mobx_state_tree_1 = require("mobx-state-tree");
 const configuration_1 = require("../configuration");
-const util_1 = require("../util");
+const util_1 = require("../data_adapters/util");
+const util_2 = require("../util");
 const QuickLRU_1 = __importDefault(require("../util/QuickLRU"));
-const dataAdapterCache_1 = require("../data_adapters/dataAdapterCache");
-/* biome-ignore lint/complexity/useRegexLiterals: */
 const refNameRegex = new RegExp('[0-9A-Za-z!#$%&+./:;?@^_|~-][0-9A-Za-z!#$%&*+./:;=?@^_|~-]*');
-// Based on the UCSC Genome Browser chromosome color palette:
-// https://github.com/ucscGenomeBrowser/kent/blob/a50ed53aff81d6fb3e34e6913ce18578292bc24e/src/hg/inc/chromColors.h
-// Some colors darkened to have at least a 3:1 contrast ratio on a white
-// background
 const refNameColors = [
     'rgb(153, 102, 0)',
     'rgb(102, 102, 0)',
@@ -24,36 +18,35 @@ const refNameColors = [
     'rgb(204, 0, 0)',
     'rgb(255, 0, 0)',
     'rgb(255, 0, 204)',
-    'rgb(165, 132, 132)', // originally 'rgb(255, 204, 204)'
-    'rgb(204, 122, 0)', // originally rgb(255, 153, 0)'
-    'rgb(178, 142, 0)', // originally 'rgb(255, 204, 0)'
-    'rgb(153, 153, 0)', // originally 'rgb(255, 255, 0)'
-    'rgb(122, 153, 0)', // originally 'rgb(204, 255, 0)'
-    'rgb(0, 165, 0)', // originally 'rgb(0, 255, 0)'
+    'rgb(165, 132, 132)',
+    'rgb(204, 122, 0)',
+    'rgb(178, 142, 0)',
+    'rgb(153, 153, 0)',
+    'rgb(122, 153, 0)',
+    'rgb(0, 165, 0)',
     'rgb(53, 128, 0)',
     'rgb(0, 0, 204)',
-    'rgb(96, 145, 242)', // originally 'rgb(102, 153, 255)'
-    'rgb(107, 142, 178)', // originally 'rgb(153, 204, 255)'
-    'rgb(0, 165, 165)', // originally 'rgb(0, 255, 255)'
-    'rgb(122, 153, 153)', // originally 'rgb(204, 255, 255)'
+    'rgb(96, 145, 242)',
+    'rgb(107, 142, 178)',
+    'rgb(0, 165, 165)',
+    'rgb(122, 153, 153)',
     'rgb(153, 0, 204)',
     'rgb(204, 51, 255)',
-    'rgb(173, 130, 216)', // originally 'rgb(204, 153, 255)'
+    'rgb(173, 130, 216)',
     'rgb(102, 102, 102)',
-    'rgb(145, 145, 145)', // originally 'rgb(153, 153, 153)'
-    'rgb(142, 142, 142)', // originally 'rgb(204, 204, 204)'
-    'rgb(142, 142, 107)', // originally 'rgb(204, 204, 153)'
-    'rgb(96, 163, 48)', // originally 'rgb(121, 204, 61)'
+    'rgb(145, 145, 145)',
+    'rgb(142, 142, 142)',
+    'rgb(142, 142, 107)',
+    'rgb(96, 163, 48)',
 ];
-async function loadRefNameMap(assembly, adapterConfig, options, signal) {
+async function loadRefNameMap(assembly, adapterConfig, options, stopToken) {
     const { sessionId } = options;
-    await (0, util_1.when)(() => !!(assembly.regions && assembly.refNameAliases), {
-        signal,
+    await (0, util_2.when)(() => !!(assembly.regions && assembly.refNameAliases), {
         name: 'when assembly ready',
     });
     const refNames = (await assembly.rpcManager.call(sessionId || 'assemblyRpc', 'CoreGetRefNames', {
         adapterConfig,
-        signal,
+        stopToken,
         ...options,
     }, { timeout: 1000000 }));
     const { refNameAliases } = assembly;
@@ -72,29 +65,21 @@ async function loadRefNameMap(assembly, adapterConfig, options, signal) {
         ])),
     };
 }
-// Valid refName pattern from https://samtools.github.io/hts-specs/SAMv1.pdf
 function checkRefName(refName) {
     if (!refNameRegex.test(refName)) {
         throw new Error(`Encountered invalid refName: "${refName}"`);
     }
 }
-/**
- * #stateModel Assembly
- */
 function assemblyFactory(assemblyConfigType, pluginManager) {
     const adapterLoads = new abortable_promise_cache_1.default({
         cache: new QuickLRU_1.default({ maxSize: 1000 }),
-        // @ts-expect-error
-        async fill(args, signal, statusCallback) {
+        async fill(args, _stopToken, statusCallback) {
             const { adapterConf, self, options } = args;
-            return loadRefNameMap(self, adapterConf, { ...options, statusCallback }, signal);
+            return loadRefNameMap(self, adapterConf, { ...options, statusCallback });
         },
     });
     return mobx_state_tree_1.types
         .model({
-        /**
-         * #property
-         */
         configuration: mobx_state_tree_1.types.safeReference(assemblyConfigType),
     })
         .volatile(() => ({
@@ -106,123 +91,70 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         cytobands: undefined,
     }))
         .views(self => ({
-        /**
-         * #method
-         */
         getConf(arg) {
             return self.configuration ? (0, configuration_1.getConf)(self, arg) : undefined;
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
         get initialized() {
-            // @ts-expect-error
             self.load();
             return !!self.refNameAliases;
         },
-        /**
-         * #getter
-         */
         get name() {
             return self.getConf('name') || '';
         },
-        /**
-         * #getter
-         */
         get regions() {
-            // @ts-expect-error
             self.load();
             return self.volatileRegions;
         },
-        /**
-         * #getter
-         */
         get aliases() {
             return self.getConf('aliases') || [];
         },
-        /**
-         * #getter
-         */
         get displayName() {
             return self.getConf('displayName');
         },
-        /**
-         * #getter
-         */
         hasName(name) {
             return this.allAliases.includes(name);
         },
-        /**
-         * #getter
-         */
         get allAliases() {
             return [this.name, ...this.aliases];
         },
-        /**
-         * #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() {
             return (0, mobx_state_tree_1.getParent)(self, 2).rpcManager;
         },
-        /**
-         * #getter
-         */
         get refNameColors() {
             const colors = self.getConf('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;
@@ -232,9 +164,6 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
                 ? undefined
                 : 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');
@@ -243,48 +172,27 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         },
     }))
         .actions(self => ({
-        /**
-         * #action
-         */
         setLoaded({ regions, refNameAliases, lowerCaseRefNameAliases, cytobands, }) {
             this.setRegions(regions);
             this.setRefNameAliases(refNameAliases, lowerCaseRefNameAliases);
             this.setCytobands(cytobands);
         },
-        /**
-         * #action
-         */
         setError(e) {
             self.error = e;
         },
-        /**
-         * #action
-         */
         setRegions(regions) {
             self.volatileRegions = regions;
         },
-        /**
-         * #action
-         */
         setRefNameAliases(aliases, lowerCaseAliases) {
             self.refNameAliases = aliases;
             self.lowerCaseRefNameAliases = lowerCaseAliases;
         },
-        /**
-         * #action
-         */
         setCytobands(cytobands) {
             self.cytobands = cytobands;
         },
-        /**
-         * #action
-         */
         setLoadingP(p) {
             self.loadingP = p;
         },
-        /**
-         * #action
-         */
         load() {
             if (!self.loadingP) {
                 self.loadingP = this.loadPre().catch((e) => {
@@ -294,9 +202,6 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
             }
             return self.loadingP;
         },
-        /**
-         * #action
-         */
         async loadPre() {
             var _a, _b;
             var _c;
@@ -323,17 +228,11 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
                     checkRefName(alias);
                     refNameAliases[alias] = refName;
                 }
-                // the override field is supplied by a RefNameAliasAdapter to make
-                // the refName field returned by the adapter to be used as the
-                // primary names for this assembly
                 if (override) {
                     refNameAliases[refName] = refName;
                 }
             }
-            // add identity to the refNameAliases list
             for (const region of adapterRegionsWithAssembly) {
-                // this ||= means that if the refNameAliasAdapter already set a
-                // mapping for the primary region to be an alias
                 refNameAliases[_c = region.refName] || (refNameAliases[_c] = region.refName);
             }
             const lowerCaseRefNameAliases = Object.fromEntries(Object.entries(refNameAliases).map(([key, val]) => [
@@ -355,27 +254,17 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         },
     }))
         .views(self => ({
-        /**
-         * #method
-         */
         getAdapterMapEntry(adapterConf, options) {
-            const { signal, statusCallback, ...rest } = options;
+            const { stopToken, statusCallback, ...rest } = options;
             if (!options.sessionId) {
                 throw new Error('sessionId is required');
             }
-            return adapterLoads.get((0, dataAdapterCache_1.adapterConfigCacheKey)(adapterConf), {
+            return adapterLoads.get((0, util_1.adapterConfigCacheKey)(adapterConf), {
                 adapterConf,
                 self,
                 options: rest,
-            }, 
-            // signal intentionally not passed here, fixes issues like #2221.
-            // alternative fix #2540 was proposed but non-working currently
-            undefined, statusCallback);
+            }, undefined, statusCallback);
         },
-        /**
-         * #method
-         * get Map of `canonical-name -> adapter-specific-name`
-         */
         async getRefNameMapForAdapter(adapterConf, opts) {
             if (!opts.sessionId) {
                 throw new Error('sessionId is required');
@@ -383,32 +272,27 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
             const map = await this.getAdapterMapEntry(adapterConf, opts);
             return map.forwardMap;
         },
-        /**
-         * #method
-         * get Map of `adapter-specific-name -> canonical-name`
-         */
         async getReverseRefNameMapForAdapter(adapterConf, opts) {
             const map = await this.getAdapterMapEntry(adapterConf, opts);
             return map.reverseMap;
         },
     }));
 }
-async function getRefNameAliases({ config, pluginManager, signal, }) {
+async function getRefNameAliases({ config, pluginManager, stopToken, }) {
     const type = pluginManager.getAdapterType(config.type);
     const CLASS = await type.getAdapterClass();
     const adapter = new CLASS(config, undefined, pluginManager);
-    return adapter.getRefNameAliases({ signal });
+    return adapter.getRefNameAliases({ stopToken });
 }
 async function getCytobands({ config, pluginManager, }) {
     const type = pluginManager.getAdapterType(config.type);
     const CLASS = await type.getAdapterClass();
     const adapter = new CLASS(config, undefined, pluginManager);
-    // @ts-expect-error
     return adapter.getData();
 }
-async function getAssemblyRegions({ config, pluginManager, signal, }) {
+async function getAssemblyRegions({ config, pluginManager, stopToken, }) {
     const type = pluginManager.getAdapterType(config.type);
     const CLASS = await type.getAdapterClass();
     const adapter = new CLASS(config, undefined, pluginManager);
-    return adapter.getRegions({ signal });
+    return adapter.getRegions({ stopToken });
 }

package/assemblyManager/assemblyConfigSchema.d.ts

@@ -1,55 +1,22 @@
-import PluginManager from '../PluginManager';
-/**
- * #config BaseAssembly
- * #category assemblyManagement
- * This corresponds to the assemblies section of the config
- */
+import type PluginManager from '../PluginManager';
 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;

package/assemblyManager/assemblyConfigSchema.js

@@ -1,86 +1,52 @@
 "use strict";
 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) {
     return (0, configuration_1.ConfigurationSchema)('BaseAssembly', {
-        /**
-         * #slot
-         * aliases are "reference name aliases" e.g. aliases for hg38 might be
-         * "GRCh38"
-         */
         aliases: {
             type: 'stringArray',
             defaultValue: [],
             description: 'Other possible names for the assembly',
         },
-        /**
-         * #slot
-         * sequence refers to a reference sequence track that has an adapter
-         * containing, importantly, a sequence adapter such as
-         * IndexedFastaAdapter
-         */
         sequence: pluginManager.getTrackType('ReferenceSequenceTrack')
             .configSchema,
-        /**
-         * #slot
-         */
         refNameColors: {
             type: 'stringArray',
             defaultValue: [],
             description: 'Define custom colors for each reference sequence. Will cycle through this list if there are not enough colors for every sequence.',
         },
         refNameAliases: (0, configuration_1.ConfigurationSchema)('RefNameAliases', {
-            /**
-             * #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: pluginManager.pluggableConfigSchemaType('adapter'),
         }, {
             preProcessSnapshot: snap => {
-                // allow refNameAliases to be unspecified
-                if (!snap.adapter) {
-                    return { adapter: { type: 'RefNameAliasAdapter' } };
-                }
-                return snap;
+                return !snap.adapter
+                    ? {
+                        adapter: {
+                            type: 'RefNameAliasAdapter',
+                        },
+                    }
+                    : snap;
             },
         }),
         cytobands: (0, configuration_1.ConfigurationSchema)('Cytoband', {
-            /**
-             * #slot cytobands.adapter
-             * cytoband data is fetched from an adapter, and can be displayed by
-             * a view type as ideograms
-             */
             adapter: pluginManager.pluggableConfigSchemaType('adapter'),
         }, {
             preProcessSnapshot: snap => {
-                // allow cytoBand to be unspecified
                 return !snap.adapter
-                    ? { adapter: { type: 'CytobandAdapter' } }
+                    ? {
+                        adapter: {
+                            type: 'CytobandAdapter',
+                        },
+                    }
                     : snap;
             },
         }),
-        /**
-         * #slot
-         */
         displayName: {
             type: 'string',
             defaultValue: '',
             description: 'A human readable display name for the assembly e.g. "Homo sapiens (hg38)" while the assembly name may just be "hg38"',
         },
     }, {
-        /**
-         * #identifier name
-         * the name acts as a unique identifier in the config, so it cannot be
-         * duplicated. it usually a short human readable "id" like hg38, but you
-         * can also optionally customize the assembly "displayName" config slot
-         */
         explicitIdentifier: 'name',
     });
 }

package/assemblyManager/assemblyManager.d.ts

@@ -1,19 +1,10 @@
-import { IAnyType } from 'mobx-state-tree';
-import { AnyConfigurationModel } from '../configuration';
-import { Assembly } from './assembly';
-import PluginManager from '../PluginManager';
-import RpcManager from '../rpc/RpcManager';
+import type { AnyConfigurationModel } from '../configuration';
+import type { Assembly } from './assembly';
+import type PluginManager from '../PluginManager';
+import type RpcManager from '../rpc/RpcManager';
+import type { IAnyType } from 'mobx-state-tree';
 type AdapterConf = Record<string, unknown>;
-/**
- * #stateModel AssemblyManager
- */
 declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): import("mobx-state-tree").IModelType<{
-    /**
-     * #property
-     * this is automatically managed by an autorun which looks in the parent
-     * session.assemblies, session.sessionAssemblies, and
-     * session.temporaryAssemblies
-     */
     assemblies: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
         configuration: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<IAnyType>>;
     }, {
@@ -228,9 +219,6 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         }>;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>>;
 } & {
-    /**
-     * #method
-     */
     get(asmName: string): ({
         configuration: any;
     } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
@@ -372,23 +360,10 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
             [x: string]: string;
         }>;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
-    /**
-     * #getter
-     */
     readonly assemblyNamesList: any[];
-    /**
-     * #getter
-     * looks at jbrowse.assemblies, session.sessionAssemblies, and
-     * session.temporaryAssemblies to load from
-     */
     readonly assemblyList: AnyConfigurationModel[];
     readonly rpcManager: RpcManager;
 } & {
-    /**
-     * #method
-     * use this method instead of assemblyManager.get(assemblyName)
-     * to get an assembly with regions loaded
-     */
     waitForAssembly(assemblyName: string): Promise<({
         configuration: any;
     } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
@@ -530,47 +505,22 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
             [x: string]: string;
         }>;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined>;
-    /**
-     * #method
-     */
     getRefNameMapForAdapter(adapterConf: AdapterConf, assemblyName: string | undefined, opts: {
-        signal?: AbortSignal;
+        stopToken?: string;
         sessionId: string;
     }): Promise<{
         [x: string]: string;
     } | undefined>;
-    /**
-     * #method
-     */
     getReverseRefNameMapForAdapter(adapterConf: AdapterConf, assemblyName: string | undefined, opts: {
-        signal?: AbortSignal;
+        stopToken?: string;
         sessionId: string;
     }): Promise<{
         [x: string]: string;
     } | undefined>;
-    /**
-     * #method
-     */
     isValidRefName(refName: string, assemblyName: string): boolean;
 } & {
     afterAttach(): void;
-    /**
-     * #action
-     * private: you would generally want to add to manipulate
-     * jbrowse.assemblies, session.sessionAssemblies, or
-     * session.temporaryAssemblies instead of using this directly
-     */
     removeAssembly(asm: Assembly): void;
-    /**
-     * #action
-     * private: you would generally want to add to manipulate
-     * jbrowse.assemblies, session.sessionAssemblies, or
-     * session.temporaryAssemblies instead of using this directly
-     *
-     * this can take an active instance of an assembly, in which case it is
-     * referred to, or it can take an identifier e.g. assembly name, which is
-     * used as a reference. snapshots cannot be used
-     */
     addAssembly(configuration: any): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export default assemblyManagerFactory;