genoverse 3.2.0 → 4.0.1

package/src/js/lib/dalliance/bin.js

@@ -0,0 +1,317 @@
+// Adapted from https://github.com/dasmoth/dalliance/blob/master/js/bin.js
+
+/* -*- mode: javascript; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+//
+// Dalliance Genome Explorer
+// (c) Thomas Down 2006-2011
+//
+// bin.js general binary data support
+//
+
+import b64Sha1 from './sha1';
+
+function BlobFetchable(b) {
+    this.blob = b;
+}
+
+BlobFetchable.prototype.slice = function(start, length) {
+    var b;
+
+    if (this.blob.slice) {
+        if (length) {
+            b = this.blob.slice(start, start + length);
+        } else {
+            b = this.blob.slice(start);
+        }
+    } else {
+        if (length) {
+            b = this.blob.webkitSlice(start, start + length);
+        } else {
+            b = this.blob.webkitSlice(start);
+        }
+    }
+    return new BlobFetchable(b);
+}
+
+BlobFetchable.prototype.salted = function() {return this;}
+
+if (typeof(FileReader) !== 'undefined') {
+    // console.log('defining async BlobFetchable.fetch');
+
+    BlobFetchable.prototype.fetch = function(callback) {
+        var reader = new FileReader();
+        reader.onloadend = function(ev) {
+            callback(bstringToBuffer(reader.result));
+        };
+        reader.readAsBinaryString(this.blob);
+    }
+
+} else {
+    // if (console && console.log)
+    //    console.log('defining sync BlobFetchable.fetch');
+
+    BlobFetchable.prototype.fetch = function(callback) {
+        var reader = new FileReaderSync();
+        try {
+            var res = reader.readAsArrayBuffer(this.blob);
+            callback(res);
+        } catch (e) {
+            callback(null, e);
+        }
+    }
+}
+
+function URLFetchable(url, start, end, opts) {
+    if (!opts) {
+        if (typeof start === 'object') {
+            opts = start;
+            start = undefined;
+        } else {
+            opts = {};
+        }
+    }
+
+    this.url = url;
+    this.start = start || 0;
+    if (end) {
+        this.end = end;
+    }
+    this.opts = opts;
+}
+
+URLFetchable.prototype.slice = function(s, l) {
+    if (s < 0) {
+        throw 'Bad slice ' + s;
+    }
+
+    var ns = this.start, ne = this.end;
+    if (ns && s) {
+        ns = ns + s;
+    } else {
+        ns = s || ns;
+    }
+    if (l && ns) {
+        ne = ns + l - 1;
+    } else {
+        ne = ne || l - 1;
+    }
+    return new URLFetchable(this.url, ns, ne, this.opts);
+}
+
+var seed=0;
+var isSafari = typeof(navigator) !== 'undefined' &&
+    navigator.userAgent.indexOf('Safari') >= 0 &&
+    navigator.userAgent.indexOf('Chrome') < 0 ;
+
+URLFetchable.prototype.fetchAsText = function(callback) {
+    var thisB = this;
+
+    this.getURL().then(function(url) {
+        try {
+            var req = new XMLHttpRequest();
+            var length;
+            if ((isSafari || thisB.opts.salt) && url.indexOf('?') < 0) {
+                url = url + '?salt=' + b64Sha1('' + Date.now() + ',' + (++seed));
+            }
+            req.open('GET', url, true);
+
+            if (thisB.end) {
+                if (thisB.end - thisB.start > 100000000) {
+                    throw 'Monster fetch!';
+                }
+                req.setRequestHeader('Range', 'bytes=' + thisB.start + '-' + thisB.end);
+                length = thisB.end - thisB.start + 1;
+            }
+
+            req.onreadystatechange = function() {
+                if (req.readyState == 4) {
+                    if (req.status == 200 || req.status == 206) {
+                        return callback(req.responseText);
+                    } else {
+                        return callback(null);
+                    }
+                }
+            };
+            if (thisB.opts.credentials) {
+                req.withCredentials = true;
+            }
+            req.send();
+        } catch (e) {
+            return callback(null);
+        }
+    }).catch(function(err) {
+        console.log(err);
+        return callback(null, err);
+    });
+}
+
+URLFetchable.prototype.salted = function() {
+    return new URLFetchable(this.url, this.start, this.end, { ...this.opts, salt: true });
+}
+
+URLFetchable.prototype.getURL = function() {
+    if (this.opts.resolver) {
+        return this.opts.resolver(this.url).then(function (urlOrObj) {
+            if (typeof urlOrObj === 'string') {
+                return urlOrObj;
+            } else {
+                return urlOrObj.url;
+            }
+        });
+    } else {
+        return Promise.resolve(this.url);
+    }
+}
+
+URLFetchable.prototype.fetch = function(callback, opts) {
+    var thisB = this;
+
+    opts = opts || {};
+    var attempt = opts.attempt || 1;
+    var truncatedLength = opts.truncatedLength;
+    if (attempt > 3) {
+        return callback(null);
+    }
+
+    this.getURL().then(function(url) {
+        try {
+            var timeout;
+            if (opts.timeout && !thisB.opts.credentials) {
+                timeout = setTimeout(
+                    function() {
+                        console.log('timing out ' + url);
+                        req.abort();
+                        return callback(null, 'Timeout');
+                    },
+                    opts.timeout
+                );
+            }
+
+            var req = new XMLHttpRequest();
+            var length;
+            if ((isSafari || thisB.opts.salt) && url.indexOf('?') < 0) {
+                url = url + '?salt=' + b64Sha1('' + Date.now() + ',' + (++seed));
+            }
+            req.open('GET', url, true);
+            req.overrideMimeType('text/plain; charset=x-user-defined');
+            if (thisB.end) {
+                if (thisB.end - thisB.start > 100000000) {
+                    throw 'Monster fetch!';
+                }
+                req.setRequestHeader('Range', 'bytes=' + thisB.start + '-' + thisB.end);
+                length = thisB.end - thisB.start + 1;
+            }
+            req.responseType = 'arraybuffer';
+            req.onreadystatechange = function() {
+                if (req.readyState == 4) {
+                    if (timeout)
+                        clearTimeout(timeout);
+                    if (req.status == 200 || req.status == 206) {
+                        if (req.response) {
+                            var bl = req.response.byteLength;
+                            if (length && length != bl && (!truncatedLength || bl != truncatedLength)) {
+                                return thisB.fetch(callback, {attempt: attempt + 1, truncatedLength: bl});
+                            } else {
+                                return callback(req.response);
+                            }
+                        } else if (req.mozResponseArrayBuffer) {
+                            return callback(req.mozResponseArrayBuffer);
+                        } else {
+                            var r = req.responseText;
+                            if (length && length != r.length && (!truncatedLength || r.length != truncatedLength)) {
+                                return thisB.fetch(callback, {attempt: attempt + 1, truncatedLength: r.length});
+                            } else {
+                                return callback(bstringToBuffer(req.responseText));
+                            }
+                        }
+                    } else {
+                        return thisB.fetch(callback, {attempt: attempt + 1});
+                    }
+                }
+            };
+            if (thisB.opts.credentials) {
+                req.withCredentials = true;
+            }
+            req.send();
+        } catch (e) {
+            return callback(null);
+        }
+    }).catch(function(err) {
+        console.log(err);
+        return callback(null, err);
+    });
+}
+
+function bstringToBuffer(result) {
+    if (!result) {
+        return null;
+    }
+
+    var ba = new Uint8Array(result.length);
+    for (var i = 0; i < ba.length; ++i) {
+        ba[i] = result.charCodeAt(i);
+    }
+    return ba.buffer;
+}
+
+// Read from Uint8Array
+
+var convertBuffer = new ArrayBuffer(8);
+var ba = new Uint8Array(convertBuffer);
+var fa = new Float32Array(convertBuffer);
+
+function readFloat(buf, offset) {
+    ba[0] = buf[offset];
+    ba[1] = buf[offset+1];
+    ba[2] = buf[offset+2];
+    ba[3] = buf[offset+3];
+    return fa[0];
+}
+
+function readInt64(ba, offset) {
+    return (ba[offset + 7] << 24) | (ba[offset + 6] << 16) | (ba[offset + 5] << 8) | (ba[offset + 4]);
+}
+
+const M1 = 256,
+      M2 = M1 * 256,
+      M3 = M2 * 256,
+      M4 = M3 * 256,
+      M5 = M4 * 256;
+
+function readInt64LE(ba, offset) {
+    return (ba[offset]) + (ba[offset + 1] * M1) + (ba[offset + 2] * M2) + (ba[offset + 3] * M3) + (ba[offset + 4] * M4) + (ba[offset + 5] * M5);
+}
+
+function readInt64BE(ba, offset) {
+    return (ba[offset + 7]) + (ba[offset + 6] * M1) + (ba[offset + 5] * M2) + (ba[offset + 4] * M3) + (ba[offset + 3] * M4) + (ba[offset + 2] * M5);
+}
+
+function readInt(ba, offset) {
+    return (ba[offset + 3] << 24) | (ba[offset + 2] << 16) | (ba[offset + 1] << 8) | (ba[offset]);
+}
+
+function readShort(ba, offset) {
+    return (ba[offset + 1] << 8) | (ba[offset]);
+}
+
+function readByte(ba, offset) {
+    return ba[offset];
+}
+
+function readIntBE(ba, offset) {
+    return (ba[offset] << 24) | (ba[offset + 1] << 16) | (ba[offset + 2] << 8) | (ba[offset + 3]);
+}
+
+export {
+  URLFetchable,
+  BlobFetchable,
+  readInt,
+  readIntBE,
+  readInt64,
+  readInt64LE,
+  readInt64BE,
+  readShort,
+  readByte,
+  readFloat,
+}