@jbrowse/plugin-alignments 1.6.7 → 1.7.0

package/dist/BamAdapter/BamAdapter.js

@@ -0,0 +1,598 @@
+"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 _bam = require("@gmod/bam");
+
+var _BaseAdapter = require("@jbrowse/core/data_adapters/BaseAdapter");
+
+var _util = require("@jbrowse/core/util");
+
+var _io = require("@jbrowse/core/util/io");
+
+var _rxjs = require("@jbrowse/core/util/rxjs");
+
+var _operators = require("rxjs/operators");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _BamSlightlyLazyFeature = _interopRequireDefault(require("./BamSlightlyLazyFeature"));
+
+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; }
+
+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 BamAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
+  (0, _inherits2["default"])(BamAdapter, _BaseFeatureDataAdapt);
+
+  var _super = _createSuper(BamAdapter);
+
+  function BamAdapter() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, BamAdapter);
+
+    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), "samHeader", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setupP", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "configured", void 0);
+    return _this;
+  }
+
+  (0, _createClass2["default"])(BamAdapter, [{
+    key: "configure",
+    value: // derived classes may not use the same configuration so a custom
+    // configure method allows derived classes to override this behavior
+    function () {
+      var _configure = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var bamLocation, location, indexType, bam, adapterConfig;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!this.configured) {
+                  bamLocation = (0, _configuration.readConfObject)(this.config, 'bamLocation');
+                  location = (0, _configuration.readConfObject)(this.config, ['index', 'location']);
+                  indexType = (0, _configuration.readConfObject)(this.config, ['index', 'indexType']);
+                  bam = new _bam.BamFile({
+                    bamFilehandle: (0, _io.openLocation)(bamLocation, this.pluginManager),
+                    csiFilehandle: indexType === 'CSI' ? (0, _io.openLocation)(location, this.pluginManager) : undefined,
+                    baiFilehandle: indexType !== 'CSI' ? (0, _io.openLocation)(location, this.pluginManager) : undefined,
+                    // chunkSizeLimit and fetchSizeLimit are more troublesome than
+                    // helpful, and have given overly large values on the ultra long
+                    // nanopore reads even with 500MB limits, so disabled with infinity
+                    chunkSizeLimit: Infinity,
+                    fetchSizeLimit: Infinity,
+                    yieldThreadTime: Infinity
+                  });
+                  adapterConfig = (0, _configuration.readConfObject)(this.config, 'sequenceAdapter');
+
+                  if (adapterConfig && this.getSubAdapter) {
+                    this.configured = this.getSubAdapter(adapterConfig).then(function (_ref) {
+                      var dataAdapter = _ref.dataAdapter;
+                      return {
+                        bam: bam,
+                        sequenceAdapter: dataAdapter
+                      };
+                    });
+                  } else {
+                    this.configured = Promise.resolve({
+                      bam: bam
+                    });
+                  }
+                }
+
+                return _context.abrupt("return", this.configured);
+
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function configure() {
+        return _configure.apply(this, arguments);
+      }
+
+      return configure;
+    }()
+  }, {
+    key: "getHeader",
+    value: function () {
+      var _getHeader = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(opts) {
+        var _yield$this$configure, bam;
+
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this.configure();
+
+              case 2:
+                _yield$this$configure = _context2.sent;
+                bam = _yield$this$configure.bam;
+                return _context2.abrupt("return", bam.getHeaderText(opts));
+
+              case 5:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getHeader(_x) {
+        return _getHeader.apply(this, arguments);
+      }
+
+      return getHeader;
+    }()
+  }, {
+    key: "setupPre",
+    value: function () {
+      var _setupPre = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(opts) {
+        var _ref2, _ref2$statusCallback, statusCallback, _yield$this$configure2, bam;
+
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _ref2 = opts || {}, _ref2$statusCallback = _ref2.statusCallback, statusCallback = _ref2$statusCallback === void 0 ? function () {} : _ref2$statusCallback;
+                _context4.next = 3;
+                return this.configure();
+
+              case 3:
+                _yield$this$configure2 = _context4.sent;
+                bam = _yield$this$configure2.bam;
+                _context4.next = 7;
+                return (0, _util.updateStatus)('Downloading index', statusCallback, /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+                  var samHeader, idToName, nameToId;
+                  return _regenerator["default"].wrap(function _callee3$(_context3) {
+                    while (1) {
+                      switch (_context3.prev = _context3.next) {
+                        case 0:
+                          _context3.next = 2;
+                          return bam.getHeader(opts);
+
+                        case 2:
+                          samHeader = _context3.sent;
+                          // use the @SQ lines in the header to figure out the
+                          // mapping between ref ref ID numbers and names
+                          idToName = [];
+                          nameToId = {};
+                          samHeader.filter(function (l) {
+                            return l.tag === 'SQ';
+                          }).forEach(function (sqLine, refId) {
+                            sqLine.data.forEach(function (item) {
+                              if (item.tag === 'SN') {
+                                // this is the ref name
+                                var refName = item.value;
+                                nameToId[refName] = refId;
+                                idToName[refId] = refName;
+                              }
+                            });
+                          });
+                          return _context3.abrupt("return", {
+                            idToName: idToName,
+                            nameToId: nameToId
+                          });
+
+                        case 7:
+                        case "end":
+                          return _context3.stop();
+                      }
+                    }
+                  }, _callee3);
+                })));
+
+              case 7:
+                this.samHeader = _context4.sent;
+                return _context4.abrupt("return", this.samHeader);
+
+              case 9:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function setupPre(_x2) {
+        return _setupPre.apply(this, arguments);
+      }
+
+      return setupPre;
+    }()
+  }, {
+    key: "setup",
+    value: function () {
+      var _setup = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(opts) {
+        var _this2 = this;
+
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                if (!this.setupP) {
+                  this.setupP = this.setupPre(opts)["catch"](function (e) {
+                    _this2.setupP = undefined;
+                    throw e;
+                  });
+                }
+
+                return _context5.abrupt("return", this.setupP);
+
+              case 2:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function setup(_x3) {
+        return _setup.apply(this, arguments);
+      }
+
+      return setup;
+    }()
+  }, {
+    key: "getRefNames",
+    value: function () {
+      var _getRefNames = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(opts) {
+        var _yield$this$setup, idToName;
+
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                _context6.next = 2;
+                return this.setup(opts);
+
+              case 2:
+                _yield$this$setup = _context6.sent;
+                idToName = _yield$this$setup.idToName;
+                return _context6.abrupt("return", idToName);
+
+              case 5:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function getRefNames(_x4) {
+        return _getRefNames.apply(this, arguments);
+      }
+
+      return getRefNames;
+    }()
+  }, {
+    key: "seqFetch",
+    value: function () {
+      var _seqFetch = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(refName, start, end) {
+        var _yield$this$configure3, sequenceAdapter, refSeqStore, features, seqChunks, sequence;
+
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                _context7.next = 2;
+                return this.configure();
+
+              case 2:
+                _yield$this$configure3 = _context7.sent;
+                sequenceAdapter = _yield$this$configure3.sequenceAdapter;
+                refSeqStore = sequenceAdapter;
+
+                if (refSeqStore) {
+                  _context7.next = 7;
+                  break;
+                }
+
+                return _context7.abrupt("return", undefined);
+
+              case 7:
+                if (refName) {
+                  _context7.next = 9;
+                  break;
+                }
+
+                return _context7.abrupt("return", undefined);
+
+              case 9:
+                features = refSeqStore.getFeatures({
+                  refName: refName,
+                  start: start,
+                  end: end,
+                  assemblyName: ''
+                });
+                _context7.next = 12;
+                return features.pipe((0, _operators.toArray)()).toPromise();
+
+              case 12:
+                seqChunks = _context7.sent;
+                sequence = '';
+                seqChunks.sort(function (a, b) {
+                  return a.get('start') - b.get('start');
+                }).forEach(function (chunk) {
+                  var chunkStart = chunk.get('start');
+                  var chunkEnd = chunk.get('end');
+                  var trimStart = Math.max(start - chunkStart, 0);
+                  var trimEnd = Math.min(end - chunkStart, chunkEnd - chunkStart);
+                  var trimLength = trimEnd - trimStart;
+                  var chunkSeq = chunk.get('seq') || chunk.get('residues');
+                  sequence += chunkSeq.substr(trimStart, trimLength);
+                });
+
+                if (!(sequence.length !== end - start)) {
+                  _context7.next = 17;
+                  break;
+                }
+
+                throw new Error("sequence fetch failed: fetching ".concat(refName, ":").concat((start - 1).toLocaleString(), "-").concat(end.toLocaleString(), " returned ").concat(sequence.length.toLocaleString(), " bases, but should have returned ").concat((end - start).toLocaleString()));
+
+              case 17:
+                return _context7.abrupt("return", sequence);
+
+              case 18:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function seqFetch(_x5, _x6, _x7) {
+        return _seqFetch.apply(this, arguments);
+      }
+
+      return seqFetch;
+    }()
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(region, opts) {
+      var _this3 = this;
+
+      var refName = region.refName,
+          start = region.start,
+          end = region.end,
+          originalRefName = region.originalRefName;
+
+      var _ref4 = opts || {},
+          signal = _ref4.signal,
+          filterBy = _ref4.filterBy,
+          _ref4$statusCallback = _ref4.statusCallback,
+          statusCallback = _ref4$statusCallback === void 0 ? function () {} : _ref4$statusCallback;
+
+      return (0, _rxjs.ObservableCreate)( /*#__PURE__*/function () {
+        var _ref5 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(observer) {
+          var _yield$_this3$configu, bam, records, _ref6, _ref6$flagInclude, flagInclude, _ref6$flagExclude, flagExclude, tagFilter, name, _iterator, _step, record, ref, flags, val;
+
+          return _regenerator["default"].wrap(function _callee8$(_context8) {
+            while (1) {
+              switch (_context8.prev = _context8.next) {
+                case 0:
+                  _context8.next = 2;
+                  return _this3.configure();
+
+                case 2:
+                  _yield$_this3$configu = _context8.sent;
+                  bam = _yield$_this3$configu.bam;
+                  _context8.next = 6;
+                  return _this3.setup(opts);
+
+                case 6:
+                  statusCallback('Downloading alignments');
+                  _context8.next = 9;
+                  return bam.getRecordsForRange(refName, start, end, opts);
+
+                case 9:
+                  records = _context8.sent;
+                  _ref6 = filterBy || {}, _ref6$flagInclude = _ref6.flagInclude, flagInclude = _ref6$flagInclude === void 0 ? 0 : _ref6$flagInclude, _ref6$flagExclude = _ref6.flagExclude, flagExclude = _ref6$flagExclude === void 0 ? 0 : _ref6$flagExclude, tagFilter = _ref6.tagFilter, name = _ref6.name;
+                  _iterator = _createForOfIteratorHelper(records);
+                  _context8.prev = 12;
+
+                  _iterator.s();
+
+                case 14:
+                  if ((_step = _iterator.n()).done) {
+                    _context8.next = 33;
+                    break;
+                  }
+
+                  record = _step.value;
+                  ref = void 0;
+
+                  if (record.get('MD')) {
+                    _context8.next = 21;
+                    break;
+                  }
+
+                  _context8.next = 20;
+                  return _this3.seqFetch(originalRefName || refName, record.get('start'), record.get('end'));
+
+                case 20:
+                  ref = _context8.sent;
+
+                case 21:
+                  flags = record.flags;
+
+                  if ((flags & flagInclude) === flagInclude && !(flags & flagExclude)) {
+                    _context8.next = 24;
+                    break;
+                  }
+
+                  return _context8.abrupt("continue", 31);
+
+                case 24:
+                  if (!tagFilter) {
+                    _context8.next = 28;
+                    break;
+                  }
+
+                  val = record.get(tagFilter.tag);
+
+                  if (val === '*' ? val !== undefined : val === tagFilter.value) {
+                    _context8.next = 28;
+                    break;
+                  }
+
+                  return _context8.abrupt("continue", 31);
+
+                case 28:
+                  if (!(name && record.get('name') !== name)) {
+                    _context8.next = 30;
+                    break;
+                  }
+
+                  return _context8.abrupt("continue", 31);
+
+                case 30:
+                  observer.next(new _BamSlightlyLazyFeature["default"](record, _this3, ref));
+
+                case 31:
+                  _context8.next = 14;
+                  break;
+
+                case 33:
+                  _context8.next = 38;
+                  break;
+
+                case 35:
+                  _context8.prev = 35;
+                  _context8.t0 = _context8["catch"](12);
+
+                  _iterator.e(_context8.t0);
+
+                case 38:
+                  _context8.prev = 38;
+
+                  _iterator.f();
+
+                  return _context8.finish(38);
+
+                case 41:
+                  statusCallback('');
+                  observer.complete();
+
+                case 43:
+                case "end":
+                  return _context8.stop();
+              }
+            }
+          }, _callee8, null, [[12, 35, 38, 41]]);
+        }));
+
+        return function (_x8) {
+          return _ref5.apply(this, arguments);
+        };
+      }(), signal);
+    }
+  }, {
+    key: "estimateRegionsStats",
+    value: function () {
+      var _estimateRegionsStats = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(regions, opts) {
+        var _yield$this$configure4, bam, bytes, fetchSizeLimit;
+
+        return _regenerator["default"].wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                _context9.next = 2;
+                return this.configure();
+
+              case 2:
+                _yield$this$configure4 = _context9.sent;
+                bam = _yield$this$configure4.bam;
+
+                if (!(bam.index.filehandle !== '?')) {
+                  _context9.next = 12;
+                  break;
+                }
+
+                _context9.next = 7;
+                return (0, _util.bytesForRegions)(regions, bam);
+
+              case 7:
+                bytes = _context9.sent;
+                fetchSizeLimit = (0, _configuration.readConfObject)(this.config, 'fetchSizeLimit');
+                return _context9.abrupt("return", {
+                  bytes: bytes,
+                  fetchSizeLimit: fetchSizeLimit
+                });
+
+              case 12:
+                return _context9.abrupt("return", (0, _get2["default"])((0, _getPrototypeOf2["default"])(BamAdapter.prototype), "estimateRegionsStats", this).call(this, regions, opts));
+
+              case 13:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+
+      function estimateRegionsStats(_x9, _x10) {
+        return _estimateRegionsStats.apply(this, arguments);
+      }
+
+      return estimateRegionsStats;
+    }()
+  }, {
+    key: "freeResources",
+    value: function
+      /* { region } */
+    freeResources() {} // depends on setup being called before the BAM constructor
+
+  }, {
+    key: "refIdToName",
+    value: function refIdToName(refId) {
+      var _this$samHeader;
+
+      return (_this$samHeader = this.samHeader) === null || _this$samHeader === void 0 ? void 0 : _this$samHeader.idToName[refId];
+    }
+  }]);
+  return BamAdapter;
+}(_BaseAdapter.BaseFeatureDataAdapter);
+
+exports["default"] = BamAdapter;