echarts 3.5.1 → 3.6.0

package/src/data/DataDiffer.js

@@ -105,7 +105,8 @@ define(function(require) {
 
     function initIndexMap(arr, map, keyArr, keyGetter) {
         for (var i = 0; i < arr.length; i++) {
-            var key = keyGetter(arr[i], i);
+            // Add prefix to avoid conflict with Object.prototype.
+            var key = '_ec_' + keyGetter(arr[i], i);
             var existence = map[key];
             if (existence == null) {
                 keyArr.push(key);

package/src/data/Graph.js

@@ -10,6 +10,10 @@ define(function(require) {
 
     var zrUtil = require('zrender/core/util');
 
+    // id may be function name of Object, add a prefix to avoid this problem.
+    function generateNodeKey (id) {
+        return '_EC_' + id;
+    }
     /**
      * @alias module:echarts/data/Graph
      * @constructor
@@ -83,7 +87,7 @@ define(function(require) {
 
         var nodesMap = this._nodesMap;
 
-        if (nodesMap[id]) {
+        if (nodesMap[generateNodeKey(id)]) {
             return;
         }
 
@@ -92,7 +96,7 @@ define(function(require) {
 
         this.nodes.push(node);
 
-        nodesMap[id] = node;
+        nodesMap[generateNodeKey(id)] = node;
         return node;
     };
 
@@ -111,7 +115,7 @@ define(function(require) {
      * @return {module:echarts/data/Graph.Node}
      */
     graphProto.getNodeById = function (id) {
-        return this._nodesMap[id];
+        return this._nodesMap[generateNodeKey(id)];
     };
 
     /**
@@ -134,10 +138,10 @@ define(function(require) {
         }
 
         if (!(n1 instanceof Node)) {
-            n1 = nodesMap[n1];
+            n1 = nodesMap[generateNodeKey(n1)];
         }
         if (!(n2 instanceof Node)) {
-            n2 = nodesMap[n2];
+            n2 = nodesMap[generateNodeKey(n2)];
         }
         if (!n1 || !n2) {
             return;
@@ -244,7 +248,7 @@ define(function(require) {
         cb, startNode, direction, context
     ) {
         if (!(startNode instanceof Node)) {
-            startNode = this._nodesMap[startNode];
+            startNode = this._nodesMap[generateNodeKey(startNode)];
         }
         if (!startNode) {
             return;
@@ -271,7 +275,7 @@ define(function(require) {
                 var otherNode = e.node1 === currentNode
                     ? e.node2 : e.node1;
                 if (!otherNode.__visited) {
-                    if (cb.call(otherNode, otherNode, currentNode)) {
+                    if (cb.call(context, otherNode, currentNode)) {
                         // Stop traversing
                         return;
                     }

package/src/data/List.js

@@ -31,7 +31,7 @@ define(function (require) {
         'stackedOn', 'hasItemOption', '_nameList', '_idList', '_rawData'
     ];
 
-    var transferProperties = function (a, b) {
+    function transferProperties(a, b) {
         zrUtil.each(TRANSFERABLE_PROPERTIES.concat(b.__wrappedMethods || []), function (propName) {
             if (b.hasOwnProperty(propName)) {
                 a[propName] = b[propName];
@@ -39,6 +39,19 @@ define(function (require) {
         });
 
         a.__wrappedMethods = b.__wrappedMethods;
+    }
+
+    function DefaultDataProvider(dataArray) {
+        this._array = dataArray || [];
+    }
+
+    DefaultDataProvider.prototype.pure = false;
+
+    DefaultDataProvider.prototype.count = function () {
+        return this._array.length;
+    };
+    DefaultDataProvider.prototype.getItem = function (idx) {
+        return this._array[idx];
     };
 
     /**
@@ -63,6 +76,8 @@ define(function (require) {
                 dimensionName = dimensions[i];
                 dimensionInfo = {
                     name: dimensionName,
+                    coordDim: dimensionName,
+                    coordDimIndex: 0,
                     stackable: false,
                     // Type can be 'float', 'int', 'number'
                     // Default is number, Precision of float may not enough
@@ -73,10 +88,16 @@ define(function (require) {
                 dimensionInfo = dimensions[i];
                 dimensionName = dimensionInfo.name;
                 dimensionInfo.type = dimensionInfo.type || 'number';
+                if (!dimensionInfo.coordDim) {
+                    dimensionInfo.coordDim = dimensionName;
+                    dimensionInfo.coordDimIndex = 0;
+                }
             }
+            dimensionInfo.otherDims = dimensionInfo.otherDims || {};
             dimensionNames.push(dimensionName);
             dimensionInfos[dimensionName] = dimensionInfo;
         }
+
         /**
          * @readOnly
          * @type {Array.<string>}
@@ -122,6 +143,7 @@ define(function (require) {
          * @type {Array.<string>}
          */
         this._idList = [];
+
         /**
          * Models of data option is stored sparse for optimizing memory cost
          * @type {Array.<module:echarts/model/Model>}
@@ -185,6 +207,7 @@ define(function (require) {
     var listProto = List.prototype;
 
     listProto.type = 'list';
+
     /**
      * If each data item has it's own option
      * @type {boolean}
@@ -204,6 +227,7 @@ define(function (require) {
         }
         return dim;
     };
+
     /**
      * Get type and stackable info of particular dimension
      * @param {string|number} dim
@@ -223,9 +247,13 @@ define(function (require) {
     listProto.initData = function (data, nameList, dimValueGetter) {
         data = data || [];
 
+        var isDataArray = zrUtil.isArray(data);
+        if (isDataArray) {
+            data = new DefaultDataProvider(data);
+        }
         if (__DEV__) {
-            if (!zrUtil.isArray(data)) {
-                throw new Error('Invalid data.');
+            if (!isDataArray && (typeof data.getItem != 'function' || typeof data.count != 'function')) {
+                throw new Error('Inavlid data provider.');
             }
         }
 
@@ -236,17 +264,20 @@ define(function (require) {
         var indices = this.indices = [];
 
         var dimensions = this.dimensions;
-        var size = data.length;
         var dimensionInfoMap = this._dimensionInfos;
 
+        var size = data.count();
+
         var idList = [];
         var nameRepeatCount = {};
+        var nameDimIdx;
 
         nameList = nameList || [];
 
         // Init storage
         for (var i = 0; i < dimensions.length; i++) {
             var dimInfo = dimensionInfoMap[dimensions[i]];
+            dimInfo.otherDims.itemName === 0 && (nameDimIdx = i);
             var DataCtor = dataCtors[dimInfo.type];
             storage[dimensions[i]] = new DataCtor(size);
         }
@@ -271,8 +302,9 @@ define(function (require) {
             );
         };
 
-        for (var idx = 0; idx < data.length; idx++) {
-            var dataItem = data[idx];
+        for (var i = 0; i < size; i++) {
+            // NOTICE: Try not to write things into dataItem
+            var dataItem = data.getItem(i);
             // Each data item is value
             // [1, 2]
             // 2
@@ -285,22 +317,26 @@ define(function (require) {
                 var dim = dimensions[k];
                 var dimStorage = storage[dim];
                 // PENDING NULL is empty or zero
-                dimStorage[idx] = dimValueGetter(dataItem, dim, idx, k);
+                dimStorage[i] = dimValueGetter(dataItem, dim, i, k);
             }
 
-            indices.push(idx);
+            indices.push(i);
         }
 
         // Use the name in option and create id
-        for (var i = 0; i < data.length; i++) {
-            if (!nameList[i]) {
-                if (data[i] && data[i].name != null) {
-                    nameList[i] = data[i].name;
+        for (var i = 0; i < size; i++) {
+            var dataItem = data.getItem(i);
+            if (!nameList[i] && dataItem) {
+                if (dataItem.name != null) {
+                    nameList[i] = dataItem.name;
+                }
+                else if (nameDimIdx != null) {
+                    nameList[i] = storage[dimensions[nameDimIdx]][i];
                 }
             }
             var name = nameList[i] || '';
             // Try using the id in option
-            var id = data[i] && data[i].id;
+            var id = dataItem && dataItem.id;
 
             if (!id && name) {
                 // Use name as id and add counter to avoid same name
@@ -337,11 +373,11 @@ define(function (require) {
         var dataIndex = this.indices[idx];
 
         // If value not exists
-        if (dataIndex == null) {
+        if (dataIndex == null || !storage[dim]) {
             return NaN;
         }
 
-        var value = storage[dim] && storage[dim][dataIndex];
+        var value = storage[dim][dataIndex];
         // FIXME ordinal data type is not stackable
         if (stack) {
             var dimensionInfo = this._dimensionInfos[dim];
@@ -549,7 +585,7 @@ define(function (require) {
      * @param {number} [maxDistance=Infinity]
      * @return {Array.<number>} Considere multiple points has the same value.
      */
-    listProto.indexOfNearest = function (dim, value, stack, maxDistance) {
+    listProto.indicesOfNearest = function (dim, value, stack, maxDistance) {
         var storage = this._storage;
         var dimData = storage[dim];
         var nearestIndices = [];
@@ -598,7 +634,7 @@ define(function (require) {
      * @return {number}
      */
     listProto.getRawDataItem = function (idx) {
-        return this._rawData[this.getRawIndex(idx)];
+        return this._rawData.getItem(this.getRawIndex(idx));
     };
 
     /**
@@ -707,7 +743,10 @@ define(function (require) {
         for (var i = 0; i < indices.length; i++) {
             var keep;
             // Simple optimization
-            if (dimSize === 1) {
+            if (!dimSize) {
+                keep = cb.call(context, i);
+            }
+            else if (dimSize === 1) {
                 keep = cb.call(
                     context, this.get(dimensions[0], i, stack), i
                 );
@@ -882,7 +921,7 @@ define(function (require) {
     listProto.getItemModel = function (idx) {
         var hostModel = this.hostModel;
         idx = this.indices[idx];
-        return new Model(this._rawData[idx], hostModel, hostModel && hostModel.ecModel);
+        return new Model(this._rawData.getItem(idx), hostModel, hostModel && hostModel.ecModel);
     };
 
     /**
@@ -999,7 +1038,7 @@ define(function (require) {
      * Get visual property of single data item
      * @param {number} idx
      * @param {string} key
-     * @param {boolean} ignoreParent
+     * @param {boolean} [ignoreParent=false]
      */
     listProto.getItemVisual = function (idx, key, ignoreParent) {
         var itemVisual = this._itemVisuals[idx];

package/src/data/helper/completeDimensions.js

@@ -4,42 +4,202 @@
 define(function (require) {
 
     var zrUtil = require('zrender/core/util');
+    var modelUtil = require('../../util/model');
+    var each = zrUtil.each;
+    var isString = zrUtil.isString;
+    var defaults = zrUtil.defaults;
+    var normalizeToArray = modelUtil.normalizeToArray;
+
+    var OTHER_DIMS = {tooltip: 1, label: 1, itemName: 1};
 
     /**
-     * Complete the dimensions array guessed from the data structure.
-     * @param  {Array.<string>} dimensions Necessary dimensions, like ['x', 'y']
-     * @param  {Array} data Data list. [[1, 2, 3], [2, 3, 4]]
-     * @param  {Object} [opt]
-     * @param  {Array.<string>} [opt.defaultNames] Default names to fill not necessary dimensions, like ['value']
-     * @param  {string} [opt.extraPrefix] Prefix of name when filling the left dimensions.
-     * @param  {number} [opt.dimCount] If not specified, guess by the first data item.
-     * @return {Array.<string>}
+     * Complete the dimensions array, by user defined `dimension` and `encode`,
+     * and guessing from the data structure.
+     * If no 'value' dimension specified, the first no-named dimension will be
+     * named as 'value'.
+     *
+     * @param {Array.<string>} sysDims Necessary dimensions, like ['x', 'y'], which
+     *      provides not only dim template, but also default order.
+     *      `name` of each item provides default coord name.
+     *      [{dimsDef: []}, ...] can be specified to give names.
+     * @param {Array} data Data list. [[1, 2, 3], [2, 3, 4]].
+     * @param {Object} [opt]
+     * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions
+     *      For example: ['asdf', {name, type}, ...].
+     * @param {Object} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}
+     * @param {string} [opt.extraPrefix] Prefix of name when filling the left dimensions.
+     * @param {string} [opt.extraFromZero] If specified, extra dim names will be:
+     *                      extraPrefix + 0, extraPrefix + extraBaseIndex + 1 ...
+     *                      If not specified, extra dim names will be:
+     *                      extraPrefix, extraPrefix + 0, extraPrefix + 1 ...
+     * @param {number} [opt.dimCount] If not specified, guess by the first data item.
+     * @return {Array.<Object>} [{
+     *      name: string mandatory,
+     *      coordDim: string mandatory,
+     *      coordDimIndex: number mandatory,
+     *      type: string optional,
+     *      tooltipName: string optional,
+     *      otherDims: {
+     *          tooltip: number optional,
+     *          label: number optional
+     *      },
+     *      isExtraCoord: boolean true or undefined.
+     *      other props ...
+     * }]
      */
-    function completeDimensions(dimensions, data, opt) {
-        if (!data) {
-            return dimensions;
-        }
-
+    function completeDimensions(sysDims, data, opt) {
+        data = data || [];
         opt = opt || {};
+        sysDims = (sysDims || []).slice();
+        var dimsDef = (opt.dimsDef || []).slice();
+        var encodeDef = zrUtil.createHashMap(opt.encodeDef);
+        var dataDimNameMap = zrUtil.createHashMap();
+        var coordDimNameMap = zrUtil.createHashMap();
+        // var valueCandidate;
+        var result = [];
 
         var dimCount = opt.dimCount;
         if (dimCount == null) {
             var value0 = retrieveValue(data[0]);
-            dimCount = zrUtil.isArray(value0) && value0.length || 1;
+            dimCount = Math.max(
+                zrUtil.isArray(value0) && value0.length || 1,
+                sysDims.length,
+                dimsDef.length
+            );
+            each(sysDims, function (sysDimItem) {
+                var sysDimItemDimsDef = sysDimItem.dimsDef;
+                sysDimItemDimsDef && (dimCount = Math.max(dimCount, sysDimItemDimsDef.length));
+            });
         }
 
-        var defaultNames = opt.defaultNames || [];
-        var extraPrefix = opt.extraPrefix || 'extra';
+        // Apply user defined dims (`name` and `type`) and init result.
         for (var i = 0; i < dimCount; i++) {
-            if (!dimensions[i]) {
-                var name = defaultNames[i] || (extraPrefix + (i - defaultNames.length));
-                dimensions[i] = guessOrdinal(data, i)
-                    ? {type: 'ordinal', name: name}
-                    : name;
+            var dimDefItem = isString(dimsDef[i]) ? {name: dimsDef[i]} : (dimsDef[i] || {});
+            var userDimName = dimDefItem.name;
+            var resultItem = result[i] = {otherDims: {}};
+            // Name will be applied later for avoiding duplication.
+            if (userDimName != null && dataDimNameMap.get(userDimName) == null) {
+                // Only if `series.dimensions` is defined in option, tooltipName
+                // will be set, and dimension will be diplayed vertically in
+                // tooltip by default.
+                resultItem.name = resultItem.tooltipName = userDimName;
+                dataDimNameMap.set(userDimName, i);
+            }
+            dimDefItem.type != null && (resultItem.type = dimDefItem.type);
+        }
+
+        // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.
+        encodeDef.each(function (dataDims, coordDim) {
+            dataDims = encodeDef.set(coordDim, normalizeToArray(dataDims).slice());
+            each(dataDims, function (resultDimIdx, coordDimIndex) {
+                // The input resultDimIdx can be dim name or index.
+                isString(resultDimIdx) && (resultDimIdx = dataDimNameMap.get(resultDimIdx));
+                if (resultDimIdx != null && resultDimIdx < dimCount) {
+                    dataDims[coordDimIndex] = resultDimIdx;
+                    applyDim(result[resultDimIdx], coordDim, coordDimIndex);
+                    // coordDim === 'value' && valueCandidate == null && (valueCandidate = resultDimIdx);
+                }
+            });
+        });
+
+        // Apply templetes and default order from `sysDims`.
+        var availDimIdx = 0;
+        each(sysDims, function (sysDimItem, sysDimIndex) {
+            var coordDim;
+            var sysDimItem;
+            var sysDimItemDimsDef;
+            var sysDimItemOtherDims;
+            if (isString(sysDimItem)) {
+                coordDim = sysDimItem;
+                sysDimItem = {};
+            }
+            else {
+                coordDim = sysDimItem.name;
+                sysDimItem = zrUtil.clone(sysDimItem);
+                // `coordDimIndex` should not be set directly.
+                sysDimItemDimsDef = sysDimItem.dimsDef;
+                sysDimItemOtherDims = sysDimItem.otherDims;
+                sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex
+                    = sysDimItem.dimsDef = sysDimItem.otherDims = null;
+            }
+
+            var dataDims = normalizeToArray(encodeDef.get(coordDim));
+            // dimensions provides default dim sequences.
+            if (!dataDims.length) {
+                for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {
+                    while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {
+                        availDimIdx++;
+                    }
+                    availDimIdx < result.length && dataDims.push(availDimIdx++);
+                }
+            }
+            // Apply templates.
+            each(dataDims, function (resultDimIdx, coordDimIndex) {
+                var resultItem = result[resultDimIdx];
+                applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);
+                // coordDim === 'value' && valueCandidate == null && (valueCandidate = resultDimIdx);
+                if (resultItem.name == null && sysDimItemDimsDef) {
+                    resultItem.name = resultItem.tooltipName = sysDimItemDimsDef[coordDimIndex];
+                }
+                sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);
+            });
+        });
+
+        // Make sure the first extra dim is 'value'.
+        var extra = opt.extraPrefix || 'value';
+
+        // Set dim `name` and other `coordDim` and other props.
+        for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
+            var resultItem = result[resultDimIdx] = result[resultDimIdx] || {};
+            var coordDim = resultItem.coordDim;
+
+            coordDim == null && (
+                resultItem.coordDim = genName(extra, coordDimNameMap, opt.extraFromZero),
+                resultItem.coordDimIndex = 0,
+                resultItem.isExtraCoord = true
+            );
+
+            resultItem.name == null && (resultItem.name = genName(
+                // Ensure At least one value dim.
+                // (dataDimNameMap.get('value') == null
+                //     && (valueCandidate == null || valueCandidate === resultDimIdx)
+                //     // Try to set as 'value' only if coordDim is not set as 'extra'.
+                //     && coordDim == null
+                // )
+                // ? 'value'
+                // :
+                resultItem.coordDim,
+                dataDimNameMap
+            ));
+
+            resultItem.type == null && guessOrdinal(data, resultDimIdx)
+                && (resultItem.type = 'ordinal');
+        }
+
+        return result;
+
+        function applyDim(resultItem, coordDim, coordDimIndex) {
+            if (OTHER_DIMS[coordDim]) {
+                resultItem.otherDims[coordDim] = coordDimIndex;
+            }
+            else {
+                resultItem.coordDim = coordDim;
+                resultItem.coordDimIndex = coordDimIndex;
+                coordDimNameMap.set(coordDim, true);
             }
         }
 
-        return dimensions;
+        function genName(name, map, fromZero) {
+            if (fromZero || map.get(name) != null) {
+                var i = 0;
+                while (map.get(name + i) != null) {
+                    i++;
+                }
+                name += i;
+            }
+            map.set(name, true);
+            return name;
+        }
     }
 
     // The rule should not be complex, otherwise user might not
@@ -53,10 +213,11 @@ define(function (require) {
             }
 
             var value = value[dimIndex];
+            // Consider usage convenience, '1', '2' will be treated as "number".
             if (value != null && isFinite(value)) {
                 return false;
             }
-            else if (zrUtil.isString(value) && value !== '-') {
+            else if (isString(value) && value !== '-') {
                 return true;
             }
         }