@gobolt/genesis 0.2.13 → 0.2.15

package/dist/node_modules/antd/es/table/hooks/useSelection.js

@@ -1,346 +1,515 @@
-import L from "../../../../@babel/runtime/helpers/esm/toConsumableArray.js";
-import * as y from "react";
-import { useCallback as B, useMemo as I } from "react";
-import Fe from "../../../../@ant-design/icons/es/icons/DownOutlined.js";
-import He from "../../../../../_virtual/index.js";
+import _toConsumableArray from "../../../../@babel/runtime/helpers/esm/toConsumableArray.js";
+import * as React from "react";
+import { useCallback, useMemo } from "react";
+import RefIcon from "../../../../@ant-design/icons/es/icons/DownOutlined.js";
+import classNames from "../../../../../_virtual/index.js";
 import "../../../../rc-table/es/Footer/index.js";
 import "../../../../rc-table/es/Table.js";
-import { INTERNAL_COL_DEFINE as he } from "../../../../rc-table/es/utils/legacyUtil.js";
+import { INTERNAL_COL_DEFINE } from "../../../../rc-table/es/utils/legacyUtil.js";
 import "../../../../rc-table/es/VirtualTable/index.js";
-import { arrDel as Xe, arrAdd as Be } from "../../../../rc-tree/es/util.js";
-import { conductCheck as ve } from "../../../../rc-tree/es/utils/conductUtil.js";
-import { convertDataToEntities as Ye } from "../../../../rc-tree/es/utils/treeUtil.js";
-import qe from "../../../../rc-util/es/hooks/useMergedState.js";
-import Je from "../../_util/hooks/useMultipleSelect.js";
-import { devUseWarning as Qe } from "../../_util/warning.js";
-import Le from "../../checkbox/index.js";
-import Ze from "../../dropdown/index.js";
-import et from "../../radio/index.js";
-const N = {}, Oe = "SELECT_ALL", Pe = "SELECT_INVERT", De = "SELECT_NONE", Ie = [], Ae = (U, h) => {
-  let C = [];
-  return (h || []).forEach((K) => {
-    C.push(K), K && typeof K == "object" && U in K && (C = [].concat(L(C), L(Ae(U, K[U]))));
-  }), C;
-}, Et = (U, h) => {
+import { arrDel, arrAdd } from "../../../../rc-tree/es/util.js";
+import { conductCheck } from "../../../../rc-tree/es/utils/conductUtil.js";
+import { convertDataToEntities } from "../../../../rc-tree/es/utils/treeUtil.js";
+import useMergedState from "../../../../rc-util/es/hooks/useMergedState.js";
+import useMultipleSelect from "../../_util/hooks/useMultipleSelect.js";
+import { devUseWarning } from "../../_util/warning.js";
+import Checkbox from "../../checkbox/index.js";
+import Dropdown from "../../dropdown/index.js";
+import Radio from "../../radio/index.js";
+const SELECTION_COLUMN = {};
+const SELECTION_ALL = "SELECT_ALL";
+const SELECTION_INVERT = "SELECT_INVERT";
+const SELECTION_NONE = "SELECT_NONE";
+const EMPTY_LIST = [];
+const flattenData = (childrenColumnName, data) => {
+  let list = [];
+  (data || []).forEach((record) => {
+    list.push(record);
+    if (record && typeof record === "object" && childrenColumnName in record) {
+      list = [].concat(_toConsumableArray(list), _toConsumableArray(flattenData(childrenColumnName, record[childrenColumnName])));
+    }
+  });
+  return list;
+};
+const useSelection = (config, rowSelection) => {
   const {
-    preserveSelectedRowKeys: C,
-    selectedRowKeys: K,
-    defaultSelectedRowKeys: Re,
-    getCheckboxProps: V,
-    onChange: Y,
-    onSelect: oe,
-    onSelectAll: le,
-    onSelectInvert: ce,
-    onSelectNone: se,
-    onSelectMultiple: q,
-    columnWidth: Ce,
-    type: O,
-    selections: $,
-    fixed: we,
-    renderCell: ge,
-    hideSelectAll: Ee,
-    checkStrictly: A = !0
-  } = h || {}, {
-    prefixCls: G,
-    data: re,
-    pageData: J,
-    getRecordByKey: g,
-    getRowKey: f,
-    expandType: ke,
-    childrenColumnName: Q,
-    locale: ie,
-    getPopupContainer: ye
-  } = U, W = Qe("Table"), [Me, Z] = Je((n) => n), [z, ae] = qe(K || Re || Ie, {
-    value: K
-  }), F = y.useRef(/* @__PURE__ */ new Map()), Se = B((n) => {
-    if (C) {
-      const l = /* @__PURE__ */ new Map();
-      n.forEach((e) => {
-        let t = g(e);
-        !t && F.current.has(e) && (t = F.current.get(e)), l.set(e, t);
-      }), F.current = l;
+    preserveSelectedRowKeys,
+    selectedRowKeys,
+    defaultSelectedRowKeys,
+    getCheckboxProps,
+    onChange: onSelectionChange,
+    onSelect,
+    onSelectAll,
+    onSelectInvert,
+    onSelectNone,
+    onSelectMultiple,
+    columnWidth: selectionColWidth,
+    type: selectionType,
+    selections,
+    fixed,
+    renderCell: customizeRenderCell,
+    hideSelectAll,
+    checkStrictly = true
+  } = rowSelection || {};
+  const {
+    prefixCls,
+    data,
+    pageData,
+    getRecordByKey,
+    getRowKey,
+    expandType,
+    childrenColumnName,
+    locale: tableLocale,
+    getPopupContainer
+  } = config;
+  const warning = devUseWarning("Table");
+  const [multipleSelect, updatePrevSelectedIndex] = useMultipleSelect((item) => item);
+  const [mergedSelectedKeys, setMergedSelectedKeys] = useMergedState(selectedRowKeys || defaultSelectedRowKeys || EMPTY_LIST, {
+    value: selectedRowKeys
+  });
+  const preserveRecordsRef = React.useRef(/* @__PURE__ */ new Map());
+  const updatePreserveRecordsCache = useCallback((keys) => {
+    if (preserveSelectedRowKeys) {
+      const newCache = /* @__PURE__ */ new Map();
+      keys.forEach((key) => {
+        let record = getRecordByKey(key);
+        if (!record && preserveRecordsRef.current.has(key)) {
+          record = preserveRecordsRef.current.get(key);
+        }
+        newCache.set(key, record);
+      });
+      preserveRecordsRef.current = newCache;
     }
-  }, [g, C]);
-  y.useEffect(() => {
-    Se(z);
-  }, [z]);
-  const S = I(() => Ae(Q, J), [Q, J]), {
-    keyEntities: ee
-  } = I(() => {
-    if (A)
+  }, [getRecordByKey, preserveSelectedRowKeys]);
+  React.useEffect(() => {
+    updatePreserveRecordsCache(mergedSelectedKeys);
+  }, [mergedSelectedKeys]);
+  const flattedData = useMemo(() => flattenData(childrenColumnName, pageData), [childrenColumnName, pageData]);
+  const {
+    keyEntities
+  } = useMemo(() => {
+    if (checkStrictly) {
       return {
         keyEntities: null
       };
-    let n = re;
-    if (C) {
-      const l = new Set(S.map((t, c) => f(t, c))), e = Array.from(F.current).reduce((t, c) => {
-        let [m, v] = c;
-        return l.has(m) ? t : t.concat(v);
+    }
+    let convertData = data;
+    if (preserveSelectedRowKeys) {
+      const keysSet = new Set(flattedData.map((record, index) => getRowKey(record, index)));
+      const preserveRecords = Array.from(preserveRecordsRef.current).reduce((total, _ref) => {
+        let [key, value] = _ref;
+        return keysSet.has(key) ? total : total.concat(value);
       }, []);
-      n = [].concat(L(n), L(e));
+      convertData = [].concat(_toConsumableArray(convertData), _toConsumableArray(preserveRecords));
     }
-    return Ye(n, {
-      externalGetKey: f,
-      childrenPropName: Q
+    return convertDataToEntities(convertData, {
+      externalGetKey: getRowKey,
+      childrenPropName: childrenColumnName
     });
-  }, [re, f, A, Q, C, S]), E = I(() => {
-    const n = /* @__PURE__ */ new Map();
-    return S.forEach((l, e) => {
-      const t = f(l, e), c = (V ? V(l) : null) || {};
-      n.set(t, c), process.env.NODE_ENV !== "production" && W(!("checked" in c || "defaultChecked" in c), "usage", "Do not set `checked` or `defaultChecked` in `getCheckboxProps`. Please use `selectedRowKeys` instead.");
-    }), n;
-  }, [S, f, V]), H = B((n) => {
-    const l = f(n);
-    let e;
-    return E.has(l) ? e = E.get(f(n)) : e = V ? V(n) : void 0, !!(e != null && e.disabled);
-  }, [E, f]), [R, xe] = I(() => {
-    if (A)
-      return [z || [], []];
-    const {
-      checkedKeys: n,
-      halfCheckedKeys: l
-    } = ve(z, !0, ee, H);
-    return [n || [], l];
-  }, [z, A, ee, H]), P = I(() => {
-    const n = O === "radio" ? R.slice(0, 1) : R;
-    return new Set(n);
-  }, [R, O]), be = I(() => O === "radio" ? /* @__PURE__ */ new Set() : new Set(xe), [xe, O]);
-  y.useEffect(() => {
-    h || ae(Ie);
-  }, [!!h]);
-  const T = B((n, l) => {
-    let e, t;
-    Se(n), C ? (e = n, t = n.map((c) => F.current.get(c))) : (e = [], t = [], n.forEach((c) => {
-      const m = g(c);
-      m !== void 0 && (e.push(c), t.push(m));
-    })), ae(e), Y == null || Y(e, t, {
-      type: l
+  }, [data, getRowKey, checkStrictly, childrenColumnName, preserveSelectedRowKeys, flattedData]);
+  const checkboxPropsMap = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    flattedData.forEach((record, index) => {
+      const key = getRowKey(record, index);
+      const checkboxProps = (getCheckboxProps ? getCheckboxProps(record) : null) || {};
+      map.set(key, checkboxProps);
+      process.env.NODE_ENV !== "production" ? warning(!("checked" in checkboxProps || "defaultChecked" in checkboxProps), "usage", "Do not set `checked` or `defaultChecked` in `getCheckboxProps`. Please use `selectedRowKeys` instead.") : void 0;
     });
-  }, [ae, g, Y, C]), te = B((n, l, e, t) => {
-    if (oe) {
-      const c = e.map((m) => g(m));
-      oe(g(n), l, c, t);
+    return map;
+  }, [flattedData, getRowKey, getCheckboxProps]);
+  const isCheckboxDisabled = useCallback((r) => {
+    const rowKey = getRowKey(r);
+    let checkboxProps;
+    if (checkboxPropsMap.has(rowKey)) {
+      checkboxProps = checkboxPropsMap.get(getRowKey(r));
+    } else {
+      checkboxProps = getCheckboxProps ? getCheckboxProps(r) : void 0;
     }
-    T(e, "single");
-  }, [oe, g, T]), de = I(() => !$ || Ee ? null : ($ === !0 ? [Oe, Pe, De] : $).map((l) => l === Oe ? {
-    key: "all",
-    text: ie.selectionAll,
-    onSelect() {
-      T(re.map((e, t) => f(e, t)).filter((e) => {
-        const t = E.get(e);
-        return !(t != null && t.disabled) || P.has(e);
-      }), "all");
+    return !!(checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.disabled);
+  }, [checkboxPropsMap, getRowKey]);
+  const [derivedSelectedKeys, derivedHalfSelectedKeys] = useMemo(() => {
+    if (checkStrictly) {
+      return [mergedSelectedKeys || [], []];
     }
-  } : l === Pe ? {
-    key: "invert",
-    text: ie.selectInvert,
-    onSelect() {
-      const e = new Set(P);
-      J.forEach((c, m) => {
-        const v = f(c, m), X = E.get(v);
-        X != null && X.disabled || (e.has(v) ? e.delete(v) : e.add(v));
+    const {
+      checkedKeys,
+      halfCheckedKeys
+    } = conductCheck(mergedSelectedKeys, true, keyEntities, isCheckboxDisabled);
+    return [checkedKeys || [], halfCheckedKeys];
+  }, [mergedSelectedKeys, checkStrictly, keyEntities, isCheckboxDisabled]);
+  const derivedSelectedKeySet = useMemo(() => {
+    const keys = selectionType === "radio" ? derivedSelectedKeys.slice(0, 1) : derivedSelectedKeys;
+    return new Set(keys);
+  }, [derivedSelectedKeys, selectionType]);
+  const derivedHalfSelectedKeySet = useMemo(() => selectionType === "radio" ? /* @__PURE__ */ new Set() : new Set(derivedHalfSelectedKeys), [derivedHalfSelectedKeys, selectionType]);
+  React.useEffect(() => {
+    if (!rowSelection) {
+      setMergedSelectedKeys(EMPTY_LIST);
+    }
+  }, [!!rowSelection]);
+  const setSelectedKeys = useCallback((keys, method) => {
+    let availableKeys;
+    let records;
+    updatePreserveRecordsCache(keys);
+    if (preserveSelectedRowKeys) {
+      availableKeys = keys;
+      records = keys.map((key) => preserveRecordsRef.current.get(key));
+    } else {
+      availableKeys = [];
+      records = [];
+      keys.forEach((key) => {
+        const record = getRecordByKey(key);
+        if (record !== void 0) {
+          availableKeys.push(key);
+          records.push(record);
+        }
       });
-      const t = Array.from(e);
-      ce && (W.deprecated(!1, "onSelectInvert", "onChange"), ce(t)), T(t, "invert");
     }
-  } : l === De ? {
-    key: "none",
-    text: ie.selectNone,
-    onSelect() {
-      se == null || se(), T(Array.from(P).filter((e) => {
-        const t = E.get(e);
-        return t == null ? void 0 : t.disabled;
-      }), "none");
+    setMergedSelectedKeys(availableKeys);
+    onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange(availableKeys, records, {
+      type: method
+    });
+  }, [setMergedSelectedKeys, getRecordByKey, onSelectionChange, preserveSelectedRowKeys]);
+  const triggerSingleSelection = useCallback((key, selected, keys, event) => {
+    if (onSelect) {
+      const rows = keys.map((k) => getRecordByKey(k));
+      onSelect(getRecordByKey(key), selected, rows, event);
     }
-  } : l).map((l) => Object.assign(Object.assign({}, l), {
-    onSelect: function() {
-      for (var e, t, c = arguments.length, m = new Array(c), v = 0; v < c; v++)
-        m[v] = arguments[v];
-      (t = l.onSelect) === null || t === void 0 || (e = t).call.apply(e, [l].concat(m)), Z(null);
+    setSelectedKeys(keys, "single");
+  }, [onSelect, getRecordByKey, setSelectedKeys]);
+  const mergedSelections = useMemo(() => {
+    if (!selections || hideSelectAll) {
+      return null;
     }
-  })), [$, P, J, f, ce, T]);
-  return [B((n) => {
-    var l;
-    if (!h)
-      return process.env.NODE_ENV !== "production" && W(!n.includes(N), "usage", "`rowSelection` is not config but `SELECTION_COLUMN` exists in the `columns`."), n.filter((o) => o !== N);
-    let e = L(n);
-    const t = new Set(P), c = S.map(f).filter((o) => !E.get(o).disabled), m = c.every((o) => t.has(o)), v = c.some((o) => t.has(o)), X = () => {
-      const o = [];
-      m ? c.forEach((i) => {
-        t.delete(i), o.push(i);
-      }) : c.forEach((i) => {
-        t.has(i) || (t.add(i), o.push(i));
-      });
-      const a = Array.from(t);
-      le == null || le(!m, a.map((i) => g(i)), o.map((i) => g(i))), T(a, "all"), Z(null);
+    const selectionList = selections === true ? [SELECTION_ALL, SELECTION_INVERT, SELECTION_NONE] : selections;
+    return selectionList.map((selection) => {
+      if (selection === SELECTION_ALL) {
+        return {
+          key: "all",
+          text: tableLocale.selectionAll,
+          onSelect() {
+            setSelectedKeys(data.map((record, index) => getRowKey(record, index)).filter((key) => {
+              const checkProps = checkboxPropsMap.get(key);
+              return !(checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled) || derivedSelectedKeySet.has(key);
+            }), "all");
+          }
+        };
+      }
+      if (selection === SELECTION_INVERT) {
+        return {
+          key: "invert",
+          text: tableLocale.selectInvert,
+          onSelect() {
+            const keySet = new Set(derivedSelectedKeySet);
+            pageData.forEach((record, index) => {
+              const key = getRowKey(record, index);
+              const checkProps = checkboxPropsMap.get(key);
+              if (!(checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled)) {
+                if (keySet.has(key)) {
+                  keySet.delete(key);
+                } else {
+                  keySet.add(key);
+                }
+              }
+            });
+            const keys = Array.from(keySet);
+            if (onSelectInvert) {
+              warning.deprecated(false, "onSelectInvert", "onChange");
+              onSelectInvert(keys);
+            }
+            setSelectedKeys(keys, "invert");
+          }
+        };
+      }
+      if (selection === SELECTION_NONE) {
+        return {
+          key: "none",
+          text: tableLocale.selectNone,
+          onSelect() {
+            onSelectNone === null || onSelectNone === void 0 ? void 0 : onSelectNone();
+            setSelectedKeys(Array.from(derivedSelectedKeySet).filter((key) => {
+              const checkProps = checkboxPropsMap.get(key);
+              return checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled;
+            }), "none");
+          }
+        };
+      }
+      return selection;
+    }).map((selection) => Object.assign(Object.assign({}, selection), {
+      onSelect: function() {
+        var _a2;
+        var _a;
+        for (var _len = arguments.length, rest = new Array(_len), _key = 0; _key < _len; _key++) {
+          rest[_key] = arguments[_key];
+        }
+        (_a = selection.onSelect) === null || _a === void 0 ? void 0 : (_a2 = _a).call.apply(_a2, [selection].concat(rest));
+        updatePrevSelectedIndex(null);
+      }
+    }));
+  }, [selections, derivedSelectedKeySet, pageData, getRowKey, onSelectInvert, setSelectedKeys]);
+  const transformColumns = useCallback((columns) => {
+    var _a;
+    if (!rowSelection) {
+      process.env.NODE_ENV !== "production" ? warning(!columns.includes(SELECTION_COLUMN), "usage", "`rowSelection` is not config but `SELECTION_COLUMN` exists in the `columns`.") : void 0;
+      return columns.filter((col) => col !== SELECTION_COLUMN);
+    }
+    let cloneColumns = _toConsumableArray(columns);
+    const keySet = new Set(derivedSelectedKeySet);
+    const recordKeys = flattedData.map(getRowKey).filter((key) => !checkboxPropsMap.get(key).disabled);
+    const checkedCurrentAll = recordKeys.every((key) => keySet.has(key));
+    const checkedCurrentSome = recordKeys.some((key) => keySet.has(key));
+    const onSelectAllChange = () => {
+      const changeKeys = [];
+      if (checkedCurrentAll) {
+        recordKeys.forEach((key) => {
+          keySet.delete(key);
+          changeKeys.push(key);
+        });
+      } else {
+        recordKeys.forEach((key) => {
+          if (!keySet.has(key)) {
+            keySet.add(key);
+            changeKeys.push(key);
+          }
+        });
+      }
+      const keys = Array.from(keySet);
+      onSelectAll === null || onSelectAll === void 0 ? void 0 : onSelectAll(!checkedCurrentAll, keys.map((k) => getRecordByKey(k)), changeKeys.map((k) => getRecordByKey(k)));
+      setSelectedKeys(keys, "all");
+      updatePrevSelectedIndex(null);
     };
-    let Ne, ue;
-    if (O !== "radio") {
-      let o;
-      if (de) {
-        const s = {
-          getPopupContainer: ye,
-          items: de.map((d, r) => {
+    let title;
+    let columnTitleCheckbox;
+    if (selectionType !== "radio") {
+      let customizeSelections;
+      if (mergedSelections) {
+        const menu = {
+          getPopupContainer,
+          items: mergedSelections.map((selection, index) => {
             const {
-              key: x,
-              text: D,
-              onSelect: k
-            } = d;
+              key,
+              text,
+              onSelect: onSelectionClick
+            } = selection;
             return {
-              key: x ?? r,
+              key: key !== null && key !== void 0 ? key : index,
               onClick: () => {
-                k == null || k(c);
+                onSelectionClick === null || onSelectionClick === void 0 ? void 0 : onSelectionClick(recordKeys);
               },
-              label: D
+              label: text
             };
           })
         };
-        o = /* @__PURE__ */ y.createElement("div", {
-          className: `${G}-selection-extra`
-        }, /* @__PURE__ */ y.createElement(Ze, {
-          menu: s,
-          getPopupContainer: ye
-        }, /* @__PURE__ */ y.createElement("span", null, /* @__PURE__ */ y.createElement(Fe, null))));
+        customizeSelections = /* @__PURE__ */ React.createElement("div", {
+          className: `${prefixCls}-selection-extra`
+        }, /* @__PURE__ */ React.createElement(Dropdown, {
+          menu,
+          getPopupContainer
+        }, /* @__PURE__ */ React.createElement("span", null, /* @__PURE__ */ React.createElement(RefIcon, null))));
       }
-      const a = S.map((s, d) => {
-        const r = f(s, d), x = E.get(r) || {};
+      const allDisabledData = flattedData.map((record, index) => {
+        const key = getRowKey(record, index);
+        const checkboxProps = checkboxPropsMap.get(key) || {};
         return Object.assign({
-          checked: t.has(r)
-        }, x);
-      }).filter((s) => {
+          checked: keySet.has(key)
+        }, checkboxProps);
+      }).filter((_ref2) => {
         let {
-          disabled: d
-        } = s;
-        return d;
-      }), i = !!a.length && a.length === S.length, p = i && a.every((s) => {
+          disabled
+        } = _ref2;
+        return disabled;
+      });
+      const allDisabled = !!allDisabledData.length && allDisabledData.length === flattedData.length;
+      const allDisabledAndChecked = allDisabled && allDisabledData.every((_ref3) => {
         let {
-          checked: d
-        } = s;
-        return d;
-      }), u = i && a.some((s) => {
+          checked
+        } = _ref3;
+        return checked;
+      });
+      const allDisabledSomeChecked = allDisabled && allDisabledData.some((_ref4) => {
         let {
-          checked: d
-        } = s;
-        return d;
+          checked
+        } = _ref4;
+        return checked;
+      });
+      columnTitleCheckbox = /* @__PURE__ */ React.createElement(Checkbox, {
+        checked: !allDisabled ? !!flattedData.length && checkedCurrentAll : allDisabledAndChecked,
+        indeterminate: !allDisabled ? !checkedCurrentAll && checkedCurrentSome : !allDisabledAndChecked && allDisabledSomeChecked,
+        onChange: onSelectAllChange,
+        disabled: flattedData.length === 0 || allDisabled,
+        "aria-label": customizeSelections ? "Custom selection" : "Select all",
+        skipGroup: true
       });
-      ue = /* @__PURE__ */ y.createElement(Le, {
-        checked: i ? p : !!S.length && m,
-        indeterminate: i ? !p && u : !m && v,
-        onChange: X,
-        disabled: S.length === 0 || i,
-        "aria-label": o ? "Custom selection" : "Select all",
-        skipGroup: !0
-      }), Ne = !Ee && /* @__PURE__ */ y.createElement("div", {
-        className: `${G}-selection`
-      }, ue, o);
+      title = !hideSelectAll && /* @__PURE__ */ React.createElement("div", {
+        className: `${prefixCls}-selection`
+      }, columnTitleCheckbox, customizeSelections);
     }
-    let fe;
-    O === "radio" ? fe = (o, a, i) => {
-      const p = f(a, i), u = t.has(p), s = E.get(p);
-      return {
-        node: /* @__PURE__ */ y.createElement(et, Object.assign({}, s, {
-          checked: u,
-          onClick: (d) => {
-            var r;
-            d.stopPropagation(), (r = s == null ? void 0 : s.onClick) === null || r === void 0 || r.call(s, d);
-          },
-          onChange: (d) => {
-            var r;
-            t.has(p) || te(p, !0, [p], d.nativeEvent), (r = s == null ? void 0 : s.onChange) === null || r === void 0 || r.call(s, d);
-          }
-        })),
-        checked: u
+    let renderCell;
+    if (selectionType === "radio") {
+      renderCell = (_, record, index) => {
+        const key = getRowKey(record, index);
+        const checked = keySet.has(key);
+        const checkboxProps = checkboxPropsMap.get(key);
+        return {
+          node: /* @__PURE__ */ React.createElement(Radio, Object.assign({}, checkboxProps, {
+            checked,
+            onClick: (e) => {
+              var _a2;
+              e.stopPropagation();
+              (_a2 = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onClick) === null || _a2 === void 0 ? void 0 : _a2.call(checkboxProps, e);
+            },
+            onChange: (event) => {
+              var _a2;
+              if (!keySet.has(key)) {
+                triggerSingleSelection(key, true, [key], event.nativeEvent);
+              }
+              (_a2 = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onChange) === null || _a2 === void 0 ? void 0 : _a2.call(checkboxProps, event);
+            }
+          })),
+          checked
+        };
       };
-    } : fe = (o, a, i) => {
-      var p;
-      const u = f(a, i), s = t.has(u), d = be.has(u), r = E.get(u);
-      let x;
-      return ke === "nest" ? (x = d, process.env.NODE_ENV !== "production" && W(typeof (r == null ? void 0 : r.indeterminate) != "boolean", "usage", "set `indeterminate` using `rowSelection.getCheckboxProps` is not allowed with tree structured dataSource.")) : x = (p = r == null ? void 0 : r.indeterminate) !== null && p !== void 0 ? p : d, {
-        node: /* @__PURE__ */ y.createElement(Le, Object.assign({}, r, {
-          indeterminate: x,
-          checked: s,
-          skipGroup: !0,
-          onClick: (D) => {
-            var k;
-            D.stopPropagation(), (k = r == null ? void 0 : r.onClick) === null || k === void 0 || k.call(r, D);
-          },
-          onChange: (D) => {
-            var k;
-            const {
-              nativeEvent: pe
-            } = D, {
-              shiftKey: Ge
-            } = pe, Ke = c.findIndex((b) => b === u), We = R.some((b) => c.includes(b));
-            if (Ge && A && We) {
-              const b = Me(Ke, c, t), M = Array.from(t);
-              q == null || q(!s, M.map((j) => g(j)), b.map((j) => g(j))), T(M, "multiple");
-            } else {
-              const b = R;
-              if (A) {
-                const M = s ? Xe(b, u) : Be(b, u);
-                te(u, !s, M, pe);
+    } else {
+      renderCell = (_, record, index) => {
+        var _a2;
+        const key = getRowKey(record, index);
+        const checked = keySet.has(key);
+        const indeterminate = derivedHalfSelectedKeySet.has(key);
+        const checkboxProps = checkboxPropsMap.get(key);
+        let mergedIndeterminate;
+        if (expandType === "nest") {
+          mergedIndeterminate = indeterminate;
+          process.env.NODE_ENV !== "production" ? warning(typeof (checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.indeterminate) !== "boolean", "usage", "set `indeterminate` using `rowSelection.getCheckboxProps` is not allowed with tree structured dataSource.") : void 0;
+        } else {
+          mergedIndeterminate = (_a2 = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.indeterminate) !== null && _a2 !== void 0 ? _a2 : indeterminate;
+        }
+        return {
+          node: /* @__PURE__ */ React.createElement(Checkbox, Object.assign({}, checkboxProps, {
+            indeterminate: mergedIndeterminate,
+            checked,
+            skipGroup: true,
+            onClick: (e) => {
+              var _a3;
+              e.stopPropagation();
+              (_a3 = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onClick) === null || _a3 === void 0 ? void 0 : _a3.call(checkboxProps, e);
+            },
+            onChange: (event) => {
+              var _a3;
+              const {
+                nativeEvent
+              } = event;
+              const {
+                shiftKey
+              } = nativeEvent;
+              const currentSelectedIndex = recordKeys.findIndex((item) => item === key);
+              const isMultiple = derivedSelectedKeys.some((item) => recordKeys.includes(item));
+              if (shiftKey && checkStrictly && isMultiple) {
+                const changedKeys = multipleSelect(currentSelectedIndex, recordKeys, keySet);
+                const keys = Array.from(keySet);
+                onSelectMultiple === null || onSelectMultiple === void 0 ? void 0 : onSelectMultiple(!checked, keys.map((recordKey) => getRecordByKey(recordKey)), changedKeys.map((recordKey) => getRecordByKey(recordKey)));
+                setSelectedKeys(keys, "multiple");
               } else {
-                const M = ve([].concat(L(b), [u]), !0, ee, H), {
-                  checkedKeys: j,
-                  halfCheckedKeys: ze
-                } = M;
-                let Te = j;
-                if (s) {
-                  const _e = new Set(j);
-                  _e.delete(u), Te = ve(Array.from(_e), {
-                    halfCheckedKeys: ze
-                  }, ee, H).checkedKeys;
+                const originCheckedKeys = derivedSelectedKeys;
+                if (checkStrictly) {
+                  const checkedKeys = checked ? arrDel(originCheckedKeys, key) : arrAdd(originCheckedKeys, key);
+                  triggerSingleSelection(key, !checked, checkedKeys, nativeEvent);
+                } else {
+                  const result = conductCheck([].concat(_toConsumableArray(originCheckedKeys), [key]), true, keyEntities, isCheckboxDisabled);
+                  const {
+                    checkedKeys,
+                    halfCheckedKeys
+                  } = result;
+                  let nextCheckedKeys = checkedKeys;
+                  if (checked) {
+                    const tempKeySet = new Set(checkedKeys);
+                    tempKeySet.delete(key);
+                    nextCheckedKeys = conductCheck(Array.from(tempKeySet), {
+                      halfCheckedKeys
+                    }, keyEntities, isCheckboxDisabled).checkedKeys;
+                  }
+                  triggerSingleSelection(key, !checked, nextCheckedKeys, nativeEvent);
                 }
-                te(u, !s, Te, pe);
               }
+              if (checked) {
+                updatePrevSelectedIndex(null);
+              } else {
+                updatePrevSelectedIndex(currentSelectedIndex);
+              }
+              (_a3 = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onChange) === null || _a3 === void 0 ? void 0 : _a3.call(checkboxProps, event);
             }
-            Z(s ? null : Ke), (k = r == null ? void 0 : r.onChange) === null || k === void 0 || k.call(r, D);
-          }
-        })),
-        checked: s
+          })),
+          checked
+        };
       };
-    };
-    const je = (o, a, i) => {
+    }
+    const renderSelectionCell = (_, record, index) => {
       const {
-        node: p,
-        checked: u
-      } = fe(o, a, i);
-      return ge ? ge(u, a, i, p) : p;
+        node,
+        checked
+      } = renderCell(_, record, index);
+      if (customizeRenderCell) {
+        return customizeRenderCell(checked, record, index, node);
+      }
+      return node;
     };
-    if (!e.includes(N))
-      if (e.findIndex((o) => {
-        var a;
-        return ((a = o[he]) === null || a === void 0 ? void 0 : a.columnType) === "EXPAND_COLUMN";
+    if (!cloneColumns.includes(SELECTION_COLUMN)) {
+      if (cloneColumns.findIndex((col) => {
+        var _a2;
+        return ((_a2 = col[INTERNAL_COL_DEFINE]) === null || _a2 === void 0 ? void 0 : _a2.columnType) === "EXPAND_COLUMN";
       }) === 0) {
-        const [o, ...a] = e;
-        e = [o, N].concat(L(a));
-      } else
-        e = [N].concat(L(e));
-    const me = e.indexOf(N);
-    process.env.NODE_ENV !== "production" && W(e.filter((o) => o === N).length <= 1, "usage", "Multiple `SELECTION_COLUMN` exist in `columns`."), e = e.filter((o, a) => o !== N || a === me);
-    const _ = e[me - 1], ne = e[me + 1];
-    let w = we;
-    w === void 0 && ((ne == null ? void 0 : ne.fixed) !== void 0 ? w = ne.fixed : (_ == null ? void 0 : _.fixed) !== void 0 && (w = _.fixed)), w && _ && ((l = _[he]) === null || l === void 0 ? void 0 : l.columnType) === "EXPAND_COLUMN" && _.fixed === void 0 && (_.fixed = w);
-    const Ue = He(`${G}-selection-col`, {
-      [`${G}-selection-col-with-dropdown`]: $ && O === "checkbox"
-    }), Ve = () => h != null && h.columnTitle ? typeof h.columnTitle == "function" ? h.columnTitle(ue) : h.columnTitle : Ne, $e = {
-      fixed: w,
-      width: Ce,
-      className: `${G}-selection-column`,
-      title: Ve(),
-      render: je,
-      onCell: h.onCell,
-      [he]: {
-        className: Ue
+        const [expandColumn, ...restColumns] = cloneColumns;
+        cloneColumns = [expandColumn, SELECTION_COLUMN].concat(_toConsumableArray(restColumns));
+      } else {
+        cloneColumns = [SELECTION_COLUMN].concat(_toConsumableArray(cloneColumns));
+      }
+    }
+    const selectionColumnIndex = cloneColumns.indexOf(SELECTION_COLUMN);
+    process.env.NODE_ENV !== "production" ? warning(cloneColumns.filter((col) => col === SELECTION_COLUMN).length <= 1, "usage", "Multiple `SELECTION_COLUMN` exist in `columns`.") : void 0;
+    cloneColumns = cloneColumns.filter((column, index) => column !== SELECTION_COLUMN || index === selectionColumnIndex);
+    const prevCol = cloneColumns[selectionColumnIndex - 1];
+    const nextCol = cloneColumns[selectionColumnIndex + 1];
+    let mergedFixed = fixed;
+    if (mergedFixed === void 0) {
+      if ((nextCol === null || nextCol === void 0 ? void 0 : nextCol.fixed) !== void 0) {
+        mergedFixed = nextCol.fixed;
+      } else if ((prevCol === null || prevCol === void 0 ? void 0 : prevCol.fixed) !== void 0) {
+        mergedFixed = prevCol.fixed;
+      }
+    }
+    if (mergedFixed && prevCol && ((_a = prevCol[INTERNAL_COL_DEFINE]) === null || _a === void 0 ? void 0 : _a.columnType) === "EXPAND_COLUMN" && prevCol.fixed === void 0) {
+      prevCol.fixed = mergedFixed;
+    }
+    const columnCls = classNames(`${prefixCls}-selection-col`, {
+      [`${prefixCls}-selection-col-with-dropdown`]: selections && selectionType === "checkbox"
+    });
+    const renderColumnTitle = () => {
+      if (!(rowSelection === null || rowSelection === void 0 ? void 0 : rowSelection.columnTitle)) {
+        return title;
+      }
+      if (typeof rowSelection.columnTitle === "function") {
+        return rowSelection.columnTitle(columnTitleCheckbox);
+      }
+      return rowSelection.columnTitle;
+    };
+    const selectionColumn = {
+      fixed: mergedFixed,
+      width: selectionColWidth,
+      className: `${prefixCls}-selection-column`,
+      title: renderColumnTitle(),
+      render: renderSelectionCell,
+      onCell: rowSelection.onCell,
+      [INTERNAL_COL_DEFINE]: {
+        className: columnCls
       }
     };
-    return e.map((o) => o === N ? $e : o);
-  }, [f, S, h, R, P, be, Ce, de, ke, E, q, te, H]), P];
+    return cloneColumns.map((col) => col === SELECTION_COLUMN ? selectionColumn : col);
+  }, [getRowKey, flattedData, rowSelection, derivedSelectedKeys, derivedSelectedKeySet, derivedHalfSelectedKeySet, selectionColWidth, mergedSelections, expandType, checkboxPropsMap, onSelectMultiple, triggerSingleSelection, isCheckboxDisabled]);
+  return [transformColumns, derivedSelectedKeySet];
 };
 export {
-  Oe as SELECTION_ALL,
-  N as SELECTION_COLUMN,
-  Pe as SELECTION_INVERT,
-  De as SELECTION_NONE,
-  Et as default
+  SELECTION_ALL,
+  SELECTION_COLUMN,
+  SELECTION_INVERT,
+  SELECTION_NONE,
+  useSelection as default
 };