@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/common/deps/tree-model/node.js

@@ -1,33 +1,29 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import { merge } from '@opentiny/vue-renderless/common/object';
-import { markNodeData, NODE_KEY } from '@opentiny/vue-renderless/common/deps/tree-model/util';
-import { indexOf } from '@opentiny/vue-renderless/common/array';
-import { hasOwn, typeOf } from '@opentiny/vue-renderless/common/type';
-import debounce from '@opentiny/vue-renderless/common/deps/debounce';
-var defaultChildrenKey = 'children';
-var getPropertyFromData = function getPropertyFromData(node, prop) {
-  var props = node.store.props;
-  var dataData = node.data || {};
-  var config = props[prop];
-  if (typeOf(config) === 'string') {
+import "../../../chunk-PKUHTIDK.js";
+import { merge } from "@opentiny/vue-renderless/common/object";
+import { markNodeData, NODE_KEY } from "@opentiny/vue-renderless/common/deps/tree-model/util";
+import { indexOf } from "@opentiny/vue-renderless/common/array";
+import { hasOwn, typeOf } from "@opentiny/vue-renderless/common/type";
+import debounce from "@opentiny/vue-renderless/common/deps/debounce";
+const defaultChildrenKey = "children";
+const getPropertyFromData = (node, prop) => {
+  const props = node.store.props;
+  const dataData = node.data || {};
+  const config = props[prop];
+  if (typeOf(config) === "string") {
     return dataData[config];
-  } else if (typeOf(config) === 'function') {
+  } else if (typeOf(config) === "function") {
     return config(dataData, node);
-  } else if (typeof config === 'undefined') {
-    var dataProp = dataData[prop];
-    return dataProp === undefined ? '' : dataProp;
+  } else if (typeof config === "undefined") {
+    const dataProp = dataData[prop];
+    return dataProp === void 0 ? "" : dataProp;
   }
 };
-export var getChildState = function getChildState(node) {
-  var all = true;
-  var none = true;
-  var allWithoutDisable = true;
-  for (var i = 0, len = node.length; i < len; i++) {
-    var _node$i = node[i],
-      checked = _node$i.checked,
-      disabled = _node$i.disabled,
-      indeterminate = _node$i.indeterminate;
+const getChildState = (node) => {
+  let all = true;
+  let none = true;
+  let allWithoutDisable = true;
+  for (let i = 0, len = node.length; i < len; i++) {
+    const { checked, disabled, indeterminate } = node[i];
     if (checked !== true || indeterminate) {
       all = false;
       if (!disabled) {
@@ -38,62 +34,42 @@ export var getChildState = function getChildState(node) {
       none = false;
     }
   }
-  var half = !all && !none;
-  return {
-    all: all,
-    none: none,
-    allWithoutDisable: allWithoutDisable,
-    half: half
-  };
+  const half = !all && !none;
+  return { all, none, allWithoutDisable, half };
 };
-var reInitChecked = function reInitChecked(node) {
-  var childNodes = node.childNodes;
+const reInitChecked = (node) => {
+  const childNodes = node.childNodes;
   if (childNodes.length === 0) {
     return;
   }
-  var _getChildState = getChildState(childNodes),
-    all = _getChildState.all,
-    none = _getChildState.none,
-    half = _getChildState.half;
+  const { all, none, half } = getChildState(childNodes);
   if (all) {
-    Object.assign(node, {
-      checked: true,
-      indeterminate: false
-    });
+    Object.assign(node, { checked: true, indeterminate: false });
   } else if (half) {
-    Object.assign(node, {
-      checked: false,
-      indeterminate: true
-    });
+    Object.assign(node, { checked: false, indeterminate: true });
   } else if (none) {
-    Object.assign(node, {
-      checked: false,
-      indeterminate: false
-    });
+    Object.assign(node, { checked: false, indeterminate: false });
   }
-  var parent = node.parent;
+  const parent = node.parent;
   if (!parent || parent.level === 0) {
     return;
   }
   !node.store.checkStrictly && reInitChecked(parent);
 };
-var nodeIdSeed = 0;
-var lazyInitChecked = debounce(0, function (node) {
-  return reInitChecked(node);
-});
-var Node = function () {
-  function Node(options) {
-    _classCallCheck(this, Node);
+let nodeIdSeed = 0;
+const lazyInitChecked = debounce(0, (node) => reInitChecked(node));
+class Node {
+  constructor(options) {
     this.init(options);
-    var store = this.store;
+    const store = this.store;
     if (!store) {
-      throw new Error('[TINY-Tree][Node]store is required!');
+      throw new Error("[TINY-Tree][Node]store is required!");
     }
     store.registerNode(this);
-    var props = store.props;
-    if (props && typeof props.isLeaf !== 'undefined') {
-      var isLeaf = getPropertyFromData(this, 'isLeaf');
-      if (typeof isLeaf === 'boolean') {
+    const props = store.props;
+    if (props && typeof props.isLeaf !== "undefined") {
+      const isLeaf = getPropertyFromData(this, "isLeaf");
+      if (typeof isLeaf === "boolean") {
         this.isLeafByUser = isLeaf;
       }
     }
@@ -105,502 +81,376 @@ var Node = function () {
       return;
     }
     this.expandByDefaultKeys();
-    var key = store.key,
-      lazy = store.lazy,
-      currentNodeKey = store.currentNodeKey;
-    if (key && currentNodeKey !== undefined && this.key === currentNodeKey) {
+    const { key, lazy, currentNodeKey } = store;
+    if (key && currentNodeKey !== void 0 && this.key === currentNodeKey) {
       store.currentNode = this;
       store.currentNode.isCurrent = true;
     }
     lazy && store._initDefaultCheckedNode(this);
     this.updateLeafState();
   }
-  _createClass(Node, [{
-    key: "initExpandState",
-    value: function initExpandState() {
-      var store = this.store,
-        data = this.data,
-        level = this.level;
-      if (store.lazy !== true && data) {
-        this.setData(data);
-        if (store.defaultExpandAll) {
-          this.expanded = true;
-        }
-      } else if (level > 0 && store.lazy && store.defaultExpandAll) {
-        this.expand();
+  initExpandState() {
+    const { store, data, level } = this;
+    if (store.lazy !== true && data) {
+      this.setData(data);
+      if (store.defaultExpandAll) {
+        this.expanded = true;
       }
+    } else if (level > 0 && store.lazy && store.defaultExpandAll) {
+      this.expand();
     }
-  }, {
-    key: "init",
-    value: function init(options) {
-      var _this = this;
-      this.id = nodeIdSeed++;
-      this.checked = false;
-      this.indeterminate = false;
-      this.expanded = false;
-      this.visible = true;
-      this.isCurrent = false;
-      this.text = null;
-      this.data = null;
-      this.parent = null;
-      Object.keys(options).forEach(function (key) {
-        if (hasOwn.call(options, key)) {
-          _this[key] = options[key];
-        }
-      });
-      this.isLeaf = !!(this.data && this.data.isLeaf);
-      this.loaded = false;
-      this.loading = false;
-      this.childNodes = [];
-      this.level = 0;
-      if (this.parent) {
-        this.level = this.parent.level + 1;
+  }
+  init(options) {
+    this.id = nodeIdSeed++;
+    this.checked = false;
+    this.indeterminate = false;
+    this.expanded = false;
+    this.visible = true;
+    this.isCurrent = false;
+    this.text = null;
+    this.data = null;
+    this.parent = null;
+    Object.keys(options).forEach((key) => {
+      if (hasOwn.call(options, key)) {
+        this[key] = options[key];
       }
+    });
+    this.isLeaf = !!(this.data && this.data.isLeaf);
+    this.loaded = false;
+    this.loading = false;
+    this.childNodes = [];
+    this.level = 0;
+    if (this.parent) {
+      this.level = this.parent.level + 1;
     }
-  }, {
-    key: "expandByDefaultKeys",
-    value: function expandByDefaultKeys() {
-      var _this$store = this.store,
-        defaultExpandedKeys = _this$store.defaultExpandedKeys,
-        key = _this$store.key,
-        autoExpandParent = _this$store.autoExpandParent;
-      if (key && defaultExpandedKeys && ~defaultExpandedKeys.indexOf(this.key)) {
-        this.expand(null, autoExpandParent);
-      }
+  }
+  expandByDefaultKeys() {
+    const { defaultExpandedKeys, key, autoExpandParent } = this.store;
+    if (key && defaultExpandedKeys && ~defaultExpandedKeys.indexOf(this.key)) {
+      this.expand(null, autoExpandParent);
     }
-  }, {
-    key: "setData",
-    value: function setData(data) {
-      if (!Array.isArray(data)) {
-        markNodeData(this, data);
-      }
-      this.data = data;
-      this.childNodes = [];
-      var children;
-      if (this.level === 0 && this.data instanceof Array) {
-        children = this.data;
-      } else {
-        children = getPropertyFromData(this, defaultChildrenKey) || [];
-      }
-      for (var i = 0, len = children.length; i < len; i++) {
-        var _data = children[i];
-        this.insertChild({
-          data: _data
-        });
-      }
+  }
+  setData(data) {
+    if (!Array.isArray(data)) {
+      markNodeData(this, data);
+    }
+    this.data = data;
+    this.childNodes = [];
+    let children;
+    if (this.level === 0 && Array.isArray(this.data)) {
+      children = this.data;
+    } else {
+      children = getPropertyFromData(this, defaultChildrenKey) || [];
+    }
+    for (let i = 0, len = children.length; i < len; i++) {
+      const data2 = children[i];
+      this.insertChild({ data: data2 });
     }
-  }, {
-    key: "key",
-    get: function get() {
-      var store = this.store,
-        data = this.data;
-      var nodeKey = store.key;
-      if (data) {
-        return data[nodeKey];
-      }
-      return null;
+  }
+  get key() {
+    const { store, data } = this;
+    const nodeKey = store.key;
+    if (data) {
+      return data[nodeKey];
     }
-  }, {
-    key: "label",
-    get: function get() {
-      return getPropertyFromData(this, 'label');
-    }
-  }, {
-    key: "disabled",
-    get: function get() {
-      return getPropertyFromData(this, 'disabled');
-    }
-  }, {
-    key: "nextSibling",
-    get: function get() {
-      var parent = this.parent;
-      if (parent) {
-        var childNodes = parent.childNodes;
-        var index = childNodes.indexOf(this);
-        if (~index) {
-          return childNodes[index + 1];
-        }
+    return null;
+  }
+  get label() {
+    return getPropertyFromData(this, "label");
+  }
+  get disabled() {
+    return getPropertyFromData(this, "disabled");
+  }
+  get nextSibling() {
+    const parent = this.parent;
+    if (parent) {
+      const childNodes = parent.childNodes;
+      const index = childNodes.indexOf(this);
+      if (~index) {
+        return childNodes[index + 1];
       }
-      return null;
     }
-  }, {
-    key: "previousSibling",
-    get: function get() {
-      var parent = this.parent;
-      if (parent) {
-        var childNodes = parent.childNodes;
-        var index = childNodes.indexOf(this);
-        if (~index) {
-          return index > 0 ? childNodes[index - 1] : null;
-        }
+    return null;
+  }
+  get previousSibling() {
+    const parent = this.parent;
+    if (parent) {
+      const childNodes = parent.childNodes;
+      const index = childNodes.indexOf(this);
+      if (~index) {
+        return index > 0 ? childNodes[index - 1] : null;
       }
-      return null;
     }
-  }, {
-    key: "remove",
-    value: function remove() {
-      var parent = this.parent;
-      parent && parent.removeChild(this);
-    }
-  }, {
-    key: "contains",
-    value: function contains(target) {
-      var deep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var walkTree = function walkTree(parent) {
-        var children = parent.childNodes || [];
-        var isContain = false;
-        for (var i = 0, len = children.length; i < len; i++) {
-          var child = children[i];
-          if (child === target || deep && walkTree(child)) {
-            isContain = true;
-            break;
-          }
-        }
-        return isContain;
-      };
-      return walkTree(this);
-    }
-  }, {
-    key: "insertChild",
-    value: function insertChild(child, index, batch) {
-      if (!child) {
-        throw new Error('[TINY-Tree] insertChild error: child is required.');
-      }
-      var insertNode = function insertNode(_ref) {
-        var arr = _ref.arr,
-          index = _ref.index,
-          item = _ref.item;
-        if (typeof index === 'undefined' || index < 0) {
-          arr.push(item);
-        } else {
-          arr.splice(index, 0, item);
-        }
-      };
-      if (!(child instanceof Node)) {
-        if (!batch) {
-          var children = this.getChildren(true);
-          if (!~children.indexOf(child.data)) {
-            insertNode({
-              arr: children,
-              index: index,
-              item: child.data
-            });
-          }
+    return null;
+  }
+  remove() {
+    const parent = this.parent;
+    parent && parent.removeChild(this);
+  }
+  contains(target, deep = true) {
+    const walkTree = (parent) => {
+      const children = parent.childNodes || [];
+      let isContain = false;
+      for (let i = 0, len = children.length; i < len; i++) {
+        const child = children[i];
+        if (child === target || deep && walkTree(child)) {
+          isContain = true;
+          break;
         }
-        merge(child, {
-          parent: this,
-          store: this.store
-        });
-        child = new Node(child);
       }
-      child.level = this.level + 1;
-      insertNode({
-        arr: this.childNodes,
-        index: index,
-        item: child
-      });
-      this.updateLeafState();
-    }
-  }, {
-    key: "insertBefore",
-    value: function insertBefore(child, beforeNode) {
-      var index;
-      if (beforeNode) {
-        index = this.childNodes.indexOf(beforeNode);
-      }
-      this.insertChild(child, index);
-    }
-  }, {
-    key: "insertAfter",
-    value: function insertAfter(child, afterNode) {
-      var index;
-      if (afterNode) {
-        index = this.childNodes.indexOf(afterNode);
-        if (~index) {
-          index += 1;
+      return isContain;
+    };
+    return walkTree(this);
+  }
+  insertChild(child, index, batch) {
+    if (!child) {
+      throw new Error("[TINY-Tree] insertChild error: child is required.");
+    }
+    const insertNode = ({ arr, index: index2, item }) => {
+      if (typeof index2 === "undefined" || index2 < 0) {
+        arr.push(item);
+      } else {
+        arr.splice(index2, 0, item);
+      }
+    };
+    if (!(child instanceof Node)) {
+      if (!batch) {
+        const children = this.getChildren(true);
+        if (!~children.indexOf(child.data)) {
+          insertNode({ arr: children, index, item: child.data });
         }
       }
-      this.insertChild(child, index);
+      merge(child, { parent: this, store: this.store });
+      child = new Node(child);
+    }
+    child.level = this.level + 1;
+    insertNode({ arr: this.childNodes, index, item: child });
+    this.updateLeafState();
+  }
+  insertBefore(child, beforeNode) {
+    let index;
+    if (beforeNode) {
+      index = this.childNodes.indexOf(beforeNode);
     }
-  }, {
-    key: "removeChild",
-    value: function removeChild(child) {
-      var children = this.getChildren() || [];
-      var index = children.indexOf(child.data);
+    this.insertChild(child, index);
+  }
+  insertAfter(child, afterNode) {
+    let index;
+    if (afterNode) {
+      index = this.childNodes.indexOf(afterNode);
       if (~index) {
-        children.splice(index, 1);
+        index += 1;
       }
-      index = this.childNodes.indexOf(child);
-      if (~index) {
-        this.store && this.store.deregisterNode(child);
-        child.parent = null;
-        this.childNodes.splice(index, 1);
+    }
+    this.insertChild(child, index);
+  }
+  removeChild(child) {
+    const children = this.getChildren() || [];
+    let index = children.indexOf(child.data);
+    if (~index) {
+      children.splice(index, 1);
+    }
+    index = this.childNodes.indexOf(child);
+    if (~index) {
+      this.store && this.store.deregisterNode(child);
+      child.parent = null;
+      this.childNodes.splice(index, 1);
+    }
+    this.updateLeafState();
+  }
+  removeChildByData(data) {
+    let removeNode = null;
+    for (let i = 0, len = this.childNodes.length; i < len; i++) {
+      const child = this.childNodes[i];
+      if (child.data === data) {
+        removeNode = child;
+        break;
       }
-      this.updateLeafState();
-    }
-  }, {
-    key: "removeChildByData",
-    value: function removeChildByData(data) {
-      var removeNode = null;
-      for (var i = 0, len = this.childNodes.length; i < len; i++) {
-        var child = this.childNodes[i];
-        if (child.data === data) {
-          removeNode = child;
-          break;
+    }
+    removeNode && this.removeChild(removeNode);
+  }
+  expand(callback, expandParent) {
+    const expandNodes = () => {
+      if (expandParent) {
+        let parentNode = this.parent;
+        while (parentNode.level > 0) {
+          parentNode.expanded = true;
+          parentNode = parentNode.parent;
         }
       }
-      removeNode && this.removeChild(removeNode);
-    }
-  }, {
-    key: "expand",
-    value: function expand(callback, expandParent) {
-      var _this2 = this;
-      var expandNodes = function expandNodes() {
-        if (expandParent) {
-          var parentNode = _this2.parent;
-          while (parentNode.level > 0) {
-            parentNode.expanded = true;
-            parentNode = parentNode.parent;
+      this.expanded = true;
+      callback && callback();
+    };
+    if (this.shouldLoadData()) {
+      this.loadData((data) => {
+        if (Array.isArray(data)) {
+          if (this.checked) {
+            this.setChecked(true, true);
+          } else if (!this.store.checkStrictly) {
+            reInitChecked(this);
           }
+          expandNodes();
         }
-        _this2.expanded = true;
-        callback && callback();
-      };
-      if (this.shouldLoadData()) {
-        this.loadData(function (data) {
-          if (Array.isArray(data)) {
-            if (_this2.checked) {
-              _this2.setChecked(true, true);
-            } else if (!_this2.store.checkStrictly) {
-              reInitChecked(_this2);
-            }
-            expandNodes();
-          }
-        });
-      } else {
-        expandNodes();
-      }
-    }
-  }, {
-    key: "doCreateChildren",
-    value: function doCreateChildren(array) {
-      var _this3 = this;
-      var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      array.forEach(function (data) {
-        _this3.insertChild(merge({
-          data: data
-        }, defaultProps), undefined, true);
       });
+    } else {
+      expandNodes();
     }
-  }, {
-    key: "collapse",
-    value: function collapse() {
-      this.expanded = false;
-    }
-  }, {
-    key: "shouldLoadData",
-    value: function shouldLoadData() {
-      return this.store.lazy === true && this.store.load && !this.loaded;
-    }
-  }, {
-    key: "updateLeafState",
-    value: function updateLeafState() {
-      var store = this.store,
-        loaded = this.loaded,
-        isLeafByUser = this.isLeafByUser;
-      var lazy = store.lazy;
-      if (lazy === true && loaded !== true && typeof isLeafByUser !== 'undefined') {
-        this.isLeaf = isLeafByUser;
-        return;
-      }
-      var childs = this.childNodes;
-      if (!lazy || lazy === true && loaded === true) {
-        this.isLeaf = !childs || childs.length === 0;
-        return;
-      }
-      this.isLeaf = false;
-    }
-  }, {
-    key: "getChildren",
-    value: function getChildren() {
-      var forceInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var level = this.level,
-        data = this.data;
-      if (level === 0) {
-        return data;
-      }
-      if (!data) {
-        return null;
-      }
-      var props = this.store.props;
-      var childrenKey = defaultChildrenKey;
-      if (props) {
-        childrenKey = props.children || defaultChildrenKey;
-      }
-      if (data[childrenKey] === undefined) {
-        data[childrenKey] = null;
-      }
-      if (forceInit && !data[childrenKey]) {
-        data[childrenKey] = [];
-      }
-      return data[childrenKey];
-    }
-  }, {
-    key: "setChecked",
-    value: function setChecked(value, isDeepChecked, recursion, passValue) {
-      this.checked = value === true;
-      this.indeterminate = value === 'half';
-      var _this$store2 = this.store,
-        checkStrictly = _this$store2.checkStrictly,
-        checkDescendants = _this$store2.checkDescendants;
-      if (checkStrictly) {
-        return;
-      }
-      var ret = this.setCheckedInner({
-        checkDescendants: checkDescendants,
-        value: value,
-        isDeepChecked: isDeepChecked,
-        passValue: passValue
-      });
-      var returnFlag = ret.returnFlag;
-      passValue = ret.passValue;
-      value = ret.value;
-      if (returnFlag) {
-        return;
-      }
-      var parentNode = this.parent;
-      if (!parentNode || parentNode.level === 0) {
-        return;
-      }
-      if (!recursion) {
-        this.store.lazy ? lazyInitChecked(parentNode) : reInitChecked(parentNode);
-      }
+  }
+  doCreateChildren(array, defaultProps = {}) {
+    array.forEach((data) => {
+      this.insertChild(merge({ data }, defaultProps), void 0, true);
+    });
+  }
+  collapse() {
+    this.expanded = false;
+  }
+  shouldLoadData() {
+    return this.store.lazy === true && this.store.load && !this.loaded;
+  }
+  updateLeafState() {
+    const { store, loaded, isLeafByUser } = this;
+    const lazy = store.lazy;
+    if (lazy === true && loaded !== true && typeof isLeafByUser !== "undefined") {
+      this.isLeaf = isLeafByUser;
+      return;
     }
-  }, {
-    key: "setCheckedInner",
-    value: function setCheckedInner(_ref2) {
-      var _this4 = this;
-      var checkDescendants = _ref2.checkDescendants,
-        value = _ref2.value,
-        isDeepChecked = _ref2.isDeepChecked,
-        passValue = _ref2.passValue;
-      var returnFlag = false;
-      if (this.shouldLoadData() && !checkDescendants) {
-        return {
-          value: value,
-          passValue: passValue,
-          returnFlag: returnFlag
-        };
-      }
-      var _getChildState2 = getChildState(this.childNodes),
-        all = _getChildState2.all,
-        allWithoutDisable = _getChildState2.allWithoutDisable;
-      if (!this.isLeaf && !all && allWithoutDisable) {
-        this.checked = false;
-        value = false;
-      }
-      var batchSetChecked = function batchSetChecked() {
-        if (isDeepChecked) {
-          var childNodes = _this4.childNodes;
-          for (var i = 0, len = childNodes.length; i < len; i++) {
-            var childNode = childNodes[i];
-            passValue = passValue || value !== false;
-            var isCheck = childNode.disabled ? childNode.checked : passValue;
-            childNode.setChecked(isCheck, isDeepChecked, true, passValue);
-          }
-          var _getChildState3 = getChildState(childNodes),
-            half = _getChildState3.half,
-            _all = _getChildState3.all;
-          if (!_all) {
-            _this4.checked = _all;
-            _this4.indeterminate = half;
-          }
+    const childs = this.childNodes;
+    if (!lazy || lazy === true && loaded === true) {
+      this.isLeaf = !childs || childs.length === 0;
+      return;
+    }
+    this.isLeaf = false;
+  }
+  getChildren(forceInit = false) {
+    const { level, data } = this;
+    if (level === 0) {
+      return data;
+    }
+    if (!data) {
+      return null;
+    }
+    const props = this.store.props;
+    let childrenKey = defaultChildrenKey;
+    if (props) {
+      childrenKey = props.children || defaultChildrenKey;
+    }
+    if (data[childrenKey] === void 0) {
+      data[childrenKey] = null;
+    }
+    if (forceInit && !data[childrenKey]) {
+      data[childrenKey] = [];
+    }
+    return data[childrenKey];
+  }
+  setChecked(value, isDeepChecked, recursion, passValue) {
+    this.checked = value === true;
+    this.indeterminate = value === "half";
+    const { checkStrictly, checkDescendants } = this.store;
+    if (checkStrictly) {
+      return;
+    }
+    let ret = this.setCheckedInner({
+      checkDescendants,
+      value,
+      isDeepChecked,
+      passValue
+    });
+    let returnFlag = ret.returnFlag;
+    passValue = ret.passValue;
+    value = ret.value;
+    if (returnFlag) {
+      return;
+    }
+    const parentNode = this.parent;
+    if (!parentNode || parentNode.level === 0) {
+      return;
+    }
+    if (!recursion) {
+      this.store.lazy ? lazyInitChecked(parentNode) : reInitChecked(parentNode);
+    }
+  }
+  setCheckedInner({ checkDescendants, value, isDeepChecked, passValue }) {
+    let returnFlag = false;
+    if (this.shouldLoadData() && !checkDescendants) {
+      return { value, passValue, returnFlag };
+    }
+    const { all, allWithoutDisable } = getChildState(this.childNodes);
+    if (!this.isLeaf && !all && allWithoutDisable) {
+      this.checked = false;
+      value = false;
+    }
+    const batchSetChecked = () => {
+      if (isDeepChecked) {
+        const childNodes = this.childNodes;
+        for (let i = 0, len = childNodes.length; i < len; i++) {
+          const childNode = childNodes[i];
+          passValue = passValue || value !== false;
+          const isCheck = childNode.disabled ? childNode.checked : passValue;
+          childNode.setChecked(isCheck, isDeepChecked, true, passValue);
+        }
+        const { half, all: all2 } = getChildState(childNodes);
+        if (!all2) {
+          this.checked = all2;
+          this.indeterminate = half;
         }
-      };
-      if (this.shouldLoadData()) {
-        var afterLoad = function afterLoad() {
-          batchSetChecked();
-          reInitChecked(_this4);
-        };
-        this.loadData(afterLoad, {
-          checked: value !== false
-        });
-        returnFlag = true;
-      } else {
-        batchSetChecked();
       }
-      return {
-        value: value,
-        passValue: passValue,
-        returnFlag: returnFlag
+    };
+    if (this.shouldLoadData()) {
+      const afterLoad = () => {
+        batchSetChecked();
+        reInitChecked(this);
       };
+      this.loadData(afterLoad, { checked: value !== false });
+      returnFlag = true;
+    } else {
+      batchSetChecked();
     }
-  }, {
-    key: "updateChildren",
-    value: function updateChildren() {
-      var _this5 = this;
-      var children = this.getChildren() || [];
-      var oldChildren = this.childNodes.map(function (child) {
-        return child.data;
-      });
-      var newChildrenMap = {};
-      var newChildren = [];
-      children.forEach(function (item, index) {
-        var key = item[NODE_KEY];
-        var isNodeExists = !!key && indexOf(oldChildren, key, function (item, data) {
-          return item[NODE_KEY] === data;
-        }) >= 0;
-        if (isNodeExists) {
-          newChildrenMap[key] = {
-            index: index,
-            data: item
-          };
-        } else {
-          newChildren.push({
-            index: index,
-            data: item
-          });
+    return { value, passValue, returnFlag };
+  }
+  updateChildren() {
+    const children = this.getChildren() || [];
+    const oldChildren = this.childNodes.map((child) => child.data);
+    const newChildrenMap = {};
+    const newChildren = [];
+    children.forEach((item, index) => {
+      const key = item[NODE_KEY];
+      const isNodeExists = !!key && indexOf(oldChildren, key, (item2, data) => item2[NODE_KEY] === data) >= 0;
+      if (isNodeExists) {
+        newChildrenMap[key] = { index, data: item };
+      } else {
+        newChildren.push({ index, data: item });
+      }
+    });
+    if (!this.store.lazy) {
+      oldChildren.forEach((item) => {
+        if (!newChildrenMap[item[NODE_KEY]]) {
+          this.removeChildByData(item);
         }
       });
-      if (!this.store.lazy) {
-        oldChildren.forEach(function (item) {
-          if (!newChildrenMap[item[NODE_KEY]]) {
-            _this5.removeChildByData(item);
-          }
-        });
-      }
-      newChildren.forEach(function (_ref3) {
-        var data = _ref3.data,
-          index = _ref3.index;
-        _this5.insertChild({
-          data: data
-        }, index);
+    }
+    newChildren.forEach(({ data, index }) => {
+      this.insertChild({ data }, index);
+    });
+    this.updateLeafState();
+  }
+  loadData(callback, defaultProps = {}) {
+    const { lazy, load } = this.store;
+    if (lazy === true && load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
+      this.loading = true;
+      this.store.load(this, (children) => {
+        this.loading = false;
+        this.loaded = true;
+        this.childNodes = [];
+        this.doCreateChildren(children, defaultProps);
+        this.updateLeafState();
+        callback && callback.call(this, children);
       });
-      this.updateLeafState();
-    }
-  }, {
-    key: "loadData",
-    value: function loadData(callback) {
-      var _this6 = this;
-      var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var _this$store3 = this.store,
-        lazy = _this$store3.lazy,
-        load = _this$store3.load;
-      if (lazy === true && load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
-        this.loading = true;
-        this.store.load(this, function (children) {
-          _this6.loading = false;
-          _this6.loaded = true;
-          _this6.childNodes = [];
-          _this6.doCreateChildren(children, defaultProps);
-          _this6.updateLeafState();
-          callback && callback.call(_this6, children);
-        });
-      } else {
-        callback && callback.call(this);
-      }
+    } else {
+      callback && callback.call(this);
     }
-  }]);
-  return Node;
-}();
-export { Node as default };
+  }
+}
+export {
+  Node as default,
+  getChildState
+};