@jbrowse/core 2.17.0 → 3.0.0

package/BaseFeatureWidget/stateModelFactory.js

@@ -1,17 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stateModelFactory = stateModelFactory;
-const mobx_state_tree_1 = require("mobx-state-tree");
 const mobx_1 = require("mobx");
-const clone_1 = __importDefault(require("clone"));
+const mobx_state_tree_1 = require("mobx-state-tree");
 const configuration_1 = require("../configuration");
 const util_1 = require("../util");
-const mst_1 = require("../util/types/mst");
 const model_1 = require("./SequenceFeatureDetails/model");
 const util_2 = require("./util");
+const mst_1 = require("../util/types/mst");
 function formatSubfeatures(obj, depth, parse, currentDepth = 0, returnObj = {}) {
     var _a;
     if (depth <= currentDepth) {
@@ -22,97 +18,39 @@ function formatSubfeatures(obj, depth, parse, currentDepth = 0, returnObj = {})
         parse(sub);
     });
 }
-/**
- * #stateModel BaseFeatureWidget
- * displays data about features, allowing configuration callbacks to modify the
- * contents of what is displayed
- *
- * see: formatDetails-\>feature,formatDetails-\>subfeatures
- */
 function stateModelFactory(pluginManager) {
     return mobx_state_tree_1.types
         .model('BaseFeatureWidget', {
-        /**
-         * #property
-         */
         id: mst_1.ElementId,
-        /**
-         * #property
-         */
         type: mobx_state_tree_1.types.literal('BaseFeatureWidget'),
-        /**
-         * #property
-         */
         featureData: mobx_state_tree_1.types.frozen(),
-        /**
-         * #property
-         */
         formattedFields: mobx_state_tree_1.types.frozen(),
-        /**
-         * #property
-         */
         unformattedFeatureData: mobx_state_tree_1.types.frozen(),
-        /**
-         * #property
-         */
         view: mobx_state_tree_1.types.safeReference(pluginManager.pluggableMstType('view', 'stateModel')),
-        /**
-         * #property
-         */
         track: mobx_state_tree_1.types.safeReference(pluginManager.pluggableMstType('track', 'stateModel')),
-        /**
-         * #property
-         */
         trackId: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         trackType: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
-        /**
-         * #property
-         */
         maxDepth: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.number),
-        /**
-         * #property
-         */
         sequenceFeatureDetails: mobx_state_tree_1.types.optional((0, model_1.SequenceFeatureDetailsF)(), {}),
     })
         .volatile(() => ({
-        /**
-         * #volatile
-         */
         error: undefined,
     }))
         .actions(self => ({
-        /**
-         * #action
-         */
         setFeatureData(featureData) {
             self.unformattedFeatureData = featureData;
         },
-        /**
-         * #action
-         */
         clearFeatureData() {
             self.featureData = undefined;
         },
-        /**
-         * #action
-         */
         setFormattedData(feat) {
             self.featureData = feat;
         },
-        /**
-         * #action
-         */
         setExtra(type, trackId, maxDepth) {
             self.trackId = trackId;
             self.trackType = type;
             self.maxDepth = maxDepth;
         },
-        /**
-         * #action
-         */
         setError(e) {
             self.error = e;
         },
@@ -127,7 +65,7 @@ function stateModelFactory(pluginManager) {
                         self.setExtra(track.type, track.configuration.trackId, (0, configuration_1.getConf)(track, ['formatDetails', 'maxDepth']));
                     }
                     if (unformattedFeatureData) {
-                        const feature = (0, clone_1.default)(unformattedFeatureData);
+                        const feature = structuredClone(unformattedFeatureData);
                         const combine = (arg2, feature) => ({
                             ...(0, configuration_1.getConf)(session, ['formatDetails', arg2], { feature }),
                             ...(0, configuration_1.getConf)(track, ['formatDetails', arg2], { feature }),
@@ -149,7 +87,6 @@ function stateModelFactory(pluginManager) {
         },
     }))
         .preProcessSnapshot(snap => {
-        // @ts-expect-error
         const { featureData, finalizedFeatureData, ...rest } = snap;
         return {
             unformattedFeatureData: featureData,
@@ -158,15 +95,8 @@ function stateModelFactory(pluginManager) {
         };
     })
         .postProcessSnapshot(snap => {
-        // xref https://github.com/mobxjs/mobx-state-tree/issues/1524 for Omit
         const { unformattedFeatureData, featureData, ...rest } = snap;
-        // finalizedFeatureData avoids running formatter twice if loading from
-        // snapshot
         return {
-            // replacing undefined with null helps with allowing fields to be
-            // hidden, setting null is not allowed by jexl so we set it to
-            // undefined to hide. see config guide. this replacement happens both
-            // here and when displaying the featureData in base feature widget
             finalizedFeatureData: (0, util_2.replaceUndefinedWithNull)(featureData),
             ...rest,
         };

package/BaseFeatureWidget/types.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
-import { SimpleFeatureSerialized } from '../util/simpleFeature';
-import { BaseFeatureWidgetModel } from './stateModelFactory';
+import type React from 'react';
+import type { BaseFeatureWidgetModel } from './stateModelFactory';
+import type { SimpleFeatureSerialized } from '../util/simpleFeature';
 export interface BaseProps extends BaseCardProps {
     feature: SimpleFeatureSerialized;
     formatter?: (val: unknown, key: string) => React.ReactNode;

package/BaseFeatureWidget/util.js

@@ -10,11 +10,9 @@ exports.replaceUndefinedWithNull = replaceUndefinedWithNull;
 function stitch(subfeats, sequence) {
     return subfeats.map(sub => sequence.slice(sub.start, sub.end)).join('');
 }
-// filter items if they have the same "ID" or location
 function getItemId(feat) {
     return `${feat.start}-${feat.end}`;
 }
-// filters if successive elements share same start/end
 function dedupe(list) {
     return list.filter((item, pos, ary) => !pos || getItemId(item) !== getItemId(ary[pos - 1]));
 }
@@ -28,7 +26,6 @@ function revlist(list, seqlen) {
         .sort((a, b) => a.start - b.start);
 }
 function calculateUTRs(cds, exons) {
-    // checking length ensures the .at below are valid
     if (!cds.length) {
         return [];
     }
@@ -48,7 +45,6 @@ function calculateUTRs(cds, exons) {
     ].map(elt => ({ ...elt, type: 'three_prime_UTR' }));
     return [...fiveUTRs, ...threeUTRs];
 }
-// calculates UTRs using impliedUTRs logic, but there are no exon subfeatures
 function calculateUTRs2(cds, parentFeat) {
     if (!cds.length) {
         return [];

package/CorePlugin.d.ts

@@ -1,5 +1,5 @@
 import Plugin from './Plugin';
-import PluginManager from './PluginManager';
+import type PluginManager from './PluginManager';
 export default class CorePlugin extends Plugin {
     name: string;
     install(pluginManager: PluginManager): void;

package/CorePlugin.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -29,18 +39,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = require("react");
 const BaseFeatureWidget_1 = require("./BaseFeatureWidget");
 const Plugin_1 = __importDefault(require("./Plugin"));
-const coreRpcMethods = __importStar(require("./rpc/coreRpcMethods"));
-const WidgetType_1 = __importDefault(require("./pluggableElementTypes/WidgetType"));
 const CytobandAdapter_1 = __importDefault(require("./data_adapters/CytobandAdapter"));
-// the core plugin, which registers types that ALL JBrowse applications are
-// expected to need.
+const WidgetType_1 = __importDefault(require("./pluggableElementTypes/WidgetType"));
+const coreRpcMethods = __importStar(require("./rpc/coreRpcMethods"));
 class CorePlugin extends Plugin_1.default {
     constructor() {
         super(...arguments);
         this.name = 'CorePlugin';
     }
     install(pluginManager) {
-        // register all our core rpc methods
         Object.values(coreRpcMethods).forEach(RpcMethod => {
             pluginManager.addRpcMethod(() => new RpcMethod(pluginManager));
         });

package/Plugin.d.ts

@@ -1,8 +1,5 @@
-import PluginManager from './PluginManager';
-import { AnyConfigurationSchemaType } from './configuration';
-/**
- * base class for a JBrowse plugin
- */
+import type PluginManager from './PluginManager';
+import type { AnyConfigurationSchemaType } from './configuration';
 export default abstract class Plugin {
     abstract name: string;
     url?: string;

package/Plugin.js

@@ -1,8 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * base class for a JBrowse plugin
- */
 class Plugin {
     install(_pluginManager) { }
     configure(_pluginManager) { }

package/PluginLoader.d.ts

@@ -1,4 +1,4 @@
-import { PluginConstructor } from './Plugin';
+import type { PluginConstructor } from './Plugin';
 export interface UMDLocPluginDefinition {
     umdLoc: {
         uri: string;

package/PluginLoader.js

@@ -8,26 +8,17 @@ exports.isESMPluginDefinition = isESMPluginDefinition;
 exports.isCJSPluginDefinition = isCJSPluginDefinition;
 exports.pluginDescriptionString = pluginDescriptionString;
 const load_script_1 = __importDefault(require("load-script"));
-// locals
 const Plugin_1 = __importDefault(require("./Plugin"));
 const ReExports_1 = __importDefault(require("./ReExports"));
 const util_1 = require("./util");
 function isUMDPluginDefinition(def) {
-    return (
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    (def.umdUrl !== undefined ||
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return ((def.umdUrl !== undefined ||
         def.url !== undefined ||
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         def.umdLoc !== undefined) &&
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         def.name !== undefined);
 }
 function isESMPluginDefinition(def) {
-    return (
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    def.esmUrl !== undefined ||
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return (def.esmUrl !== undefined ||
         def.esmLoc !== undefined);
 }
 function promisifiedLoadScript(src) {
@@ -46,16 +37,13 @@ async function loadScript(scriptUrl) {
     if (!isInWebWorker()) {
         return promisifiedLoadScript(scriptUrl);
     }
-    // @ts-expect-error
     if (globalThis.importScripts) {
-        // @ts-expect-error
         await globalThis.importScripts(scriptUrl);
         return;
     }
     throw new Error('cannot figure out how to load external JS scripts in this environment');
 }
 function isCJSPluginDefinition(def) {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     return def.cjsUrl !== undefined;
 }
 function pluginDescriptionString(pluginDefinition) {
@@ -102,7 +90,6 @@ class PluginLoader {
             throw new Error('No ESM fetcher installed');
         }
         const plugin = await this.fetchESM(parsedUrl.href);
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (!plugin) {
             throw new Error(`Could not load ESM plugin: ${parsedUrl}`);
         }
@@ -123,10 +110,8 @@ class PluginLoader {
             await loadScript(parsedUrl.href);
         }
         else {
-            // @ts-expect-error
             globalThis[umdName] = { default: Plugin_1.default };
         }
-        // @ts-expect-error
         const plugin = globalThis[umdName];
         if (!plugin) {
             throw new Error(`Failed to load UMD bundle for ${moduleName}, ${umdName} is undefined`);
@@ -150,14 +135,12 @@ class PluginLoader {
         else {
             throw new Error(`Could not determine plugin type: ${JSON.stringify(def)}`);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (!plugin.default) {
             throw new Error(`${pluginDescriptionString(def)} does not have a default export, cannot load`);
         }
         return plugin.default;
     }
     installGlobalReExports(target) {
-        // @ts-expect-error
         target.JBrowseExports = Object.fromEntries(Object.entries(ReExports_1.default).map(([moduleName, module]) => {
             return [moduleName, module];
         }));

package/PluginManager.d.ts

@@ -1,21 +1,21 @@
-import { IAnyType, IAnyModelType } from 'mobx-state-tree';
-import PluggableElementBase from './pluggableElementTypes/PluggableElementBase';
-import RendererType from './pluggableElementTypes/renderers/RendererType';
+import ReExports from './ReExports';
 import AdapterType from './pluggableElementTypes/AdapterType';
-import TrackType from './pluggableElementTypes/TrackType';
-import DisplayType from './pluggableElementTypes/DisplayType';
-import ViewType from './pluggableElementTypes/ViewType';
-import WidgetType from './pluggableElementTypes/WidgetType';
+import AddTrackWorkflowType from './pluggableElementTypes/AddTrackWorkflowType';
 import ConnectionType from './pluggableElementTypes/ConnectionType';
-import RpcMethodType from './pluggableElementTypes/RpcMethodType';
+import DisplayType from './pluggableElementTypes/DisplayType';
 import InternetAccountType from './pluggableElementTypes/InternetAccountType';
+import RpcMethodType from './pluggableElementTypes/RpcMethodType';
 import TextSearchAdapterType from './pluggableElementTypes/TextSearchAdapterType';
-import AddTrackWorkflowType from './pluggableElementTypes/AddTrackWorkflowType';
-import Plugin from './Plugin';
-import ReExports from './ReExports';
-import { PluggableElementType, PluggableElementMember } from './pluggableElementTypes';
-import { AbstractRootModel } from './util';
-import { PluginDefinition } from './PluginLoader';
+import TrackType from './pluggableElementTypes/TrackType';
+import ViewType from './pluggableElementTypes/ViewType';
+import WidgetType from './pluggableElementTypes/WidgetType';
+import RendererType from './pluggableElementTypes/renderers/RendererType';
+import type Plugin from './Plugin';
+import type { PluginDefinition } from './PluginLoader';
+import type { PluggableElementMember, PluggableElementType } from './pluggableElementTypes';
+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[];
@@ -24,7 +24,6 @@ declare class PhasedScheduler<PhaseName extends string> {
     run(): void;
 }
 type PluggableElementTypeGroup = 'renderer' | 'adapter' | 'display' | 'track' | 'connection' | 'view' | 'widget' | 'rpc method' | 'internet account' | 'text search adapter' | 'add track workflow';
-/** internal class that holds the info for a certain element type */
 declare class TypeRecord<ElementClass extends PluggableElementBase> {
     typeName: string;
     baseClass: (new (...args: unknown[]) => ElementClass) | (Function & {
@@ -40,13 +39,6 @@ declare class TypeRecord<ElementClass extends PluggableElementBase> {
     all(): ElementClass[];
 }
 type AnyFunction = (...args: any) => any;
-/**
- * free-form string-to-unknown mapping of metadata related to the instance of
- * this plugin. `isCore` is typically set to `Boolean(true)` if the plugin was
- * loaded as part of the "core" set of plugins for this application. Can also
- * use this metadata to stash other things about why the plugin is loaded, such
- * as where it came from, what plugin depends on it, etc.
- */
 export type PluginMetadata = Record<string, unknown>;
 export interface PluginLoadRecord {
     metadata?: PluginMetadata;
@@ -100,7 +92,7 @@ export default class PluginManager {
     getPlugin(name: string): Plugin | undefined;
     hasPlugin(name: string): boolean;
     createPluggableElements(): this;
-    setRootModel(rootModel: AbstractRootModel): void;
+    setRootModel(rootModel: AbstractRootModel): this;
     configure(): this;
     getElementTypeRecord(groupName: PluggableElementTypeGroup): TypeRecord<PluggableElementBase>;
     addElementType(groupName: PluggableElementTypeGroup, creationCallback: (pluginManager: PluginManager) => PluggableElementType): this;
@@ -113,9 +105,7 @@ export default class PluginManager {
     getRpcElements(): RpcMethodType[];
     getDisplayElements(): DisplayType[];
     getAdapterElements(): AdapterType[];
-    /** get a MST type for the union of all specified pluggable MST types */
     pluggableMstType(groupName: PluggableElementTypeGroup, fieldName: PluggableElementMember, fallback?: IAnyType): IAnyType;
-    /** get a MST type for the union of all specified pluggable config schemas */
     pluggableConfigSchemaType(typeGroup: PluggableElementTypeGroup, fieldName?: PluggableElementMember): IAnyModelType;
     jbrequireCache: Map<any, any>;
     lib: {
@@ -217,10 +207,11 @@ export default class PluginManager {
         react: typeof import("react");
         'react/jsx-runtime': typeof import("react/jsx-runtime");
         'react-dom': typeof import("react-dom");
+        'react-dom/client': typeof import("react-dom/client");
         '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/internals").GridApiCommunity>() => React.MutableRefObject<Api>;
+            useGridApiRef: <Api extends import("@mui/x-data-grid").GridApiCommon = import("@mui/x-data-grid/internals").GridApiCommunity>() => import("@mui/x-internals/types").RefObject<Api>;
             useGridRootProps: () => import("@mui/x-data-grid/internals").DataGridProcessedProps;
         };
         '@mui/material/utils': typeof import("@mui/material/utils");
@@ -258,12 +249,6 @@ export default class PluginManager {
         };
     };
     load: <FTYPE extends AnyFunction>(lib: FTYPE) => ReturnType<FTYPE>;
-    /**
-     * Get the re-exported version of the given package name.
-     * Throws an error if the package is not re-exported by the plugin manager.
-     *
-     * @returns the library's default export
-     */
     jbrequire: (lib: keyof typeof ReExports | AnyFunction | {
         default: AnyFunction;
     }) => any;

package/PluginManager.js

@@ -3,25 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 const mobx_state_tree_1 = require("mobx-state-tree");
-const RendererType_1 = __importDefault(require("./pluggableElementTypes/renderers/RendererType"));
+const CorePlugin_1 = __importDefault(require("./CorePlugin"));
+const ReExports_1 = __importDefault(require("./ReExports"));
+const configuration_1 = require("./configuration");
 const AdapterType_1 = __importDefault(require("./pluggableElementTypes/AdapterType"));
-const TrackType_1 = __importDefault(require("./pluggableElementTypes/TrackType"));
-const DisplayType_1 = __importDefault(require("./pluggableElementTypes/DisplayType"));
-const ViewType_1 = __importDefault(require("./pluggableElementTypes/ViewType"));
-const WidgetType_1 = __importDefault(require("./pluggableElementTypes/WidgetType"));
+const AddTrackWorkflowType_1 = __importDefault(require("./pluggableElementTypes/AddTrackWorkflowType"));
 const ConnectionType_1 = __importDefault(require("./pluggableElementTypes/ConnectionType"));
-const RpcMethodType_1 = __importDefault(require("./pluggableElementTypes/RpcMethodType"));
+const DisplayType_1 = __importDefault(require("./pluggableElementTypes/DisplayType"));
 const InternetAccountType_1 = __importDefault(require("./pluggableElementTypes/InternetAccountType"));
+const RpcMethodType_1 = __importDefault(require("./pluggableElementTypes/RpcMethodType"));
 const TextSearchAdapterType_1 = __importDefault(require("./pluggableElementTypes/TextSearchAdapterType"));
-const AddTrackWorkflowType_1 = __importDefault(require("./pluggableElementTypes/AddTrackWorkflowType"));
-const configuration_1 = require("./configuration");
-const ReExports_1 = __importDefault(require("./ReExports"));
-const CorePlugin_1 = __importDefault(require("./CorePlugin"));
+const TrackType_1 = __importDefault(require("./pluggableElementTypes/TrackType"));
+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"));
-// helper class that keeps groups of callbacks that are then run in a specified
-// order by group
 class PhasedScheduler {
     constructor(...phaseOrder) {
         this.phaseCallbacks = new Map();
@@ -46,7 +43,6 @@ class PhasedScheduler {
         });
     }
 }
-/** internal class that holds the info for a certain element type */
 class TypeRecord {
     constructor(typeName, baseClass) {
         this.typeName = typeName;
@@ -97,16 +93,9 @@ class PluginManager {
             }
             return this.jbrequireCache.get(lib);
         };
-        /**
-         * Get the re-exported version of the given package name.
-         * Throws an error if the package is not re-exported by the plugin manager.
-         *
-         * @returns the library's default export
-         */
         this.jbrequire = (lib) => {
             if (typeof lib === 'string') {
                 const pack = this.lib[lib];
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                 if (!pack) {
                     throw new TypeError(`No jbrequire re-export defined for package '${lib}'. If this package must be shared between plugins, add it to ReExports.js. If it does not need to be shared, just import it normally.`);
                 }
@@ -115,20 +104,17 @@ class PluginManager {
             if (typeof lib === 'function') {
                 return this.load(lib);
             }
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             if (lib.default) {
                 return this.jbrequire(lib.default);
             }
             throw new TypeError('lib passed to jbrequire must be either a string or a function');
         };
-        // add the core plugin
         this.addPlugin({
             plugin: new CorePlugin_1.default(),
             metadata: {
                 isCore: true,
             },
         });
-        // add all the initial plugins
         initialPlugins.forEach(plugin => {
             this.addPlugin(plugin);
         });
@@ -146,8 +132,6 @@ class PluginManager {
         if (this.configured) {
             throw new Error('JBrowse already configured, cannot add plugins');
         }
-        // check for availability of 'install' and 'configure' as a proxy for being
-        // an 'instanceof Plugin'
         const [plugin, metadata = {}] = 'install' in load && 'configure' in load
             ? [load, {}]
             : [load.plugin, load.metadata];
@@ -169,8 +153,6 @@ class PluginManager {
         return this.getPlugin(name) !== undefined;
     }
     createPluggableElements() {
-        // run the creation callbacks for each element type in order.
-        // see elementCreationSchedule above for the creation order
         if (this.elementCreationSchedule) {
             this.elementCreationSchedule.run();
             this.elementCreationSchedule = undefined;
@@ -179,6 +161,7 @@ class PluginManager {
     }
     setRootModel(rootModel) {
         this.rootModel = rootModel;
+        return this;
     }
     configure() {
         if (this.configured) {
@@ -230,9 +213,11 @@ class PluginManager {
                 throw new Error(`cannot add a ${groupName} with no name`);
             }
             if (typeRecord.has(newElement.name)) {
-                throw new Error(`${groupName} ${newElement.name} already registered, cannot register it again`);
+                console.warn(`${groupName} ${newElement.name} already registered, cannot register it again`);
+            }
+            else {
+                typeRecord.add(newElement.name, this.evaluateExtensionPoint('Core-extendPluggableElement', newElement));
             }
-            typeRecord.add(newElement.name, this.evaluateExtensionPoint('Core-extendPluggableElement', newElement));
         });
         return this;
     }
@@ -263,26 +248,20 @@ class PluginManager {
     getAdapterElements() {
         return this.getElementTypesInGroup('adapter');
     }
-    /** get a MST type for the union of all specified pluggable MST types */
     pluggableMstType(groupName, fieldName, fallback = mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.null)) {
         const pluggableTypes = this.getElementTypeRecord(groupName)
             .all()
-            // @ts-expect-error
             .map(t => t[fieldName])
             .filter(t => (0, mobx_state_tree_1.isType)(t) && (0, mobx_state_tree_1.isModelType)(t));
-        // try to smooth over the case when no types are registered, mostly
-        // encountered in tests
         if (pluggableTypes.length === 0 && typeof jest === 'undefined') {
             console.warn(`No pluggable types found matching ('${groupName}','${fieldName}')`);
             return fallback;
         }
         return mobx_state_tree_1.types.union(...pluggableTypes);
     }
-    /** get a MST type for the union of all specified pluggable config schemas */
     pluggableConfigSchemaType(typeGroup, fieldName = 'configSchema') {
         const pluggableTypes = this.getElementTypeRecord(typeGroup)
             .all()
-            // @ts-expect-error
             .map(t => t[fieldName])
             .filter(t => (0, configuration_1.isBareConfigurationSchemaType)(t));
         if (pluggableTypes.length === 0) {
@@ -336,13 +315,10 @@ class PluginManager {
         return this.addElementType('text search adapter', cb);
     }
     addTrackType(cb) {
-        // Goes through the already-created displays and registers the ones that
-        // specify this track type
         const callback = () => {
             const track = cb(this);
             const displays = this.getElementTypesInGroup('display');
             displays.forEach(display => {
-                // track may have already added the displayType in its cb
                 if (display.trackType === track.name &&
                     !track.displayTypes.includes(display)) {
                     track.addDisplayType(display);
@@ -360,8 +336,6 @@ class PluginManager {
             const newView = cb(this);
             const displays = this.getElementTypesInGroup('display');
             displays.forEach(display => {
-                // view may have already added the displayType in its callback
-                // see ViewType for description of extendedName
                 if ((display.viewType === newView.name ||
                     display.viewType === newView.extendedName) &&
                     !newView.displayTypes.includes(display)) {

package/ReExports/DataGrid.js

@@ -1,5 +1,4 @@
 "use strict";
-// convert named export to default for lazy react
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = void 0;
 var x_data_grid_1 = require("@mui/x-data-grid");

package/ReExports/list.d.ts

@@ -1,7 +1,2 @@
-/**
- * Used by plugin build systems to determine if a module is provided by JBrowse
- * globally and thus doesn't need to be bundled. A check in ./modules.tsx makes
- * sure this is in sync with the re-exported modules.
- */
 declare const _default: string[];
 export default _default;