echarts 3.5.4 → 3.6.0

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];
@@ -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;
             }
         }

package/src/echarts.js

@@ -276,14 +276,7 @@ define(function (require) {
             ecModel.init(null, null, theme, optionManager);
         }
 
-        // FIXME
-        // ugly
-        this.__lastOnlyGraphic = !!(option && option.graphic);
-        zrUtil.each(option, function (o, mainType) {
-            mainType !== 'graphic' && (this.__lastOnlyGraphic = false);
-        }, this);
-
-        this._model.setOption(option, optionPreprocessorFuncs, this.__lastOnlyGraphic);
+        this._model.setOption(option, optionPreprocessorFuncs);
 
         if (lazyUpdate) {
             this[OPTION_UPDATED] = {silent: silent};
@@ -809,21 +802,7 @@ define(function (require) {
 
             prepareView.call(this, 'chart', ecModel);
 
-            // FIXME
-            // ugly
-            if (this.__lastOnlyGraphic) {
-                each(this._componentsViews, function (componentView) {
-                    var componentModel = componentView.__model;
-                    if (componentModel && componentModel.mainType === 'graphic') {
-                        componentView.render(componentModel, ecModel, this._api, payload);
-                        updateZ(componentModel, componentView);
-                    }
-                }, this);
-                this.__lastOnlyGraphic = false;
-            }
-            else {
-                updateMethods.update.call(this, payload);
-            }
+            updateMethods.update.call(this, payload);
         }
     };
 
@@ -1140,7 +1119,7 @@ define(function (require) {
             }
 
             // Consider: id same and type changed.
-            var viewId = model.id + '_' + model.type;
+            var viewId = '_ec_' + model.id + '_' + model.type;
             var view = viewMap[viewId];
             if (!view) {
                 var classType = parseClassType(model.type);
@@ -1206,7 +1185,8 @@ define(function (require) {
             var data = series.getData();
             if (stack && data.type === 'list') {
                 var previousStack = stackedDataMap[stack];
-                if (previousStack) {
+                // Avoid conflict with Object.prototype
+                if (stackedDataMap.hasOwnProperty(stack) && previousStack) {
                     data.stackedOn = previousStack;
                 }
                 stackedDataMap[stack] = data;
@@ -1528,6 +1508,7 @@ define(function (require) {
     var idBase = new Date() - 0;
     var groupIdBase = new Date() - 0;
     var DOM_ATTRIBUTE_KEY = '_echarts_instance_';
+
     /**
      * @alias module:echarts
      */
@@ -1535,9 +1516,9 @@ define(function (require) {
         /**
          * @type {number}
          */
-        version: '3.5.4',
+        version: '3.6.0',
         dependencies: {
-            zrender: '3.4.4'
+            zrender: '3.5.0'
         }
     };
 
@@ -1604,9 +1585,21 @@ define(function (require) {
                     + echarts.dependencies.zrender + '+'
                 );
             }
+
             if (!dom) {
                 throw new Error('Initialize failed: invalid dom.');
             }
+        }
+
+        var existInstance = echarts.getInstanceByDom(dom);
+        if (existInstance) {
+            if (__DEV__) {
+                console.warn('There is a chart instance already initialized on the dom.');
+            }
+            return existInstance;
+        }
+
+        if (__DEV__) {
             if (zrUtil.isDom(dom)
                 && dom.nodeName.toUpperCase() !== 'CANVAS'
                 && (
@@ -1622,8 +1615,12 @@ define(function (require) {
         chart.id = 'ec_' + idBase++;
         instances[chart.id] = chart;
 
-        dom.setAttribute &&
+        if (dom.setAttribute) {
             dom.setAttribute(DOM_ATTRIBUTE_KEY, chart.id);
+        }
+        else {
+            dom[DOM_ATTRIBUTE_KEY] = chart.id;
+        }
 
         enableConnect(chart);
 
@@ -1671,12 +1668,13 @@ define(function (require) {
      * @param  {module:echarts~ECharts|HTMLDomElement|string} chart
      */
     echarts.dispose = function (chart) {
-        if (zrUtil.isDom(chart)) {
-            chart = echarts.getInstanceByDom(chart);
-        }
-        else if (typeof chart === 'string') {
+        if (typeof chart === 'string') {
             chart = instances[chart];
         }
+        else if (!(chart instanceof ECharts)){
+            // Try to treat as dom
+            chart = echarts.getInstanceByDom(chart);
+        }
         if ((chart instanceof ECharts) && !chart.isDisposed()) {
             chart.dispose();
         }
@@ -1687,9 +1685,16 @@ define(function (require) {
      * @return {echarts~ECharts}
      */
     echarts.getInstanceByDom = function (dom) {
-        var key = dom.getAttribute(DOM_ATTRIBUTE_KEY);
+        var key;
+        if (dom.getAttribute) {
+            key = dom.getAttribute(DOM_ATTRIBUTE_KEY);
+        }
+        else {
+            key = dom[DOM_ATTRIBUTE_KEY];
+        }
         return instances[key];
     };
+
     /**
      * @param {string} key
      * @return {echarts~ECharts}

package/src/helper.js

@@ -19,14 +19,7 @@ define(function (require) {
         },
 
         /**
-         * 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>}
+         * @see {module:echarts/data/helper/completeDimensions}
          */
         completeDimensions: require('./data/helper/completeDimensions'),