@jbrowse/plugin-bed 1.5.9 → 1.6.3

package/dist/BedTabixAdapter/BedTabixAdapter.d.ts

@@ -2,9 +2,8 @@ import { BaseFeatureDataAdapter, BaseOptions } from '@jbrowse/core/data_adapters
 import { Region } from '@jbrowse/core/util/types';
 import { Feature } from '@jbrowse/core/util/simpleFeature';
 import { TabixIndexedFile } from '@gmod/tabix';
-import { Instance } from 'mobx-state-tree';
-import MyConfigSchema from './configSchema';
 import PluginManager from '@jbrowse/core/PluginManager';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration/configurationSchema';
 import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
 export default class BedTabixAdapter extends BaseFeatureDataAdapter {
     private parser;
@@ -12,7 +11,7 @@ export default class BedTabixAdapter extends BaseFeatureDataAdapter {
     protected columnNames: string[];
     protected scoreColumn: string;
     static capabilities: string[];
-    constructor(config: Instance<typeof MyConfigSchema>, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
+    constructor(config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
     getRefNames(opts?: BaseOptions): Promise<any>;
     getHeader(): Promise<string>;
     defaultParser(fields: string[], line: string): {

package/dist/BigBedAdapter/BigBedAdapter.d.ts

@@ -1,24 +1,46 @@
+import { BigBed } from '@gmod/bbi';
 import { BaseFeatureDataAdapter, BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { Region } from '@jbrowse/core/util/types';
 import { Feature } from '@jbrowse/core/util/simpleFeature';
-import { Instance } from 'mobx-state-tree';
-import configSchema from './configSchema';
-import PluginManager from '@jbrowse/core/PluginManager';
-import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
+interface BEDFeature {
+    chrom: string;
+    chromStart: number;
+    chromEnd: number;
+    [key: string]: any;
+}
+interface Parser {
+    parseLine: (line: string, opts: {
+        uniqueId: string | number;
+    }) => BEDFeature;
+    autoSql: {
+        fields: {
+            name: string;
+            comment: string;
+        }[];
+    };
+}
 export default class BigBedAdapter extends BaseFeatureDataAdapter {
-    private bigbed;
-    private parser;
-    constructor(config: Instance<typeof configSchema>, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
-    getRefNames(): Promise<string[]>;
+    private cached?;
+    configurePre(opts?: BaseOptions): Promise<{
+        bigbed: BigBed;
+        header: any;
+        parser: Parser;
+    }>;
+    configure(opts?: BaseOptions): Promise<{
+        bigbed: BigBed;
+        header: any;
+        parser: Parser;
+    }>;
+    getRefNames(opts?: BaseOptions): Promise<string[]>;
     getHeader(opts?: BaseOptions): Promise<{
         version: any;
         fileType: any;
-        autoSql: any;
+        autoSql: {};
         fields: {
-            [k: string]: any;
+            [k: string]: string;
         };
     }>;
-    refIdToName(refId: number): Promise<any>;
     getFeatures(region: Region, opts?: BaseOptions): import("rxjs").Observable<Feature>;
     freeResources(): void;
 }
+export {};

package/dist/plugin-bed.cjs.development.js

@@ -125,14 +125,14 @@ function _inherits(subClass, superClass) {
     throw new TypeError("Super expression must either be null or a function");
   }
 
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
   Object.defineProperty(subClass, "prototype", {
-    value: Object.create(superClass && superClass.prototype, {
-      constructor: {
-        value: subClass,
-        writable: true,
-        configurable: true
-      }
-    }),
     writable: false
   });
   if (superClass) _setPrototypeOf(subClass, superClass);
@@ -327,12 +327,15 @@ var BedPlugin = /*#__PURE__*/function (_Plugin) {
           var regexGuess = /\.(bb|bigbed)$/i;
           var adapterName = 'BigBedAdapter';
           var fileName = tracks.getFileName(file);
+          var obj = {
+            type: adapterName,
+            bigBedLocation: file
+          };
 
-          if (regexGuess.test(fileName) || adapterHint === adapterName) {
-            return {
-              type: adapterName,
-              bigBedLocation: file
-            };
+          if (regexGuess.test(fileName) && !adapterHint) {
+            return obj;
+          } else if (adapterHint === adapterName) {
+            return obj;
           }
 
           return adapterGuesser(file, index, adapterHint);
@@ -1222,47 +1225,48 @@ function ucscProcessedTranscript(feature) {
 var _excluded = ["fields"],
     _excluded2 = ["chromStart", "chromEnd", "chrom"];
 
+function isUCSC(f) {
+  return f.get('thickStart') && f.get('blockCount') && f.get('strand') !== 0;
+}
+
 var BigBedAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
   _inherits(BigBedAdapter, _BaseFeatureDataAdapt);
 
   var _super = /*#__PURE__*/_createSuper(BigBedAdapter);
 
-  function BigBedAdapter(config, getSubAdapter, pluginManager) {
-    var _this;
-
+  function BigBedAdapter() {
     _classCallCheck(this, BigBedAdapter);
 
-    _this = _super.call(this, config, getSubAdapter, pluginManager);
-    var bigBedLocation = configuration.readConfObject(config, 'bigBedLocation');
-    _this.bigbed = new bbi.BigBed({
-      filehandle: io.openLocation(bigBedLocation, _this.pluginManager)
-    });
-    _this.parser = _this.bigbed.getHeader().then(function (_ref) {
-      var autoSql = _ref.autoSql;
-      return new BED({
-        autoSql: autoSql
-      });
-    });
-    return _this;
+    return _super.apply(this, arguments);
   }
 
   _createClass(BigBedAdapter, [{
-    key: "getRefNames",
+    key: "configurePre",
     value: function () {
-      var _getRefNames = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
+      var _configurePre = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(opts) {
+        var bigbed, header, parser;
         return runtime_1.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
-                _context.t0 = Object;
+                bigbed = new bbi.BigBed({
+                  filehandle: io.openLocation(configuration.readConfObject(this.config, 'bigBedLocation'), this.pluginManager)
+                });
                 _context.next = 3;
-                return this.bigbed.getHeader();
+                return bigbed.getHeader(opts);
 
               case 3:
-                _context.t1 = _context.sent.refsByName;
-                return _context.abrupt("return", _context.t0.keys.call(_context.t0, _context.t1));
+                header = _context.sent;
+                parser = new BED({
+                  autoSql: header.autoSql
+                });
+                return _context.abrupt("return", {
+                  bigbed: bigbed,
+                  header: header,
+                  parser: parser
+                });
 
-              case 5:
+              case 6:
               case "end":
                 return _context.stop();
             }
@@ -1270,50 +1274,32 @@ var BigBedAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
         }, _callee, this);
       }));
 
-      function getRefNames() {
-        return _getRefNames.apply(this, arguments);
+      function configurePre(_x) {
+        return _configurePre.apply(this, arguments);
       }
 
-      return getRefNames;
+      return configurePre;
     }()
   }, {
-    key: "getHeader",
+    key: "configure",
     value: function () {
-      var _getHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(opts) {
-        var _yield$this$bigbed$ge, version, fileType, _yield$this$parser, autoSql, fields, rest, f;
+      var _configure = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(opts) {
+        var _this = this;
 
         return runtime_1.wrap(function _callee2$(_context2) {
           while (1) {
             switch (_context2.prev = _context2.next) {
               case 0:
-                _context2.next = 2;
-                return this.bigbed.getHeader(opts);
+                if (!this.cached) {
+                  this.cached = this.configurePre(opts)["catch"](function (e) {
+                    _this.cached = undefined;
+                    throw e;
+                  });
+                }
 
-              case 2:
-                _yield$this$bigbed$ge = _context2.sent;
-                version = _yield$this$bigbed$ge.version;
-                fileType = _yield$this$bigbed$ge.fileType;
-                _context2.next = 7;
-                return this.parser;
-
-              case 7:
-                _yield$this$parser = _context2.sent;
-                autoSql = _yield$this$parser.autoSql;
-                fields = autoSql.fields, rest = _objectWithoutProperties(autoSql, _excluded);
-                f = Object.fromEntries( // @ts-ignore
-                fields.map(function (_ref2) {
-                  var name = _ref2.name,
-                      comment = _ref2.comment;
-                  return [name, comment];
-                }));
-                return _context2.abrupt("return", {
-                  version: version,
-                  fileType: fileType,
-                  autoSql: _objectSpread2({}, rest),
-                  fields: f
-                });
+                return _context2.abrupt("return", this.cached);
 
-              case 12:
+              case 2:
               case "end":
                 return _context2.stop();
             }
@@ -1321,50 +1307,87 @@ var BigBedAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
         }, _callee2, this);
       }));
 
-      function getHeader(_x) {
-        return _getHeader.apply(this, arguments);
+      function configure(_x2) {
+        return _configure.apply(this, arguments);
       }
 
-      return getHeader;
+      return configure;
     }()
   }, {
-    key: "refIdToName",
+    key: "getRefNames",
     value: function () {
-      var _refIdToName = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(refId) {
+      var _getRefNames = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(opts) {
+        var _yield$this$configure, header;
+
         return runtime_1.wrap(function _callee3$(_context3) {
           while (1) {
             switch (_context3.prev = _context3.next) {
               case 0:
                 _context3.next = 2;
-                return this.bigbed.getHeader();
+                return this.configure(opts);
 
               case 2:
-                _context3.t1 = refId;
-                _context3.t0 = _context3.sent.refsByNumber[_context3.t1];
+                _yield$this$configure = _context3.sent;
+                header = _yield$this$configure.header;
+                return _context3.abrupt("return", Object.keys(header.refsByName));
 
-                if (_context3.t0) {
-                  _context3.next = 6;
-                  break;
-                }
+              case 5:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
 
-                _context3.t0 = {};
+      function getRefNames(_x3) {
+        return _getRefNames.apply(this, arguments);
+      }
 
-              case 6:
-                return _context3.abrupt("return", _context3.t0.name);
+      return getRefNames;
+    }()
+  }, {
+    key: "getHeader",
+    value: function () {
+      var _getHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(opts) {
+        var _yield$this$configure2, parser, header, version, fileType, _parser$autoSql, fields, rest;
 
-              case 7:
+        return runtime_1.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return this.configure(opts);
+
+              case 2:
+                _yield$this$configure2 = _context4.sent;
+                parser = _yield$this$configure2.parser;
+                header = _yield$this$configure2.header;
+                version = header.version, fileType = header.fileType;
+                _parser$autoSql = parser.autoSql, fields = _parser$autoSql.fields, rest = _objectWithoutProperties(_parser$autoSql, _excluded);
+                return _context4.abrupt("return", {
+                  version: version,
+                  fileType: fileType,
+                  autoSql: _objectSpread2({}, rest),
+                  fields: Object.fromEntries(fields.map(function (_ref) {
+                    var name = _ref.name,
+                        comment = _ref.comment;
+                    return [name, comment];
+                  }))
+                });
+
+              case 8:
               case "end":
-                return _context3.stop();
+                return _context4.stop();
             }
           }
-        }, _callee3, this);
+        }, _callee4, this);
       }));
 
-      function refIdToName(_x2) {
-        return _refIdToName.apply(this, arguments);
+      function getHeader(_x4) {
+        return _getHeader.apply(this, arguments);
       }
 
-      return refIdToName;
+      return getHeader;
     }()
   }, {
     key: "getFeatures",
@@ -1377,26 +1400,29 @@ var BigBedAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
           end = region.end;
       var signal = opts.signal;
       return rxjs.ObservableCreate( /*#__PURE__*/function () {
-        var _ref3 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(observer) {
-          var parser, ob;
-          return runtime_1.wrap(function _callee4$(_context4) {
+        var _ref2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(observer) {
+          var _yield$_this2$configu, parser, bigbed, ob;
+
+          return runtime_1.wrap(function _callee5$(_context5) {
             while (1) {
-              switch (_context4.prev = _context4.next) {
+              switch (_context5.prev = _context5.next) {
                 case 0:
-                  _context4.prev = 0;
-                  _context4.next = 3;
-                  return _this2.parser;
+                  _context5.prev = 0;
+                  _context5.next = 3;
+                  return _this2.configure(opts);
 
                 case 3:
-                  parser = _context4.sent;
-                  _context4.next = 6;
-                  return _this2.bigbed.getFeatureStream(refName, start, end, {
+                  _yield$_this2$configu = _context5.sent;
+                  parser = _yield$_this2$configu.parser;
+                  bigbed = _yield$_this2$configu.bigbed;
+                  _context5.next = 8;
+                  return bigbed.getFeatureStream(refName, start, end, {
                     signal: signal,
                     basesPerSpan: end - start
                   });
 
-                case 6:
-                  ob = _context4.sent;
+                case 8:
+                  ob = _context5.sent;
                   ob.pipe(operators.mergeAll(), operators.map(function (r) {
                     var data = parser.parseLine("".concat(refName, "\t").concat(r.start, "\t").concat(r.end, "\t").concat(r.rest), {
                       uniqueId: r.uniqueId
@@ -1441,26 +1467,26 @@ var BigBedAdapter = /*#__PURE__*/function (_BaseFeatureDataAdapt) {
                     // should be converted to a gene, CNV bigbed has many gene like
                     // features including thickStart and blockCount but no strand
 
-                    return f.get('thickStart') && f.get('blockCount') && f.get('strand') !== 0 ? ucscProcessedTranscript(f) : f;
+                    return isUCSC(f) ? ucscProcessedTranscript(f) : f;
                   })).subscribe(observer);
-                  _context4.next = 13;
+                  _context5.next = 15;
                   break;
 
-                case 10:
-                  _context4.prev = 10;
-                  _context4.t0 = _context4["catch"](0);
-                  observer.error(_context4.t0);
+                case 12:
+                  _context5.prev = 12;
+                  _context5.t0 = _context5["catch"](0);
+                  observer.error(_context5.t0);
 
-                case 13:
+                case 15:
                 case "end":
-                  return _context4.stop();
+                  return _context5.stop();
               }
             }
-          }, _callee4, null, [[0, 10]]);
+          }, _callee5, null, [[0, 12]]);
         }));
 
-        return function (_x3) {
-          return _ref3.apply(this, arguments);
+        return function (_x5) {
+          return _ref2.apply(this, arguments);
         };
       }(), opts.signal);
     }