@fmdevui/fm-dev 1.0.112 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/adjustEdge.js

@@ -0,0 +1,137 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var curve = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/curve.js');
+var vector = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js');
+var graphHelper = require('./graphHelper.js');
+
+var v1 = [];
+var v2 = [];
+var v3 = [];
+var quadraticAt = curve.quadraticAt;
+var v2DistSquare = vector.distSquare;
+var mathAbs = Math.abs;
+function intersectCurveCircle(curvePoints, center, radius) {
+  var p0 = curvePoints[0];
+  var p1 = curvePoints[1];
+  var p2 = curvePoints[2];
+  var d = Infinity;
+  var t;
+  var radiusSquare = radius * radius;
+  var interval = 0.1;
+  for (var _t = 0.1; _t <= 0.9; _t += 0.1) {
+    v1[0] = quadraticAt(p0[0], p1[0], p2[0], _t);
+    v1[1] = quadraticAt(p0[1], p1[1], p2[1], _t);
+    var diff = mathAbs(v2DistSquare(v1, center) - radiusSquare);
+    if (diff < d) {
+      d = diff;
+      t = _t;
+    }
+  }
+  // Assume the segment is monotone，Find root through Bisection method
+  // At most 32 iteration
+  for (var i = 0; i < 32; i++) {
+    // let prev = t - interval;
+    var next = t + interval;
+    // v1[0] = quadraticAt(p0[0], p1[0], p2[0], prev);
+    // v1[1] = quadraticAt(p0[1], p1[1], p2[1], prev);
+    v2[0] = quadraticAt(p0[0], p1[0], p2[0], t);
+    v2[1] = quadraticAt(p0[1], p1[1], p2[1], t);
+    v3[0] = quadraticAt(p0[0], p1[0], p2[0], next);
+    v3[1] = quadraticAt(p0[1], p1[1], p2[1], next);
+    var diff = v2DistSquare(v2, center) - radiusSquare;
+    if (mathAbs(diff) < 1e-2) {
+      break;
+    }
+    // let prevDiff = v2DistSquare(v1, center) - radiusSquare;
+    var nextDiff = v2DistSquare(v3, center) - radiusSquare;
+    interval /= 2;
+    if (diff < 0) {
+      if (nextDiff >= 0) {
+        t = t + interval;
+      } else {
+        t = t - interval;
+      }
+    } else {
+      if (nextDiff >= 0) {
+        t = t - interval;
+      } else {
+        t = t + interval;
+      }
+    }
+  }
+  return t;
+}
+// Adjust edge to avoid
+function adjustEdge(graph, scale) {
+  var tmp0 = [];
+  var quadraticSubdivide = curve.quadraticSubdivide;
+  var pts = [[], [], []];
+  var pts2 = [[], []];
+  var v = [];
+  scale /= 2;
+  graph.eachEdge(function (edge, idx) {
+    var linePoints = edge.getLayout();
+    var fromSymbol = edge.getVisual('fromSymbol');
+    var toSymbol = edge.getVisual('toSymbol');
+    if (!linePoints.__original) {
+      linePoints.__original = [vector.clone(linePoints[0]), vector.clone(linePoints[1])];
+      if (linePoints[2]) {
+        linePoints.__original.push(vector.clone(linePoints[2]));
+      }
+    }
+    var originalPoints = linePoints.__original;
+    // Quadratic curve
+    if (linePoints[2] != null) {
+      vector.copy(pts[0], originalPoints[0]);
+      vector.copy(pts[1], originalPoints[2]);
+      vector.copy(pts[2], originalPoints[1]);
+      if (fromSymbol && fromSymbol !== 'none') {
+        var symbolSize = graphHelper.getSymbolSize(edge.node1);
+        var t = intersectCurveCircle(pts, originalPoints[0], symbolSize * scale);
+        // Subdivide and get the second
+        quadraticSubdivide(pts[0][0], pts[1][0], pts[2][0], t, tmp0);
+        pts[0][0] = tmp0[3];
+        pts[1][0] = tmp0[4];
+        quadraticSubdivide(pts[0][1], pts[1][1], pts[2][1], t, tmp0);
+        pts[0][1] = tmp0[3];
+        pts[1][1] = tmp0[4];
+      }
+      if (toSymbol && toSymbol !== 'none') {
+        var symbolSize = graphHelper.getSymbolSize(edge.node2);
+        var t = intersectCurveCircle(pts, originalPoints[1], symbolSize * scale);
+        // Subdivide and get the first
+        quadraticSubdivide(pts[0][0], pts[1][0], pts[2][0], t, tmp0);
+        pts[1][0] = tmp0[1];
+        pts[2][0] = tmp0[2];
+        quadraticSubdivide(pts[0][1], pts[1][1], pts[2][1], t, tmp0);
+        pts[1][1] = tmp0[1];
+        pts[2][1] = tmp0[2];
+      }
+      // Copy back to layout
+      vector.copy(linePoints[0], pts[0]);
+      vector.copy(linePoints[1], pts[2]);
+      vector.copy(linePoints[2], pts[1]);
+    }
+    // Line
+    else {
+      vector.copy(pts2[0], originalPoints[0]);
+      vector.copy(pts2[1], originalPoints[1]);
+      vector.sub(v, pts2[1], pts2[0]);
+      vector.normalize(v, v);
+      if (fromSymbol && fromSymbol !== 'none') {
+        var symbolSize = graphHelper.getSymbolSize(edge.node1);
+        vector.scaleAndAdd(pts2[0], pts2[0], v, symbolSize * scale);
+      }
+      if (toSymbol && toSymbol !== 'none') {
+        var symbolSize = graphHelper.getSymbolSize(edge.node2);
+        vector.scaleAndAdd(pts2[1], pts2[1], v, -symbolSize * scale);
+      }
+      vector.copy(linePoints[0], pts2[0]);
+      vector.copy(linePoints[1], pts2[1]);
+    }
+  });
+}
+
+exports.default = adjustEdge;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/categoryFilter.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+function categoryFilter(ecModel) {
+  var legendModels = ecModel.findComponents({
+    mainType: 'legend'
+  });
+  if (!legendModels || !legendModels.length) {
+    return;
+  }
+  ecModel.eachSeriesByType('graph', function (graphSeries) {
+    var categoriesData = graphSeries.getCategoriesData();
+    var graph = graphSeries.getGraph();
+    var data = graph.data;
+    var categoryNames = categoriesData.mapArray(categoriesData.getName);
+    data.filterSelf(function (idx) {
+      var model = data.getItemModel(idx);
+      var category = model.getShallow('category');
+      if (category != null) {
+        if (util.isNumber(category)) {
+          category = categoryNames[category];
+        }
+        // If in any legend component the status is not selected.
+        for (var i = 0; i < legendModels.length; i++) {
+          if (!legendModels[i].isSelected(category)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    });
+  });
+}
+
+exports.default = categoryFilter;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/categoryVisual.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+function categoryVisual(ecModel) {
+  var paletteScope = {};
+  ecModel.eachSeriesByType('graph', function (seriesModel) {
+    var categoriesData = seriesModel.getCategoriesData();
+    var data = seriesModel.getData();
+    var categoryNameIdxMap = {};
+    categoriesData.each(function (idx) {
+      var name = categoriesData.getName(idx);
+      // Add prefix to avoid conflict with Object.prototype.
+      categoryNameIdxMap['ec-' + name] = idx;
+      var itemModel = categoriesData.getItemModel(idx);
+      var style = itemModel.getModel('itemStyle').getItemStyle();
+      if (!style.fill) {
+        // Get color from palette.
+        style.fill = seriesModel.getColorFromPalette(name, paletteScope);
+      }
+      categoriesData.setItemVisual(idx, 'style', style);
+      var symbolVisualList = ['symbol', 'symbolSize', 'symbolKeepAspect'];
+      for (var i = 0; i < symbolVisualList.length; i++) {
+        var symbolVisual = itemModel.getShallow(symbolVisualList[i], true);
+        if (symbolVisual != null) {
+          categoriesData.setItemVisual(idx, symbolVisualList[i], symbolVisual);
+        }
+      }
+    });
+    // Assign category color to visual
+    if (categoriesData.count()) {
+      data.each(function (idx) {
+        var model = data.getItemModel(idx);
+        var categoryIdx = model.getShallow('category');
+        if (categoryIdx != null) {
+          if (util.isString(categoryIdx)) {
+            categoryIdx = categoryNameIdxMap['ec-' + categoryIdx];
+          }
+          var categoryStyle = categoriesData.getItemVisual(categoryIdx, 'style');
+          var style = data.ensureUniqueItemVisual(idx, 'style');
+          util.extend(style, categoryStyle);
+          var visualList = ['symbol', 'symbolSize', 'symbolKeepAspect'];
+          for (var i = 0; i < visualList.length; i++) {
+            data.setItemVisual(idx, visualList[i], categoriesData.getItemVisual(categoryIdx, visualList[i]));
+          }
+        }
+      });
+    }
+  });
+}
+
+exports.default = categoryVisual;

package/lib/node_modules/.pnpm/echarts@6.0.0/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/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/circularLayoutHelper.js

@@ -0,0 +1,154 @@
+'use strict';
+
+var vector = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js');
+var graphHelper = require('./graphHelper.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/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/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/createView.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var View = require('../../coord/View.js');
+var layout = require('../../util/layout.js');
+var bbox = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/bbox.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var CoordinateSystem = require('../../core/CoordinateSystem.js');
+
+function getViewRect(seriesModel, api, aspect) {
+  var layoutRef = layout.createBoxLayoutReference(seriesModel, api);
+  var option = util.extend(seriesModel.getBoxLayoutParams(), {
+    aspect: aspect
+  });
+  var viewRect = layout.getLayoutRect(option, layoutRef.refContainer);
+  return layout.applyPreserveAspect(seriesModel, viewRect, aspect);
+}
+function createViewCoordSys(ecModel, api) {
+  var viewList = [];
+  ecModel.eachSeriesByType('graph', function (seriesModel) {
+    CoordinateSystem.injectCoordSysByOption({
+      targetModel: seriesModel,
+      coordSysType: 'view',
+      coordSysProvider: createViewCoordSys,
+      isDefaultDataCoordSys: true
+    });
+    function createViewCoordSys() {
+      var data = seriesModel.getData();
+      var positions = data.mapArray(function (idx) {
+        var itemModel = data.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 viewCoordSys = new View.default(null, {
+        api: api,
+        ecModel: ecModel
+      });
+      viewCoordSys.zoomLimit = seriesModel.get('scaleLimit');
+      viewCoordSys.setBoundingRect(min[0], min[1], bbWidth, bbHeight);
+      viewCoordSys.setViewRect(viewRect.x, viewRect.y, viewRect.width, viewRect.height);
+      // Update roam info
+      viewCoordSys.setCenter(seriesModel.get('center'));
+      viewCoordSys.setZoom(seriesModel.get('zoom'));
+      viewList.push(viewCoordSys);
+      return viewCoordSys;
+    }
+  });
+  return viewList;
+}
+
+exports.default = createViewCoordSys;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/edgeVisual.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/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/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/forceHelper.js

@@ -0,0 +1,138 @@
+'use strict';
+
+var vector = require('../../../../../../zrender@6.0.0/node_modules/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;