ep-craft 0.1.37 → 0.1.39

package/dist/components/tree-v2/EpTreeNode.vue.js

@@ -0,0 +1,127 @@
+import { defineComponent as D, inject as T, computed as k, openBlock as p, createElementBlock as I, withModifiers as s, normalizeClass as u, unref as d, createElementVNode as O, normalizeStyle as w, createBlock as f, withCtx as z, resolveDynamicComponent as M, createCommentVNode as h, createVNode as S } from "vue";
+import { EpIcon as L } from "../icon/index.js";
+import { CaretRight as R } from "@element-plus/icons-vue";
+import { EpCheckbox as V } from "../checkbox/index.js";
+import { useNamespace as F } from "../../hooks/use-namespace/index.js";
+import { isFunction as P, isString as Y } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { mutable as $ } from "../../utils/typescript.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import j from "./tree-node-content.js";
+import { treeNodeEmits as J, ROOT_TREE_INJECTION_KEY as K, EMPTY_NODE as U, NODE_CONTEXTMENU as X } from "./virtual-tree.js";
+const q = ["aria-expanded", "aria-disabled", "aria-checked", "data-key"], me = /* @__PURE__ */ D({
+  name: "EpTreeNode",
+  __name: "EpTreeNode",
+  props: {
+    node: { default: () => $(U) },
+    expanded: { type: Boolean },
+    checked: { type: Boolean },
+    indeterminate: { type: Boolean },
+    showCheckbox: { type: Boolean },
+    disabled: { type: Boolean },
+    current: { type: Boolean },
+    hiddenExpandIcon: { type: Boolean },
+    itemSize: { default: 26 }
+  },
+  emits: J,
+  setup(e, { emit: C }) {
+    const r = e, m = C, n = T(K), i = F("tree"), E = k(() => (n == null ? void 0 : n.props.indent) ?? 16), x = k(() => (n == null ? void 0 : n.props.icon) ?? R), b = (t) => {
+      var l;
+      const o = (l = n == null ? void 0 : n.props.props) == null ? void 0 : l.class;
+      if (!o) return {};
+      let a;
+      if (P(o)) {
+        const { data: c } = t;
+        a = o(c, t);
+      } else
+        a = o;
+      return Y(a) ? { [a]: !0 } : a;
+    }, N = (t) => {
+      m("click", r.node, t);
+    }, y = (t) => {
+      m("drop", r.node, t);
+    }, g = () => {
+      m("toggle", r.node);
+    }, v = (t) => {
+      m("check", r.node, t);
+    }, B = (t) => {
+      var o, a, l, c;
+      (l = (a = (o = n == null ? void 0 : n.instance) == null ? void 0 : o.vnode) == null ? void 0 : a.props) != null && l.onNodeContextmenu && (t.stopPropagation(), t.preventDefault()), n == null || n.ctx.emit(X, t, (c = r.node) == null ? void 0 : c.data, r.node);
+    };
+    return (t, o) => {
+      var a, l, c;
+      return p(), I("div", {
+        ref: "node$",
+        class: u([
+          d(i).b("node"),
+          d(i).is("expanded", e.expanded),
+          d(i).is("current", e.current),
+          d(i).is("focusable", !e.disabled),
+          d(i).is("checked", !e.disabled && e.checked),
+          b(e.node)
+        ]),
+        role: "treeitem",
+        tabindex: "-1",
+        "aria-expanded": e.expanded,
+        "aria-disabled": e.disabled,
+        "aria-checked": e.checked,
+        "data-key": (a = e.node) == null ? void 0 : a.key,
+        onClick: s(N, ["stop"]),
+        onContextmenu: B,
+        onDragover: o[1] || (o[1] = s(() => {
+        }, ["prevent"])),
+        onDragenter: o[2] || (o[2] = s(() => {
+        }, ["prevent"])),
+        onDrop: s(y, ["stop"])
+      }, [
+        O("div", {
+          class: u(d(i).be("node", "content")),
+          style: w({
+            paddingLeft: `${(e.node.level - 1) * E.value}px`,
+            height: e.itemSize + "px"
+          })
+        }, [
+          x.value ? (p(), f(d(L), {
+            key: 0,
+            class: u([
+              d(i).is("leaf", !!((l = e.node) != null && l.isLeaf)),
+              d(i).is("hidden", e.hiddenExpandIcon),
+              {
+                expanded: !((c = e.node) != null && c.isLeaf) && e.expanded
+              },
+              d(i).be("node", "expand-icon")
+            ]),
+            onClick: s(g, ["stop"])
+          }, {
+            default: z(() => [
+              (p(), f(M(x.value)))
+            ]),
+            _: 1
+          }, 8, ["class"])) : h("", !0),
+          e.showCheckbox ? (p(), f(d(V), {
+            key: 1,
+            "model-value": e.checked,
+            indeterminate: e.indeterminate,
+            disabled: e.disabled,
+            onChange: v,
+            onClick: o[0] || (o[0] = s(() => {
+            }, ["stop"]))
+          }, null, 8, ["model-value", "indeterminate", "disabled"])) : h("", !0),
+          S(d(j), {
+            node: { ...e.node, expanded: e.expanded }
+          }, null, 8, ["node"])
+        ], 6)
+      ], 42, q);
+    };
+  }
+});
+export {
+  me as default
+};

package/dist/components/tree-v2/EpTreeNode2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpTreeNode.vue.js";
+export {
+  f as default
+};

package/dist/components/tree-v2/EpTreeV2.vue.d.ts

@@ -0,0 +1,61 @@
+import type { TreeProps } from './types';
+declare var __VLS_17: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TreeProps, {
+    toggleCheckbox: (node: import("./types").TreeNode, isChecked: import("../checkbox").CheckboxValueType, nodeClick?: boolean, immediateUpdate?: boolean, deep?: boolean) => void;
+    getCurrentNode: () => import("./types").TreeNodeData | undefined;
+    getCurrentKey: () => import("./types").TreeKey | undefined;
+    setCurrentKey: (key: import("./types").TreeKey) => void;
+    getCheckedKeys: (leafOnly?: boolean) => import("./types").TreeKey[];
+    getCheckedNodes: (leafOnly?: boolean) => import("./types").TreeNodeData[];
+    getHalfCheckedKeys: () => import("./types").TreeKey[];
+    getHalfCheckedNodes: () => import("./types").TreeNodeData[];
+    setChecked: (key: import("./types").TreeKey, isChecked: boolean, deep?: boolean) => void;
+    setCheckedKeys: (keys: import("./types").TreeKey[]) => void;
+    filter: (query: string) => void;
+    setData: (data: import("./types").TreeData) => void;
+    getNode: (data: import("./types").TreeKey | import("./types").TreeNodeData) => import("./types").TreeNode | undefined;
+    expandNode: (node: import("./types").TreeNode) => void;
+    collapseNode: (node: import("./types").TreeNode) => void;
+    setExpandedKeys: (keys: import("./types").TreeKey[]) => void;
+    scrollToNode: (key: import("./types").TreeKey, strategy?: import("../virtual-list").Alignment) => void;
+    scrollTo: (offset: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    check: (data: import("../tree").TreeNodeData, checkedInfo: import("./types").CheckedInfo) => void;
+    "current-change": (data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => void;
+    "node-drop": (data: import("../tree").TreeNodeData, node: import("./types").TreeNode, e: DragEvent) => void;
+    "node-expand": (data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => void;
+    "check-change": (data: import("../tree").TreeNodeData, checked: boolean) => void;
+    "node-click": (data: import("../tree").TreeNodeData, node: import("./types").TreeNode, e: MouseEvent) => void;
+    "node-contextmenu": (evt: Event, data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => void;
+    "node-collapse": (data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => void;
+}, string, import("vue").PublicProps, Readonly<TreeProps> & Readonly<{
+    onCheck?: ((data: import("../tree").TreeNodeData, checkedInfo: import("./types").CheckedInfo) => any) | undefined;
+    "onCurrent-change"?: ((data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => any) | undefined;
+    "onCheck-change"?: ((data: import("../tree").TreeNodeData, checked: boolean) => any) | undefined;
+    "onNode-click"?: ((data: import("../tree").TreeNodeData, node: import("./types").TreeNode, e: MouseEvent) => any) | undefined;
+    "onNode-contextmenu"?: ((evt: Event, data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => any) | undefined;
+    "onNode-collapse"?: ((data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => any) | undefined;
+    "onNode-expand"?: ((data: import("../tree").TreeNodeData, node: import("./types").TreeNode) => any) | undefined;
+    "onNode-drop"?: ((data: import("../tree").TreeNodeData, node: import("./types").TreeNode, e: DragEvent) => any) | undefined;
+}>, {
+    data: import("./types").TreeData;
+    props: import("./types").TreeOptionProps;
+    height: number;
+    perfMode: boolean;
+    itemSize: number;
+    checkOnClickLeaf: boolean;
+    indent: number;
+    defaultCheckedKeys: import("./types").TreeKey[];
+    defaultExpandedKeys: import("./types").TreeKey[];
+    expandOnClickNode: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tree-v2/EpTreeV2.vue.js

@@ -0,0 +1,168 @@
+import { defineComponent as X, useSlots as Z, computed as _, provide as h, getCurrentInstance as ee, openBlock as i, createElementBlock as u, normalizeClass as c, unref as e, createBlock as f, withCtx as te, normalizeStyle as oe, renderSlot as le, createElementVNode as re, toDisplayString as ne } from "vue";
+import { useNamespace as ie } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { mutable as s } from "../../utils/typescript.js";
+import "@element-plus/icons-vue";
+import { useLocale as se } from "../../hooks/use-locale/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import { formItemContextKey as ae } from "../form/src/constants.js";
+import ce from "../virtual-list/src/components/fixed-size-list.js";
+import "../virtual-list/src/components/dynamic-size-list.js";
+import "../virtual-list/src/props.js";
+import { useTree as de } from "./composables/useTree.js";
+import me from "./EpTreeNode.vue.js";
+import { treeEmits as pe, ROOT_TREE_INJECTION_KEY as he, TreeOptionsEnum as n } from "./virtual-tree.js";
+const He = /* @__PURE__ */ X({
+  name: "EpTreeV2",
+  __name: "EpTreeV2",
+  props: {
+    data: { default: () => s([]) },
+    emptyText: {},
+    height: { default: 200 },
+    props: { default: () => s({
+      children: n.CHILDREN,
+      label: n.LABEL,
+      disabled: n.DISABLED,
+      value: n.KEY,
+      class: n.CLASS
+    }) },
+    highlightCurrent: { type: Boolean },
+    showCheckbox: { type: Boolean },
+    defaultCheckedKeys: { default: () => s([]) },
+    checkStrictly: { type: Boolean },
+    defaultExpandedKeys: { default: () => s([]) },
+    indent: { default: 16 },
+    itemSize: { default: 26 },
+    icon: {},
+    expandOnClickNode: { type: Boolean, default: !0 },
+    checkOnClickNode: { type: Boolean },
+    checkOnClickLeaf: { type: Boolean, default: !0 },
+    currentNodeKey: {},
+    accordion: { type: Boolean },
+    filterMethod: {},
+    perfMode: { type: Boolean, default: !0 },
+    scrollbarAlwaysOn: { type: Boolean }
+  },
+  emits: pe,
+  setup(l, { expose: y, emit: k }) {
+    const a = l, d = k, C = Z(), m = _(() => a.itemSize);
+    h(he, {
+      ctx: {
+        emit: d,
+        slots: C
+      },
+      props: a,
+      instance: ee()
+    }), h(ae, void 0);
+    const { t: g } = se(), r = ie("tree"), {
+      flattenTree: p,
+      isNotEmpty: N,
+      listRef: x,
+      toggleExpand: E,
+      isIndeterminate: b,
+      isChecked: T,
+      isDisabled: B,
+      isCurrent: K,
+      isForceHiddenExpandIcon: S,
+      handleNodeClick: z,
+      handleNodeDrop: w,
+      handleNodeCheck: D,
+      // expose
+      toggleCheckbox: O,
+      getCurrentNode: v,
+      getCurrentKey: I,
+      setCurrentKey: L,
+      getCheckedKeys: A,
+      getCheckedNodes: R,
+      getHalfCheckedKeys: H,
+      getHalfCheckedNodes: M,
+      setChecked: V,
+      setCheckedKeys: F,
+      filter: Y,
+      setData: $,
+      getNode: J,
+      expandNode: j,
+      collapseNode: q,
+      setExpandedKeys: G,
+      scrollToNode: P,
+      scrollTo: Q
+    } = de(a, d);
+    return y({
+      toggleCheckbox: O,
+      getCurrentNode: v,
+      getCurrentKey: I,
+      setCurrentKey: L,
+      getCheckedKeys: A,
+      getCheckedNodes: R,
+      getHalfCheckedKeys: H,
+      getHalfCheckedNodes: M,
+      setChecked: V,
+      setCheckedKeys: F,
+      filter: Y,
+      setData: $,
+      getNode: J,
+      expandNode: j,
+      collapseNode: q,
+      setExpandedKeys: G,
+      scrollToNode: P,
+      scrollTo: Q
+    }), (U, ue) => (i(), u("div", {
+      class: c([e(r).b(), { [e(r).m("highlight-current")]: l.highlightCurrent }]),
+      role: "tree"
+    }, [
+      e(N) ? (i(), f(e(ce), {
+        key: 0,
+        ref_key: "listRef",
+        ref: x,
+        "class-name": e(r).b("virtual-list"),
+        data: e(p),
+        total: e(p).length,
+        height: l.height,
+        "item-size": m.value,
+        "perf-mode": l.perfMode,
+        "scrollbar-always-on": l.scrollbarAlwaysOn
+      }, {
+        default: te(({ data: t, index: o, style: W }) => [
+          (i(), f(me, {
+            key: t[o].key,
+            style: oe(W),
+            node: t[o],
+            expanded: t[o].expanded,
+            "show-checkbox": l.showCheckbox,
+            checked: e(T)(t[o]),
+            indeterminate: e(b)(t[o]),
+            "item-size": m.value,
+            disabled: e(B)(t[o]),
+            current: e(K)(t[o]),
+            "hidden-expand-icon": e(S)(t[o]),
+            onClick: e(z),
+            onToggle: e(E),
+            onCheck: e(D),
+            onDrop: e(w)
+          }, null, 8, ["style", "node", "expanded", "show-checkbox", "checked", "indeterminate", "item-size", "disabled", "current", "hidden-expand-icon", "onClick", "onToggle", "onCheck", "onDrop"]))
+        ]),
+        _: 1
+      }, 8, ["class-name", "data", "total", "height", "item-size", "perf-mode", "scrollbar-always-on"])) : (i(), u("div", {
+        key: 1,
+        class: c(e(r).e("empty-block"))
+      }, [
+        le(U.$slots, "empty", {}, () => [
+          re("span", {
+            class: c(e(r).e("empty-text"))
+          }, ne(l.emptyText ?? e(g)("el.tree.emptyText")), 3)
+        ])
+      ], 2))
+    ], 2));
+  }
+});
+export {
+  He as default
+};

package/dist/components/tree-v2/EpTreeV22.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpTreeV2.vue.js";
+export {
+  f as default
+};

package/dist/components/tree-v2/composables/useCheck.d.ts

@@ -0,0 +1,15 @@
+import type { CheckboxValueType } from '../../checkbox';
+import type { Ref } from 'vue';
+import type { Tree, TreeKey, TreeNode, TreeNodeData, TreeProps } from '../types';
+export declare function useCheck(props: TreeProps, tree: Ref<Tree | undefined>): {
+    updateCheckedKeys: (deep?: boolean) => void;
+    toggleCheckbox: (node: TreeNode, isChecked: CheckboxValueType, nodeClick?: boolean, immediateUpdate?: boolean, deep?: boolean) => void;
+    isChecked: (node: TreeNode) => boolean;
+    isIndeterminate: (node: TreeNode) => boolean;
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getCheckedNodes: (leafOnly?: boolean) => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    getHalfCheckedNodes: () => TreeNodeData[];
+    setChecked: (key: TreeKey, isChecked: boolean, deep?: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[]) => void;
+};

package/dist/components/tree-v2/composables/useCheck.js

@@ -0,0 +1,142 @@
+import { ref as w, getCurrentInstance as G, watch as j, nextTick as x } from "vue";
+import { SetOperationEnum as H, NODE_CHECK as q, NODE_CHECK_CHANGE as z } from "../virtual-tree.js";
+function J(n, t) {
+  const k = w(/* @__PURE__ */ new Set()), y = w(/* @__PURE__ */ new Set()), { emit: E } = G();
+  j(
+    [() => t.value, () => n.defaultCheckedKeys],
+    () => x(() => {
+      m(n.defaultCheckedKeys);
+    }),
+    {
+      immediate: !0
+    }
+  );
+  const v = (e = !1) => {
+    if (!t.value || !n.showCheckbox || n.checkStrictly && !e)
+      return;
+    const { levelTreeNodeMap: s, maxLevel: a } = t.value, c = k.value, f = /* @__PURE__ */ new Set();
+    for (let h = a; h >= 1; --h) {
+      const o = s.get(h);
+      o && o.forEach((l) => {
+        const i = l.children;
+        let C = !l.isLeaf || l.disabled || c.has(l.key);
+        if (i) {
+          let u = !0, d = !1;
+          for (const S of i) {
+            const b = S.key;
+            if (S.isEffectivelyChecked || (C = !1), c.has(b))
+              d = !0;
+            else if (f.has(b)) {
+              u = !1, d = !0;
+              break;
+            } else
+              u = !1;
+          }
+          u ? c.add(l.key) : d ? (f.add(l.key), c.delete(l.key)) : (c.delete(l.key), f.delete(l.key));
+        }
+        l.isEffectivelyChecked = C;
+      });
+    }
+    y.value = f;
+  }, N = (e) => k.value.has(e.key), D = (e) => y.value.has(e.key), r = (e, s, a = !0, c = !0, f = !1) => {
+    const h = k.value, o = e.children;
+    (!n.checkStrictly || f) && a && (o != null && o.length) && (s = o.some((i) => !i.isEffectivelyChecked));
+    const l = (i, C) => {
+      h[C ? H.ADD : H.DELETE](
+        i.key
+      );
+      const u = i.children;
+      (!n.checkStrictly || f) && u && u.forEach((d) => {
+        (!d.disabled || d.children) && l(d, C);
+      });
+    };
+    l(e, s), c && v(), a && M(e, s);
+  }, M = (e, s) => {
+    const { checkedNodes: a, checkedKeys: c } = K(), { halfCheckedNodes: f, halfCheckedKeys: h } = g();
+    E(q, e.data, {
+      checkedKeys: c,
+      checkedNodes: a,
+      halfCheckedKeys: h,
+      halfCheckedNodes: f
+    }), E(z, e.data, s);
+  };
+  function L(e = !1) {
+    return K(e).checkedKeys;
+  }
+  function _(e = !1) {
+    return K(e).checkedNodes;
+  }
+  function T() {
+    return g().halfCheckedKeys;
+  }
+  function A() {
+    return g().halfCheckedNodes;
+  }
+  function K(e = !1) {
+    const s = [], a = [];
+    if (t != null && t.value && n.showCheckbox) {
+      const { treeNodeMap: c } = t.value;
+      k.value.forEach((f) => {
+        const h = c.get(f);
+        h && (!e || e && h.isLeaf) && (a.push(f), s.push(h.data));
+      });
+    }
+    return {
+      checkedKeys: a,
+      checkedNodes: s
+    };
+  }
+  function g() {
+    const e = [], s = [];
+    if (t != null && t.value && n.showCheckbox) {
+      const { treeNodeMap: a } = t.value;
+      y.value.forEach((c) => {
+        const f = a.get(c);
+        f && (s.push(c), e.push(f.data));
+      });
+    }
+    return {
+      halfCheckedNodes: e,
+      halfCheckedKeys: s
+    };
+  }
+  function I(e) {
+    k.value.clear(), y.value.clear(), x(() => {
+      m(e);
+    });
+  }
+  function O(e, s, a) {
+    if (t != null && t.value && n.showCheckbox) {
+      const c = t.value.treeNodeMap.get(e);
+      c && r(c, s, !1, void 0, a);
+    }
+  }
+  function m(e) {
+    if (t != null && t.value) {
+      const { treeNodeMap: s } = t.value;
+      if (n.showCheckbox && s && (e == null ? void 0 : e.length) > 0) {
+        for (const a of e) {
+          const c = s.get(a);
+          c && !N(c) && r(c, !0, !1, !1);
+        }
+        v();
+      }
+    }
+  }
+  return {
+    updateCheckedKeys: v,
+    toggleCheckbox: r,
+    isChecked: N,
+    isIndeterminate: D,
+    // expose
+    getCheckedKeys: L,
+    getCheckedNodes: _,
+    getHalfCheckedKeys: T,
+    getHalfCheckedNodes: A,
+    setChecked: O,
+    setCheckedKeys: I
+  };
+}
+export {
+  J as useCheck
+};

package/dist/components/tree-v2/composables/useFilter.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+import type { Tree, TreeKey, TreeNode, TreeProps } from '../types';
+export declare function useFilter(props: TreeProps, tree: Ref<Tree | undefined>): {
+    hiddenExpandIconKeySet: Ref<Set<TreeKey> & Omit<Set<TreeKey>, keyof Set<any>>, Set<TreeKey> | (Set<TreeKey> & Omit<Set<TreeKey>, keyof Set<any>>)>;
+    hiddenNodeKeySet: Ref<Set<TreeKey> & Omit<Set<TreeKey>, keyof Set<any>>, Set<TreeKey> | (Set<TreeKey> & Omit<Set<TreeKey>, keyof Set<any>>)>;
+    doFilter: (query: string) => Set<TreeKey> | undefined;
+    isForceHiddenExpandIcon: (node: TreeNode) => boolean;
+};

package/dist/components/tree-v2/composables/useFilter.js

@@ -0,0 +1,50 @@
+import { ref as p, computed as K } from "vue";
+import { isFunction as F } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+function M(c, y) {
+  const f = p(/* @__PURE__ */ new Set([])), r = p(/* @__PURE__ */ new Set([])), k = K(() => F(c.filterMethod));
+  function m(a) {
+    var h;
+    if (!k.value)
+      return;
+    const d = /* @__PURE__ */ new Set(), l = r.value, i = f.value, o = [], v = ((h = y.value) == null ? void 0 : h.treeNodes) || [], s = c.filterMethod;
+    i.clear();
+    function u(S) {
+      S.forEach((e) => {
+        o.push(e), s != null && s(a, e.data, e) ? o.forEach((t) => {
+          d.add(t.key), t.expanded = !0;
+        }) : (e.expanded = !1, e.isLeaf && i.add(e.key));
+        const n = e.children;
+        if (n && u(n), !e.isLeaf) {
+          if (!d.has(e.key))
+            i.add(e.key);
+          else if (n) {
+            let t = !0;
+            for (const E of n)
+              if (!i.has(E.key)) {
+                t = !1;
+                break;
+              }
+            t ? l.add(e.key) : l.delete(e.key);
+          }
+        }
+        o.pop();
+      });
+    }
+    return u(v), d;
+  }
+  function x(a) {
+    return r.value.has(a.key);
+  }
+  return {
+    hiddenExpandIconKeySet: r,
+    hiddenNodeKeySet: f,
+    doFilter: m,
+    isForceHiddenExpandIcon: x
+  };
+}
+export {
+  M as useFilter
+};