@qsxy/element-plus-react 1.0.1 → 1.0.3

package/dist/Tree/model/node.js

@@ -0,0 +1,601 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { NODE_KEY, markNodeData } from "./util";
+import isNil from 'lodash/isNil';
+import { isBoolean, isFunction, isString, isUndefined } from "../../Util";
+export var getChildState = function getChildState(node) {
+  var all = true;
+  var none = true;
+  var allWithoutDisable = true;
+  var isEffectivelyChecked = true;
+  for (var i = 0, j = node.length; i < j; i++) {
+    var n = node[i];
+    if (n.checked !== true || n.indeterminate) {
+      all = false;
+      if (!n.disabled) {
+        allWithoutDisable = false;
+      }
+    }
+    if (n.checked !== false || n.indeterminate) {
+      none = false;
+    }
+    if (!n.isEffectivelyChecked) {
+      isEffectivelyChecked = false;
+    }
+  }
+  return {
+    all: all,
+    none: none,
+    allWithoutDisable: allWithoutDisable,
+    half: !all && !none,
+    isEffectivelyChecked: isEffectivelyChecked
+  };
+};
+var _reInitChecked = function reInitChecked(node) {
+  if (node.childNodes.length === 0 || node.loading) {
+    node.isEffectivelyChecked = node.disabled || node.checked;
+    return;
+  }
+  var _getChildState = getChildState(node.childNodes),
+    all = _getChildState.all,
+    none = _getChildState.none,
+    half = _getChildState.half,
+    isEffectivelyChecked = _getChildState.isEffectivelyChecked;
+  node.isEffectivelyChecked = isEffectivelyChecked;
+  if (all) {
+    node.checked = true;
+    node.indeterminate = false;
+  } else if (half) {
+    node.checked = false;
+    node.indeterminate = true;
+  } else if (none) {
+    node.checked = false;
+    node.indeterminate = false;
+  }
+  var parent = node.parent;
+  if (!parent || parent.level === 0) {
+    return;
+  }
+  if (!node.store.checkStrictly) {
+    _reInitChecked(parent);
+  }
+};
+var getPropertyFromData = function getPropertyFromData(node, prop) {
+  var props = node.store.props;
+  var data = node.data || {};
+  var config = props[prop];
+  if (isFunction(config)) {
+    return config(data, node);
+  } else if (isString(config)) {
+    return data[config];
+  } else if (isUndefined(config)) {
+    var dataProp = data[prop];
+    return isUndefined(dataProp) ? '' : dataProp;
+  }
+};
+var setCanFocus = function setCanFocus(childNodes, focus) {
+  childNodes.forEach(function (item) {
+    item.canFocus = focus;
+    setCanFocus(item.childNodes, focus);
+  });
+};
+var nodeIdSeed = 0;
+var Node = /*#__PURE__*/function () {
+  function Node(options) {
+    _classCallCheck(this, Node);
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "text", void 0);
+    _defineProperty(this, "checked", void 0);
+    _defineProperty(this, "indeterminate", void 0);
+    _defineProperty(this, "data", void 0);
+    _defineProperty(this, "expanded", void 0);
+    _defineProperty(this, "parent", void 0);
+    _defineProperty(this, "visible", void 0);
+    _defineProperty(this, "isCurrent", void 0);
+    _defineProperty(this, "store", void 0);
+    _defineProperty(this, "isLeafByUser", undefined);
+    _defineProperty(this, "isLeaf", undefined);
+    _defineProperty(this, "canFocus", void 0);
+    _defineProperty(this, "level", void 0);
+    _defineProperty(this, "loaded", void 0);
+    _defineProperty(this, "childNodes", void 0);
+    _defineProperty(this, "loading", void 0);
+    /**
+     * Determines whether the current tree node is effectively checked.
+     *
+     * Rules:
+     * 1. A disabled leaf node is always considered checked.
+     * 2. A non-disabled leaf node reflects its actual checked state.
+     * 3. A non-leaf node is considered checked only when:
+     *    - All of its child nodes are effectively checked, and
+     *    - Each child follows the same evaluation rules:
+     *      - Disabled leaf nodes follow rule #1.
+     *      - Non-leaf child nodes are recursively evaluated under this rule (#3).
+     */
+    _defineProperty(this, "isEffectivelyChecked", false);
+    this.id = nodeIdSeed++;
+    this.text = null;
+    this.checked = false;
+    this.indeterminate = false;
+    this.data = null;
+    this.expanded = false;
+    this.parent = null;
+    this.visible = true;
+    this.isCurrent = false;
+    this.canFocus = false;
+    for (var name in options) {
+      if (Object.prototype.hasOwnProperty.call(options, name)) {
+        this[name] = options[name];
+      }
+    }
+
+    // internal
+    this.level = 0;
+    this.loaded = false;
+    this.childNodes = [];
+    this.loading = false;
+    if (this.parent) {
+      this.level = this.parent.level + 1;
+    }
+  }
+  _createClass(Node, [{
+    key: "initialize",
+    value: function initialize() {
+      var _this$parent;
+      var store = this.store;
+      if (!store) {
+        throw new Error('[Node]store is required!');
+      }
+      store.registerNode(this);
+      var props = store.props;
+      if (props && typeof props.isLeaf !== 'undefined') {
+        var isLeaf = getPropertyFromData(this, 'isLeaf');
+        if (isBoolean(isLeaf)) {
+          this.isLeafByUser = isLeaf;
+        }
+      }
+      if (store.lazy !== true && this.data) {
+        this.setData(this.data);
+        if (store.defaultExpandAll) {
+          this.expanded = true;
+          this.canFocus = true;
+        }
+      } else if (this.level > 0 && store.lazy && store.defaultExpandAll && !this.isLeafByUser) {
+        this.expand();
+      }
+      if (!Array.isArray(this.data)) {
+        markNodeData(this, this.data);
+      }
+      if (!this.data) {
+        return;
+      }
+      var defaultExpandedKeys = store.defaultExpandedKeys;
+      var key = store.key;
+      if (key && !isNil(this.key) && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
+        this.expand(null, store.autoExpandParent);
+      }
+      if (key && store.currentNodeKey !== undefined && this.key === store.currentNodeKey) {
+        store.currentNode && (store.currentNode.isCurrent = false);
+        store.currentNode = this;
+        store.currentNode.isCurrent = true;
+      }
+      if (store.lazy) {
+        store._initDefaultCheckedNode(this);
+      }
+      this.updateLeafState();
+      if (this.level === 1 || ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.expanded) === true) {
+        this.canFocus = true;
+      }
+    }
+  }, {
+    key: "setData",
+    value: function setData(data) {
+      if (!Array.isArray(data)) {
+        markNodeData(this, data);
+      }
+      this.data = data;
+      this.childNodes = [];
+      var children;
+      if (this.level === 0 && Array.isArray(this.data)) {
+        children = this.data;
+      } else {
+        children = getPropertyFromData(this, 'children') || [];
+      }
+      for (var i = 0, j = children.length; i < j; i++) {
+        this.insertChild({
+          data: children[i]
+        });
+      }
+    }
+  }, {
+    key: "label",
+    get: function get() {
+      return getPropertyFromData(this, 'label');
+    }
+  }, {
+    key: "key",
+    get: function get() {
+      var nodeKey = this.store.key;
+      if (this.data) {
+        return this.data[nodeKey];
+      }
+      return null;
+    }
+  }, {
+    key: "disabled",
+    get: function get() {
+      return getPropertyFromData(this, 'disabled');
+    }
+  }, {
+    key: "nextSibling",
+    get: function get() {
+      var parent = this.parent;
+      if (parent) {
+        var index = parent.childNodes.indexOf(this);
+        if (index > -1) {
+          return parent.childNodes[index + 1];
+        }
+      }
+      return null;
+    }
+  }, {
+    key: "previousSibling",
+    get: function get() {
+      var parent = this.parent;
+      if (parent) {
+        var index = parent.childNodes.indexOf(this);
+        if (index > -1) {
+          return index > 0 ? parent.childNodes[index - 1] : null;
+        }
+      }
+      return null;
+    }
+  }, {
+    key: "contains",
+    value: function contains(target) {
+      var deep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return (this.childNodes || []).some(function (child) {
+        return child === target || deep && child.contains(target);
+      });
+    }
+  }, {
+    key: "remove",
+    value: function remove() {
+      var parent = this.parent;
+      if (parent) {
+        parent.removeChild(this);
+      }
+    }
+  }, {
+    key: "insertChild",
+    value: function insertChild(child, index, batch) {
+      if (!child) {
+        throw new Error('InsertChild error: child is required.');
+      }
+      if (!(child instanceof Node)) {
+        if (!batch) {
+          var children = this.getChildren(true);
+          if (!(children !== null && children !== void 0 && children.includes(child.data))) {
+            if (isUndefined(index) || index < 0) {
+              children === null || children === void 0 || children.push(child.data);
+            } else {
+              children === null || children === void 0 || children.splice(index, 0, child.data);
+            }
+          }
+        }
+        Object.assign(child, {
+          parent: this,
+          store: this.store
+        });
+        child = new Node(child);
+        if (child instanceof Node) {
+          child.initialize();
+        }
+      }
+      child.level = this.level + 1;
+      if (isUndefined(index) || index < 0) {
+        this.childNodes.push(child);
+      } else {
+        this.childNodes.splice(index, 0, child);
+      }
+      this.updateLeafState();
+    }
+  }, {
+    key: "insertBefore",
+    value: function insertBefore(child, ref) {
+      var index;
+      if (ref) {
+        index = this.childNodes.indexOf(ref);
+      }
+      this.insertChild(child, index);
+    }
+  }, {
+    key: "insertAfter",
+    value: function insertAfter(child, ref) {
+      var index;
+      if (ref) {
+        index = this.childNodes.indexOf(ref);
+        if (index !== -1) {
+          index += 1;
+        }
+      }
+      this.insertChild(child, index);
+    }
+  }, {
+    key: "removeChild",
+    value: function removeChild(child) {
+      var children = this.getChildren() || [];
+      var dataIndex = children.indexOf(child.data);
+      if (dataIndex > -1) {
+        children.splice(dataIndex, 1);
+      }
+      var index = this.childNodes.indexOf(child);
+      if (index > -1) {
+        this.store && this.store.deregisterNode(child);
+        child.parent = null;
+        this.childNodes.splice(index, 1);
+      }
+      this.updateLeafState();
+    }
+  }, {
+    key: "removeChildByData",
+    value: function removeChildByData(data) {
+      var targetNode = this.childNodes.find(function (child) {
+        return child.data === data;
+      });
+      if (targetNode) {
+        this.removeChild(targetNode);
+      }
+    }
+  }, {
+    key: "expand",
+    value: function expand(callback, expandParent) {
+      var _this = this;
+      var done = function done() {
+        if (expandParent) {
+          var parent = _this.parent;
+          while (parent && parent.level > 0) {
+            parent.expanded = true;
+            parent = parent.parent;
+          }
+        }
+        _this.expanded = true;
+        if (callback) {
+          callback();
+        }
+        setCanFocus(_this.childNodes, true);
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(function (data) {
+          if (Array.isArray(data)) {
+            if (_this.checked) {
+              _this.setChecked(true, true);
+            } else if (!_this.store.checkStrictly) {
+              _reInitChecked(_this);
+            }
+            done();
+          }
+        });
+      } else {
+        done();
+      }
+    }
+  }, {
+    key: "doCreateChildren",
+    value: function doCreateChildren(array) {
+      var _this2 = this;
+      var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      array.forEach(function (item) {
+        _this2.insertChild(Object.assign({
+          data: item
+        }, defaultProps), undefined, true);
+      });
+    }
+  }, {
+    key: "collapse",
+    value: function collapse() {
+      this.expanded = false;
+      setCanFocus(this.childNodes, false);
+    }
+  }, {
+    key: "shouldLoadData",
+    value: function shouldLoadData() {
+      return Boolean(this.store.lazy === true && this.store.load && !this.loaded);
+    }
+  }, {
+    key: "updateLeafState",
+    value: function updateLeafState() {
+      if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== 'undefined') {
+        this.isLeaf = this.isLeafByUser;
+        this.isEffectivelyChecked = this.isLeaf && this.disabled;
+        return;
+      }
+      var childNodes = this.childNodes;
+      if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
+        this.isLeaf = !childNodes || childNodes.length === 0;
+        this.isEffectivelyChecked = this.isLeaf && this.disabled;
+        return;
+      }
+      this.isLeaf = false;
+    }
+  }, {
+    key: "setChecked",
+    value: function setChecked(value, deep, recursion, passValue) {
+      var _this3 = this;
+      this.indeterminate = value === 'half';
+      this.checked = value === true;
+      this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked);
+      if (this.store.checkStrictly) {
+        return;
+      }
+      if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+        var handleDescendants = function handleDescendants() {
+          if (deep) {
+            var childNodes = _this3.childNodes;
+            for (var i = 0, j = childNodes.length; i < j; i++) {
+              var child = childNodes[i];
+              passValue = passValue || value !== false;
+              var isCheck = child.disabled && child.isLeaf ? child.checked : passValue;
+              child.setChecked(isCheck, deep, true, passValue);
+            }
+            var _getChildState2 = getChildState(childNodes),
+              half = _getChildState2.half,
+              all = _getChildState2.all,
+              isEffectivelyChecked = _getChildState2.isEffectivelyChecked;
+            if (!all) {
+              _this3.checked = all;
+              _this3.indeterminate = half;
+            }
+            _this3.isEffectivelyChecked = !_this3.childNodes.length ? _this3.disabled || _this3.checked : isEffectivelyChecked;
+          }
+        };
+        if (this.shouldLoadData()) {
+          // Only work on lazy load data.
+          this.loadData(function () {
+            handleDescendants();
+            _reInitChecked(_this3);
+          }, {
+            checked: value !== false
+          });
+          return;
+        } else {
+          handleDescendants();
+        }
+      }
+      var parent = this.parent;
+      if (!parent || parent.level === 0) {
+        return;
+      }
+      if (!recursion) {
+        _reInitChecked(parent);
+      }
+    }
+  }, {
+    key: "getChildren",
+    value: function getChildren() {
+      var forceInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      // this is data
+      if (this.level === 0) {
+        return this.data;
+      }
+      var data = this.data;
+      if (!data) {
+        return null;
+      }
+      var props = this.store.props;
+      var children = 'children';
+      if (props) {
+        children = props.children || 'children';
+      }
+      if (isUndefined(data[children])) {
+        data[children] = null;
+      }
+      if (forceInit && !data[children]) {
+        data[children] = [];
+      }
+      return data[children];
+    }
+  }, {
+    key: "updateChildren",
+    value: function updateChildren() {
+      var _this4 = this;
+      var newData = this.getChildren() || [];
+      var oldData = this.childNodes.map(function (node) {
+        return node.data;
+      });
+      var newDataMap = {};
+      var newNodes = [];
+      newData.forEach(function (item, index) {
+        var key = item[NODE_KEY];
+        var isNodeExists = !!key && oldData.some(function (data) {
+          return (data === null || data === void 0 ? void 0 : data[NODE_KEY]) === key;
+        });
+        if (isNodeExists) {
+          newDataMap[key] = {
+            index: index,
+            data: item
+          };
+        } else {
+          newNodes.push({
+            index: index,
+            data: item
+          });
+        }
+      });
+      if (!this.store.lazy) {
+        oldData.forEach(function (item) {
+          if (!newDataMap[item === null || item === void 0 ? void 0 : item[NODE_KEY]]) {
+            _this4.removeChildByData(item);
+          }
+        });
+      }
+      newNodes.forEach(function (_ref) {
+        var index = _ref.index,
+          data = _ref.data;
+        _this4.insertChild({
+          data: data
+        }, index);
+      });
+      this.updateLeafState();
+    }
+  }, {
+    key: "loadData",
+    value: function loadData(callback) {
+      var _this5 = this;
+      var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
+        this.loading = true;
+        var resolve = function resolve(children) {
+          _this5.childNodes = [];
+          _this5.doCreateChildren(children, defaultProps);
+          _this5.loaded = true;
+          _this5.loading = false;
+          _this5.updateLeafState();
+          if (callback) {
+            callback.call(_this5, children);
+          }
+        };
+        var reject = function reject() {
+          _this5.loading = false;
+          _this5.store.forceUpdate();
+        };
+        this.store.load(this, resolve, reject);
+      } else {
+        if (callback) {
+          callback.call(this);
+        }
+      }
+    }
+  }, {
+    key: "eachNode",
+    value: function eachNode(callback) {
+      var arr = [this];
+      while (arr.length) {
+        var _node = arr.shift();
+        arr.unshift.apply(arr, _toConsumableArray(_node.childNodes));
+        callback(_node);
+      }
+    }
+  }, {
+    key: "reInitChecked",
+    value: function reInitChecked() {
+      if (this.store.checkStrictly) {
+        return;
+      }
+      _reInitChecked(this);
+    }
+  }]);
+  return Node;
+}();
+export default Node;

package/dist/Tree/model/tree-store.d.ts

@@ -0,0 +1,52 @@
+import { FilterNodeMethodFunction, FilterValue, LoadFunction, TreeData, TreeKey, TreeNodeData, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions } from '../typings';
+import Node from './node';
+export default class TreeStore {
+    currentNode: Node | null;
+    currentNodeKey: TreeKey | null;
+    nodesMap: TreeStoreNodesMap;
+    root: Node;
+    data: TreeData;
+    lazy: boolean;
+    load?: LoadFunction;
+    filterNodeMethod?: FilterNodeMethodFunction;
+    key: TreeKey;
+    defaultCheckedKeys?: TreeKey[];
+    checkStrictly: boolean;
+    defaultExpandedKeys?: TreeKey[];
+    autoExpandParent: boolean;
+    defaultExpandAll: boolean;
+    checkDescendants: boolean;
+    props: TreeOptionProps;
+    forceUpdate?: () => void;
+    constructor(options: TreeStoreOptions);
+    initialize(): void;
+    filter(value: FilterValue): void;
+    setData(newVal: TreeData): void;
+    getNode(data: TreeKey | TreeNodeData | Node): Node;
+    insertBefore(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+    insertAfter(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+    remove(data: TreeNodeData | Node): void;
+    append(data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node): void;
+    _initDefaultCheckedNodes(): void;
+    _initDefaultCheckedNode(node: Node): void;
+    setDefaultCheckedKey(newVal: TreeKey[]): void;
+    registerNode(node: Node): void;
+    deregisterNode(node: Node): void;
+    getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): TreeNodeData[];
+    getCheckedKeys(leafOnly?: boolean): TreeKey[];
+    getHalfCheckedNodes(): TreeNodeData[];
+    getHalfCheckedKeys(): TreeKey[];
+    _getAllNodes(): Node[];
+    updateChildren(key: TreeKey, data: TreeData): void;
+    _setCheckedKeys(key: TreeKey, leafOnly: boolean, checkedKeys: {
+        [key: string]: boolean;
+    }): void;
+    setCheckedNodes(array: Node[], leafOnly?: boolean): void;
+    setCheckedKeys(keys: TreeKey[], leafOnly?: boolean): void;
+    setDefaultExpandedKeys(keys: TreeKey[]): void;
+    setChecked(data: TreeKey | TreeNodeData, checked: boolean, deep: boolean): void;
+    getCurrentNode(): Node;
+    setCurrentNode(currentNode: Node): void;
+    setUserCurrentNode(node: Node, shouldAutoExpandParent?: boolean): void;
+    setCurrentNodeKey(key: TreeKey | null, shouldAutoExpandParent?: boolean): void;
+}