highcharts 6.1.4 → 6.2.0

package/es-modules/modules/broken-axis.src.js

@@ -1,5 +1,5 @@
 /**
- * (c) 2009-2017 Torstein Honsi
+ * (c) 2009-2018 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */
@@ -76,8 +76,14 @@ extend(Axis.prototype, {
     }
 });
 
+addEvent(Axis, 'afterInit', function () {
+    if (typeof this.setBreaks === 'function') {
+        this.setBreaks(this.options.breaks, false);
+    }
+});
+
 addEvent(Axis, 'afterSetTickPositions', function () {
-    if (this.options.breaks) {
+    if (this.isBroken) {
         var axis = this,
             tickPositions = this.tickPositions,
             info = this.tickPositions.info,
@@ -97,55 +103,77 @@ addEvent(Axis, 'afterSetTickPositions', function () {
 
 // Force Axis to be not-ordinal when breaks are defined
 addEvent(Axis, 'afterSetOptions', function () {
-    if (this.options.breaks && this.options.breaks.length) {
+    if (this.isBroken) {
         this.options.ordinal = false;
     }
 });
 
-addEvent(Axis, 'afterInit', function () {
+/**
+ * Dynamically set or unset breaks in an axis. This function in lighter than
+ * usin Axis.update, and it also preserves animation.
+ * @param  {Array} [breaks]
+ *         The breaks to add. When `undefined` it removes existing breaks.
+ * @param  {Boolean} [redraw=true]
+ *         Whether to redraw the chart immediately.
+ */
+Axis.prototype.setBreaks = function (breaks, redraw) {
     var axis = this,
-        breaks;
-
-    breaks = this.options.breaks;
-    axis.isBroken = (isArray(breaks) && !!breaks.length);
-    if (axis.isBroken) {
-        axis.val2lin = function (val) {
-            var nval = val,
-                brk,
-                i;
-
-            for (i = 0; i < axis.breakArray.length; i++) {
-                brk = axis.breakArray[i];
-                if (brk.to <= val) {
-                    nval -= brk.len;
-                } else if (brk.from >= val) {
-                    break;
-                } else if (axis.isInBreak(brk, val)) {
-                    nval -= (val - brk.from);
-                    break;
-                }
+        isBroken = (isArray(breaks) && !!breaks.length);
+
+    function breakVal2Lin(val) {
+        var nval = val,
+            brk,
+            i;
+
+        for (i = 0; i < axis.breakArray.length; i++) {
+            brk = axis.breakArray[i];
+            if (brk.to <= val) {
+                nval -= brk.len;
+            } else if (brk.from >= val) {
+                break;
+            } else if (axis.isInBreak(brk, val)) {
+                nval -= (val - brk.from);
+                break;
             }
+        }
 
-            return nval;
-        };
+        return nval;
+    }
 
-        axis.lin2val = function (val) {
-            var nval = val,
-                brk,
-                i;
-
-            for (i = 0; i < axis.breakArray.length; i++) {
-                brk = axis.breakArray[i];
-                if (brk.from >= nval) {
-                    break;
-                } else if (brk.to < nval) {
-                    nval += brk.len;
-                } else if (axis.isInBreak(brk, nval)) {
-                    nval += brk.len;
-                }
+    function breakLin2Val(val) {
+        var nval = val,
+            brk,
+            i;
+
+        for (i = 0; i < axis.breakArray.length; i++) {
+            brk = axis.breakArray[i];
+            if (brk.from >= nval) {
+                break;
+            } else if (brk.to < nval) {
+                nval += brk.len;
+            } else if (axis.isInBreak(brk, nval)) {
+                nval += brk.len;
             }
-            return nval;
-        };
+        }
+        return nval;
+    }
+
+
+    axis.isDirty = axis.isBroken !== isBroken;
+    axis.isBroken = isBroken;
+    axis.options.breaks = axis.userOptions.breaks = breaks;
+    axis.forceRedraw = true; // Force recalculation in setScale
+
+    if (!isBroken && axis.val2lin === breakVal2Lin) {
+        // Revert to prototype functions
+        delete axis.val2lin;
+        delete axis.lin2val;
+    }
+
+    if (isBroken) {
+        axis.userOptions.ordinal = false;
+        axis.val2lin = breakVal2Lin;
+        axis.lin2val = breakLin2Val;
 
         axis.setExtremes = function (
             newMin,
@@ -156,11 +184,13 @@ addEvent(Axis, 'afterInit', function () {
         ) {
             // If trying to set extremes inside a break, extend it to before and
             // after the break ( #3857 )
-            while (this.isInAnyBreak(newMin)) {
-                newMin -= this.closestPointRange;
-            }
-            while (this.isInAnyBreak(newMax)) {
-                newMax -= this.closestPointRange;
+            if (this.isBroken) {
+                while (this.isInAnyBreak(newMin)) {
+                    newMin -= this.closestPointRange;
+                }
+                while (this.isInAnyBreak(newMax)) {
+                    newMax -= this.closestPointRange;
+                }
             }
             Axis.prototype.setExtremes.call(
                 this,
@@ -175,108 +205,113 @@ addEvent(Axis, 'afterInit', function () {
         axis.setAxisTranslation = function (saveOld) {
             Axis.prototype.setAxisTranslation.call(this, saveOld);
 
-            var breaks = axis.options.breaks,
-                breakArrayT = [],    // Temporary one
-                breakArray = [],
-                length = 0,
-                inBrk,
-                repeat,
-                min = axis.userMin || axis.min,
-                max = axis.userMax || axis.max,
-                pointRangePadding = pick(axis.pointRangePadding, 0),
-                start,
-                i;
-
-            // Min & max check (#4247)
-            each(breaks, function (brk) {
-                repeat = brk.repeat || Infinity;
-                if (axis.isInBreak(brk, min)) {
-                    min += (brk.to % repeat) - (min % repeat);
-                }
-                if (axis.isInBreak(brk, max)) {
-                    max -= (max % repeat) - (brk.from % repeat);
-                }
-            });
+            this.unitLength = null;
+            if (this.isBroken) {
+                var breaks = axis.options.breaks,
+                    breakArrayT = [],    // Temporary one
+                    breakArray = [],
+                    length = 0,
+                    inBrk,
+                    repeat,
+                    min = axis.userMin || axis.min,
+                    max = axis.userMax || axis.max,
+                    pointRangePadding = pick(axis.pointRangePadding, 0),
+                    start,
+                    i;
+
+                // Min & max check (#4247)
+                each(breaks, function (brk) {
+                    repeat = brk.repeat || Infinity;
+                    if (axis.isInBreak(brk, min)) {
+                        min += (brk.to % repeat) - (min % repeat);
+                    }
+                    if (axis.isInBreak(brk, max)) {
+                        max -= (max % repeat) - (brk.from % repeat);
+                    }
+                });
 
-            // Construct an array holding all breaks in the axis
-            each(breaks, function (brk) {
-                start = brk.from;
-                repeat = brk.repeat || Infinity;
+                // Construct an array holding all breaks in the axis
+                each(breaks, function (brk) {
+                    start = brk.from;
+                    repeat = brk.repeat || Infinity;
 
-                while (start - repeat > min) {
-                    start -= repeat;
-                }
-                while (start < min) {
-                    start += repeat;
-                }
+                    while (start - repeat > min) {
+                        start -= repeat;
+                    }
+                    while (start < min) {
+                        start += repeat;
+                    }
 
-                for (i = start; i < max; i += repeat) {
-                    breakArrayT.push({
-                        value: i,
-                        move: 'in'
-                    });
-                    breakArrayT.push({
-                        value: i + (brk.to - brk.from),
-                        move: 'out',
-                        size: brk.breakSize
-                    });
-                }
-            });
+                    for (i = start; i < max; i += repeat) {
+                        breakArrayT.push({
+                            value: i,
+                            move: 'in'
+                        });
+                        breakArrayT.push({
+                            value: i + (brk.to - brk.from),
+                            move: 'out',
+                            size: brk.breakSize
+                        });
+                    }
+                });
 
-            breakArrayT.sort(function (a, b) {
-                var ret;
-                if (a.value === b.value) {
-                    ret = (a.move === 'in' ? 0 : 1) - (b.move === 'in' ? 0 : 1);
-                } else {
-                    ret = a.value - b.value;
-                }
-                return ret;
-            });
+                breakArrayT.sort(function (a, b) {
+                    return (
+                        (a.value === b.value) ?
+                        (a.move === 'in' ? 0 : 1) - (b.move === 'in' ? 0 : 1) :
+                        a.value - b.value
+                    );
+                });
 
-            // Simplify the breaks
-            inBrk = 0;
-            start = min;
+                // Simplify the breaks
+                inBrk = 0;
+                start = min;
 
-            each(breakArrayT, function (brk) {
-                inBrk += (brk.move === 'in' ? 1 : -1);
+                each(breakArrayT, function (brk) {
+                    inBrk += (brk.move === 'in' ? 1 : -1);
 
-                if (inBrk === 1 && brk.move === 'in') {
-                    start = brk.value;
-                }
-                if (inBrk === 0) {
-                    breakArray.push({
-                        from: start,
-                        to: brk.value,
-                        len: brk.value - start - (brk.size || 0)
-                    });
-                    length += brk.value - start - (brk.size || 0);
-                }
-            });
+                    if (inBrk === 1 && brk.move === 'in') {
+                        start = brk.value;
+                    }
+                    if (inBrk === 0) {
+                        breakArray.push({
+                            from: start,
+                            to: brk.value,
+                            len: brk.value - start - (brk.size || 0)
+                        });
+                        length += brk.value - start - (brk.size || 0);
+                    }
+                });
 
-            axis.breakArray = breakArray;
+                axis.breakArray = breakArray;
 
-            // Used with staticScale, and below, the actual axis length when
-            // breaks are substracted.
-            axis.unitLength = max - min - length + pointRangePadding;
+                // Used with staticScale, and below, the actual axis length when
+                // breaks are substracted.
+                axis.unitLength = max - min - length + pointRangePadding;
 
-            fireEvent(axis, 'afterBreaks');
+                fireEvent(axis, 'afterBreaks');
 
-            if (axis.options.staticScale) {
-                axis.transA = axis.options.staticScale;
-            } else if (axis.unitLength) {
-                axis.transA *= (max - axis.min + pointRangePadding) /
-                    axis.unitLength;
-            }
+                if (axis.staticScale) {
+                    axis.transA = axis.staticScale;
+                } else if (axis.unitLength) {
+                    axis.transA *= (max - axis.min + pointRangePadding) /
+                        axis.unitLength;
+                }
 
-            if (pointRangePadding) {
-                axis.minPixelPadding = axis.transA * axis.minPointOffset;
-            }
+                if (pointRangePadding) {
+                    axis.minPixelPadding = axis.transA * axis.minPointOffset;
+                }
 
-            axis.min = min;
-            axis.max = max;
+                axis.min = min;
+                axis.max = max;
+            }
         };
     }
-});
+
+    if (pick(redraw, true)) {
+        this.chart.redraw();
+    }
+};
 
 wrap(Series.prototype, 'generatePoints', function (proceed) {
 

package/es-modules/modules/data.src.js

@@ -1,7 +1,7 @@
 /**
  * Data module
  *
- * (c) 2012-2017 Torstein Honsi
+ * (c) 2012-2018 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */
@@ -166,7 +166,7 @@ var addEvent = Highcharts.addEvent,
  * @sample {highstock} highcharts/data/start-end/ Don't get series names from the CSV
  * @default true
  * @since 4.1.0
- * @product highcharts highstock
+ * @product highcharts highstock gantt
  * @apioption data.firstRowAsNames
  */