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

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

@@ -1,389 +1,288 @@
-import _typeof from "@babel/runtime/helpers/typeof";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import { hasOwn, isNull } from '@opentiny/vue-renderless/common/type';
-import { getNodeKey } from '@opentiny/vue-renderless/common/deps/tree-model/util';
-import Node from '@opentiny/vue-renderless/common/deps/tree-model/node';
-var TreeStore = function () {
-  function TreeStore(options) {
-    var _this = this;
-    _classCallCheck(this, TreeStore);
+import "../../../chunk-PKUHTIDK.js";
+import { hasOwn, isNull } from "@opentiny/vue-renderless/common/type";
+import { getNodeKey } from "@opentiny/vue-renderless/common/deps/tree-model/util";
+import Node from "@opentiny/vue-renderless/common/deps/tree-model/node";
+class TreeStore {
+  constructor(options) {
     this.currentNode = null;
     this.currentNodeKey = null;
-    for (var option in options) {
+    for (let option in options) {
       if (hasOwn.call(options, option)) {
         this[option] = options[option];
       }
     }
     this.nodesMap = {};
-    this.root = new Node({
-      data: this.data,
-      store: this
-    });
+    this.root = new Node({ data: this.data, store: this });
     if (this.lazy && this.load) {
-      this.load(this.root, function (data) {
-        _this.root.doCreateChildren(data);
-        _this._initDefaultCheckedNodes();
+      this.load(this.root, (data) => {
+        this.root.doCreateChildren(data);
+        this._initDefaultCheckedNodes();
       });
     } else {
       this._initDefaultCheckedNodes();
     }
   }
-  _createClass(TreeStore, [{
-    key: "filter",
-    value: function filter(value) {
-      var _this2 = this;
-      var lazy = this.lazy,
-        getMappingData = this.getMappingData,
-        filterNodeMethod = this.filterNodeMethod;
-      var walkTree = function walkTree(node) {
-        var childNodes = node.root ? node.root.childNodes : node.childNodes;
-        childNodes.forEach(function (child) {
-          var mappingData = getMappingData.call(_this2, child.data);
-          child.visible = filterNodeMethod.call(child, value, mappingData, child);
-          walkTree(child);
-        });
-        if (!node.visible && childNodes.length) {
-          var allHidden = !childNodes.some(function (_ref) {
-            var visible = _ref.visible;
-            return visible;
-          });
-          if (node.root) {
-            node.root.visible = allHidden === false;
-          } else {
-            node.visible = allHidden === false;
-          }
-        }
-        if (!value) {
-          return;
-        }
-        if (node.visible && !node.isLeaf && !lazy) {
-          node.expand();
-        }
-      };
-      walkTree(this);
-    }
-  }, {
-    key: "getMappingData",
-    value: function getMappingData(data) {
-      var props = this.props || {};
-      var mapping = {};
-      Object.keys(props).forEach(function (key) {
-        if (hasOwn.call(props, key)) {
-          mapping[key] = data[props[key]];
-        }
+  filter(value) {
+    const { lazy, getMappingData, filterNodeMethod } = this;
+    const walkTree = (node) => {
+      const childNodes = node.root ? node.root.childNodes : node.childNodes;
+      childNodes.forEach((child) => {
+        const mappingData = getMappingData.call(this, child.data);
+        child.visible = filterNodeMethod.call(child, value, mappingData, child);
+        walkTree(child);
       });
-      return Object.assign(data, mapping);
-    }
-  }, {
-    key: "setData",
-    value: function setData(newVal) {
-      if (newVal !== this.root.data) {
-        this.root.setData(newVal);
-        this._initDefaultCheckedNodes();
-      } else {
-        this.root.updateChildren();
+      if (!node.visible && childNodes.length) {
+        let allHidden = !childNodes.some(({ visible }) => visible);
+        if (node.root) {
+          node.root.visible = allHidden === false;
+        } else {
+          node.visible = allHidden === false;
+        }
       }
-    }
-  }, {
-    key: "getNode",
-    value: function getNode(data) {
-      if (data instanceof Node) {
-        return data;
+      if (!value) {
+        return;
       }
-      var nodeKey = _typeof(data) !== 'object' ? data : getNodeKey(this.key, data);
-      return this.nodesMap[nodeKey] || null;
-    }
-  }, {
-    key: "insertBefore",
-    value: function insertBefore(data, insertData) {
-      var refNode = this.getNode(insertData);
-      refNode.parent.insertBefore({
-        data: data
-      }, refNode);
-    }
-  }, {
-    key: "insertAfter",
-    value: function insertAfter(data, insertData) {
-      var refNode = this.getNode(insertData);
-      refNode.parent.insertAfter({
-        data: data
-      }, refNode);
-    }
-  }, {
-    key: "remove",
-    value: function remove(data) {
-      var treeNode = this.getNode(data);
-      if (treeNode && treeNode.parent) {
-        if (treeNode === this.currentNode) {
-          this.currentNode = null;
-        }
-        treeNode.parent.removeChild(treeNode);
+      if (node.visible && !node.isLeaf && !lazy) {
+        node.expand();
       }
-    }
-  }, {
-    key: "append",
-    value: function append(data, parentData) {
-      var parentNode = parentData ? this.getNode(parentData) : this.root;
-      parentNode && parentNode.insertChild({
-        data: data
-      });
-    }
-  }, {
-    key: "setDefaultCheckedKey",
-    value: function setDefaultCheckedKey(newValue) {
-      if (newValue !== this.defaultCheckedKeys) {
-        this.defaultCheckedKeys = newValue;
-        this._initDefaultCheckedNodes();
+    };
+    walkTree(this);
+  }
+  getMappingData(data) {
+    const props = this.props || {};
+    const mapping = {};
+    Object.keys(props).forEach((key) => {
+      if (hasOwn.call(props, key)) {
+        mapping[key] = data[props[key]];
       }
+    });
+    return Object.assign(data, mapping);
+  }
+  setData(newVal) {
+    if (newVal !== this.root.data) {
+      this.root.setData(newVal);
+      this._initDefaultCheckedNodes();
+    } else {
+      this.root.updateChildren();
     }
-  }, {
-    key: "_initDefaultCheckedNodes",
-    value: function _initDefaultCheckedNodes() {
-      var _this3 = this;
-      var defaultCheckedKeys = this.defaultCheckedKeys || [];
-      var nodesMap = this.nodesMap;
-      defaultCheckedKeys.forEach(function (checkedKey) {
-        var node = nodesMap[checkedKey];
-        node && node.setChecked(true, !_this3.checkStrictly);
-      });
-    }
-  }, {
-    key: "_initDefaultCheckedNode",
-    value: function _initDefaultCheckedNode(node) {
-      var defaultCheckedKeys = this.defaultCheckedKeys || [];
-      ~defaultCheckedKeys.indexOf(node.key) && node.setChecked(true, !this.checkStrictly);
-    }
-  }, {
-    key: "getCheckedKeys",
-    value: function getCheckedKeys() {
-      var _this4 = this;
-      var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      return this.getCheckedNodes(leafOnly).map(function (node) {
-        return (node || {})[_this4.key];
-      });
-    }
-  }, {
-    key: "getHalfCheckedKeys",
-    value: function getHalfCheckedKeys() {
-      var _this5 = this;
-      return this.getHalfCheckedNodes().map(function (node) {
-        return (node || {})[_this5.key];
-      });
-    }
-  }, {
-    key: "deregisterNode",
-    value: function deregisterNode(node) {
-      var _this6 = this;
-      var key = this.key;
-      if (!key || !node || !node.data) {
-        return;
-      }
-      node.childNodes.forEach(function (child) {
-        _this6.deregisterNode(child);
-      });
-      delete this.nodesMap[node.key];
+  }
+  getNode(data) {
+    if (data instanceof Node) {
+      return data;
     }
-  }, {
-    key: "registerNode",
-    value: function registerNode(node) {
-      var key = this.key;
-      if (!key || !node || !node.data) {
-        return;
-      }
-      var nodeKey = node.key;
-      if (nodeKey !== undefined) {
-        this.nodesMap[nodeKey] = node;
+    const nodeKey = typeof data !== "object" ? data : getNodeKey(this.key, data);
+    return this.nodesMap[nodeKey] || null;
+  }
+  insertBefore(data, insertData) {
+    const refNode = this.getNode(insertData);
+    refNode.parent.insertBefore({ data }, refNode);
+  }
+  insertAfter(data, insertData) {
+    const refNode = this.getNode(insertData);
+    refNode.parent.insertAfter({ data }, refNode);
+  }
+  remove(data) {
+    const treeNode = this.getNode(data);
+    if (treeNode && treeNode.parent) {
+      if (treeNode === this.currentNode) {
+        this.currentNode = null;
       }
+      treeNode.parent.removeChild(treeNode);
     }
-  }, {
-    key: "getCheckedNodes",
-    value: function getCheckedNodes() {
-      var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var includeHalfChecked = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var checkedNodes = [];
-      var walkTree = function walkTree(node) {
-        var childNodes = node.root ? node.root.childNodes : node.childNodes;
-        childNodes.forEach(function (child) {
-          var checked = child.checked,
-            indeterminate = child.indeterminate,
-            isLeaf = child.isLeaf,
-            data = child.data;
-          if ((checked || includeHalfChecked && indeterminate) && (!leafOnly || leafOnly && isLeaf)) {
-            checkedNodes.push(data);
-          }
-          walkTree(child);
-        });
-      };
-      walkTree(this);
-      return checkedNodes;
+  }
+  append(data, parentData) {
+    const parentNode = parentData ? this.getNode(parentData) : this.root;
+    parentNode && parentNode.insertChild({ data });
+  }
+  setDefaultCheckedKey(newValue) {
+    if (newValue !== this.defaultCheckedKeys) {
+      this.defaultCheckedKeys = newValue;
+      this._initDefaultCheckedNodes();
     }
-  }, {
-    key: "getHalfCheckedNodes",
-    value: function getHalfCheckedNodes() {
-      var nodes = [];
-      var walkTree = function walkTree(node) {
-        var childNodes = node.root ? node.root.childNodes : node.childNodes;
-        childNodes.forEach(function (child) {
-          var indeterminate = child.indeterminate,
-            data = child.data;
-          indeterminate && nodes.push(data);
-          walkTree(child);
-        });
-      };
-      walkTree(this);
-      return nodes;
+  }
+  _initDefaultCheckedNodes() {
+    const defaultCheckedKeys = this.defaultCheckedKeys || [];
+    const nodesMap = this.nodesMap;
+    defaultCheckedKeys.forEach((checkedKey) => {
+      const node = nodesMap[checkedKey];
+      node && node.setChecked(true, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(node) {
+    const defaultCheckedKeys = this.defaultCheckedKeys || [];
+    ~defaultCheckedKeys.indexOf(node.key) && node.setChecked(true, !this.checkStrictly);
+  }
+  getCheckedKeys(leafOnly = false) {
+    return this.getCheckedNodes(leafOnly).map((node) => (node || {})[this.key]);
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((node) => (node || {})[this.key]);
+  }
+  deregisterNode(node) {
+    const key = this.key;
+    if (!key || !node || !node.data) {
+      return;
     }
-  }, {
-    key: "_getAllNodes",
-    value: function _getAllNodes() {
-      var allNodes = [];
-      var nodesMap = this.nodesMap;
-      Object.keys(nodesMap).forEach(function (nodeKey) {
-        hasOwn.call(nodesMap, nodeKey) && allNodes.push(nodesMap[nodeKey]);
-      });
-      return allNodes;
+    node.childNodes.forEach((child) => {
+      this.deregisterNode(child);
+    });
+    delete this.nodesMap[node.key];
+  }
+  registerNode(node) {
+    const key = this.key;
+    if (!key || !node || !node.data) {
+      return;
     }
-  }, {
-    key: "updateChildren",
-    value: function updateChildren(key, data) {
-      var node = this.nodesMap[key];
-      if (!node) {
-        return;
-      }
-      var childNodes = node.childNodes;
-      for (var i = childNodes.length - 1; i >= 0; i--) {
-        this.remove(childNodes[i].data);
-      }
-      for (var _i = 0, len = data.length; _i < len; _i++) {
-        var child = data[_i];
-        this.append(child, node.data);
-      }
+    const nodeKey = node.key;
+    if (nodeKey !== void 0) {
+      this.nodesMap[nodeKey] = node;
     }
-  }, {
-    key: "_setCheckedKeys",
-    value: function _setCheckedKeys(key) {
-      var _this7 = this;
-      var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var checkedKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      var nodes = this._getAllNodes().sort(function (prevNode, nextNode) {
-        return nextNode.level - prevNode.level;
-      });
-      var cache = Object.create(null);
-      var keys = Object.keys(checkedKeys);
-      nodes.forEach(function (node) {
-        node.setChecked(false, false);
-      });
-      var _loop = function _loop() {
-        var node = nodes[i];
-        var nodeKey = node.data[key].toString();
-        var checked = ~keys.indexOf(nodeKey);
-        if (!checked) {
-          if (node.checked && !cache[nodeKey]) {
-            node.setChecked(false, false);
-          }
-        } else {
-          var parentNode = node.parent;
-          while (parentNode && parentNode.level > 0) {
-            cache[parentNode.data[key]] = true;
-            parentNode = parentNode.parent;
-          }
-          if (node.isLeaf || _this7.checkStrictly) {
-            node.setChecked(true, false);
-          } else if (leafOnly) {
-            node.setChecked(false, false);
-            var walkTree = function walkTree(node) {
-              var childNodes = node.childNodes;
-              childNodes.forEach(function (child) {
-                !child.isLeaf && child.setChecked(false, false);
-                walkTree(child);
-              });
-            };
-            walkTree(node);
-          } else {
-            node.setChecked(true, true);
-          }
+  }
+  getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
+    const checkedNodes = [];
+    const walkTree = (node) => {
+      const childNodes = node.root ? node.root.childNodes : node.childNodes;
+      childNodes.forEach((child) => {
+        const { checked, indeterminate, isLeaf, data } = child;
+        if ((checked || includeHalfChecked && indeterminate) && (!leafOnly || leafOnly && isLeaf)) {
+          checkedNodes.push(data);
         }
-      };
-      for (var i = 0, len = nodes.length; i < len; i++) {
-        _loop();
-      }
-    }
-  }, {
-    key: "setDefaultExpandedKeys",
-    value: function setDefaultExpandedKeys(keys) {
-      var _this8 = this;
-      keys = keys || [];
-      this.defaultExpandedKeys = keys;
-      keys.forEach(function (key) {
-        var node = _this8.getNode(key);
-        node && node.expand(null, _this8.autoExpandParent);
+        walkTree(child);
       });
-    }
-  }, {
-    key: "setCheckedKeys",
-    value: function setCheckedKeys(keys) {
-      var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      this.defaultCheckedKeys = keys;
-      var checkedKeys = {};
-      keys.forEach(function (key) {
-        checkedKeys[key] = true;
+    };
+    walkTree(this);
+    return checkedNodes;
+  }
+  getHalfCheckedNodes() {
+    const nodes = [];
+    const walkTree = (node) => {
+      const childNodes = node.root ? node.root.childNodes : node.childNodes;
+      childNodes.forEach((child) => {
+        const { indeterminate, data } = child;
+        indeterminate && nodes.push(data);
+        walkTree(child);
       });
-      this._setCheckedKeys(this.key, leafOnly, checkedKeys);
+    };
+    walkTree(this);
+    return nodes;
+  }
+  _getAllNodes() {
+    const allNodes = [];
+    const nodesMap = this.nodesMap;
+    Object.keys(nodesMap).forEach((nodeKey) => {
+      hasOwn.call(nodesMap, nodeKey) && allNodes.push(nodesMap[nodeKey]);
+    });
+    return allNodes;
+  }
+  updateChildren(key, data) {
+    const node = this.nodesMap[key];
+    if (!node) {
+      return;
     }
-  }, {
-    key: "setCheckedNodes",
-    value: function setCheckedNodes(array) {
-      var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var key = this.key;
-      var checkedKeys = {};
-      array.forEach(function (item) {
-        checkedKeys[(item || {})[key]] = true;
-      });
-      this._setCheckedKeys(key, leafOnly, checkedKeys);
+    const childNodes = node.childNodes;
+    for (let i = childNodes.length - 1; i >= 0; i--) {
+      this.remove(childNodes[i].data);
     }
-  }, {
-    key: "setChecked",
-    value: function setChecked(data, checked, deep) {
-      var node = this.getNode(data);
-      node && node.setChecked(!!checked, deep);
+    for (let i = 0, len = data.length; i < len; i++) {
+      const child = data[i];
+      this.append(child, node.data);
     }
-  }, {
-    key: "setCurrentNode",
-    value: function setCurrentNode(currentNode) {
-      var prevNode = this.currentNode;
-      if (prevNode) {
-        prevNode.isCurrent = false;
-      }
-      this.currentNode = currentNode;
-      if (currentNode) {
-        this.currentNode.isCurrent = true;
+  }
+  _setCheckedKeys(key, leafOnly = false, checkedKeys = {}) {
+    const nodes = this._getAllNodes().sort((prevNode, nextNode) => nextNode.level - prevNode.level);
+    const cache = /* @__PURE__ */ Object.create(null);
+    const keys = Object.keys(checkedKeys);
+    nodes.forEach((node) => {
+      node.setChecked(false, false);
+    });
+    for (let i = 0, len = nodes.length; i < len; i++) {
+      const node = nodes[i];
+      const nodeKey = node.data[key].toString();
+      let checked = ~keys.indexOf(nodeKey);
+      if (!checked) {
+        if (node.checked && !cache[nodeKey]) {
+          node.setChecked(false, false);
+        }
+      } else {
+        let parentNode = node.parent;
+        while (parentNode && parentNode.level > 0) {
+          cache[parentNode.data[key]] = true;
+          parentNode = parentNode.parent;
+        }
+        if (node.isLeaf || this.checkStrictly) {
+          node.setChecked(true, false);
+        } else if (leafOnly) {
+          node.setChecked(false, false);
+          const walkTree = (node2) => {
+            const childNodes = node2.childNodes;
+            childNodes.forEach((child) => {
+              !child.isLeaf && child.setChecked(false, false);
+              walkTree(child);
+            });
+          };
+          walkTree(node);
+        } else {
+          node.setChecked(true, true);
+        }
       }
     }
-  }, {
-    key: "getCurrentNode",
-    value: function getCurrentNode() {
-      return this.currentNode;
+  }
+  setDefaultExpandedKeys(keys) {
+    keys = keys || [];
+    this.defaultExpandedKeys = keys;
+    keys.forEach((key) => {
+      const node = this.getNode(key);
+      node && node.expand(null, this.autoExpandParent);
+    });
+  }
+  setCheckedKeys(keys, leafOnly = false) {
+    this.defaultCheckedKeys = keys;
+    const checkedKeys = {};
+    keys.forEach((key) => {
+      checkedKeys[key] = true;
+    });
+    this._setCheckedKeys(this.key, leafOnly, checkedKeys);
+  }
+  setCheckedNodes(array, leafOnly = false) {
+    const key = this.key;
+    const checkedKeys = {};
+    array.forEach((item) => {
+      checkedKeys[(item || {})[key]] = true;
+    });
+    this._setCheckedKeys(key, leafOnly, checkedKeys);
+  }
+  setChecked(data, checked, deep) {
+    const node = this.getNode(data);
+    node && node.setChecked(!!checked, deep);
+  }
+  setCurrentNode(currentNode) {
+    const prevNode = this.currentNode;
+    if (prevNode) {
+      prevNode.isCurrent = false;
     }
-  }, {
-    key: "setCurrentNodeKey",
-    value: function setCurrentNodeKey(key) {
-      if (isNull(key)) {
-        this.currentNode && (this.currentNode.isCurrent = false);
-        this.currentNode = null;
-        return;
-      }
-      var node = this.getNode(key);
-      node && this.setCurrentNode(node);
+    this.currentNode = currentNode;
+    if (currentNode) {
+      this.currentNode.isCurrent = true;
     }
-  }, {
-    key: "setUserCurrentNode",
-    value: function setUserCurrentNode(node) {
-      var key = node[this.key];
-      var currNode = this.nodesMap[key];
-      this.setCurrentNode(currNode);
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  setCurrentNodeKey(key) {
+    if (isNull(key)) {
+      this.currentNode && (this.currentNode.isCurrent = false);
+      this.currentNode = null;
+      return;
     }
-  }]);
-  return TreeStore;
-}();
-export { TreeStore as default };
+    const node = this.getNode(key);
+    node && this.setCurrentNode(node);
+  }
+  setUserCurrentNode(node) {
+    const key = node[this.key];
+    const currNode = this.nodesMap[key];
+    this.setCurrentNode(currNode);
+  }
+}
+export {
+  TreeStore as default
+};

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

@@ -1,11 +1,12 @@
-export var NODE_KEY = '$treeNodeId';
-export var getNodeKey = function getNodeKey(key, data) {
+import "../../../chunk-PKUHTIDK.js";
+const NODE_KEY = "$treeNodeId";
+const getNodeKey = function(key, data) {
   if (!key) {
     return data[NODE_KEY];
   }
   return data[key];
 };
-export var markNodeData = function markNodeData(node, data) {
+const markNodeData = function(node, data) {
   if (!data || data[NODE_KEY]) {
     return;
   }
@@ -15,4 +16,9 @@ export var markNodeData = function markNodeData(node, data) {
     configurable: false,
     writable: false
   });
-};
+};
+export {
+  NODE_KEY,
+  getNodeKey,
+  markNodeData
+};