@antv/hierarchy 0.6.13 → 0.7.0

package/src/indented.js

@@ -1,52 +0,0 @@
-const TreeLayout = require('./layout/base');
-const indentedTree = require('./layout/indented');
-const separateTree = require('./layout/separate-root');
-const util = require('./util');
-
-
-const VALID_DIRECTIONS = [
-  'LR', // left to right
-  'RL', // right to left
-  'H' // horizontal
-];
-const DEFAULT_DIRECTION = VALID_DIRECTIONS[0];
-
-class IndentedLayout extends TreeLayout {
-  execute() {
-    const me = this;
-    const options = me.options;
-    const root = me.rootNode;
-    options.isHorizontal = true;
-    // default indent 20 and sink first children;
-    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, align);
-    } else if (direction === VALID_DIRECTIONS[1]) { // RL
-      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, align);
-      left.right2left();
-      indentedTree(right, indent, dropCap, align);
-      const bbox = left.getBoundingBox();
-      right.translate(bbox.width, 0);
-      root.x = right.x - root.width / 2;
-    }
-    return root;
-  }
-}
-
-const DEFAULT_OPTIONS = {
-};
-
-function indentedLayout(root, options) {
-  options = util.assign({}, DEFAULT_OPTIONS, options);
-  return new IndentedLayout(root, options).execute();
-}
-
-module.exports = indentedLayout;

package/src/index.js

@@ -1,9 +0,0 @@
-
-const hierarchy = {
-  compactBox: require('./compact-box'),
-  dendrogram: require('./dendrogram'),
-  indented: require('./indented'),
-  mindmap: require('./mindmap')
-};
-
-module.exports = hierarchy;

package/src/layout/base.js

@@ -1,16 +0,0 @@
-
-const hierarchy = require('./hierarchy');
-
-class Layout {
-  constructor(root, options = {}) {
-    const me = this;
-    me.options = options;
-    me.rootNode = hierarchy(root, options);
-  }
-
-  execute() {
-    throw new Error('please override this method');
-  }
-}
-
-module.exports = Layout;

package/src/layout/dendrogram.js

@@ -1,105 +0,0 @@
-// wrap tree node
-// TODO considering size
-const util = require('../util');
-
-function WrappedTree(height = 0, children = []) {
-  const me = this;
-  me.x = me.y = 0;
-  me.leftChild = me.rightChild = null;
-  me.height = 0;
-  me.children = children;
-}
-
-const DEFAULT_OPTIONS = {
-  isHorizontal: true,
-  nodeSep: 20,
-  nodeSize: 20,
-  rankSep: 200,
-  subTreeSep: 10
-};
-
-function convertBack(converted/* WrappedTree */, root/* TreeNode */, isHorizontal) {
-  if (isHorizontal) {
-    root.x = converted.x;
-    root.y = converted.y;
-  } else {
-    root.x = converted.y;
-    root.y = converted.x;
-  }
-  converted.children.forEach((child, i) => {
-    convertBack(child, root.children[i], isHorizontal);
-  });
-}
-
-module.exports = (root, options = {}) => {
-  options = util.assign({}, DEFAULT_OPTIONS, options);
-
-  let maxDepth = 0;
-  function wrappedTreeFromNode(n) {
-    if (!n) return null;
-    n.width = 0;
-    if (n.depth && n.depth > maxDepth) {
-      maxDepth = n.depth; // get the max depth
-    }
-    const children = n.children;
-    const childrenCount = children.length;
-    const t = new WrappedTree(n.height, []);
-    children.forEach((child, i) => {
-      const childWT = wrappedTreeFromNode(child);
-      t.children.push(childWT);
-      if (i === 0) {
-        // t.leftChild = childWT.leftChild ? childWT.leftChild : childWT
-        t.leftChild = childWT;
-      }
-      if (i === (childrenCount - 1)) {
-        // t.rightChild = childWT.rightChild ? childWT.rightChild : childWT
-        t.rightChild = childWT;
-      }
-    });
-    t.originNode = n;
-    t.isLeaf = n.isLeaf();
-    return t;
-  }
-
-  function getDrawingDepth(t) {
-    if (t.isLeaf || t.children.length === 0) {
-      t.drawingDepth = maxDepth;
-    } else {
-      const depths = t.children.map(child => getDrawingDepth(child));
-      const minChildDepth = Math.min.apply(null, depths);
-      t.drawingDepth = minChildDepth - 1;
-    }
-    return t.drawingDepth;
-  }
-
-  let prevLeaf;
-
-  function position(t) {
-    t.x = t.drawingDepth * options.rankSep;
-    if (t.isLeaf) {
-      t.y = 0;
-      if (prevLeaf) {
-        t.y = prevLeaf.y + prevLeaf.height + options.nodeSep;
-        if (t.originNode.parent !== prevLeaf.originNode.parent) {
-          t.y += options.subTreeSep;
-        }
-      }
-      prevLeaf = t;
-    } else {
-      t.children.forEach(child => {
-        position(child);
-      });
-      t.y = (t.leftChild.y + t.rightChild.y) / 2;
-    }
-  }
-
-  // wrap node
-  const wt = wrappedTreeFromNode(root);
-  // get depth for drawing
-  getDrawingDepth(wt);
-  // get position
-  position(wt);
-  // get x, y
-  convertBack(wt, root, options.isHorizontal);
-  return root;
-};

package/src/layout/do-layout.js

@@ -1,106 +0,0 @@
-const separateTree = require('./separate-root');
-const VALID_DIRECTIONS = [
-  'LR', // left to right
-  'RL', // right to left
-  'TB', // top to bottom
-  'BT', // bottom to top
-  'H', // horizontal
-  'V' // vertical
-];
-const HORIZONTAL_DIRECTIONS = [
-  'LR',
-  'RL',
-  'H'
-];
-const isHorizontal = direction => HORIZONTAL_DIRECTIONS.indexOf(direction) > -1;
-const DEFAULT_DIRECTION = VALID_DIRECTIONS[0];
-
-module.exports = (root, options, layoutAlgrithm) => {
-  const direction = options.direction || DEFAULT_DIRECTION;
-  options.isHorizontal = isHorizontal(direction);
-  if (direction && VALID_DIRECTIONS.indexOf(direction) === -1) {
-    throw new TypeError(`Invalid direction: ${direction}`);
-  }
-
-  if (direction === VALID_DIRECTIONS[0]) {
-    // LR
-    layoutAlgrithm(root, options);
-  } else if (direction === VALID_DIRECTIONS[1]) {
-    // RL
-    layoutAlgrithm(root, options);
-    root.right2left();
-  } else if (direction === VALID_DIRECTIONS[2]) {
-    // TB
-    layoutAlgrithm(root, options);
-  } else if (direction === VALID_DIRECTIONS[3]) {
-    // BT
-    layoutAlgrithm(root, options);
-    root.bottom2top();
-  } else if (direction === VALID_DIRECTIONS[4] || direction === VALID_DIRECTIONS[5]) {
-    // H or V
-    // separate into left and right trees
-    const { left, right } = separateTree(root, options);
-    // do layout for left and right trees
-    layoutAlgrithm(left, options);
-    layoutAlgrithm(right, options);
-    options.isHorizontal ? (left.right2left()) : (left.bottom2top());
-    // combine left and right trees
-    right.translate(left.x - right.x, left.y - right.y);
-    // translate root
-    root.x = left.x;
-    root.y = right.y;
-    const bb = root.getBoundingBox();
-    if (options.isHorizontal) {
-      if (bb.top < 0) {
-        root.translate(0, -bb.top);
-      }
-    } else {
-      if (bb.left < 0) {
-        root.translate(-bb.left, 0);
-      }
-    }
-  }
-  // fixed root position, default value is true
-  let fixedRoot = options.fixedRoot;
-  if (fixedRoot === undefined) fixedRoot = true;
-  if (fixedRoot) {
-    root.translate(-(root.x + root.width / 2 + root.hgap), -(root.y + root.height / 2 + root.vgap));
-  }
-
-  reassignXYIfRadial(root, options);
-
-  return root;
-};
-
-
-function reassignXYIfRadial(root, options) {
-  if (options.radial) {
-    const [ rScale, radScale ] = options.isHorizontal ? [ "x", "y" ] : [ "y", "x" ];
-
-    const min = { x: Infinity, y: Infinity };
-    const max = { x: -Infinity, y: -Infinity };
-
-    let count = 0;
-    root.DFTraverse((node) => {
-      count++;
-      const { x, y } = node;
-      min.x = Math.min(min.x, x);
-      min.y = Math.min(min.y, y);
-      max.x = Math.max(max.x, x);
-      max.y = Math.max(max.y, y);
-    });
-
-    const radDiff = max[radScale] - min[radScale];
-    if (radDiff === 0) return;
-
-    const avgRad = (Math.PI * 2) / count;
-    root.DFTraverse((node) => {
-      const rad =
-        ((node[radScale] - min[radScale]) / radDiff) * (Math.PI * 2 - avgRad) +
-        avgRad;
-      const r = node[rScale] - root[rScale];
-      node.x = Math.cos(rad) * r;
-      node.y = Math.sin(rad) * r;
-    });
-  }
-}

package/src/layout/hierarchy.js

@@ -1,187 +0,0 @@
-/* eslint-disable no-cond-assign */
-const util = require('../util');
-
-const PEM = 18;
-const DEFAULT_HEIGHT = PEM * 2;
-const DEFAULT_GAP = PEM;
-
-const DEFAULT_OPTIONS = {
-  getId(d) {
-    return d.id || d.name;
-  },
-  getPreH(d) {
-    return d.preH || 0;
-  },
-  getPreV(d) {
-    return d.preV || 0;
-  },
-  getHGap(d) {
-    return d.hgap || DEFAULT_GAP;
-  },
-  getVGap(d) {
-    return d.vgap || DEFAULT_GAP;
-  },
-  getChildren(d) {
-    return d.children;
-  },
-  getHeight(d) {
-    return d.height || DEFAULT_HEIGHT;
-  },
-  getWidth(d) {
-    const label = d.label || ' ';
-    return d.width || (label.split('').length * PEM); // FIXME DO NOT get width like this
-  }
-};
-
-function Node(data, options) {
-  const me = this;
-  me.vgap = me.hgap = 0;
-  if (data instanceof Node) return data;
-  me.data = data;
-  /*
-   * Gaps: filling space between nodes
-   * (x, y) ----------------------
-   * |            vgap            |
-   * |    --------------------    h
-   * | h |                    |   e
-   * | g |                    |   i
-   * | a |                    |   g
-   * | p |                    |   h
-   * |   ---------------------    t
-   * |                            |
-   *  -----------width------------
-   */
-  const hgap = options.getHGap(data);
-  const vgap = options.getVGap(data);
-  me.preH = options.getPreH(data);
-  me.preV = options.getPreV(data);
-  me.width = options.getWidth(data);
-  me.height = options.getHeight(data);
-  me.width += me.preH;
-  me.height += me.preV;
-  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() {
-    return (this.depth === 0);
-  },
-
-  isLeaf() {
-    return (this.children.length === 0);
-  },
-
-  addGap(hgap, vgap) {
-    const me = this;
-    me.hgap += hgap;
-    me.vgap += vgap;
-    me.width += 2 * hgap;
-    me.height += 2 * vgap;
-  },
-
-  eachNode(callback) { // Depth First traverse
-    const me = this;
-    let nodes = [ me ];
-    let current;
-    while (current = nodes.shift()) {
-      callback(current);
-      nodes = current.children.concat(nodes);
-    }
-  },
-
-  DFTraverse(callback) { // Depth First traverse
-    this.eachNode(callback);
-  },
-
-  BFTraverse(callback) { // Breadth First traverse
-    const me = this;
-    let nodes = [ me ];
-    let current;
-    while (current = nodes.shift()) {
-      callback(current);
-      nodes = nodes.concat(current.children);
-    }
-  },
-
-  getBoundingBox() {
-    // BBox for just one tree node
-    const bb = {
-      left: Number.MAX_VALUE,
-      top: Number.MAX_VALUE,
-      width: 0,
-      height: 0
-    };
-    this.eachNode(node => {
-      bb.left = Math.min(bb.left, node.x);
-      bb.top = Math.min(bb.top, node.y);
-      bb.width = Math.max(bb.width, node.x + node.width);
-      bb.height = Math.max(bb.height, node.y + node.height);
-    });
-    return bb;
-  },
-
-  // translate
-  translate(tx = 0, ty = 0) {
-    this.eachNode(node => {
-      node.x += tx;
-      node.y += ty;
-      node.x += node.preH;
-      node.y += node.preV;
-    });
-  },
-
-  right2left() {
-    const me = this;
-    const bb = me.getBoundingBox();
-    me.eachNode(node => {
-      node.x = node.x - (node.x - bb.left) * 2 - node.width;
-      // node.x = - node.x;
-    });
-    me.translate(bb.width, 0);
-  },
-
-  bottom2top() {
-    const me = this;
-    const bb = me.getBoundingBox();
-    me.eachNode(node => {
-      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) {
-  options = util.assign({}, DEFAULT_OPTIONS, options);
-  const root = new Node(data, options);
-  const nodes = [ root ];
-  let node;
-  if (!isolated && !data.collapsed) {
-    while (node = nodes.shift()) {
-      if (!node.data.collapsed) {
-        const children = options.getChildren(node.data);
-        const length = children ? children.length : 0;
-        node.children = new Array(length);
-        if (children && length) {
-          for (let i = 0; i < length; i++) {
-            const child = new Node(children[i], options);
-            node.children[i] = child;
-            nodes.push(child);
-            child.parent = node;
-            child.depth = node.depth + 1;
-          }
-        }
-      }
-    }
-  }
-  return root;
-}
-
-module.exports = hierarchy;

package/src/layout/indented.js

@@ -1,40 +0,0 @@
-const 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
-  const displacementX =
-    typeof indent === "function" ? indent(node) : indent * node.depth;
-
-  if (!dropCap) {
-    try {
-      if (node.id === node.parent.children[0].id) {
-        node.x += displacementX;
-        node.y = previousNode ? previousNode.y : 0;
-        return;
-      }
-    } catch (e) {
-      // skip to normal when a node has no parent
-    }
-  }
-
-  node.x += displacementX;
-  if (previousNode) {
-    node.y = previousNode.y + util.getHeight(previousNode, node, align);
-    if (previousNode.parent && node.parent.id !== previousNode.parent.id) {
-      // previous node has different parent
-      const prevParent = previousNode.parent;
-      const preY = prevParent.y + util.getHeight(prevParent, node, align);
-      node.y = preY > node.y ? preY : node.y;
-    }
-  } else {
-    node.y = 0;
-  }
-  return;
-}
-module.exports = (root, indent, dropCap, align) => {
-  let previousNode = null;
-  root.eachNode((node) => {
-    positionNode(node, previousNode, indent, dropCap, align);
-    previousNode = node;
-  });
-};

package/src/layout/mindmap.js

@@ -1,93 +0,0 @@
-const util = require('../util');
-
-function secondWalk(node, options) {
-  let totalHeight = 0;
-  if (!node.children.length) {
-    totalHeight = node.height;
-  } else {
-    node.children.forEach(c => {
-      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) {
-  const children = node.children;
-  const len = children.length;
-  if (len) {
-    children.forEach(c => {
-      thirdWalk(c);
-    });
-    const first = children[0];
-    const last = children[len - 1];
-    const childrenHeight = last.y - first.y + last.height;
-    let childrenTotalHeight = 0;
-    children.forEach(child => {
-      childrenTotalHeight += child.totalHeight;
-    });
-    if (childrenHeight > node.height) {
-      // 当子节点总高度大于父节点高度
-      node.y = first.y + childrenHeight / 2 - node.height / 2;
-    } else if (children.length !== 1 || node.height > childrenTotalHeight) {
-      // 多于一个子节点或者父节点大于所有子节点的总高度
-      const offset = node.y + (node.height - childrenHeight) / 2 - first.y;
-      children.forEach(c => {
-        c.translate(0, offset);
-      });
-    } else {
-      // 只有一个子节点
-      node.y = (first.y + first.height / 2 + last.y + last.height / 2) / 2 - node.height / 2;
-    }
-  }
-}
-
-const DEFAULT_OPTIONS = {
-  getSubTreeSep() {
-    return 0;
-  }
-};
-
-module.exports = (root, options = {}) => {
-  options = util.assign({}, DEFAULT_OPTIONS, options);
-  root.parent = {
-    x: 0,
-    width: 0,
-    height: 0,
-    y: 0
-  };
-  // first walk
-  root.BFTraverse(node => {
-    node.x = node.parent.x + node.parent.width; // simply get x
-  });
-  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(node => {
-    const children = node.children;
-    const len = children.length;
-    if (len) {
-      const 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 (let i = 1; i < len; i++) {
-          const c = children[i];
-          c.startY = children[i - 1].startY + children[i - 1].totalHeight;
-          c.y = c.startY + c.totalHeight / 2 - c.height / 2;
-        }
-      }
-    }
-  });
-
-  // third walk
-  thirdWalk(root);
-};