@dtjoy/dt-design 1.1.1 → 1.1.5

package/lib/table/features/resize/useResize.js

@@ -0,0 +1,595 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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; }
+/**
+ * 获取列宽追踪用的列标识。
+ * 无 key 且无 dataIndex 的列（如 selection / expand 等功能列）不可标识，返回 null：
+ * 不注入拖拽手柄，也不进入 widths Map，避免多列共用 '' 键互相覆盖。
+ */
+function getColumnKey(col) {
+  var _col$key;
+  var key = (_col$key = col.key) !== null && _col$key !== void 0 ? _col$key : col.dataIndex;
+  return key != null ? key : null;
+}
+
+/**
+ * 表头拖拽改变列宽的 hook
+ *
+ * 核心交互策略：
+ *
+ * **初始弹性分配**：
+ * - 初始所有列为"弹性列"，按 baseWidth 比例分配容器剩余空间，填满容器
+ * - remainder > 0：弹性列膨胀；remainder < 0：弹性列收缩（不低于 minWidth）
+ *
+ * **拖拽冻结**：
+ * - 松手时，将所有列的 baseWidth 冻结为当前渲染宽度，并全部标记为固定列
+ * - 这样松手后 remainder ≈ 0，不会触发 flex 重分配
+ * - 列边界精确停留在鼠标位置（跟手）
+ * - 总宽 = 渲染宽度之和，可能 ≠ containerWidth（出现滚动条或空白）
+ * - 用户可调用 resetColumnWidths 恢复所有列为弹性列
+ *
+ * **拖拽精度**：
+ * - 使用 th.offsetWidth（实际渲染宽度）作为拖拽起点
+ * - 用户拖 N px → 新宽度 = 渲染宽度 ± N px，松手后冻结，视觉无跳变
+ *
+ * **其他特性**：
+ * - 容器宽度测量滚动区域 clientWidth，自动排除垂直滚动条
+ * - scrollX = 列宽总和，覆盖 scroll.x 避免 table-layout:fixed 下的浏览器重分配
+ * - rAF + 直接 DOM 操作实现高性能拖拽
+ */
+function useResize(_ref) {
+  var columns = _ref.columns,
+    _ref$enabled = _ref.enabled,
+    enabled = _ref$enabled === void 0 ? false : _ref$enabled,
+    _ref$defaultMinWidth = _ref.defaultMinWidth,
+    defaultMinWidth = _ref$defaultMinWidth === void 0 ? 60 : _ref$defaultMinWidth,
+    containerRef = _ref.containerRef,
+    onColumnResize = _ref.onColumnResize,
+    prefixCls = _ref.prefixCls;
+  // 扁平化列（仅叶子列可以 resize）
+  var flattenColumns = React.useMemo(function () {
+    var result = [];
+    function walk(cols) {
+      cols.forEach(function (col) {
+        var children = col.children;
+        if (children && children.length > 0) {
+          walk(children);
+        } else {
+          result.push(col);
+        }
+      });
+    }
+    walk(columns);
+    return result;
+  }, [columns]);
+
+  // 初始化列宽（从 column.width 读取）
+  var _React$useState = React.useState(function () {
+      var map = new Map();
+      flattenColumns.forEach(function (col) {
+        var key = getColumnKey(col);
+        if (key == null) return;
+        if (col.width != null) {
+          var w = Number(col.width);
+          if (!Number.isNaN(w)) map.set(key, w);
+        }
+      });
+      return map;
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    columnWidths = _React$useState2[0],
+    setColumnWidths = _React$useState2[1];
+
+  // 记录用户拖拽过的列 key（被拖拽过的列变为"固定列"，不再吸收 remainder）
+  var _React$useState3 = React.useState(function () {
+      return new Set();
+    }),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    resizedKeys = _React$useState4[0],
+    setResizedKeys = _React$useState4[1];
+
+  // 同步外部 columns 变化
+  React.useEffect(function () {
+    setColumnWidths(function (prev) {
+      var next = new Map(prev);
+      flattenColumns.forEach(function (col) {
+        var key = getColumnKey(col);
+        if (key == null) return;
+        if (col.width != null && !next.has(key)) {
+          var w = Number(col.width);
+          if (!Number.isNaN(w)) next.set(key, w);
+        }
+      });
+      return next;
+    });
+  }, [flattenColumns]);
+
+  // 拖拽状态：正在拖拽的列 key（使用 state 驱动渲染）
+  var _React$useState5 = React.useState(null),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    resizingKey = _React$useState6[0],
+    setResizingKey = _React$useState6[1];
+
+  // 竖线 DOM ref（直接操作 DOM 避免频繁 state 更新）
+  var lineRef = React.useRef(null);
+
+  // 拖拽过程中的 ref（避免闭包陷阱）
+  var dragRef = React.useRef(null);
+
+  // 存储当前拖拽的事件监听器清理函数
+  // 用于：1) 组件卸载时清理泄漏的监听器  2) 重复 mousedown 时清理旧拖拽
+  var cleanupDragListenersRef = React.useRef(null);
+
+  // columnWidths / flattenColumns / onColumnResize 的 ref 镜像
+  // 用于稳定 onStartResize 引用，避免每次拖拽松手后 transformColumns 链重跑
+  var columnWidthsRef = React.useRef(columnWidths);
+  columnWidthsRef.current = columnWidths;
+  var flattenColumnsRef = React.useRef(flattenColumns);
+  flattenColumnsRef.current = flattenColumns;
+  var onColumnResizeRef = React.useRef(onColumnResize);
+  onColumnResizeRef.current = onColumnResize;
+  // renderWidthsRef 在 renderWidths memo 之后初始化
+  var renderWidthsRef = React.useRef(new Map());
+
+  // 获取列的可调整配置
+  var getResizeConfig = React.useCallback(function (col) {
+    var _col$resizable, _col$minWidth;
+    // 不可标识的列（无 key/dataIndex，如 selection / expand 列）不可调整
+    var colEnabled = ((_col$resizable = col.resizable) !== null && _col$resizable !== void 0 ? _col$resizable : enabled) && getColumnKey(col) != null;
+    return {
+      enabled: colEnabled,
+      minWidth: (_col$minWidth = col.minWidth) !== null && _col$minWidth !== void 0 ? _col$minWidth : defaultMinWidth,
+      maxWidth: col.maxWidth
+    };
+  }, [enabled, defaultMinWidth]);
+
+  // ========================= 滚动区域查找 =========================
+  // 查找表格滚动区域元素，用于容器宽度测量和竖线定位。
+  //
+  // 优先级：
+  //   1. .{prefixCls}-tbody   — 虚拟滚动模式（Grid 组件）
+  //   2. .{prefixCls}-body    — fixHeader 模式，body 有 overflowY: scroll
+  //   3. .{prefixCls}-content  — unique table 模式
+  //   4. .{prefixCls}-container — 回退
+  var findScrollElement = React.useCallback(function (wrapper) {
+    var tbody = wrapper.querySelector(".".concat(prefixCls, "-tbody"));
+    if (tbody) return tbody;
+    var body = wrapper.querySelector(".".concat(prefixCls, "-body"));
+    if (body) return body;
+    var content = wrapper.querySelector(".".concat(prefixCls, "-content"));
+    if (content) return content;
+    return wrapper.querySelector(".".concat(prefixCls, "-container"));
+  }, [prefixCls]);
+
+  // ========================= 容器宽度测量 =========================
+  // 测量表格滚动区域的 clientWidth，自动排除垂直滚动条宽度。
+  // 使用 useLayoutEffect 在浏览器绘制前完成首次测量，避免初始化闪烁。
+  var _React$useState7 = React.useState(0),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    containerWidth = _React$useState8[0],
+    setContainerWidth = _React$useState8[1];
+  React.useLayoutEffect(function () {
+    var wrapper = containerRef === null || containerRef === void 0 ? void 0 : containerRef.current;
+    if (!wrapper) return;
+    var measure = function measure() {
+      var el = findScrollElement(wrapper);
+      if (el) {
+        setContainerWidth(el.clientWidth);
+      }
+    };
+
+    // 首次测量
+    measure();
+
+    // 监听容器尺寸变化
+    var resizeObserver = new ResizeObserver(function () {
+      measure();
+    });
+
+    // 观察 container（外层尺寸变化）
+    var container = wrapper.querySelector(".".concat(prefixCls, "-container"));
+    if (container) {
+      resizeObserver.observe(container);
+    }
+
+    // 也观察滚动区域（滚动条出现/消失时 clientWidth 会变化）
+    var scrollEl = findScrollElement(wrapper);
+    if (scrollEl && scrollEl !== container) {
+      resizeObserver.observe(scrollEl);
+    }
+    return function () {
+      resizeObserver.disconnect();
+    };
+  }, [containerRef, findScrollElement]);
+
+  // ========================= 渲染宽度计算 =========================
+  // renderWidths: 实际传给 colgroup 的宽度
+  // scrollX: renderWidths 的总和，用于覆盖 scroll.x
+  //
+  // 策略（对齐 Element Plus updateColumnsWidth）：
+  //   1. 收集所有列的 baseWidth，计算 totalWidth
+  //   2. flexColumns = 未在 resizedKeys 中的列（弹性列）
+  //   3. remainder = containerWidth - totalWidth
+  //   4. remainder ≠ 0 且有弹性列时，按 baseWidth 比例分配 remainder 给弹性列
+  //      - remainder > 0：弹性列膨胀（吸收剩余空间）
+  //      - remainder < 0：弹性列收缩（让出超出空间），但不低于 minWidth
+  //      - 第一个弹性列吸收舍入误差，确保 totalRender === containerWidth
+  //   5. remainder = 0 或无弹性列时，使用 baseWidth
+  var _React$useMemo = React.useMemo(function () {
+      var map = new Map();
+
+      // 1. 收集每列的基础宽度
+      var entries = [];
+      var totalWidth = 0;
+      flattenColumns.forEach(function (col) {
+        var key = getColumnKey(col);
+        // 不可标识的列不参与宽度分配，保留自身 width / 自然宽度
+        if (key == null) return;
+        var mapWidth = columnWidths.get(key);
+        // Guard against NaN: non-numeric string widths are treated as missing
+        var rawW = col.width != null ? Number(col.width) : 0;
+        // 未设 width 且未被拖拽冻结的列：以 defaultMinWidth 为基础宽度参与弹性分配，
+        // 避免渲染宽度被覆盖为 0 而塌陷为 0~1px
+        var baseWidth = mapWidth !== null && mapWidth !== void 0 ? mapWidth : Number.isNaN(rawW) || rawW <= 0 ? defaultMinWidth : rawW;
+        var flex = !resizedKeys.has(key) && baseWidth > 0;
+        entries.push({
+          key: key,
+          width: baseWidth,
+          flex: flex
+        });
+        totalWidth += baseWidth;
+      });
+
+      // 2. 收集弹性列
+      var flexEntries = entries.filter(function (e) {
+        return e.flex;
+      });
+
+      // 3. 计算剩余空间
+      var remainder = containerWidth > 0 && flexEntries.length > 0 ? containerWidth - totalWidth : 0;
+
+      // 4. 分配（remainder > 0 膨胀，remainder < 0 收缩）
+      if (remainder !== 0) {
+        var flexTotal = flexEntries.reduce(function (sum, e) {
+          return sum + e.width;
+        }, 0);
+        if (remainder > 0) {
+          // 膨胀：按 baseWidth 比例分配剩余空间
+          var ratio = remainder / flexTotal;
+          var assigned = 0;
+          flexEntries.forEach(function (entry, index) {
+            if (index === 0) return; // 第一个弹性列最后计算，吸收舍入误差
+            var flex = Math.floor(entry.width * ratio);
+            assigned += flex;
+            map.set(entry.key, entry.width + flex);
+          });
+          // 第一个弹性列 = remainder - 其他弹性列已分配的量
+          var firstFlex = remainder - assigned;
+          map.set(flexEntries[0].key, flexEntries[0].width + firstFlex);
+        } else {
+          // 收缩：按 baseWidth 比例从弹性列中扣除超出空间（对齐 Element Plus）
+          var deficit = -remainder; // 需要扣除的总量
+          var _ratio = deficit / flexTotal;
+
+          // 先计算每列的扣除量，确保不低于 minWidth
+          var actualDeducted = 0;
+          var deductions = flexEntries.map(function (entry, index) {
+            if (index === 0) return 0; // 第一个弹性列最后计算
+            var maxDeduct = Math.max(0, entry.width - defaultMinWidth);
+            var deduct = Math.min(Math.floor(entry.width * _ratio), maxDeduct);
+            actualDeducted += deduct;
+            return deduct;
+          });
+
+          // 第一个弹性列扣除剩余量，但不低于 minWidth
+          var firstDeduct = Math.min(deficit - actualDeducted, Math.max(0, flexEntries[0].width - defaultMinWidth));
+          deductions[0] = firstDeduct;
+          actualDeducted += firstDeduct;
+
+          // 应用扣除
+          flexEntries.forEach(function (entry, index) {
+            map.set(entry.key, entry.width - deductions[index]);
+          });
+
+          // 如果弹性列全部到 minWidth 仍然不够扣除，totalRender > containerWidth，出现滚动条
+        }
+      }
+
+      // 非弹性列 + remainder = 0 时的弹性列，使用 baseWidth
+      var totalRender = 0;
+      entries.forEach(function (entry) {
+        if (!map.has(entry.key)) {
+          map.set(entry.key, entry.width);
+        }
+        totalRender += map.get(entry.key);
+      });
+
+      // scrollX: 当 containerWidth > 0 时使用 totalRender（列宽总和）
+      //          当 containerWidth = 0（尚未测量）时返回 null，由 InternalTable 回退到用户 scroll.x
+      var sx = containerWidth > 0 ? totalRender : null;
+      return {
+        renderWidths: map,
+        scrollX: sx
+      };
+    }, [flattenColumns, columnWidths, containerWidth, resizedKeys, defaultMinWidth]),
+    renderWidths = _React$useMemo.renderWidths,
+    scrollX = _React$useMemo.scrollX;
+
+  // 同步 renderWidths 到 ref（供 onUp 中读取当前渲染宽度）
+  renderWidthsRef.current = renderWidths;
+
+  // 更新竖线位置（直接操作 DOM，不触发 React 重渲染）
+  // 竖线覆盖表格本体（.xxx-container），不覆盖分页等外部区域
+  var updateLinePosition = React.useCallback(function (clientX) {
+    var line = lineRef.current;
+    var wrapper = containerRef === null || containerRef === void 0 ? void 0 : containerRef.current;
+    if (!line || !wrapper) return;
+
+    // 查找表格本体容器（排除分页、title、footer、spin 等区域）
+    var tableContainer = wrapper.querySelector(".".concat(prefixCls, "-container"));
+    if (!tableContainer) return;
+
+    // 查找滚动区域元素（与 containerWidth 测量使用相同的优先级）
+    // 使用 scrollEl.clientWidth 计算右边界，自动排除垂直滚动条宽度
+    var scrollEl = findScrollElement(wrapper);
+    if (!scrollEl) return;
+    var wrapperRect = wrapper.getBoundingClientRect();
+    var tableRect = tableContainer.getBoundingClientRect();
+    var scrollRect = scrollEl.getBoundingClientRect();
+
+    // 竖线的 top / height 基于表格本体相对于 wrapper 的偏移
+    var topOffset = tableRect.top - wrapperRect.top;
+    var tableHeight = tableRect.height;
+
+    // 水平位置：竖线是 absolute 定位在 wrapper 内，直接用 clientX 减去 wrapper 左边界
+    // wrapper 本身不滚动（滚动发生在 .ant-table-container 内部），所以不需要 scrollLeft
+    var left = clientX - wrapperRect.left;
+
+    // 限制在滚动区域范围内（使用 scrollEl.clientWidth 排除垂直滚动条）
+    var minLeft = scrollRect.left - wrapperRect.left;
+    var maxLeft = minLeft + scrollEl.clientWidth;
+    left = Math.max(minLeft, Math.min(left, maxLeft));
+    line.style.left = "".concat(left, "px");
+    line.style.top = "".concat(topOffset, "px");
+    line.style.height = "".concat(tableHeight, "px");
+    line.style.display = 'block';
+  }, [containerRef, findScrollElement, prefixCls]);
+
+  // 隐藏竖线
+  var hideLine = React.useCallback(function () {
+    if (lineRef.current) {
+      lineRef.current.style.display = 'none';
+    }
+  }, []);
+
+  // 组件卸载时清理残留的拖拽监听器，防止内存泄漏
+  React.useEffect(function () {
+    return function () {
+      var _cleanupDragListeners, _dragRef$current;
+      (_cleanupDragListeners = cleanupDragListenersRef.current) === null || _cleanupDragListeners === void 0 || _cleanupDragListeners.call(cleanupDragListenersRef);
+      cleanupDragListenersRef.current = null;
+      if (((_dragRef$current = dragRef.current) === null || _dragRef$current === void 0 ? void 0 : _dragRef$current.rafId) != null) {
+        cancelAnimationFrame(dragRef.current.rafId);
+      }
+      dragRef.current = null;
+    };
+  }, []);
+
+  // 开始拖拽
+  // actualWidth 由 ResizeHandle 从 th.offsetWidth 测量后传入，确保与实际渲染宽度一致
+  var onStartResize = React.useCallback(function (e, col, actualWidth) {
+    var _cleanupDragListeners2, _columnWidthsRef$curr;
+    var key = getColumnKey(col);
+    var config = getResizeConfig(col);
+    if (key == null || !config.enabled) return;
+    e.preventDefault();
+    e.stopPropagation();
+
+    // 如果有正在进行的拖拽，先清理旧的事件监听器（防止重复 mousedown 导致监听器堆积）
+    (_cleanupDragListeners2 = cleanupDragListenersRef.current) === null || _cleanupDragListeners2 === void 0 || _cleanupDragListeners2.call(cleanupDragListenersRef);
+    cleanupDragListenersRef.current = null;
+
+    // 使用 DOM 测量的实际渲染宽度作为拖拽起点（包含 remainder）
+    // 参考 Element Plus：columnWidth = finalLeft - startColumnLeft
+    // 用户拖 3px → 新宽度 = 渲染宽度 - 3px，松手后变固定列，视觉无跳变
+    // Guard against NaN: if col.width is a non-numeric string (e.g. 'auto'),
+    // Number(col.width) returns NaN, which would corrupt the drag math.
+    var rawWidth = col.width != null ? Number(col.width) : 0;
+    var baseWidth = (_columnWidthsRef$curr = columnWidthsRef.current.get(key)) !== null && _columnWidthsRef$curr !== void 0 ? _columnWidthsRef$curr : Number.isNaN(rawWidth) ? 0 : rawWidth;
+    var currentWidth = actualWidth !== null && actualWidth !== void 0 ? actualWidth : baseWidth;
+    dragRef.current = {
+      key: key,
+      startX: e.clientX,
+      startWidth: currentWidth,
+      minWidth: config.minWidth,
+      maxWidth: config.maxWidth,
+      latestWidth: currentWidth,
+      latestClientX: e.clientX,
+      rafId: null
+    };
+    setResizingKey(key);
+
+    // 立即显示竖线
+    updateLinePosition(e.clientX);
+    var onMove = function onMove(ev) {
+      if (!dragRef.current) return;
+
+      // 始终存储最新的 clientX，rAF 回调中使用此值
+      dragRef.current.latestClientX = ev.clientX;
+
+      // 使用 rAF 节流：如果上一帧还没执行完，跳过本次调度
+      if (dragRef.current.rafId != null) return;
+      dragRef.current.rafId = requestAnimationFrame(function () {
+        if (!dragRef.current) return;
+        dragRef.current.rafId = null;
+
+        // 使用最新存储的 clientX 计算，而非闭包中的 ev
+        var delta = dragRef.current.latestClientX - dragRef.current.startX;
+        var newWidth = dragRef.current.startWidth + delta;
+        newWidth = Math.max(newWidth, dragRef.current.minWidth);
+        if (dragRef.current.maxWidth != null) {
+          newWidth = Math.min(newWidth, dragRef.current.maxWidth);
+        }
+        dragRef.current.latestWidth = newWidth;
+
+        // 直接操作 DOM 更新竖线位置（不触发 React 重渲染）
+        updateLinePosition(dragRef.current.latestClientX);
+      });
+    };
+    var onUp = function onUp() {
+      var _dragRef$current2;
+      document.removeEventListener('mousemove', onMove);
+      document.removeEventListener('mouseup', onUp);
+      cleanupDragListenersRef.current = null;
+      document.body.style.cursor = '';
+      document.body.style.userSelect = '';
+
+      // 取消未执行的 rAF
+      if (((_dragRef$current2 = dragRef.current) === null || _dragRef$current2 === void 0 ? void 0 : _dragRef$current2.rafId) != null) {
+        cancelAnimationFrame(dragRef.current.rafId);
+      }
+      if (dragRef.current) {
+        var _onColumnResizeRef$cu, _col$onResize;
+        var _dragRef$current3 = dragRef.current,
+          k = _dragRef$current3.key,
+          latestWidth = _dragRef$current3.latestWidth;
+
+        // 核心修复：冻结所有列的 baseWidth 为当前渲染宽度
+        // 这样松手后 renderWidths 重算时，baseWidth === renderedWidth，
+        // remainder ≈ 0，不会触发 flex 重分配，列边界精确停留在鼠标位置。
+        // 同时将所有列标记为固定列（不再参与 flex 分配）。
+        var currentRendered = renderWidthsRef.current;
+        setColumnWidths(function (prev) {
+          var next = new Map(prev);
+          // 冻结所有列的 baseWidth 为当前渲染宽度
+          currentRendered.forEach(function (w, key) {
+            // 不冻结 0 / NaN：未分配到渲染宽度的列保持弹性，避免塌陷宽度被永久化
+            if (w > 0 && !Number.isNaN(w)) next.set(key, w);
+          });
+          // 被拖拽的列使用用户拖拽的最终宽度
+          next.set(k, latestWidth);
+          return next;
+        });
+
+        // 将所有列标记为固定列（不再参与 flex 分配）
+        setResizedKeys(function (prev) {
+          var next = new Set(prev);
+          flattenColumnsRef.current.forEach(function (col) {
+            var key = getColumnKey(col);
+            if (key != null) next.add(key);
+          });
+          return next;
+        });
+
+        // 触发回调
+        (_onColumnResizeRef$cu = onColumnResizeRef.current) === null || _onColumnResizeRef$cu === void 0 || _onColumnResizeRef$cu.call(onColumnResizeRef, k, latestWidth);
+
+        // 触发列的 onResize 回调
+        var _col = flattenColumnsRef.current.find(function (c) {
+          return getColumnKey(c) === k;
+        });
+        _col === null || _col === void 0 || (_col$onResize = _col.onResize) === null || _col$onResize === void 0 || _col$onResize.call(_col, latestWidth);
+      }
+
+      // 隐藏竖线
+      hideLine();
+      dragRef.current = null;
+      setResizingKey(null);
+    };
+    document.addEventListener('mousemove', onMove);
+    document.addEventListener('mouseup', onUp);
+    document.body.style.cursor = 'col-resize';
+    document.body.style.userSelect = 'none';
+
+    // 存储清理函数，用于组件卸载或重复 mousedown 时清理
+    cleanupDragListenersRef.current = function () {
+      document.removeEventListener('mousemove', onMove);
+      document.removeEventListener('mouseup', onUp);
+    };
+  }, [getResizeConfig, updateLinePosition, hideLine]);
+
+  // 获取列的渲染宽度（= 用户宽度 + 剩余空间分配）
+  var getColumnRenderWidth = React.useCallback(function (col) {
+    var key = getColumnKey(col);
+    // 不可标识的列不注入覆盖宽度
+    if (key == null) return undefined;
+    var renderWidth = renderWidths.get(key);
+    if (renderWidth != null) return renderWidth;
+    var mapWidth = columnWidths.get(key);
+    if (mapWidth != null) return mapWidth;
+    if (col.width != null) return Number(col.width);
+    return undefined;
+  }, [renderWidths, columnWidths]);
+
+  // 检查某列是否可调整
+  var isColumnResizable = React.useCallback(function (col) {
+    return getResizeConfig(col).enabled;
+  }, [getResizeConfig]);
+
+  // 键盘调整列宽（不走 MouseEvent 路径，直接更新 state）
+  var setColumnWidth = React.useCallback(function (col, newWidth) {
+    var _onColumnResizeRef$cu2, _col$onResize2;
+    var key = getColumnKey(col);
+    var config = getResizeConfig(col);
+    if (key == null || !config.enabled) return;
+
+    // clamp 到 minWidth / maxWidth
+    newWidth = Math.max(newWidth, config.minWidth);
+    if (config.maxWidth != null) {
+      newWidth = Math.min(newWidth, config.maxWidth);
+    }
+
+    // 冻结所有列的 baseWidth 为当前渲染宽度，标记为固定列
+    var currentRendered = renderWidthsRef.current;
+    setColumnWidths(function (prev) {
+      var next = new Map(prev);
+      currentRendered.forEach(function (w, k) {
+        // 不冻结 0 / NaN：未分配到渲染宽度的列保持弹性，避免塌陷宽度被永久化
+        if (w > 0 && !Number.isNaN(w)) next.set(k, w);
+      });
+      next.set(key, newWidth);
+      return next;
+    });
+    setResizedKeys(function (prev) {
+      var next = new Set(prev);
+      flattenColumnsRef.current.forEach(function (c) {
+        var k = getColumnKey(c);
+        if (k != null) next.add(k);
+      });
+      return next;
+    });
+    (_onColumnResizeRef$cu2 = onColumnResizeRef.current) === null || _onColumnResizeRef$cu2 === void 0 || _onColumnResizeRef$cu2.call(onColumnResizeRef, key, newWidth);
+    (_col$onResize2 = col.onResize) === null || _col$onResize2 === void 0 || _col$onResize2.call(col, newWidth);
+  }, [getResizeConfig]);
+
+  // 重置列宽（同时清空 resizedKeys，恢复所有列为弹性列）
+  var resetColumnWidths = React.useCallback(function () {
+    setColumnWidths(new Map());
+    setResizedKeys(new Set());
+  }, []);
+  return {
+    resizingKey: resizingKey,
+    lineRef: lineRef,
+    renderWidths: renderWidths,
+    scrollX: scrollX,
+    getColumnRenderWidth: getColumnRenderWidth,
+    isColumnResizable: isColumnResizable,
+    onStartResize: onStartResize,
+    setColumnWidth: setColumnWidth,
+    resetColumnWidths: resetColumnWidths
+  };
+}
+var _default = exports.default = useResize;

package/lib/table/features/selection/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SELECTION_ALL", {
+  enumerable: true,
+  get: function get() {
+    return _useSelection.SELECTION_ALL;
+  }
+});
+Object.defineProperty(exports, "SELECTION_COLUMN", {
+  enumerable: true,
+  get: function get() {
+    return _useSelection.SELECTION_COLUMN;
+  }
+});
+Object.defineProperty(exports, "SELECTION_INVERT", {
+  enumerable: true,
+  get: function get() {
+    return _useSelection.SELECTION_INVERT;
+  }
+});
+Object.defineProperty(exports, "SELECTION_NONE", {
+  enumerable: true,
+  get: function get() {
+    return _useSelection.SELECTION_NONE;
+  }
+});
+Object.defineProperty(exports, "useSelection", {
+  enumerable: true,
+  get: function get() {
+    return _useSelection.default;
+  }
+});
+var _useSelection = _interopRequireWildcard(require("./useSelection"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }