@jbrowse/plugin-data-management 1.6.7 → 1.7.0

package/dist/HierarchicalTrackSelectorWidget/model.js

@@ -0,0 +1,306 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.generateHierarchy = generateHierarchy;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _util = require("@jbrowse/core/util");
+
+var _mst = require("@jbrowse/core/util/types/mst");
+
+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 hasAnyOverlap = function hasAnyOverlap() {
+  var a1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var a2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return !!a1.find(function (value) {
+    return a2.includes(value);
+  });
+};
+
+function passesFilter(filter, config) {
+  var name = getTrackName(config);
+  var categories = (0, _configuration.readConfObject)(config, 'category') || [];
+  var filterLower = filter.toLowerCase();
+  return !!name.toLowerCase().includes(filterLower) || categories.filter(function (cat) {
+    return !!cat.toLowerCase().includes(filterLower);
+  }).length;
+}
+
+function getTrackName(config) {
+  if (!config.trackId) {
+    throw new Error('not a track');
+  }
+
+  return (0, _configuration.readConfObject)(config, 'name') || "Reference sequence (".concat((0, _configuration.readConfObject)((0, _mobxStateTree.getParent)(config), 'name'), ")");
+}
+
+function generateHierarchy(model, trackConfigurations, collapsed) {
+  var hierarchy = {
+    children: []
+  };
+  var filterText = model.filterText,
+      view = model.view;
+  trackConfigurations.filter(function (trackConf) {
+    return passesFilter(filterText, trackConf);
+  }).forEach(function (trackConf) {
+    // copy the categories since this array can be mutated downstream
+    var categories = (0, _toConsumableArray2["default"])((0, _configuration.readConfObject)(trackConf, 'category') || []); // silly thing where if trackId ends with sessionTrack, then push it to
+    // a category that starts with a space to force sort to the top...
+    // double whammy hackyness
+
+    if (trackConf.trackId.endsWith('sessionTrack')) {
+      categories.unshift(' Session tracks');
+    }
+
+    var currLevel = hierarchy; // find existing category to put track into or create it
+
+    var _loop = function _loop(i) {
+      var category = categories[i];
+      var ret = currLevel.children.find(function (c) {
+        return c.name === category;
+      });
+      var id = categories.slice(0, i + 1).join(',');
+
+      if (!ret) {
+        var n = {
+          children: [],
+          name: category,
+          id: id,
+          isOpenByDefault: !collapsed.get(id)
+        };
+        currLevel.children.push(n);
+        currLevel = n;
+      } else {
+        currLevel = ret;
+      }
+    };
+
+    for (var i = 0; i < categories.length; i++) {
+      _loop(i);
+    } // using splice here tries to group leaf nodes above hierarchical nodes
+
+
+    currLevel.children.splice(currLevel.children.findIndex(function (elt) {
+      return elt.children.length;
+    }), 0, {
+      id: trackConf.trackId,
+      name: getTrackName(trackConf),
+      conf: trackConf,
+      checked: !!view.tracks.find(function (f) {
+        return f.configuration === trackConf;
+      }),
+      children: []
+    });
+  });
+  return hierarchy.children;
+}
+
+var _default = function _default(pluginManager) {
+  return _mobxStateTree.types.model('HierarchicalTrackSelectorWidget', {
+    id: _mst.ElementId,
+    type: _mobxStateTree.types.literal('HierarchicalTrackSelectorWidget'),
+    collapsed: _mobxStateTree.types.map(_mobxStateTree.types["boolean"]),
+    filterText: '',
+    view: _mobxStateTree.types.safeReference(pluginManager.pluggableMstType('view', 'stateModel'))
+  }).actions(function (self) {
+    return {
+      setView: function setView(view) {
+        self.view = view;
+      },
+      toggleCategory: function toggleCategory(pathName) {
+        self.collapsed.set(pathName, !self.collapsed.get(pathName));
+      },
+      clearFilterText: function clearFilterText() {
+        self.filterText = '';
+      },
+      setFilterText: function setFilterText(newText) {
+        self.filterText = newText;
+      }
+    };
+  }).views(function (self) {
+    return {
+      getRefSeqTrackConf: function getRefSeqTrackConf(assemblyName) {
+        var _getSession = (0, _util.getSession)(self),
+            assemblyManager = _getSession.assemblyManager;
+
+        var assembly = assemblyManager.get(assemblyName);
+        var trackConf = assembly === null || assembly === void 0 ? void 0 : assembly.configuration.sequence;
+        var viewType = pluginManager.getViewType(self.view.type);
+
+        if (trackConf) {
+          var _iterator = _createForOfIteratorHelper(trackConf.displays),
+              _step;
+
+          try {
+            var _loop2 = function _loop2() {
+              var display = _step.value;
+
+              if (viewType.displayTypes.find(function (displayType) {
+                return displayType.name === display.type;
+              })) {
+                return {
+                  v: trackConf
+                };
+              }
+            };
+
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var _ret = _loop2();
+
+              if ((0, _typeof2["default"])(_ret) === "object") return _ret.v;
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+
+        return undefined;
+      },
+      trackConfigurations: function trackConfigurations(assemblyName) {
+        if (!self.view) {
+          return [];
+        }
+
+        var session = (0, _util.getSession)(self);
+        var trackConfigurations = session.tracks,
+            assemblyManager = session.assemblyManager;
+        var assembly = assemblyManager.get(assemblyName);
+
+        if (!assembly) {
+          return [];
+        }
+
+        var refseq = self.getRefSeqTrackConf(assemblyName); // filter out tracks that don't match the current assembly (check all
+        // assembly aliases) and display types
+
+        return (refseq ? [refseq] : []).concat((0, _toConsumableArray2["default"])(trackConfigurations.filter(function (conf) {
+          var trackConfAssemblies = (0, _configuration.readConfObject)(conf, 'assemblyNames');
+          var allAliases = assembly.allAliases;
+          return hasAnyOverlap(allAliases, trackConfAssemblies);
+        }).filter(function (conf) {
+          var _pluginManager$getVie = pluginManager.getViewType(self.view.type),
+              displayTypes = _pluginManager$getVie.displayTypes;
+
+          var compatibleDisplays = displayTypes.map(function (display) {
+            return display.name;
+          });
+          var trackDisplays = conf.displays.map(function (display) {
+            return display.type;
+          });
+          return hasAnyOverlap(compatibleDisplays, trackDisplays);
+        })));
+      },
+
+      get assemblyNames() {
+        return self.view ? self.view.assemblyNames : [];
+      },
+
+      connectionTrackConfigurations: function connectionTrackConfigurations(assemblyName, connection) {
+        if (!self.view) {
+          return [];
+        }
+
+        var trackConfigurations = connection.tracks;
+        var session = (0, _util.getSession)(self);
+        var assemblyManager = session.assemblyManager;
+        var assembly = assemblyManager.get(assemblyName);
+
+        if (!(assembly && assembly.initialized)) {
+          return [];
+        } // filter out tracks that don't match the current display types
+
+
+        return trackConfigurations.filter(function (conf) {
+          var trackConfAssemblies = (0, _configuration.readConfObject)(conf, 'assemblyNames');
+          var allAliases = assembly.allAliases;
+          return hasAnyOverlap(allAliases, trackConfAssemblies);
+        }).filter(function (conf) {
+          var _pluginManager$getVie2 = pluginManager.getViewType(self.view.type),
+              displayTypes = _pluginManager$getVie2.displayTypes;
+
+          var compatibleDisplays = displayTypes.map(function (display) {
+            return display.name;
+          });
+          var trackDisplays = conf.displays.map(function (display) {
+            return display.type;
+          });
+          return hasAnyOverlap(compatibleDisplays, trackDisplays);
+        });
+      },
+      hierarchy: function hierarchy(assemblyName) {
+        var _this = this;
+
+        var hier = generateHierarchy(self, self.trackConfigurations(assemblyName), self.collapsed);
+        var session = (0, _util.getSession)(self);
+        var conns = session.connectionInstances.filter(function (conn) {
+          var configAssemblyNames = (0, _configuration.readConfObject)(conn.configuration, 'assemblyNames');
+
+          if (configAssemblyNames.length === 0) {
+            return true;
+          }
+
+          return configAssemblyNames.includes(assemblyName);
+        }).map(function (conn, index) {
+          var c = session.connections[index];
+          return {
+            id: c.connectionId,
+            name: (0, _configuration.readConfObject)(c, 'name'),
+            children: _this.connectionHierarchy(assemblyName, conn),
+            state: {
+              expanded: true
+            }
+          };
+        });
+        return {
+          name: 'Root',
+          id: 'Root',
+          children: [{
+            name: 'Tracks',
+            id: 'Tracks',
+            children: hier
+          }].concat((0, _toConsumableArray2["default"])(conns))
+        };
+      },
+      connectionHierarchy: function connectionHierarchy(assemblyName, connection) {
+        return generateHierarchy(self, self.connectionTrackConfigurations(assemblyName, connection), self.collapsed);
+      },
+      // This recursively gets tracks from lower paths
+      allTracksInCategoryPath: function allTracksInCategoryPath(path, connection, assemblyName) {
+        var currentHier = connection ? self.connectionHierarchy(connection) : self.hierarchy(assemblyName);
+        path.forEach(function (pathItem) {
+          currentHier = currentHier.get(pathItem) || new Map();
+        });
+        var tracks = {};
+        currentHier.forEach(function (contents, name) {
+          if (contents.trackId) {
+            tracks[contents.trackId] = contents;
+          } else {
+            tracks = Object.assign(tracks, self.allTracksInCategoryPath(path.concat([name])));
+          }
+        });
+        return tracks;
+      }
+    };
+  });
+};
+
+exports["default"] = _default;

package/dist/HierarchicalTrackSelectorWidget/model.test.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _model = require("./model");
+
+xtest('can generate hierarchy correctly', function () {
+  var trackConfigurations = [{
+    trackId: 'zonker',
+    category: {
+      expr: {
+        evalSync: function evalSync() {
+          return ['Bar', 'Baz'];
+        }
+      }
+    }
+  }, {
+    trackId: 'zoo'
+  }, {
+    trackId: 'bee',
+    category: {
+      expr: {
+        evalSync: function evalSync() {
+          return ['Bar'];
+        }
+      }
+    }
+  }];
+  expect((0, _model.generateHierarchy)(trackConfigurations)).toEqual(new Map([['Bar', new Map([['bee', trackConfigurations[2]], ['Baz', new Map([['zonker', trackConfigurations[0]]])]])], ['zoo', trackConfigurations[1]]]));
+});

package/dist/PluginStoreWidget/components/CustomPluginForm.js

@@ -0,0 +1,217 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _mobxReact = require("mobx-react");
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _clsx2 = _interopRequireDefault(require("clsx"));
+
+var _core = require("@material-ui/core");
+
+var _IconButton = _interopRequireDefault(require("@material-ui/core/IconButton"));
+
+var _Close = _interopRequireDefault(require("@material-ui/icons/Close"));
+
+var _ExpandMore = _interopRequireDefault(require("@material-ui/icons/ExpandMore"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+// icons
+var useStyles = (0, _core.makeStyles)(function (theme) {
+  return {
+    closeButton: {
+      position: 'absolute',
+      right: theme.spacing(1),
+      top: theme.spacing(1)
+    },
+    dialogContent: {
+      display: 'flex',
+      flexDirection: 'column'
+    },
+    expand: {
+      transform: 'rotate(0deg)',
+      marginLeft: 'auto',
+      transition: theme.transitions.create('transform', {
+        duration: theme.transitions.duration.shortest
+      })
+    },
+    expandOpen: {
+      transform: 'rotate(180deg)'
+    }
+  };
+});
+
+function CustomPluginForm(_ref) {
+  var open = _ref.open,
+      onClose = _ref.onClose,
+      model = _ref.model;
+  var classes = useStyles();
+
+  var _useState = (0, _react.useState)(''),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      umdPluginName = _useState2[0],
+      setUMDPluginName = _useState2[1];
+
+  var _useState3 = (0, _react.useState)(''),
+      _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+      umdPluginUrl = _useState4[0],
+      setUMDPluginUrl = _useState4[1];
+
+  var _useState5 = (0, _react.useState)(''),
+      _useState6 = (0, _slicedToArray2["default"])(_useState5, 2),
+      esmPluginUrl = _useState6[0],
+      setESMPluginUrl = _useState6[1];
+
+  var _useState7 = (0, _react.useState)(''),
+      _useState8 = (0, _slicedToArray2["default"])(_useState7, 2),
+      cjsPluginUrl = _useState8[0],
+      setCJSPluginUrl = _useState8[1];
+
+  var _useState9 = (0, _react.useState)(false),
+      _useState10 = (0, _slicedToArray2["default"])(_useState9, 2),
+      advancedOptionsOpen = _useState10[0],
+      setAdvancedOptionsOpen = _useState10[1];
+
+  function handleChange(event) {
+    var _event$target = event.target,
+        name = _event$target.name,
+        value = _event$target.value;
+
+    if (name === 'umdName') {
+      setUMDPluginName(value);
+    }
+
+    if (name === 'umdUrl') {
+      setUMDPluginUrl(value);
+    }
+
+    if (name === 'esmUrl') {
+      setESMPluginUrl(value);
+    }
+
+    if (name === 'cjsUrl') {
+      setCJSPluginUrl(value);
+    }
+  }
+
+  function handleOpenAdvancedOptions() {
+    setAdvancedOptionsOpen(!advancedOptionsOpen);
+  }
+
+  var rootModel = (0, _mobxStateTree.getRoot)(model);
+  var jbrowse = rootModel.jbrowse;
+  var ready = Boolean(umdPluginName && umdPluginUrl || esmPluginUrl || cjsPluginUrl);
+
+  function handleSubmit() {
+    if (!ready) {
+      return;
+    }
+
+    var pluginDefinition = {};
+
+    if (umdPluginName && umdPluginUrl) {
+      pluginDefinition.name = umdPluginName;
+      pluginDefinition.umdUrl = umdPluginUrl;
+    }
+
+    if (esmPluginUrl) {
+      pluginDefinition.esmUrl = esmPluginUrl;
+    }
+
+    if (cjsPluginUrl) {
+      pluginDefinition.cjsUrl = cjsPluginUrl;
+    }
+
+    jbrowse.addPlugin(pluginDefinition);
+  }
+
+  function handleClose() {
+    setUMDPluginName('');
+    setUMDPluginUrl('');
+    setESMPluginUrl('');
+    setCJSPluginUrl('');
+    onClose();
+  }
+
+  return /*#__PURE__*/_react["default"].createElement(_core.Dialog, {
+    open: open,
+    onClose: handleClose
+  }, /*#__PURE__*/_react["default"].createElement(_core.DialogTitle, null, "Add custom plugin", /*#__PURE__*/_react["default"].createElement(_IconButton["default"], {
+    size: "medium",
+    className: classes.closeButton,
+    onClick: function onClick() {
+      return onClose();
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_Close["default"], null))), /*#__PURE__*/_react["default"].createElement("form", {
+    onSubmit: handleSubmit
+  }, /*#__PURE__*/_react["default"].createElement(_core.DialogContent, {
+    className: classes.dialogContent
+  }, /*#__PURE__*/_react["default"].createElement(_core.DialogContentText, null, "Enter the name of the plugin and its URL. The name should match what is defined in the plugin's build."), /*#__PURE__*/_react["default"].createElement(_core.TextField, {
+    id: "umd-name-input",
+    name: "umdName",
+    label: "Plugin name",
+    variant: "outlined",
+    value: umdPluginName,
+    onChange: handleChange
+  }), /*#__PURE__*/_react["default"].createElement(_core.TextField, {
+    id: "umd-url-input",
+    name: "umdUrl",
+    label: "Plugin URL",
+    variant: "outlined",
+    value: umdPluginUrl,
+    onChange: handleChange
+  }), /*#__PURE__*/_react["default"].createElement(_core.DialogContentText, {
+    onClick: handleOpenAdvancedOptions
+  }, /*#__PURE__*/_react["default"].createElement(_IconButton["default"], {
+    className: (0, _clsx2["default"])(classes.expand, (0, _defineProperty2["default"])({}, classes.expandOpen, advancedOptionsOpen)),
+    "aria-expanded": advancedOptionsOpen,
+    "aria-label": "show more"
+  }, /*#__PURE__*/_react["default"].createElement(_ExpandMore["default"], null)), "Advanced options"), /*#__PURE__*/_react["default"].createElement(_core.Collapse, {
+    "in": advancedOptionsOpen
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    className: classes.dialogContent
+  }, /*#__PURE__*/_react["default"].createElement(_core.DialogContentText, null, "The above fields assume that the plugin is built in UMD format. If your plugin is in another format, or you have additional builds you want to add (such as a CJS build for using NodeJS APIs in desktop), you can enter the URLs for those builds below."), /*#__PURE__*/_react["default"].createElement(_core.TextField, {
+    id: "esm-url-input",
+    name: "esmUrl",
+    label: "ESM build URL",
+    variant: "outlined",
+    value: esmPluginUrl,
+    onChange: handleChange
+  }), /*#__PURE__*/_react["default"].createElement(_core.TextField, {
+    id: "cjs-url-input",
+    name: "cjsUrl",
+    label: "CJS build URL",
+    variant: "outlined",
+    value: cjsPluginUrl,
+    onChange: handleChange
+  })))), /*#__PURE__*/_react["default"].createElement(_core.DialogActions, null, /*#__PURE__*/_react["default"].createElement(_core.Button, {
+    variant: "contained",
+    onClick: handleClose
+  }, "Cancel"), /*#__PURE__*/_react["default"].createElement(_core.Button, {
+    variant: "contained",
+    color: "primary",
+    onClick: handleSubmit,
+    disabled: !ready
+  }, "Submit"))));
+}
+
+var _default = (0, _mobxReact.observer)(CustomPluginForm);
+
+exports["default"] = _default;

package/dist/PluginStoreWidget/components/InstalledPlugin.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _mobxReact = require("mobx-react");
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _core = require("@material-ui/core");
+
+var _Close = _interopRequireDefault(require("@material-ui/icons/Close"));
+
+var _Lock = _interopRequireDefault(require("@material-ui/icons/Lock"));
+
+var _util = require("@jbrowse/core/util");
+
+var _types = require("@jbrowse/core/util/types");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var useStyles = (0, _core.makeStyles)(function () {
+  return {
+    closeDialog: {
+      position: 'absolute',
+      right: 0,
+      top: 0
+    },
+    dialogContainer: {
+      margin: 15
+    },
+    lockedPluginTooltip: {
+      marginRight: '0.5rem'
+    }
+  };
+});
+
+function LockedPlugin() {
+  var classes = useStyles();
+  return /*#__PURE__*/_react["default"].createElement(_core.Tooltip, {
+    className: classes.lockedPluginTooltip,
+    title: "This plugin was installed by an administrator, you cannot remove it."
+  }, /*#__PURE__*/_react["default"].createElement(_Lock["default"], null));
+}
+
+function PluginDialog(_ref) {
+  var _onClose = _ref.onClose,
+      plugin = _ref.plugin;
+  var classes = useStyles();
+  return /*#__PURE__*/_react["default"].createElement(_core.Dialog, {
+    open: true,
+    onClose: function onClose() {
+      return _onClose();
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_core.DialogTitle, null, /*#__PURE__*/_react["default"].createElement(_core.IconButton, {
+    className: classes.closeDialog,
+    "aria-label": "close-dialog",
+    onClick: function onClick() {
+      return _onClose();
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_Close["default"], null))), /*#__PURE__*/_react["default"].createElement(_core.DialogContent, null, /*#__PURE__*/_react["default"].createElement(_core.Typography, null, "Please confirm that you want to remove ", plugin, ". Note: if any resources in this session still use this plugin, it may cause your session to crash"), /*#__PURE__*/_react["default"].createElement(_core.DialogActions, null, /*#__PURE__*/_react["default"].createElement(_core.Button, {
+    variant: "contained",
+    color: "primary",
+    onClick: function onClick() {
+      // avoid showing runtime plugin warning
+      window.setTimeout(function () {
+        _onClose(plugin);
+      }, 500);
+    }
+  }, "Confirm"), /*#__PURE__*/_react["default"].createElement(_core.Button, {
+    variant: "contained",
+    color: "secondary",
+    onClick: function onClick() {
+      _onClose();
+    }
+  }, "Cancel"))));
+}
+
+function InstalledPlugin(_ref2) {
+  var plugin = _ref2.plugin,
+      model = _ref2.model,
+      pluginManager = _ref2.pluginManager;
+
+  var _useState = (0, _react.useState)(),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      dialogPlugin = _useState2[0],
+      setDialogPlugin = _useState2[1];
+
+  var session = (0, _util.getSession)(model);
+  var _ref3 = session,
+      sessionPlugins = _ref3.sessionPlugins;
+  var isSessionPlugin = sessionPlugins === null || sessionPlugins === void 0 ? void 0 : sessionPlugins.some(function (p) {
+    return pluginManager.pluginMetadata[plugin.name].url === p.url;
+  });
+  var rootModel = (0, _mobxStateTree.getParent)(model, 3);
+  var jbrowse = rootModel.jbrowse,
+      adminMode = rootModel.adminMode;
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, dialogPlugin ? /*#__PURE__*/_react["default"].createElement(PluginDialog, {
+    plugin: dialogPlugin,
+    onClose: function onClose(name) {
+      if (name) {
+        var pluginMetadata = pluginManager.pluginMetadata[plugin.name];
+
+        if (adminMode) {
+          jbrowse.removePlugin(pluginMetadata);
+        } else if ((0, _types.isSessionWithSessionPlugins)(session)) {
+          session.removeSessionPlugin(pluginMetadata);
+        }
+      }
+
+      setDialogPlugin(undefined);
+    }
+  }) : null, /*#__PURE__*/_react["default"].createElement(_core.ListItem, {
+    key: plugin.name
+  }, adminMode || isSessionPlugin ? /*#__PURE__*/_react["default"].createElement(_core.IconButton, {
+    "aria-label": "removePlugin",
+    "data-testid": "removePlugin-".concat(plugin.name),
+    onClick: function onClick() {
+      return setDialogPlugin(plugin.name);
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_Close["default"], null)) : /*#__PURE__*/_react["default"].createElement(LockedPlugin, null), /*#__PURE__*/_react["default"].createElement(_core.Typography, null, plugin.name)));
+}
+
+var _default = (0, _mobxReact.observer)(InstalledPlugin);
+
+exports["default"] = _default;