@xtctwins/tctwins-bimx-engine 0.1.21 → 0.1.22

package/dist/StructureTree-DBu9xTue.mjs

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