ep-craft 0.1.34 → 0.1.36

package/dist/components/tree/src/model/tree-store.js

@@ -0,0 +1,223 @@
+import { nextTick as p } from "vue";
+import { isNil as N } from "lodash-unified";
+import { isPropAbsent as k } from "../../../../utils/types.js";
+import "@vueuse/core";
+import { hasOwn as C, NOOP as g, isObject as K } from "@vue/shared";
+import "@element-plus/icons-vue";
+import y from "./node.js";
+import { getNodeKey as m } from "./util.js";
+class O {
+  constructor(e) {
+    this.lazy = !1, this.checkStrictly = !1, this.autoExpandParent = !1, this.defaultExpandAll = !1, this.checkDescendants = !1, this.currentNode = null, this.currentNodeKey = null;
+    for (const t in e)
+      C(e, t) && (this[t] = e[t]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new y({
+      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();
+        },
+        g
+      );
+    } else
+      this._initDefaultCheckedNodes();
+  }
+  filter(e) {
+    const t = this.filterNodeMethod, s = this.lazy, o = async function(i) {
+      const h = i.root ? i.root.childNodes : i.childNodes;
+      for (const [r, d] of h.entries())
+        d.visible = !!(t != null && t.call(
+          d,
+          e,
+          d.data,
+          d
+        )), r % 80 === 0 && r > 0 && await p(), await o(d);
+      if (!i.visible && h.length) {
+        let r = !0;
+        r = !h.some((d) => d.visible), i.root ? i.root.visible = r === !1 : i.visible = r === !1;
+      }
+      e && i.visible && !i.isLeaf && (!s || i.loaded) && i.expand();
+    };
+    o(this);
+  }
+  setData(e) {
+    e !== this.root.data ? (this.nodesMap = {}, this.root.setData(e), this._initDefaultCheckedNodes(), this.setCurrentNodeKey(this.currentNodeKey)) : this.root.updateChildren();
+  }
+  getNode(e) {
+    if (e instanceof y) return e;
+    const t = K(e) ? m(this.key, e) : e;
+    return this.nodesMap[t] || null;
+  }
+  insertBefore(e, t) {
+    var o;
+    const s = this.getNode(t);
+    (o = s.parent) == null || o.insertBefore({ data: e }, s);
+  }
+  insertAfter(e, t) {
+    var o;
+    const s = this.getNode(t);
+    (o = s.parent) == null || o.insertAfter({ data: e }, s);
+  }
+  remove(e) {
+    const t = this.getNode(e);
+    t && t.parent && (t === this.currentNode && (this.currentNode = null), t.parent.removeChild(t));
+  }
+  append(e, t) {
+    const s = k(t) ? this.root : this.getNode(t);
+    s && s.insertChild({ data: e });
+  }
+  _initDefaultCheckedNodes() {
+    const e = this.defaultCheckedKeys || [], t = this.nodesMap;
+    e.forEach((s) => {
+      const o = t[s];
+      o && o.setChecked(!0, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(e) {
+    const t = this.defaultCheckedKeys || [];
+    !N(e.key) && t.includes(e.key) && e.setChecked(!0, !this.checkStrictly);
+  }
+  setDefaultCheckedKey(e) {
+    e !== this.defaultCheckedKeys && (this.defaultCheckedKeys = e, this._initDefaultCheckedNodes());
+  }
+  registerNode(e) {
+    const t = this.key;
+    if (!(!e || !e.data))
+      if (!t)
+        this.nodesMap[e.id] = e;
+      else {
+        const s = e.key;
+        N(s) || (this.nodesMap[s] = e);
+      }
+  }
+  deregisterNode(e) {
+    !this.key || !e || !e.data || (e.childNodes.forEach((s) => {
+      this.deregisterNode(s);
+    }), delete this.nodesMap[e.key]);
+  }
+  getCheckedNodes(e = !1, t = !1) {
+    const s = [], o = function(i) {
+      (i.root ? i.root.childNodes : i.childNodes).forEach((r) => {
+        (r.checked || t && r.indeterminate) && (!e || e && r.isLeaf) && s.push(r.data), o(r);
+      });
+    };
+    return o(this), s;
+  }
+  getCheckedKeys(e = !1) {
+    return this.getCheckedNodes(e).map((t) => (t || {})[this.key]);
+  }
+  getHalfCheckedNodes() {
+    const e = [], t = function(s) {
+      (s.root ? s.root.childNodes : s.childNodes).forEach((i) => {
+        i.indeterminate && e.push(i.data), t(i);
+      });
+    };
+    return t(this), e;
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((e) => (e || {})[this.key]);
+  }
+  _getAllNodes() {
+    const e = [], t = this.nodesMap;
+    for (const s in t)
+      C(t, s) && e.push(t[s]);
+    return e;
+  }
+  updateChildren(e, t) {
+    const s = this.nodesMap[e];
+    if (!s) return;
+    const o = s.childNodes;
+    for (let i = o.length - 1; i >= 0; i--) {
+      const h = o[i];
+      this.remove(h.data);
+    }
+    for (let i = 0, h = t.length; i < h; i++) {
+      const r = t[i];
+      this.append(r, s.data);
+    }
+  }
+  _setCheckedKeys(e, t = !1, s) {
+    const o = this._getAllNodes().sort((d, n) => d.level - n.level), i = /* @__PURE__ */ Object.create(null), h = Object.keys(s);
+    o.forEach((d) => d.setChecked(!1, !1));
+    const r = (d) => {
+      d.childNodes.forEach((n) => {
+        var c;
+        i[n.data[e]] = !0, (c = n.childNodes) != null && c.length && r(n);
+      });
+    };
+    for (let d = 0, n = o.length; d < n; d++) {
+      const c = o[d], l = c.data[e].toString();
+      if (!h.includes(l)) {
+        c.checked && !i[l] && c.setChecked(!1, !1);
+        continue;
+      }
+      if (c.childNodes.length && r(c), c.isLeaf || this.checkStrictly) {
+        c.setChecked(!0, !1);
+        continue;
+      }
+      if (c.setChecked(!0, !0), t) {
+        c.setChecked(!1, !1, !0);
+        const f = function(u) {
+          u.childNodes.forEach((a) => {
+            a.isLeaf || a.setChecked(!1, !1, !0), f(a);
+          }), u.reInitChecked();
+        };
+        f(c);
+      }
+    }
+  }
+  setCheckedNodes(e, t = !1) {
+    const s = this.key, o = {};
+    e.forEach((i) => {
+      o[(i || {})[s]] = !0;
+    }), this._setCheckedKeys(s, t, o);
+  }
+  setCheckedKeys(e, t = !1) {
+    this.defaultCheckedKeys = e;
+    const s = this.key, o = {};
+    e.forEach((i) => {
+      o[i] = !0;
+    }), this._setCheckedKeys(s, t, o);
+  }
+  setDefaultExpandedKeys(e) {
+    e = e || [], this.defaultExpandedKeys = e, e.forEach((t) => {
+      const s = this.getNode(t);
+      s && s.expand(null, this.autoExpandParent);
+    });
+  }
+  setChecked(e, t, s) {
+    const o = this.getNode(e);
+    o && o.setChecked(!!t, s);
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  setCurrentNode(e) {
+    const t = this.currentNode;
+    t && (t.isCurrent = !1), this.currentNode = e, this.currentNode.isCurrent = !0;
+  }
+  setUserCurrentNode(e, t = !0) {
+    var i;
+    const s = e[this.key], o = this.nodesMap[s];
+    this.setCurrentNode(o), t && this.currentNode && this.currentNode.level > 1 && ((i = this.currentNode.parent) == null || i.expand(null, !0));
+  }
+  setCurrentNodeKey(e, t = !0) {
+    var o;
+    if (this.currentNodeKey = e, k(e)) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const s = this.getNode(e);
+    s && (this.setCurrentNode(s), t && this.currentNode && this.currentNode.level > 1 && ((o = this.currentNode.parent) == null || o.expand(null, !0)));
+  }
+}
+export {
+  O as default
+};