@xtctwins/tctwins-industry-engine 0.0.1

package/dist/StructureTree-CHhrQiDL.mjs

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