fec-dev-designer 1.0.0

package/es/node_modules/element-plus/es/components/tree/src/model/node.js

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

package/es/node_modules/element-plus/es/components/tree/src/model/tree-store.js

@@ -0,0 +1,223 @@
+import { nextTick as p } from "vue";
+import u from "./node.js";
+import { getNodeKey as g } from "./util.js";
+import { hasOwn as N, NOOP as v, isObject as K } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { isPropAbsent as k } from "../../../../utils/types.js";
+import C from "../../../../../../lodash-es/isNil.js";
+class S {
+  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)
+      N(e, t) && (this[t] = e[t]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new u({
+      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();
+        },
+        v
+      );
+    } else
+      this._initDefaultCheckedNodes();
+  }
+  filter(e) {
+    const t = this.filterNodeMethod, s = this.lazy, i = async function(o) {
+      const h = o.root ? o.root.childNodes : o.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 i(d);
+      if (!o.visible && h.length) {
+        let r = !0;
+        r = !h.some((d) => d.visible), o.root ? o.root.visible = r === !1 : o.visible = r === !1;
+      }
+      e && o.visible && !o.isLeaf && (!s || o.loaded) && o.expand();
+    };
+    i(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 u)
+      return e;
+    const t = K(e) ? g(this.key, e) : e;
+    return this.nodesMap[t] || null;
+  }
+  insertBefore(e, t) {
+    var s;
+    const i = this.getNode(t);
+    (s = i.parent) == null || s.insertBefore({ data: e }, i);
+  }
+  insertAfter(e, t) {
+    var s;
+    const i = this.getNode(t);
+    (s = i.parent) == null || s.insertAfter({ data: e }, i);
+  }
+  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 i = t[s];
+      i && i.setChecked(!0, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(e) {
+    const t = this.defaultCheckedKeys || [];
+    !C(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;
+        C(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 = [], 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);
+      });
+    };
+    return i(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((o) => {
+        o.indeterminate && e.push(o.data), t(o);
+      });
+    };
+    return t(this), e;
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((e) => (e || {})[this.key]);
+  }
+  _getAllNodes() {
+    const e = [], t = this.nodesMap;
+    for (const s in t)
+      N(t, s) && e.push(t[s]);
+    return e;
+  }
+  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 h = i[o];
+      this.remove(h.data);
+    }
+    for (let o = 0, h = t.length; o < h; o++) {
+      const r = t[o];
+      this.append(r, s.data);
+    }
+  }
+  _setCheckedKeys(e, t = !1, s) {
+    const i = this._getAllNodes().sort((d, c) => d.level - c.level), o = /* @__PURE__ */ Object.create(null), h = Object.keys(s);
+    i.forEach((d) => d.setChecked(!1, !1));
+    const r = (d) => {
+      d.childNodes.forEach((c) => {
+        var n;
+        o[c.data[e]] = !0, (n = c.childNodes) != null && n.length && r(c);
+      });
+    };
+    for (let d = 0, c = i.length; d < c; d++) {
+      const n = i[d], l = n.data[e].toString();
+      if (!h.includes(l)) {
+        n.checked && !o[l] && n.setChecked(!1, !1);
+        continue;
+      }
+      if (n.childNodes.length && r(n), n.isLeaf || this.checkStrictly) {
+        n.setChecked(!0, !1);
+        continue;
+      }
+      if (n.setChecked(!0, !0), t) {
+        n.setChecked(!1, !1);
+        const f = function(y) {
+          y.childNodes.forEach((a) => {
+            a.isLeaf || a.setChecked(!1, !1), f(a);
+          });
+        };
+        f(n);
+      }
+    }
+  }
+  setCheckedNodes(e, t = !1) {
+    const s = this.key, i = {};
+    e.forEach((o) => {
+      i[(o || {})[s]] = !0;
+    }), this._setCheckedKeys(s, t, i);
+  }
+  setCheckedKeys(e, t = !1) {
+    this.defaultCheckedKeys = e;
+    const s = this.key, i = {};
+    e.forEach((o) => {
+      i[o] = !0;
+    }), this._setCheckedKeys(s, t, i);
+  }
+  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 i = this.getNode(e);
+    i && i.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 s;
+    const i = e[this.key], o = this.nodesMap[i];
+    this.setCurrentNode(o), t && this.currentNode && this.currentNode.level > 1 && ((s = this.currentNode.parent) == null || s.expand(null, !0));
+  }
+  setCurrentNodeKey(e, t = !0) {
+    var s;
+    if (this.currentNodeKey = e, k(e)) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const i = this.getNode(e);
+    i && (this.setCurrentNode(i), t && this.currentNode && this.currentNode.level > 1 && ((s = this.currentNode.parent) == null || s.expand(null, !0)));
+  }
+}
+export {
+  S as default
+};

package/es/node_modules/element-plus/es/components/tree/src/model/useDragNode.js

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

package/es/node_modules/element-plus/es/components/tree/src/model/useKeydown.js

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

package/es/node_modules/element-plus/es/components/tree/src/model/useNodeExpandEventBroadcast.js

@@ -0,0 +1,27 @@
+import { inject as a, onBeforeUnmount as i, provide as c } from "vue";
+import { TREE_NODE_MAP_INJECTION_KEY as t } from "../tokens.js";
+function E(o) {
+  const n = a(
+    t,
+    null
+  );
+  let e = {
+    treeNodeExpand: (r) => {
+      var d;
+      o.node !== r && ((d = o.node) == null || d.collapse());
+    },
+    children: /* @__PURE__ */ new Set()
+  };
+  return n && n.children.add(e), i(() => {
+    n && n.children.delete(e), e = null;
+  }), c(t, e), {
+    broadcastExpanded: (r) => {
+      if (o.accordion)
+        for (const d of e.children)
+          d.treeNodeExpand(r);
+    }
+  };
+}
+export {
+  E as useNodeExpandEventBroadcast
+};