@chaoswise/ui 3.0.6 → 3.0.7

package/lib/Antd5/table/hooks/useSelection.js

@@ -0,0 +1,578 @@
+function _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import { useCallback, useMemo } from 'react';
+import DownOutlined from '@ant-design/icons/DownOutlined';
+import classNames from 'classnames';
+import { INTERNAL_COL_DEFINE } from 'rc-table';
+import { arrAdd, arrDel } from 'rc-tree/lib/util';
+import { conductCheck } from 'rc-tree/lib/utils/conductUtil';
+import { convertDataToEntities } from 'rc-tree/lib/utils/treeUtil';
+import useMergedState from 'rc-util/lib/hooks/useMergedState';
+import useMultipleSelect from '../../_util/hooks/useMultipleSelect';
+import { devUseWarning } from '../../_util/warning';
+import Checkbox from '../../checkbox';
+import Dropdown from '../../dropdown';
+import Radio from '../../radio';
+// TODO: warning if use ajax!!!
+export var SELECTION_COLUMN = {};
+export var SELECTION_ALL = 'SELECT_ALL';
+export var SELECTION_INVERT = 'SELECT_INVERT';
+export var SELECTION_NONE = 'SELECT_NONE';
+var EMPTY_LIST = [];
+var flattenData = function flattenData(childrenColumnName, data) {
+  var list = [];
+  (data || []).forEach(function (record) {
+    list.push(record);
+    if (record && _typeof(record) === 'object' && childrenColumnName in record) {
+      list = [].concat(_toConsumableArray(list), _toConsumableArray(flattenData(childrenColumnName, record[childrenColumnName])));
+    }
+  });
+  return list;
+};
+var useSelection = function useSelection(config, rowSelection) {
+  var _ref = rowSelection || {},
+    preserveSelectedRowKeys = _ref.preserveSelectedRowKeys,
+    selectedRowKeys = _ref.selectedRowKeys,
+    defaultSelectedRowKeys = _ref.defaultSelectedRowKeys,
+    getCheckboxProps = _ref.getCheckboxProps,
+    onSelectionChange = _ref.onChange,
+    onSelect = _ref.onSelect,
+    onSelectAll = _ref.onSelectAll,
+    onSelectInvert = _ref.onSelectInvert,
+    onSelectNone = _ref.onSelectNone,
+    onSelectMultiple = _ref.onSelectMultiple,
+    selectionColWidth = _ref.columnWidth,
+    selectionType = _ref.type,
+    selections = _ref.selections,
+    fixed = _ref.fixed,
+    customizeRenderCell = _ref.renderCell,
+    hideSelectAll = _ref.hideSelectAll,
+    _ref$checkStrictly = _ref.checkStrictly,
+    checkStrictly = _ref$checkStrictly === void 0 ? true : _ref$checkStrictly;
+  var prefixCls = config.prefixCls,
+    data = config.data,
+    pageData = config.pageData,
+    getRecordByKey = config.getRecordByKey,
+    getRowKey = config.getRowKey,
+    expandType = config.expandType,
+    childrenColumnName = config.childrenColumnName,
+    tableLocale = config.locale,
+    getPopupContainer = config.getPopupContainer;
+  var warning = devUseWarning('Table');
+  // ========================= MultipleSelect =========================
+  var _useMultipleSelect = useMultipleSelect(function (item) {
+      return item;
+    }),
+    _useMultipleSelect2 = _slicedToArray(_useMultipleSelect, 2),
+    multipleSelect = _useMultipleSelect2[0],
+    updatePrevSelectedIndex = _useMultipleSelect2[1];
+  // ========================= Keys =========================
+  var _useMergedState = useMergedState(selectedRowKeys || defaultSelectedRowKeys || EMPTY_LIST, {
+      value: selectedRowKeys
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    mergedSelectedKeys = _useMergedState2[0],
+    setMergedSelectedKeys = _useMergedState2[1];
+  // ======================== Caches ========================
+  var preserveRecordsRef = React.useRef(new Map());
+  var updatePreserveRecordsCache = useCallback(function (keys) {
+    if (preserveSelectedRowKeys) {
+      var newCache = new Map();
+      // Keep key if mark as preserveSelectedRowKeys
+      keys.forEach(function (key) {
+        var record = getRecordByKey(key);
+        if (!record && preserveRecordsRef.current.has(key)) {
+          record = preserveRecordsRef.current.get(key);
+        }
+        newCache.set(key, record);
+      });
+      // Refresh to new cache
+      preserveRecordsRef.current = newCache;
+    }
+  }, [getRecordByKey, preserveSelectedRowKeys]);
+  // Update cache with selectedKeys
+  React.useEffect(function () {
+    updatePreserveRecordsCache(mergedSelectedKeys);
+  }, [mergedSelectedKeys]);
+  var _useMemo = useMemo(function () {
+      if (checkStrictly) {
+        return {
+          keyEntities: null
+        };
+      }
+      var convertData = data;
+      if (preserveSelectedRowKeys) {
+        var keysSet = new Set(data.map(function (record, index) {
+          return getRowKey(record, index);
+        }));
+        // remove preserveRecords that duplicate data
+        var preserveRecords = Array.from(preserveRecordsRef.current).reduce(function (total, _ref2) {
+          var _ref3 = _slicedToArray(_ref2, 2),
+            key = _ref3[0],
+            value = _ref3[1];
+          return keysSet.has(key) ? total : total.concat(value);
+        }, []);
+        convertData = [].concat(_toConsumableArray(convertData), _toConsumableArray(preserveRecords));
+      }
+      return convertDataToEntities(convertData, {
+        externalGetKey: getRowKey,
+        childrenPropName: childrenColumnName
+      });
+    }, [data, getRowKey, checkStrictly, childrenColumnName, preserveSelectedRowKeys]),
+    keyEntities = _useMemo.keyEntities;
+  // Get flatten data
+  var flattedData = useMemo(function () {
+    return flattenData(childrenColumnName, pageData);
+  }, [childrenColumnName, pageData]);
+  // Get all checkbox props
+  var checkboxPropsMap = useMemo(function () {
+    var map = new Map();
+    flattedData.forEach(function (record, index) {
+      var key = getRowKey(record, index);
+      var checkboxProps = (getCheckboxProps ? getCheckboxProps(record) : null) || {};
+      map.set(key, checkboxProps);
+      warning(!('checked' in checkboxProps || 'defaultChecked' in checkboxProps), 'usage', 'Do not set `checked` or `defaultChecked` in `getCheckboxProps`. Please use `selectedRowKeys` instead.');
+    });
+    return map;
+  }, [flattedData, getRowKey, getCheckboxProps]);
+  var isCheckboxDisabled = useCallback(function (r) {
+    var _checkboxPropsMap$get;
+    return !!((_checkboxPropsMap$get = checkboxPropsMap.get(getRowKey(r))) !== null && _checkboxPropsMap$get !== void 0 && _checkboxPropsMap$get.disabled);
+  }, [checkboxPropsMap, getRowKey]);
+  var _useMemo2 = useMemo(function () {
+      if (checkStrictly) {
+        return [mergedSelectedKeys || [], []];
+      }
+      var _conductCheck = conductCheck(mergedSelectedKeys, true, keyEntities, isCheckboxDisabled),
+        checkedKeys = _conductCheck.checkedKeys,
+        halfCheckedKeys = _conductCheck.halfCheckedKeys;
+      return [checkedKeys || [], halfCheckedKeys];
+    }, [mergedSelectedKeys, checkStrictly, keyEntities, isCheckboxDisabled]),
+    _useMemo3 = _slicedToArray(_useMemo2, 2),
+    derivedSelectedKeys = _useMemo3[0],
+    derivedHalfSelectedKeys = _useMemo3[1];
+  var derivedSelectedKeySet = useMemo(function () {
+    var keys = selectionType === 'radio' ? derivedSelectedKeys.slice(0, 1) : derivedSelectedKeys;
+    return new Set(keys);
+  }, [derivedSelectedKeys, selectionType]);
+  var derivedHalfSelectedKeySet = useMemo(function () {
+    return selectionType === 'radio' ? new Set() : new Set(derivedHalfSelectedKeys);
+  }, [derivedHalfSelectedKeys, selectionType]);
+  // Reset if rowSelection reset
+  React.useEffect(function () {
+    if (!rowSelection) {
+      setMergedSelectedKeys(EMPTY_LIST);
+    }
+  }, [!!rowSelection]);
+  var setSelectedKeys = useCallback(function (keys, method) {
+    var availableKeys;
+    var records;
+    updatePreserveRecordsCache(keys);
+    if (preserveSelectedRowKeys) {
+      availableKeys = keys;
+      records = keys.map(function (key) {
+        return preserveRecordsRef.current.get(key);
+      });
+    } else {
+      // Filter key which not exist in the `dataSource`
+      availableKeys = [];
+      records = [];
+      keys.forEach(function (key) {
+        var record = getRecordByKey(key);
+        if (record !== undefined) {
+          availableKeys.push(key);
+          records.push(record);
+        }
+      });
+    }
+    setMergedSelectedKeys(availableKeys);
+    onSelectionChange === null || onSelectionChange === void 0 || onSelectionChange(availableKeys, records, {
+      type: method
+    });
+  }, [setMergedSelectedKeys, getRecordByKey, onSelectionChange, preserveSelectedRowKeys]);
+  // ====================== Selections ======================
+  // Trigger single `onSelect` event
+  var triggerSingleSelection = useCallback(function (key, selected, keys, event) {
+    if (onSelect) {
+      var rows = keys.map(function (k) {
+        return getRecordByKey(k);
+      });
+      onSelect(getRecordByKey(key), selected, rows, event);
+    }
+    setSelectedKeys(keys, 'single');
+  }, [onSelect, getRecordByKey, setSelectedKeys]);
+  var mergedSelections = useMemo(function () {
+    if (!selections || hideSelectAll) {
+      return null;
+    }
+    var selectionList = selections === true ? [SELECTION_ALL, SELECTION_INVERT, SELECTION_NONE] : selections;
+    return selectionList.map(function (selection) {
+      if (selection === SELECTION_ALL) {
+        return {
+          key: 'all',
+          text: tableLocale.selectionAll,
+          onSelect: function onSelect() {
+            setSelectedKeys(data.map(function (record, index) {
+              return getRowKey(record, index);
+            }).filter(function (key) {
+              var checkProps = checkboxPropsMap.get(key);
+              return !(checkProps !== null && checkProps !== void 0 && checkProps.disabled) || derivedSelectedKeySet.has(key);
+            }), 'all');
+          }
+        };
+      }
+      if (selection === SELECTION_INVERT) {
+        return {
+          key: 'invert',
+          text: tableLocale.selectInvert,
+          onSelect: function onSelect() {
+            var keySet = new Set(derivedSelectedKeySet);
+            pageData.forEach(function (record, index) {
+              var key = getRowKey(record, index);
+              var checkProps = checkboxPropsMap.get(key);
+              if (!(checkProps !== null && checkProps !== void 0 && checkProps.disabled)) {
+                if (keySet.has(key)) {
+                  keySet["delete"](key);
+                } else {
+                  keySet.add(key);
+                }
+              }
+            });
+            var 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: function onSelect() {
+            onSelectNone === null || onSelectNone === void 0 || onSelectNone();
+            setSelectedKeys(Array.from(derivedSelectedKeySet).filter(function (key) {
+              var checkProps = checkboxPropsMap.get(key);
+              return checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled;
+            }), 'none');
+          }
+        };
+      }
+      return selection;
+    }).map(function (selection) {
+      return _objectSpread(_objectSpread({}, selection), {}, {
+        onSelect: function onSelect() {
+          var _selection$onSelect;
+          for (var _len = arguments.length, rest = new Array(_len), _key = 0; _key < _len; _key++) {
+            rest[_key] = arguments[_key];
+          }
+          (_selection$onSelect = selection.onSelect) === null || _selection$onSelect === void 0 || _selection$onSelect.call.apply(_selection$onSelect, [selection].concat(rest));
+          updatePrevSelectedIndex(null);
+        }
+      });
+    });
+  }, [selections, derivedSelectedKeySet, pageData, getRowKey, onSelectInvert, setSelectedKeys]);
+  // ======================= Columns ========================
+  var transformColumns = useCallback(function (columns) {
+    var _prevCol$INTERNAL_COL;
+    // >>>>>>>>>>> Skip if not exists `rowSelection`
+    if (!rowSelection) {
+      warning(!columns.includes(SELECTION_COLUMN), 'usage', '`rowSelection` is not config but `SELECTION_COLUMN` exists in the `columns`.');
+      return columns.filter(function (col) {
+        return col !== SELECTION_COLUMN;
+      });
+    }
+    // >>>>>>>>>>> Support selection
+    var cloneColumns = _toConsumableArray(columns);
+    var keySet = new Set(derivedSelectedKeySet);
+    // Record key only need check with enabled
+    var recordKeys = flattedData.map(getRowKey).filter(function (key) {
+      return !checkboxPropsMap.get(key).disabled;
+    });
+    var checkedCurrentAll = recordKeys.every(function (key) {
+      return keySet.has(key);
+    });
+    var checkedCurrentSome = recordKeys.some(function (key) {
+      return keySet.has(key);
+    });
+    var onSelectAllChange = function onSelectAllChange() {
+      var changeKeys = [];
+      if (checkedCurrentAll) {
+        recordKeys.forEach(function (key) {
+          keySet["delete"](key);
+          changeKeys.push(key);
+        });
+      } else {
+        recordKeys.forEach(function (key) {
+          if (!keySet.has(key)) {
+            keySet.add(key);
+            changeKeys.push(key);
+          }
+        });
+      }
+      var keys = Array.from(keySet);
+      onSelectAll === null || onSelectAll === void 0 || onSelectAll(!checkedCurrentAll, keys.map(function (k) {
+        return getRecordByKey(k);
+      }), changeKeys.map(function (k) {
+        return getRecordByKey(k);
+      }));
+      setSelectedKeys(keys, 'all');
+      updatePrevSelectedIndex(null);
+    };
+    // ===================== Render =====================
+    // Title Cell
+    var title;
+    var columnTitleCheckbox;
+    if (selectionType !== 'radio') {
+      var customizeSelections;
+      if (mergedSelections) {
+        var menu = {
+          getPopupContainer: getPopupContainer,
+          items: mergedSelections.map(function (selection, index) {
+            var key = selection.key,
+              text = selection.text,
+              onSelectionClick = selection.onSelect;
+            return {
+              key: key !== null && key !== void 0 ? key : index,
+              onClick: function onClick() {
+                onSelectionClick === null || onSelectionClick === void 0 || onSelectionClick(recordKeys);
+              },
+              label: text
+            };
+          })
+        };
+        customizeSelections = _jsx("div", {
+          className: "".concat(prefixCls, "-selection-extra"),
+          children: _jsx(Dropdown, {
+            menu: menu,
+            getPopupContainer: getPopupContainer,
+            children: _jsx("span", {
+              children: _jsx(DownOutlined, {})
+            })
+          })
+        });
+      }
+      var allDisabledData = flattedData.map(function (record, index) {
+        var key = getRowKey(record, index);
+        var checkboxProps = checkboxPropsMap.get(key) || {};
+        return _objectSpread({
+          checked: keySet.has(key)
+        }, checkboxProps);
+      }).filter(function (_ref4) {
+        var disabled = _ref4.disabled;
+        return disabled;
+      });
+      var allDisabled = !!allDisabledData.length && allDisabledData.length === flattedData.length;
+      var allDisabledAndChecked = allDisabled && allDisabledData.every(function (_ref5) {
+        var checked = _ref5.checked;
+        return checked;
+      });
+      var allDisabledSomeChecked = allDisabled && allDisabledData.some(function (_ref6) {
+        var checked = _ref6.checked;
+        return checked;
+      });
+      columnTitleCheckbox = _jsx(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
+      });
+      title = !hideSelectAll && _jsxs("div", {
+        className: "".concat(prefixCls, "-selection"),
+        children: [columnTitleCheckbox, customizeSelections]
+      });
+    }
+    // Body Cell
+    var renderCell;
+    if (selectionType === 'radio') {
+      renderCell = function renderCell(_, record, index) {
+        var key = getRowKey(record, index);
+        var checked = keySet.has(key);
+        return {
+          node: _jsx(Radio, _objectSpread(_objectSpread({}, checkboxPropsMap.get(key)), {}, {
+            checked: checked,
+            onClick: function onClick(e) {
+              return e.stopPropagation();
+            },
+            onChange: function onChange(event) {
+              if (!keySet.has(key)) {
+                triggerSingleSelection(key, true, [key], event.nativeEvent);
+              }
+            }
+          })),
+          checked: checked
+        };
+      };
+    } else {
+      renderCell = function renderCell(_, record, index) {
+        var key = getRowKey(record, index);
+        var checked = keySet.has(key);
+        var indeterminate = derivedHalfSelectedKeySet.has(key);
+        var checkboxProps = checkboxPropsMap.get(key);
+        var mergedIndeterminate;
+        if (expandType === 'nest') {
+          mergedIndeterminate = indeterminate;
+          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.');
+        } else {
+          var _checkboxProps$indete;
+          mergedIndeterminate = (_checkboxProps$indete = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.indeterminate) !== null && _checkboxProps$indete !== void 0 ? _checkboxProps$indete : indeterminate;
+        }
+        // Record checked
+        return {
+          node: _jsx(Checkbox, _objectSpread(_objectSpread({}, checkboxProps), {}, {
+            indeterminate: mergedIndeterminate,
+            checked: checked,
+            skipGroup: true,
+            onClick: function onClick(e) {
+              return e.stopPropagation();
+            },
+            onChange: function onChange(_ref7) {
+              var nativeEvent = _ref7.nativeEvent;
+              var shiftKey = nativeEvent.shiftKey;
+              var currentSelectedIndex = recordKeys.findIndex(function (item) {
+                return item === key;
+              });
+              var isMultiple = derivedSelectedKeys.some(function (item) {
+                return recordKeys.includes(item);
+              });
+              if (shiftKey && checkStrictly && isMultiple) {
+                var changedKeys = multipleSelect(currentSelectedIndex, recordKeys, keySet);
+                var keys = Array.from(keySet);
+                onSelectMultiple === null || onSelectMultiple === void 0 || onSelectMultiple(!checked, keys.map(function (recordKey) {
+                  return getRecordByKey(recordKey);
+                }), changedKeys.map(function (recordKey) {
+                  return getRecordByKey(recordKey);
+                }));
+                setSelectedKeys(keys, 'multiple');
+              } else {
+                // Single record selected
+                var originCheckedKeys = derivedSelectedKeys;
+                if (checkStrictly) {
+                  var checkedKeys = checked ? arrDel(originCheckedKeys, key) : arrAdd(originCheckedKeys, key);
+                  triggerSingleSelection(key, !checked, checkedKeys, nativeEvent);
+                } else {
+                  // Always fill first
+                  var result = conductCheck([].concat(_toConsumableArray(originCheckedKeys), [key]), true, keyEntities, isCheckboxDisabled);
+                  var _checkedKeys = result.checkedKeys,
+                    halfCheckedKeys = result.halfCheckedKeys;
+                  var nextCheckedKeys = _checkedKeys;
+                  // If remove, we do it again to correction
+                  if (checked) {
+                    var tempKeySet = new Set(_checkedKeys);
+                    tempKeySet["delete"](key);
+                    nextCheckedKeys = conductCheck(Array.from(tempKeySet), {
+                      checked: false,
+                      halfCheckedKeys: halfCheckedKeys
+                    }, keyEntities, isCheckboxDisabled).checkedKeys;
+                  }
+                  triggerSingleSelection(key, !checked, nextCheckedKeys, nativeEvent);
+                }
+              }
+              if (checked) {
+                updatePrevSelectedIndex(null);
+              } else {
+                updatePrevSelectedIndex(currentSelectedIndex);
+              }
+            }
+          })),
+          checked: checked
+        };
+      };
+    }
+    var renderSelectionCell = function renderSelectionCell(_, record, index) {
+      var _renderCell = renderCell(_, record, index),
+        node = _renderCell.node,
+        checked = _renderCell.checked;
+      if (customizeRenderCell) {
+        return customizeRenderCell(checked, record, index, node);
+      }
+      return node;
+    };
+    // Insert selection column if not exist
+    if (!cloneColumns.includes(SELECTION_COLUMN)) {
+      // Always after expand icon
+      if (cloneColumns.findIndex(function (col) {
+        var _col$INTERNAL_COL_DEF;
+        return ((_col$INTERNAL_COL_DEF = col[INTERNAL_COL_DEFINE]) === null || _col$INTERNAL_COL_DEF === void 0 ? void 0 : _col$INTERNAL_COL_DEF.columnType) === 'EXPAND_COLUMN';
+      }) === 0) {
+        var _cloneColumns = cloneColumns,
+          _cloneColumns2 = _toArray(_cloneColumns),
+          expandColumn = _cloneColumns2[0],
+          restColumns = _cloneColumns2.slice(1);
+        cloneColumns = [expandColumn, SELECTION_COLUMN].concat(_toConsumableArray(restColumns));
+      } else {
+        // Normal insert at first column
+        cloneColumns = [SELECTION_COLUMN].concat(_toConsumableArray(cloneColumns));
+      }
+    }
+    // Deduplicate selection column
+    var selectionColumnIndex = cloneColumns.indexOf(SELECTION_COLUMN);
+    warning(cloneColumns.filter(function (col) {
+      return col === SELECTION_COLUMN;
+    }).length <= 1, 'usage', 'Multiple `SELECTION_COLUMN` exist in `columns`.');
+    cloneColumns = cloneColumns.filter(function (column, index) {
+      return column !== SELECTION_COLUMN || index === selectionColumnIndex;
+    });
+    // Fixed column logic
+    var prevCol = cloneColumns[selectionColumnIndex - 1];
+    var nextCol = cloneColumns[selectionColumnIndex + 1];
+    var mergedFixed = fixed;
+    if (mergedFixed === undefined) {
+      if ((nextCol === null || nextCol === void 0 ? void 0 : nextCol.fixed) !== undefined) {
+        mergedFixed = nextCol.fixed;
+      } else if ((prevCol === null || prevCol === void 0 ? void 0 : prevCol.fixed) !== undefined) {
+        mergedFixed = prevCol.fixed;
+      }
+    }
+    if (mergedFixed && prevCol && ((_prevCol$INTERNAL_COL = prevCol[INTERNAL_COL_DEFINE]) === null || _prevCol$INTERNAL_COL === void 0 ? void 0 : _prevCol$INTERNAL_COL.columnType) === 'EXPAND_COLUMN' && prevCol.fixed === undefined) {
+      prevCol.fixed = mergedFixed;
+    }
+    var columnCls = classNames("".concat(prefixCls, "-selection-col"), _defineProperty({}, "".concat(prefixCls, "-selection-col-with-dropdown"), selections && selectionType === 'checkbox'));
+    var renderColumnTitle = function renderColumnTitle() {
+      if (!(rowSelection !== null && rowSelection !== void 0 && rowSelection.columnTitle)) {
+        return title;
+      }
+      if (typeof rowSelection.columnTitle === 'function') {
+        return rowSelection.columnTitle(columnTitleCheckbox);
+      }
+      return rowSelection.columnTitle;
+    };
+    // Replace with real selection column
+    var selectionColumn = _defineProperty({
+      fixed: mergedFixed,
+      width: selectionColWidth,
+      className: "".concat(prefixCls, "-selection-column"),
+      title: renderColumnTitle(),
+      render: renderSelectionCell,
+      onCell: rowSelection.onCell
+    }, INTERNAL_COL_DEFINE, {
+      className: columnCls
+    });
+    return cloneColumns.map(function (col) {
+      return col === SELECTION_COLUMN ? selectionColumn : col;
+    });
+  }, [getRowKey, flattedData, rowSelection, derivedSelectedKeys, derivedSelectedKeySet, derivedHalfSelectedKeySet, selectionColWidth, mergedSelections, expandType, checkboxPropsMap, onSelectMultiple, triggerSingleSelection, isCheckboxDisabled]);
+  return [transformColumns, derivedSelectedKeySet];
+};
+export default useSelection;