@jbrowse/plugin-gff3 1.6.8 → 1.7.1

package/dist/Gff3TabixAdapter/Gff3TabixAdapter.js

@@ -0,0 +1,395 @@
+"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 _range = require("@jbrowse/core/util/range");
+
+var _io = require("@jbrowse/core/util/io");
+
+var _rxjs = require("@jbrowse/core/util/rxjs");
+
+var _simpleFeature = _interopRequireDefault(require("@jbrowse/core/util/simpleFeature"));
+
+var _tabix = require("@gmod/tabix");
+
+var _gff = _interopRequireDefault(require("@gmod/gff"));
+
+var _configuration = require("@jbrowse/core/configuration");
+
+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 _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
+  (0, _inherits2["default"])(_default, _BaseFeatureDataAdapt);
+
+  var _super = _createSuper(_default);
+
+  function _default(config, getSubAdapter, pluginManager) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, _default);
+    _this = _super.call(this, config, getSubAdapter, pluginManager);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "gff", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "dontRedispatch", void 0);
+    var gffGzLocation = (0, _configuration.readConfObject)(config, 'gffGzLocation');
+    var indexType = (0, _configuration.readConfObject)(config, ['index', 'indexType']);
+    var location = (0, _configuration.readConfObject)(config, ['index', 'location']);
+    var dontRedispatch = (0, _configuration.readConfObject)(config, 'dontRedispatch');
+    _this.dontRedispatch = dontRedispatch || ['chromosome', 'contig', 'region'];
+    _this.gff = new _tabix.TabixIndexedFile({
+      filehandle: (0, _io.openLocation)(gffGzLocation, _this.pluginManager),
+      csiFilehandle: indexType === 'CSI' ? (0, _io.openLocation)(location, _this.pluginManager) : undefined,
+      tbiFilehandle: indexType !== 'CSI' ? (0, _io.openLocation)(location, _this.pluginManager) : undefined,
+      chunkCacheSize: 50 * Math.pow(2, 20),
+      renameRefSeqs: function renameRefSeqs(n) {
+        return n;
+      }
+    });
+    return _this;
+  }
+
+  (0, _createClass2["default"])(_default, [{
+    key: "getRefNames",
+    value: function () {
+      var _getRefNames = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var opts,
+            _args = arguments;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                opts = _args.length > 0 && _args[0] !== undefined ? _args[0] : {};
+                return _context.abrupt("return", this.gff.getReferenceSequenceNames(opts));
+
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function getRefNames() {
+        return _getRefNames.apply(this, arguments);
+      }
+
+      return getRefNames;
+    }()
+  }, {
+    key: "getHeader",
+    value: function () {
+      var _getHeader = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", this.gff.getHeader());
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getHeader() {
+        return _getHeader.apply(this, arguments);
+      }
+
+      return getHeader;
+    }()
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(query) {
+      var _this2 = 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 _callee3(observer) {
+          var metadata;
+          return _regenerator["default"].wrap(function _callee3$(_context3) {
+            while (1) {
+              switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 2;
+                  return _this2.gff.getMetadata();
+
+                case 2:
+                  metadata = _context3.sent;
+
+                  _this2.getFeaturesHelper(query, opts, metadata, observer, true);
+
+                case 4:
+                case "end":
+                  return _context3.stop();
+              }
+            }
+          }, _callee3);
+        }));
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }(), opts.signal);
+    }
+  }, {
+    key: "getFeaturesHelper",
+    value: function () {
+      var _getFeaturesHelper = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(query) {
+        var _this3 = this;
+
+        var opts,
+            metadata,
+            observer,
+            allowRedispatch,
+            originalQuery,
+            lines,
+            minStart,
+            maxEnd,
+            gff3,
+            features,
+            _args4 = arguments;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                opts = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : {};
+                metadata = _args4.length > 2 ? _args4[2] : undefined;
+                observer = _args4.length > 3 ? _args4[3] : undefined;
+                allowRedispatch = _args4.length > 4 ? _args4[4] : undefined;
+                originalQuery = _args4.length > 5 && _args4[5] !== undefined ? _args4[5] : query;
+                _context4.prev = 5;
+                lines = [];
+                _context4.next = 9;
+                return this.gff.getLines(query.refName, query.start, query.end, function (line, fileOffset) {
+                  lines.push(_this3.parseLine(metadata.columnNumbers, line, fileOffset));
+                });
+
+              case 9:
+                if (!(allowRedispatch && lines.length)) {
+                  _context4.next = 16;
+                  break;
+                }
+
+                minStart = Infinity;
+                maxEnd = -Infinity;
+                lines.forEach(function (line) {
+                  var featureType = line.fields[2]; // only expand redispatch range if feature is not a "dontRedispatch" type
+                  // skips large regions like chromosome,region
+
+                  if (!_this3.dontRedispatch.includes(featureType)) {
+                    var start = line.start - 1; // gff is 1-based
+
+                    if (start < minStart) {
+                      minStart = start;
+                    }
+
+                    if (line.end > maxEnd) {
+                      maxEnd = line.end;
+                    }
+                  }
+                });
+
+                if (!(maxEnd > query.end || minStart < query.start)) {
+                  _context4.next = 16;
+                  break;
+                }
+
+                // make a new feature callback to only return top-level features
+                // in the original query range
+                this.getFeaturesHelper(_objectSpread(_objectSpread({}, query), {}, {
+                  start: minStart,
+                  end: maxEnd
+                }), opts, metadata, observer, false, query);
+                return _context4.abrupt("return");
+
+              case 16:
+                gff3 = lines.map(function (lineRecord) {
+                  if (lineRecord.fields[8] && lineRecord.fields[8] !== '.') {
+                    if (!lineRecord.fields[8].includes('_lineHash')) {
+                      lineRecord.fields[8] += ";_lineHash=".concat(lineRecord.lineHash);
+                    }
+                  } else {
+                    lineRecord.fields[8] = "_lineHash=".concat(lineRecord.lineHash);
+                  }
+
+                  return lineRecord.fields.join('\t');
+                }).join('\n');
+                features = _gff["default"].parseStringSync(gff3, {
+                  parseFeatures: true,
+                  parseComments: false,
+                  parseDirectives: false,
+                  parseSequences: false
+                });
+                features.forEach(function (featureLocs) {
+                  return _this3.formatFeatures(featureLocs).forEach(function (f) {
+                    if ((0, _range.doesIntersect2)(f.get('start'), f.get('end'), originalQuery.start, originalQuery.end)) {
+                      observer.next(f);
+                    }
+                  });
+                });
+                observer.complete();
+                _context4.next = 25;
+                break;
+
+              case 22:
+                _context4.prev = 22;
+                _context4.t0 = _context4["catch"](5);
+                observer.error(_context4.t0);
+
+              case 25:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this, [[5, 22]]);
+      }));
+
+      function getFeaturesHelper(_x2) {
+        return _getFeaturesHelper.apply(this, arguments);
+      }
+
+      return getFeaturesHelper;
+    }()
+  }, {
+    key: "parseLine",
+    value: function parseLine(columnNumbers, line, fileOffset) {
+      var fields = line.split('\t'); // note: index column numbers are 1-based
+
+      return {
+        start: +fields[columnNumbers.start - 1],
+        end: +fields[columnNumbers.end - 1],
+        lineHash: fileOffset,
+        fields: fields
+      };
+    }
+  }, {
+    key: "formatFeatures",
+    value: function formatFeatures(featureLocs) {
+      var _this4 = this;
+
+      return featureLocs.map(function (featureLoc) {
+        return new _simpleFeature["default"]({
+          data: _this4.featureData(featureLoc),
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          id: "".concat(_this4.id, "-offset-").concat(featureLoc.attributes._lineHash[0])
+        });
+      });
+    }
+  }, {
+    key: "featureData",
+    value: function featureData(data) {
+      var _this5 = this;
+
+      var f = _objectSpread({}, data);
+
+      f.start -= 1; // convert to interbase
+
+      if (data.strand === '+') {
+        f.strand = 1;
+      } else if (data.strand === '-') {
+        f.strand = -1;
+      } else if (data.strand === '.') {
+        f.strand = 0;
+      } else {
+        f.strand = undefined;
+      }
+
+      f.phase = Number(data.phase);
+      f.refName = data.seq_id;
+
+      if (data.score === null) {
+        delete f.score;
+      }
+
+      if (data.phase === null) {
+        delete f.score;
+      }
+
+      var defaultFields = ['start', 'end', 'seq_id', 'score', 'type', 'source', 'phase', 'strand'];
+      var dataAttributes = data.attributes || {};
+      Object.keys(dataAttributes).forEach(function (a) {
+        var b = a.toLowerCase();
+
+        if (defaultFields.includes(b)) {
+          // add "suffix" to tag name if it already exists
+          // reproduces behavior of NCList
+          b += '2';
+        }
+
+        if (dataAttributes[a] !== null) {
+          var attr = dataAttributes[a];
+
+          if (Array.isArray(attr) && attr.length === 1) {
+            ;
+            var _attr = attr;
+
+            var _attr2 = (0, _slicedToArray2["default"])(_attr, 1);
+
+            attr = _attr2[0];
+          }
+
+          f[b] = attr;
+        }
+      });
+      f.refName = f.seq_id; // the SimpleFeature constructor takes care of recursively inflating subfeatures
+
+      if (data.child_features && data.child_features.length) {
+        f.subfeatures = data.child_features.map(function (childLocs) {
+          return childLocs.map(function (childLoc) {
+            return _this5.featureData(childLoc);
+          });
+        }).flat();
+      }
+
+      delete f.child_features;
+      delete f.data;
+      delete f.derived_features;
+      delete f._linehash;
+      delete f.attributes;
+      delete f.seq_id;
+      return f;
+    }
+  }, {
+    key: "freeResources",
+    value: function
+      /* { region } */
+    freeResources() {}
+  }]);
+  return _default;
+}(_BaseAdapter.BaseFeatureDataAdapter);
+
+exports["default"] = _default;

package/dist/Gff3TabixAdapter/Gff3TabixAdapter.test.js

@@ -0,0 +1,74 @@
+"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 _configSchema = _interopRequireDefault(require("./configSchema"));
+
+var _Gff3TabixAdapter = _interopRequireDefault(require("./Gff3TabixAdapter"));
+
+describe('adapter can fetch features from volvox.gff3', function () {
+  var adapter;
+  beforeEach(function () {
+    adapter = new _Gff3TabixAdapter["default"](_configSchema["default"].create({
+      gffGzLocation: {
+        localPath: require.resolve('../test_data/volvox.sort.gff3.gz')
+      },
+      index: {
+        location: {
+          localPath: require.resolve('../test_data/volvox.sort.gff3.gz.tbi')
+        }
+      }
+    }));
+  });
+  it('test getfeatures on gff plain text adapter', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var features, featuresArray, featuresJsonArray;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            features = adapter.getFeatures({
+              refName: 'ctgB',
+              start: 0,
+              end: 200000,
+              assemblyName: 'volvox'
+            });
+            _context.t0 = expect;
+            _context.next = 4;
+            return adapter.hasDataForRefName('ctgA');
+
+          case 4:
+            _context.t1 = _context.sent;
+            (0, _context.t0)(_context.t1).toBe(true);
+            _context.t2 = expect;
+            _context.next = 9;
+            return adapter.hasDataForRefName('ctgB');
+
+          case 9:
+            _context.t3 = _context.sent;
+            (0, _context.t2)(_context.t3).toBe(true);
+            _context.next = 13;
+            return features.pipe((0, _operators.toArray)()).toPromise();
+
+          case 13:
+            featuresArray = _context.sent;
+            // There are only 4 features in ctgB
+            expect(featuresArray.length).toBe(4);
+            featuresJsonArray = featuresArray.map(function (f) {
+              return f.toJSON();
+            });
+            expect(featuresJsonArray).toMatchSnapshot();
+
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+});

package/dist/Gff3TabixAdapter/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/Gff3TabixAdapter/configSchema.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _default = (0, _configuration.ConfigurationSchema)('Gff3TabixAdapter', {
+  gffGzLocation: {
+    type: 'fileLocation',
+    defaultValue: {
+      uri: '/path/to/my.gff.gz',
+      locationType: 'UriLocation'
+    }
+  },
+  index: (0, _configuration.ConfigurationSchema)('Gff3TabixIndex', {
+    indexType: {
+      model: _mobxStateTree.types.enumeration('IndexType', ['TBI', 'CSI']),
+      type: 'stringEnum',
+      defaultValue: 'TBI'
+    },
+    location: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/my.gff.gz.tbi',
+        locationType: 'UriLocation'
+      }
+    }
+  }),
+  dontRedispatch: {
+    type: 'stringArray',
+    defaultValue: ['chromosome', 'region']
+  }
+}, {
+  explicitlyTyped: true
+});
+
+exports["default"] = _default;

package/dist/Gff3TabixAdapter/index.d.ts

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

package/dist/Gff3TabixAdapter/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/index.d.ts

@@ -1,6 +1,6 @@
-import PluginManager from '@jbrowse/core/PluginManager';
-import Plugin from '@jbrowse/core/Plugin';
-export default class extends Plugin {
-    name: string;
-    install(pluginManager: PluginManager): void;
-}
+import PluginManager from '@jbrowse/core/PluginManager';
+import Plugin from '@jbrowse/core/Plugin';
+export default class extends Plugin {
+    name: string;
+    install(pluginManager: PluginManager): void;
+}