vft 0.0.375 → 0.0.376

package/es/components/tree/model/node.js

@@ -1,58 +1,32 @@
-import { hasOwn } from "@vft/utils";
-import { reactive } from "vue";
-import { markNodeData, NODE_KEY } from "./util.js";
-const getChildState = (node) => {
-  let all = true;
-  let none = true;
-  let allWithoutDisable = true;
-  for (let i = 0, j = node.length; i < j; i++) {
-    const n = node[i];
-    if (n.checked !== true || n.indeterminate) {
-      all = false;
-      if (!n.disabled) {
-        allWithoutDisable = false;
-      }
-    }
-    if (n.checked !== false || n.indeterminate) {
-      none = false;
-    }
-  }
-  return { all, none, allWithoutDisable, half: !all && !none };
-};
-const reInitChecked = function(node) {
-  if (node.childNodes.length === 0 || node.loading) return;
-  const { all, none, half } = getChildState(node.childNodes);
-  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;
-  }
-  const parent = node.parent;
-  if (!parent || parent.level === 0) return;
-  if (!node.store.checkStrictly) {
-    reInitChecked(parent);
+import { hasOwn as m } from "@vft/utils";
+import { reactive as D } from "vue";
+import { markNodeData as C, NODE_KEY as y } from "./util.js";
+const N = (r) => {
+  let e = !0, t = !0, i = !0;
+  for (let s = 0, a = r.length; s < a; s++) {
+    const h = r[s];
+    (h.checked !== !0 || h.indeterminate) && (e = !1, h.disabled || (i = !1)), (h.checked !== !1 || h.indeterminate) && (t = !1);
   }
-};
-const getPropertyFromData = function(node, prop) {
-  const props = node.store.props;
-  const data = node.data || {};
-  const config = props[prop];
-  if (typeof config === "function") {
-    return config(data, node);
-  } else if (typeof config === "string") {
-    return data[config];
-  } else if (typeof config === "undefined") {
-    const dataProp = data[prop];
-    return dataProp === void 0 ? "" : dataProp;
+  return { all: e, none: t, allWithoutDisable: i, half: !e && !t };
+}, o = function(r) {
+  if (r.childNodes.length === 0 || r.loading) return;
+  const { all: e, none: t, half: i } = N(r.childNodes);
+  e ? (r.checked = !0, r.indeterminate = !1) : i ? (r.checked = !1, r.indeterminate = !0) : t && (r.checked = !1, r.indeterminate = !1);
+  const s = r.parent;
+  !s || s.level === 0 || r.store.checkStrictly || o(s);
+}, l = function(r, e) {
+  const t = r.store.props, i = r.data || {}, s = t[e];
+  if (typeof s == "function")
+    return s(i, r);
+  if (typeof s == "string")
+    return i[s];
+  if (typeof s > "u") {
+    const a = i[e];
+    return a === void 0 ? "" : a;
   }
 };
-let nodeIdSeed = 0;
-class Node {
+let L = 0;
+class f {
   id;
   text;
   checked;
@@ -70,378 +44,223 @@ class Node {
   loaded;
   childNodes;
   loading;
-  constructor(options) {
-    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 (const name in options) {
-      if (hasOwn(options, name)) {
-        this[name] = options[name];
-      }
-    }
-    this.level = 0;
-    this.loaded = false;
-    this.childNodes = [];
-    this.loading = false;
-    if (this.parent) {
-      this.level = this.parent.level + 1;
-    }
+  constructor(e) {
+    this.id = L++, this.text = null, this.checked = !1, this.indeterminate = !1, this.data = null, this.expanded = !1, this.parent = null, this.visible = !0, this.isCurrent = !1, this.canFocus = !1;
+    for (const t in e)
+      m(e, t) && (this[t] = e[t]);
+    this.level = 0, this.loaded = !1, this.childNodes = [], this.loading = !1, this.parent && (this.level = this.parent.level + 1);
   }
   initialize() {
-    const store = this.store;
-    if (!store) {
+    const e = this.store;
+    if (!e)
       throw new Error("[Node]store is required!");
-    }
-    store.registerNode(this);
-    const props = store.props;
-    if (props && typeof props.isLeaf !== "undefined") {
-      const isLeaf = getPropertyFromData(this, "isLeaf");
-      if (typeof isLeaf === "boolean") {
-        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.expand();
-    }
-    if (!Array.isArray(this.data)) {
-      markNodeData(this, this.data);
-    }
-    if (!this.data) return;
-    const defaultExpandedKeys = store.defaultExpandedKeys;
-    const key = store.key;
-    if (key && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
-      this.expand(null, store.autoExpandParent);
-    }
-    if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
-      store.currentNode = this;
-      store.currentNode.isCurrent = true;
-    }
-    if (store.lazy) {
-      store._initDefaultCheckedNode(this);
-    }
-    this.updateLeafState();
-    if (this.parent && (this.level === 1 || this.parent.expanded === true))
-      this.canFocus = true;
+    e.registerNode(this);
+    const t = e.props;
+    if (t && typeof t.isLeaf < "u") {
+      const a = l(this, "isLeaf");
+      typeof a == "boolean" && (this.isLeafByUser = a);
+    }
+    if (e.lazy !== !0 && this.data ? (this.setData(this.data), e.defaultExpandAll && (this.expanded = !0, this.canFocus = !0)) : this.level > 0 && e.lazy && e.defaultExpandAll && this.expand(), Array.isArray(this.data) || C(this, this.data), !this.data) return;
+    const i = e.defaultExpandedKeys, s = e.key;
+    s && i && i.includes(this.key) && this.expand(null, e.autoExpandParent), s && e.currentNodeKey !== void 0 && this.key === e.currentNodeKey && (e.currentNode = this, e.currentNode.isCurrent = !0), e.lazy && e._initDefaultCheckedNode(this), this.updateLeafState(), this.parent && (this.level === 1 || this.parent.expanded === !0) && (this.canFocus = !0);
   }
-  setData(data) {
-    if (!Array.isArray(data)) {
-      markNodeData(this, data);
-    }
-    this.data = data;
-    this.childNodes = [];
-    let children;
-    if (this.level === 0 && Array.isArray(this.data)) {
-      children = this.data;
-    } else {
-      children = getPropertyFromData(this, "children") || [];
-    }
-    for (let i = 0, j = children.length; i < j; i++) {
-      this.insertChild({ data: children[i] });
-    }
+  setData(e) {
+    Array.isArray(e) || C(this, e), this.data = e, this.childNodes = [];
+    let t;
+    this.level === 0 && Array.isArray(this.data) ? t = this.data : t = l(this, "children") || [];
+    for (let i = 0, s = t.length; i < s; i++)
+      this.insertChild({ data: t[i] });
   }
   get label() {
-    return getPropertyFromData(this, "label");
+    return l(this, "label");
   }
   get key() {
-    const nodeKey = this.store.key;
-    if (this.data) return this.data[nodeKey];
-    return null;
+    const e = this.store.key;
+    return this.data ? this.data[e] : null;
   }
   get disabled() {
-    return getPropertyFromData(this, "disabled");
+    return l(this, "disabled");
   }
   get nextSibling() {
-    const parent = this.parent;
-    if (parent) {
-      const index = parent.childNodes.indexOf(this);
-      if (index > -1) {
-        return parent.childNodes[index + 1];
-      }
+    const e = this.parent;
+    if (e) {
+      const t = e.childNodes.indexOf(this);
+      if (t > -1)
+        return e.childNodes[t + 1];
     }
     return null;
   }
   get previousSibling() {
-    const parent = this.parent;
-    if (parent) {
-      const index = parent.childNodes.indexOf(this);
-      if (index > -1) {
-        return index > 0 ? parent.childNodes[index - 1] : null;
-      }
+    const e = this.parent;
+    if (e) {
+      const t = e.childNodes.indexOf(this);
+      if (t > -1)
+        return t > 0 ? e.childNodes[t - 1] : null;
     }
     return null;
   }
-  contains(target, deep = true) {
+  contains(e, t = !0) {
     return (this.childNodes || []).some(
-      (child) => child === target || deep && child.contains(target)
+      (i) => i === e || t && i.contains(e)
     );
   }
   remove() {
-    const parent = this.parent;
-    if (parent) {
-      parent.removeChild(this);
-    }
+    const e = this.parent;
+    e && e.removeChild(this);
   }
-  insertChild(child, index, batch) {
-    if (!child) throw new Error("InsertChild error: child is required.");
-    if (!(child instanceof Node)) {
-      if (!batch) {
-        const children = this.getChildren(true);
-        if (!children.includes(child.data)) {
-          if (typeof index === "undefined" || index < 0) {
-            children.push(child.data);
-          } else {
-            children.splice(index, 0, child.data);
-          }
-        }
+  insertChild(e, t, i) {
+    if (!e) throw new Error("InsertChild error: child is required.");
+    if (!(e instanceof f)) {
+      if (!i) {
+        const s = this.getChildren(!0);
+        s.includes(e.data) || (typeof t > "u" || t < 0 ? s.push(e.data) : s.splice(t, 0, e.data));
       }
-      Object.assign(child, {
+      Object.assign(e, {
         parent: this,
         store: this.store
-      });
-      child = reactive(new Node(child));
-      if (child instanceof Node) {
-        child.initialize();
-      }
-    }
-    child.level = this.level + 1;
-    if (typeof index === "undefined" || index < 0) {
-      this.childNodes.push(child);
-    } else {
-      this.childNodes.splice(index, 0, child);
+      }), e = D(new f(e)), e instanceof f && e.initialize();
     }
-    this.updateLeafState();
+    e.level = this.level + 1, typeof t > "u" || t < 0 ? this.childNodes.push(e) : this.childNodes.splice(t, 0, e), this.updateLeafState();
   }
-  updateNode(data) {
-    const parent = this.parent;
-    if (parent) {
-      const index = parent.childNodes.indexOf(this);
-      parent.childNodes[index].data = data;
+  updateNode(e) {
+    const t = this.parent;
+    if (t) {
+      const i = t.childNodes.indexOf(this);
+      t.childNodes[i].data = e;
     }
   }
-  insertBefore(child, ref) {
-    let index;
-    if (ref) {
-      index = this.childNodes.indexOf(ref);
-    }
-    this.insertChild(child, index);
+  insertBefore(e, t) {
+    let i;
+    t && (i = this.childNodes.indexOf(t)), this.insertChild(e, i);
   }
-  insertAfter(child, ref) {
-    let index;
-    if (ref) {
-      index = this.childNodes.indexOf(ref);
-      if (index !== -1) index += 1;
-    }
-    this.insertChild(child, index);
+  insertAfter(e, t) {
+    let i;
+    t && (i = this.childNodes.indexOf(t), i !== -1 && (i += 1)), this.insertChild(e, i);
   }
-  removeChild(child) {
-    const children = this.getChildren() || [];
-    const dataIndex = children.indexOf(child.data);
-    if (dataIndex > -1) {
-      children.splice(dataIndex, 1);
-    }
-    const index = this.childNodes.indexOf(child);
-    if (index > -1) {
-      this.store && this.store.deregisterNode(child);
-      child.parent = null;
-      this.childNodes.splice(index, 1);
-    }
-    this.updateLeafState();
+  removeChild(e) {
+    const t = this.getChildren() || [], i = t.indexOf(e.data);
+    i > -1 && t.splice(i, 1);
+    const s = this.childNodes.indexOf(e);
+    s > -1 && (this.store && this.store.deregisterNode(e), e.parent = null, this.childNodes.splice(s, 1)), this.updateLeafState();
   }
-  removeChildByData(data) {
-    let targetNode = null;
-    for (let i = 0; i < this.childNodes.length; i++) {
-      if (this.childNodes[i].data === data) {
-        targetNode = this.childNodes[i];
+  removeChildByData(e) {
+    let t = null;
+    for (let i = 0; i < this.childNodes.length; i++)
+      if (this.childNodes[i].data === e) {
+        t = this.childNodes[i];
         break;
       }
-    }
-    if (targetNode) {
-      this.removeChild(targetNode);
-    }
+    t && this.removeChild(t);
   }
-  expand(callback, expandParent) {
-    const done = () => {
-      if (expandParent) {
-        let parent = this.parent;
-        while (parent.level > 0) {
-          parent.expanded = true;
-          parent = parent.parent;
-        }
+  expand(e, t) {
+    const i = () => {
+      if (t) {
+        let s = this.parent;
+        for (; s.level > 0; )
+          s.expanded = !0, s = s.parent;
       }
-      this.expanded = true;
-      if (callback) callback();
-      this.childNodes.forEach((item) => {
-        item.canFocus = true;
+      this.expanded = !0, e && e(), this.childNodes.forEach((s) => {
+        s.canFocus = !0;
       });
     };
-    if (this.shouldLoadData()) {
-      this.loadData((data) => {
-        if (Array.isArray(data)) {
-          if (this.checked) {
-            this.setChecked(true, true);
-          } else if (!this.store.checkStrictly) {
-            reInitChecked(this);
-          }
-          done();
-        }
-      });
-    } else {
-      done();
-    }
+    this.shouldLoadData() ? this.loadData((s) => {
+      Array.isArray(s) && (this.checked ? this.setChecked(!0, !0) : this.store.checkStrictly || o(this), i());
+    }) : i();
   }
-  doCreateChildren(array, defaultProps = {}) {
-    array.forEach((item) => {
+  doCreateChildren(e, t = {}) {
+    e.forEach((i) => {
       this.insertChild(
-        Object.assign({ data: item }, defaultProps),
+        Object.assign({ data: i }, t),
         void 0,
-        true
+        !0
       );
     });
   }
   collapse() {
-    this.expanded = false;
-    this.childNodes.forEach((item) => {
-      item.canFocus = false;
+    this.expanded = !1, this.childNodes.forEach((e) => {
+      e.canFocus = !1;
     });
   }
   shouldLoadData() {
-    return this.store.lazy === true && this.store.load && !this.loaded;
+    return this.store.lazy === !0 && this.store.load && !this.loaded;
   }
   updateLeafState() {
-    if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
+    if (this.store.lazy === !0 && this.loaded !== !0 && typeof this.isLeafByUser < "u") {
       this.isLeaf = this.isLeafByUser;
       return;
     }
-    const childNodes = this.childNodes;
-    if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
-      this.isLeaf = !childNodes || childNodes.length === 0;
+    const e = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === !0 && this.loaded === !0) {
+      this.isLeaf = !e || e.length === 0;
       return;
     }
-    this.isLeaf = false;
+    this.isLeaf = !1;
   }
-  setChecked(value, deep, recursion, passValue) {
-    this.indeterminate = value === "half";
-    this.checked = value === true;
-    if (this.store.checkStrictly) return;
+  setChecked(e, t, i, s) {
+    if (this.indeterminate = e === "half", this.checked = e === !0, this.store.checkStrictly) return;
     if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
-      const { all, allWithoutDisable } = getChildState(this.childNodes);
-      if (!this.isLeaf && !all && allWithoutDisable) {
-        this.checked = false;
-        value = false;
-      }
-      const handleDescendants = () => {
-        if (deep) {
-          const childNodes = this.childNodes;
-          for (let i = 0, j = childNodes.length; i < j; i++) {
-            const child = childNodes[i];
-            passValue = passValue || value !== false;
-            const isCheck = child.disabled ? child.checked : passValue;
-            child.setChecked(isCheck, deep, true, passValue);
-          }
-          const { half, all: all2 } = getChildState(childNodes);
-          if (!all2) {
-            this.checked = all2;
-            this.indeterminate = half;
+      const { all: h, allWithoutDisable: d } = N(this.childNodes);
+      !this.isLeaf && !h && d && (this.checked = !1, e = !1);
+      const c = () => {
+        if (t) {
+          const n = this.childNodes;
+          for (let u = 0, k = n.length; u < k; u++) {
+            const p = n[u];
+            s = s || e !== !1;
+            const v = p.disabled ? p.checked : s;
+            p.setChecked(v, t, !0, s);
           }
+          const { half: x, all: g } = N(n);
+          g || (this.checked = g, this.indeterminate = x);
         }
       };
       if (this.shouldLoadData()) {
         this.loadData(
           () => {
-            handleDescendants();
-            reInitChecked(this);
+            c(), o(this);
           },
           {
-            checked: value !== false
+            checked: e !== !1
           }
         );
         return;
-      } else {
-        handleDescendants();
-      }
-    }
-    const parent = this.parent;
-    if (!parent || parent.level === 0) return;
-    if (!recursion) {
-      reInitChecked(parent);
+      } else
+        c();
     }
+    const a = this.parent;
+    !a || a.level === 0 || i || o(a);
   }
-  getChildren(forceInit = false) {
+  getChildren(e = !1) {
     if (this.level === 0) return this.data;
-    const data = this.data;
-    if (!data) return null;
-    const props = this.store.props;
-    let children = "children";
-    if (props) {
-      children = props.children || "children";
-    }
-    if (data[children] === void 0) {
-      data[children] = null;
-    }
-    if (forceInit && !data[children]) {
-      data[children] = [];
-    }
-    return data[children];
+    const t = this.data;
+    if (!t) return null;
+    const i = this.store.props;
+    let s = "children";
+    return i && (s = i.children || "children"), t[s] === void 0 && (t[s] = null), e && !t[s] && (t[s] = []), t[s];
   }
   updateChildren() {
-    const newData = this.getChildren() || [];
-    const oldData = this.childNodes.map((node) => node.data);
-    const newDataMap = {};
-    const newNodes = [];
-    newData.forEach((item, index) => {
-      const key = item[NODE_KEY];
-      const isNodeExists = !!key && oldData.findIndex((data) => data[NODE_KEY] === key) >= 0;
-      if (isNodeExists) {
-        newDataMap[key] = { index, data: item };
-      } else {
-        newNodes.push({ index, data: item });
-      }
-    });
-    if (!this.store.lazy) {
-      oldData.forEach((item) => {
-        if (!newDataMap[item[NODE_KEY]]) this.removeChildByData(item);
-      });
-    }
-    newNodes.forEach(({ index, data }) => {
-      this.insertChild({ data }, index);
-    });
-    this.updateLeafState();
+    const e = this.getChildren() || [], t = this.childNodes.map((a) => a.data), i = {}, s = [];
+    e.forEach((a, h) => {
+      const d = a[y];
+      !!d && t.findIndex((n) => n[y] === d) >= 0 ? i[d] = { index: h, data: a } : s.push({ index: h, data: a });
+    }), this.store.lazy || t.forEach((a) => {
+      i[a[y]] || this.removeChildByData(a);
+    }), s.forEach(({ index: a, data: h }) => {
+      this.insertChild({ data: h }, a);
+    }), this.updateLeafState();
   }
-  loadData(callback, defaultProps = {}) {
-    if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
-      this.loading = true;
-      const resolve = (children) => {
-        this.childNodes = [];
-        this.doCreateChildren(children, defaultProps);
-        this.loaded = true;
-        this.loading = false;
-        this.updateLeafState();
-        if (callback) {
-          callback.call(this, children);
-        }
+  loadData(e, t = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(t).length)) {
+      this.loading = !0;
+      const i = (s) => {
+        this.childNodes = [], this.doCreateChildren(s, t), this.loaded = !0, this.loading = !1, this.updateLeafState(), e && e.call(this, s);
       };
-      this.store.load(this, resolve);
-    } else {
-      if (callback) {
-        callback.call(this);
-      }
-    }
+      this.store.load(this, i);
+    } else
+      e && e.call(this);
   }
 }
 export {
-  Node as default,
-  getChildState
+  f as default,
+  N as getChildState
 };