igv 3.0.1 → 3.0.2

package/dist/igv.js

@@ -19021,13 +19021,13 @@
             if (Array.isArray(trackViewOrTrackViewList)) {
                 dataRange = { min: Number.MAX_SAFE_INTEGER, max:-Number.MAX_SAFE_INTEGER };
                 for (const trackView of trackViewOrTrackViewList) {
-                    if (trackView.dataRange) {
-                        dataRange.min = Math.min(trackView.dataRange.min, dataRange.min);
-                        dataRange.max = Math.max(trackView.dataRange.max, dataRange.max);
+                    if (trackView.track.dataRange) {
+                        dataRange.min = Math.min(trackView.track.dataRange.min, dataRange.min);
+                        dataRange.max = Math.max(trackView.track.dataRange.max, dataRange.max);
                     }
                 }
             } else {
-                dataRange = trackViewOrTrackViewList.dataRange;
+                dataRange = trackViewOrTrackViewList.track.dataRange;
             }
 
             if (dataRange) {
@@ -19069,7 +19069,7 @@
                 } else {
                     const list = Array.isArray(trackViewOfTrackViewList) ? trackViewOfTrackViewList : [ trackViewOfTrackViewList ];
                     for (const trackView of list) {
-                        trackView.dataRange = { min, max };
+                        trackView.track.setDataRange({ min, max });
                     }
 
                 }
@@ -26702,6 +26702,14 @@
             return menuItems
         }
 
+        setDataRange({ min, max }) {
+
+            this.dataRange = { min, max };
+            this.autoscale = false;
+            this.autoscaleGroup = undefined;
+            this.trackView.repaintViews();
+        }
+
         /**
          * Return the first feature in this track whose start position is > position
          * @param chr
@@ -27069,7 +27077,7 @@
             this.filter = tokens[6];
             this.info = {};
             const infoStr = tokens[7];
-            if (infoStr) {
+            if (infoStr && infoStr !== '.') {
                 for (let elem of infoStr.split(';')) {
                     var element = elem.split('=');
                     this.info[element[0]] = element[1];
@@ -27228,9 +27236,10 @@
                 }
             }
 
-            if (this.info) {
+            const infoKeys = Object.keys(this.info);
+            if (this.info && infoKeys.length > 0) {
                 fields.push({html: '<hr style="border-top: dotted 1px;border-color: #c9c3ba" />'});
-                for (let key of Object.keys(this.info)) {
+                for (let key of infoKeys) {
                     fields.push({name: key, value: arrayToString(decodeURIComponent(this.info[key]))});
                 }
             }
@@ -27297,7 +27306,7 @@
         }
 
         getAttributeValue(key) {
-           return this.mate.getAttributeValue(key)
+            return this.mate.getAttributeValue(key)
         }
 
         getInfo(tag) {
@@ -27320,7 +27329,7 @@
             popupData.push({name: 'Pos', value: `${numberFormatter$1(this.pos)}`});
             popupData.push({html: '<hr style="border-top: dotted 1px;border-color: #c9c3ba" />'});
             popupData.push("SV");
-            popupData.push(... this.mate.popupData(genomicLocation, genomeId));
+            popupData.push(...this.mate.popupData(genomicLocation, genomeId));
 
             return popupData
         }
@@ -31216,7 +31225,7 @@
 
     function getDecoder(definedFieldCount, fieldCount, autoSql, format) {
 
-        if ("biginteract" === format || (autoSql && ('chromatinInteract' === autoSql.table) || 'interact' === autoSql.table)) {
+        if ("biginteract" === format || (autoSql && ('chromatinInteract' === autoSql.table || 'interact' === autoSql.table))) {
             return decodeInteract
         } else {
             const standardFieldCount = definedFieldCount - 3;
@@ -34422,7 +34431,7 @@
             }
 
 
-            if (!this.config.isMergedTrack) {
+            if (!this.isMergedTrack) {
                 IGVGraphics.fillRect(context, 0, options.pixelTop, pixelWidth, pixelHeight, {'fillStyle': "rgb(255, 255, 255)"});
             }
 
@@ -41611,39 +41620,36 @@
      * THE SOFTWARE.
      */
 
-
     /**
-     * Represents 2 or more wig tracks overlaid on a common viewport.
+     * Represents 2 or more  tracks overlaid on a common viewport.
      */
     class MergedTrack extends TrackBase {
 
         static defaults = {
+            autoscale: undefined,
             alpha: 0.5,
             height: 50
         }
 
-        constructor(config, browser) {
+        constructor(config, browser, tracks) {
             super(config, browser);
             this.type = "merged";
-            this.featureType = "numeric";
             this.paintAxis = paintAxis;
             this.graphType = config.graphType;
-        }
-
-        init(config) {
-            if (!(config.tracks || config._tracks)) {
-                throw Error("Error: no tracks defined for merged track" + config)
+            if (tracks) {
+                this.tracks = tracks;   // Dynamic creation, actual track objects (not configurations)
+            } else {
+                this.tracks = [];
             }
-            super.init(config);
         }
 
+
         async postInit() {
 
-            this.tracks = [];
             if (this.config.tracks) {
-                // Configured merged track
+                // Track configurations, this indicates a configured merged track as opposed to dynamic merge through the UI
+                // Actual track objects need to be created.
                 for (let tconf of this.config.tracks) {
-                    tconf.isMergedTrack = true;
                     const t = await this.browser.createTrack(tconf);
                     if (t) {
                         this.tracks.push(t);
@@ -41654,24 +41660,27 @@
                         await t.postInit();
                     }
                 }
-                // Explicit merged settings -- these will override any individual track settings
-                if (this.config.autoscale) {
-                    this.autoscale = this.config.autoscale;
-                } else if (this.config.max !== undefined) {
-                    this.dataRange = {
-                        min: this.config.min || 0,
-                        max: this.config.max
-                    };
-                } else {
-                    this.autoscale = !this.tracks.every(t => t.config.autoscale || t.config.max !== undefined);
+                // Default to autoscale unless scale if range or autoscale is not otherwise defined
+                const allTracksSpecified = this.config.tracks.every(config => config.autoscale !== undefined || config.max !== undefined);
+                if (!allTracksSpecified) {
+                    this.config.autoscale = this.config.max === undefined;
                 }
-            } else {
-                // Dynamic merged track
-                this.tracks = this.config._tracks;
-                this.autoscale = false;
-                delete this.config._tracks;
             }
 
+            // Mark constitutive tracks as merged.
+            for (let t of this.tracks) t.isMergedTrack = true;
+
+            // Explicit settings -- these will override any individual track settings
+            if(this.config.autoscale) {
+                this.autoscale = this.config.autoscale;
+            } else if (this.config.max !== undefined) {
+                this.setDataRange ({
+                    min: this.config.min || 0,
+                    max: this.config.max
+                });
+            }
+
+
             if (this.config.flipAxis !== undefined) {
                 for (let t of this.tracks) t.flipAxis = this.config.flipAxis;
             }
@@ -41681,25 +41690,28 @@
             }
 
             this.resolutionAware = this.tracks.some(t => t.resolutionAware);
-
         }
 
         set flipAxis(b) {
             this.config.flipAxis = b;
-            for (let t of this.tracks) t.flipAxis = b;
+            for (let t of numericTracks(this.tracks)) {
+                t.flipAxis = b;
+            }
         }
 
         get flipAxis() {
-            return this.tracks.every(t => t.flipAxis)
+            return numericTracks(this.tracks).every(t => t.flipAxis)
         }
 
         set logScale(b) {
             this.config.logScale = b;
-            for (let t of this.tracks) t.logScale = b;
+            for (let t of numericTracks(this.tracks)) {
+                t.logScale = b;
+            }
         }
 
         get logScale() {
-            return this.tracks.every(t => t.logScale)
+            return numericTracks(this.tracks).every(t => t.logScale)
         }
 
         get height() {
@@ -41717,49 +41729,76 @@
             }
         }
 
-        get dataRange() {
-
-            if (undefined === this.tracks || 0 === this.tracks.length) {
-                return undefined
+        set autoscale(b) {
+            this._autoscale = b;
+            if(b === false && this.tracks) {
+                for(let t of this.tracks) t.autoscale = false;
             }
+        }
 
-            const list = this.tracks.filter(track => undefined !== track.dataRange);
-            if (list.length !== this.tracks.length) {
-                return undefined
-            }
+        get autoscale() {
+            return this._autoscale
+        }
 
-            const minSet = new Set(this.tracks.map(({dataRange}) => dataRange.min));
-            if (1 !== minSet.size) {
-                return undefined
-            }
+        /**
+         * Set the data range of all constitutive numeric tracks.  This method is called from the menu item, i.e. an explicit
+         * setting, so it should disable autoscale as well.
+         *
+         * @param min
+         * @param max
+         */
 
-            const maxSet = new Set(this.tracks.map(({dataRange}) => dataRange.max));
-            if (1 !== maxSet.size) {
-                return undefined
+        setDataRange({min, max}) {
+            this.autoscale = false;
+            for (const track of numericTracks(this.tracks)) {
+                track.dataRange = {min, max};
+                track.autoscale = false;
+                track.autoscaleGroup = false;
             }
+        }
 
-            return { min: [ ...minSet ][ 0 ],  max: [ ...maxSet ][ 0 ] }
+        set dataRange({min, max}) {
+            for (const track of numericTracks(this.tracks)) {
+                track.dataRange = {min, max};
+            }
         }
 
-        set dataRange({ min, max }) {
-            for (const track of this.tracks) {
-                track.dataRange = { min, max };
+        /**
+         * Return a DataRang {min, max} if all constitutive numeric tracks have identical range.  A numeric track is defined
+         * as a track with a data range.  Otherwise return undefined.
+         *
+         * @returns {{min: any, max: any}|undefined}
+         */
+        get dataRange() {
+            if(this.tracks) {
+                const num = numericTracks(this.tracks);
+                if (num.length > 0) {
+                    const firstRange = num[0].dataRange;
+                    if (num.every(t => t.dataRange && t.dataRange.min === firstRange.min && t.dataRange.max === firstRange.max)) {
+                        return firstRange
+                    }
+                }
             }
+            return undefined
         }
 
+
         menuItemList() {
             const items = [];
-            if (this.flipAxis !== undefined) {
-                items.push({
-                    label: "Flip y-axis",
-                    click: function flipYAxisHandler() {
-                        this.flipAxis = !this.flipAxis;
-                        this.trackView.repaintViews();
-                    }
-                });
-            }
+            if (numericTracks(this.tracks).length > 0) {
 
-            items.push(...this.numericDataMenuItems());
+                if (this.flipAxis !== undefined) {
+                    items.push({
+                        label: "Flip y-axis",
+                        click: function flipYAxisHandler() {
+                            this.flipAxis = !this.flipAxis;
+                            this.trackView.repaintViews();
+                        }
+                    });
+                }
+
+                items.push(...this.numericDataMenuItems());
+            }
 
             items.push('<hr/>');
             items.push(this.overlayTrackAlphaAdjustmentMenuItem());
@@ -41776,7 +41815,14 @@
 
             const promises = this.tracks.map((t) => t.getFeatures(chr, bpStart, bpEnd, bpPerPixel));
             const featureArrays = await Promise.all(promises);
-            return new MergedFeatureCollection(featureArrays)
+            
+            if (featureArrays.every((arr) => arr.length === 0)){
+                return new MergedFeatureCollection([], [])
+            }
+            else {
+                const trackNames = this.tracks.map((t) => t.name);
+                return new MergedFeatureCollection(featureArrays, trackNames)
+            }
         }
 
         draw(options) {
@@ -41788,11 +41834,6 @@
                 trackOptions.features = mergedFeatures.featureArrays[i];
                 trackOptions.alpha = this.alpha;
 
-                if (this.dataRange) {
-                    // Single data scale for all tracks
-                    this.tracks[i].dataRange = this.dataRange;
-                }
-
                 if (this.graphType) {
                     this.tracks[i].graphType = this.graphType;
                 }
@@ -41886,6 +41927,7 @@
             let scaleChange;
 
             if (this.autoscale) {
+                // Overrides any specific track scale settings
                 scaleChange = true;
                 let allFeatures = [];
                 for (let visibleViewport of visibleViewports) {
@@ -41900,7 +41942,12 @@
                             allFeatures.push({value: mergedFeatureCollection.getMin(start, end)});
                         }
                     }
-                    this.dataRange = doAutoscale(allFeatures);
+                    const dataRange = doAutoscale(allFeatures);
+                    for (const track of numericTracks(this.tracks)) {
+                        // Do not use this.dataRange, as that has side effects
+                        track.dataRange = dataRange;
+                    }
+
                 }
             } else {
                 // Individual track scaling
@@ -41980,6 +42027,7 @@
                     if (groupAutoscale) {
                         track.autoscaleGroup = name;
                     }
+                    track.isMergedTrack = false;
                     browser.addTrack(track.config, track);
                 }
                 browser.updateViews();
@@ -41993,25 +42041,30 @@
 
     class MergedFeatureCollection {
 
-        constructor(featureArrays) {
+        constructor(featureArrays,trackNames) {
             this.featureArrays = featureArrays;
+            //trackNames is needed for the popup data to populate track names 
+            //preserving the order of the actual tracks
+            this.trackNames = trackNames;
         }
 
         getMax(start, end) {
             let max = -Number.MAX_VALUE;
 
             for (let a of this.featureArrays) {
-                for (let f of a) {
-                    if (typeof f.value === 'undefined' || Number.isNaN(f.value)) {
-                        continue
-                    }
-                    if (f.end < start) {
-                        continue
-                    }
-                    if (f.start > end) {
-                        break
+                if (Array.isArray(a)) {
+                    for (let f of a) {
+                        if (typeof f.value === 'undefined' || Number.isNaN(f.value)) {
+                            continue
+                        }
+                        if (f.end < start) {
+                            continue
+                        }
+                        if (f.start > end) {
+                            break
+                        }
+                        max = Math.max(max, f.value);
                     }
-                    max = Math.max(max, f.value);
                 }
             }
 
@@ -42022,15 +42075,17 @@
         getMin(start, end) {
             let min = 0;
             for (let a of this.featureArrays) {
-                for (let f of a) {
-                    if (typeof f.value !== 'undefined' && !Number.isNaN(f.value)) {
-                        if (f.end < start) {
-                            continue
-                        }
-                        if (f.start > end) {
-                            break
+                if (Array.isArray(a)) {
+                    for (let f of a) {
+                        if (typeof f.value !== 'undefined' && !Number.isNaN(f.value)) {
+                            if (f.end < start) {
+                                continue
+                            }
+                            if (f.start > end) {
+                                break
+                            }
+                            min = Math.min(min, f.value);
                         }
-                        min = Math.min(min, f.value);
                     }
                 }
             }
@@ -42038,6 +42093,16 @@
         }
     }
 
+    /**
+     * Heuristic for finding numeric tracks.
+     *
+     * @param tracks
+     * @returns {*}
+     */
+    const numericTracks = (tracks) => {
+        return tracks ? tracks.filter(track => undefined !== track.dataRange || undefined !== track.autoscale || undefined !== track.autoscaleGroup) : []
+    };
+
     class OverlayTrackButton extends NavbarButton {
         constructor(browser, parent) {
 
@@ -42083,13 +42148,13 @@
                 {
                     name: 'Overlay',
                     type: 'merged',
+                    autoscale: false,
                     alpha: 0.5, //fudge * (1.0/tracks.length),
                     height: Math.max(...tracks.map(({ height }) => height)),
                     order: Math.min(...tracks.map(({ order }) => order)),
-                    _tracks: flattenedTracks
                 };
 
-            const mergedTrack = new MergedTrack(config, this.browser);
+            const mergedTrack = new MergedTrack(config, this.browser, flattenedTracks);
 
             for (const track of tracks) {
                 this.browser.removeTrack(track);
@@ -42309,27 +42374,6 @@
             }
         }
 
-        get dataRange() {
-            return this.track.dataRange ? this.track.dataRange : undefined
-        }
-
-        set dataRange({ min, max }) {
-
-            this.track.dataRange = { min, max };
-
-            this.track.autoscale = false;
-            this.track.autoscaleGroup = undefined;
-
-            const list = this.browser.trackViews.filter(({track}) => track.autoscaleGroup);
-            if (1 === list.length) {
-                list[0].track.autoscale = false;
-                list[0].track.autoscaleGroup = undefined;
-                list[0].repaintViews();
-            }
-
-            this.repaintViews();
-
-        }
 
         presentColorPicker(key) {
 
@@ -49778,46 +49822,41 @@
         },
 
         /**
+         * @param ba - UInt8Array  bytes to decode
          *
-         * @param ba  bytes to decode as a UInt8Array
-         * @param genome  optional igv genome object
-         * @returns {{ magicNumer: number, size: number, chrNames: Array, chrToIndex: ({}|*), chrAliasTable: ({}|*) }}
+         * @returns {{size: *, chrNames: *[], magicNumber: *, chrToIndex: {}}}
          */
-        decodeBamHeader: function (ba, genome) {
+        decodeBamHeader: function (ba) {
 
-            var magic, samHeaderLen, samHeader, chrToIndex, chrNames;
 
-            magic = readInt(ba, 0);
+            const magic = readInt(ba, 0);
             if (magic !== BAM1_MAGIC_NUMBER) {
                 throw new Error('BAM header errror: bad magic number.  This could be caused by either a corrupt or missing file.')
             }
 
-            samHeaderLen = readInt(ba, 4);
-            samHeader = '';
-
+            const samHeaderLen = readInt(ba, 4);
+            let samHeader = '';
             for (var i = 0; i < samHeaderLen; ++i) {
                 samHeader += String.fromCharCode(ba[i + 8]);
             }
 
-            var nRef = readInt(ba, samHeaderLen + 8);
-            var p = samHeaderLen + 12;
+            const nRef = readInt(ba, samHeaderLen + 8);
+            let p = samHeaderLen + 12;
 
-            chrToIndex = {};
-            chrNames = [];
+            const chrToIndex = {};
+            const chrNames = [];
 
             for (i = 0; i < nRef; ++i) {
-                var lName = readInt(ba, p);
-                var name = '';
-                for (var j = 0; j < lName - 1; ++j) {
+                const len = readInt(ba, p);
+                let name = '';
+                for (var j = 0; j < len - 1; ++j) {
                     name += String.fromCharCode(ba[p + 4 + j]);
                 }
-                readInt(ba, p + lName + 4);
-                //dlog(name + ': ' + lRef);
 
                 chrToIndex[name] = i;
                 chrNames[i] = name;
 
-                p = p + 8 + lName;
+                p = p + 8 + len;
             }
 
             return {
@@ -50807,8 +50846,8 @@
                 const ba = unbgzf(compressedData.buffer);
                 this.header = BamUtils.decodeBamHeader(ba, this.genome);
                 this.chrAliasTable = new Map();
-                for (let key of Object.keys(this.header.chrAliasTable)) {
-                    this.chrAliasTable.set(key, this.header.chrAliasTable[key]);
+                for (let name of this.header.chrNames) {
+                    this.chrAliasTable.set(name, this.genome.getChromosomeName(name));
                 }
             }
 
@@ -50818,6 +50857,7 @@
 
             // BAM decoding
             const ba = unbgzf(compressedData.buffer);
+            this.header = BamUtils.decodeBamHeader(ba, this.genome);
 
             const chrIdx = this.header.chrToIndex[chr];
             const alignmentContainer = new AlignmentContainer(chr, start, end, this.config);
@@ -57662,6 +57702,7 @@
 
 
         constructor(config, parent) {
+            this.featureType = 'numeric';
             this.parent = parent;
             this.featureSource = parent.featureSource;
 
@@ -66140,12 +66181,12 @@
                     if (this.signals.includes(signal_name)) {
                         let tconf = {};
                         tconf.type = "wig";
-                        tconf.isMergedTrack = true;
                         tconf.features = wig;
                         tconf.name = signal_name;
                         tconf.color = this.signal_colors.filter(x => x.singal_name === signal_name).map(x => x.color);
                         const t = await this.browser.createTrack(tconf);
                         if (t) {
+                            t.isMergedTrack = true;
                             t.autoscale = false;     // Scaling done from merged track
                             this.tracks.push(t);
                         } else {
@@ -66324,12 +66365,12 @@
                 if (this.signals.includes(signal_name)) {
                     let tconf = {};
                     tconf.type = "wig";
-                    tconf.isMergedTrack = true;
                     tconf.features = wig;
                     tconf.name = signal_name;
                     tconf.color = this.signal_colors.filter(x => x.singal_name === signal_name).map(x => x.color);
                     const t = await this.browser.createTrack(tconf);
                     if (t) {
+                        t.isMergedTrack = true;
                         t.autoscale = false;     // Scaling done from merged track
                         this.tracks.push(t);
                     } else {
@@ -66722,23 +66763,26 @@
             this.header = await this.getHeader();
 
             // Set colorBy, if not explicitly set default to allele frequency, if available, otherwise default to none (undefined)
-            const infoFields = new Set(Object.keys(this.header.INFO));
-            if (this.config.colorBy) {
-                this.colorBy = this.config.colorBy;
-            } else if (!this.config.color && infoFields.has('AF')) {
-                this.colorBy = 'AF';
-            }
+            if(this.header.INFO) {
+                const infoFields = new Set(Object.keys(this.header.INFO));
+                if (this.config.colorBy) {
+                    this.colorBy = this.config.colorBy;
+                } else if (!this.config.color && infoFields.has('AF')) {
+                    this.colorBy = 'AF';
+                }
 
-            // Configure menu items based on info available
-            if (infoFields.has('AF')) {
-                this._colorByItems.set('AF', 'Allele frequency');
-            }
-            if (infoFields.has('VT')) {
-                this._colorByItems.set('VT', 'Variant Type');
-            }
-            if (infoFields.has('SVTYPE')) {
-                this._colorByItems.set('SVTYPE', 'SV Type');
+                // Configure menu items based on info available
+                if (infoFields.has('AF')) {
+                    this._colorByItems.set('AF', 'Allele frequency');
+                }
+                if (infoFields.has('VT')) {
+                    this._colorByItems.set('VT', 'Variant Type');
+                }
+                if (infoFields.has('SVTYPE')) {
+                    this._colorByItems.set('SVTYPE', 'SV Type');
+                }
             }
+
             if (this.config.colorBy && !this._colorByItems.has(this.config.colorBy)) {
                 this._colorByItems.set(this.config.colorBy, this.config.colorBy);
             }
@@ -69583,11 +69627,15 @@
         JUNCTION_MOTIF_PALETTE.getColor(motif);
     });
 
-    // rendering context with values that only need to be computed once per render, rather than for each splice junction
-    const junctionRenderingContext = {};
 
     class SpliceJunctionTrack extends TrackBase {
 
+        static defaults = {
+            margin: 10,
+            colorByNumReadsThreshold: 5,
+            height: 100
+        }
+
         constructor(config, browser) {
             super(config, browser);
         }
@@ -69608,16 +69656,6 @@
                     FeatureSource(config, this.browser.genome);
             }
 
-            this.margin = config.margin === undefined ? 10 : config.margin;
-
-            if (!this.height) {
-                this.height = 100;
-            }
-
-            //set defaults
-            if (config.colorByNumReadsThreshold === undefined) {
-                config.colorByNumReadsThreshold = 5;
-            }
         }
 
         async postInit() {
@@ -69672,13 +69710,16 @@
             const bpEnd = bpStart + pixelWidth * bpPerPixel + 1;
 
 
-            if (!this.config.isMergedTrack) {
+            if (!this.isMergedTrack) {
                 IGVGraphics.fillRect(ctx, 0, options.pixelTop, pixelWidth, pixelHeight, {'fillStyle': "rgb(255, 255, 255)"});
             }
 
             if (featureList) {
 
 
+                // rendering context with values that only need to be computed once per render, rather than for each splice junction
+                const junctionRenderingContext = {};
+
                 junctionRenderingContext.referenceFrame = options.viewport.referenceFrame;
                 junctionRenderingContext.referenceFrameStart = junctionRenderingContext.referenceFrame.start;
                 junctionRenderingContext.referenceFrameEnd = junctionRenderingContext.referenceFrameStart +
@@ -69691,7 +69732,7 @@
                 for (let feature of featureList) {
                     if (feature.end < bpStart) continue
                     if (feature.start > bpEnd) break
-                    this.renderJunction(feature, bpStart, bpPerPixel, pixelHeight, ctx);
+                    this.renderJunction(feature, bpStart, bpPerPixel, pixelHeight, ctx, junctionRenderingContext);
                 }
 
             } else {
@@ -69708,7 +69749,7 @@
          * @param pixelHeight  pixel height of the current canvas
          * @param ctx  the canvas 2d context
          */
-        renderJunction(feature, bpStart, xScale, pixelHeight, ctx) {
+        renderJunction(feature, bpStart, xScale, pixelHeight, ctx, junctionRenderingContext) {
             // cache whether this junction is rendered or filtered out. Use later to exclude non-rendered junctions from click detection.
             feature.isVisible = false;
 
@@ -69792,7 +69833,7 @@
             }
 
             const py = this.margin;
-            const rowHeight = this.height;
+            const rowHeight = pixelHeight;
 
             const cy = py + 0.5 * rowHeight;
             let topY = py;
@@ -70477,7 +70518,7 @@
         })
     }
 
-    const _version = "3.0.1";
+    const _version = "3.0.2";
     function version() {
         return _version
     }
@@ -72928,7 +72969,7 @@
         }
 
         /**
-         * Return the canonical chromosome name for the alias.  If none found return the alias.
+         * Return the cached canonical chromosome name for the alias.  If none found return the alias.
          *
          * Note this will only work if a "search" for ths chromosome has been performed previously.
          *