@jbrowse/plugin-variants 1.6.9 → 1.7.3

package/dist/VcfAdapter/VcfAdapter.js

@@ -0,0 +1,383 @@
+"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 _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+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 _BaseAdapter = require("@jbrowse/core/data_adapters/BaseAdapter");
+
+var _io = require("@jbrowse/core/util/io");
+
+var _rxjs = require("@jbrowse/core/util/rxjs");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _intervalTree = _interopRequireDefault(require("@flatten-js/interval-tree"));
+
+var _bgzfFilehandle = require("@gmod/bgzf-filehandle");
+
+var _vcf = _interopRequireDefault(require("@gmod/vcf"));
+
+var _VcfFeature = _interopRequireDefault(require("../VcfTabixAdapter/VcfFeature"));
+
+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 readVcf = function readVcf(f) {
+  var lines = f.split('\n');
+  var header = [];
+  var rest = [];
+  lines.forEach(function (line) {
+    if (line.startsWith('#')) {
+      header.push(line);
+    } else if (line) {
+      rest.push(line);
+    }
+  });
+  return {
+    header: header.join('\n'),
+    lines: rest
+  };
+};
+
+function isGzip(buf) {
+  return buf[0] === 31 && buf[1] === 139 && buf[2] === 8;
+}
+
+var VcfAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
+  (0, _inherits2["default"])(VcfAdapter, _BaseFeatureDataAdapt);
+
+  var _super = _createSuper(VcfAdapter);
+
+  function VcfAdapter() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, VcfAdapter);
+
+    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), "vcfFeatures", void 0);
+    return _this;
+  }
+
+  (0, _createClass2["default"])(VcfAdapter, [{
+    key: "getHeader",
+    value: function () {
+      var _getHeader = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var _yield$this$setup, header;
+
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.setup();
+
+              case 2:
+                _yield$this$setup = _context.sent;
+                header = _yield$this$setup.header;
+                return _context.abrupt("return", header);
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function getHeader() {
+        return _getHeader.apply(this, arguments);
+      }
+
+      return getHeader;
+    }()
+  }, {
+    key: "getMetadata",
+    value: function () {
+      var _getMetadata = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _yield$this$setup2, header, parser;
+
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this.setup();
+
+              case 2:
+                _yield$this$setup2 = _context2.sent;
+                header = _yield$this$setup2.header;
+                parser = new _vcf["default"]({
+                  header: header
+                });
+                return _context2.abrupt("return", parser.getMetadata());
+
+              case 6:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getMetadata() {
+        return _getMetadata.apply(this, arguments);
+      }
+
+      return getMetadata;
+    }() // converts lines into an interval tree
+
+  }, {
+    key: "setupP",
+    value: function () {
+      var _setupP = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var buffer, buf, str, _readVcf, header, lines, intervalTree;
+
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return (0, _io.openLocation)((0, _configuration.readConfObject)(this.config, 'vcfLocation'), this.pluginManager).readFile();
+
+              case 2:
+                buffer = _context3.sent;
+
+                if (!isGzip(buffer)) {
+                  _context3.next = 9;
+                  break;
+                }
+
+                _context3.next = 6;
+                return (0, _bgzfFilehandle.unzip)(buffer);
+
+              case 6:
+                _context3.t0 = _context3.sent;
+                _context3.next = 10;
+                break;
+
+              case 9:
+                _context3.t0 = buffer;
+
+              case 10:
+                buf = _context3.t0;
+
+                if (!(buf.length > 536870888)) {
+                  _context3.next = 13;
+                  break;
+                }
+
+                throw new Error('Data exceeds maximum string length (512MB)');
+
+              case 13:
+                str = new TextDecoder().decode(buf);
+                _readVcf = readVcf(str), header = _readVcf.header, lines = _readVcf.lines;
+                intervalTree = lines.map(function (line, id) {
+                  var _info$match;
+
+                  var _line$split = line.split('\t'),
+                      _line$split2 = (0, _slicedToArray2["default"])(_line$split, 8),
+                      refName = _line$split2[0],
+                      startP = _line$split2[1],
+                      ref = _line$split2[3],
+                      info = _line$split2[7];
+
+                  var start = +startP - 1;
+                  var end = +(((_info$match = info.match(/END=(\d+)/)) === null || _info$match === void 0 ? void 0 : _info$match[1].trim()) || start + ref.length);
+                  return {
+                    line: line,
+                    refName: refName,
+                    start: start,
+                    end: end,
+                    id: id
+                  };
+                }).reduce(function (acc, obj) {
+                  var key = obj.refName;
+
+                  if (!acc[key]) {
+                    acc[key] = new _intervalTree["default"]();
+                  }
+
+                  acc[key].insert([obj.start, obj.end], obj);
+                  return acc;
+                }, {});
+                return _context3.abrupt("return", {
+                  header: header,
+                  intervalTree: intervalTree
+                });
+
+              case 17:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function setupP() {
+        return _setupP.apply(this, arguments);
+      }
+
+      return setupP;
+    }()
+  }, {
+    key: "setup",
+    value: function () {
+      var _setup = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var _this2 = this;
+
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                if (!this.vcfFeatures) {
+                  this.vcfFeatures = this.setupP()["catch"](function (e) {
+                    _this2.vcfFeatures = undefined;
+                    throw e;
+                  });
+                }
+
+                return _context4.abrupt("return", this.vcfFeatures);
+
+              case 2:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function setup() {
+        return _setup.apply(this, arguments);
+      }
+
+      return setup;
+    }()
+  }, {
+    key: "getRefNames",
+    value: function () {
+      var _getRefNames = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+        var _,
+            _yield$this$setup3,
+            intervalTree,
+            _args5 = arguments;
+
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _ = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : {};
+                _context5.next = 3;
+                return this.setup();
+
+              case 3:
+                _yield$this$setup3 = _context5.sent;
+                intervalTree = _yield$this$setup3.intervalTree;
+                return _context5.abrupt("return", Object.keys(intervalTree));
+
+              case 6:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function getRefNames() {
+        return _getRefNames.apply(this, arguments);
+      }
+
+      return getRefNames;
+    }()
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(region) {
+      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 _intervalTree$refName, start, end, refName, _yield$_this3$setup, header, intervalTree, parser;
+
+          return _regenerator["default"].wrap(function _callee6$(_context6) {
+            while (1) {
+              switch (_context6.prev = _context6.next) {
+                case 0:
+                  _context6.prev = 0;
+                  start = region.start, end = region.end, refName = region.refName;
+                  _context6.next = 4;
+                  return _this3.setup();
+
+                case 4:
+                  _yield$_this3$setup = _context6.sent;
+                  header = _yield$_this3$setup.header;
+                  intervalTree = _yield$_this3$setup.intervalTree;
+                  parser = new _vcf["default"]({
+                    header: header
+                  });
+                  (_intervalTree$refName = intervalTree[refName]) === null || _intervalTree$refName === void 0 ? void 0 : _intervalTree$refName.search([start, end]).forEach(function (f) {
+                    return observer.next(new _VcfFeature["default"]({
+                      variant: parser.parseLine(f.line),
+                      parser: parser,
+                      id: "".concat(_this3.id, "-").concat(f.id)
+                    }));
+                  });
+                  observer.complete();
+                  _context6.next = 15;
+                  break;
+
+                case 12:
+                  _context6.prev = 12;
+                  _context6.t0 = _context6["catch"](0);
+                  observer.error(_context6.t0);
+
+                case 15:
+                case "end":
+                  return _context6.stop();
+              }
+            }
+          }, _callee6, null, [[0, 12]]);
+        }));
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }(), opts.signal);
+    }
+  }, {
+    key: "freeResources",
+    value: function freeResources() {}
+  }]);
+  return VcfAdapter;
+}(_BaseAdapter.BaseFeatureDataAdapter);
+
+exports["default"] = VcfAdapter;
+(0, _defineProperty2["default"])(VcfAdapter, "capabilities", ['getFeatures', 'getRefNames']);

package/dist/VcfAdapter/VcfAdapter.test.js

@@ -0,0 +1,55 @@
+"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 _VcfAdapter = _interopRequireDefault(require("./VcfAdapter"));
+
+var _configSchema = _interopRequireDefault(require("./configSchema"));
+
+var _webEncoding = require("web-encoding");
+
+window.TextDecoder = _webEncoding.TextDecoder;
+test('adapter can fetch variants from volvox.vcf', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+  var adapter, features, names, featuresArray;
+  return _regenerator["default"].wrap(function _callee$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          adapter = new _VcfAdapter["default"](_configSchema["default"].create({
+            vcfLocation: {
+              localPath: require.resolve('./test_data/volvox.filtered.vcf'),
+              locationType: 'LocalPathLocation'
+            }
+          }));
+          features = adapter.getFeatures({
+            assemblyName: 'volvox',
+            refName: 'ctgA',
+            start: 0,
+            end: 20000
+          });
+          _context.next = 4;
+          return adapter.getRefNames();
+
+        case 4:
+          names = _context.sent;
+          expect(names).toMatchSnapshot();
+          _context.next = 8;
+          return features.pipe((0, _operators.toArray)()).toPromise();
+
+        case 8:
+          featuresArray = _context.sent;
+          expect(featuresArray.slice(0, 5)).toMatchSnapshot();
+
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _callee);
+})));

package/dist/VcfAdapter/configSchema.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
-export default _default;
+declare const _default: import("@jbrowse/core/configuration").AnyConfigurationSchemaType;
+export default _default;

package/dist/VcfAdapter/configSchema.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _default = (0, _configuration.ConfigurationSchema)('VcfAdapter', {
+  vcfLocation: {
+    type: 'fileLocation',
+    defaultValue: {
+      uri: '/path/to/my.vcf',
+      locationType: 'UriLocation'
+    }
+  }
+}, {
+  explicitlyTyped: true
+});
+
+exports["default"] = _default;

package/dist/VcfAdapter/index.d.ts

@@ -1 +1 @@
-export { default as configSchema } from './configSchema';
+export { default as configSchema } from './configSchema';

package/dist/VcfAdapter/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"));

package/dist/VcfTabixAdapter/VcfFeature.d.ts

@@ -1,59 +1,59 @@
-import { Feature } from '@jbrowse/core/util/simpleFeature';
-/**
- * VCF Feature creation with lazy genotype evaluation.
- */
-interface Samples {
-    [key: string]: {
-        [key: string]: {
-            values: string[] | number[] | null;
-        };
-    };
-}
-interface FeatureData {
-    [key: string]: unknown;
-    refName: string;
-    start: number;
-    end: number;
-    description?: string;
-    type?: string;
-    name?: string;
-    aliases?: string[];
-    samples?: Samples;
-}
-export default class VCFFeature implements Feature {
-    private variant;
-    private parser;
-    private data;
-    private _id;
-    constructor(args: {
-        variant: any;
-        parser: any;
-        id: string;
-    });
-    get(field: string): any;
-    set(): void;
-    parent(): undefined;
-    children(): undefined;
-    tags(): string[];
-    id(): string;
-    dataFromVariant(variant: {
-        REF: string;
-        POS: number;
-        ALT: string[];
-        CHROM: string;
-        INFO: any;
-        ID: string[];
-    }): FeatureData;
-    /**
-     * Get a sequence ontology (SO) term that describes the variant type
-     */
-    _getSOTermAndDescription(ref: string, alt: string[]): [string, string] | [undefined, undefined];
-    static _altTypeToSO: {
-        [key: string]: string | undefined;
-    };
-    _getSOAndDescFromAltDefs(ref: string, alt: string): [string, string] | [undefined, undefined];
-    _getSOAndDescByExamination(ref: string, alt: string): [string, string];
-    _makeDescriptionString(soTerm: string, ref: string, alt: string): string;
-    toJSON(): any;
-}
-export {};
+import { Feature } from '@jbrowse/core/util/simpleFeature';
+/**
+ * VCF Feature creation with lazy genotype evaluation.
+ */
+interface Samples {
+    [key: string]: {
+        [key: string]: {
+            values: string[] | number[] | null;
+        };
+    };
+}
+interface FeatureData {
+    [key: string]: unknown;
+    refName: string;
+    start: number;
+    end: number;
+    description?: string;
+    type?: string;
+    name?: string;
+    aliases?: string[];
+    samples?: Samples;
+}
+export default class VCFFeature implements Feature {
+    private variant;
+    private parser;
+    private data;
+    private _id;
+    constructor(args: {
+        variant: any;
+        parser: any;
+        id: string;
+    });
+    get(field: string): any;
+    set(): void;
+    parent(): undefined;
+    children(): undefined;
+    tags(): string[];
+    id(): string;
+    dataFromVariant(variant: {
+        REF: string;
+        POS: number;
+        ALT: string[];
+        CHROM: string;
+        INFO: any;
+        ID: string[];
+    }): FeatureData;
+    /**
+     * Get a sequence ontology (SO) term that describes the variant type
+     */
+    _getSOTermAndDescription(ref: string, alt: string[]): [string, string] | [undefined, undefined];
+    static _altTypeToSO: {
+        [key: string]: string | undefined;
+    };
+    _getSOAndDescFromAltDefs(ref: string, alt: string): [string, string] | [undefined, undefined];
+    _getSOAndDescByExamination(ref: string, alt: string): [string, string];
+    _makeDescriptionString(soTerm: string, ref: string, alt: string): string;
+    toJSON(): any;
+}
+export {};