first commit

node_modules/echarts/lib/chart/lines/LinesSeries.js

@@ -0,0 +1,332 @@
+
+/*
+* 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 _config = require("../../config");
+
+var __DEV__ = _config.__DEV__;
+
+var SeriesModel = require("../../model/Series");
+
+var List = require("../../data/List");
+
+var _util = require("zrender/lib/core/util");
+
+var concatArray = _util.concatArray;
+var mergeAll = _util.mergeAll;
+var map = _util.map;
+
+var _format = require("../../util/format");
+
+var encodeHTML = _format.encodeHTML;
+
+var CoordinateSystem = require("../../CoordinateSystem");
+
+/*
+* 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.
+*/
+
+/* global Uint32Array, Float64Array, Float32Array */
+var Uint32Arr = typeof Uint32Array === 'undefined' ? Array : Uint32Array;
+var Float64Arr = typeof Float64Array === 'undefined' ? Array : Float64Array;
+
+function compatEc2(seriesOpt) {
+  var data = seriesOpt.data;
+
+  if (data && data[0] && data[0][0] && data[0][0].coord) {
+    seriesOpt.data = map(data, function (itemOpt) {
+      var coords = [itemOpt[0].coord, itemOpt[1].coord];
+      var target = {
+        coords: coords
+      };
+
+      if (itemOpt[0].name) {
+        target.fromName = itemOpt[0].name;
+      }
+
+      if (itemOpt[1].name) {
+        target.toName = itemOpt[1].name;
+      }
+
+      return mergeAll([target, itemOpt[0], itemOpt[1]]);
+    });
+  }
+}
+
+var LinesSeries = SeriesModel.extend({
+  type: 'series.lines',
+  dependencies: ['grid', 'polar'],
+  visualColorAccessPath: 'lineStyle.color',
+  init: function (option) {
+    // The input data may be null/undefined.
+    option.data = option.data || []; // Not using preprocessor because mergeOption may not have series.type
+
+    compatEc2(option);
+
+    var result = this._processFlatCoordsArray(option.data);
+
+    this._flatCoords = result.flatCoords;
+    this._flatCoordsOffset = result.flatCoordsOffset;
+
+    if (result.flatCoords) {
+      option.data = new Float32Array(result.count);
+    }
+
+    LinesSeries.superApply(this, 'init', arguments);
+  },
+  mergeOption: function (option) {
+    compatEc2(option);
+
+    if (option.data) {
+      // Only update when have option data to merge.
+      var result = this._processFlatCoordsArray(option.data);
+
+      this._flatCoords = result.flatCoords;
+      this._flatCoordsOffset = result.flatCoordsOffset;
+
+      if (result.flatCoords) {
+        option.data = new Float32Array(result.count);
+      }
+    }
+
+    LinesSeries.superApply(this, 'mergeOption', arguments);
+  },
+  appendData: function (params) {
+    var result = this._processFlatCoordsArray(params.data);
+
+    if (result.flatCoords) {
+      if (!this._flatCoords) {
+        this._flatCoords = result.flatCoords;
+        this._flatCoordsOffset = result.flatCoordsOffset;
+      } else {
+        this._flatCoords = concatArray(this._flatCoords, result.flatCoords);
+        this._flatCoordsOffset = concatArray(this._flatCoordsOffset, result.flatCoordsOffset);
+      }
+
+      params.data = new Float32Array(result.count);
+    }
+
+    this.getRawData().appendData(params.data);
+  },
+  _getCoordsFromItemModel: function (idx) {
+    var itemModel = this.getData().getItemModel(idx);
+    var coords = itemModel.option instanceof Array ? itemModel.option : itemModel.getShallow('coords');
+    return coords;
+  },
+  getLineCoordsCount: function (idx) {
+    if (this._flatCoordsOffset) {
+      return this._flatCoordsOffset[idx * 2 + 1];
+    } else {
+      return this._getCoordsFromItemModel(idx).length;
+    }
+  },
+  getLineCoords: function (idx, out) {
+    if (this._flatCoordsOffset) {
+      var offset = this._flatCoordsOffset[idx * 2];
+      var len = this._flatCoordsOffset[idx * 2 + 1];
+
+      for (var i = 0; i < len; i++) {
+        out[i] = out[i] || [];
+        out[i][0] = this._flatCoords[offset + i * 2];
+        out[i][1] = this._flatCoords[offset + i * 2 + 1];
+      }
+
+      return len;
+    } else {
+      var coords = this._getCoordsFromItemModel(idx);
+
+      for (var i = 0; i < coords.length; i++) {
+        out[i] = out[i] || [];
+        out[i][0] = coords[i][0];
+        out[i][1] = coords[i][1];
+      }
+
+      return coords.length;
+    }
+  },
+  _processFlatCoordsArray: function (data) {
+    var startOffset = 0;
+
+    if (this._flatCoords) {
+      startOffset = this._flatCoords.length;
+    } // Stored as a typed array. In format
+    // Points Count(2) | x | y | x | y | Points Count(3) | x |  y | x | y | x | y |
+
+
+    if (typeof data[0] === 'number') {
+      var len = data.length; // Store offset and len of each segment
+
+      var coordsOffsetAndLenStorage = new Uint32Arr(len);
+      var coordsStorage = new Float64Arr(len);
+      var coordsCursor = 0;
+      var offsetCursor = 0;
+      var dataCount = 0;
+
+      for (var i = 0; i < len;) {
+        dataCount++;
+        var count = data[i++]; // Offset
+
+        coordsOffsetAndLenStorage[offsetCursor++] = coordsCursor + startOffset; // Len
+
+        coordsOffsetAndLenStorage[offsetCursor++] = count;
+
+        for (var k = 0; k < count; k++) {
+          var x = data[i++];
+          var y = data[i++];
+          coordsStorage[coordsCursor++] = x;
+          coordsStorage[coordsCursor++] = y;
+
+          if (i > len) {}
+        }
+      }
+
+      return {
+        flatCoordsOffset: new Uint32Array(coordsOffsetAndLenStorage.buffer, 0, offsetCursor),
+        flatCoords: coordsStorage,
+        count: dataCount
+      };
+    }
+
+    return {
+      flatCoordsOffset: null,
+      flatCoords: null,
+      count: data.length
+    };
+  },
+  getInitialData: function (option, ecModel) {
+    var lineData = new List(['value'], this);
+    lineData.hasItemOption = false;
+    lineData.initData(option.data, [], function (dataItem, dimName, dataIndex, dimIndex) {
+      // dataItem is simply coords
+      if (dataItem instanceof Array) {
+        return NaN;
+      } else {
+        lineData.hasItemOption = true;
+        var value = dataItem.value;
+
+        if (value != null) {
+          return value instanceof Array ? value[dimIndex] : value;
+        }
+      }
+    });
+    return lineData;
+  },
+  formatTooltip: function (dataIndex) {
+    var data = this.getData();
+    var itemModel = data.getItemModel(dataIndex);
+    var name = itemModel.get('name');
+
+    if (name) {
+      return name;
+    }
+
+    var fromName = itemModel.get('fromName');
+    var toName = itemModel.get('toName');
+    var html = [];
+    fromName != null && html.push(fromName);
+    toName != null && html.push(toName);
+    return encodeHTML(html.join(' > '));
+  },
+  preventIncremental: function () {
+    return !!this.get('effect.show');
+  },
+  getProgressive: function () {
+    var progressive = this.option.progressive;
+
+    if (progressive == null) {
+      return this.option.large ? 1e4 : this.get('progressive');
+    }
+
+    return progressive;
+  },
+  getProgressiveThreshold: function () {
+    var progressiveThreshold = this.option.progressiveThreshold;
+
+    if (progressiveThreshold == null) {
+      return this.option.large ? 2e4 : this.get('progressiveThreshold');
+    }
+
+    return progressiveThreshold;
+  },
+  defaultOption: {
+    coordinateSystem: 'geo',
+    zlevel: 0,
+    z: 2,
+    legendHoverLink: true,
+    hoverAnimation: true,
+    // Cartesian coordinate system
+    xAxisIndex: 0,
+    yAxisIndex: 0,
+    symbol: ['none', 'none'],
+    symbolSize: [10, 10],
+    // Geo coordinate system
+    geoIndex: 0,
+    effect: {
+      show: false,
+      period: 4,
+      // Animation delay. support callback
+      // delay: 0,
+      // If move with constant speed px/sec
+      // period will be ignored if this property is > 0,
+      constantSpeed: 0,
+      symbol: 'circle',
+      symbolSize: 3,
+      loop: true,
+      // Length of trail, 0 - 1
+      trailLength: 0.2 // Same with lineStyle.color
+      // color
+
+    },
+    large: false,
+    // Available when large is true
+    largeThreshold: 2000,
+    // If lines are polyline
+    // polyline not support curveness, label, animation
+    polyline: false,
+    // If clip the overflow.
+    // Available when coordinateSystem is cartesian or polar.
+    clip: true,
+    label: {
+      show: false,
+      position: 'end' // distance: 5,
+      // formatter: 标签文本格式器，同Tooltip.formatter，不支持异步回调
+
+    },
+    lineStyle: {
+      opacity: 0.5
+    }
+  }
+});
+var _default = LinesSeries;
+module.exports = _default;

node_modules/echarts/lib/chart/lines/LinesView.js

@@ -0,0 +1,198 @@
+
+/*
+* 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 _config = require("../../config");
+
+var __DEV__ = _config.__DEV__;
+
+var echarts = require("../../echarts");
+
+var LineDraw = require("../helper/LineDraw");
+
+var EffectLine = require("../helper/EffectLine");
+
+var Line = require("../helper/Line");
+
+var Polyline = require("../helper/Polyline");
+
+var EffectPolyline = require("../helper/EffectPolyline");
+
+var LargeLineDraw = require("../helper/LargeLineDraw");
+
+var linesLayout = require("./linesLayout");
+
+var _createClipPathFromCoordSys = require("../helper/createClipPathFromCoordSys");
+
+var createClipPath = _createClipPathFromCoordSys.createClipPath;
+
+/*
+* 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 _default = echarts.extendChartView({
+  type: 'lines',
+  init: function () {},
+  render: function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+
+    var lineDraw = this._updateLineDraw(data, seriesModel);
+
+    var zlevel = seriesModel.get('zlevel');
+    var trailLength = seriesModel.get('effect.trailLength');
+    var zr = api.getZr(); // Avoid the drag cause ghost shadow
+    // FIXME Better way ?
+    // SVG doesn't support
+
+    var isSvg = zr.painter.getType() === 'svg';
+
+    if (!isSvg) {
+      zr.painter.getLayer(zlevel).clear(true);
+    } // Config layer with motion blur
+
+
+    if (this._lastZlevel != null && !isSvg) {
+      zr.configLayer(this._lastZlevel, {
+        motionBlur: false
+      });
+    }
+
+    if (this._showEffect(seriesModel) && trailLength) {
+      if (!isSvg) {
+        zr.configLayer(zlevel, {
+          motionBlur: true,
+          lastFrameAlpha: Math.max(Math.min(trailLength / 10 + 0.9, 1), 0)
+        });
+      }
+    }
+
+    lineDraw.updateData(data);
+    var clipPath = seriesModel.get('clip', true) && createClipPath(seriesModel.coordinateSystem, false, seriesModel);
+
+    if (clipPath) {
+      this.group.setClipPath(clipPath);
+    } else {
+      this.group.removeClipPath();
+    }
+
+    this._lastZlevel = zlevel;
+    this._finished = true;
+  },
+  incrementalPrepareRender: function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+
+    var lineDraw = this._updateLineDraw(data, seriesModel);
+
+    lineDraw.incrementalPrepareUpdate(data);
+
+    this._clearLayer(api);
+
+    this._finished = false;
+  },
+  incrementalRender: function (taskParams, seriesModel, ecModel) {
+    this._lineDraw.incrementalUpdate(taskParams, seriesModel.getData());
+
+    this._finished = taskParams.end === seriesModel.getData().count();
+  },
+  updateTransform: function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+    var pipelineContext = seriesModel.pipelineContext;
+
+    if (!this._finished || pipelineContext.large || pipelineContext.progressiveRender) {
+      // TODO Don't have to do update in large mode. Only do it when there are millions of data.
+      return {
+        update: true
+      };
+    } else {
+      // TODO Use same logic with ScatterView.
+      // Manually update layout
+      var res = linesLayout.reset(seriesModel);
+
+      if (res.progress) {
+        res.progress({
+          start: 0,
+          end: data.count()
+        }, data);
+      }
+
+      this._lineDraw.updateLayout();
+
+      this._clearLayer(api);
+    }
+  },
+  _updateLineDraw: function (data, seriesModel) {
+    var lineDraw = this._lineDraw;
+
+    var hasEffect = this._showEffect(seriesModel);
+
+    var isPolyline = !!seriesModel.get('polyline');
+    var pipelineContext = seriesModel.pipelineContext;
+    var isLargeDraw = pipelineContext.large;
+
+    if (!lineDraw || hasEffect !== this._hasEffet || isPolyline !== this._isPolyline || isLargeDraw !== this._isLargeDraw) {
+      if (lineDraw) {
+        lineDraw.remove();
+      }
+
+      lineDraw = this._lineDraw = isLargeDraw ? new LargeLineDraw() : new LineDraw(isPolyline ? hasEffect ? EffectPolyline : Polyline : hasEffect ? EffectLine : Line);
+      this._hasEffet = hasEffect;
+      this._isPolyline = isPolyline;
+      this._isLargeDraw = isLargeDraw;
+      this.group.removeAll();
+    }
+
+    this.group.add(lineDraw.group);
+    return lineDraw;
+  },
+  _showEffect: function (seriesModel) {
+    return !!seriesModel.get('effect.show');
+  },
+  _clearLayer: function (api) {
+    // Not use motion when dragging or zooming
+    var zr = api.getZr();
+    var isSvg = zr.painter.getType() === 'svg';
+
+    if (!isSvg && this._lastZlevel != null) {
+      zr.painter.getLayer(this._lastZlevel).clear(true);
+    }
+  },
+  remove: function (ecModel, api) {
+    this._lineDraw && this._lineDraw.remove();
+    this._lineDraw = null; // Clear motion when lineDraw is removed
+
+    this._clearLayer(api);
+  },
+  dispose: function () {}
+});
+
+module.exports = _default;

node_modules/echarts/lib/chart/lines/linesLayout.js

@@ -0,0 +1,118 @@
+
+/*
+* 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 createRenderPlanner = require("../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.
+*/
+
+/* global Float32Array */
+var _default = {
+  seriesType: 'lines',
+  plan: createRenderPlanner(),
+  reset: function (seriesModel) {
+    var coordSys = seriesModel.coordinateSystem;
+    var isPolyline = seriesModel.get('polyline');
+    var isLarge = seriesModel.pipelineContext.large;
+
+    function progress(params, lineData) {
+      var lineCoords = [];
+
+      if (isLarge) {
+        var points;
+        var segCount = params.end - params.start;
+
+        if (isPolyline) {
+          var totalCoordsCount = 0;
+
+          for (var i = params.start; i < params.end; i++) {
+            totalCoordsCount += seriesModel.getLineCoordsCount(i);
+          }
+
+          points = new Float32Array(segCount + totalCoordsCount * 2);
+        } else {
+          points = new Float32Array(segCount * 4);
+        }
+
+        var offset = 0;
+        var pt = [];
+
+        for (var i = params.start; i < params.end; i++) {
+          var len = seriesModel.getLineCoords(i, lineCoords);
+
+          if (isPolyline) {
+            points[offset++] = len;
+          }
+
+          for (var k = 0; k < len; k++) {
+            pt = coordSys.dataToPoint(lineCoords[k], false, pt);
+            points[offset++] = pt[0];
+            points[offset++] = pt[1];
+          }
+        }
+
+        lineData.setLayout('linesPoints', points);
+      } else {
+        for (var i = params.start; i < params.end; i++) {
+          var itemModel = lineData.getItemModel(i);
+          var len = seriesModel.getLineCoords(i, lineCoords);
+          var pts = [];
+
+          if (isPolyline) {
+            for (var j = 0; j < len; j++) {
+              pts.push(coordSys.dataToPoint(lineCoords[j]));
+            }
+          } else {
+            pts[0] = coordSys.dataToPoint(lineCoords[0]);
+            pts[1] = coordSys.dataToPoint(lineCoords[1]);
+            var curveness = itemModel.get('lineStyle.curveness');
+
+            if (+curveness) {
+              pts[2] = [(pts[0][0] + pts[1][0]) / 2 - (pts[0][1] - pts[1][1]) * curveness, (pts[0][1] + pts[1][1]) / 2 - (pts[1][0] - pts[0][0]) * curveness];
+            }
+          }
+
+          lineData.setItemLayout(i, pts);
+        }
+      }
+    }
+
+    return {
+      progress: progress
+    };
+  }
+};
+module.exports = _default;

node_modules/echarts/lib/chart/lines/linesVisual.js

@@ -0,0 +1,77 @@
+
+/*
+* 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.
+*/
+
+/*
+* 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 normalize(a) {
+  if (!(a instanceof Array)) {
+    a = [a, a];
+  }
+
+  return a;
+}
+
+var opacityQuery = 'lineStyle.opacity'.split('.');
+var _default = {
+  seriesType: 'lines',
+  reset: function (seriesModel, ecModel, api) {
+    var symbolType = normalize(seriesModel.get('symbol'));
+    var symbolSize = normalize(seriesModel.get('symbolSize'));
+    var data = seriesModel.getData();
+    data.setVisual('fromSymbol', symbolType && symbolType[0]);
+    data.setVisual('toSymbol', symbolType && symbolType[1]);
+    data.setVisual('fromSymbolSize', symbolSize && symbolSize[0]);
+    data.setVisual('toSymbolSize', symbolSize && symbolSize[1]);
+    data.setVisual('opacity', seriesModel.get(opacityQuery));
+
+    function dataEach(data, idx) {
+      var itemModel = data.getItemModel(idx);
+      var symbolType = normalize(itemModel.getShallow('symbol', true));
+      var symbolSize = normalize(itemModel.getShallow('symbolSize', true));
+      var opacity = itemModel.get(opacityQuery);
+      symbolType[0] && data.setItemVisual(idx, 'fromSymbol', symbolType[0]);
+      symbolType[1] && data.setItemVisual(idx, 'toSymbol', symbolType[1]);
+      symbolSize[0] && data.setItemVisual(idx, 'fromSymbolSize', symbolSize[0]);
+      symbolSize[1] && data.setItemVisual(idx, 'toSymbolSize', symbolSize[1]);
+      data.setItemVisual(idx, 'opacity', opacity);
+    }
+
+    return {
+      dataEach: data.hasItemOption ? dataEach : null
+    };
+  }
+};
+module.exports = _default;