highcharts 6.1.1 → 6.2.0

package/js/modules/boost.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.1.1 (2018-06-27)
+ * @license Highcharts JS v6.2.0 (2018-10-17)
  * Boost module
  *
  * (c) 2010-2017 Highsoft AS
@@ -11,6 +11,10 @@
 (function (factory) {
 	if (typeof module === 'object' && module.exports) {
 		module.exports = factory;
+	} else if (typeof define === 'function' && define.amd) {
+		define(function () {
+			return factory;
+		});
 	} else {
 		factory(Highcharts);
 	}
@@ -281,6 +285,7 @@
 		    Series = H.Series,
 		    seriesTypes = H.seriesTypes,
 		    each = H.each,
+		    objEach = H.objectEach,
 		    extend = H.extend,
 		    addEvent = H.addEvent,
 		    fireEvent = H.fireEvent,
@@ -512,6 +517,12 @@
 
 		            series = chart.series[i];
 
+		            // Don't count series with boostThreshold set to 0
+		            // See #8950
+		            if (series.options.boostThreshold === 0) {
+		                continue;
+		            }
+
 		            if (boostableMap[series.type]) {
 		                ++canBoostCount;
 		            }
@@ -527,20 +538,37 @@
 		        }
 		    }
 
-		    chart.boostForceChartBoost =
+		    chart.boostForceChartBoost = allowBoostForce && (
 		        (
-		            allowBoostForce &&
 		            canBoostCount === chart.series.length &&
 		            sboostCount > 0
 		        ) ||
-		        sboostCount > 5;
+		        sboostCount > 5
+		    );
 
 		    return chart.boostForceChartBoost;
 		}
 
+		/**
+		 * Return true if ths boost.enabled option is true
+		 * @param  {Highcharts.Chart} chart The chart
+		 * @return {boolean}
+		 */
+		function boostEnabled(chart) {
+		    return pick(
+		        (
+		            chart &&
+		            chart.options &&
+		            chart.options.boost &&
+		            chart.options.boost.enabled
+		        ),
+		        true
+		    );
+		}
+
 		/*
 		 * Returns true if the chart is in series boost mode
-		 * @param chart {Highchart.Chart} - the chart to check
+		 * @param chart {Highcharts.Chart} - the chart to check
 		 * @returns {Boolean} - true if the chart is in series boost mode
 		 */
 		Chart.prototype.isChartSeriesBoosting = function () {
@@ -811,9 +839,20 @@
 		        // Uniform for invertion
 		        isInverted,
 		        plotHeightUniform,
+		        // Error stack
+		        errors = [],
 		        // Texture uniform
 		        uSamplerUniform;
 
+		    /*
+		     * Handle errors accumulated in errors stack
+		     */
+		    function handleErrors() {
+		        if (errors.length) {
+		            H.error('[highcharts boost] shader error - ' + errors.join('\n'));
+		        }
+		    }
+
 		    /* String to shader program
 		     * @param {string} str - the program source
 		     * @param {string} type - the program type: either `vertex` or `fragment`
@@ -828,7 +867,13 @@
 		        gl.compileShader(shader);
 
 		        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-		            // console.error('shader error:', gl.getShaderInfoLog(shader));
+		            errors.push(
+		                'when compiling ' +
+		                type +
+		                ' shader:\n' +
+		                gl.getShaderInfoLog(shader)
+		            );
+
 		            return false;
 		        }
 		        return shader;
@@ -845,7 +890,7 @@
 
 		        if (!v || !f) {
 		            shaderProgram = false;
-		            // console.error('error creating shader program');
+		            handleErrors();
 		            return false;
 		        }
 
@@ -857,8 +902,16 @@
 
 		        gl.attachShader(shaderProgram, v);
 		        gl.attachShader(shaderProgram, f);
+
 		        gl.linkProgram(shaderProgram);
 
+		        if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
+		            errors.push(gl.getProgramInfoLog(shaderProgram));
+		            handleErrors();
+		            shaderProgram = false;
+		            return false;
+		        }
+
 		        gl.useProgram(shaderProgram);
 
 		        gl.bindAttribLocation(shaderProgram, 0, 'aVertexPosition');
@@ -874,6 +927,7 @@
 		        isCircleUniform = uloc('isCircle');
 		        isInverted = uloc('isInverted');
 		        plotHeightUniform = uloc('plotHeight');
+
 		        return true;
 		    }
 
@@ -881,11 +935,9 @@
 		     * Destroy the shader
 		     */
 		    function destroy() {
-		        if (gl) {
-		            if (shaderProgram) {
-		                gl.deleteProgram(shaderProgram);
-		                shaderProgram = false;
-		            }
+		        if (gl && shaderProgram) {
+		            gl.deleteProgram(shaderProgram);
+		            shaderProgram = false;
 		        }
 		    }
 
@@ -895,7 +947,9 @@
 		     * or until 0 is bound.
 		     */
 		    function bind() {
-		        gl.useProgram(shaderProgram);
+		        if (gl && shaderProgram) {
+		            gl.useProgram(shaderProgram);
+		        }
 		    }
 
 		    /*
@@ -905,17 +959,24 @@
 		     * @param val {float} - the value to set
 		     */
 		    function setUniform(name, val) {
-		        var u = uLocations[name] = uLocations[name] ||
-		                                    gl.getUniformLocation(shaderProgram, name);
-		        gl.uniform1f(u, val);
+		        if (gl && shaderProgram) {
+		            var u = uLocations[name] = uLocations[name] ||
+		                                       gl.getUniformLocation(
+		                                          shaderProgram,
+		                                          name
+		                                       );
+		            gl.uniform1f(u, val);
+		        }
 		    }
 
 		    /*
 		     * Set the active texture
 		     * @param texture - the texture
 		     */
-		    function setTexture() {
-		        gl.uniform1i(uSamplerUniform, 0);
+		    function setTexture(texture) {
+		        if (gl && shaderProgram) {
+		            gl.uniform1i(uSamplerUniform, texture);
+		        }
 		    }
 
 		    /*
@@ -923,26 +984,34 @@
 		     * @flag is the state
 		     */
 		    function setInverted(flag) {
-		        gl.uniform1i(isInverted, flag);
+		        if (gl && shaderProgram) {
+		            gl.uniform1i(isInverted, flag);
+		        }
 		    }
 
 		    /*
 		     * Enable/disable circle drawing
 		     */
 		    function setDrawAsCircle(flag) {
-		        gl.uniform1i(isCircleUniform, flag ? 1 : 0);
+		        if (gl && shaderProgram) {
+		            gl.uniform1i(isCircleUniform, flag ? 1 : 0);
+		        }
 		    }
 
 		    function setPlotHeight(n) {
-		        gl.uniform1f(plotHeightUniform, n);
+		        if (gl && shaderProgram) {
+		            gl.uniform1f(plotHeightUniform, n);
+		        }
 		    }
 
 		    /*
 		     * Flush
 		     */
 		    function reset() {
-		        gl.uniform1i(isBubbleUniform, 0);
-		        gl.uniform1i(isCircleUniform, 0);
+		        if (gl && shaderProgram) {
+		            gl.uniform1i(isBubbleUniform, 0);
+		            gl.uniform1i(isCircleUniform, 0);
+		        }
 		    }
 
 		    /*
@@ -954,7 +1023,7 @@
 		            zMin = Number.MAX_VALUE,
 		            zMax = -Number.MAX_VALUE;
 
-		        if (series.type === 'bubble') {
+		        if (gl && shaderProgram && series.type === 'bubble') {
 		            zMin = pick(seriesOptions.zMin, Math.min(
 		                zMin,
 		                Math.max(
@@ -990,20 +1059,24 @@
 		     * @param color {Array<float>} - an array with RGBA values
 		     */
 		    function setColor(color) {
-		        gl.uniform4f(
-		            fillColorUniform,
-		            color[0] / 255.0,
-		            color[1] / 255.0,
-		            color[2] / 255.0,
-		            color[3]
-		        );
+		        if (gl && shaderProgram) {
+		            gl.uniform4f(
+		                fillColorUniform,
+		                color[0] / 255.0,
+		                color[1] / 255.0,
+		                color[2] / 255.0,
+		                color[3]
+		            );
+		        }
 		    }
 
 		    /*
 		     * Set skip translation
 		     */
 		    function setSkipTranslation(flag) {
-		        gl.uniform1i(skipTranslationUniform, flag === true ? 1 : 0);
+		        if (gl && shaderProgram) {
+		            gl.uniform1i(skipTranslationUniform, flag === true ? 1 : 0);
+		        }
 		    }
 
 		    /*
@@ -1011,7 +1084,9 @@
 		     * @param m {Matrix4x4} - the matrix
 		     */
 		    function setPMatrix(m) {
-		        gl.uniformMatrix4fv(pUniform, false, m);
+		        if (gl && shaderProgram) {
+		            gl.uniformMatrix4fv(pUniform, false, m);
+		        }
 		    }
 
 		    /*
@@ -1019,7 +1094,9 @@
 		     * @param p {float} - point size
 		     */
 		    function setPointSize(p) {
-		        gl.uniform1f(psUniform, p);
+		        if (gl && shaderProgram) {
+		            gl.uniform1f(psUniform, p);
+		        }
 		    }
 
 		    /*
@@ -1031,7 +1108,9 @@
 		    }
 
 		    if (gl) {
-		        createShader();
+		        if (!createShader()) {
+		            return false;
+		        }
 		    }
 
 		    return {
@@ -1243,20 +1322,16 @@
 		        data = false,
 		        // The marker data
 		        markerData = false,
-		        // Is the texture ready?
-		        textureIsReady = false,
 		        // Exports
 		        exports = {},
 		        // Is it inited?
 		        isInited = false,
 		        // The series stack
 		        series = [],
-		        // Texture for circles
-		        circleTexture = doc.createElement('canvas'),
-		        // Context for circle texture
-		        circleCtx = circleTexture.getContext('2d'),
-		        // Handle for the circle texture
-		        circleTextureHandle,
+
+		        // Texture handles
+		        textureHandles = {},
+
 		        // Things to draw as "rectangles" (i.e lines)
 		        asBar = {
 		            'column': true,
@@ -1430,10 +1505,11 @@
 		            color,
 		            scolor,
 		            sdata = isStacked ? series.data : (xData || rawData),
-		            closestLeft = { x: -Number.MAX_VALUE, y: 0 },
-		            closestRight = { x: Number.MIN_VALUE, y: 0 },
+		            closestLeft = { x: Number.MAX_VALUE, y: 0 },
+		            closestRight = { x: -Number.MAX_VALUE, y: 0 },
 
 		            skipped = 0,
+		            hadPoints = false,
 
 		            cullXThreshold = 1,
 		            cullYThreshold = 1,
@@ -1454,7 +1530,8 @@
 		            pcolor = false,
 		            drawAsBar = asBar[series.type],
 		            isXInside = false,
-		            isYInside = true;
+		            isYInside = true,
+		            threshold = options.threshold;
 
 		        if (options.boostData && options.boostData.length > 0) {
 		            return;
@@ -1762,7 +1839,7 @@
 		                closestRight.y = y;
 		            }
 
-		            if (x < xMin && closestLeft.x < xMin) {
+		            if (x < xMin && closestLeft.x > xMin) {
 		                closestLeft.x = x;
 		                closestLeft.y = y;
 		            }
@@ -1772,7 +1849,7 @@
 		            }
 
 		            // Cull points outside the extremes
-		            if (y === null || !isYInside) {
+		            if (y === null || (!isYInside && !nextInside && !prevInside)) {
 		                beginSegment();
 		                continue;
 		            }
@@ -1798,6 +1875,13 @@
 		                }
 
 		                if (x > plotWidth) {
+		                    // If this is  rendered as a point, just skip drawing it
+		                    // entirely, as we're not dependandt on lineTo'ing to it.
+		                    // See #8197
+		                    if (inst.drawMode === 'points') {
+		                        continue;
+		                    }
+
 		                    x = plotWidth;
 		                }
 
@@ -1816,6 +1900,9 @@
 		                    }
 		                }
 
+		                if (!isRange && !isStacked) {
+		                    minVal = Math.max(threshold, yMin); // #8731
+		                }
 		                if (!settings.useGPUTranslations) {
 		                    minVal = yAxis.toPixels(minVal, true);
 		                }
@@ -1853,7 +1940,7 @@
 
 		            if (!settings.useGPUTranslations &&
 		                !settings.usePreallocated &&
-		                (lastX && x - lastX < cullXThreshold) &&
+		                (lastX && Math.abs(x - lastX) < cullXThreshold) &&
 		                (lastY && Math.abs(y - lastY) < cullYThreshold)
 		            ) {
 		                if (settings.debug.showSkipSummary) {
@@ -1897,13 +1984,15 @@
 
 		            lastX = x;
 		            lastY = y;
+
+		            hadPoints = true;
 		        }
 
 		        if (settings.debug.showSkipSummary) {
 		            console.log('skipped points:', skipped); // eslint-disable-line no-console
 		        }
 
-		        function pushSupplementPoint(point) {
+		        function pushSupplementPoint(point, atStart) {
 		            if (!settings.useGPUTranslations) {
 		                inst.skipTranslation = true;
 		                point.x = xAxis.toPixels(point.x, true);
@@ -1913,6 +2002,11 @@
 		            // We should only do this for lines, and we should ignore markers
 		            // since there's no point here that would have a marker.
 
+		            if (atStart) {
+		                data = [point.x, point.y, 0, 2].concat(data);
+		                return;
+		            }
+
 		            vertice(
 		                point.x,
 		                point.y,
@@ -1921,13 +2015,19 @@
 		            );
 		        }
 
-		        if (!lastX &&
+		        if (
+		            !hadPoints &&
 		            connectNulls !== false &&
-		            closestLeft > -Number.MAX_VALUE &&
-		            closestRight < Number.MAX_VALUE) {
-		            // There are no points within the selected range
-		            pushSupplementPoint(closestLeft);
-		            pushSupplementPoint(closestRight);
+		            series.drawMode === 'line_strip'
+		        ) {
+		            if (closestLeft.x < Number.MAX_VALUE) {
+		                // We actually need to push this *before* the complete buffer.
+		                pushSupplementPoint(closestLeft, true);
+		            }
+
+		            if (closestRight.x > -Number.MAX_VALUE) {
+		                pushSupplementPoint(closestRight);
+		            }
 		        }
 
 		        closeSegment();
@@ -2066,7 +2166,7 @@
 		            return false;
 		        }
 
-		        if (!gl || !width || !height) {
+		        if (!gl || !width || !height || !shader) {
 		            return false;
 		        }
 
@@ -2079,7 +2179,6 @@
 
 		        shader.bind();
 
-
 		        gl.viewport(0, 0, width, height);
 		        shader.setPMatrix(orthoMatrix(width, height));
 		        shader.setPlotHeight(chart.plotHeight);
@@ -2091,17 +2190,12 @@
 		        vbuffer.build(exports.data, 'aVertexPosition', 4);
 		        vbuffer.bind();
 
-		        if (textureIsReady) {
-		            gl.bindTexture(gl.TEXTURE_2D, circleTextureHandle);
-		            shader.setTexture(circleTextureHandle);
-		        }
-
 		        shader.setInverted(chart.inverted);
 
-
 		        // Render the series
 		        each(series, function (s, si) {
 		            var options = s.series.options,
+		                shapeOptions = options.marker,
 		                sindex,
 		                lineWidth = typeof options.lineWidth !== 'undefined' ?
 		                    options.lineWidth :
@@ -2122,8 +2216,23 @@
 		                            ) || 10)
 		                ),
 		                fillColor,
+		                shapeTexture = textureHandles[
+		                    (shapeOptions && shapeOptions.symbol) || s.series.symbol
+		                ] || textureHandles.circle,
 		                color;
 
+		            if (
+		                s.segments.length === 0 ||
+		                (s.segmentslength && s.segments[0].from === s.segments[0].to)
+		            ) {
+		                return;
+		            }
+
+		            if (shapeTexture.isReady) {
+		                gl.bindTexture(gl.TEXTURE_2D, shapeTexture.handle);
+		                shader.setTexture(shapeTexture.handle);
+		            }
+
             
 		            fillColor = (
 		                s.series.markerGroup &&
@@ -2204,7 +2313,7 @@
 		            }
 
 		            shader.setDrawAsCircle(
-		                (asCircle[s.series.type] && textureIsReady) || false
+		                asCircle[s.series.type] || false
 		            );
 
 		            // Do the actual rendering
@@ -2277,8 +2386,8 @@
 		     * @param h {Integer} - the height of the viewport
 		     */
 		    function setSize(w, h) {
-		        // Skip if there's no change
-		        if (width === w && h === h) {
+		        // Skip if there's no change, or if we have no valid shader
+		        if ((width === w && h === h) || !shader) {
 		            return;
 		        }
 
@@ -2337,71 +2446,127 @@
 		        gl.depthFunc(gl.LESS);
 
 		        shader = GLShader(gl); // eslint-disable-line new-cap
+
+		        if (!shader) {
+		            // We need to abort, there's no shader context
+		            return false;
+		        }
+
 		        vbuffer = GLVertexBuffer(gl, shader); // eslint-disable-line new-cap
 
-		        textureIsReady = false;
+		        function createTexture(name, fn) {
+		            var props = {
+		                    isReady: false,
+		                    texture: doc.createElement('canvas'),
+		                    handle: gl.createTexture()
+		                },
+		                ctx = props.texture.getContext('2d');
 
-		        // Set up the circle texture used for bubbles
-		        circleTextureHandle = gl.createTexture();
+		            textureHandles[name] = props;
 
-		        // Draw the circle
-		        circleTexture.width = 512;
-		        circleTexture.height = 512;
+		            props.texture.width = 512;
+		            props.texture.height = 512;
 
-		        circleCtx.mozImageSmoothingEnabled = false;
-		        circleCtx.webkitImageSmoothingEnabled = false;
-		        circleCtx.msImageSmoothingEnabled = false;
-		        circleCtx.imageSmoothingEnabled = false;
+		            ctx.mozImageSmoothingEnabled = false;
+		            ctx.webkitImageSmoothingEnabled = false;
+		            ctx.msImageSmoothingEnabled = false;
+		            ctx.imageSmoothingEnabled = false;
 
-		        circleCtx.strokeStyle = 'rgba(255, 255, 255, 0)';
-		        circleCtx.fillStyle = '#FFF';
+		            ctx.strokeStyle = 'rgba(255, 255, 255, 0)';
+		            ctx.fillStyle = '#FFF';
 
-		        circleCtx.beginPath();
-		        circleCtx.arc(256, 256, 256, 0, 2 * Math.PI);
-		        circleCtx.stroke();
-		        circleCtx.fill();
+		            fn(ctx);
 
-		        try {
+		            try {
 
-		            gl.bindTexture(gl.TEXTURE_2D, circleTextureHandle);
-		            // gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+		                gl.activeTexture(gl.TEXTURE0);
+		                gl.bindTexture(gl.TEXTURE_2D, props.handle);
+		                // gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
 
-		            gl.texImage2D(
-		                gl.TEXTURE_2D,
-		                0,
-		                gl.RGBA,
-		                gl.RGBA,
-		                gl.UNSIGNED_BYTE,
-		                circleTexture
-		            );
+		                gl.texImage2D(
+		                    gl.TEXTURE_2D,
+		                    0,
+		                    gl.RGBA,
+		                    gl.RGBA,
+		                    gl.UNSIGNED_BYTE,
+		                    props.texture
+		                );
 
-		            gl.texParameteri(
-		                gl.TEXTURE_2D,
-		                gl.TEXTURE_WRAP_S,
-		                gl.CLAMP_TO_EDGE
-		            );
-		            gl.texParameteri(
-		                gl.TEXTURE_2D,
-		                gl.TEXTURE_WRAP_T,
-		                gl.CLAMP_TO_EDGE
-		            );
-		            gl.texParameteri(
-		                gl.TEXTURE_2D,
-		                gl.TEXTURE_MAG_FILTER,
-		                gl.LINEAR
-		            );
-		            gl.texParameteri(
-		                gl.TEXTURE_2D,
-		                gl.TEXTURE_MIN_FILTER,
-		                gl.LINEAR
-		            );
+		                gl.texParameteri(
+		                    gl.TEXTURE_2D,
+		                    gl.TEXTURE_WRAP_S,
+		                    gl.CLAMP_TO_EDGE
+		                );
+
+		                gl.texParameteri(
+		                    gl.TEXTURE_2D,
+		                    gl.TEXTURE_WRAP_T,
+		                    gl.CLAMP_TO_EDGE
+		                );
+
+		                gl.texParameteri(
+		                    gl.TEXTURE_2D,
+		                    gl.TEXTURE_MAG_FILTER,
+		                    gl.LINEAR
+		                );
+
+		                gl.texParameteri(
+		                    gl.TEXTURE_2D,
+		                    gl.TEXTURE_MIN_FILTER,
+		                    gl.LINEAR
+		                );
 
-		            // gl.generateMipmap(gl.TEXTURE_2D);
+		                // gl.generateMipmap(gl.TEXTURE_2D);
 
-		            gl.bindTexture(gl.TEXTURE_2D, null);
+		                gl.bindTexture(gl.TEXTURE_2D, null);
 
-		            textureIsReady = true;
-		        } catch (e) {}
+		                props.isReady = true;
+		            } catch (e) {}
+		        }
+
+		        // Circle shape
+		        createTexture('circle', function (ctx) {
+		            ctx.beginPath();
+		            ctx.arc(256, 256, 256, 0, 2 * Math.PI);
+		            ctx.stroke();
+		            ctx.fill();
+		        });
+
+		        // Square shape
+		        createTexture('square', function (ctx) {
+		            ctx.fillRect(0, 0, 512, 512);
+		        });
+
+		        // Diamond shape
+		        createTexture('diamond', function (ctx) {
+		            ctx.beginPath();
+		            ctx.moveTo(256, 0);
+		            ctx.lineTo(512, 256);
+		            ctx.lineTo(256, 512);
+		            ctx.lineTo(0, 256);
+		            ctx.lineTo(256, 0);
+		            ctx.fill();
+		        });
+
+		        // Triangle shape
+		        createTexture('triangle', function (ctx) {
+		            ctx.beginPath();
+		            ctx.moveTo(0, 512);
+		            ctx.lineTo(256, 0);
+		            ctx.lineTo(512, 512);
+		            ctx.lineTo(0, 512);
+		            ctx.fill();
+		        });
+
+		        // Triangle shape (rotated)
+		        createTexture('triangle-down', function (ctx) {
+		            ctx.beginPath();
+		            ctx.moveTo(0, 0);
+		            ctx.lineTo(256, 512);
+		            ctx.lineTo(512, 0);
+		            ctx.lineTo(0, 0);
+		            ctx.fill();
+		        });
 
 		        isInited = true;
 
@@ -2433,9 +2598,13 @@
 		        vbuffer.destroy();
 		        shader.destroy();
 		        if (gl) {
-		            if (circleTextureHandle) {
-		                gl.deleteTexture(circleTextureHandle);
-		            }
+
+		            objEach(textureHandles, function (key) {
+		                if (textureHandles[key].handle) {
+		                    gl.deleteTexture(textureHandles[key].handle);
+		                }
+		            });
+
 		            gl.canvas.width = 1;
 		            gl.canvas.height = 1;
 		        }
@@ -2607,7 +2776,13 @@
 
 		        }); // eslint-disable-line new-cap
 
-		        target.ogl.init(target.canvas);
+		        if (!target.ogl.init(target.canvas)) {
+		            // The OGL renderer couldn't be inited.
+		            // This likely means a shader error as we wouldn't get to this point
+		            // if there was no WebGL support.
+		            H.error('[highcharts boost] - unable to init WebGL renderer');
+		        }
+
 		        // target.ogl.clear();
 		        target.ogl.setOptions(chart.options.boost || {});
 
@@ -2797,24 +2972,16 @@
 		], function (method) {
 		    function branch(proceed) {
 		        var letItPass = this.options.stacking &&
-		                        (method === 'translate' || method === 'generatePoints'),
-		            enabled = pick(
-		                (
-		                    this.chart &&
-		                    this.chart.options &&
-		                    this.chart.options.boost &&
-		                    this.chart.options.boost.enabled
-		                ),
-		                true
-		            );
+		            (method === 'translate' || method === 'generatePoints');
 
 		        if (
 		            !this.isSeriesBoosting ||
 		            letItPass ||
-		            !enabled ||
+		            !boostEnabled(this.chart) ||
 		            this.type === 'heatmap' ||
 		            this.type === 'treemap' ||
-		            !boostableMap[this.type]
+		            !boostableMap[this.type] ||
+		            this.options.boostThreshold === 0
 		        ) {
 
 		            proceed.call(this);
@@ -2859,7 +3026,7 @@
 		        );
 		    }
 
-		    if (boostableMap[this.type]) {
+		    if (boostEnabled(this.chart) && boostableMap[this.type]) {
 
 		        // If there are no extremes given in the options, we also need to
 		        // process the data to read the data extremes. If this is a heatmap, do
@@ -3103,6 +3270,7 @@
 		                minI,
 		                maxI,
 		                boostOptions,
+		                compareX = options.findNearestPointBy === 'x',
 
 		                xDataFull = (
 		                    this.xData ||
@@ -3112,8 +3280,8 @@
 		                ),
 
 		                addKDPoint = function (clientX, plotY, i) {
-		                    // Shaves off about 60ms compared to repeated concatination
-		                    index = clientX + ',' + plotY;
+		                    // Shaves off about 60ms compared to repeated concatenation
+		                    index = compareX ? clientX : clientX + ',' + plotY;
 
 		                    // The k-d tree requires series points.
 		                    // Reduce the amount of points, since the time to build the
@@ -3185,7 +3353,6 @@
 		                renderer.pushSeries(series);
 		                // Perform the actual renderer if we're on series level
 		                renderIfNotSeriesBoosting(renderer, this, chart);
-		                // console.log(series, chart);
 		            }
 
 		            /* This builds the KD-tree */