@jbrowse/plugin-legacy-jbrowse 1.6.9 → 1.7.3

package/dist/JBrowse1Connection/jb1ConfigParse.d.ts

@@ -1,11 +1,11 @@
-import { Config } from './types';
-export declare function parseJB1Json(config: Config | string, url: string): Config;
-export declare function parseJB1Conf(config: string, url: string): Config;
-/**
- * Applies defaults and any other necessary tweaks to the loaded configuration.
- * @param conf - the object containing the configuration, which it modifies
- * in-place
- * @param url - URL of the config file
- * @returns the same object it was passed
- */
-export declare function regularizeConf(conf: Config, url: string): Config;
+import { Config } from './types';
+export declare function parseJB1Json(config: Config | string, url: string): Config;
+export declare function parseJB1Conf(config: string, url: string): Config;
+/**
+ * Applies defaults and any other necessary tweaks to the loaded configuration.
+ * @param conf - the object containing the configuration, which it modifies
+ * in-place
+ * @param url - URL of the config file
+ * @returns the same object it was passed
+ */
+export declare function regularizeConf(conf: Config, url: string): Config;

package/dist/JBrowse1Connection/jb1ConfigParse.js

@@ -0,0 +1,476 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseJB1Conf = parseJB1Conf;
+exports.parseJB1Json = parseJB1Json;
+exports.regularizeConf = regularizeConf;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _getValue = _interopRequireDefault(require("get-value"));
+
+var _setValue = _interopRequireDefault(require("set-value"));
+
+var _util = require("@jbrowse/core/util");
+
+var _util2 = require("./util");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function parseJB1Json(config, url) {
+  if (typeof config === 'string') {
+    var parsedConf;
+
+    try {
+      parsedConf = JSON.parse(config);
+    } catch (error) {
+      throw new Error("".concat(error, " when parsing configuration."));
+    }
+
+    return regularizeConf(parsedConf, url);
+  }
+
+  return regularizeConf(config, url);
+}
+
+function parseJB1Conf(config, url) {
+  var parsedConf;
+
+  try {
+    parsedConf = parse(config, url);
+  } catch (error) {
+    throw new Error("".concat(error, " when parsing configuration."));
+  }
+
+  return regularizeConf(parsedConf, url);
+}
+
+function isAlwaysArray(varName) {
+  if (varName === 'include') {
+    return true;
+  }
+
+  return false;
+}
+
+function parse(text, url) {
+  var section = [];
+  var keyPath;
+  var operation;
+  var value;
+  var data = {
+    tracks: {}
+  };
+  var lineNumber;
+
+  function recordVal() {
+    if (value !== undefined) {
+      var parsedValue;
+
+      try {
+        // parse json
+        var match = value.match(/^json:(.+)/i);
+
+        if (match) {
+          parsedValue = JSON.parse(match[1]);
+        } // parse numbers if it looks numeric
+        else if (/^[+-]?[\d.,]+([eE][-+]?\d+)?$/.test(value)) {
+          parsedValue = parseFloat(value.replace(/,/g, ''));
+        } else {
+          parsedValue = value;
+        }
+
+        if (!keyPath) {
+          throw new Error("Error parsing in section ".concat(section.join(' - ')));
+        }
+
+        var path = section.concat(keyPath).join('.');
+
+        if (operation === '+=') {
+          var existing = (0, _getValue["default"])(data, path);
+
+          if (existing) {
+            if (!Array.isArray(existing)) {
+              existing = [existing];
+            }
+          } else {
+            existing = [];
+          }
+
+          existing.push(parsedValue);
+          parsedValue = existing;
+        }
+
+        if (parsedValue === 'true') {
+          parsedValue = true;
+        }
+
+        if (parsedValue === 'false') {
+          parsedValue = false;
+        }
+
+        (0, _setValue["default"])(data, path, parsedValue);
+      } catch (e) {
+        throw new Error("syntax error".concat(url ? " in ".concat(url) : '').concat(lineNumber ? " at line ".concat(lineNumber - 1) : ''));
+      }
+    }
+  }
+
+  text.split('\n').forEach(function (textLine, i) {
+    lineNumber = i + 1;
+    var line = textLine.replace(/^\s*#.+/, ''); // new section
+
+    var match;
+
+    if (match = line.match(/^\s*\[([^\]]+)/)) {
+      // new section
+      recordVal();
+      keyPath = undefined;
+      value = undefined;
+      section = match[1].trim().split(/\s*\.\s*/);
+
+      if (section.length === 1 && section[0].toLowerCase() === 'general') {
+        section = [];
+      }
+    } // new value
+    else if (match = line.match(value === undefined ? /^([^+=]+)(\+?=)(.*)/ : /^(\S[^+=]+)(\+?=)(.*)/)) {
+      recordVal();
+      keyPath = match[1].trim().split(/\s*\.\s*/);
+      var _match = match;
+
+      var _match2 = (0, _slicedToArray2["default"])(_match, 3);
+
+      operation = _match2[2];
+
+      if (isAlwaysArray(section.concat(keyPath).join('.'))) {
+        operation = '+=';
+      }
+
+      value = match[3].trim();
+    } // add to existing array value
+    else if (keyPath !== undefined && (match = line.match(/^\s{0,4}\+\s*(.+)/))) {
+      recordVal();
+      operation = '+=';
+      value = match[1].trim();
+    } // add to existing value
+    else if (value !== undefined && (match = line.match(/^\s+(\S.*)/))) {
+      value += value.length ? " ".concat(match[1].trim()) : match[1].trim();
+    } // done with last value
+    else {
+      recordVal();
+      keyPath = undefined;
+      value = undefined;
+    }
+  });
+  recordVal();
+  return data;
+}
+/**
+ * Applies defaults and any other necessary tweaks to the loaded configuration.
+ * @param conf - the object containing the configuration, which it modifies
+ * in-place
+ * @param url - URL of the config file
+ * @returns the same object it was passed
+ */
+
+
+function regularizeConf(conf, url) {
+  // if tracks is not an array, convert it to one
+  if (conf.tracks && !Array.isArray(conf.tracks)) {
+    // if it's a single track config, wrap it in an arrayref
+    if ((0, _util2.isTrack)(conf.tracks)) {
+      conf.tracks = [conf.tracks];
+    } // otherwise, coerce it to an array
+    else {
+      var tracks = [];
+
+      for (var _i = 0, _Object$keys = Object.keys(conf.tracks); _i < _Object$keys.length; _i++) {
+        var label = _Object$keys[_i];
+        var track = conf.tracks[label];
+
+        if ((0, _util2.isTrack)(track)) {
+          tracks.push(track);
+        } else {
+          tracks.push(_objectSpread({
+            label: label
+          }, track));
+        }
+      }
+
+      conf.tracks = tracks;
+    }
+  } // regularize trackMetadata.sources
+
+
+  var meta = conf.trackMetadata;
+
+  if (meta && meta.sources) {
+    // if it's a single source config, wrap it in an arrayref
+    if (typeof meta.sources === 'string') {
+      meta.sources = [meta.sources];
+    }
+
+    if ((0, _util2.isSource)(meta.sources)) {
+      meta.sources = [meta.sources];
+    }
+
+    if (!Array.isArray(meta.sources)) {
+      var sources = [];
+
+      for (var _i2 = 0, _Object$keys2 = Object.keys(meta.sources); _i2 < _Object$keys2.length; _i2++) {
+        var name = _Object$keys2[_i2];
+        var source = meta.sources[name];
+
+        if (!('name' in source)) {
+          source.name = name;
+        }
+
+        sources.push(source);
+      }
+
+      meta.sources = sources;
+    } // coerce any string source defs to be URLs, and try to detect their types
+
+
+    meta.sources = meta.sources.map(function (sourceDef) {
+      if (typeof sourceDef === 'string') {
+        var newSourceDef = {
+          url: sourceDef
+        };
+        var typeMatch = sourceDef.match(/\.(\w+)$/);
+
+        if (typeMatch) {
+          newSourceDef.type = typeMatch[1].toLowerCase();
+        }
+
+        return newSourceDef;
+      }
+
+      return sourceDef;
+    });
+  }
+
+  conf.sourceUrl = conf.sourceUrl || url;
+
+  if (conf.sourceUrl.startsWith('/')) {
+    conf.sourceUrl = new URL(conf.sourceUrl, window.location.href).href;
+  }
+
+  conf.baseUrl = conf.baseUrl || new URL('.', conf.sourceUrl).href;
+
+  if (conf.baseUrl.length && !conf.baseUrl.endsWith('/')) {
+    conf.baseUrl += '/';
+  }
+
+  if (conf.sourceUrl) {
+    // set a default baseUrl in each of the track and store confs, and the names
+    // conf, if needed
+    var addBase = [];
+
+    if (conf.tracks) {
+      addBase.push.apply(addBase, (0, _toConsumableArray2["default"])(conf.tracks));
+    }
+
+    if (conf.stores) {
+      addBase.push.apply(addBase, (0, _toConsumableArray2["default"])(Object.values(conf.stores)));
+    }
+
+    if (conf.names) {
+      addBase.push(conf.names);
+    }
+
+    addBase.forEach(function (t) {
+      if (!t.baseUrl) {
+        t.baseUrl = conf.baseUrl || '/';
+      }
+    }); // resolve the refSeqs and nameUrl if present
+
+    if (conf.refSeqs && typeof conf.refSeqs === 'string') {
+      conf.refSeqs = new URL(conf.refSeqs, conf.sourceUrl).href;
+    }
+
+    if (conf.nameUrl) {
+      conf.nameUrl = new URL(conf.nameUrl, conf.sourceUrl).href;
+    }
+  }
+
+  conf.stores = conf.stores || {};
+  (conf.tracks || []).forEach(function (trackConfig) {
+    // if there is a `config` subpart, just copy its keys in to the top-level
+    // config
+    if (trackConfig.config) {
+      var c = trackConfig.config;
+      delete trackConfig.config;
+      trackConfig = _objectSpread(_objectSpread({}, c), trackConfig);
+    } // skip if it's a new-style track def
+
+
+    if (trackConfig.store) {
+      return;
+    }
+
+    var trackClassName;
+
+    if (trackConfig.type === 'FeatureTrack') {
+      trackClassName = 'JBrowse/View/Track/HTMLFeatures';
+    } else if (trackConfig.type === 'ImageTrack') {
+      trackClassName = 'JBrowse/View/Track/FixedImage';
+    } else if (trackConfig.type === 'ImageTrack.Wiggle') {
+      trackClassName = 'JBrowse/View/Track/FixedImage/Wiggle';
+    } else if (trackConfig.type === 'SequenceTrack') {
+      trackClassName = 'JBrowse/View/Track/Sequence';
+    } else {
+      trackClassName = regularizeClass('JBrowse/View/Track', trackConfig.type);
+    }
+
+    trackConfig.type = trackClassName;
+    synthesizeTrackStoreConfig(conf, trackConfig);
+
+    if (trackConfig.histograms) {
+      if (!trackConfig.histograms.baseUrl) {
+        trackConfig.histograms.baseUrl = trackConfig.baseUrl;
+      }
+
+      synthesizeTrackStoreConfig(conf, trackConfig.histograms);
+    }
+  });
+  return conf;
+}
+/**
+ * prefix class name with `root` if it contains no slashes
+ * @param root - Prefix root
+ * @param className - class name
+ */
+
+
+function regularizeClass(root, className) {
+  if (!className) {
+    return '';
+  }
+
+  if (!className.includes('/')) {
+    className = "".concat(root, "/").concat(className);
+  }
+
+  className = className.replace(/^\//, '');
+  return className;
+}
+
+function guessStoreClass(trackConfig, urlTemplate) {
+  if (!trackConfig) {
+    return '';
+  }
+
+  if (trackConfig.type && trackConfig.type.includes('/FixedImage')) {
+    return "JBrowse/Store/TiledImage/Fixed".concat(trackConfig.backendVersion === 0 ? '_v0' : '');
+  }
+
+  if (/\.jsonz?$/i.test(urlTemplate)) {
+    return "JBrowse/Store/SeqFeature/NCList".concat(trackConfig.backendVersion === 0 ? '_v0' : '');
+  }
+
+  if (/\.bam$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/BAM';
+  }
+
+  if (/\.cram$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/CRAM';
+  }
+
+  if (/\.gff3?$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/GFF3';
+  }
+
+  if (/\.bed$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/BED';
+  }
+
+  if (/\.vcf.b?gz$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/VCFTabix';
+  }
+
+  if (/\.gff3?.b?gz$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/GFF3Tabix';
+  }
+
+  if (/\.bed.b?gz$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/BEDTabix';
+  }
+
+  if (/\.(bw|bigwig)$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/BigWig';
+  }
+
+  if (/\.(bb|bigbed)$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/BigBed';
+  }
+
+  if (/\.(fa|fasta)$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/IndexedFasta';
+  }
+
+  if (/\.(fa|fasta)\.b?gz$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/BgzipIndexedFasta';
+  }
+
+  if (/\.2bit$/i.test(urlTemplate)) {
+    return 'JBrowse/Store/SeqFeature/TwoBit';
+  }
+
+  if (trackConfig.type && trackConfig.type.endsWith('/Sequence')) {
+    return 'JBrowse/Store/Sequence/StaticChunked';
+  }
+
+  return '';
+}
+
+function synthesizeTrackStoreConfig(mainConf, trackConfig) {
+  // figure out what data store class to use with the track, applying some
+  // defaults if it is not explicit in the configuration
+  var _trackConfig$urlTempl = trackConfig.urlTemplate,
+      urlTemplate = _trackConfig$urlTempl === void 0 ? '' : _trackConfig$urlTempl;
+  var storeClass;
+
+  if (trackConfig.storeClass) {
+    storeClass = regularizeClass('JBrowse/Store', trackConfig.storeClass);
+  } else {
+    storeClass = guessStoreClass(trackConfig, urlTemplate);
+  }
+
+  if (!storeClass) {
+    console.warn("Unable to determine an appropriate data store to use with track '".concat(trackConfig.label, "', please explicitly specify a storeClass in the configuration."));
+    return;
+  } // synthesize a separate store conf
+
+
+  var storeConf = _objectSpread(_objectSpread({}, trackConfig), {}, {
+    type: storeClass
+  }); // if this is the first sequence store we see, and we have no refseqs store
+  // defined explicitly, make this the refseqs store.
+
+
+  if ((storeClass === 'JBrowse/Store/Sequence/StaticChunked' || storeClass === 'JBrowse/Store/Sequence/IndexedFasta' || storeClass === 'JBrowse/Store/SeqFeature/IndexedFasta' || storeClass === 'JBrowse/Store/SeqFeature/BgzipIndexedFasta' || storeClass === 'JBrowse/Store/SeqFeature/TwoBit' || storeClass === 'JBrowse/Store/Sequence/TwoBit' || trackConfig.useAsRefSeqStore) && !(mainConf.stores && mainConf.stores.refseqs)) {
+    storeConf.name = 'refseqs';
+  } else {
+    storeConf.name = "store".concat((0, _util.objectHash)(storeConf));
+  } // record it
+
+
+  if (!mainConf.stores) {
+    mainConf.stores = {};
+  }
+
+  mainConf.stores[storeConf.name] = storeConf; // connect it to the track conf
+
+  trackConfig.store = storeConf.name;
+}

package/dist/JBrowse1Connection/jb1ToJb2.d.ts

@@ -1,47 +1,47 @@
-import { Track, RefSeqs } from './types';
-interface Jb2Track {
-    trackId: string;
-    name: string;
-    description?: string;
-    category?: string[];
-    adapter?: Jb2Adapter;
-    type?: string;
-    defaultRendering?: string;
-}
-interface Jb2Adapter {
-    type: string;
-    features?: Jb2Feature[];
-    bamLocation?: Jb2Location;
-    cramLocation?: Jb2Location;
-    craiLocation?: Jb2Location;
-    fastaLocation?: Jb2Location;
-    faiLocation?: Jb2Location;
-    gziLocation?: Jb2Location;
-    twoBitLocation?: Jb2Location;
-    bigWigLocation?: Jb2Location;
-    bigBedLocation?: Jb2Location;
-    vcfGzLocation?: Jb2Location;
-    gffGzLocation?: Jb2Location;
-    bedGzLocation?: Jb2Location;
-    index?: {
-        location: Jb2Location;
-        indexType?: string;
-    };
-    rootUrlTemplate?: Jb2Location;
-    sequenceAdapter?: Jb2Adapter;
-}
-interface Jb2Feature {
-    refName: string;
-    uniqueId: string;
-    start: number;
-    end: number;
-}
-interface Jb2Location {
-    uri?: string;
-    localPath?: string;
-    blobId?: string;
-    locationType?: string;
-}
-export declare function convertTrackConfig(jb1TrackConfig: Track, dataRoot: string, sequenceAdapter: Jb2Adapter): Jb2Track;
-export declare function createRefSeqsAdapter(refSeqs: string | RefSeqs): Promise<Jb2Adapter>;
-export {};
+import { Track, RefSeqs } from './types';
+interface Jb2Track {
+    trackId: string;
+    name: string;
+    description?: string;
+    category?: string[];
+    adapter?: Jb2Adapter;
+    type?: string;
+    defaultRendering?: string;
+}
+interface Jb2Adapter {
+    type: string;
+    features?: Jb2Feature[];
+    bamLocation?: Jb2Location;
+    cramLocation?: Jb2Location;
+    craiLocation?: Jb2Location;
+    fastaLocation?: Jb2Location;
+    faiLocation?: Jb2Location;
+    gziLocation?: Jb2Location;
+    twoBitLocation?: Jb2Location;
+    bigWigLocation?: Jb2Location;
+    bigBedLocation?: Jb2Location;
+    vcfGzLocation?: Jb2Location;
+    gffGzLocation?: Jb2Location;
+    bedGzLocation?: Jb2Location;
+    index?: {
+        location: Jb2Location;
+        indexType?: string;
+    };
+    rootUrlTemplate?: Jb2Location;
+    sequenceAdapter?: Jb2Adapter;
+}
+interface Jb2Feature {
+    refName: string;
+    uniqueId: string;
+    start: number;
+    end: number;
+}
+interface Jb2Location {
+    uri?: string;
+    localPath?: string;
+    blobId?: string;
+    locationType?: string;
+}
+export declare function convertTrackConfig(jb1TrackConfig: Track, dataRoot: string, sequenceAdapter: Jb2Adapter): Jb2Track;
+export declare function createRefSeqsAdapter(refSeqs: string | RefSeqs): Promise<Jb2Adapter>;
+export {};