igv 3.2.4 → 3.2.5

package/dist/igv.js

@@ -8629,6 +8629,7 @@
    }
 
 
+   let promise;
    /**
     * Return a promise for an access token for the given scope.  If the user hasn't authorized the scope request it
     *
@@ -8647,22 +8648,27 @@
            return google.igv.tokenResponse.access_token
        } else {
            const tokenClient = google.igv.tokenClient;
-           return new Promise((resolve, reject) => {
-               try {
-                   // Settle this promise in the response callback for requestAccessToken()
-                   tokenClient.callback = (tokenResponse) => {
-                       if (tokenResponse.error !== undefined) {
-                           reject(tokenResponse);
-                       }
-                       google.igv.tokenResponse = tokenResponse;
-                       google.igv.tokenExpiresAt = Date.now() + tokenResponse.expires_in * 1000;
-                       resolve(tokenResponse.access_token);
-                   };
-                   tokenClient.requestAccessToken({scope});
-               } catch (err) {
-                   console.log(err);
-               }
-           })
+           if(!promise) {
+               promise = new Promise((resolve, reject) => {
+                   try {
+                       // Settle this promise in the response callback for requestAccessToken()
+                       tokenClient.callback = (tokenResponse) => {
+                           if (tokenResponse.error !== undefined) {
+                               reject(tokenResponse);
+                           }
+                           google.igv.tokenResponse = tokenResponse;
+                           google.igv.tokenExpiresAt = Date.now() + tokenResponse.expires_in * 1000;
+                           console.log("Access token expires at " + new Date(google.igv.tokenExpiresAt));
+                           resolve(tokenResponse.access_token);
+                       };
+                       console.log("Requesting access token");
+                       tokenClient.requestAccessToken({scope});
+                   } catch (err) {
+                       console.log(err);
+                   }
+               });
+           }
+           return promise
        }
    }
 
@@ -30852,6 +30858,7 @@
    }
 
    const DEFAULT_GENOMES_URL = "https://igv.org/genomes/genomes.json";
+   const BACKUP_GENOMES_URL = "https://raw.githubusercontent.com/igvteam/igv.js/main/packages/igv/src/genomes/genomes.json";
 
    const GenomeUtils = {
 
@@ -30859,34 +30866,41 @@
 
            if (!GenomeUtils.KNOWN_GENOMES) {
 
-               const table = {};
+               GenomeUtils.KNOWN_GENOMES = {};
+
+               const processJson = (jsonArray, table) => {
+                   jsonArray.forEach(function (json) {
+                       table[json.id] = json;
+                   });
+                   return table
+               };
 
                // Get default genomes
                if (config.loadDefaultGenomes !== false) {
-                   const url = DEFAULT_GENOMES_URL;
-                   const jsonArray = await igvxhr.loadJson(url, {timeout: 5000});
-                   processJson(jsonArray);
+                   try {
+                       const jsonArray = await igvxhr.loadJson(DEFAULT_GENOMES_URL, {timeout: 2000});
+                       processJson(jsonArray, GenomeUtils.KNOWN_GENOMES);
+                   } catch (error) {
+                       try {
+                           console.error("Error initializing default genomes:", error);
+                           const jsonArray = await igvxhr.loadJson(BACKUP_GENOMES_URL, {timeout: 2000});
+                           processJson(jsonArray, GenomeUtils.KNOWN_GENOMES);
+                       } catch (e) {
+                           console.error("Error initializing backup genomes:", error);
+                       }
+                   }
                }
 
-               // Add user-defined genomes
+               // Append user-defined genomes, which might override defaults
                const genomeList = config.genomeList || config.genomes;
                if (genomeList) {
                    if (typeof genomeList === 'string') {
                        const jsonArray = await igvxhr.loadJson(genomeList, {});
-                       processJson(jsonArray);
+                        processJson(jsonArray, GenomeUtils.KNOWN_GENOMES);
                    } else {
-                       processJson(genomeList);
+                        processJson(genomeList, GenomeUtils.KNOWN_GENOMES);
                    }
                }
-
-               GenomeUtils.KNOWN_GENOMES = table;
-
-               function processJson(jsonArray) {
-                   jsonArray.forEach(function (json) {
-                       table[json.id] = json;
-                   });
-                   return table
-               }
            }
        },
 
@@ -30912,7 +30926,7 @@
            } else if (idOrConfig.genome) {
                genomeID = idOrConfig.genome;
            } else if (idOrConfig.id !== undefined && !(idOrConfig.fastaURL || idOrConfig.twobitURL)) {
-               // Backward compatibilityz
+               // Backward compatibility
                genomeID = idOrConfig.id;
            }
 
@@ -68825,6 +68839,115 @@ ${indent}columns: ${matrix.columns}
        }
    }
 
+   /**
+    * Configurable properties
+    * Locus {chr, start, end}
+    * url - url to image.   Later url to webservice to fetch image
+    */
+
+   class ImageTrack extends TrackBase {
+
+       static defaults = {}
+
+       constructor(config, browser) {
+           super(config, browser);
+       }
+
+       init(config) {
+
+           super.init(config);
+
+           if (!config.images) {
+               throw Error("images are required")
+           }
+
+           this.locus = config.locus;
+           this.type = "image";
+           this.resolutionAware = true;
+       }
+
+
+       async postInit() {
+
+           this._images = [];
+
+           for (let i of this.config.images) {
+               const img = new Image();
+               img.onload = () => {
+                   i.img = img;
+                   i.bpPerPixel = (i.end - i.start) / img.width;
+                   this._images.push(i);
+               };
+               img.onerror = (err) => {
+                   console.error(err);
+               };
+               //if (img.complete) {   //cached image
+               //    img.onload()
+              // }
+               img.src = i.src;
+           }
+
+       }
+
+       computePixelHeight(features) {
+           return features ? features.height : 0
+       }
+
+
+       menuItemList() {
+
+           const menuItems = [];
+
+           return menuItems
+       }
+
+
+       async getFeatures(chr, start, end, bpPerPixel) {
+           // Return  image.  Scaled or not?
+           return this.selectImage(chr, start, end, bpPerPixel)
+       }
+
+       selectImage(chr, start, end, bpPerPixel) {
+
+           // Select the highest resolution image containing the interval.  If no image contains the interval return
+           // the lowest resolution image if it overlaps
+           if(this._images.length == 0) {
+               return null
+           }
+           this._images.sort((a, b) => a.bpPerPixel < b.bpPerPixel ? -1 : 1);
+           for(let i of this._images) {
+               if(i.bpPerPixel > bpPerPixel) {
+                   return i
+               }
+           }
+           const lowRes = this._images[this._images.length-1];
+           if(lowRes.chr === chr) {
+               return lowRes
+           } else {
+               return null
+           }
+       }
+
+       draw({context, pixelTop, pixelWidth, pixelHeight, features, bpPerPixel, bpStart}) {
+
+           const image = features.img;
+           if (image) {
+               const nw = image.width;
+               const nh = image.height;
+               const imageBpPerPixel = (features.end - features.start) / nw;
+               const scale = imageBpPerPixel / bpPerPixel;
+               const x = (features.start - bpStart) / bpPerPixel;
+               context.drawImage(image, x, 0, scale * nw, nh);
+           }
+
+       }
+
+       get supportsWholeGenome() {
+           return false
+       }
+
+   }
+
    //import CNVPytorTrack from "./CNVpytor/cnvpytorTrack.js"
 
 
@@ -68850,7 +68973,8 @@ ${indent}columns: ${matrix.columns}
            ['gcnv', (config, browser) => new GCNVTrack(config, browser)],
            ['junction', (config, browser) => new SpliceJunctionTrack(config, browser)],
            ['blat', (config, browser) => new BlatTrack(config, browser)],
-           ['cnvpytor', (config, browser) => new CNVPytorTrack(config, browser)]
+           ['cnvpytor', (config, browser) => new CNVPytorTrack(config, browser)],
+           ['image', (config, browser) => new ImageTrack(config, browser)]
        ]);
 
 
@@ -69328,7 +69452,7 @@ ${indent}columns: ${matrix.columns}
        })
    }
 
-   const _version = "3.2.4";
+   const _version = "3.2.5";
    function version() {
        return _version
    }
@@ -73871,7 +73995,7 @@ ${indent}columns: ${matrix.columns}
        async loadTrackList(configList) {
 
            // Impose an order if not specified
-           let order = 0;
+           let order = this.trackViews.length + 1;
            for (let c of configList) {
                if (c.order === undefined) {
                    c.order = order++;