first commit

node_modules/echarts/lib/coord/parallel/AxisModel.js

@@ -0,0 +1,157 @@
+
+/*
+* 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 zrUtil = require("zrender/lib/core/util");
+
+var ComponentModel = require("../../model/Component");
+
+var makeStyleMapper = require("../../model/mixin/makeStyleMapper");
+
+var axisModelCreator = require("../axisModelCreator");
+
+var numberUtil = require("../../util/number");
+
+var axisModelCommonMixin = require("../axisModelCommonMixin");
+
+/*
+* 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 AxisModel = ComponentModel.extend({
+  type: 'baseParallelAxis',
+
+  /**
+   * @type {module:echarts/coord/parallel/Axis}
+   */
+  axis: null,
+
+  /**
+   * @type {Array.<Array.<number>}
+   * @readOnly
+   */
+  activeIntervals: [],
+
+  /**
+   * @return {Object}
+   */
+  getAreaSelectStyle: function () {
+    return makeStyleMapper([['fill', 'color'], ['lineWidth', 'borderWidth'], ['stroke', 'borderColor'], ['width', 'width'], ['opacity', 'opacity']])(this.getModel('areaSelectStyle'));
+  },
+
+  /**
+   * The code of this feature is put on AxisModel but not ParallelAxis,
+   * because axisModel can be alive after echarts updating but instance of
+   * ParallelAxis having been disposed. this._activeInterval should be kept
+   * when action dispatched (i.e. legend click).
+   *
+   * @param {Array.<Array<number>>} intervals interval.length === 0
+   *                                          means set all active.
+   * @public
+   */
+  setActiveIntervals: function (intervals) {
+    var activeIntervals = this.activeIntervals = zrUtil.clone(intervals); // Normalize
+
+    if (activeIntervals) {
+      for (var i = activeIntervals.length - 1; i >= 0; i--) {
+        numberUtil.asc(activeIntervals[i]);
+      }
+    }
+  },
+
+  /**
+   * @param {number|string} [value] When attempting to detect 'no activeIntervals set',
+   *                         value can not be input.
+   * @return {string} 'normal': no activeIntervals set,
+   *                  'active',
+   *                  'inactive'.
+   * @public
+   */
+  getActiveState: function (value) {
+    var activeIntervals = this.activeIntervals;
+
+    if (!activeIntervals.length) {
+      return 'normal';
+    }
+
+    if (value == null || isNaN(value)) {
+      return 'inactive';
+    } // Simple optimization
+
+
+    if (activeIntervals.length === 1) {
+      var interval = activeIntervals[0];
+
+      if (interval[0] <= value && value <= interval[1]) {
+        return 'active';
+      }
+    } else {
+      for (var i = 0, len = activeIntervals.length; i < len; i++) {
+        if (activeIntervals[i][0] <= value && value <= activeIntervals[i][1]) {
+          return 'active';
+        }
+      }
+    }
+
+    return 'inactive';
+  }
+});
+var defaultOption = {
+  type: 'value',
+
+  /**
+   * @type {Array.<number>}
+   */
+  dim: null,
+  // 0, 1, 2, ...
+  // parallelIndex: null,
+  areaSelectStyle: {
+    width: 20,
+    borderWidth: 1,
+    borderColor: 'rgba(160,197,232)',
+    color: 'rgba(160,197,232)',
+    opacity: 0.3
+  },
+  realtime: true,
+  // Whether realtime update view when select.
+  z: 10
+};
+zrUtil.merge(AxisModel.prototype, axisModelCommonMixin);
+
+function getAxisType(axisName, option) {
+  return option.type || (option.data ? 'category' : 'value');
+}
+
+axisModelCreator('parallel', AxisModel, getAxisType, defaultOption);
+var _default = AxisModel;
+module.exports = _default;

node_modules/echarts/lib/coord/parallel/Parallel.js

@@ -0,0 +1,515 @@
+
+/*
+* 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 zrUtil = require("zrender/lib/core/util");
+
+var matrix = require("zrender/lib/core/matrix");
+
+var layoutUtil = require("../../util/layout");
+
+var axisHelper = require("../../coord/axisHelper");
+
+var ParallelAxis = require("./ParallelAxis");
+
+var graphic = require("../../util/graphic");
+
+var numberUtil = require("../../util/number");
+
+var sliderMove = require("../../component/helper/sliderMove");
+
+/*
+* 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.
+*/
+
+/**
+ * Parallel Coordinates
+ * <https://en.wikipedia.org/wiki/Parallel_coordinates>
+ */
+var each = zrUtil.each;
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathFloor = Math.floor;
+var mathCeil = Math.ceil;
+var round = numberUtil.round;
+var PI = Math.PI;
+
+function Parallel(parallelModel, ecModel, api) {
+  /**
+   * key: dimension
+   * @type {Object.<string, module:echarts/coord/parallel/Axis>}
+   * @private
+   */
+  this._axesMap = zrUtil.createHashMap();
+  /**
+   * key: dimension
+   * value: {position: [], rotation, }
+   * @type {Object.<string, Object>}
+   * @private
+   */
+
+  this._axesLayout = {};
+  /**
+   * Always follow axis order.
+   * @type {Array.<string>}
+   * @readOnly
+   */
+
+  this.dimensions = parallelModel.dimensions;
+  /**
+   * @type {module:zrender/core/BoundingRect}
+   */
+
+  this._rect;
+  /**
+   * @type {module:echarts/coord/parallel/ParallelModel}
+   */
+
+  this._model = parallelModel;
+
+  this._init(parallelModel, ecModel, api);
+}
+
+Parallel.prototype = {
+  type: 'parallel',
+  constructor: Parallel,
+
+  /**
+   * Initialize cartesian coordinate systems
+   * @private
+   */
+  _init: function (parallelModel, ecModel, api) {
+    var dimensions = parallelModel.dimensions;
+    var parallelAxisIndex = parallelModel.parallelAxisIndex;
+    each(dimensions, function (dim, idx) {
+      var axisIndex = parallelAxisIndex[idx];
+      var axisModel = ecModel.getComponent('parallelAxis', axisIndex);
+
+      var axis = this._axesMap.set(dim, new ParallelAxis(dim, axisHelper.createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisIndex));
+
+      var isCategory = axis.type === 'category';
+      axis.onBand = isCategory && axisModel.get('boundaryGap');
+      axis.inverse = axisModel.get('inverse'); // Injection
+
+      axisModel.axis = axis;
+      axis.model = axisModel;
+      axis.coordinateSystem = axisModel.coordinateSystem = this;
+    }, this);
+  },
+
+  /**
+   * Update axis scale after data processed
+   * @param  {module:echarts/model/Global} ecModel
+   * @param  {module:echarts/ExtensionAPI} api
+   */
+  update: function (ecModel, api) {
+    this._updateAxesFromSeries(this._model, ecModel);
+  },
+
+  /**
+   * @override
+   */
+  containPoint: function (point) {
+    var layoutInfo = this._makeLayoutInfo();
+
+    var axisBase = layoutInfo.axisBase;
+    var layoutBase = layoutInfo.layoutBase;
+    var pixelDimIndex = layoutInfo.pixelDimIndex;
+    var pAxis = point[1 - pixelDimIndex];
+    var pLayout = point[pixelDimIndex];
+    return pAxis >= axisBase && pAxis <= axisBase + layoutInfo.axisLength && pLayout >= layoutBase && pLayout <= layoutBase + layoutInfo.layoutLength;
+  },
+  getModel: function () {
+    return this._model;
+  },
+
+  /**
+   * Update properties from series
+   * @private
+   */
+  _updateAxesFromSeries: function (parallelModel, ecModel) {
+    ecModel.eachSeries(function (seriesModel) {
+      if (!parallelModel.contains(seriesModel, ecModel)) {
+        return;
+      }
+
+      var data = seriesModel.getData();
+      each(this.dimensions, function (dim) {
+        var axis = this._axesMap.get(dim);
+
+        axis.scale.unionExtentFromData(data, data.mapDimension(dim));
+        axisHelper.niceScaleExtent(axis.scale, axis.model);
+      }, this);
+    }, this);
+  },
+
+  /**
+   * Resize the parallel coordinate system.
+   * @param {module:echarts/coord/parallel/ParallelModel} parallelModel
+   * @param {module:echarts/ExtensionAPI} api
+   */
+  resize: function (parallelModel, api) {
+    this._rect = layoutUtil.getLayoutRect(parallelModel.getBoxLayoutParams(), {
+      width: api.getWidth(),
+      height: api.getHeight()
+    });
+
+    this._layoutAxes();
+  },
+
+  /**
+   * @return {module:zrender/core/BoundingRect}
+   */
+  getRect: function () {
+    return this._rect;
+  },
+
+  /**
+   * @private
+   */
+  _makeLayoutInfo: function () {
+    var parallelModel = this._model;
+    var rect = this._rect;
+    var xy = ['x', 'y'];
+    var wh = ['width', 'height'];
+    var layout = parallelModel.get('layout');
+    var pixelDimIndex = layout === 'horizontal' ? 0 : 1;
+    var layoutLength = rect[wh[pixelDimIndex]];
+    var layoutExtent = [0, layoutLength];
+    var axisCount = this.dimensions.length;
+    var axisExpandWidth = restrict(parallelModel.get('axisExpandWidth'), layoutExtent);
+    var axisExpandCount = restrict(parallelModel.get('axisExpandCount') || 0, [0, axisCount]);
+    var axisExpandable = parallelModel.get('axisExpandable') && axisCount > 3 && axisCount > axisExpandCount && axisExpandCount > 1 && axisExpandWidth > 0 && layoutLength > 0; // `axisExpandWindow` is According to the coordinates of [0, axisExpandLength],
+    // for sake of consider the case that axisCollapseWidth is 0 (when screen is narrow),
+    // where collapsed axes should be overlapped.
+
+    var axisExpandWindow = parallelModel.get('axisExpandWindow');
+    var winSize;
+
+    if (!axisExpandWindow) {
+      winSize = restrict(axisExpandWidth * (axisExpandCount - 1), layoutExtent);
+      var axisExpandCenter = parallelModel.get('axisExpandCenter') || mathFloor(axisCount / 2);
+      axisExpandWindow = [axisExpandWidth * axisExpandCenter - winSize / 2];
+      axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+    } else {
+      winSize = restrict(axisExpandWindow[1] - axisExpandWindow[0], layoutExtent);
+      axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+    }
+
+    var axisCollapseWidth = (layoutLength - winSize) / (axisCount - axisExpandCount); // Avoid axisCollapseWidth is too small.
+
+    axisCollapseWidth < 3 && (axisCollapseWidth = 0); // Find the first and last indices > ewin[0] and < ewin[1].
+
+    var winInnerIndices = [mathFloor(round(axisExpandWindow[0] / axisExpandWidth, 1)) + 1, mathCeil(round(axisExpandWindow[1] / axisExpandWidth, 1)) - 1]; // Pos in ec coordinates.
+
+    var axisExpandWindow0Pos = axisCollapseWidth / axisExpandWidth * axisExpandWindow[0];
+    return {
+      layout: layout,
+      pixelDimIndex: pixelDimIndex,
+      layoutBase: rect[xy[pixelDimIndex]],
+      layoutLength: layoutLength,
+      axisBase: rect[xy[1 - pixelDimIndex]],
+      axisLength: rect[wh[1 - pixelDimIndex]],
+      axisExpandable: axisExpandable,
+      axisExpandWidth: axisExpandWidth,
+      axisCollapseWidth: axisCollapseWidth,
+      axisExpandWindow: axisExpandWindow,
+      axisCount: axisCount,
+      winInnerIndices: winInnerIndices,
+      axisExpandWindow0Pos: axisExpandWindow0Pos
+    };
+  },
+
+  /**
+   * @private
+   */
+  _layoutAxes: function () {
+    var rect = this._rect;
+    var axes = this._axesMap;
+    var dimensions = this.dimensions;
+
+    var layoutInfo = this._makeLayoutInfo();
+
+    var layout = layoutInfo.layout;
+    axes.each(function (axis) {
+      var axisExtent = [0, layoutInfo.axisLength];
+      var idx = axis.inverse ? 1 : 0;
+      axis.setExtent(axisExtent[idx], axisExtent[1 - idx]);
+    });
+    each(dimensions, function (dim, idx) {
+      var posInfo = (layoutInfo.axisExpandable ? layoutAxisWithExpand : layoutAxisWithoutExpand)(idx, layoutInfo);
+      var positionTable = {
+        horizontal: {
+          x: posInfo.position,
+          y: layoutInfo.axisLength
+        },
+        vertical: {
+          x: 0,
+          y: posInfo.position
+        }
+      };
+      var rotationTable = {
+        horizontal: PI / 2,
+        vertical: 0
+      };
+      var position = [positionTable[layout].x + rect.x, positionTable[layout].y + rect.y];
+      var rotation = rotationTable[layout];
+      var transform = matrix.create();
+      matrix.rotate(transform, transform, rotation);
+      matrix.translate(transform, transform, position); // TODO
+      // tick等排布信息。
+      // TODO
+      // 根据axis order 更新 dimensions顺序。
+
+      this._axesLayout[dim] = {
+        position: position,
+        rotation: rotation,
+        transform: transform,
+        axisNameAvailableWidth: posInfo.axisNameAvailableWidth,
+        axisLabelShow: posInfo.axisLabelShow,
+        nameTruncateMaxWidth: posInfo.nameTruncateMaxWidth,
+        tickDirection: 1,
+        labelDirection: 1
+      };
+    }, this);
+  },
+
+  /**
+   * Get axis by dim.
+   * @param {string} dim
+   * @return {module:echarts/coord/parallel/ParallelAxis} [description]
+   */
+  getAxis: function (dim) {
+    return this._axesMap.get(dim);
+  },
+
+  /**
+   * Convert a dim value of a single item of series data to Point.
+   * @param {*} value
+   * @param {string} dim
+   * @return {Array}
+   */
+  dataToPoint: function (value, dim) {
+    return this.axisCoordToPoint(this._axesMap.get(dim).dataToCoord(value), dim);
+  },
+
+  /**
+   * Travel data for one time, get activeState of each data item.
+   * @param {module:echarts/data/List} data
+   * @param {Functio} cb param: {string} activeState 'active' or 'inactive' or 'normal'
+   *                            {number} dataIndex
+   * @param {number} [start=0] the start dataIndex that travel from.
+   * @param {number} [end=data.count()] the next dataIndex of the last dataIndex will be travel.
+   */
+  eachActiveState: function (data, callback, start, end) {
+    start == null && (start = 0);
+    end == null && (end = data.count());
+    var axesMap = this._axesMap;
+    var dimensions = this.dimensions;
+    var dataDimensions = [];
+    var axisModels = [];
+    zrUtil.each(dimensions, function (axisDim) {
+      dataDimensions.push(data.mapDimension(axisDim));
+      axisModels.push(axesMap.get(axisDim).model);
+    });
+    var hasActiveSet = this.hasAxisBrushed();
+
+    for (var dataIndex = start; dataIndex < end; dataIndex++) {
+      var activeState;
+
+      if (!hasActiveSet) {
+        activeState = 'normal';
+      } else {
+        activeState = 'active';
+        var values = data.getValues(dataDimensions, dataIndex);
+
+        for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+          var state = axisModels[j].getActiveState(values[j]);
+
+          if (state === 'inactive') {
+            activeState = 'inactive';
+            break;
+          }
+        }
+      }
+
+      callback(activeState, dataIndex);
+    }
+  },
+
+  /**
+   * Whether has any activeSet.
+   * @return {boolean}
+   */
+  hasAxisBrushed: function () {
+    var dimensions = this.dimensions;
+    var axesMap = this._axesMap;
+    var hasActiveSet = false;
+
+    for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+      if (axesMap.get(dimensions[j]).model.getActiveState() !== 'normal') {
+        hasActiveSet = true;
+      }
+    }
+
+    return hasActiveSet;
+  },
+
+  /**
+   * Convert coords of each axis to Point.
+   *  Return point. For example: [10, 20]
+   * @param {Array.<number>} coords
+   * @param {string} dim
+   * @return {Array.<number>}
+   */
+  axisCoordToPoint: function (coord, dim) {
+    var axisLayout = this._axesLayout[dim];
+    return graphic.applyTransform([coord, 0], axisLayout.transform);
+  },
+
+  /**
+   * Get axis layout.
+   */
+  getAxisLayout: function (dim) {
+    return zrUtil.clone(this._axesLayout[dim]);
+  },
+
+  /**
+   * @param {Array.<number>} point
+   * @return {Object} {axisExpandWindow, delta, behavior: 'jump' | 'slide' | 'none'}.
+   */
+  getSlidedAxisExpandWindow: function (point) {
+    var layoutInfo = this._makeLayoutInfo();
+
+    var pixelDimIndex = layoutInfo.pixelDimIndex;
+    var axisExpandWindow = layoutInfo.axisExpandWindow.slice();
+    var winSize = axisExpandWindow[1] - axisExpandWindow[0];
+    var extent = [0, layoutInfo.axisExpandWidth * (layoutInfo.axisCount - 1)]; // Out of the area of coordinate system.
+
+    if (!this.containPoint(point)) {
+      return {
+        behavior: 'none',
+        axisExpandWindow: axisExpandWindow
+      };
+    } // Conver the point from global to expand coordinates.
+
+
+    var pointCoord = point[pixelDimIndex] - layoutInfo.layoutBase - layoutInfo.axisExpandWindow0Pos; // For dragging operation convenience, the window should not be
+    // slided when mouse is the center area of the window.
+
+    var delta;
+    var behavior = 'slide';
+    var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+
+    var triggerArea = this._model.get('axisExpandSlideTriggerArea'); // But consider touch device, jump is necessary.
+
+
+    var useJump = triggerArea[0] != null;
+
+    if (axisCollapseWidth) {
+      if (useJump && axisCollapseWidth && pointCoord < winSize * triggerArea[0]) {
+        behavior = 'jump';
+        delta = pointCoord - winSize * triggerArea[2];
+      } else if (useJump && axisCollapseWidth && pointCoord > winSize * (1 - triggerArea[0])) {
+        behavior = 'jump';
+        delta = pointCoord - winSize * (1 - triggerArea[2]);
+      } else {
+        (delta = pointCoord - winSize * triggerArea[1]) >= 0 && (delta = pointCoord - winSize * (1 - triggerArea[1])) <= 0 && (delta = 0);
+      }
+
+      delta *= layoutInfo.axisExpandWidth / axisCollapseWidth;
+      delta ? sliderMove(delta, axisExpandWindow, extent, 'all') // Avoid nonsense triger on mousemove.
+      : behavior = 'none';
+    } // When screen is too narrow, make it visible and slidable, although it is hard to interact.
+    else {
+        var winSize = axisExpandWindow[1] - axisExpandWindow[0];
+        var pos = extent[1] * pointCoord / winSize;
+        axisExpandWindow = [mathMax(0, pos - winSize / 2)];
+        axisExpandWindow[1] = mathMin(extent[1], axisExpandWindow[0] + winSize);
+        axisExpandWindow[0] = axisExpandWindow[1] - winSize;
+      }
+
+    return {
+      axisExpandWindow: axisExpandWindow,
+      behavior: behavior
+    };
+  }
+};
+
+function restrict(len, extent) {
+  return mathMin(mathMax(len, extent[0]), extent[1]);
+}
+
+function layoutAxisWithoutExpand(axisIndex, layoutInfo) {
+  var step = layoutInfo.layoutLength / (layoutInfo.axisCount - 1);
+  return {
+    position: step * axisIndex,
+    axisNameAvailableWidth: step,
+    axisLabelShow: true
+  };
+}
+
+function layoutAxisWithExpand(axisIndex, layoutInfo) {
+  var layoutLength = layoutInfo.layoutLength;
+  var axisExpandWidth = layoutInfo.axisExpandWidth;
+  var axisCount = layoutInfo.axisCount;
+  var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+  var winInnerIndices = layoutInfo.winInnerIndices;
+  var position;
+  var axisNameAvailableWidth = axisCollapseWidth;
+  var axisLabelShow = false;
+  var nameTruncateMaxWidth;
+
+  if (axisIndex < winInnerIndices[0]) {
+    position = axisIndex * axisCollapseWidth;
+    nameTruncateMaxWidth = axisCollapseWidth;
+  } else if (axisIndex <= winInnerIndices[1]) {
+    position = layoutInfo.axisExpandWindow0Pos + axisIndex * axisExpandWidth - layoutInfo.axisExpandWindow[0];
+    axisNameAvailableWidth = axisExpandWidth;
+    axisLabelShow = true;
+  } else {
+    position = layoutLength - (axisCount - 1 - axisIndex) * axisCollapseWidth;
+    nameTruncateMaxWidth = axisCollapseWidth;
+  }
+
+  return {
+    position: position,
+    axisNameAvailableWidth: axisNameAvailableWidth,
+    axisLabelShow: axisLabelShow,
+    nameTruncateMaxWidth: nameTruncateMaxWidth
+  };
+}
+
+var _default = Parallel;
+module.exports = _default;

node_modules/echarts/lib/coord/parallel/ParallelAxis.js

@@ -0,0 +1,90 @@
+
+/*
+* 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 zrUtil = require("zrender/lib/core/util");
+
+var Axis = require("../Axis");
+
+/*
+* 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.
+*/
+
+/**
+ * @constructor module:echarts/coord/parallel/ParallelAxis
+ * @extends {module:echarts/coord/Axis}
+ * @param {string} dim
+ * @param {*} scale
+ * @param {Array.<number>} coordExtent
+ * @param {string} axisType
+ */
+var ParallelAxis = function (dim, scale, coordExtent, axisType, axisIndex) {
+  Axis.call(this, dim, scale, coordExtent);
+  /**
+   * Axis type
+   *  - 'category'
+   *  - 'value'
+   *  - 'time'
+   *  - 'log'
+   * @type {string}
+   */
+
+  this.type = axisType || 'value';
+  /**
+   * @type {number}
+   * @readOnly
+   */
+
+  this.axisIndex = axisIndex;
+};
+
+ParallelAxis.prototype = {
+  constructor: ParallelAxis,
+
+  /**
+   * Axis model
+   * @param {module:echarts/coord/parallel/AxisModel}
+   */
+  model: null,
+
+  /**
+   * @override
+   */
+  isHorizontal: function () {
+    return this.coordinateSystem.getModel().get('layout') !== 'horizontal';
+  }
+};
+zrUtil.inherits(ParallelAxis, Axis);
+var _default = ParallelAxis;
+module.exports = _default;

node_modules/echarts/lib/coord/parallel/ParallelModel.js

@@ -0,0 +1,149 @@
+
+/*
+* 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 zrUtil = require("zrender/lib/core/util");
+
+var Component = require("../../model/Component");
+
+require("./AxisModel");
+
+/*
+* 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 = Component.extend({
+  type: 'parallel',
+  dependencies: ['parallelAxis'],
+
+  /**
+   * @type {module:echarts/coord/parallel/Parallel}
+   */
+  coordinateSystem: null,
+
+  /**
+   * Each item like: 'dim0', 'dim1', 'dim2', ...
+   * @type {Array.<string>}
+   * @readOnly
+   */
+  dimensions: null,
+
+  /**
+   * Coresponding to dimensions.
+   * @type {Array.<number>}
+   * @readOnly
+   */
+  parallelAxisIndex: null,
+  layoutMode: 'box',
+  defaultOption: {
+    zlevel: 0,
+    z: 0,
+    left: 80,
+    top: 60,
+    right: 80,
+    bottom: 60,
+    // width: {totalWidth} - left - right,
+    // height: {totalHeight} - top - bottom,
+    layout: 'horizontal',
+    // 'horizontal' or 'vertical'
+    // FIXME
+    // naming?
+    axisExpandable: false,
+    axisExpandCenter: null,
+    axisExpandCount: 0,
+    axisExpandWidth: 50,
+    // FIXME '10%' ?
+    axisExpandRate: 17,
+    axisExpandDebounce: 50,
+    // [out, in, jumpTarget]. In percentage. If use [null, 0.05], null means full.
+    // Do not doc to user until necessary.
+    axisExpandSlideTriggerArea: [-0.15, 0.05, 0.4],
+    axisExpandTriggerOn: 'click',
+    // 'mousemove' or 'click'
+    parallelAxisDefault: null
+  },
+
+  /**
+   * @override
+   */
+  init: function () {
+    Component.prototype.init.apply(this, arguments);
+    this.mergeOption({});
+  },
+
+  /**
+   * @override
+   */
+  mergeOption: function (newOption) {
+    var thisOption = this.option;
+    newOption && zrUtil.merge(thisOption, newOption, true);
+
+    this._initDimensions();
+  },
+
+  /**
+   * Whether series or axis is in this coordinate system.
+   * @param {module:echarts/model/Series|module:echarts/coord/parallel/AxisModel} model
+   * @param {module:echarts/model/Global} ecModel
+   */
+  contains: function (model, ecModel) {
+    var parallelIndex = model.get('parallelIndex');
+    return parallelIndex != null && ecModel.getComponent('parallel', parallelIndex) === this;
+  },
+  setAxisExpand: function (opt) {
+    zrUtil.each(['axisExpandable', 'axisExpandCenter', 'axisExpandCount', 'axisExpandWidth', 'axisExpandWindow'], function (name) {
+      if (opt.hasOwnProperty(name)) {
+        this.option[name] = opt[name];
+      }
+    }, this);
+  },
+
+  /**
+   * @private
+   */
+  _initDimensions: function () {
+    var dimensions = this.dimensions = [];
+    var parallelAxisIndex = this.parallelAxisIndex = [];
+    var axisModels = zrUtil.filter(this.dependentModels.parallelAxis, function (axisModel) {
+      // Can not use this.contains here, because
+      // initialization has not been completed yet.
+      return (axisModel.get('parallelIndex') || 0) === this.componentIndex;
+    }, this);
+    zrUtil.each(axisModels, function (axisModel) {
+      dimensions.push('dim' + axisModel.get('dim'));
+      parallelAxisIndex.push(axisModel.componentIndex);
+    });
+  }
+});
+
+module.exports = _default;

node_modules/echarts/lib/coord/parallel/parallelCreator.js

@@ -0,0 +1,73 @@
+
+/*
+* 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 Parallel = require("./Parallel");
+
+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.
+*/
+
+/**
+ * Parallel coordinate system creater.
+ */
+function create(ecModel, api) {
+  var coordSysList = [];
+  ecModel.eachComponent('parallel', function (parallelModel, idx) {
+    var coordSys = new Parallel(parallelModel, ecModel, api);
+    coordSys.name = 'parallel_' + idx;
+    coordSys.resize(parallelModel, api);
+    parallelModel.coordinateSystem = coordSys;
+    coordSys.model = parallelModel;
+    coordSysList.push(coordSys);
+  }); // Inject the coordinateSystems into seriesModel
+
+  ecModel.eachSeries(function (seriesModel) {
+    if (seriesModel.get('coordinateSystem') === 'parallel') {
+      var parallelModel = ecModel.queryComponents({
+        mainType: 'parallel',
+        index: seriesModel.get('parallelIndex'),
+        id: seriesModel.get('parallelId')
+      })[0];
+      seriesModel.coordinateSystem = parallelModel.coordinateSystem;
+    }
+  });
+  return coordSysList;
+}
+
+CoordinateSystem.register('parallel', {
+  create: create
+});

node_modules/echarts/lib/coord/parallel/parallelPreprocessor.js

@@ -0,0 +1,91 @@
+
+/*
+* 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 zrUtil = require("zrender/lib/core/util");
+
+var modelUtil = require("../../util/model");
+
+/*
+* 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(option) {
+  createParallelIfNeeded(option);
+  mergeAxisOptionFromParallel(option);
+}
+/**
+ * Create a parallel coordinate if not exists.
+ * @inner
+ */
+
+
+function createParallelIfNeeded(option) {
+  if (option.parallel) {
+    return;
+  }
+
+  var hasParallelSeries = false;
+  zrUtil.each(option.series, function (seriesOpt) {
+    if (seriesOpt && seriesOpt.type === 'parallel') {
+      hasParallelSeries = true;
+    }
+  });
+
+  if (hasParallelSeries) {
+    option.parallel = [{}];
+  }
+}
+/**
+ * Merge aixs definition from parallel option (if exists) to axis option.
+ * @inner
+ */
+
+
+function mergeAxisOptionFromParallel(option) {
+  var axes = modelUtil.normalizeToArray(option.parallelAxis);
+  zrUtil.each(axes, function (axisOption) {
+    if (!zrUtil.isObject(axisOption)) {
+      return;
+    }
+
+    var parallelIndex = axisOption.parallelIndex || 0;
+    var parallelOption = modelUtil.normalizeToArray(option.parallel)[parallelIndex];
+
+    if (parallelOption && parallelOption.parallelAxisDefault) {
+      zrUtil.merge(axisOption, parallelOption.parallelAxisDefault, false);
+    }
+  });
+}
+
+module.exports = _default;