ep-craft 0.1.33 → 0.1.35

package/dist/components/tree/src/model/node.js

@@ -0,0 +1,263 @@
+import { reactive as m } from "vue";
+import { isNil as D } from "lodash-unified";
+import { isBoolean as S, isUndefined as o } from "../../../../utils/types.js";
+import "@vueuse/core";
+import { hasOwn as b, isArray as c, isFunction as w, isString as z } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { markNodeData as g, NODE_KEY as k } from "./util.js";
+const v = (a) => {
+  let e = !0, t = !0, s = !0, i = !0;
+  for (let h = 0, d = a.length; h < d; h++) {
+    const r = a[h];
+    (r.checked !== !0 || r.indeterminate) && (e = !1, r.disabled || (s = !1)), (r.checked !== !1 || r.indeterminate) && (t = !1), r.isEffectivelyChecked || (i = !1);
+  }
+  return {
+    all: e,
+    none: t,
+    allWithoutDisable: s,
+    half: !e && !t,
+    isEffectivelyChecked: i
+  };
+}, n = function(a) {
+  if (a.childNodes.length === 0 || a.loading) {
+    a.isEffectivelyChecked = a.disabled || a.checked;
+    return;
+  }
+  const { all: e, none: t, half: s, isEffectivelyChecked: i } = v(
+    a.childNodes
+  );
+  a.isEffectivelyChecked = i, e ? (a.checked = !0, a.indeterminate = !1) : s ? (a.checked = !1, a.indeterminate = !0) : t && (a.checked = !1, a.indeterminate = !1);
+  const h = a.parent;
+  !h || h.level === 0 || a.store.checkStrictly || n(h);
+}, u = function(a, e) {
+  const t = a.store.props, s = a.data || {}, i = t[e];
+  if (w(i))
+    return i(s, a);
+  if (z(i))
+    return s[i];
+  if (o(i)) {
+    const h = s[e];
+    return o(h) ? "" : h;
+  }
+}, C = function(a, e) {
+  a.forEach((t) => {
+    t.canFocus = e, C(t.childNodes, e);
+  });
+};
+let O = 0;
+class p {
+  constructor(e) {
+    this.isLeafByUser = void 0, this.isLeaf = void 0, this.isEffectivelyChecked = !1, this.id = O++, 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)
+      b(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() {
+    var h;
+    const e = this.store;
+    if (!e)
+      throw new Error("[Node]store is required!");
+    e.registerNode(this);
+    const t = e.props;
+    if (t && typeof t.isLeaf < "u") {
+      const d = u(this, "isLeaf");
+      S(d) && (this.isLeafByUser = d);
+    }
+    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.isLeafByUser && this.expand(), c(this.data) || g(this, this.data), !this.data) return;
+    const s = e.defaultExpandedKeys, i = e.key;
+    i && !D(this.key) && s && s.includes(this.key) && this.expand(null, e.autoExpandParent), i && e.currentNodeKey !== void 0 && this.key === e.currentNodeKey && (e.currentNode && (e.currentNode.isCurrent = !1), e.currentNode = this, e.currentNode.isCurrent = !0), e.lazy && e._initDefaultCheckedNode(this), this.updateLeafState(), (this.level === 1 || ((h = this.parent) == null ? void 0 : h.expanded) === !0) && (this.canFocus = !0);
+  }
+  setData(e) {
+    c(e) || g(this, e), this.data = e, this.childNodes = [];
+    let t;
+    this.level === 0 && c(this.data) ? t = this.data : t = u(this, "children") || [];
+    for (let s = 0, i = t.length; s < i; s++)
+      this.insertChild({ data: t[s] });
+  }
+  get label() {
+    return u(this, "label");
+  }
+  get key() {
+    const e = this.store.key;
+    return this.data ? this.data[e] : null;
+  }
+  get disabled() {
+    return u(this, "disabled");
+  }
+  get nextSibling() {
+    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 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(e, t = !0) {
+    return (this.childNodes || []).some(
+      (s) => s === e || t && s.contains(e)
+    );
+  }
+  remove() {
+    const e = this.parent;
+    e && e.removeChild(this);
+  }
+  insertChild(e, t, s) {
+    if (!e) throw new Error("InsertChild error: child is required.");
+    if (!(e instanceof p)) {
+      if (!s) {
+        const i = this.getChildren(!0);
+        i != null && i.includes(e.data) || (o(t) || t < 0 ? i == null || i.push(e.data) : i == null || i.splice(t, 0, e.data));
+      }
+      Object.assign(e, {
+        parent: this,
+        store: this.store
+      }), e = m(new p(e)), e instanceof p && e.initialize();
+    }
+    e.level = this.level + 1, o(t) || t < 0 ? this.childNodes.push(e) : this.childNodes.splice(t, 0, e), this.updateLeafState();
+  }
+  insertBefore(e, t) {
+    let s;
+    t && (s = this.childNodes.indexOf(t)), this.insertChild(e, s);
+  }
+  insertAfter(e, t) {
+    let s;
+    t && (s = this.childNodes.indexOf(t), s !== -1 && (s += 1)), this.insertChild(e, s);
+  }
+  removeChild(e) {
+    const t = this.getChildren() || [], s = t.indexOf(e.data);
+    s > -1 && t.splice(s, 1);
+    const i = this.childNodes.indexOf(e);
+    i > -1 && (this.store && this.store.deregisterNode(e), e.parent = null, this.childNodes.splice(i, 1)), this.updateLeafState();
+  }
+  removeChildByData(e) {
+    const t = this.childNodes.find((s) => s.data === e);
+    t && this.removeChild(t);
+  }
+  expand(e, t) {
+    const s = () => {
+      if (t) {
+        let i = this.parent;
+        for (; i && i.level > 0; )
+          i.expanded = !0, i = i.parent;
+      }
+      this.expanded = !0, e && e(), C(this.childNodes, !0);
+    };
+    this.shouldLoadData() ? this.loadData((i) => {
+      c(i) && (this.store.checkStrictly || (this.checked ? this.setChecked(!0, !0) : n(this)), s());
+    }) : s();
+  }
+  doCreateChildren(e, t = {}) {
+    e.forEach((s) => {
+      this.insertChild(
+        Object.assign({ data: s }, t),
+        void 0,
+        !0
+      );
+    });
+  }
+  collapse() {
+    this.expanded = !1, C(this.childNodes, !1);
+  }
+  shouldLoadData() {
+    return !!(this.store.lazy === !0 && this.store.load && !this.loaded);
+  }
+  updateLeafState() {
+    if (this.store.lazy === !0 && this.loaded !== !0 && typeof this.isLeafByUser < "u") {
+      this.isLeaf = this.isLeafByUser, this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    const e = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === !0 && this.loaded === !0) {
+      this.isLeaf = !e || e.length === 0, this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    this.isLeaf = !1;
+  }
+  setChecked(e, t, s, i) {
+    if (this.indeterminate = e === "half", this.checked = e === !0, this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked), this.store.checkStrictly && !t) return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const d = () => {
+        if (t) {
+          const r = this.childNodes;
+          for (let y = 0, x = r.length; y < x; y++) {
+            const f = r[y];
+            i = i || e !== !1;
+            const L = f.disabled && f.isLeaf ? f.checked : i;
+            f.setChecked(L, t, !0, i);
+          }
+          const { half: N, all: l, isEffectivelyChecked: E } = v(r);
+          l || (this.checked = l, this.indeterminate = N), this.isEffectivelyChecked = this.childNodes.length ? E : this.disabled || this.checked;
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(
+          () => {
+            d(), n(this);
+          },
+          {
+            checked: e !== !1
+          }
+        );
+        return;
+      } else
+        d();
+    }
+    const h = this.parent;
+    !h || h.level === 0 || !s && !this.store.checkStrictly && n(h);
+  }
+  getChildren(e = !1) {
+    if (this.level === 0) return this.data;
+    const t = this.data;
+    if (!t) return null;
+    const s = this.store.props;
+    let i = "children";
+    return s && (i = s.children || "children"), o(t[i]) && (t[i] = null), e && !t[i] && (t[i] = []), t[i];
+  }
+  updateChildren() {
+    const e = this.getChildren() || [], t = this.childNodes.map((h) => h.data), s = {}, i = [];
+    e.forEach((h, d) => {
+      const r = h[k];
+      !!r && t.some((l) => (l == null ? void 0 : l[k]) === r) ? s[r] = { index: d, data: h } : i.push({ index: d, data: h });
+    }), this.store.lazy || t.forEach((h) => {
+      s[h == null ? void 0 : h[k]] || this.removeChildByData(h);
+    }), i.forEach(({ index: h, data: d }) => {
+      this.insertChild({ data: d }, h);
+    }), this.updateLeafState();
+  }
+  loadData(e, t = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(t).length)) {
+      this.loading = !0;
+      const s = (h) => {
+        this.childNodes = [], this.doCreateChildren(h, t), this.loaded = !0, this.loading = !1, this.updateLeafState(), e && e.call(this, h);
+      }, i = () => {
+        this.loading = !1;
+      };
+      this.store.load(this, s, i);
+    } else
+      e && e.call(this);
+  }
+  eachNode(e) {
+    const t = [this];
+    for (; t.length; ) {
+      const s = t.shift();
+      t.unshift(...s.childNodes), e(s);
+    }
+  }
+  reInitChecked() {
+    this.store.checkStrictly || n(this);
+  }
+}
+export {
+  p as default,
+  v as getChildState
+};

package/dist/components/tree/src/model/tree-store.d.ts

@@ -0,0 +1,51 @@
+import Node from './node';
+import type { FilterNodeMethodFunction, FilterValue, LoadFunction, TreeData, TreeKey, TreeNodeData, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions } from '../tree.type';
+export default class TreeStore {
+    currentNode: Node | null;
+    currentNodeKey: TreeKey | null;
+    nodesMap: TreeStoreNodesMap;
+    root: Node;
+    data: TreeData;
+    lazy: boolean;
+    load?: LoadFunction;
+    filterNodeMethod?: FilterNodeMethodFunction;
+    key: TreeKey;
+    defaultCheckedKeys?: TreeKey[];
+    checkStrictly: boolean;
+    defaultExpandedKeys?: TreeKey[];
+    autoExpandParent: boolean;
+    defaultExpandAll: boolean;
+    checkDescendants: boolean;
+    props: TreeOptionProps;
+    constructor(options: TreeStoreOptions);
+    initialize(): void;
+    filter(value: FilterValue): void;
+    setData(newVal: TreeData): void;
+    getNode(data: TreeKey | TreeNodeData | Node): Node;
+    insertBefore(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+    insertAfter(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+    remove(data: TreeNodeData | Node): void;
+    append(data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node): void;
+    _initDefaultCheckedNodes(): void;
+    _initDefaultCheckedNode(node: Node): void;
+    setDefaultCheckedKey(newVal: TreeKey[]): void;
+    registerNode(node: Node): void;
+    deregisterNode(node: Node): void;
+    getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): TreeNodeData[];
+    getCheckedKeys(leafOnly?: boolean): TreeKey[];
+    getHalfCheckedNodes(): TreeNodeData[];
+    getHalfCheckedKeys(): TreeKey[];
+    _getAllNodes(): Node[];
+    updateChildren(key: TreeKey, data: TreeData): void;
+    _setCheckedKeys(key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+        [key: string]: boolean;
+    }): void;
+    setCheckedNodes(array: Node[], leafOnly?: boolean): void;
+    setCheckedKeys(keys: TreeKey[], leafOnly?: boolean): void;
+    setDefaultExpandedKeys(keys: TreeKey[]): void;
+    setChecked(data: TreeKey | TreeNodeData, checked: boolean, deep: boolean): void;
+    getCurrentNode(): Node | null;
+    setCurrentNode(currentNode: Node): void;
+    setUserCurrentNode(node: Node, shouldAutoExpandParent?: boolean): void;
+    setCurrentNodeKey(key: TreeKey | null, shouldAutoExpandParent?: boolean): void;
+}

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
+};