igv 3.5.2 → 3.5.3

package/dist/igv.esm.js

@@ -8702,7 +8702,7 @@ async function getDriveFileInfo(googleDriveURL) {
     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, {
@@ -8884,6 +8884,10 @@ class Throttle {
 
 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({
@@ -8891,6 +8895,7 @@ class IGVXhr {
         });
         this.RANGE_WARNING_GIVEN = false;
         this.oauth = new Oauth();
+        this.corsProxy = undefined;
     }
 
     setApiKey(key) {
@@ -8915,7 +8920,7 @@ class IGVXhr {
      * @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)) {
@@ -8960,7 +8965,7 @@ class IGVXhr {
 
         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) {
@@ -8990,6 +8995,7 @@ class IGVXhr {
 
         const self = this;
         const _url = url;   // The unmodified URL, needed in case of an oAuth retry
+        const {host} = parseUri(_url);
 
         url = mapUrl$1(url);
 
@@ -9070,8 +9076,10 @@ class IGVXhr {
 
             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'];
@@ -9087,7 +9095,7 @@ class IGVXhr {
                             // 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));
@@ -9104,20 +9112,29 @@ class IGVXhr {
                     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);
                 }
             };
 
@@ -9149,6 +9166,27 @@ class IGVXhr {
                 }
             }
 
+            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);
@@ -9167,6 +9205,8 @@ class IGVXhr {
                     }
                 }
             }
+
+
         })
 
     }
@@ -9239,20 +9279,29 @@ class IGVXhr {
     }
 
     /**
-     * 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
+            }
+        }
     }
 
 }
@@ -20664,6 +20713,7 @@ class FeatureFileReader {
 
         switch (config.format) {
             case "vcf":
+            case "vcftabix":
                 return new VcfParser(config)
             case "seg" :
                 return new SegParser("seg")
@@ -21275,6 +21325,7 @@ class HtsgetVariantReader extends HtsgetReader {
     }
 }
 
+// Base class for feature sources.  Subclasses must implement getFeatures().
 class BaseFeatureSource {
 
     constructor(genome) {
@@ -21336,59 +21387,10 @@ class BaseFeatureSource {
         }
     }
 
-    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;
@@ -26527,6 +26529,88 @@ class GenbankFeatureSource extends BaseFeatureSource {
     }
 }
 
+/**
+ * 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) {
@@ -26541,6 +26625,9 @@ function FeatureSource(config, genome) {
         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)
     }
@@ -30403,6 +30490,19 @@ const supportedTypes = new Set([
 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) {
@@ -30548,14 +30648,13 @@ class TrackDbHub {
      */
     #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) {
@@ -30605,9 +30704,14 @@ class TrackDbHub {
 
         }
         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");
@@ -37788,6 +37892,8 @@ function inferTrackType(format) {
             case "tdf":
                 return "wig"
             case "vcf":
+            case "vcftabix":
+            case "vcf.list":
                 return "variant"
             case "seg":
                 return "seg"
@@ -37842,7 +37948,7 @@ function translateDeprecatedTypes(config) {
     } 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) {
@@ -38122,7 +38228,7 @@ class SegTrack extends TrackBase {
         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,
@@ -62819,7 +62925,8 @@ class VariantTrack extends TrackBase {
     }
 
     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() {
@@ -62892,7 +62999,7 @@ class VariantTrack extends TrackBase {
         const yOffset = TOP_MARGIN + nVariantRows * (variantHeight + vGap);
 
         return {
-            names: this.sampleKeys,
+            names: this.sampleKeys || [],
             yOffset,
             height,
             // groups: this.groups,
@@ -67023,7 +67130,7 @@ function createReferenceFrameList(loci, genome, browserFlanking, minimumBases, v
     })
 }
 
-const _version = "3.5.2";
+const _version = "3.5.3";
 function version() {
     return _version
 }
@@ -74570,6 +74677,10 @@ class Browser {
             config = JSON.parse(config);
         }
 
+        if(config.format && config.format.toLowerCase() === 'sampleinfo') {
+            return this.loadSampleInfo(config)
+        }
+
         let track;
         try {
             track = await this.createTrack(config);
@@ -76346,6 +76457,10 @@ function setOauthToken(accessToken, host) {
     return igvxhr.setOauthToken(accessToken, host)
 }
 
+function setCORSProxy(proxyURL) {
+    igvxhr.corsProxy = proxyURL;
+}
+
 // Backward compatibility
 const oauth = igvxhr.oauth;
 
@@ -76362,6 +76477,7 @@ var index = {
     visibilityChange,
     setGoogleOauthToken,
     setOauthToken,
+    setCORSProxy,
     oauth,
     version,
     setApiKey,