@dtjoy/dt-design 1.1.2 → 1.1.5

package/es/table/features/selection/useSelection.js

@@ -0,0 +1,579 @@
+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); }
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+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(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+import { useCallback, useMemo } from 'react';
+import DownOutlined from '@ant-design/icons/DownOutlined';
+import { INTERNAL_COL_DEFINE } from "../../shared/utils/legacyUtil";
+import { conductCheck } from 'rc-tree/lib/utils/conductUtil';
+import { convertDataToEntities } from 'rc-tree/lib/utils/treeUtil';
+import { useControlledState } from "../../../_util/rcUtil";
+import { clsx } from 'clsx';
+import { useMultipleSelect } from "../../../_util/hooks/useMultipleSelect";
+import { isFunction, isPlainObject } from "../../../_util/is";
+import { devUseWarning } from "../../../_util/warning";
+import Checkbox from 'antd/lib/checkbox';
+import Dropdown from 'antd/lib/dropdown';
+import Radio from 'antd/lib/radio';
+function arrAdd(list, value) {
+  var clone = list.slice();
+  var index = clone.indexOf(value);
+  if (index === -1) {
+    clone.push(value);
+  }
+  return clone;
+}
+function arrDel(list, value) {
+  var clone = list.slice();
+  var index = clone.indexOf(value);
+  if (index !== -1) {
+    clone.splice(index, 1);
+  }
+  return clone;
+}
+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 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  (data || []).forEach(function (record) {
+    list.push(record);
+    if (isPlainObject(record) && childrenColumnName in record) {
+      flattenData(childrenColumnName, record[childrenColumnName], list);
+    }
+  });
+  return list;
+};
+var useSelection = function useSelection(config, rowSelection) {
+  var _ref = rowSelection || {},
+    preserveSelectedRowKeys = _ref.preserveSelectedRowKeys,
+    selectedRowKeys = _ref.selectedRowKeys,
+    defaultSelectedRowKeys = _ref.defaultSelectedRowKeys,
+    getCheckboxProps = _ref.getCheckboxProps,
+    getTitleCheckboxProps = _ref.getTitleCheckboxProps,
+    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');
+  var _useMultipleSelect = useMultipleSelect(function (item) {
+      return item;
+    }),
+    _useMultipleSelect2 = _slicedToArray(_useMultipleSelect, 2),
+    multipleSelect = _useMultipleSelect2[0],
+    updatePrevSelectedIndex = _useMultipleSelect2[1];
+  var _ref2 = useControlledState(defaultSelectedRowKeys || EMPTY_LIST, {
+      value: selectedRowKeys
+    }),
+    _ref3 = _slicedToArray(_ref2, 2),
+    mergedSelectedKeys = _ref3[0],
+    setMergedSelectedKeys = _ref3[1];
+  var mergedSelectedKeyList = mergedSelectedKeys !== null && mergedSelectedKeys !== void 0 ? mergedSelectedKeys : EMPTY_LIST;
+  var preserveRecordsRef = React.useRef(new Map());
+  var updatePreserveRecordsCache = useCallback(function (keys) {
+    if (preserveSelectedRowKeys) {
+      var newCache = new Map();
+      keys.forEach(function (key) {
+        var record = getRecordByKey(key);
+        if (!record && preserveRecordsRef.current.has(key)) {
+          record = preserveRecordsRef.current.get(key);
+        }
+        newCache.set(key, record);
+      });
+      preserveRecordsRef.current = newCache;
+    }
+  }, [getRecordByKey, preserveSelectedRowKeys]);
+  React.useEffect(function () {
+    updatePreserveRecordsCache(mergedSelectedKeyList);
+  }, [mergedSelectedKeyList, updatePreserveRecordsCache]);
+  var flattedData = useMemo(function () {
+    return flattenData(childrenColumnName, pageData);
+  }, [childrenColumnName, pageData]);
+  var _useMemo = useMemo(function () {
+      if (checkStrictly) {
+        return {
+          keyEntities: null
+        };
+      }
+      var convertData = data;
+      if (preserveSelectedRowKeys) {
+        var keysSet = new Set(flattedData.map(getRowKey));
+        var preserveRecords = Array.from(preserveRecordsRef.current).reduce(function (total, _ref4) {
+          var _ref5 = _slicedToArray(_ref4, 2),
+            key = _ref5[0],
+            value = _ref5[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, flattedData]),
+    keyEntities = _useMemo.keyEntities;
+  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 _checkboxProps;
+    var rowKey = getRowKey(r);
+    var checkboxProps;
+    if (checkboxPropsMap.has(rowKey)) {
+      checkboxProps = checkboxPropsMap.get(getRowKey(r));
+    } else {
+      checkboxProps = getCheckboxProps ? getCheckboxProps(r) : undefined;
+    }
+    return !!((_checkboxProps = checkboxProps) !== null && _checkboxProps !== void 0 && _checkboxProps.disabled);
+  }, [checkboxPropsMap, getRowKey]);
+  var _useMemo2 = useMemo(function () {
+      if (checkStrictly) {
+        return [mergedSelectedKeyList, []];
+      }
+      var _conductCheck = conductCheck(mergedSelectedKeyList, true, keyEntities, isCheckboxDisabled),
+        checkedKeys = _conductCheck.checkedKeys,
+        halfCheckedKeys = _conductCheck.halfCheckedKeys;
+      return [checkedKeys || [], halfCheckedKeys];
+    }, [mergedSelectedKeyList, 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]);
+  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 {
+      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]);
+  var triggerSingleSelection = useCallback(function (key, selected, keys, event) {
+    if (onSelect) {
+      var rows = keys.map(getRecordByKey);
+      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) {
+      var mergedSelection;
+      if (selection === SELECTION_ALL) {
+        mergedSelection = {
+          key: 'all',
+          text: tableLocale.selectionAll,
+          onSelect: function onSelect() {
+            setSelectedKeys(data.reduce(function (keys, record, index) {
+              var key = getRowKey(record, index);
+              var checkProps = checkboxPropsMap.get(key);
+              if (!(checkProps !== null && checkProps !== void 0 && checkProps.disabled) || derivedSelectedKeySet.has(key)) {
+                keys.push(key);
+              }
+              return keys;
+            }, []), 'all');
+          }
+        };
+      } else if (selection === SELECTION_INVERT) {
+        mergedSelection = {
+          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');
+          }
+        };
+      } else if (selection === SELECTION_NONE) {
+        mergedSelection = {
+          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');
+          }
+        };
+      } else {
+        mergedSelection = selection;
+      }
+      return _objectSpread(_objectSpread({}, mergedSelection), {}, {
+        onSelect: function onSelect(currentRowKeys) {
+          var _mergedSelection$onSe, _mergedSelection;
+          (_mergedSelection$onSe = (_mergedSelection = mergedSelection).onSelect) === null || _mergedSelection$onSe === void 0 || _mergedSelection$onSe.call(_mergedSelection, currentRowKeys);
+          updatePrevSelectedIndex(null);
+        }
+      });
+    });
+  }, [selections, hideSelectAll, tableLocale.selectionAll, tableLocale.selectInvert, tableLocale.selectNone, checkboxPropsMap, derivedSelectedKeySet, data, pageData, getRowKey, onSelectInvert, setSelectedKeys]);
+  var transformColumns = useCallback(function (columns) {
+    var _prevCol$INTERNAL_COL;
+    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;
+      });
+    }
+    var cloneColumns = _toConsumableArray(columns);
+    var keySet = new Set(derivedSelectedKeySet);
+    var recordKeys = flattedData.reduce(function (keys, record, index) {
+      var key = getRowKey(record, index);
+      if (!checkboxPropsMap.get(key).disabled) {
+        keys.push(key);
+      }
+      return keys;
+    }, []);
+    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(getRecordByKey), changeKeys.map(getRecordByKey));
+      setSelectedKeys(keys, 'all');
+      updatePrevSelectedIndex(null);
+    };
+    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 = /*#__PURE__*/React.createElement("div", {
+          className: "".concat(prefixCls, "-selection-extra")
+        }, /*#__PURE__*/React.createElement(Dropdown, {
+          menu: menu,
+          getPopupContainer: getPopupContainer
+        }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(DownOutlined, null))));
+      }
+      var allDisabledData = flattedData.reduce(function (list, record, index) {
+        var key = getRowKey(record, index);
+        var checkboxProps = checkboxPropsMap.get(key) || {};
+        var item = _objectSpread({
+          checked: keySet.has(key)
+        }, checkboxProps);
+        if (item.disabled) {
+          list.push(item);
+        }
+        return list;
+      }, []);
+      var allDisabled = !!allDisabledData.length && allDisabledData.length === flattedData.length;
+      var allDisabledAndChecked = allDisabled && allDisabledData.every(function (_ref6) {
+        var checked = _ref6.checked;
+        return checked;
+      });
+      var allDisabledSomeChecked = allDisabled && allDisabledData.some(function (_ref7) {
+        var checked = _ref7.checked;
+        return checked;
+      });
+      var customCheckboxProps = (getTitleCheckboxProps === null || getTitleCheckboxProps === void 0 ? void 0 : getTitleCheckboxProps()) || {};
+      var _onChange = customCheckboxProps.onChange,
+        disabled = customCheckboxProps.disabled;
+      columnTitleCheckbox = /*#__PURE__*/React.createElement(Checkbox, _extends({
+        "aria-label": customizeSelections ? 'Custom selection' : 'Select all'
+      }, customCheckboxProps, {
+        checked: !allDisabled ? !!flattedData.length && checkedCurrentAll : allDisabledAndChecked,
+        indeterminate: !allDisabled ? !checkedCurrentAll && checkedCurrentSome : !allDisabledAndChecked && allDisabledSomeChecked,
+        onChange: function onChange(e) {
+          onSelectAllChange();
+          _onChange === null || _onChange === void 0 || _onChange(e);
+        },
+        disabled: disabled !== null && disabled !== void 0 ? disabled : flattedData.length === 0 || allDisabled,
+        skipGroup: true
+      }));
+      title = !hideSelectAll && /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-selection")
+      }, columnTitleCheckbox, customizeSelections);
+    }
+    var renderCell;
+    if (selectionType === 'radio') {
+      renderCell = function renderCell(_, record, index) {
+        var key = getRowKey(record, index);
+        var checked = keySet.has(key);
+        var checkboxProps = checkboxPropsMap.get(key);
+        var defaultAriaLabel = "Select row ".concat(index + 1);
+        return {
+          node: /*#__PURE__*/React.createElement(Radio, _extends({
+            "aria-label": defaultAriaLabel
+          }, checkboxProps, {
+            checked: checked,
+            onClick: function onClick(e) {
+              var _checkboxProps$onClic;
+              e.stopPropagation();
+              checkboxProps === null || checkboxProps === void 0 || (_checkboxProps$onClic = checkboxProps.onClick) === null || _checkboxProps$onClic === void 0 || _checkboxProps$onClic.call(checkboxProps, e);
+            },
+            onChange: function onChange(event) {
+              var _checkboxProps$onChan;
+              if (!keySet.has(key)) {
+                triggerSingleSelection(key, true, [key], event.nativeEvent);
+              }
+              checkboxProps === null || checkboxProps === void 0 || (_checkboxProps$onChan = checkboxProps.onChange) === null || _checkboxProps$onChan === void 0 || _checkboxProps$onChan.call(checkboxProps, event);
+            }
+          })),
+          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;
+        }
+        var defaultAriaLabel = checked ? "Row ".concat(index + 1, " selected") : "Select row ".concat(index + 1);
+        return {
+          node: /*#__PURE__*/React.createElement(Checkbox, _extends({
+            "aria-label": defaultAriaLabel
+          }, checkboxProps, {
+            indeterminate: mergedIndeterminate,
+            checked: checked,
+            skipGroup: true,
+            onClick: function onClick(e) {
+              var _checkboxProps$onClic2;
+              e.stopPropagation();
+              checkboxProps === null || checkboxProps === void 0 || (_checkboxProps$onClic2 = checkboxProps.onClick) === null || _checkboxProps$onClic2 === void 0 || _checkboxProps$onClic2.call(checkboxProps, e);
+            },
+            onChange: function onChange(event) {
+              var _checkboxProps$onChan2;
+              var nativeEvent = event.nativeEvent;
+              var shiftKey = nativeEvent.shiftKey;
+              var currentSelectedIndex = recordKeys.indexOf(key);
+              var isMultiple = derivedSelectedKeySet.size > 0 && recordKeys.some(function (key) {
+                return derivedSelectedKeySet.has(key);
+              });
+              if (shiftKey && checkStrictly && isMultiple) {
+                var changedKeys = multipleSelect(currentSelectedIndex, recordKeys, keySet);
+                var keys = Array.from(keySet);
+                onSelectMultiple === null || onSelectMultiple === void 0 || onSelectMultiple(!checked, keys.map(getRecordByKey), changedKeys.map(getRecordByKey));
+                setSelectedKeys(keys, 'multiple');
+              } else {
+                var originCheckedKeys = derivedSelectedKeys;
+                if (checkStrictly) {
+                  var checkedKeys = checked ? arrDel(originCheckedKeys, key) : arrAdd(originCheckedKeys, key);
+                  triggerSingleSelection(key, !checked, checkedKeys, nativeEvent);
+                } else {
+                  var result = conductCheck([].concat(_toConsumableArray(originCheckedKeys), [key]), true, keyEntities, isCheckboxDisabled);
+                  var _checkedKeys = result.checkedKeys,
+                    halfCheckedKeys = result.halfCheckedKeys;
+                  var nextCheckedKeys = _checkedKeys;
+                  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);
+              }
+              checkboxProps === null || checkboxProps === void 0 || (_checkboxProps$onChan2 = checkboxProps.onChange) === null || _checkboxProps$onChan2 === void 0 || _checkboxProps$onChan2.call(checkboxProps, event);
+            }
+          })),
+          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;
+    };
+    if (!cloneColumns.includes(SELECTION_COLUMN)) {
+      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 {
+        cloneColumns = [SELECTION_COLUMN].concat(_toConsumableArray(cloneColumns));
+      }
+    }
+    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;
+    });
+    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 = clsx("".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 (isFunction(rowSelection.columnTitle)) {
+        return rowSelection.columnTitle(columnTitleCheckbox);
+      }
+      return rowSelection.columnTitle;
+    };
+    var selectionColumn = _defineProperty({
+      fixed: mergedFixed,
+      width: selectionColWidth,
+      className: "".concat(prefixCls, "-selection-column"),
+      title: renderColumnTitle(),
+      render: renderSelectionCell,
+      onCell: rowSelection.onCell,
+      align: rowSelection.align
+    }, 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;

package/es/table/features/sort/index.d.ts

@@ -0,0 +1 @@
+export { getSortData, default as useSorter } from './useSorter';

package/es/table/features/sort/index.js

@@ -0,0 +1 @@
+export { getSortData, default as useSorter } from "./useSorter";

package/es/table/features/sort/useSorter.d.ts

@@ -0,0 +1,21 @@
+import type { AnyObject } from '../../../_util/type';
+import type { ColumnsType, ColumnTitleProps, ColumnType, Key, SorterResult, SorterTooltipProps, SortOrder, TableLocale, TransformColumns } from '../../interface';
+export interface SortState<RecordType = AnyObject> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    sortOrder: SortOrder | null;
+    multiplePriority: number | false;
+}
+export declare const getSortData: <RecordType extends AnyObject = AnyObject>(data: readonly RecordType[], sortStates: SortState<RecordType>[], childrenColumnName: string) => RecordType[];
+interface SorterConfig<RecordType = AnyObject> {
+    prefixCls: string;
+    mergedColumns: ColumnsType<RecordType>;
+    baseColumns?: ColumnsType<RecordType>;
+    onSorterChange: (sorterResult: SorterResult<RecordType> | SorterResult<RecordType>[], sortStates: SortState<RecordType>[]) => void;
+    sortDirections: SortOrder[];
+    tableLocale?: TableLocale;
+    showSorterTooltip?: boolean | SorterTooltipProps;
+    globalLocale?: any;
+}
+declare const useFilterSorter: <RecordType extends AnyObject = AnyObject>(props: SorterConfig<RecordType>) => [TransformColumns<RecordType>, SortState<RecordType>[], ColumnTitleProps<RecordType>, () => SorterResult<RecordType> | SorterResult<RecordType>[]];
+export default useFilterSorter;