echarts 4.0.1 → 4.1.0

package/lib/layout/barGrid.js

@@ -3,7 +3,34 @@ var zrUtil = require("zrender/lib/core/util");
 var _number = require("../util/number");
 
 var parsePercent = _number.parsePercent;
+
+var _dataStackHelper = require("../data/helper/dataStackHelper");
+
+var isDimensionStacked = _dataStackHelper.isDimensionStacked;
+
+var createRenderPlanner = require("../chart/helper/createRenderPlanner");
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
 var STACK_PREFIX = '__ec_stack_';
+var LARGE_BAR_MIN_WIDTH = 0.5;
+var LargeArr = typeof Float32Array !== 'undefined' ? Float32Array : Array;
 
 function getSeriesStackId(seriesModel) {
   return seriesModel.get('stack') || STACK_PREFIX + seriesModel.seriesIndex;
@@ -24,7 +51,7 @@ function getAxisKey(axis) {
  */
 
 
-function getLayoutOnAxis(opt, api) {
+function getLayoutOnAxis(opt) {
   var params = [];
   var baseAxis = opt.axis;
   var axisKey = 'axis0';
@@ -43,7 +70,7 @@ function getLayoutOnAxis(opt, api) {
     }, opt));
   }
 
-  var widthAndOffsets = doCalBarWidthAndOffset(params, api);
+  var widthAndOffsets = doCalBarWidthAndOffset(params);
   var result = [];
 
   for (var i = 0; i < opt.count; i++) {
@@ -55,8 +82,20 @@ function getLayoutOnAxis(opt, api) {
   return result;
 }
 
-function calBarWidthAndOffset(barSeries, api) {
-  var seriesInfoList = zrUtil.map(barSeries, function (seriesModel) {
+function prepareLayoutBarSeries(seriesType, ecModel) {
+  var seriesModels = [];
+  ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+    // Check series coordinate, do layout for cartesian2d only
+    if (isOnCartesian(seriesModel) && !isInLargeMode(seriesModel)) {
+      seriesModels.push(seriesModel);
+    }
+  });
+  return seriesModels;
+}
+
+function makeColumnLayout(barSeries) {
+  var seriesInfoList = [];
+  zrUtil.each(barSeries, function (seriesModel) {
     var data = seriesModel.getData();
     var cartesian = seriesModel.coordinateSystem;
     var baseAxis = cartesian.getBaseAxis();
@@ -66,7 +105,7 @@ function calBarWidthAndOffset(barSeries, api) {
     var barMaxWidth = parsePercent(seriesModel.get('barMaxWidth'), bandWidth);
     var barGap = seriesModel.get('barGap');
     var barCategoryGap = seriesModel.get('barCategoryGap');
-    return {
+    seriesInfoList.push({
       bandWidth: bandWidth,
       barWidth: barWidth,
       barMaxWidth: barMaxWidth,
@@ -74,12 +113,12 @@ function calBarWidthAndOffset(barSeries, api) {
       barCategoryGap: barCategoryGap,
       axisKey: getAxisKey(baseAxis),
       stackId: getSeriesStackId(seriesModel)
-    };
+    });
   });
-  return doCalBarWidthAndOffset(seriesInfoList, api);
+  return doCalBarWidthAndOffset(seriesInfoList);
 }
 
-function doCalBarWidthAndOffset(seriesInfoList, api) {
+function doCalBarWidthAndOffset(seriesInfoList) {
   // Columns info on each category axis. Key is cartesian name
   var columnsMap = {};
   zrUtil.each(seriesInfoList, function (seriesInfo, idx) {
@@ -182,25 +221,37 @@ function doCalBarWidthAndOffset(seriesInfoList, api) {
   });
   return result;
 }
+/**
+ * @param {Object} barWidthAndOffset The result of makeColumnLayout
+ * @param {module:echarts/coord/Axis} axis
+ * @param {module:echarts/model/Series} [seriesModel] If not provided, return all.
+ * @return {Object} {stackId: {offset, width}} or {offset, width} if seriesModel provided.
+ */
+
+
+function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) {
+  if (barWidthAndOffset && axis) {
+    var result = barWidthAndOffset[getAxisKey(axis)];
+
+    if (result != null && seriesModel != null) {
+      result = result[getSeriesStackId(seriesModel)];
+    }
+
+    return result;
+  }
+}
 /**
  * @param {string} seriesType
  * @param {module:echarts/model/Global} ecModel
- * @param {module:echarts/ExtensionAPI} api
  */
 
 
-function layout(seriesType, ecModel, api) {
-  var barWidthAndOffset = calBarWidthAndOffset(zrUtil.filter(ecModel.getSeriesByType(seriesType), function (seriesModel) {
-    return !ecModel.isSeriesFiltered(seriesModel) && seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'cartesian2d';
-  }));
+function layout(seriesType, ecModel) {
+  var seriesModels = prepareLayoutBarSeries(seriesType, ecModel);
+  var barWidthAndOffset = makeColumnLayout(seriesModels);
   var lastStackCoords = {};
   var lastStackCoordsOrigin = {};
-  ecModel.eachSeriesByType(seriesType, function (seriesModel) {
-    // Check series coordinate, do layout for cartesian2d only
-    if (seriesModel.coordinateSystem.type !== 'cartesian2d') {
-      return;
-    }
-
+  zrUtil.each(seriesModels, function (seriesModel) {
     var data = seriesModel.getData();
     var cartesian = seriesModel.coordinateSystem;
     var baseAxis = cartesian.getBaseAxis();
@@ -210,11 +261,6 @@ function layout(seriesType, ecModel, api) {
     var columnWidth = columnLayoutInfo.width;
     var valueAxis = cartesian.getOtherAxis(baseAxis);
     var barMinHeight = seriesModel.get('barMinHeight') || 0;
-    var valueAxisStart = baseAxis.onZero ? valueAxis.toGlobalCoord(valueAxis.dataToCoord(0)) : valueAxis.getGlobalExtent()[0];
-    var coordDims = [data.mapDimension('x'), data.mapDimension('y')];
-    var coords = data.mapArray(coordDims, function (x, y) {
-      return cartesian.dataToPoint([x, y]);
-    }, true);
     lastStackCoords[stackId] = lastStackCoords[stackId] || [];
     lastStackCoordsOrigin[stackId] = lastStackCoordsOrigin[stackId] || []; // Fix #4243
 
@@ -222,60 +268,71 @@ function layout(seriesType, ecModel, api) {
       offset: columnOffset,
       size: columnWidth
     });
-    data.each(data.mapDimension(valueAxis.dim), function (value, idx) {
+    var valueDim = data.mapDimension(valueAxis.dim);
+    var baseDim = data.mapDimension(baseAxis.dim);
+    var stacked = isDimensionStacked(data, valueDim
+    /*, baseDim*/
+    );
+    var isValueAxisH = valueAxis.isHorizontal();
+    var valueAxisStart = getValueAxisStart(baseAxis, valueAxis, stacked);
+
+    for (var idx = 0, len = data.count(); idx < len; idx++) {
+      var value = data.get(valueDim, idx);
+      var baseValue = data.get(baseDim, idx);
+
       if (isNaN(value)) {
-        return;
+        continue;
       }
 
-      if (!lastStackCoords[stackId][idx]) {
-        lastStackCoords[stackId][idx] = {
-          p: valueAxisStart,
-          // Positive stack
-          n: valueAxisStart // Negative stack
+      var sign = value >= 0 ? 'p' : 'n';
+      var baseCoord = valueAxisStart; // Because of the barMinHeight, we can not use the value in
+      // stackResultDimension directly.
+
+      if (stacked) {
+        // Only ordinal axis can be stacked.
+        if (!lastStackCoords[stackId][baseValue]) {
+          lastStackCoords[stackId][baseValue] = {
+            p: valueAxisStart,
+            // Positive stack
+            n: valueAxisStart // Negative stack
 
-        };
-        lastStackCoordsOrigin[stackId][idx] = {
-          p: valueAxisStart,
-          // Positive stack
-          n: valueAxisStart // Negative stack
+          };
+        } // Should also consider #4243
 
-        };
+
+        baseCoord = lastStackCoords[stackId][baseValue][sign];
       }
 
-      var sign = value >= 0 ? 'p' : 'n';
-      var coord = coords[idx];
-      var lastCoord = lastStackCoords[stackId][idx][sign];
-      var lastCoordOrigin = lastStackCoordsOrigin[stackId][idx][sign];
       var x;
       var y;
       var width;
       var height;
 
-      if (valueAxis.isHorizontal()) {
-        x = lastCoord;
+      if (isValueAxisH) {
+        var coord = cartesian.dataToPoint([value, baseValue]);
+        x = baseCoord;
         y = coord[1] + columnOffset;
-        width = coord[0] - lastCoordOrigin;
+        width = coord[0] - valueAxisStart;
         height = columnWidth;
-        lastStackCoordsOrigin[stackId][idx][sign] += width;
 
         if (Math.abs(width) < barMinHeight) {
           width = (width < 0 ? -1 : 1) * barMinHeight;
         }
 
-        lastStackCoords[stackId][idx][sign] += width;
+        stacked && (lastStackCoords[stackId][baseValue][sign] += width);
       } else {
+        var coord = cartesian.dataToPoint([baseValue, value]);
         x = coord[0] + columnOffset;
-        y = lastCoord;
+        y = baseCoord;
         width = columnWidth;
-        height = coord[1] - lastCoordOrigin;
-        lastStackCoordsOrigin[stackId][idx][sign] += height;
+        height = coord[1] - valueAxisStart;
 
         if (Math.abs(height) < barMinHeight) {
           // Include zero to has a positive bar
           height = (height <= 0 ? -1 : 1) * barMinHeight;
         }
 
-        lastStackCoords[stackId][idx][sign] += height;
+        stacked && (lastStackCoords[stackId][baseValue][sign] += height);
       }
 
       data.setItemLayout(idx, {
@@ -284,10 +341,78 @@ function layout(seriesType, ecModel, api) {
         width: width,
         height: height
       });
-    }, true);
+    }
   }, this);
+} // TODO: Do not support stack in large mode yet.
+
+
+var largeLayout = {
+  seriesType: 'bar',
+  plan: createRenderPlanner(),
+  reset: function (seriesModel) {
+    if (!isOnCartesian(seriesModel) || !isInLargeMode(seriesModel)) {
+      return;
+    }
+
+    var data = seriesModel.getData();
+    var cartesian = seriesModel.coordinateSystem;
+    var baseAxis = cartesian.getBaseAxis();
+    var valueAxis = cartesian.getOtherAxis(baseAxis);
+    var valueDim = data.mapDimension(valueAxis.dim);
+    var baseDim = data.mapDimension(baseAxis.dim);
+    var valueAxisHorizontal = valueAxis.isHorizontal();
+    var valueDimIdx = valueAxisHorizontal ? 0 : 1;
+    var barWidth = retrieveColumnLayout(makeColumnLayout([seriesModel]), baseAxis, seriesModel).width;
+
+    if (!(barWidth > LARGE_BAR_MIN_WIDTH)) {
+      // jshint ignore:line
+      barWidth = LARGE_BAR_MIN_WIDTH;
+    }
+
+    return {
+      progress: progress
+    };
+
+    function progress(params, data) {
+      var largePoints = new LargeArr(params.count * 2);
+      var dataIndex;
+      var coord = [];
+      var valuePair = [];
+      var offset = 0;
+
+      while ((dataIndex = params.next()) != null) {
+        valuePair[valueDimIdx] = data.get(valueDim, dataIndex);
+        valuePair[1 - valueDimIdx] = data.get(baseDim, dataIndex);
+        coord = cartesian.dataToPoint(valuePair, null, coord);
+        largePoints[offset++] = coord[0];
+        largePoints[offset++] = coord[1];
+      }
+
+      data.setLayout({
+        largePoints: largePoints,
+        barWidth: barWidth,
+        valueAxisStart: getValueAxisStart(baseAxis, valueAxis, false),
+        valueAxisHorizontal: valueAxisHorizontal
+      });
+    }
+  }
+};
+
+function isOnCartesian(seriesModel) {
+  return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'cartesian2d';
+}
+
+function isInLargeMode(seriesModel) {
+  return seriesModel.pipelineContext && seriesModel.pipelineContext.large;
+}
+
+function getValueAxisStart(baseAxis, valueAxis, stacked) {
+  return zrUtil.indexOf(baseAxis.getAxesOnZeroOf(), valueAxis) >= 0 || stacked ? valueAxis.toGlobalCoord(valueAxis.dataToCoord(0)) : valueAxis.getGlobalExtent()[0];
 }
 
 exports.getLayoutOnAxis = getLayoutOnAxis;
-exports.calBarWidthAndOffset = calBarWidthAndOffset;
-exports.layout = layout;
+exports.prepareLayoutBarSeries = prepareLayoutBarSeries;
+exports.makeColumnLayout = makeColumnLayout;
+exports.retrieveColumnLayout = retrieveColumnLayout;
+exports.layout = layout;
+exports.largeLayout = largeLayout;

package/lib/layout/barPolar.js

@@ -4,6 +4,28 @@ var _number = require("../util/number");
 
 var parsePercent = _number.parsePercent;
 
+var _dataStackHelper = require("../data/helper/dataStackHelper");
+
+var isDimensionStacked = _dataStackHelper.isDimensionStacked;
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
 function getSeriesStackId(seriesModel) {
   return seriesModel.get('stack') || '__ec_stack_' + seriesModel.seriesIndex;
 }
@@ -22,7 +44,6 @@ function barLayoutPolar(seriesType, ecModel, api) {
   var width = api.getWidth();
   var height = api.getHeight();
   var lastStackCoords = {};
-  var lastStackCoordsOrigin = {};
   var barWidthAndOffset = calRadialBar(zrUtil.filter(ecModel.getSeriesByType(seriesType), function (seriesModel) {
     return !ecModel.isSeriesFiltered(seriesModel) && seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'polar';
   }));
@@ -34,7 +55,6 @@ function barLayoutPolar(seriesType, ecModel, api) {
 
     var data = seriesModel.getData();
     var polar = seriesModel.coordinateSystem;
-    var angleAxis = polar.getAngleAxis();
     var baseAxis = polar.getBaseAxis();
     var stackId = getSeriesStackId(seriesModel);
     var columnLayoutInfo = barWidthAndOffset[getAxisKey(baseAxis)][stackId];
@@ -46,100 +66,97 @@ function barLayoutPolar(seriesType, ecModel, api) {
     var cy = parsePercent(center[1], height);
     var barMinHeight = seriesModel.get('barMinHeight') || 0;
     var barMinAngle = seriesModel.get('barMinAngle') || 0;
-    var valueAxisStart = valueAxis.getExtent()[0];
-    var valueMax = valueAxis.model.get('max');
-    var valueMin = valueAxis.model.get('min');
-    var coordDims = [data.mapDimension('radius'), data.mapDimension('angle')];
-    var coords = data.mapArray(coordDims, function (radius, angle) {
-      return polar.dataToPoint([radius, angle]);
-    }, true);
     lastStackCoords[stackId] = lastStackCoords[stackId] || [];
-    lastStackCoordsOrigin[stackId] = lastStackCoordsOrigin[stackId] || []; // Fix #4243
+    var valueDim = data.mapDimension(valueAxis.dim);
+    var baseDim = data.mapDimension(baseAxis.dim);
+    var stacked = isDimensionStacked(data, valueDim
+    /*, baseDim*/
+    );
+    var valueAxisStart = valueAxis.getExtent()[0];
+
+    for (var idx = 0, len = data.count(); idx < len; idx++) {
+      var value = data.get(valueDim, idx);
+      var baseValue = data.get(baseDim, idx);
 
-    data.each(data.mapDimension(valueAxis.dim), function (value, idx) {
       if (isNaN(value)) {
-        return;
+        continue;
       }
 
-      if (!lastStackCoords[stackId][idx]) {
-        lastStackCoords[stackId][idx] = {
-          p: valueAxisStart,
-          // Positive stack
-          n: valueAxisStart // Negative stack
+      var sign = value >= 0 ? 'p' : 'n';
+      var baseCoord = valueAxisStart; // Because of the barMinHeight, we can not use the value in
+      // stackResultDimension directly.
+      // Only ordinal axis can be stacked.
+
+      if (stacked) {
+        if (!lastStackCoords[stackId][baseValue]) {
+          lastStackCoords[stackId][baseValue] = {
+            p: valueAxisStart,
+            // Positive stack
+            n: valueAxisStart // Negative stack
 
-        };
-        lastStackCoordsOrigin[stackId][idx] = {
-          p: valueAxisStart,
-          // Positive stack
-          n: valueAxisStart // Negative stack
+          };
+        } // Should also consider #4243
 
-        };
+
+        baseCoord = lastStackCoords[stackId][baseValue][sign];
       }
 
-      var sign = value >= 0 ? 'p' : 'n';
-      var coord = polar.pointToCoord(coords[idx]);
-      var lastCoordOrigin = lastStackCoordsOrigin[stackId][idx][sign];
       var r0;
       var r;
       var startAngle;
-      var endAngle;
+      var endAngle; // radial sector
 
       if (valueAxis.dim === 'radius') {
-        // radial sector
-        r0 = lastCoordOrigin;
-        r = coord[0];
-        startAngle = (-coord[1] + columnOffset) * Math.PI / 180;
-        endAngle = startAngle + columnWidth * Math.PI / 180;
-
-        if (Math.abs(r) < barMinHeight) {
-          r = r0 + (r < 0 ? -1 : 1) * barMinHeight;
-        }
+        var radiusSpan = valueAxis.dataToRadius(value) - valueAxisStart;
+        var angle = baseAxis.dataToAngle(baseValue);
 
-        lastStackCoordsOrigin[stackId][idx][sign] = r;
-      } else {
-        // tangential sector
-        r0 = coord[0] + columnOffset;
-        r = r0 + columnWidth; // clamp data if min or max is defined for valueAxis
-
-        if (valueMax != null) {
-          value = Math.min(value, valueMax);
+        if (Math.abs(radiusSpan) < barMinHeight) {
+          radiusSpan = (radiusSpan < 0 ? -1 : 1) * barMinHeight;
         }
 
-        if (valueMin != null) {
-          value = Math.max(value, valueMin);
+        r0 = baseCoord;
+        r = baseCoord + radiusSpan;
+        startAngle = angle - columnOffset;
+        endAngle = startAngle - columnWidth;
+        stacked && (lastStackCoords[stackId][baseValue][sign] = r);
+      } // tangential sector
+      else {
+          // angleAxis must be clamped.
+          var angleSpan = valueAxis.dataToAngle(value, true) - valueAxisStart;
+          var radius = baseAxis.dataToRadius(baseValue);
+
+          if (Math.abs(angleSpan) < barMinAngle) {
+            angleSpan = (angleSpan < 0 ? -1 : 1) * barMinAngle;
+          }
+
+          r0 = radius + columnOffset;
+          r = r0 + columnWidth;
+          startAngle = baseCoord;
+          endAngle = baseCoord + angleSpan; // if the previous stack is at the end of the ring,
+          // add a round to differentiate it from origin
+          // var extent = angleAxis.getExtent();
+          // var stackCoord = angle;
+          // if (stackCoord === extent[0] && value > 0) {
+          //     stackCoord = extent[1];
+          // }
+          // else if (stackCoord === extent[1] && value < 0) {
+          //     stackCoord = extent[0];
+          // }
+
+          stacked && (lastStackCoords[stackId][baseValue][sign] = endAngle);
         }
 
-        var angle = angleAxis.dataToAngle(value);
-
-        if (Math.abs(angle - lastCoordOrigin) < barMinAngle) {
-          angle = lastCoordOrigin - (value < 0 ? -1 : 1) * barMinAngle;
-        }
-
-        startAngle = -lastCoordOrigin * Math.PI / 180;
-        endAngle = -angle * Math.PI / 180; // if the previous stack is at the end of the ring,
-        // add a round to differentiate it from origin
-
-        var extent = angleAxis.getExtent();
-        var stackCoord = angle;
-
-        if (stackCoord === extent[0] && value > 0) {
-          stackCoord = extent[1];
-        } else if (stackCoord === extent[1] && value < 0) {
-          stackCoord = extent[0];
-        }
-
-        lastStackCoordsOrigin[stackId][idx][sign] = stackCoord;
-      }
-
       data.setItemLayout(idx, {
         cx: cx,
         cy: cy,
         r0: r0,
         r: r,
-        startAngle: startAngle,
-        endAngle: endAngle
+        // Consider that positive angle is anti-clockwise,
+        // while positive radian of sector is clockwise
+        startAngle: -startAngle * Math.PI / 180,
+        endAngle: -endAngle * Math.PI / 180
       });
-    }, true);
+    }
   }, this);
 }
 /**

package/lib/layout/points.js

@@ -4,6 +4,28 @@ var map = _util.map;
 
 var createRenderPlanner = require("../chart/helper/createRenderPlanner");
 
+var _dataStackHelper = require("../data/helper/dataStackHelper");
+
+var isDimensionStacked = _dataStackHelper.isDimensionStacked;
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
 function _default(seriesType) {
   return {
     seriesType: seriesType,
@@ -19,9 +41,22 @@ function _default(seriesType) {
       }
 
       var dims = map(coordSys.dimensions, function (dim) {
-        return data.getDimension(data.mapDimension(dim));
+        return data.mapDimension(dim);
       }).slice(0, 2);
       var dimLen = dims.length;
+      var stackResultDim = data.getCalculationInfo('stackResultDimension');
+
+      if (isDimensionStacked(data, dims[0]
+      /*, dims[1]*/
+      )) {
+        dims[0] = stackResultDim;
+      }
+
+      if (isDimensionStacked(data, dims[1]
+      /*, dims[0]*/
+      )) {
+        dims[1] = stackResultDim;
+      }
 
       function progress(params, data) {
         var segCount = params.end - params.start;
@@ -31,11 +66,11 @@ function _default(seriesType) {
           var point;
 
           if (dimLen === 1) {
-            var x = data.get(dims[0], i, true);
+            var x = data.get(dims[0], i);
             point = !isNaN(x) && coordSys.dataToPoint(x, null, tmpOut);
           } else {
-            var x = tmpIn[0] = data.get(dims[0], i, true);
-            var y = tmpIn[1] = data.get(dims[1], i, true); // Also {Array.<number>}, not undefined to avoid if...else... statement
+            var x = tmpIn[0] = data.get(dims[0], i);
+            var y = tmpIn[1] = data.get(dims[1], i); // Also {Array.<number>}, not undefined to avoid if...else... statement
 
             point = !isNaN(x) && !isNaN(y) && coordSys.dataToPoint(tmpIn, null, tmpOut);
           }

package/lib/loading/default.js

@@ -2,6 +2,24 @@ var zrUtil = require("zrender/lib/core/util");
 
 var graphic = require("../util/graphic");
 
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
 var PI = Math.PI;
 /**
  * @param {module:echarts/ExtensionAPI} api

package/lib/model/Component.js

@@ -17,6 +17,25 @@ var layout = require("../util/layout");
 
 var boxLayoutMixin = require("./mixin/boxLayout");
 
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
 /**
  * Component model
  *