@jbrowse/plugin-gtf 1.7.4 → 1.7.7

package/dist/GtfAdapter/GtfAdapter.d.ts

@@ -4,11 +4,18 @@ import IntervalTree from '@flatten-js/interval-tree';
 import { Feature } from '@jbrowse/core/util/simpleFeature';
 export default class extends BaseFeatureDataAdapter {
     protected gtfFeatures?: Promise<{
-        intervalTree: Record<string, IntervalTree>;
+        feats: {
+            [key: string]: string[];
+        };
     }>;
+    protected intervalTrees: {
+        [key: string]: Promise<IntervalTree | undefined> | undefined;
+    };
     private loadDataP;
     private loadData;
     getRefNames(opts?: BaseOptions): Promise<string[]>;
+    private loadFeatureIntervalTreeHelper;
+    private loadFeatureIntervalTree;
     getFeatures(query: NoAssemblyRegion, opts?: BaseOptions): import("rxjs").Observable<Feature>;
     freeResources(): void;
 }

package/dist/GtfAdapter/GtfAdapter.js

@@ -27,8 +27,6 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _BaseAdapter = require("@jbrowse/core/data_adapters/BaseAdapter");
 
-var _configuration = require("@jbrowse/core/configuration");
-
 var _io = require("@jbrowse/core/util/io");
 
 var _rxjs = require("@jbrowse/core/util/rxjs");
@@ -67,6 +65,7 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
 
     _this = _super.call.apply(_super, [this].concat(args));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gtfFeatures", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "intervalTrees", {});
     return _this;
   }
 
@@ -74,15 +73,13 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
     key: "loadDataP",
     value: function () {
       var _loadDataP = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var _this2 = this;
-
-        var buffer, buf, data, feats, intervalTree;
+        var buffer, buf, data, lines, feats, i, refName;
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
                 _context.next = 2;
-                return (0, _io.openLocation)((0, _configuration.readConfObject)(this.config, 'gtfLocation'), this.pluginManager).readFile();
+                return (0, _io.openLocation)(this.getConf('gtfLocation'), this.pluginManager).readFile();
 
               case 2:
                 buffer = _context.sent;
@@ -117,32 +114,26 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
                 data = new TextDecoder('utf8', {
                   fatal: true
                 }).decode(buf);
-                feats = _gtf.default.parseStringSync(data, {
-                  parseFeatures: true,
-                  parseComments: false,
-                  parseDirectives: false,
-                  parseSequences: false
+                lines = data.split('\n').filter(function (f) {
+                  return !!f && !f.startsWith('#');
                 });
-                intervalTree = feats.flat().map(function (f, i) {
-                  return new _simpleFeature.default({
-                    data: (0, _util.featureData)(f),
-                    id: "".concat(_this2.id, "-offset-").concat(i)
-                  });
-                }).reduce(function (acc, obj) {
-                  var key = obj.get('refName');
+                feats = {};
+
+                for (i = 0; i < lines.length; i++) {
+                  refName = lines[i].split('\t')[0];
 
-                  if (!acc[key]) {
-                    acc[key] = new _intervalTree.default();
+                  if (!feats[refName]) {
+                    feats[refName] = [];
                   }
 
-                  acc[key].insert([obj.get('start'), obj.get('end')], obj);
-                  return acc;
-                }, {});
+                  feats[refName].push(lines[i]);
+                }
+
                 return _context.abrupt("return", {
-                  intervalTree: intervalTree
+                  feats: feats
                 });
 
-              case 17:
+              case 18:
               case "end":
                 return _context.stop();
             }
@@ -160,7 +151,7 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
     key: "loadData",
     value: function () {
       var _loadData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
-        var _this3 = this;
+        var _this2 = this;
 
         return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) {
@@ -168,7 +159,7 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
               case 0:
                 if (!this.gtfFeatures) {
                   this.gtfFeatures = this.loadDataP().catch(function (e) {
-                    _this3.gtfFeatures = undefined;
+                    _this2.gtfFeatures = undefined;
                     throw e;
                   });
                 }
@@ -195,7 +186,7 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
       var _getRefNames = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
         var opts,
             _yield$this$loadData,
-            intervalTree,
+            feats,
             _args3 = arguments;
 
         return _regenerator.default.wrap(function _callee3$(_context3) {
@@ -208,8 +199,8 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
 
               case 3:
                 _yield$this$loadData = _context3.sent;
-                intervalTree = _yield$this$loadData.intervalTree;
-                return _context3.abrupt("return", Object.keys(intervalTree));
+                feats = _yield$this$loadData.feats;
+                return _context3.abrupt("return", Object.keys(feats));
 
               case 6:
               case "end":
@@ -225,49 +216,143 @@ var _default = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
 
       return getRefNames;
     }()
+  }, {
+    key: "loadFeatureIntervalTreeHelper",
+    value: function () {
+      var _loadFeatureIntervalTreeHelper = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(refName) {
+        var _this3 = this;
+
+        var _yield$this$loadData2, feats, lines, data, intervalTree, ret, i, obj;
+
+        return _regenerator.default.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;
+                feats = _yield$this$loadData2.feats;
+                lines = feats[refName];
+
+                if (lines) {
+                  _context4.next = 7;
+                  break;
+                }
+
+                return _context4.abrupt("return", undefined);
+
+              case 7:
+                data = _gtf.default.parseStringSync(lines.join('\n'), {
+                  parseFeatures: true,
+                  parseComments: false,
+                  parseDirectives: false,
+                  parseSequences: false
+                });
+                intervalTree = new _intervalTree.default();
+                ret = data.flat().map(function (f, i) {
+                  return new _simpleFeature.default({
+                    data: (0, _util.featureData)(f),
+                    id: "".concat(_this3.id, "-offset-").concat(i)
+                  });
+                });
+
+                for (i = 0; i < ret.length; i++) {
+                  obj = ret[i];
+                  intervalTree.insert([obj.get('start'), obj.get('end')], obj);
+                }
+
+                return _context4.abrupt("return", intervalTree);
+
+              case 12:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function loadFeatureIntervalTreeHelper(_x) {
+        return _loadFeatureIntervalTreeHelper.apply(this, arguments);
+      }
+
+      return loadFeatureIntervalTreeHelper;
+    }()
+  }, {
+    key: "loadFeatureIntervalTree",
+    value: function () {
+      var _loadFeatureIntervalTree = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(refName) {
+        var _this4 = this;
+
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                if (!this.intervalTrees[refName]) {
+                  this.intervalTrees[refName] = this.loadFeatureIntervalTreeHelper(refName).catch(function (e) {
+                    _this4.intervalTrees[refName] = undefined;
+                    throw e;
+                  });
+                }
+
+                return _context5.abrupt("return", this.intervalTrees[refName]);
+
+              case 2:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function loadFeatureIntervalTree(_x2) {
+        return _loadFeatureIntervalTree.apply(this, arguments);
+      }
+
+      return loadFeatureIntervalTree;
+    }()
   }, {
     key: "getFeatures",
     value: function getFeatures(query) {
-      var _this4 = this;
+      var _this5 = 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 _callee4(observer) {
-          var _intervalTree$refName, start, end, refName, _yield$_this4$loadDat, intervalTree;
-
-          return _regenerator.default.wrap(function _callee4$(_context4) {
+        var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(observer) {
+          var start, end, refName, intervalTree;
+          return _regenerator.default.wrap(function _callee6$(_context6) {
             while (1) {
-              switch (_context4.prev = _context4.next) {
+              switch (_context6.prev = _context6.next) {
                 case 0:
-                  _context4.prev = 0;
+                  _context6.prev = 0;
                   start = query.start, end = query.end, refName = query.refName;
-                  _context4.next = 4;
-                  return _this4.loadData();
+                  _context6.next = 4;
+                  return _this5.loadFeatureIntervalTree(refName);
 
                 case 4:
-                  _yield$_this4$loadDat = _context4.sent;
-                  intervalTree = _yield$_this4$loadDat.intervalTree;
-                  (_intervalTree$refName = intervalTree[refName]) === null || _intervalTree$refName === void 0 ? void 0 : _intervalTree$refName.search([start, end]).forEach(function (f) {
+                  intervalTree = _context6.sent;
+                  intervalTree === null || intervalTree === void 0 ? void 0 : intervalTree.search([start, end]).forEach(function (f) {
                     return observer.next(f);
                   });
                   observer.complete();
-                  _context4.next = 13;
+                  _context6.next = 12;
                   break;
 
-                case 10:
-                  _context4.prev = 10;
-                  _context4.t0 = _context4["catch"](0);
-                  observer.error(_context4.t0);
+                case 9:
+                  _context6.prev = 9;
+                  _context6.t0 = _context6["catch"](0);
+                  observer.error(_context6.t0);
 
-                case 13:
+                case 12:
                 case "end":
-                  return _context4.stop();
+                  return _context6.stop();
               }
             }
-          }, _callee4, null, [[0, 10]]);
+          }, _callee6, null, [[0, 9]]);
         }));
 
-        return function (_x) {
+        return function (_x3) {
           return _ref.apply(this, arguments);
         };
       }(), opts.signal);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-gtf",
-  "version": "1.7.4",
+  "version": "1.7.7",
   "description": "JBrowse 2 gtf feature adapter",
   "keywords": [
     "jbrowse",
@@ -51,5 +51,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "0a3e0c58055bbab8e3ab0270c139291b96eff403"
+  "gitHead": "2c26e04ae942c380bf2f5b79ef7a49cc32b7bfed"
 }

package/src/GtfAdapter/GtfAdapter.ts

@@ -3,13 +3,11 @@ import {
   BaseOptions,
 } from '@jbrowse/core/data_adapters/BaseAdapter'
 import { NoAssemblyRegion } from '@jbrowse/core/util/types'
-import { readConfObject } from '@jbrowse/core/configuration'
 import { openLocation } from '@jbrowse/core/util/io'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import IntervalTree from '@flatten-js/interval-tree'
 import SimpleFeature, { Feature } from '@jbrowse/core/util/simpleFeature'
 import { unzip } from '@gmod/bgzf-filehandle'
-
 import gtf from '@gmod/gtf'
 import { FeatureLoc, featureData } from '../util'
 function isGzip(buf: Buffer) {
@@ -18,12 +16,16 @@ function isGzip(buf: Buffer) {
 
 export default class extends BaseFeatureDataAdapter {
   protected gtfFeatures?: Promise<{
-    intervalTree: Record<string, IntervalTree>
+    feats: { [key: string]: string[] }
   }>
 
+  protected intervalTrees: {
+    [key: string]: Promise<IntervalTree | undefined> | undefined
+  } = {}
+
   private async loadDataP() {
     const buffer = await openLocation(
-      readConfObject(this.config, 'gtfLocation'),
+      this.getConf('gtfLocation'),
       this.pluginManager,
     ).readFile()
 
@@ -33,31 +35,18 @@ export default class extends BaseFeatureDataAdapter {
       throw new Error('Data exceeds maximum string length (512MB)')
     }
     const data = new TextDecoder('utf8', { fatal: true }).decode(buf)
-    const feats = gtf.parseStringSync(data, {
-      parseFeatures: true,
-      parseComments: false,
-      parseDirectives: false,
-      parseSequences: false,
-    }) as FeatureLoc[][]
 
-    const intervalTree = feats
-      .flat()
-      .map(
-        (f, i) =>
-          new SimpleFeature({
-            data: featureData(f),
-            id: `${this.id}-offset-${i}`,
-          }),
-      )
-      .reduce((acc, obj) => {
-        const key = obj.get('refName')
-        if (!acc[key]) {
-          acc[key] = new IntervalTree()
-        }
-        acc[key].insert([obj.get('start'), obj.get('end')], obj)
-        return acc
-      }, {} as Record<string, IntervalTree>)
-    return { intervalTree }
+    const lines = data.split('\n').filter(f => !!f && !f.startsWith('#'))
+    const feats = {} as { [key: string]: string[] }
+    for (let i = 0; i < lines.length; i++) {
+      const refName = lines[i].split('\t')[0]
+      if (!feats[refName]) {
+        feats[refName] = []
+      }
+      feats[refName].push(lines[i])
+    }
+
+    return { feats }
   }
 
   private async loadData() {
@@ -72,18 +61,57 @@ export default class extends BaseFeatureDataAdapter {
   }
 
   public async getRefNames(opts: BaseOptions = {}) {
-    const { intervalTree } = await this.loadData()
-    return Object.keys(intervalTree)
+    const { feats } = await this.loadData()
+    return Object.keys(feats)
+  }
+
+  private async loadFeatureIntervalTreeHelper(refName: string) {
+    const { feats } = await this.loadData()
+    const lines = feats[refName]
+    if (!lines) {
+      return undefined
+    }
+    const data = gtf.parseStringSync(lines.join('\n'), {
+      parseFeatures: true,
+      parseComments: false,
+      parseDirectives: false,
+      parseSequences: false,
+    }) as FeatureLoc[][]
+
+    const intervalTree = new IntervalTree()
+    const ret = data.flat().map(
+      (f, i) =>
+        new SimpleFeature({
+          data: featureData(f),
+          id: `${this.id}-offset-${i}`,
+        }),
+    )
+
+    for (let i = 0; i < ret.length; i++) {
+      const obj = ret[i]
+      intervalTree.insert([obj.get('start'), obj.get('end')], obj)
+    }
+    return intervalTree
+  }
+
+  private async loadFeatureIntervalTree(refName: string) {
+    if (!this.intervalTrees[refName]) {
+      this.intervalTrees[refName] = this.loadFeatureIntervalTreeHelper(
+        refName,
+      ).catch(e => {
+        this.intervalTrees[refName] = undefined
+        throw e
+      })
+    }
+    return this.intervalTrees[refName]
   }
 
   public getFeatures(query: NoAssemblyRegion, opts: BaseOptions = {}) {
     return ObservableCreate<Feature>(async observer => {
       try {
         const { start, end, refName } = query
-        const { intervalTree } = await this.loadData()
-        intervalTree[refName]
-          ?.search([start, end])
-          .forEach(f => observer.next(f))
+        const intervalTree = await this.loadFeatureIntervalTree(refName)
+        intervalTree?.search([start, end]).forEach(f => observer.next(f))
         observer.complete()
       } catch (e) {
         observer.error(e)