@jbrowse/plugin-legacy-jbrowse 1.6.9 → 1.7.3

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);
+  })));
+});

package/dist/JBrowse1TextSeachAdapter/JBrowse1TextSearchAdapter.d.ts

@@ -1,33 +1,33 @@
-import { BaseTextSearchAdapter, BaseArgs, BaseAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
-import { Instance } from 'mobx-state-tree';
-import MyConfigSchema from './configSchema';
-import HttpMap from './HttpMap';
-import PluginManager from '@jbrowse/core/PluginManager';
-import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
-export interface TooManyHits {
-    name: string;
-    hitLimit: number;
-}
-interface SearchResults {
-    prefix: ({
-        name: string;
-    } | string)[];
-    exact: [string, number, string, string, number, number][];
-}
-export declare type NamesIndexRecord = string | Array<string | number>;
-export default class JBrowse1TextSearchAdapter extends BaseAdapter implements BaseTextSearchAdapter {
-    httpMap: HttpMap;
-    tracksNames?: string[];
-    constructor(config: Instance<typeof MyConfigSchema>, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
-    /**
-     * Returns the contents of the file containing the query if it exists
-     * else it returns empty
-     * @param query - string query
-     */
-    loadIndexFile(query: string): Promise<Record<string, SearchResults>>;
-    searchIndex(args: BaseArgs): Promise<BaseResult[]>;
-    formatResults(results: SearchResults, tracks: string[], searchType?: string): BaseResult[];
-    freeResources(): void;
-}
-export {};
+import { BaseTextSearchAdapter, BaseArgs, BaseAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
+import { Instance } from 'mobx-state-tree';
+import MyConfigSchema from './configSchema';
+import HttpMap from './HttpMap';
+import PluginManager from '@jbrowse/core/PluginManager';
+import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
+export interface TooManyHits {
+    name: string;
+    hitLimit: number;
+}
+interface SearchResults {
+    prefix: ({
+        name: string;
+    } | string)[];
+    exact: [string, number, string, string, number, number][];
+}
+export declare type NamesIndexRecord = string | Array<string | number>;
+export default class JBrowse1TextSearchAdapter extends BaseAdapter implements BaseTextSearchAdapter {
+    httpMap: HttpMap;
+    tracksNames?: string[];
+    constructor(config: Instance<typeof MyConfigSchema>, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
+    /**
+     * Returns the contents of the file containing the query if it exists
+     * else it returns empty
+     * @param query - string query
+     */
+    loadIndexFile(query: string): Promise<Record<string, SearchResults>>;
+    searchIndex(args: BaseArgs): Promise<BaseResult[]>;
+    formatResults(results: SearchResults, tracks: string[], searchType?: string): BaseResult[];
+    freeResources(): void;
+}
+export {};