@dtjoy/dt-design 1.1.1 → 1.1.5

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

@@ -0,0 +1,372 @@
+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 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 _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 _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; }
+import * as React from 'react';
+import CaretDownOutlined from '@ant-design/icons/CaretDownOutlined';
+import CaretUpOutlined from '@ant-design/icons/CaretUpOutlined';
+import { KeyCode } from "../../../_util/rcUtil";
+import { clsx } from 'clsx';
+import { isFunction, isNumber, isPlainObject } from "../../../_util/is";
+import Tooltip from 'antd/lib/tooltip';
+import { getColumnKey, getColumnPos, renderColumnTitle, safeColumnTitle } from "../../shared/utils/util";
+var ASCEND = 'ascend';
+var DESCEND = 'descend';
+var getMultiplePriority = function getMultiplePriority(column) {
+  if (isPlainObject(column.sorter) && isNumber(column.sorter.multiple)) {
+    return column.sorter.multiple;
+  }
+  return false;
+};
+var getSortFunction = function getSortFunction(sorter) {
+  if (isFunction(sorter)) {
+    return sorter;
+  }
+  if (isPlainObject(sorter) && sorter.compare) {
+    return sorter.compare;
+  }
+  return false;
+};
+var nextSortDirection = function nextSortDirection(sortDirections, current) {
+  if (!current) {
+    return sortDirections[0];
+  }
+  return sortDirections[sortDirections.indexOf(current) + 1];
+};
+var collectSortStates = function collectSortStates(columns, init, pos) {
+  var sortStates = [];
+  var pushState = function pushState(column, columnPos) {
+    sortStates.push({
+      column: column,
+      key: getColumnKey(column, columnPos),
+      multiplePriority: getMultiplePriority(column),
+      sortOrder: column.sortOrder
+    });
+  };
+  (columns || []).forEach(function (column, index) {
+    var columnPos = getColumnPos(index, pos);
+    if (column.children) {
+      if ('sortOrder' in column) {
+        pushState(column, columnPos);
+      }
+      sortStates = [].concat(_toConsumableArray(sortStates), _toConsumableArray(collectSortStates(column.children, init, columnPos)));
+    } else if (column.sorter) {
+      if ('sortOrder' in column) {
+        pushState(column, columnPos);
+      } else if (init && column.defaultSortOrder) {
+        sortStates.push({
+          column: column,
+          key: getColumnKey(column, columnPos),
+          multiplePriority: getMultiplePriority(column),
+          sortOrder: column.defaultSortOrder
+        });
+      }
+    }
+  });
+  return sortStates;
+};
+var injectSorter = function injectSorter(prefixCls, columns, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, pos, a11yLocale) {
+  var finalColumns = (columns || []).map(function (column, index) {
+    var columnPos = getColumnPos(index, pos);
+    var newColumn = column;
+    if (newColumn.sorter) {
+      var sortDirections = newColumn.sortDirections || defaultSortDirections;
+      var showSorterTooltip = newColumn.showSorterTooltip === undefined ? tableShowSorterTooltip : newColumn.showSorterTooltip;
+      var columnKey = getColumnKey(newColumn, columnPos);
+      var sorterState = sorterStates.find(function (_ref) {
+        var key = _ref.key;
+        return key === columnKey;
+      });
+      var sortOrder = sorterState ? sorterState.sortOrder : null;
+      var nextSortOrder = nextSortDirection(sortDirections, sortOrder);
+      var sorter;
+      if (column.sortIcon) {
+        sorter = column.sortIcon({
+          sortOrder: sortOrder
+        });
+      } else {
+        var upNode = sortDirections.includes(ASCEND) && /*#__PURE__*/React.createElement(CaretUpOutlined, {
+          className: clsx("".concat(prefixCls, "-column-sorter-up"), {
+            active: sortOrder === ASCEND
+          })
+        });
+        var downNode = sortDirections.includes(DESCEND) && /*#__PURE__*/React.createElement(CaretDownOutlined, {
+          className: clsx("".concat(prefixCls, "-column-sorter-down"), {
+            active: sortOrder === DESCEND
+          })
+        });
+        sorter = /*#__PURE__*/React.createElement("span", {
+          className: clsx("".concat(prefixCls, "-column-sorter"), _defineProperty({}, "".concat(prefixCls, "-column-sorter-full"), !!(upNode && downNode)))
+        }, /*#__PURE__*/React.createElement("span", {
+          className: "".concat(prefixCls, "-column-sorter-inner"),
+          "aria-hidden": "true"
+        }, upNode, downNode));
+      }
+      var _ref2 = tableLocale || {},
+        cancelSort = _ref2.cancelSort,
+        triggerAsc = _ref2.triggerAsc,
+        triggerDesc = _ref2.triggerDesc;
+      var sortTip = cancelSort;
+      if (nextSortOrder === DESCEND) {
+        sortTip = triggerDesc;
+      } else if (nextSortOrder === ASCEND) {
+        sortTip = triggerAsc;
+      }
+      var tooltipProps = isPlainObject(showSorterTooltip) ? _objectSpread({
+        title: sortTip
+      }, showSorterTooltip) : {
+        title: sortTip
+      };
+      newColumn = _objectSpread(_objectSpread({}, newColumn), {}, {
+        className: clsx(newColumn.className, _defineProperty({}, "".concat(prefixCls, "-column-sort"), sortOrder)),
+        title: function title(renderProps) {
+          var columnSortersClass = "".concat(prefixCls, "-column-sorters");
+          var renderColumnTitleWrapper = /*#__PURE__*/React.createElement("span", {
+            className: "".concat(prefixCls, "-column-title")
+          }, renderColumnTitle(column.title, renderProps));
+          var renderSortTitle = /*#__PURE__*/React.createElement("div", {
+            className: columnSortersClass
+          }, renderColumnTitleWrapper, sorter);
+          if (showSorterTooltip) {
+            if (typeof showSorterTooltip !== 'boolean' && (showSorterTooltip === null || showSorterTooltip === void 0 ? void 0 : showSorterTooltip.target) === 'sorter-icon') {
+              return /*#__PURE__*/React.createElement("div", {
+                className: clsx(columnSortersClass, "".concat(columnSortersClass, "-tooltip-target-sorter"))
+              }, renderColumnTitleWrapper, /*#__PURE__*/React.createElement(Tooltip, tooltipProps, sorter));
+            }
+            return /*#__PURE__*/React.createElement(Tooltip, tooltipProps, renderSortTitle);
+          }
+          return renderSortTitle;
+        },
+        onHeaderCell: function onHeaderCell(col) {
+          var _column$onHeaderCell;
+          var cell = ((_column$onHeaderCell = column.onHeaderCell) === null || _column$onHeaderCell === void 0 ? void 0 : _column$onHeaderCell.call(column, col)) || {};
+          var originOnClick = cell.onClick;
+          var originOKeyDown = cell.onKeyDown;
+          cell.onClick = function (event) {
+            triggerSorter({
+              column: column,
+              key: columnKey,
+              sortOrder: nextSortOrder,
+              multiplePriority: getMultiplePriority(column)
+            });
+            originOnClick === null || originOnClick === void 0 || originOnClick(event);
+          };
+          cell.onKeyDown = function (event) {
+            if (event.keyCode === KeyCode.ENTER) {
+              triggerSorter({
+                column: column,
+                key: columnKey,
+                sortOrder: nextSortOrder,
+                multiplePriority: getMultiplePriority(column)
+              });
+              originOKeyDown === null || originOKeyDown === void 0 || originOKeyDown(event);
+            }
+          };
+          var renderTitle = safeColumnTitle(column.title, {});
+          var displayTitle = renderTitle === null || renderTitle === void 0 ? void 0 : renderTitle.toString();
+          if (sortOrder) {
+            cell['aria-sort'] = sortOrder === 'ascend' ? 'ascending' : 'descending';
+          }
+          cell['aria-label'] = displayTitle || '';
+          cell.className = clsx(cell.className, "".concat(prefixCls, "-column-has-sorters"));
+          cell.tabIndex = 0;
+          if (column.ellipsis) {
+            cell.title = (renderTitle !== null && renderTitle !== void 0 ? renderTitle : '').toString();
+          }
+          return cell;
+        }
+      });
+    }
+    if ('children' in newColumn) {
+      newColumn = _objectSpread(_objectSpread({}, newColumn), {}, {
+        children: injectSorter(prefixCls, newColumn.children, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, columnPos, a11yLocale)
+      });
+    }
+    return newColumn;
+  });
+  return finalColumns;
+};
+var stateToInfo = function stateToInfo(sorterState) {
+  var column = sorterState.column,
+    sortOrder = sorterState.sortOrder;
+  return {
+    column: column,
+    order: sortOrder,
+    field: column.dataIndex,
+    columnKey: column.key
+  };
+};
+var generateSorterInfo = function generateSorterInfo(sorterStates) {
+  var activeSorters = sorterStates.reduce(function (list, sorterState) {
+    if (sorterState.sortOrder) {
+      list.push(stateToInfo(sorterState));
+    }
+    return list;
+  }, []);
+  if (activeSorters.length === 0 && sorterStates.length) {
+    var lastIndex = sorterStates.length - 1;
+    return _objectSpread(_objectSpread({}, stateToInfo(sorterStates[lastIndex])), {}, {
+      column: undefined,
+      order: undefined,
+      field: undefined,
+      columnKey: undefined
+    });
+  }
+  if (activeSorters.length <= 1) {
+    return activeSorters[0] || {};
+  }
+  return activeSorters;
+};
+export var getSortData = function getSortData(data, sortStates, childrenColumnName) {
+  var innerSorterStates = sortStates.slice().sort(function (a, b) {
+    return b.multiplePriority - a.multiplePriority;
+  });
+  var cloneData = data.slice();
+  var runningSorters = innerSorterStates.filter(function (_ref3) {
+    var sorter = _ref3.column.sorter,
+      sortOrder = _ref3.sortOrder;
+    return getSortFunction(sorter) && sortOrder;
+  });
+  if (!runningSorters.length) {
+    return cloneData;
+  }
+  return cloneData.sort(function (record1, record2) {
+    for (var i = 0; i < runningSorters.length; i += 1) {
+      var sorterState = runningSorters[i];
+      var sorter = sorterState.column.sorter,
+        sortOrder = sorterState.sortOrder;
+      var compareFn = getSortFunction(sorter);
+      if (compareFn && sortOrder) {
+        var compareResult = compareFn(record1, record2, sortOrder);
+        if (compareResult !== 0) {
+          return sortOrder === ASCEND ? compareResult : -compareResult;
+        }
+      }
+    }
+    return 0;
+  }).map(function (record) {
+    var subRecords = record[childrenColumnName];
+    if (subRecords) {
+      return _objectSpread(_objectSpread({}, record), {}, _defineProperty({}, childrenColumnName, getSortData(subRecords, sortStates, childrenColumnName)));
+    }
+    return record;
+  });
+};
+var useFilterSorter = function useFilterSorter(props) {
+  var prefixCls = props.prefixCls,
+    mergedColumns = props.mergedColumns,
+    baseColumns = props.baseColumns,
+    sortDirections = props.sortDirections,
+    tableLocale = props.tableLocale,
+    showSorterTooltip = props.showSorterTooltip,
+    onSorterChange = props.onSorterChange,
+    globalLocale = props.globalLocale;
+  var collectColumns = baseColumns !== null && baseColumns !== void 0 ? baseColumns : mergedColumns;
+  var _React$useState = React.useState(function () {
+      return collectSortStates(collectColumns, true);
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    sortStates = _React$useState2[0],
+    setSortStates = _React$useState2[1];
+  var getColumnKeys = function getColumnKeys(columns, pos) {
+    var newKeys = [];
+    columns.forEach(function (item, index) {
+      var columnPos = getColumnPos(index, pos);
+      newKeys.push(getColumnKey(item, columnPos));
+      if (Array.isArray(item.children)) {
+        var childKeys = getColumnKeys(item.children, columnPos);
+        newKeys.push.apply(newKeys, _toConsumableArray(childKeys));
+      }
+    });
+    return newKeys;
+  };
+  var mergedSorterStates = React.useMemo(function () {
+    var validate = true;
+    var collectedStates = collectSortStates(collectColumns, false);
+    if (!collectedStates.length) {
+      var collectColumnsKeys = getColumnKeys(collectColumns);
+      return sortStates.filter(function (_ref4) {
+        var key = _ref4.key;
+        return collectColumnsKeys.includes(key);
+      });
+    }
+    var validateStates = [];
+    function patchStates(state) {
+      if (validate) {
+        validateStates.push(state);
+      } else {
+        validateStates.push(_objectSpread(_objectSpread({}, state), {}, {
+          sortOrder: null
+        }));
+      }
+    }
+    var multipleMode = null;
+    collectedStates.forEach(function (state) {
+      if (multipleMode === null) {
+        patchStates(state);
+        if (state.sortOrder) {
+          if (state.multiplePriority === false) {
+            validate = false;
+          } else {
+            multipleMode = true;
+          }
+        }
+      } else if (multipleMode && state.multiplePriority !== false) {
+        patchStates(state);
+      } else {
+        validate = false;
+        patchStates(state);
+      }
+    });
+    return validateStates;
+  }, [collectColumns, sortStates]);
+  var columnTitleSorterProps = React.useMemo(function () {
+    var _sortColumns$, _sortColumns$2;
+    var sortColumns = mergedSorterStates.map(function (_ref5) {
+      var column = _ref5.column,
+        sortOrder = _ref5.sortOrder;
+      return {
+        column: column,
+        order: sortOrder
+      };
+    });
+    return {
+      sortColumns: sortColumns,
+      sortColumn: (_sortColumns$ = sortColumns[0]) === null || _sortColumns$ === void 0 ? void 0 : _sortColumns$.column,
+      sortOrder: (_sortColumns$2 = sortColumns[0]) === null || _sortColumns$2 === void 0 ? void 0 : _sortColumns$2.order
+    };
+  }, [mergedSorterStates]);
+  var triggerSorter = function triggerSorter(sortState) {
+    var newSorterStates;
+    if (sortState.multiplePriority === false || !mergedSorterStates.length || mergedSorterStates[0].multiplePriority === false) {
+      newSorterStates = [sortState];
+    } else {
+      newSorterStates = [].concat(_toConsumableArray(mergedSorterStates.filter(function (_ref6) {
+        var key = _ref6.key;
+        return key !== sortState.key;
+      })), [sortState]);
+    }
+    setSortStates(newSorterStates);
+    onSorterChange(generateSorterInfo(newSorterStates), newSorterStates);
+  };
+  var transformColumns = function transformColumns(innerColumns) {
+    return injectSorter(prefixCls, innerColumns, mergedSorterStates, triggerSorter, sortDirections, tableLocale, showSorterTooltip, undefined, globalLocale);
+  };
+  var getSorters = function getSorters() {
+    return generateSorterInfo(mergedSorterStates);
+  };
+  return [transformColumns, mergedSorterStates, columnTitleSorterProps, getSorters];
+};
+export default useFilterSorter;

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

@@ -0,0 +1,2 @@
+export { default as stickyScrollBar } from './stickyScrollBar';
+export { default as useSticky } from './useSticky';

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

@@ -0,0 +1,2 @@
+export { default as stickyScrollBar } from "./stickyScrollBar";
+export { default as useSticky } from "./useSticky";

package/es/table/features/sticky/stickyScrollBar.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+interface StickyScrollBarProps {
+    scrollBodyRef: React.RefObject<HTMLDivElement>;
+    onScroll: (params: {
+        scrollLeft?: number;
+    }) => void;
+    offsetScroll: number;
+    container: HTMLElement | Window;
+    direction: string;
+}
+declare const _default: React.ForwardRefExoticComponent<StickyScrollBarProps & React.RefAttributes<unknown>>;
+export default _default;

package/es/table/features/sticky/stickyScrollBar.js

@@ -0,0 +1,203 @@
+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 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; }
+import { useContext } from "../../../_util/context";
+import { clsx } from 'clsx';
+import { getDOM } from 'rc-util/lib/Dom/findDOMNode';
+import getScrollBarSize from 'rc-util/lib/getScrollBarSize';
+import raf from 'rc-util/lib/raf';
+import * as React from 'react';
+import TableContext from "../../shared/context/TableContext";
+import { useLayoutState } from "../virtual/useFrame";
+import { getOffset } from "../fixed/offsetUtil";
+var MOUSEUP_EVENT = 'mouseup';
+var MOUSEMOVE_EVENT = 'mousemove';
+var SCROLL_EVENT = 'scroll';
+var RESIZE_EVENT = 'resize';
+var StickyScrollBar = function StickyScrollBar(props, ref) {
+  var _scrollBodyRef$curren, _scrollBodyRef$curren2;
+  var scrollBodyRef = props.scrollBodyRef,
+    onScroll = props.onScroll,
+    offsetScroll = props.offsetScroll,
+    container = props.container,
+    direction = props.direction;
+  var prefixCls = useContext(TableContext, 'prefixCls');
+  var bodyScrollWidth = ((_scrollBodyRef$curren = scrollBodyRef.current) === null || _scrollBodyRef$curren === void 0 ? void 0 : _scrollBodyRef$curren.scrollWidth) || 0;
+  var bodyWidth = ((_scrollBodyRef$curren2 = scrollBodyRef.current) === null || _scrollBodyRef$curren2 === void 0 ? void 0 : _scrollBodyRef$curren2.clientWidth) || 0;
+  var scrollBarWidth = bodyScrollWidth && bodyWidth * (bodyWidth / bodyScrollWidth);
+  var scrollBarRef = React.useRef(null);
+  var _useLayoutState = useLayoutState({
+      scrollLeft: 0,
+      isHiddenScrollBar: true
+    }),
+    _useLayoutState2 = _slicedToArray(_useLayoutState, 2),
+    scrollState = _useLayoutState2[0],
+    setScrollState = _useLayoutState2[1];
+  var refState = React.useRef({
+    delta: 0,
+    x: 0
+  });
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isActive = _React$useState2[0],
+    setActive = _React$useState2[1];
+  var rafRef = React.useRef(null);
+  React.useEffect(function () {
+    return function () {
+      if (rafRef.current) {
+        raf.cancel(rafRef.current);
+      }
+    };
+  }, []);
+  var onMouseUp = function onMouseUp() {
+    setActive(false);
+  };
+  var onMouseDown = function onMouseDown(event) {
+    event.persist();
+    refState.current.delta = event.pageX - scrollState.scrollLeft;
+    refState.current.x = 0;
+    setActive(true);
+    event.preventDefault();
+  };
+  var onMouseMove = function onMouseMove(event) {
+    var _window;
+    // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
+    var _ref = event || ((_window = window) === null || _window === void 0 ? void 0 : _window.event),
+      buttons = _ref.buttons;
+    if (!isActive || buttons === 0) {
+      // If out body mouse up, we can set isActive false when mouse move
+      if (isActive) {
+        setActive(false);
+      }
+      return;
+    }
+    var left = refState.current.x + event.pageX - refState.current.x - refState.current.delta;
+    var isRTL = direction === 'rtl';
+    // Limit scroll range
+    left = Math.max(isRTL ? scrollBarWidth - bodyWidth : 0, Math.min(isRTL ? 0 : bodyWidth - scrollBarWidth, left));
+    // Calculate the scroll position and update
+    var shouldScroll = !isRTL || Math.abs(left) + Math.abs(scrollBarWidth) < bodyWidth;
+    if (shouldScroll) {
+      onScroll({
+        scrollLeft: left / bodyWidth * (bodyScrollWidth + 2)
+      });
+      refState.current.x = event.pageX;
+    }
+  };
+  var checkScrollBarVisible = function checkScrollBarVisible() {
+    if (rafRef.current) {
+      raf.cancel(rafRef.current);
+    }
+    rafRef.current = raf(function () {
+      if (!scrollBodyRef.current) {
+        return;
+      }
+      var tableOffsetTop = getOffset(scrollBodyRef.current).top;
+      var tableBottomOffset = tableOffsetTop + scrollBodyRef.current.offsetHeight;
+      var currentClientOffset = container === window ? document.documentElement.scrollTop + window.innerHeight : getOffset(container).top + container.clientHeight;
+      if (tableBottomOffset - getScrollBarSize() <= currentClientOffset || tableOffsetTop >= currentClientOffset - offsetScroll) {
+        setScrollState(function (state) {
+          return _objectSpread(_objectSpread({}, state), {}, {
+            isHiddenScrollBar: true
+          });
+        });
+      } else {
+        setScrollState(function (state) {
+          return _objectSpread(_objectSpread({}, state), {}, {
+            isHiddenScrollBar: false
+          });
+        });
+      }
+    });
+  };
+  var setScrollLeft = function setScrollLeft(left) {
+    setScrollState(function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        scrollLeft: left / bodyScrollWidth * bodyWidth || 0
+      });
+    });
+  };
+  React.useImperativeHandle(ref, function () {
+    return {
+      setScrollLeft: setScrollLeft,
+      checkScrollBarVisible: checkScrollBarVisible
+    };
+  });
+  React.useEffect(function () {
+    document.body.addEventListener(MOUSEUP_EVENT, onMouseUp, false);
+    document.body.addEventListener(MOUSEMOVE_EVENT, onMouseMove, false);
+    checkScrollBarVisible();
+    return function () {
+      document.body.removeEventListener(MOUSEUP_EVENT, onMouseUp);
+      document.body.removeEventListener(MOUSEMOVE_EVENT, onMouseMove);
+    };
+  }, [scrollBarWidth, isActive]);
+
+  // Loop for scroll event check
+  React.useEffect(function () {
+    if (scrollBodyRef.current) {
+      var scrollParents = [];
+      var parent = getDOM(scrollBodyRef.current);
+      while (parent) {
+        scrollParents.push(parent);
+        parent = parent.parentElement;
+      }
+      scrollParents.forEach(function (p) {
+        p.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);
+      });
+      window.addEventListener(RESIZE_EVENT, checkScrollBarVisible, false);
+      window.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);
+      container.addEventListener(SCROLL_EVENT, checkScrollBarVisible, false);
+      return function () {
+        scrollParents.forEach(function (p) {
+          p.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);
+        });
+        window.removeEventListener(RESIZE_EVENT, checkScrollBarVisible);
+        window.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);
+        container.removeEventListener(SCROLL_EVENT, checkScrollBarVisible);
+      };
+    }
+  }, [container]);
+  React.useEffect(function () {
+    if (!scrollState.isHiddenScrollBar) {
+      setScrollState(function (state) {
+        var bodyNode = scrollBodyRef.current;
+        if (!bodyNode) {
+          return state;
+        }
+        return _objectSpread(_objectSpread({}, state), {}, {
+          scrollLeft: bodyNode.scrollLeft / bodyNode.scrollWidth * bodyNode.clientWidth
+        });
+      });
+    }
+  }, [scrollState.isHiddenScrollBar]);
+  if (bodyScrollWidth <= bodyWidth || !scrollBarWidth || scrollState.isHiddenScrollBar) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    style: {
+      height: getScrollBarSize(),
+      width: bodyWidth,
+      bottom: offsetScroll
+    },
+    className: "".concat(prefixCls, "-sticky-scroll")
+  }, /*#__PURE__*/React.createElement("div", {
+    onMouseDown: onMouseDown,
+    ref: scrollBarRef,
+    className: clsx("".concat(prefixCls, "-sticky-scroll-bar"), _defineProperty({}, "".concat(prefixCls, "-sticky-scroll-bar-active"), isActive)),
+    style: {
+      width: "".concat(scrollBarWidth, "px"),
+      transform: "translate3d(".concat(scrollState.scrollLeft, "px, 0, 0)")
+    }
+  }));
+};
+export default /*#__PURE__*/React.forwardRef(StickyScrollBar);

package/es/table/features/sticky/useSticky.d.ts

@@ -0,0 +1,10 @@
+import type { TableSticky } from '../../interface';
+/** Sticky header hooks */
+export default function useSticky(sticky: boolean | TableSticky | undefined, prefixCls: string): {
+    isSticky: boolean;
+    offsetHeader: number;
+    offsetSummary: number;
+    offsetScroll: number;
+    stickyClassName: string;
+    container: Window | HTMLElement;
+};

package/es/table/features/sticky/useSticky.js

@@ -0,0 +1,34 @@
+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 * as React from 'react';
+import canUseDom from 'rc-util/lib/Dom/canUseDom';
+// fix ssr render
+var defaultContainer = canUseDom() ? window : null;
+
+/** Sticky header hooks */
+export default function useSticky(sticky, prefixCls) {
+  var _ref = _typeof(sticky) === 'object' ? sticky : {},
+    _ref$offsetHeader = _ref.offsetHeader,
+    offsetHeader = _ref$offsetHeader === void 0 ? 0 : _ref$offsetHeader,
+    _ref$offsetSummary = _ref.offsetSummary,
+    offsetSummary = _ref$offsetSummary === void 0 ? 0 : _ref$offsetSummary,
+    _ref$offsetScroll = _ref.offsetScroll,
+    offsetScroll = _ref$offsetScroll === void 0 ? 0 : _ref$offsetScroll,
+    _ref$getContainer = _ref.getContainer,
+    getContainer = _ref$getContainer === void 0 ? function () {
+      return defaultContainer;
+    } : _ref$getContainer;
+  var container = getContainer() || defaultContainer;
+  var isSticky = !!sticky;
+  return React.useMemo(function () {
+    return {
+      isSticky: isSticky,
+      stickyClassName: isSticky ? "".concat(prefixCls, "-sticky-holder") : '',
+      offsetHeader: offsetHeader,
+      offsetSummary: offsetSummary,
+      offsetScroll: offsetScroll,
+      // `container` is only `null` during SSR (no DOM), where sticky
+      // rendering never happens; the declared contract stays non-null.
+      container: container
+    };
+  }, [isSticky, offsetScroll, offsetHeader, offsetSummary, prefixCls, container]);
+}

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

@@ -0,0 +1 @@
+export { default as Summary } from '../../components/Footer/Summary';

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

@@ -0,0 +1 @@
+export { default as Summary } from "../../components/Footer/Summary";

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

@@ -0,0 +1,2 @@
+export { type FlattenData, default as useFlattenRecords } from './useFlattenRecords';
+export { type Updater, useLayoutState, useTimeoutLock, } from './useFrame';

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

@@ -0,0 +1,2 @@
+export { default as useFlattenRecords } from "./useFlattenRecords";
+export { useLayoutState, useTimeoutLock } from "./useFrame";