vft 0.0.361 → 0.0.363

package/es/components/tree/model/tree-store.js

@@ -1,7 +1,7 @@
-import { hasOwn as u, isObject as C } from "@vft/utils";
-import N from "./node.js";
-import { getNodeKey as y } from "./util.js";
-class m {
+import { hasOwn, isObject } from "@vft/utils";
+import Node from "./node.js";
+import { getNodeKey } from "./util.js";
+class TreeStore {
   currentNode;
   currentNodeKey;
   nodesMap;
@@ -18,198 +18,300 @@ class m {
   defaultExpandAll;
   checkDescendants;
   props;
-  constructor(e) {
-    this.currentNode = null, this.currentNodeKey = null;
-    for (const t in e)
-      u(e, t) && (this[t] = e[t]);
+  constructor(options) {
+    this.currentNode = null;
+    this.currentNodeKey = null;
+    for (const option in options) {
+      if (hasOwn(options, option)) {
+        this[option] = options[option];
+      }
+    }
     this.nodesMap = {};
   }
   initialize() {
-    if (this.root = new N({
+    this.root = new Node({
       data: this.data,
       store: this
-    }), this.root.initialize(), this.lazy && this.load) {
-      const e = this.load;
-      e(this.root, (t) => {
-        this.root.doCreateChildren(t), this._initDefaultCheckedNodes();
+    });
+    this.root.initialize();
+    if (this.lazy && this.load) {
+      const loadFn = this.load;
+      loadFn(this.root, (data) => {
+        this.root.doCreateChildren(data);
+        this._initDefaultCheckedNodes();
       });
-    } else
+    } else {
       this._initDefaultCheckedNodes();
+    }
   }
-  filter(e) {
-    const t = this.filterNodeMethod, s = this.lazy, i = function(o) {
-      const d = o.root ? o.root.childNodes : o.childNodes;
-      if (d.forEach((r) => {
-        r.visible = t.call(r, e, r.data, r), i(r);
-      }), !o.visible && d.length) {
-        let r = !0;
-        r = !d.some((c) => c.visible), o.root ? o.root.visible = r === !1 : o.visible = r === !1;
+  filter(value) {
+    const filterNodeMethod = this.filterNodeMethod;
+    const lazy = this.lazy;
+    const traverse = function(node) {
+      const childNodes = node.root ? node.root.childNodes : node.childNodes;
+      childNodes.forEach((child) => {
+        child.visible = filterNodeMethod.call(child, value, child.data, child);
+        traverse(child);
+      });
+      if (!node.visible && childNodes.length) {
+        let allHidden = true;
+        allHidden = !childNodes.some((child) => child.visible);
+        if (node.root) {
+          node.root.visible = allHidden === false;
+        } else {
+          node.visible = allHidden === false;
+        }
       }
-      e && o.visible && !o.isLeaf && !s && o.expand();
+      if (!value) return;
+      if (node.visible && !node.isLeaf && !lazy)
+        node.expand();
     };
-    i(this);
+    traverse(this);
   }
-  setData(e) {
-    e !== this.root.data ? (this.root.setData(e), this._initDefaultCheckedNodes()) : this.root.updateChildren();
+  setData(newVal) {
+    const instanceChanged = newVal !== this.root.data;
+    if (instanceChanged) {
+      this.root.setData(newVal);
+      this._initDefaultCheckedNodes();
+    } else {
+      this.root.updateChildren();
+    }
   }
-  getNode(e) {
-    if (e instanceof N) return e;
-    const t = C(e) ? y(this.key, e) : e;
-    return this.nodesMap[t] || null;
+  getNode(data) {
+    if (data instanceof Node) return data;
+    const key = isObject(data) ? getNodeKey(this.key, data) : data;
+    return this.nodesMap[key] || null;
   }
-  insertBefore(e, t) {
-    const s = this.getNode(t);
-    s.parent.insertBefore({ data: e }, s);
+  insertBefore(data, refData) {
+    const refNode = this.getNode(refData);
+    refNode.parent.insertBefore({ data }, refNode);
   }
-  insertAfter(e, t) {
-    const s = this.getNode(t);
-    s.parent.insertAfter({ data: e }, s);
+  insertAfter(data, refData) {
+    const refNode = this.getNode(refData);
+    refNode.parent.insertAfter({ data }, refNode);
   }
-  updateNode(e, t) {
-    const s = this.getNode(t);
-    s && s.updateNode(e, s);
+  updateNode(data, refData) {
+    const refNode = this.getNode(refData);
+    if (!refNode) return;
+    refNode.updateNode(data, refNode);
   }
-  remove(e) {
-    const t = this.getNode(e);
-    t && t.parent && (t === this.currentNode && (this.currentNode = null), t.parent.removeChild(t));
+  remove(data) {
+    const node = this.getNode(data);
+    if (node && node.parent) {
+      if (node === this.currentNode) {
+        this.currentNode = null;
+      }
+      node.parent.removeChild(node);
+    }
   }
-  append(e, t) {
-    const s = t ? this.getNode(t) : this.root;
-    s && s.insertChild({ data: e });
+  append(data, parentData) {
+    const parentNode = parentData ? this.getNode(parentData) : this.root;
+    if (parentNode) {
+      parentNode.insertChild({ data });
+    }
   }
-  updateChildren(e, t) {
-    const s = this.nodesMap[e];
-    if (!s) return;
-    const i = s.childNodes;
-    for (let o = i.length - 1; o >= 0; o--) {
-      const d = i[o];
-      this.remove(d.data);
+  updateChildren(key, data) {
+    const node = this.nodesMap[key];
+    if (!node) return;
+    const childNodes = node.childNodes;
+    for (let i = childNodes.length - 1; i >= 0; i--) {
+      const child = childNodes[i];
+      this.remove(child.data);
     }
-    for (let o = 0, d = t.length; o < d; o++) {
-      const r = t[o];
-      this.append(r, s.data);
+    for (let i = 0, j = data.length; i < j; i++) {
+      const child = data[i];
+      this.append(child, node.data);
     }
   }
   _initDefaultCheckedNodes() {
-    const e = this.defaultCheckedKeys || [], t = this.nodesMap;
-    e.forEach((s) => {
-      const i = t[s];
-      i && i.setChecked(!0, !this.checkStrictly);
+    const defaultCheckedKeys = this.defaultCheckedKeys || [];
+    const nodesMap = this.nodesMap;
+    defaultCheckedKeys.forEach((checkedKey) => {
+      const node = nodesMap[checkedKey];
+      if (node) {
+        node.setChecked(true, !this.checkStrictly);
+      }
     });
   }
-  _initDefaultCheckedNode(e) {
-    (this.defaultCheckedKeys || []).includes(e.key) && e.setChecked(!0, !this.checkStrictly);
+  _initDefaultCheckedNode(node) {
+    const defaultCheckedKeys = this.defaultCheckedKeys || [];
+    if (defaultCheckedKeys.includes(node.key)) {
+      node.setChecked(true, !this.checkStrictly);
+    }
   }
-  setDefaultCheckedKey(e) {
-    e !== this.defaultCheckedKeys && (this.defaultCheckedKeys = e, this._initDefaultCheckedNodes());
+  setDefaultCheckedKey(newVal) {
+    if (newVal !== this.defaultCheckedKeys) {
+      this.defaultCheckedKeys = newVal;
+      this._initDefaultCheckedNodes();
+    }
   }
-  registerNode(e) {
-    const t = this.key;
-    !e || !e.data || (t ? e.key !== void 0 && (this.nodesMap[e.key] = e) : this.nodesMap[e.id] = e);
+  registerNode(node) {
+    const key = this.key;
+    if (!node || !node.data) return;
+    if (!key) {
+      this.nodesMap[node.id] = node;
+    } else {
+      const nodeKey = node.key;
+      if (nodeKey !== void 0) this.nodesMap[node.key] = node;
+    }
   }
-  deregisterNode(e) {
-    !this.key || !e || !e.data || (e.childNodes.forEach((s) => {
-      this.deregisterNode(s);
-    }), delete this.nodesMap[e.key]);
+  deregisterNode(node) {
+    const key = this.key;
+    if (!key || !node || !node.data) return;
+    node.childNodes.forEach((child) => {
+      this.deregisterNode(child);
+    });
+    delete this.nodesMap[node.key];
   }
-  getCheckedNodes(e = !1, t = !1) {
-    const s = [], i = function(o) {
-      (o.root ? o.root.childNodes : o.childNodes).forEach((r) => {
-        (r.checked || t && r.indeterminate) && (!e || e && r.isLeaf) && s.push(r.data), i(r);
+  getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
+    const checkedNodes = [];
+    const traverse = function(node) {
+      const childNodes = node.root ? node.root.childNodes : node.childNodes;
+      childNodes.forEach((child) => {
+        if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
+          checkedNodes.push(child.data);
+        }
+        traverse(child);
       });
     };
-    return i(this), s;
+    traverse(this);
+    return checkedNodes;
   }
-  getCheckedKeys(e = !1) {
-    return this.getCheckedNodes(e).map((t) => (t || {})[this.key]);
+  getCheckedKeys(leafOnly = false) {
+    return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
   }
   getHalfCheckedNodes() {
-    const e = [], t = function(s) {
-      (s.root ? s.root.childNodes : s.childNodes).forEach((o) => {
-        o.indeterminate && e.push(o.data), t(o);
+    const nodes = [];
+    const traverse = function(node) {
+      const childNodes = node.root ? node.root.childNodes : node.childNodes;
+      childNodes.forEach((child) => {
+        if (child.indeterminate) {
+          nodes.push(child.data);
+        }
+        traverse(child);
       });
     };
-    return t(this), e;
+    traverse(this);
+    return nodes;
   }
   getHalfCheckedKeys() {
-    return this.getHalfCheckedNodes().map((e) => (e || {})[this.key]);
+    return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
   }
   _getAllNodes() {
-    const e = [], t = this.nodesMap;
-    for (const s in t)
-      u(t, s) && e.push(t[s]);
-    return e;
-  }
-  _setCheckedKeys(e, t = !1, s) {
-    const i = this._getAllNodes().sort((r, c) => c.level - r.level), o = /* @__PURE__ */ Object.create(null), d = Object.keys(s);
-    i.forEach((r) => r.setChecked(!1, !1));
-    for (let r = 0, c = i.length; r < c; r++) {
-      const n = i[r], l = n.data[e].toString();
-      if (!d.includes(l)) {
-        n.checked && !o[l] && n.setChecked(!1, !1);
+    const allNodes = [];
+    const nodesMap = this.nodesMap;
+    for (const nodeKey in nodesMap) {
+      if (hasOwn(nodesMap, nodeKey)) {
+        allNodes.push(nodesMap[nodeKey]);
+      }
+    }
+    return allNodes;
+  }
+  _setCheckedKeys(key, leafOnly = false, checkedKeys) {
+    const allNodes = this._getAllNodes().sort((a, b) => b.level - a.level);
+    const cache = /* @__PURE__ */ Object.create(null);
+    const keys = Object.keys(checkedKeys);
+    allNodes.forEach((node) => node.setChecked(false, false));
+    for (let i = 0, j = allNodes.length; i < j; i++) {
+      const node = allNodes[i];
+      const nodeKey = node.data[key].toString();
+      const checked = keys.includes(nodeKey);
+      if (!checked) {
+        if (node.checked && !cache[nodeKey]) {
+          node.setChecked(false, false);
+        }
         continue;
       }
-      let h = n.parent;
-      for (; h && h.level > 0; )
-        o[h.data[e]] = !0, h = h.parent;
-      if (n.isLeaf || this.checkStrictly) {
-        n.setChecked(!0, !1);
+      let parent = node.parent;
+      while (parent && parent.level > 0) {
+        cache[parent.data[key]] = true;
+        parent = parent.parent;
+      }
+      if (node.isLeaf || this.checkStrictly) {
+        node.setChecked(true, false);
         continue;
       }
-      if (n.setChecked(!0, !0), t) {
-        n.setChecked(!1, !1);
-        const f = function(k) {
-          k.childNodes.forEach((a) => {
-            a.isLeaf || a.setChecked(!1, !1), f(a);
+      node.setChecked(true, true);
+      if (leafOnly) {
+        node.setChecked(false, false);
+        const traverse = function(node2) {
+          const childNodes = node2.childNodes;
+          childNodes.forEach((child) => {
+            if (!child.isLeaf) {
+              child.setChecked(false, false);
+            }
+            traverse(child);
           });
         };
-        f(n);
+        traverse(node);
       }
     }
   }
-  setCheckedNodes(e, t = !1) {
-    const s = this.key, i = {};
-    e.forEach((o) => {
-      i[(o || {})[s]] = !0;
-    }), this._setCheckedKeys(s, t, i);
+  setCheckedNodes(array, leafOnly = false) {
+    const key = this.key;
+    const checkedKeys = {};
+    array.forEach((item) => {
+      checkedKeys[(item || {})[key]] = true;
+    });
+    this._setCheckedKeys(key, leafOnly, checkedKeys);
   }
-  setCheckedKeys(e, t = !1) {
-    this.defaultCheckedKeys = e;
-    const s = this.key, i = {};
-    e.forEach((o) => {
-      i[o] = !0;
-    }), this._setCheckedKeys(s, t, i);
+  setCheckedKeys(keys, leafOnly = false) {
+    this.defaultCheckedKeys = keys;
+    const key = this.key;
+    const checkedKeys = {};
+    keys.forEach((key2) => {
+      checkedKeys[key2] = true;
+    });
+    this._setCheckedKeys(key, leafOnly, checkedKeys);
   }
-  setDefaultExpandedKeys(e) {
-    e = e || [], this.defaultExpandedKeys = e, e.forEach((t) => {
-      const s = this.getNode(t);
-      s && s.expand(null, this.autoExpandParent);
+  setDefaultExpandedKeys(keys) {
+    keys = keys || [];
+    this.defaultExpandedKeys = keys;
+    keys.forEach((key) => {
+      const node = this.getNode(key);
+      if (node) node.expand(null, this.autoExpandParent);
     });
   }
-  setChecked(e, t, s) {
-    const i = this.getNode(e);
-    i && i.setChecked(!!t, s);
+  setChecked(data, checked, deep) {
+    const node = this.getNode(data);
+    if (node) {
+      node.setChecked(!!checked, deep);
+    }
   }
   getCurrentNode() {
     return this.currentNode;
   }
-  setCurrentNode(e) {
-    const t = this.currentNode;
-    t && (t.isCurrent = !1), this.currentNode = e, this.currentNode.isCurrent = !0;
+  setCurrentNode(currentNode) {
+    const prevCurrentNode = this.currentNode;
+    if (prevCurrentNode) {
+      prevCurrentNode.isCurrent = false;
+    }
+    this.currentNode = currentNode;
+    this.currentNode.isCurrent = true;
   }
-  setUserCurrentNode(e, t = !0) {
-    const s = e[this.key], i = this.nodesMap[s];
-    this.setCurrentNode(i), t && this.currentNode.level > 1 && this.currentNode.parent.expand(null, !0);
+  setUserCurrentNode(node, shouldAutoExpandParent = true) {
+    const key = node[this.key];
+    const currNode = this.nodesMap[key];
+    this.setCurrentNode(currNode);
+    if (shouldAutoExpandParent && this.currentNode.level > 1) {
+      this.currentNode.parent.expand(null, true);
+    }
   }
-  setCurrentNodeKey(e, t = !0) {
-    if (e == null) {
-      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+  setCurrentNodeKey(key, shouldAutoExpandParent = true) {
+    if (key === null || key === void 0) {
+      this.currentNode && (this.currentNode.isCurrent = false);
+      this.currentNode = null;
       return;
     }
-    const s = this.getNode(e);
-    s && (this.setCurrentNode(s), t && this.currentNode.level > 1 && this.currentNode.parent.expand(null, !0));
+    const node = this.getNode(key);
+    if (node) {
+      this.setCurrentNode(node);
+      if (shouldAutoExpandParent && this.currentNode.level > 1) {
+        this.currentNode.parent.expand(null, true);
+      }
+    }
   }
 }
 export {
-  m as default
+  TreeStore as default
 };