@jbrowse/plugin-legacy-jbrowse 1.6.9 → 1.7.0

package/dist/JBrowse1Connection/util.js

@@ -0,0 +1,177 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clone = clone;
+exports.deepUpdate = deepUpdate;
+exports.fillTemplate = fillTemplate;
+exports.isSource = isSource;
+exports.isTrack = isTrack;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _getValue = _interopRequireDefault(require("get-value"));
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isTrack(arg) {
+  return arg && arg.label && typeof arg.label === 'string';
+} // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+function isSource(arg) {
+  return arg && arg.url && typeof arg.url === 'string';
+}
+/**
+ * updates a with values from b, recursively
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+function deepUpdate(a, b) {
+  for (var _i = 0, _Object$keys = Object.keys(b); _i < _Object$keys.length; _i++) {
+    var prop = _Object$keys[_i];
+
+    if (prop in a && (0, _typeof2["default"])(b[prop]) === 'object' && (0, _typeof2["default"])(a[prop]) === 'object') {
+      deepUpdate(a[prop], b[prop]);
+    } else if (typeof a[prop] === 'undefined' || typeof b[prop] !== 'undefined') {
+      a[prop] = b[prop];
+    }
+  }
+
+  return a;
+}
+/**
+ * replace variables in a template string with values
+ * @param template - String with variable names in curly brackets
+ * e.g., `http://foo/{bar}?arg={baz.foo}`
+ * @param fillWith - object with attribute-value mappings
+ * e.g., `{ 'bar': 'someurl', 'baz': { 'foo': 42 } }`
+ * @returns the template string with variables in fillWith replaced
+ * e.g., 'htp://foo/someurl?arg=valueforbaz'
+ */
+
+
+function fillTemplate(template, fillWith) {
+  var _this = this;
+
+  return template.replace(/\{([\w\s.]+)\}/g, function (match, varName) {
+    varName = varName.replace(/\s+/g, ''); // remove all whitespace
+
+    var fill = (0, _getValue["default"])(fillWith, varName);
+
+    if (fill !== undefined) {
+      if (typeof fill === 'function') {
+        return fill(varName);
+      }
+
+      return fill;
+    }
+
+    if (fillWith.callback) {
+      // @ts-ignore
+      var v = fillWith.callback.call(_this, varName);
+
+      if (v !== undefined) {
+        return v;
+      }
+    }
+
+    return match;
+  });
+}
+/**
+ * Clones objects (including DOM nodes) and all children.
+ * Warning: do not clone cyclic structures
+ * (Lifted from dojo https://github.com/dojo/dojo/blob/master/_base/lang.js)
+ * @param src - The object to clone
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+function clone(src) {
+  if (!src || (0, _typeof2["default"])(src) !== 'object' || Object.prototype.toString.call(src) === '[object Function]') {
+    // null, undefined, any non-object, or function
+    return src; // anything
+  }
+
+  if (src.nodeType && 'cloneNode' in src) {
+    // DOM Node
+    return src.cloneNode(true); // Node
+  }
+
+  if (src instanceof Date) {
+    // Date
+    return new Date(src.getTime()); // Date
+  }
+
+  if (src instanceof RegExp) {
+    // RegExp
+    return new RegExp(src); // RegExp
+  }
+
+  var r;
+  var i;
+  var l;
+
+  if (Array.isArray(src)) {
+    // array
+    r = [];
+
+    for (i = 0, l = src.length; i < l; ++i) {
+      if (i in src) {
+        r[i] = clone(src[i]);
+      }
+    } // we don't clone functions for performance reasons
+    //    }else if(d.isFunction(src)){
+    //      // function
+    //      r = function(){ return src.apply(this, arguments); };
+
+  } else {
+    // generic objects
+    r = src.constructor ? new src.constructor() : {};
+  }
+
+  return mixin(r, src, clone);
+}
+/**
+ * Copies/adds all properties of source to dest; returns dest.
+ * (Lifted from dojo https://github.com/dojo/dojo/blob/master/_base/lang.js)
+ *
+ * All properties, including functions (sometimes termed "methods"), excluding
+ * any non-standard extensions found in Object.prototype, are copied/added to
+ * dest. Copying/adding each particular property is delegated to copyFunc
+ * (if any); copyFunc defaults to the Javascript assignment operator if not
+ * provided. Notice that by default, mixin executes a so-called "shallow copy"
+ * and aggregate types are copied/added by reference.
+ * @param dest - The object to which to copy/add all properties contained in
+ * source.
+ * @param source - The object from which to draw all properties to copy into dest.
+ * @param copyFunc - The process used to copy/add a property in source; defaults
+ * to the Javascript assignment operator.
+ * @returns dest, as modified
+ */
+
+
+function mixin(dest, source, copyFunc) {
+  var name;
+  var s;
+  var empty = {};
+
+  for (name in source) {
+    // the (!(name in empty) || empty[name] !== s) condition avoids copying
+    // properties in "source" inherited from Object.prototype.	 For example,
+    // if dest has a custom toString() method, don't overwrite it with the
+    // toString() method that source inherited from Object.prototype
+    s = source[name];
+
+    if (!(name in dest) || // @ts-ignore
+    dest[name] !== s && (!(name in empty) || empty[name] !== s)) {
+      dest[name] = copyFunc ? copyFunc(s) : s;
+    }
+  }
+
+  return dest; // Object
+}

package/dist/JBrowse1TextSeachAdapter/HttpMap.js

@@ -0,0 +1,350 @@
+"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 _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _bufferCrc = _interopRequireDefault(require("buffer-crc32"));
+
+/*
+ * Helper class allows reading names index generated in JBrowse1
+ * Adapted from https://github.com/GMOD/jbrowse/blob/master/src/JBrowse/Store/Hash.js
+ */
+var HttpMap = /*#__PURE__*/function () {
+  function HttpMap(args) {
+    (0, _classCallCheck2["default"])(this, HttpMap);
+    (0, _defineProperty2["default"])(this, "url", void 0);
+    // make sure url has a trailing slash
+    this.url = /\/$/.test(args.url) ? args.url : "".concat(args.url, "/");
+  }
+  /**
+   * loads meta.json file from names directory and reads number of hash_bits used
+   */
+
+
+  (0, _createClass2["default"])(HttpMap, [{
+    key: "readMeta",
+    value: function () {
+      var _readMeta = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var meta, compress, tracks, hashHexCharacters;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.loadFile('meta.json');
+
+              case 2:
+                meta = _context.sent;
+                compress = meta.compress, tracks = meta.track_names;
+                hashHexCharacters = Math.ceil(meta.hash_bits / 4);
+                return _context.abrupt("return", {
+                  hashHexCharacters: hashHexCharacters,
+                  compress: compress,
+                  tracks: tracks
+                });
+
+              case 6:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function readMeta() {
+        return _readMeta.apply(this, arguments);
+      }
+
+      return readMeta;
+    }()
+  }, {
+    key: "getHashHexCharacters",
+    value: function () {
+      var _getHashHexCharacters = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var meta;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this.readMeta();
+
+              case 2:
+                meta = _context2.sent;
+                return _context2.abrupt("return", meta.hashHexCharacters);
+
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getHashHexCharacters() {
+        return _getHashHexCharacters.apply(this, arguments);
+      }
+
+      return getHashHexCharacters;
+    }()
+  }, {
+    key: "getCompress",
+    value: function () {
+      var _getCompress = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var meta;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return this.readMeta();
+
+              case 2:
+                meta = _context3.sent;
+                return _context3.abrupt("return", meta.compress);
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function getCompress() {
+        return _getCompress.apply(this, arguments);
+      }
+
+      return getCompress;
+    }()
+  }, {
+    key: "getTrackNames",
+    value: function () {
+      var _getTrackNames = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var meta;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return this.readMeta();
+
+              case 2:
+                meta = _context4.sent;
+                return _context4.abrupt("return", meta.tracks);
+
+              case 4:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function getTrackNames() {
+        return _getTrackNames.apply(this, arguments);
+      }
+
+      return getTrackNames;
+    }()
+    /**
+     * Returns contents of a bucket given a key
+     * @param key - string
+     */
+
+  }, {
+    key: "get",
+    value: function () {
+      var _get = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(key) {
+        var bucket;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return this.getBucket(key);
+
+              case 2:
+                bucket = _context5.sent;
+                return _context5.abrupt("return", bucket[key]);
+
+              case 4:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function get(_x) {
+        return _get.apply(this, arguments);
+      }
+
+      return get;
+    }()
+    /**
+     * Returns a bucket given a key
+     * @param key - string
+     */
+
+  }, {
+    key: "getBucket",
+    value: function () {
+      var _getBucket = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(key) {
+        var bucketIdent, hexToDirPath;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                bucketIdent = this.hash(key);
+                _context6.next = 3;
+                return this.hexToDirPath(bucketIdent);
+
+              case 3:
+                hexToDirPath = _context6.sent;
+                return _context6.abrupt("return", this.loadFile(hexToDirPath));
+
+              case 5:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function getBucket(_x2) {
+        return _getBucket.apply(this, arguments);
+      }
+
+      return getBucket;
+    }()
+    /**
+     * Loads a file using the url and provided id.
+     * Returns response object with contents of the file
+     * @param id - string
+     */
+
+  }, {
+    key: "loadFile",
+    value: function () {
+      var _loadFile = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(id) {
+        var response;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                _context7.next = 2;
+                return fetch("".concat(this.url).concat(id));
+
+              case 2:
+                response = _context7.sent;
+
+                if (response.ok) {
+                  _context7.next = 5;
+                  break;
+                }
+
+                throw new Error("HTTP ".concat(response.status, " ").concat(response.statusText));
+
+              case 5:
+                return _context7.abrupt("return", response.json());
+
+              case 6:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function loadFile(_x3) {
+        return _loadFile.apply(this, arguments);
+      }
+
+      return loadFile;
+    }()
+    /**
+     * Returns the corresponding path of the file given a hex string
+     * @param hex - hex string
+     */
+
+  }, {
+    key: "hexToDirPath",
+    value: function () {
+      var _hexToDirPath = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(hex) {
+        var hashHexCharacters, compress, dirpath, i;
+        return _regenerator["default"].wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                _context8.next = 2;
+                return this.getHashHexCharacters();
+
+              case 2:
+                hashHexCharacters = _context8.sent;
+
+                if (!hashHexCharacters) {
+                  _context8.next = 12;
+                  break;
+                }
+
+                _context8.next = 6;
+                return this.getCompress();
+
+              case 6:
+                compress = _context8.sent;
+
+                while (hex.length < 8) {
+                  hex = "0".concat(hex);
+                }
+
+                hex = hex.substr(8 - hashHexCharacters);
+                dirpath = [];
+
+                for (i = 0; i < hex.length; i += 3) {
+                  dirpath.push(hex.substring(i, i + 3));
+                }
+
+                return _context8.abrupt("return", "".concat(dirpath.join('/'), ".json").concat(compress ? 'z' : ''));
+
+              case 12:
+                return _context8.abrupt("return", '');
+
+              case 13:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function hexToDirPath(_x4) {
+        return _hexToDirPath.apply(this, arguments);
+      }
+
+      return hexToDirPath;
+    }()
+  }, {
+    key: "hash",
+    value: function hash(data) {
+      return (0, _bufferCrc["default"])(Buffer.from(data)).toString('hex').toLowerCase().replace('-', 'n');
+    }
+  }]);
+  return HttpMap;
+}();
+
+exports["default"] = HttpMap;

package/dist/JBrowse1TextSeachAdapter/HttpMap.test.js

@@ -0,0 +1,118 @@
+"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 _path = _interopRequireDefault(require("path"));
+
+var _meta = _interopRequireDefault(require("../../test_data/names/meta.json"));
+
+var _ = _interopRequireDefault(require("../../test_data/names/0.json"));
+
+var _f = _interopRequireDefault(require("../../test_data/names/f.json"));
+
+var _HttpMap = _interopRequireDefault(require("./HttpMap"));
+
+describe('test JBrowse1 hash implementation', function () {
+  test('read from meta', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var mockFetch, rootTemplate, spy, hashMap;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            mockFetch = function _mockFetch(url) {
+              var response = {};
+
+              if (url.includes('names/meta.json')) {
+                response = _meta["default"];
+              }
+
+              return Promise.resolve(new Response(JSON.stringify(response)));
+            };
+
+            rootTemplate = _path["default"].join(__dirname, '..', '..', '..', '..', 'test_data', 'names').replace(/\\/g, '\\\\');
+            spy = jest.spyOn(global, 'fetch'); // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+            spy.mockImplementation(mockFetch);
+            hashMap = new _HttpMap["default"]({
+              url: rootTemplate
+            });
+            _context.next = 7;
+            return hashMap.getBucket('apple');
+
+          case 7:
+            _context.t0 = expect;
+            _context.next = 10;
+            return hashMap.getHashHexCharacters();
+
+          case 10:
+            _context.t1 = _context.sent;
+            (0, _context.t0)(_context.t1).toBe(1);
+            _context.t2 = expect;
+            _context.next = 15;
+            return hashMap.getCompress();
+
+          case 15:
+            _context.t3 = _context.sent;
+            (0, _context.t2)(_context.t3).toBe(0);
+
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+  test('get bucket contents', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    var mockFetch, rootTemplate, spy, hashMap;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            mockFetch = function _mockFetch2(url) {
+              var response = {};
+
+              if (url.includes('names/meta.json')) {
+                response = _meta["default"];
+              }
+
+              if (url.includes('names/0.json')) {
+                response = _["default"];
+              }
+
+              if (url.includes('names/f.json')) {
+                response = _f["default"];
+              }
+
+              return Promise.resolve(new Response(JSON.stringify(response)));
+            };
+
+            rootTemplate = _path["default"].join(__dirname, '..', '..', '..', '..', 'test_data', 'names').replace(/\\/g, '\\\\');
+            spy = jest.spyOn(global, 'fetch'); // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+            spy.mockImplementation(mockFetch);
+            hashMap = new _HttpMap["default"]({
+              url: rootTemplate
+            });
+            _context2.next = 7;
+            return hashMap.getBucket('apple');
+
+          case 7:
+            expect(spy).toHaveBeenLastCalledWith("".concat(rootTemplate, "/0.json"));
+            _context2.next = 10;
+            return hashMap.getBucket('apple3');
+
+          case 10:
+            expect(spy).toHaveBeenLastCalledWith("".concat(rootTemplate, "/f.json"));
+
+          case 11:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  })));
+});