@jbrowse/plugin-alignments 1.6.9 → 1.7.3

package/dist/CramAdapter/CramAdapter.js

@@ -0,0 +1,660 @@
+"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 _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 _cram = require("@gmod/cram");
+
+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 _CramSlightlyLazyFeature = _interopRequireDefault(require("./CramSlightlyLazyFeature"));
+
+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 CramAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
+  (0, _inherits2["default"])(CramAdapter, _BaseFeatureDataAdapt);
+
+  var _super = _createSuper(CramAdapter);
+
+  function CramAdapter() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, CramAdapter);
+
+    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", {});
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setupP", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "seqIdToRefName", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "seqIdToOriginalRefName", []);
+    return _this;
+  }
+
+  (0, _createClass2["default"])(CramAdapter, [{
+    key: "configure",
+    value: function () {
+      var _configure = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var cramLocation, craiLocation, cram, sequenceAdapterType, seqConf, _yield$this$getSubAda, sequenceAdapter;
+
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                cramLocation = this.getConf('cramLocation');
+                craiLocation = this.getConf('craiLocation');
+
+                if (cramLocation) {
+                  _context.next = 4;
+                  break;
+                }
+
+                throw new Error('missing cramLocation argument');
+
+              case 4:
+                if (craiLocation) {
+                  _context.next = 6;
+                  break;
+                }
+
+                throw new Error('missing craiLocation argument');
+
+              case 6:
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                cram = new _cram.IndexedCramFile({
+                  cramFilehandle: (0, _io.openLocation)(cramLocation, this.pluginManager),
+                  index: new _cram.CraiIndex({
+                    filehandle: (0, _io.openLocation)(craiLocation, this.pluginManager)
+                  }),
+                  seqFetch: this.seqFetch.bind(this),
+                  checkSequenceMD5: false,
+                  fetchSizeLimit: 200000000 // just make this a large size to avoid hitting it
+
+                }); // instantiate the sequence adapter
+
+                sequenceAdapterType = this.getConf(['sequenceAdapter', 'type']);
+
+                if (this.getSubAdapter) {
+                  _context.next = 10;
+                  break;
+                }
+
+                throw new Error('Error getting subadapter');
+
+              case 10:
+                seqConf = this.getConf('sequenceAdapter');
+                _context.next = 13;
+                return this.getSubAdapter(seqConf);
+
+              case 13:
+                _yield$this$getSubAda = _context.sent;
+                sequenceAdapter = _yield$this$getSubAda.dataAdapter;
+
+                if (sequenceAdapter instanceof _BaseAdapter.BaseFeatureDataAdapter) {
+                  _context.next = 17;
+                  break;
+                }
+
+                throw new Error("CRAM feature adapters cannot use sequence adapters of type '".concat(sequenceAdapterType, "'"));
+
+              case 17:
+                return _context.abrupt("return", {
+                  cram: cram,
+                  sequenceAdapter: sequenceAdapter
+                });
+
+              case 18:
+              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, cram;
+
+        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;
+                cram = _yield$this$configure.cram;
+                return _context2.abrupt("return", cram.cram.getHeaderText(opts));
+
+              case 5:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getHeader(_x) {
+        return _getHeader.apply(this, arguments);
+      }
+
+      return getHeader;
+    }()
+  }, {
+    key: "seqFetch",
+    value: function () {
+      var _seqFetch = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(seqId, start, end) {
+        var _yield$this$configure2, sequenceAdapter, refName, seqChunks, sequence;
+
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                start -= 1; // convert from 1-based closed to interbase
+
+                _context3.next = 3;
+                return this.configure();
+
+              case 3:
+                _yield$this$configure2 = _context3.sent;
+                sequenceAdapter = _yield$this$configure2.sequenceAdapter;
+                refName = this.refIdToOriginalName(seqId) || this.refIdToName(seqId);
+
+                if (refName) {
+                  _context3.next = 8;
+                  break;
+                }
+
+                return _context3.abrupt("return", undefined);
+
+              case 8:
+                _context3.next = 10;
+                return sequenceAdapter.getFeatures({
+                  refName: refName,
+                  start: start,
+                  end: end,
+                  assemblyName: ''
+                }).pipe((0, _operators.toArray)()).toPromise();
+
+              case 10:
+                seqChunks = _context3.sent;
+                sequence = seqChunks.sort(function (a, b) {
+                  return a.get('start') - b.get('start');
+                }).map(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');
+                  return chunkSeq.substr(trimStart, trimLength);
+                }).join('');
+
+                if (!(sequence.length !== end - start)) {
+                  _context3.next = 14;
+                  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 14:
+                return _context3.abrupt("return", sequence);
+
+              case 15:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function seqFetch(_x2, _x3, _x4) {
+        return _seqFetch.apply(this, arguments);
+      }
+
+      return seqFetch;
+    }()
+  }, {
+    key: "setupPre",
+    value: function () {
+      var _setupPre = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(opts) {
+        var _ref, _ref$statusCallback, statusCallback, configured, cram, samHeader, idToName, nameToId, readGroups, data;
+
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _ref = opts || {}, _ref$statusCallback = _ref.statusCallback, statusCallback = _ref$statusCallback === void 0 ? function () {} : _ref$statusCallback;
+                _context4.next = 3;
+                return this.configure();
+
+              case 3:
+                configured = _context4.sent;
+                statusCallback('Downloading index');
+                cram = configured.cram;
+                _context4.next = 8;
+                return cram.cram.getSamHeader(opts === null || opts === void 0 ? void 0 : opts.signal);
+
+              case 8:
+                samHeader = _context4.sent;
+                // use the @SQ lines in the header to figure out the
+                // mapping between 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;
+                    }
+                  });
+                });
+                readGroups = samHeader.filter(function (l) {
+                  return l.tag === 'RG';
+                }).map(function (rgLine) {
+                  var _rgLine$data$find;
+
+                  return (_rgLine$data$find = rgLine.data.find(function (item) {
+                    return item.tag === 'ID';
+                  })) === null || _rgLine$data$find === void 0 ? void 0 : _rgLine$data$find.value;
+                });
+                data = {
+                  idToName: idToName,
+                  nameToId: nameToId,
+                  readGroups: readGroups
+                };
+                statusCallback('');
+                this.samHeader = data;
+                return _context4.abrupt("return", _objectSpread({
+                  samHeader: data
+                }, configured));
+
+              case 17:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function setupPre(_x5) {
+        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(_x6) {
+        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, samHeader;
+
+        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;
+                samHeader = _yield$this$setup.samHeader;
+
+                if (samHeader.idToName) {
+                  _context6.next = 6;
+                  break;
+                }
+
+                throw new Error('CRAM file has no header lines');
+
+              case 6:
+                return _context6.abrupt("return", samHeader.idToName);
+
+              case 7:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function getRefNames(_x7) {
+        return _getRefNames.apply(this, arguments);
+      }
+
+      return getRefNames;
+    }() // use info from the SAM header if possible, but fall back to using
+    // the ref seq order from when the browser's refseqs were loaded
+
+  }, {
+    key: "refNameToId",
+    value: function refNameToId(refName) {
+      if (this.samHeader.nameToId) {
+        return this.samHeader.nameToId[refName];
+      }
+
+      if (this.seqIdToRefName) {
+        return this.seqIdToRefName.indexOf(refName);
+      }
+
+      return undefined;
+    } // use info from the SAM header if possible, but fall back to using
+    // the ref seq order from when the browser's refseqs were loaded
+
+  }, {
+    key: "refIdToName",
+    value: function refIdToName(refId) {
+      if (this.samHeader.idToName) {
+        return this.samHeader.idToName[refId];
+      }
+
+      if (this.seqIdToRefName) {
+        return this.seqIdToRefName[refId];
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "refIdToOriginalName",
+    value: function refIdToOriginalName(refId) {
+      return this.seqIdToOriginalRefName[refId];
+    }
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(region, opts) {
+      var _this3 = this;
+
+      var _ref2 = opts || {},
+          signal = _ref2.signal,
+          filterBy = _ref2.filterBy,
+          _ref2$statusCallback = _ref2.statusCallback,
+          statusCallback = _ref2$statusCallback === void 0 ? function () {} : _ref2$statusCallback;
+
+      var refName = region.refName,
+          start = region.start,
+          end = region.end,
+          originalRefName = region.originalRefName;
+      return (0, _rxjs.ObservableCreate)( /*#__PURE__*/function () {
+        var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(observer) {
+          var _yield$_this3$setup, cram, sequenceAdapter, refId, records, _ref4, _ref4$flagInclude, flagInclude, _ref4$flagExclude, flagExclude, tagFilter, name, filtered;
+
+          return _regenerator["default"].wrap(function _callee7$(_context7) {
+            while (1) {
+              switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.next = 2;
+                  return _this3.setup(opts);
+
+                case 2:
+                  _yield$_this3$setup = _context7.sent;
+                  cram = _yield$_this3$setup.cram;
+                  sequenceAdapter = _yield$_this3$setup.sequenceAdapter;
+                  statusCallback('Downloading alignments');
+
+                  if (_this3.seqIdToRefName) {
+                    _context7.next = 10;
+                    break;
+                  }
+
+                  _context7.next = 9;
+                  return sequenceAdapter.getRefNames(opts);
+
+                case 9:
+                  _this3.seqIdToRefName = _context7.sent;
+
+                case 10:
+                  refId = _this3.refNameToId(refName);
+
+                  if (!(refId !== undefined)) {
+                    _context7.next = 24;
+                    break;
+                  }
+
+                  if (originalRefName) {
+                    _this3.seqIdToOriginalRefName[refId] = originalRefName;
+                  }
+
+                  _context7.next = 15;
+                  return cram.getRecordsForRange(refId, start, end, opts);
+
+                case 15:
+                  records = _context7.sent;
+                  (0, _util.checkAbortSignal)(signal);
+                  _ref4 = filterBy || {}, _ref4$flagInclude = _ref4.flagInclude, flagInclude = _ref4$flagInclude === void 0 ? 0 : _ref4$flagInclude, _ref4$flagExclude = _ref4.flagExclude, flagExclude = _ref4$flagExclude === void 0 ? 0 : _ref4$flagExclude, tagFilter = _ref4.tagFilter, name = _ref4.name; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+                  filtered = records.filter(function (record) {
+                    var flags = record.flags;
+                    return (flags & flagInclude) === flagInclude && !(flags & flagExclude);
+                  });
+
+                  if (tagFilter) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    filtered = filtered.filter(function (record) {
+                      var val = record[tagFilter.tag];
+                      return val === '*' ? val !== undefined : val === tagFilter.value;
+                    });
+                  }
+
+                  if (name) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    filtered = filtered.filter(function (record) {
+                      return record.name === name;
+                    });
+                  } // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+                  filtered.forEach(function (record) {
+                    observer.next(_this3.cramRecordToFeature(record));
+                  });
+                  _context7.next = 25;
+                  break;
+
+                case 24:
+                  console.warn('Unknown refName', refName);
+
+                case 25:
+                  statusCallback('');
+                  observer.complete();
+
+                case 27:
+                case "end":
+                  return _context7.stop();
+              }
+            }
+          }, _callee7);
+        }));
+
+        return function (_x8) {
+          return _ref3.apply(this, arguments);
+        };
+      }(), signal);
+    }
+  }, {
+    key: "freeResources",
+    value: function
+      /* { region } */
+    freeResources() {}
+  }, {
+    key: "cramRecordToFeature",
+    value: function cramRecordToFeature(record) {
+      return new _CramSlightlyLazyFeature["default"](record, this);
+    } // we return the configured fetchSizeLimit, and the bytes for the region
+
+  }, {
+    key: "estimateRegionsStats",
+    value: function () {
+      var _estimateRegionsStats = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(regions, opts) {
+        var bytes, fetchSizeLimit;
+        return _regenerator["default"].wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                _context8.next = 2;
+                return this.bytesForRegions(regions, opts);
+
+              case 2:
+                bytes = _context8.sent;
+                fetchSizeLimit = this.getConf('fetchSizeLimit');
+                return _context8.abrupt("return", {
+                  bytes: bytes,
+                  fetchSizeLimit: fetchSizeLimit
+                });
+
+              case 5:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function estimateRegionsStats(_x9, _x10) {
+        return _estimateRegionsStats.apply(this, arguments);
+      }
+
+      return estimateRegionsStats;
+    }()
+    /**
+     * get the approximate number of bytes queried from the file for the given
+     * query regions
+     * @param regions - list of query regions
+     */
+
+  }, {
+    key: "bytesForRegions",
+    value: function () {
+      var _bytesForRegions = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(regions, _opts) {
+        var _this4 = this;
+
+        var _yield$this$configure3, cram, blockResults;
+
+        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$configure3 = _context9.sent;
+                cram = _yield$this$configure3.cram;
+                _context9.next = 6;
+                return Promise.all(regions.map(function (region) {
+                  var refName = region.refName,
+                      start = region.start,
+                      end = region.end;
+
+                  var chrId = _this4.refNameToId(refName);
+
+                  return cram.index.getEntriesForRange(chrId, start, end);
+                }));
+
+              case 6:
+                blockResults = _context9.sent;
+                return _context9.abrupt("return", blockResults.flat().reduce(function (a, b) {
+                  return a + b.sliceBytes;
+                }, 0));
+
+              case 8:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+
+      function bytesForRegions(_x11, _x12) {
+        return _bytesForRegions.apply(this, arguments);
+      }
+
+      return bytesForRegions;
+    }()
+  }]);
+  return CramAdapter;
+}(_BaseAdapter.BaseFeatureDataAdapter);
+
+exports["default"] = CramAdapter;