@jbrowse/plugin-alignments 1.6.9 → 1.7.3

package/dist/CramAdapter/CramAdapter.test.js

@@ -0,0 +1,138 @@
+"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 _genericFilehandle = require("generic-filehandle");
+
+var _PluginManager = _interopRequireDefault(require("@jbrowse/core/PluginManager"));
+
+var _CramAdapter = _interopRequireDefault(require("./CramAdapter"));
+
+var _CramTestAdapters = require("./CramTestAdapters");
+
+var _configSchema = _interopRequireDefault(require("./configSchema"));
+
+var pluginManager = new _PluginManager["default"]();
+var configSchema = pluginManager.load(_configSchema["default"]);
+
+var getVolvoxSequenceSubAdapter = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", {
+              dataAdapter: new _CramTestAdapters.SequenceAdapter(new _genericFilehandle.LocalFile(require.resolve('../../test_data/volvox.fa'))),
+              sessionIds: new Set()
+            });
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getVolvoxSequenceSubAdapter() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+test('adapter can fetch features from volvox-sorted.cram', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+  var adapter, features, featuresArray, featuresJsonArray;
+  return _regenerator["default"].wrap(function _callee2$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          adapter = new _CramAdapter["default"](configSchema.create({
+            cramLocation: {
+              localPath: require.resolve('../../test_data/volvox-sorted.cram'),
+              locationType: 'LocalPathLocation'
+            },
+            craiLocation: {
+              localPath: require.resolve('../../test_data/volvox-sorted.cram.crai'),
+              locationType: 'LocalPathLocation'
+            }
+          }), getVolvoxSequenceSubAdapter, pluginManager);
+          features = adapter.getFeatures({
+            assemblyName: 'volvox',
+            refName: 'ctgA',
+            start: 0,
+            end: 20000
+          });
+          _context2.next = 4;
+          return features.pipe((0, _operators.toArray)()).toPromise();
+
+        case 4:
+          featuresArray = _context2.sent;
+          expect(featuresArray[0].get('refName')).toBe('ctgA');
+          featuresJsonArray = featuresArray.map(function (f) {
+            return f.toJSON();
+          });
+          expect(featuresJsonArray.length).toEqual(3809);
+          expect(featuresJsonArray.slice(1000, 1010)).toMatchSnapshot();
+          expect(adapter.refIdToName(0)).toBe('ctgA');
+          expect(adapter.refIdToName(1)).toBe(undefined);
+          _context2.t0 = expect;
+          _context2.next = 14;
+          return adapter.hasDataForRefName('ctgA');
+
+        case 14:
+          _context2.t1 = _context2.sent;
+          (0, _context2.t0)(_context2.t1).toBe(true);
+
+        case 16:
+        case "end":
+          return _context2.stop();
+      }
+    }
+  }, _callee2);
+})));
+test('test usage of cramSlightlyLazyFeature toJSON (used in the widget)', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+  var adapter, features, featuresArray, f;
+  return _regenerator["default"].wrap(function _callee3$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          adapter = new _CramAdapter["default"](configSchema.create({
+            cramLocation: {
+              localPath: require.resolve('../../test_data/volvox-sorted.cram'),
+              locationType: 'LocalPathLocation'
+            },
+            craiLocation: {
+              localPath: require.resolve('../../test_data/volvox-sorted.cram.crai'),
+              locationType: 'LocalPathLocation'
+            }
+          }), getVolvoxSequenceSubAdapter, pluginManager);
+          features = adapter.getFeatures({
+            assemblyName: 'volvox',
+            refName: 'ctgA',
+            start: 0,
+            end: 100
+          });
+          _context3.next = 4;
+          return features.pipe((0, _operators.toArray)()).toPromise();
+
+        case 4:
+          featuresArray = _context3.sent;
+          f = featuresArray[0].toJSON();
+          expect(f.refName).toBe('ctgA');
+          expect(f.start).toBe(2);
+          expect(f.end).toBe(102); // don't pass the mismatches to the frontend
+
+          expect(f.mismatches).toEqual(undefined);
+
+        case 10:
+        case "end":
+          return _context3.stop();
+      }
+    }
+  }, _callee3);
+})));

package/dist/CramAdapter/CramSlightlyLazyFeature.d.ts

@@ -1,49 +1,49 @@
-import { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util/simpleFeature';
-import CramAdapter from './CramAdapter';
-export interface Mismatch {
-    qual?: number;
-    start: number;
-    length: number;
-    type: string;
-    base: string;
-    altbase?: string;
-    seq?: string;
-    cliplen?: number;
-}
-export default class CramSlightlyLazyFeature implements Feature {
-    private record;
-    private _store;
-    constructor(record: any, _store: CramAdapter);
-    _get_name(): any;
-    _get_start(): number;
-    _get_end(): number;
-    _get_cram_read_features(): any;
-    _get_type(): string;
-    _get_score(): any;
-    _get_flags(): any;
-    _get_strand(): 1 | -1;
-    _read_group_id(): number | undefined;
-    _get_qual(): any;
-    qualRaw(): any;
-    _get_seq_id(): string | undefined;
-    _get_refName(): string | undefined;
-    _get_is_paired(): boolean;
-    _get_pair_orientation(): any;
-    _get_template_length(): any;
-    _get_next_seq_id(): string | undefined;
-    _get_next_pos(): any;
-    _get_next_segment_position(): string | undefined;
-    _get_tags(): any;
-    _get_seq(): any;
-    _get_CIGAR(): string;
-    tags(): string[];
-    id(): string;
-    get(field: string): any;
-    parent(): undefined | Feature;
-    children(): undefined | Feature[];
-    set(): void;
-    pairedFeature(): boolean;
-    _get_clipPos(): any;
-    toJSON(): SimpleFeatureSerialized;
-    _get_mismatches(): Mismatch[];
-}
+import { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util/simpleFeature';
+import CramAdapter from './CramAdapter';
+export interface Mismatch {
+    qual?: number;
+    start: number;
+    length: number;
+    type: string;
+    base: string;
+    altbase?: string;
+    seq?: string;
+    cliplen?: number;
+}
+export default class CramSlightlyLazyFeature implements Feature {
+    private record;
+    private _store;
+    constructor(record: any, _store: CramAdapter);
+    _get_name(): any;
+    _get_start(): number;
+    _get_end(): number;
+    _get_cram_read_features(): any;
+    _get_type(): string;
+    _get_score(): any;
+    _get_flags(): any;
+    _get_strand(): 1 | -1;
+    _read_group_id(): number | undefined;
+    _get_qual(): any;
+    qualRaw(): any;
+    _get_seq_id(): string | undefined;
+    _get_refName(): string | undefined;
+    _get_is_paired(): boolean;
+    _get_pair_orientation(): any;
+    _get_template_length(): any;
+    _get_next_seq_id(): string | undefined;
+    _get_next_pos(): any;
+    _get_next_segment_position(): string | undefined;
+    _get_tags(): any;
+    _get_seq(): any;
+    _get_CIGAR(): string;
+    tags(): string[];
+    id(): string;
+    get(field: string): any;
+    parent(): undefined | Feature;
+    children(): undefined | Feature[];
+    set(): void;
+    pairedFeature(): boolean;
+    _get_clipPos(): any;
+    toJSON(): SimpleFeatureSerialized;
+    _get_mismatches(): Mismatch[];
+}

package/dist/CramAdapter/CramSlightlyLazyFeature.js

@@ -0,0 +1,447 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+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; }
+
+/* eslint-disable no-underscore-dangle */
+var CramSlightlyLazyFeature = /*#__PURE__*/function () {
+  // uses parameter properties to automatically create fields on the class
+  // https://www.typescriptlang.org/docs/handbook/classes.html#parameter-properties
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function CramSlightlyLazyFeature(record, _store) {
+    (0, _classCallCheck2["default"])(this, CramSlightlyLazyFeature);
+    this.record = record;
+    this._store = _store;
+  }
+
+  (0, _createClass2["default"])(CramSlightlyLazyFeature, [{
+    key: "_get_name",
+    value: function _get_name() {
+      return this.record.readName;
+    }
+  }, {
+    key: "_get_start",
+    value: function _get_start() {
+      return this.record.alignmentStart - 1;
+    }
+  }, {
+    key: "_get_end",
+    value: function _get_end() {
+      return this.record.alignmentStart + this.record.lengthOnRef - 1;
+    }
+  }, {
+    key: "_get_cram_read_features",
+    value: function _get_cram_read_features() {
+      return this.record.readFeatures;
+    }
+  }, {
+    key: "_get_type",
+    value: function _get_type() {
+      return 'match';
+    }
+  }, {
+    key: "_get_score",
+    value: function _get_score() {
+      return this.record.mappingQuality;
+    }
+  }, {
+    key: "_get_flags",
+    value: function _get_flags() {
+      return this.record.flags;
+    }
+  }, {
+    key: "_get_strand",
+    value: function _get_strand() {
+      return this.record.isReverseComplemented() ? -1 : 1;
+    }
+  }, {
+    key: "_read_group_id",
+    value: function _read_group_id() {
+      var rg = this._store.samHeader.readGroups;
+      return rg ? rg[this.record.readGroupId] : undefined;
+    }
+  }, {
+    key: "_get_qual",
+    value: function _get_qual() {
+      return (this.record.qualityScores || []).join(' ');
+    }
+  }, {
+    key: "qualRaw",
+    value: function qualRaw() {
+      return this.record.qualityScores;
+    }
+  }, {
+    key: "_get_seq_id",
+    value: function _get_seq_id() {
+      return this._store.refIdToName(this.record.sequenceId);
+    }
+  }, {
+    key: "_get_refName",
+    value: function _get_refName() {
+      return this._get_seq_id();
+    }
+  }, {
+    key: "_get_is_paired",
+    value: function _get_is_paired() {
+      return !!this.record.mate;
+    }
+  }, {
+    key: "_get_pair_orientation",
+    value: function _get_pair_orientation() {
+      return this.record.isPaired() ? this.record.getPairOrientation() : undefined;
+    }
+  }, {
+    key: "_get_template_length",
+    value: function _get_template_length() {
+      return this.record.templateLength || this.record.templateSize;
+    }
+  }, {
+    key: "_get_next_seq_id",
+    value: function _get_next_seq_id() {
+      return this.record.mate ? this._store.refIdToName(this.record.mate.sequenceId) : undefined;
+    }
+  }, {
+    key: "_get_next_pos",
+    value: function _get_next_pos() {
+      return this.record.mate ? this.record.mate.alignmentStart : undefined;
+    }
+  }, {
+    key: "_get_next_segment_position",
+    value: function _get_next_segment_position() {
+      return this.record.mate ? "".concat(this._store.refIdToName(this.record.mate.sequenceId), ":").concat(this.record.mate.alignmentStart) : undefined;
+    }
+  }, {
+    key: "_get_tags",
+    value: function _get_tags() {
+      var RG = this._read_group_id();
+
+      var tags = this.record.tags; // avoids a tag copy if no RG, but just copy if there is one
+
+      return RG !== undefined ? _objectSpread(_objectSpread({}, tags), {}, {
+        RG: RG
+      }) : tags;
+    }
+  }, {
+    key: "_get_seq",
+    value: function _get_seq() {
+      return this.record.getReadBases();
+    } // generate a CIGAR, based on code from jkbonfield
+
+  }, {
+    key: "_get_CIGAR",
+    value: function _get_CIGAR() {
+      var seq = '';
+      var cigar = '';
+      var op = 'M';
+      var oplen = 0; // not sure I should access these, but...
+
+      var ref = this.record._refRegion.seq;
+      var refStart = this.record._refRegion.start;
+      var last_pos = this.record.alignmentStart;
+      var sublen = 0;
+
+      if (typeof this.record.readFeatures !== 'undefined') {
+        // @ts-ignore
+        this.record.readFeatures.forEach(function (_ref) {
+          var code = _ref.code,
+              refPos = _ref.refPos,
+              sub = _ref.sub,
+              data = _ref.data;
+          sublen = refPos - last_pos;
+          seq += ref.substring(last_pos - refStart, refPos - refStart);
+          last_pos = refPos;
+
+          if (oplen && op !== 'M') {
+            cigar += oplen + op;
+            oplen = 0;
+          }
+
+          if (sublen) {
+            op = 'M';
+            oplen += sublen;
+          }
+
+          if (code === 'b') {
+            // An array of bases stored verbatim
+            var ret = data.split(',');
+            var added = String.fromCharCode.apply(String, (0, _toConsumableArray2["default"])(ret));
+            seq += added;
+            last_pos += added.length;
+            oplen += added.length;
+          } else if (code === 'B') {
+            // Single base (+ qual score)
+            seq += sub;
+            last_pos++;
+            oplen++;
+          } else if (code === 'X') {
+            // Substitution
+            seq += sub;
+            last_pos++;
+            oplen++;
+          } else if (code === 'D' || code === 'N') {
+            // Deletion or Ref Skip
+            last_pos += data;
+
+            if (oplen) {
+              cigar += oplen + op;
+            }
+
+            cigar += data + code;
+            oplen = 0;
+          } else if (code === 'I' || code === 'S') {
+            // Insertion or soft-clip
+            seq += data;
+
+            if (oplen) {
+              cigar += oplen + op;
+            }
+
+            cigar += data.length + code;
+            oplen = 0;
+          } else if (code === 'i') {
+            // Single base insertion
+            seq += data;
+
+            if (oplen) {
+              cigar += oplen + op;
+            }
+
+            cigar += "".concat(1, "I");
+            oplen = 0;
+          } else if (code === 'P') {
+            // Padding
+            if (oplen) {
+              cigar += oplen + op;
+            }
+
+            cigar += "".concat(data, "P");
+          } else if (code === 'H') {
+            // Hard clip
+            if (oplen) {
+              cigar += oplen + op;
+            }
+
+            cigar += "".concat(data, "H");
+            oplen = 0;
+          } // else q or Q
+
+        });
+      } else {
+        sublen = this.record.readLength - seq.length;
+      }
+
+      if (seq.length !== this.record.readLength) {
+        sublen = this.record.readLength - seq.length;
+        seq += ref.substring(last_pos - refStart, last_pos - refStart + sublen);
+
+        if (oplen && op !== 'M') {
+          cigar += oplen + op;
+          oplen = 0;
+        }
+
+        op = 'M';
+        oplen += sublen;
+      }
+
+      if (oplen) {
+        cigar += oplen + op;
+      }
+
+      return cigar;
+    }
+  }, {
+    key: "tags",
+    value: function tags() {
+      var properties = Object.getOwnPropertyNames(CramSlightlyLazyFeature.prototype);
+      return properties.filter(function (prop) {
+        return prop.startsWith('_get_') && prop !== '_get_mismatches' && prop !== '_get_cram_read_features';
+      }).map(function (methodName) {
+        return methodName.replace('_get_', '');
+      });
+    }
+  }, {
+    key: "id",
+    value: function id() {
+      return "".concat(this._store.id, "-").concat(this.record.uniqueId);
+    }
+  }, {
+    key: "get",
+    value: function get(field) {
+      var methodName = "_get_".concat(field); // @ts-ignore
+
+      if (this[methodName]) {
+        // @ts-ignore
+        return this[methodName]();
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "parent",
+    value: function parent() {
+      return undefined;
+    }
+  }, {
+    key: "children",
+    value: function children() {
+      return undefined;
+    }
+  }, {
+    key: "set",
+    value: function set() {}
+  }, {
+    key: "pairedFeature",
+    value: function pairedFeature() {
+      return false;
+    }
+  }, {
+    key: "_get_clipPos",
+    value: function _get_clipPos() {
+      var mismatches = this.get('mismatches');
+
+      if (mismatches.length) {
+        var _record = this.get('strand') === -1 ? mismatches[mismatches.length - 1] : mismatches[0];
+
+        var type = _record.type,
+            cliplen = _record.cliplen;
+
+        if (type === 'softclip' || type === 'hardclip') {
+          return cliplen;
+        }
+      }
+
+      return 0;
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      var _this = this;
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      var tags = {};
+      this.tags().forEach(function (t) {
+        var val = _this.get(t);
+
+        if (val !== undefined) {
+          tags[t] = val;
+        }
+      });
+      return _objectSpread(_objectSpread({}, tags), {}, {
+        name: this.get('name'),
+        type: this.get('type'),
+        uniqueId: this.id()
+      });
+    }
+  }, {
+    key: "_get_mismatches",
+    value: function _get_mismatches() {
+      var readFeatures = this.get('cram_read_features');
+      var qual = this.qualRaw();
+
+      if (!readFeatures) {
+        return [];
+      }
+
+      var start = this.get('start');
+      var mismatches = [];
+      readFeatures.forEach(function (args) {
+        var code = args.code,
+            pos = args.pos,
+            data = args.data,
+            sub = args.sub,
+            ref = args.ref;
+        var refPos = args.refPos - 1 - start;
+
+        if (code === 'X') {
+          // substitution
+          mismatches.push({
+            start: refPos,
+            length: 1,
+            base: sub,
+            qual: qual === null || qual === void 0 ? void 0 : qual[pos],
+            altbase: ref,
+            type: 'mismatch'
+          });
+        } else if (code === 'I') {
+          // insertion
+          mismatches.push({
+            start: refPos,
+            type: 'insertion',
+            base: "".concat(data.length),
+            length: 0
+          });
+        } else if (code === 'N') {
+          // reference skip
+          mismatches.push({
+            type: 'skip',
+            length: data,
+            start: refPos,
+            base: 'N'
+          });
+        } else if (code === 'S') {
+          // soft clip
+          var len = data.length;
+          mismatches.push({
+            start: refPos,
+            type: 'softclip',
+            base: "S".concat(len),
+            cliplen: len,
+            length: 1
+          });
+        } else if (code === 'P') {// padding
+        } else if (code === 'H') {
+          // hard clip
+          var _len = data;
+          mismatches.push({
+            start: refPos,
+            type: 'hardclip',
+            base: "H".concat(_len),
+            cliplen: _len,
+            length: 1
+          });
+        } else if (code === 'D') {
+          // deletion
+          mismatches.push({
+            type: 'deletion',
+            length: data,
+            start: refPos,
+            base: '*'
+          });
+        } else if (code === 'b') {// stretch of bases
+        } else if (code === 'q') {// stretch of qual scores
+        } else if (code === 'B') {// a pair of [base, qual]
+        } else if (code === 'i') {
+          // single-base insertion
+          // insertion
+          mismatches.push({
+            start: refPos,
+            type: 'insertion',
+            base: data,
+            length: 1
+          });
+        } else if (code === 'Q') {// single quality value
+        }
+      });
+      return mismatches;
+    }
+  }]);
+  return CramSlightlyLazyFeature;
+}();
+
+exports["default"] = CramSlightlyLazyFeature;