hys-ui 0.1.1 → 0.2.0

package/dist/composables/useTransfer.js

@@ -0,0 +1,257 @@
+import { ref as k, computed as r, watch as te, onDeactivated as he, onBeforeUnmount as ge, onActivated as se, nextTick as E } from "vue";
+import { transferRows as de, transferWords as Se, transferLabel as we } from "./transfer.js";
+const H = ["left", "right"], K = (a, i) => a.length === i.length && a.every((f, B) => f === i[B]), D = (a) => [
+  ...new Set(
+    a.filter(
+      (i) => typeof i == "string" || typeof i == "number" && Number.isFinite(i)
+    )
+  )
+], y = (a, i) => Number.isFinite(a) && a > 0 ? Math.max(1, Math.floor(a)) : i;
+function ye(a, i, f, B) {
+  const I = new Set(a.modelValue ?? a.defaultValue ?? []), g = k(!0), J = k([...a.defaultValue ?? []]), R = k([
+    ...a.defaultCheckedKeys ?? [],
+    ...(a.leftDefaultChecked ?? []).filter(
+      (e) => !I.has(e)
+    ),
+    ...(a.rightDefaultChecked ?? []).filter(
+      (e) => I.has(e)
+    )
+  ]), Q = y(
+    typeof a.pagination == "object" ? a.pagination.pageSize : void 0,
+    10
+  ), U = k({ left: "", right: "" }), V = k({ left: 1, right: 1 }), L = k({ left: Q, right: Q }), b = k(!1), X = k("");
+  let N = 0, T = 0;
+  const s = r(() => de(a)), q = r(() => D(a.modelValue ?? J.value)), c = r(() => new Set(q.value)), W = r(() => Se(a.locale)), x = r(
+    () => !g.value || i.value || !!a.loading || b.value
+  ), o = r(
+    () => D(a.checkedKeys ?? R.value).filter((e) => {
+      const t = s.value.map.get(e);
+      return t && !t.disabled && !(a.oneWay && c.value.has(e));
+    })
+  ), ae = r(() => new Set(o.value)), F = r(() => {
+    const e = s.value.rows.filter((l) => !c.value.has(l.key)), t = a.targetOrder && a.targetOrder !== "original" ? q.value.flatMap((l) => {
+      const n = s.value.map.get(l);
+      return n ? [n] : [];
+    }) : s.value.rows.filter((l) => c.value.has(l.key));
+    return { left: e, right: t };
+  }), O = r(() => {
+    var e, t;
+    return {
+      left: ((e = a.searchValues) == null ? void 0 : e.left) ?? U.value.left,
+      right: ((t = a.searchValues) == null ? void 0 : t.right) ?? U.value.right
+    };
+  }), d = r(
+    () => Object.fromEntries(
+      H.map((e) => {
+        const t = O.value[e].trim(), l = t.toLocaleLowerCase();
+        return [
+          e,
+          t ? F.value[e].filter(
+            (n) => a.filterMethod ? a.filterMethod(t, n.option, e) : n.label.toLocaleLowerCase().includes(l)
+          ) : F.value[e]
+        ];
+      })
+    )
+  ), Y = r(
+    () => typeof a.pagination == "object" ? a.pagination : {}
+  ), v = r(() => {
+    var e, t;
+    return {
+      left: y((e = a.pageSizes) == null ? void 0 : e.left, L.value.left),
+      right: y((t = a.pageSizes) == null ? void 0 : t.right, L.value.right)
+    };
+  });
+  te(
+    () => Y.value.pageSize,
+    (e) => {
+      L.value = {
+        left: y(e, 10),
+        right: y(e, 10)
+      };
+    }
+  );
+  const P = r(() => ({
+    left: Math.max(
+      1,
+      Math.ceil(d.value.left.length / v.value.left)
+    ),
+    right: Math.max(
+      1,
+      Math.ceil(d.value.right.length / v.value.right)
+    )
+  })), S = r(() => {
+    var e, t;
+    return {
+      left: Math.min(
+        P.value.left,
+        y((e = a.pages) == null ? void 0 : e.left, V.value.left)
+      ),
+      right: Math.min(
+        P.value.right,
+        y((t = a.pages) == null ? void 0 : t.right, V.value.right)
+      )
+    };
+  }), Z = r(() => ({
+    left: a.pagination ? d.value.left.slice(
+      (S.value.left - 1) * v.value.left,
+      S.value.left * v.value.left
+    ) : d.value.left,
+    right: a.pagination ? d.value.right.slice(
+      (S.value.right - 1) * v.value.right,
+      S.value.right * v.value.right
+    ) : d.value.right
+  }));
+  function _(e) {
+    return e ? o.value.filter(
+      (t) => c.value.has(t) === (e === "right")
+    ) : [...o.value];
+  }
+  async function C(e) {
+    if (x.value) return !1;
+    const t = D(e).filter((u) => {
+      const h = s.value.map.get(u);
+      return h && !h.disabled && !(a.oneWay && c.value.has(u));
+    }), l = [...o.value];
+    if (K(t, l) && K(t, D(a.checkedKeys ?? R.value)))
+      return !1;
+    const n = ++T, m = H.map((u) => ({
+      side: u,
+      before: l.filter(
+        (h) => c.value.has(h) === (u === "right")
+      ),
+      next: t.filter(
+        (h) => c.value.has(h) === (u === "right")
+      )
+    }));
+    if (R.value = t, f("update:checkedKeys", [...t]), g.value) {
+      for (const u of m)
+        K(u.before, u.next) || f("checkChange", u.side, [...u.next]);
+      f("selectChange", [...m[0].next], [...m[1].next]);
+    }
+    return await E(), !(!g.value || i.value || a.loading || n !== T || !K(t, o.value));
+  }
+  function le(e, t) {
+    const l = s.value.map.get(e);
+    if (!l || l.disabled || a.oneWay && c.value.has(e))
+      return Promise.resolve(!1);
+    const n = new Set(o.value);
+    return t ?? !n.has(e) ? n.add(e) : n.delete(e), C([...n]);
+  }
+  function G(e, t = "page") {
+    return (t === "all" ? F.value[e] : t === "filtered" ? d.value[e] : Z.value[e]).filter((l) => !l.disabled && !(a.oneWay && e === "right"));
+  }
+  function ne(e, t = !0, l = "page") {
+    const n = new Set(o.value);
+    for (const m of G(e, l))
+      t ? n.add(m.key) : n.delete(m.key);
+    return C([...n]);
+  }
+  function ue(e, t = "page") {
+    const l = new Set(o.value);
+    for (const n of G(e, t))
+      l.has(n.key) ? l.delete(n.key) : l.add(n.key);
+    return C([...l]);
+  }
+  function re(e) {
+    return C(
+      e ? o.value.filter(
+        (t) => c.value.has(t) !== (e === "right")
+      ) : []
+    );
+  }
+  async function ie(e, t = _(
+    e === "right" ? "left" : "right"
+  )) {
+    if (x.value) return !1;
+    const l = e === "right", n = [...q.value], m = new Set(n), u = D(t).filter((z) => {
+      const ee = s.value.map.get(z);
+      return ee && !ee.disabled && m.has(z) !== l;
+    });
+    if (!u.length) return !1;
+    const h = new Set(u), A = l ? a.targetOrder === "unshift" ? [...u, ...n] : [...n, ...u] : n.filter((z) => !h.has(z)), ve = ++N;
+    return b.value = !0, J.value = A, f("update:modelValue", [...A]), g.value && f("change", [...A], e, [...u]), await E(), ve !== N || (b.value = !1, !g.value || i.value || a.loading || !K(A, q.value)) ? !1 : (C(o.value.filter((z) => !h.has(z))), X.value = we(W.value.moved, {
+      direction: l ? W.value.added : W.value.removed,
+      count: u.length
+    }), a.validateEvent !== !1 && B(), !0);
+  }
+  function fe(e, t) {
+    if (x.value || !Number.isFinite(t)) return;
+    const l = Math.max(
+      1,
+      Math.min(P.value[e], Math.floor(t))
+    );
+    l !== (w.pages ?? S.value)[e] && (V.value[e] = l, j("pages", e, l), f("pageChange", e, l, v.value[e]));
+  }
+  function oe(e, t) {
+    if (x.value || !Number.isFinite(t) || t < 1) return;
+    const l = Math.floor(t);
+    l !== (w.pageSizes ?? v.value)[e] && (L.value[e] = l, V.value[e] = 1, j("pageSizes", e, l), j("pages", e, 1), f("pageSizeChange", e, l), f("pageChange", e, 1, l));
+  }
+  function $(e, t) {
+    if (x.value || (M ?? O.value)[e] === t)
+      return;
+    const l = S.value[e];
+    U.value[e] = t, V.value[e] = 1;
+    const n = { ...M ?? O.value, [e]: t };
+    M = n, f("update:searchValues", n), E(() => {
+      M === n && (M = void 0);
+    }), l !== 1 && j("pages", e, 1), f("search", e, t);
+  }
+  function ce(e) {
+    for (const t of e ? [e] : H) $(t, "");
+  }
+  let M;
+  const w = {};
+  function j(e, t, l) {
+    const n = {
+      ...w[e] ?? (e === "pages" ? S.value : v.value),
+      [t]: l
+    };
+    w[e] = n, f("update:" + e, n), E(() => {
+      w[e] === n && delete w[e];
+    });
+  }
+  function p() {
+    g.value = !1, N++, T++, b.value = !1, M = void 0, delete w.pages, delete w.pageSizes;
+  }
+  return he(p), ge(p), se(() => g.value = !0), te(
+    () => [i.value, a.loading],
+    () => {
+      (i.value || a.loading) && (N++, T++, b.value = !1);
+    }
+  ), {
+    live: g,
+    busy: x,
+    pending: b,
+    data: s,
+    keys: q,
+    targetSet: c,
+    checked: o,
+    checkedSet: ae,
+    words: W,
+    all: F,
+    filtered: d,
+    visible: Z,
+    searchValues: O,
+    pageSizes: v,
+    pages: S,
+    pageCounts: P,
+    pagination: Y,
+    announcement: X,
+    getCheckedKeys: _,
+    setCheckedKeys: C,
+    check: le,
+    checkAll: ne,
+    invertSelection: ue,
+    clearChecked: re,
+    move: ie,
+    setPage: fe,
+    setPageSize: oe,
+    setSearch: $,
+    clearSearch: ce,
+    selectionScope: G
+  };
+}
+export {
+  ye as useTransfer
+};

package/dist/composables/useTree.js

@@ -0,0 +1,439 @@
+import { ref as xe, shallowRef as A, computed as f, watch as q, onDeactivated as ze, onBeforeUnmount as Re, onActivated as He, nextTick as F, toRaw as be } from "vue";
+import { treeIndex as pe, treeLocale as Oe, treeKeys as x, treeKey as X, treeAssign as Se, treeField as Ue } from "./tree.js";
+const I = (u, b) => u.length === b.length && u.every((i, z) => i === b[z]), Ae = (u, b) => u.size === b.length && b.every((i) => u.has(i));
+function Je(u, b, i, z, T = {}) {
+  const h = xe(!0), ne = A(u.defaultValue ?? null), ue = A(
+    u.defaultCheckedKeys ?? []
+  ), Y = A(
+    u.defaultExpandedKeys ?? []
+  ), R = A([]), re = xe(u.defaultSearchValue ?? ""), N = A(/* @__PURE__ */ new Map()), M = A(/* @__PURE__ */ new Set()), m = A(/* @__PURE__ */ new Map()), r = f(
+    () => pe(u.nodes, u, N.value)
+  ), Ne = f(() => ({ ...Oe, ...u.locale })), v = f(() => !h.value || b.value || !!u.loading), B = f(
+    () => u.modelValue === void 0 ? ne.value : u.modelValue
+  ), y = f(
+    () => x(
+      Array.isArray(B.value) ? B.value : X(B.value) ? [B.value] : []
+    )
+  ), se = f(() => new Set(y.value)), D = f(() => !!u.multiple || Array.isArray(B.value)), Z = f(() => u.searchValue ?? re.value), P = f(
+    () => x(u.expandedKeys ?? Y.value)
+  ), _ = f(() => new Set(u.loadedKeys ?? R.value)), H = (e) => {
+    const l = [];
+    let a = r.value.map.get(e);
+    for (; (a == null ? void 0 : a.parent) !== void 0; )
+      l.push(a.parent), a = r.value.map.get(a.parent);
+    return l;
+  }, V = f(() => {
+    const e = new Set(P.value);
+    if (u.autoExpandParent)
+      for (let l = r.value.rows.length - 1; l >= 0; l--) {
+        const a = r.value.rows[l];
+        e.has(a.key) && a.parent !== void 0 && e.add(a.parent);
+      }
+    return e;
+  }), $ = f(() => {
+    const e = /* @__PURE__ */ new Set(), l = Z.value.trim();
+    if (!l) return e;
+    for (const a of r.value.rows)
+      (u.filterNode ? u.filterNode(l, a.node) : a.label.toLocaleLowerCase().includes(l.toLocaleLowerCase())) && e.add(a.key);
+    return e;
+  }), Me = f(() => {
+    const e = Z.value.trim(), l = new Set($.value);
+    if (e && u.filterMode !== "highlight") {
+      for (let t = r.value.rows.length - 1; t >= 0; t--) {
+        const n = r.value.rows[t];
+        l.has(n.key) && n.parent !== void 0 && l.add(n.parent);
+      }
+      if (u.showMatchedChildren) {
+        const t = new Set($.value);
+        for (const n of r.value.rows)
+          n.parent !== void 0 && t.has(n.parent) && (t.add(n.key), l.add(n.key));
+      }
+    }
+    const a = /* @__PURE__ */ new Set();
+    return r.value.rows.filter((t) => {
+      const n = e && u.filterMode !== "highlight" ? l.has(t.key) : t.parent === void 0 || a.has(t.parent);
+      return n && (e && u.filterMode !== "highlight" || V.value.has(t.key)) && a.add(t.key), n;
+    });
+  }), p = (e) => !!e && !e.checkboxDisabled && e.checkable;
+  function Pe(e, l = !0) {
+    const a = [], t = [e];
+    for (; t.length; ) {
+      const n = r.value.map.get(t.pop());
+      if (!(!n || l && !p(n))) {
+        a.push(n.key);
+        for (let s = n.children.length - 1; s >= 0; s--)
+          t.push(n.children[s]);
+      }
+    }
+    return a;
+  }
+  function de(e, l = !u.checkStrictly) {
+    const a = new Set(x(e)), t = /* @__PURE__ */ new Set();
+    if (l) {
+      const n = /* @__PURE__ */ new Set(), s = [...e];
+      for (; s.length; ) {
+        const o = s.pop(), d = r.value.map.get(o);
+        if (!(!d || n.has(o) || !p(d))) {
+          n.add(o), a.add(o);
+          for (const c of d.children) s.push(c);
+        }
+      }
+      for (let o = r.value.rows.length - 1; o >= 0; o--) {
+        const d = r.value.rows[o];
+        if (!p(d)) continue;
+        const c = d.children.filter(
+          (C) => p(r.value.map.get(C))
+        );
+        c.length && (c.every((C) => a.has(C)) ? a.add(d.key) : (a.delete(d.key), c.some((C) => a.has(C) || t.has(C)) && t.add(d.key)));
+      }
+    } else
+      for (const n of u.halfCheckedKeys ?? [])
+        r.value.map.has(n) && !a.has(n) && t.add(n);
+    return { full: a, half: t };
+  }
+  const oe = f(
+    () => de(u.checkedKeys ?? ue.value)
+  ), S = f(() => oe.value.full), O = f(() => oe.value.half), U = (e, l = !1) => r.value.rows.filter((a) => e.has(a.key) && (!l || !a.hasChildren)).map((a) => a.key), ie = (e = !1) => U(S.value, e), ce = () => U(O.value), fe = (e = !1, l = !1) => r.value.rows.filter(
+    (a) => (S.value.has(a.key) || l && O.value.has(a.key)) && (!e || !a.hasChildren)
+  ).map((a) => a.node), E = (e) => X(e) ? e : typeof u.nodeKey == "function" ? u.nodeKey(e) : Ue(
+    e,
+    typeof u.nodeKey == "string" ? u.nodeKey : r.value.fields.id
+  ), L = (e) => r.value.map.get(E(e)), k = (e) => {
+    var l;
+    return (l = L(e)) == null ? void 0 : l.node;
+  };
+  let w = 0, ve = 0, he = 0;
+  function ee(e, l, a) {
+    return {
+      node: e,
+      checked: l,
+      checkedKeys: ie(),
+      checkedNodes: fe(),
+      halfCheckedKeys: ce(),
+      halfCheckedNodes: r.value.rows.filter((t) => O.value.has(t.key)).map((t) => t.node),
+      event: a
+    };
+  }
+  async function we(e, l, a, t) {
+    if (v.value) return !1;
+    const n = de(e), s = [...n.full], o = ++ve, d = w;
+    return Ae(S.value, s) || (u.checkedKeys === void 0 && (ue.value = s), i("update:checkedKeys", s), i("check", s, {
+      ...ee(l, a, t),
+      checkedKeys: U(n.full),
+      checkedNodes: r.value.rows.filter((c) => n.full.has(c.key)).map((c) => c.node),
+      halfCheckedKeys: U(n.half),
+      halfCheckedNodes: r.value.rows.filter((c) => n.half.has(c.key)).map((c) => c.node)
+    }), await F(), !h.value || w !== d || o !== ve || !Ae(S.value, s)) ? !1 : (i("check-change", ee(l, a, t)), z(), !0);
+  }
+  function Ve(e, l = !1) {
+    const a = x(e).filter((t) => {
+      const n = r.value.map.get(t);
+      return !n || p(n) && (!l || !n.hasChildren);
+    });
+    for (const t of S.value)
+      r.value.map.has(t) && !p(r.value.map.get(t)) && a.push(t);
+    return we(a);
+  }
+  function Ee(e, l, a = !u.checkStrictly, t) {
+    const n = L(e);
+    if (!p(n) || !n) return Promise.resolve(!1);
+    const s = new Set(S.value), o = a ? Pe(n.key) : [n.key];
+    for (const d of o) l ? s.add(d) : s.delete(d);
+    if (!l && !u.checkStrictly)
+      for (const d of H(n.key)) s.delete(d);
+    return we([...s], n.node, l, t);
+  }
+  async function ae(e, l = null, a) {
+    if (v.value || u.selectable === !1) return !1;
+    const t = x(e).filter((d) => {
+      const c = r.value.map.get(d);
+      return !c || !c.disabled && c.selectable;
+    });
+    if (D.value || t.splice(1), I(t, y.value)) return !1;
+    const n = D.value ? t : t[0] ?? null, s = w, o = ++he;
+    return u.modelValue === void 0 && (ne.value = n), i("update:modelValue", n), l && i("select", l, {
+      node: l,
+      selected: t.includes(E(l)),
+      selectedKeys: t,
+      selectedNodes: t.flatMap((d) => k(d) ?? []),
+      event: a
+    }), await F(), !h.value || w !== s || o !== he || !I(t, y.value) ? !1 : (i("selection-change", {
+      node: l,
+      selected: l ? t.includes(E(l)) : !1,
+      selectedKeys: t,
+      selectedNodes: t.flatMap((d) => k(d) ?? []),
+      event: a
+    }), z(), !0);
+  }
+  function Le(e, l) {
+    if (v.value || e.disabled || !e.selectable || u.selectable === !1)
+      return Promise.resolve(!1);
+    const a = se.value.has(e.key) ? D.value || u.allowDeselect ? y.value.filter((t) => t !== e.key) : y.value : D.value ? [...y.value, e.key] : [e.key];
+    return ae(a, e.node, l);
+  }
+  async function le(e) {
+    if (v.value) return !1;
+    const l = x(e), a = w;
+    return I(l, P.value) ? !1 : (u.expandedKeys === void 0 && (Y.value = l), i("update:expandedKeys", l), await F(), h.value && w === a && I(l, P.value));
+  }
+  const K = /* @__PURE__ */ new Map();
+  function j() {
+    for (const e of K.values()) e.controller.abort();
+    K.clear(), M.value = /* @__PURE__ */ new Set();
+  }
+  function G(e, l = !1) {
+    var ke;
+    const a = r.value.map.get(e);
+    if (!a || v.value || ((ke = T.loadActive) == null ? void 0 : ke.value) === !1 || !u.loadChildren || a.leaf)
+      return Promise.resolve(!1);
+    if (!l && (_.value.has(e) || a.children.length))
+      return Promise.resolve(!0);
+    if (K.has(e)) return K.get(e).promise;
+    const t = new AbortController(), n = w, s = u.nodes, o = u.loadChildren;
+    let d;
+    const c = new Promise((W) => d = W);
+    K.set(e, { controller: t, promise: c }), t.signal.addEventListener("abort", () => d(!1), {
+      once: !0
+    }), M.value = /* @__PURE__ */ new Set([...M.value, e]);
+    const C = new Map(m.value);
+    return C.delete(e), m.value = C, (async () => {
+      var W, Ke;
+      try {
+        const g = await o(a.node, {
+          signal: t.signal,
+          key: e
+        });
+        if (t.signal.aborted || !h.value || n !== w || s !== u.nodes || ((W = r.value.map.get(e)) == null ? void 0 : W.node) !== a.node || o !== u.loadChildren)
+          return !1;
+        if (!Array.isArray(g))
+          throw new TypeError("loadChildren must resolve to an array");
+        const te = x([...u.loadedKeys ?? R.value, e]);
+        if (u.loadedKeys === void 0 && (R.value = te), i("update:loadedKeys", te), await F(), t.signal.aborted || !h.value || n !== w || !_.value.has(e))
+          return !1;
+        const Ce = new Map(N.value);
+        return Ce.set(e, g), N.value = Ce, i("children-loaded", { node: a.node, children: g }), i("load", { node: a.node, children: g, loadedKeys: te }), !0;
+      } catch (g) {
+        return t.signal.aborted || !h.value || n !== w || (m.value = new Map([...m.value, [e, g]]), i("load-error", { node: a.node, error: g })), !1;
+      } finally {
+        if (((Ke = K.get(e)) == null ? void 0 : Ke.controller) === t) {
+          K.delete(e);
+          const g = new Set(M.value);
+          g.delete(e), M.value = g;
+        }
+      }
+    })().then(d, () => d(!1)), c;
+  }
+  async function qe(e, l = !0) {
+    const a = r.value.map.get(e);
+    if (!a || a.disabled || !a.hasChildren || v.value) return !1;
+    const t = m.value.has(e);
+    let n = P.value.filter((o) => o !== e);
+    !l && u.autoExpandParent && (n = n.filter((o) => !H(o).includes(e))), l && (u.accordion && (n = n.filter((o) => {
+      let d = r.value.map.get(o);
+      for (; d && d.depth > a.depth; )
+        d = d.parent === void 0 ? void 0 : r.value.map.get(d.parent);
+      return !d || d.parent !== a.parent || d.key === e;
+    })), n.push(e));
+    const s = await le(n);
+    return s && i(l ? "node-expand" : "node-collapse", a.node, {
+      key: e,
+      expanded: l,
+      expandedKeys: [...V.value]
+    }), l && V.value.has(e) && (!m.value.has(e) || t) && await G(e), s;
+  }
+  function Te(e) {
+    v.value || (u.searchValue === void 0 && (re.value = e), i("update:searchValue", e), i("search", e));
+  }
+  async function Be(e, l = !0) {
+    if (e !== null) {
+      const a = r.value.map.get(e);
+      if (!a || a.disabled || !a.selectable) return !1;
+    }
+    return e !== null && l && await le(
+      x([...P.value, ...H(e)])
+    ), ae(
+      e === null ? [] : [e],
+      e === null ? null : k(e) ?? null
+    );
+  }
+  function J(e, l) {
+    const a = r.value.map.get(e);
+    if (!a) return;
+    let t = Se(a.node, r.value.fields.children, [
+      ...l
+    ]), n = a;
+    for (; n.parent !== void 0; ) {
+      const s = r.value.map.get(n.parent);
+      t = Se(
+        s.node,
+        r.value.fields.children,
+        s.children.map((o) => o === n.key ? t : k(o))
+      ), n = s;
+    }
+    return r.value.roots.map((s) => s === n.key ? t : k(s));
+  }
+  async function Q(e, l, a) {
+    if (!e || v.value) return !1;
+    const t = pe(e, u);
+    return t.invalid || (i("update:nodes", e), i("data-change", { nodes: e, action: l, key: a }), await F(), !h.value) ? !1 : I(
+      r.value.rows.map((n) => n.key),
+      t.rows.map((n) => n.key)
+    ) && r.value.rows.every(
+      (n, s) => n.parent === t.rows[s].parent && be(n.node) === be(t.rows[s].node)
+    );
+  }
+  function ye(e) {
+    return (e.parent === void 0 ? r.value.roots : r.value.map.get(e.parent).children).map((l) => k(l));
+  }
+  function ge(e, l, a) {
+    const t = L(l), n = E(e);
+    if (!t || t.disabled || !X(n) || r.value.map.has(n))
+      return Promise.resolve(!1);
+    const s = ye(t), o = s.indexOf(t.node);
+    return s.splice(o + (a ? 1 : 0), 0, e), Q(
+      t.parent === void 0 ? s : J(t.parent, s),
+      a ? "insertAfter" : "insertBefore",
+      n
+    );
+  }
+  const De = (e, l) => {
+    const a = E(e), t = l === void 0 ? void 0 : L(l);
+    return !X(a) || r.value.map.has(a) || l !== void 0 && (!t || t.disabled || t.leaf) ? Promise.resolve(!1) : Q(
+      t ? J(t.key, [
+        ...t.children.map((n) => k(n)),
+        e
+      ]) : [...u.nodes, e],
+      "append",
+      a
+    );
+  };
+  function Fe(e) {
+    const l = L(e);
+    if (!l || l.disabled) return Promise.resolve(!1);
+    const a = ye(l).filter((t) => E(t) !== l.key);
+    return Q(
+      l.parent === void 0 ? a : J(l.parent, a),
+      "remove",
+      l.key
+    );
+  }
+  async function Ie(e) {
+    var a;
+    return !r.value.map.get(e) || v.value ? !1 : ((a = K.get(e)) == null || a.controller.abort(), K.delete(e), G(e, !0));
+  }
+  q(
+    () => [
+      u.nodes,
+      u.loadChildren,
+      u.nodeKey,
+      u.fieldNames
+    ],
+    () => {
+      w++, j(), N.value = /* @__PURE__ */ new Map(), R.value = [], m.value = /* @__PURE__ */ new Map();
+    },
+    { flush: "sync" }
+  ), q(
+    () => [u.nodes, u.defaultExpandAll],
+    () => {
+      u.defaultExpandAll && u.expandedKeys === void 0 && (Y.value = r.value.rows.filter((e) => e.hasChildren).map((e) => e.key));
+    },
+    { immediate: !0 }
+  ), q(
+    () => {
+      var e;
+      return [
+        ...V.value,
+        h.value,
+        v.value,
+        r.value,
+        (e = T.loadActive) == null ? void 0 : e.value
+      ];
+    },
+    () => {
+      var e;
+      if (!v.value && ((e = T.loadActive) == null ? void 0 : e.value) !== !1)
+        for (const l of V.value) {
+          const a = r.value.map.get(l);
+          a != null && a.hasChildren && !a.children.length && !_.value.has(l) && !m.value.has(l) && G(l);
+        }
+    },
+    { immediate: !0 }
+  ), q(
+    () => u.loadedKeys,
+    (e, l) => {
+      if (e && l) {
+        const a = new Map(N.value);
+        for (const t of l) e.includes(t) || a.delete(t);
+        N.value = a;
+      }
+    },
+    { flush: "sync" }
+  );
+  function me() {
+    h.value = !1, w++, j();
+  }
+  return T.loadActive && q(
+    T.loadActive,
+    (e) => {
+      e || j();
+    },
+    { flush: "sync" }
+  ), q(
+    v,
+    (e) => {
+      e && j();
+    },
+    { flush: "sync" }
+  ), ze(me), Re(me), He(() => h.value = !0), {
+    live: h,
+    busy: v,
+    index: r,
+    words: Ne,
+    query: Z,
+    expanded: V,
+    rawExpanded: P,
+    selected: y,
+    selection: se,
+    multiple: D,
+    visible: Me,
+    matches: $,
+    checked: S,
+    halfChecked: O,
+    loadingKeys: M,
+    failures: m,
+    ancestors: H,
+    getNode: k,
+    getNodeInfo: L,
+    getCheckedKeys: ie,
+    getCheckedNodes: fe,
+    getHalfCheckedKeys: ce,
+    checkInfo: ee,
+    setCheckedKeys: Ve,
+    setChecked: Ee,
+    selectNode: Le,
+    setSelectedKeys: ae,
+    setCurrentKey: Be,
+    getCurrentKey: () => y.value[0] ?? null,
+    getCurrentNode: () => y.value.length ? k(y.value[0]) ?? null : null,
+    setExpandedKeys: le,
+    expandNode: qe,
+    filter: Te,
+    reloadNode: Ie,
+    load: G,
+    append: De,
+    remove: Fe,
+    insertBefore: (e, l) => ge(e, l, !1),
+    insertAfter: (e, l) => ge(e, l, !0),
+    updateKeyChildren: (e, l) => {
+      var a, t;
+      return (a = r.value.map.get(e)) != null && a.disabled || (t = r.value.map.get(e)) != null && t.leaf && l.length ? Promise.resolve(!1) : Q(
+        J(e, l),
+        "updateKeyChildren",
+        e
+      );
+    }
+  };
+}
+export {
+  Je as useTree
+};