@rainbow-oh/yee-c 0.8.12 → 0.8.14

package/dist/esm/Table/hooks/useFilter.d.ts

@@ -1,13 +1,19 @@
-type FilterValue = string | number;
+import type { ColumnProps, FilterValue } from '../interface';
 type FilterInput = FilterValue | FilterValue[];
 type FilterOptions = {
     dataIndex: string;
     value: FilterInput;
 };
-export default function useFilter({ data, }: {
+type FilterRecord = {
+    value: FilterInput;
+    dataIndex: string;
+};
+export default function useFilter({ data, columns, }: {
     data: Array<Record<string, unknown>>;
+    columns: ColumnProps[];
 }): {
     data: Record<string, unknown>[];
+    filterRecords: FilterRecord[];
     onFilter: ({ value, dataIndex }: FilterOptions) => void;
 };
 export {};

package/dist/esm/Table/hooks/useFilter.js

@@ -14,7 +14,7 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 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 { useMemo, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 var isEmptyFilterValue = function isEmptyFilterValue(value) {
   return value === '' || Array.isArray(value) && value.length === 0;
 };
@@ -22,52 +22,71 @@ var normalizeValue = function normalizeValue(value) {
   return value === null || value === undefined ? '' : String(value).toLowerCase();
 };
 export default function useFilter(_ref) {
-  var data = _ref.data;
+  var data = _ref.data,
+    columns = _ref.columns;
   var _useState = useState([]),
     _useState2 = _slicedToArray(_useState, 2),
     filterRecords = _useState2[0],
     setFilterRecords = _useState2[1];
-  var onFilter = function onFilter(_ref2) {
-    var value = _ref2.value,
-      dataIndex = _ref2.dataIndex;
-    var newFilterMap = _toConsumableArray(filterRecords);
-    if (isEmptyFilterValue(value)) {
-      newFilterMap = newFilterMap.filter(function (item) {
-        return item.dataIndex !== dataIndex;
+  var columnMap = useMemo(function () {
+    return new Map(columns.flatMap(function (column) {
+      return column.dataIndex ? [[column.dataIndex, column]] : [];
+    }));
+  }, [columns]);
+  useEffect(function () {
+    setFilterRecords(function (current) {
+      var next = current.filter(function (_ref2) {
+        var dataIndex = _ref2.dataIndex;
+        return columnMap.has(dataIndex);
       });
-    } else {
-      var exited = false;
-      newFilterMap = newFilterMap.map(function (item) {
-        if (item.dataIndex === dataIndex) {
-          exited = true;
-          return _objectSpread(_objectSpread({}, item), {}, {
-            value: value
-          });
-        }
-        return item;
+      return next.length === current.length ? current : next;
+    });
+  }, [columnMap]);
+  var onFilter = function onFilter(_ref3) {
+    var value = _ref3.value,
+      dataIndex = _ref3.dataIndex;
+    setFilterRecords(function (current) {
+      if (isEmptyFilterValue(value)) {
+        return current.filter(function (item) {
+          return item.dataIndex !== dataIndex;
+        });
+      }
+      var index = current.findIndex(function (item) {
+        return item.dataIndex === dataIndex;
       });
-      if (!exited) {
-        newFilterMap.push({
+      if (index === -1) {
+        return [].concat(_toConsumableArray(current), [{
           dataIndex: dataIndex,
           value: value
-        });
+        }]);
       }
-    }
-    setFilterRecords(newFilterMap);
+      return current.map(function (item, itemIndex) {
+        return itemIndex === index ? _objectSpread(_objectSpread({}, item), {}, {
+          value: value
+        }) : item;
+      });
+    });
   };
   var filtered = useMemo(function () {
-    var handled = filterRecords.filter(function (_ref3) {
-      var dataIndex = _ref3.dataIndex,
-        value = _ref3.value;
-      return Boolean(dataIndex) && !isEmptyFilterValue(value);
+    var handled = filterRecords.filter(function (_ref4) {
+      var dataIndex = _ref4.dataIndex,
+        value = _ref4.value;
+      return Boolean(dataIndex) && columnMap.has(dataIndex) && !isEmptyFilterValue(value);
     });
     if (!handled.length) {
       return data;
     }
     return data.filter(function (item) {
-      return handled.some(function (_ref4) {
-        var dataIndex = _ref4.dataIndex,
-          value = _ref4.value;
+      return handled.every(function (_ref5) {
+        var _columnMap$get;
+        var dataIndex = _ref5.dataIndex,
+          value = _ref5.value;
+        var customFilter = (_columnMap$get = columnMap.get(dataIndex)) === null || _columnMap$get === void 0 || (_columnMap$get = _columnMap$get.filter) === null || _columnMap$get === void 0 ? void 0 : _columnMap$get.onFilter;
+        if (customFilter) {
+          return Array.isArray(value) ? value.some(function (filterValue) {
+            return customFilter(filterValue, item);
+          }) : customFilter(value, item);
+        }
         var targetValue = normalizeValue(item[dataIndex]);
         if (Array.isArray(value)) {
           return value.some(function (filterValue) {
@@ -77,9 +96,10 @@ export default function useFilter(_ref) {
         return targetValue.includes(normalizeValue(value));
       });
     });
-  }, [data, filterRecords]);
+  }, [columnMap, data, filterRecords]);
   return {
     data: filtered,
+    filterRecords: filterRecords,
     onFilter: onFilter
   };
 }

package/dist/esm/Table/hooks/usePagination.js

@@ -77,16 +77,6 @@ export default function usePagination(_ref) {
       pageSize: pageSize
     });
   };
-  if (pagination === false) {
-    return {
-      pageData: data,
-      current: 1,
-      pageSize: data.length,
-      pagination: false
-    };
-  }
-
-  // eslint-disable-next-line react-hooks/rules-of-hooks
   var pageData = useMemo(function () {
     var total = data.length;
     if (total <= mergedPageSize) return data;
@@ -98,6 +88,14 @@ export default function usePagination(_ref) {
     var start = (current - 1) * mergedPageSize;
     return data.slice(start, start + mergedPageSize);
   }, [data, meregdCurrent, mergedPageSize]);
+  if (pagination === false) {
+    return {
+      pageData: data,
+      current: 1,
+      pageSize: data.length,
+      pagination: false
+    };
+  }
   return {
     pageData: pageData,
     current: meregdCurrent,

package/dist/esm/Table/hooks/useSelection.d.ts

@@ -3,15 +3,15 @@ import type { RowSelectionType, SelectionKeyType } from '../interface';
 export default function useSelection({ pageData, dataSource: data, getRowKey, rowSelection, allKeys, }: {
     pageData: Array<Record<string, unknown>>;
     dataSource: Array<Record<string, unknown>>;
-    getRowKey: (record: Record<string, unknown>) => string;
+    getRowKey: (record: Record<string, unknown>) => SelectionKeyType;
     allKeys: Array<SelectionKeyType>;
     rowSelection?: RowSelectionType;
 }): {
     selectedRowKeys: (string | number)[];
     checkedAll: boolean;
-    pageDataRowKeys: string[];
+    pageDataRowKeys: SelectionKeyType[];
     onCheck: (checked: boolean, key: number | string) => void;
     onCheckAll: (event: ChangeEvent<HTMLInputElement>) => void;
     onRadioCheck: (checked: boolean, key: number | string) => void;
-    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    onChange: (event: ChangeEvent<HTMLInputElement>, key: SelectionKeyType) => void;
 };

package/dist/esm/Table/hooks/useSelection.js

@@ -40,11 +40,20 @@ export default function useSelection(_ref) {
     onChange === null || onChange === void 0 || onChange(rowKeys, rowRecords);
   };
   var getDisabledKeys = function getDisabledKeys() {
+    if (disabled === true) {
+      return pageData.map(function (record) {
+        return getRowKey(record);
+      });
+    }
     if (Array.isArray(disabled)) {
-      return disabled;
+      return pageData.filter(function (_, index) {
+        return disabled[index];
+      }).map(function (record) {
+        return getRowKey(record);
+      });
     }
     if (typeof disabled === 'function') {
-      return Array.isArray(pageData) && pageData.filter(function (record, index) {
+      return pageData.filter(function (record, index) {
         return disabled(record, index);
       }).map(function (record) {
         return getRowKey(record);
@@ -52,13 +61,10 @@ export default function useSelection(_ref) {
     }
     return [];
   };
-  var getPageDataRowKeys = function getPageDataRowKeys() {
-    return Array.isArray(pageData) && pageData.map(function (record) {
-      return getRowKey(record);
-    });
-  };
   var disabledKeys = getDisabledKeys();
-  var pageDataRowKeys = getPageDataRowKeys();
+  var pageDataRowKeys = pageData.map(function (record) {
+    return getRowKey(record);
+  });
   var isCheckedAll = function isCheckedAll() {
     var filtered = pageDataRowKeys.filter(function (key) {
       return !disabledKeys.includes(key);
@@ -93,7 +99,7 @@ export default function useSelection(_ref) {
     });
     setMergedSelectedRowKeys(rowKeys);
     onChange === null || onChange === void 0 || onChange(rowKeys, rowRecords);
-    onSelectAll === null || onSelectAll === void 0 || onSelectAll(rowKeys, rowRecords, checked);
+    onSelectAll === null || onSelectAll === void 0 || onSelectAll(checked, rowKeys, rowRecords);
   };
   var onRadioCheck = function onRadioCheck(checked, key) {
     var record = pageData.find(function (item) {
@@ -102,8 +108,7 @@ export default function useSelection(_ref) {
     setMergedSelectedRowKeys([key]);
     onChange === null || onChange === void 0 || onChange([key], record);
   };
-  var handleChange = function handleChange(event) {
-    var key = event.target.value;
+  var handleChange = function handleChange(event, key) {
     var checked = event.target.checked;
     if (type === 'checkbox') {
       onCheck(checked, key);

package/dist/esm/Table/hooks/useSorter.d.ts

@@ -1,6 +1,9 @@
 import { ColumnProps } from '../interface';
-type SortState = {
-    [dataIndex: string]: 0 | 1 | -1;
+type SortOrder = 1 | -1;
+type SortState = Record<string, SortOrder>;
+type SortChangeResult = {
+    data: Array<Record<string, unknown>>;
+    sorters: SortState;
 };
 export default function useSorter({ data, columns, }: {
     data: Array<Record<string, unknown>>;
@@ -8,6 +11,6 @@ export default function useSorter({ data, columns, }: {
 }): {
     data: Record<string, unknown>[];
     sorters: SortState;
-    onSort: (dataIndex: string) => void;
+    onSort: (dataIndex: string) => SortChangeResult;
 };
 export {};

package/dist/esm/Table/hooks/useSorter.js

@@ -1,122 +1,235 @@
-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 _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 _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; }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 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 _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 _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 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 _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; }
+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 { useCallback, useEffect, useMemo, useState } from 'react';
-export default function useSorter(_ref) {
-  var data = _ref.data,
-    columns = _ref.columns;
-  var getDefaultSorters = useCallback(function () {
-    var sorters = {};
-    columns.forEach(function (column) {
-      var dataIndex = column.dataIndex,
-        sorter = column.sorter;
-      if (!sorter) return;
-      var _ref2 = typeof sorter === 'boolean' ? {} : sorter,
-        defaultSortOrder = _ref2.defaultSortOrder;
-      if (dataIndex && sorter) {
-        if (defaultSortOrder === 'ascend') {
-          sorters[dataIndex] = 1;
-        } else if (defaultSortOrder === 'descend') {
-          sorters[dataIndex] = -1;
-        } else {
-          sorters[dataIndex] = 0;
-        }
-      }
-    });
-    return sorters;
-  }, [columns]);
-  var _useState = useState(getDefaultSorters()),
-    _useState2 = _slicedToArray(_useState, 2),
-    sorters = _useState2[0],
-    setSorters = _useState2[1];
-
-  // when columns changed, reset sorters
-  useEffect(function () {
-    setSorters(getDefaultSorters());
-  }, [getDefaultSorters]);
-
-  // handle sort on column title click
-  var onSort = function onSort(dataIndex) {
-    setSorters(function (prev) {
-      var _newSorters$dataIndex;
-      var newSorters = _objectSpread({}, prev);
-      var currentOrder = (_newSorters$dataIndex = newSorters[dataIndex]) !== null && _newSorters$dataIndex !== void 0 ? _newSorters$dataIndex : 0;
-      if (currentOrder === 0) {
-        newSorters[dataIndex] = 1;
-      } else if (currentOrder === 1) {
-        newSorters[dataIndex] = -1;
-      } else {
-        newSorters[dataIndex] = 0;
-      }
-
-      // is multiple sort
-      var isMultipleSort = undefined;
-      if (isMultipleSort) {} else {
-        Object.keys(newSorters).forEach(function (key) {
-          if (key !== dataIndex) {
-            delete newSorters[key];
-          }
-        });
-      }
-      return newSorters;
+var getSorterConfig = function getSorterConfig(column) {
+  return column && _typeof(column.sorter) === 'object' ? column.sorter : undefined;
+};
+var toSortOrder = function toSortOrder(order) {
+  if (order === 'ascend') return 1;
+  if (order === 'descend') return -1;
+  return 0;
+};
+var getNextSortOrder = function getNextSortOrder(order) {
+  if (order === 0) return 1;
+  if (order === 1) return -1;
+  return 0;
+};
+var isMultipleSorter = function isMultipleSorter(column) {
+  var _getSorterConfig;
+  return Boolean((_getSorterConfig = getSorterConfig(column)) === null || _getSorterConfig === void 0 ? void 0 : _getSorterConfig.multiple);
+};
+var applySortChange = function applySortChange(queue, column, order, columnMap) {
+  var _getSorterConfig2;
+  var dataIndex = column.dataIndex;
+  if (!dataIndex) return queue;
+  if (order === 0) {
+    return queue.filter(function (item) {
+      return item.dataIndex !== dataIndex;
     });
+  }
+  var multiple = (_getSorterConfig2 = getSorterConfig(column)) === null || _getSorterConfig2 === void 0 ? void 0 : _getSorterConfig2.multiple;
+  var nextItem = {
+    dataIndex: dataIndex,
+    order: order
   };
-  var sorted = useMemo(function () {
-    var activeSorters = Object.entries(sorters).filter(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 2),
-        order = _ref4[1];
-      return order !== 0;
-    });
-    if (activeSorters.length === 0) {
-      return data;
+  if (!multiple) {
+    return [nextItem];
+  }
+  var next = queue.filter(function (item) {
+    return item.dataIndex === dataIndex || isMultipleSorter(columnMap.get(item.dataIndex));
+  });
+  var currentIndex = next.findIndex(function (item) {
+    return item.dataIndex === dataIndex;
+  });
+  if (currentIndex === -1) {
+    next.push(nextItem);
+  } else {
+    next[currentIndex] = nextItem;
+  }
+  if (typeof multiple === 'number') {
+    var limit = Math.max(1, Math.floor(multiple));
+    while (next.length > limit) {
+      var removeIndex = next.findIndex(function (item) {
+        return item.dataIndex !== dataIndex;
+      });
+      if (removeIndex === -1) break;
+      next.splice(removeIndex, 1);
     }
-    var sortedData = _toConsumableArray(data).sort(function (a, b) {
-      var _iterator = _createForOfIteratorHelper(activeSorters),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _step$value = _slicedToArray(_step.value, 2),
-            _dataIndex = _step$value[0],
-            order = _step$value[1];
-          var aValue = a[_dataIndex];
-          var bValue = b[_dataIndex];
-
-          // Handle undefined/null values
-          if (aValue === null && bValue === null) continue;
-          if (aValue === null || aValue === undefined) return 1;
-          if (bValue === null || bValue === undefined) return -1;
-
-          // Compare values
-          if (aValue < bValue) {
-            return order === -1 ? 1 : -1;
-          }
-          if (aValue > bValue) {
-            return order === -1 ? -1 : 1;
+  }
+  return next;
+};
+var normalizeQueue = function normalizeQueue(queue, columnMap) {
+  return queue.reduce(function (next, item) {
+    var column = columnMap.get(item.dataIndex);
+    return column ? applySortChange(next, column, item.order, columnMap) : next;
+  }, []);
+};
+var areQueuesEqual = function areQueuesEqual(a, b) {
+  return a.length === b.length && a.every(function (item, index) {
+    var _b$index, _b$index2;
+    return item.dataIndex === ((_b$index = b[index]) === null || _b$index === void 0 ? void 0 : _b$index.dataIndex) && item.order === ((_b$index2 = b[index]) === null || _b$index2 === void 0 ? void 0 : _b$index2.order);
+  });
+};
+var createColumnMap = function createColumnMap(columns) {
+  return new Map(columns.filter(function (column) {
+    return Boolean(column.dataIndex && column.sorter);
+  }).map(function (column) {
+    return [column.dataIndex, column];
+  }));
+};
+var createInitialQueue = function createInitialQueue(columns, columnMap) {
+  return columns.reduce(function (queue, column) {
+    var config = getSorterConfig(column);
+    var order = toSortOrder((config === null || config === void 0 ? void 0 : config.sortOrder) !== undefined ? config.sortOrder : config === null || config === void 0 ? void 0 : config.defaultSortOrder);
+    return order ? applySortChange(queue, column, order, columnMap) : queue;
+  }, []);
+};
+var mergeControlledSorters = function mergeControlledSorters(queue, columns, columnMap) {
+  var controlledOrders = new Map();
+  columns.forEach(function (column) {
+    var config = getSorterConfig(column);
+    if (column.dataIndex && (config === null || config === void 0 ? void 0 : config.sortOrder) !== undefined) {
+      controlledOrders.set(column.dataIndex, toSortOrder(config.sortOrder));
+    }
+  });
+  var uncontrolledQueue = queue.filter(function (item) {
+    return !controlledOrders.has(item.dataIndex);
+  });
+  var controlledQueue = [];
+  queue.forEach(function (item) {
+    var controlledOrder = controlledOrders.get(item.dataIndex);
+    if (controlledOrder === undefined) return;
+    controlledOrders.delete(item.dataIndex);
+    if (controlledOrder) {
+      controlledQueue.push({
+        dataIndex: item.dataIndex,
+        order: controlledOrder
+      });
+    }
+  });
+  columns.forEach(function (column) {
+    var dataIndex = column.dataIndex;
+    if (!dataIndex) return;
+    var controlledOrder = controlledOrders.get(dataIndex);
+    if (controlledOrder) {
+      controlledQueue.push({
+        dataIndex: dataIndex,
+        order: controlledOrder
+      });
+    }
+  });
+  return normalizeQueue([].concat(_toConsumableArray(uncontrolledQueue), controlledQueue), columnMap);
+};
+var queueToSortState = function queueToSortState(queue) {
+  return Object.fromEntries(queue.map(function (_ref) {
+    var dataIndex = _ref.dataIndex,
+      order = _ref.order;
+    return [dataIndex, order];
+  }));
+};
+var compareValues = function compareValues(a, b) {
+  if (Object.is(a, b)) return 0;
+  if (typeof a === 'number' && typeof b === 'number') return a - b;
+  if (typeof a === 'bigint' && typeof b === 'bigint') return a < b ? -1 : 1;
+  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+  if (typeof a === 'boolean' && typeof b === 'boolean') {
+    return Number(a) - Number(b);
+  }
+  return String(a).localeCompare(String(b));
+};
+var sortData = function sortData(data, queue, columnMap) {
+  if (!queue.length) return data;
+  return _toConsumableArray(data).sort(function (a, b) {
+    var _iterator = _createForOfIteratorHelper(queue),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _getSorterConfig3;
+        var _step$value = _step.value,
+          dataIndex = _step$value.dataIndex,
+          order = _step$value.order;
+        var aValue = a[dataIndex];
+        var bValue = b[dataIndex];
+        var compare = (_getSorterConfig3 = getSorterConfig(columnMap.get(dataIndex))) === null || _getSorterConfig3 === void 0 ? void 0 : _getSorterConfig3.sort;
+        if (compare) {
+          var _result = compare(a, b);
+          if (_result !== 0) {
+            return order === -1 ? -_result : _result;
           }
+          continue;
+        }
+        if (aValue === null && bValue === null) continue;
+        if (aValue === null || aValue === undefined) return 1;
+        if (bValue === null || bValue === undefined) return -1;
+        var result = compareValues(aValue, bValue);
+        if (result !== 0) {
+          return order === -1 ? -result : result;
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
       }
-      return 0;
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return 0;
+  });
+};
+export default function useSorter(_ref2) {
+  var data = _ref2.data,
+    columns = _ref2.columns;
+  var columnMap = useMemo(function () {
+    return createColumnMap(columns);
+  }, [columns]);
+  var _useState = useState(function () {
+      return createInitialQueue(columns, columnMap);
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    internalQueue = _useState2[0],
+    setInternalQueue = _useState2[1];
+  useEffect(function () {
+    setInternalQueue(function (current) {
+      var next = normalizeQueue(current, columnMap);
+      return areQueuesEqual(current, next) ? current : next;
     });
-    return sortedData;
-  }, [data, sorters]);
+  }, [columnMap]);
+  var activeQueue = useMemo(function () {
+    return mergeControlledSorters(internalQueue, columns, columnMap);
+  }, [internalQueue, columns, columnMap]);
+  var sorters = useMemo(function () {
+    return queueToSortState(activeQueue);
+  }, [activeQueue]);
+  var sorted = useMemo(function () {
+    return sortData(data, activeQueue, columnMap);
+  }, [data, activeQueue, columnMap]);
+  var onSort = useCallback(function (dataIndex) {
+    var _activeQueue$find$ord, _activeQueue$find;
+    var column = columnMap.get(dataIndex);
+    if (!column) return {
+      data: sorted,
+      sorters: sorters
+    };
+    var currentOrder = (_activeQueue$find$ord = (_activeQueue$find = activeQueue.find(function (item) {
+      return item.dataIndex === dataIndex;
+    })) === null || _activeQueue$find === void 0 ? void 0 : _activeQueue$find.order) !== null && _activeQueue$find$ord !== void 0 ? _activeQueue$find$ord : 0;
+    var nextQueue = applySortChange(activeQueue, column, getNextSortOrder(currentOrder), columnMap);
+    var nextSorters = queueToSortState(nextQueue);
+    var nextData = sortData(data, nextQueue, columnMap);
+    setInternalQueue(nextQueue);
+    return {
+      data: nextData,
+      sorters: nextSorters
+    };
+  }, [activeQueue, columnMap, data, sorted, sorters]);
   return {
     data: sorted,
     sorters: sorters,