@xtctwins/tctwins-industry-engine 0.0.9 → 0.0.11

package/dist/StructureTree-CCWwAbnr.mjs

@@ -0,0 +1,1824 @@
+import { _ as ye, u as se, w as Be, b as ze, c as Xe, a as Ze, i as ne, h as we, d as De, e as ge, f as Te, g as me, j as Fe, N as et, k as tt, l as Pe, r as _e, m as nt, E as ot, n as st, o as dt, p as at, q as X, s as rt, t as ke, v as it, x as lt, y as ct, z as ut, A as ee, B as xe, T as $e, C as ht, D as ft, F as pt, G as vt } from "./index-CaiiH-9N.mjs";
+import { _ as yt } from "./tallPanel-eXWPdhmU.mjs";
+import { _ as gt } from "./panel.vue_vue_type_style_index_0_lang-D3swRKXl.mjs";
+import { E as kt } from "./el-checkbox-_VjUMARt.mjs";
+import { defineComponent as re, createBlock as U, openBlock as T, Transition as Nt, mergeProps as Ct, unref as W, toHandlers as mt, withCtx as B, renderSlot as be, ref as D, computed as Ke, onMounted as Ae, onUpdated as Re, resolveDynamicComponent as qe, normalizeStyle as Ue, normalizeClass as H, useAttrs as bt, reactive as Et, nextTick as fe, inject as pe, h as je, onBeforeUnmount as Ve, provide as ve, resolveComponent as te, withDirectives as J, createElementBlock as O, withModifiers as Z, createElementVNode as x, createVNode as I, createCommentVNode as le, Fragment as ue, renderList as he, vShow as G, getCurrentInstance as Ye, watch as R, toDisplayString as q } from "vue";
+import { S as Ne } from "./const-DeViLYl5.mjs";
+import { Loading as _t, CaretRight as xt } from "@element-plus/icons-vue";
+const wt = re({
+  name: "ElCollapseTransition",
+  __name: "collapse-transition",
+  setup(n) {
+    const e = se("collapse-transition"), o = (t) => {
+      t.style.maxHeight = "", t.style.overflow = t.dataset.oldOverflow, t.style.paddingTop = t.dataset.oldPaddingTop, t.style.paddingBottom = t.dataset.oldPaddingBottom;
+    }, s = {
+      beforeEnter(t) {
+        t.dataset || (t.dataset = {}), t.dataset.oldPaddingTop = t.style.paddingTop, t.dataset.oldPaddingBottom = t.style.paddingBottom, t.style.height && (t.dataset.elExistsHeight = t.style.height), t.style.maxHeight = 0, t.style.paddingTop = 0, t.style.paddingBottom = 0;
+      },
+      enter(t) {
+        requestAnimationFrame(() => {
+          t.dataset.oldOverflow = t.style.overflow, t.dataset.elExistsHeight ? t.style.maxHeight = t.dataset.elExistsHeight : t.scrollHeight !== 0 ? t.style.maxHeight = `${t.scrollHeight}px` : t.style.maxHeight = 0, t.style.paddingTop = t.dataset.oldPaddingTop, t.style.paddingBottom = t.dataset.oldPaddingBottom, t.style.overflow = "hidden";
+        });
+      },
+      afterEnter(t) {
+        t.style.maxHeight = "", t.style.overflow = t.dataset.oldOverflow;
+      },
+      enterCancelled(t) {
+        o(t);
+      },
+      beforeLeave(t) {
+        t.dataset || (t.dataset = {}), t.dataset.oldPaddingTop = t.style.paddingTop, t.dataset.oldPaddingBottom = t.style.paddingBottom, t.dataset.oldOverflow = t.style.overflow, t.style.maxHeight = `${t.scrollHeight}px`, t.style.overflow = "hidden";
+      },
+      leave(t) {
+        t.scrollHeight !== 0 && (t.style.maxHeight = 0, t.style.paddingTop = 0, t.style.paddingBottom = 0);
+      },
+      afterLeave(t) {
+        o(t);
+      },
+      leaveCancelled(t) {
+        o(t);
+      }
+    };
+    return (t, d) => (T(), U(Nt, Ct({
+      name: W(e).b()
+    }, mt(s)), {
+      default: B(() => [
+        be(t.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["name"]));
+  }
+});
+var Dt = /* @__PURE__ */ ye(wt, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/collapse-transition/src/collapse-transition.vue"]]);
+const Tt = Be(Dt), Kt = ze({
+  type: {
+    type: String,
+    values: ["primary", "success", "info", "warning", "danger", ""],
+    default: ""
+  },
+  size: {
+    type: String,
+    values: Xe,
+    default: ""
+  },
+  truncated: Boolean,
+  lineClamp: {
+    type: [String, Number]
+  },
+  tag: {
+    type: String,
+    default: "span"
+  }
+}), St = re({
+  name: "ElText",
+  __name: "text",
+  props: Kt,
+  setup(n) {
+    const e = n, o = D(), s = Ze(), t = se("text"), d = Ke(() => [
+      t.b(),
+      t.m(e.type),
+      t.m(s.value),
+      t.is("truncated", e.truncated),
+      t.is("line-clamp", !ne(e.lineClamp))
+    ]), r = () => {
+      var i, f, h, a, u, c, N;
+      if (bt().title)
+        return;
+      let m = !1;
+      const y = ((i = o.value) == null ? void 0 : i.textContent) || "";
+      if (e.truncated) {
+        const w = (f = o.value) == null ? void 0 : f.offsetWidth, K = (h = o.value) == null ? void 0 : h.scrollWidth;
+        w && K && K > w && (m = !0);
+      } else if (!ne(e.lineClamp)) {
+        const w = (a = o.value) == null ? void 0 : a.offsetHeight, K = (u = o.value) == null ? void 0 : u.scrollHeight;
+        w && K && K > w && (m = !0);
+      }
+      m ? (c = o.value) == null || c.setAttribute("title", y) : (N = o.value) == null || N.removeAttribute("title");
+    };
+    return Ae(r), Re(r), (i, f) => (T(), U(qe(i.tag), {
+      ref_key: "textRef",
+      ref: o,
+      class: H(d.value),
+      style: Ue({ "-webkit-line-clamp": i.lineClamp })
+    }, {
+      default: B(() => [
+        be(i.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["class", "style"]));
+  }
+});
+var It = /* @__PURE__ */ ye(St, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/text/src/text.vue"]]);
+const Bt = Be(It), ae = "$treeNodeId", Me = function(n, e) {
+  !e || e[ae] || Object.defineProperty(e, ae, {
+    value: n.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, Le = (n, e) => e == null ? void 0 : e[n || ae], Se = (n, e, o) => {
+  const s = n.value.currentNode;
+  o();
+  const t = n.value.currentNode;
+  s !== t && e("current-change", t ? t.data : null, t);
+}, We = (n) => {
+  let e = !0, o = !0, s = !0, t = !0;
+  for (let d = 0, r = n.length; d < r; d++) {
+    const i = n[d];
+    (i.checked !== !0 || i.indeterminate) && (e = !1, i.disabled || (s = !1)), (i.checked !== !1 || i.indeterminate) && (o = !1), i.isEffectivelyChecked || (t = !1);
+  }
+  return {
+    all: e,
+    none: o,
+    allWithoutDisable: s,
+    half: !e && !o,
+    isEffectivelyChecked: t
+  };
+}, ce = function(n) {
+  if (n.childNodes.length === 0 || n.loading) {
+    n.isEffectivelyChecked = n.disabled || n.checked;
+    return;
+  }
+  const { all: e, none: o, half: s, isEffectivelyChecked: t } = We(
+    n.childNodes
+  );
+  n.isEffectivelyChecked = t, e ? (n.checked = !0, n.indeterminate = !1) : s ? (n.checked = !1, n.indeterminate = !0) : o && (n.checked = !1, n.indeterminate = !1);
+  const d = n.parent;
+  !d || d.level === 0 || n.store.checkStrictly || ce(d);
+}, Ce = function(n, e) {
+  const o = n.store.props, s = n.data || {}, t = o[e];
+  if (me(t))
+    return t(s, n);
+  if (Fe(t))
+    return s[t];
+  if (ne(t)) {
+    const d = s[e];
+    return ne(d) ? "" : d;
+  }
+}, Ie = function(n, e) {
+  n.forEach((o) => {
+    o.canFocus = e, Ie(o.childNodes, e);
+  });
+};
+let At = 0;
+class oe {
+  constructor(e) {
+    this.isLeafByUser = void 0, this.isLeaf = void 0, this.isEffectivelyChecked = !1, this.id = At++, 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 o in e)
+      we(e, o) && (this[o] = e[o]);
+    this.level = 0, this.loaded = !1, this.childNodes = [], this.loading = !1, this.parent && (this.level = this.parent.level + 1);
+  }
+  initialize() {
+    var e;
+    const o = this.store;
+    if (!o)
+      throw new Error("[Node]store is required!");
+    o.registerNode(this);
+    const s = o.props;
+    if (s && typeof s.isLeaf < "u") {
+      const r = Ce(this, "isLeaf");
+      De(r) && (this.isLeafByUser = r);
+    }
+    if (o.lazy !== !0 && this.data ? (this.setData(this.data), o.defaultExpandAll && (this.expanded = !0, this.canFocus = !0)) : this.level > 0 && o.lazy && o.defaultExpandAll && !this.isLeafByUser && this.expand(), ge(this.data) || Me(this, this.data), !this.data)
+      return;
+    const t = o.defaultExpandedKeys, d = o.key;
+    d && !Te(this.key) && t && t.includes(this.key) && this.expand(null, o.autoExpandParent), d && o.currentNodeKey !== void 0 && this.key === o.currentNodeKey && (o.currentNode && (o.currentNode.isCurrent = !1), o.currentNode = this, o.currentNode.isCurrent = !0), o.lazy && o._initDefaultCheckedNode(this), this.updateLeafState(), (this.level === 1 || ((e = this.parent) == null ? void 0 : e.expanded) === !0) && (this.canFocus = !0);
+  }
+  setData(e) {
+    ge(e) || Me(this, e), this.data = e, this.childNodes = [];
+    let o;
+    this.level === 0 && ge(this.data) ? o = this.data : o = Ce(this, "children") || [];
+    for (let s = 0, t = o.length; s < t; s++)
+      this.insertChild({ data: o[s] });
+  }
+  get label() {
+    return Ce(this, "label");
+  }
+  get key() {
+    const e = this.store.key;
+    return this.data ? this.data[e] : null;
+  }
+  get disabled() {
+    return Ce(this, "disabled");
+  }
+  get nextSibling() {
+    const e = this.parent;
+    if (e) {
+      const o = e.childNodes.indexOf(this);
+      if (o > -1)
+        return e.childNodes[o + 1];
+    }
+    return null;
+  }
+  get previousSibling() {
+    const e = this.parent;
+    if (e) {
+      const o = e.childNodes.indexOf(this);
+      if (o > -1)
+        return o > 0 ? e.childNodes[o - 1] : null;
+    }
+    return null;
+  }
+  contains(e, o = !0) {
+    return (this.childNodes || []).some(
+      (s) => s === e || o && s.contains(e)
+    );
+  }
+  remove() {
+    const e = this.parent;
+    e && e.removeChild(this);
+  }
+  insertChild(e, o, s) {
+    if (!e)
+      throw new Error("InsertChild error: child is required.");
+    if (!(e instanceof oe)) {
+      if (!s) {
+        const t = this.getChildren(!0);
+        t != null && t.includes(e.data) || (ne(o) || o < 0 ? t == null || t.push(e.data) : t == null || t.splice(o, 0, e.data));
+      }
+      Object.assign(e, {
+        parent: this,
+        store: this.store
+      }), e = Et(new oe(e)), e instanceof oe && e.initialize();
+    }
+    e.level = this.level + 1, ne(o) || o < 0 ? this.childNodes.push(e) : this.childNodes.splice(o, 0, e), this.updateLeafState();
+  }
+  insertBefore(e, o) {
+    let s;
+    o && (s = this.childNodes.indexOf(o)), this.insertChild(e, s);
+  }
+  insertAfter(e, o) {
+    let s;
+    o && (s = this.childNodes.indexOf(o), s !== -1 && (s += 1)), this.insertChild(e, s);
+  }
+  removeChild(e) {
+    const o = this.getChildren() || [], s = o.indexOf(e.data);
+    s > -1 && o.splice(s, 1);
+    const t = this.childNodes.indexOf(e);
+    t > -1 && (this.store && this.store.deregisterNode(e), e.parent = null, this.childNodes.splice(t, 1)), this.updateLeafState();
+  }
+  removeChildByData(e) {
+    const o = this.childNodes.find((s) => s.data === e);
+    o && this.removeChild(o);
+  }
+  expand(e, o) {
+    const s = () => {
+      if (o) {
+        let t = this.parent;
+        for (; t && t.level > 0; )
+          t.expanded = !0, t = t.parent;
+      }
+      this.expanded = !0, e && e(), Ie(this.childNodes, !0);
+    };
+    this.shouldLoadData() ? this.loadData((t) => {
+      ge(t) && (this.checked ? this.setChecked(!0, !0) : this.store.checkStrictly || ce(this), s());
+    }) : s();
+  }
+  doCreateChildren(e, o = {}) {
+    e.forEach((s) => {
+      this.insertChild(
+        Object.assign({ data: s }, o),
+        void 0,
+        !0
+      );
+    });
+  }
+  collapse() {
+    this.expanded = !1, Ie(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, o, s, t) {
+    if (this.indeterminate = e === "half", this.checked = e === !0, this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked), this.store.checkStrictly)
+      return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const r = () => {
+        if (o) {
+          const i = this.childNodes;
+          for (let u = 0, c = i.length; u < c; u++) {
+            const N = i[u];
+            t = t || e !== !1;
+            const C = N.disabled && N.isLeaf ? N.checked : t;
+            N.setChecked(C, o, !0, t);
+          }
+          const { half: f, all: h, isEffectivelyChecked: a } = We(i);
+          h || (this.checked = h, this.indeterminate = f), this.isEffectivelyChecked = this.childNodes.length ? a : this.disabled || this.checked;
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(
+          () => {
+            r(), ce(this);
+          },
+          {
+            checked: e !== !1
+          }
+        );
+        return;
+      } else
+        r();
+    }
+    const d = this.parent;
+    !d || d.level === 0 || s || ce(d);
+  }
+  getChildren(e = !1) {
+    if (this.level === 0)
+      return this.data;
+    const o = this.data;
+    if (!o)
+      return null;
+    const s = this.store.props;
+    let t = "children";
+    return s && (t = s.children || "children"), ne(o[t]) && (o[t] = null), e && !o[t] && (o[t] = []), o[t];
+  }
+  updateChildren() {
+    const e = this.getChildren() || [], o = this.childNodes.map((d) => d.data), s = {}, t = [];
+    e.forEach((d, r) => {
+      const i = d[ae];
+      !!i && o.some((h) => (h == null ? void 0 : h[ae]) === i) ? s[i] = { index: r, data: d } : t.push({ index: r, data: d });
+    }), this.store.lazy || o.forEach((d) => {
+      s[d == null ? void 0 : d[ae]] || this.removeChildByData(d);
+    }), t.forEach(({ index: d, data: r }) => {
+      this.insertChild({ data: r }, d);
+    }), this.updateLeafState();
+  }
+  loadData(e, o = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(o).length)) {
+      this.loading = !0;
+      const s = (d) => {
+        this.childNodes = [], this.doCreateChildren(d, o), this.loaded = !0, this.loading = !1, this.updateLeafState(), e && e.call(this, d);
+      }, t = () => {
+        this.loading = !1;
+      };
+      this.store.load(this, s, t);
+    } else
+      e && e.call(this);
+  }
+  eachNode(e) {
+    const o = [this];
+    for (; o.length; ) {
+      const s = o.shift();
+      o.unshift(...s.childNodes), e(s);
+    }
+  }
+  reInitChecked() {
+    this.store.checkStrictly || ce(this);
+  }
+}
+class Lt {
+  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 o in e)
+      we(e, o) && (this[o] = e[o]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new oe({
+      data: this.data,
+      store: this
+    }), this.root.initialize(), this.lazy && this.load) {
+      const e = this.load;
+      e(
+        this.root,
+        (o) => {
+          this.root.doCreateChildren(o), this._initDefaultCheckedNodes();
+        },
+        et
+      );
+    } else
+      this._initDefaultCheckedNodes();
+  }
+  filter(e) {
+    const o = this.filterNodeMethod, s = this.lazy, t = async function(d) {
+      const r = d.root ? d.root.childNodes : d.childNodes;
+      for (const [i, f] of r.entries())
+        f.visible = !!(o != null && o.call(
+          f,
+          e,
+          f.data,
+          f
+        )), i % 80 === 0 && i > 0 && await fe(), await t(f);
+      if (!d.visible && r.length) {
+        let i = !0;
+        i = !r.some((f) => f.visible), d.root ? d.root.visible = i === !1 : d.visible = i === !1;
+      }
+      e && d.visible && !d.isLeaf && (!s || d.loaded) && d.expand();
+    };
+    t(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 oe)
+      return e;
+    const o = tt(e) ? Le(this.key, e) : e;
+    return this.nodesMap[o] || null;
+  }
+  insertBefore(e, o) {
+    var s;
+    const t = this.getNode(o);
+    (s = t.parent) == null || s.insertBefore({ data: e }, t);
+  }
+  insertAfter(e, o) {
+    var s;
+    const t = this.getNode(o);
+    (s = t.parent) == null || s.insertAfter({ data: e }, t);
+  }
+  remove(e) {
+    const o = this.getNode(e);
+    o && o.parent && (o === this.currentNode && (this.currentNode = null), o.parent.removeChild(o));
+  }
+  append(e, o) {
+    const s = Pe(o) ? this.root : this.getNode(o);
+    s && s.insertChild({ data: e });
+  }
+  _initDefaultCheckedNodes() {
+    const e = this.defaultCheckedKeys || [], o = this.nodesMap;
+    e.forEach((s) => {
+      const t = o[s];
+      t && t.setChecked(!0, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(e) {
+    const o = this.defaultCheckedKeys || [];
+    !Te(e.key) && o.includes(e.key) && e.setChecked(!0, !this.checkStrictly);
+  }
+  setDefaultCheckedKey(e) {
+    e !== this.defaultCheckedKeys && (this.defaultCheckedKeys = e, this._initDefaultCheckedNodes());
+  }
+  registerNode(e) {
+    const o = this.key;
+    if (!(!e || !e.data))
+      if (!o)
+        this.nodesMap[e.id] = e;
+      else {
+        const s = e.key;
+        Te(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, o = !1) {
+    const s = [], t = function(d) {
+      (d.root ? d.root.childNodes : d.childNodes).forEach((i) => {
+        (i.checked || o && i.indeterminate) && (!e || e && i.isLeaf) && s.push(i.data), t(i);
+      });
+    };
+    return t(this), s;
+  }
+  getCheckedKeys(e = !1) {
+    return this.getCheckedNodes(e).map((o) => (o || {})[this.key]);
+  }
+  getHalfCheckedNodes() {
+    const e = [], o = function(s) {
+      (s.root ? s.root.childNodes : s.childNodes).forEach((d) => {
+        d.indeterminate && e.push(d.data), o(d);
+      });
+    };
+    return o(this), e;
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((e) => (e || {})[this.key]);
+  }
+  _getAllNodes() {
+    const e = [], o = this.nodesMap;
+    for (const s in o)
+      we(o, s) && e.push(o[s]);
+    return e;
+  }
+  updateChildren(e, o) {
+    const s = this.nodesMap[e];
+    if (!s)
+      return;
+    const t = s.childNodes;
+    for (let d = t.length - 1; d >= 0; d--) {
+      const r = t[d];
+      this.remove(r.data);
+    }
+    for (let d = 0, r = o.length; d < r; d++) {
+      const i = o[d];
+      this.append(i, s.data);
+    }
+  }
+  _setCheckedKeys(e, o = !1, s) {
+    const t = this._getAllNodes().sort((f, h) => f.level - h.level), d = /* @__PURE__ */ Object.create(null), r = Object.keys(s);
+    t.forEach((f) => f.setChecked(!1, !1));
+    const i = (f) => {
+      f.childNodes.forEach((h) => {
+        var a;
+        d[h.data[e]] = !0, (a = h.childNodes) != null && a.length && i(h);
+      });
+    };
+    for (let f = 0, h = t.length; f < h; f++) {
+      const a = t[f], u = a.data[e].toString();
+      if (!r.includes(u)) {
+        a.checked && !d[u] && a.setChecked(!1, !1);
+        continue;
+      }
+      if (a.childNodes.length && i(a), a.isLeaf || this.checkStrictly) {
+        a.setChecked(!0, !1);
+        continue;
+      }
+      if (a.setChecked(!0, !0), o) {
+        a.setChecked(!1, !1);
+        const N = function(C) {
+          C.childNodes.forEach((y) => {
+            y.isLeaf || y.setChecked(!1, !1), N(y);
+          });
+        };
+        N(a);
+      }
+    }
+  }
+  setCheckedNodes(e, o = !1) {
+    const s = this.key, t = {};
+    e.forEach((d) => {
+      t[(d || {})[s]] = !0;
+    }), this._setCheckedKeys(s, o, t);
+  }
+  setCheckedKeys(e, o = !1) {
+    this.defaultCheckedKeys = e;
+    const s = this.key, t = {};
+    e.forEach((d) => {
+      t[d] = !0;
+    }), this._setCheckedKeys(s, o, t);
+  }
+  setDefaultExpandedKeys(e) {
+    e = e || [], this.defaultExpandedKeys = e, e.forEach((o) => {
+      const s = this.getNode(o);
+      s && s.expand(null, this.autoExpandParent);
+    });
+  }
+  setChecked(e, o, s) {
+    const t = this.getNode(e);
+    t && t.setChecked(!!o, s);
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  setCurrentNode(e) {
+    const o = this.currentNode;
+    o && (o.isCurrent = !1), this.currentNode = e, this.currentNode.isCurrent = !0;
+  }
+  setUserCurrentNode(e, o = !0) {
+    var s;
+    const t = e[this.key], d = this.nodesMap[t];
+    this.setCurrentNode(d), o && this.currentNode && this.currentNode.level > 1 && ((s = this.currentNode.parent) == null || s.expand(null, !0));
+  }
+  setCurrentNodeKey(e, o = !0) {
+    var s;
+    if (this.currentNodeKey = e, Pe(e)) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const t = this.getNode(e);
+    t && (this.setCurrentNode(t), o && this.currentNode && this.currentNode.level > 1 && ((s = this.currentNode.parent) == null || s.expand(null, !0)));
+  }
+}
+const Oe = "RootTree", Je = "NodeInstance", He = "TreeNodeMap", Ot = re({
+  name: "ElTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(n) {
+    const e = se("tree"), o = pe(
+      Je
+    ), s = pe(Oe);
+    return () => {
+      const t = n.node, { data: d, store: r } = t;
+      return n.renderContent ? n.renderContent(je, { _self: o, node: t, data: d, store: r }) : be(s.ctx.slots, "default", { node: t, data: d }, () => [
+        je(
+          Bt,
+          { tag: "span", truncated: !0, class: e.be("node", "label") },
+          () => [t.label]
+        )
+      ]);
+    };
+  }
+});
+var Pt = /* @__PURE__ */ ye(Ot, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node-content.vue"]]);
+function Ge(n) {
+  const e = pe(
+    He,
+    null
+  );
+  let o = {
+    treeNodeExpand: (s) => {
+      var t;
+      n.node !== s && ((t = n.node) == null || t.collapse());
+    },
+    children: /* @__PURE__ */ new Set()
+  };
+  return e && e.children.add(o), Ve(() => {
+    e && e.children.delete(o), o = null;
+  }), ve(He, o), {
+    broadcastExpanded: (s) => {
+      if (n.accordion)
+        for (const t of o.children)
+          t.treeNodeExpand(s);
+    }
+  };
+}
+const Qe = Symbol("dragEvents");
+function $t({
+  props: n,
+  ctx: e,
+  el$: o,
+  dropIndicator$: s,
+  store: t
+}) {
+  const d = se("tree"), r = D({
+    showDropIndicator: !1,
+    draggingNode: null,
+    dropNode: null,
+    allowDrop: !0,
+    dropType: null
+  });
+  return ve(Qe, {
+    treeNodeDragStart: ({ event: a, treeNode: u }) => {
+      if (a.dataTransfer) {
+        if (me(n.allowDrag) && !n.allowDrag(u.node))
+          return a.preventDefault(), !1;
+        a.dataTransfer.effectAllowed = "move";
+        try {
+          a.dataTransfer.setData("text/plain", "");
+        } catch {
+        }
+        r.value.draggingNode = u, e.emit("node-drag-start", u.node, a);
+      }
+    },
+    treeNodeDragOver: ({ event: a, treeNode: u }) => {
+      if (!a.dataTransfer)
+        return;
+      const c = u, N = r.value.dropNode;
+      N && N.node.id !== c.node.id && _e(N.$el, d.is("drop-inner"));
+      const C = r.value.draggingNode;
+      if (!C || !c)
+        return;
+      let m = !0, y = !0, w = !0, K = !0;
+      me(n.allowDrop) && (m = n.allowDrop(C.node, c.node, "prev"), K = y = n.allowDrop(
+        C.node,
+        c.node,
+        "inner"
+      ), w = n.allowDrop(C.node, c.node, "next")), a.dataTransfer.dropEffect = y || m || w ? "move" : "none", (m || y || w) && (N == null ? void 0 : N.node.id) !== c.node.id && (N && e.emit("node-drag-leave", C.node, N.node, a), e.emit("node-drag-enter", C.node, c.node, a)), m || y || w ? r.value.dropNode = c : r.value.dropNode = null, c.node.nextSibling === C.node && (w = !1), c.node.previousSibling === C.node && (m = !1), c.node.contains(C.node, !1) && (y = !1), (C.node === c.node || C.node.contains(c.node)) && (m = !1, y = !1, w = !1);
+      const z = c.$el, P = z.querySelector(`.${d.be("node", "content")}`).getBoundingClientRect(), $ = o.value.getBoundingClientRect(), Q = o.value.scrollTop;
+      let A;
+      const de = m ? y ? 0.25 : w ? 0.45 : 1 : Number.NEGATIVE_INFINITY, g = w ? y ? 0.75 : m ? 0.55 : 0 : Number.POSITIVE_INFINITY;
+      let E = -9999;
+      const S = a.clientY - P.top;
+      S < P.height * de ? A = "before" : S > P.height * g ? A = "after" : y ? A = "inner" : A = "none";
+      const L = z.querySelector(`.${d.be("node", "expand-icon")}`).getBoundingClientRect(), F = s.value;
+      A === "before" ? E = L.top - $.top + Q : A === "after" && (E = L.bottom - $.top + Q), F.style.top = `${E}px`, F.style.left = `${L.right - $.left}px`, A === "inner" ? nt(z, d.is("drop-inner")) : _e(z, d.is("drop-inner")), r.value.showDropIndicator = A === "before" || A === "after", r.value.allowDrop = r.value.showDropIndicator || K, r.value.dropType = A, e.emit("node-drag-over", C.node, c.node, a);
+    },
+    treeNodeDragEnd: (a) => {
+      var u, c;
+      const { draggingNode: N, dropType: C, dropNode: m } = r.value;
+      if (a.preventDefault(), a.dataTransfer && (a.dataTransfer.dropEffect = "move"), N != null && N.node.data && m) {
+        const y = { data: N.node.data };
+        C !== "none" && N.node.remove(), C === "before" ? (u = m.node.parent) == null || u.insertBefore(y, m.node) : C === "after" ? (c = m.node.parent) == null || c.insertAfter(y, m.node) : C === "inner" && m.node.insertChild(y), C !== "none" && (t.value.registerNode(y), t.value.key && N.node.eachNode((w) => {
+          var K;
+          (K = t.value.nodesMap[w.data[t.value.key]]) == null || K.setChecked(
+            w.checked,
+            !t.value.checkStrictly
+          );
+        })), _e(m.$el, d.is("drop-inner")), e.emit(
+          "node-drag-end",
+          N.node,
+          m.node,
+          C,
+          a
+        ), C !== "none" && e.emit(
+          "node-drop",
+          N.node,
+          m.node,
+          C,
+          a
+        );
+      }
+      N && !m && e.emit("node-drag-end", N.node, null, C, a), r.value.showDropIndicator = !1, r.value.draggingNode = null, r.value.dropNode = null, r.value.allowDrop = !0;
+    }
+  }), {
+    dragState: r
+  };
+}
+const jt = re({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: Tt,
+    ElCheckbox: kt,
+    NodeContent: Pt,
+    ElIcon: ot,
+    Loading: _t
+  },
+  props: {
+    node: {
+      type: oe,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(n, e) {
+    const o = se("tree"), { broadcastExpanded: s } = Ge(n), t = pe(Oe), d = D(!1), r = D(!1), i = D(), f = D(), h = D(), a = pe(Qe), u = Ye();
+    ve(Je, u), t || st("Tree", "Can not find node's tree."), n.node.expanded && (d.value = !0, r.value = !0);
+    const c = t.props.props.children || "children";
+    R(
+      () => {
+        var g;
+        const E = (g = n.node.data) == null ? void 0 : g[c];
+        return E && [...E];
+      },
+      () => {
+        n.node.updateChildren();
+      }
+    ), R(
+      () => n.node.indeterminate,
+      (g) => {
+        m(n.node.checked, g);
+      }
+    ), R(
+      () => n.node.checked,
+      (g) => {
+        m(g, n.node.indeterminate);
+      }
+    ), R(
+      () => n.node.childNodes.length,
+      () => n.node.reInitChecked()
+    ), R(
+      () => n.node.expanded,
+      (g) => {
+        fe(() => d.value = g), g && (r.value = !0);
+      }
+    );
+    const N = (g) => Le(t.props.nodeKey, g.data), C = (g) => {
+      const E = n.props.class;
+      if (!E)
+        return {};
+      let S;
+      if (me(E)) {
+        const { data: L } = g;
+        S = E(L, g);
+      } else
+        S = E;
+      return Fe(S) ? { [S]: !0 } : S;
+    }, m = (g, E) => {
+      (i.value !== g || f.value !== E) && t.ctx.emit("check-change", n.node.data, g, E), i.value = g, f.value = E;
+    }, y = (g) => {
+      Se(t.store, t.ctx.emit, () => {
+        var E;
+        if ((E = t == null ? void 0 : t.props) == null ? void 0 : E.nodeKey) {
+          const L = N(n.node);
+          t.store.value.setCurrentNodeKey(L);
+        } else
+          t.store.value.setCurrentNode(n.node);
+      }), t.currentNode.value = n.node, t.props.expandOnClickNode && K(), (t.props.checkOnClickNode || n.node.isLeaf && t.props.checkOnClickLeaf && n.showCheckbox) && !n.node.disabled && z(!n.node.checked), t.ctx.emit("node-click", n.node.data, n.node, u, g);
+    }, w = (g) => {
+      var E;
+      (E = t.instance.vnode.props) != null && E.onNodeContextmenu && (g.stopPropagation(), g.preventDefault()), t.ctx.emit(
+        "node-contextmenu",
+        g,
+        n.node.data,
+        n.node,
+        u
+      );
+    }, K = () => {
+      n.node.isLeaf || (d.value ? (t.ctx.emit("node-collapse", n.node.data, n.node, u), n.node.collapse()) : n.node.expand(() => {
+        e.emit("node-expand", n.node.data, n.node, u);
+      }));
+    }, z = (g) => {
+      const E = t == null ? void 0 : t.props.checkStrictly, S = n.node.childNodes;
+      !E && S.length && (g = S.some((L) => !L.isEffectivelyChecked)), n.node.setChecked(g, !E), fe(() => {
+        const L = t.store.value;
+        t.ctx.emit("check", n.node.data, {
+          checkedNodes: L.getCheckedNodes(),
+          checkedKeys: L.getCheckedKeys(),
+          halfCheckedNodes: L.getHalfCheckedNodes(),
+          halfCheckedKeys: L.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: o,
+      node$: h,
+      tree: t,
+      expanded: d,
+      childNodeRendered: r,
+      oldChecked: i,
+      oldIndeterminate: f,
+      getNodeKey: N,
+      getNodeClass: C,
+      handleSelectChange: m,
+      handleClick: y,
+      handleContextMenu: w,
+      handleExpandIconClick: K,
+      handleCheckChange: z,
+      handleChildNodeExpand: (g, E, S) => {
+        s(E), t.ctx.emit("node-expand", g, E, S);
+      },
+      handleDragStart: (g) => {
+        t.props.draggable && a.treeNodeDragStart({ event: g, treeNode: n });
+      },
+      handleDragOver: (g) => {
+        g.preventDefault(), t.props.draggable && a.treeNodeDragOver({
+          event: g,
+          treeNode: { $el: h.value, node: n.node }
+        });
+      },
+      handleDrop: (g) => {
+        g.preventDefault();
+      },
+      handleDragEnd: (g) => {
+        t.props.draggable && a.treeNodeDragEnd(g);
+      },
+      CaretRight: xt
+    };
+  }
+}), Mt = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"], Ht = ["aria-expanded"];
+function zt(n, e, o, s, t, d) {
+  const r = te("el-icon"), i = te("el-checkbox"), f = te("loading"), h = te("node-content"), a = te("el-tree-node"), u = te("el-collapse-transition");
+  return J((T(), O("div", {
+    ref: "node$",
+    class: H([
+      n.ns.b("node"),
+      n.ns.is("expanded", n.expanded),
+      n.ns.is("current", n.node.isCurrent),
+      n.ns.is("hidden", !n.node.visible),
+      n.ns.is("focusable", !n.node.disabled),
+      n.ns.is("checked", !n.node.disabled && n.node.checked),
+      n.getNodeClass(n.node)
+    ]),
+    role: "treeitem",
+    tabindex: "-1",
+    "aria-expanded": n.expanded,
+    "aria-disabled": n.node.disabled,
+    "aria-checked": n.node.checked,
+    draggable: n.tree.props.draggable,
+    "data-key": n.getNodeKey(n.node),
+    onClick: e[2] || (e[2] = Z((...c) => n.handleClick && n.handleClick(...c), ["stop"])),
+    onContextmenu: e[3] || (e[3] = (...c) => n.handleContextMenu && n.handleContextMenu(...c)),
+    onDragstart: e[4] || (e[4] = Z((...c) => n.handleDragStart && n.handleDragStart(...c), ["stop"])),
+    onDragover: e[5] || (e[5] = Z((...c) => n.handleDragOver && n.handleDragOver(...c), ["stop"])),
+    onDragend: e[6] || (e[6] = Z((...c) => n.handleDragEnd && n.handleDragEnd(...c), ["stop"])),
+    onDrop: e[7] || (e[7] = Z((...c) => n.handleDrop && n.handleDrop(...c), ["stop"]))
+  }, [
+    x(
+      "div",
+      {
+        class: H(n.ns.be("node", "content")),
+        style: Ue({ paddingLeft: (n.node.level - 1) * n.tree.props.indent + "px" })
+      },
+      [
+        n.tree.props.icon || n.CaretRight ? (T(), U(r, {
+          key: 0,
+          class: H([
+            n.ns.be("node", "expand-icon"),
+            n.ns.is("leaf", n.node.isLeaf),
+            {
+              expanded: !n.node.isLeaf && n.expanded
+            }
+          ]),
+          onClick: Z(n.handleExpandIconClick, ["stop"])
+        }, {
+          default: B(() => [
+            (T(), U(qe(n.tree.props.icon || n.CaretRight)))
+          ]),
+          _: 1
+        }, 8, ["class", "onClick"])) : le("v-if", !0),
+        n.showCheckbox ? (T(), U(i, {
+          key: 1,
+          "model-value": n.node.checked,
+          indeterminate: n.node.indeterminate,
+          disabled: !!n.node.disabled,
+          onClick: e[0] || (e[0] = Z(() => {
+          }, ["stop"])),
+          onChange: n.handleCheckChange
+        }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : le("v-if", !0),
+        n.node.loading ? (T(), U(r, {
+          key: 2,
+          class: H([n.ns.be("node", "loading-icon"), n.ns.is("loading")])
+        }, {
+          default: B(() => [
+            I(f)
+          ]),
+          _: 1
+        }, 8, ["class"])) : le("v-if", !0),
+        I(h, {
+          node: n.node,
+          "render-content": n.renderContent
+        }, null, 8, ["node", "render-content"])
+      ],
+      6
+    ),
+    I(u, null, {
+      default: B(() => [
+        !n.renderAfterExpand || n.childNodeRendered ? J((T(), O("div", {
+          key: 0,
+          class: H(n.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": n.expanded,
+          onClick: e[1] || (e[1] = Z(() => {
+          }, ["stop"]))
+        }, [
+          (T(!0), O(
+            ue,
+            null,
+            he(n.node.childNodes, (c) => (T(), U(a, {
+              key: n.getNodeKey(c),
+              "render-content": n.renderContent,
+              "render-after-expand": n.renderAfterExpand,
+              "show-checkbox": n.showCheckbox,
+              node: c,
+              accordion: n.accordion,
+              props: n.props,
+              onNodeExpand: n.handleChildNodeExpand
+            }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))),
+            128
+          ))
+        ], 10, Ht)), [
+          [G, n.expanded]
+        ]) : le("v-if", !0)
+      ]),
+      _: 1
+    })
+  ], 42, Mt)), [
+    [G, n.node.visible]
+  ]);
+}
+var Ft = /* @__PURE__ */ ye(jt, [["render", zt], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node.vue"]]);
+function Rt({ el$: n }, e) {
+  const o = se("tree");
+  Ae(() => {
+    d();
+  }), Re(() => {
+    var r;
+    (r = n.value) == null || r.querySelectorAll("input[type=checkbox]").forEach((i) => {
+      i.setAttribute("tabindex", "-1");
+    });
+  });
+  function s(r, i) {
+    var f, h;
+    const a = e.value.getNode(r[i].dataset.key);
+    return a.canFocus && a.visible && (((f = a.parent) == null ? void 0 : f.expanded) || ((h = a.parent) == null ? void 0 : h.level) === 0);
+  }
+  dt(n, "keydown", (r) => {
+    const i = r.target;
+    if (!i.className.includes(o.b("node")))
+      return;
+    const f = at(r), h = Array.from(
+      n.value.querySelectorAll(`.${o.is("focusable")}[role=treeitem]`)
+    ), a = h.indexOf(i);
+    let u;
+    if ([X.up, X.down].includes(f)) {
+      if (r.preventDefault(), f === X.up) {
+        u = a === -1 ? 0 : a !== 0 ? a - 1 : h.length - 1;
+        const N = u;
+        for (; !s(h, u); ) {
+          if (u--, u === N) {
+            u = -1;
+            break;
+          }
+          u < 0 && (u = h.length - 1);
+        }
+      } else {
+        u = a === -1 ? 0 : a < h.length - 1 ? a + 1 : 0;
+        const N = u;
+        for (; !s(h, u); ) {
+          if (u++, u === N) {
+            u = -1;
+            break;
+          }
+          u >= h.length && (u = 0);
+        }
+      }
+      u !== -1 && h[u].focus();
+    }
+    [X.left, X.right].includes(f) && (r.preventDefault(), i.click());
+    const c = i.querySelector(
+      '[type="checkbox"]'
+    );
+    [X.enter, X.numpadEnter, X.space].includes(
+      f
+    ) && c && (r.preventDefault(), c.click());
+  });
+  const d = () => {
+    var r;
+    if (!n.value)
+      return;
+    const i = Array.from(
+      n.value.querySelectorAll(`.${o.is("focusable")}[role=treeitem]`)
+    );
+    Array.from(
+      n.value.querySelectorAll("input[type=checkbox]")
+    ).forEach((a) => {
+      a.setAttribute("tabindex", "-1");
+    });
+    const h = n.value.querySelectorAll(
+      `.${o.is("checked")}[role=treeitem]`
+    );
+    if (h.length) {
+      h[0].setAttribute("tabindex", "0");
+      return;
+    }
+    (r = i[0]) == null || r.setAttribute("tabindex", "0");
+  };
+}
+const qt = ze({
+  data: {
+    type: ke(Array),
+    default: () => []
+  },
+  emptyText: {
+    type: String
+  },
+  renderAfterExpand: {
+    type: Boolean,
+    default: !0
+  },
+  nodeKey: String,
+  checkStrictly: Boolean,
+  defaultExpandAll: Boolean,
+  expandOnClickNode: {
+    type: Boolean,
+    default: !0
+  },
+  checkOnClickNode: Boolean,
+  checkOnClickLeaf: {
+    type: Boolean,
+    default: !0
+  },
+  checkDescendants: Boolean,
+  autoExpandParent: {
+    type: Boolean,
+    default: !0
+  },
+  defaultCheckedKeys: {
+    type: Array
+  },
+  defaultExpandedKeys: {
+    type: Array
+  },
+  currentNodeKey: {
+    type: [String, Number]
+  },
+  renderContent: {
+    type: ke(Function)
+  },
+  showCheckbox: Boolean,
+  draggable: Boolean,
+  allowDrag: {
+    type: ke(Function)
+  },
+  allowDrop: {
+    type: ke(Function)
+  },
+  props: {
+    type: Object,
+    default: () => ({
+      children: "children",
+      label: "label",
+      disabled: "disabled"
+    })
+  },
+  lazy: Boolean,
+  highlightCurrent: Boolean,
+  load: {
+    type: Function
+  },
+  filterNodeMethod: {
+    type: Function
+  },
+  accordion: Boolean,
+  indent: {
+    type: Number,
+    default: 18
+  },
+  icon: {
+    type: rt
+  }
+}), Ut = {
+  "check-change": (n, e, o) => n && De(e) && De(o),
+  "current-change": (n, e) => !0,
+  "node-click": (n, e, o, s) => n && e && s instanceof Event,
+  "node-contextmenu": (n, e, o, s) => n instanceof Event && e && o,
+  "node-collapse": (n, e, o) => n && e,
+  "node-expand": (n, e, o) => n && e,
+  check: (n, e) => n && e,
+  "node-drag-start": (n, e) => n && e,
+  "node-drag-end": (n, e, o, s) => n && s,
+  "node-drop": (n, e, o, s) => n && e && s,
+  "node-drag-leave": (n, e, o) => n && e && o,
+  "node-drag-enter": (n, e, o) => n && e && o,
+  "node-drag-over": (n, e, o) => n && e && o
+}, Vt = re({
+  name: "ElTree",
+  components: { ElTreeNode: Ft },
+  props: qt,
+  emits: Ut,
+  setup(n, e) {
+    const { t: o } = it(), s = se("tree"), t = D(
+      new Lt({
+        key: n.nodeKey,
+        data: n.data,
+        lazy: n.lazy,
+        props: n.props,
+        load: n.load,
+        currentNodeKey: n.currentNodeKey,
+        checkStrictly: n.checkStrictly,
+        checkDescendants: n.checkDescendants,
+        defaultCheckedKeys: n.defaultCheckedKeys,
+        defaultExpandedKeys: n.defaultExpandedKeys,
+        autoExpandParent: n.autoExpandParent,
+        defaultExpandAll: n.defaultExpandAll,
+        filterNodeMethod: n.filterNodeMethod
+      })
+    );
+    t.value.initialize();
+    const d = D(t.value.root), r = D(null), i = D(null), f = D(null), { broadcastExpanded: h } = Ge(n), { dragState: a } = $t({
+      props: n,
+      ctx: e,
+      el$: i,
+      dropIndicator$: f,
+      store: t
+    });
+    Rt({ el$: i }, t);
+    const u = Ye(), c = Ke(() => {
+      let l = u == null ? void 0 : u.parent;
+      for (; l; ) {
+        if (l.type.name === "ElTreeSelect")
+          return !0;
+        l = l.parent;
+      }
+      return !1;
+    }), N = Ke(() => {
+      const { childNodes: l } = d.value;
+      return (!l || l.length === 0 || l.every(({ visible: v }) => !v)) && !c.value;
+    });
+    R(
+      () => n.currentNodeKey,
+      (l) => {
+        t.value.setCurrentNodeKey(l ?? null);
+      }
+    ), R(
+      () => n.defaultCheckedKeys,
+      (l, v) => {
+        lt(l, v) || t.value.setDefaultCheckedKey(l ?? []);
+      }
+    ), R(
+      () => n.defaultExpandedKeys,
+      (l) => {
+        t.value.setDefaultExpandedKeys(l ?? []);
+      }
+    ), R(
+      () => n.data,
+      (l) => {
+        t.value.setData(l);
+      },
+      { deep: !0 }
+    ), R(
+      () => n.checkStrictly,
+      (l) => {
+        t.value.checkStrictly = l;
+      }
+    );
+    const C = (l) => {
+      if (!n.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      t.value.filter(l);
+    }, m = (l) => Le(n.nodeKey, l.data), y = (l) => {
+      if (!n.nodeKey)
+        throw new Error(`[Tree] nodeKey is required in ${l}`);
+    }, w = (l) => {
+      y("getNodePath");
+      const v = t.value.getNode(l);
+      if (!v)
+        return [];
+      const j = [v.data];
+      let M = v.parent;
+      for (; M && M !== d.value; )
+        j.push(M.data), M = M.parent;
+      return j.reverse();
+    }, K = (l, v) => t.value.getCheckedNodes(l, v), z = (l) => t.value.getCheckedKeys(l), P = () => {
+      const l = t.value.getCurrentNode();
+      return l ? l.data : null;
+    }, $ = () => {
+      y("getCurrentKey");
+      const l = P();
+      return l ? l[n.nodeKey] : null;
+    }, Q = (l, v) => {
+      y("setCheckedNodes"), t.value.setCheckedNodes(l, v);
+    }, A = (l, v) => {
+      y("setCheckedKeys"), t.value.setCheckedKeys(l, v);
+    }, de = (l, v, j) => {
+      t.value.setChecked(l, v, j);
+    }, g = () => t.value.getHalfCheckedNodes(), E = () => t.value.getHalfCheckedKeys(), S = (l, v = !0) => {
+      y("setCurrentNode"), Se(t, e.emit, () => {
+        h(l), t.value.setUserCurrentNode(l, v);
+      });
+    }, L = (l = null, v = !0) => {
+      y("setCurrentKey"), Se(t, e.emit, () => {
+        h(), t.value.setCurrentNodeKey(l, v);
+      });
+    }, F = (l) => t.value.getNode(l), V = (l) => {
+      t.value.remove(l);
+    }, ie = (l, v) => {
+      t.value.append(l, v);
+    }, p = (l, v) => {
+      t.value.insertBefore(l, v);
+    }, k = (l, v) => {
+      t.value.insertAfter(l, v);
+    }, _ = (l, v, j) => {
+      h(v), e.emit("node-expand", l, v, j);
+    }, Y = (l, v) => {
+      y("updateKeyChild"), t.value.updateChildren(l, v);
+    };
+    return ve(Oe, {
+      ctx: e,
+      props: n,
+      store: t,
+      root: d,
+      currentNode: r,
+      instance: u
+    }), ve(ct, void 0), {
+      ns: s,
+      store: t,
+      root: d,
+      currentNode: r,
+      dragState: a,
+      el$: i,
+      dropIndicator$: f,
+      isEmpty: N,
+      filter: C,
+      getNodeKey: m,
+      getNodePath: w,
+      getCheckedNodes: K,
+      getCheckedKeys: z,
+      getCurrentNode: P,
+      getCurrentKey: $,
+      setCheckedNodes: Q,
+      setCheckedKeys: A,
+      setChecked: de,
+      getHalfCheckedNodes: g,
+      getHalfCheckedKeys: E,
+      setCurrentNode: S,
+      setCurrentKey: L,
+      t: o,
+      getNode: F,
+      remove: V,
+      append: ie,
+      insertBefore: p,
+      insertAfter: k,
+      handleNodeExpand: _,
+      updateKeyChildren: Y
+    };
+  }
+});
+function Yt(n, e, o, s, t, d) {
+  const r = te("el-tree-node");
+  return T(), O(
+    "div",
+    {
+      ref: "el$",
+      class: H([
+        n.ns.b(),
+        n.ns.is("dragging", !!n.dragState.draggingNode),
+        n.ns.is("drop-not-allow", !n.dragState.allowDrop),
+        n.ns.is("drop-inner", n.dragState.dropType === "inner"),
+        { [n.ns.m("highlight-current")]: n.highlightCurrent }
+      ]),
+      role: "tree"
+    },
+    [
+      (T(!0), O(
+        ue,
+        null,
+        he(n.root.childNodes, (i) => (T(), U(r, {
+          key: n.getNodeKey(i),
+          node: i,
+          props: n.props,
+          accordion: n.accordion,
+          "render-after-expand": n.renderAfterExpand,
+          "show-checkbox": n.showCheckbox,
+          "render-content": n.renderContent,
+          onNodeExpand: n.handleNodeExpand
+        }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]))),
+        128
+      )),
+      n.isEmpty ? (T(), O(
+        "div",
+        {
+          key: 0,
+          class: H(n.ns.e("empty-block"))
+        },
+        [
+          be(n.$slots, "empty", {}, () => {
+            var i;
+            return [
+              x(
+                "span",
+                {
+                  class: H(n.ns.e("empty-text"))
+                },
+                q((i = n.emptyText) != null ? i : n.t("el.tree.emptyText")),
+                3
+              )
+            ];
+          })
+        ],
+        2
+      )) : le("v-if", !0),
+      J(x(
+        "div",
+        {
+          ref: "dropIndicator$",
+          class: H(n.ns.e("drop-indicator"))
+        },
+        null,
+        2
+      ), [
+        [G, n.dragState.showDropIndicator]
+      ])
+    ],
+    2
+  );
+}
+var Wt = /* @__PURE__ */ ye(Vt, [["render", Yt], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree.vue"]]);
+const Jt = Be(Wt), Gt = {
+  key: 0,
+  class: "panel_content"
+}, Qt = { class: "types" }, Xt = ["onClick"], Zt = { class: "tree" }, en = {
+  key: 1,
+  class: "panel_content_null"
+}, tn = { class: "pc_tree_type_button" }, nn = ["onClick"], on = { class: "pc_tree_content" }, sn = { class: "tree-search-box" }, dn = { class: "tree-wrapper" }, an = ["id"], rn = { class: "tree-wrapper" }, ln = ["id"], cn = { class: "tree-wrapper" }, un = ["id"], hn = {
+  key: 2,
+  class: "operate-tree-box"
+}, fn = { class: "operate-tree" }, pn = { class: "tree-title-box" }, vn = { class: "tree-title-icon" }, yn = { class: "tree-category-box" }, gn = { class: "tree-category-list" }, kn = ["onClick"], Nn = { class: "tree-search-box" }, Cn = { class: "tree-content" }, mn = { class: "tree-wrapper" }, bn = ["id"], En = { class: "tree-wrapper" }, _n = ["id"], xn = { class: "tree-wrapper" }, wn = ["id"], Dn = /* @__PURE__ */ re({
+  __name: "StructureTree",
+  props: ["componentId"],
+  emits: ["closePanel", "emitHandler"],
+  setup(n, { emit: e }) {
+    const o = ut(), s = n, t = D(!1), d = D(!1), r = D(), i = D(), f = D(), h = D(), a = D(0), u = D(), c = D(), N = D(), C = D(), m = D();
+    let y;
+    const w = D(""), K = D(""), z = D("");
+    R(
+      () => o.isToolActive(s.componentId),
+      (p) => {
+        if (t.value && p) {
+          if (d.value || S(Ne[0]), K.value == z.value || K.value == "")
+            return;
+          E(K.value);
+        }
+      }
+    ), R(w, (p) => {
+      var k, _, Y;
+      a.value === 0 ? (k = r.value) == null || k.filter(p) : a.value === 1 ? (_ = i.value) == null || _.filter(p) : a.value === 2 && ((Y = f.value) == null || Y.filter(p));
+    });
+    const P = (p, k) => p ? k.title.includes(w.value) : !0, $ = {
+      children: "children",
+      label: "title",
+      value: "nodeId"
+    }, Q = e, A = (p) => {
+      Q("emitHandler", p);
+    }, de = D(!1);
+    Ae(() => {
+      ee("userInfo").isInShare && ee("userInfo").isShareClient && (de.value = !0), o.setReadyById(s.componentId);
+    });
+    const g = () => {
+      d.value = !1, y = window.bimViewer;
+      const { eventTrigger: p } = y;
+      p.on("treeAllReady", (k) => {
+        t.value = !0, h.value = k, console.log("初始化结构树数据", h.value), y.SetShowSpaceModeActive(!1);
+      }), ee("isMobile") || p.on("pickedEntity", (k) => {
+        d.value && (K.value = k.id, o.isToolActive(s.componentId) && E(k.id));
+      }), ee("isMobile") && (p.on("touchEntity", (k) => {
+        d.value !== !1 && (K.value = k.id, o.isToolActive(s.componentId) && E(k.id));
+      }), p.on("touchNothing", () => {
+        fe(() => {
+          m.value = "";
+        }), A({
+          isTool: !0,
+          event_target: "StructureTree",
+          event_name: "touchNothing",
+          content: {
+            msg: "pickedNothing"
+          }
+        });
+      }));
+    };
+    xe.on("BimViewer", g), Ve(() => {
+      xe.off("BimViewer", g);
+    });
+    const E = (p) => {
+      let k, _;
+      a.value === 0 ? k = y.objectsExplorer.objectList[p] ? y.objectsExplorer.objectList[p] : null : a.value === 1 ? k = y.classesExplorer.objectList[p] ? y.classesExplorer.objectList[p] : null : a.value === 2 && (k = y.storeysExplorer.objectList[p] ? y.storeysExplorer.objectList[p] : null), k && (m.value = k.nodeId, a.value === 0 ? (r.value.setCurrentKey(k.nodeId, !0), _ = document.getElementById(k.nodeId + "0")) : a.value === 1 ? (i.value.setCurrentKey(k.nodeId, !0), _ = document.getElementById(k.nodeId + "1")) : a.value === 2 && (f.value.setCurrentKey(k.nodeId, !0), _ = document.getElementById(k.nodeId + "2")), setTimeout(() => {
+        _ && fe(() => {
+          _.scrollIntoView({ block: "center" });
+        });
+      }, 200), z.value = p, A({
+        isTool: !0,
+        event_target: "StructureTree",
+        event_name: "pickedEntity",
+        content: {
+          entityId: p,
+          viewer_nodeId: k.nodeId
+        }
+      }));
+    }, S = (p) => {
+      if (p.id == 0) {
+        if (!c.value) {
+          if (c.value = h.value.objectsData ? h.value.objectsData : [], c.value[0]) {
+            c.value[0].title = "全部";
+            const k = c.value.map((_) => _.nodeId);
+            r.value.setCheckedKeys(k);
+          }
+          d.value = !0;
+        }
+      } else if (p.id == 1) {
+        if (!C.value && (N.value = h.value.classesData ? h.value.classesData : [], N.value[0])) {
+          N.value[0].title = "全部";
+          const k = N.value.map((_) => _.nodeId);
+          i.value.setCheckedKeys(k);
+        }
+      } else if (p.id == 2 && !C.value && (C.value = h.value.storeysData ? h.value.storeysData : [], C.value[0])) {
+        C.value[0].title = "全部";
+        const k = C.value.map((_) => _.nodeId);
+        f.value.setCheckedKeys(k);
+      }
+      A({
+        isTool: !0,
+        event_target: "StructureTree",
+        event_name: "changeTreeStructure",
+        content: {
+          item: p
+        }
+      }), a.value !== p.id && (a.value = p.id);
+    };
+    let L = [];
+    const F = (p, k) => {
+      L.includes(p.nodeId) ? p.checked = !0 : p.checked = !p.checked;
+      const _ = y.viewer.scene.objects[p.objectId];
+      _ ? y.setEntityVisible(_, p.checked) : Y(p, p.checked), l(p, p.checked), A({
+        isTool: !0,
+        event_target: "StructureTree",
+        event_name: "clickTreeBox",
+        content: {
+          active_tree: a.value,
+          nodeId: p.nodeId,
+          status: p.checked
+        }
+      });
+      function Y(v, j) {
+        if (v.checked = j, v.children.length == 0) {
+          const M = y.viewer.scene.objects[v.objectId];
+          M && y.setEntityVisible(M, v.checked);
+        } else
+          for (let M = 0; M < v.children.length; M++)
+            Y(v.children[M], j);
+      }
+      function l(v, j) {
+        v.checked = j, v.parent && l(v.parent, j);
+      }
+      L = k.halfCheckedKeys;
+    }, V = (p, k) => {
+      const _ = y.viewer.scene.objects[p.objectId];
+      _ && (y.setAllObjectsSelected(!1), y.setEntitySelected(_), y.viewFitEntity(_)), xe.emit("tree_clickNode", _), A({
+        isTool: !0,
+        event_target: "StructureTree",
+        event_name: "clickTreeNode",
+        content: {
+          active_tree: a.value,
+          objectId: p.objectId
+        }
+      });
+    }, ie = () => {
+      Q("closePanel");
+    };
+    return (p, k) => {
+      const _ = Jt, Y = gt, l = ht, v = ft, j = yt, M = pt;
+      return !W(ee)("isMobile") && W($e).currentTheme == "blue" ? (T(), U(Y, {
+        key: 0,
+        class: "web_tree_container",
+        width: 268,
+        panelTitle: "结构树",
+        "click-handle": ie
+      }, {
+        default: B(() => [
+          d.value ? (T(), O("div", Gt, [
+            x("div", Qt, [
+              (T(!0), O(ue, null, he(W(Ne), (b) => (T(), O("div", {
+                key: b.id,
+                class: H(["types-item", { "types-item-active": a.value === b.id }]),
+                onClick: (Ee) => S(b)
+              }, q(b.name), 11, Xt))), 128))
+            ]),
+            x("div", Zt, [
+              I(_, {
+                ref: "tree",
+                height: 700,
+                "node-key": "nodeId",
+                data: u.value,
+                "current-node-key": m.value,
+                "highlight-current": !0,
+                props: $,
+                "show-checkbox": "",
+                onCheck: F,
+                onNodeClick: V,
+                "empty-text": "暂无数据"
+              }, null, 8, ["data", "current-node-key"])
+            ])
+          ])) : (T(), O("div", en, [...k[2] || (k[2] = [
+            x("span", null, "加载中...", -1)
+          ])]))
+        ]),
+        _: 1
+      })) : !W(ee)("isMobile") && W($e).currentTheme == "light-gray" ? (T(), U(j, {
+        key: 1,
+        class: "pc_structure_container",
+        width: 286,
+        panelTitle: "结构树",
+        "click-handle": ie,
+        pos: W(ee)("treePos"),
+        setWidth: ""
+      }, {
+        default: B(() => [
+          x("div", tn, [
+            (T(!0), O(ue, null, he(W(Ne), (b) => (T(), O("div", {
+              key: b.id,
+              class: H(["type_button", { type_button_active: a.value === b.id }]),
+              onClick: (Ee) => S(b)
+            }, q(b.name), 11, nn))), 128))
+          ]),
+          x("div", on, [
+            x("div", sn, [
+              I(l, {
+                modelValue: w.value,
+                "onUpdate:modelValue": k[0] || (k[0] = (b) => w.value = b),
+                placeholder: "请输入需搜索的内容",
+                "prefix-icon": "Search",
+                clearable: ""
+              }, null, 8, ["modelValue"])
+            ]),
+            J(x("div", dn, [
+              I(v, null, {
+                default: B(() => [
+                  I(_, {
+                    ref_key: "tree0",
+                    ref: r,
+                    "node-key": "nodeId",
+                    data: c.value,
+                    "current-node-key": m.value,
+                    "highlight-current": !0,
+                    props: $,
+                    "filter-node-method": P,
+                    "show-checkbox": "",
+                    onCheck: F,
+                    onNodeClick: V,
+                    "empty-text": "暂无数据"
+                  }, {
+                    default: B(({ node: b }) => [
+                      x("span", {
+                        id: b.key + "0",
+                        class: "tree_node_text"
+                      }, q(b.data.title), 9, an)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [G, a.value == 0]
+            ]),
+            J(x("div", rn, [
+              I(v, null, {
+                default: B(() => [
+                  I(_, {
+                    ref_key: "tree1",
+                    ref: i,
+                    "node-key": "nodeId",
+                    data: N.value,
+                    "current-node-key": m.value,
+                    "highlight-current": !0,
+                    props: $,
+                    "filter-node-method": P,
+                    "show-checkbox": "",
+                    onCheck: F,
+                    onNodeClick: V,
+                    "empty-text": "暂无数据"
+                  }, {
+                    default: B(({ node: b }) => [
+                      x("span", {
+                        id: b.key + "1",
+                        class: "tree_node_text"
+                      }, q(b.data.title), 9, ln)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [G, a.value == 1]
+            ]),
+            J(x("div", cn, [
+              I(v, null, {
+                default: B(() => [
+                  I(_, {
+                    ref_key: "tree2",
+                    ref: f,
+                    "node-key": "nodeId",
+                    data: C.value,
+                    "current-node-key": m.value,
+                    "highlight-current": !0,
+                    props: $,
+                    "filter-node-method": P,
+                    "show-checkbox": "",
+                    onCheck: F,
+                    onNodeClick: V,
+                    "empty-text": "暂无数据"
+                  }, {
+                    default: B(({ node: b }) => [
+                      x("span", {
+                        id: b.key + "2",
+                        class: "tree_node_text"
+                      }, q(b.data.title), 9, un)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [G, a.value == 2]
+            ])
+          ])
+        ]),
+        _: 1
+      }, 8, ["pos"])) : (T(), O("div", hn, [
+        x("div", fn, [
+          x("div", pn, [
+            k[3] || (k[3] = x("div", { class: "tree-title" }, "结构树", -1)),
+            x("div", vn, [
+              I(M, {
+                class: "close",
+                width: 0.4,
+                "size-type": "rem",
+                "click-handle": ie
+              })
+            ])
+          ]),
+          x("div", yn, [
+            I(v, null, {
+              default: B(() => [
+                x("div", gn, [
+                  (T(!0), O(ue, null, he(W(Ne), (b, Ee) => (T(), O("div", {
+                    key: Ee,
+                    class: H(["tree-category-item", {
+                      "tree-category-item-active": b.id === a.value
+                    }]),
+                    onClick: (Tn) => S(b)
+                  }, q(b.name), 11, kn))), 128))
+                ])
+              ]),
+              _: 1
+            })
+          ]),
+          x("div", Nn, [
+            I(l, {
+              modelValue: w.value,
+              "onUpdate:modelValue": k[1] || (k[1] = (b) => w.value = b),
+              placeholder: "请输入需搜索的内容",
+              "prefix-icon": "Search",
+              clearable: ""
+            }, null, 8, ["modelValue"])
+          ]),
+          x("div", Cn, [
+            J(x("div", mn, [
+              I(v, null, {
+                default: B(() => [
+                  I(_, {
+                    ref_key: "tree0",
+                    ref: r,
+                    "node-key": "nodeId",
+                    data: c.value,
+                    "current-node-key": m.value,
+                    "highlight-current": !0,
+                    props: $,
+                    "filter-node-method": P,
+                    "show-checkbox": "",
+                    onCheck: F,
+                    onNodeClick: V,
+                    "empty-text": "暂无数据"
+                  }, {
+                    default: B(({ node: b }) => [
+                      x("span", {
+                        id: b.key + "0",
+                        class: "tree_node_text"
+                      }, q(b.data.title), 9, bn)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [G, a.value == 0]
+            ]),
+            J(x("div", En, [
+              I(v, null, {
+                default: B(() => [
+                  I(_, {
+                    ref_key: "tree1",
+                    ref: i,
+                    "node-key": "nodeId",
+                    data: N.value,
+                    "current-node-key": m.value,
+                    "highlight-current": !0,
+                    props: $,
+                    "filter-node-method": P,
+                    "show-checkbox": "",
+                    onCheck: F,
+                    onNodeClick: V,
+                    "empty-text": "暂无数据"
+                  }, {
+                    default: B(({ node: b }) => [
+                      x("span", {
+                        id: b.key + "1",
+                        class: "tree_node_text"
+                      }, q(b.data.title), 9, _n)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [G, a.value == 1]
+            ]),
+            J(x("div", xn, [
+              I(v, null, {
+                default: B(() => [
+                  I(_, {
+                    ref_key: "tree2",
+                    ref: f,
+                    "node-key": "nodeId",
+                    data: C.value,
+                    "current-node-key": m.value,
+                    "highlight-current": !0,
+                    props: $,
+                    "filter-node-method": P,
+                    "show-checkbox": "",
+                    onCheck: F,
+                    onNodeClick: V,
+                    "empty-text": "暂无数据"
+                  }, {
+                    default: B(({ node: b }) => [
+                      x("span", {
+                        id: b.key + "2",
+                        class: "tree_node_text"
+                      }, q(b.data.title), 9, wn)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [G, a.value == 2]
+            ])
+          ])
+        ])
+      ]));
+    };
+  }
+}), Pn = /* @__PURE__ */ vt(Dn, [["__scopeId", "data-v-a544c927"]]);
+export {
+  Pn as default
+};