echarts 4.0.1 → 4.1.0

package/lib/stream/Scheduler.js

@@ -1,6 +1,8 @@
 var _util = require("zrender/lib/core/util");
 
 var each = _util.each;
+var map = _util.map;
+var isArray = _util.isArray;
 var isFunction = _util.isFunction;
 var createHashMap = _util.createHashMap;
 var noop = _util.noop;
@@ -21,6 +23,25 @@ var _model = require("../util/model");
 
 var normalizeToArray = _model.normalizeToArray;
 
+/*
+* 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.
+*/
+
 /**
  * @module echarts/stream/Scheduler
  */
@@ -28,11 +49,17 @@ var normalizeToArray = _model.normalizeToArray;
 /**
  * @constructor
  */
-function Scheduler(ecInstance, api) {
-  // this._pipelineMap = createHashMap();
+function Scheduler(ecInstance, api, dataProcessorHandlers, visualHandlers) {
   this.ecInstance = ecInstance;
   this.api = api;
-  this.unfinished;
+  this.unfinished; // Fix current processors in case that in some rear cases that
+  // processors might be registered after echarts instance created.
+  // Register processors incrementally for a echarts instance is
+  // not supported by this stream architecture.
+
+  var dataProcessorHandlers = this._dataProcessorHandlers = dataProcessorHandlers.slice();
+  var visualHandlers = this._visualHandlers = visualHandlers.slice();
+  this._allHandlers = dataProcessorHandlers.concat(visualHandlers);
   /**
    * @private
    * @type {
@@ -48,7 +75,43 @@ function Scheduler(ecInstance, api) {
   this._stageTaskMap = createHashMap();
 }
 
-var proto = Scheduler.prototype; // If seriesModel provided, incremental threshold is check by series data.
+var proto = Scheduler.prototype;
+/**
+ * @param {module:echarts/model/Global} ecModel
+ * @param {Object} payload
+ */
+
+proto.restoreData = function (ecModel, payload) {
+  // TODO: Only restroe needed series and components, but not all components.
+  // Currently `restoreData` of all of the series and component will be called.
+  // But some independent components like `title`, `legend`, `graphic`, `toolbox`,
+  // `tooltip`, `axisPointer`, etc, do not need series refresh when `setOption`,
+  // and some components like coordinate system, axes, dataZoom, visualMap only
+  // need their target series refresh.
+  // (1) If we are implementing this feature some day, we should consider these cases:
+  // if a data processor depends on a component (e.g., dataZoomProcessor depends
+  // on the settings of `dataZoom`), it should be re-performed if the component
+  // is modified by `setOption`.
+  // (2) If a processor depends on sevral series, speicified by its `getTargetSeries`,
+  // it should be re-performed when the result array of `getTargetSeries` changed.
+  // We use `dependencies` to cover these issues.
+  // (3) How to update target series when coordinate system related components modified.
+  // TODO: simply the dirty mechanism? Check whether only the case here can set tasks dirty,
+  // and this case all of the tasks will be set as dirty.
+  ecModel.restoreData(payload); // Theoretically an overall task not only depends on each of its target series, but also
+  // depends on all of the series.
+  // The overall task is not in pipeline, and `ecModel.restoreData` only set pipeline tasks
+  // dirty. If `getTargetSeries` of an overall task returns nothing, we should also ensure
+  // that the overall task is set as dirty and to be performed, otherwise it probably cause
+  // state chaos. So we have to set dirty of all of the overall tasks manually, otherwise it
+  // probably cause state chaos (consider `dataZoomProcessor`).
+
+  this._stageTaskMap.each(function (taskRecord) {
+    var overallTask = taskRecord.overallTask;
+    overallTask && overallTask.dirty();
+  });
+}; // If seriesModel provided, incremental threshold is check by series data.
+
 
 proto.getPerformArgs = function (task, isBlock) {
   // For overall task
@@ -59,9 +122,14 @@ proto.getPerformArgs = function (task, isBlock) {
   var pipeline = this._pipelineMap.get(task.__pipeline.id);
 
   var pCtx = pipeline.context;
-  var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.incrementalRender) && task.__idxInPipeline > pipeline.bockIndex;
+  var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.progressiveRender) && task.__idxInPipeline > pipeline.blockIndex;
+  var step = incremental ? pipeline.step : null;
+  var modDataCount = pCtx && pCtx.modDataCount;
+  var modBy = modDataCount != null ? Math.ceil(modDataCount / step) : null;
   return {
-    step: incremental ? pipeline.step : null
+    step: step,
+    modBy: modBy,
+    modDataCount: modDataCount
   };
 };
 
@@ -81,11 +149,20 @@ proto.updateStreamModes = function (seriesModel, view) {
   var pipeline = this._pipelineMap.get(seriesModel.uid);
 
   var data = seriesModel.getData();
-  var dataLen = data.count();
-  var incrementalRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold;
-  var large = seriesModel.get('large') && dataLen >= seriesModel.get('largeThreshold');
+  var dataLen = data.count(); // `progressiveRender` means that can render progressively in each
+  // animation frame. Note that some types of series do not provide
+  // `view.incrementalPrepareRender` but support `chart.appendData`. We
+  // use the term `incremental` but not `progressive` to describe the
+  // case that `chart.appendData`.
+
+  var progressiveRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold;
+  var large = seriesModel.get('large') && dataLen >= seriesModel.get('largeThreshold'); // TODO: modDataCount should not updated if `appendData`, otherwise cause whole repaint.
+  // see `test/candlestick-large3.html`
+
+  var modDataCount = seriesModel.get('progressiveChunkMode') === 'mod' ? dataLen : null;
   seriesModel.pipelineContext = pipeline.context = {
-    incrementalRender: incrementalRender,
+    progressiveRender: progressiveRender,
+    modDataCount: modDataCount,
     large: large
   };
 };
@@ -102,20 +179,19 @@ proto.restorePipelines = function (ecModel) {
       tail: null,
       threshold: seriesModel.getProgressiveThreshold(),
       progressiveEnabled: progressive && !(seriesModel.preventIncremental && seriesModel.preventIncremental()),
-      bockIndex: -1,
-      step: progressive || 700,
-      // ??? Temporarily number
+      blockIndex: -1,
+      step: Math.round(progressive || 700),
       count: 0
     });
     pipe(scheduler, seriesModel, seriesModel.dataTask);
   });
 };
 
-proto.prepareStageTasks = function (stageHandlers, useClearVisual) {
+proto.prepareStageTasks = function () {
   var stageTaskMap = this._stageTaskMap;
   var ecModel = this.ecInstance.getModel();
   var api = this.api;
-  each(stageHandlers, function (handler) {
+  each(this._allHandlers, function (handler) {
     var record = stageTaskMap.get(handler.uid) || stageTaskMap.set(handler.uid, []);
     handler.reset && createSeriesStageTask(this, handler, record, ecModel, api);
     handler.overallReset && createOverallStageTask(this, handler, record, ecModel, api);
@@ -132,9 +208,9 @@ proto.prepareView = function (view, model, ecModel, api) {
   pipe(this, model, renderTask);
 };
 
-proto.performDataProcessorTasks = function (stageHandlers, ecModel, payload) {
+proto.performDataProcessorTasks = function (ecModel, payload) {
   // If we do not use `block` here, it should be considered when to update modes.
-  performStageTasks(this, stageHandlers, ecModel, payload, {
+  performStageTasks(this, this._dataProcessorHandlers, ecModel, payload, {
     block: true
   });
 }; // opt
@@ -142,8 +218,8 @@ proto.performDataProcessorTasks = function (stageHandlers, ecModel, payload) {
 // opt.setDirty
 
 
-proto.performVisualTasks = function (stageHandlers, ecModel, payload, opt) {
-  performStageTasks(this, stageHandlers, ecModel, payload, opt);
+proto.performVisualTasks = function (ecModel, payload, opt) {
+  performStageTasks(this, this._visualHandlers, ecModel, payload, opt);
 };
 
 function performStageTasks(scheduler, stageHandlers, ecModel, payload, opt) {
@@ -216,7 +292,7 @@ proto.plan = function () {
 
     do {
       if (task.__block) {
-        pipeline.bockIndex = task.__idxInPipeline;
+        pipeline.blockIndex = task.__idxInPipeline;
         break;
       }
 
@@ -291,7 +367,7 @@ function createOverallStageTask(scheduler, stageHandler, stageHandlerRecord, ecM
   var seriesType = stageHandler.seriesType;
   var getTargetSeries = stageHandler.getTargetSeries;
   var overallProgress = true;
-  var isOverallFilter = stageHandler.isOverallFilter; // An overall task with seriesType detected or has `getTargetSeries`, we add
+  var modifyOutputEnd = stageHandler.modifyOutputEnd; // An overall task with seriesType detected or has `getTargetSeries`, we add
   // stub in each pipelines, it will set the overall task dirty when the pipeline
   // progress. Moreover, to avoid call the overall task each frame (too frequent),
   // we set the pipeline block.
@@ -311,14 +387,22 @@ function createOverallStageTask(scheduler, stageHandler, stageHandlerRecord, ecM
 
   function createStub(seriesModel) {
     var pipelineId = seriesModel.uid;
-    var stub = agentStubMap.get(pipelineId) || agentStubMap.set(pipelineId, createTask({
-      reset: stubReset,
-      onDirty: stubOnDirty
-    }));
+    var stub = agentStubMap.get(pipelineId);
+
+    if (!stub) {
+      stub = agentStubMap.set(pipelineId, createTask({
+        reset: stubReset,
+        onDirty: stubOnDirty
+      })); // When the result of `getTargetSeries` changed, the overallTask
+      // should be set as dirty and re-performed.
+
+      overallTask.dirty();
+    }
+
     stub.context = {
       model: seriesModel,
       overallProgress: overallProgress,
-      isOverallFilter: isOverallFilter
+      modifyOutputEnd: modifyOutputEnd
     };
     stub.agent = overallTask;
     stub.__block = overallProgress;
@@ -329,7 +413,10 @@ function createOverallStageTask(scheduler, stageHandler, stageHandlerRecord, ecM
   var pipelineMap = scheduler._pipelineMap;
   agentStubMap.each(function (stub, pipelineId) {
     if (!pipelineMap.get(pipelineId)) {
-      stub.dispose();
+      stub.dispose(); // When the result of `getTargetSeries` changed, the overallTask
+      // should be set as dirty and re-performed.
+
+      overallTask.dirty();
       agentStubMap.removeKey(pipelineId);
     }
   });
@@ -362,18 +449,17 @@ function seriesTaskReset(context) {
   }
 
   var resetDefines = context.resetDefines = normalizeToArray(context.reset(context.model, context.ecModel, context.api, context.payload));
-
-  if (resetDefines.length) {
-    return seriesTaskProgress;
-  }
+  return resetDefines.length > 1 ? map(resetDefines, function (v, idx) {
+    return makeSeriesTaskProgress(idx);
+  }) : singleSeriesTaskProgress;
 }
 
-function seriesTaskProgress(params, context) {
-  var data = context.data;
-  var resetDefines = context.resetDefines;
+var singleSeriesTaskProgress = makeSeriesTaskProgress(0);
 
-  for (var k = 0; k < resetDefines.length; k++) {
-    var resetDefine = resetDefines[k];
+function makeSeriesTaskProgress(resetDefineIdx) {
+  return function (params, context) {
+    var data = context.data;
+    var resetDefine = context.resetDefines[resetDefineIdx];
 
     if (resetDefine && resetDefine.dataEach) {
       for (var i = params.start; i < params.end; i++) {
@@ -382,7 +468,7 @@ function seriesTaskProgress(params, context) {
     } else if (resetDefine && resetDefine.progress) {
       resetDefine.progress(params, data);
     }
-  }
+  };
 }
 
 function seriesTaskCount(context) {

package/lib/stream/task.js

@@ -1,11 +1,31 @@
 var _util = require("zrender/lib/core/util");
 
 var assert = _util.assert;
+var isArray = _util.isArray;
 
 var _config = require("../config");
 
 var __DEV__ = _config.__DEV__;
 
+/*
+* 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.
+*/
+
 /**
  * @param {Object} define
  * @return See the return of `createTask`.
@@ -40,6 +60,8 @@ var taskProto = Task.prototype;
  * @param {Object} performArgs
  * @param {number} [performArgs.step] Specified step.
  * @param {number} [performArgs.skip] Skip customer perform call.
+ * @param {number} [performArgs.modBy] Sampling window size.
+ * @param {number} [performArgs.modDataCount] Sampling count.
  */
 
 taskProto.perform = function (performArgs) {
@@ -61,18 +83,37 @@ taskProto.perform = function (performArgs) {
 
   if (this._plan && !skip) {
     planResult = this._plan(this.context);
+  } // Support sharding by mod, which changes the render sequence and makes the rendered graphic
+  // elements uniformed distributed when progress, especially when moving or zooming.
+
+
+  var lastModBy = normalizeModBy(this._modBy);
+  var lastModDataCount = this._modDataCount || 0;
+  var modBy = normalizeModBy(performArgs && performArgs.modBy);
+  var modDataCount = performArgs && performArgs.modDataCount || 0;
+
+  if (lastModBy !== modBy || lastModDataCount !== modDataCount) {
+    planResult = 'reset';
+  }
+
+  function normalizeModBy(val) {
+    !(val >= 1) && (val = 1); // jshint ignore:line
+
+    return val;
   }
 
+  var forceFirstProgress;
+
   if (this._dirty || planResult === 'reset') {
     this._dirty = false;
-    reset(this, skip);
+    forceFirstProgress = reset(this, skip);
   }
 
+  this._modBy = modBy;
+  this._modDataCount = modDataCount;
   var step = performArgs && performArgs.step;
 
   if (upTask) {
-    // ??? FIXME move to schedueler?
-    // this._dueEnd = Math.max(upTask._outputDueEnd, this._dueEnd);
     this._dueEnd = upTask._outputDueEnd;
   } // DataTask or overallTask
   else {
@@ -84,10 +125,19 @@ taskProto.perform = function (performArgs) {
   if (this._progress) {
     var start = this._dueIndex;
     var end = Math.min(step != null ? this._dueIndex + step : Infinity, this._dueEnd);
-    !skip && start < end && this._progress({
-      start: start,
-      end: end
-    }, this.context);
+
+    if (!skip && (forceFirstProgress || start < end)) {
+      var progress = this._progress;
+
+      if (isArray(progress)) {
+        for (var i = 0; i < progress.length; i++) {
+          doProgress(this, progress[i], start, end, modBy, modDataCount);
+        }
+      } else {
+        doProgress(this, progress, start, end, modBy, modDataCount);
+      }
+    }
+
     this._dueIndex = end; // If no `outputDueEnd`, assume that output data and
     // input data is the same, so use `dueIndex` as `outputDueEnd`.
 
@@ -103,21 +153,80 @@ taskProto.perform = function (performArgs) {
   return this.unfinished();
 };
 
+var iterator = function () {
+  var end;
+  var current;
+  var modBy;
+  var modDataCount;
+  var winCount;
+  var it = {
+    reset: function (s, e, sStep, sCount) {
+      current = s;
+      end = e;
+      modBy = sStep;
+      modDataCount = sCount;
+      winCount = Math.ceil(modDataCount / modBy);
+      it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext;
+    }
+  };
+  return it;
+
+  function sequentialNext() {
+    return current < end ? current++ : null;
+  }
+
+  function modNext() {
+    var dataIndex = current % winCount * modBy + Math.ceil(current / winCount);
+    var result = current >= end ? null : dataIndex < modDataCount ? dataIndex // If modDataCount is smaller than data.count() (consider `appendData` case),
+    // Use normal linear rendering mode.
+    : current;
+    current++;
+    return result;
+  }
+}();
+
 taskProto.dirty = function () {
   this._dirty = true;
   this._onDirty && this._onDirty(this.context);
 };
-/**
- * @param {Object} [params]
- */
 
+function doProgress(taskIns, progress, start, end, modBy, modDataCount) {
+  iterator.reset(start, end, modBy, modDataCount);
+  taskIns._callingProgress = progress;
+
+  taskIns._callingProgress({
+    start: start,
+    end: end,
+    count: end - start,
+    next: iterator.next
+  }, taskIns.context);
+}
 
 function reset(taskIns, skip) {
   taskIns._dueIndex = taskIns._outputDueEnd = taskIns._dueEnd = 0;
   taskIns._settedOutputEnd = null;
-  taskIns._progress = !skip && taskIns._reset && taskIns._reset(taskIns.context);
+  var progress;
+  var forceFirstProgress;
+
+  if (!skip && taskIns._reset) {
+    progress = taskIns._reset(taskIns.context);
+
+    if (progress && progress.progress) {
+      forceFirstProgress = progress.forceFirstProgress;
+      progress = progress.progress;
+    } // To simplify no progress checking, array must has item.
+
+
+    if (isArray(progress) && !progress.length) {
+      progress = null;
+    }
+  }
+
+  taskIns._progress = progress;
+  taskIns._modBy = taskIns._modDataCount = null;
   var downstream = taskIns._downstream;
   downstream && downstream.dirty();
+  return forceFirstProgress;
 }
 /**
  * @return {boolean}
@@ -162,13 +271,55 @@ taskProto.getDownstream = function () {
 };
 
 taskProto.setOutputEnd = function (end) {
-  // ??? FIXME: check
   // This only happend in dataTask, dataZoom, map, currently.
   // where dataZoom do not set end each time, but only set
   // when reset. So we should record the setted end, in case
   // that the stub of dataZoom perform again and earse the
   // setted end by upstream.
-  this._outputDueEnd = this._settedOutputEnd = end; // this._outputDueEnd = end;
-};
+  this._outputDueEnd = this._settedOutputEnd = end;
+}; ///////////////////////////////////////////////////////////
+// For stream debug (Should be commented out after used!)
+// Usage: printTask(this, 'begin');
+// Usage: printTask(this, null, {someExtraProp});
+// function printTask(task, prefix, extra) {
+//     window.ecTaskUID == null && (window.ecTaskUID = 0);
+//     task.uidDebug == null && (task.uidDebug = `task_${window.ecTaskUID++}`);
+//     task.agent && task.agent.uidDebug == null && (task.agent.uidDebug = `task_${window.ecTaskUID++}`);
+//     var props = [];
+//     if (task.__pipeline) {
+//         var val = `${task.__idxInPipeline}/${task.__pipeline.tail.__idxInPipeline} ${task.agent ? '(stub)' : ''}`;
+//         props.push({text: 'idx', value: val});
+//     } else {
+//         var stubCount = 0;
+//         task.agentStubMap.each(() => stubCount++);
+//         props.push({text: 'idx', value: `overall (stubs: ${stubCount})`});
+//     }
+//     props.push({text: 'uid', value: task.uidDebug});
+//     if (task.__pipeline) {
+//         props.push({text: 'pid', value: task.__pipeline.id});
+//         task.agent && props.push(
+//             {text: 'stubFor', value: task.agent.uidDebug}
+//         );
+//     }
+//     props.push(
+//         {text: 'dirty', value: task._dirty},
+//         {text: 'dueIndex', value: task._dueIndex},
+//         {text: 'dueEnd', value: task._dueEnd},
+//         {text: 'outputDueEnd', value: task._outputDueEnd}
+//     );
+//     if (extra) {
+//         Object.keys(extra).forEach(key => {
+//             props.push({text: key, value: extra[key]});
+//         });
+//     }
+//     var args = ['color: blue'];
+//     var msg = `%c[${prefix || 'T'}] %c` + props.map(item => (
+//         args.push('color: black', 'color: red'),
+//         `${item.text}: %c${item.value}`
+//     )).join('%c, ');
+//     console.log.apply(console, [msg].concat(args));
+//     // console.log(this);
+// }
+
 
 exports.createTask = createTask;

package/lib/theme/dark.js

@@ -1,3 +1,21 @@
+/*
+* 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 contrastColor = '#eee';
 
 var axisCommon = function () {

package/lib/theme/light.js

@@ -1,3 +1,21 @@
+/*
+* 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 colorAll = ['#37A2DA', '#32C5E9', '#67E0E3', '#9FE6B8', '#FFDB5C', '#ff9f7f', '#fb7293', '#E062AE', '#E690D1', '#e7bcf3', '#9d96f5', '#8378EA', '#96BFFF'];
 var _default = {
   color: colorAll,

package/lib/util/KDTree.js

@@ -1,5 +1,24 @@
 var quickSelect = require("./quickSelect");
 
+/*
+* 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.
+*/
+
 /**
  * K-Dimension Tree
  *

package/lib/util/animation.js

@@ -1,5 +1,24 @@
 var zrUtil = require("zrender/lib/core/util");
 
+/*
+* 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.
+*/
+
 /**
  * @param {number} [time=500] Time in ms
  * @param {string} [easing='linear']

package/lib/util/array/nest.js

@@ -1,5 +1,24 @@
 var zrUtil = require("zrender/lib/core/util");
 
+/*
+* 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.
+*/
+
 /**
  * nest helper used to group by the array.
  * can specified the keys and sort the keys.

package/lib/util/clazz.js

@@ -4,6 +4,24 @@ var __DEV__ = _config.__DEV__;
 
 var zrUtil = require("zrender/lib/core/util");
 
+/*
+* 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 TYPE_DELIMITER = '.';
 var IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';
 /**