genoverse 3.2.0 → 4.0.1

package/src/js/lib/dalliance/lh3utils.js

@@ -0,0 +1,105 @@
+// Adapted from https://github.com/dasmoth/dalliance/blob/master/js/lh3utils.js
+
+/* -*- mode: javascript; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+//
+// Dalliance Genome Explorer
+// (c) Thomas Down 2006-2011
+//
+// lh3utils.js: common support for lh3's file formats
+//
+
+import inflateBuffer from './jszlib-inflate';
+
+function Vob(b, o) {
+  this.block = b;
+  this.offset = o;
+}
+
+Vob.prototype.toString = function() {
+  return '' + this.block + ':' + this.offset;
+}
+
+function readVob(ba, offset, allowZero) {
+  var block = ((ba[offset+6] & 0xff) * 0x100000000) + ((ba[offset+5] & 0xff) * 0x1000000) + ((ba[offset+4] & 0xff) * 0x10000) + ((ba[offset+3] & 0xff) * 0x100) + ((ba[offset+2] & 0xff));
+  var bint = (ba[offset+1] << 8) | (ba[offset]);
+  if (block == 0 && bint == 0 && !allowZero) {
+      return null;  // Should only happen in the linear index?
+  } else {
+      return new Vob(block, bint);
+  }
+}
+
+function unbgzf(data, lim) {
+  lim = Math.min(lim || 1, data.byteLength - 50);
+  var oBlockList = [];
+  var ptr = [0];
+  var totalSize = 0;
+
+  while (ptr[0] < lim) {
+      var ba = new Uint8Array(data, ptr[0], 12); // FIXME is this enough for all credible BGZF block headers?
+      var xlen = (ba[11] << 8) | (ba[10]);
+      // dlog('xlen[' + (ptr[0]) +']=' + xlen);
+      var unc = inflateBuffer(data, 12 + xlen + ptr[0], Math.min(65536, data.byteLength - 12 - xlen - ptr[0]), ptr);
+      ptr[0] += 8;
+      totalSize += unc.byteLength;
+      oBlockList.push(unc);
+  }
+
+  if (oBlockList.length == 1) {
+      return oBlockList[0];
+  } else {
+      var out = new Uint8Array(totalSize);
+      var cursor = 0;
+      for (var i = 0; i < oBlockList.length; ++i) {
+          var b = new Uint8Array(oBlockList[i]);
+          arrayCopy(b, 0, out, cursor, b.length);
+          cursor += b.length;
+      }
+      return out.buffer;
+  }
+}
+
+function Chunk(minv, maxv) {
+  this.minv = minv; this.maxv = maxv;
+}
+
+
+//
+// Binning (transliterated from SAM1.3 spec)
+//
+
+/* calculate bin given an alignment covering [beg,end) (zero-based, half-close-half-open) */
+function reg2bin(beg, end)
+{
+  --end;
+  if (beg>>14 == end>>14) return ((1<<15)-1)/7 + (beg>>14);
+  if (beg>>17 == end>>17) return ((1<<12)-1)/7 + (beg>>17);
+  if (beg>>20 == end>>20) return ((1<<9)-1)/7 + (beg>>20);
+  if (beg>>23 == end>>23) return ((1<<6)-1)/7 + (beg>>23);
+  if (beg>>26 == end>>26) return ((1<<3)-1)/7 + (beg>>26);
+  return 0;
+}
+
+/* calculate the list of bins that may overlap with region [beg,end) (zero-based) */
+var MAX_BIN = (((1<<18)-1)/7);
+function reg2bins(beg, end)
+{
+  var i = 0, k, list = [];
+  --end;
+  list.push(0);
+  for (k = 1 + (beg>>26); k <= 1 + (end>>26); ++k) list.push(k);
+  for (k = 9 + (beg>>23); k <= 9 + (end>>23); ++k) list.push(k);
+  for (k = 73 + (beg>>20); k <= 73 + (end>>20); ++k) list.push(k);
+  for (k = 585 + (beg>>17); k <= 585 + (end>>17); ++k) list.push(k);
+  for (k = 4681 + (beg>>14); k <= 4681 + (end>>14); ++k) list.push(k);
+  return list;
+}
+
+export {
+  unbgzf,
+  readVob,
+  reg2bin,
+  reg2bins,
+  Chunk,
+};

package/src/js/lib/dalliance/sha1.js

@@ -0,0 +1,334 @@
+// Adapted from https://github.com/dasmoth/dalliance/blob/master/js/sha1.js
+
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS 180-1
+ * Version 2.2 Copyright Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+/*
+ * Configurable variables. You may need to tweak these to be compatible with
+ * the server-side, but the defaults work in most cases.
+ */
+var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
+var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
+
+/*
+ * These are the functions you'll usually want to call
+ * They take string arguments and return either hex or base-64 encoded strings
+ */
+function hex_sha1(s)    { return rstr2hex(rstr_sha1(str2rstr_utf8(s))); }
+function b64_sha1(s)    { return rstr2b64(rstr_sha1(str2rstr_utf8(s))); }
+function any_sha1(s, e) { return rstr2any(rstr_sha1(str2rstr_utf8(s)), e); }
+function hex_hmac_sha1(k, d)
+  { return rstr2hex(rstr_hmac_sha1(str2rstr_utf8(k), str2rstr_utf8(d))); }
+function b64_hmac_sha1(k, d)
+  { return rstr2b64(rstr_hmac_sha1(str2rstr_utf8(k), str2rstr_utf8(d))); }
+function any_hmac_sha1(k, d, e)
+  { return rstr2any(rstr_hmac_sha1(str2rstr_utf8(k), str2rstr_utf8(d)), e); }
+
+/*
+ * Perform a simple self-test to see if the VM is working
+ */
+function sha1_vm_test()
+{
+  return hex_sha1("abc").toLowerCase() == "a9993e364706816aba3e25717850c26c9cd0d89d";
+}
+
+/*
+ * Calculate the SHA1 of a raw string
+ */
+function rstr_sha1(s)
+{
+  return binb2rstr(binb_sha1(rstr2binb(s), s.length * 8));
+}
+
+/*
+ * Calculate the HMAC-SHA1 of a key and some data (raw strings)
+ */
+function rstr_hmac_sha1(key, data)
+{
+  var bkey = rstr2binb(key);
+  if(bkey.length > 16) bkey = binb_sha1(bkey, key.length * 8);
+
+  var ipad = Array(16), opad = Array(16);
+  for(var i = 0; i < 16; i++)
+  {
+    ipad[i] = bkey[i] ^ 0x36363636;
+    opad[i] = bkey[i] ^ 0x5C5C5C5C;
+  }
+
+  var hash = binb_sha1(ipad.concat(rstr2binb(data)), 512 + data.length * 8);
+  return binb2rstr(binb_sha1(opad.concat(hash), 512 + 160));
+}
+
+/*
+ * Convert a raw string to a hex string
+ */
+function rstr2hex(input)
+{
+  // try { hexcase } catch(e) { hexcase=0; }
+  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+  var output = "";
+  var x;
+  for(var i = 0; i < input.length; i++)
+  {
+    x = input.charCodeAt(i);
+    output += hex_tab.charAt((x >>> 4) & 0x0F)
+           +  hex_tab.charAt( x        & 0x0F);
+  }
+  return output;
+}
+
+/*
+ * Convert a raw string to a base-64 string
+ */
+function rstr2b64(input)
+{
+  // try { b64pad } catch(e) { b64pad=''; }
+  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var output = "";
+  var len = input.length;
+  for(var i = 0; i < len; i += 3)
+  {
+    var triplet = (input.charCodeAt(i) << 16)
+                | (i + 1 < len ? input.charCodeAt(i+1) << 8 : 0)
+                | (i + 2 < len ? input.charCodeAt(i+2)      : 0);
+    for(var j = 0; j < 4; j++)
+    {
+      if(i * 8 + j * 6 > input.length * 8) output += b64pad;
+      else output += tab.charAt((triplet >>> 6*(3-j)) & 0x3F);
+    }
+  }
+  return output;
+}
+
+/*
+ * Convert a raw string to an arbitrary string encoding
+ */
+function rstr2any(input, encoding)
+{
+  var divisor = encoding.length;
+  var remainders = Array();
+  var i, q, x, quotient;
+
+  /* Convert to an array of 16-bit big-endian values, forming the dividend */
+  var dividend = Array(Math.ceil(input.length / 2));
+  for(i = 0; i < dividend.length; i++)
+  {
+    dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
+  }
+
+  /*
+   * Repeatedly perform a long division. The binary array forms the dividend,
+   * the length of the encoding is the divisor. Once computed, the quotient
+   * forms the dividend for the next step. We stop when the dividend is zero.
+   * All remainders are stored for later use.
+   */
+  while(dividend.length > 0)
+  {
+    quotient = Array();
+    x = 0;
+    for(i = 0; i < dividend.length; i++)
+    {
+      x = (x << 16) + dividend[i];
+      q = Math.floor(x / divisor);
+      x -= q * divisor;
+      if(quotient.length > 0 || q > 0)
+        quotient[quotient.length] = q;
+    }
+    remainders[remainders.length] = x;
+    dividend = quotient;
+  }
+
+  /* Convert the remainders to the output string */
+  var output = "";
+  for(i = remainders.length - 1; i >= 0; i--)
+    output += encoding.charAt(remainders[i]);
+
+  /* Append leading zero equivalents */
+  var full_length = Math.ceil(input.length * 8 /
+                                    (Math.log(encoding.length) / Math.log(2)))
+  for(i = output.length; i < full_length; i++)
+    output = encoding[0] + output;
+
+  return output;
+}
+
+/*
+ * Encode a string as utf-8.
+ * For efficiency, this assumes the input is valid utf-16.
+ */
+function str2rstr_utf8(input)
+{
+  var output = "";
+  var i = -1;
+  var x, y;
+
+  while(++i < input.length)
+  {
+    /* Decode utf-16 surrogate pairs */
+    x = input.charCodeAt(i);
+    y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
+    if(0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF)
+    {
+      x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
+      i++;
+    }
+
+    /* Encode output as utf-8 */
+    if(x <= 0x7F)
+      output += String.fromCharCode(x);
+    else if(x <= 0x7FF)
+      output += String.fromCharCode(0xC0 | ((x >>> 6 ) & 0x1F),
+                                    0x80 | ( x         & 0x3F));
+    else if(x <= 0xFFFF)
+      output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),
+                                    0x80 | ((x >>> 6 ) & 0x3F),
+                                    0x80 | ( x         & 0x3F));
+    else if(x <= 0x1FFFFF)
+      output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),
+                                    0x80 | ((x >>> 12) & 0x3F),
+                                    0x80 | ((x >>> 6 ) & 0x3F),
+                                    0x80 | ( x         & 0x3F));
+  }
+  return output;
+}
+
+/*
+ * Encode a string as utf-16
+ */
+function str2rstr_utf16le(input)
+{
+  var output = "";
+  for(var i = 0; i < input.length; i++)
+    output += String.fromCharCode( input.charCodeAt(i)        & 0xFF,
+                                  (input.charCodeAt(i) >>> 8) & 0xFF);
+  return output;
+}
+
+function str2rstr_utf16be(input)
+{
+  var output = "";
+  for(var i = 0; i < input.length; i++)
+    output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF,
+                                   input.charCodeAt(i)        & 0xFF);
+  return output;
+}
+
+/*
+ * Convert a raw string to an array of big-endian words
+ * Characters >255 have their high-byte silently ignored.
+ */
+function rstr2binb(input)
+{
+  var output = Array(input.length >> 2);
+  for(var i = 0; i < output.length; i++)
+    output[i] = 0;
+  for(var i = 0; i < input.length * 8; i += 8)
+    output[i>>5] |= (input.charCodeAt(i / 8) & 0xFF) << (24 - i % 32);
+  return output;
+}
+
+/*
+ * Convert an array of big-endian words to a string
+ */
+function binb2rstr(input)
+{
+  var output = "";
+  for(var i = 0; i < input.length * 32; i += 8)
+    output += String.fromCharCode((input[i>>5] >>> (24 - i % 32)) & 0xFF);
+  return output;
+}
+
+/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+function binb_sha1(x, len)
+{
+  /* append padding */
+  x[len >> 5] |= 0x80 << (24 - len % 32);
+  x[((len + 64 >> 9) << 4) + 15] = len;
+
+  var w = Array(80);
+  var a =  1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d =  271733878;
+  var e = -1009589776;
+
+  for(var i = 0; i < x.length; i += 16)
+  {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    var olde = e;
+
+    for(var j = 0; j < 80; j++)
+    {
+      if(j < 16) w[j] = x[i + j];
+      else w[j] = bit_rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+      var t = safe_add(safe_add(bit_rol(a, 5), sha1_ft(j, b, c, d)),
+                       safe_add(safe_add(e, w[j]), sha1_kt(j)));
+      e = d;
+      d = c;
+      c = bit_rol(b, 30);
+      b = a;
+      a = t;
+    }
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+    e = safe_add(e, olde);
+  }
+  return Array(a, b, c, d, e);
+
+}
+
+/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+function sha1_ft(t, b, c, d)
+{
+  if(t < 20) return (b & c) | ((~b) & d);
+  if(t < 40) return b ^ c ^ d;
+  if(t < 60) return (b & c) | (b & d) | (c & d);
+  return b ^ c ^ d;
+}
+
+/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+function sha1_kt(t)
+{
+  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
+         (t < 60) ? -1894007588 : -899497514;
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y)
+{
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xFFFF);
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function bit_rol(num, cnt)
+{
+  return (num << cnt) | (num >>> (32 - cnt));
+}
+
+export default b64_sha1;

package/src/js/lib/import-tracks.js

@@ -0,0 +1,42 @@
+import _set from 'lodash/set';
+
+/*
+  Add each track file to Genoverse.Track, such that, e.g.
+  src/js/Track/library/Foo/Bar/Baz.js    => Genoverse.Track.Foo.Bar.Baz
+  src/js/Track/Controller/Foo/Bar/Baz.js => Genoverse.Track.Controller.Foo.Bar.Baz
+  src/js/Track/Model/Foo/Bar/Baz.js      => Genoverse.Track.Model.Foo.Bar.Baz
+  src/js/Track/View/Foo/Bar/Baz.js       => Genoverse.Track.View.Foo.Bar.Baz
+
+  A file in library/ which also exports { Controller, Model, View } will cause these to also be added to Genoverse.Track, e.g.
+  src/js/Track/library/Legend.js => Genoverse.Track.Legend, Genoverse.Track.Controller.Legend, Genoverse.Track.Model.Legend, Genoverse.Track.View.Legend
+*/
+const setTrackNamespace = (Track, namespace, exportKey, fileExport) => {
+  if (fileExport) {
+    _set(
+      exportKey === 'default' ? Track : Track[exportKey],
+      namespace.replace('library/', '').split('/'),
+      fileExport
+    );
+  }
+};
+
+export default (Track, requireContext, { exclude = [] } = {}) => {
+  const trackImports = requireContext.keys().reduce(
+    (acc, key, ...args) => {
+      const k = key.replace('./', '').replace('.js', '');
+
+      if (exclude && (exclude.includes(k) || exclude.includes(k.replace('library/', '').replace(/\//g, '.')))) {
+        return acc;
+      }
+
+      return Object.assign(acc, { [k]: requireContext(key, ...args) });
+    },
+    {}
+  );
+
+  Object.keys(trackImports).sort().forEach(
+    namespace => Object.keys(trackImports[namespace]).sort().forEach(
+      exportKey => setTrackNamespace(Track, namespace, exportKey, trackImports[namespace][exportKey])
+    )
+  );
+};

package/src/js/lib/jquery.js

@@ -0,0 +1,26 @@
+import jQuery from 'jquery';
+
+// Bits of jquery-ui which we care about
+import 'jquery-ui/ui/position';
+import 'jquery-ui/ui/widgets/draggable';
+import 'jquery-ui/ui/widgets/resizable';
+import 'jquery-ui/ui/widgets/sortable';
+
+const oldGlobal = {
+  $      : global.$,
+  jQuery : global.jQuery,
+};
+
+global.$ = global.jQuery = jQuery;
+
+const importAll = r => r.keys().forEach(r);
+
+try {
+  importAll(require.context('./jquery-plugins', false, /\.js$/));
+} finally {
+  // Don't assign Genoverse's version of jQuery to global (window)
+  global.$      = oldGlobal.$;
+  global.jQuery = oldGlobal.jQuery;
+}
+
+export default jQuery;

package/src/js/lib/polyfills.js

@@ -0,0 +1,11 @@
+// Polyfills required to support IE11
+import 'core-js/es/promise';
+import 'core-js/es/object/assign';
+import 'core-js/es/object/entries';
+import 'core-js/es/object/values';
+import 'core-js/es/array/includes';
+import 'core-js/es/array/fill';
+import 'core-js/es/array/find';
+import 'core-js/es/array/flat';
+import 'core-js/es/array/flat-map';
+import 'core-js/stable/url';

package/src/js/lib/wrap-functions.js

@@ -0,0 +1,88 @@
+const trigger = (obj, when, funcName, mainObj, events, args) => {
+  const eventKey = `${when}${funcName}`;
+  const once     = events[`${eventKey}.once`] || [];
+  const funcs    = (events[eventKey] || []).concat(once, typeof mainObj[eventKey] === 'function' ? mainObj[eventKey] : []);
+
+  if (once.length) {
+    delete events[`${eventKey}.once`];
+  }
+
+  funcs.forEach(func => func.apply(obj, args));
+};
+
+/**
+ * functionWrap - wraps event handlers and adds debugging functionality
+ */
+const functionWrap = (key, obj, mainObj, events, debugWrapper) => {
+  if (obj.functions[key] || /^(before|after)/.test(key)) {
+    return;
+  }
+
+  const funcName   = `${key.substring(0, 1).toUpperCase()}${key.substring(1)}`;
+  const debug      = debugWrapper.for;
+  const debugLabel = debug ? `${debugWrapper.label}.${key}` : false;
+  const debugTime  = debug === 'time' || (typeof debug === 'object' && debug[key]);
+
+  obj.functions[key] = obj[key].bind(obj);
+
+  obj[key] = (...args) => {
+    const currentConfigFunctions = (obj._currentConfig || obj.track?._currentConfig)?.func || {};
+
+    let rtn;
+
+    // Debugging functionality
+    // Enabled by "debug": true || 'time' || { functionName: true, ...} option
+    if (debug === true) { // if "debug": true, simply log function call
+      console.log(debugLabel); // eslint-disable-line no-console
+    } else if (debugTime) { // if debug: 'time' || { functionName: true, ...}, log function time
+      console.time(`time: ${debugLabel}`); // eslint-disable-line no-console
+    }
+
+    trigger(obj, 'before', funcName, mainObj, events, args);
+
+    if (currentConfigFunctions[key]) {
+      // override to add a value for base
+      obj.base = obj.functions[key] || (() => {});
+
+      rtn = currentConfigFunctions[key].apply(obj, args);
+    } else {
+      rtn = obj.functions[key](...args);
+    }
+
+    trigger(obj, 'after', funcName, mainObj, events, args);
+
+    if (debugTime) {
+      console.timeEnd(`time: ${debugLabel}`); // eslint-disable-line no-console
+    }
+
+    return rtn;
+  };
+};
+
+const wrapFunctions = (obj, objType) => {
+  obj.functions = obj.functions || {};
+
+  const isBrowser = objType === 'Genoverse';
+  const mainObj   = isBrowser || objType === 'Track' ? obj : obj.track;
+  const events    = isBrowser ? obj.events.browser : obj.browser.events.tracks;
+
+  const debugWrapper = {
+    for   : mainObj.debug,
+    label : (
+      mainObj.debug
+        ? [
+          isBrowser ? 'Genoverse' : mainObj.id || mainObj.name || 'Track',
+          obj !== mainObj ? objType : false,
+        ].filter(Boolean).join('.')
+        : false
+    ),
+  };
+
+  for (const key in obj) { // eslint-disable-line no-restricted-syntax
+    if (typeof obj[key] === 'function' && typeof obj[key].ancestor !== 'function' && !key.match(/^(base|extend|constructor|controller|model|view|on|once|prop|loadPlugins|loadGenome|jQuery)$/)) {
+      functionWrap(key, obj, mainObj, events, debugWrapper);
+    }
+  }
+};
+
+export default wrapFunctions;