igv 3.2.4 → 3.2.6

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
        }
    }
 
@@ -10946,7 +10952,7 @@
        return list;
    }
 
-   /*! @license DOMPurify 3.2.4 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.4/LICENSE */
+   /*! @license DOMPurify 3.2.5 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.5/LICENSE */
 
    const {
      entries,
@@ -11006,6 +11012,9 @@
     */
    function unapply(func) {
      return function (thisArg) {
+       if (thisArg instanceof RegExp) {
+         thisArg.lastIndex = 0;
+       }
        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }
@@ -11244,7 +11253,7 @@
    function createDOMPurify() {
      let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
      const DOMPurify = root => createDOMPurify(root);
-     DOMPurify.version = '3.2.4';
+     DOMPurify.version = '3.2.5';
      DOMPurify.removed = [];
      if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
        // Not running in a browser, provide a factory function
@@ -11849,7 +11858,7 @@
          allowedTags: ALLOWED_TAGS
        });
        /* Detect mXSS attempts abusing namespace confusion */
-       if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+       if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
          _forceRemove(currentNode);
          return true;
        }
@@ -16343,7 +16352,10 @@
                    }
                } else {
                    // All directives that could change the format, and thus decoder, should have been read by now.
-                   this.setDecoder(header.format);
+                   // Set the decoder, unless it is explicitly set in the track configuration (not common)
+                   if(!this.config.decode) {
+                       this.setDecoder(header.format);
+                   }
 
                    // If the line can be parsed as a feature assume we are beyond the header, if any
                    const tokens = line.split(this.delimiter || "\t");
@@ -30852,6 +30864,7 @@
    }
 
    const DEFAULT_GENOMES_URL = "https://igv.org/genomes/genomes.json";
+   const BACKUP_GENOMES_URL = "https://raw.githubusercontent.com/igvteam/igv-genomes/refs/heads/main/dist/genomes.json";
 
    const GenomeUtils = {
 
@@ -30859,34 +30872,42 @@
 
            if (!GenomeUtils.KNOWN_GENOMES) {
 
-               const table = {};
+               let table = {};
+
+               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, table);
+                   } catch (error) {
+                       try {
+                           console.error("Error initializing default genomes:", error);
+                           const jsonArray = await igvxhr.loadJson(BACKUP_GENOMES_URL, {timeout: 2000});
+                           processJson(jsonArray, table);
+                       } 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, table);
                    } else {
-                       processJson(genomeList);
+                        processJson(genomeList, table);
                    }
                }
-
                GenomeUtils.KNOWN_GENOMES = table;
-
-               function processJson(jsonArray) {
-                   jsonArray.forEach(function (json) {
-                       table[json.id] = json;
-                   });
-                   return table
-               }
            }
        },
 
@@ -30912,7 +30933,7 @@
            } else if (idOrConfig.genome) {
                genomeID = idOrConfig.genome;
            } else if (idOrConfig.id !== undefined && !(idOrConfig.fastaURL || idOrConfig.twobitURL)) {
-               // Backward compatibilityz
+               // Backward compatibility
                genomeID = idOrConfig.id;
            }
 
@@ -47613,7 +47634,7 @@
            if (!this.colorBy) {
                this.colorBy = this.hasPairs ? "unexpectedPair" : "none";
            }
-           
+
            let pixelTop = options.pixelTop - BAMTrack.coverageTrackHeight;
            if (this.top) {
                ctx.translate(0, this.top);
@@ -48320,7 +48341,12 @@
                this.trackView.repaintViews();
            }
 
-           return {name: undefined, element: createCheckbox(menuItem.label, showCheck), click: clickHandler, init: undefined}
+           return {
+               name: undefined,
+               element: createCheckbox(menuItem.label, showCheck),
+               click: clickHandler,
+               init: undefined
+           }
        }
 
 
@@ -48367,7 +48393,12 @@
                }
            }
 
-           return {name: undefined, element: createCheckbox(menuItem.label, showCheck), dialog: clickHandler, init: undefined}
+           return {
+               name: undefined,
+               element: createCheckbox(menuItem.label, showCheck),
+               dialog: clickHandler,
+               init: undefined
+           }
 
        }
 
@@ -48489,38 +48520,88 @@
                        });
                    }
 
+                   list.push('<hr/>');
+                   const softClips = clickedAlignment.softClippedBlocks();
                    list.push({
                        label: 'View read sequence',
                        click: () => {
-                           const seqstring = clickedAlignment.seq; //.map(b => String.fromCharCode(b)).join("");
-                           if (!seqstring || "*" === seqstring) {
-                               this.browser.alert.present("Read sequence: *");
-                           } else {
-                               this.browser.alert.present(seqstring);
-                           }
+                           const seqstring = clickedAlignment.seq;
+                           this.browser.alert.present(seqstring && seqstring !== "*" ? seqstring : "Read sequence: *");
                        }
                    });
 
+                   if (softClips.left && softClips.left.len > 0) {
+                       list.push({
+                           label: 'View left soft-clipped sequence',
+                           click: () => {
+                               const clippedSequence = clickedAlignment.seq.substring(softClips.left.seqOffset, softClips.left.seqOffset + softClips.left.len);
+                               this.browser.alert.present(clippedSequence);
+                           }
+                       });
+                   }
+
+                   if (softClips.right && softClips.right.len > 0) {
+                       list.push({
+                           label: 'View right soft-clipped sequence',
+                           click: () => {
+                               const clippedSequence = clickedAlignment.seq.substring(softClips.right.seqOffset, softClips.right.seqOffset + softClips.right.len);
+                               this.browser.alert.present(clippedSequence);
+                           }
+                       });
+                   }
+
+                   list.push('<hr/>');
+
                    if (isSecureContext()) {
                        list.push({
                            label: 'Copy read sequence',
                            click: async () => {
-                               const seq = clickedAlignment.seq; //.map(b => String.fromCharCode(b)).join("");
                                try {
-                                   await navigator.clipboard.writeText(seq);
+                                   await navigator.clipboard.writeText(clickedAlignment.seq);
                                } catch (e) {
                                    console.error(e);
                                    this.browser.alert.present(`error copying sequence to clipboard ${e}`);
                                }
-
                            }
                        });
+
+                       if (softClips.left && softClips.left.len > 0) {
+                           list.push({
+                               label: 'Copy left soft-clipped sequence',
+                               click: async () => {
+                                   try {
+                                       const clippedSequence = clickedAlignment.seq.substring(softClips.left.seqOffset, softClips.left.seqOffset + softClips.left.len);
+                                       await navigator.clipboard.writeText(clippedSequence);
+                                   } catch (e) {
+                                       console.error(e);
+                                       this.browser.alert.present(`error copying sequence to clipboard ${e}`);
+                                   }
+                               }
+                           });
+                       }
+
+                       if (softClips.right && softClips.right.len > 0) {
+                           list.push({
+                               label: 'Copy right soft-clipped sequence',
+                               click: async () => {
+                                   try {
+                                       const clippedSequence = clickedAlignment.seq.substring(softClips.right.seqOffset, softClips.right.seqOffset + softClips.right.len);
+                                       await navigator.clipboard.writeText(clippedSequence);
+                                   } catch (e) {
+                                       console.error(e);
+                                       this.browser.alert.present(`error copying sequence to clipboard ${e}`);
+                                   }
+                               }
+                           });
+                       }
                    }
 
-                   // TODO if genome supports blat
+                   // TODO test if genome supports blat
                    const seqstring = clickedAlignment.seq;
                    if (seqstring && "*" !== seqstring) {
 
+                       list.push('<hr/>');
+
                        if (seqstring.length < maxSequenceSize$1) {
                            list.push({
                                label: 'BLAT read sequence',
@@ -48538,7 +48619,7 @@
                            list.push({
                                label: 'BLAT left soft-clipped sequence',
                                click: () => {
-                                   const clippedSequence = seqstring.substr(softClips.left.seqOffset, softClips.left.len);
+                                   const clippedSequence = seqstring.substring(softClips.left.seqOffset, softClips.left.seqOffset + softClips.left.len);
                                    const sequence = clickedAlignment.isNegativeStrand() ? reverseComplementSequence(clippedSequence) : clippedSequence;
                                    const name = `${clickedAlignment.readName} - blat left clip`;
                                    const title = `${this.name} - ${name}`;
@@ -48550,7 +48631,7 @@
                            list.push({
                                label: 'BLAT right soft-clipped sequence',
                                click: () => {
-                                   const clippedSequence = seqstring.substr(softClips.right.seqOffset, softClips.right.len);
+                                   const clippedSequence = seqstring.substring(softClips.right.seqOffset, softClips.right.seqOffset + softClips.right.len);
                                    const sequence = clickedAlignment.isNegativeStrand() ? reverseComplementSequence(clippedSequence) : clippedSequence;
                                    const name = `${clickedAlignment.readName} - blat right clip`;
                                    const title = `${this.name} - ${name}`;
@@ -48599,7 +48680,7 @@
            const offsetY = y - this.top;
            const genomicLocation = clickState.genomicLocation;
 
-           if(features.packedGroups) {
+           if (features.packedGroups) {
                let minGroupY = Number.MAX_VALUE;
                for (let group of features.packedGroups.values()) {
                    minGroupY = Math.min(minGroupY, group.pixelTop);
@@ -68825,6 +68906,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 +69040,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 +69519,7 @@ ${indent}columns: ${matrix.columns}
        })
    }
 
-   const _version = "3.2.4";
+   const _version = "3.2.6";
    function version() {
        return _version
    }
@@ -73871,7 +74062,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++;