@jbrowse/core 2.17.0 → 2.18.0

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

@@ -29,18 +29,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: {
@@ -258,12 +248,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) {
@@ -263,26 +246,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 +313,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 +334,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;

package/ReExports/list.js

@@ -1,10 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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.
- */
 exports.default = [
     'mobx',
     'mobx-state-tree',

package/ReExports/modules.d.ts

@@ -1,40 +1,42 @@
+import type { LazyExoticComponent } from 'react';
 import React from 'react';
-import * as ReactJSXRuntime from 'react/jsx-runtime';
-import * as ReactDom from 'react-dom';
-import * as mobx from 'mobx';
-import * as mst from 'mobx-state-tree';
-import * as mxreact from 'mobx-react';
+import { useTheme } from '@mui/material';
 import * as MUIStyles from '@mui/material/styles';
 import * as MUIUtils from '@mui/material/utils';
 import { useGridApiContext } from '@mui/x-data-grid';
+import * as mobx from 'mobx';
+import * as mxreact from 'mobx-react';
+import * as mst from 'mobx-state-tree';
+import * as ReactJSXRuntime from 'react/jsx-runtime';
+import * as ReactDom from 'react-dom';
+import Plugin from '../Plugin';
+import * as Configuration from '../configuration';
 import * as BaseAdapterExports from '../data_adapters/BaseAdapter';
 import * as pluggableElementTypes from '../pluggableElementTypes';
 import * as pluggableElementTypeModels from '../pluggableElementTypes/models';
-import * as ServerSideRendererType from '../pluggableElementTypes/renderers/ServerSideRendererType';
 import * as BoxRendererType from '../pluggableElementTypes/renderers/BoxRendererType';
 import * as FeatureRendererType from '../pluggableElementTypes/renderers/FeatureRendererType';
 import * as RendererType from '../pluggableElementTypes/renderers/RendererType';
-import * as Configuration from '../configuration';
-import Plugin from '../Plugin';
+import * as ServerSideRendererType from '../pluggableElementTypes/renderers/ServerSideRendererType';
 import * as coreUi from '../ui';
 import * as coreUtil from '../util';
 import * as coreColor from '../util/color';
-import * as coreLayouts from '../util/layouts';
-import * as trackUtils from '../util/tracks';
 import * as coreIo from '../util/io';
+import * as coreLayouts from '../util/layouts';
 import * as coreMstReflection from '../util/mst-reflection';
 import * as rxjs from '../util/rxjs';
+import * as trackUtils from '../util/tracks';
 import * as mstTypes from '../util/types/mst';
 declare const libs: {
-    '@material-ui/lab/ToggleButton': React.LazyExoticComponent<import("@mui/material").ExtendButtonBase<import("@mui/material").ToggleButtonTypeMap<{}, "button">>>;
-    '@material-ui/lab/ToggleButtonGroup': React.LazyExoticComponent<typeof import("@mui/material").ToggleButtonGroup>;
-    '@material-ui/lab/Autocomplete': React.LazyExoticComponent<typeof import("@mui/material").Autocomplete>;
-    '@material-ui/lab/Alert': React.LazyExoticComponent<typeof import("@mui/material").Alert>;
+    '@material-ui/lab/ToggleButton': LazyExoticComponent<import("@mui/material").ExtendButtonBase<import("@mui/material").ToggleButtonTypeMap<{}, "button">>>;
+    '@material-ui/lab/ToggleButtonGroup': LazyExoticComponent<typeof import("@mui/material").ToggleButtonGroup>;
+    '@material-ui/lab/Autocomplete': LazyExoticComponent<typeof import("@mui/material").Autocomplete>;
+    '@material-ui/lab/Alert': LazyExoticComponent<typeof import("@mui/material").Alert>;
     '@material-ui/lab': {
-        Alert: React.LazyExoticComponent<typeof import("@mui/material").Alert>;
-        Autocomplete: React.LazyExoticComponent<typeof import("@mui/material").Autocomplete>;
-        ToggleButton: React.LazyExoticComponent<import("@mui/material").ExtendButtonBase<import("@mui/material").ToggleButtonTypeMap<{}, "button">>>;
-        ToggleButtonGroup: React.LazyExoticComponent<typeof import("@mui/material").ToggleButtonGroup>;
+        Alert: LazyExoticComponent<typeof import("@mui/material").Alert>;
+        Autocomplete: LazyExoticComponent<typeof import("@mui/material").Autocomplete>;
+        ToggleButton: LazyExoticComponent<import("@mui/material").ExtendButtonBase<import("@mui/material").ToggleButtonTypeMap<{}, "button">>>;
+        ToggleButtonGroup: LazyExoticComponent<typeof import("@mui/material").ToggleButtonGroup>;
     };
     '@jbrowse/core/Plugin': typeof Plugin;
     '@jbrowse/core/pluggableElementTypes': typeof pluggableElementTypes;
@@ -147,13 +149,13 @@ declare const libs: {
         };
     };
     '@material-ui/core': {
-        useTheme: typeof MUIStyles.useTheme;
+        useTheme: typeof useTheme;
         alpha: typeof MUIStyles.alpha;
         makeStyles: (args: any) => () => Record<string, string>;
     };
     '@mui/material': {
         alpha: typeof MUIStyles.alpha;
-        useTheme: typeof MUIStyles.useTheme;
+        useTheme: typeof useTheme;
     };
     '@mui/material/styles': {
         MUIStyles: typeof MUIStyles;

package/ReExports/modules.js

@@ -26,46 +26,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable react-refresh/only-export-components */
-// this is all the stuff that the pluginManager re-exports for plugins to use
 const react_1 = __importStar(require("react"));
-const ReactJSXRuntime = __importStar(require("react/jsx-runtime"));
-const ReactDom = __importStar(require("react-dom"));
-const mobx = __importStar(require("mobx"));
-const mst = __importStar(require("mobx-state-tree"));
-const mxreact = __importStar(require("mobx-react"));
-const mui_1 = require("tss-react/mui");
+const material_1 = require("@mui/material");
 const MUIStyles = __importStar(require("@mui/material/styles"));
 const MUIUtils = __importStar(require("@mui/material/utils"));
-const material_1 = require("@mui/material");
 const x_data_grid_1 = require("@mui/x-data-grid");
-// material-ui lab
+const mobx = __importStar(require("mobx"));
+const mxreact = __importStar(require("mobx-react"));
+const mst = __importStar(require("mobx-state-tree"));
+const ReactJSXRuntime = __importStar(require("react/jsx-runtime"));
+const ReactDom = __importStar(require("react-dom"));
+const mui_1 = require("tss-react/mui");
+const Plugin_1 = __importDefault(require("../Plugin"));
+const Configuration = __importStar(require("../configuration"));
 const BaseAdapterExports = __importStar(require("../data_adapters/BaseAdapter"));
-const Base1DViewModel_1 = __importDefault(require("../util/Base1DViewModel"));
 const pluggableElementTypes = __importStar(require("../pluggableElementTypes"));
-const ViewType_1 = __importDefault(require("../pluggableElementTypes/ViewType"));
+const list_1 = __importDefault(require("./list"));
 const AdapterType_1 = __importDefault(require("../pluggableElementTypes/AdapterType"));
 const DisplayType_1 = __importDefault(require("../pluggableElementTypes/DisplayType"));
 const TrackType_1 = __importDefault(require("../pluggableElementTypes/TrackType"));
+const ViewType_1 = __importDefault(require("../pluggableElementTypes/ViewType"));
 const WidgetType_1 = __importDefault(require("../pluggableElementTypes/WidgetType"));
 const pluggableElementTypeModels = __importStar(require("../pluggableElementTypes/models"));
-const ServerSideRendererType = __importStar(require("../pluggableElementTypes/renderers/ServerSideRendererType"));
-const CircularChordRendererType_1 = __importDefault(require("../pluggableElementTypes/renderers/CircularChordRendererType"));
 const BoxRendererType = __importStar(require("../pluggableElementTypes/renderers/BoxRendererType"));
+const CircularChordRendererType_1 = __importDefault(require("../pluggableElementTypes/renderers/CircularChordRendererType"));
 const FeatureRendererType = __importStar(require("../pluggableElementTypes/renderers/FeatureRendererType"));
 const RendererType = __importStar(require("../pluggableElementTypes/renderers/RendererType"));
-const Configuration = __importStar(require("../configuration"));
-const Plugin_1 = __importDefault(require("../Plugin"));
+const ServerSideRendererType = __importStar(require("../pluggableElementTypes/renderers/ServerSideRendererType"));
 const coreUi = __importStar(require("../ui"));
 const coreUtil = __importStar(require("../util"));
+const Base1DViewModel_1 = __importDefault(require("../util/Base1DViewModel"));
 const coreColor = __importStar(require("../util/color"));
-const coreLayouts = __importStar(require("../util/layouts"));
-const trackUtils = __importStar(require("../util/tracks"));
 const coreIo = __importStar(require("../util/io"));
+const coreLayouts = __importStar(require("../util/layouts"));
 const coreMstReflection = __importStar(require("../util/mst-reflection"));
 const rxjs = __importStar(require("../util/rxjs"));
+const trackUtils = __importStar(require("../util/tracks"));
 const mstTypes = __importStar(require("../util/types/mst"));
-const list_1 = __importDefault(require("./list"));
 const Entries = {
     Accordion: (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('@mui/material/Accordion')))),
     AccordionActions: (0, react_1.lazy)(() => Promise.resolve().then(() => __importStar(require('@mui/material/AccordionActions')))),
@@ -373,7 +370,6 @@ const libs = {
         useGridRootProps: x_data_grid_1.useGridRootProps,
         ...LazyDataGridComponents,
     },
-    // special case so plugins can easily use @mui/icons-material; don't remove
     '@mui/material/utils': MUIUtils,
     '@material-ui/core/utils': MUIUtils,
     'tss-react/mui': { makeStyles: mui_1.makeStyles },
@@ -391,8 +387,6 @@ const libs = {
         alpha: MUIStyles.alpha,
         useTheme: MUIStyles.useTheme,
     },
-    // end special case
-    // material-ui subcomponents, should get rid of these
     '@mui/material/styles': {
         MUIStyles,
         makeStyles: (args) => {
@@ -409,7 +403,6 @@ const libs = {
     },
     ...MaterialPrefixMUI,
     ...MuiPrefixMUI,
-    // these are core in @mui/material, but used to be in @material-ui/lab
     '@material-ui/lab/ToggleButton': Entries.ToggleButton,
     '@material-ui/lab/ToggleButtonGroup': Entries.ToggleButtonGroup,
     '@material-ui/lab/Autocomplete': Entries.Autocomplete,
@@ -452,8 +445,6 @@ const libs = {
     '@jbrowse/core/data_adapters/BaseAdapter': BaseAdapterExports,
 };
 const libsList = Object.keys(libs);
-// make sure that all the items in the ReExports/list array (used by build
-// systems and such) are included here, and vice versa
 const inLibsOnly = libsList.filter(mod => !list_1.default.includes(mod));
 if (inLibsOnly.length > 0) {
     throw new Error(`The following modules are in the modules libs, but not the re-exports list: ${inLibsOnly.join(', ')}`);

package/TextSearch/BaseResults.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
-import TextSearchAdapterType from '../pluggableElementTypes/TextSearchAdapterType';
-import { SearchType } from '../data_adapters/BaseAdapter';
+import type React from 'react';
+import type { SearchType } from '../data_adapters/BaseAdapter';
+import type TextSearchAdapterType from '../pluggableElementTypes/TextSearchAdapterType';
 export interface BaseResultArgs {
     label: string;
     displayString?: string;