echarts 3.5.1 → 3.6.0

package/lib/model/Series.js

@@ -181,7 +181,7 @@
          * @return {Array.<string>} dimensions on the axis.
          */
         coordDimToDataDim: function (coordDim) {
-            return [coordDim];
+            return modelUtil.coordDimToDataDim(this.getData(), coordDim);
         },
 
         /**
@@ -191,7 +191,7 @@
          * @return {string}
          */
         dataDimToCoordDim: function (dataDim) {
-            return dataDim;
+            return modelUtil.dataDimToCoordDim(this.getData(), dataDim);
         },
 
         /**
@@ -215,35 +215,46 @@
          */
         formatTooltip: function (dataIndex, multipleSeries, dataType) {
             function formatArrayValue(value) {
-                var result = [];
-
-                zrUtil.each(value, function (val, idx) {
-                    var dimInfo = data.getDimensionInfo(idx);
-                    var dimType = dimInfo && dimInfo.type;
-                    var valStr;
+                var vertially = zrUtil.reduce(value, function (vertially, val, idx) {
+                    var dimItem = data.getDimensionInfo(idx);
+                    return vertially |= dimItem.tooltip !== false && dimItem.tooltipName != null;
+                }, 0);
 
-                    if (dimType === 'ordinal') {
-                        valStr = val + '';
-                    }
-                    else if (dimType === 'time') {
-                        valStr = multipleSeries ? '' : formatUtil.formatTime('yyyy/MM/dd hh:mm:ss', val);
-                    }
-                    else {
-                        valStr = addCommas(val);
+                var result = [];
+                var tooltipDims = modelUtil.otherDimToDataDim(data, 'tooltip');
+
+                tooltipDims.length
+                    ? zrUtil.each(tooltipDims, function (dimIdx) {
+                        setEachItem(data.get(dimIdx, dataIndex), dimIdx);
+                    })
+                    // By default, all dims is used on tooltip.
+                    : zrUtil.each(value, setEachItem);
+
+                function setEachItem(val, dimIdx) {
+                    var dimInfo = data.getDimensionInfo(dimIdx);
+                    // If `dimInfo.tooltip` is not set, show tooltip.
+                    if (!dimInfo || dimInfo.otherDims.tooltip === false) {
+                        return;
                     }
+                    var dimType = dimInfo.type;
+                    var valStr = (vertially ? '- ' + (dimInfo.tooltipName || dimInfo.name) + ': ' : '')
+                        + (dimType === 'ordinal'
+                            ? val + ''
+                            : dimType === 'time'
+                            ? (multipleSeries ? '' : formatUtil.formatTime('yyyy/MM/dd hh:mm:ss', val))
+                            : addCommas(val)
+                        );
+                    valStr && result.push(encodeHTML(valStr));
+                }
 
-                    valStr && result.push(valStr);
-                });
-
-                return result.join(', ');
+                return (vertially ? '<br/>' : '') + result.join(vertially ? '<br/>' : ', ');
             }
 
             var data = get(this, 'data');
 
             var value = this.getRawValue(dataIndex);
-            var formattedValue = encodeHTML(
-                zrUtil.isArray(value) ? formatArrayValue(value) : addCommas(value)
-            );
+            var formattedValue = zrUtil.isArray(value)
+                ? formatArrayValue(value) : encodeHTML(addCommas(value));
             var name = data.getName(dataIndex);
 
             var color = data.getItemVisual(dataIndex, 'color');
@@ -252,8 +263,7 @@
             }
             color = color || 'transparent';
 
-            var colorEl = '<span style="display:inline-block;margin-right:5px;'
-                + 'border-radius:10px;width:9px;height:9px;background-color:' + encodeHTML(color) + '"></span>';
+            var colorEl = formatUtil.getTooltipMarker(color);
 
             var seriesName = this.name;
             // FIXME
@@ -261,14 +271,16 @@
                 // Not show '-'
                 seriesName = '';
             }
+            seriesName = seriesName
+                ? encodeHTML(seriesName) + (!multipleSeries ? '<br/>' : ': ')
+                : '';
             return !multipleSeries
-                ? ((seriesName && encodeHTML(seriesName) + '<br />') + colorEl
+                ? seriesName + colorEl
                     + (name
-                        ? encodeHTML(name) + ' : ' + formattedValue
+                        ? encodeHTML(name) + ': ' + formattedValue
                         : formattedValue
                     )
-                  )
-                : (colorEl + encodeHTML(this.name) + ' : ' + formattedValue);
+                : colorEl + seriesName + formattedValue;
         },
 
         /**

package/lib/model/globalDefault.js

@@ -51,5 +51,8 @@
         // `progressiveThreshold`, otherwise hover will cause restart of progressive,
         // which is unexpected.
         // see example <echarts/test/heatmap-large.html>.
-        hoverLayerThreshold: 3000
+        hoverLayerThreshold: 3000,
+
+        // See: module:echarts/scale/Time
+        useUTC: false
     };

package/lib/model/mixin/colorPalette.js

@@ -14,7 +14,8 @@
             scope = scope || this;
             var colorIdx = get(scope, 'colorIdx') || 0;
             var colorNameMap = get(scope, 'colorNameMap') || set(scope, 'colorNameMap', {});
-            if (colorNameMap[name]) {
+            // Use `hasOwnProperty` to avoid conflict with Object.prototype.
+            if (colorNameMap.hasOwnProperty(name)) {
                 return colorNameMap[name];
             }
             var colorPalette = this.get('color', true) || [];

package/lib/model/mixin/textStyle.js

@@ -1,10 +1,7 @@
 
 
     var textContain = require('zrender/lib/contain/text');
-
-    function getShallow(model, path) {
-        return model && model.getShallow(path);
-    }
+    var graphicUtil = require('../../util/graphic');
 
     module.exports = {
         /**
@@ -22,15 +19,12 @@
          * @return {string}
          */
         getFont: function () {
-            var ecModel = this.ecModel;
-            var gTextStyleModel = ecModel && ecModel.getModel('textStyle');
-            return [
-                // FIXME in node-canvas fontWeight is before fontStyle
-                this.getShallow('fontStyle') || getShallow(gTextStyleModel, 'fontStyle'),
-                this.getShallow('fontWeight') || getShallow(gTextStyleModel, 'fontWeight'),
-                (this.getShallow('fontSize') || getShallow(gTextStyleModel, 'fontSize') || 12) + 'px',
-                this.getShallow('fontFamily') || getShallow(gTextStyleModel, 'fontFamily') || 'sans-serif'
-            ].join(' ');
+            return graphicUtil.getFont({
+                fontStyle: this.getShallow('fontStyle'),
+                fontWeight: this.getShallow('fontWeight'),
+                fontSize: this.getShallow('fontSize'),
+                fontFamily: this.getShallow('fontFamily')
+            }, this.ecModel);
         },
 
         getTextRect: function (text) {

package/lib/scale/Interval.js

@@ -8,12 +8,10 @@
     var numberUtil = require('../util/number');
     var formatUtil = require('../util/format');
     var Scale = require('./Scale');
+    var helper = require('./helper');
 
-    var mathFloor = Math.floor;
-    var mathCeil = Math.ceil;
+    var roundNumber = numberUtil.round;
 
-    var getPrecisionSafe = numberUtil.getPrecisionSafe;
-    var roundingErrorFix = numberUtil.round;
     /**
      * @alias module:echarts/coord/scale/Interval
      * @constructor
@@ -49,8 +47,10 @@
          * Get interval
          */
         getInterval: function () {
-            if (!this._interval) {
-                this.niceTicks();
+            if (__DEV__) {
+                if (this._interval == null) {
+                    throw new Error('`nice` should be called firstly' );
+                }
             }
             return this._interval;
         },
@@ -69,43 +69,14 @@
          * @return {Array.<number>}
          */
         getTicks: function () {
-            if (!this._interval) {
-                this.niceTicks();
-            }
-            var interval = this._interval;
-            var extent = this._extent;
-            var ticks = [];
-
-            // Consider this case: using dataZoom toolbox, zoom and zoom.
-            var safeLimit = 10000;
-
-            if (interval) {
-                var niceExtent = this._niceExtent;
-                var precision = this._intervalPrecision = getPrecisionSafe(interval);
-                // FIXME
-                precision += 2;
-
-                if (extent[0] < niceExtent[0]) {
-                    ticks.push(extent[0]);
-                }
-                var tick = niceExtent[0];
-
-                while (tick <= niceExtent[1]) {
-                    ticks.push(tick);
-                    // Avoid rounding error
-                    tick = roundingErrorFix(tick + interval, precision);
-                    if (ticks.length > safeLimit) {
-                        return [];
-                    }
-                }
-                // Consider this case: the last item of ticks is smaller
-                // than niceExtent[1] and niceExtent[1] === extent[1].
-                if (extent[1] > (ticks.length ? ticks[ticks.length - 1] : niceExtent[1])) {
-                    ticks.push(extent[1]);
+            if (__DEV__) {
+                if (this._interval == null) {
+                    throw new Error('`nice` should be called firstly' );
                 }
             }
-
-            return ticks;
+            return helper.intervalScaleGetTicks(
+                this._interval, this._extent, this._niceExtent, this._intervalPrecision
+            );
         },
 
         /**
@@ -125,15 +96,27 @@
          * @param {Object} [opt]
          * @param {number|string} [opt.precision] If 'auto', use nice presision.
          * @param {boolean} [opt.pad] returns 1.50 but not 1.5 if precision is 2.
-         * @return {number}
+         * @return {string}
          */
         getLabel: function (data, opt) {
+            if (data == null) {
+                return '';
+            }
+
             var precision = opt && opt.precision;
-            if (data != null && precision != null) {
+
+            if (precision == null) {
+                precision = numberUtil.getPrecisionSafe(data) || 0;
+            }
+            else if (precision === 'auto') {
                 // Should be more precise then tick.
-                precision === 'auto' && (precision = this._intervalPrecision + 2);
-                data = roundingErrorFix(data, precision, opt && opt.pad);
+                precision = this._intervalPrecision;
             }
+
+            // (1) If `precision` is set, 12.005 should be display as '12.00500'.
+            // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.
+            data = roundNumber(data, precision, true);
+
             return formatUtil.addCommas(data);
         },
 
@@ -141,8 +124,9 @@
          * Update interval and extent of intervals for nice ticks
          *
          * @param {number} [splitNumber = 5] Desired number of ticks
+         * @param {number} [minInterval]
          */
-        niceTicks: function (splitNumber) {
+        niceTicks: function (splitNumber, minInterval) {
             splitNumber = splitNumber || 5;
             var extent = this._extent;
             var span = extent[1] - extent[0];
@@ -156,36 +140,22 @@
                 extent.reverse();
             }
 
-            // From "Nice Numbers for Graph Labels" of Graphic Gems
-            // var niceSpan = numberUtil.nice(span, false);
-            var step = roundingErrorFix(
-                numberUtil.nice(span / splitNumber, true),
-                Math.max(
-                    getPrecisionSafe(extent[0]),
-                    getPrecisionSafe(extent[1])
-                // extent may be [0, 1], and step should have 1 more digits.
-                // To make it safe we add 2 more digits
-                ) + 2
-            );
-
-            var precision = getPrecisionSafe(step) + 2;
-            // Niced extent inside original extent
-            var niceExtent = [
-                roundingErrorFix(mathCeil(extent[0] / step) * step, precision),
-                roundingErrorFix(mathFloor(extent[1] / step) * step, precision)
-            ];
+            var result = helper.intervalScaleNiceTicks(extent, splitNumber, minInterval);
 
-            this._interval = step;
-            this._niceExtent = niceExtent;
+            this._intervalPrecision = result.intervalPrecision;
+            this._interval = result.interval;
+            this._niceExtent = result.niceTickExtent;
         },
 
         /**
          * Nice extent.
-         * @param {number} [splitNumber = 5] Given approx tick number
-         * @param {boolean} [fixMin=false]
-         * @param {boolean} [fixMax=false]
+         * @param {Object} opt
+         * @param {number} [opt.splitNumber = 5] Given approx tick number
+         * @param {boolean} [opt.fixMin=false]
+         * @param {boolean} [opt.fixMax=false]
+         * @param {boolean} [opt.minInterval=false]
          */
-        niceExtent: function (splitNumber, fixMin, fixMax) {
+        niceExtent: function (opt) {
             var extent = this._extent;
             // If extent start and end are same, expand them
             if (extent[0] === extent[1]) {
@@ -197,7 +167,7 @@
                     //      Plus data are all 100 and axis extent are [100, 100].
                     // Extend to the both side will cause expanded max is larger than fixed max.
                     // So only expand to the smaller side.
-                    if (!fixMax) {
+                    if (!opt.fixMax) {
                         extent[1] += expandSize / 2;
                         extent[0] -= expandSize / 2;
                     }
@@ -216,16 +186,16 @@
                 extent[1] = 1;
             }
 
-            this.niceTicks(splitNumber);
+            this.niceTicks(opt.splitNumber, opt.minInterval);
 
             // var extent = this._extent;
             var interval = this._interval;
 
-            if (!fixMin) {
-                extent[0] = roundingErrorFix(mathFloor(extent[0] / interval) * interval);
+            if (!opt.fixMin) {
+                extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
             }
-            if (!fixMax) {
-                extent[1] = roundingErrorFix(mathCeil(extent[1] / interval) * interval);
+            if (!opt.fixMax) {
+                extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
             }
         }
     });

package/lib/scale/Log.js

@@ -158,16 +158,14 @@
 
         /**
          * Nice extent.
-         * @param {number} [approxTickNum = 10] Given approx tick number
-         * @param {boolean} [fixMin=false]
-         * @param {boolean} [fixMax=false]
+         * @override
          */
-        niceExtent: function (splitNumber, fixMin, fixMax) {
-            intervalScaleProto.niceExtent.call(this, splitNumber, fixMin, fixMax);
+        niceExtent: function (opt) {
+            intervalScaleProto.niceExtent.call(this, opt);
 
             var originalScale = this._originalScale;
-            originalScale.__fixMin = fixMin;
-            originalScale.__fixMax = fixMax;
+            originalScale.__fixMin = opt.fixMin;
+            originalScale.__fixMax = opt.fixMax;
         }
 
     });

package/lib/scale/Scale.js

@@ -6,7 +6,12 @@
 
     var clazzUtil = require('../util/clazz');
 
-    function Scale() {
+    /**
+     * @param {Object} [setting]
+     */
+    function Scale(setting) {
+        this._setting = setting || {};
+
         /**
          * Extent
          * @type {Array.<number>}
@@ -39,6 +44,10 @@
         return val;
     };
 
+    scaleProto.getSetting = function (name) {
+        return this._setting[name];
+    };
+
     scaleProto.contain = function (val) {
         var extent = this._extent;
         return val >= extent[0] && val <= extent[1];

package/lib/scale/Time.js

@@ -5,9 +5,20 @@
 
 
 
+    // [About UTC and local time zone]:
+    // In most cases, `number.parseDate` will treat input data string as local time
+    // (except time zone is specified in time string). And `format.formateTime` returns
+    // local time by default. option.useUTC is false by default. This design have
+    // concidered these common case:
+    // (1) Time that is persistent in server is in UTC, but it is needed to be diplayed
+    // in local time by default.
+    // (2) By default, the input data string (e.g., '2011-01-02') should be displayed
+    // as its original time, without any time difference.
+
     var zrUtil = require('zrender/lib/core/util');
     var numberUtil = require('../util/number');
     var formatUtil = require('../util/format');
+    var scaleHelper = require('./helper');
 
     var IntervalScale = require('./Interval');
 
@@ -41,17 +52,21 @@
     var TimeScale = IntervalScale.extend({
         type: 'time',
 
-        // Overwrite
+        /**
+         * @override
+         */
         getLabel: function (val) {
             var stepLvl = this._stepLvl;
 
             var date = new Date(val);
 
-            return formatUtil.formatTime(stepLvl[0], date);
+            return formatUtil.formatTime(stepLvl[0], date, this.getSetting('useUTC'));
         },
 
-        // Overwrite
-        niceExtent: function (approxTickNum, fixMin, fixMax) {
+        /**
+         * @override
+         */
+        niceExtent: function (opt) {
             var extent = this._extent;
             // If extent start and end are same, expand them
             if (extent[0] === extent[1]) {
@@ -66,21 +81,25 @@
                 extent[0] = extent[1] - ONE_DAY;
             }
 
-            this.niceTicks(approxTickNum);
+            this.niceTicks(opt.splitNumber);
 
             // var extent = this._extent;
             var interval = this._interval;
 
-            if (!fixMin) {
+            if (!opt.fixMin) {
                 extent[0] = numberUtil.round(mathFloor(extent[0] / interval) * interval);
             }
-            if (!fixMax) {
+            if (!opt.fixMax) {
                 extent[1] = numberUtil.round(mathCeil(extent[1] / interval) * interval);
             }
         },
 
-        // Overwrite
+        /**
+         * @override
+         */
         niceTicks: function (approxTickNum) {
+            var timezoneOffset = this.getSetting('useUTC')
+                ? 0 : numberUtil.getTimezoneOffset() * 60 * 1000;
             approxTickNum = approxTickNum || 10;
 
             var extent = this._extent;
@@ -103,10 +122,12 @@
             }
 
             var niceExtent = [
-                mathCeil(extent[0] / interval) * interval,
-                mathFloor(extent[1] / interval) * interval
+                Math.round(mathCeil((extent[0] - timezoneOffset) / interval) * interval + timezoneOffset),
+                Math.round(mathFloor((extent[1] - timezoneOffset)/ interval) * interval + timezoneOffset)
             ];
 
+            scaleHelper.fixExtent(niceExtent, extent);
+
             this._stepLvl = level;
             // Interval will be used in getTicks
             this._interval = interval;
@@ -151,10 +172,11 @@
     ];
 
     /**
+     * @param {module:echarts/model/Model}
      * @return {module:echarts/scale/Time}
      */
-    TimeScale.create = function () {
-        return new TimeScale();
+    TimeScale.create = function (model) {
+        return new TimeScale({useUTC: model.ecModel.get('useUTC')});
     };
 
     module.exports = TimeScale;

package/lib/scale/helper.js

@@ -0,0 +1,93 @@
+/**
+ * For testable.
+ */
+
+
+    var numberUtil = require('../util/number');
+
+    var roundNumber = numberUtil.round;
+
+    var helper = {};
+
+    /**
+     * @param {Array.<number>} extent Both extent[0] and extent[1] should be valid number.
+     *                                Should be extent[0] < extent[1].
+     * @param {number} splitNumber splitNumber should be >= 1.
+     * @param {number} [minInterval]
+     * @return {Object} {interval, intervalPrecision, niceTickExtent}
+     */
+    helper.intervalScaleNiceTicks = function (extent, splitNumber, minInterval) {
+        var result = {};
+        var span = extent[1] - extent[0];
+
+        var interval = result.interval = numberUtil.nice(span / splitNumber, true);
+        if (minInterval != null && interval < minInterval) {
+            interval = result.interval = minInterval;
+        }
+        // Tow more digital for tick.
+        var precision = result.intervalPrecision = numberUtil.getPrecisionSafe(interval) + 2;
+        // Niced extent inside original extent
+        var niceTickExtent = result.niceTickExtent = [
+            roundNumber(Math.ceil(extent[0] / interval) * interval, precision),
+            roundNumber(Math.floor(extent[1] / interval) * interval, precision)
+        ];
+
+        helper.fixExtent(niceTickExtent, extent);
+
+        return result;
+    };
+
+    function clamp(niceTickExtent, idx, extent) {
+        niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]);
+    }
+
+    // In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent.
+    helper.fixExtent = function (niceTickExtent, extent) {
+        !isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]);
+        !isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]);
+        clamp(niceTickExtent, 0, extent);
+        clamp(niceTickExtent, 1, extent);
+        if (niceTickExtent[0] > niceTickExtent[1]) {
+            niceTickExtent[0] = niceTickExtent[1];
+        }
+    };
+
+    helper.intervalScaleGetTicks = function (interval, extent, niceTickExtent, intervalPrecision) {
+        var ticks = [];
+
+        // If interval is 0, return [];
+        if (!interval) {
+            return ticks;
+        }
+
+        // Consider this case: using dataZoom toolbox, zoom and zoom.
+        var safeLimit = 10000;
+
+        if (extent[0] < niceTickExtent[0]) {
+            ticks.push(extent[0]);
+        }
+        var tick = niceTickExtent[0];
+
+        while (tick <= niceTickExtent[1]) {
+            ticks.push(tick);
+            // Avoid rounding error
+            tick = roundNumber(tick + interval, intervalPrecision);
+            if (tick === ticks[ticks.length - 1]) {
+                // Consider out of safe float point, e.g.,
+                // -3711126.9907707 + 2e-10 === -3711126.9907707
+                break;
+            }
+            if (ticks.length > safeLimit) {
+                return [];
+            }
+        }
+        // Consider this case: the last item of ticks is smaller
+        // than niceTickExtent[1] and niceTickExtent[1] === extent[1].
+        if (extent[1] > (ticks.length ? ticks[ticks.length - 1] : niceTickExtent[1])) {
+            ticks.push(extent[1]);
+        }
+
+        return ticks;
+    };
+
+    module.exports = helper;

package/lib/util/format.js

@@ -5,9 +5,11 @@
     var textContain = require('zrender/lib/contain/text');
 
     var formatUtil = {};
+
     /**
      * 每三位默认加,格式化
-     * @type {string|number} x
+     * @param {string|number} x
+     * @return {string}
      */
     formatUtil.addCommas = function (x) {
         if (isNaN(x)) {
@@ -127,6 +129,18 @@
         return tpl;
     };
 
+    /**
+     * @param {string} color
+     * @param {string} [extraCssText]
+     * @return {string}
+     */
+    formatUtil.getTooltipMarker = function (color, extraCssText) {
+        return color
+            ? '<span style="display:inline-block;margin-right:5px;'
+                + 'border-radius:10px;width:9px;height:9px;background-color:'
+                + formatUtil.encodeHTML(color) + ';' + (extraCssText || '') + '"></span>'
+            : '';
+    };
 
     /**
      * @param {string} str
@@ -141,15 +155,12 @@
      * ISO Date format
      * @param {string} tpl
      * @param {number} value
-     * @param {boolean} [isLocal=false] Default use UTC
-     *  Why default UTC? In most case, time provided by user is
-     *  understood in UTC. For example, new Date('2012-01-01')
-     *  or a string '2012-01-01' or a timestamp. So it is
-     *  recommended to format time in UTC.
-     *  (see `echarts/util/number.js#parseDate`);
+     * @param {boolean} [isUTC=false] Default in local time.
+     *           see `module:echarts/scale/Time`
+     *           and `module:echarts/util/number#parseDate`.
      * @inner
      */
-    formatUtil.formatTime = function (tpl, value, isLocal) {
+    formatUtil.formatTime = function (tpl, value, isUTC) {
         if (tpl === 'week'
             || tpl === 'month'
             || tpl === 'quarter'
@@ -160,7 +171,7 @@
         }
 
         var date = numberUtil.parseDate(value);
-        var utc = isLocal ? '' : 'UTC';
+        var utc = isUTC ? 'UTC' : '';
         var y = date['get' + utc + 'FullYear']();
         var M = date['get' + utc + 'Month']() + 1;
         var d = date['get' + utc + 'Date']();