echarts 3.6.1 → 3.7.2

package/src/preprocessor/helper/compatStyle.js

@@ -1,6 +1,10 @@
 define(function (require) {
 
     var zrUtil = require('zrender/core/util');
+    var modelUtil = require('../../util/model');
+
+    var each = zrUtil.each;
+    var isObject = zrUtil.isObject;
 
     var POSSIBLE_STYLES = [
         'areaStyle', 'lineStyle', 'nodeStyle', 'linkStyle',
@@ -9,68 +13,176 @@ define(function (require) {
 
     function compatItemStyle(opt) {
         var itemStyleOpt = opt && opt.itemStyle;
-        if (itemStyleOpt) {
-            zrUtil.each(POSSIBLE_STYLES, function (styleName) {
-                var normalItemStyleOpt = itemStyleOpt.normal;
-                var emphasisItemStyleOpt = itemStyleOpt.emphasis;
-                if (normalItemStyleOpt && normalItemStyleOpt[styleName]) {
-                    opt[styleName] = opt[styleName] || {};
-                    if (!opt[styleName].normal) {
-                        opt[styleName].normal = normalItemStyleOpt[styleName];
-                    }
-                    else {
-                        zrUtil.merge(opt[styleName].normal, normalItemStyleOpt[styleName]);
-                    }
-                    normalItemStyleOpt[styleName] = null;
+        if (!itemStyleOpt) {
+            return;
+        }
+        for (var i = 0, len = POSSIBLE_STYLES.length; i < len; i++) {
+            var styleName = POSSIBLE_STYLES[i];
+            var normalItemStyleOpt = itemStyleOpt.normal;
+            var emphasisItemStyleOpt = itemStyleOpt.emphasis;
+            if (normalItemStyleOpt && normalItemStyleOpt[styleName]) {
+                opt[styleName] = opt[styleName] || {};
+                if (!opt[styleName].normal) {
+                    opt[styleName].normal = normalItemStyleOpt[styleName];
                 }
-                if (emphasisItemStyleOpt && emphasisItemStyleOpt[styleName]) {
-                    opt[styleName] = opt[styleName] || {};
-                    if (!opt[styleName].emphasis) {
-                        opt[styleName].emphasis = emphasisItemStyleOpt[styleName];
-                    }
-                    else {
-                        zrUtil.merge(opt[styleName].emphasis, emphasisItemStyleOpt[styleName]);
-                    }
-                    emphasisItemStyleOpt[styleName] = null;
+                else {
+                    zrUtil.merge(opt[styleName].normal, normalItemStyleOpt[styleName]);
+                }
+                normalItemStyleOpt[styleName] = null;
+            }
+            if (emphasisItemStyleOpt && emphasisItemStyleOpt[styleName]) {
+                opt[styleName] = opt[styleName] || {};
+                if (!opt[styleName].emphasis) {
+                    opt[styleName].emphasis = emphasisItemStyleOpt[styleName];
+                }
+                else {
+                    zrUtil.merge(opt[styleName].emphasis, emphasisItemStyleOpt[styleName]);
+                }
+                emphasisItemStyleOpt[styleName] = null;
+            }
+        }
+    }
+
+    function compatTextStyle(opt, propName) {
+        var labelOptSingle = isObject(opt) && opt[propName];
+        var textStyle = isObject(labelOptSingle) && labelOptSingle.textStyle;
+        if (textStyle) {
+            for (var i = 0, len = modelUtil.TEXT_STYLE_OPTIONS.length; i < len; i++) {
+                var propName = modelUtil.TEXT_STYLE_OPTIONS[i];
+                if (textStyle.hasOwnProperty(propName)) {
+                    labelOptSingle[propName] = textStyle[propName];
                 }
-            });
+            }
+        }
+    }
+
+    function compatLabelTextStyle(labelOpt) {
+        if (isObject(labelOpt)) {
+            compatTextStyle(labelOpt, 'normal');
+            compatTextStyle(labelOpt, 'emphasis');
         }
     }
 
-    return function (seriesOpt) {
-        if (!seriesOpt) {
+    function processSeries(seriesOpt) {
+        if (!isObject(seriesOpt)) {
             return;
         }
+
         compatItemStyle(seriesOpt);
-        compatItemStyle(seriesOpt.markPoint);
+        compatLabelTextStyle(seriesOpt.label);
+        // treemap
+        compatLabelTextStyle(seriesOpt.upperLabel);
+        // graph
+        compatLabelTextStyle(seriesOpt.edgeLabel);
+
+        var markPoint = seriesOpt.markPoint;
+        compatItemStyle(markPoint);
+        compatLabelTextStyle(markPoint && markPoint.label);
+
+        var markLine = seriesOpt.markLine;
         compatItemStyle(seriesOpt.markLine);
+        compatLabelTextStyle(markLine && markLine.label);
+
+        var markArea = seriesOpt.markArea;
+        compatLabelTextStyle(markArea && markArea.label);
+
+        // For gauge
+        compatTextStyle(seriesOpt, 'axisLabel');
+        compatTextStyle(seriesOpt, 'title');
+        compatTextStyle(seriesOpt, 'detail');
+
         var data = seriesOpt.data;
         if (data) {
             for (var i = 0; i < data.length; i++) {
                 compatItemStyle(data[i]);
+                compatLabelTextStyle(data[i] && data[i].label);
             }
-            // mark point data
-            var markPoint = seriesOpt.markPoint;
-            if (markPoint && markPoint.data) {
-                var mpData = markPoint.data;
-                for (var i = 0; i < mpData.length; i++) {
-                    compatItemStyle(mpData[i]);
-                }
+        }
+
+        // mark point data
+        var markPoint = seriesOpt.markPoint;
+        if (markPoint && markPoint.data) {
+            var mpData = markPoint.data;
+            for (var i = 0; i < mpData.length; i++) {
+                compatItemStyle(mpData[i]);
+                compatLabelTextStyle(mpData[i] && mpData[i].label);
             }
-            // mark line data
-            var markLine = seriesOpt.markLine;
-            if (markLine && markLine.data) {
-                var mlData = markLine.data;
-                for (var i = 0; i < mlData.length; i++) {
-                    if (zrUtil.isArray(mlData[i])) {
-                        compatItemStyle(mlData[i][0]);
-                        compatItemStyle(mlData[i][1]);
-                    }
-                    else {
-                        compatItemStyle(mlData[i]);
-                    }
+        }
+        // mark line data
+        var markLine = seriesOpt.markLine;
+        if (markLine && markLine.data) {
+            var mlData = markLine.data;
+            for (var i = 0; i < mlData.length; i++) {
+                if (zrUtil.isArray(mlData[i])) {
+                    compatItemStyle(mlData[i][0]);
+                    compatLabelTextStyle(mlData[i][0] && mlData[i][0].label);
+                    compatItemStyle(mlData[i][1]);
+                    compatLabelTextStyle(mlData[i][1] && mlData[i][1].label);
+                }
+                else {
+                    compatItemStyle(mlData[i]);
+                    compatLabelTextStyle(mlData[i] && mlData[i].label);
                 }
             }
         }
+    }
+
+    function toArr(o) {
+        return zrUtil.isArray(o) ? o : o ? [o] : [];
+    }
+
+    function toObj(o) {
+        return (zrUtil.isArray(o) ? o[0] : o) || {};
+    }
+
+    return function (option, isTheme) {
+        each(toArr(option.series), function (seriesOpt) {
+            isObject(seriesOpt) && processSeries(seriesOpt);
+        });
+
+        var axes = ['xAxis', 'yAxis', 'radiusAxis', 'angleAxis', 'singleAxis', 'parallelAxis', 'radar'];
+        isTheme && axes.push('valueAxis', 'categoryAxis', 'logAxis', 'timeAxis');
+
+        each(
+            axes,
+            function (axisName) {
+                each(toArr(option[axisName]), function (axisOpt) {
+                    if (axisOpt) {
+                        compatTextStyle(axisOpt, 'axisLabel');
+                        compatTextStyle(axisOpt.axisPointer, 'label');
+                    }
+                });
+            }
+        );
+
+        each(toArr(option.parallel), function (parallelOpt) {
+            var parallelAxisDefault = parallelOpt && parallelOpt.parallelAxisDefault;
+            compatTextStyle(parallelAxisDefault, 'axisLabel');
+            compatTextStyle(parallelAxisDefault && parallelAxisDefault.axisPointer, 'label');
+        });
+
+        each(toArr(option.calendar), function (calendarOpt) {
+            compatTextStyle(calendarOpt, 'dayLabel');
+            compatTextStyle(calendarOpt, 'monthLabel');
+            compatTextStyle(calendarOpt, 'yearLabel');
+        });
+
+        // radar.name.textStyle
+        each(toArr(option.radar), function (radarOpt) {
+            compatTextStyle(radarOpt, 'name');
+        });
+
+        each(toArr(option.geo), function (geoOpt) {
+            if (isObject(geoOpt)) {
+                compatLabelTextStyle(geoOpt.label);
+                each(toArr(geoOpt.regions), function (regionObj) {
+                    compatLabelTextStyle(regionObj.label);
+                });
+            }
+        });
+
+        compatLabelTextStyle(toObj(option.timeline).label);
+        compatTextStyle(toObj(option.axisPointer), 'label');
+        compatTextStyle(toObj(option.tooltip).axisPointer, 'label');
     };
 });

package/src/scale/Interval.js

@@ -58,6 +58,8 @@ define(function (require) {
             // Dropped auto calculated niceExtent and use user setted extent
             // We assume user wan't to set both interval, min, max to get a better result
             this._niceExtent = this._extent.slice();
+
+            this._intervalPrecision = helper.getIntervalPrecision(interval);
         },
 
         /**
@@ -115,8 +117,9 @@ define(function (require) {
          *
          * @param {number} [splitNumber = 5] Desired number of ticks
          * @param {number} [minInterval]
+         * @param {number} [maxInterval]
          */
-        niceTicks: function (splitNumber, minInterval) {
+        niceTicks: function (splitNumber, minInterval, maxInterval) {
             splitNumber = splitNumber || 5;
             var extent = this._extent;
             var span = extent[1] - extent[0];
@@ -130,7 +133,9 @@ define(function (require) {
                 extent.reverse();
             }
 
-            var result = helper.intervalScaleNiceTicks(extent, splitNumber, minInterval);
+            var result = helper.intervalScaleNiceTicks(
+                extent, splitNumber, minInterval, maxInterval
+            );
 
             this._intervalPrecision = result.intervalPrecision;
             this._interval = result.interval;
@@ -143,7 +148,8 @@ define(function (require) {
          * @param {number} [opt.splitNumber = 5] Given approx tick number
          * @param {boolean} [opt.fixMin=false]
          * @param {boolean} [opt.fixMax=false]
-         * @param {boolean} [opt.minInterval=false]
+         * @param {boolean} [opt.minInterval]
+         * @param {boolean} [opt.maxInterval]
          */
         niceExtent: function (opt) {
             var extent = this._extent;
@@ -176,7 +182,7 @@ define(function (require) {
                 extent[1] = 1;
             }
 
-            this.niceTicks(opt.splitNumber, opt.minInterval);
+            this.niceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
 
             // var extent = this._extent;
             var interval = this._interval;

package/src/scale/Time.js

@@ -77,11 +77,11 @@ define(function (require) {
             // If there are no data and extent are [Infinity, -Infinity]
             if (extent[1] === -Infinity && extent[0] === Infinity) {
                 var d = new Date();
-                extent[1] = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+                extent[1] = +new Date(d.getFullYear(), d.getMonth(), d.getDate());
                 extent[0] = extent[1] - ONE_DAY;
             }
 
-            this.niceTicks(opt.splitNumber);
+            this.niceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
 
             // var extent = this._extent;
             var interval = this._interval;
@@ -97,14 +97,20 @@ define(function (require) {
         /**
          * @override
          */
-        niceTicks: function (approxTickNum) {
-            var timezoneOffset = this.getSetting('useUTC')
-                ? 0 : numberUtil.getTimezoneOffset() * 60 * 1000;
+        niceTicks: function (approxTickNum, minInterval, maxInterval) {
             approxTickNum = approxTickNum || 10;
 
             var extent = this._extent;
             var span = extent[1] - extent[0];
             var approxInterval = span / approxTickNum;
+
+            if (minInterval != null && approxInterval < minInterval) {
+                approxInterval = minInterval;
+            }
+            if (maxInterval != null && approxInterval > maxInterval) {
+                approxInterval = maxInterval;
+            }
+
             var scaleLevelsLen = scaleLevels.length;
             var idx = bisect(scaleLevels, approxInterval, 0, scaleLevelsLen);
 
@@ -121,9 +127,11 @@ define(function (require) {
                 interval *= yearStep;
             }
 
+            var timezoneOffset = this.getSetting('useUTC')
+                ? 0 : (new Date(+extent[0] || +extent[1])).getTimezoneOffset() * 60 * 1000;
             var niceExtent = [
                 Math.round(mathCeil((extent[0] - timezoneOffset) / interval) * interval + timezoneOffset),
-                Math.round(mathFloor((extent[1] - timezoneOffset)/ interval) * interval + timezoneOffset)
+                Math.round(mathFloor((extent[1] - timezoneOffset) / interval) * interval + timezoneOffset)
             ];
 
             scaleHelper.fixExtent(niceExtent, extent);

package/src/scale/helper.js

@@ -14,9 +14,10 @@ define(function (require) {
      *                                Should be extent[0] < extent[1].
      * @param {number} splitNumber splitNumber should be >= 1.
      * @param {number} [minInterval]
+     * @param {number} [maxInterval]
      * @return {Object} {interval, intervalPrecision, niceTickExtent}
      */
-    helper.intervalScaleNiceTicks = function (extent, splitNumber, minInterval) {
+    helper.intervalScaleNiceTicks = function (extent, splitNumber, minInterval, maxInterval) {
         var result = {};
         var span = extent[1] - extent[0];
 
@@ -24,8 +25,11 @@ define(function (require) {
         if (minInterval != null && interval < minInterval) {
             interval = result.interval = minInterval;
         }
+        if (maxInterval != null && interval > maxInterval) {
+            interval = result.interval = maxInterval;
+        }
         // Tow more digital for tick.
-        var precision = result.intervalPrecision = numberUtil.getPrecisionSafe(interval) + 2;
+        var precision = result.intervalPrecision = helper.getIntervalPrecision(interval);
         // Niced extent inside original extent
         var niceTickExtent = result.niceTickExtent = [
             roundNumber(Math.ceil(extent[0] / interval) * interval, precision),
@@ -37,6 +41,15 @@ define(function (require) {
         return result;
     };
 
+    /**
+     * @param {number} interval
+     * @return {number} interval precision
+     */
+    helper.getIntervalPrecision = function (interval) {
+        // Tow more digital for tick.
+        return numberUtil.getPrecisionSafe(interval) + 2;
+    };
+
     function clamp(niceTickExtent, idx, extent) {
         niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]);
     }

package/src/util/format.js

@@ -37,29 +37,7 @@ define(function (require) {
         return str;
     };
 
-    /**
-     * Normalize css liked array configuration
-     * e.g.
-     *  3 => [3, 3, 3, 3]
-     *  [4, 2] => [4, 2, 4, 2]
-     *  [4, 3, 2] => [4, 3, 2, 3]
-     * @param {number|Array.<number>} val
-     */
-    formatUtil.normalizeCssArray = function (val) {
-        var len = val.length;
-        if (typeof (val) === 'number') {
-            return [val, val, val, val];
-        }
-        else if (len === 2) {
-            // vertical | horizontal
-            return [val[0], val[1], val[0], val[1]];
-        }
-        else if (len === 3) {
-            // top | horizontal | bottom
-            return [val[0], val[1], val[2], val[1]];
-        }
-        return val;
-    };
+    formatUtil.normalizeCssArray = zrUtil.normalizeCssArray;
 
     var encodeHTML = formatUtil.encodeHTML = function (source) {
         return String(source)
@@ -180,7 +158,7 @@ define(function (require) {
         var s = date['get' + utc + 'Seconds']();
 
         tpl = tpl.replace('MM', s2d(M))
-            .toLowerCase()
+            .replace('M', M)
             .replace('yyyy', y)
             .replace('yy', y % 100)
             .replace('dd', s2d(d))
@@ -206,5 +184,7 @@ define(function (require) {
 
     formatUtil.truncateText = textContain.truncateText;
 
+    formatUtil.getTextRect = textContain.getBoundingRect;
+
     return formatUtil;
 });