x-next 1.13.0 → 1.15.0

package/dist/es/components/tree-select/TreeSelectDropdown.vue.js

@@ -0,0 +1,57 @@
+import i from "./TreeSelectDropdown.vue2.js";
+import { resolveComponent as y, openBlock as s, createElementBlock as l, normalizeClass as o, renderSlot as r, createCommentVNode as t, createBlock as a, resolveDynamicComponent as m, Fragment as f, mergeProps as u, withCtx as v, createElementVNode as $ } from "vue";
+import c from "../../_virtual/_plugin-vue_export-helper.js";
+const w = ["id"];
+function k(e, n, h, N, C, E) {
+  const p = y("spin");
+  return s(), l("div", {
+    id: e.id,
+    class: o(e.cls),
+    role: "tree",
+    onKeydown: n[0] || (n[0] = (...d) => e.handleKeydown && e.handleKeydown(...d))
+  }, [
+    e.$slots.header && (!e.empty || e.showHeaderOnEmpty) ? (s(), l("div", {
+      key: 0,
+      class: o(e.className.element("header"))
+    }, [
+      r(e.$slots, "header")
+    ], 2)) : t("", !0),
+    e.loading ? (s(), a(p, {
+      key: 1,
+      class: o(e.className.element("loading"))
+    }, null, 8, ["class"])) : e.empty ? (s(), l("div", {
+      key: 2,
+      class: o(e.className.element("empty"))
+    }, [
+      r(e.$slots, "empty", {}, () => [
+        (s(), a(m("Empty"), { component: "tree-select" }))
+      ])
+    ], 2)) : (s(), l(f, { key: 3 }, [
+      e.virtualList ? r(e.$slots, "virtual-list", {}, void 0, void 0, 0) : (s(), a(m(e.displayScrollbar ? "ScrollbarComponent" : "div"), u({
+        key: 1,
+        ref: "wrapperComRef",
+        class: e.className.element("list-wrapper"),
+        style: e.wrapperStyle
+      }, e.scrollbarProps), {
+        default: v(() => [
+          $("ul", {
+            class: o(e.className.element("list"))
+          }, [
+            r(e.$slots, "default")
+          ], 2)
+        ]),
+        _: 3
+      }, 16, ["class", "style"]))
+    ], 64)),
+    e.$slots.footer && (!e.empty || e.showFooterOnEmpty) ? (s(), l("div", {
+      key: 4,
+      class: o(e.className.element("footer"))
+    }, [
+      r(e.$slots, "footer")
+    ], 2)) : t("", !0)
+  ], 42, w);
+}
+const B = /* @__PURE__ */ c(i, [["render", k]]);
+export {
+  B as default
+};

package/dist/es/components/tree-select/TreeSelectDropdown.vue2.js

@@ -0,0 +1,79 @@
+import { defineComponent as y, toRefs as h, computed as n } from "vue";
+import { Empty as w } from "../empty/index.js";
+import { Spin as b } from "../spin/index.js";
+import { Scrollbar as S } from "../scrollbar-v2/index.js";
+import { useComponentRef as B } from "../../_hooks/use-component-ref.js";
+import { useScrollbar as g } from "../../_hooks/use-scrollbar.js";
+import { getClassNameMixin as x } from "../../_utils/config.js";
+const N = y({
+  name: "TreeSelectDropdown",
+  components: {
+    ScrollbarComponent: S,
+    Empty: w,
+    Spin: b
+  },
+  props: {
+    id: String,
+    loading: Boolean,
+    empty: Boolean,
+    virtualList: Boolean,
+    showLine: Boolean,
+    scrollbar: {
+      type: [Boolean, Object],
+      default: !0
+    },
+    maxHeight: {
+      type: [Number, String]
+    },
+    onScroll: {
+      type: [Function, Array]
+    },
+    showHeaderOnEmpty: {
+      type: Boolean,
+      default: !1
+    },
+    showFooterOnEmpty: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["scroll", "keydown"],
+  setup(r, { emit: l, slots: a }) {
+    const { scrollbar: m } = h(r), e = x("tree-select--dropdown"), { componentRef: t } = B("containerRef"), { displayScrollbar: s, scrollbarProps: i } = g(m), p = n(
+      () => {
+        var o;
+        return ((o = t.value) == null ? void 0 : o.$el) ?? t.value;
+      }
+    ), c = n(() => {
+      const o = r.maxHeight;
+      return o === void 0 ? {} : {
+        maxHeight: typeof o == "number" ? `${o}px` : o
+      };
+    }), f = (o) => {
+      l("scroll", o);
+    }, d = (o) => {
+      l("keydown", o);
+    }, u = n(() => [
+      e.block,
+      {
+        [e.modifier("has-header")]: !!a.header,
+        [e.modifier("has-footer")]: !!a.footer,
+        [e.modifier("with-line")]: r.showLine
+      }
+    ]);
+    return {
+      className: e,
+      cls: u,
+      wrapperComRef: t,
+      wrapperRef: p,
+      wrapperStyle: c,
+      displayScrollbar: s,
+      scrollbarProps: i,
+      handleScroll: f,
+      handleKeydown: d
+    };
+  }
+});
+export {
+  N as default
+};

package/dist/es/components/tree-select/hooks/use-tree-select.js

@@ -0,0 +1,376 @@
+import { computed as r, ref as L, watch as Se, watchEffect as tt } from "vue";
+import { isNull as xe, isUndefined as F, isString as be, isNumber as at, isFunction as ce } from "../../../_utils/is.js";
+import { KEYBOARD_KEY as g } from "../../../_utils/keyboard.js";
+import { DEFAULT_FIELD_NAMES as ut, buildTree as lt, getKeysFromValues as nt, normalizeKey as k, conductCheckState as rt, filterTreeNodes as st, getVisibleNodes as ct, getKeyFromValue as T, isValidKey as U, toggleCheckState as Ce, getValueFromKey as oe, filterCheckedKeysByStrategy as ot } from "../utils.js";
+const gt = (I) => {
+  var Ke;
+  const {
+    data: Ve,
+    fieldNames: W,
+    modelValue: ie,
+    defaultValue: Ae,
+    multiple: b,
+    treeCheckable: O,
+    treeCheckStrictly: H,
+    checkedStrategy: P,
+    labelInValue: C,
+    selectable: z,
+    expandedKeys: V,
+    defaultExpandedKeys: M,
+    defaultExpandAll: Y,
+    autoExpandParent: G,
+    filterTreeNode: j,
+    loadMore: m,
+    fallbackOption: A,
+    formatLabel: _,
+    popupVisible: y,
+    disabled: s,
+    loading: c,
+    onUpdateModelValue: Ne,
+    onChange: Ee,
+    onUpdateExpandedKeys: Re,
+    onExpand: Le,
+    onUpdateInputValue: Fe,
+    onPopupVisibleChange: B
+  } = I, q = r(() => ({
+    ...ut,
+    ...W == null ? void 0 : W.value
+  })), J = L(Ae.value), _e = r(() => ie.value ?? J.value), w = r(() => {
+    const e = _e.value;
+    return xe(e) || F(e) || e === "" ? [] : Array.isArray(e) ? e : [e];
+  });
+  Se(ie, (e) => {
+    (F(e) || xe(e)) && (J.value = b != null && b.value ? [] : void 0);
+  });
+  const Q = r(() => lt(Ve.value ?? [], q.value)), o = r(() => Q.value.nodeMap), h = r(() => Q.value.orderedNodes), i = r(() => !!(O != null && O.value)), X = r(() => !!(b != null && b.value) || i.value), E = r(() => !!(H != null && H.value)), Be = r(() => (P == null ? void 0 : P.value) ?? "parent"), p = r(() => nt(w.value).map(k)), N = r(() => i.value ? rt(p.value, o.value, h.value, E.value) : { checked: new Set(p.value), halfChecked: /* @__PURE__ */ new Set() }), De = (e) => E.value ? h.value.filter((t) => e.checked.has(t.key)).map((t) => t.key) : ot(
+    e,
+    Be.value,
+    h.value,
+    o.value
+  ), ve = L(((Ke = I.defaultInputValue) == null ? void 0 : Ke.value) ?? ""), Z = r(() => {
+    var e;
+    return ((e = I.inputValue) == null ? void 0 : e.value) ?? ve.value;
+  }), fe = (e) => {
+    ve.value = e, Fe(e);
+  }, D = L([]), Te = r(() => (V == null ? void 0 : V.value) ?? D.value), S = r(
+    () => new Set(Te.value.map((e) => k(e)))
+  ), $ = /* @__PURE__ */ new Set();
+  tt(() => {
+    if (!F(V == null ? void 0 : V.value)) return;
+    const e = new Set(D.value.map((u) => k(u)));
+    let t = !1;
+    const a = (u) => {
+      e.has(u) || (e.add(u), t = !0), $.add(u);
+    };
+    if (Y != null && Y.value)
+      for (const u of h.value)
+        !u.isLeaf && !$.has(u.key) && a(u.key);
+    for (const u of (M == null ? void 0 : M.value) ?? []) {
+      const l = k(u);
+      if (!$.has(l)) {
+        a(l);
+        const n = o.value.get(l);
+        (G == null ? void 0 : G.value) !== !1 && (n == null || n.pathKeys.forEach((d) => a(d)));
+      }
+    }
+    t && (D.value = Array.from(e).map(
+      (u) => {
+        var l;
+        return ((l = o.value.get(u)) == null ? void 0 : l.value) ?? oe(u);
+      }
+    ));
+  });
+  const de = r(
+    () => st(
+      h.value,
+      o.value,
+      Z.value,
+      (j == null ? void 0 : j.value) ?? !0
+    )
+  ), ee = r(
+    () => ct(h.value, S.value, de.value)
+  ), K = (e) => o.value.get(e), Ue = (e) => {
+    const t = z == null ? void 0 : z.value;
+    return t === "leaf" ? e.isLeaf : ce(t) ? !!t(e.raw, { isLeaf: e.isLeaf, level: e.level }) : t !== !1;
+  }, ye = (e) => e.selectable && Ue(e), Ie = (e) => i.value && e.checkable && !e.disabled, We = (e) => i.value ? N.value.checked.has(e.key) : p.value.includes(e.key), Oe = (e) => i.value && N.value.halfChecked.has(e.key), He = (e) => S.value.has(e.key), v = L(), te = r(() => ee.value.filter((e) => !e.disabled)), he = () => {
+    var a;
+    const e = te.value, t = p.value[p.value.length - 1];
+    return t && e.some((u) => u.key === t) ? t : (a = e[0]) == null ? void 0 : a.key;
+  };
+  Se(y, (e) => {
+    e && (v.value = he());
+  });
+  const Pe = (e) => {
+    v.value = e;
+  }, pe = (e) => {
+    const t = te.value;
+    if (t.length === 0) return;
+    if (F(v.value))
+      return e === "down" ? t[0].key : t[t.length - 1].key;
+    const a = t.findIndex((l) => l.key === v.value);
+    if (a === -1) return he();
+    const u = (t.length + a + (e === "up" ? -1 : 1)) % t.length;
+    return t[u].key;
+  }, ge = (e) => {
+    D.value = e, Re(e);
+  }, ae = (e, t) => {
+    const a = K(e);
+    if (!a) return;
+    const u = new Set(S.value);
+    if (t === u.has(e)) return;
+    t ? u.add(e) : u.delete(e);
+    const l = Array.from(u).map(
+      (n) => {
+        var d;
+        return ((d = o.value.get(n)) == null ? void 0 : d.value) ?? oe(n);
+      }
+    );
+    ge(l), Le(l, { node: a.raw, expanded: t });
+  }, x = L([]), ze = (e) => x.value.includes(e), R = (e, t) => {
+    const a = K(e);
+    if (!a || a.disabled) return;
+    if (!(t ?? !S.value.has(e))) {
+      ae(e, !1);
+      return;
+    }
+    if (!(!!(m != null && m.value) && !a.isLeaf && a.childrenKeys.length === 0)) {
+      ae(e, !0);
+      return;
+    }
+    x.value.includes(e) || (x.value = [...x.value, e], (async () => {
+      var n;
+      try {
+        await ((n = m == null ? void 0 : m.value) == null ? void 0 : n.call(m, a.raw)), ae(e, !0);
+      } finally {
+        x.value = x.value.filter((d) => d !== e);
+      }
+    })());
+  }, Me = (e, t) => {
+    R(e, t);
+  }, ue = /* @__PURE__ */ new Map(), le = (e) => ce(_ == null ? void 0 : _.value) ? _.value(e.raw) : e.title, ne = (e) => C != null && C.value ? { value: e.value, label: le(e), raw: e.raw } : e.value, f = (e, t) => {
+    J.value = e, Ne(e), Ee(e, t);
+  }, re = (e) => w.value.filter((t) => {
+    const a = T(t);
+    return U(a) ? !e.includes(k(a)) : !1;
+  }), Ye = (e) => e.map((t) => o.value.get(t)).filter((t) => !!t).map(ne), Ge = () => p.value.filter((e) => !o.value.has(e)).map((e) => {
+    const t = oe(e);
+    return C != null && C.value ? { value: t, label: ue.get(e) ?? String(t) } : t;
+  }), se = (e) => [
+    ...Ye(De(e)),
+    ...Ge()
+  ], ke = (e) => {
+    if (!i.value || !e.checkable || e.disabled || e.disableCheckbox) return;
+    const t = !N.value.checked.has(e.key), a = Ce(
+      N.value,
+      e,
+      t,
+      o.value,
+      E.value
+    );
+    f(se(a), {
+      node: e.raw,
+      checked: t,
+      selected: t
+    });
+  }, je = (e) => {
+    if (e.disabled) return;
+    if (!ye(e)) {
+      e.isLeaf || R(e.key, !0);
+      return;
+    }
+    if (i.value) {
+      ke(e);
+      return;
+    }
+    if (!X.value) {
+      if (p.value[0] === e.key) return;
+      f(ne(e), { node: e.raw, selected: !0 });
+      return;
+    }
+    const a = p.value.includes(e.key), u = a ? re([e.key]) : [...w.value, ne(e)];
+    f(u, { node: e.raw, selected: !a });
+  }, me = (e) => {
+    if (s != null && s.value || c != null && c.value) return;
+    const t = K(e);
+    t && je(t);
+  }, qe = (e) => {
+    if (s != null && s.value || c != null && c.value) return;
+    const t = K(e);
+    if (t != null && t.disabled) return;
+    if (!i.value) {
+      f(re([e]), { node: t == null ? void 0 : t.raw, selected: !1 });
+      return;
+    }
+    if (!t) {
+      f(re([e]), {});
+      return;
+    }
+    const a = Ce(N.value, t, !1, o.value, E.value);
+    f(se(a), {
+      node: t.raw,
+      checked: !1,
+      selected: !1
+    });
+  }, Je = () => {
+    if (!(s != null && s.value || c != null && c.value)) {
+      if (X.value) {
+        const e = w.value.filter((t) => {
+          var u;
+          const a = T(t);
+          return U(a) && ((u = o.value.get(k(a))) == null ? void 0 : u.disabled);
+        });
+        f(e, {});
+      } else
+        f(void 0, {});
+      fe("");
+    }
+  }, Qe = (e, t) => {
+    const a = ue.get(k(e));
+    return a !== void 0 ? a : t && be(t.label) ? t.label : String(e);
+  }, Xe = (e) => {
+    const t = A == null ? void 0 : A.value;
+    if (ce(t)) return t(e);
+  }, Ze = r(() => {
+    const e = [];
+    for (const t of w.value) {
+      const a = T(t);
+      if (!U(a)) continue;
+      const u = k(a), l = o.value.get(u), n = be(t) || at(t) ? void 0 : t;
+      if (l) {
+        const we = le(l);
+        ue.set(u, we), e.push({ value: l.value, label: we, raw: l.raw });
+        continue;
+      }
+      if ((A == null ? void 0 : A.value) === !1 && !n) continue;
+      const d = Xe(a), et = (n == null ? void 0 : n.label) ?? (d ? String(d[q.value.title] ?? a) : Qe(a, n));
+      e.push({ value: a, label: et, raw: d ?? (n == null ? void 0 : n.raw) });
+    }
+    return e;
+  }), $e = r(
+    () => w.value.some((e) => {
+      var a;
+      const t = T(e);
+      return U(t) ? !((a = o.value.get(k(t))) != null && a.disabled) : !1;
+    })
+  );
+  return {
+    // state
+    mergedFieldNames: q,
+    treeData: Q,
+    nodeMap: o,
+    orderedNodes: h,
+    valueArray: w,
+    publicKeys: p,
+    checkState: N,
+    isCheckable: i,
+    isMultiple: X,
+    isStrict: E,
+    filterResult: de,
+    visibleNodes: ee,
+    activeKey: v,
+    expandedKeySet: S,
+    displayValues: Ze,
+    clearable: $e,
+    loadingKeys: x,
+    computedInputValue: Z,
+    // helpers
+    getNodeInfo: K,
+    isNodeSelectable: ye,
+    isNodeCheckable: Ie,
+    isNodeSelected: We,
+    isNodeHalfChecked: Oe,
+    isNodeExpanded: He,
+    isLoadingNode: ze,
+    getDisplayLabel: le,
+    updateInputValue: fe,
+    setActiveKey: Pe,
+    getNextActiveKey: pe,
+    expandNode: R,
+    toggleExpand: Me,
+    handleSelect: me,
+    handleRemove: qe,
+    handleClear: Je,
+    handleKeyDown: (e) => {
+      if (s != null && s.value || e.isComposing || e.keyCode === 229 || e.ctrlKey || e.altKey || e.metaKey || e.shiftKey) return;
+      const t = () => {
+        e.stopPropagation(), e.preventDefault();
+      };
+      if (e.key === g.TAB) {
+        y.value && B(!1);
+        return;
+      }
+      if (e.key === g.ESC) {
+        y.value && (t(), B(!1));
+        return;
+      }
+      if (c != null && c.value) return;
+      const a = v.value;
+      if (e.key === g.ENTER) {
+        y.value ? a && (t(), me(a)) : (t(), B(!0));
+        return;
+      }
+      if (e.key === g.SPACE) {
+        if (y.value && i.value && a) {
+          const u = K(a);
+          u && !u.disabled && u.checkable && !u.disableCheckbox && (t(), ke(u));
+        }
+        return;
+      }
+      if (e.key === g.ARROW_DOWN || e.key === g.ARROW_UP) {
+        const u = e.key === g.ARROW_UP ? "up" : "down";
+        if (t(), !y.value) {
+          B(!0);
+          return;
+        }
+        const l = pe(u);
+        F(l) || (v.value = l);
+        return;
+      }
+      if (e.key === "Home" || e.key === "End") {
+        if (y.value && Z.value === "") {
+          const u = te.value, l = e.key === "Home" ? u[0] : u[u.length - 1];
+          l && (t(), v.value = l.key);
+        }
+        return;
+      }
+      if (e.key === g.ARROW_RIGHT) {
+        if (!y.value || !a) return;
+        const u = K(a);
+        if (!u || u.isLeaf) return;
+        if (t(), !S.value.has(u.key))
+          R(u.key, !0);
+        else {
+          const l = ee.value.find(
+            (n) => n.parentKey === u.key && !n.disabled
+          );
+          l && (v.value = l.key);
+        }
+        return;
+      }
+      if (e.key === g.ARROW_LEFT) {
+        if (!y.value || !a) return;
+        const u = K(a);
+        if (!u) return;
+        t(), !u.isLeaf && S.value.has(u.key) ? R(u.key, !1) : u.parentKey && (v.value = u.parentKey);
+      }
+    },
+    emitValue: f,
+    expandAll: (e = !0) => {
+      if (s != null && s.value) return;
+      const t = e ? h.value.filter((a) => !a.disabled && !a.isLeaf).map((a) => a.value) : [];
+      ge(t);
+    },
+    checkAll: (e = !0) => {
+      if (!i.value || s != null && s.value || c != null && c.value) return;
+      const t = e ? {
+        checked: new Set(
+          h.value.filter((a) => a.checkable && !a.disabled).map((a) => a.key)
+        )
+      } : { checked: /* @__PURE__ */ new Set() };
+      f(se(t), {});
+    }
+  };
+};
+export {
+  gt as useTreeSelect
+};

package/dist/es/components/tree-select/index.js

@@ -0,0 +1,13 @@
+import r from "./TreeSelect.js";
+import t from "./TreeSelectDropdown.vue.js";
+import { generateComponent as e } from "../../_utils/vue-eco.js";
+import { getComponentPrefix as o } from "../../_utils/config.js";
+const l = e(o("TreeSelect"), r), f = e(
+  o("TreeSelectDropdown"),
+  t
+);
+export {
+  l as TreeSelect,
+  f as TreeSelectDropdown,
+  l as default
+};

package/dist/es/components/tree-select/utils.js

@@ -0,0 +1,181 @@
+import { isNumber as b, isString as p, isArray as E, isFunction as F } from "../../_utils/is.js";
+const A = {
+  key: "key",
+  title: "title",
+  children: "children",
+  disabled: "disabled",
+  checkable: "checkable",
+  disableCheckbox: "disableCheckbox",
+  selectable: "selectable",
+  isLeaf: "isLeaf",
+  icon: "icon"
+}, S = (e) => b(e) ? `__x_tree__number-${e}` : `__x_tree__string-${e}`, B = (e) => e.startsWith("__x_tree__number-") ? Number(e.slice(17)) : e.startsWith("__x_tree__string-") ? e.slice(17) : e, $ = (e) => {
+  if (p(e) || b(e))
+    return e;
+  if (e && typeof e == "object" && "value" in e)
+    return e.value;
+}, m = (e) => p(e) || b(e), O = (e, t) => {
+  const h = /* @__PURE__ */ new Map(), o = [], c = [], n = (s, l, r, a, d) => {
+    s.forEach((i, K) => {
+      const x = i[t.key], u = [...a, String(K)];
+      let k = m(x) ? x : `__x_tree__auto-${u.join("-")}`, f = S(k);
+      h.has(f) && (console.warn(
+        `[x-next] TreeSelect: duplicate node key "${String(k)}", fallback to path key.`
+      ), k = `__x_tree__auto-${u.join("-")}`, f = S(k));
+      const g = E(i[t.children]) ? i[t.children] : [], v = i[t.isLeaf], L = g.length === 0 && v !== !1, _ = {
+        key: f,
+        value: k,
+        title: i[t.title] !== void 0 ? String(i[t.title]) : String(k),
+        raw: i,
+        level: l,
+        index: o.length,
+        parentKey: r,
+        pathKeys: d ? [...d.pathKeys, d.key] : [],
+        childrenKeys: [],
+        siblingIndex: K,
+        siblingCount: s.length,
+        isLeaf: L,
+        disabled: !!i[t.disabled],
+        checkable: i[t.checkable] !== !1,
+        disableCheckbox: !!i[t.disableCheckbox],
+        selectable: i[t.selectable] !== !1,
+        loading: !1
+      };
+      h.set(f, _), o.push(_), d ? d.childrenKeys.push(f) : c.push(f), g.length > 0 && n(g, l + 1, f, u, _);
+    });
+  };
+  return n(e ?? [], 0, void 0, [], void 0), { nodeMap: h, orderedNodes: o, rootKeys: c };
+}, y = (e) => e.checkable && !e.disabled, w = (e, t) => e.childrenKeys.map((h) => t.get(h)).filter(
+  (h) => h !== void 0 && y(h)
+), C = (e, t, h) => {
+  const o = [], c = (n) => {
+    for (const s of n) {
+      const l = e.get(s);
+      l && ((!h || h(l)) && o.push(l.key), c(l.childrenKeys));
+    }
+  };
+  return c(t.childrenKeys), o;
+}, D = (e, t) => [t.key, ...C(e, t, y)], I = () => ({
+  checked: /* @__PURE__ */ new Set(),
+  halfChecked: /* @__PURE__ */ new Set()
+}), V = (e, t, h, o) => {
+  const c = I(), n = /* @__PURE__ */ new Set();
+  for (const s of e) {
+    const l = t.get(s);
+    l && n.add(l.key);
+  }
+  if (o)
+    return c.checked = new Set(n), c;
+  for (const s of n) {
+    const l = t.get(s);
+    l && y(l) && (c.checked.add(l.key), C(t, l, y).forEach(
+      (r) => c.checked.add(r)
+    ));
+  }
+  for (let s = h.length - 1; s >= 0; s--) {
+    const l = h[s];
+    if (!l) continue;
+    const r = w(l, t);
+    if (r.length === 0 || !y(l)) continue;
+    let a = !0, d = !1;
+    for (const i of r)
+      c.checked.has(i.key) ? d = !0 : (a = !1, c.halfChecked.has(i.key) && (d = !0));
+    a ? (c.checked.add(l.key), c.halfChecked.delete(l.key)) : (c.checked.delete(l.key), d ? c.halfChecked.add(l.key) : c.halfChecked.delete(l.key));
+  }
+  return c;
+}, T = (e, t, h) => {
+  const o = w(e, t);
+  if (o.length === 0)
+    return h.checked.has(e.key) ? "checked" : "none";
+  let c = !0, n = !1;
+  for (const s of o)
+    h.checked.has(s.key) ? n = !0 : (c = !1, h.halfChecked.has(s.key) && (n = !0));
+  return c ? "checked" : n ? "half" : "none";
+}, W = (e, t, h, o, c) => {
+  const n = {
+    checked: new Set(e.checked),
+    halfChecked: new Set(e.halfChecked)
+  };
+  if (c)
+    return h ? n.checked.add(t.key) : n.checked.delete(t.key), n.halfChecked.delete(t.key), n;
+  const s = D(o, t);
+  for (const r of s)
+    h ? n.checked.add(r) : n.checked.delete(r), n.halfChecked.delete(r);
+  let l = t.parentKey;
+  for (; l; ) {
+    const r = o.get(l);
+    if (!r) break;
+    if (y(r)) {
+      const a = T(r, o, n);
+      a === "checked" ? (n.checked.add(r.key), n.halfChecked.delete(r.key)) : (n.checked.delete(r.key), a === "half" ? n.halfChecked.add(r.key) : n.halfChecked.delete(r.key));
+    }
+    l = r.parentKey;
+  }
+  return n;
+}, z = (e, t, h, o) => {
+  const c = h.filter((s) => e.checked.has(s.key)).map((s) => s.key);
+  if (t === "all") return c;
+  if (t === "parent")
+    return c.filter(
+      (s) => {
+        var l;
+        return !((l = o.get(s)) != null && l.pathKeys.some((r) => e.checked.has(r)));
+      }
+    );
+  const n = /* @__PURE__ */ new Set();
+  for (const s of c) {
+    const l = o.get(s);
+    l && l.pathKeys.forEach((r) => n.add(r));
+  }
+  return c.filter((s) => !n.has(s));
+}, H = (e, t, h, o) => {
+  if (!h || o === !1) return null;
+  const c = h.toLowerCase(), n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), l = (r) => F(o) ? o(h, r.raw) : r.title.toLowerCase().includes(c);
+  for (const r of e)
+    l(r) && (n.add(r.key), s.add(r.key), C(t, r).forEach((a) => s.add(a)), r.pathKeys.forEach((a) => s.add(a)));
+  return { keptKeys: s, matchedKeys: n, query: h };
+}, P = (e, t, h) => {
+  const o = h ? e.filter((c) => h.keptKeys.has(c.key)) : e.filter((c) => c.pathKeys.every((n) => t.has(n)));
+  return o.map((c, n) => {
+    let s = !0;
+    for (let l = n + 1; l < o.length && !(o[l].level < c.level); l++)
+      if (o[l].level === c.level) {
+        s = !1;
+        break;
+      }
+    return { ...c, lastChild: s };
+  });
+}, Q = (e, t) => {
+  if (!t) return [{ text: e, match: !1 }];
+  const h = e.toLowerCase(), o = t.toLowerCase(), c = [];
+  let n = 0, s = h.indexOf(o);
+  for (; s !== -1; )
+    s > n && c.push({ text: e.slice(n, s), match: !1 }), c.push({ text: e.slice(s, s + t.length), match: !0 }), n = s + t.length, s = h.indexOf(o, n);
+  return n < e.length && c.push({ text: e.slice(n), match: !1 }), c.length > 0 ? c : [{ text: e, match: !1 }];
+}, U = (e) => {
+  const t = [];
+  for (const h of e) {
+    const o = $(h);
+    m(o) && t.push(o);
+  }
+  return t;
+};
+export {
+  A as DEFAULT_FIELD_NAMES,
+  O as buildTree,
+  V as conductCheckState,
+  z as filterCheckedKeysByStrategy,
+  H as filterTreeNodes,
+  D as getCascadeKeys,
+  C as getDescendantKeys,
+  w as getEligibleChildren,
+  $ as getKeyFromValue,
+  U as getKeysFromValues,
+  B as getValueFromKey,
+  P as getVisibleNodes,
+  y as isCascadeCheckable,
+  m as isValidKey,
+  S as normalizeKey,
+  Q as splitHighlightText,
+  W as toggleCheckState
+};