@unicom-cloud/ui 0.8.44 → 0.8.46

package/tree/Tree.js

@@ -0,0 +1,549 @@
+var O = Object.defineProperty;
+var M = (P, u, e) => u in P ? O(P, u, { enumerable: !0, configurable: !0, writable: !0, value: e }) : P[u] = e;
+var n = (P, u, e) => M(P, typeof u != "symbol" ? u + "" : u, e);
+import { jsx as b } from "react/jsx-runtime";
+import { Component as v, createElement as I } from "react";
+import { isEmptyObject as A } from "@unicom-cloud/utils/is";
+import N from "lodash/get";
+import T from "lodash/has";
+import $ from "lodash/isArray";
+import x from "lodash/isEqualWith";
+import F from "lodash/isFunction";
+import _ from "lodash/isUndefined";
+/* empty css                  */
+import "../config-provider/ConfigProvider.js";
+import E from "@unicom-cloud/utils/class-name";
+import { pickDataAttributes as H } from "../utils/pick.js";
+import { TreeContext as R } from "./Context.js";
+import L from "./Node.js";
+import j from "./NodeList.js";
+import { getTreeDataFromTreeChildren as W, getCheckedKeysByInitKeys as U, getAllCheckedKeysByCheck as z } from "./util.js";
+import { ConfigContext as q } from "../config-provider/context.js";
+const w = {
+  key: "key",
+  title: "title",
+  children: "children",
+  selectable: "selectable",
+  disabled: "disabled",
+  disableCheckbox: "disableCheckbox",
+  checkable: "checkable",
+  isLeaf: "isLeaf"
+}, B = {
+  selectable: !0,
+  autoExpandParent: !0,
+  checkedStrategy: "all",
+  actionOnClick: "select",
+  allowDrop: () => !0,
+  fieldNames: w
+}, V = [
+  "style",
+  "className",
+  "height",
+  "size",
+  "blockNode",
+  "autoExpandParent",
+  "checkedStrategy",
+  "fieldNames",
+  "icons",
+  "virtualListProps",
+  "showLine",
+  "selectable",
+  "allowDrop",
+  "actionOnClick"
+], k = class k extends v {
+  constructor(e, i) {
+    super(e, i);
+    n(this, "context");
+    n(this, "key2nodeProps", {});
+    n(this, "dragNode");
+    n(this, "nodeListRef");
+    n(this, "dropPosition");
+    n(this, "getMergedProps", (e) => {
+      const { componentConfig: i } = this.context ?? {}, s = e || this.props, t = (i == null ? void 0 : i.Tree) || {}, r = {};
+      return V.forEach((o) => {
+        _(s[o]) ? _(t[o]) ? r[o] = B[o] : r[o] = t[o] : r[o] = s[o];
+      }), r;
+    });
+    // index: 第几个dom元素, 如果传入的是字符串，会作为 node 的 key去查找。
+    // nodeProps 参数似乎咩有什么用。。。但是不知道外部有没有调用，就当key用吧。。
+    n(this, "scrollIntoView", (e, i) => {
+      let s = e;
+      i && (s = i._key), this.nodeListRef && this.nodeListRef.scrollIntoView(
+        s,
+        i || this.key2nodeProps[s]
+      );
+    });
+    n(this, "getTreeData", () => "treeData" in this.props ? this.props.treeData : W(this.props.children));
+    // 以下外部传入的属性改变时，需要更新nodeList
+    n(this, "needUpdateTreeData", (e, i) => {
+      const s = [
+        "fieldNames",
+        "selectable",
+        "draggable",
+        "checkStrictly",
+        "showLine",
+        "blockNode",
+        "checkable",
+        "treeData",
+        "children"
+      ];
+      return e.treeData !== i.treeData || e.children !== i.children || s.some((t) => x(e[t], i[t]));
+    });
+    // 根据 fieldNames 获取节点数据
+    n(this, "getFieldInfo", (e) => {
+      const i = this.getMergedProps(), { selectable: s } = i, t = {
+        ...w,
+        ..."treeData" in this.props ? i.fieldNames : {}
+      }, r = {
+        children: N(e, t.children) || e[t.children],
+        selectable: (N(e, t.selectable) || e[t.selectable]) ?? s,
+        checkable: (N(e, t.checkable) || e[t.checkable]) ?? this.props.checkable,
+        title: N(e, t.title) || e[t.title],
+        disabled: N(e, t.disabled) || e[t.disabled],
+        disableCheckbox: N(e, t.disableCheckbox) || e[t.disableCheckbox],
+        isLeaf: N(e, t.isLeaf) || e[t.isLeaf],
+        key: N(e, t.key) || e[t.key]
+      };
+      return (!T(e, t.key) || !(t.key in e)) && delete r.key, r;
+    });
+    n(this, "getNodeList", (e, i) => {
+      this.key2nodeProps = {};
+      const s = i || this.context.getPrefixCls("tree"), t = [];
+      let r = 0;
+      const { showLine: o, blockNode: c } = this.getMergedProps(), d = (l, h) => {
+        const f = l.length;
+        return l.map((K, y) => {
+          const {
+            children: p,
+            selectable: a,
+            checkable: m,
+            key: g = `${(h == null ? void 0 : h._key) || ""}-${y}`,
+            ...D
+          } = this.getFieldInfo(K), C = {
+            // data 中含有dataRef时，优先级较高
+            dataRef: K,
+            draggable: this.props.draggable,
+            selectable: a,
+            checkable: m,
+            showLine: o,
+            blockNode: c,
+            ...K,
+            ...D,
+            key: g,
+            children: p,
+            _key: g,
+            _index: r++,
+            parentKey: h ? h._key : void 0,
+            pathParentKeys: h && h.pathParentKeys || [],
+            _level: h._level || 0,
+            // 保存node在sowLine模式下是否显示缩进线。如果父节点是其所在层级的最后一个节点，那么所有的子节点（包括孙子节点等）在父节点所在层级的缩进格都不显示缩进线。
+            _lineless: h && h._lineless ? [...h._lineless || [], h._isTail] : []
+          };
+          return f === y + 1 && (C.className = E(
+            `${s}-node-is-tail`,
+            C.className
+          )), t.push(C), this.key2nodeProps[g] = C, p && p.length && (this.key2nodeProps[g].children = d(p, {
+            _key: g,
+            _level: C._level + 1,
+            _lineless: C._lineless,
+            _isTail: f === y + 1,
+            pathParentKeys: [...(h == null ? void 0 : h.pathParentKeys) || [], g]
+          })), C;
+        });
+      };
+      return d(e || [], {}), t;
+    });
+    n(this, "getInitExpandedKeys", (e) => {
+      if (!this.getMergedProps().autoExpandParent)
+        return e || [];
+      if (!e)
+        return Object.keys(this.key2nodeProps).filter((s) => {
+          const t = this.key2nodeProps[s];
+          return t.children && t.children.length;
+        });
+      const i = {};
+      return e.forEach((s) => {
+        const t = this.key2nodeProps[s];
+        t && (i[s] = 1, t.pathParentKeys && t.pathParentKeys.forEach((r) => {
+          i[r] = 1;
+        }));
+      }), Object.keys(i);
+    });
+    n(this, "getInitCheckedKeys", (e) => {
+      if (!this.props.checkStrictly) {
+        const { checkedKeys: i, indeterminateKeys: s } = U(
+          e,
+          this.key2nodeProps
+        );
+        return {
+          checkedKeys: i,
+          halfCheckedKeys: s
+        };
+      }
+      return {
+        checkedKeys: e,
+        halfCheckedKeys: this.props.halfCheckedKeys || []
+      };
+    });
+    n(this, "handleSelect", (e, i) => {
+      const { onSelect: s } = this.props, t = { e: i, node: this.getCacheNode([e])[0] };
+      if (this.props.multiple) {
+        const r = [...this.state.selectedKeys], o = r.indexOf(e);
+        o > -1 ? (r.splice(o, 1), t.selected = !1) : (t.selected = !0, r.push(e)), t.selectedNodes = this.getCacheNode(r), "selectedKeys" in this.props || this.setState({ selectedKeys: r }), s == null || s(r, t);
+      } else
+        t.selected = !0, t.selectedNodes = this.getCacheNode([e]), "selectedKeys" in this.props || this.setState({ selectedKeys: [e] }), s == null || s([e], t);
+    });
+    n(this, "handleCheck", (e, i, s) => {
+      const { checkedStrategy: t } = this.getMergedProps(), { onCheck: r, checkStrictly: o } = this.props, c = { e: s, node: this.getCacheNode([i])[0] };
+      let d = this.state.checkedKeys, l = this.state.halfCheckedKeys;
+      if (o) {
+        e ? d = d.concat(i) : d = d.filter((f) => f !== i);
+        const h = {};
+        "checkedKeys" in this.props || (h.checkedKeys = d), "halfCheckedKeys" in this.props || (h.halfCheckedKeys = l), A(h) || this.setState({ ...h });
+      } else {
+        const { checkedKeys: h, indeterminateKeys: f } = z(
+          i,
+          e,
+          d,
+          this.key2nodeProps,
+          l
+        );
+        d = h, l = f, "checkedKeys" in this.props ? this.setState({ halfCheckedKeys: l }) : this.setState({ checkedKeys: d, halfCheckedKeys: l }), t === k.SHOW_PARENT ? d = d.filter((K) => {
+          const y = this.key2nodeProps[K];
+          if (!y || d.indexOf(y.parentKey) === -1)
+            return !0;
+        }) : t === k.SHOW_CHILD && (d = d.filter((K) => {
+          var p, a;
+          const y = this.key2nodeProps[K];
+          if (!y || !((p = y.children) != null && p.length) || (a = y.children) != null && a.every((m) => d.indexOf(m._key) === -1))
+            return !0;
+        }));
+      }
+      r == null || r(d, {
+        checkedNodes: this.getCacheNode(d),
+        checked: e,
+        halfCheckedKeys: l,
+        halfCheckedNodes: this.getCacheNode(l),
+        ...c
+      });
+    });
+    n(this, "handleLoadMore", (e) => {
+      const { loadMore: i } = this.props;
+      if (F(i)) {
+        const { loadingKeys: s = [], loadedKeys: t } = this.state;
+        this.setState(
+          {
+            loadingKeys: Array.from(/* @__PURE__ */ new Set([...s, e._key])),
+            loadedKeys: t.filter((r) => r !== e._key)
+          },
+          async () => {
+            try {
+              await i(this.getCacheNode([e._key])[0]), this.setState({
+                loadedKeys: Array.from(
+                  /* @__PURE__ */ new Set([...this.state.loadedKeys, e._key])
+                ),
+                loadingKeys: this.state.loadingKeys.filter(
+                  (r) => r !== e._key
+                )
+              }), this.handleExpand(!e.expanded, e._key);
+            } catch (r) {
+              console.error("[tree]load data error: ", r), this.setState({
+                loadingKeys: this.state.loadingKeys.filter(
+                  (o) => o !== e._key
+                )
+              });
+            }
+          }
+        );
+      }
+    });
+    n(this, "handleNodeDragStart", (e, i) => {
+      this.dragNode = this.getCacheNode([i._key])[0], this.dropPosition = 0;
+      const { onDragStart: s } = this.props;
+      s == null || s(e, this.getCacheNode([i._key])[0]);
+    });
+    n(this, "handleNodeDragEnd", (e, i) => {
+      this.dragNode = null, this.dropPosition = 0;
+      const { onDragEnd: s } = this.props;
+      s == null || s(e, this.getCacheNode([i._key])[0]);
+    });
+    n(this, "handleNodeDragOver", (e, i, s) => {
+      this.dropPosition = s;
+      const { onDragOver: t } = this.props;
+      t == null || t(e, this.getCacheNode([i._key])[0]);
+    });
+    n(this, "handleNodeDragLeave", (e, i) => {
+      this.dropPosition = 0;
+      const { onDragLeave: s } = this.props;
+      s == null || s(e, this.getCacheNode([i._key])[0]);
+    });
+    n(this, "isChildOfNode", (e, i) => {
+      let s = this.key2nodeProps[e.parentKey];
+      for (; s; ) {
+        const { _key: t, parentKey: r } = s;
+        if (t === i.props._key)
+          return !0;
+        if (r === t) return;
+        s = this.key2nodeProps[r];
+      }
+    });
+    n(this, "isSameNode", (e, i) => {
+      if (e === void 0 || i === void 0) return !1;
+      if (e === i) return !0;
+      const s = e.key, t = i.key;
+      if (s !== void 0 || t !== void 0) return s === t;
+      const r = e.props._key, o = i.props._key;
+      return r === void 0 && o === void 0 ? !1 : r === o;
+    });
+    n(this, "handleNodeDrop", (e, i, s) => {
+      if (this.dragNode) {
+        const { allowDrop: t } = this.getMergedProps(), { onDrop: r } = this.props, o = this.getCacheNode([i._key])[0];
+        if (r && !this.isChildOfNode(i, this.dragNode) && !this.isSameNode(this.dragNode, o)) {
+          if (t && !t({
+            dropNode: o,
+            dragNode: this.dragNode,
+            dropPosition: s
+          }))
+            return;
+          r({
+            dragNode: this.dragNode,
+            dropNode: o,
+            dropPosition: s,
+            e
+          });
+        }
+      }
+    });
+    n(this, "handleAllowDrop", (e, i) => {
+      const { allowDrop: s } = this.getMergedProps();
+      let t = !0;
+      return typeof s == "function" && (t = s({
+        dropNode: this.getCacheNode([e._key])[0],
+        dragNode: this.dragNode,
+        dropPosition: i
+      })), t;
+    });
+    n(this, "handleExpand", (e, i) => {
+      const { currentExpandKeys: s, expandedKeys: t = [] } = this.state, { onExpand: r } = this.props;
+      if (s.indexOf(i) > -1)
+        return;
+      let o = [];
+      e ? o = Array.from(/* @__PURE__ */ new Set([...t, i])) : o = t.filter((c) => c !== i), "expandedKeys" in this.props || this.setState({
+        expandedKeys: o,
+        currentExpandKeys: [...s, i]
+      }), r == null || r(o, {
+        expanded: e,
+        node: this.getCacheNode([i])[0],
+        expandedNodes: this.getCacheNode(o)
+      });
+    });
+    n(this, "getCacheNode", (e) => {
+      const { __PqbAdapterMode__: i } = this.props, s = [];
+      return [].concat(e).forEach((r) => {
+        const o = this.key2nodeProps[r];
+        o && s.push(o);
+      }), this.getNodeProps(s).map((r) => i ? {
+        props: r,
+        key: e
+      } : /* @__PURE__ */ I(L, { ...r, key: r.key }));
+    });
+    // 转换为 set 类型，便于查找。主要是传递给node-list使用
+    n(this, "getDataSet", (e) => {
+      var i, s, t, r;
+      return {
+        expandedKeysSet: (e == null ? void 0 : e.expandedKeysSet) || new Set(((i = this.state) == null ? void 0 : i.expandedKeys) || []),
+        checkedKeysSet: (e == null ? void 0 : e.checkedKeysSet) || new Set(((s = this.state) == null ? void 0 : s.checkedKeys) || []),
+        selectedKeysSet: (e == null ? void 0 : e.selectedKeysSet) || new Set(((t = this.state) == null ? void 0 : t.selectedKeys) || []),
+        halfCheckedKeysSet: (e == null ? void 0 : e.halfCheckedKeysSet) || new Set(((r = this.state) == null ? void 0 : r.halfCheckedKeys) || [])
+      };
+    });
+    // dataSet:传入构建好的expandedKeysSet,, checkedKeysSet, halfCheckedKeysSet ，性能优化
+    n(this, "getNodeProps", (e, i) => {
+      const { autoExpandParent: s } = this.getMergedProps(), { loadMore: t } = this.props, {
+        selectedKeys: r,
+        expandedKeys: o,
+        checkedKeys: c,
+        loadingKeys: d = [],
+        loadedKeys: l = []
+      } = this.state, {
+        expandedKeysSet: h,
+        checkedKeysSet: f,
+        selectedKeysSet: K,
+        halfCheckedKeysSet: y
+      } = this.getDataSet(i), p = (a) => {
+        const m = a.children && a.children.length, g = {
+          isLeaf: !m,
+          autoExpandParent: m ? s : !1,
+          expanded: h ? h.has(a._key) : o.indexOf(a._key) > -1
+        };
+        if (t) {
+          const D = l.indexOf(a._key) > -1;
+          g.loaded = D, g.isLeaf = m ? !1 : a.isLeaf;
+        }
+        return {
+          ...a,
+          ...g,
+          selected: K.has(a._key),
+          indeterminated: y.has(a._key),
+          loading: d.indexOf(a._key) > -1,
+          checked: f.has(a._key),
+          selectedKeys: r,
+          checkedKeys: c,
+          loadingKeys: d,
+          loadedKeys: l,
+          expandedKeys: o,
+          childrenData: a.children || [],
+          children: null
+        };
+      };
+      return $(e) ? e.map((a) => p(a)) : p(e);
+    });
+    n(this, "handleExpandEnd", (e) => {
+      this.setState((i) => {
+        const { currentExpandKeys: s } = i;
+        return s.indexOf(e) > -1 ? {
+          currentExpandKeys: s.filter((t) => t !== e)
+        } : {};
+      });
+    });
+    // 获取tree的state数据，在子组件里使用。
+    n(this, "getTreeState", () => this.state);
+    this.state = {};
+    const s = this.getTreeData(), t = this.getNodeList(s, i.getPrefixCls("tree")), { checkedKeys: r, halfCheckedKeys: o } = this.getInitCheckedKeys(
+      e.checkedKeys || e.defaultCheckedKeys || []
+    );
+    this.state = {
+      selectedKeys: e.selectedKeys || e.defaultSelectedKeys || [],
+      checkedKeys: r,
+      halfCheckedKeys: o,
+      expandedKeys: this.getInitExpandedKeys(
+        e.expandedKeys || e.defaultExpandedKeys
+      ),
+      loadedKeys: [],
+      loadingKeys: [],
+      currentExpandKeys: [],
+      nodeList: t
+    };
+  }
+  static getDerivedStateFromProps(e, i) {
+    const s = {};
+    return "selectedKeys" in e && !x(e.selectedKeys, i.selectedKeys) && (s.selectedKeys = e.selectedKeys || []), Object.keys(s).length ? s : null;
+  }
+  componentDidUpdate(e) {
+    const i = this.getMergedProps(e), s = this.getMergedProps();
+    if (e !== this.props || !x(i, s)) {
+      const t = {};
+      if (this.needUpdateTreeData(
+        { prevMergedProps: i, ...e },
+        { ...s, ...this.props }
+      )) {
+        const o = this.getTreeData(), c = this.getNodeList(o);
+        t.treeData = o, t.nodeList = c;
+      }
+      if (t.treeData || "checkedKeys" in this.props && !x(e.checkedKeys, this.props.checkedKeys)) {
+        const o = "checkedKeys" in this.props ? this.props.checkedKeys : this.state.checkedKeys, { halfCheckedKeys: c, checkedKeys: d } = this.getInitCheckedKeys(
+          o || []
+        );
+        x(d, this.state.checkedKeys) || (t.checkedKeys = d), x(c, this.state.halfCheckedKeys) || (t.halfCheckedKeys = c);
+      }
+      this.props.checkStrictly && "halfCheckedKeys" in this.props && !x(e.halfCheckedKeys, this.props.halfCheckedKeys) && (t.halfCheckedKeys = this.props.halfCheckedKeys), "expandedKeys" in this.props && !x(this.props.expandedKeys, e.expandedKeys) && (t.expandedKeys = this.props.expandedKeys, t.currentExpandKeys = [
+        ...t.expandedKeys,
+        ...this.state.expandedKeys
+      ].reduce((o, c) => {
+        const d = o.indexOf(c);
+        return d === -1 ? o.push(c) : o.splice(d, 1), o;
+      }, []).filter((o, c, d) => {
+        var l;
+        if (this.key2nodeProps[o])
+          return this.key2nodeProps[o].pathParentKeys.some((f) => d.indexOf(f) > -1) ? !1 : (l = this.key2nodeProps[o].children) == null ? void 0 : l.length;
+      }));
+      const r = t.currentExpandKeys || this.state.currentExpandKeys;
+      t.treeData && r && (t.currentExpandKeys = r.filter((o) => {
+        const c = t.treeData.find((d) => d.key === o);
+        return c && c.children && c.children.length;
+      })), Object.keys(t).length && this.setState(t);
+    }
+  }
+  render() {
+    const {
+      className: e,
+      showLine: i,
+      size: s,
+      virtualListProps: t,
+      height: r,
+      style: o,
+      icons: c,
+      actionOnClick: d
+    } = this.getMergedProps(), { loadMore: l, checkable: h } = this.props, f = t ? {
+      threshold: 100,
+      ...t
+    } : r ? { height: r, threshold: 100 } : {
+      threshold: null
+    }, { getPrefixCls: K, rtl: y } = this.context, p = K("tree");
+    return /* @__PURE__ */ b(
+      R.Provider,
+      {
+        value: {
+          icons: c,
+          key2nodeProps: this.key2nodeProps,
+          getFieldInfo: this.getFieldInfo,
+          getTreeState: this.getTreeState,
+          getNodeProps: this.getNodeProps,
+          onExpandEnd: this.handleExpandEnd,
+          onSelect: this.handleSelect,
+          onCheck: this.handleCheck,
+          onNodeDragStart: this.handleNodeDragStart,
+          onNodeDragEnd: this.handleNodeDragEnd,
+          onNodeDragLeave: this.handleNodeDragLeave,
+          onNodeDragOver: this.handleNodeDragOver,
+          onNodeDrop: this.handleNodeDrop,
+          onExpand: this.handleExpand,
+          renderExtra: this.props.renderExtra,
+          renderTitle: this.props.renderTitle,
+          loadMore: l && this.handleLoadMore,
+          allowDrop: this.handleAllowDrop,
+          actionOnClick: d,
+          virtualListProps: f
+        },
+        children: /* @__PURE__ */ b(
+          j,
+          {
+            ref: (a) => {
+              this.nodeListRef = a;
+            },
+            className: E(
+              p,
+              {
+                [`${p}-checkable`]: h,
+                [`${p}-show-line`]: i,
+                [`${p}-size-${s}`]: s,
+                [`${p}-rtl`]: y
+              },
+              e
+            ),
+            style: o,
+            filterNode: this.props.filterNode,
+            virtualListProps: f,
+            expandedKeys: this.state.expandedKeys,
+            currentExpandKeys: this.state.currentExpandKeys,
+            getNodeProps: this.getNodeProps,
+            getDataSet: this.getDataSet,
+            nodeList: this.state.nodeList,
+            onMouseDown: this.props.onMouseDown,
+            ariaProps: {
+              role: "tree",
+              "aria-multiselectable": this.props.multiple,
+              tabIndex: 0,
+              ...H(this.props)
+            }
+          }
+        )
+      }
+    );
+  }
+};
+n(k, "displayName", "Tree"), n(k, "SHOW_PARENT", "parent"), n(k, "SHOW_ALL", "all"), n(k, "SHOW_CHILD", "child"), n(k, "Node", L), n(k, "contextType", q);
+let S = k;
+export {
+  S as default
+};

package/tree/util.js

@@ -0,0 +1,76 @@
+import o from "react";
+const C = (t) => {
+  const n = (r) => o.Children.map(r, (e) => {
+    if (!o.isValidElement(e))
+      return;
+    const d = e.key;
+    return {
+      ...e.props,
+      key: d,
+      children: n(e.props.children)
+    };
+  });
+  return n(t);
+};
+function f(t, n) {
+  const r = /* @__PURE__ */ new Set(), e = (d) => {
+    d.map((s) => {
+      const c = s.key, a = n[c];
+      !a || a.disabled || a.disableCheckbox || a.checkable === !1 || (r.add(c), e(a.children || []));
+    });
+  };
+  return t && e(t.children || []), r;
+}
+const u = (t, n, r, e) => {
+  [...n[t].pathParentKeys].reverse().some((s) => {
+    const c = n[s];
+    if (c && !c.disabled && !c.disableCheckbox && c.checkable !== !1) {
+      let a = 0, l = 0;
+      c.children.some(({ key: i }) => {
+        const h = n[i];
+        if (!h || h.disabled || h.disableCheckbox || h.checkable === !1)
+          return !1;
+        if (a++, r.has(i))
+          l++;
+        else if (e.has(i))
+          return l += 0.5, !0;
+      }), !l || l === a ? e.delete(s) : e.add(s), l && l === a ? r.add(s) : r.delete(s);
+    } else
+      return !0;
+  });
+};
+function K(t, n) {
+  const r = new Set(t || []), e = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+  return t.forEach((s) => {
+    d.has(s) || f(n[s], n).forEach((a) => {
+      d.add(a);
+    }), n[s] && !n[s].pathParentKeys.some(
+      (c) => r.has(c)
+    ) && u(s, n, r, e);
+  }), {
+    checkedKeys: [.../* @__PURE__ */ new Set([...r, ...d])],
+    indeterminateKeys: [...e]
+  };
+}
+function S(t, n, r, e, d) {
+  if (!e[t])
+    return {
+      checkedKeys: r,
+      indeterminateKeys: d
+    };
+  const s = new Set(r), c = new Set(d), a = f(e[t], e), l = s;
+  return n ? (l.add(t), c.delete(t), a.forEach((i) => {
+    l.add(i);
+  })) : (c.delete(t), l.delete(t), a.forEach((i) => {
+    l.delete(i);
+  })), u(t, e, s, c), {
+    checkedKeys: [...l],
+    indeterminateKeys: [...c]
+  };
+}
+export {
+  S as getAllCheckedKeysByCheck,
+  K as getCheckedKeysByInitKeys,
+  f as getChildNodeKeys,
+  C as getTreeDataFromTreeChildren
+};