@opentiny/vue-renderless 3.1.0-alpha.0

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

@@ -0,0 +1,586 @@
+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') {
+    return dataData[config];
+  } else if (typeOf(config) === 'function') {
+    return config(dataData, node);
+  } else if (typeof config === 'undefined') {
+    var dataProp = dataData[prop];
+    return dataProp === undefined ? '' : 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;
+    if (checked !== true || indeterminate) {
+      all = false;
+      if (!disabled) {
+        allWithoutDisable = false;
+      }
+    }
+    if (checked !== false || indeterminate) {
+      none = false;
+    }
+  }
+  var half = !all && !none;
+  return {
+    all: all,
+    none: none,
+    allWithoutDisable: allWithoutDisable,
+    half: half
+  };
+};
+var reInitChecked = function reInitChecked(node) {
+  var childNodes = node.childNodes;
+  if (childNodes.length === 0) return;
+  var _getChildState = getChildState(childNodes),
+    all = _getChildState.all,
+    none = _getChildState.none,
+    half = _getChildState.half;
+  if (all) {
+    Object.assign(node, {
+      checked: true,
+      indeterminate: false
+    });
+  } else if (half) {
+    Object.assign(node, {
+      checked: false,
+      indeterminate: true
+    });
+  } else if (none) {
+    Object.assign(node, {
+      checked: false,
+      indeterminate: false
+    });
+  }
+  var 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);
+    this.init(options);
+    var store = this.store;
+    if (!store) {
+      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') {
+        this.isLeafByUser = isLeaf;
+      }
+    }
+    this.initExpandState();
+    if (!Array.isArray(this.data)) {
+      markNodeData(this, this.data);
+    }
+    if (!this.data) return;
+    this.expandByDefaultKeys();
+    var key = store.key,
+      lazy = store.lazy,
+      currentNodeKey = store.currentNodeKey;
+    if (key && currentNodeKey !== undefined && 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();
+      }
+    }
+  }, {
+    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;
+      }
+    }
+  }, {
+    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);
+      }
+    }
+  }, {
+    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
+        });
+      }
+    }
+  }, {
+    key: "key",
+    get: function get() {
+      var store = this.store,
+        data = this.data;
+      var nodeKey = store.key;
+      if (data) return data[nodeKey];
+      return null;
+    }
+  }, {
+    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;
+    }
+  }, {
+    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;
+    }
+  }, {
+    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
+            });
+          }
+        }
+        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;
+        }
+      }
+      this.insertChild(child, index);
+    }
+  }, {
+    key: "removeChild",
+    value: function removeChild(child) {
+      var children = this.getChildren() || [];
+      var 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();
+    }
+  }, {
+    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);
+    }
+  }, {
+    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;
+          }
+        }
+        _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);
+      });
+    }
+  }, {
+    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);
+      }
+    }
+  }, {
+    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;
+          }
+        }
+      };
+      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
+      };
+    }
+  }, {
+    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
+          });
+        }
+      });
+      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);
+      });
+      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);
+      }
+    }
+  }]);
+  return Node;
+}();
+export { Node as default };