@jbrowse/core 2.0.1 → 2.1.0

package/PluginManager.js

@@ -1,684 +1,395 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _mobxStateTree = require("mobx-state-tree");
-
-var _RendererType = _interopRequireDefault(require("./pluggableElementTypes/renderers/RendererType"));
-
-var _AdapterType = _interopRequireDefault(require("./pluggableElementTypes/AdapterType"));
-
-var _TrackType = _interopRequireDefault(require("./pluggableElementTypes/TrackType"));
-
-var _DisplayType = _interopRequireDefault(require("./pluggableElementTypes/DisplayType"));
-
-var _ViewType = _interopRequireDefault(require("./pluggableElementTypes/ViewType"));
-
-var _WidgetType = _interopRequireDefault(require("./pluggableElementTypes/WidgetType"));
-
-var _ConnectionType = _interopRequireDefault(require("./pluggableElementTypes/ConnectionType"));
-
-var _RpcMethodType = _interopRequireDefault(require("./pluggableElementTypes/RpcMethodType"));
-
-var _InternetAccountType = _interopRequireDefault(require("./pluggableElementTypes/InternetAccountType"));
-
-var _TextSearchAdapterType = _interopRequireDefault(require("./pluggableElementTypes/TextSearchAdapterType"));
-
-var _configuration = require("./configuration");
-
-var _Plugin = _interopRequireDefault(require("./Plugin"));
-
-var _ReExports = _interopRequireDefault(require("./ReExports"));
-
-var _CorePlugin = _interopRequireDefault(require("./CorePlugin"));
-
-var _jexl = _interopRequireDefault(require("./util/jexl"));
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mobx_state_tree_1 = require("mobx-state-tree");
+const RendererType_1 = __importDefault(require("./pluggableElementTypes/renderers/RendererType"));
+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 ConnectionType_1 = __importDefault(require("./pluggableElementTypes/ConnectionType"));
+const RpcMethodType_1 = __importDefault(require("./pluggableElementTypes/RpcMethodType"));
+const InternetAccountType_1 = __importDefault(require("./pluggableElementTypes/InternetAccountType"));
+const TextSearchAdapterType_1 = __importDefault(require("./pluggableElementTypes/TextSearchAdapterType"));
+const AddTrackWorkflowType_1 = __importDefault(require("./pluggableElementTypes/AddTrackWorkflowType"));
+const configuration_1 = require("./configuration");
+const Plugin_1 = __importDefault(require("./Plugin"));
+const ReExports_1 = __importDefault(require("./ReExports"));
+const CorePlugin_1 = __importDefault(require("./CorePlugin"));
+const jexl_1 = __importDefault(require("./util/jexl"));
 /** little helper class that keeps groups of callbacks that are
 then run in a specified order by group */
-var PhasedScheduler = /*#__PURE__*/function () {
-  function PhasedScheduler() {
-    (0, _classCallCheck2.default)(this, PhasedScheduler);
-    (0, _defineProperty2.default)(this, "phaseCallbacks", new Map());
-    (0, _defineProperty2.default)(this, "phaseOrder", []);
-
-    for (var _len = arguments.length, phaseOrder = new Array(_len), _key = 0; _key < _len; _key++) {
-      phaseOrder[_key] = arguments[_key];
-    }
-
-    this.phaseOrder = phaseOrder;
-  }
-
-  (0, _createClass2.default)(PhasedScheduler, [{
-    key: "add",
-    value: function add(phase, callback) {
-      if (!this.phaseOrder.includes(phase)) {
-        throw new Error("unknown phase ".concat(phase));
-      }
-
-      var phaseCallbacks = this.phaseCallbacks.get(phase);
-
-      if (!phaseCallbacks) {
-        phaseCallbacks = [];
-        this.phaseCallbacks.set(phase, phaseCallbacks);
-      }
-
-      phaseCallbacks.push(callback);
-    }
-  }, {
-    key: "run",
-    value: function run() {
-      var _this = this;
-
-      this.phaseOrder.forEach(function (phaseName) {
-        var _this$phaseCallbacks$;
-
-        (_this$phaseCallbacks$ = _this.phaseCallbacks.get(phaseName)) === null || _this$phaseCallbacks$ === void 0 ? void 0 : _this$phaseCallbacks$.forEach(function (callback) {
-          return callback();
+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() {
+        this.phaseOrder.forEach(phaseName => {
+            var _a;
+            (_a = this.phaseCallbacks.get(phaseName)) === null || _a === void 0 ? void 0 : _a.forEach(callback => callback());
         });
-      });
     }
-  }]);
-  return PhasedScheduler;
-}();
-
+}
 /** internal class that holds the info for a certain element type */
-var TypeRecord = /*#__PURE__*/function () {
-  function TypeRecord(typeName, baseClass) {
-    (0, _classCallCheck2.default)(this, TypeRecord);
-    this.typeName = typeName;
-    this.baseClass = baseClass;
-    (0, _defineProperty2.default)(this, "registeredTypes", {});
-  }
-
-  (0, _createClass2.default)(TypeRecord, [{
-    key: "add",
-    value: function add(name, t) {
-      this.registeredTypes[name] = t;
-    }
-  }, {
-    key: "has",
-    value: function has(name) {
-      return name in this.registeredTypes;
-    }
-  }, {
-    key: "get",
-    value: function get(name) {
-      if (!this.has(name)) {
-        throw new Error("".concat(this.typeName, " '").concat(name, "' not found, perhaps its plugin is not loaded or its plugin has not added it."));
-      }
-
-      return this.registeredTypes[name];
-    }
-  }, {
-    key: "all",
-    value: function all() {
-      return Object.values(this.registeredTypes);
-    }
-  }]);
-  return TypeRecord;
-}(); // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-
-var PluginManager = /*#__PURE__*/function () {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function PluginManager() {
-    var _this2 = this;
-
-    var initialPlugins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    (0, _classCallCheck2.default)(this, PluginManager);
-    (0, _defineProperty2.default)(this, "plugins", []);
-    (0, _defineProperty2.default)(this, "jexl", (0, _jexl.default)());
-    (0, _defineProperty2.default)(this, "pluginMetadata", {});
-    (0, _defineProperty2.default)(this, "runtimePluginDefinitions", []);
-    (0, _defineProperty2.default)(this, "elementCreationSchedule", new PhasedScheduler('renderer', 'adapter', 'text search adapter', 'display', 'track', 'connection', 'view', 'widget', 'rpc method', 'internet account'));
-    (0, _defineProperty2.default)(this, "rendererTypes", new TypeRecord('RendererType', _RendererType.default));
-    (0, _defineProperty2.default)(this, "adapterTypes", new TypeRecord('AdapterType', _AdapterType.default));
-    (0, _defineProperty2.default)(this, "textSearchAdapterTypes", new TypeRecord('TextSearchAdapterType', _TextSearchAdapterType.default));
-    (0, _defineProperty2.default)(this, "trackTypes", new TypeRecord('TrackType', _TrackType.default));
-    (0, _defineProperty2.default)(this, "displayTypes", new TypeRecord('DisplayType', _DisplayType.default));
-    (0, _defineProperty2.default)(this, "connectionTypes", new TypeRecord('ConnectionType', _ConnectionType.default));
-    (0, _defineProperty2.default)(this, "viewTypes", new TypeRecord('ViewType', _ViewType.default));
-    (0, _defineProperty2.default)(this, "widgetTypes", new TypeRecord('WidgetType', _WidgetType.default));
-    (0, _defineProperty2.default)(this, "rpcMethods", new TypeRecord('RpcMethodType', _RpcMethodType.default));
-    (0, _defineProperty2.default)(this, "internetAccountTypes", new TypeRecord('InternetAccountType', _InternetAccountType.default));
-    (0, _defineProperty2.default)(this, "configured", false);
-    (0, _defineProperty2.default)(this, "rootModel", void 0);
-    (0, _defineProperty2.default)(this, "extensionPoints", new Map());
-    (0, _defineProperty2.default)(this, "jbrequireCache", new Map());
-    (0, _defineProperty2.default)(this, "lib", _ReExports.default);
-    (0, _defineProperty2.default)(this, "load", function (lib) {
-      if (!_this2.jbrequireCache.has(lib)) {
-        _this2.jbrequireCache.set(lib, lib(_this2));
-      }
-
-      return _this2.jbrequireCache.get(lib);
-    });
-    (0, _defineProperty2.default)(this, "jbrequire", function (lib // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
-      if (typeof lib === 'string') {
-        var pack = _this2.lib[lib];
-
-        if (!pack) {
-          throw new TypeError("No jbrequire re-export defined for package '".concat(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."));
+class TypeRecord {
+    constructor(typeName, baseClass) {
+        this.typeName = typeName;
+        this.baseClass = baseClass;
+        this.registeredTypes = {};
+    }
+    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 pack;
-      }
-
-      if (typeof lib === 'function') {
-        return _this2.load(lib);
-      }
-
-      if (lib.default) {
-        return _this2.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.default(),
-      metadata: {
-        isCore: true
-      }
-    }); // add all the initial plugins
-
-    initialPlugins.forEach(function (plugin) {
-      _this2.addPlugin(plugin);
-    });
-  }
-
-  (0, _createClass2.default)(PluginManager, [{
-    key: "pluginConfigurationSchemas",
-    value: function pluginConfigurationSchemas() {
-      var configurationSchemas = {};
-      this.plugins.forEach(function (plugin) {
-        if (plugin.configurationSchema) {
-          configurationSchemas[plugin.name] = plugin.configurationSchema;
+        return this.registeredTypes[name];
+    }
+    all() {
+        return Object.values(this.registeredTypes);
+    }
+}
+class PluginManager {
+    constructor(initialPlugins = []) {
+        this.plugins = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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.rendererTypes = new TypeRecord('RendererType', RendererType_1.default);
+        this.adapterTypes = new TypeRecord('AdapterType', AdapterType_1.default);
+        this.textSearchAdapterTypes = new TypeRecord('TextSearchAdapterType', TextSearchAdapterType_1.default);
+        this.trackTypes = new TypeRecord('TrackType', TrackType_1.default);
+        this.displayTypes = new TypeRecord('DisplayType', DisplayType_1.default);
+        this.connectionTypes = new TypeRecord('ConnectionType', ConnectionType_1.default);
+        this.viewTypes = new TypeRecord('ViewType', ViewType_1.default);
+        this.widgetTypes = new TypeRecord('WidgetType', WidgetType_1.default);
+        this.rpcMethods = new TypeRecord('RpcMethodType', RpcMethodType_1.default);
+        this.addTrackWidgets = new TypeRecord('AddTrackWorkflow', AddTrackWorkflowType_1.default);
+        this.internetAccountTypes = new TypeRecord('InternetAccountType', InternetAccountType_1.default);
+        this.configured = false;
+        this.extensionPoints = new Map();
+        this.jbrequireCache = new Map();
+        this.lib = ReExports_1.default;
+        this.load = (lib) => {
+            if (!this.jbrequireCache.has(lib)) {
+                this.jbrequireCache.set(lib, lib(this));
+            }
+            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];
+                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;
+            }
+            if (typeof lib === 'function') {
+                return this.load(lib);
+            }
+            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);
+        });
+    }
+    pluginConfigurationSchemas() {
+        const configurationSchemas = {};
+        this.plugins.forEach(plugin => {
+            if (plugin.configurationSchema) {
+                configurationSchemas[plugin.name] = plugin.configurationSchema;
+            }
+        });
+        return configurationSchemas;
+    }
+    addPlugin(load) {
+        if (this.configured) {
+            throw new Error('JBrowse already configured, cannot add plugins');
         }
-      });
-      return configurationSchemas;
-    }
-  }, {
-    key: "addPlugin",
-    value: function addPlugin(load) {
-      if (this.configured) {
-        throw new Error('JBrowse already configured, cannot add plugins');
-      }
-
-      var _ref = load instanceof _Plugin.default ? [load, {}] : [load.plugin, load.metadata],
-          _ref2 = (0, _slicedToArray2.default)(_ref, 2),
-          plugin = _ref2[0],
-          _ref2$ = _ref2[1],
-          metadata = _ref2$ === void 0 ? {} : _ref2$;
-
-      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;
-    }
-  }, {
-    key: "getPlugin",
-    value: function getPlugin(name) {
-      return this.plugins.find(function (p) {
-        return p.name === name;
-      });
-    }
-  }, {
-    key: "hasPlugin",
-    value: function hasPlugin(name) {
-      return this.getPlugin(name) !== undefined;
-    }
-  }, {
-    key: "createPluggableElements",
-    value: function createPluggableElements() {
-      // run the creation callbacks for each element type in order.
-      // see elementCreationSchedule above for the creation order
-      if (this.elementCreationSchedule) {
-        this.elementCreationSchedule.run();
-        delete this.elementCreationSchedule;
-      }
-
-      return this;
-    }
-  }, {
-    key: "setRootModel",
-    value: function setRootModel(rootModel) {
-      this.rootModel = rootModel;
-    }
-  }, {
-    key: "configure",
-    value: function configure() {
-      var _this3 = this;
-
-      if (this.configured) {
-        throw new Error('already configured');
-      }
-
-      this.plugins.forEach(function (plugin) {
-        return plugin.configure(_this3);
-      });
-      this.configured = true; // console.log(JSON.stringify(getSnapshot(model)))
-
-      return this;
-    }
-  }, {
-    key: "getElementTypeRecord",
-    value: function 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;
-
-        default:
-          throw new Error("invalid element type '".concat(groupName, "'"));
-      }
-    }
-  }, {
-    key: "addElementType",
-    value: function addElementType(groupName, creationCallback) {
-      var _this4 = this;
-
-      if (typeof creationCallback !== 'function') {
-        throw new Error('must provide a callback function that returns the new type object');
-      }
-
-      var typeRecord = this.getElementTypeRecord(groupName);
-
-      if (this.elementCreationSchedule) {
-        this.elementCreationSchedule.add(groupName, function () {
-          var newElement = creationCallback(_this4);
-
-          if (!newElement.name) {
-            throw new Error("cannot add a ".concat(groupName, " with no name"));
-          }
-
-          if (typeRecord.has(newElement.name)) {
-            throw new Error("".concat(groupName, " ").concat(newElement.name, " already registered, cannot register it again"));
-          }
-
-          newElement = _this4.evaluateExtensionPoint('Core-extendPluggableElement', newElement);
-          typeRecord.add(newElement.name, newElement);
+        const [plugin, metadata = {}] = load instanceof Plugin_1.default ? [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() {
+        // run the creation callbacks for each element type in order.
+        // see elementCreationSchedule above for the creation order
+        if (this.elementCreationSchedule) {
+            this.elementCreationSchedule.run();
+            delete this.elementCreationSchedule;
+        }
+        return this;
+    }
+    setRootModel(rootModel) {
+        this.rootModel = rootModel;
+    }
+    configure() {
+        if (this.configured) {
+            throw new Error('already configured');
+        }
+        this.plugins.forEach(plugin => plugin.configure(this));
+        this.configured = true;
+        // console.log(JSON.stringify(getSnapshot(model)))
+        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;
+            default:
+                throw new Error(`invalid element type '${groupName}'`);
+        }
+    }
+    addElementType(groupName, creationCallback) {
+        var _a;
+        if (typeof creationCallback !== 'function') {
+            throw new Error('must provide a callback function that returns the new type object');
+        }
+        const typeRecord = this.getElementTypeRecord(groupName);
+        (_a = this.elementCreationSchedule) === null || _a === void 0 ? void 0 : _a.add(groupName, () => {
+            const newElement = creationCallback(this);
+            if (!newElement.name) {
+                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`);
+            }
+            typeRecord.add(newElement.name, this.evaluateExtensionPoint('Core-extendPluggableElement', newElement));
         });
-      }
-
-      return this;
-    }
-  }, {
-    key: "getElementType",
-    value: function getElementType(groupName, typeName) {
-      var typeRecord = this.getElementTypeRecord(groupName);
-      return typeRecord.get(typeName);
-    }
-  }, {
-    key: "getElementTypesInGroup",
-    value: function getElementTypesInGroup(groupName) {
-      var typeRecord = this.getElementTypeRecord(groupName);
-      return typeRecord.all();
+        return this;
+    }
+    getElementType(groupName, typeName) {
+        return this.getElementTypeRecord(groupName).get(typeName);
+    }
+    getElementTypesInGroup(groupName) {
+        return this.getElementTypeRecord(groupName).all();
     }
     /** get a MST type for the union of all specified pluggable MST types */
-
-  }, {
-    key: "pluggableMstType",
-    value: function pluggableMstType(typeGroup, fieldName) {
-      var fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _mobxStateTree.types.maybe(_mobxStateTree.types.null);
-      var pluggableTypes = this.getElementTypeRecord(typeGroup).all() // @ts-ignore
-      .map(function (t) {
-        return t[fieldName];
-      }).filter(function (t) {
-        return (0, _mobxStateTree.isType)(t) && (0, _mobxStateTree.isModelType)(t);
-      }); // try to smooth over the case when no types are registered, mostly
-      // encountered in tests
-
-      if (pluggableTypes.length === 0) {
-        console.warn("No JBrowse pluggable types found matching ('".concat(typeGroup, "','").concat(fieldName, "')"));
-        return fallback;
-      }
-
-      return _mobxStateTree.types.union.apply(_mobxStateTree.types, (0, _toConsumableArray2.default)(pluggableTypes));
+    pluggableMstType(groupName, fieldName, fallback = mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.null)) {
+        const pluggableTypes = this.getElementTypeRecord(groupName)
+            .all()
+            // @ts-ignore
+            .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) {
+            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 */
-
-  }, {
-    key: "pluggableConfigSchemaType",
-    value: function pluggableConfigSchemaType(typeGroup) {
-      var fieldName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'configSchema';
-      var pluggableTypes = this.getElementTypeRecord(typeGroup).all() // @ts-ignore
-      .map(function (t) {
-        return t[fieldName];
-      }).filter(function (t) {
-        return (0, _configuration.isBareConfigurationSchemaType)(t);
-      });
-
-      if (pluggableTypes.length === 0) {
-        pluggableTypes.push((0, _configuration.ConfigurationSchema)('Null', {}));
-      }
-
-      return _mobxStateTree.types.union.apply(_mobxStateTree.types, (0, _toConsumableArray2.default)(pluggableTypes));
-    }
-  }, {
-    key: "getRendererType",
-    value: function getRendererType(typeName) {
-      return this.rendererTypes.get(typeName);
-    }
-  }, {
-    key: "getRendererTypes",
-    value: function getRendererTypes() {
-      return this.rendererTypes.all();
-    }
-  }, {
-    key: "getAdapterType",
-    value: function getAdapterType(typeName) {
-      return this.adapterTypes.get(typeName);
-    }
-  }, {
-    key: "getTextSearchAdapterType",
-    value: function getTextSearchAdapterType(typeName) {
-      return this.textSearchAdapterTypes.get(typeName);
-    }
-  }, {
-    key: "getTrackType",
-    value: function getTrackType(typeName) {
-      return this.trackTypes.get(typeName);
-    }
-  }, {
-    key: "getDisplayType",
-    value: function getDisplayType(typeName) {
-      return this.displayTypes.get(typeName);
-    }
-  }, {
-    key: "getViewType",
-    value: function getViewType(typeName) {
-      return this.viewTypes.get(typeName);
-    }
-  }, {
-    key: "getWidgetType",
-    value: function getWidgetType(typeName) {
-      return this.widgetTypes.get(typeName);
-    }
-  }, {
-    key: "getConnectionType",
-    value: function getConnectionType(typeName) {
-      return this.connectionTypes.get(typeName);
-    }
-  }, {
-    key: "getRpcMethodType",
-    value: function getRpcMethodType(methodName) {
-      return this.rpcMethods.get(methodName);
-    }
-  }, {
-    key: "getInternetAccountType",
-    value: function getInternetAccountType(internetAccountName) {
-      return this.internetAccountTypes.get(internetAccountName);
-    }
-  }, {
-    key: "addRendererType",
-    value: function addRendererType(creationCallback) {
-      return this.addElementType('renderer', creationCallback);
-    }
-  }, {
-    key: "addAdapterType",
-    value: function addAdapterType(creationCallback) {
-      return this.addElementType('adapter', creationCallback);
-    }
-  }, {
-    key: "addTextSearchAdapterType",
-    value: function addTextSearchAdapterType(creationCallback) {
-      return this.addElementType('text search adapter', creationCallback);
-    }
-  }, {
-    key: "addTrackType",
-    value: function addTrackType(creationCallback) {
-      var _this5 = this;
-
-      // Goes through the already-created displays and registers the ones that
-      // specify this track type
-      var callback = function callback() {
-        var track = creationCallback(_this5);
-
-        _this5.getElementTypesInGroup('display').forEach(function (display) {
-          if (display.trackType === track.name && // track may have already added the displayType in its creationCallback
-          !track.displayTypes.includes(display)) {
-            track.addDisplayType(display);
-          }
-        });
-
-        return track;
-      };
-
-      return this.addElementType('track', callback);
-    }
-  }, {
-    key: "addDisplayType",
-    value: function addDisplayType(creationCallback) {
-      return this.addElementType('display', creationCallback);
-    }
-  }, {
-    key: "addViewType",
-    value: function addViewType(creationCallback) {
-      var _this6 = this;
-
-      var callback = function callback() {
-        var newView = creationCallback(_this6);
-
-        _this6.getElementTypesInGroup('display').forEach(function (display) {
-          if (display.viewType === newView.name && // view may have already added the displayType in its creationCallback
-          !newView.displayTypes.includes(display)) {
-            newView.addDisplayType(display);
-          }
-        });
-
-        return newView;
-      };
-
-      return this.addElementType('view', callback);
-    }
-  }, {
-    key: "addWidgetType",
-    value: function addWidgetType(creationCallback) {
-      return this.addElementType('widget', creationCallback);
-    }
-  }, {
-    key: "addConnectionType",
-    value: function addConnectionType(creationCallback) {
-      return this.addElementType('connection', creationCallback);
-    }
-  }, {
-    key: "addRpcMethod",
-    value: function addRpcMethod(creationCallback) {
-      return this.addElementType('rpc method', creationCallback);
-    }
-  }, {
-    key: "addInternetAccountType",
-    value: function addInternetAccountType(creationCallback) {
-      return this.addElementType('internet account', creationCallback);
-    }
-  }, {
-    key: "addToExtensionPoint",
-    value: function addToExtensionPoint(extensionPointName, callback) {
-      var callbacks = this.extensionPoints.get(extensionPointName);
-
-      if (!callbacks) {
-        callbacks = [];
-        this.extensionPoints.set(extensionPointName, callbacks);
-      }
-
-      callbacks.push(callback);
-    }
-  }, {
-    key: "evaluateExtensionPoint",
-    value: function evaluateExtensionPoint(extensionPointName, extendee) {
-      var callbacks = this.extensionPoints.get(extensionPointName);
-      var accumulator = extendee;
-
-      if (callbacks) {
-        var _iterator = _createForOfIteratorHelper(callbacks),
-            _step;
-
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var callback = _step.value;
-
-            try {
-              accumulator = callback(accumulator);
-            } catch (error) {
-              console.error(error);
+    pluggableConfigSchemaType(typeGroup, fieldName = 'configSchema') {
+        const pluggableTypes = this.getElementTypeRecord(typeGroup)
+            .all()
+            // @ts-ignore
+            .map(t => t[fieldName])
+            .filter(t => (0, configuration_1.isBareConfigurationSchemaType)(t));
+        if (pluggableTypes.length === 0) {
+            pluggableTypes.push((0, configuration_1.ConfigurationSchema)('Null', {}));
+        }
+        return mobx_state_tree_1.types.union(...pluggableTypes);
+    }
+    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) {
+        // 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);
+                }
+            });
+            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');
+            displays.forEach(display => {
+                // view may have already added the displayType in its callback
+                if (display.viewType === newView.name &&
+                    !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);
+    }
+    addToExtensionPoint(extensionPointName, callback) {
+        let callbacks = this.extensionPoints.get(extensionPointName);
+        if (!callbacks) {
+            callbacks = [];
+            this.extensionPoints.set(extensionPointName, callbacks);
+        }
+        callbacks.push(callback);
+    }
+    evaluateExtensionPoint(extensionPointName, extendee) {
+        const callbacks = this.extensionPoints.get(extensionPointName);
+        let accumulator = extendee;
+        if (callbacks) {
+            for (const callback of callbacks) {
+                try {
+                    accumulator = callback(accumulator);
+                }
+                catch (error) {
+                    console.error(error);
+                }
             }
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
         }
-      }
-
-      return accumulator;
-    }
-  }, {
-    key: "evaluateAsyncExtensionPoint",
-    value: function () {
-      var _evaluateAsyncExtensionPoint = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(extensionPointName, extendee) {
-        var callbacks, accumulator, _iterator2, _step2, callback;
-
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                callbacks = this.extensionPoints.get(extensionPointName);
-                accumulator = extendee;
-
-                if (!callbacks) {
-                  _context.next = 27;
-                  break;
+        return accumulator;
+    }
+    async evaluateAsyncExtensionPoint(extensionPointName, extendee) {
+        const callbacks = this.extensionPoints.get(extensionPointName);
+        let accumulator = extendee;
+        if (callbacks) {
+            for (const callback of callbacks) {
+                try {
+                    accumulator = await callback(accumulator);
                 }
-
-                _iterator2 = _createForOfIteratorHelper(callbacks);
-                _context.prev = 4;
-
-                _iterator2.s();
-
-              case 6:
-                if ((_step2 = _iterator2.n()).done) {
-                  _context.next = 19;
-                  break;
+                catch (error) {
+                    console.error(error);
                 }
-
-                callback = _step2.value;
-                _context.prev = 8;
-                _context.next = 11;
-                return callback(accumulator);
-
-              case 11:
-                accumulator = _context.sent;
-                _context.next = 17;
-                break;
-
-              case 14:
-                _context.prev = 14;
-                _context.t0 = _context["catch"](8);
-                console.error(_context.t0);
-
-              case 17:
-                _context.next = 6;
-                break;
-
-              case 19:
-                _context.next = 24;
-                break;
-
-              case 21:
-                _context.prev = 21;
-                _context.t1 = _context["catch"](4);
-
-                _iterator2.e(_context.t1);
-
-              case 24:
-                _context.prev = 24;
-
-                _iterator2.f();
-
-                return _context.finish(24);
-
-              case 27:
-                return _context.abrupt("return", accumulator);
-
-              case 28:
-              case "end":
-                return _context.stop();
             }
-          }
-        }, _callee, this, [[4, 21, 24, 27], [8, 14]]);
-      }));
-
-      function evaluateAsyncExtensionPoint(_x, _x2) {
-        return _evaluateAsyncExtensionPoint.apply(this, arguments);
-      }
-
-      return evaluateAsyncExtensionPoint;
-    }()
-  }]);
-  return PluginManager;
-}();
-
-exports.default = PluginManager;
+        }
+        return accumulator;
+    }
+}
+exports.default = PluginManager;