hys-ui 0.1.1 → 0.3.0

package/dist/composables/useTransferMotion.js

@@ -0,0 +1,185 @@
+import { inject as K, watch as U, onActivated as V, onDeactivated as G, onBeforeUnmount as J } from "vue";
+import { useHysRootAttrs as Q } from "../config.js";
+import { useMotion as X } from "../motion/useMotion.js";
+import { overlayOwnerKey as Y } from "./overlayManager.js";
+import { transferToken as T } from "./transfer.js";
+const D = (x) => '[data-transfer-key="' + x.replace(
+  /["\\\n\r\f]/g,
+  (a) => "\\" + a.codePointAt(0).toString(16) + " "
+) + '"]';
+function ne(x, a) {
+  const j = Q(), { effectiveMotion: P } = X(), w = K(Y, void 0), C = /* @__PURE__ */ new Set(), M = /* @__PURE__ */ new Set();
+  let A, L = 0, F = !0, k, b;
+  const q = () => Number.isFinite(a.moveDuration) ? Math.max(0, Math.min(1500, a.moveDuration)) : 240, E = () => Number.isFinite(a.maxAnimatedItems) ? Math.max(0, Math.min(12, Math.floor(a.maxAnimatedItems))) : 6, z = () => {
+    var e;
+    return F && ((e = x.value) == null ? void 0 : e.isConnected) && (w == null ? void 0 : w.value) !== !1 && a.animated !== !1 && a.moveAnimation !== "none" && q() > 0 && P.value !== "off";
+  };
+  function o() {
+    L++, A !== void 0 && cancelAnimationFrame(A), A = void 0, clearTimeout(k), k = void 0, window.removeEventListener("scroll", o, !0), window.removeEventListener("resize", o), window.removeEventListener("focusin", o), window.removeEventListener("blur", o), window.removeEventListener("keydown", B);
+    for (const e of M)
+      e.animation.cancel(), e.restore(), e.node.remove();
+    M.clear();
+    for (const e of C) e.classList.remove("hys-ui-transfer-landed");
+    C.clear(), b == null || b.classList.remove("hys-ui-transfer-received"), b = void 0;
+  }
+  function B(e) {
+    e.key === "Escape" && o();
+  }
+  function O(e) {
+    var s;
+    return (s = x.value) == null ? void 0 : s.querySelector(
+      '.hys-ui-transfer-pane[data-side="' + e + '"]'
+    );
+  }
+  function I(e, s) {
+    var v, g;
+    if (o(), !z() || !s.length) return;
+    const d = (v = O(
+      e === "right" ? "left" : "right"
+    )) == null ? void 0 : v.querySelector(".hys-ui-pf-transfer-list"), i = {
+      generation: L,
+      direction: e,
+      count: s.length,
+      samples: []
+    };
+    if (!d || !E() || typeof HTMLElement.prototype.animate != "function")
+      return i;
+    const r = d.getBoundingClientRect(), u = Math.max(0, r.top), c = Math.min(window.innerHeight, r.bottom);
+    if (r.right <= 0 || r.left >= window.innerWidth || c <= u)
+      return i;
+    const l = new Set(s.map(T)), n = /* @__PURE__ */ new Set();
+    function y(t) {
+      var S;
+      if (!t || !d.contains(t) || i.samples.length >= E())
+        return;
+      const f = t.dataset.transferKey;
+      if (!l.has(f) || n.has(f)) return;
+      const m = t.getBoundingClientRect();
+      !m.width || !m.height || m.bottom <= u || m.top >= c || (n.add(f), i.samples.push({
+        token: f,
+        label: (((S = t.querySelector(".hys-ui-transfer-label")) == null ? void 0 : S.textContent) ?? t.textContent ?? "").trim().slice(0, 120),
+        box: m
+      }));
+    }
+    if (s.length <= E())
+      for (const t of s)
+        y(d.querySelector(D(T(t))));
+    else if (document.elementFromPoint) {
+      const t = Math.min(24, Math.max(1, Math.ceil((c - u) / 20))), f = Math.max(
+        1,
+        Math.min(window.innerWidth - 1, r.left + r.width / 2)
+      );
+      for (let m = 0; m < t && i.samples.length < E(); m++)
+        y(
+          (g = document.elementFromPoint(f, u + (m + 0.5) * (c - u) / t)) == null ? void 0 : g.closest(".hys-ui-transfer-row")
+        );
+    }
+    return i;
+  }
+  function N(e) {
+    if (!e || e.generation !== L || !z()) return;
+    const s = O(e.direction), d = s == null ? void 0 : s.querySelector(".hys-ui-pf-transfer-list");
+    if (!s || !d) return;
+    const i = d.getBoundingClientRect();
+    if (i.right <= 0 || i.left >= window.innerWidth || i.bottom <= 0 || i.top >= window.innerHeight)
+      return;
+    b = s, s.classList.add("hys-ui-transfer-received");
+    const r = e.samples.length ? getComputedStyle(x.value) : void 0, u = (c) => {
+      c.restore(), c.node.remove(), M.delete(c);
+    };
+    for (const [c, l] of e.samples.entries()) {
+      const n = d.querySelector(D(l.token)), y = n == null ? void 0 : n.getBoundingClientRect(), v = !!y && y.bottom > Math.max(0, i.top) && y.top < Math.min(window.innerHeight, i.bottom), g = v ? y : {
+        left: Math.max(8, i.left + 8),
+        top: Math.max(
+          8,
+          Math.min(
+            window.innerHeight - 44,
+            i.top + Math.min(i.height / 2, 80) + c * 4
+          )
+        ),
+        width: Math.max(40, i.width - 16),
+        height: l.box.height
+      }, t = document.createElement("div");
+      t.className = "hys-ui-transfer-flight";
+      for (const [p, h] of Object.entries(j.value))
+        t.setAttribute(p, h);
+      t.setAttribute("aria-hidden", "true"), t.inert = !0, t.textContent = l.label + (c === e.samples.length - 1 && e.count > e.samples.length ? " · +" + (e.count - e.samples.length) : ""), Object.assign(t.style, {
+        left: l.box.left + "px",
+        top: l.box.top + "px",
+        width: l.box.width + "px",
+        height: l.box.height + "px",
+        fontFamily: r == null ? void 0 : r.fontFamily,
+        fontSize: r == null ? void 0 : r.fontSize
+      });
+      for (const p of [
+        "--hys-ui-primary",
+        "--hys-ui-primary-soft",
+        "--hys-ui-border",
+        "--hys-ui-surface",
+        "--hys-ui-text",
+        "--hys-ui-muted"
+      ]) {
+        const h = r == null ? void 0 : r.getPropertyValue(p);
+        h && t.style.setProperty(p, h);
+      }
+      const f = (n == null ? void 0 : n.style.opacity) ?? "", m = (n == null ? void 0 : n.style.transition) ?? "";
+      let S = !1;
+      const R = () => {
+        S || (S = !0, n && v && (n.style.opacity = f, n.style.transition = m));
+      };
+      n && v && (n.style.transition = "none", n.style.opacity = "0"), document.body.append(t);
+      const H = "translate3d(" + (g.left - l.box.left) + "px," + (g.top - l.box.top) + "px,0) scale(" + g.width / l.box.width + "," + g.height / l.box.height + ")", W = a.moveAnimation === "fade" ? [
+        { transform: H, opacity: 0 },
+        { transform: H, opacity: 1 }
+      ] : [
+        { transform: "translate3d(0,0,0) scale(1)", opacity: 0.9 },
+        { transform: H, opacity: 1 }
+      ];
+      try {
+        const p = t.animate(W, {
+          duration: q(),
+          easing: "cubic-bezier(.22,1,.36,1)",
+          fill: "both"
+        }), h = { node: t, animation: p, restore: R };
+        M.add(h), p.finished.then(
+          () => {
+            u(h), n && v && n.isConnected && e.generation === L && z() && a.highlightOnArrival !== !1 && (n.classList.add("hys-ui-transfer-landed"), C.add(n));
+          },
+          () => u(h)
+        );
+      } catch {
+        R(), t.remove();
+      }
+    }
+    A = requestAnimationFrame(() => {
+      A = void 0, e.generation === L && window.addEventListener("scroll", o, !0);
+    }), window.addEventListener("resize", o), window.addEventListener("focusin", o), window.addEventListener("blur", o), window.addEventListener("keydown", B), k = setTimeout(o, q() + 440);
+  }
+  return U(
+    () => [
+      a.animated,
+      a.moveAnimation,
+      a.moveDuration,
+      a.maxAnimatedItems,
+      a.highlightOnArrival,
+      P.value,
+      w == null ? void 0 : w.value
+    ],
+    o,
+    { flush: "sync" }
+  ), V(() => {
+    F = !0;
+  }), G(() => {
+    F = !1, o();
+  }), J(o), {
+    capture: I,
+    play: N,
+    stop: o,
+    cancelPlaying: () => {
+      (M.size || b) && o();
+    }
+  };
+}
+export {
+  ne as useTransferMotion
+};

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
+};