@jbrowse/plugin-variants 1.6.7 → 1.7.0

package/dist/VcfTabixAdapter/VcfTabixAdapter.js

@@ -0,0 +1,392 @@
+"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 _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _BaseAdapter = require("@jbrowse/core/data_adapters/BaseAdapter");
+
+var _io = require("@jbrowse/core/util/io");
+
+var _util = require("@jbrowse/core/util");
+
+var _rxjs = require("@jbrowse/core/util/rxjs");
+
+var _tabix = require("@gmod/tabix");
+
+var _vcf = _interopRequireDefault(require("@gmod/vcf"));
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _VcfFeature = _interopRequireDefault(require("./VcfFeature"));
+
+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 _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
+  (0, _inherits2["default"])(_default, _BaseFeatureDataAdapt);
+
+  var _super = _createSuper(_default);
+
+  function _default() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, _default);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "configured", void 0);
+    return _this;
+  }
+
+  (0, _createClass2["default"])(_default, [{
+    key: "configurePre",
+    value: function () {
+      var _configurePre = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var vcfGzLocation, location, indexType, filehandle, isCSI, vcf, header;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                vcfGzLocation = (0, _configuration.readConfObject)(this.config, 'vcfGzLocation');
+                location = (0, _configuration.readConfObject)(this.config, ['index', 'location']);
+                indexType = (0, _configuration.readConfObject)(this.config, ['index', 'indexType']);
+                filehandle = (0, _io.openLocation)(vcfGzLocation, this.pluginManager);
+                isCSI = indexType === 'CSI';
+                vcf = new _tabix.TabixIndexedFile({
+                  filehandle: filehandle,
+                  csiFilehandle: isCSI ? (0, _io.openLocation)(location, this.pluginManager) : undefined,
+                  tbiFilehandle: !isCSI ? (0, _io.openLocation)(location, this.pluginManager) : undefined,
+                  chunkCacheSize: 50 * Math.pow(2, 20),
+                  chunkSizeLimit: 1000000000
+                });
+                _context.next = 8;
+                return vcf.getHeader();
+
+              case 8:
+                header = _context.sent;
+                return _context.abrupt("return", {
+                  filehandle: filehandle,
+                  vcf: vcf,
+                  parser: new _vcf["default"]({
+                    header: header
+                  })
+                });
+
+              case 10:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function configurePre() {
+        return _configurePre.apply(this, arguments);
+      }
+
+      return configurePre;
+    }()
+  }, {
+    key: "configure",
+    value: function () {
+      var _configure = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _this2 = this;
+
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!this.configured) {
+                  this.configured = this.configurePre()["catch"](function (e) {
+                    _this2.configured = undefined;
+                    throw e;
+                  });
+                }
+
+                return _context2.abrupt("return", this.configured);
+
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function configure() {
+        return _configure.apply(this, arguments);
+      }
+
+      return configure;
+    }()
+  }, {
+    key: "getRefNames",
+    value: function () {
+      var _getRefNames = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var opts,
+            _yield$this$configure,
+            vcf,
+            _args3 = arguments;
+
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                opts = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {};
+                _context3.next = 3;
+                return this.configure();
+
+              case 3:
+                _yield$this$configure = _context3.sent;
+                vcf = _yield$this$configure.vcf;
+                return _context3.abrupt("return", vcf.getReferenceSequenceNames(opts));
+
+              case 6:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function getRefNames() {
+        return _getRefNames.apply(this, arguments);
+      }
+
+      return getRefNames;
+    }()
+  }, {
+    key: "getHeader",
+    value: function () {
+      var _getHeader = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var _yield$this$configure2, vcf;
+
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return this.configure();
+
+              case 2:
+                _yield$this$configure2 = _context4.sent;
+                vcf = _yield$this$configure2.vcf;
+                return _context4.abrupt("return", vcf.getHeader());
+
+              case 5:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function getHeader() {
+        return _getHeader.apply(this, arguments);
+      }
+
+      return getHeader;
+    }()
+  }, {
+    key: "getMetadata",
+    value: function () {
+      var _getMetadata = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+        var _yield$this$configure3, parser;
+
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return this.configure();
+
+              case 2:
+                _yield$this$configure3 = _context5.sent;
+                parser = _yield$this$configure3.parser;
+                return _context5.abrupt("return", parser.getMetadata());
+
+              case 5:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function getMetadata() {
+        return _getMetadata.apply(this, arguments);
+      }
+
+      return getMetadata;
+    }()
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(query) {
+      var _this3 = this;
+
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return (0, _rxjs.ObservableCreate)( /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(observer) {
+          var refName, start, end, _yield$_this3$configu, vcf, parser;
+
+          return _regenerator["default"].wrap(function _callee6$(_context6) {
+            while (1) {
+              switch (_context6.prev = _context6.next) {
+                case 0:
+                  refName = query.refName, start = query.start, end = query.end;
+                  _context6.next = 3;
+                  return _this3.configure();
+
+                case 3:
+                  _yield$_this3$configu = _context6.sent;
+                  vcf = _yield$_this3$configu.vcf;
+                  parser = _yield$_this3$configu.parser;
+                  _context6.next = 8;
+                  return vcf.getLines(refName, start, end, _objectSpread({
+                    lineCallback: function lineCallback(line, fileOffset) {
+                      observer.next(new _VcfFeature["default"]({
+                        variant: parser.parseLine(line),
+                        parser: parser,
+                        id: "".concat(_this3.id, "-vcf-").concat(fileOffset)
+                      }));
+                    }
+                  }, opts));
+
+                case 8:
+                  observer.complete();
+
+                case 9:
+                case "end":
+                  return _context6.stop();
+              }
+            }
+          }, _callee6);
+        }));
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }(), opts.signal);
+    }
+    /**
+     * Checks if the data source has data for the given reference sequence,
+     * and then gets the features in the region if it does
+     *
+     * Currently this just calls getFeatureInRegion for each region. Adapters that
+     * are frequently called on multiple regions simultaneously may want to
+     * implement a more efficient custom version of this method.
+     *
+     * Also includes a bit of extra logging to warn when fetching a large portion
+     * of a VCF
+     * @param regions - Regions
+     * @param opts - Feature adapter options
+     * @returns Observable of Feature objects in the regions
+     */
+
+  }, {
+    key: "getFeaturesInMultipleRegions",
+    value: function getFeaturesInMultipleRegions(regions) {
+      var _this4 = this;
+
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // TODO: restore commented version below once TSDX supports Rollup v2
+      // xref: https://github.com/rollup/rollup/blob/master/CHANGELOG.md#bug-fixes-45
+      var superGetFeaturesInMultipleRegions = (0, _get2["default"])((0, _getPrototypeOf2["default"])(_default.prototype), "getFeaturesInMultipleRegions", this);
+      return (0, _rxjs.ObservableCreate)( /*#__PURE__*/function () {
+        var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(observer) {
+          var _yield$_this4$configu, vcf, bytes, _yield$_this4$configu2, filehandle, stat, pct;
+
+          return _regenerator["default"].wrap(function _callee7$(_context7) {
+            while (1) {
+              switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.next = 2;
+                  return _this4.configure();
+
+                case 2:
+                  _yield$_this4$configu = _context7.sent;
+                  vcf = _yield$_this4$configu.vcf;
+                  _context7.next = 6;
+                  return (0, _util.bytesForRegions)(regions, vcf.index);
+
+                case 6:
+                  bytes = _context7.sent;
+                  _context7.next = 9;
+                  return _this4.configure();
+
+                case 9:
+                  _yield$_this4$configu2 = _context7.sent;
+                  filehandle = _yield$_this4$configu2.filehandle;
+                  _context7.next = 13;
+                  return filehandle.stat();
+
+                case 13:
+                  stat = _context7.sent;
+                  pct = Math.round(bytes / stat.size * 100);
+
+                  if (pct > 100) {
+                    // this is just a bad estimate, make 100% if it goes over
+                    pct = 100;
+                  }
+
+                  if (pct > 60) {
+                    console.warn("getFeaturesInMultipleRegions fetching ".concat(pct, "% of VCF file, but whole-file streaming not yet implemented"));
+                  }
+
+                  superGetFeaturesInMultipleRegions.call(_this4, regions, opts).subscribe(observer); // super.getFeaturesInMultipleRegions(regions, opts).subscribe(observer)
+
+                case 18:
+                case "end":
+                  return _context7.stop();
+              }
+            }
+          }, _callee7);
+        }));
+
+        return function (_x2) {
+          return _ref2.apply(this, arguments);
+        };
+      }());
+    }
+  }, {
+    key: "freeResources",
+    value: function
+      /* { region } */
+    freeResources() {}
+  }]);
+  return _default;
+}(_BaseAdapter.BaseFeatureDataAdapter);
+
+exports["default"] = _default;

package/dist/VcfTabixAdapter/VcfTabixAdapter.test.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _operators = require("rxjs/operators");
+
+var _VcfTabixAdapter = _interopRequireDefault(require("./VcfTabixAdapter"));
+
+var _configSchema = _interopRequireDefault(require("./configSchema"));
+
+test('adapter can fetch variants from volvox.vcf.gz', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+  var adapter, csiAdapter, csiFeatures, names, csiNames, features, featuresArray, csiFeaturesArray, featuresNonExist, featuresArrayNonExist;
+  return _regenerator["default"].wrap(function _callee$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          adapter = new _VcfTabixAdapter["default"](_configSchema["default"].create({
+            vcfGzLocation: {
+              localPath: require.resolve('./test_data/volvox.filtered.vcf.gz'),
+              locationType: 'LocalPathLocation'
+            },
+            index: {
+              indexType: 'TBI',
+              location: {
+                localPath: require.resolve('./test_data/volvox.filtered.vcf.gz.tbi'),
+                locationType: 'LocalPathLocation'
+              }
+            }
+          }));
+          csiAdapter = new _VcfTabixAdapter["default"](_configSchema["default"].create({
+            vcfGzLocation: {
+              localPath: require.resolve('./test_data/volvox.filtered.vcf.gz'),
+              locationType: 'LocalPathLocation'
+            },
+            index: {
+              indexType: 'CSI',
+              location: {
+                localPath: require.resolve('./test_data/volvox.filtered.vcf.gz.csi'),
+                locationType: 'LocalPathLocation'
+              }
+            }
+          }));
+          csiFeatures = csiAdapter.getFeatures({
+            refName: 'ctgA',
+            start: 0,
+            end: 20000
+          });
+          _context.next = 5;
+          return adapter.getRefNames();
+
+        case 5:
+          names = _context.sent;
+          _context.next = 8;
+          return csiAdapter.getRefNames();
+
+        case 8:
+          csiNames = _context.sent;
+          expect(names).toEqual(csiNames);
+          expect(names).toMatchSnapshot();
+          features = adapter.getFeatures({
+            refName: 'ctgA',
+            start: 0,
+            end: 20000
+          });
+          _context.next = 14;
+          return features.pipe((0, _operators.toArray)()).toPromise();
+
+        case 14:
+          featuresArray = _context.sent;
+          _context.next = 17;
+          return csiFeatures.pipe((0, _operators.toArray)()).toPromise();
+
+        case 17:
+          csiFeaturesArray = _context.sent;
+          expect(featuresArray.slice(0, 5)).toMatchSnapshot();
+          expect(csiFeaturesArray.slice(0, 5)).toEqual(featuresArray.slice(0, 5));
+          featuresNonExist = adapter.getFeatures({
+            refName: 'ctgC',
+            start: 0,
+            end: 20000
+          });
+          _context.next = 23;
+          return featuresNonExist.pipe((0, _operators.toArray)()).toPromise();
+
+        case 23:
+          featuresArrayNonExist = _context.sent;
+          expect(featuresArrayNonExist).toEqual([]);
+
+        case 25:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _callee);
+})));

package/dist/VcfTabixAdapter/configSchema.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _default = (0, _configuration.ConfigurationSchema)('VcfTabixAdapter', {
+  vcfGzLocation: {
+    type: 'fileLocation',
+    defaultValue: {
+      uri: '/path/to/my.vcf.gz',
+      locationType: 'UriLocation'
+    }
+  },
+  index: (0, _configuration.ConfigurationSchema)('VcfIndex', {
+    indexType: {
+      model: _mobxStateTree.types.enumeration('IndexType', ['TBI', 'CSI']),
+      type: 'stringEnum',
+      defaultValue: 'TBI'
+    },
+    location: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/my.vcf.gz.tbi',
+        locationType: 'UriLocation'
+      }
+    }
+  })
+}, {
+  explicitlyTyped: true
+});
+
+exports["default"] = _default;

package/dist/VcfTabixAdapter/index.js

@@ -0,0 +1,15 @@
+"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"];
+  }
+});
+
+var _configSchema = _interopRequireDefault(require("./configSchema"));