vft 0.0.73 → 0.0.76

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

@@ -0,0 +1,197 @@
+import { hasOwn as u, isObject as C } from "@vft/utils";
+import N from "./node.js";
+import { getNodeKey as y } from "./util.js";
+class M {
+  constructor(e) {
+    this.currentNode = null, this.currentNodeKey = null;
+    for (const t in e)
+      u(e, t) && (this[t] = e[t]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new N({
+      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();
+      });
+    } else
+      this._initDefaultCheckedNodes();
+  }
+  filter(e) {
+    const t = this.filterNodeMethod, s = this.lazy, o = function(i) {
+      const d = i.root ? i.root.childNodes : i.childNodes;
+      if (d.forEach((r) => {
+        r.visible = t.call(r, e, r.data, r), o(r);
+      }), !i.visible && d.length) {
+        let r = !0;
+        r = !d.some((h) => h.visible), i.root ? i.root.visible = r === !1 : i.visible = r === !1;
+      }
+      e && i.visible && !i.isLeaf && !s && i.expand();
+    };
+    o(this);
+  }
+  setData(e) {
+    e !== this.root.data ? (this.root.setData(e), this._initDefaultCheckedNodes()) : 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;
+  }
+  insertBefore(e, t) {
+    const s = this.getNode(t);
+    s.parent.insertBefore({ data: e }, s);
+  }
+  insertAfter(e, t) {
+    const s = this.getNode(t);
+    s.parent.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 = t ? this.getNode(t) : this.root;
+    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) {
+    (this.defaultCheckedKeys || []).includes(e.key) && e.setChecked(!0, !this.checkStrictly);
+  }
+  setDefaultCheckedKey(e) {
+    e !== this.defaultCheckedKeys && (this.defaultCheckedKeys = e, 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);
+  }
+  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)
+      u(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 d = o[i];
+      this.remove(d.data);
+    }
+    for (let i = 0, d = t.length; i < d; i++) {
+      const r = t[i];
+      this.append(r, s.data);
+    }
+  }
+  _setCheckedKeys(e, t = !1, s) {
+    const o = this._getAllNodes().sort((r, h) => h.level - r.level), i = /* @__PURE__ */ Object.create(null), d = Object.keys(s);
+    o.forEach((r) => r.setChecked(!1, !1));
+    for (let r = 0, h = o.length; r < h; r++) {
+      const n = o[r], l = n.data[e].toString();
+      if (!d.includes(l)) {
+        n.checked && !i[l] && n.setChecked(!1, !1);
+        continue;
+      }
+      let c = n.parent;
+      for (; c && c.level > 0; )
+        i[c.data[e]] = !0, c = c.parent;
+      if (n.isLeaf || this.checkStrictly) {
+        n.setChecked(!0, !1);
+        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);
+          });
+        };
+        f(n);
+      }
+    }
+  }
+  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) {
+    const s = e[this.key], o = this.nodesMap[s];
+    this.setCurrentNode(o), t && this.currentNode.level > 1 && this.currentNode.parent.expand(null, !0);
+  }
+  setCurrentNodeKey(e, t = !0) {
+    if (e == null) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const s = this.getNode(e);
+    s && (this.setCurrentNode(s), t && this.currentNode.level > 1 && this.currentNode.parent.expand(null, !0));
+  }
+}
+export {
+  M as default
+};

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

@@ -0,0 +1,71 @@
+import { ref as I, provide as S } from "vue";
+import { removeClass as v, addClass as E } from "@vft/utils";
+import { useNamespace as P } from "../../../hooks/use-namespace/index.js";
+import "@popperjs/core";
+import "lodash";
+import "../../../hooks/use-z-index/index.js";
+import "@vueuse/core";
+import "../../../utils/ns-cover.js";
+const B = Symbol("dragEvents");
+function F({ props: p, ctx: s, el$: h, dropIndicator$: b, store: T }) {
+  const g = P("tree"), d = I({
+    showDropIndicator: !1,
+    draggingNode: null,
+    dropNode: null,
+    allowDrop: !0,
+    dropType: null
+  });
+  return S(B, {
+    treeNodeDragStart: ({ event: r, treeNode: t }) => {
+      if (typeof p.allowDrag == "function" && !p.allowDrag(t.node))
+        return r.preventDefault(), !1;
+      r.dataTransfer.effectAllowed = "move";
+      try {
+        r.dataTransfer.setData("text/plain", "");
+      } catch {
+      }
+      d.value.draggingNode = t, s.emit("node-drag-start", t.node, r);
+    },
+    treeNodeDragOver: ({ event: r, treeNode: t }) => {
+      const e = t, o = d.value.dropNode;
+      o && o !== e && v(o.$el, g.is("drop-inner"));
+      const n = d.value.draggingNode;
+      if (!n || !e)
+        return;
+      let l = !0, i = !0, f = !0, N = !0;
+      typeof p.allowDrop == "function" && (l = p.allowDrop(n.node, e.node, "prev"), N = i = p.allowDrop(
+        n.node,
+        e.node,
+        "inner"
+      ), f = p.allowDrop(n.node, e.node, "next")), r.dataTransfer.dropEffect = i || l || f ? "move" : "none", (l || i || f) && o !== e && (o && s.emit("node-drag-leave", n.node, o.node, r), s.emit("node-drag-enter", n.node, e.node, r)), (l || i || f) && (d.value.dropNode = e), e.node.nextSibling === n.node && (f = !1), e.node.previousSibling === n.node && (l = !1), e.node.contains(n.node, !1) && (i = !1), (n.node === e.node || n.node.contains(e.node)) && (l = !1, i = !1, f = !1);
+      const u = e.$el.getBoundingClientRect(), c = h.value.getBoundingClientRect();
+      let a;
+      const $ = l ? i ? 0.25 : f ? 0.45 : 1 : -1, C = f ? i ? 0.75 : l ? 0.55 : 0 : 1;
+      let m = -9999;
+      const w = r.clientY - u.top;
+      w < u.height * $ ? a = "before" : w > u.height * C ? a = "after" : i ? a = "inner" : a = "none";
+      const D = e.$el.querySelector(`.${g.be("node", "expand-icon")}`).getBoundingClientRect(), y = b.value;
+      a === "before" ? m = D.top - c.top : a === "after" && (m = D.bottom - c.top), y.style.top = `${m}px`, y.style.left = `${D.right - c.left}px`, a === "inner" ? E(e.$el, g.is("drop-inner")) : v(e.$el, g.is("drop-inner")), d.value.showDropIndicator = a === "before" || a === "after", d.value.allowDrop = d.value.showDropIndicator || N, d.value.dropType = a, s.emit("node-drag-over", n.node, e.node, r);
+    },
+    treeNodeDragEnd: (r) => {
+      const { draggingNode: t, dropType: e, dropNode: o } = d.value;
+      if (r.preventDefault(), r.dataTransfer.dropEffect = "move", t && o) {
+        const n = { data: t.node.data };
+        e !== "none" && t.node.remove(), e === "before" ? o.node.parent.insertBefore(n, o.node) : e === "after" ? o.node.parent.insertAfter(n, o.node) : e === "inner" && o.node.insertChild(n), e !== "none" && T.value.registerNode(n), v(o.$el, g.is("drop-inner")), s.emit(
+          "node-drag-end",
+          t.node,
+          o.node,
+          e,
+          r
+        ), e !== "none" && s.emit("node-drop", t.node, o.node, e, r);
+      }
+      t && !o && s.emit("node-drag-end", t.node, null, e, r), d.value.showDropIndicator = !1, d.value.draggingNode = null, d.value.dropNode = null, d.value.allowDrop = !0;
+    }
+  }), {
+    dragState: d
+  };
+}
+export {
+  B as dragEventsKey,
+  F as useDragNodeHandler
+};

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

@@ -0,0 +1,81 @@
+import { shallowRef as m, onMounted as v, onUpdated as y, watch as h } from "vue";
+import { useEventListener as b } from "@vueuse/core";
+import { EVENT_CODE as a } from "../../../constants/aria.js";
+import { useNamespace as k } from "../../../hooks/use-namespace/index.js";
+import "@popperjs/core";
+import "lodash";
+import "../../../hooks/use-z-index/index.js";
+import "@vft/utils";
+import "../../../utils/ns-cover.js";
+function K({ el$: l }, d) {
+  const u = k("tree"), t = m([]), i = m([]);
+  v(() => {
+    p();
+  }), y(() => {
+    t.value = Array.from(l.value.querySelectorAll("[role=treeitem]")), i.value = Array.from(
+      l.value.querySelectorAll("input[type=checkbox]")
+    );
+  }), h(i, (r) => {
+    r.forEach((o) => {
+      o.setAttribute("tabindex", "-1");
+    });
+  }), b(l, "keydown", (r) => {
+    const o = r.target;
+    if (!o.className.includes(u.b("node")))
+      return;
+    const c = r.code;
+    t.value = Array.from(
+      l.value.querySelectorAll(`.${u.is("focusable")}[role=treeitem]`)
+    );
+    const n = t.value.indexOf(o);
+    let e;
+    if ([a.up, a.down].includes(c)) {
+      if (r.preventDefault(), c === a.up) {
+        e = n === -1 ? 0 : n !== 0 ? n - 1 : t.value.length - 1;
+        const s = e;
+        for (; !d.value.getNode(t.value[e].dataset.key).canFocus; ) {
+          if (e--, e === s) {
+            e = -1;
+            break;
+          }
+          e < 0 && (e = t.value.length - 1);
+        }
+      } else {
+        e = n === -1 ? 0 : n < t.value.length - 1 ? n + 1 : 0;
+        const s = e;
+        for (; !d.value.getNode(t.value[e].dataset.key).canFocus; ) {
+          if (e++, e === s) {
+            e = -1;
+            break;
+          }
+          e >= t.value.length && (e = 0);
+        }
+      }
+      e !== -1 && t.value[e].focus();
+    }
+    [a.left, a.right].includes(c) && (r.preventDefault(), o.click());
+    const f = o.querySelector(
+      '[type="checkbox"]'
+    );
+    [a.enter, a.space].includes(c) && f && (r.preventDefault(), f.click());
+  });
+  const p = () => {
+    var o;
+    t.value = Array.from(
+      l.value.querySelectorAll(`.${u.is("focusable")}[role=treeitem]`)
+    ), i.value = Array.from(
+      l.value.querySelectorAll("input[type=checkbox]")
+    );
+    const r = l.value.querySelectorAll(
+      `.${u.is("checked")}[role=treeitem]`
+    );
+    if (r.length) {
+      r[0].setAttribute("tabindex", "0");
+      return;
+    }
+    (o = t.value[0]) == null || o.setAttribute("tabindex", "0");
+  };
+}
+export {
+  K as useKeydown
+};

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

@@ -0,0 +1,19 @@
+import { inject as t, provide as a } from "vue";
+function i(e) {
+  const n = t("TreeNodeMap", null), d = {
+    treeNodeExpand: (o) => {
+      e.node !== o && e.node.collapse();
+    },
+    children: []
+  };
+  return n && n.children.push(d), a("TreeNodeMap", d), {
+    broadcastExpanded: (o) => {
+      if (e.accordion)
+        for (const r of d.children)
+          r.treeNodeExpand(o);
+    }
+  };
+}
+export {
+  i as useNodeExpandEventBroadcast
+};

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

@@ -0,0 +1,21 @@
+const t = "$treeNodeId", c = function(r, e) {
+  !e || e[t] || Object.defineProperty(e, t, {
+    value: r.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, l = function(r, e) {
+  return r ? e[r] : e[t];
+}, a = (r, e, u) => {
+  const o = r.value.currentNode;
+  u();
+  const n = r.value.currentNode;
+  o !== n && e("current-change", n ? n.data : null, n);
+};
+export {
+  t as NODE_KEY,
+  l as getNodeKey,
+  a as handleCurrentChange,
+  c as markNodeData
+};

package/es/components/tree/style/css.js

@@ -0,0 +1,3 @@
+import "vft/theme-style/base.css";
+import "vft/theme-style/vft-checkbox.css";
+import "vft/theme-style/vft-tree.css";

package/es/components/tree/style/index.js

@@ -0,0 +1,3 @@
+import "vft/theme-style/src/base.scss";
+import "vft/theme-style/src/checkbox.scss";
+import "vft/theme-style/src/tree.scss";

package/es/components/tree/tree-node-content.vue.js

@@ -0,0 +1,4 @@
+import f from "./tree-node-content.vue2.js";
+export {
+  f as default
+};

package/es/components/tree/tree-node-content.vue2.js

@@ -0,0 +1,28 @@
+import { defineComponent as m, inject as r, h as s } from "vue";
+import { useNamespace as i } from "../../hooks/use-namespace/index.js";
+import "@popperjs/core";
+import "lodash";
+import "../../hooks/use-z-index/index.js";
+import "@vueuse/core";
+import "@vft/utils";
+import "../../utils/ns-cover.js";
+const _ = m({
+  name: "VftTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(t) {
+    const a = i("tree"), c = r("NodeInstance"), n = r("RootTree");
+    return () => {
+      const e = t.node, { data: o, store: d } = e;
+      return t.renderContent ? t.renderContent(s, { _self: c, node: e, data: o, store: d }) : n.ctx.slots.default ? n.ctx.slots.default({ node: e, data: o }) : s("span", { class: a.be("node", "label") }, [e.label]);
+    };
+  }
+});
+export {
+  _ as default
+};

package/es/components/tree/tree-node.vue.js

@@ -0,0 +1,98 @@
+import C from "./tree-node.vue2.js";
+import { resolveComponent as a, withDirectives as g, openBlock as r, createElementBlock as i, normalizeClass as s, withModifiers as d, createElementVNode as v, normalizeStyle as D, createVNode as l, createBlock as p, createCommentVNode as t, withCtx as N, Fragment as y, renderList as E, vShow as k } from "vue";
+import w from "../../_virtual/_plugin-vue_export-helper.js";
+const $ = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"], L = ["aria-expanded"];
+function S(e, n, c, B, M, V) {
+  const h = a("vft-icon"), m = a("vft-checkbox"), u = a("node-content"), b = a("tree-node", !0), f = a("vft-collapse-transition");
+  return g((r(), i("div", {
+    ref: "node$",
+    class: s([
+      e.ns.b("node"),
+      e.ns.is("expanded", e.expanded),
+      e.ns.is("current", e.node.isCurrent),
+      e.ns.is("hidden", !e.node.visible),
+      e.ns.is("focusable", !e.node.disabled),
+      e.ns.is("checked", !e.node.disabled && e.node.checked),
+      e.getNodeClass(e.node)
+    ]),
+    role: "treeitem",
+    tabindex: "-1",
+    "aria-expanded": e.expanded,
+    "aria-disabled": e.node.disabled,
+    "aria-checked": e.node.checked,
+    draggable: e.tree.props.draggable,
+    "data-key": e.getNodeKey(e.node),
+    onClick: n[1] || (n[1] = d((...o) => e.handleClick && e.handleClick(...o), ["stop"])),
+    onContextmenu: n[2] || (n[2] = (...o) => e.handleContextMenu && e.handleContextMenu(...o)),
+    onDragstart: n[3] || (n[3] = d((...o) => e.handleDragStart && e.handleDragStart(...o), ["stop"])),
+    onDragover: n[4] || (n[4] = d((...o) => e.handleDragOver && e.handleDragOver(...o), ["stop"])),
+    onDragend: n[5] || (n[5] = d((...o) => e.handleDragEnd && e.handleDragEnd(...o), ["stop"])),
+    onDrop: n[6] || (n[6] = d((...o) => e.handleDrop && e.handleDrop(...o), ["stop"]))
+  }, [
+    v("div", {
+      class: s(e.ns.be("node", "content")),
+      style: D({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+    }, [
+      l(h, {
+        icon: e.tree.props.icon || "ico-ep:caret-right",
+        class: s([
+          e.ns.be("node", "expand-icon"),
+          e.ns.is("leaf", e.node.isLeaf),
+          {
+            expanded: !e.node.isLeaf && e.expanded
+          }
+        ]),
+        onClick: d(e.handleExpandIconClick, ["stop"])
+      }, null, 8, ["icon", "class", "onClick"]),
+      e.showCheckbox ? (r(), p(m, {
+        key: 0,
+        "model-value": e.node.checked,
+        indeterminate: e.node.indeterminate,
+        disabled: !!e.node.disabled,
+        onClick: n[0] || (n[0] = d(() => {
+        }, ["stop"])),
+        onChange: e.handleCheckChange
+      }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : t("", !0),
+      e.node.loading ? (r(), p(h, {
+        key: 1,
+        icon: "ico-ep:loading",
+        rotate: "",
+        class: s([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+      }, null, 8, ["class"])) : t("", !0),
+      l(u, {
+        node: e.node,
+        "render-content": e.renderContent
+      }, null, 8, ["node", "render-content"])
+    ], 6),
+    l(f, null, {
+      default: N(() => [
+        !e.renderAfterExpand || e.childNodeRendered ? g((r(), i("div", {
+          key: 0,
+          class: s(e.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": e.expanded
+        }, [
+          (r(!0), i(y, null, E(e.node.childNodes, (o) => (r(), p(b, {
+            key: e.getNodeKey(o),
+            "render-content": e.renderContent,
+            "render-after-expand": e.renderAfterExpand,
+            "show-checkbox": e.showCheckbox,
+            node: o,
+            accordion: e.accordion,
+            props: e.props,
+            onNodeExpand: e.handleChildNodeExpand
+          }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))), 128))
+        ], 10, L)), [
+          [k, e.expanded]
+        ]) : t("", !0)
+      ]),
+      _: 1
+    })
+  ], 42, $)), [
+    [k, e.node.visible]
+  ]);
+}
+const O = /* @__PURE__ */ w(C, [["render", S]]);
+export {
+  O as default
+};

package/es/components/tree/tree-node.vue2.js

@@ -0,0 +1,152 @@
+import { defineComponent as S, inject as x, ref as r, getCurrentInstance as T, provide as I, watch as l, nextTick as N } from "vue";
+import { isFunction as _, isString as B } from "@vft/utils";
+import $ from "../collapse-transition/index.js";
+import { VftCheckbox as F } from "../checkbox/index.js";
+import { VftIcon as V } from "../icon/index.js";
+import { debugWarn as j } from "../../utils/error.js";
+import "lodash";
+import "@vueuse/core";
+import "../../utils/ns-cover.js";
+import { useNamespace as w } from "../../hooks/use-namespace/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import H from "./tree-node-content.vue2.js";
+import { getNodeKey as R, handleCurrentChange as A } from "./model/util.js";
+import { useNodeExpandEventBroadcast as L } from "./model/useNodeExpandEventBroadcast.js";
+import { dragEventsKey as M } from "./model/useDragNode.js";
+import P from "./model/node.js";
+const he = S({
+  name: "TreeNode",
+  components: {
+    VftCollapseTransition: $,
+    VftCheckbox: F,
+    NodeContent: H,
+    VftIcon: V
+  },
+  props: {
+    node: {
+      type: P,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["node-expand"],
+  setup(n, k) {
+    const v = w("tree"), { broadcastExpanded: p } = L(n), t = x("RootTree"), c = r(!1), i = r(!1), s = r(null), u = r(null), m = r(null), h = x(M), a = T();
+    I("NodeInstance", a), t || j("Tree", "Can not find node's tree."), n.node.expanded && (c.value = !0, i.value = !0);
+    const y = t.props.children || "children";
+    l(
+      () => {
+        const e = n.node.data[y];
+        return e && [...e];
+      },
+      () => {
+        n.node.updateChildren();
+      }
+    ), l(
+      () => n.node.indeterminate,
+      (e) => {
+        f(n.node.checked, e);
+      }
+    ), l(
+      () => n.node.checked,
+      (e) => {
+        f(e, n.node.indeterminate);
+      }
+    ), l(
+      () => n.node.expanded,
+      (e) => {
+        N(() => c.value = e), e && (i.value = !0);
+      }
+    );
+    const D = (e) => R(t.props.nodeKey, e.data), E = (e) => {
+      const d = n.props.class;
+      if (!d)
+        return {};
+      let o;
+      if (_(d)) {
+        const { data: O } = e;
+        o = d(O, e);
+      } else
+        o = d;
+      return B(o) ? { [o]: !0 } : o;
+    }, f = (e, d) => {
+      (s.value !== e || u.value !== d) && t.ctx.emit("check-change", n.node.data, e, d), s.value = e, u.value = d;
+    }, K = (e) => {
+      A(
+        t.store,
+        t.ctx.emit,
+        () => t.store.value.setCurrentNode(n.node)
+      ), t.currentNode.value = n.node, t.props.expandOnClickNode && g(), t.props.checkOnClickNode && !n.node.disabled && C(null, {
+        target: { checked: !n.node.checked }
+      }), t.ctx.emit("node-click", n.node.data, n.node, a, e);
+    }, b = (e) => {
+      t.instance.vnode.props.onNodeContextmenu && (e.stopPropagation(), e.preventDefault()), t.ctx.emit(
+        "node-contextmenu",
+        e,
+        n.node.data,
+        n.node,
+        a
+      );
+    }, g = () => {
+      n.node.isLeaf || (c.value ? (t.ctx.emit("node-collapse", n.node.data, n.node, a), n.node.collapse()) : (n.node.expand(), k.emit("node-expand", n.node.data, n.node, a)));
+    }, C = (e, d) => {
+      n.node.setChecked(d.target.checked, !t.props.checkStrictly), N(() => {
+        const o = t.store.value;
+        t.ctx.emit("check", n.node.data, {
+          checkedNodes: o.getCheckedNodes(),
+          checkedKeys: o.getCheckedKeys(),
+          halfCheckedNodes: o.getHalfCheckedNodes(),
+          halfCheckedKeys: o.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: v,
+      node$: m,
+      tree: t,
+      expanded: c,
+      childNodeRendered: i,
+      oldChecked: s,
+      oldIndeterminate: u,
+      getNodeKey: D,
+      getNodeClass: E,
+      handleSelectChange: f,
+      handleClick: K,
+      handleContextMenu: b,
+      handleExpandIconClick: g,
+      handleCheckChange: C,
+      handleChildNodeExpand: (e, d, o) => {
+        p(d), t.ctx.emit("node-expand", e, d, o);
+      },
+      handleDragStart: (e) => {
+        t.props.draggable && h.treeNodeDragStart({ event: e, treeNode: n });
+      },
+      handleDragOver: (e) => {
+        e.preventDefault(), t.props.draggable && h.treeNodeDragOver({
+          event: e,
+          treeNode: { $el: m.value, node: n.node }
+        });
+      },
+      handleDrop: (e) => {
+        e.preventDefault();
+      },
+      handleDragEnd: (e) => {
+        t.props.draggable && h.treeNodeDragEnd(e);
+      }
+    };
+  }
+});
+export {
+  he as default
+};

package/es/components/tree/tree.type.js

@@ -0,0 +1 @@
+