aibox-custom-component-packages 0.0.7 → 0.0.8

package/es/DocSyncSelect.mjs

@@ -0,0 +1,2661 @@
+import { w as Ve } from "./chunks/index.bCzIhWFw.js";
+import { createBlock as U, createCommentVNode as G, unref as $, openBlock as T, withCtx as W, createElementBlock as P, Fragment as de, ref as B, computed as K, createElementVNode as j, createVNode as H, renderList as je, normalizeClass as ue, toDisplayString as te, withModifiers as et, useAttrs as tt, watch as Z, nextTick as ie, onMounted as Ie, mergeProps as De, renderSlot as J, h as me, pushScopeId as it, popScopeId as st, withScopeId as lt, markRaw as nt, shallowReactive as rt, resolveComponent as we, resolveDirective as ot, withDirectives as at, resolveDynamicComponent as Ae, normalizeStyle as He, toHandlers as ct, normalizeProps as dt, guardReactiveProps as ut, onUnmounted as ht } from "vue";
+import { ElIcon as ve, ElAutoResizer as ft, ElTreeV2 as pt, ElCheckbox as mt, ElInput as vt, ElSegmented as yt } from "element-plus";
+import { FeishuLocalUploadXlsx as gt, FeishuLocalUploadDoc as bt, FeishuLocalUploadPdf as St, FeishuLocalUploadPpt as Tt, FeishuLocalUploadTxt as _t, FeishuLocalUploadImg as zt, IconFeishuExcel as kt, IconFeishuMulitTable as $t, IconFeishuDoc as It, IconFeishuKnowledge as Dt, IconDelete as wt, CaretRight as xt, Empty as Ct, Seach as Nt } from "color-message-aibox-vue";
+import { IconEmpty as xe } from "color-star-custom-components";
+import { _ as ae } from "./chunks/_plugin-vue_export-helper.CHgC5LLL.js";
+import Lt from "mitt";
+import { u as Ot } from "./chunks/i18n.k9Q_HVMs.js";
+import './assets/DocSyncSelect.css';const ne = {
+  label: "name",
+  children: "children",
+  value: "id"
+}, oe = {
+  FRONTEND: "frontend",
+  BACKEND: "backend"
+}, Ue = [
+  "sheet",
+  "bitable",
+  "doc",
+  "docx",
+  "wiki",
+  "pdf",
+  "pptx",
+  "ppt",
+  "xlsx",
+  "xls",
+  "txt",
+  "png",
+  "jpg",
+  "jpeg"
+], At = 34, le = {
+  MY_FILES: "myFiles",
+  FEISHU_KNOWLEDGE: "feishuKnowledge"
+}, ye = /* @__PURE__ */ Object.assign({
+  name: "FileTypeIcon"
+}, {
+  __name: "FileTypeIcon",
+  props: {
+    // 文件类型
+    fileType: {
+      type: String,
+      required: !1,
+      default: ""
+    },
+    //本地上传类型
+    isLocalFileType: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    // 图标大小
+    size: {
+      type: Number,
+      default: 32
+    }
+  },
+  setup(e) {
+    return (i, t) => e.fileType && $(Ue).includes(e.fileType) ? (T(), U($(ve), {
+      key: 0,
+      size: e.size
+    }, {
+      default: W(() => [
+        e.isLocalFileType ? (T(), P(de, { key: 0 }, [
+          ["xlsx", "xls"].includes(e.fileType) ? (T(), U($(gt), { key: 0 })) : ["doc", "docx"].includes(e.fileType) ? (T(), U($(bt), { key: 1 })) : ["pdf"].includes(e.fileType) ? (T(), U($(St), { key: 2 })) : ["pptx", "ppt"].includes(e.fileType) ? (T(), U($(Tt), { key: 3 })) : ["txt"].includes(e.fileType) ? (T(), U($(_t), { key: 4 })) : ["png", "jpg", "jpeg"].includes(e.fileType) ? (T(), U($(zt), { key: 5 })) : G("", !0)
+        ], 64)) : (T(), P(de, { key: 1 }, [
+          ["sheet"].includes(e.fileType) ? (T(), U($(kt), { key: 0 })) : ["bitable"].includes(e.fileType) ? (T(), U($($t), { key: 1 })) : ["doc", "docx"].includes(e.fileType) ? (T(), U($(It), { key: 2 })) : ["wiki"].includes(e.fileType) ? (T(), U($(Dt), { key: 3 })) : G("", !0)
+        ], 64))
+      ]),
+      _: 1
+    }, 8, ["size"])) : G("", !0);
+  }
+}), Et = { class: "right-wrap" }, Mt = { class: "content" }, Rt = {
+  key: 0,
+  class: "empty-state"
+}, Pt = {
+  key: 1,
+  class: "selected-list"
+}, Ft = ["onClick"], Vt = { class: "item-content" }, jt = { class: "item-main" }, Ht = { class: "doc-icon" }, Ut = { class: "doc-info" }, Bt = { class: "doc-name" }, Kt = {
+  key: 0,
+  class: "doc-suffix"
+}, Wt = ["onClick"], qt = /* @__PURE__ */ Object.assign({
+  name: "RightLayout"
+}, {
+  __name: "RightLayout",
+  props: {
+    // 已选择的文档列表
+    selectedDocuments: {
+      type: Array,
+      default: () => []
+    },
+    // 树配置
+    treeProps: {
+      type: Object,
+      default: () => ne
+    }
+  },
+  emits: ["delete-node"],
+  setup(e, { emit: i }) {
+    const t = e, s = i, l = B(-1), r = K(() => t.selectedDocuments.filter((n) => Ue.includes(n.type))), a = (n) => {
+      l.value = l.value === n ? -1 : n;
+    }, o = (n) => {
+      s("delete-node", n), l.value = -1;
+    };
+    return (n, c) => (T(), P("div", Et, [
+      j("div", Mt, [
+        r.value.length === 0 ? (T(), P("div", Rt, [
+          H($(xe))
+        ])) : (T(), P("div", Pt, [
+          (T(!0), P(de, null, je(r.value, (d, p) => (T(), P("div", {
+            key: d[e.treeProps.value],
+            class: ue(["selected-item", { "is-selected": l.value === p }]),
+            onClick: (I) => a(p)
+          }, [
+            j("div", Vt, [
+              j("div", jt, [
+                j("div", Ht, [
+                  H(ye, {
+                    "file-type": d.type,
+                    size: 26,
+                    isLocalFileType: d?.isLocalFileType
+                  }, null, 8, ["file-type", "isLocalFileType"])
+                ]),
+                j("div", Ut, [
+                  j("div", Bt, te(d[e.treeProps.label]), 1),
+                  d.suffix ? (T(), P("div", Kt, te(d.suffix), 1)) : G("", !0)
+                ])
+              ]),
+              j("div", {
+                class: "flex items-center",
+                onClick: et((I) => o(d), ["stop"])
+              }, [
+                H($(ve), {
+                  size: 14,
+                  color: "var(--neutral-color-5)"
+                }, {
+                  default: W(() => [
+                    H($(wt))
+                  ]),
+                  _: 1
+                })
+              ], 8, Wt)
+            ])
+          ], 10, Ft))), 128))
+        ]))
+      ])
+    ]));
+  }
+}), Yt = /* @__PURE__ */ ae(qt, [["__scopeId", "data-v-6736cdb6"]]);
+function Xt(e) {
+  return {
+    name: "element-tree-line",
+    props: {
+      node: {
+        type: Object,
+        required: !0
+      },
+      data: {
+        type: Object
+      },
+      treeData: {
+        type: Array
+      },
+      indent: {
+        type: Number,
+        default() {
+          return 16;
+        }
+      },
+      showLabelLine: {
+        type: Boolean,
+        default: !0
+      }
+    },
+    render(i) {
+      const t = e || i, s = this.getScopedSlot("default"), l = this.getScopedSlot("node-label"), r = this.getScopedSlot("after-node-label"), a = s ? this.getScopedSlotValue(s, {
+        node: this.node,
+        data: this.data
+      }) : [
+        l ? this.getScopedSlotValue(l, {
+          node: this.node,
+          data: this.data
+        }) : t(
+          "span",
+          { class: "element-tree-node-label" },
+          this.node.label
+        ),
+        this.showLabelLine ? t("span", {
+          class: "element-tree-node-label-line"
+        }) : null,
+        this.getScopedSlotValue(r, {
+          node: this.node,
+          data: this.data
+        })
+      ], o = [];
+      let n = this.node;
+      for (; n; ) {
+        let d = n.parent;
+        if (n.level === 1 && !n.parent) {
+          if (!this.treeData || !Array.isArray(this.treeData))
+            throw Error(
+              "if you using el-tree-v2 (Virtualized Tree) of element-plus,element-tree-line required data."
+            );
+          d = {
+            children: Array.isArray(this.treeData) ? this.treeData.map((p) => ({ ...p, key: p.id })) : [],
+            level: 0,
+            key: "node-0",
+            parent: null
+          };
+        }
+        if (d) {
+          const p = (d.children || d.childNodes).findIndex(
+            (I) => (I.key || I.id) === (n.key || n.id)
+          );
+          o.unshift(
+            p === (d.children || d.childNodes).length - 1
+          );
+        }
+        n = d;
+      }
+      const c = [];
+      for (let d = 0; d < this.node.level; d++)
+        o[d] && this.node.level - 1 !== d || c.push(
+          t("span", {
+            class: {
+              "element-tree-node-line-ver": !0,
+              "last-node-isLeaf-line": o[d] && this.node.level - 1 === d
+            },
+            style: { left: this.indent * d + "px" }
+          })
+        );
+      return t(
+        "span",
+        {
+          class: "element-tree-node-label-wrapper"
+        },
+        [a].concat(c).concat([
+          t("span", {
+            class: "element-tree-node-line-hor",
+            style: {
+              width: (this.node.isLeaf ? 24 : 8) + "px",
+              left: (this.node.level - 1) * this.indent + "px"
+            }
+          })
+        ])
+      );
+    },
+    methods: {
+      getScopedSlot(i) {
+        if (!i)
+          return null;
+        const t = i.split("||");
+        let s = null;
+        for (let l = 0; l < t.length; l++) {
+          const r = t[l], a = (this.$slots || {})[r];
+          if (a) {
+            s = a;
+            break;
+          }
+          if (s = (this.$scopedSlots || {})[r], s)
+            break;
+        }
+        return s;
+      },
+      getScopedSlotValue(i, t, s = null) {
+        return typeof i == "function" ? i(t) || s : i || s;
+      }
+    }
+  };
+}
+function Ce(e) {
+  const i = Xt(e);
+  return e && (i.methods.getScopedSlot = function(s) {
+    if (!s)
+      return null;
+    const l = s.split("||");
+    let r = null;
+    for (let a = 0; a < l.length; a++) {
+      const o = l[a], n = (this.$slots || {})[o];
+      if (n) {
+        r = n;
+        break;
+      }
+    }
+    return r;
+  }), i;
+}
+Ce();
+var he = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Gt(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var be, Ee;
+function Zt() {
+  if (Ee) return be;
+  Ee = 1;
+  var e = "Expected a function", i = NaN, t = "[object Symbol]", s = /^\s+|\s+$/g, l = /^[-+]0x[0-9a-f]+$/i, r = /^0b[01]+$/i, a = /^0o[0-7]+$/i, o = parseInt, n = typeof he == "object" && he && he.Object === Object && he, c = typeof self == "object" && self && self.Object === Object && self, d = n || c || Function("return this")(), p = Object.prototype, I = p.toString, m = Math.max, _ = Math.min, h = function() {
+    return d.Date.now();
+  };
+  function v(g, M, f) {
+    var D, C, y, O, x, E, q = 0, ee = !1, F = !1, Q = !0;
+    if (typeof g != "function")
+      throw new TypeError(e);
+    M = S(M) || 0, A(f) && (ee = !!f.leading, F = "maxWait" in f, y = F ? m(S(f.maxWait) || 0, M) : y, Q = "trailing" in f ? !!f.trailing : Q);
+    function z(V) {
+      var X = D, ce = C;
+      return D = C = void 0, q = V, O = g.apply(ce, X), O;
+    }
+    function u(V) {
+      return q = V, x = setTimeout(L, M), ee ? z(V) : O;
+    }
+    function b(V) {
+      var X = V - E, ce = V - q, Oe = M - X;
+      return F ? _(Oe, y - ce) : Oe;
+    }
+    function k(V) {
+      var X = V - E, ce = V - q;
+      return E === void 0 || X >= M || X < 0 || F && ce >= y;
+    }
+    function L() {
+      var V = h();
+      if (k(V))
+        return R(V);
+      x = setTimeout(L, b(V));
+    }
+    function R(V) {
+      return x = void 0, Q && D ? z(V) : (D = C = void 0, O);
+    }
+    function Y() {
+      x !== void 0 && clearTimeout(x), q = 0, D = E = C = x = void 0;
+    }
+    function re() {
+      return x === void 0 ? O : R(h());
+    }
+    function se() {
+      var V = h(), X = k(V);
+      if (D = arguments, C = this, E = V, X) {
+        if (x === void 0)
+          return u(E);
+        if (F)
+          return x = setTimeout(L, M), z(E);
+      }
+      return x === void 0 && (x = setTimeout(L, M)), O;
+    }
+    return se.cancel = Y, se.flush = re, se;
+  }
+  function A(g) {
+    var M = typeof g;
+    return !!g && (M == "object" || M == "function");
+  }
+  function w(g) {
+    return !!g && typeof g == "object";
+  }
+  function N(g) {
+    return typeof g == "symbol" || w(g) && I.call(g) == t;
+  }
+  function S(g) {
+    if (typeof g == "number")
+      return g;
+    if (N(g))
+      return i;
+    if (A(g)) {
+      var M = typeof g.valueOf == "function" ? g.valueOf() : g;
+      g = A(M) ? M + "" : M;
+    }
+    if (typeof g != "string")
+      return g === 0 ? g : +g;
+    g = g.replace(s, "");
+    var f = r.test(g);
+    return f || a.test(g) ? o(g.slice(2), f ? 2 : 8) : l.test(g) ? i : +g;
+  }
+  return be = v, be;
+}
+var Jt = Zt();
+const Qt = /* @__PURE__ */ Gt(Jt), Be = (e) => e && Array.isArray(e) && e.length === 1 && e[0] && typeof e[0] == "object" && e[0].falseChild === !0, ei = (e) => !e || !e.children ? !0 : !Be(e.children), ti = (e, i = 800) => Qt((t) => {
+  e("search", { keyword: t });
+}, i), Ke = (e, i, t) => !e || !Array.isArray(e) ? [] : e.reduce((s, l) => {
+  const r = l[t.label]?.toLowerCase().includes(i.toLowerCase()), a = l.suffix?.toLowerCase().includes(i.toLowerCase());
+  if (r || a)
+    s.push({ ...l });
+  else if (l[t.children]) {
+    const o = Ke(l[t.children], i, t);
+    o.length > 0 && s.push({
+      ...l,
+      [t.children]: o
+    });
+  }
+  return s;
+}, []), Te = (e, i) => {
+  let t = [];
+  if (!e) return t;
+  const s = e[i.children];
+  if (s && Array.isArray(s))
+    for (const l of s)
+      t.push(l), t = t.concat(Te(l, i));
+  return t;
+}, ii = (e, i, t = !1) => {
+  let s = 0;
+  function l(r) {
+    for (const a of r) {
+      const o = a[i.children] && a[i.children].length > 0;
+      t ? s++ : o || s++, o && l(a[i.children]);
+    }
+  }
+  return l(e), s;
+}, si = (e, i, t) => {
+  const s = /* @__PURE__ */ new Map();
+  function l(r, a = []) {
+    for (const o of r) {
+      const n = [...a, o];
+      o.children && o.children.length > 0 ? l(o.children, n) : i.includes(o[t]) && a.forEach((c) => {
+        s.has(c[t]) || s.set(c[t], { ...c });
+      });
+    }
+  }
+  return l(e), Array.from(s.values());
+}, li = (e, i) => {
+  const t = i?.value || "id", s = i?.children || "children", l = /* @__PURE__ */ new Set(), r = (a) => {
+    if (Array.isArray(a))
+      for (const o of a) {
+        o && o[t] != null && l.add(o[t]);
+        const n = o?.[s];
+        n && Array.isArray(n) && n.length > 0 && r(n);
+      }
+  };
+  return r(e), l;
+}, Me = ({
+  tabKey: e,
+  currentSelectedDocs: i,
+  hasSelectToRightDocList: t,
+  treeData: s,
+  treeProps: l
+}) => {
+  const r = Array.isArray(t) ? t : [], a = l?.value, o = (s && Array.isArray(s[e]) ? s[e] : []) || [], n = li(o, l), c = r.filter((d) => !n.has(d?.[a]));
+  return [...i, ...c];
+}, ni = (e, i, t) => {
+  if (!Array.isArray(e) || i == null)
+    return null;
+  const s = t?.value || "id", l = t?.children || "children", r = (a) => {
+    for (const o of a) {
+      if (o && o[s] === i)
+        return o;
+      const n = o?.[l];
+      if (Array.isArray(n) && n.length > 0) {
+        const c = r(n);
+        if (c)
+          return c;
+      }
+    }
+    return null;
+  };
+  return r(e);
+}, We = (e, i) => {
+  if (!e) return !1;
+  const t = i?.children || "children";
+  if (Be(e[t]))
+    return !0;
+  const s = e[t];
+  if (s && Array.isArray(s)) {
+    for (const l of s)
+      if (We(l, i))
+        return !0;
+  }
+  return !1;
+}, Re = (e, i) => e === le.MY_FILES ? i?.myFilesHasMore || !1 : e === le.FEISHU_KNOWLEDGE && i?.feishuKnowledgeHasMore || !1, ri = { class: "w-full h-full flex flex-col overflow-hidden" }, oi = /* @__PURE__ */ Object.assign({
+  name: "TreeSelectLayout"
+}, {
+  __name: "TreeSelectLayout",
+  props: {
+    // 初始值
+    modelValue: {
+      type: Object,
+      default: () => []
+    },
+    // 树形节点对象结构
+    treeProps: {
+      type: Object,
+      default: () => ne
+    },
+    // 接口配置
+    apiConfig: {
+      type: Function
+    },
+    // 懒加载函数
+    loadNode: {
+      type: Function
+    },
+    // 请求参数
+    reqParams: {
+      type: Object,
+      default: () => ({})
+    },
+    // 是否在组件挂载时自动加载数据
+    autoLoad: {
+      type: Boolean,
+      default: !0
+    },
+    // 是否多选
+    isMultiple: {
+      type: Boolean,
+      default: !0
+    },
+    // 是否有过滤
+    hasFilter: {
+      type: Boolean,
+      default: !1
+    },
+    treeList: {
+      type: Array,
+      default: () => []
+    },
+    // 是否有线条样式
+    hasTreeLine: {
+      type: Boolean,
+      default: !0
+    },
+    // 选中的节点是否包含父节点
+    includeParentSelected: {
+      type: Boolean,
+      default: !1
+    },
+    // 文本配置
+    textConfig: {
+      type: Object,
+      default: () => ({
+        searchPlaceholder: ""
+      })
+    },
+    getTabSelectedDocuments: {
+      type: Function,
+      default: () => () => []
+    }
+  },
+  emits: ["handleCheck", "initFinish", "node-expand"],
+  setup(e, { expose: i, emit: t }) {
+    const s = Ce(me), l = e, r = t, a = tt(), o = () => me(xt, {
+      style: { color: "var(--text-color-2)", fontSize: "16px" }
+    }), n = l.isMultiple ? 20 : 10, c = l.isMultiple ? 15 : 11, d = B([]), p = B(null), I = B(null), m = K(() => l.treeProps.value), _ = K(() => l.treeProps.label), h = K(() => l.treeProps.children), v = B(!1), A = K(() => !l.isMultiple && v.value), w = K(() => typeof l.apiConfig == "function"), N = () => {
+      let z = p.value?.getCheckedNodes(), u = z.map((k) => k[m.value]), b = [];
+      return l.includeParentSelected && (b = si(
+        d.value,
+        u,
+        m.value
+      )), {
+        selectedNodeValues: u,
+        // 选中节点的值的集合
+        selectedNodes: z,
+        // 选中节点的集合
+        selectedParentNodes: b
+        // 选中节点的所有父节点
+      };
+    }, S = (z, u) => {
+      C(z, u);
+    }, g = (z) => {
+      r("node-expand", z);
+    }, M = (z, u) => {
+      l.isMultiple || (v.value = !0, I.value = u.key, r("handleCheck", {
+        selectedValue: [I.value],
+        // 选中节点的值
+        selectedNode: [u.data]
+        // // 选中节点
+      }));
+    };
+    B("");
+    const f = (z, u) => u[_.value].includes(z), D = K(() => ii(
+      d.value,
+      l.treeProps,
+      l.includeParentSelected
+    ));
+    function C(z = null, u = null) {
+      const { selectedNodeValues: b, selectedNodes: k, selectedParentNodes: L } = N();
+      let R = null;
+      if (z && u) {
+        const Y = z[m.value];
+        R = u.checkedKeys.includes(Y);
+      }
+      r("handleCheck", {
+        selectedValue: b,
+        // 选中节点的值的集合
+        selectedNode: k,
+        // 选中节点的集合
+        selectedParentNodes: L,
+        checkedNode: z,
+        // 当前勾选的节点
+        isChecked: R
+        // 是否勾选
+      });
+    }
+    const y = (z, u) => {
+      p.value?.setChecked(z, u), C();
+    }, O = () => {
+      a["default-checked-keys"] && ie(() => {
+        C();
+      });
+    }, x = (z) => {
+      p.value && (!z || z.length === 0 ? p.value?.setCheckedKeys([]) : p.value?.setCheckedKeys(z));
+    }, E = (z, u) => {
+      const b = (k) => {
+        for (let L = 0; L < k.length; L++) {
+          const R = k[L];
+          if (R[m.value] === z) {
+            const Y = q(u);
+            return R[h.value] = Y, R.isLeaf = !u || u.length === 0, console.log("节点更新后:", {
+              nodeKey: z,
+              childrenLength: Y.length,
+              isLeaf: R.isLeaf
+            }), d.value = [...d.value], !0;
+          }
+          if (R[h.value] && R[h.value].length > 0 && b(R[h.value]))
+            return !0;
+        }
+        return !1;
+      };
+      b(d.value);
+    }, q = (z) => z?.map((u) => ({
+      ...u,
+      [h.value]: u[h.value]?.length ? q(u[h.value]) : void 0
+    })), ee = async () => {
+      w.value ? l.apiConfig(l.reqParams)?.then((z) => {
+        d.value = q(
+          z?.data?.orgOptionSoList || z?.data || []
+        ), O(), Q(l.modelValue), r("initFinish", d.value);
+      }) : F();
+    }, F = () => {
+      d.value = q(l.treeList || []), d.value.length && (O(), Q(l.modelValue));
+    }, Q = (z) => {
+      const u = z && z.length && z.map((b) => b[l.treeProps.value]);
+      ie(() => {
+        p.value?.setCheckedKeys(u);
+      });
+    };
+    return Z(
+      () => l.treeList,
+      () => {
+        F();
+      },
+      { deep: !0 }
+    ), Z(
+      () => l.modelValue,
+      (z) => {
+        ie(() => {
+          Q(z);
+        });
+      },
+      { deep: !0 }
+    ), Ie(() => {
+      ee();
+    }), i({
+      allNodeNumbers: D,
+      loadData: ee,
+      setNodeCheckStatus: y,
+      updateNodeChildren: E,
+      syncSelectedNodes: x
+      // 新增
+    }), (z, u) => (T(), P("div", ri, [
+      j("div", {
+        class: ue([e.hasFilter ? "pd-l-8 pd-r-8" : "", "flex-1 overflow-hidden"])
+      }, [
+        H($(ft), null, {
+          default: W(({ width: b, height: k }) => [
+            H($(pt), De({
+              ref_key: "treeRef",
+              ref: p,
+              height: k,
+              width: b,
+              "check-strictly": !0,
+              data: d.value,
+              props: e.treeProps,
+              "node-key": m.value,
+              "show-checkbox": !0,
+              "item-size": $(At),
+              indent: $(n),
+              "highlight-current": A.value,
+              icon: o,
+              "filter-method": f,
+              lazy: "",
+              load: e.loadNode
+            }, $(a), {
+              onNodeClick: M,
+              onCheck: S,
+              onNodeExpand: g,
+              class: ["hide-false-child-checkbox"]
+            }), {
+              default: W(({ node: L }) => [
+                j("div", {
+                  class: ue(["tree-node-content", { "false-child-node": L.data?.falseChild }])
+                }, [
+                  J(z.$slots, "node", {
+                    node: L,
+                    data: L.data
+                  }, () => [
+                    e.hasTreeLine ? (T(), U($(s), {
+                      key: 0,
+                      node: L,
+                      treeData: d.value,
+                      showLabelLine: !1,
+                      indent: $(c)
+                    }, null, 8, ["node", "treeData", "indent"])) : G("", !0),
+                    j("span", null, te(L.data[_.value]), 1)
+                  ], !0)
+                ], 2)
+              ]),
+              empty: W(() => [
+                H($(xe))
+              ]),
+              _: 3
+            }, 16, ["height", "width", "data", "props", "node-key", "item-size", "indent", "highlight-current", "load"])
+          ]),
+          _: 3
+        })
+      ], 2)
+    ]));
+  }
+}), ai = /* @__PURE__ */ ae(oi, [["__scopeId", "data-v-258f00ca"]]);
+function ci() {
+  var e = window.navigator.userAgent, i = e.indexOf("MSIE ");
+  if (i > 0)
+    return parseInt(e.substring(i + 5, e.indexOf(".", i)), 10);
+  var t = e.indexOf("Trident/");
+  if (t > 0) {
+    var s = e.indexOf("rv:");
+    return parseInt(e.substring(s + 3, e.indexOf(".", s)), 10);
+  }
+  var l = e.indexOf("Edge/");
+  return l > 0 ? parseInt(e.substring(l + 5, e.indexOf(".", l)), 10) : -1;
+}
+let fe;
+function _e() {
+  _e.init || (_e.init = !0, fe = ci() !== -1);
+}
+var ge = {
+  name: "ResizeObserver",
+  props: {
+    emitOnMount: {
+      type: Boolean,
+      default: !1
+    },
+    ignoreWidth: {
+      type: Boolean,
+      default: !1
+    },
+    ignoreHeight: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [
+    "notify"
+  ],
+  mounted() {
+    _e(), ie(() => {
+      this._w = this.$el.offsetWidth, this._h = this.$el.offsetHeight, this.emitOnMount && this.emitSize();
+    });
+    const e = document.createElement("object");
+    this._resizeObject = e, e.setAttribute("aria-hidden", "true"), e.setAttribute("tabindex", -1), e.onload = this.addResizeHandlers, e.type = "text/html", fe && this.$el.appendChild(e), e.data = "about:blank", fe || this.$el.appendChild(e);
+  },
+  beforeUnmount() {
+    this.removeResizeHandlers();
+  },
+  methods: {
+    compareAndNotify() {
+      (!this.ignoreWidth && this._w !== this.$el.offsetWidth || !this.ignoreHeight && this._h !== this.$el.offsetHeight) && (this._w = this.$el.offsetWidth, this._h = this.$el.offsetHeight, this.emitSize());
+    },
+    emitSize() {
+      this.$emit("notify", {
+        width: this._w,
+        height: this._h
+      });
+    },
+    addResizeHandlers() {
+      this._resizeObject.contentDocument.defaultView.addEventListener("resize", this.compareAndNotify), this.compareAndNotify();
+    },
+    removeResizeHandlers() {
+      this._resizeObject && this._resizeObject.onload && (!fe && this._resizeObject.contentDocument && this._resizeObject.contentDocument.defaultView.removeEventListener("resize", this.compareAndNotify), this.$el.removeChild(this._resizeObject), this._resizeObject.onload = null, this._resizeObject = null);
+    }
+  }
+};
+const di = /* @__PURE__ */ lt("data-v-b329ee4c");
+it("data-v-b329ee4c");
+const ui = {
+  class: "resize-observer",
+  tabindex: "-1"
+};
+st();
+const hi = /* @__PURE__ */ di((e, i, t, s, l, r) => (T(), U("div", ui)));
+ge.render = hi;
+ge.__scopeId = "data-v-b329ee4c";
+ge.__file = "src/components/ResizeObserver.vue";
+function pe(e) {
+  "@babel/helpers - typeof";
+  return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? pe = function(i) {
+    return typeof i;
+  } : pe = function(i) {
+    return i && typeof Symbol == "function" && i.constructor === Symbol && i !== Symbol.prototype ? "symbol" : typeof i;
+  }, pe(e);
+}
+function fi(e, i) {
+  if (!(e instanceof i))
+    throw new TypeError("Cannot call a class as a function");
+}
+function pi(e, i) {
+  for (var t = 0; t < i.length; t++) {
+    var s = i[t];
+    s.enumerable = s.enumerable || !1, s.configurable = !0, "value" in s && (s.writable = !0), Object.defineProperty(e, s.key, s);
+  }
+}
+function mi(e, i, t) {
+  return i && pi(e.prototype, i), e;
+}
+function Pe(e) {
+  return vi(e) || yi(e) || gi(e) || bi();
+}
+function vi(e) {
+  if (Array.isArray(e)) return ze(e);
+}
+function yi(e) {
+  if (typeof Symbol < "u" && Symbol.iterator in Object(e)) return Array.from(e);
+}
+function gi(e, i) {
+  if (e) {
+    if (typeof e == "string") return ze(e, i);
+    var t = Object.prototype.toString.call(e).slice(8, -1);
+    if (t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set") return Array.from(e);
+    if (t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)) return ze(e, i);
+  }
+}
+function ze(e, i) {
+  (i == null || i > e.length) && (i = e.length);
+  for (var t = 0, s = new Array(i); t < i; t++) s[t] = e[t];
+  return s;
+}
+function bi() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function Si(e) {
+  var i;
+  return typeof e == "function" ? i = {
+    callback: e
+  } : i = e, i;
+}
+function Ti(e, i) {
+  var t = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, s, l, r, a = function(n) {
+    for (var c = arguments.length, d = new Array(c > 1 ? c - 1 : 0), p = 1; p < c; p++)
+      d[p - 1] = arguments[p];
+    if (r = d, !(s && n === l)) {
+      var I = t.leading;
+      typeof I == "function" && (I = I(n, l)), (!s || n !== l) && I && e.apply(void 0, [n].concat(Pe(r))), l = n, clearTimeout(s), s = setTimeout(function() {
+        e.apply(void 0, [n].concat(Pe(r))), s = 0;
+      }, i);
+    }
+  };
+  return a._clear = function() {
+    clearTimeout(s), s = null;
+  }, a;
+}
+function qe(e, i) {
+  if (e === i) return !0;
+  if (pe(e) === "object") {
+    for (var t in e)
+      if (!qe(e[t], i[t]))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+var _i = /* @__PURE__ */ (function() {
+  function e(i, t, s) {
+    fi(this, e), this.el = i, this.observer = null, this.frozen = !1, this.createObserver(t, s);
+  }
+  return mi(e, [{
+    key: "createObserver",
+    value: function(t, s) {
+      var l = this;
+      if (this.observer && this.destroyObserver(), !this.frozen) {
+        if (this.options = Si(t), this.callback = function(o, n) {
+          l.options.callback(o, n), o && l.options.once && (l.frozen = !0, l.destroyObserver());
+        }, this.callback && this.options.throttle) {
+          var r = this.options.throttleOptions || {}, a = r.leading;
+          this.callback = Ti(this.callback, this.options.throttle, {
+            leading: function(n) {
+              return a === "both" || a === "visible" && n || a === "hidden" && !n;
+            }
+          });
+        }
+        this.oldResult = void 0, this.observer = new IntersectionObserver(function(o) {
+          var n = o[0];
+          if (o.length > 1) {
+            var c = o.find(function(p) {
+              return p.isIntersecting;
+            });
+            c && (n = c);
+          }
+          if (l.callback) {
+            var d = n.isIntersecting && n.intersectionRatio >= l.threshold;
+            if (d === l.oldResult) return;
+            l.oldResult = d, l.callback(d, n);
+          }
+        }, this.options.intersection), ie(function() {
+          l.observer && l.observer.observe(l.el);
+        });
+      }
+    }
+  }, {
+    key: "destroyObserver",
+    value: function() {
+      this.observer && (this.observer.disconnect(), this.observer = null), this.callback && this.callback._clear && (this.callback._clear(), this.callback = null);
+    }
+  }, {
+    key: "threshold",
+    get: function() {
+      return this.options.intersection && typeof this.options.intersection.threshold == "number" ? this.options.intersection.threshold : 0;
+    }
+  }]), e;
+})();
+function Ye(e, i, t) {
+  var s = i.value;
+  if (s)
+    if (typeof IntersectionObserver > "u")
+      console.warn("[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill");
+    else {
+      var l = new _i(e, s, t);
+      e._vue_visibilityState = l;
+    }
+}
+function zi(e, i, t) {
+  var s = i.value, l = i.oldValue;
+  if (!qe(s, l)) {
+    var r = e._vue_visibilityState;
+    if (!s) {
+      Xe(e);
+      return;
+    }
+    r ? r.createObserver(s, t) : Ye(e, {
+      value: s
+    }, t);
+  }
+}
+function Xe(e) {
+  var i = e._vue_visibilityState;
+  i && (i.destroyObserver(), delete e._vue_visibilityState);
+}
+var ki = {
+  beforeMount: Ye,
+  updated: zi,
+  unmounted: Xe
+}, $i = {
+  itemsLimit: 1e3
+}, Ii = /(auto|scroll)/;
+function Ge(e, i) {
+  return e.parentNode === null ? i : Ge(e.parentNode, i.concat([e]));
+}
+var Se = function(i, t) {
+  return getComputedStyle(i, null).getPropertyValue(t);
+}, Di = function(i) {
+  return Se(i, "overflow") + Se(i, "overflow-y") + Se(i, "overflow-x");
+}, wi = function(i) {
+  return Ii.test(Di(i));
+};
+function Fe(e) {
+  if (e instanceof HTMLElement || e instanceof SVGElement) {
+    for (var i = Ge(e.parentNode, []), t = 0; t < i.length; t += 1)
+      if (wi(i[t]))
+        return i[t];
+    return document.scrollingElement || document.documentElement;
+  }
+}
+function ke(e) {
+  "@babel/helpers - typeof";
+  return ke = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(i) {
+    return typeof i;
+  } : function(i) {
+    return i && typeof Symbol == "function" && i.constructor === Symbol && i !== Symbol.prototype ? "symbol" : typeof i;
+  }, ke(e);
+}
+var Ze = {
+  items: {
+    type: Array,
+    required: !0
+  },
+  keyField: {
+    type: String,
+    default: "id"
+  },
+  direction: {
+    type: String,
+    default: "vertical",
+    validator: function(i) {
+      return ["vertical", "horizontal"].includes(i);
+    }
+  },
+  listTag: {
+    type: String,
+    default: "div"
+  },
+  itemTag: {
+    type: String,
+    default: "div"
+  }
+};
+function Je() {
+  return this.items.length && ke(this.items[0]) !== "object";
+}
+var $e = !1;
+if (typeof window < "u") {
+  $e = !1;
+  try {
+    var xi = Object.defineProperty({}, "passive", {
+      get: function() {
+        $e = !0;
+      }
+    });
+    window.addEventListener("test", null, xi);
+  } catch {
+  }
+}
+let Ci = 0;
+var Ne = {
+  name: "RecycleScroller",
+  components: {
+    ResizeObserver: ge
+  },
+  directives: {
+    ObserveVisibility: ki
+  },
+  props: {
+    ...Ze,
+    itemSize: {
+      type: Number,
+      default: null
+    },
+    gridItems: {
+      type: Number,
+      default: void 0
+    },
+    itemSecondarySize: {
+      type: Number,
+      default: void 0
+    },
+    minItemSize: {
+      type: [Number, String],
+      default: null
+    },
+    sizeField: {
+      type: String,
+      default: "size"
+    },
+    typeField: {
+      type: String,
+      default: "type"
+    },
+    buffer: {
+      type: Number,
+      default: 200
+    },
+    pageMode: {
+      type: Boolean,
+      default: !1
+    },
+    prerender: {
+      type: Number,
+      default: 0
+    },
+    emitUpdate: {
+      type: Boolean,
+      default: !1
+    },
+    updateInterval: {
+      type: Number,
+      default: 0
+    },
+    skipHover: {
+      type: Boolean,
+      default: !1
+    },
+    listTag: {
+      type: String,
+      default: "div"
+    },
+    itemTag: {
+      type: String,
+      default: "div"
+    },
+    listClass: {
+      type: [String, Object, Array],
+      default: ""
+    },
+    itemClass: {
+      type: [String, Object, Array],
+      default: ""
+    }
+  },
+  emits: [
+    "resize",
+    "visible",
+    "hidden",
+    "update",
+    "scroll-start",
+    "scroll-end"
+  ],
+  data() {
+    return {
+      pool: [],
+      totalSize: 0,
+      ready: !1,
+      hoverKey: null
+    };
+  },
+  computed: {
+    sizes() {
+      if (this.itemSize === null) {
+        const e = {
+          "-1": { accumulator: 0 }
+        }, i = this.items, t = this.sizeField, s = this.minItemSize;
+        let l = 1e4, r = 0, a;
+        for (let o = 0, n = i.length; o < n; o++)
+          a = i[o][t] || s, a < l && (l = a), r += a, e[o] = { accumulator: r, size: a };
+        return this.$_computedMinItemSize = l, e;
+      }
+      return [];
+    },
+    simpleArray: Je,
+    itemIndexByKey() {
+      const { keyField: e, items: i } = this, t = {};
+      for (let s = 0, l = i.length; s < l; s++)
+        t[i[s][e]] = s;
+      return t;
+    }
+  },
+  watch: {
+    items() {
+      this.updateVisibleItems(!0);
+    },
+    pageMode() {
+      this.applyPageMode(), this.updateVisibleItems(!1);
+    },
+    sizes: {
+      handler() {
+        this.updateVisibleItems(!1);
+      },
+      deep: !0
+    },
+    gridItems() {
+      this.updateVisibleItems(!0);
+    },
+    itemSecondarySize() {
+      this.updateVisibleItems(!0);
+    }
+  },
+  created() {
+    this.$_startIndex = 0, this.$_endIndex = 0, this.$_views = /* @__PURE__ */ new Map(), this.$_unusedViews = /* @__PURE__ */ new Map(), this.$_scrollDirty = !1, this.$_lastUpdateScrollPosition = 0, this.prerender && (this.$_prerender = !0, this.updateVisibleItems(!1)), this.gridItems && !this.itemSize && console.error("[vue-recycle-scroller] You must provide an itemSize when using gridItems");
+  },
+  mounted() {
+    this.applyPageMode(), this.$nextTick(() => {
+      this.$_prerender = !1, this.updateVisibleItems(!0), this.ready = !0;
+    });
+  },
+  activated() {
+    const e = this.$_lastUpdateScrollPosition;
+    typeof e == "number" && this.$nextTick(() => {
+      this.scrollToPosition(e);
+    });
+  },
+  beforeUnmount() {
+    this.removeListeners();
+  },
+  methods: {
+    addView(e, i, t, s, l) {
+      const r = nt({
+        id: Ci++,
+        index: i,
+        used: !0,
+        key: s,
+        type: l
+      }), a = rt({
+        item: t,
+        position: 0,
+        nr: r
+      });
+      return e.push(a), a;
+    },
+    unuseView(e, i = !1) {
+      const t = this.$_unusedViews, s = e.nr.type;
+      let l = t.get(s);
+      l || (l = [], t.set(s, l)), l.push(e), i || (e.nr.used = !1, e.position = -9999);
+    },
+    handleResize() {
+      this.$emit("resize"), this.ready && this.updateVisibleItems(!1);
+    },
+    handleScroll(e) {
+      if (!this.$_scrollDirty) {
+        if (this.$_scrollDirty = !0, this.$_updateTimeout) return;
+        const i = () => requestAnimationFrame(() => {
+          this.$_scrollDirty = !1;
+          const { continuous: t } = this.updateVisibleItems(!1, !0);
+          t || (clearTimeout(this.$_refreshTimout), this.$_refreshTimout = setTimeout(this.handleScroll, this.updateInterval + 100));
+        });
+        i(), this.updateInterval && (this.$_updateTimeout = setTimeout(() => {
+          this.$_updateTimeout = 0, this.$_scrollDirty && i();
+        }, this.updateInterval));
+      }
+    },
+    handleVisibilityChange(e, i) {
+      this.ready && (e || i.boundingClientRect.width !== 0 || i.boundingClientRect.height !== 0 ? (this.$emit("visible"), requestAnimationFrame(() => {
+        this.updateVisibleItems(!1);
+      })) : this.$emit("hidden"));
+    },
+    updateVisibleItems(e, i = !1) {
+      const t = this.itemSize, s = this.gridItems || 1, l = this.itemSecondarySize || t, r = this.$_computedMinItemSize, a = this.typeField, o = this.simpleArray ? null : this.keyField, n = this.items, c = n.length, d = this.sizes, p = this.$_views, I = this.$_unusedViews, m = this.pool, _ = this.itemIndexByKey;
+      let h, v, A, w, N;
+      if (!c)
+        h = v = w = N = A = 0;
+      else if (this.$_prerender)
+        h = w = 0, v = N = Math.min(this.prerender, n.length), A = null;
+      else {
+        const y = this.getScroll();
+        if (i) {
+          let E = y.start - this.$_lastUpdateScrollPosition;
+          if (E < 0 && (E = -E), t === null && E < r || E < t)
+            return {
+              continuous: !0
+            };
+        }
+        this.$_lastUpdateScrollPosition = y.start;
+        const O = this.buffer;
+        y.start -= O, y.end += O;
+        let x = 0;
+        if (this.$refs.before && (x = this.$refs.before.scrollHeight, y.start -= x), this.$refs.after) {
+          const E = this.$refs.after.scrollHeight;
+          y.end += E;
+        }
+        if (t === null) {
+          let E, q = 0, ee = c - 1, F = ~~(c / 2), Q;
+          do
+            Q = F, E = d[F].accumulator, E < y.start ? q = F : F < c - 1 && d[F + 1].accumulator > y.start && (ee = F), F = ~~((q + ee) / 2);
+          while (F !== Q);
+          for (F < 0 && (F = 0), h = F, A = d[c - 1].accumulator, v = F; v < c && d[v].accumulator < y.end; v++) ;
+          for (v === -1 ? v = n.length - 1 : (v++, v > c && (v = c)), w = h; w < c && x + d[w].accumulator < y.start; w++) ;
+          for (N = w; N < c && x + d[N].accumulator < y.end; N++) ;
+        } else {
+          h = ~~(y.start / t * s);
+          const E = h % s;
+          h -= E, v = Math.ceil(y.end / t * s), w = Math.max(0, Math.floor((y.start - x) / t * s)), N = Math.floor((y.end - x) / t * s), h < 0 && (h = 0), v > c && (v = c), w < 0 && (w = 0), N > c && (N = c), A = Math.ceil(c / s) * t;
+        }
+      }
+      v - h > $i.itemsLimit && this.itemsLimitError(), this.totalSize = A;
+      let S;
+      const g = h <= this.$_endIndex && v >= this.$_startIndex;
+      if (g)
+        for (let y = 0, O = m.length; y < O; y++)
+          S = m[y], S.nr.used && (e && (S.nr.index = _[S.item[o]]), (S.nr.index == null || S.nr.index < h || S.nr.index >= v) && this.unuseView(S));
+      const M = g ? null : /* @__PURE__ */ new Map();
+      let f, D, C;
+      for (let y = h; y < v; y++) {
+        f = n[y];
+        const O = o ? f[o] : f;
+        if (O == null)
+          throw new Error(`Key is ${O} on item (keyField is '${o}')`);
+        if (S = p.get(O), !t && !d[y].size) {
+          S && this.unuseView(S);
+          continue;
+        }
+        D = f[a];
+        let x = I.get(D), E = !1;
+        if (!S)
+          g ? x && x.length ? S = x.pop() : S = this.addView(m, y, f, O, D) : (C = M.get(D) || 0, (!x || C >= x.length) && (S = this.addView(m, y, f, O, D), this.unuseView(S, !0), x = I.get(D)), S = x[C], M.set(D, C + 1)), p.delete(S.nr.key), S.nr.used = !0, S.nr.index = y, S.nr.key = O, S.nr.type = D, p.set(O, S), E = !0;
+        else if (!S.nr.used && (S.nr.used = !0, E = !0, x)) {
+          const q = x.indexOf(S);
+          q !== -1 && x.splice(q, 1);
+        }
+        S.item = f, E && (y === n.length - 1 && this.$emit("scroll-end"), y === 0 && this.$emit("scroll-start")), t === null ? (S.position = d[y - 1].accumulator, S.offset = 0) : (S.position = Math.floor(y / s) * t, S.offset = y % s * l);
+      }
+      return this.$_startIndex = h, this.$_endIndex = v, this.emitUpdate && this.$emit("update", h, v, w, N), clearTimeout(this.$_sortTimer), this.$_sortTimer = setTimeout(this.sortViews, this.updateInterval + 300), {
+        continuous: g
+      };
+    },
+    getListenerTarget() {
+      let e = Fe(this.$el);
+      return window.document && (e === window.document.documentElement || e === window.document.body) && (e = window), e;
+    },
+    getScroll() {
+      const { $el: e, direction: i } = this, t = i === "vertical";
+      let s;
+      if (this.pageMode) {
+        const l = e.getBoundingClientRect(), r = t ? l.height : l.width;
+        let a = -(t ? l.top : l.left), o = t ? window.innerHeight : window.innerWidth;
+        a < 0 && (o += a, a = 0), a + o > r && (o = r - a), s = {
+          start: a,
+          end: a + o
+        };
+      } else t ? s = {
+        start: e.scrollTop,
+        end: e.scrollTop + e.clientHeight
+      } : s = {
+        start: e.scrollLeft,
+        end: e.scrollLeft + e.clientWidth
+      };
+      return s;
+    },
+    applyPageMode() {
+      this.pageMode ? this.addListeners() : this.removeListeners();
+    },
+    addListeners() {
+      this.listenerTarget = this.getListenerTarget(), this.listenerTarget.addEventListener("scroll", this.handleScroll, $e ? {
+        passive: !0
+      } : !1), this.listenerTarget.addEventListener("resize", this.handleResize);
+    },
+    removeListeners() {
+      this.listenerTarget && (this.listenerTarget.removeEventListener("scroll", this.handleScroll), this.listenerTarget.removeEventListener("resize", this.handleResize), this.listenerTarget = null);
+    },
+    scrollToItem(e) {
+      let i;
+      const t = this.gridItems || 1;
+      this.itemSize === null ? i = e > 0 ? this.sizes[e - 1].accumulator : 0 : i = Math.floor(e / t) * this.itemSize, this.scrollToPosition(i);
+    },
+    scrollToPosition(e) {
+      const i = this.direction === "vertical" ? { scroll: "scrollTop", start: "top" } : { scroll: "scrollLeft", start: "left" };
+      let t, s, l;
+      if (this.pageMode) {
+        const r = Fe(this.$el), a = r.tagName === "HTML" ? 0 : r[i.scroll], o = r.getBoundingClientRect(), c = this.$el.getBoundingClientRect()[i.start] - o[i.start];
+        t = r, s = i.scroll, l = e + a + c;
+      } else
+        t = this.$el, s = i.scroll, l = e;
+      t[s] = l;
+    },
+    itemsLimitError() {
+      throw setTimeout(() => {
+        console.log("It seems the scroller element isn't scrolling, so it tries to render all the items at once.", "Scroller:", this.$el), console.log("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.");
+      }), new Error("Rendered items limit reached");
+    },
+    sortViews() {
+      this.pool.sort((e, i) => e.nr.index - i.nr.index);
+    }
+  }
+};
+const Ni = {
+  key: 0,
+  ref: "before",
+  class: "vue-recycle-scroller__slot"
+}, Li = {
+  key: 1,
+  ref: "after",
+  class: "vue-recycle-scroller__slot"
+};
+function Oi(e, i, t, s, l, r) {
+  const a = we("ResizeObserver"), o = ot("observe-visibility");
+  return at((T(), P(
+    "div",
+    {
+      class: ue(["vue-recycle-scroller", {
+        ready: l.ready,
+        "page-mode": t.pageMode,
+        [`direction-${e.direction}`]: !0
+      }]),
+      onScrollPassive: i[0] || (i[0] = (...n) => r.handleScroll && r.handleScroll(...n))
+    },
+    [
+      e.$slots.before ? (T(), P(
+        "div",
+        Ni,
+        [
+          J(e.$slots, "before")
+        ],
+        512
+        /* NEED_PATCH */
+      )) : G("v-if", !0),
+      (T(), U(Ae(t.listTag), {
+        ref: "wrapper",
+        style: He({ [e.direction === "vertical" ? "minHeight" : "minWidth"]: l.totalSize + "px" }),
+        class: ue(["vue-recycle-scroller__item-wrapper", t.listClass])
+      }, {
+        default: W(() => [
+          (T(!0), P(
+            de,
+            null,
+            je(l.pool, (n) => (T(), U(Ae(t.itemTag), De({
+              key: n.nr.id,
+              style: l.ready ? {
+                transform: `translate${e.direction === "vertical" ? "Y" : "X"}(${n.position}px) translate${e.direction === "vertical" ? "X" : "Y"}(${n.offset}px)`,
+                width: t.gridItems ? `${e.direction === "vertical" && t.itemSecondarySize || t.itemSize}px` : void 0,
+                height: t.gridItems ? `${e.direction === "horizontal" && t.itemSecondarySize || t.itemSize}px` : void 0
+              } : null,
+              class: ["vue-recycle-scroller__item-view", [
+                t.itemClass,
+                {
+                  hover: !t.skipHover && l.hoverKey === n.nr.key
+                }
+              ]]
+            }, ct(t.skipHover ? {} : {
+              mouseenter: () => {
+                l.hoverKey = n.nr.key;
+              },
+              mouseleave: () => {
+                l.hoverKey = null;
+              }
+            })), {
+              default: W(() => [
+                J(e.$slots, "default", {
+                  item: n.item,
+                  index: n.nr.index,
+                  active: n.nr.used
+                })
+              ]),
+              _: 2
+              /* DYNAMIC */
+            }, 1040, ["style", "class"]))),
+            128
+            /* KEYED_FRAGMENT */
+          )),
+          J(e.$slots, "empty")
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["style", "class"])),
+      e.$slots.after ? (T(), P(
+        "div",
+        Li,
+        [
+          J(e.$slots, "after")
+        ],
+        512
+        /* NEED_PATCH */
+      )) : G("v-if", !0),
+      H(a, { onNotify: r.handleResize }, null, 8, ["onNotify"])
+    ],
+    34
+    /* CLASS, HYDRATE_EVENTS */
+  )), [
+    [o, r.handleVisibilityChange]
+  ]);
+}
+Ne.render = Oi;
+Ne.__file = "src/components/RecycleScroller.vue";
+var Le = {
+  name: "DynamicScroller",
+  components: {
+    RecycleScroller: Ne
+  },
+  provide() {
+    return typeof ResizeObserver < "u" && (this.$_resizeObserver = new ResizeObserver((e) => {
+      requestAnimationFrame(() => {
+        if (Array.isArray(e)) {
+          for (const i of e)
+            if (i.target && i.target.$_vs_onResize) {
+              let t, s;
+              if (i.borderBoxSize) {
+                const l = i.borderBoxSize[0];
+                t = l.inlineSize, s = l.blockSize;
+              } else
+                t = i.contentRect.width, s = i.contentRect.height;
+              i.target.$_vs_onResize(i.target.$_vs_id, t, s);
+            }
+        }
+      });
+    })), {
+      vscrollData: this.vscrollData,
+      vscrollParent: this,
+      vscrollResizeObserver: this.$_resizeObserver
+    };
+  },
+  inheritAttrs: !1,
+  props: {
+    ...Ze,
+    minItemSize: {
+      type: [Number, String],
+      required: !0
+    }
+  },
+  emits: [
+    "resize",
+    "visible"
+  ],
+  data() {
+    return {
+      vscrollData: {
+        active: !0,
+        sizes: {},
+        keyField: this.keyField,
+        simpleArray: !1
+      }
+    };
+  },
+  computed: {
+    simpleArray: Je,
+    itemsWithSize() {
+      const e = [], { items: i, keyField: t, simpleArray: s } = this, l = this.vscrollData.sizes, r = i.length;
+      for (let a = 0; a < r; a++) {
+        const o = i[a], n = s ? a : o[t];
+        let c = l[n];
+        typeof c > "u" && !this.$_undefinedMap[n] && (c = 0), e.push({
+          item: o,
+          id: n,
+          size: c
+        });
+      }
+      return e;
+    }
+  },
+  watch: {
+    items() {
+      this.forceUpdate();
+    },
+    simpleArray: {
+      handler(e) {
+        this.vscrollData.simpleArray = e;
+      },
+      immediate: !0
+    },
+    direction(e) {
+      this.forceUpdate(!0);
+    },
+    itemsWithSize(e, i) {
+      const t = this.$el.scrollTop;
+      let s = 0, l = 0;
+      const r = Math.min(e.length, i.length);
+      for (let o = 0; o < r && !(s >= t); o++)
+        s += i[o].size || this.minItemSize, l += e[o].size || this.minItemSize;
+      const a = l - s;
+      a !== 0 && (this.$el.scrollTop += a);
+    }
+  },
+  beforeCreate() {
+    this.$_updates = [], this.$_undefinedSizes = 0, this.$_undefinedMap = {}, this.$_events = Lt();
+  },
+  activated() {
+    this.vscrollData.active = !0;
+  },
+  deactivated() {
+    this.vscrollData.active = !1;
+  },
+  unmounted() {
+    this.$_events.all.clear();
+  },
+  methods: {
+    onScrollerResize() {
+      this.$refs.scroller && this.forceUpdate(), this.$emit("resize");
+    },
+    onScrollerVisible() {
+      this.$_events.emit("vscroll:update", { force: !1 }), this.$emit("visible");
+    },
+    forceUpdate(e = !1) {
+      (e || this.simpleArray) && (this.vscrollData.sizes = {}), this.$_events.emit("vscroll:update", { force: !0 });
+    },
+    scrollToItem(e) {
+      const i = this.$refs.scroller;
+      i && i.scrollToItem(e);
+    },
+    getItemSize(e, i = void 0) {
+      const t = this.simpleArray ? i ?? this.items.indexOf(e) : e[this.keyField];
+      return this.vscrollData.sizes[t] || 0;
+    },
+    scrollToBottom() {
+      if (this.$_scrollingToBottom) return;
+      this.$_scrollingToBottom = !0;
+      const e = this.$el;
+      this.$nextTick(() => {
+        e.scrollTop = e.scrollHeight + 5e3;
+        const i = () => {
+          e.scrollTop = e.scrollHeight + 5e3, requestAnimationFrame(() => {
+            e.scrollTop = e.scrollHeight + 5e3, this.$_undefinedSizes === 0 ? this.$_scrollingToBottom = !1 : requestAnimationFrame(i);
+          });
+        };
+        requestAnimationFrame(i);
+      });
+    }
+  }
+};
+function Ai(e, i, t, s, l, r) {
+  const a = we("RecycleScroller");
+  return T(), U(a, De({
+    ref: "scroller",
+    items: r.itemsWithSize,
+    "min-item-size": t.minItemSize,
+    direction: e.direction,
+    "key-field": "id",
+    "list-tag": e.listTag,
+    "item-tag": e.itemTag
+  }, e.$attrs, {
+    onResize: r.onScrollerResize,
+    onVisible: r.onScrollerVisible
+  }), {
+    default: W(({ item: o, index: n, active: c }) => [
+      J(e.$slots, "default", dt(ut({
+        item: o.item,
+        index: n,
+        active: c,
+        itemWithSize: o
+      })))
+    ]),
+    before: W(() => [
+      J(e.$slots, "before")
+    ]),
+    after: W(() => [
+      J(e.$slots, "after")
+    ]),
+    empty: W(() => [
+      J(e.$slots, "empty")
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 16, ["items", "min-item-size", "direction", "list-tag", "item-tag", "onResize", "onVisible"]);
+}
+Le.render = Ai;
+Le.__file = "src/components/DynamicScroller.vue";
+var Qe = {
+  name: "DynamicScrollerItem",
+  inject: [
+    "vscrollData",
+    "vscrollParent",
+    "vscrollResizeObserver"
+  ],
+  props: {
+    // eslint-disable-next-line vue/require-prop-types
+    item: {
+      required: !0
+    },
+    watchData: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Indicates if the view is actively used to display an item.
+     */
+    active: {
+      type: Boolean,
+      required: !0
+    },
+    index: {
+      type: Number,
+      default: void 0
+    },
+    sizeDependencies: {
+      type: [Array, Object],
+      default: null
+    },
+    emitResize: {
+      type: Boolean,
+      default: !1
+    },
+    tag: {
+      type: String,
+      default: "div"
+    }
+  },
+  emits: [
+    "resize"
+  ],
+  computed: {
+    id() {
+      if (this.vscrollData.simpleArray) return this.index;
+      if (this.vscrollData.keyField in this.item) return this.item[this.vscrollData.keyField];
+      throw new Error(`keyField '${this.vscrollData.keyField}' not found in your item. You should set a valid keyField prop on your Scroller`);
+    },
+    size() {
+      return this.vscrollData.sizes[this.id] || 0;
+    },
+    finalActive() {
+      return this.active && this.vscrollData.active;
+    }
+  },
+  watch: {
+    watchData: "updateWatchData",
+    id(e, i) {
+      if (this.$el.$_vs_id = this.id, this.size || this.onDataUpdate(), this.$_sizeObserved) {
+        const t = this.vscrollData.sizes[i], s = this.vscrollData.sizes[e];
+        t != null && t !== s && this.applySize(t);
+      }
+    },
+    finalActive(e) {
+      this.size || (e ? this.vscrollParent.$_undefinedMap[this.id] || (this.vscrollParent.$_undefinedSizes++, this.vscrollParent.$_undefinedMap[this.id] = !0) : this.vscrollParent.$_undefinedMap[this.id] && (this.vscrollParent.$_undefinedSizes--, this.vscrollParent.$_undefinedMap[this.id] = !1)), this.vscrollResizeObserver ? e ? this.observeSize() : this.unobserveSize() : e && this.$_pendingVScrollUpdate === this.id && this.updateSize();
+    }
+  },
+  created() {
+    if (!this.$isServer && (this.$_forceNextVScrollUpdate = null, this.updateWatchData(), !this.vscrollResizeObserver)) {
+      for (const e in this.sizeDependencies)
+        this.$watch(() => this.sizeDependencies[e], this.onDataUpdate);
+      this.vscrollParent.$_events.on("vscroll:update", this.onVscrollUpdate);
+    }
+  },
+  mounted() {
+    this.finalActive && (this.updateSize(), this.observeSize());
+  },
+  beforeUnmount() {
+    this.vscrollParent.$_events.off("vscroll:update", this.onVscrollUpdate), this.unobserveSize();
+  },
+  methods: {
+    updateSize() {
+      this.finalActive ? this.$_pendingSizeUpdate !== this.id && (this.$_pendingSizeUpdate = this.id, this.$_forceNextVScrollUpdate = null, this.$_pendingVScrollUpdate = null, this.computeSize(this.id)) : this.$_forceNextVScrollUpdate = this.id;
+    },
+    updateWatchData() {
+      this.watchData && !this.vscrollResizeObserver ? this.$_watchData = this.$watch("item", () => {
+        this.onDataUpdate();
+      }, {
+        deep: !0
+      }) : this.$_watchData && (this.$_watchData(), this.$_watchData = null);
+    },
+    onVscrollUpdate({ force: e }) {
+      !this.finalActive && e && (this.$_pendingVScrollUpdate = this.id), (this.$_forceNextVScrollUpdate === this.id || e || !this.size) && this.updateSize();
+    },
+    onDataUpdate() {
+      this.updateSize();
+    },
+    computeSize(e) {
+      this.$nextTick(() => {
+        if (this.id === e) {
+          const i = this.$el.offsetWidth, t = this.$el.offsetHeight;
+          this.applyWidthHeight(i, t);
+        }
+        this.$_pendingSizeUpdate = null;
+      });
+    },
+    applyWidthHeight(e, i) {
+      const t = ~~(this.vscrollParent.direction === "vertical" ? i : e);
+      t && this.size !== t && this.applySize(t);
+    },
+    applySize(e) {
+      this.vscrollParent.$_undefinedMap[this.id] && (this.vscrollParent.$_undefinedSizes--, this.vscrollParent.$_undefinedMap[this.id] = void 0), this.vscrollData.sizes[this.id] = e, this.emitResize && this.$emit("resize", this.id);
+    },
+    observeSize() {
+      this.vscrollResizeObserver && (this.$_sizeObserved || (this.vscrollResizeObserver.observe(this.$el), this.$el.$_vs_id = this.id, this.$el.$_vs_onResize = this.onResize, this.$_sizeObserved = !0));
+    },
+    unobserveSize() {
+      this.vscrollResizeObserver && this.$_sizeObserved && (this.vscrollResizeObserver.unobserve(this.$el), this.$el.$_vs_onResize = void 0, this.$_sizeObserved = !1);
+    },
+    onResize(e, i, t) {
+      this.id === e && this.applyWidthHeight(i, t);
+    }
+  },
+  render() {
+    return me(this.tag, this.$slots.default());
+  }
+};
+Qe.__file = "src/components/DynamicScrollerItem.vue";
+const Ei = {
+  key: 0,
+  class: "loading-indicator"
+}, Mi = { class: "loading-text" }, Ri = {
+  key: 1,
+  class: "no-more-tip"
+}, Pi = {
+  key: 1,
+  class: "empty-state"
+}, Fi = { class: "empty-text" }, Vi = {
+  __name: "ScrollList",
+  props: {
+    // 数据源
+    items: {
+      type: Array,
+      default: () => []
+    },
+    // 是否正在加载
+    loading: {
+      type: Boolean,
+      default: !1
+    },
+    // 是否还有更多数据
+    hasMore: {
+      type: Boolean,
+      default: !0
+    },
+    // 加载提示文本
+    loadingText: {
+      type: String,
+      default: "加载中..."
+    },
+    // 没有更多数据提示文本
+    noMoreText: {
+      type: String,
+      default: "没有更多了"
+    },
+    // 空状态文本
+    emptyText: {
+      type: String,
+      default: "暂无数据"
+    },
+    // 容器高度
+    height: {
+      type: String,
+      default: "auto"
+    },
+    // 最小项目高度（用于虚拟滚动计算，单位：px）
+    minItemSize: {
+      type: Number,
+      default: 60
+    },
+    // 缓冲区大小（渲染可见区域之外的额外项目数）
+    buffer: {
+      type: Number,
+      default: 200
+    },
+    // 触发加载更多的距离阈值（像素）
+    threshold: {
+      type: Number,
+      default: 100
+    },
+    // 用于标识每个 item 的字段名
+    keyField: {
+      type: String,
+      default: "id"
+    }
+  },
+  emits: ["load-more", "scroll"],
+  setup(e, { expose: i, emit: t }) {
+    const s = e, l = t, r = B(null), a = B(null), o = B(!1);
+    let n = null;
+    const c = K(() => ({
+      height: s.height
+    })), d = () => {
+      console.log("loadMore triggered----", o.value || !s.hasMore || s.loading), !(o.value || !s.hasMore || s.loading) && (o.value = !0, l("load-more"));
+    }, p = () => {
+      o.value = !1, I();
+    }, I = () => {
+      r.value && r.value.scrollToPosition(0);
+    }, m = () => {
+      if (r.value) {
+        const w = r.value.$el;
+        w && (w.scrollTop = w.scrollHeight);
+      }
+    }, _ = (w) => {
+      r.value && r.value.scrollToItem(w);
+    }, h = () => {
+      if (!a.value || !r.value) return;
+      const w = r.value.$el;
+      if (!w) return;
+      const N = {
+        root: w,
+        rootMargin: `${s.threshold}px`,
+        threshold: 0.1
+      };
+      n = new IntersectionObserver((S) => {
+        S.forEach((g) => {
+          console.log(
+            "Setting up Intersection Observer-----",
+            g.isIntersecting,
+            s.hasMore,
+            !o.value,
+            !s.loading
+          ), g.isIntersecting && s.hasMore && !o.value && !s.loading && d();
+        });
+      }, N), n.observe(a.value);
+    }, v = () => {
+      n && (n.disconnect(), n = null);
+    }, A = (w) => {
+      const N = w.target;
+      l("scroll", {
+        scrollTop: N.scrollTop,
+        scrollHeight: N.scrollHeight,
+        clientHeight: N.clientHeight
+      });
+    };
+    return Z(
+      () => s.loading,
+      (w) => {
+        w || (o.value = !1);
+      }
+    ), Z(
+      () => s.items.length,
+      async () => {
+        await ie(), v(), s.hasMore && h();
+      }
+    ), Ie(async () => {
+      await ie(), s.hasMore && h();
+    }), ht(() => {
+      v();
+    }), i({
+      reset: p,
+      scrollToTop: I,
+      scrollToBottom: m,
+      scrollToItem: _,
+      loadMore: d
+    }), (w, N) => {
+      const S = we("Loading");
+      return T(), P("div", {
+        class: "scroll-list",
+        style: He(c.value)
+      }, [
+        e.items.length > 0 ? (T(), U($(Le), {
+          key: 0,
+          ref_key: "scrollerRef",
+          ref: r,
+          items: e.items,
+          "min-item-size": e.minItemSize,
+          buffer: e.buffer,
+          "key-field": e.keyField,
+          class: "scroller",
+          onScroll: A
+        }, {
+          default: W(({ item: g, index: M, active: f }) => [
+            H($(Qe), {
+              item: g,
+              active: f,
+              "data-index": M,
+              "size-dependencies": [g]
+            }, {
+              default: W(() => [
+                J(w.$slots, "default", {
+                  item: g,
+                  index: M,
+                  active: f
+                }, void 0, !0)
+              ]),
+              _: 2
+            }, 1032, ["item", "active", "data-index", "size-dependencies"])
+          ]),
+          after: W(() => [
+            e.hasMore ? (T(), P("div", {
+              key: 0,
+              ref_key: "loadMoreTriggerRef",
+              ref: a,
+              class: "load-more-trigger"
+            }, [
+              o.value ? (T(), P("div", Ei, [
+                H($(ve), { class: "is-loading" }, {
+                  default: W(() => [
+                    H(S)
+                  ]),
+                  _: 1
+                }),
+                j("span", Mi, te(e.loadingText), 1)
+              ])) : G("", !0)
+            ], 512)) : G("", !0),
+            !e.hasMore && e.items.length > 0 ? (T(), P("div", Ri, te(e.noMoreText), 1)) : G("", !0)
+          ]),
+          _: 3
+        }, 8, ["items", "min-item-size", "buffer", "key-field"])) : G("", !0),
+        e.items.length === 0 && !o.value ? (T(), P("div", Pi, [
+          J(w.$slots, "empty", {}, () => [
+            H($(ve), {
+              class: "empty-icon",
+              size: 80
+            }, {
+              default: W(() => [
+                H($(Ct))
+              ]),
+              _: 1
+            }),
+            j("div", Fi, te(e.emptyText), 1)
+          ], !0)
+        ])) : G("", !0)
+      ], 4);
+    };
+  }
+}, ji = /* @__PURE__ */ ae(Vi, [["__scopeId", "data-v-37e01654"]]), Hi = { class: "search-wrap" }, Ui = { class: "list-item" }, Bi = ["onClick"], Ki = { class: "node-info" }, Wi = { class: "node-label" }, qi = {
+  key: 0,
+  class: "node-suffix"
+}, Yi = {
+  __name: "index",
+  props: {
+    items: {
+      type: Array,
+      default: () => []
+    },
+    loading: {
+      type: Boolean,
+      default: !1
+    },
+    hasMore: {
+      type: Boolean,
+      default: !1
+    },
+    height: {
+      type: String,
+      default: "100%"
+    },
+    minItemSize: {
+      type: Number,
+      default: 50
+    },
+    buffer: {
+      type: Number,
+      default: 100
+    },
+    treeProps: {
+      type: Object,
+      default: () => ({
+        label: "label",
+        value: "value"
+      })
+    },
+    // 已选择的文档（当前 tab 的选择）
+    selectedDocuments: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["load-more", "item-check"],
+  setup(e, { emit: i }) {
+    const { t } = Ot(), s = e, l = K(() => s.items.map((n) => {
+      const c = (s.selectedDocuments || []).some(
+        (d) => d.id === n.id
+      );
+      return {
+        ...n,
+        isSelected: c
+      };
+    })), r = i, a = (n, c) => {
+      r("item-check", n, c);
+    }, o = () => {
+      r("load-more");
+    };
+    return (n, c) => (T(), P("div", Hi, [
+      H(ji, {
+        items: l.value,
+        loading: e.loading,
+        "key-field": "id",
+        "has-more": e.hasMore,
+        "loading-text": $(t)("FEISHU_SEARCH_TEXT.LOADING_TEXT"),
+        "no-more-text": $(t)("FEISHU_SEARCH_TEXT.NO_MORE_TEXT"),
+        "empty-text": $(t)("FEISHU_SEARCH_TEXT.EMPTY_TEXT"),
+        height: e.height,
+        "min-item-size": e.minItemSize,
+        buffer: e.buffer,
+        onLoadMore: o
+      }, {
+        default: W(({ item: d }) => [
+          j("div", Ui, [
+            J(n.$slots, "default", { item: d }, () => [
+              j("div", {
+                class: "search-item",
+                onClick: () => a(d, !d.isSelected)
+              }, [
+                H($(mt), {
+                  "model-value": d.isSelected
+                }, null, 8, ["model-value"]),
+                H(ye, {
+                  "file-type": d.type,
+                  size: 26,
+                  isLocalFileType: n.data?.isLocalFileType
+                }, null, 8, ["file-type", "isLocalFileType"]),
+                j("div", Ki, [
+                  j("span", Wi, te(d[e.treeProps.label]), 1),
+                  d.suffix ? (T(), P("span", qi, te(d.suffix), 1)) : G("", !0)
+                ])
+              ], 8, Bi)
+            ], !0)
+          ])
+        ]),
+        _: 3
+      }, 8, ["items", "loading", "has-more", "loading-text", "no-more-text", "empty-text", "height", "min-item-size", "buffer"])
+    ]));
+  }
+}, Xi = /* @__PURE__ */ ae(Yi, [["__scopeId", "data-v-9b7f5847"]]), Gi = { class: "left-wrap" }, Zi = { class: "content" }, Ji = { class: "input-wrap" }, Qi = { class: "tree-container" }, es = { class: "tree-node-content" }, ts = { class: "node-info" }, is = { class: "node-label" }, ss = {
+  key: 0,
+  class: "node-suffix"
+}, ls = 15, ns = /* @__PURE__ */ Object.assign({
+  name: "LeftLayout"
+}, {
+  __name: "LeftLayout",
+  props: {
+    // 文件夹选项卡配置
+    tabs: {
+      type: Array,
+      default: () => []
+    },
+    // 文档树数据
+    treeData: {
+      type: Object,
+      default: () => ({})
+    },
+    // 树配置
+    treeProps: {
+      type: Object,
+      default: () => ne
+    },
+    // 已选择的文档（当前 tab 的选择）
+    selectedDocuments: {
+      type: Array,
+      default: () => []
+    },
+    // 当前激活的 tab
+    currentTab: {
+      type: String,
+      default: ""
+    },
+    // 搜索类型：'frontend' 前端搜索 | 'backend' 后端搜索
+    searchType: {
+      type: String,
+      default: oe.FRONTEND,
+      validator: (e) => Object.values(oe).includes(e)
+    },
+    // 文本配置
+    textConfig: {
+      type: Object,
+      default: () => ({
+        searchPlaceholder: ""
+      })
+    },
+    getTabSelectedDocuments: {
+      type: Function,
+      default: () => () => []
+    },
+    responseSearchHook: {
+      type: Object,
+      default: () => {
+      }
+    }
+  },
+  emits: [
+    "node-check",
+    "tab-change",
+    "search",
+    "node-expand",
+    "load-more",
+    "node-check-search"
+  ],
+  setup(e, { expose: i, emit: t }) {
+    const s = e, l = t, r = Ce(me), a = B(), o = B(""), n = B(s.currentTab || s.tabs[0]?.value || le.MY_FILES), c = B([]), d = B(!1), p = B(!1), I = K(() => s.tabs.map((f) => ({
+      label: f.label,
+      value: f.value
+    }))), m = K(() => s.treeData[n.value] || []);
+    Z(
+      () => s.responseSearchHook,
+      (f, D) => {
+        p.value = Re(s.currentTab, f), d.value = !1;
+      },
+      { deep: !0, immediate: !0 }
+    );
+    const _ = ti(l, 800), h = K(() => {
+      if (s.searchType === oe.BACKEND)
+        return m.value;
+      const f = o.value?.trim();
+      return f ? Ke(m.value, f, s.treeProps) : m.value;
+    }), v = (f) => s.getTabSelectedDocuments(n.value).some((C) => C[s.treeProps.value] === f), A = K(() => {
+      if (!o.value?.trim()) return [];
+      const f = (D, C = 0) => {
+        let y = [];
+        return D.forEach((O) => {
+          y.push({
+            ...O,
+            level: C,
+            isSelected: v(O[s.treeProps.value])
+          }), O[s.treeProps.children] && O[s.treeProps.children].length > 0 && (y = y.concat(f(O[s.treeProps.children], C + 1)));
+        }), y;
+      };
+      return f(h.value);
+    }), w = (f) => {
+      l("node-check", f);
+    }, N = (f, D) => {
+      const C = {
+        selectedNode: s.getTabSelectedDocuments(n.value),
+        checkedNode: f,
+        isChecked: D
+      };
+      l("node-check-search", C);
+    };
+    Z(n, (f) => {
+      p.value = Re(f, s.responseSearchHook), l("tab-change", f);
+    }), Z(
+      () => s.treeData,
+      () => {
+        d.value = !1, a.value && a.value.syncSelectedNodes && ie(() => {
+          const f = (s.selectedDocuments || []).map((D) => D[s.treeProps.value]);
+          a.value.syncSelectedNodes(f);
+        });
+      },
+      { deep: !0 }
+    );
+    const S = (f) => {
+      ei(f) || l("node-expand", {
+        node: f,
+        tabKey: n.value
+      });
+    }, g = () => {
+      d.value = !0, l("load-more");
+    }, M = (f, D) => {
+      a.value && a.value?.updateNodeChildren && a.value.updateNodeChildren(f, D);
+    };
+    return Z(o, (f) => {
+      s.searchType === oe.BACKEND ? (f && f.trim() && (d.value = !0), _(f || "")) : d.value = !1;
+    }), Z(
+      () => s.currentTab,
+      (f) => {
+        f && f !== n.value && (n.value = f);
+      },
+      { immediate: !0 }
+    ), Z(
+      () => s.selectedDocuments,
+      (f) => {
+        c.value = f || [];
+      },
+      { immediate: !0, deep: !0 }
+    ), i({
+      setNodeCheckStatus: (f, D) => {
+        a.value?.setNodeCheckStatus(f, D);
+      },
+      updateNodeChildren: M,
+      syncSelectedNodes: (f) => {
+        a.value?.syncSelectedNodes(f);
+      }
+    }), (f, D) => (T(), P("div", Gi, [
+      j("div", Zi, [
+        j("div", Ji, [
+          H($(vt), {
+            modelValue: o.value,
+            "onUpdate:modelValue": D[0] || (D[0] = (C) => o.value = C),
+            placeholder: s.textConfig.searchPlaceholder,
+            "prefix-icon": $(Nt),
+            clearable: ""
+          }, null, 8, ["modelValue", "placeholder", "prefix-icon"])
+        ]),
+        H($(yt), {
+          modelValue: n.value,
+          "onUpdate:modelValue": D[1] || (D[1] = (C) => n.value = C),
+          options: I.value
+        }, null, 8, ["modelValue", "options"]),
+        j("div", Qi, [
+          !h.value || h.value.length === 0 ? (T(), U($(xe), { key: 0 })) : (T(), P(de, { key: 1 }, [
+            o.value.trim() !== "" ? (T(), U(Xi, {
+              key: 0,
+              items: A.value,
+              loading: d.value,
+              "has-more": p.value,
+              "min-item-size": 50,
+              buffer: 100,
+              "tree-props": e.treeProps,
+              "selected-documents": e.selectedDocuments,
+              onItemCheck: N,
+              onLoadMore: g
+            }, null, 8, ["items", "loading", "has-more", "tree-props", "selected-documents"])) : (T(), U(ai, {
+              key: 1,
+              modelValue: c.value,
+              "onUpdate:modelValue": D[2] || (D[2] = (C) => c.value = C),
+              ref_key: "treeSelectRef",
+              ref: a,
+              "tree-list": h.value,
+              "tree-props": e.treeProps,
+              "filter-keyword": o.value,
+              itemSize: 50,
+              hasTreeLine: !0,
+              "text-config": e.textConfig,
+              includeParentSelected: !0,
+              onHandleCheck: w,
+              onNodeExpand: S,
+              getTabSelectedDocuments: e.getTabSelectedDocuments
+            }, {
+              node: W(({ node: C, data: y }) => [
+                J(f.$slots, "node", {
+                  node: C,
+                  data: y
+                }, () => [
+                  H($(r), {
+                    node: C,
+                    treeData: h.value,
+                    showLabelLine: !0,
+                    indent: ls
+                  }, {
+                    default: W(() => [
+                      j("div", es, [
+                        H(ye, {
+                          "file-type": y.type,
+                          size: 26,
+                          isLocalFileType: y?.isLocalFileType
+                        }, null, 8, ["file-type", "isLocalFileType"]),
+                        j("div", ts, [
+                          j("span", is, te(y[e.treeProps.label]), 1),
+                          y.suffix ? (T(), P("span", ss, te(y.suffix), 1)) : G("", !0)
+                        ])
+                      ])
+                    ]),
+                    _: 2
+                  }, 1032, ["node", "treeData"])
+                ], !0)
+              ]),
+              _: 3
+            }, 8, ["modelValue", "tree-list", "tree-props", "filter-keyword", "text-config", "getTabSelectedDocuments"]))
+          ], 64))
+        ])
+      ])
+    ]));
+  }
+}), rs = /* @__PURE__ */ ae(ns, [["__scopeId", "data-v-6bf8c501"]]);
+function os(e = {}) {
+  const { valueKey: i = "id" } = e, t = B(/* @__PURE__ */ new Map()), s = K(() => {
+    const m = [], _ = /* @__PURE__ */ new Set();
+    return t.value.forEach((h) => {
+      h.forEach((v) => {
+        const A = v[i];
+        _.has(A) || (m.push(v), _.add(A));
+      });
+    }), m;
+  });
+  return {
+    // 状态
+    allSelectedDocuments: s,
+    selectionMap: t,
+    // 方法
+    getTabSelectedDocuments: (m) => {
+      const _ = t.value.get(m);
+      return _ ? Array.from(_.values()) : [];
+    },
+    updateTabSelection: (m, _ = []) => {
+      t.value.has(m) || t.value.set(m, /* @__PURE__ */ new Map());
+      const h = /* @__PURE__ */ new Map();
+      _.forEach((v) => {
+        v && v[i] != null && h.set(v[i], v);
+      }), t.value.set(m, h), t.value = new Map(t.value);
+    },
+    removeDocument: (m) => {
+      const _ = m[i];
+      let h = null;
+      return t.value.forEach((v, A) => {
+        v.has(_) && (v.delete(_), h = A);
+      }), h && (t.value = new Map(t.value)), h;
+    },
+    toggleDocument: (m, _, h) => {
+      t.value.has(m) || t.value.set(m, /* @__PURE__ */ new Map());
+      const v = t.value.get(m), A = _[i];
+      h ? v.set(A, _) : v.delete(A), t.value = new Map(t.value);
+    },
+    clearTabSelection: (m) => {
+      t.value.has(m) && (t.value.get(m).clear(), t.value = new Map(t.value));
+    },
+    clearAllSelection: () => {
+      t.value.clear(), t.value = new Map(t.value);
+    },
+    isDocumentSelected: (m, _) => {
+      const h = t.value.get(m);
+      return h ? h.has(_) : !1;
+    },
+    setAllDocuments: (m = [], _ = "") => {
+      t.value.clear(), m.forEach((h) => {
+        const v = h.tabKey || _;
+        if (!v) return;
+        t.value.has(v) || t.value.set(v, /* @__PURE__ */ new Map()), t.value.get(v).set(h[i], h);
+      }), t.value = new Map(t.value);
+    },
+    getStatistics: () => {
+      const m = {
+        total: s.value.length,
+        byTab: {}
+      };
+      return t.value.forEach((_, h) => {
+        m.byTab[h] = _.size;
+      }), m;
+    }
+  };
+}
+function as(e = {}) {
+  const { valueKey: i = ne.value, childrenKey: t = ne.children } = e, s = B(/* @__PURE__ */ new Map()), l = B({}), r = K(() => {
+    const p = {};
+    return s.value.forEach((I, m) => {
+      p[m] = I;
+    }), p;
+  });
+  return {
+    // 状态
+    allTabDocList: s,
+    allTabTreeDataObject: r,
+    responseSearchHook: l,
+    // 方法
+    setAllTabsTreeData: (p = {}) => {
+      const I = /* @__PURE__ */ new Map();
+      p && typeof p == "object" && Object.keys(p).forEach((m) => {
+        const _ = Array.isArray(p[m]) ? p[m] : [];
+        I.set(m, _);
+      }), s.value = I;
+    },
+    getTabTreeData: (p) => s.value.get(p) || [],
+    setTabTreeData: (p, I = []) => {
+      const m = new Map(s.value);
+      m.set(p, Array.isArray(I) ? I : []), s.value = m;
+    },
+    updateNodeChildren: (p, I, m = []) => {
+      const _ = s.value.get(p);
+      if (!_ || !Array.isArray(_)) return;
+      const h = (w) => w.map((N) => {
+        if (N[i] === I)
+          return {
+            ...N,
+            [t]: m
+          };
+        const S = N[t];
+        return Array.isArray(S) && S.length > 0 ? {
+          ...N,
+          [t]: h(S)
+        } : N;
+      }), v = h(_), A = new Map(s.value);
+      A.set(p, v), s.value = A;
+    },
+    setResponseSearchHook: (p) => {
+      l.value = p;
+    }
+  };
+}
+const cs = { class: "doc-sync-select" }, ds = /* @__PURE__ */ Object.assign({
+  name: "DocSyncSelect"
+}, {
+  __name: "layout",
+  props: {
+    // 选中的文档列表
+    modelValue: {
+      type: Array,
+      default: () => []
+    },
+    // 文档树数据（业务端传入）
+    treeData: {
+      type: Object,
+      default: () => ({})
+    },
+    // 树数据更新元数据，用于智能响应不同类型的更新操作
+    updateMeta: {
+      type: Object,
+      default: () => ({ updateId: "", operation: null, context: {} })
+    },
+    // 树配置
+    treeProps: {
+      type: Object,
+      default: () => ne
+    },
+    // 文件夹选项卡配置
+    tabs: {
+      type: Array,
+      default: () => []
+    },
+    // 搜索类型：'frontend' 前端搜索 | 'backend' 后端搜索
+    searchType: {
+      type: String,
+      default: oe.FRONTEND,
+      validator: (e) => Object.values(oe).includes(e)
+    },
+    // 文本配置（用于配置组件中的中文文本）
+    textConfig: {
+      type: Object,
+      default: () => ({
+        searchPlaceholder: ""
+      })
+    }
+  },
+  emits: [
+    "update:modelValue",
+    "change",
+    "search",
+    "load-node",
+    "recursive-load",
+    "load-more"
+  ],
+  setup(e, { expose: i, emit: t }) {
+    const s = e, l = t, r = K(() => ({ ...ne, ...s.treeProps })), a = K(() => r.value.value), o = K(() => r.value.children), n = B(), c = B(s.tabs[0]?.value || ""), {
+      allSelectedDocuments: d,
+      getTabSelectedDocuments: p,
+      updateTabSelection: I,
+      removeDocument: m,
+      setAllDocuments: _
+    } = os({ valueKey: r.value.value }), h = (u = d.value) => {
+      l("update:modelValue", u), l("change", u);
+    }, {
+      allTabTreeDataObject: v,
+      setAllTabsTreeData: A,
+      updateNodeChildren: w,
+      responseSearchHook: N,
+      setResponseSearchHook: S
+    } = as({
+      valueKey: a.value,
+      childrenKey: o.value
+    });
+    Z(
+      () => s.treeData,
+      (u) => {
+        A(u || {});
+      },
+      { deep: !0, immediate: !0 }
+    ), Z(
+      () => s.updateMeta,
+      (u, b) => {
+        if (!u || !u.updateId || u.updateId === (b?.updateId || ""))
+          return;
+        const { operation: k, context: L } = u;
+        switch (k) {
+          case "node-children-update":
+            q(L);
+            break;
+          case "recursive-load":
+            ee(L);
+            break;
+          case "search":
+          case "load-more":
+            F(L);
+            break;
+        }
+      },
+      { deep: !0, immediate: !1 }
+    );
+    const g = K(() => p(c.value)), M = (u) => {
+      c.value = u;
+      const b = p(u);
+      n.value && n.value.syncSelectedNodes && ie(() => {
+        const k = b.map((L) => L[r.value.value]);
+        n.value.syncSelectedNodes(k);
+      });
+    }, f = (u, b, k) => {
+      ie(() => {
+        const L = b || [], Y = [...Te(u, r.value), u, ...L];
+        I(k, Y), h();
+      });
+    }, D = (u) => {
+      let { selectedNode: b, checkedNode: k, isChecked: L } = u;
+      const R = p(c.value);
+      if (b = Me({
+        tabKey: c.value,
+        currentSelectedDocs: [k],
+        // 使用与左侧展示一致的树数据源，避免因懒加载/局部更新与原始props不一致
+        treeData: v.value,
+        treeProps: r.value,
+        hasSelectToRightDocList: R
+      }), !L) {
+        I(
+          c.value,
+          R.filter((Y) => Y.id !== k.id)
+        ), h();
+        return;
+      }
+      I(c.value, [...R, ...b]), h();
+    }, C = (u) => {
+      let { selectedNode: b, checkedNode: k, isChecked: L } = u;
+      const R = p(c.value);
+      if (b = Me({
+        tabKey: c.value,
+        currentSelectedDocs: b,
+        // 使用与左侧展示一致的树数据源，避免因懒加载/局部更新与原始props不一致
+        treeData: v.value,
+        treeProps: r.value,
+        hasSelectToRightDocList: R
+      }), !k?.hasChildren) {
+        I(c.value, b), h();
+        return;
+      }
+      if (!L) {
+        const Y = Te(k, r.value), re = /* @__PURE__ */ new Set([
+          k[a.value],
+          ...Y.map((X) => X[a.value])
+        ]), V = p(c.value).filter((X) => !re.has(X[a.value]));
+        I(c.value, V), re.forEach((X) => {
+          n.value?.setNodeCheckStatus && n.value.setNodeCheckStatus(X, !1);
+        }), h();
+        return;
+      }
+      if (L && k && We(k, r.value)) {
+        x(k);
+        return;
+      } else
+        f(k, b || [], c.value);
+    }, y = (u) => {
+      const b = r.value.value;
+      m(u) === c.value && n.value && n.value.setNodeCheckStatus && n.value.setNodeCheckStatus(u[b], !1), h();
+    }, O = ({ node: u, tabKey: b }) => {
+      let k = {};
+      b === le.FEISHU_KNOWLEDGE ? k = {
+        spaceId: u?.spaceId,
+        parentNodeToken: u?.nodeToken
+      } : b === le.MY_FILES && (k = {
+        folderToken: u?.folderToken
+      }), l("load-node", {
+        nodeKey: u[r.value?.value],
+        nodeData: u,
+        tabKey: b,
+        requestParams: k
+      });
+    }, x = (u) => {
+      let b = {};
+      c.value === le.FEISHU_KNOWLEDGE ? b = {
+        spaceId: u?.spaceId,
+        parentNodeToken: u?.nodeToken,
+        recursive: !0
+      } : c.value === le.MY_FILES && (b = {
+        folderToken: u?.folderToken,
+        recursive: !0
+      }), l("recursive-load", {
+        nodeKey: u[r.value?.value],
+        nodeData: u,
+        // 传递完整节点对象
+        tabKey: c.value,
+        requestParams: b
+      });
+    }, E = (u, b) => {
+      n.value && n.value.updateNodeChildren && n.value.updateNodeChildren(u, b), c.value && w(c.value, u, b);
+    }, q = (u) => {
+      const { nodeKey: b, newChildren: k } = u;
+      n.value?.updateNodeChildren && n.value.updateNodeChildren(b, k);
+    }, ee = (u) => {
+      const { nodeKey: b, tabKey: k, newChildren: L, originalNode: R, nodeData: Y, error: re } = u;
+      if (re)
+        return;
+      const se = ni(
+        s.treeData[k] || [],
+        R?.id || b,
+        r.value
+      );
+      if (!se)
+        return;
+      const V = p(k || c.value);
+      f(se, V, k || c.value);
+    }, F = (u) => {
+      const { responseSearch: b } = u;
+      S(b);
+    }, Q = ({ keyword: u }) => {
+      l("search", { keyword: u });
+    }, z = () => {
+      l("load-more", c.value);
+    };
+    return Ie(() => {
+      s.modelValue && s.modelValue.length > 0 && _(s.modelValue, c.value);
+    }), Z(
+      () => s.modelValue,
+      (u, b) => {
+        if (!u || u.length === 0) {
+          b && b.length > 0 && _([]);
+          return;
+        }
+        const k = d.value;
+        k.length === u.length && u.every(
+          (R) => k.some(
+            (Y) => Y[r.value.value] === R[r.value.value]
+          )
+        ) || _(u, c.value);
+      },
+      { deep: !0 }
+    ), i({
+      // 清空选择
+      clearSelection: () => {
+        _([]), h([]);
+      },
+      // 获取选中项
+      getSelectedDocuments: () => d.value,
+      // 设置选中项
+      setSelectedDocuments: (u) => {
+        _(u, c.value), h();
+      },
+      // 更新节点children
+      updateNodeChildren: E
+    }), (u, b) => (T(), P("div", cs, [
+      H(rs, {
+        tabs: e.tabs,
+        "tree-data": $(v),
+        "tree-props": r.value,
+        "selected-documents": g.value,
+        "current-tab": c.value,
+        "search-type": e.searchType,
+        "text-config": e.textConfig,
+        "response-search-hook": $(N),
+        ref_key: "leftLayoutRef",
+        ref: n,
+        onNodeCheck: C,
+        onNodeCheckSearch: D,
+        onTabChange: M,
+        onSearch: Q,
+        onNodeExpand: O,
+        onLoadMore: z,
+        getTabSelectedDocuments: $(p)
+      }, null, 8, ["tabs", "tree-data", "tree-props", "selected-documents", "current-tab", "search-type", "text-config", "response-search-hook", "getTabSelectedDocuments"]),
+      H(Yt, {
+        "selected-documents": $(d),
+        "tree-props": r.value,
+        onDeleteNode: y
+      }, null, 8, ["selected-documents", "tree-props"])
+    ]));
+  }
+}), us = /* @__PURE__ */ ae(ds, [["__scopeId", "data-v-c45c2d8e"]]), Ss = Ve(us), Ts = Ve(ye);
+export {
+  Ss as DocSyncSelect,
+  Ts as FileTypeIcon,
+  Ss as default
+};