igv 3.0.1 → 3.0.2

package/dist/igv.esm.js

@@ -19015,13 +19015,13 @@ class DataRangeDialog {
         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) {
@@ -19063,7 +19063,7 @@ class DataRangeDialog {
             } else {
                 const list = Array.isArray(trackViewOfTrackViewList) ? trackViewOfTrackViewList : [ trackViewOfTrackViewList ];
                 for (const trackView of list) {
-                    trackView.dataRange = { min, max };
+                    trackView.track.setDataRange({ min, max });
                 }
 
             }
@@ -26696,6 +26696,14 @@ class TrackBase {
         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
@@ -27063,7 +27071,7 @@ class Variant {
         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];
@@ -27222,9 +27230,10 @@ class Variant {
             }
         }
 
-        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]))});
             }
         }
@@ -27291,7 +27300,7 @@ class SVComplement {
     }
 
     getAttributeValue(key) {
-       return this.mate.getAttributeValue(key)
+        return this.mate.getAttributeValue(key)
     }
 
     getInfo(tag) {
@@ -27314,7 +27323,7 @@ class SVComplement {
         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
     }
@@ -31210,7 +31219,7 @@ function overlaps(item, chrIdx1, startBase, chrIdx2, endBase) {
 
 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;
@@ -34416,7 +34425,7 @@ class FeatureTrack extends TrackBase {
         }
 
 
-        if (!this.config.isMergedTrack) {
+        if (!this.isMergedTrack) {
             IGVGraphics.fillRect(context, 0, options.pixelTop, pixelWidth, pixelHeight, {'fillStyle': "rgb(255, 255, 255)"});
         }
 
@@ -41605,39 +41614,36 @@ function paintAxis(ctx, width, height, colorOrUndefined) {
  * 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);
@@ -41648,24 +41654,27 @@ class MergedTrack extends TrackBase {
                     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;
         }
@@ -41675,25 +41684,28 @@ class MergedTrack extends TrackBase {
         }
 
         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() {
@@ -41711,49 +41723,76 @@ class MergedTrack extends TrackBase {
         }
     }
 
-    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());
@@ -41770,7 +41809,14 @@ class MergedTrack extends TrackBase {
 
         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) {
@@ -41782,11 +41828,6 @@ class MergedTrack extends TrackBase {
             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;
             }
@@ -41880,6 +41921,7 @@ class MergedTrack extends TrackBase {
         let scaleChange;
 
         if (this.autoscale) {
+            // Overrides any specific track scale settings
             scaleChange = true;
             let allFeatures = [];
             for (let visibleViewport of visibleViewports) {
@@ -41894,7 +41936,12 @@ class MergedTrack extends TrackBase {
                         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
@@ -41974,6 +42021,7 @@ class MergedTrack extends TrackBase {
                 if (groupAutoscale) {
                     track.autoscaleGroup = name;
                 }
+                track.isMergedTrack = false;
                 browser.addTrack(track.config, track);
             }
             browser.updateViews();
@@ -41987,25 +42035,30 @@ class MergedTrack extends TrackBase {
 
 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);
             }
         }
 
@@ -42016,15 +42069,17 @@ class MergedFeatureCollection {
     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);
                 }
             }
         }
@@ -42032,6 +42087,16 @@ class MergedFeatureCollection {
     }
 }
 
+/**
+ * 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) {
 
@@ -42077,13 +42142,13 @@ function trackOverlayClickHandler(e) {
             {
                 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);
@@ -42303,27 +42368,6 @@ class TrackView {
         }
     }
 
-    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) {
 
@@ -49772,46 +49816,41 @@ const BamUtils = {
     },
 
     /**
+     * @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 {
@@ -50801,8 +50840,8 @@ class HtsgetBamReader extends HtsgetReader {
             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));
             }
         }
 
@@ -50812,6 +50851,7 @@ class HtsgetBamReader extends HtsgetReader {
 
         // 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);
@@ -57656,6 +57696,7 @@ class CoverageTrack  {
 
 
     constructor(config, parent) {
+        this.featureType = 'numeric';
         this.parent = parent;
         this.featureSource = parent.featureSource;
 
@@ -66134,12 +66175,12 @@ class CNVPytorTrack extends TrackBase {
                 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 {
@@ -66318,12 +66359,12 @@ class CNVPytorTrack extends TrackBase {
             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 {
@@ -66716,23 +66757,26 @@ class VariantTrack extends TrackBase {
         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);
         }
@@ -69577,11 +69621,15 @@ someMotifValues.forEach(motif => {
     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);
     }
@@ -69602,16 +69650,6 @@ class SpliceJunctionTrack extends TrackBase {
                 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() {
@@ -69666,13 +69704,16 @@ class SpliceJunctionTrack extends TrackBase {
         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 +
@@ -69685,7 +69726,7 @@ class SpliceJunctionTrack extends TrackBase {
             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 {
@@ -69702,7 +69743,7 @@ class SpliceJunctionTrack extends TrackBase {
      * @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;
 
@@ -69786,7 +69827,7 @@ class SpliceJunctionTrack extends TrackBase {
         }
 
         const py = this.margin;
-        const rowHeight = this.height;
+        const rowHeight = pixelHeight;
 
         const cy = py + 0.5 * rowHeight;
         let topY = py;
@@ -70471,7 +70512,7 @@ function createReferenceFrameList(loci, genome, browserFlanking, minimumBases, v
     })
 }
 
-const _version = "3.0.1";
+const _version = "3.0.2";
 function version() {
     return _version
 }
@@ -72922,7 +72963,7 @@ class ChromAliasBB {
     }
 
     /**
-     * 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.
      *