@jbrowse/plugin-variants 1.6.8 → 1.7.1

package/dist/VcfTabixAdapter/VcfFeature.js

@@ -0,0 +1,261 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _vcf = require("@gmod/vcf");
+
+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; }
+
+var VCFFeature = /*#__PURE__*/function () {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function VCFFeature(args) {
+    (0, _classCallCheck2["default"])(this, VCFFeature);
+    (0, _defineProperty2["default"])(this, "variant", void 0);
+    (0, _defineProperty2["default"])(this, "parser", void 0);
+    (0, _defineProperty2["default"])(this, "data", void 0);
+    (0, _defineProperty2["default"])(this, "_id", void 0);
+    this.variant = args.variant;
+    this.parser = args.parser;
+    this.data = this.dataFromVariant(this.variant);
+    this._id = args.id;
+  } // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+  (0, _createClass2["default"])(VCFFeature, [{
+    key: "get",
+    value: function get(field) {
+      return field === 'samples' ? this.variant.SAMPLES : this.data[field] || this.variant[field];
+    }
+  }, {
+    key: "set",
+    value: function set() {}
+  }, {
+    key: "parent",
+    value: function parent() {
+      return undefined;
+    }
+  }, {
+    key: "children",
+    value: function children() {
+      return undefined;
+    }
+  }, {
+    key: "tags",
+    value: function tags() {
+      var t = [].concat((0, _toConsumableArray2["default"])(Object.keys(this.data)), (0, _toConsumableArray2["default"])(Object.keys(this.variant)), ['samples']);
+      return t;
+    }
+  }, {
+    key: "id",
+    value: function id() {
+      return this._id;
+    }
+  }, {
+    key: "dataFromVariant",
+    value: function dataFromVariant(variant) {
+      var REF = variant.REF,
+          ALT = variant.ALT,
+          POS = variant.POS,
+          CHROM = variant.CHROM,
+          INFO = variant.INFO,
+          ID = variant.ID;
+      var start = POS - 1;
+
+      var _this$_getSOTermAndDe = this._getSOTermAndDescription(REF, ALT),
+          _this$_getSOTermAndDe2 = (0, _slicedToArray2["default"])(_this$_getSOTermAndDe, 2),
+          SO_term = _this$_getSOTermAndDe2[0],
+          description = _this$_getSOTermAndDe2[1];
+
+      var isTRA = ALT === null || ALT === void 0 ? void 0 : ALT.some(function (f) {
+        return f === '<TRA>';
+      });
+      var isSymbolic = ALT === null || ALT === void 0 ? void 0 : ALT.some(function (f) {
+        return f.indexOf('<') !== -1;
+      });
+      return {
+        refName: CHROM,
+        start: start,
+        end: isSymbolic && INFO.END && !isTRA ? +INFO.END[0] : start + REF.length,
+        description: description,
+        type: SO_term,
+        name: ID === null || ID === void 0 ? void 0 : ID.join(','),
+        aliases: ID && ID.length > 1 ? variant.ID.slice(1) : undefined
+      };
+    }
+    /**
+     * Get a sequence ontology (SO) term that describes the variant type
+     */
+
+  }, {
+    key: "_getSOTermAndDescription",
+    value: function _getSOTermAndDescription(ref, alt) {
+      var _this = this;
+
+      // it's just a remark if there are no alternate alleles
+      if (!alt || alt === []) {
+        return ['remark', 'no alternative alleles'];
+      }
+
+      var soTerms = new Set();
+      var descriptions = new Set();
+      alt.forEach(function (a) {
+        var _this$_getSOAndDescFr = _this._getSOAndDescFromAltDefs(ref, a),
+            _this$_getSOAndDescFr2 = (0, _slicedToArray2["default"])(_this$_getSOAndDescFr, 2),
+            soTerm = _this$_getSOAndDescFr2[0],
+            description = _this$_getSOAndDescFr2[1];
+
+        if (!soTerm) {
+          ;
+
+          var _this$_getSOAndDescBy = _this._getSOAndDescByExamination(ref, a);
+
+          var _this$_getSOAndDescBy2 = (0, _slicedToArray2["default"])(_this$_getSOAndDescBy, 2);
+
+          soTerm = _this$_getSOAndDescBy2[0];
+          description = _this$_getSOAndDescBy2[1];
+        }
+
+        if (soTerm && description) {
+          soTerms.add(soTerm);
+          descriptions.add(description);
+        }
+      }); // Combine descriptions like ["SNV G -> A", "SNV G -> T"] to ["SNV G -> A,T"]
+
+      if (descriptions.size > 1) {
+        var prefixes = new Set((0, _toConsumableArray2["default"])(descriptions).map(function (desc) {
+          var prefix = desc.split('->');
+          return prefix[1] ? prefix[0] : desc;
+        }));
+        var new_descs = (0, _toConsumableArray2["default"])(prefixes).map(function (prefix) {
+          var suffixes = (0, _toConsumableArray2["default"])(descriptions).map(function (desc) {
+            var pref = desc.split('-> ');
+            return pref[1] && pref[0] === prefix ? pref[1] : '';
+          }).filter(function (f) {
+            return !!f;
+          });
+          return suffixes.length ? prefix + '-> ' + suffixes.join(',') : (0, _toConsumableArray2["default"])(descriptions).join(',');
+        });
+        descriptions = new Set(new_descs);
+      }
+
+      if (soTerms.size) {
+        return [(0, _toConsumableArray2["default"])(soTerms).join(','), (0, _toConsumableArray2["default"])(descriptions).join(',')];
+      }
+
+      return [undefined, undefined];
+    }
+  }, {
+    key: "_getSOAndDescFromAltDefs",
+    value: function _getSOAndDescFromAltDefs(ref, alt) {
+      if (typeof alt === 'string' && !alt.startsWith('<')) {
+        return [undefined, undefined];
+      } // look for a definition with an SO type for this
+
+
+      var soTerm = VCFFeature._altTypeToSO[alt]; // if no SO term but ALT is in metadata, assume sequence_variant
+
+      if (!soTerm && this.parser.getMetadata('ALT', alt)) {
+        soTerm = 'sequence_variant';
+      }
+
+      if (soTerm) {
+        return [soTerm, alt];
+      } // try to look for a definition for a parent term if we can
+
+
+      var modAlt = alt.split(':');
+
+      if (modAlt.length > 1) {
+        return this._getSOAndDescFromAltDefs(ref, "<".concat(modAlt.slice(0, modAlt.length - 1).join(':'), ">"));
+      } // no parent
+
+
+      return [undefined, undefined];
+    } // note: term SNV is used instead of SNP because SO definition of SNP says
+    // abundance must be at least 1% in population, and can't be sure we meet
+    // that
+
+  }, {
+    key: "_getSOAndDescByExamination",
+    value: function _getSOAndDescByExamination(ref, alt) {
+      var bnd = (0, _vcf.parseBreakend)(alt);
+
+      if (bnd) {
+        return ['breakend', alt];
+      } else if (ref.length === 1 && alt.length === 1) {
+        return ['SNV', this._makeDescriptionString('SNV', ref, alt)];
+      } else if (alt === '<INS>') {
+        return ['insertion', alt];
+      } else if (alt === '<DEL>') {
+        return ['deletion', alt];
+      } else if (alt === '<INV>') {
+        return ['deletion', alt];
+      } else if (alt === '<TRA>') {
+        return ['translocation', alt];
+      } else if (alt.includes('<')) {
+        return ['sv', alt];
+      } else if (ref.length === alt.length) {
+        if (ref.split('').reverse().join('') === alt) {
+          return ['inversion', this._makeDescriptionString('inversion', ref, alt)];
+        }
+
+        return ['substitution', this._makeDescriptionString('substitution', ref, alt)];
+      } else if (ref.length <= alt.length) {
+        return ['insertion', this._makeDescriptionString('insertion', ref, alt)];
+      } else if (ref.length > alt.length) {
+        return ['deletion', this._makeDescriptionString('deletion', ref, alt)];
+      }
+
+      return ['indel', this._makeDescriptionString('indel', ref, alt)];
+    }
+  }, {
+    key: "_makeDescriptionString",
+    value: function _makeDescriptionString(soTerm, ref, alt) {
+      return "".concat(soTerm, " ").concat(ref, " -> ").concat(alt);
+    } // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return _objectSpread(_objectSpread(_objectSpread({
+        uniqueId: this._id
+      }, this.variant), this.data), {}, {
+        samples: this.variant.SAMPLES
+      });
+    }
+  }]);
+  return VCFFeature;
+}();
+
+exports["default"] = VCFFeature;
+(0, _defineProperty2["default"])(VCFFeature, "_altTypeToSO", {
+  DEL: 'deletion',
+  INS: 'insertion',
+  DUP: 'duplication',
+  INV: 'inversion',
+  INVDUP: 'inverted duplication',
+  CNV: 'copy_number_variation',
+  TRA: 'translocation',
+  'DUP:TANDEM': 'tandem_duplication',
+  NON_REF: 'sequence_variant',
+  '*': 'sequence_variant'
+});

package/dist/VcfTabixAdapter/VcfFeature.test.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _vcf = _interopRequireDefault(require("@gmod/vcf"));
+
+var _VcfFeature = _interopRequireDefault(require("./VcfFeature"));
+
+test('test usage of the VcfFeature', function () {
+  var parser = new _vcf["default"]({
+    header: "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam"
+  });
+  var line = "lcl|Scaffald_1\t80465\trs118266897\tR\tA\t29\tPASS\tNS=3;0,14;AF=0.5;DB;112;PG2.1";
+  var variant = parser.parseLine(line);
+  var f = new _VcfFeature["default"]({
+    parser: parser,
+    variant: variant,
+    id: 'myuniqueid'
+  });
+  expect(f.id()).toEqual('myuniqueid');
+  expect(f.get('name')).toEqual('rs118266897');
+});
+test('try INS feature with END less than start', function () {
+  var parser = new _vcf["default"]({
+    header: "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam"
+  });
+  var line = "chr1\t100\trs123\tR\tA\t29\tPASS\tEND=1;SVTYPE=INS";
+  var variant = parser.parseLine(line);
+  var f = new _VcfFeature["default"]({
+    parser: parser,
+    variant: variant,
+    id: 'myuniqueid'
+  });
+  expect(f.id()).toEqual('myuniqueid');
+  expect(f.get('start')).toEqual(99);
+  expect(f.get('end')).toEqual(100);
+});
+test('try DEL feature with END info field valid', function () {
+  var parser = new _vcf["default"]({
+    header: "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam"
+  });
+  var line = "chr1\t100\trs123\tR\t<DEL>\t29\tPASS\tEND=1000;SVTYPE=DEL";
+  var variant = parser.parseLine(line);
+  var f = new _VcfFeature["default"]({
+    parser: parser,
+    variant: variant,
+    id: 'myuniqueid'
+  });
+  expect(f.id()).toEqual('myuniqueid');
+  expect(f.get('start')).toEqual(99);
+  expect(f.get('end')).toEqual(1000);
+});
+describe('test SV description', function () {
+  it('multiple SVs', function () {
+    var parser = new _vcf["default"]({
+      header: "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam"
+    });
+    var line = "chr1\t100\trs123\tR\t<INVDUP>,<INV>\t29\tPASS\tEND=1000;SVTYPE=DEL";
+    var variant = parser.parseLine(line);
+    var f = new _VcfFeature["default"]({
+      parser: parser,
+      variant: variant,
+      id: 'myuniqueid'
+    });
+    expect(f.get('description')).toEqual('<INVDUP>,<INV>');
+  });
+  it('BND', function () {
+    var parser = new _vcf["default"]({
+      header: "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam"
+    });
+    var line = "chr1\t100\trs123\tR\tG[ctgA:34200[\t29\tPASS\tEND=1000;SVTYPE=BND";
+    var variant = parser.parseLine(line);
+    var f = new _VcfFeature["default"]({
+      parser: parser,
+      variant: variant,
+      id: 'myuniqueid'
+    });
+    expect(f.get('description')).toEqual('G[ctgA:34200[');
+  });
+  it('multiple BND', function () {
+    var parser = new _vcf["default"]({
+      header: "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam"
+    });
+    var line = "chr1\t100\trs123\tR\tG[ctgA:34200[,G[ctgA:44200[\t29\tPASS\tEND=1000;SVTYPE=BND";
+    var variant = parser.parseLine(line);
+    var f = new _VcfFeature["default"]({
+      parser: parser,
+      variant: variant,
+      id: 'myuniqueid'
+    });
+    expect(f.get('description')).toEqual('G[ctgA:34200[,G[ctgA:44200[');
+  });
+  it('multiple SNV', function () {
+    var parser = new _vcf["default"]({
+      header: "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tBAMs/caudaus.sorted.sam"
+    });
+    var line = "chr1\t100\trs123\tG\tA,C\t29\tPASS\tHELLO=world";
+    var variant = parser.parseLine(line);
+    var f = new _VcfFeature["default"]({
+      parser: parser,
+      variant: variant,
+      id: 'myuniqueid'
+    });
+    expect(f.get('description')).toEqual('SNV G -> A,C');
+  });
+});

package/dist/VcfTabixAdapter/VcfTabixAdapter.d.ts

@@ -1,35 +1,35 @@
-import { BaseFeatureDataAdapter, BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { NoAssemblyRegion, Region } from '@jbrowse/core/util/types';
-import { Feature } from '@jbrowse/core/util/simpleFeature';
-import { TabixIndexedFile } from '@gmod/tabix';
-import VcfParser from '@gmod/vcf';
-import { GenericFilehandle } from 'generic-filehandle';
-export default class extends BaseFeatureDataAdapter {
-    private configured?;
-    private configurePre;
-    protected configure(): Promise<{
-        filehandle: GenericFilehandle;
-        vcf: TabixIndexedFile;
-        parser: VcfParser;
-    }>;
-    getRefNames(opts?: BaseOptions): Promise<any>;
-    getHeader(): Promise<string>;
-    getMetadata(): Promise<any>;
-    getFeatures(query: NoAssemblyRegion, opts?: BaseOptions): import("rxjs").Observable<Feature>;
-    /**
-     * 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
-     */
-    getFeaturesInMultipleRegions(regions: Region[], opts?: BaseOptions): import("rxjs").Observable<Feature>;
-    freeResources(): void;
-}
+import { BaseFeatureDataAdapter, BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { NoAssemblyRegion, Region } from '@jbrowse/core/util/types';
+import { Feature } from '@jbrowse/core/util/simpleFeature';
+import { TabixIndexedFile } from '@gmod/tabix';
+import VcfParser from '@gmod/vcf';
+import { GenericFilehandle } from 'generic-filehandle';
+export default class extends BaseFeatureDataAdapter {
+    private configured?;
+    private configurePre;
+    protected configure(): Promise<{
+        filehandle: GenericFilehandle;
+        vcf: TabixIndexedFile;
+        parser: VcfParser;
+    }>;
+    getRefNames(opts?: BaseOptions): Promise<any>;
+    getHeader(): Promise<string>;
+    getMetadata(): Promise<any>;
+    getFeatures(query: NoAssemblyRegion, opts?: BaseOptions): import("rxjs").Observable<Feature>;
+    /**
+     * 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
+     */
+    getFeaturesInMultipleRegions(regions: Region[], opts?: BaseOptions): import("rxjs").Observable<Feature>;
+    freeResources(): void;
+}