vft 0.0.363 → 0.0.365

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

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