@jbrowse/plugin-legacy-jbrowse 1.6.7 → 1.7.0

package/dist/JBrowse1Connection/configSchema.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _models = require("@jbrowse/core/pluggableElementTypes/models");
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _default = (0, _configuration.ConfigurationSchema)('JBrowse1Connection', {
+  dataDirLocation: {
+    type: 'fileLocation',
+    defaultValue: {
+      uri: 'http://mysite.com/jbrowse/data/',
+      locationType: 'UriLocation'
+    },
+    description: 'the location of the JBrowse 1 data directory, often something like http://mysite.com/jbrowse/data/'
+  },
+  assemblyNames: {
+    description: 'name of the assembly the connection belongs to, should be a single entry',
+    type: 'stringArray',
+    defaultValue: []
+  }
+}, {
+  baseConfiguration: _models.baseConnectionConfig
+});
+
+exports["default"] = _default;

package/dist/JBrowse1Connection/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "configSchema", {
+  enumerable: true,
+  get: function get() {
+    return _configSchema["default"];
+  }
+});
+Object.defineProperty(exports, "modelFactory", {
+  enumerable: true,
+  get: function get() {
+    return _model["default"];
+  }
+});
+
+var _model = _interopRequireDefault(require("./model"));
+
+var _configSchema = _interopRequireDefault(require("./configSchema"));

package/dist/JBrowse1Connection/jb1ConfigLoad.js

@@ -0,0 +1,555 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFinalConfig = createFinalConfig;
+exports.fetchConfigFile = fetchConfigFile;
+exports.fetchJb1 = fetchJb1;
+exports.parseJb1 = parseJb1;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _io = require("@jbrowse/core/util/io");
+
+var _jb1ConfigParse = require("./jb1ConfigParse");
+
+var _util = require("./util");
+
+function isUriLocation(location) {
+  return location.uri !== undefined;
+}
+
+function isLocalPathLocation(location) {
+  return location.localPath !== undefined;
+}
+
+function fetchJb1() {
+  return _fetchJb.apply(this, arguments);
+}
+
+function _fetchJb() {
+  _fetchJb = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var dataRoot,
+        baseConfig,
+        baseConfigRoot,
+        protocol,
+        dataRootReg,
+        dataRootLocation,
+        baseProtocol,
+        baseConfigLocation,
+        _newConfig,
+        _i3,
+        _arr,
+        conf,
+        fetchedConfig,
+        newConfig,
+        _args = arguments;
+
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            dataRoot = _args.length > 0 && _args[0] !== undefined ? _args[0] : {
+              uri: '',
+              locationType: 'UriLocation'
+            };
+            baseConfig = _args.length > 1 && _args[1] !== undefined ? _args[1] : {
+              include: ['{dataRoot}/trackList.json', '{dataRoot}/tracks.conf']
+            };
+            baseConfigRoot = _args.length > 2 && _args[2] !== undefined ? _args[2] : {
+              uri: '',
+              locationType: 'UriLocation'
+            };
+            protocol = 'uri' in dataRoot ? 'uri' : 'localPath';
+            dataRootReg = JSON.parse(JSON.stringify(dataRoot));
+            dataRootLocation = '';
+
+            if (isUriLocation(dataRoot)) {
+              dataRootLocation = dataRoot.uri;
+            }
+
+            if (isLocalPathLocation(dataRoot)) {
+              dataRootLocation = dataRoot.localPath;
+            }
+
+            if (dataRootLocation.endsWith('/')) {
+              dataRootReg[protocol] = dataRootLocation.slice(0, dataRootLocation.length - 1);
+            }
+
+            if (!(isUriLocation(baseConfigRoot) && baseConfigRoot.uri || isLocalPathLocation(baseConfigRoot) && baseConfigRoot.localPath)) {
+              _context.next = 35;
+              break;
+            }
+
+            baseProtocol = 'uri' in baseConfigRoot ? 'uri' : 'localPath';
+            baseConfigLocation = '';
+
+            if (isUriLocation(baseConfigRoot)) {
+              baseConfigLocation = baseConfigRoot.uri;
+            }
+
+            if (isLocalPathLocation(baseConfigRoot)) {
+              baseConfigLocation = baseConfigRoot.localPath;
+            }
+
+            if (baseConfigLocation.endsWith('/')) {
+              baseConfigLocation = baseConfigLocation.slice(0, baseConfigLocation.length - 1);
+            }
+
+            _newConfig = {};
+            _i3 = 0, _arr = ['jbrowse.conf', 'jbrowse_conf.json'];
+
+          case 17:
+            if (!(_i3 < _arr.length)) {
+              _context.next = 33;
+              break;
+            }
+
+            conf = _arr[_i3];
+            fetchedConfig = null;
+            _context.prev = 20;
+            _context.next = 23;
+            return fetchConfigFile((0, _defineProperty2["default"])({}, baseProtocol, "".concat(baseConfigLocation, "/").concat(conf)));
+
+          case 23:
+            fetchedConfig = _context.sent;
+            _context.next = 29;
+            break;
+
+          case 26:
+            _context.prev = 26;
+            _context.t0 = _context["catch"](20);
+            console.error("tried to access ".concat(baseConfigLocation, "/").concat(conf, ", but failed"));
+
+          case 29:
+            _newConfig = mergeConfigs(_newConfig, fetchedConfig) || {};
+
+          case 30:
+            _i3++;
+            _context.next = 17;
+            break;
+
+          case 33:
+            if (dataRootReg[protocol]) {
+              _newConfig.dataRoot = dataRootReg[protocol];
+            }
+
+            return _context.abrupt("return", createFinalConfig(_newConfig));
+
+          case 35:
+            newConfig = (0, _jb1ConfigParse.regularizeConf)(baseConfig, window.location.href);
+
+            if (dataRootReg[protocol]) {
+              newConfig.dataRoot = dataRootReg[protocol];
+            }
+
+            return _context.abrupt("return", createFinalConfig(newConfig));
+
+          case 38:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[20, 26]]);
+  }));
+  return _fetchJb.apply(this, arguments);
+}
+
+function createFinalConfig(_x) {
+  return _createFinalConfig.apply(this, arguments);
+}
+
+function _createFinalConfig() {
+  _createFinalConfig = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(baseConfig) {
+    var defaults,
+        configWithDefaults,
+        finalConfig,
+        _args2 = arguments;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            defaults = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : configDefaults;
+            configWithDefaults = (0, _util.deepUpdate)((0, _util.clone)(defaults), baseConfig);
+            _context2.next = 4;
+            return loadIncludes(configWithDefaults);
+
+          case 4:
+            finalConfig = _context2.sent;
+            finalConfig = mergeConfigs(finalConfig, baseConfig) || finalConfig;
+            fillTemplates(finalConfig, finalConfig);
+            validateConfig(finalConfig);
+            return _context2.abrupt("return", finalConfig);
+
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _createFinalConfig.apply(this, arguments);
+}
+
+function fetchConfigFile(_x2) {
+  return _fetchConfigFile.apply(this, arguments);
+}
+
+function _fetchConfigFile() {
+  _fetchConfigFile = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(location) {
+    var result;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return (0, _io.openLocation)(location).readFile('utf8');
+
+          case 2:
+            result = _context3.sent;
+
+            if (!isUriLocation(location)) {
+              _context3.next = 5;
+              break;
+            }
+
+            return _context3.abrupt("return", parseJb1(result, location.uri));
+
+          case 5:
+            if (!isLocalPathLocation(location)) {
+              _context3.next = 7;
+              break;
+            }
+
+            return _context3.abrupt("return", parseJb1(result, location.localPath));
+
+          case 7:
+            return _context3.abrupt("return", parseJb1(result));
+
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _fetchConfigFile.apply(this, arguments);
+}
+
+function parseJb1(config) {
+  var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+  if (config.trim().startsWith('{')) {
+    return (0, _jb1ConfigParse.parseJB1Json)(config, url);
+  }
+
+  return (0, _jb1ConfigParse.parseJB1Conf)(config, url);
+}
+/**
+ * Merges config object b into a. Properties in b override those in a.
+ */
+
+
+function mergeConfigs(a, b) {
+  if (b === null) {
+    return null;
+  }
+
+  if (a === null) {
+    a = {};
+  }
+
+  for (var _i = 0, _Object$keys = Object.keys(b); _i < _Object$keys.length; _i++) {
+    var prop = _Object$keys[_i];
+
+    if (prop === 'tracks' && prop in a) {
+      var aTracks = a[prop] || [];
+      var bTracks = b[prop] || [];
+
+      if (Array.isArray(aTracks) && Array.isArray(bTracks)) {
+        a[prop] = mergeTrackConfigs(aTracks || [], bTracks || []);
+      } else {
+        throw new Error("Track config has not been properly regularized: ".concat(aTracks, " ").concat(bTracks));
+      }
+    } else if (!noRecursiveMerge(prop) && prop in a && // @ts-ignore
+    (0, _typeof2["default"])(b[prop]) === 'object' && // @ts-ignore
+    (0, _typeof2["default"])(a[prop]) === 'object') {
+      // @ts-ignore
+      a[prop] = (0, _util.deepUpdate)(a[prop], b[prop]);
+    } else if (prop === 'dataRoot') {
+      if (a[prop] === undefined || a[prop] === 'data' && b[prop] !== undefined) {
+        a[prop] = b[prop];
+      } // @ts-ignore
+
+    } else if (a[prop] === undefined || b[prop] !== undefined) {
+      // @ts-ignore
+      a[prop] = b[prop];
+    }
+  }
+
+  return a;
+}
+/**
+ * Special-case merging of two `tracks` configuration arrays.
+ */
+
+
+function mergeTrackConfigs(a, b) {
+  if (!b.length) {
+    return a;
+  } // index the tracks in `a` by track label
+
+
+  var aTracks = {};
+  a.forEach(function (t, i) {
+    t.index = i;
+    aTracks[t.label] = t;
+  });
+  b.forEach(function (bT) {
+    var aT = aTracks[bT.label];
+
+    if (aT) {
+      mergeConfigs(aT, bT);
+    } else {
+      a.push(bT);
+    }
+  });
+  return a;
+}
+/**
+ * Recursively fetch, parse, and merge all the includes in the given config
+ * object.  Calls the callback with the resulting configuration when finished.
+ * @param inputConfig - Config to load includes into
+ */
+
+
+function loadIncludes(_x3) {
+  return _loadIncludes.apply(this, arguments);
+}
+
+function _loadIncludes() {
+  _loadIncludes = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(inputConfig) {
+    var loadRecur, _loadRecur;
+
+    return _regenerator["default"].wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _loadRecur = function _loadRecur3() {
+              _loadRecur = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(config, upstreamConf) {
+                var sourceUrl, newUpstreamConf, includes, loads, includedDataObjects;
+                return _regenerator["default"].wrap(function _callee5$(_context5) {
+                  while (1) {
+                    switch (_context5.prev = _context5.next) {
+                      case 0:
+                        sourceUrl = config.sourceUrl || config.baseUrl;
+
+                        if (sourceUrl) {
+                          _context5.next = 3;
+                          break;
+                        }
+
+                        throw new Error("Could not determine source URL: ".concat(JSON.stringify(config)));
+
+                      case 3:
+                        newUpstreamConf = mergeConfigs((0, _util.clone)(upstreamConf), config);
+
+                        if (newUpstreamConf) {
+                          _context5.next = 6;
+                          break;
+                        }
+
+                        throw new Error('Problem merging configs');
+
+                      case 6:
+                        includes = fillTemplates(regularizeIncludes(config.include || []), newUpstreamConf);
+                        delete config.include;
+                        loads = includes.map( /*#__PURE__*/function () {
+                          var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(include) {
+                            var includedData;
+                            return _regenerator["default"].wrap(function _callee4$(_context4) {
+                              while (1) {
+                                switch (_context4.prev = _context4.next) {
+                                  case 0:
+                                    include.cacheBuster = inputConfig.cacheBuster;
+                                    _context4.next = 3;
+                                    return fetchConfigFile({
+                                      uri: new URL(include.url, sourceUrl).href,
+                                      locationType: 'UriLocation'
+                                    });
+
+                                  case 3:
+                                    includedData = _context4.sent;
+                                    return _context4.abrupt("return", loadRecur(includedData, newUpstreamConf));
+
+                                  case 5:
+                                  case "end":
+                                    return _context4.stop();
+                                }
+                              }
+                            }, _callee4);
+                          }));
+
+                          return function (_x6) {
+                            return _ref.apply(this, arguments);
+                          };
+                        }());
+                        _context5.next = 11;
+                        return Promise.all(loads);
+
+                      case 11:
+                        includedDataObjects = _context5.sent;
+                        includedDataObjects.forEach(function (includedData) {
+                          config = mergeConfigs(config, includedData) || config;
+                        });
+                        return _context5.abrupt("return", config);
+
+                      case 14:
+                      case "end":
+                        return _context5.stop();
+                    }
+                  }
+                }, _callee5);
+              }));
+              return _loadRecur.apply(this, arguments);
+            };
+
+            loadRecur = function _loadRecur2(_x4, _x5) {
+              return _loadRecur.apply(this, arguments);
+            };
+
+            inputConfig = (0, _util.clone)(inputConfig);
+            return _context6.abrupt("return", loadRecur(inputConfig, {}));
+
+          case 4:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _loadIncludes.apply(this, arguments);
+}
+
+function regularizeIncludes(includes) {
+  if (!includes) {
+    return [];
+  } // coerce include to an array
+
+
+  if (!Array.isArray(includes)) {
+    includes = [includes];
+  }
+
+  return includes.map(function (include) {
+    // coerce bare strings in the includes to URLs
+    if (typeof include === 'string') {
+      include = {
+        url: include
+      };
+    } // set defaults for format and version
+
+
+    if (!('format' in include)) {
+      include.format = include.url.endsWith('.conf') ? 'conf' : 'JB_json';
+    }
+
+    if (include.format === 'JB_json' && !('version' in include)) {
+      include.version = 1;
+    }
+
+    return include;
+  });
+} // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unnecessary-type-constraint
+
+
+function fillTemplates(subconfig, config) {
+  if (!subconfig) {
+    return subconfig;
+  }
+
+  if (Array.isArray(subconfig)) {
+    for (var i = 0; i < subconfig.length; i += 1) {
+      subconfig[i] = fillTemplates(subconfig[i], config);
+    }
+  } else if ((0, _typeof2["default"])(subconfig) === 'object') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var sub = subconfig;
+
+    for (var _i2 = 0, _Object$keys2 = Object.keys(sub); _i2 < _Object$keys2.length; _i2++) {
+      var name = _Object$keys2[_i2];
+      sub[name] = fillTemplates(sub[name], config);
+    }
+  } else if (typeof subconfig === 'string') {
+    // @ts-ignore
+    return (0, _util.fillTemplate)(subconfig, config);
+  }
+
+  return subconfig;
+}
+/**
+ * list of config properties that should not be recursively merged
+ * @param propName - name of config property
+ */
+
+
+function noRecursiveMerge(propName) {
+  return propName === 'datasets';
+}
+
+var configDefaults = {
+  tracks: [],
+  containerID: 'GenomeBrowser',
+  dataRoot: 'data',
+  show_tracklist: true,
+  show_nav: true,
+  show_menu: true,
+  show_overview: true,
+  show_fullviewlink: true,
+  update_browser_title: true,
+  updateBrowserURL: true,
+  refSeqs: '{dataRoot}/seq/refSeqs.json',
+  include: ['jbrowse.conf', 'jbrowse_conf.json'],
+  nameUrl: '{dataRoot}/names/root.json',
+  datasets: {
+    _DEFAULT_EXAMPLES: true,
+    volvox: {
+      url: '?data=sample_data/json/volvox',
+      name: 'Volvox Example'
+    },
+    modencode: {
+      url: '?data=sample_data/json/modencode',
+      name: 'MODEncode Example'
+    },
+    yeast: {
+      url: '?data=sample_data/json/yeast',
+      name: 'Yeast Example'
+    }
+  },
+  highlightSearchedRegions: false,
+  highResolutionMode: 'auto'
+};
+/**
+ * Examine the loaded and merged configuration for errors.  Throws
+ * exceptions if it finds anything amiss.
+ * @returns nothing meaningful
+ */
+
+function validateConfig(config) {
+  if (!config.tracks) {
+    config.tracks = [];
+  }
+
+  if (!config.baseUrl) {
+    throw new Error('Must provide a `baseUrl` in configuration');
+  }
+}