@jbrowse/plugin-linear-genome-view 1.6.9 → 1.7.0

package/dist/BaseLinearDisplay/models/baseLinearDisplayConfigSchema.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.baseLinearDisplayConfigSchema = void 0;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var baseLinearDisplayConfigSchema = (0, _configuration.ConfigurationSchema)('BaseLinearDisplay', {
+  maxFeatureScreenDensity: {
+    type: 'number',
+    description: 'maximum features per pixel that is displayed in the view, used if byte size estimates not available',
+    defaultValue: 0.3
+  },
+  fetchSizeLimit: {
+    type: 'number',
+    defaultValue: 1000000,
+    description: "maximum data to attempt to download for a given track, used if adapter doesn't specify one"
+  }
+}, {
+  explicitIdentifier: 'displayId'
+});
+exports.baseLinearDisplayConfigSchema = baseLinearDisplayConfigSchema;

package/dist/BaseLinearDisplay/models/serverSideRenderedBlock.js

@@ -0,0 +1,328 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.renderBlockData = renderBlockData;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+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");
+
+var _types = require("@jbrowse/core/util/types");
+
+var _tracks = require("@jbrowse/core/util/tracks");
+
+var _ServerSideRenderedBlockContent = _interopRequireDefault(require("../components/ServerSideRenderedBlockContent"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+// the MST state of a single server-side-rendered block in a display
+var blockState = _mobxStateTree.types.model('BlockState', {
+  key: _mobxStateTree.types.string,
+  region: _mst.Region,
+  reloadFlag: 0,
+  isLeftEndOfDisplayedRegion: false,
+  isRightEndOfDisplayedRegion: false
+}) // NOTE: all this volatile stuff has to be filled in at once, so that it stays consistent
+["volatile"](function () {
+  return {
+    renderInProgress: undefined,
+    filled: false,
+    reactElement: undefined,
+    features: undefined,
+    layout: undefined,
+    status: '',
+    error: undefined,
+    message: undefined,
+    maxHeightReached: false,
+    ReactComponent: _ServerSideRenderedBlockContent["default"],
+    renderProps: undefined
+  };
+}).actions(function (self) {
+  var renderInProgress;
+  return {
+    doReload: function doReload() {
+      self.reloadFlag = self.reloadFlag + 1;
+    },
+    afterAttach: function afterAttach() {
+      var display = (0, _util.getContainingDisplay)(self);
+      (0, _util.makeAbortableReaction)(self, renderBlockData, renderBlockEffect, // reaction doesn't expect async here
+      {
+        name: "".concat(display.id, "/").concat((0, _util.assembleLocString)(self.region), " rendering"),
+        delay: display.renderDelay,
+        fireImmediately: true
+      }, this.setLoading, this.setRendered, this.setError);
+    },
+    setStatus: function setStatus(message) {
+      self.status = message;
+    },
+    setLoading: function setLoading(abortController) {
+      if (renderInProgress !== undefined) {
+        if (!renderInProgress.signal.aborted) {
+          renderInProgress.abort();
+        }
+      }
+
+      self.filled = false;
+      self.message = undefined;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.error = undefined;
+      self.maxHeightReached = false;
+      self.renderProps = undefined;
+      renderInProgress = abortController;
+    },
+    setMessage: function setMessage(messageText) {
+      if (renderInProgress && !renderInProgress.signal.aborted) {
+        renderInProgress.abort();
+      }
+
+      self.filled = false;
+      self.message = messageText;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.error = undefined;
+      self.maxHeightReached = false;
+      self.renderProps = undefined;
+      renderInProgress = undefined;
+    },
+    setRendered: function setRendered(props) {
+      if (!props) {
+        return;
+      }
+
+      var reactElement = props.reactElement,
+          features = props.features,
+          layout = props.layout,
+          maxHeightReached = props.maxHeightReached,
+          renderProps = props.renderProps;
+      self.filled = true;
+      self.message = undefined;
+      self.reactElement = reactElement;
+      self.features = features;
+      self.layout = layout;
+      self.error = undefined;
+      self.maxHeightReached = maxHeightReached;
+      self.renderProps = renderProps;
+      renderInProgress = undefined;
+    },
+    setError: function setError(error) {
+      console.error(error);
+
+      if (renderInProgress && !renderInProgress.signal.aborted) {
+        renderInProgress.abort();
+      } // the rendering failed for some reason
+
+
+      self.filled = false;
+      self.message = undefined;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.maxHeightReached = false;
+      self.error = error;
+      self.renderProps = undefined;
+      renderInProgress = undefined;
+
+      if ((0, _types.isRetryException)(error)) {
+        this.reload();
+      }
+    },
+    reload: function reload() {
+      self.renderInProgress = undefined;
+      self.filled = false;
+      self.reactElement = undefined;
+      self.features = undefined;
+      self.layout = undefined;
+      self.error = undefined;
+      self.message = undefined;
+      self.maxHeightReached = false;
+      self.ReactComponent = _ServerSideRenderedBlockContent["default"];
+      self.renderProps = undefined;
+      (0, _mobxStateTree.getParent)(self, 2).reload();
+    },
+    beforeDestroy: function beforeDestroy() {
+      if (renderInProgress && !renderInProgress.signal.aborted) {
+        renderInProgress.abort();
+      }
+
+      var display = (0, _util.getContainingDisplay)(self);
+
+      var _getSession = (0, _util.getSession)(self),
+          rpcManager = _getSession.rpcManager;
+
+      var rendererType = display.rendererType;
+
+      var _renderBlockData = renderBlockData((0, _mobxStateTree.cast)(self)),
+          renderArgs = _renderBlockData.renderArgs; // renderArgs can be undefined if an error occured in this block
+
+
+      if (renderArgs) {
+        rendererType.freeResourcesInClient(rpcManager, JSON.parse(JSON.stringify(renderArgs)))["catch"](function (e) {
+          // just console.error if it's something while it's being destroyed
+          console.warn('Error while destroying block', e);
+        });
+      }
+    }
+  };
+});
+
+var _default = blockState;
+exports["default"] = _default;
+
+// calls the render worker to render the block content not using a flow for
+// this, because the flow doesn't work with autorun
+function renderBlockData(self, optDisplay) {
+  try {
+    var display = optDisplay || (0, _util.getContainingDisplay)(self);
+
+    var _getSession2 = (0, _util.getSession)(display),
+        assemblyManager = _getSession2.assemblyManager,
+        rpcManager = _getSession2.rpcManager;
+
+    var adapterConfig = display.adapterConfig,
+        rendererType = display.rendererType,
+        error = display.error,
+        parentTrack = display.parentTrack;
+    var assemblyNames = (0, _tracks.getTrackAssemblyNames)(parentTrack);
+    var regionAsm = self.region.assemblyName;
+
+    if (!assemblyNames.includes(regionAsm) && !assemblyNames.find(function (name) {
+      var _assemblyManager$get;
+
+      return (_assemblyManager$get = assemblyManager.get(name)) === null || _assemblyManager$get === void 0 ? void 0 : _assemblyManager$get.hasName(regionAsm);
+    })) {
+      throw new Error("region assembly (".concat(regionAsm, ") does not match track assemblies (").concat(assemblyNames, ")"));
+    }
+
+    var renderProps = display.renderProps();
+    var config = renderProps.config; // This line is to trigger the mobx reaction when the config changes
+    // It won't trigger the reaction if it doesn't think we're accessing it
+
+    (0, _configuration.readConfObject)(config);
+    var sessionId = (0, _tracks.getRpcSessionId)(display);
+    var cannotBeRenderedReason = display.regionCannotBeRendered(self.region);
+    return {
+      rendererType: rendererType,
+      rpcManager: rpcManager,
+      renderProps: renderProps,
+      cannotBeRenderedReason: cannotBeRenderedReason,
+      displayError: error,
+      renderArgs: {
+        statusCallback: function statusCallback(message) {
+          if ((0, _mobxStateTree.isAlive)(self)) {
+            self.setStatus(message);
+          }
+        },
+        assemblyName: self.region.assemblyName,
+        regions: [self.region],
+        adapterConfig: adapterConfig,
+        rendererType: rendererType.name,
+        sessionId: sessionId,
+        blockKey: self.key,
+        reloadFlag: self.reloadFlag,
+        timeout: 1000000 // 10000,
+
+      }
+    };
+  } catch (e) {
+    return {
+      displayError: e
+    };
+  }
+}
+
+function renderBlockEffect(_x, _x2, _x3) {
+  return _renderBlockEffect.apply(this, arguments);
+}
+
+function _renderBlockEffect() {
+  _renderBlockEffect = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(props, signal, self) {
+    var _ref, rendererType, renderProps, rpcManager, renderArgs, cannotBeRenderedReason, displayError, _yield$rendererType$r, reactElement, features, layout, maxHeightReached;
+
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _ref = props, rendererType = _ref.rendererType, renderProps = _ref.renderProps, rpcManager = _ref.rpcManager, renderArgs = _ref.renderArgs, cannotBeRenderedReason = _ref.cannotBeRenderedReason, displayError = _ref.displayError;
+
+            if ((0, _mobxStateTree.isAlive)(self)) {
+              _context.next = 3;
+              break;
+            }
+
+            return _context.abrupt("return", undefined);
+
+          case 3:
+            if (!displayError) {
+              _context.next = 6;
+              break;
+            }
+
+            self.setError(displayError);
+            return _context.abrupt("return", undefined);
+
+          case 6:
+            if (!cannotBeRenderedReason) {
+              _context.next = 9;
+              break;
+            }
+
+            self.setMessage(cannotBeRenderedReason);
+            return _context.abrupt("return", undefined);
+
+          case 9:
+            if (!renderProps.notReady) {
+              _context.next = 11;
+              break;
+            }
+
+            return _context.abrupt("return", undefined);
+
+          case 11:
+            _context.next = 13;
+            return rendererType.renderInClient(rpcManager, _objectSpread(_objectSpread(_objectSpread({}, renderArgs), renderProps), {}, {
+              viewParams: (0, _util.getViewParams)(self),
+              signal: signal
+            }));
+
+          case 13:
+            _yield$rendererType$r = _context.sent;
+            reactElement = _yield$rendererType$r.reactElement;
+            features = _yield$rendererType$r.features;
+            layout = _yield$rendererType$r.layout;
+            maxHeightReached = _yield$rendererType$r.maxHeightReached;
+            return _context.abrupt("return", {
+              reactElement: reactElement,
+              features: features,
+              layout: layout,
+              maxHeightReached: maxHeightReached
+            });
+
+          case 19:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _renderBlockEffect.apply(this, arguments);
+}

package/dist/LinearBareDisplay/configSchema.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configSchemaFactory = configSchemaFactory;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _BaseLinearDisplay = require("../BaseLinearDisplay");
+
+function configSchemaFactory(pluginManager) {
+  return (0, _configuration.ConfigurationSchema)('LinearBareDisplay', {
+    renderer: pluginManager.pluggableConfigSchemaType('renderer')
+  }, {
+    baseConfiguration: _BaseLinearDisplay.baseLinearDisplayConfigSchema,
+    explicitlyTyped: true
+  });
+}

package/dist/LinearBareDisplay/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "configSchemaFactory", {
+  enumerable: true,
+  get: function get() {
+    return _configSchema.configSchemaFactory;
+  }
+});
+Object.defineProperty(exports, "stateModelFactory", {
+  enumerable: true,
+  get: function get() {
+    return _model.stateModelFactory;
+  }
+});
+
+var _configSchema = require("./configSchema");
+
+var _model = require("./model");

package/dist/LinearBareDisplay/index.test.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _ = require(".");
+
+test('config schema renderer type', function () {
+  var stubPluginManager = {
+    pluggableConfigSchemaType: function pluggableConfigSchemaType(type) {
+      var one = (0, _configuration.ConfigurationSchema)("".concat(type, "_TypeOne"), {}, {
+        explicitlyTyped: true
+      });
+      var two = (0, _configuration.ConfigurationSchema)("".concat(type, "_TypeTwo"), {}, {
+        explicitlyTyped: true
+      });
+      var three = (0, _configuration.ConfigurationSchema)("".concat(type, "_TypeThree"), {}, {
+        explicitlyTyped: true
+      });
+      return _mobxStateTree.types.union(one, two, three);
+    }
+  };
+  var configSchema = (0, _.configSchemaFactory)(stubPluginManager);
+  var instance = configSchema.create({
+    type: 'LinearBareDisplay',
+    displayId: 'displayId0',
+    renderer: {
+      type: 'renderer_TypeTwo'
+    }
+  });
+  expect(instance.renderer.type).toBe('renderer_TypeTwo');
+});

package/dist/LinearBareDisplay/model.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stateModelFactory = stateModelFactory;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _configurationSchema = require("@jbrowse/core/configuration/configurationSchema");
+
+var _tracks = require("@jbrowse/core/util/tracks");
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _BaseLinearDisplay = require("../BaseLinearDisplay");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function stateModelFactory(configSchema) {
+  return _mobxStateTree.types.compose('LinearBareDisplay', _BaseLinearDisplay.BaseLinearDisplay, _mobxStateTree.types.model({
+    type: _mobxStateTree.types.literal('LinearBareDisplay'),
+    configuration: (0, _configurationSchema.ConfigurationReference)(configSchema)
+  })).views(function (self) {
+    var superRenderProps = self.renderProps;
+    return {
+      renderProps: function renderProps() {
+        return _objectSpread(_objectSpread(_objectSpread({}, superRenderProps()), (0, _tracks.getParentRenderProps)(self)), {}, {
+          rpcDriverName: self.rpcDriverName,
+          config: self.configuration.renderer
+        });
+      },
+
+      get rendererTypeName() {
+        return self.configuration.renderer.type;
+      }
+
+    };
+  });
+}

package/dist/LinearBasicDisplay/components/SetMaxHeight.js

@@ -0,0 +1,94 @@
+"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 _core = require("@material-ui/core");
+
+var _Close = _interopRequireDefault(require("@material-ui/icons/Close"));
+
+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 (theme) {
+  return {
+    root: {
+      width: 500
+    },
+    closeButton: {
+      position: 'absolute',
+      right: theme.spacing(1),
+      top: theme.spacing(1),
+      color: theme.palette.grey[500]
+    },
+    field: {
+      margin: theme.spacing(2)
+    }
+  };
+});
+
+function SetMaxHeightDlg(props) {
+  var model = props.model,
+      handleClose = props.handleClose;
+  var classes = useStyles();
+  var _model$maxHeight = model.maxHeight,
+      maxHeight = _model$maxHeight === void 0 ? '' : _model$maxHeight;
+
+  var _useState = (0, _react.useState)("".concat(maxHeight)),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      max = _useState2[0],
+      setMax = _useState2[1];
+
+  return /*#__PURE__*/_react["default"].createElement(_core.Dialog, {
+    open: true,
+    onClose: handleClose,
+    "aria-labelledby": "alert-dialog-title",
+    "aria-describedby": "alert-dialog-description"
+  }, /*#__PURE__*/_react["default"].createElement(_core.DialogTitle, {
+    id: "alert-dialog-title"
+  }, "Filter options", /*#__PURE__*/_react["default"].createElement(_core.IconButton, {
+    "aria-label": "close",
+    className: classes.closeButton,
+    onClick: handleClose
+  }, /*#__PURE__*/_react["default"].createElement(_Close["default"], null))), /*#__PURE__*/_react["default"].createElement(_core.DialogContent, {
+    className: classes.root
+  }, /*#__PURE__*/_react["default"].createElement(_core.Typography, null, "Set max height for the track. For example, you can increase this if the layout says \"Max height reached\""), /*#__PURE__*/_react["default"].createElement(_core.TextField, {
+    value: max,
+    onChange: function onChange(event) {
+      return setMax(event.target.value);
+    },
+    placeholder: "Enter max score"
+  }), /*#__PURE__*/_react["default"].createElement(_core.DialogActions, null, /*#__PURE__*/_react["default"].createElement(_core.Button, {
+    variant: "contained",
+    color: "primary",
+    type: "submit",
+    autoFocus: true,
+    onClick: function onClick() {
+      model.setMaxHeight(max !== '' && !Number.isNaN(+max) ? +max : undefined);
+      handleClose();
+    }
+  }, "Submit"), /*#__PURE__*/_react["default"].createElement(_core.Button, {
+    variant: "contained",
+    color: "secondary",
+    onClick: function onClick() {
+      return handleClose();
+    }
+  }, "Cancel"))));
+}
+
+var _default = (0, _mobxReact.observer)(SetMaxHeightDlg);
+
+exports["default"] = _default;

package/dist/LinearBasicDisplay/configSchema.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = configSchemaFactory;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _BaseLinearDisplay = require("../BaseLinearDisplay");
+
+function configSchemaFactory(pluginManager) {
+  return (0, _configuration.ConfigurationSchema)('LinearBasicDisplay', {
+    mouseover: {
+      type: 'string',
+      description: 'what to display in a given mouseover',
+      defaultValue: "jexl:get(feature,'name')",
+      contextVariable: ['feature']
+    },
+    renderer: pluginManager.pluggableConfigSchemaType('renderer')
+  }, {
+    baseConfiguration: _BaseLinearDisplay.baseLinearDisplayConfigSchema,
+    explicitlyTyped: true
+  });
+}

package/dist/LinearBasicDisplay/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "configSchema", {
+  enumerable: true,
+  get: function get() {
+    return _configSchema["default"];
+  }
+});
+Object.defineProperty(exports, "modelFactory", {
+  enumerable: true,
+  get: function get() {
+    return _model["default"];
+  }
+});
+
+var _model = _interopRequireDefault(require("./model"));
+
+var _configSchema = _interopRequireDefault(require("./configSchema"));