@jbrowse/core 3.5.0 → 3.5.1

package/BaseFeatureWidget/BaseFeatureDetail/DataGridDetails.js

@@ -53,7 +53,7 @@ function DataGridDetails({ value, prefix, name, }) {
     if (unionKeys.size < keys.length + 5) {
         return ((0, jsx_runtime_1.jsxs)("div", { className: classes.margin, children: [(0, jsx_runtime_1.jsx)(FieldName_1.default, { prefix: prefix, name: name }), (0, jsx_runtime_1.jsx)(material_1.FormControlLabel, { control: (0, jsx_runtime_1.jsx)(material_1.Checkbox, { checked: checked, onChange: event => {
                             setChecked(event.target.checked);
-                        } }), label: (0, jsx_runtime_1.jsx)(material_1.Typography, { variant: "body2", children: "Show options" }) }), (0, jsx_runtime_1.jsx)(DataGridFlexContainer_1.default, { children: (0, jsx_runtime_1.jsx)(x_data_grid_1.DataGrid, { rows: rows, rowHeight: 20, columnHeaderHeight: 35, hideFooter: rows.length < 25, showToolbar: checked, columns: colNames.map((val, index) => ({
+                        } }), label: (0, jsx_runtime_1.jsx)(material_1.Typography, { variant: "body2", children: "Show options" }) }), (0, jsx_runtime_1.jsx)(DataGridFlexContainer_1.default, { children: (0, jsx_runtime_1.jsx)(x_data_grid_1.DataGrid, { disableRowSelectionOnClick: true, rows: rows, rowHeight: 20, columnHeaderHeight: 35, hideFooter: rows.length < 25, showToolbar: checked, columns: colNames.map((val, index) => ({
                             field: val,
                             width: widths[index],
                             renderCell: ({ value }) => ((0, jsx_runtime_1.jsx)("div", { className: classes.cell, children: (0, jsx_runtime_1.jsx)(ui_1.SanitizedHTML, { html: (0, util_1.getStr)(value || '') }) })),

package/PhasedScheduler.d.ts

@@ -0,0 +1,7 @@
+export default class PhasedScheduler<PhaseName extends string> {
+    phaseCallbacks: Map<PhaseName, Function[]>;
+    phaseOrder: PhaseName[];
+    constructor(...phaseOrder: PhaseName[]);
+    add(phase: PhaseName, callback: Function): void;
+    run(): void;
+}

package/PhasedScheduler.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PhasedScheduler {
+    constructor(...phaseOrder) {
+        this.phaseCallbacks = new Map();
+        this.phaseOrder = [];
+        this.phaseOrder = phaseOrder;
+    }
+    add(phase, callback) {
+        if (!this.phaseOrder.includes(phase)) {
+            throw new Error(`unknown phase ${phase}`);
+        }
+        let phaseCallbacks = this.phaseCallbacks.get(phase);
+        if (!phaseCallbacks) {
+            phaseCallbacks = [];
+            this.phaseCallbacks.set(phase, phaseCallbacks);
+        }
+        phaseCallbacks.push(callback);
+    }
+    run() {
+        for (const phaseName of this.phaseOrder) {
+            for (const callback of this.phaseCallbacks.get(phaseName) || []) {
+                callback();
+            }
+        }
+    }
+}
+exports.default = PhasedScheduler;

package/Plugin.d.ts

@@ -7,5 +7,7 @@ export default abstract class Plugin {
     install(_pluginManager: PluginManager): void;
     configure(_pluginManager: PluginManager): void;
     configurationSchema?: AnyConfigurationSchemaType;
+    configurationSchemaUnnamespaced?: AnyConfigurationSchemaType;
+    rootConfigurationSchema?: (arg: PluginManager) => AnyConfigurationSchemaType;
 }
 export type PluginConstructor = new (...args: unknown[]) => Plugin;

package/PluginManager.d.ts

@@ -1,3 +1,4 @@
+import PhasedScheduler from './PhasedScheduler';
 import ReExports from './ReExports';
 import AdapterType from './pluggableElementTypes/AdapterType';
 import AddTrackWorkflowType from './pluggableElementTypes/AddTrackWorkflowType';
@@ -16,13 +17,6 @@ import type { PluggableElementMember, PluggableElementType } from './pluggableEl
 import type PluggableElementBase from './pluggableElementTypes/PluggableElementBase';
 import type { AbstractRootModel } from './util';
 import type { IAnyModelType, IAnyType } from 'mobx-state-tree';
-declare class PhasedScheduler<PhaseName extends string> {
-    phaseCallbacks: Map<PhaseName, Function[]>;
-    phaseOrder: PhaseName[];
-    constructor(...phaseOrder: PhaseName[]);
-    add(phase: PhaseName, callback: Function): void;
-    run(): void;
-}
 type PluggableElementTypeGroup = 'renderer' | 'adapter' | 'display' | 'track' | 'connection' | 'view' | 'widget' | 'rpc method' | 'internet account' | 'text search adapter' | 'add track workflow';
 declare class TypeRecord<ElementClass extends PluggableElementBase> {
     typeName: string;
@@ -87,7 +81,9 @@ export default class PluginManager {
     rootModel?: AbstractRootModel;
     extensionPoints: Map<string, Function[]>;
     constructor(initialPlugins?: (Plugin | PluginLoadRecord)[]);
-    pluginConfigurationSchemas(): Record<string, unknown>;
+    pluginConfigurationNamespacedSchemas(): Record<string, unknown>;
+    pluginConfigurationUnnamespacedSchemas(): Record<string, unknown>;
+    pluginConfigurationRootSchemas(): Record<string, unknown>;
     addPlugin(load: Plugin | PluginLoadRecord | RuntimePluginLoadRecord): this;
     getPlugin(name: string): Plugin | undefined;
     hasPlugin(name: string): boolean;

package/PluginManager.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const mobx_state_tree_1 = require("mobx-state-tree");
 const CorePlugin_1 = __importDefault(require("./CorePlugin"));
+const PhasedScheduler_1 = __importDefault(require("./PhasedScheduler"));
 const ReExports_1 = __importDefault(require("./ReExports"));
 const configuration_1 = require("./configuration");
 const AdapterType_1 = __importDefault(require("./pluggableElementTypes/AdapterType"));
@@ -19,31 +20,6 @@ const ViewType_1 = __importDefault(require("./pluggableElementTypes/ViewType"));
 const WidgetType_1 = __importDefault(require("./pluggableElementTypes/WidgetType"));
 const RendererType_1 = __importDefault(require("./pluggableElementTypes/renderers/RendererType"));
 const jexl_1 = __importDefault(require("./util/jexl"));
-class PhasedScheduler {
-    constructor(...phaseOrder) {
-        this.phaseCallbacks = new Map();
-        this.phaseOrder = [];
-        this.phaseOrder = phaseOrder;
-    }
-    add(phase, callback) {
-        if (!this.phaseOrder.includes(phase)) {
-            throw new Error(`unknown phase ${phase}`);
-        }
-        let phaseCallbacks = this.phaseCallbacks.get(phase);
-        if (!phaseCallbacks) {
-            phaseCallbacks = [];
-            this.phaseCallbacks.set(phase, phaseCallbacks);
-        }
-        phaseCallbacks.push(callback);
-    }
-    run() {
-        for (const phaseName of this.phaseOrder) {
-            for (const callback of this.phaseCallbacks.get(phaseName) || []) {
-                callback();
-            }
-        }
-    }
-}
 class TypeRecord {
     constructor(typeName, baseClass) {
         this.typeName = typeName;
@@ -72,7 +48,7 @@ class PluginManager {
         this.jexl = (0, jexl_1.default)();
         this.pluginMetadata = {};
         this.runtimePluginDefinitions = [];
-        this.elementCreationSchedule = new PhasedScheduler('renderer', 'adapter', 'text search adapter', 'display', 'track', 'connection', 'view', 'widget', 'rpc method', 'internet account', 'add track workflow');
+        this.elementCreationSchedule = new PhasedScheduler_1.default('renderer', 'adapter', 'text search adapter', 'display', 'track', 'connection', 'view', 'widget', 'rpc method', 'internet account', 'add track workflow');
         this.rendererTypes = new TypeRecord('RendererType', RendererType_1.default);
         this.adapterTypes = new TypeRecord('AdapterType', AdapterType_1.default);
         this.textSearchAdapterTypes = new TypeRecord('TextSearchAdapterType', TextSearchAdapterType_1.default);
@@ -121,7 +97,7 @@ class PluginManager {
             this.addPlugin(plugin);
         }
     }
-    pluginConfigurationSchemas() {
+    pluginConfigurationNamespacedSchemas() {
         const configurationSchemas = {};
         for (const plugin of this.plugins) {
             if (plugin.configurationSchema) {
@@ -130,6 +106,30 @@ class PluginManager {
         }
         return configurationSchemas;
     }
+    pluginConfigurationUnnamespacedSchemas() {
+        let configurationSchemas = {};
+        for (const plugin of this.plugins) {
+            if (plugin.configurationSchemaUnnamespaced) {
+                configurationSchemas = {
+                    ...configurationSchemas,
+                    ...plugin.configurationSchemaUnnamespaced,
+                };
+            }
+        }
+        return configurationSchemas;
+    }
+    pluginConfigurationRootSchemas() {
+        let configurationSchemas = {};
+        for (const plugin of this.plugins) {
+            if (plugin.rootConfigurationSchema) {
+                configurationSchemas = {
+                    ...configurationSchemas,
+                    ...plugin.rootConfigurationSchema(this),
+                };
+            }
+        }
+        return configurationSchemas;
+    }
     addPlugin(load) {
         if (this.configured) {
             throw new Error('JBrowse already configured, cannot add plugins');

package/assemblyManager/assembly.d.ts

@@ -22,16 +22,18 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
     loadingP: Promise<void> | undefined;
     volatileRegions: BasicRegion[] | undefined;
     refNameAliases: RefNameAliases | undefined;
-    lowerCaseRefNameAliases: RefNameAliases | undefined;
     cytobands: Feature[] | undefined;
 } & {
     getConf(arg: string): any;
+    readonly lowerCaseRefNameAliases: {
+        [k: string]: string;
+    } | undefined;
 } & {
     readonly initialized: boolean;
     readonly name: string;
     readonly regions: BasicRegion[] | undefined;
     readonly aliases: string[];
-    readonly displayName: string | undefined;
+    readonly displayName: string;
     hasName(name: string): boolean;
     readonly allAliases: string[];
     readonly allRefNames: string[] | undefined;
@@ -46,15 +48,14 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
     getRefNameColor(refName: string): string | undefined;
     isValidRefName(refName: string): boolean;
 } & {
-    setLoaded({ regions, refNameAliases, lowerCaseRefNameAliases, cytobands, }: {
+    setLoaded({ regions, refNameAliases, cytobands, }: {
         regions: Region[];
         refNameAliases: RefNameAliases;
-        lowerCaseRefNameAliases: RefNameAliases;
         cytobands: Feature[];
     }): void;
     setError(e: unknown): void;
     setRegions(regions: Region[]): void;
-    setRefNameAliases(aliases: RefNameAliases, lowerCaseAliases: RefNameAliases): void;
+    setRefNameAliases(aliases: RefNameAliases): void;
     setCytobands(cytobands: Feature[]): void;
     setLoadingP(p?: Promise<void>): void;
     load(): Promise<void>;
@@ -63,6 +64,7 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
     getAdapterMapEntry(adapterConf: AdapterConf, options: BaseOptions): Promise<RefNameMap>;
     getRefNameMapForAdapter(adapterConf: AdapterConf, opts: BaseOptions): Promise<RefNameAliases>;
     getReverseRefNameMapForAdapter(adapterConf: AdapterConf, opts: BaseOptions): Promise<RefNameAliases>;
+    afterCreate(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type AssemblyModel = ReturnType<typeof assemblyFactory>;
 export type Assembly = Instance<AssemblyModel>;

package/assemblyManager/assembly.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = assemblyFactory;
 const abortable_promise_cache_1 = __importDefault(require("@gmod/abortable-promise-cache"));
+const mobx_1 = require("mobx");
 const mobx_state_tree_1 = require("mobx-state-tree");
 const configuration_1 = require("../configuration");
 const util_1 = require("../data_adapters/util");
@@ -87,13 +88,19 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         loadingP: undefined,
         volatileRegions: undefined,
         refNameAliases: undefined,
-        lowerCaseRefNameAliases: undefined,
         cytobands: undefined,
     }))
         .views(self => ({
         getConf(arg) {
             return self.configuration ? (0, configuration_1.getConf)(self, arg) : undefined;
         },
+        get lowerCaseRefNameAliases() {
+            return self.refNameAliases
+                ? Object.fromEntries(Object.entries(self.refNameAliases).map(([key, val]) => {
+                    return [key.toLowerCase(), val];
+                }))
+                : undefined;
+        },
     }))
         .views(self => ({
         get initialized() {
@@ -172,9 +179,9 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         },
     }))
         .actions(self => ({
-        setLoaded({ regions, refNameAliases, lowerCaseRefNameAliases, cytobands, }) {
+        setLoaded({ regions, refNameAliases, cytobands, }) {
             this.setRegions(regions);
-            this.setRefNameAliases(refNameAliases, lowerCaseRefNameAliases);
+            this.setRefNameAliases(refNameAliases);
             this.setCytobands(cytobands);
         },
         setError(e) {
@@ -183,9 +190,8 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         setRegions(regions) {
             self.volatileRegions = regions;
         },
-        setRefNameAliases(aliases, lowerCaseAliases) {
+        setRefNameAliases(aliases) {
             self.refNameAliases = aliases;
-            self.lowerCaseRefNameAliases = lowerCaseAliases;
         },
         setCytobands(cytobands) {
             self.cytobands = cytobands;
@@ -214,10 +220,9 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
                 config: sequenceAdapterConf,
                 pluginManager,
             });
-            const adapterRegionsWithAssembly = regions.map(r => {
+            for (const r of regions) {
                 checkRefName(r.refName);
-                return { ...r, assemblyName };
-            });
+            }
             const refNameAliases = {};
             const refNameAliasCollection = await getRefNameAliases({
                 config: refNameAliasesAdapterConf,
@@ -232,20 +237,16 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
                     refNameAliases[refName] = refName;
                 }
             }
-            for (const region of adapterRegionsWithAssembly) {
+            for (const region of regions) {
                 refNameAliases[_c = region.refName] || (refNameAliases[_c] = region.refName);
             }
-            const lowerCaseRefNameAliases = Object.fromEntries(Object.entries(refNameAliases).map(([key, val]) => [
-                key.toLowerCase(),
-                val,
-            ]));
             this.setLoaded({
                 refNameAliases,
-                regions: adapterRegionsWithAssembly.map(r => ({
+                regions: regions.map(r => ({
                     ...r,
                     refName: refNameAliases[r.refName] || r.refName,
+                    assemblyName,
                 })),
-                lowerCaseRefNameAliases,
                 cytobands: await getCytobands({
                     config: cytobandAdapterConf,
                     pluginManager,
@@ -276,6 +277,11 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
             const map = await this.getAdapterMapEntry(adapterConf, opts);
             return map.reverseMap;
         },
+        afterCreate() {
+            (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(() => {
+                self.allRefNamesWithLowerCase;
+            }));
+        },
     }));
 }
 async function getRefNameAliases({ config, pluginManager, stopToken, }) {