igv 3.0.5 → 3.0.6

package/dist/igv.js

@@ -22880,6 +22880,20 @@
             this.length = dataView.byteLength;
         }
 
+        /**
+         * Print the first "n" bytes to the console.  Used for debugging.
+         * @param n
+         */
+        dumpBytes (n = 100) {
+            const pos = this.position;
+            const bytes = [];
+            for(let i=0; i<= n; i++) {
+                bytes.push(this.getByte());
+            }
+            console.log(bytes.join(" "));
+            this.setPosition(pos);
+        }
+
         setPosition(position) {
             this.position = position;
         }
@@ -31443,7 +31457,6 @@
                 const idToName = [];
                 let sumLengths = 0;
                 const readTreeNode = (offset) => {
-
                     if (offset >= 0) binaryParser.position = offset;
                     const type = binaryParser.getByte();
                     binaryParser.getByte();
@@ -31480,7 +31493,7 @@
                 };
 
                 // Recursively walk tree to populate dictionary
-                readTreeNode(binaryParser);
+                readTreeNode( -1);
 
                 return new ChromTree(header, nameToId, idToName, sumLengths)
             }
@@ -32171,6 +32184,16 @@
             }
         }
 
+        /**
+         * The BB header consists of
+         *  (1) the common header
+         *  (2) the zoom headers
+         *  (3) autosql
+         *  (4) total summary block (version 2 and later)
+         *
+         *  In addition, we read the chromomsome B+ tree
+         * @returns {Promise<*>}
+         */
         async loadHeader() {
 
             if (this.header) {
@@ -32188,7 +32211,7 @@
                 // Assume low-to-high unless proven otherwise
                 this.littleEndian = true;
 
-                let binaryParser = new BinaryParser$1(new DataView(data), this.littleEndian);
+                const binaryParser = new BinaryParser$1(new DataView(data), this.littleEndian);
                 let magic = binaryParser.getUInt();
                 if (magic === BIGWIG_MAGIC_LTH$1) {
                     this.type = "bigwig";
@@ -32223,30 +32246,33 @@
                     extensionOffset: binaryParser.getLong()
                 };
 
+                // Read the next chunk containing zoom headers, autosql, and total summary if present.  TotalSummary size = 40 bytes
                 const startOffset = BBFILE_HEADER_SIZE;
+                const size = header.totalSummaryOffset > 0 ?
+                    header.totalSummaryOffset - startOffset + 40 :
+                    Math.min(header.fullDataOffset, header.chromTreeOffset) - startOffset;
                 let range = {
                     start: startOffset,
-                    size: (header.fullDataOffset - startOffset + 4)
+                    size: size
                 };
                 data = await this.loader.loadArrayBuffer(this.path, buildOptions(this.config, {range: range}));
-
-                const nZooms = header.nZoomLevels;
-                binaryParser = new BinaryParser$1(new DataView(data), this.littleEndian);
+                const extHeaderParser = new BinaryParser$1(new DataView(data), this.littleEndian);
 
                 // Load zoom headers, store in order of decreasing reduction level (increasing resolution)
+                const nZooms = header.nZoomLevels;
                 this.zoomLevelHeaders = [];
                 this.firstZoomDataOffset = Number.MAX_SAFE_INTEGER;
                 for (let i = 1; i <= nZooms; i++) {
                     const zoomNumber = nZooms - i;
-                    const zlh = new ZoomLevelHeader(zoomNumber, binaryParser);
+                    const zlh = new ZoomLevelHeader(zoomNumber, extHeaderParser);
                     this.firstZoomDataOffset = Math.min(zlh.dataOffset, this.firstZoomDataOffset);
                     this.zoomLevelHeaders[zoomNumber] = zlh;
                 }
 
                 // Autosql
                 if (header.autoSqlOffset > 0) {
-                    binaryParser.position = header.autoSqlOffset - startOffset;
-                    const autoSqlString = binaryParser.getString();
+                    extHeaderParser.position = header.autoSqlOffset - startOffset;
+                    const autoSqlString = extHeaderParser.getString();
                     if (autoSqlString) {
                         this.autoSql = parseAutoSQL(autoSqlString);
                     }
@@ -32254,35 +32280,73 @@
 
                 // Total summary
                 if (header.totalSummaryOffset > 0) {
-                    binaryParser.position = header.totalSummaryOffset - startOffset;
-                    this.totalSummary = new BWTotalSummary(binaryParser);
-                }
-
-                // Chrom data index
-                if (header.chromTreeOffset > 0) {
-                    binaryParser.position = header.chromTreeOffset - startOffset;
-                    this.chromTree = await ChromTree.parseTree(binaryParser, startOffset, this.genome);
-                    this.chrNames = new Set(this.chromTree.idToName);
-                } else {
-                    // TODO -- this is an error, not expected
-                    throw "BigWig chromosome tree offset <= 0"
+                    extHeaderParser.position = header.totalSummaryOffset - startOffset;
+                    this.totalSummary = new BWTotalSummary(extHeaderParser);
                 }
 
-                //Finally total data count
-                binaryParser.position = header.fullDataOffset - startOffset;
-                header.dataCount = binaryParser.getInt();
+                // Chrom data index.  The start is known, size is not, but we can estimate it
+                const bufferSize = Math.min(200000, Math.max(10000, header.fullDataOffset - header.chromTreeOffset));
+                this.chromTree = await this.#readChromTree(header.chromTreeOffset, bufferSize);
+                this.chrNames = new Set(this.chromTree.idToName);
 
-                this.featureDensity = header.dataCount / this.chromTree.sumLengths;
+                // Estimate feature density from dataCount (bigbed only)
+                if("bigbed" === this.type) {
+                    const dataCount = await this.#readDataCount(header.fullDataOffset);
+                    this.featureDensity = dataCount / this.chromTree.sumLengths;
+                }
 
                 this.header = header;
 
-
                 //extension
                 if (header.extensionOffset > 0) {
                     await this.loadExtendedHeader(header.extensionOffset);
                 }
-              return this.header
+                return this.header
+            }
+        }
+
+        async #readDataCount(offset) {
+            const data = await this.loader.loadArrayBuffer(this.path, buildOptions(this.config, {
+                range: {
+                    start: offset,
+                    size: 4
+                }
+            }));
+            const binaryParser = new BinaryParser$1(new DataView(data), this.littleEndian);
+            return binaryParser.getInt()
+        }
+
+        /**
+         * Used when the chromTreeOffset is > fullDataOffset, that is when the chrom tree is not in the initial chunk
+         * read for parsing the header.  We know the start position, but not the total size of the chrom tree
+         *
+         * @returns {Promise<void>}
+         */
+        async #readChromTree(chromTreeOffset, bufferSize) {
+
+            let size = bufferSize;
+            const load = async () => {
+                const data = await this.loader.loadArrayBuffer(this.path, buildOptions(this.config, {
+                    range: {
+                        start: chromTreeOffset,
+                        size: size
+                    }
+                }));
+                const binaryParser = new BinaryParser$1(new DataView(data), this.littleEndian);
+                return ChromTree.parseTree(binaryParser, chromTreeOffset, this.genome)
+            };
+
+            let error;
+            while (size < 1000000) {
+                try {
+                    const chromTree = await load();
+                    return chromTree
+                } catch (e) {
+                    error = e;
+                    size *= 2;
+                }
             }
+            throw (error)
         }
 
         async loadExtendedHeader(offset) {
@@ -33459,7 +33523,10 @@
             for (let feature of featureList) {
                 for (let field of searchableFields) {
                     let key;
-                    if (typeof feature.getAttributeValue === 'function') {
+                    if(feature.hasOwnProperty(field)) {
+                        key = feature[field];
+                    }
+                    else if (typeof feature.getAttributeValue === 'function') {
                         key = feature.getAttributeValue(field);
                     }
                     if (key) {
@@ -70527,7 +70594,7 @@
         })
     }
 
-    const _version = "3.0.5";
+    const _version = "3.0.6";
     function version() {
         return _version
     }
@@ -76262,7 +76329,7 @@
     async function keyUpHandler(event) {
 
         // Feature jumping disabled in multi-locus view
-        if (this.referenceFrameList.length > 1) return
+        if (!this.referenceFrameList || this.referenceFrameList.length > 1) return
 
         if (event.code === 'KeyF' || event.code === 'KeyB') {