@mdsfe/mds-ui/dist/_util/tree/tree.js

A set of enterprise-class Vue UI components.

'use strict';

exports.__esModule = true;

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _map = require('babel-runtime/core-js/map');

var _map2 = _interopRequireDefault(_map);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _node = require('./node');

var _node2 = _interopRequireDefault(_node);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Tree = function () {
  function Tree(options) {
    var _this = this;

    (0, _classCallCheck3.default)(this, Tree);

    for (var name in options) {
      if (options.hasOwnProperty(name)) {
        this[name] = options[name];
      }
    }
    if (!this.prop || (0, _typeof3.default)(this.prop) !== 'object') {
      this.prop = {
        label: 'label',
        key: 'key',
        isLeaf: 'isLeaf',
        disabled: 'disabled',
        children: 'children'
      };
    }

    this.nodesMap = new _map2.default();
    this.root = new _node2.default({
      data: this.data,
      tree: this
    });

    // 根据load函数渲染根节点
    if (this.load) {
      this.load(this.root, function (arr) {
        if (!Array.isArray(arr)) {
          throw new Error('传入子元素必须是数组');
        }
        arr.forEach(function (item) {
          _this.root.appendChild(item);
        });
      });
    }
  }

  Tree.prototype.setData = function setData(newVal) {
    var dataChange = newVal !== this.root.data;
    if (dataChange) {
      this.nodesMap = new _map2.default();
      this.root = new _node2.default({
        data: newVal,
        tree: this
      });
    }
  };

  Tree.prototype.handleSelectedChange = function handleSelectedChange(key) {
    var selectedNode = this.nodesMap.get(key);
    if (!selectedNode.selected) {
      this.nodesMap.forEach(function (node, nodeKey) {
        node.selected = false;
        if (nodeKey === key) {
          node.selected = true;
        }
      });
      this.$tree.$emit('node-selected-change', selectedNode.data, selectedNode, selectedNode.getPath(), selectedNode.getPath(true));
    }
  };

  Tree.prototype.handleDefaultCheckedKeys = function handleDefaultCheckedKeys() {
    var _this2 = this;

    // 处理defaultCheckedKeys
    if (this.defaultCheckedKeys) {
      this.defaultCheckedKeys.forEach(function (item) {
        _this2.nodesMap.get(item).check = true;
      });
    }
  };

  Tree.prototype.search = function search(value) {
    var _this3 = this;

    var recursionChildren = function recursionChildren(node) {
      var childNodes = node.root ? node.root.childNodes : node.childNodes;
      childNodes.forEach(function (item) {
        item.searchWords = null;
        item.visible = _this3.searchNodeMethod.call(item, value, item.data, item);
        if (item.visible) {
          item.searchWords = value;
        }
        recursionChildren(item);
      });

      // 子节点有匹配项的情况父节点需要显示
      if (!node.visible && childNodes.length) {
        var hiddenAllChildren = void 0;
        hiddenAllChildren = !childNodes.some(function (child) {
          return child.visible;
        });
        if (!node.root) {
          node.visible = !hiddenAllChildren;
        } else {
          node.root.visible = false;
        }
      }

      // 节点显示的情况下展开所有子节点
      if (node.visible && !node.isLeaf && !_this3.load && value) {
        node.changeExpanded(true);
      }
    };
    recursionChildren(this);
  };

  Tree.prototype.getCheckedNodes = function getCheckedNodes(leafOnly) {
    var result = [];
    if (leafOnly) {
      this.nodesMap.forEach(function (item) {
        if (item.checked && !item.data.children) {
          result.push(item.data);
        }
      });
    } else {
      this.nodesMap.forEach(function (item) {
        if (item.checked) {
          result.push(item.data);
        }
      });
    }
    return result;
  };

  Tree.prototype.getCheckedKeys = function getCheckedKeys(leafOnly) {
    var result = [];
    if (leafOnly) {
      this.nodesMap.forEach(function (item) {
        if (item.checked && !item.data.children) {
          result.push(item.key);
        }
      });
    } else {
      this.nodesMap.forEach(function (item) {
        if (item.checked) {
          result.push(item.key);
        }
      });
    }
    return result;
  };

  Tree.prototype.setCheckedKeys = function setCheckedKeys(checkArr) {
    var _this4 = this;

    if (!Array.isArray(checkArr)) {
      throw new Error('需要输入一个key数组');
    }
    var exec = function exec() {
      _this4.nodesMap.forEach(function (item) {
        item.check = false;
      });
      checkArr.forEach(function (item) {
        _this4.nodesMap.get(item).check = true;
      });
    };
    window.requestAnimationFrame(exec);
  };

  Tree.prototype.setChecked = function setChecked(key, checkState) {
    var _this5 = this;

    // 分{key, check}数组和单独传入key两种形式
    var is = function is(val, type) {
      var res = Object.prototype.toString.call(val);
      return res.includes(type);
    };

    var checkNode = function checkNode(_key, _checkState) {
      var node = _this5.nodesMap.get(_key);
      if (!node) {
        throw new Error('请输入正确的key');
      }
      node.check = _checkState;
    };

    if (is(key, 'String') && is(checkState, 'Boolean')) {
      checkNode(key, checkState);
      return;
    }
    if (is(key, 'Array') && !checkState) {
      var exec = function exec() {
        key.forEach(function (_ref) {
          var key = _ref.key,
              check = _ref.check;

          checkNode(key, check);
        });
      };
      window.requestAnimationFrame(exec);
    }
  };

  Tree.prototype.getHalfCheckedNodes = function getHalfCheckedNodes() {
    var result = [];
    this.nodesMap.forEach(function (item) {
      if (item.indeterminate) {
        result.push(item.data);
      }
    });
    return result;
  };

  Tree.prototype.getHalfCheckedKeys = function getHalfCheckedKeys() {
    var result = [];
    this.nodesMap.forEach(function (item) {
      if (item.indeterminate) {
        result.push(item.data.key);
      }
    });
    return result;
  };

  Tree.prototype.getCurrentKey = function getCurrentKey() {
    for (var _iterator = this.nodesMap.values(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
      var _ref2;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref2 = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref2 = _i.value;
      }

      var item = _ref2;

      if (item.selected) {
        return item.data.key;
      }
    }
    return null;
  };

  Tree.prototype.getCurrentNode = function getCurrentNode() {
    for (var _iterator2 = this.nodesMap.values(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
      var _ref3;

      if (_isArray2) {
        if (_i2 >= _iterator2.length) break;
        _ref3 = _iterator2[_i2++];
      } else {
        _i2 = _iterator2.next();
        if (_i2.done) break;
        _ref3 = _i2.value;
      }

      var item = _ref3;

      if (item.selected) {
        return item.data;
      }
    }
    return null;
  };

  Tree.prototype.setCurrentKey = function setCurrentKey(key) {
    if (key) {
      this.handleSelectedChange(key);
    } else {
      this.nodesMap.forEach(function (node) {
        node.selected = false;
      });
    }
  };

  Tree.prototype.getNode = function getNode(key) {
    var node = this.nodesMap.get(key);
    if (node) {
      return node;
    }
    return null;
  };

  Tree.prototype.getCheckNode = function getCheckNode(nodeFlag) {
    var arr = [];
    this.nodesMap.forEach(function (item) {
      if (item.checked) {
        nodeFlag ? arr.push(item) : arr.push(item.data);
      }
    });
    return arr;
  };

  Tree.prototype.getCheckNodeKey = function getCheckNodeKey() {
    var arr = [];
    this.getCheckNode(true).forEach(function (node) {
      arr.push(node.key);
    });
    return arr;
  };

  Tree.prototype.getIndeterminateNode = function getIndeterminateNode(nodeFlag) {
    var arr = [];
    this.nodesMap.forEach(function (item) {
      if (item.indeterminate) {
        nodeFlag ? arr.push(item) : arr.push(item.data);
      }
    });
    return arr;
  };

  Tree.prototype.getIndeterminateNodeKey = function getIndeterminateNodeKey() {
    var arr = [];
    this.getIndeterminateNode(true).forEach(function (node) {
      arr.push(node.key);
    });
    return arr;
  };

  Tree.prototype.setCheckNode = function setCheckNode(keys) {
    var bor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

    var nodesMap = this.nodesMap;

    if (Array.isArray(keys)) {
      keys.forEach(function (item) {
        var node = nodesMap.get(item);
        if (node) node.check = bor;
      });
    } else {
      var node = nodesMap.get(keys);
      if (node) nodesMap.get(keys).check = bor;
    }
  };

  Tree.prototype.getCheckNodeTree = function getCheckNodeTree() {
    var _this6 = this;

    var root = this.root;

    if (Array.isArray(root.data)) {
      var newTree = [];
      root.indeterminateChildNodes.forEach(function (item) {
        newTree.push(copyNode(item, _this6));
      });
      return newTree;
    } else {
      return copyNode(root, this);
    }
  };

  Tree.prototype.appendNodes = function appendNodes(key, nodes) {
    var parent = this.nodesMap.get(key);
    if (!parent) {
      return;
    }
    if (Array.isArray(nodes)) {
      if ((typeof nodes === 'undefined' ? 'undefined' : (0, _typeof3.default)(nodes)) === 'object') {
        nodes.forEach(function (item) {
          parent.appendChild(item);
        });
      }
    } else if ((typeof nodes === 'undefined' ? 'undefined' : (0, _typeof3.default)(nodes)) === 'object') {
      parent.appendChild(nodes);
    }
  };

  Tree.prototype.deleteNodeByKey = function deleteNodeByKey(keys) {
    var _this7 = this;

    if (Array.isArray(keys)) {
      keys.forEach(function (item) {
        var node = _this7.nodesMap.get(item);
        if (node) node.remove();
      });
    } else {
      var node = this.nodesMap.get(keys);
      node.remove();
    }
  };

  Tree.prototype.clearCheckNode = function clearCheckNode() {
    this.nodesMap.forEach(function (item) {
      item.checked = false;
      item.indeterminate = false;
    });
  };

  return Tree;
}();

exports.default = Tree;


var copyData = function copyData(data, tree) {
  var newData = {};
  for (var key in data) {
    if (data.hasOwnProperty(key) && key !== tree.prop.children) {
      newData[key] = data[key];
    }
  }
  return newData;
};
var copyNode = function copyNode(node, tree) {
  var newData = copyData(node.data, tree);
  if (node.isLeaf) {
    return newData;
  }
  newData[tree.prop.children] = [];
  node.indeterminateChildNodes.forEach(function (item) {
    newData[tree.prop.children].push(copyNode(item, tree));
  });
  return newData;
};

// const deepCopy = function(o) {
//   if (o instanceof Array) {
//     let n = []
//     for (let i = 0; i < o.length; ++i) {
//       n[i] = deepCopy(o[i])
//     }
//     return n
//   } else if (o instanceof Object) {
//     let n = {}
//     for (let i in o) {
//       n[i] = deepCopy(o[i])
//     }
//     return n
//   } else {
//     return o
//   }
// }