@jbrowse/core 2.1.6 → 2.2.0

package/BaseFeatureWidget/BaseFeatureDetail.d.ts

@@ -10,8 +10,8 @@ export declare const useStyles: (params: void, styleOverrides?: {
 } | undefined) => {
     classes: Record<"expansionPanelDetails" | "expandIcon" | "field" | "fieldDescription" | "fieldName" | "fieldValue" | "fieldSubvalue", string>;
     theme: import("@mui/material").Theme;
-    css: import("tss-react/types").Css;
-    cx: import("tss-react/types").Cx;
+    css: import("tss-react").Css;
+    cx: import("tss-react").Cx;
 };
 export declare function BaseCard({ children, title, defaultExpanded, }: BaseCardProps): JSX.Element;
 export declare const FieldName: ({ description, name, width, prefix, }: {

package/BaseFeatureWidget/SequenceFeatureDetails.js

@@ -36,6 +36,7 @@ const SequenceHelpDialog_1 = __importDefault(require("./SequenceHelpDialog"));
 const SequencePanel_1 = __importDefault(require("./SequencePanel"));
 const util_1 = require("../util");
 const configuration_1 = require("../configuration");
+const ui_1 = require("../ui");
 // icons
 const Settings_1 = __importDefault(require("@mui/icons-material/Settings"));
 const Help_1 = __importDefault(require("@mui/icons-material/Help"));
@@ -201,7 +202,7 @@ function SequenceFeatureDetails({ model, feature }) {
                 react_1.default.createElement(material_1.IconButton, { onClick: () => setSettingsDlgOpen(true) },
                     react_1.default.createElement(Settings_1.default, null))),
             react_1.default.createElement("br", null),
-            react_1.default.createElement(react_1.default.Fragment, null, error ? (react_1.default.createElement(material_1.Typography, { color: "error" }, `${error}`)) : loading ? (react_1.default.createElement(material_1.Typography, null, "Loading gene sequence...")) : sequence ? ('error' in sequence ? (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement(react_1.default.Fragment, null, error ? (react_1.default.createElement(material_1.Typography, { color: "error" }, `${error}`)) : loading ? (react_1.default.createElement(ui_1.LoadingEllipses, null)) : sequence ? ('error' in sequence ? (react_1.default.createElement(react_1.default.Fragment, null,
                 react_1.default.createElement(material_1.Typography, { color: "error" }, sequence.error),
                 react_1.default.createElement(material_1.Button, { variant: "contained", color: "inherit", onClick: () => setForceLoad({ ...forceLoad, force: true }) }, "Force load"))) : (react_1.default.createElement(SequencePanel_1.default, { ref: seqPanelRef, feature: parentFeature, mode: mode, sequence: sequence, intronBp: intronBp }))) : (react_1.default.createElement(material_1.Typography, null, "No sequence found"))))) : null,
         settingsDlgOpen ? (react_1.default.createElement(SequenceFeatureSettingsDialog_1.default, { handleClose: arg => {

package/PluginManager.d.ts

@@ -223,7 +223,7 @@ export default class PluginManager {
             makeStyles: <Params = void, RuleNameSubsetReferencableInNestedSelectors extends string = never>(params?: {
                 name?: string | Record<string, unknown> | undefined;
                 uniqId?: string | undefined;
-            } | undefined) => <RuleName extends string>(cssObjectByRuleNameOrGetCssObjectByRuleName: Record<RuleName, import("tss-react/types").CSSObject> | ((theme: import("@mui/material").Theme, params: Params, classes: Record<RuleNameSubsetReferencableInNestedSelectors, string>) => Record<RuleNameSubsetReferencableInNestedSelectors | RuleName, import("tss-react/types").CSSObject>)) => (params: Params, styleOverrides?: {
+            } | undefined) => <RuleName extends string>(cssObjectByRuleNameOrGetCssObjectByRuleName: Record<RuleName, import("tss-react").CSSObject> | ((theme: import("@mui/material").Theme, params: Params, classes: Record<RuleNameSubsetReferencableInNestedSelectors, string>) => Record<RuleNameSubsetReferencableInNestedSelectors | RuleName, import("tss-react").CSSObject>)) => (params: Params, styleOverrides?: {
                 props: {
                     classes?: Record<string, string> | undefined;
                 } & Record<string, unknown>;
@@ -231,8 +231,8 @@ export default class PluginManager {
             } | undefined) => {
                 classes: Record<RuleName, string>;
                 theme: import("@mui/material").Theme;
-                css: import("tss-react/types").Css;
-                cx: import("tss-react/types").Cx;
+                css: import("tss-react").Css;
+                cx: import("tss-react").Cx;
             };
         };
         '@material-ui/core': {

package/ReExports/modules.d.ts

@@ -144,7 +144,7 @@ declare const libs: {
         makeStyles: <Params = void, RuleNameSubsetReferencableInNestedSelectors extends string = never>(params?: {
             name?: string | Record<string, unknown> | undefined;
             uniqId?: string | undefined;
-        } | undefined) => <RuleName extends string>(cssObjectByRuleNameOrGetCssObjectByRuleName: Record<RuleName, import("tss-react/types").CSSObject> | ((theme: MUIStyles.Theme, params: Params, classes: Record<RuleNameSubsetReferencableInNestedSelectors, string>) => Record<RuleNameSubsetReferencableInNestedSelectors | RuleName, import("tss-react/types").CSSObject>)) => (params: Params, styleOverrides?: {
+        } | undefined) => <RuleName extends string>(cssObjectByRuleNameOrGetCssObjectByRuleName: Record<RuleName, import("tss-react").CSSObject> | ((theme: MUIStyles.Theme, params: Params, classes: Record<RuleNameSubsetReferencableInNestedSelectors, string>) => Record<RuleNameSubsetReferencableInNestedSelectors | RuleName, import("tss-react").CSSObject>)) => (params: Params, styleOverrides?: {
             props: {
                 classes?: Record<string, string> | undefined;
             } & Record<string, unknown>;
@@ -152,8 +152,8 @@ declare const libs: {
         } | undefined) => {
             classes: Record<RuleName, string>;
             theme: MUIStyles.Theme;
-            css: import("tss-react/types").Css;
-            cx: import("tss-react/types").Cx;
+            css: import("tss-react").Css;
+            cx: import("tss-react").Cx;
         };
     };
     '@material-ui/core': {

package/assemblyManager/assembly.d.ts

@@ -17,44 +17,50 @@ export interface BasicRegion {
     refName: string;
     assemblyName: string;
 }
-export default function assemblyFactory(assemblyConfigType: IAnyType, pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+export interface Loading {
+    adapterRegionsWithAssembly: Region[];
+    refNameAliases: RefNameAliases;
+    lowerCaseRefNameAliases: RefNameAliases;
+    cytobands: Feature[];
+}
+export default function assemblyFactory(assemblyConfigType: IAnyType, pm: PluginManager): import("mobx-state-tree").IModelType<{
     configuration: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<IAnyType>>;
 }, {
-    error: Error | undefined;
-    regions: BasicRegion[] | undefined;
+    error: unknown;
+    loaded: boolean;
+    loadingP: Promise<void> | undefined;
+    volatileRegions: BasicRegion[] | undefined;
     refNameAliases: RefNameAliases | undefined;
     lowerCaseRefNameAliases: RefNameAliases | undefined;
     cytobands: Feature[] | undefined;
 } & {
     readonly initialized: boolean;
     readonly name: string;
+    readonly regions: BasicRegion[] | undefined;
     readonly aliases: string[];
     readonly displayName: string | undefined;
     hasName(name: string): boolean;
     readonly allAliases: string[];
-    readonly refNames: string[] | undefined;
     readonly allRefNames: string[] | undefined;
     readonly lowerCaseRefNames: string[] | undefined;
     readonly allRefNamesWithLowerCase: string[] | undefined;
     readonly rpcManager: any;
     readonly refNameColors: string[];
+} & {
+    readonly refNames: string[] | undefined;
 } & {
     getCanonicalRefName(refName: string): string;
     getRefNameColor(refName: string): string | undefined;
     isValidRefName(refName: string): boolean;
 } & {
-    setLoading(): void;
-    setLoaded({ adapterRegionsWithAssembly, refNameAliases, lowerCaseRefNameAliases, cytobands, }: {
-        adapterRegionsWithAssembly: Region[];
-        refNameAliases: RefNameAliases;
-        lowerCaseRefNameAliases: RefNameAliases;
-        cytobands: Feature[];
-    }): void;
-    setError(e: Error): void;
+    setLoaded({ adapterRegionsWithAssembly, refNameAliases, lowerCaseRefNameAliases, cytobands, }: Loading): void;
+    setError(e: unknown): void;
     setRegions(regions: Region[]): void;
-    setRefNameAliases(aliases: RefNameAliases, lowerCase: RefNameAliases): void;
+    setRefNameAliases(aliases: RefNameAliases, lcAliases: RefNameAliases): void;
     setCytobands(cytobands: Feature[]): void;
-    afterAttach(): void;
+    setLoadingP(p?: Promise<void>): void;
+    load(): Promise<void>;
+    loadPre(): Promise<void>;
 } & {
     getAdapterMapEntry(adapterConf: unknown, options: BaseOptions): Promise<RefNameMap>;
     /**

package/assemblyManager/assembly.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
 const mobx_state_tree_1 = require("mobx-state-tree");
+const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
 const abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
 // locals
 const configuration_1 = require("../configuration");
@@ -81,7 +81,7 @@ function checkRefName(refName) {
 function getAdapterId(adapterConf) {
     return (0, json_stable_stringify_1.default)(adapterConf);
 }
-function assemblyFactory(assemblyConfigType, pluginManager) {
+function assemblyFactory(assemblyConfigType, pm) {
     const adapterLoads = new abortable_promise_cache_1.default({
         cache: new QuickLRU_1.default({ maxSize: 1000 }),
         async fill(args, signal, statusCallback) {
@@ -95,18 +95,27 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
     })
         .volatile(() => ({
         error: undefined,
-        regions: undefined,
+        loaded: false,
+        loadingP: undefined,
+        volatileRegions: undefined,
         refNameAliases: undefined,
         lowerCaseRefNameAliases: undefined,
         cytobands: undefined,
     }))
         .views(self => ({
         get initialized() {
+            // @ts-ignore
+            self.load();
             return !!self.refNameAliases;
         },
         get name() {
             return (0, configuration_1.getConf)(self, 'name');
         },
+        get regions() {
+            // @ts-ignore
+            self.load();
+            return self.volatileRegions;
+        },
         get aliases() {
             return (0, configuration_1.getConf)(self, 'aliases');
         },
@@ -119,10 +128,6 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         get allAliases() {
             return [this.name, ...this.aliases];
         },
-        get refNames() {
-            var _a;
-            return (_a = self.regions) === null || _a === void 0 ? void 0 : _a.map(region => region.refName);
-        },
         // 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
@@ -149,6 +154,12 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
             const colors = (0, configuration_1.getConf)(self, 'refNameColors');
             return colors.length === 0 ? refNameColors : colors;
         },
+    }))
+        .views(self => ({
+        get refNames() {
+            var _a;
+            return (_a = self.regions) === null || _a === void 0 ? void 0 : _a.map(region => region.refName);
+        },
     }))
         .views(self => ({
         getCanonicalRefName(refName) {
@@ -158,9 +169,11 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
             return (self.refNameAliases[refName] || self.lowerCaseRefNameAliases[refName]);
         },
         getRefNameColor(refName) {
-            var _a;
-            const idx = (_a = self.refNames) === null || _a === void 0 ? void 0 : _a.findIndex(r => r === refName);
-            if (idx === undefined || idx === -1) {
+            if (!self.refNames) {
+                return undefined;
+            }
+            const idx = self.refNames.findIndex(r => r === refName);
+            if (idx === -1) {
                 return undefined;
             }
             return self.refNameColors[idx % self.refNameColors.length];
@@ -173,8 +186,8 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         },
     }))
         .actions(self => ({
-        setLoading() { },
         setLoaded({ adapterRegionsWithAssembly, refNameAliases, lowerCaseRefNameAliases, cytobands, }) {
+            self.loaded = true;
             this.setRegions(adapterRegionsWithAssembly);
             this.setRefNameAliases(refNameAliases, lowerCaseRefNameAliases);
             this.setCytobands(cytobands);
@@ -184,21 +197,62 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
             self.error = e;
         },
         setRegions(regions) {
-            self.regions = regions;
+            self.volatileRegions = regions;
         },
-        setRefNameAliases(aliases, lowerCase) {
+        setRefNameAliases(aliases, lcAliases) {
             self.refNameAliases = aliases;
-            self.lowerCaseRefNameAliases = lowerCase;
+            self.lowerCaseRefNameAliases = lcAliases;
         },
         setCytobands(cytobands) {
             self.cytobands = cytobands;
         },
-        afterAttach() {
-            (0, util_1.makeAbortableReaction)(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            self, 
-            // @ts-ignore
-            makeLoadAssemblyData(pluginManager), loadAssemblyReaction, { name: `${self.name} assembly loading`, fireImmediately: true }, this.setLoading, this.setLoaded, this.setError);
+        setLoadingP(p) {
+            self.loadingP = p;
+        },
+        load() {
+            if (!self.loadingP) {
+                self.loadingP = this.loadPre().catch(e => {
+                    this.setLoadingP(undefined);
+                    this.setError(e);
+                });
+            }
+            return self.loadingP;
+        },
+        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 assemblyName = self.name;
+            const regions = await getAssemblyRegions(sequenceAdapterConf, pm);
+            const adapterRegionsWithAssembly = regions.map(r => {
+                checkRefName(r.refName);
+                return { ...r, assemblyName };
+            });
+            const refNameAliases = {};
+            const ret = await getRefNameAliases(refNameAliasesAdapterConf, pm);
+            const cytobands = await getCytobands(cytobandAdapterConf, pm);
+            ret.forEach(({ refName, aliases }) => {
+                aliases.forEach(a => {
+                    checkRefName(a);
+                    refNameAliases[a] = refName;
+                });
+            });
+            // add identity to the refNameAliases list
+            adapterRegionsWithAssembly.forEach(region => {
+                refNameAliases[region.refName] = region.refName;
+            });
+            const lowerCaseRefNameAliases = Object.fromEntries(Object.entries(refNameAliases).map(([key, val]) => [
+                key.toLowerCase(),
+                val,
+            ]));
+            this.setLoaded({
+                adapterRegionsWithAssembly,
+                refNameAliases,
+                lowerCaseRefNameAliases,
+                cytobands,
+            });
         },
     }))
         .views(self => ({
@@ -237,61 +291,6 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
     }));
 }
 exports.default = assemblyFactory;
-function makeLoadAssemblyData(pluginManager) {
-    return (self) => {
-        if (self.configuration) {
-            // use full configuration instead of snapshot of the config, the
-            // rpcManager normally receives a snapshot but we bypass rpcManager here
-            // to avoid spinning up a webworker
-            const { sequence, refNameAliases, cytobands } = self.configuration;
-            const sequenceAdapterConfig = sequence.adapter;
-            const refNameAliasesAdapterConfig = refNameAliases === null || refNameAliases === void 0 ? void 0 : refNameAliases.adapter;
-            const cytobandAdapterConfig = cytobands === null || cytobands === void 0 ? void 0 : cytobands.adapter;
-            return {
-                sequenceAdapterConfig,
-                assemblyName: self.name,
-                refNameAliasesAdapterConfig,
-                cytobandAdapterConfig,
-                pluginManager,
-            };
-        }
-        return undefined;
-    };
-}
-async function loadAssemblyReaction(props, signal) {
-    if (!props) {
-        return;
-    }
-    const { sequenceAdapterConfig, assemblyName, refNameAliasesAdapterConfig, cytobandAdapterConfig, pluginManager, } = props;
-    const adapterRegions = await getAssemblyRegions(sequenceAdapterConfig, pluginManager, signal);
-    const adapterRegionsWithAssembly = adapterRegions.map(adapterRegion => {
-        checkRefName(adapterRegion.refName);
-        return { ...adapterRegion, assemblyName };
-    });
-    const refNameAliases = {};
-    const aliases = await getRefNameAliases(refNameAliasesAdapterConfig, pluginManager, signal);
-    const cytobands = await getCytobands(cytobandAdapterConfig, pluginManager);
-    aliases.forEach(({ refName, aliases }) => {
-        aliases.forEach(alias => {
-            checkRefName(alias);
-            refNameAliases[alias] = refName;
-        });
-    });
-    // add identity to the refNameAliases list
-    adapterRegionsWithAssembly.forEach(region => {
-        refNameAliases[region.refName] = region.refName;
-    });
-    const lowerCaseRefNameAliases = Object.fromEntries(Object.entries(refNameAliases).map(([key, val]) => [
-        key.toLowerCase(),
-        val,
-    ]));
-    return {
-        adapterRegionsWithAssembly,
-        refNameAliases,
-        lowerCaseRefNameAliases,
-        cytobands,
-    };
-}
 async function getRefNameAliases(config, pm, signal) {
     const type = pm.getAdapterType(config.type);
     const CLASS = await type.getAdapterClass();

package/assemblyManager/assemblyConfigSchema.d.ts

@@ -1,3 +1,7 @@
 import PluginManager from '../PluginManager';
-declare const _default: (pluginManager: PluginManager) => import("../configuration").AnyConfigurationSchemaType;
-export default _default;
+/**
+ * #config BaseAssembly
+ * This corresponds to the assemblies section of the config
+ */
+declare function assemblyConfigSchema(pluginManager: PluginManager): import("../configuration").AnyConfigurationSchemaType;
+export default assemblyConfigSchema;

package/assemblyManager/assemblyConfigSchema.js

@@ -1,21 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("../configuration");
-exports.default = (pluginManager) => {
+/**
+ * #config BaseAssembly
+ * 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 => {
@@ -28,6 +50,11 @@ exports.default = (pluginManager) => {
             },
         }),
         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 => {
@@ -39,12 +66,22 @@ exports.default = (pluginManager) => {
                 return 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',
     });
-};
+}
+exports.default = assemblyConfigSchema;