@antv/hierarchy 0.6.7 → 0.6.9

package/lib/layout/hierarchy.js

@@ -1,6 +1,5 @@
 /* eslint-disable no-cond-assign */
 var util = require('../util');
-
 var PEM = 18;
 var DEFAULT_HEIGHT = PEM * 2;
 var DEFAULT_GAP = PEM;
@@ -50,7 +49,6 @@ function Node(data, options) {
    * |                            |
    *  -----------width------------
    */
-
   var hgap = options.getHGap(data);
   var vgap = options.getVGap(data);
   me.preH = options.getPreH(data);
@@ -62,15 +60,12 @@ function Node(data, options) {
   me.id = options.getId(data);
   me.x = me.y = 0;
   me.depth = 0;
-
   if (!me.children) {
     me.children = [];
   }
-
   me.addGap(hgap, vgap);
   return me;
 }
-
 util.assign(Node.prototype, {
   isRoot: function isRoot() {
     return this.depth === 0;
@@ -90,7 +85,6 @@ util.assign(Node.prototype, {
     var me = this;
     var nodes = [me];
     var current;
-
     while (current = nodes.shift()) {
       callback(current);
       nodes = current.children.concat(nodes);
@@ -105,7 +99,6 @@ util.assign(Node.prototype, {
     var me = this;
     var nodes = [me];
     var current;
-
     while (current = nodes.shift()) {
       callback(current);
       nodes = nodes.concat(current.children);
@@ -132,11 +125,9 @@ util.assign(Node.prototype, {
     if (tx === void 0) {
       tx = 0;
     }
-
     if (ty === void 0) {
       ty = 0;
     }
-
     this.eachNode(function (node) {
       node.x += tx;
       node.y += ty;
@@ -148,37 +139,37 @@ util.assign(Node.prototype, {
     var me = this;
     var bb = me.getBoundingBox();
     me.eachNode(function (node) {
-      node.x = node.x - (node.x - bb.left) * 2 - node.width; // node.x = - node.x;
+      node.x = node.x - (node.x - bb.left) * 2 - node.width;
+      // node.x = - node.x;
     });
+
     me.translate(bb.width, 0);
   },
   bottom2top: function bottom2top() {
     var me = this;
     var bb = me.getBoundingBox();
     me.eachNode(function (node) {
-      node.y = node.y - (node.y - bb.top) * 2 - node.height; // node.y = - node.y;
+      node.y = node.y - (node.y - bb.top) * 2 - node.height;
+      // node.y = - node.y;
     });
+
     me.translate(0, bb.height);
   }
 });
-
 function hierarchy(data, options, isolated) {
   if (options === void 0) {
     options = {};
   }
-
   options = util.assign({}, DEFAULT_OPTIONS, options);
   var root = new Node(data, options);
   var nodes = [root];
   var node;
-
   if (!isolated && !data.collapsed) {
     while (node = nodes.shift()) {
       if (!node.data.collapsed) {
         var children = options.getChildren(node.data);
         var length = children ? children.length : 0;
         node.children = new Array(length);
-
         if (children && length) {
           for (var i = 0; i < length; i++) {
             var child = new Node(children[i], options);
@@ -191,8 +182,6 @@ function hierarchy(data, options, isolated) {
       }
     }
   }
-
   return root;
 }
-
 module.exports = hierarchy;

package/lib/layout/indented.js

@@ -1,24 +1,42 @@
-function positionNode(node, previousNode, dx, dropCap) {
+var util = require('../util');
+function positionNode(node, previousNode, indent, dropCap, align) {
+  //  caculate the node's horizontal offset DX, dx's type might be number or function
+  var displacementX = typeof indent === 'function' ? indent(node) : indent * node.depth;
   if (!dropCap) {
     try {
       if (node.id === node.parent.children[0].id) {
-        node.x += dx * node.depth;
+        node.x += displacementX;
         node.y = previousNode ? previousNode.y : 0;
         return;
       }
-    } catch (e) {// skip to normal when a node has no parent
+    } catch (e) {
+      // skip to normal when a node has no parent
     }
   }
-
-  node.x += dx * node.depth;
-  node.y = previousNode ? previousNode.y + previousNode.height : 0;
+  node.x += displacementX;
+  if (previousNode) {
+    var _previousNode$parent;
+    node.y = previousNode.y + util.getHeight(previousNode, node, align);
+    if (node.parent.id !== ((_previousNode$parent = previousNode.parent) == null ? void 0 : _previousNode$parent.id)) {
+      // previous node has different parent
+      var index = node.parent.children.findIndex(function (n) {
+        return n.id === node.id;
+      });
+      var preNode = node.parent.children[index - 1];
+      if (preNode) {
+        var preY = preNode.y + util.getHeight(preNode, node, align);
+        node.y = preY > node.y ? preY : node.y;
+      }
+    }
+  } else {
+    node.y = 0;
+  }
   return;
 }
-
-module.exports = function (root, indent, dropCap) {
+module.exports = function (root, indent, dropCap, align) {
   var previousNode = null;
   root.eachNode(function (node) {
-    positionNode(node, previousNode, indent, dropCap);
+    positionNode(node, previousNode, indent, dropCap, align);
     previousNode = node;
   });
 };

package/lib/layout/mindmap.js

@@ -1,8 +1,6 @@
 var util = require('../util');
-
 function secondWalk(node, options) {
   var totalHeight = 0;
-
   if (!node.children.length) {
     totalHeight = node.height;
   } else {
@@ -10,16 +8,13 @@ function secondWalk(node, options) {
       totalHeight += secondWalk(c, options);
     });
   }
-
   node._subTreeSep = options.getSubTreeSep(node.data);
   node.totalHeight = Math.max(node.height, totalHeight) + 2 * node._subTreeSep;
   return node.totalHeight;
 }
-
 function thirdWalk(node) {
   var children = node.children;
   var len = children.length;
-
   if (len) {
     children.forEach(function (c) {
       thirdWalk(c);
@@ -31,7 +26,6 @@ function thirdWalk(node) {
     children.forEach(function (child) {
       childrenTotalHeight += child.totalHeight;
     });
-
     if (childrenHeight > node.height) {
       // 当子节点总高度大于父节点高度
       node.y = first.y + childrenHeight / 2 - node.height / 2;
@@ -47,50 +41,44 @@ function thirdWalk(node) {
     }
   }
 }
-
 var DEFAULT_OPTIONS = {
   getSubTreeSep: function getSubTreeSep() {
     return 0;
   }
 };
-
 module.exports = function (root, options) {
   if (options === void 0) {
     options = {};
   }
-
   options = util.assign({}, DEFAULT_OPTIONS, options);
   root.parent = {
     x: 0,
     width: 0,
     height: 0,
     y: 0
-  }; // first walk
-
+  };
+  // first walk
   root.BFTraverse(function (node) {
     node.x = node.parent.x + node.parent.width; // simply get x
   });
-  root.parent = null; // second walk
 
+  root.parent = null;
+  // second walk
   secondWalk(root, options); // assign sub tree totalHeight
   // adjusting
   // separating nodes
-
   root.startY = 0;
   root.y = root.totalHeight / 2 - root.height / 2;
   root.eachNode(function (node) {
     var children = node.children;
     var len = children.length;
-
     if (len) {
       var first = children[0];
       first.startY = node.startY + node._subTreeSep;
-
       if (len === 1) {
         first.y = node.y + node.height / 2 - first.height / 2;
       } else {
         first.y = first.startY + first.totalHeight / 2 - first.height / 2;
-
         for (var i = 1; i < len; i++) {
           var c = children[i];
           c.startY = children[i - 1].startY + children[i - 1].totalHeight;
@@ -98,7 +86,8 @@ module.exports = function (root, options) {
         }
       }
     }
-  }); // third walk
+  });
 
+  // third walk
   thirdWalk(root);
 };

package/lib/layout/non-layered-tidy.js

@@ -3,33 +3,37 @@ function WrappedTree(w, h, y, c) {
   if (c === void 0) {
     c = [];
   }
-
-  var me = this; // size
-
+  var me = this;
+  // size
   me.w = w || 0;
-  me.h = h || 0; // position
+  me.h = h || 0;
 
+  // position
   me.y = y || 0;
-  me.x = 0; // children
+  me.x = 0;
 
+  // children
   me.c = c || [];
-  me.cs = c.length; // modified
+  me.cs = c.length;
 
+  // modified
   me.prelim = 0;
   me.mod = 0;
   me.shift = 0;
-  me.change = 0; // left/right tree
+  me.change = 0;
 
+  // left/right tree
   me.tl = null;
-  me.tr = null; // extreme left/right tree
+  me.tr = null;
 
+  // extreme left/right tree
   me.el = null;
-  me.er = null; // modified left/right tree
+  me.er = null;
 
+  // modified left/right tree
   me.msel = 0;
   me.mser = 0;
 }
-
 WrappedTree.fromNode = function (root, isHorizontal) {
   if (!root) return null;
   var children = [];
@@ -38,21 +42,19 @@ WrappedTree.fromNode = function (root, isHorizontal) {
   });
   if (isHorizontal) return new WrappedTree(root.height, root.width, root.x, children);
   return new WrappedTree(root.width, root.height, root.y, children);
-}; // node utils
-
+};
 
+// node utils
 function moveRight(node, move, isHorizontal) {
   if (isHorizontal) {
     node.y += move;
   } else {
     node.x += move;
   }
-
   node.children.forEach(function (child) {
     moveRight(child, move, isHorizontal);
   });
 }
-
 function getMin(node, isHorizontal) {
   var res = isHorizontal ? node.y : node.x;
   node.children.forEach(function (child) {
@@ -60,33 +62,24 @@ function getMin(node, isHorizontal) {
   });
   return res;
 }
-
 function normalize(node, isHorizontal) {
   var min = getMin(node, isHorizontal);
   moveRight(node, -min, isHorizontal);
 }
-
-function convertBack(converted
-/* WrappedTree */
-, root
-/* TreeNode */
-, isHorizontal) {
+function convertBack(converted /* WrappedTree */, root /* TreeNode */, isHorizontal) {
   if (isHorizontal) {
     root.y = converted.x;
   } else {
     root.x = converted.x;
   }
-
   converted.c.forEach(function (child, i) {
     convertBack(child, root.children[i], isHorizontal);
   });
 }
-
 function layer(node, isHorizontal, d) {
   if (d === void 0) {
     d = 0;
   }
-
   if (isHorizontal) {
     node.x = d;
     d += node.width;
@@ -94,39 +87,31 @@ function layer(node, isHorizontal, d) {
     node.y = d;
     d += node.height;
   }
-
   node.children.forEach(function (child) {
     layer(child, isHorizontal, d);
   });
 }
-
 module.exports = function (root, options) {
   if (options === void 0) {
     options = {};
   }
-
   var isHorizontal = options.isHorizontal;
-
   function firstWalk(t) {
     if (t.cs === 0) {
       setExtremes(t);
       return;
     }
-
     firstWalk(t.c[0]);
     var ih = updateIYL(bottom(t.c[0].el), 0, null);
-
     for (var i = 1; i < t.cs; ++i) {
       firstWalk(t.c[i]);
       var min = bottom(t.c[i].er);
       separate(t, i, ih);
       ih = updateIYL(min, i, ih);
     }
-
     positionRoot(t);
     setExtremes(t);
   }
-
   function setExtremes(t) {
     if (t.cs === 0) {
       t.el = t;
@@ -139,62 +124,50 @@ module.exports = function (root, options) {
       t.mser = t.c[t.cs - 1].mser;
     }
   }
-
   function separate(t, i, ih) {
     var sr = t.c[i - 1];
     var mssr = sr.mod;
     var cl = t.c[i];
     var mscl = cl.mod;
-
     while (sr !== null && cl !== null) {
       if (bottom(sr) > ih.low) ih = ih.nxt;
       var dist = mssr + sr.prelim + sr.w - (mscl + cl.prelim);
-
       if (dist > 0) {
         mscl += dist;
         moveSubtree(t, i, ih.index, dist);
       }
-
       var sy = bottom(sr);
       var cy = bottom(cl);
-
       if (sy <= cy) {
         sr = nextRightContour(sr);
         if (sr !== null) mssr += sr.mod;
       }
-
       if (sy >= cy) {
         cl = nextLeftContour(cl);
         if (cl !== null) mscl += cl.mod;
       }
     }
-
     if (!sr && !!cl) {
       setLeftThread(t, i, cl, mscl);
     } else if (!!sr && !cl) {
       setRightThread(t, i, sr, mssr);
     }
   }
-
   function moveSubtree(t, i, si, dist) {
     t.c[i].mod += dist;
     t.c[i].msel += dist;
     t.c[i].mser += dist;
     distributeExtra(t, i, si, dist);
   }
-
   function nextLeftContour(t) {
     return t.cs === 0 ? t.tl : t.c[0];
   }
-
   function nextRightContour(t) {
     return t.cs === 0 ? t.tr : t.c[t.cs - 1];
   }
-
   function bottom(t) {
     return t.y + t.h;
   }
-
   function setLeftThread(t, i, cl, modsumcl) {
     var li = t.c[0].el;
     li.tl = cl;
@@ -204,7 +177,6 @@ module.exports = function (root, options) {
     t.c[0].el = t.c[i].el;
     t.c[0].msel = t.c[i].msel;
   }
-
   function setRightThread(t, i, sr, modsumsr) {
     var ri = t.c[i].er;
     ri.tr = sr;
@@ -214,21 +186,17 @@ module.exports = function (root, options) {
     t.c[i].er = t.c[i - 1].er;
     t.c[i].mser = t.c[i - 1].mser;
   }
-
   function positionRoot(t) {
     t.prelim = (t.c[0].prelim + t.c[0].mod + t.c[t.cs - 1].mod + t.c[t.cs - 1].prelim + t.c[t.cs - 1].w) / 2 - t.w / 2;
   }
-
   function secondWalk(t, modsum) {
     modsum += t.mod;
     t.x = t.prelim + modsum;
     addChildSpacing(t);
-
     for (var i = 0; i < t.cs; i++) {
       secondWalk(t.c[i], modsum);
     }
   }
-
   function distributeExtra(t, i, si, dist) {
     if (si !== i - 1) {
       var nr = i - si;
@@ -237,31 +205,27 @@ module.exports = function (root, options) {
       t.c[i].change -= dist - dist / nr;
     }
   }
-
   function addChildSpacing(t) {
     var d = 0;
     var modsumdelta = 0;
-
     for (var i = 0; i < t.cs; i++) {
       d += t.c[i].shift;
       modsumdelta += d + t.c[i].change;
       t.c[i].mod += modsumdelta;
     }
   }
-
   function updateIYL(low, index, ih) {
     while (ih !== null && low >= ih.low) {
       ih = ih.nxt;
     }
-
     return {
       low: low,
       index: index,
       nxt: ih
     };
-  } // do layout
-
+  }
 
+  // do layout
   layer(root, isHorizontal);
   var wt = WrappedTree.fromNode(root, isHorizontal);
   firstWalk(wt);

package/lib/layout/separate-root.js

@@ -1,34 +1,27 @@
 var hierarchy = require('./hierarchy');
-
 module.exports = function (root, options) {
   // separate into left and right trees
   var left = hierarchy(root.data, options, true); // root only
-
   var right = hierarchy(root.data, options, true); // root only
   // automatically
-
   var treeSize = root.children.length;
-  var rightTreeSize = Math.round(treeSize / 2); // separate left and right tree by meta data
-
+  var rightTreeSize = Math.round(treeSize / 2);
+  // separate left and right tree by meta data
   var getSide = options.getSide || function (child, index) {
     if (index < rightTreeSize) {
       return 'right';
     }
-
     return 'left';
   };
-
   for (var i = 0; i < treeSize; i++) {
     var child = root.children[i];
     var side = getSide(child, i);
-
     if (side === 'right') {
       right.children.push(child);
     } else {
       left.children.push(child);
     }
   }
-
   left.eachNode(function (node) {
     if (!node.isRoot()) {
       node.side = 'left';

package/lib/mindmap.js

@@ -1,35 +1,24 @@
-function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
-
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 var TreeLayout = require('./layout/base');
-
 var mindmap = require('./layout/mindmap');
-
 var doTreeLayout = require('./layout/do-layout');
-
 var util = require('./util');
-
 var MindmapLayout = /*#__PURE__*/function (_TreeLayout) {
   _inheritsLoose(MindmapLayout, _TreeLayout);
-
   function MindmapLayout() {
     return _TreeLayout.apply(this, arguments) || this;
   }
-
   var _proto = MindmapLayout.prototype;
-
   _proto.execute = function execute() {
     var me = this;
     return doTreeLayout(me.rootNode, me.options, mindmap);
   };
-
   return MindmapLayout;
 }(TreeLayout);
-
 var DEFAULT_OPTIONS = {};
-
 function mindmapLayout(root, options) {
   options = util.assign({}, DEFAULT_OPTIONS, options);
   return new MindmapLayout(root, options).execute();
 }
-
 module.exports = mindmapLayout;

package/lib/util.js

@@ -1,6 +1,21 @@
 var _require = require('@antv/util'),
-    mix = _require.mix;
+  mix = _require.mix;
 
+/**
+ * Get average height or height for node's position calculation, according to align.
+ * @param {*} preNode previous node
+ * @param {*} node current node, whose position is going to be calculated
+ * @param {'center' | undefined} align 'center' means nodes align at the center, other value means align at the left-top
+ * @param {string} heightField field name for height value on preNode and node
+ * @return {number} the height for calculation
+ */
+function getHeight(preNode, node, align, heightField) {
+  if (heightField === void 0) {
+    heightField = 'height';
+  }
+  return align === 'center' ? (preNode[heightField] + node[heightField]) / 2 : preNode.height;
+}
 module.exports = {
-  assign: mix
+  assign: mix,
+  getHeight: getHeight
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/hierarchy",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "layout algorithms for visualizing hierarchical data",
   "main": "build/hierarchy.js",
   "browser": "build/hierarchy.js",
@@ -32,7 +32,9 @@
     "connect": "~3.6.5",
     "d3-queue": "~3.0.7",
     "debug": "~3.1.0",
-    "electron": "~2.0.6",
+    "spectron": "^13.0.0",
+    "electron-packager": "^15.2.0",
+    "electron": "^11.2.1",
     "eslint": "~3.19.0",
     "eslint-config-airbnb": "~15.0.1",
     "eslint-config-egg": "~4.2.0",
@@ -80,6 +82,9 @@
     "silent": false
   },
   "dependencies": {
-    "@antv/util": "^2.0.7"
+    "@antv/util": "^2.0.7",
+    "electron": "^11.2.1",
+    "electron-packager": "^17.1.1",
+    "spectron": "^19.0.0"
   }
 }

package/src/indented.js

@@ -18,22 +18,21 @@ class IndentedLayout extends TreeLayout {
     const root = me.rootNode;
     options.isHorizontal = true;
     // default indent 20 and sink first children;
-    const { indent = 20, dropCap = true } = options;
-    const direction = options.direction || DEFAULT_DIRECTION;
+    const { indent = 20, dropCap = true, direction = DEFAULT_DIRECTION, align } = options;
     if (direction && VALID_DIRECTIONS.indexOf(direction) === -1) {
       throw new TypeError(`Invalid direction: ${direction}`);
     }
     if (direction === VALID_DIRECTIONS[0]) { // LR
-      indentedTree(root, indent, dropCap);
+      indentedTree(root, indent, dropCap, align);
     } else if (direction === VALID_DIRECTIONS[1]) { // RL
-      indentedTree(root, indent, dropCap);
+      indentedTree(root, indent, dropCap, align);
       root.right2left();
     } else if (direction === VALID_DIRECTIONS[2]) { // H
       // separate into left and right trees
       const { left, right } = separateTree(root, options);
-      indentedTree(left, indent, dropCap);
+      indentedTree(left, indent, dropCap, align);
       left.right2left();
-      indentedTree(right, indent, dropCap);
+      indentedTree(right, indent, dropCap, align);
       const bbox = left.getBoundingBox();
       right.translate(bbox.width, 0);
       root.x = right.x - root.width / 2;