@jbrowse/plugin-gff3 1.4.3 → 1.5.2

package/dist/plugin-gff3.esm.js

@@ -2,6 +2,7 @@ import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
 import Plugin from '@jbrowse/core/Plugin';
 import { types } from 'mobx-state-tree';
 import { ConfigurationSchema, readConfObject } from '@jbrowse/core/configuration';
+import { getFileName, makeIndex, makeIndexType } from '@jbrowse/core/util/tracks';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { doesIntersect2 } from '@jbrowse/core/util/range';
 import { openLocation } from '@jbrowse/core/util/io';
@@ -9,6 +10,8 @@ import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
 import { TabixIndexedFile } from '@gmod/tabix';
 import gff from '@gmod/gff';
+import IntervalTree from '@flatten-js/interval-tree';
+import { unzip } from '@gmod/bgzf-filehandle';
 
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
@@ -176,6 +179,8 @@ function _assertThisInitialized(self) {
 function _possibleConstructorReturn(self, call) {
   if (call && (typeof call === "object" || typeof call === "function")) {
     return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
   }
 
   return _assertThisInitialized(self);
@@ -263,7 +268,8 @@ var gff3TabixAdapterConfigSchema = /*#__PURE__*/ConfigurationSchema('Gff3TabixAd
   gffGzLocation: {
     type: 'fileLocation',
     defaultValue: {
-      uri: '/path/to/my.gff.gz'
+      uri: '/path/to/my.gff.gz',
+      locationType: 'UriLocation'
     }
   },
   index: /*#__PURE__*/ConfigurationSchema('Gff3TabixIndex', {
@@ -275,7 +281,8 @@ var gff3TabixAdapterConfigSchema = /*#__PURE__*/ConfigurationSchema('Gff3TabixAd
     location: {
       type: 'fileLocation',
       defaultValue: {
-        uri: '/path/to/my.gff.gz.tbi'
+        uri: '/path/to/my.gff.gz.tbi',
+        locationType: 'UriLocation'
       }
     }
   }),
@@ -287,6 +294,18 @@ var gff3TabixAdapterConfigSchema = /*#__PURE__*/ConfigurationSchema('Gff3TabixAd
   explicitlyTyped: true
 });
 
+var gff3AdapterConfigSchema = /*#__PURE__*/ConfigurationSchema('Gff3Adapter', {
+  gffLocation: {
+    type: 'fileLocation',
+    defaultValue: {
+      uri: '/path/to/my.gff',
+      locationType: 'UriLocation'
+    }
+  }
+}, {
+  explicitlyTyped: true
+});
+
 var _default = /*#__PURE__*/function (_Plugin) {
   _inherits(_default, _Plugin);
 
@@ -298,7 +317,7 @@ var _default = /*#__PURE__*/function (_Plugin) {
     _classCallCheck(this, _default);
 
     _this = _super.apply(this, arguments);
-    _this.name = 'GFF3TabixPlugin';
+    _this.name = 'GFF3Plugin';
     return _this;
   }
 
@@ -316,6 +335,55 @@ var _default = /*#__PURE__*/function (_Plugin) {
           }
         });
       });
+      pluginManager.addToExtensionPoint('Core-guessAdapterForLocation', function (adapterGuesser) {
+        return function (file, index, adapterHint) {
+          var regexGuess = /\.gff3?\.b?gz$/i;
+          var adapterName = 'Gff3TabixAdapter';
+          var fileName = getFileName(file);
+          var indexName = index && getFileName(index);
+
+          if (regexGuess.test(fileName) || adapterHint === adapterName) {
+            return {
+              type: adapterName,
+              bamLocation: file,
+              gffGzLocation: file,
+              index: {
+                location: index || makeIndex(file, '.tbi'),
+                indexType: makeIndexType(indexName, 'CSI', 'TBI')
+              }
+            };
+          }
+
+          return adapterGuesser(file, index, adapterHint);
+        };
+      });
+      pluginManager.addAdapterType(function () {
+        return new AdapterType({
+          name: 'Gff3Adapter',
+          configSchema: gff3AdapterConfigSchema,
+          getAdapterClass: function getAdapterClass() {
+            return Promise.resolve().then(function () { return Gff3Adapter; }).then(function (r) {
+              return r["default"];
+            });
+          }
+        });
+      });
+      pluginManager.addToExtensionPoint('Core-guessAdapterForLocation', function (adapterGuesser) {
+        return function (file, index, adapterHint) {
+          var regexGuess = /\.gff3?$/i;
+          var adapterName = 'Gff3Adapter';
+          var fileName = getFileName(file);
+
+          if (regexGuess.test(fileName) || adapterHint === adapterName) {
+            return {
+              type: adapterName,
+              gffLocation: file
+            };
+          }
+
+          return adapterGuesser(file, index, adapterHint);
+        };
+      });
     }
   }]);
 
@@ -419,11 +487,9 @@ var runtime_1 = /*#__PURE__*/createCommonjsModule(function (module) {
 
 
     var IteratorPrototype = {};
-
-    IteratorPrototype[iteratorSymbol] = function () {
+    define(IteratorPrototype, iteratorSymbol, function () {
       return this;
-    };
-
+    });
     var getProto = Object.getPrototypeOf;
     var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
 
@@ -434,8 +500,9 @@ var runtime_1 = /*#__PURE__*/createCommonjsModule(function (module) {
     }
 
     var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-    GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
-    GeneratorFunctionPrototype.constructor = GeneratorFunction;
+    GeneratorFunction.prototype = GeneratorFunctionPrototype;
+    define(Gp, "constructor", GeneratorFunctionPrototype);
+    define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
     GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"); // Helper for defining the .next, .throw, and .return methods of the
     // Iterator interface in terms of a single ._invoke method.
 
@@ -540,11 +607,9 @@ var runtime_1 = /*#__PURE__*/createCommonjsModule(function (module) {
     }
 
     defineIteratorMethods(AsyncIterator.prototype);
-
-    AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+    define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
       return this;
-    };
-
+    });
     exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of
     // AsyncIterator objects; they just return a Promise for the value of
     // the final result produced by the iterator.
@@ -721,13 +786,12 @@ var runtime_1 = /*#__PURE__*/createCommonjsModule(function (module) {
     // object to not be returned from this call. This ensures that doesn't happen.
     // See https://github.com/facebook/regenerator/issues/274 for more details.
 
-    Gp[iteratorSymbol] = function () {
+    define(Gp, iteratorSymbol, function () {
       return this;
-    };
-
-    Gp.toString = function () {
+    });
+    define(Gp, "toString", function () {
       return "[object Generator]";
-    };
+    });
 
     function pushTryEntry(locs) {
       var entry = {
@@ -1039,14 +1103,19 @@ var runtime_1 = /*#__PURE__*/createCommonjsModule(function (module) {
   } catch (accidentalStrictMode) {
     // This module should not be running in strict mode, so the above
     // assignment should always work unless something is misconfigured. Just
-    // in case runtime.js accidentally runs in strict mode, we can escape
+    // in case runtime.js accidentally runs in strict mode, in modern engines
+    // we can explicitly access globalThis. In older engines we can escape
     // strict mode using a global Function call. This could conceivably fail
     // if a Content Security Policy forbids using Function, but in that case
     // the proper solution is to fix the accidental strict mode problem. If
     // you've misconfigured your bundler to force strict mode and applied a
     // CSP to forbid Function, and you're not willing to fix either of those
     // problems, please detail your unique predicament in a GitHub issue.
-    Function("r", "regeneratorRuntime = r")(runtime);
+    if (typeof globalThis === "object") {
+      globalThis.regeneratorRuntime = runtime;
+    } else {
+      Function("r", "regeneratorRuntime = r")(runtime);
+    }
   }
 });
 
@@ -1055,21 +1124,21 @@ var _default$1 = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
 
   var _super = /*#__PURE__*/_createSuper(_default);
 
-  function _default(config) {
+  function _default(config, getSubAdapter, pluginManager) {
     var _this;
 
     _classCallCheck(this, _default);
 
-    _this = _super.call(this, config);
+    _this = _super.call(this, config, getSubAdapter, pluginManager);
     var gffGzLocation = readConfObject(config, 'gffGzLocation');
     var indexType = readConfObject(config, ['index', 'indexType']);
     var location = readConfObject(config, ['index', 'location']);
     var dontRedispatch = readConfObject(config, 'dontRedispatch');
     _this.dontRedispatch = dontRedispatch || ['chromosome', 'contig', 'region'];
     _this.gff = new TabixIndexedFile({
-      filehandle: openLocation(gffGzLocation),
-      csiFilehandle: indexType === 'CSI' ? openLocation(location) : undefined,
-      tbiFilehandle: indexType !== 'CSI' ? openLocation(location) : undefined,
+      filehandle: openLocation(gffGzLocation, _this.pluginManager),
+      csiFilehandle: indexType === 'CSI' ? openLocation(location, _this.pluginManager) : undefined,
+      tbiFilehandle: indexType !== 'CSI' ? openLocation(location, _this.pluginManager) : undefined,
       chunkCacheSize: 50 * Math.pow(2, 20),
       renameRefSeqs: function renameRefSeqs(n) {
         return n;
@@ -1226,9 +1295,6 @@ var _default$1 = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
                   break;
                 }
 
-                // console.log(
-                //   `redispatching ${query.start}-${query.end} => ${minStart}-${maxEnd}`,
-                // )
                 // make a new feature callback to only return top-level features
                 // in the original query range
                 this.getFeaturesHelper(_objectSpread2(_objectSpread2({}, query), {}, {
@@ -1380,9 +1446,9 @@ var _default$1 = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
     }
   }, {
     key: "freeResources",
-    value: function freeResources()
-    /* { region } */
-    {}
+    value: function
+      /* { region } */
+    freeResources() {}
   }]);
 
   return _default;
@@ -1393,5 +1459,343 @@ var Gff3TabixAdapter = {
   'default': _default$1
 };
 
+function isGzip(buf) {
+  return buf[0] === 31 && buf[1] === 139 && buf[2] === 8;
+}
+
+var _default$2 = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
+  _inherits(_default, _BaseFeatureDataAdapt);
+
+  var _super = /*#__PURE__*/_createSuper(_default);
+
+  function _default() {
+    _classCallCheck(this, _default);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(_default, [{
+    key: "loadDataP",
+    value: function () {
+      var _loadDataP = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
+        var _this = this;
+
+        var buffer, buf, data, lines, headerLines, i, header, feats, intervalTree;
+        return runtime_1.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return openLocation(readConfObject(this.config, 'gffLocation'), this.pluginManager).readFile();
+
+              case 2:
+                buffer = _context.sent;
+
+                if (!isGzip(buffer)) {
+                  _context.next = 9;
+                  break;
+                }
+
+                _context.next = 6;
+                return unzip(buffer);
+
+              case 6:
+                _context.t0 = _context.sent;
+                _context.next = 10;
+                break;
+
+              case 9:
+                _context.t0 = buffer;
+
+              case 10:
+                buf = _context.t0;
+
+                if (!(buf.length > 536870888)) {
+                  _context.next = 13;
+                  break;
+                }
+
+                throw new Error('Data exceeds maximum string length (512MB)');
+
+              case 13:
+                data = new TextDecoder('utf8', {
+                  fatal: true
+                }).decode(buf);
+                lines = data.split('\n');
+                headerLines = [];
+
+                for (i = 0; i < lines.length && lines[i].startsWith('#'); i++) {
+                  headerLines.push(lines[i]);
+                }
+
+                header = headerLines.join('\n');
+                feats = gff.parseStringSync(data, {
+                  parseFeatures: true,
+                  parseComments: false,
+                  parseDirectives: false,
+                  parseSequences: false
+                });
+                intervalTree = feats.flat().map(function (f, i) {
+                  return new SimpleFeature({
+                    data: _this.featureData(f),
+                    id: "".concat(_this.id, "-offset-").concat(i)
+                  });
+                }).reduce(function (acc, obj) {
+                  var key = obj.get('refName');
+
+                  if (!acc[key]) {
+                    acc[key] = new IntervalTree();
+                  }
+
+                  acc[key].insert([obj.get('start'), obj.get('end')], obj);
+                  return acc;
+                }, {});
+                return _context.abrupt("return", {
+                  header: header,
+                  intervalTree: intervalTree
+                });
+
+              case 21:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function loadDataP() {
+        return _loadDataP.apply(this, arguments);
+      }
+
+      return loadDataP;
+    }()
+  }, {
+    key: "loadData",
+    value: function () {
+      var _loadData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2() {
+        var _this2 = this;
+
+        return runtime_1.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!this.gffFeatures) {
+                  this.gffFeatures = this.loadDataP()["catch"](function (e) {
+                    _this2.gffFeatures = undefined;
+                    throw e;
+                  });
+                }
+
+                return _context2.abrupt("return", this.gffFeatures);
+
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function loadData() {
+        return _loadData.apply(this, arguments);
+      }
+
+      return loadData;
+    }()
+  }, {
+    key: "getRefNames",
+    value: function () {
+      var _getRefNames = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3() {
+        var _yield$this$loadData,
+            intervalTree;
+
+        return runtime_1.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 3;
+                return this.loadData();
+
+              case 3:
+                _yield$this$loadData = _context3.sent;
+                intervalTree = _yield$this$loadData.intervalTree;
+                return _context3.abrupt("return", Object.keys(intervalTree));
+
+              case 6:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function getRefNames() {
+        return _getRefNames.apply(this, arguments);
+      }
+
+      return getRefNames;
+    }()
+  }, {
+    key: "getHeader",
+    value: function () {
+      var _getHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
+        var _yield$this$loadData2, header;
+
+        return runtime_1.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return this.loadData();
+
+              case 2:
+                _yield$this$loadData2 = _context4.sent;
+                header = _yield$this$loadData2.header;
+                return _context4.abrupt("return", header);
+
+              case 5:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function getHeader() {
+        return _getHeader.apply(this, arguments);
+      }
+
+      return getHeader;
+    }()
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(query) {
+      var _this3 = this;
+
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return ObservableCreate( /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(observer) {
+          var _intervalTree$refName, start, end, refName, _yield$_this3$loadDat, intervalTree;
+
+          return runtime_1.wrap(function _callee5$(_context5) {
+            while (1) {
+              switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.prev = 0;
+                  start = query.start, end = query.end, refName = query.refName;
+                  _context5.next = 4;
+                  return _this3.loadData();
+
+                case 4:
+                  _yield$_this3$loadDat = _context5.sent;
+                  intervalTree = _yield$_this3$loadDat.intervalTree;
+                  (_intervalTree$refName = intervalTree[refName]) === null || _intervalTree$refName === void 0 ? void 0 : _intervalTree$refName.search([start, end]).forEach(function (f) {
+                    return observer.next(f);
+                  });
+                  observer.complete();
+                  _context5.next = 13;
+                  break;
+
+                case 10:
+                  _context5.prev = 10;
+                  _context5.t0 = _context5["catch"](0);
+                  observer.error(_context5.t0);
+
+                case 13:
+                case "end":
+                  return _context5.stop();
+              }
+            }
+          }, _callee5, null, [[0, 10]]);
+        }));
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }(), opts.signal);
+    }
+  }, {
+    key: "featureData",
+    value: function featureData(data) {
+      var _this4 = this;
+
+      var f = _objectSpread2({}, data);
+
+      f.start -= 1; // convert to interbase
+
+      f.strand = {
+        '+': 1,
+        '-': -1,
+        '.': 0,
+        '?': undefined
+      }[data.strand]; // convert strand
+
+      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'];
+      Object.keys(data.attributes).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 (data.attributes[a] !== null) {
+          var attr = data.attributes[a];
+
+          if (Array.isArray(attr) && attr.length === 1) {
+            var _attr = attr;
+
+            var _attr2 = _slicedToArray(_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 _this4.featureData(childLoc);
+          });
+        }).flat();
+      }
+
+      delete f.child_features;
+      delete f.data;
+      delete f.derived_features;
+      delete f.attributes;
+      delete f.seq_id;
+      return f;
+    }
+  }, {
+    key: "freeResources",
+    value: function
+      /* { region } */
+    freeResources() {}
+  }]);
+
+  return _default;
+}(BaseFeatureDataAdapter);
+
+var Gff3Adapter = {
+  __proto__: null,
+  'default': _default$2
+};
+
 export default _default;
 //# sourceMappingURL=plugin-gff3.esm.js.map