@jbrowse/core 2.0.1 → 2.1.0

package/PluginLoader.js

@@ -1,438 +1,169 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCJSPluginDefinition = exports.isESMPluginDefinition = exports.isUMDPluginDefinition = exports.PluginSourceConfigurationSchema = void 0;
+const load_script2_1 = __importDefault(require("load-script2"));
+const configuration_1 = require("./configuration");
+const ReExports_1 = __importDefault(require("./ReExports"));
+const util_1 = require("./util");
+exports.PluginSourceConfigurationSchema = (0, configuration_1.ConfigurationSchema)('PluginSource', {
+    name: {
+        type: 'string',
+        defaultValue: '',
+    },
+    url: {
+        type: 'string',
+        defaultValue: '',
+    },
 });
-exports.default = exports.PluginSourceConfigurationSchema = void 0;
-exports.isCJSPluginDefinition = isCJSPluginDefinition;
-exports.isESMPluginDefinition = isESMPluginDefinition;
-exports.isUMDPluginDefinition = isUMDPluginDefinition;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-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 _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-var _loadScript = _interopRequireDefault(require("load-script2"));
-
-var _configuration = require("./configuration");
-
-var _ReExports = _interopRequireDefault(require("./ReExports"));
-
-var _util = require("./util");
-
-var PluginSourceConfigurationSchema = (0, _configuration.ConfigurationSchema)('PluginSource', {
-  name: {
-    type: 'string',
-    defaultValue: ''
-  },
-  url: {
-    type: 'string',
-    defaultValue: ''
-  }
-});
-exports.PluginSourceConfigurationSchema = PluginSourceConfigurationSchema;
-
 function isUMDPluginDefinition(pluginDefinition) {
-  return (pluginDefinition.umdUrl !== undefined || pluginDefinition.url !== undefined) && pluginDefinition.name !== undefined;
+    return ((pluginDefinition.umdUrl !== undefined ||
+        pluginDefinition.url !== undefined) &&
+        pluginDefinition
+            .name !== undefined);
 }
-
+exports.isUMDPluginDefinition = isUMDPluginDefinition;
 function isESMPluginDefinition(pluginDefinition) {
-  return pluginDefinition.esmUrl !== undefined;
+    return pluginDefinition.esmUrl !== undefined;
 }
-
+exports.isESMPluginDefinition = isESMPluginDefinition;
 function isCJSPluginDefinition(pluginDefinition) {
-  return pluginDefinition.cjsUrl !== undefined;
+    return pluginDefinition.cjsUrl !== undefined;
 }
-
+exports.isCJSPluginDefinition = isCJSPluginDefinition;
 function getGlobalObject() {
-  // Based on window-or-global
-  // https://github.com/purposeindustries/window-or-global/blob/322abc71de0010c9e5d9d0729df40959e1ef8775/lib/index.js
-  return (// eslint-disable-next-line no-restricted-globals
-    (typeof self === "undefined" ? "undefined" : (0, _typeof2.default)(self)) === 'object' && self.self === self && self || (typeof global === "undefined" ? "undefined" : (0, _typeof2.default)(global)) === 'object' && global.global === global && global || // @ts-ignore
-    this
-  );
+    // Based on window-or-global
+    // https://github.com/purposeindustries/window-or-global/blob/322abc71de0010c9e5d9d0729df40959e1ef8775/lib/index.js
+    return (
+    // eslint-disable-next-line no-restricted-globals
+    (typeof self === 'object' && self.self === self && self) ||
+        (typeof global === 'object' && global.global === global && global) ||
+        // @ts-ignore
+        this);
 }
-
 function isInWebWorker(globalObject) {
-  return Boolean('WorkerGlobalScope' in globalObject);
+    return Boolean('WorkerGlobalScope' in globalObject);
 }
-
-var PluginLoader = /*#__PURE__*/function () {
-  function PluginLoader() {
-    var pluginDefinitions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    var args = arguments.length > 1 ? arguments[1] : undefined;
-    (0, _classCallCheck2.default)(this, PluginLoader);
-    (0, _defineProperty2.default)(this, "definitions", []);
-    (0, _defineProperty2.default)(this, "fetchESM", void 0);
-    (0, _defineProperty2.default)(this, "fetchCJS", void 0);
-    this.fetchESM = args === null || args === void 0 ? void 0 : args.fetchESM;
-    this.fetchCJS = args === null || args === void 0 ? void 0 : args.fetchCJS;
-    this.definitions = JSON.parse(JSON.stringify(pluginDefinitions));
-  }
-
-  (0, _createClass2.default)(PluginLoader, [{
-    key: "loadScript",
-    value: function loadScript(scriptUrl) {
-      var globalObject = getGlobalObject();
-
-      if (!isInWebWorker(globalObject)) {
-        return (0, _loadScript.default)(scriptUrl);
-      } // @ts-ignore
-
-
-      if (globalObject && globalObject.importScripts) {
-        return new Promise(function (resolve, reject) {
-          try {
-            // @ts-ignore
-            globalObject.importScripts(scriptUrl);
-          } catch (error) {
-            reject(error || new Error("failed to load ".concat(scriptUrl)));
-            return;
-          }
-
-          resolve();
-        });
-      }
-
-      throw new Error('cannot figure out how to load external JS scripts in this environment');
+class PluginLoader {
+    constructor(pluginDefinitions = [], args) {
+        this.definitions = [];
+        this.fetchESM = args === null || args === void 0 ? void 0 : args.fetchESM;
+        this.fetchCJS = args === null || args === void 0 ? void 0 : args.fetchCJS;
+        this.definitions = JSON.parse(JSON.stringify(pluginDefinitions));
     }
-  }, {
-    key: "loadCJSPlugin",
-    value: function () {
-      var _loadCJSPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref) {
-        var cjsUrl, parsedUrl;
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                cjsUrl = _ref.cjsUrl;
-                _context.prev = 1;
-                parsedUrl = new URL(cjsUrl, getGlobalObject().location.href);
-                _context.next = 9;
-                break;
-
-              case 5:
-                _context.prev = 5;
-                _context.t0 = _context["catch"](1);
-                console.error(_context.t0);
-                throw new Error("Error parsing URL: ".concat(cjsUrl));
-
-              case 9:
-                if (!(parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')) {
-                  _context.next = 11;
-                  break;
-                }
-
-                throw new Error("Cannot load plugins using protocol \"".concat(parsedUrl.protocol, "\""));
-
-              case 11:
-                if (this.fetchCJS) {
-                  _context.next = 13;
-                  break;
-                }
-
-                throw new Error('No fetchCJS callback provided');
-
-              case 13:
-                return _context.abrupt("return", this.fetchCJS(parsedUrl.href));
-
-              case 14:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this, [[1, 5]]);
-      }));
-
-      function loadCJSPlugin(_x) {
-        return _loadCJSPlugin.apply(this, arguments);
-      }
-
-      return loadCJSPlugin;
-    }()
-  }, {
-    key: "loadESMPlugin",
-    value: function () {
-      var _loadESMPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(pluginDefinition) {
-        var _this$fetchESM;
-
-        var parsedUrl, plugin;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                _context2.prev = 0;
-                parsedUrl = new URL(pluginDefinition.esmUrl, getGlobalObject().location.href);
-                _context2.next = 8;
-                break;
-
-              case 4:
-                _context2.prev = 4;
-                _context2.t0 = _context2["catch"](0);
-                console.error(_context2.t0);
-                throw new Error("Error parsing URL: ".concat(pluginDefinition.esmUrl));
-
-              case 8:
-                if (!(parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')) {
-                  _context2.next = 10;
-                  break;
-                }
-
-                throw new Error("cannot load plugins using protocol \"".concat(parsedUrl.protocol, "\""));
-
-              case 10:
-                _context2.next = 12;
-                return (_this$fetchESM = this.fetchESM) === null || _this$fetchESM === void 0 ? void 0 : _this$fetchESM.call(this, parsedUrl.href);
-
-              case 12:
-                plugin = _context2.sent;
-
-                if (plugin) {
-                  _context2.next = 15;
-                  break;
-                }
-
-                throw new Error("Could not load ESM plugin: ".concat(parsedUrl));
-
-              case 15:
-                return _context2.abrupt("return", plugin);
-
-              case 16:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this, [[0, 4]]);
-      }));
-
-      function loadESMPlugin(_x2) {
-        return _loadESMPlugin.apply(this, arguments);
-      }
-
-      return loadESMPlugin;
-    }()
-  }, {
-    key: "loadUMDPlugin",
-    value: function () {
-      var _loadUMDPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(pluginDefinition) {
-        var umdUrl, parsedUrl, moduleName, umdName, globalObject, plugin;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                umdUrl = 'url' in pluginDefinition ? pluginDefinition.url : pluginDefinition.umdUrl;
-                _context3.prev = 1;
-                parsedUrl = new URL(umdUrl, getGlobalObject().location.href);
-                _context3.next = 9;
-                break;
-
-              case 5:
-                _context3.prev = 5;
-                _context3.t0 = _context3["catch"](1);
-                console.error(_context3.t0);
-                throw new Error("Error parsing URL: ".concat(umdUrl));
-
-              case 9:
-                if (!(parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')) {
-                  _context3.next = 11;
-                  break;
+    loadScript(scriptUrl) {
+        const globalObject = getGlobalObject();
+        if (!isInWebWorker(globalObject)) {
+            return (0, load_script2_1.default)(scriptUrl);
+        }
+        // @ts-ignore
+        if (globalObject && globalObject.importScripts) {
+            return new Promise((resolve, reject) => {
+                try {
+                    // @ts-ignore
+                    globalObject.importScripts(scriptUrl);
                 }
-
-                throw new Error("cannot load plugins using protocol \"".concat(parsedUrl.protocol, "\""));
-
-              case 11:
-                _context3.next = 13;
-                return this.loadScript(parsedUrl.href);
-
-              case 13:
-                moduleName = pluginDefinition.name;
-                umdName = "JBrowsePlugin".concat(moduleName);
-                globalObject = getGlobalObject(); // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-                plugin = globalObject[umdName];
-
-                if (plugin) {
-                  _context3.next = 19;
-                  break;
+                catch (error) {
+                    reject(error || new Error(`failed to load ${scriptUrl}`));
+                    return;
                 }
-
-                throw new Error("Failed to load UMD bundle for ".concat(moduleName, ", ").concat(globalObject.constructor.name, ".").concat(umdName, " is undefined"));
-
-              case 19:
-                return _context3.abrupt("return", plugin);
-
-              case 20:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3, this, [[1, 5]]);
-      }));
-
-      function loadUMDPlugin(_x3) {
-        return _loadUMDPlugin.apply(this, arguments);
-      }
-
-      return loadUMDPlugin;
-    }()
-  }, {
-    key: "loadPlugin",
-    value: function () {
-      var _loadPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(definition) {
-        var plugin;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) {
-            switch (_context4.prev = _context4.next) {
-              case 0:
-                if (!(_util.isElectron && isCJSPluginDefinition(definition))) {
-                  _context4.next = 6;
-                  break;
-                }
-
-                _context4.next = 3;
-                return this.loadCJSPlugin(definition);
-
-              case 3:
-                plugin = _context4.sent;
-                _context4.next = 23;
-                break;
-
-              case 6:
-                if (!isESMPluginDefinition(definition)) {
-                  _context4.next = 12;
-                  break;
-                }
-
-                _context4.next = 9;
-                return this.loadESMPlugin(definition);
-
-              case 9:
-                plugin = _context4.sent;
-                _context4.next = 23;
-                break;
-
-              case 12:
-                if (!isUMDPluginDefinition(definition)) {
-                  _context4.next = 18;
-                  break;
-                }
-
-                _context4.next = 15;
-                return this.loadUMDPlugin(definition);
-
-              case 15:
-                plugin = _context4.sent;
-                _context4.next = 23;
-                break;
-
-              case 18:
-                if (!(!_util.isElectron && isCJSPluginDefinition(definition))) {
-                  _context4.next = 22;
-                  break;
-                }
-
-                throw new Error("Only CommonJS plugin found, but not in a NodeJS environment: ".concat(JSON.stringify(definition)));
-
-              case 22:
-                throw new Error("Could not determine plugin type: ".concat(JSON.stringify(definition)));
-
-              case 23:
-                return _context4.abrupt("return", plugin.default);
-
-              case 24:
-              case "end":
-                return _context4.stop();
-            }
-          }
-        }, _callee4, this);
-      }));
-
-      function loadPlugin(_x4) {
-        return _loadPlugin.apply(this, arguments);
-      }
-
-      return loadPlugin;
-    }()
-  }, {
-    key: "installGlobalReExports",
-    value: function installGlobalReExports(target) {
-      // @ts-ignore
-      target.JBrowseExports = Object.fromEntries(Object.entries(_ReExports.default).map(function (_ref2) {
-        var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
-            moduleName = _ref3[0],
-            module = _ref3[1];
-
-        return [moduleName, module];
-      }));
+                resolve();
+            });
+        }
+        throw new Error('cannot figure out how to load external JS scripts in this environment');
+    }
+    async loadCJSPlugin({ cjsUrl }) {
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(cjsUrl, getGlobalObject().location.href);
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error(`Error parsing URL: ${cjsUrl}`);
+        }
+        if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+            throw new Error(`Cannot load plugins using protocol "${parsedUrl.protocol}"`);
+        }
+        if (!this.fetchCJS) {
+            throw new Error('No fetchCJS callback provided');
+        }
+        return this.fetchCJS(parsedUrl.href);
+    }
+    async loadESMPlugin(pluginDefinition) {
+        var _a;
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(pluginDefinition.esmUrl, getGlobalObject().location.href);
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error(`Error parsing URL: ${pluginDefinition.esmUrl}`);
+        }
+        if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+            throw new Error(`cannot load plugins using protocol "${parsedUrl.protocol}"`);
+        }
+        const plugin = (await ((_a = this.fetchESM) === null || _a === void 0 ? void 0 : _a.call(this, parsedUrl.href)));
+        if (!plugin) {
+            throw new Error(`Could not load ESM plugin: ${parsedUrl}`);
+        }
+        return plugin;
     }
-  }, {
-    key: "load",
-    value: function () {
-      var _load = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
-        var _this = this;
-
-        return _regenerator.default.wrap(function _callee6$(_context6) {
-          while (1) {
-            switch (_context6.prev = _context6.next) {
-              case 0:
-                return _context6.abrupt("return", Promise.all(this.definitions.map( /*#__PURE__*/function () {
-                  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(definition) {
-                    return _regenerator.default.wrap(function _callee5$(_context5) {
-                      while (1) {
-                        switch (_context5.prev = _context5.next) {
-                          case 0:
-                            _context5.next = 2;
-                            return _this.loadPlugin(definition);
-
-                          case 2:
-                            _context5.t0 = _context5.sent;
-                            _context5.t1 = definition;
-                            return _context5.abrupt("return", {
-                              plugin: _context5.t0,
-                              definition: _context5.t1
-                            });
-
-                          case 5:
-                          case "end":
-                            return _context5.stop();
-                        }
-                      }
-                    }, _callee5);
-                  }));
-
-                  return function (_x5) {
-                    return _ref4.apply(this, arguments);
-                  };
-                }())));
-
-              case 1:
-              case "end":
-                return _context6.stop();
-            }
-          }
-        }, _callee6, this);
-      }));
-
-      function load() {
-        return _load.apply(this, arguments);
-      }
-
-      return load;
-    }()
-  }]);
-  return PluginLoader;
-}();
-
-exports.default = PluginLoader;
+    async loadUMDPlugin(pluginDefinition) {
+        const umdUrl = 'url' in pluginDefinition ? pluginDefinition.url : pluginDefinition.umdUrl;
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(umdUrl, getGlobalObject().location.href);
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error(`Error parsing URL: ${umdUrl}`);
+        }
+        if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+            throw new Error(`cannot load plugins using protocol "${parsedUrl.protocol}"`);
+        }
+        await this.loadScript(parsedUrl.href);
+        const moduleName = pluginDefinition.name;
+        const umdName = `JBrowsePlugin${moduleName}`;
+        const globalObject = getGlobalObject();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const plugin = globalObject[umdName];
+        if (!plugin) {
+            throw new Error(`Failed to load UMD bundle for ${moduleName}, ${globalObject.constructor.name}.${umdName} is undefined`);
+        }
+        return plugin;
+    }
+    async loadPlugin(definition) {
+        let plugin;
+        if (util_1.isElectron && isCJSPluginDefinition(definition)) {
+            plugin = await this.loadCJSPlugin(definition);
+        }
+        else if (isESMPluginDefinition(definition)) {
+            plugin = await this.loadESMPlugin(definition);
+        }
+        else if (isUMDPluginDefinition(definition)) {
+            plugin = await this.loadUMDPlugin(definition);
+        }
+        else if (!util_1.isElectron && isCJSPluginDefinition(definition)) {
+            throw new Error(`Only CommonJS plugin found, but not in a NodeJS environment: ${JSON.stringify(definition)}`);
+        }
+        else {
+            throw new Error(`Could not determine plugin type: ${JSON.stringify(definition)}`);
+        }
+        return plugin.default;
+    }
+    installGlobalReExports(target) {
+        // @ts-ignore
+        target.JBrowseExports = Object.fromEntries(Object.entries(ReExports_1.default).map(([moduleName, module]) => {
+            return [moduleName, module];
+        }));
+    }
+    async load() {
+        return Promise.all(this.definitions.map(async (definition) => ({
+            plugin: await this.loadPlugin(definition),
+            definition,
+        })));
+    }
+}
+exports.default = PluginLoader;

package/PluginManager.d.ts

@@ -11,6 +11,7 @@ import ConnectionType from './pluggableElementTypes/ConnectionType';
 import RpcMethodType from './pluggableElementTypes/RpcMethodType';
 import InternetAccountType from './pluggableElementTypes/InternetAccountType';
 import TextSearchAdapterType from './pluggableElementTypes/TextSearchAdapterType';
+import AddTrackWorkflowType from './pluggableElementTypes/AddTrackWorkflowType';
 import Plugin from './Plugin';
 import ReExports from './ReExports';
 import { PluggableElementType, PluggableElementMember } from './pluggableElementTypes';
@@ -25,7 +26,7 @@ declare class PhasedScheduler<PhaseName extends string> {
     add(phase: PhaseName, callback: Function): void;
     run(): void;
 }
-declare type PluggableElementTypeGroup = 'renderer' | 'adapter' | 'display' | 'track' | 'connection' | 'view' | 'widget' | 'rpc method' | 'internet account' | 'text search adapter';
+declare 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;
@@ -78,6 +79,7 @@ export default class PluginManager {
     viewTypes: TypeRecord<ViewType>;
     widgetTypes: TypeRecord<WidgetType>;
     rpcMethods: TypeRecord<RpcMethodType>;
+    addTrackWidgets: TypeRecord<AddTrackWorkflowType>;
     internetAccountTypes: TypeRecord<InternetAccountType>;
     configured: boolean;
     rootModel?: AbstractRootModel;
@@ -97,7 +99,7 @@ export default class PluginManager {
     getElementType(groupName: PluggableElementTypeGroup, typeName: string): PluggableElementBase;
     getElementTypesInGroup(groupName: PluggableElementTypeGroup): PluggableElementBase[];
     /** get a MST type for the union of all specified pluggable MST types */
-    pluggableMstType(typeGroup: PluggableElementTypeGroup, fieldName: PluggableElementMember, fallback?: IAnyType): IAnyType;
+    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>;
@@ -210,7 +212,6 @@ export default class PluginManager {
         'react-dom': typeof import("react-dom");
         'mobx-react': typeof import("mobx-react");
         '@mui/x-data-grid': {
-            DataGrid: any;
             useGridApiContext: typeof import("@mui/x-data-grid").useGridApiContext;
             useGridApiRef: <Api extends import("@mui/x-data-grid").GridApiCommon = import("@mui/x-data-grid/models/api/gridApiCommunity").GridApiCommunity>() => import("react").MutableRefObject<Api>;
             useGridRootProps: () => import("@mui/x-data-grid/models/props/DataGridProps").DataGridProcessedProps<any>;
@@ -262,20 +263,22 @@ export default class PluginManager {
     getTrackType(typeName: string): TrackType;
     getDisplayType(typeName: string): DisplayType;
     getViewType(typeName: string): ViewType;
+    getAddTrackWorkflow(typeName: string): AddTrackWorkflowType;
     getWidgetType(typeName: string): WidgetType;
     getConnectionType(typeName: string): ConnectionType;
     getRpcMethodType(methodName: string): RpcMethodType;
-    getInternetAccountType(internetAccountName: string): InternetAccountType;
-    addRendererType(creationCallback: (pluginManager: PluginManager) => RendererType): this;
-    addAdapterType(creationCallback: (pluginManager: PluginManager) => AdapterType): this;
-    addTextSearchAdapterType(creationCallback: (pluginManager: PluginManager) => TextSearchAdapterType): this;
-    addTrackType(creationCallback: (pluginManager: PluginManager) => TrackType): this;
-    addDisplayType(creationCallback: (pluginManager: PluginManager) => DisplayType): this;
-    addViewType(creationCallback: (pluginManager: PluginManager) => ViewType): this;
-    addWidgetType(creationCallback: (pluginManager: PluginManager) => WidgetType): this;
-    addConnectionType(creationCallback: (pluginManager: PluginManager) => ConnectionType): this;
-    addRpcMethod(creationCallback: (pluginManager: PluginManager) => RpcMethodType): this;
-    addInternetAccountType(creationCallback: (pluginManager: PluginManager) => InternetAccountType): this;
+    getInternetAccountType(name: string): InternetAccountType;
+    addRendererType(cb: (pm: PluginManager) => RendererType): this;
+    addAdapterType(cb: (pm: PluginManager) => AdapterType): this;
+    addTextSearchAdapterType(cb: (pm: PluginManager) => TextSearchAdapterType): this;
+    addTrackType(cb: (pm: PluginManager) => TrackType): this;
+    addDisplayType(cb: (pluginManager: PluginManager) => DisplayType): this;
+    addViewType(cb: (pluginManager: PluginManager) => ViewType): this;
+    addWidgetType(cb: (pm: PluginManager) => WidgetType): this;
+    addConnectionType(cb: (pm: PluginManager) => ConnectionType): this;
+    addRpcMethod(cb: (pm: PluginManager) => RpcMethodType): this;
+    addInternetAccountType(cb: (pm: PluginManager) => InternetAccountType): this;
+    addAddTrackWorkflowType(cb: (pm: PluginManager) => AddTrackWorkflowType): this;
     addToExtensionPoint<T>(extensionPointName: string, callback: (extendee: T) => T): void;
     evaluateExtensionPoint(extensionPointName: string, extendee: unknown): unknown;
     evaluateAsyncExtensionPoint(extensionPointName: string, extendee: unknown): Promise<unknown>;