office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/chart/graph/circularLayout.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var circularLayoutHelper = require('./circularLayoutHelper.js');
+
+function graphCircularLayout(ecModel) {
+  ecModel.eachSeriesByType('graph', function (seriesModel) {
+    if (seriesModel.get('layout') === 'circular') {
+      circularLayoutHelper.circularLayout(seriesModel, 'symbolSize');
+    }
+  });
+}
+
+exports["default"] = graphCircularLayout;

package/lib/node_modules/echarts/lib/chart/graph/circularLayoutHelper.js

@@ -0,0 +1,156 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vector = require('../../../../zrender/lib/core/vector.js');
+var graphHelper = require('./graphHelper.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var multipleGraphEdgeHelper = require('../helper/multipleGraphEdgeHelper.js');
+
+var PI = Math.PI;
+var _symbolRadiansHalf = [];
+/**
+ * `basedOn` can be:
+ * 'value':
+ *     This layout is not accurate and have same bad case. For example,
+ *     if the min value is very smaller than the max value, the nodes
+ *     with the min value probably overlap even though there is enough
+ *     space to layout them. So we only use this approach in the as the
+ *     init layout of the force layout.
+ *     FIXME
+ *     Probably we do not need this method any more but use
+ *     `basedOn: 'symbolSize'` in force layout if
+ *     delay its init operations to GraphView.
+ * 'symbolSize':
+ *     This approach work only if all of the symbol size calculated.
+ *     That is, the progressive rendering is not applied to graph.
+ *     FIXME
+ *     If progressive rendering is applied to graph some day,
+ *     probably we have to use `basedOn: 'value'`.
+ */
+function circularLayout(seriesModel, basedOn, draggingNode, pointer) {
+  var coordSys = seriesModel.coordinateSystem;
+  if (coordSys && coordSys.type !== 'view') {
+    return;
+  }
+  var rect = coordSys.getBoundingRect();
+  var nodeData = seriesModel.getData();
+  var graph = nodeData.graph;
+  var cx = rect.width / 2 + rect.x;
+  var cy = rect.height / 2 + rect.y;
+  var r = Math.min(rect.width, rect.height) / 2;
+  var count = nodeData.count();
+  nodeData.setLayout({
+    cx: cx,
+    cy: cy
+  });
+  if (!count) {
+    return;
+  }
+  if (draggingNode) {
+    var _a = coordSys.pointToData(pointer),
+      tempX = _a[0],
+      tempY = _a[1];
+    var v = [tempX - cx, tempY - cy];
+    vector.normalize(v, v);
+    vector.scale(v, v, r);
+    draggingNode.setLayout([cx + v[0], cy + v[1]], true);
+    var circularRotateLabel = seriesModel.get(['circular', 'rotateLabel']);
+    rotateNodeLabel(draggingNode, circularRotateLabel, cx, cy);
+  }
+  _layoutNodesBasedOn[basedOn](seriesModel, graph, nodeData, r, cx, cy, count);
+  graph.eachEdge(function (edge, index) {
+    var curveness = util.retrieve3(edge.getModel().get(['lineStyle', 'curveness']), multipleGraphEdgeHelper.getCurvenessForEdge(edge, seriesModel, index), 0);
+    var p1 = vector.clone(edge.node1.getLayout());
+    var p2 = vector.clone(edge.node2.getLayout());
+    var cp1;
+    var x12 = (p1[0] + p2[0]) / 2;
+    var y12 = (p1[1] + p2[1]) / 2;
+    if (+curveness) {
+      curveness *= 3;
+      cp1 = [cx * curveness + x12 * (1 - curveness), cy * curveness + y12 * (1 - curveness)];
+    }
+    edge.setLayout([p1, p2, cp1]);
+  });
+}
+var _layoutNodesBasedOn = {
+  value: function (seriesModel, graph, nodeData, r, cx, cy, count) {
+    var angle = 0;
+    var sum = nodeData.getSum('value');
+    var unitAngle = Math.PI * 2 / (sum || count);
+    graph.eachNode(function (node) {
+      var value = node.getValue('value');
+      var radianHalf = unitAngle * (sum ? value : 1) / 2;
+      angle += radianHalf;
+      node.setLayout([r * Math.cos(angle) + cx, r * Math.sin(angle) + cy]);
+      angle += radianHalf;
+    });
+  },
+  symbolSize: function (seriesModel, graph, nodeData, r, cx, cy, count) {
+    var sumRadian = 0;
+    _symbolRadiansHalf.length = count;
+    var nodeScale = graphHelper.getNodeGlobalScale(seriesModel);
+    graph.eachNode(function (node) {
+      var symbolSize = graphHelper.getSymbolSize(node);
+      // Normally this case will not happen, but we still add
+      // some the defensive code (2px is an arbitrary value).
+      isNaN(symbolSize) && (symbolSize = 2);
+      symbolSize < 0 && (symbolSize = 0);
+      symbolSize *= nodeScale;
+      var symbolRadianHalf = Math.asin(symbolSize / 2 / r);
+      // when `symbolSize / 2` is bigger than `r`.
+      isNaN(symbolRadianHalf) && (symbolRadianHalf = PI / 2);
+      _symbolRadiansHalf[node.dataIndex] = symbolRadianHalf;
+      sumRadian += symbolRadianHalf * 2;
+    });
+    var halfRemainRadian = (2 * PI - sumRadian) / count / 2;
+    var angle = 0;
+    graph.eachNode(function (node) {
+      var radianHalf = halfRemainRadian + _symbolRadiansHalf[node.dataIndex];
+      angle += radianHalf;
+      // init circular layout for
+      // 1. layout undefined node
+      // 2. not fixed node
+      (!node.getLayout() || !node.getLayout().fixed) && node.setLayout([r * Math.cos(angle) + cx, r * Math.sin(angle) + cy]);
+      angle += radianHalf;
+    });
+  }
+};
+function rotateNodeLabel(node, circularRotateLabel, cx, cy) {
+  var el = node.getGraphicEl();
+  // need to check if el exists. '-' value may not create node element.
+  if (!el) {
+    return;
+  }
+  var nodeModel = node.getModel();
+  var labelRotate = nodeModel.get(['label', 'rotate']) || 0;
+  var symbolPath = el.getSymbolPath();
+  if (circularRotateLabel) {
+    var pos = node.getLayout();
+    var rad = Math.atan2(pos[1] - cy, pos[0] - cx);
+    if (rad < 0) {
+      rad = Math.PI * 2 + rad;
+    }
+    var isLeft = pos[0] < cx;
+    if (isLeft) {
+      rad = rad - Math.PI;
+    }
+    var textPosition = isLeft ? 'left' : 'right';
+    symbolPath.setTextConfig({
+      rotation: -rad,
+      position: textPosition,
+      origin: 'center'
+    });
+    var emphasisState = symbolPath.ensureState('emphasis');
+    util.extend(emphasisState.textConfig || (emphasisState.textConfig = {}), {
+      position: textPosition
+    });
+  } else {
+    symbolPath.setTextConfig({
+      rotation: labelRotate *= Math.PI / 180
+    });
+  }
+}
+
+exports.circularLayout = circularLayout;
+exports.rotateNodeLabel = rotateNodeLabel;

package/lib/node_modules/echarts/lib/chart/graph/createView.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var View = require('../../coord/View.js');
+var layout = require('../../util/layout.js');
+var bbox = require('../../../../zrender/lib/core/bbox.js');
+var util = require('../../../../zrender/lib/core/util.js');
+
+function getViewRect(seriesModel, api, aspect) {
+  var option = util.extend(seriesModel.getBoxLayoutParams(), {
+    aspect: aspect
+  });
+  return layout.getLayoutRect(option, {
+    width: api.getWidth(),
+    height: api.getHeight()
+  });
+}
+function createViewCoordSys(ecModel, api) {
+  var viewList = [];
+  ecModel.eachSeriesByType('graph', function (seriesModel) {
+    var coordSysType = seriesModel.get('coordinateSystem');
+    if (!coordSysType || coordSysType === 'view') {
+      var data_1 = seriesModel.getData();
+      var positions = data_1.mapArray(function (idx) {
+        var itemModel = data_1.getItemModel(idx);
+        return [+itemModel.get('x'), +itemModel.get('y')];
+      });
+      var min = [];
+      var max = [];
+      bbox.fromPoints(positions, min, max);
+      // If width or height is 0
+      if (max[0] - min[0] === 0) {
+        max[0] += 1;
+        min[0] -= 1;
+      }
+      if (max[1] - min[1] === 0) {
+        max[1] += 1;
+        min[1] -= 1;
+      }
+      var aspect = (max[0] - min[0]) / (max[1] - min[1]);
+      // FIXME If get view rect after data processed?
+      var viewRect = getViewRect(seriesModel, api, aspect);
+      // Position may be NaN, use view rect instead
+      if (isNaN(aspect)) {
+        min = [viewRect.x, viewRect.y];
+        max = [viewRect.x + viewRect.width, viewRect.y + viewRect.height];
+      }
+      var bbWidth = max[0] - min[0];
+      var bbHeight = max[1] - min[1];
+      var viewWidth = viewRect.width;
+      var viewHeight = viewRect.height;
+      var viewCoordSys = seriesModel.coordinateSystem = new View["default"]();
+      viewCoordSys.zoomLimit = seriesModel.get('scaleLimit');
+      viewCoordSys.setBoundingRect(min[0], min[1], bbWidth, bbHeight);
+      viewCoordSys.setViewRect(viewRect.x, viewRect.y, viewWidth, viewHeight);
+      // Update roam info
+      viewCoordSys.setCenter(seriesModel.get('center'), api);
+      viewCoordSys.setZoom(seriesModel.get('zoom'));
+      viewList.push(viewCoordSys);
+    }
+  });
+  return viewList;
+}
+
+exports["default"] = createViewCoordSys;

package/lib/node_modules/echarts/lib/chart/graph/edgeVisual.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+
+function normalize(a) {
+  if (!(a instanceof Array)) {
+    a = [a, a];
+  }
+  return a;
+}
+function graphEdgeVisual(ecModel) {
+  ecModel.eachSeriesByType('graph', function (seriesModel) {
+    var graph = seriesModel.getGraph();
+    var edgeData = seriesModel.getEdgeData();
+    var symbolType = normalize(seriesModel.get('edgeSymbol'));
+    var symbolSize = normalize(seriesModel.get('edgeSymbolSize'));
+    // const colorQuery = ['lineStyle', 'color'] as const;
+    // const opacityQuery = ['lineStyle', 'opacity'] as const;
+    edgeData.setVisual('fromSymbol', symbolType && symbolType[0]);
+    edgeData.setVisual('toSymbol', symbolType && symbolType[1]);
+    edgeData.setVisual('fromSymbolSize', symbolSize && symbolSize[0]);
+    edgeData.setVisual('toSymbolSize', symbolSize && symbolSize[1]);
+    edgeData.setVisual('style', seriesModel.getModel('lineStyle').getLineStyle());
+    edgeData.each(function (idx) {
+      var itemModel = edgeData.getItemModel(idx);
+      var edge = graph.getEdgeByIndex(idx);
+      var symbolType = normalize(itemModel.getShallow('symbol', true));
+      var symbolSize = normalize(itemModel.getShallow('symbolSize', true));
+      // Edge visual must after node visual
+      var style = itemModel.getModel('lineStyle').getLineStyle();
+      var existsStyle = edgeData.ensureUniqueItemVisual(idx, 'style');
+      util.extend(existsStyle, style);
+      switch (existsStyle.stroke) {
+        case 'source':
+          {
+            var nodeStyle = edge.node1.getVisual('style');
+            existsStyle.stroke = nodeStyle && nodeStyle.fill;
+            break;
+          }
+        case 'target':
+          {
+            var nodeStyle = edge.node2.getVisual('style');
+            existsStyle.stroke = nodeStyle && nodeStyle.fill;
+            break;
+          }
+      }
+      symbolType[0] && edge.setVisual('fromSymbol', symbolType[0]);
+      symbolType[1] && edge.setVisual('toSymbol', symbolType[1]);
+      symbolSize[0] && edge.setVisual('fromSymbolSize', symbolSize[0]);
+      symbolSize[1] && edge.setVisual('toSymbolSize', symbolSize[1]);
+    });
+  });
+}
+
+exports["default"] = graphEdgeVisual;

package/lib/node_modules/echarts/lib/chart/graph/forceHelper.js

@@ -0,0 +1,140 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vector = require('../../../../zrender/lib/core/vector.js');
+
+var scaleAndAdd = vector.scaleAndAdd;
+// function adjacentNode(n, e) {
+//     return e.n1 === n ? e.n2 : e.n1;
+// }
+function forceLayout(inNodes, inEdges, opts) {
+  var nodes = inNodes;
+  var edges = inEdges;
+  var rect = opts.rect;
+  var width = rect.width;
+  var height = rect.height;
+  var center = [rect.x + width / 2, rect.y + height / 2];
+  // let scale = opts.scale || 1;
+  var gravity = opts.gravity == null ? 0.1 : opts.gravity;
+  // for (let i = 0; i < edges.length; i++) {
+  //     let e = edges[i];
+  //     let n1 = e.n1;
+  //     let n2 = e.n2;
+  //     n1.edges = n1.edges || [];
+  //     n2.edges = n2.edges || [];
+  //     n1.edges.push(e);
+  //     n2.edges.push(e);
+  // }
+  // Init position
+  for (var i = 0; i < nodes.length; i++) {
+    var n = nodes[i];
+    if (!n.p) {
+      n.p = vector.create(width * (Math.random() - 0.5) + center[0], height * (Math.random() - 0.5) + center[1]);
+    }
+    n.pp = vector.clone(n.p);
+    n.edges = null;
+  }
+  // Formula in 'Graph Drawing by Force-directed Placement'
+  // let k = scale * Math.sqrt(width * height / nodes.length);
+  // let k2 = k * k;
+  var initialFriction = opts.friction == null ? 0.6 : opts.friction;
+  var friction = initialFriction;
+  var beforeStepCallback;
+  var afterStepCallback;
+  return {
+    warmUp: function () {
+      friction = initialFriction * 0.8;
+    },
+    setFixed: function (idx) {
+      nodes[idx].fixed = true;
+    },
+    setUnfixed: function (idx) {
+      nodes[idx].fixed = false;
+    },
+    /**
+     * Before step hook
+     */
+    beforeStep: function (cb) {
+      beforeStepCallback = cb;
+    },
+    /**
+     * After step hook
+     */
+    afterStep: function (cb) {
+      afterStepCallback = cb;
+    },
+    /**
+     * Some formulas were originally copied from "d3.js"
+     * https://github.com/d3/d3/blob/b516d77fb8566b576088e73410437494717ada26/src/layout/force.js
+     * with some modifications made for this project.
+     * See the license statement at the head of this file.
+     */
+    step: function (cb) {
+      beforeStepCallback && beforeStepCallback(nodes, edges);
+      var v12 = [];
+      var nLen = nodes.length;
+      for (var i = 0; i < edges.length; i++) {
+        var e = edges[i];
+        if (e.ignoreForceLayout) {
+          continue;
+        }
+        var n1 = e.n1;
+        var n2 = e.n2;
+        vector.sub(v12, n2.p, n1.p);
+        var d = vector.len(v12) - e.d;
+        var w = n2.w / (n1.w + n2.w);
+        if (isNaN(w)) {
+          w = 0;
+        }
+        vector.normalize(v12, v12);
+        !n1.fixed && scaleAndAdd(n1.p, n1.p, v12, w * d * friction);
+        !n2.fixed && scaleAndAdd(n2.p, n2.p, v12, -(1 - w) * d * friction);
+      }
+      // Gravity
+      for (var i = 0; i < nLen; i++) {
+        var n = nodes[i];
+        if (!n.fixed) {
+          vector.sub(v12, center, n.p);
+          // let d = vec2.len(v12);
+          // vec2.scale(v12, v12, 1 / d);
+          // let gravityFactor = gravity;
+          scaleAndAdd(n.p, n.p, v12, gravity * friction);
+        }
+      }
+      // Repulsive
+      // PENDING
+      for (var i = 0; i < nLen; i++) {
+        var n1 = nodes[i];
+        for (var j = i + 1; j < nLen; j++) {
+          var n2 = nodes[j];
+          vector.sub(v12, n2.p, n1.p);
+          var d = vector.len(v12);
+          if (d === 0) {
+            // Random repulse
+            vector.set(v12, Math.random() - 0.5, Math.random() - 0.5);
+            d = 1;
+          }
+          var repFact = (n1.rep + n2.rep) / d / d;
+          !n1.fixed && scaleAndAdd(n1.pp, n1.pp, v12, repFact);
+          !n2.fixed && scaleAndAdd(n2.pp, n2.pp, v12, -repFact);
+        }
+      }
+      var v = [];
+      for (var i = 0; i < nLen; i++) {
+        var n = nodes[i];
+        if (!n.fixed) {
+          vector.sub(v, n.p, n.pp);
+          scaleAndAdd(n.p, n.p, v, friction);
+          vector.copy(n.pp, n.p);
+        }
+      }
+      friction = friction * 0.992;
+      var finished = friction < 0.01;
+      afterStepCallback && afterStepCallback(nodes, edges, finished);
+      cb && cb(finished);
+    }
+  };
+}
+
+exports.forceLayout = forceLayout;

package/lib/node_modules/echarts/lib/chart/graph/forceLayout.js

@@ -0,0 +1,124 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var forceHelper = require('./forceHelper.js');
+var simpleLayoutHelper = require('./simpleLayoutHelper.js');
+var circularLayoutHelper = require('./circularLayoutHelper.js');
+var number = require('../../util/number.js');
+var vector = require('../../../../zrender/lib/core/vector.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var multipleGraphEdgeHelper = require('../helper/multipleGraphEdgeHelper.js');
+
+function graphForceLayout(ecModel) {
+  ecModel.eachSeriesByType('graph', function (graphSeries) {
+    var coordSys = graphSeries.coordinateSystem;
+    if (coordSys && coordSys.type !== 'view') {
+      return;
+    }
+    if (graphSeries.get('layout') === 'force') {
+      var preservedPoints_1 = graphSeries.preservedPoints || {};
+      var graph_1 = graphSeries.getGraph();
+      var nodeData_1 = graph_1.data;
+      var edgeData = graph_1.edgeData;
+      var forceModel = graphSeries.getModel('force');
+      var initLayout = forceModel.get('initLayout');
+      if (graphSeries.preservedPoints) {
+        nodeData_1.each(function (idx) {
+          var id = nodeData_1.getId(idx);
+          nodeData_1.setItemLayout(idx, preservedPoints_1[id] || [NaN, NaN]);
+        });
+      } else if (!initLayout || initLayout === 'none') {
+        simpleLayoutHelper.simpleLayout(graphSeries);
+      } else if (initLayout === 'circular') {
+        circularLayoutHelper.circularLayout(graphSeries, 'value');
+      }
+      var nodeDataExtent_1 = nodeData_1.getDataExtent('value');
+      var edgeDataExtent_1 = edgeData.getDataExtent('value');
+      // let edgeDataExtent = edgeData.getDataExtent('value');
+      var repulsion = forceModel.get('repulsion');
+      var edgeLength = forceModel.get('edgeLength');
+      var repulsionArr_1 = util.isArray(repulsion) ? repulsion : [repulsion, repulsion];
+      var edgeLengthArr_1 = util.isArray(edgeLength) ? edgeLength : [edgeLength, edgeLength];
+      // Larger value has smaller length
+      edgeLengthArr_1 = [edgeLengthArr_1[1], edgeLengthArr_1[0]];
+      var nodes_1 = nodeData_1.mapArray('value', function (value, idx) {
+        var point = nodeData_1.getItemLayout(idx);
+        var rep = number.linearMap(value, nodeDataExtent_1, repulsionArr_1);
+        if (isNaN(rep)) {
+          rep = (repulsionArr_1[0] + repulsionArr_1[1]) / 2;
+        }
+        return {
+          w: rep,
+          rep: rep,
+          fixed: nodeData_1.getItemModel(idx).get('fixed'),
+          p: !point || isNaN(point[0]) || isNaN(point[1]) ? null : point
+        };
+      });
+      var edges = edgeData.mapArray('value', function (value, idx) {
+        var edge = graph_1.getEdgeByIndex(idx);
+        var d = number.linearMap(value, edgeDataExtent_1, edgeLengthArr_1);
+        if (isNaN(d)) {
+          d = (edgeLengthArr_1[0] + edgeLengthArr_1[1]) / 2;
+        }
+        var edgeModel = edge.getModel();
+        var curveness = util.retrieve3(edge.getModel().get(['lineStyle', 'curveness']), -multipleGraphEdgeHelper.getCurvenessForEdge(edge, graphSeries, idx, true), 0);
+        return {
+          n1: nodes_1[edge.node1.dataIndex],
+          n2: nodes_1[edge.node2.dataIndex],
+          d: d,
+          curveness: curveness,
+          ignoreForceLayout: edgeModel.get('ignoreForceLayout')
+        };
+      });
+      // let coordSys = graphSeries.coordinateSystem;
+      var rect = coordSys.getBoundingRect();
+      var forceInstance = forceHelper.forceLayout(nodes_1, edges, {
+        rect: rect,
+        gravity: forceModel.get('gravity'),
+        friction: forceModel.get('friction')
+      });
+      forceInstance.beforeStep(function (nodes, edges) {
+        for (var i = 0, l = nodes.length; i < l; i++) {
+          if (nodes[i].fixed) {
+            // Write back to layout instance
+            vector.copy(nodes[i].p, graph_1.getNodeByIndex(i).getLayout());
+          }
+        }
+      });
+      forceInstance.afterStep(function (nodes, edges, stopped) {
+        for (var i = 0, l = nodes.length; i < l; i++) {
+          if (!nodes[i].fixed) {
+            graph_1.getNodeByIndex(i).setLayout(nodes[i].p);
+          }
+          preservedPoints_1[nodeData_1.getId(i)] = nodes[i].p;
+        }
+        for (var i = 0, l = edges.length; i < l; i++) {
+          var e = edges[i];
+          var edge = graph_1.getEdgeByIndex(i);
+          var p1 = e.n1.p;
+          var p2 = e.n2.p;
+          var points = edge.getLayout();
+          points = points ? points.slice() : [];
+          points[0] = points[0] || [];
+          points[1] = points[1] || [];
+          vector.copy(points[0], p1);
+          vector.copy(points[1], p2);
+          if (+e.curveness) {
+            points[2] = [(p1[0] + p2[0]) / 2 - (p1[1] - p2[1]) * e.curveness, (p1[1] + p2[1]) / 2 - (p2[0] - p1[0]) * e.curveness];
+          }
+          edge.setLayout(points);
+        }
+      });
+      graphSeries.forceLayout = forceInstance;
+      graphSeries.preservedPoints = preservedPoints_1;
+      // Step to get the layout
+      forceInstance.step();
+    } else {
+      // Remove prev injected forceLayout instance
+      graphSeries.forceLayout = null;
+    }
+  });
+}
+
+exports["default"] = graphForceLayout;

package/lib/node_modules/echarts/lib/chart/graph/graphHelper.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*
+* 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.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* 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 getNodeGlobalScale(seriesModel) {
+  var coordSys = seriesModel.coordinateSystem;
+  if (coordSys.type !== 'view') {
+    return 1;
+  }
+  var nodeScaleRatio = seriesModel.option.nodeScaleRatio;
+  var groupZoom = coordSys.scaleX;
+  // Scale node when zoom changes
+  var roamZoom = coordSys.getZoom();
+  var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
+  return nodeScale / groupZoom;
+}
+function getSymbolSize(node) {
+  var symbolSize = node.getVisual('symbolSize');
+  if (symbolSize instanceof Array) {
+    symbolSize = (symbolSize[0] + symbolSize[1]) / 2;
+  }
+  return +symbolSize;
+}
+
+exports.getNodeGlobalScale = getNodeGlobalScale;
+exports.getSymbolSize = getSymbolSize;

package/lib/node_modules/echarts/lib/chart/graph/install.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var categoryFilter = require('./categoryFilter.js');
+var categoryVisual = require('./categoryVisual.js');
+var edgeVisual = require('./edgeVisual.js');
+var simpleLayout = require('./simpleLayout.js');
+var circularLayout = require('./circularLayout.js');
+var forceLayout = require('./forceLayout.js');
+var createView = require('./createView.js');
+var View = require('../../coord/View.js');
+var GraphView = require('./GraphView.js');
+var GraphSeries = require('./GraphSeries.js');
+var roamHelper = require('../../action/roamHelper.js');
+var util = require('../../../../zrender/lib/core/util.js');
+
+var actionInfo = {
+  type: 'graphRoam',
+  event: 'graphRoam',
+  update: 'none'
+};
+function install(registers) {
+  registers.registerChartView(GraphView["default"]);
+  registers.registerSeriesModel(GraphSeries["default"]);
+  registers.registerProcessor(categoryFilter["default"]);
+  registers.registerVisual(categoryVisual["default"]);
+  registers.registerVisual(edgeVisual["default"]);
+  registers.registerLayout(simpleLayout["default"]);
+  registers.registerLayout(registers.PRIORITY.VISUAL.POST_CHART_LAYOUT, circularLayout["default"]);
+  registers.registerLayout(forceLayout["default"]);
+  registers.registerCoordinateSystem('graphView', {
+    dimensions: View["default"].dimensions,
+    create: createView["default"]
+  });
+  // Register legacy focus actions
+  registers.registerAction({
+    type: 'focusNodeAdjacency',
+    event: 'focusNodeAdjacency',
+    update: 'series:focusNodeAdjacency'
+  }, util.noop);
+  registers.registerAction({
+    type: 'unfocusNodeAdjacency',
+    event: 'unfocusNodeAdjacency',
+    update: 'series:unfocusNodeAdjacency'
+  }, util.noop);
+  // Register roam action.
+  registers.registerAction(actionInfo, function (payload, ecModel, api) {
+    ecModel.eachComponent({
+      mainType: 'series',
+      query: payload
+    }, function (seriesModel) {
+      var coordSys = seriesModel.coordinateSystem;
+      var res = roamHelper.updateCenterAndZoom(coordSys, payload, undefined, api);
+      seriesModel.setCenter && seriesModel.setCenter(res.center);
+      seriesModel.setZoom && seriesModel.setZoom(res.zoom);
+    });
+  });
+}
+
+exports.install = install;