@jbrowse/core 3.7.0 → 4.0.0

package/esm/PluginManager.js

@@ -0,0 +1,414 @@
+import { isModelType, isType, types } from '@jbrowse/mobx-state-tree';
+import CorePlugin from "./CorePlugin.js";
+import PhasedScheduler from "./PhasedScheduler.js";
+import ReExports from "./ReExports/index.js";
+import { ConfigurationSchema, isBareConfigurationSchemaType, } from "./configuration/index.js";
+import AdapterType from "./pluggableElementTypes/AdapterType.js";
+import AddTrackWorkflowType from "./pluggableElementTypes/AddTrackWorkflowType.js";
+import ConnectionType from "./pluggableElementTypes/ConnectionType.js";
+import DisplayType from "./pluggableElementTypes/DisplayType.js";
+import GlyphType from "./pluggableElementTypes/GlyphType.js";
+import InternetAccountType from "./pluggableElementTypes/InternetAccountType.js";
+import RpcMethodType from "./pluggableElementTypes/RpcMethodType.js";
+import TextSearchAdapterType from "./pluggableElementTypes/TextSearchAdapterType.js";
+import TrackType from "./pluggableElementTypes/TrackType.js";
+import ViewType from "./pluggableElementTypes/ViewType.js";
+import WidgetType from "./pluggableElementTypes/WidgetType.js";
+import RendererType from "./pluggableElementTypes/renderers/RendererType.js";
+import createJexlInstance from "./util/jexl.js";
+class TypeRecord {
+    typeName;
+    baseClass;
+    registeredTypes = {};
+    constructor(typeName, baseClass) {
+        this.typeName = typeName;
+        this.baseClass = baseClass;
+    }
+    add(name, t) {
+        this.registeredTypes[name] = t;
+    }
+    has(name) {
+        return name in this.registeredTypes;
+    }
+    get(name) {
+        if (!this.has(name)) {
+            throw new Error(`${this.typeName} '${name}' not found, perhaps its plugin is not loaded or its plugin has not added it.`);
+        }
+        return this.registeredTypes[name];
+    }
+    all() {
+        return Object.values(this.registeredTypes);
+    }
+}
+export default class PluginManager {
+    plugins = [];
+    jexl = createJexlInstance();
+    pluginMetadata = {};
+    runtimePluginDefinitions = [];
+    elementCreationSchedule = new PhasedScheduler('glyph', 'renderer', 'adapter', 'text search adapter', 'display', 'track', 'connection', 'view', 'widget', 'rpc method', 'internet account', 'add track workflow');
+    glyphTypes = new TypeRecord('GlyphType', GlyphType);
+    rendererTypes = new TypeRecord('RendererType', RendererType);
+    adapterTypes = new TypeRecord('AdapterType', AdapterType);
+    textSearchAdapterTypes = new TypeRecord('TextSearchAdapterType', TextSearchAdapterType);
+    trackTypes = new TypeRecord('TrackType', TrackType);
+    displayTypes = new TypeRecord('DisplayType', DisplayType);
+    connectionTypes = new TypeRecord('ConnectionType', ConnectionType);
+    viewTypes = new TypeRecord('ViewType', ViewType);
+    widgetTypes = new TypeRecord('WidgetType', WidgetType);
+    rpcMethods = new TypeRecord('RpcMethodType', RpcMethodType);
+    addTrackWidgets = new TypeRecord('AddTrackWorkflow', AddTrackWorkflowType);
+    internetAccountTypes = new TypeRecord('InternetAccountType', InternetAccountType);
+    configured = false;
+    rootModel;
+    extensionPoints = new Map();
+    constructor(initialPlugins = []) {
+        this.addPlugin({
+            plugin: new CorePlugin(),
+            metadata: {
+                isCore: true,
+            },
+        });
+        for (const plugin of initialPlugins) {
+            this.addPlugin(plugin);
+        }
+    }
+    pluginConfigurationNamespacedSchemas() {
+        const configurationSchemas = {};
+        for (const plugin of this.plugins) {
+            if (plugin.configurationSchema) {
+                configurationSchemas[plugin.name] = plugin.configurationSchema;
+            }
+        }
+        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');
+        }
+        const [plugin, metadata = {}] = 'install' in load && 'configure' in load
+            ? [load, {}]
+            : [load.plugin, load.metadata];
+        if (this.plugins.includes(plugin)) {
+            throw new Error('plugin already installed');
+        }
+        this.pluginMetadata[plugin.name] = metadata;
+        if ('definition' in load) {
+            this.runtimePluginDefinitions.push(load.definition);
+        }
+        plugin.install(this);
+        this.plugins.push(plugin);
+        return this;
+    }
+    getPlugin(name) {
+        return this.plugins.find(p => p.name === name);
+    }
+    hasPlugin(name) {
+        return this.getPlugin(name) !== undefined;
+    }
+    createPluggableElements() {
+        if (this.elementCreationSchedule) {
+            this.elementCreationSchedule.run();
+            this.elementCreationSchedule = undefined;
+        }
+        return this;
+    }
+    setRootModel(rootModel) {
+        this.rootModel = rootModel;
+        return this;
+    }
+    configure() {
+        if (this.configured) {
+            throw new Error('already configured');
+        }
+        for (const plugin of this.plugins) {
+            plugin.configure(this);
+        }
+        this.configured = true;
+        return this;
+    }
+    getElementTypeRecord(groupName) {
+        switch (groupName) {
+            case 'adapter':
+                return this.adapterTypes;
+            case 'text search adapter':
+                return this.textSearchAdapterTypes;
+            case 'connection':
+                return this.connectionTypes;
+            case 'widget':
+                return this.widgetTypes;
+            case 'renderer':
+                return this.rendererTypes;
+            case 'display':
+                return this.displayTypes;
+            case 'track':
+                return this.trackTypes;
+            case 'view':
+                return this.viewTypes;
+            case 'rpc method':
+                return this.rpcMethods;
+            case 'internet account':
+                return this.internetAccountTypes;
+            case 'add track workflow':
+                return this.addTrackWidgets;
+            case 'glyph':
+                return this.glyphTypes;
+            default:
+                throw new Error(`invalid element type '${groupName}'`);
+        }
+    }
+    addElementType(groupName, creationCallback) {
+        if (typeof creationCallback !== 'function') {
+            throw new Error('must provide a callback function that returns the new type object');
+        }
+        const typeRecord = this.getElementTypeRecord(groupName);
+        this.elementCreationSchedule?.add(groupName, () => {
+            const newElement = creationCallback(this);
+            if (!newElement.name) {
+                throw new Error(`cannot add a ${groupName} with no name`);
+            }
+            if (typeRecord.has(newElement.name)) {
+                console.warn(`${groupName} ${newElement.name} already registered, cannot register it again`);
+            }
+            else {
+                typeRecord.add(newElement.name, this.evaluateExtensionPoint('Core-extendPluggableElement', newElement));
+            }
+        });
+        return this;
+    }
+    getElementType(groupName, typeName) {
+        return this.getElementTypeRecord(groupName).get(typeName);
+    }
+    getElementTypesInGroup(groupName) {
+        return this.getElementTypeRecord(groupName).all();
+    }
+    getViewElements() {
+        return this.getElementTypesInGroup('view');
+    }
+    getTrackElements() {
+        return this.getElementTypesInGroup('track');
+    }
+    getConnectionElements() {
+        return this.getElementTypesInGroup('connection');
+    }
+    getAddTrackWorkflowElements() {
+        return this.getElementTypesInGroup('add track workflow');
+    }
+    getRpcElements() {
+        return this.getElementTypesInGroup('rpc method');
+    }
+    getDisplayElements() {
+        return this.getElementTypesInGroup('display');
+    }
+    getAdapterElements() {
+        return this.getElementTypesInGroup('adapter');
+    }
+    pluggableMstType(groupName, fieldName, fallback = types.maybe(types.null)) {
+        const pluggableTypes = this.getElementTypeRecord(groupName)
+            .all()
+            .map(t => t[fieldName])
+            .filter(t => isType(t) && isModelType(t));
+        if (pluggableTypes.length === 0 && typeof jest === 'undefined') {
+            console.warn(`No pluggable types found matching ('${groupName}','${fieldName}')`);
+            return fallback;
+        }
+        return types.union(...pluggableTypes);
+    }
+    pluggableConfigSchemaType(typeGroup, fieldName = 'configSchema') {
+        const pluggableTypes = this.getElementTypeRecord(typeGroup)
+            .all()
+            .map(t => t[fieldName])
+            .filter(t => isBareConfigurationSchemaType(t));
+        if (pluggableTypes.length === 0) {
+            pluggableTypes.push(ConfigurationSchema('Null', {}));
+        }
+        return types.union(...pluggableTypes);
+    }
+    jbrequireCache = new Map();
+    lib = ReExports;
+    load = (lib) => {
+        if (!this.jbrequireCache.has(lib)) {
+            this.jbrequireCache.set(lib, lib(this));
+        }
+        return this.jbrequireCache.get(lib);
+    };
+    jbrequire = (lib) => {
+        if (typeof lib === 'string') {
+            const pack = this.lib[lib];
+            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.`);
+            }
+            return pack;
+        }
+        else if (typeof lib === 'function') {
+            return this.load(lib);
+        }
+        else if (lib.default) {
+            console.warn('initiated jbrequire on a {default:Function}');
+            return this.jbrequire(lib.default);
+        }
+        throw new TypeError('lib passed to jbrequire must be either a string or a function');
+    };
+    getRendererType(typeName) {
+        return this.rendererTypes.get(typeName);
+    }
+    getRendererTypes() {
+        return this.rendererTypes.all();
+    }
+    getAdapterType(typeName) {
+        return this.adapterTypes.get(typeName);
+    }
+    getTextSearchAdapterType(typeName) {
+        return this.textSearchAdapterTypes.get(typeName);
+    }
+    getTrackType(typeName) {
+        return this.trackTypes.get(typeName);
+    }
+    getDisplayType(typeName) {
+        return this.displayTypes.get(typeName);
+    }
+    getViewType(typeName) {
+        return this.viewTypes.get(typeName);
+    }
+    getAddTrackWorkflow(typeName) {
+        return this.addTrackWidgets.get(typeName);
+    }
+    getWidgetType(typeName) {
+        return this.widgetTypes.get(typeName);
+    }
+    getConnectionType(typeName) {
+        return this.connectionTypes.get(typeName);
+    }
+    getRpcMethodType(methodName) {
+        return this.rpcMethods.get(methodName);
+    }
+    getInternetAccountType(name) {
+        return this.internetAccountTypes.get(name);
+    }
+    addRendererType(cb) {
+        return this.addElementType('renderer', cb);
+    }
+    addAdapterType(cb) {
+        return this.addElementType('adapter', cb);
+    }
+    addTextSearchAdapterType(cb) {
+        return this.addElementType('text search adapter', cb);
+    }
+    addTrackType(cb) {
+        const callback = () => {
+            const track = cb(this);
+            const displays = this.getElementTypesInGroup('display');
+            for (const display of displays) {
+                if (display.trackType === track.name &&
+                    !track.displayTypes.includes(display)) {
+                    track.addDisplayType(display);
+                }
+            }
+            return track;
+        };
+        return this.addElementType('track', callback);
+    }
+    addDisplayType(cb) {
+        return this.addElementType('display', cb);
+    }
+    addViewType(cb) {
+        const callback = () => {
+            const newView = cb(this);
+            const displays = this.getElementTypesInGroup('display');
+            for (const display of displays) {
+                if ((display.viewType === newView.name ||
+                    display.viewType === newView.extendedName) &&
+                    !newView.displayTypes.includes(display)) {
+                    newView.addDisplayType(display);
+                }
+            }
+            return newView;
+        };
+        return this.addElementType('view', callback);
+    }
+    addWidgetType(cb) {
+        return this.addElementType('widget', cb);
+    }
+    addConnectionType(cb) {
+        return this.addElementType('connection', cb);
+    }
+    addRpcMethod(cb) {
+        return this.addElementType('rpc method', cb);
+    }
+    addInternetAccountType(cb) {
+        return this.addElementType('internet account', cb);
+    }
+    addAddTrackWorkflowType(cb) {
+        return this.addElementType('add track workflow', cb);
+    }
+    addGlyphType(cb) {
+        return this.addElementType('glyph', cb);
+    }
+    getGlyphType(typeName) {
+        return this.glyphTypes.get(typeName);
+    }
+    getGlyphTypes() {
+        return this.glyphTypes.all();
+    }
+    addToExtensionPoint(extensionPointName, callback) {
+        let callbacks = this.extensionPoints.get(extensionPointName);
+        if (!callbacks) {
+            callbacks = [];
+            this.extensionPoints.set(extensionPointName, callbacks);
+        }
+        callbacks.push(callback);
+    }
+    evaluateExtensionPoint(extensionPointName, extendee, props) {
+        const callbacks = this.extensionPoints.get(extensionPointName);
+        let accumulator = extendee;
+        if (callbacks) {
+            for (const callback of callbacks) {
+                try {
+                    accumulator = callback(accumulator, props);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+        }
+        return accumulator;
+    }
+    async evaluateAsyncExtensionPoint(extensionPointName, extendee, props) {
+        const callbacks = this.extensionPoints.get(extensionPointName);
+        let accumulator = extendee;
+        if (callbacks) {
+            for (const callback of callbacks) {
+                try {
+                    accumulator = await callback(accumulator, props);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+        }
+        return accumulator;
+    }
+}

package/esm/ReExports/BaseFeatureDetails.js

@@ -0,0 +1,9 @@
+import { lazy } from 'react';
+import { lazyMap } from "./lazify.js";
+export const BaseFeatureDetail = lazyMap({
+    Attributes: lazy(() => import("../BaseFeatureWidget/BaseFeatureDetail/Attributes.js")),
+    FeatureDetails: lazy(() => import("../BaseFeatureWidget/BaseFeatureDetail/FeatureDetails.js")),
+    BaseCard: lazy(() => import("../BaseFeatureWidget/BaseFeatureDetail/BaseCard.js")),
+    BaseAttributes: lazy(() => import("../BaseFeatureWidget/BaseFeatureDetail/BaseAttributes.js")),
+    BaseCoreDetails: lazy(() => import("../BaseFeatureWidget/BaseFeatureDetail/BaseCoreDetails.js")),
+}, '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/');

package/esm/ReExports/DataGrid.js

@@ -0,0 +1 @@
+export { DataGrid as default } from '@mui/x-data-grid';

package/esm/ReExports/MuiDataGridReExports.js

@@ -0,0 +1,131 @@
+import { lazy } from 'react';
+export const DataGridEntries = {
+    DataGrid: lazy(() => import('@mui/x-data-grid').then(module => ({ default: module.DataGrid }))),
+    GridActionsCellItem: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridActionsCellItem,
+    }))),
+    GridAddIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridAddIcon,
+    }))),
+    GridArrowDownwardIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridArrowDownwardIcon,
+    }))),
+    GridArrowUpwardIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridArrowUpwardIcon,
+    }))),
+    GridCellCheckboxForwardRef: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridCellCheckboxForwardRef,
+    }))),
+    GridCellCheckboxRenderer: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridCellCheckboxRenderer,
+    }))),
+    GridCheckCircleIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridCheckCircleIcon,
+    }))),
+    GridCheckIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridCheckIcon,
+    }))),
+    GridCloseIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridCloseIcon,
+    }))),
+    GridColumnHeaderSeparator: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridColumnHeaderSeparator,
+    }))),
+    GridColumnHeaderSortIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridColumnHeaderSortIcon,
+    }))),
+    GridColumnIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridColumnIcon,
+    }))),
+    GridColumnMenu: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridColumnMenu,
+    }))),
+    GridColumnMenuContainer: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridColumnMenuContainer,
+    }))),
+    GridDragIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridDragIcon,
+    }))),
+    GridExpandMoreIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridExpandMoreIcon,
+    }))),
+    GridFilterAltIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridFilterAltIcon,
+    }))),
+    GridFilterForm: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridFilterForm,
+    }))),
+    GridFilterListIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridFilterListIcon,
+    }))),
+    GridFilterPanel: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridFilterPanel,
+    }))),
+    GridFooter: lazy(() => import('@mui/x-data-grid').then(module => ({ default: module.GridFooter }))),
+    GridFooterContainer: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridFooterContainer,
+    }))),
+    GridHeader: lazy(() => import('@mui/x-data-grid').then(module => ({ default: module.GridHeader }))),
+    GridHeaderCheckbox: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridHeaderCheckbox,
+    }))),
+    GridKeyboardArrowRight: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridKeyboardArrowRight,
+    }))),
+    GridLoadIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridLoadIcon,
+    }))),
+    GridLoadingOverlay: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridLoadingOverlay,
+    }))),
+    GridMenuIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridMenuIcon,
+    }))),
+    GridMoreVertIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridMoreVertIcon,
+    }))),
+    GridNoRowsOverlay: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridNoRowsOverlay,
+    }))),
+    GridOverlay: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridOverlay,
+    }))),
+    GridPagination: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridPagination,
+    }))),
+    GridPanel: lazy(() => import('@mui/x-data-grid').then(module => ({ default: module.GridPanel }))),
+    GridPanelWrapper: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridPanelWrapper,
+    }))),
+    GridRemoveIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridRemoveIcon,
+    }))),
+    GridRoot: lazy(() => import('@mui/x-data-grid').then(module => ({ default: module.GridRoot }))),
+    GridRowCount: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridRowCount,
+    }))),
+    GridSearchIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridSearchIcon,
+    }))),
+    GridSelectedRowCount: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridSelectedRowCount,
+    }))),
+    GridSeparatorIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridSeparatorIcon,
+    }))),
+    GridTableRowsIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridTableRowsIcon,
+    }))),
+    GridToolbarExportContainer: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridToolbarExportContainer,
+    }))),
+    GridTripleDotsVerticalIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridTripleDotsVerticalIcon,
+    }))),
+    GridViewHeadlineIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridViewHeadlineIcon,
+    }))),
+    GridViewStreamIcon: lazy(() => import('@mui/x-data-grid').then(module => ({
+        default: module.GridViewStreamIcon,
+    }))),
+};