igv 3.5.1 → 3.5.3

package/dist/igv.js

@@ -8708,7 +8708,7 @@
        const response = await fetch(endPoint);
        let json = await response.json();
        if (json.error && json.error.code === 404) {
-           let scope = "https://www.googleapis.com/auth/drive.readonly";
+           let scope = "https://www.googleapis.com/auth/drive.file";
            const access_token = await getAccessToken(scope);
            if (access_token) {
                const response = await fetch(endPoint, {
@@ -8890,6 +8890,10 @@
 
    class IGVXhr {
 
+       UCSC_HOST = "hgdownload.soe.ucsc.edu"
+       UCSC_BACKUP_HOST = "genome-browser.s3.us-east-1.amazonaws.com"
+
+
        constructor() {
            this.apiKey = undefined;
            this.googleThrottle = new Throttle({
@@ -8897,6 +8901,7 @@
            });
            this.RANGE_WARNING_GIVEN = false;
            this.oauth = new Oauth();
+           this.corsProxy = undefined;
        }
 
        setApiKey(key) {
@@ -8921,7 +8926,7 @@
         * @param options
         * @returns {Promise<Uint8Array>}
         */
-        async loadByteArray(url, options) {
+       async loadByteArray(url, options) {
            const arraybuffer = await this.loadArrayBuffer(url, options);
            let plain;
            if (isgzipped(arraybuffer)) {
@@ -8966,7 +8971,7 @@
 
            if (isFile(url)) {
                return this._loadFileSlice(url, options)
-           } else if (typeof url.startsWith === 'function') {   // Test for string
+           } else if (isString$3(url)) {
                if (url.startsWith("data:")) {
                    const buffer = decodeDataURI$1(url).buffer;
                    if (options.range) {
@@ -8996,6 +9001,7 @@
 
            const self = this;
            const _url = url;   // The unmodified URL, needed in case of an oAuth retry
+           const {host} = parseUri(_url);
 
            url = mapUrl$1(url);
 
@@ -9076,8 +9082,10 @@
 
                xhr.onload = async function (event) {
 
+                   const isFileProtocol = url.toLowerCase().startsWith("file:");
+
                    // when the url points to a local file, the status is 0
-                   if (xhr.status === 0 || (xhr.status >= 200 && xhr.status <= 300)) {
+                   if ((xhr.status >= 200 && xhr.status <= 300) || (isFileProtocol && xhr.status === 0)) {
                        if ("HEAD" === options.method) {
                            // Support fetching specific headers.  Attempting to fetch all headers can be problematic with CORS
                            const headers = options.requestedHeaders || ['content-length'];
@@ -9093,7 +9101,7 @@
                                // For small files a range starting at 0 can return the whole file => 200
                                // Provide just the slice we asked for, throw out the rest quietly
                                // If file is large warn user
-                               if (xhr.response.length > 100000 && !self.RANGE_WARNING_GIVEN) {
+                               if (xhr.response.length > 1000000 && !self.RANGE_WARNING_GIVEN) {
                                    alert(`Warning: Range header ignored for URL: ${url}.  This can have severe performance impacts.`);
                                }
                                resolve(xhr.response.slice(range.start, range.start + range.size));
@@ -9110,20 +9118,29 @@
                        tryGoogleAuth();
 
                    } else {
+                       const error = new Error(`Error accessing resource: ${url} status: ${xhr.status}`);
                        if (xhr.status === 403) {
                            handleError("Access forbidden: " + url);
+                       } else if (host === self.UCSC_HOST) {
+                           tryUcscBackup(self.UCSC_HOST, self.UCSC_BACKUP_HOST, error);
+                       } else if (xhr.status === 0 && self.corsProxy && !options.corsProxyRetried) {
+                           tryCorsProxy(error);
                        } else {
-                           handleError(xhr.status);
+                           handleError(error);
                        }
                    }
                };
 
-
                xhr.onerror = function (event) {
+                   const error = new Error(`Error accessing resource: ${url} status: ${xhr.status}`);
                    if (isGoogleURL(url) && !options.retries) {
                        tryGoogleAuth();
+                   } else if (host === self.UCSC_HOST) {
+                       tryUcscBackup(self.UCSC_HOST, self.UCSC_BACKUP_HOST, error);
+                   } else if (self.corsProxy && !options.corsProxyRetried) {
+                       tryCorsProxy(error);
                    } else {
-                       handleError("Error accessing resource: " + url + " Status: " + xhr.status);
+                       handleError(error);
                    }
                };
 
@@ -9155,6 +9172,27 @@
                    }
                }
 
+               async function tryCorsProxy(error) {
+                   options.corsProxyRetried = true;
+                   const proxyUrl = self.corsProxy + (_url.includes("?") ? "&" : "?") + "url=" + encodeURIComponent(_url);
+                   try {
+                       const result = await self._loadURL(proxyUrl, options);
+                       resolve(result);
+                   } catch (e) {
+                       handleError(error);
+                   }
+               }
+
+               async function tryUcscBackup(UCSC_HOST, UCSC_BACKUP_HOST, error) {
+                   const backupUrl = _url.replace(UCSC_HOST, UCSC_BACKUP_HOST);
+                   try {
+                       const result = await self._loadURL(backupUrl, options);
+                       resolve(result);
+                   } catch (e) {
+                       handleError(error);
+                   }
+               }
+
                async function tryGoogleAuth() {
                    try {
                        const accessToken = await fetchGoogleAccessToken(_url);
@@ -9173,6 +9211,8 @@
                        }
                    }
                }
+
+
            })
 
        }
@@ -9245,20 +9285,29 @@
        }
 
        /**
-        * This method should only be called when it is known the server supports HEAD requests.  It is used to recover
-        * from 416 errors from out-of-spec WRT range request servers.  Notably Globus.
-        * * *
+        * Return the content length of the file at the given URL.  This is not guaranteed to succeed, some servers
+        * do not support or allow the content-length header.
+        *
         * @param url
         * @param options
         * @returns {Promise<unknown>}
         */
        async getContentLength(url, options) {
-           options = options || {};
-           options.method = 'HEAD';
-           options.requestedHeaders = ['content-length'];
-           const headerMap = await this._loadURL(url, options);
-           const contentLengthString = headerMap['content-length'];
-           return contentLengthString ? Number.parseInt(contentLengthString) : 0
+           if (isFile(url)) {
+               return url.size
+           } else {
+               try {
+                   options = options || {};
+                   options.method = 'HEAD';
+                   options.requestedHeaders = ['content-length'];
+                   const headerMap = await this._loadURL(url, options);
+                   const contentLengthString = headerMap['content-length'];
+                   return contentLengthString ? Number.parseInt(contentLengthString) : 0
+               } catch (e) {
+                   console.error(e);
+                   return -1
+               }
+           }
        }
 
    }
@@ -20670,6 +20719,7 @@
 
            switch (config.format) {
                case "vcf":
+               case "vcftabix":
                    return new VcfParser(config)
                case "seg" :
                    return new SegParser("seg")
@@ -21281,6 +21331,7 @@
        }
    }
 
+   // Base class for feature sources.  Subclasses must implement getFeatures().
    class BaseFeatureSource {
 
        constructor(genome) {
@@ -21342,59 +21393,10 @@
            }
        }
 
-       async previousFeature(chr, position, direction, visibilityWindow) {
-
-           let chromosomeNames = this.genome.chromosomeNames || [chr];
-           let idx = chromosomeNames.indexOf(chr);
-           if (idx < 0) return // This shouldn't happen
-
-           // Look ahead (or behind) in 10 kb intervals, but no further than visibilityWindow
-           const window = Math.min(10000, visibilityWindow || 10000);
-           let queryStart = direction ? position : Math.max(position - window, 0);
-           while (idx < chromosomeNames.length && idx >= 0) {
-               chr = chromosomeNames[idx];
-               const chromosome = this.genome.getChromosome(chr);
-               const chromosomeEnd = chromosome.bpLength;
-               while (queryStart < chromosomeEnd && queryStart >= 0) {
-                   let queryEnd = Math.min(position, queryStart + window);
-                   const featureList = await this.getFeatures({chr, start: queryStart, end: queryEnd, visibilityWindow});
-                   if (featureList) {
-
-                       const compare = (o1, o2) => o1.start - o2.start + o1.end - o2.end;
-                       const sortedList = Array.from(featureList);
-                       sortedList.sort(compare);
-
-                       // Search for next or previous feature relative to centers.  We use a linear search because the
-                       // feature is likely to be near the first or end of the list
-                       let idx = direction ? 0 : sortedList.length - 1;
-                       while(idx >= 0 && idx < sortedList.length) {
-                           const f = sortedList[idx];
-                           const center = (f.start + f.end) / 2;
-                           if(direction) {
-                               if(center > position) return f
-                               idx++;
-                           } else {
-                               if(center < position) return f
-                               idx--;
-                           }
-                       }
-                   }
-                   queryStart = direction ? queryEnd : queryStart - window;
-               }
-               if (direction) {
-                   idx++;
-                   queryStart = 0;
-                   position = 0;
-               } else {
-                   idx--;
-                   if (idx < 0) break
-                   const prevChromosome = this.genome.getChromosome(chromosomeNames[idx]);
-                   position = prevChromosome.bpLength;
-                   queryStart = position - window;
-               }
-           }
+       // Subclasses must implement
+       async getFeatures({chr, start, end, bpPerPixel, visibilityWindow}) {
+           throw new Error("getFeatures not implemented")
        }
-
    }
 
    const GZIP_FLAG = 0x1;
@@ -26533,6 +26535,88 @@
        }
    }
 
+   /**
+    * A feature source for a "list" file.  A list file is a text file with two columns, chromosome and URL.  It was
+    * created for the 1KG genotype files, which are split by chromosome, and at the moment that is the only use case.
+    */
+
+   class ListFeatureSource extends BaseFeatureSource {
+
+       constructor(config, genome) {
+           super(genome);
+           this.config = config;
+           this.featureSourceMap = null;
+           this.header = null;
+       }
+
+       async getHeader() {
+
+           if (!this.header) {
+
+               if (!this.featureSourceMap) {
+                   await this.init();
+               }
+               // Return the header from the first feature source.  It is assumed that all sources have a common header.
+               const firstFS = this.featureSourceMap.values().next().value;
+               if (firstFS && firstFS.getHeader) {
+                   this.header = firstFS.getHeader();
+               } else {
+                   this.header = Promise.resolve(undefined);
+               }
+           }
+
+           return this.header
+
+       }
+
+       async getFeatures({chr, start, end, bpPerPixel, visibilityWindow}) {
+
+           if (!this.featureSourceMap) {
+               await this.init();
+           }
+           const fs = this.featureSourceMap.get(chr);
+           if (fs) {
+               return fs.getFeatures({chr, start, end, bpPerPixel, visibilityWindow})
+           } else {
+               return []
+           }
+       }
+
+       async init() {
+           this.featureSourceMap = new Map();
+
+           const options = buildOptions(this.config);
+           const data = await igvxhr.loadByteArray(this.config.url, options);
+           const dataWrapper = getDataWrapper(data);
+
+           let line;
+           while ((line = dataWrapper.nextLine()) !== undefined) {
+               const trimmed = line.trim();
+               if (!trimmed.startsWith('#')) {
+                   const tokens = trimmed.split(/\s+/);
+                   if (tokens.length > 1) {
+                       const chr = tokens[0];
+                       const path = tokens[1];
+                       const sourceConfig = Object.assign({}, this.config);
+                       sourceConfig.url = path;
+                       if (path.endsWith(".vcf.gz")) {
+                           sourceConfig.format = "vcf";
+                           sourceConfig.indexURL = path + ".tbi";
+                       }
+                       this.featureSourceMap.set(chr, FeatureSource(sourceConfig, this.genome));
+                   }
+               }
+           }
+       }
+
+       supportWholeGenome() {
+           return false
+       }
+   }
+
+   // chrY	https://1000genomes.s3.amazonaws.com/release/20130502/ALL.chrY.phase3_integrated_v1b.20130502.genotypes.vcf.gz
+   // chrX	https://1000genomes.s3.amazonaws.com/release/20130502/ALL.chrX.phase3_shapeit2_mvncall_integrated_v1b.20130502.genotypes.vcf.gz
+
    const bbFormats = new Set(['bigwig', 'bw', 'bigbed', 'bb', 'biginteract', 'biggenepred', 'bignarrowpeak']);
 
    function FeatureSource(config, genome) {
@@ -26547,6 +26631,9 @@
            return new TDFSource(config, genome)
        } else if ("gbk" === format) {
            return new GenbankFeatureSource(config, genome)
+       } else if ("vcf.list" === format) {
+           // This is a text file with two columns:   <chr>  <url to vcf>
+           return new ListFeatureSource(config, genome)
        } else {
            return new TextFeatureSource(config, genome)
        }
@@ -27017,14 +27104,14 @@
            if (phase) {
                stringA = sequenceInterval.getSequence(phaseExtentStart, phaseExtentEnd);
 
-               if (undefined === stringA) {
+               if (!stringA) {
                    return undefined
                }
 
                [ss, ee] = [getEonStart(riteExon), getEonStart(riteExon) + (3 - phase)];
                stringB = sequenceInterval.getSequence(ss, ee);
 
-               if (undefined === stringB) {
+               if (!stringB) {
                    return undefined
                }
 
@@ -27036,7 +27123,7 @@
            if (remainder) {
                stringB = sequenceInterval.getSequence(remainder.start, remainder.end);
 
-               if (undefined === stringB) {
+               if (!stringB) {
                    return undefined
                }
 
@@ -27044,7 +27131,7 @@
                const leftEnd = getExonEnd(leftExon);
                stringA = sequenceInterval.getSequence(leftEnd - leftPhase, leftEnd);
 
-               if (undefined === stringA) {
+               if (!stringA) {
                    return undefined
                }
 
@@ -30409,6 +30496,19 @@
    const filterTracks = new Set(["cytoBandIdeo", "assembly", "gap", "gapOverlap", "allGaps",
        "cpgIslandExtUnmasked", "windowMasker"]);
 
+   const vizModeMap = new Map([
+       ["pack", "EXPANDED"],
+       ["full", "EXPANDED"],
+       ["squish", "SQUISHED"],
+       ["dense", "COLLAPSED"]
+   ]);
+   const typeFormatMap = new Map([
+       ["vcftabix", "vcf"],
+       ["vcfphasedtrio", "vcf"],
+       ["bigdbsnp", "bigbed"],
+       ["genepred", "refgene"]
+   ]);
+
    class TrackDbHub {
 
        constructor(trackStanzas, groupStanzas) {
@@ -30554,14 +30654,13 @@
         */
        #getTrackConfig(t) {
 
-           const format = t.format;
+           const format = typeFormatMap.get(t.format) || t.format;
 
            const config = {
                "id": t.getProperty("track"),
                "name": t.getProperty("shortLabel"),
                "format": format,
-               "url": t.getProperty("bigDataUrl"),
-               "displayMode": t.displayMode,
+               "url": t.getProperty("bigDataUrl")
            };
 
            if ("vcfTabix" === format) {
@@ -30611,9 +30710,14 @@
 
            }
            if (t.hasProperty("itemRgb")) ;
-           if ("hide" === t.getProperty("visibility")) {
-               // TODO -- this not supported yet
-               config.visible = false;
+           if(t.hasProperty("visibility")) {
+               if ("hide" === t.getProperty("visibility")) {
+                   // TODO -- this not supported yet
+                   config.visible = false;
+               }
+               else {
+                   config.displayMode = vizModeMap.get(t.getProperty("visibility")) || "COLLAPSED";
+               }
            }
            if (t.hasProperty("url")) {
                config.infoURL = t.getProperty("url");
@@ -37794,6 +37898,8 @@
                case "tdf":
                    return "wig"
                case "vcf":
+               case "vcftabix":
+               case "vcf.list":
                    return "variant"
                case "seg":
                    return "seg"
@@ -37848,7 +37954,7 @@
        } else if ("bam" === config.type) {
            config.type = "alignment";
            config.format = "bam";
-       } else if ("vcf" === config.type) {
+       } else if ("vcf" === config.type || "vcftabix" === config.type) {
            config.type = "variant";
            config.format = "vcf";
        } else if ("t2d" === config.type) {
@@ -38128,7 +38234,7 @@
            const groupIndeces = NULL_GROUP !== this.groupBy ?
                this.sampleKeys.map(sample => this.getGroupIndex(sample)) : undefined;
            return {
-               names: this.sampleKeys,
+               names: this.sampleKeys || [],
                height: this.sampleHeight,
                yOffset: 0,
                groups: this.groups,
@@ -42831,6 +42937,49 @@
            const end = Number.parseInt(se[1].replace(/,/g, ""));
            return new Locus({chr, start, end})
        }
+
+       /**
+        * Return true if the locus string represents a single base, e.g. "chr1:12345" or "chr1:12345-12345"
+        * @param locus
+        * @returns {boolean}
+        */
+       static isSingleBaseLocusString(locus) {
+
+           if (!locus || typeof locus !== 'string') {
+               return false
+           }
+
+           const parts = locus.split(':');
+           if (parts.length <= 1) {
+               return false
+           }
+
+           const range = parts[1].replace(/,/g, '');
+           if (!range) {
+               return false
+           }
+
+           const rangeParts = range.split('-');
+           const startString = rangeParts[0];
+           const start = parseInt(startString, 10);
+
+           if (String(start) !== startString || !Number.isInteger(start)) {
+               return false
+           }
+
+           if (rangeParts.length === 1) {
+               return true
+           }
+
+           const endString = rangeParts[1];
+           const end = parseInt(endString, 10);
+
+           if (String(end) !== endString || !Number.isInteger(end)) {
+               return false
+           }
+
+           return start === end
+       }
    }
 
    /*!
@@ -62782,7 +62931,8 @@ ${indent}columns: ${matrix.columns}
        }
 
        get supportsWholeGenome() {
-           return !this.config.indexURL || this.config.supportsWholeGenome === true
+           const sourceSupportsWG = typeof this.featureSource.supportsWholeGenome === 'function' && this.featureSource.supportsWholeGenome();
+           return sourceSupportsWG || this.config.supportsWholeGenome === true
        }
 
        get color() {
@@ -62855,7 +63005,7 @@ ${indent}columns: ${matrix.columns}
            const yOffset = TOP_MARGIN + nVariantRows * (variantHeight + vGap);
 
            return {
-               names: this.sampleKeys,
+               names: this.sampleKeys || [],
                yOffset,
                height,
                // groups: this.groups,
@@ -66986,7 +67136,7 @@ ${indent}columns: ${matrix.columns}
        })
    }
 
-   const _version = "3.5.1";
+   const _version = "3.5.3";
    function version() {
        return _version
    }
@@ -74241,6 +74391,12 @@ ${indent}columns: ${matrix.columns}
 
            await this.loadTrackList(nonLocalTrackConfigurations);
 
+           // If an initial locus is defined and represents a single basedo a "search" here.  This will force micro
+           // adjustments after width of track column(s) is known.  This can be an issue when the center gide is shown
+           // Without this adjustment the single base would be off center by a few pixels.
+           if (session.locus && Locus.isSingleBaseLocusString(session.locus)) {
+               await this.search(session.locus);
+           }
        }
 
        cleanHouseForSession() {
@@ -74527,6 +74683,10 @@ ${indent}columns: ${matrix.columns}
                config = JSON.parse(config);
            }
 
+           if(config.format && config.format.toLowerCase() === 'sampleinfo') {
+               return this.loadSampleInfo(config)
+           }
+
            let track;
            try {
                track = await this.createTrack(config);
@@ -76303,6 +76463,10 @@ ${indent}columns: ${matrix.columns}
        return igvxhr.setOauthToken(accessToken, host)
    }
 
+   function setCORSProxy(proxyURL) {
+       igvxhr.corsProxy = proxyURL;
+   }
+
    // Backward compatibility
    const oauth = igvxhr.oauth;
 
@@ -76319,6 +76483,7 @@ ${indent}columns: ${matrix.columns}
        visibilityChange,
        setGoogleOauthToken,
        setOauthToken,
+       setCORSProxy,
        oauth,
        version,
        setApiKey,