@nokecy/qc-ui-components 0.0.0-stage → 2.0.0-beta.1

package/dist/cjs/array-table/hooks.js

@@ -0,0 +1,559 @@
+"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.useRowDrag = exports.useKeyboardNavigation = exports.useCellFocus = exports.useCellEscapeRevert = exports.suppressNativeInputKeys = exports.isNativeInputKey = exports.focusGridCell = exports.focusAddedRow = exports.createTabToNextCell = void 0;
+var _react = require("react");
+var _indexColumn = require("./indexColumn");
+var _excluded = ["pending"];
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+// setSelectionRange 仅 textarea 与 text/search/url/tel/password 类型 input 支持;
+// checkbox/number/date 等调用会抛 InvalidStateError,故用白名单守卫。@author nokecy
+var supportsSelectionRange = function supportsSelectionRange(el) {
+  return (
+    // 日期组件自行管理光标和分段选区，表格只聚焦，不覆盖其选区。@author nokecy
+    !el.closest('.ant-picker') && (el.tagName === 'TEXTAREA' || /^(text|search|url|tel|password)$/i.test(el.type || 'text'))
+  );
+};
+/** 点击、键盘导航和字段挂载共用一次聚焦意图，新交互使旧任务失效。@author nokecy */
+var useCellFocusRequests = function useCellFocusRequests() {
+  var enabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  var generation = (0, _react.useRef)(0);
+  var mounted = (0, _react.useRef)(true);
+  var timers = (0, _react.useRef)(new Set());
+  var pendingCell = (0, _react.useRef)(undefined);
+  var cancel = (0, _react.useCallback)(function () {
+    generation.current += 1;
+    pendingCell.current = undefined;
+    timers.current.forEach(clearTimeout);
+    timers.current.clear();
+  }, []);
+  (0, _react.useEffect)(function () {
+    mounted.current = true;
+    if (!enabled) return;
+    var onFocus = function onFocus(event) {
+      if (!pendingCell.current) return;
+      var cell = pendingCell.current();
+      if (!(cell !== null && cell !== void 0 && cell.isConnected) || !(event.target instanceof Node) || !cell.contains(event.target)) cancel();
+    };
+    document.addEventListener('pointerdown', cancel, true);
+    document.addEventListener('keydown', cancel, true);
+    document.addEventListener('focusin', onFocus, true);
+    window.addEventListener('blur', cancel);
+    return function () {
+      mounted.current = false;
+      cancel();
+      document.removeEventListener('pointerdown', cancel, true);
+      document.removeEventListener('keydown', cancel, true);
+      document.removeEventListener('focusin', onFocus, true);
+      window.removeEventListener('blur', cancel);
+    };
+  }, [cancel, enabled]);
+  return (0, _react.useCallback)(function (resolveCell) {
+    var isTargetCurrent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
+      return true;
+    };
+    cancel();
+    var requestGeneration = generation.current;
+    pendingCell.current = resolveCell;
+    var isCurrent = function isCurrent() {
+      return mounted.current && generation.current === requestGeneration && isTargetCurrent();
+    };
+    return {
+      isCurrent: isCurrent,
+      schedule: function schedule(callback, delay) {
+        if (!isCurrent()) return;
+        var timer = setTimeout(function () {
+          timers.current.delete(timer);
+          if (isCurrent()) callback();
+        }, delay);
+        timers.current.add(timer);
+      }
+    };
+  }, [cancel]);
+};
+
+/** 单元格聚焦；已获得焦点的控件保留用户光标，等待挂载的请求可被新操作取消。@author nokecy */
+
+/**
+ * 鼠标点击刚把懒挂载格挂成真控件后，补一次展开。
+ * 点击落在纯文本上，控件是点击之后才挂载的，antd 根本没收到这次点击，所以要自己补：
+ * Select 在 mousedown 上切换展开（已展开则不动，避免补成关闭），DatePicker 在 click 上展开。@author nokecy
+ */
+var openFreshlyMountedControl = function openFreshlyMountedControl(input) {
+  if (input.closest('.ant-picker')) {
+    input.click();
+    return;
+  }
+  var select = input.closest('.ant-select');
+  if (select && !select.classList.contains('ant-select-open')) {
+    input.dispatchEvent(new MouseEvent('mousedown', {
+      bubbles: true,
+      cancelable: true
+    }));
+  }
+};
+
+/**
+ * @param options.openDateOnKeyboard 键盘到达日期格时是否自动展开面板，默认 false：与演示一致——
+ *   鼠标点击由 antd 自己展开，键盘到达保持收起、直接键入覆盖。传 true 才在键盘落焦那一次展开。
+ */
+var useCellFocus = exports.useCellFocus = function useCellFocus() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var beginFocusRequest = useCellFocusRequests();
+  var openDateOnKeyboard = options.openDateOnKeyboard === true;
+  var openDateRef = (0, _react.useRef)(openDateOnKeyboard);
+  openDateRef.current = openDateOnKeyboard;
+  /** source 是一次性的来源提示，只作用于这一次落焦；鼠标来源与已聚焦的格不会触发展开。 */
+  var focusInputInCell = (0, _react.useCallback)(function (cell) {
+    var _ref, _cell$querySelector;
+    var isTargetCurrent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
+      return true;
+    };
+    var source = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'pointer';
+    var row = cell.closest('.ag-row');
+    var rowId = row === null || row === void 0 ? void 0 : row.getAttribute('row-id');
+    var rowIndex = row === null || row === void 0 ? void 0 : row.getAttribute('row-index');
+    var colId = cell.getAttribute('col-id');
+    var request = beginFocusRequest(function () {
+      return cell;
+    }, function () {
+      return cell.isConnected && isTargetCurrent() && (row === null || row === void 0 ? void 0 : row.getAttribute('row-id')) === rowId && (row === null || row === void 0 ? void 0 : row.getAttribute('row-index')) === rowIndex && cell.getAttribute('col-id') === colId;
+    });
+    if (!request.isCurrent()) return;
+    var focusElement = function focusElement(element) {
+      if (!(element !== null && element !== void 0 && element.isConnected) || !cell.contains(element) || !request.isCurrent()) return;
+      if (document.activeElement === element) return;
+      element.focus();
+      // 懒挂载格的鼠标点击落在纯文本上，antd 没收到点击，挂载后补展开一次（只在刚挂载的那一次，
+      // 已聚焦的格在上面直接返回，再点不会重复触发）；键盘到达保持收起，openDateOnKeyboard 才在日期格展开。
+      if (document.activeElement === element) {
+        if (source === 'pointer-activated') openFreshlyMountedControl(element);else if (source === 'keyboard' && openDateRef.current && element.closest('.ant-picker')) element.click();
+      }
+      // 首次进入全选（规范 §7.6.3：键入即覆盖，不是追加）；同步设置，避免延迟任务覆盖用户随后选择的文字。
+      // 已聚焦的输入框在上面直接返回，所以用户点出来的光标/选区不会被改动。@author nokecy
+      if (document.activeElement === element && element.matches('input, textarea') && supportsSelectionRange(element)) {
+        element.select();
+      }
+    };
+    var active = document.activeElement;
+    if (active && cell.contains(active) && active.matches('input, textarea, [contenteditable="true"]')) return;
+    var selector = 'input:not([readonly]):not([disabled]), textarea:not([readonly]):not([disabled])';
+    var editableElement = cell.querySelector('.ant-formily-editable');
+    if (editableElement) {
+      var focusEditor = function focusEditor() {
+        return focusElement(editableElement.querySelector(selector));
+      };
+      if (editableElement.dataset.editableState === 'editing') {
+        focusEditor();
+      } else {
+        editableElement.click();
+        if (!request.isCurrent()) return;
+        editableElement.dispatchEvent(new Event('focus', {
+          bubbles: true
+        }));
+        request.schedule(focusEditor, 150);
+      }
+      return;
+    }
+    focusElement((_ref = (_cell$querySelector = cell.querySelector(selector)) !== null && _cell$querySelector !== void 0 ? _cell$querySelector : cell.querySelector('input:not([disabled]), textarea:not([disabled]), [contenteditable="true"], [tabindex]:not([disabled])')) !== null && _ref !== void 0 ? _ref : cell);
+  }, [beginFocusRequest]);
+  var scheduleCellFocus = (0, _react.useCallback)(function (resolveCell, delay, isTargetCurrent, source) {
+    var request = beginFocusRequest(resolveCell, isTargetCurrent);
+    request.schedule(function () {
+      var cell = resolveCell();
+      if (cell !== null && cell !== void 0 && cell.isConnected) focusInputInCell(cell, isTargetCurrent, source);
+    }, delay);
+  }, [beginFocusRequest, focusInputInCell]);
+  return {
+    focusInputInCell: focusInputInCell,
+    scheduleCellFocus: scheduleCellFocus,
+    beginFocusRequest: beginFocusRequest
+  };
+};
+
+/**
+ * 键盘导航 Hook
+ * 处理方向键在表格单元格间的导航
+ */
+var useKeyboardNavigation = exports.useKeyboardNavigation = function useKeyboardNavigation(ref, dataSource, focusInputInCell, activateCell, beginSharedFocusRequest, isTabFocusDeferred) {
+  var beginLocalFocusRequest = useCellFocusRequests(!beginSharedFocusRequest);
+  var beginFocusRequest = beginSharedFocusRequest !== null && beginSharedFocusRequest !== void 0 ? beginSharedFocusRequest : beginLocalFocusRequest;
+  var handleCellKeyDown = (0, _react.useCallback)(function (event) {
+    var _nativeKeyDecisions$g;
+    var keyEvent = event.event,
+      node = event.node,
+      colDef = event.colDef,
+      api = event.api;
+    if (!keyEvent) return;
+    // 输入框里移动光标/扩选/全选的按键归输入框,表格不导航(见 isNativeInputKey)。
+    // 判定用 keydown 当时记下的(见 suppressNativeInputKeys);没记过(不是 AG-Grid 触发的)才现算。
+    if ((_nativeKeyDecisions$g = nativeKeyDecisions.get(keyEvent)) !== null && _nativeKeyDecisions$g !== void 0 ? _nativeKeyDecisions$g : isNativeInputKey(keyEvent)) return;
+
+    // Tab / Enter 由 AG-Grid 自己换格，但它只聚焦单元格 div，输入框拿不到焦点、键入无效：
+    // 等 AG-Grid 换完格再把焦点落进新格的输入框（并全选）。方向键走下面自己的导航。@author nokecy
+    if ((keyEvent.key === 'Tab' || keyEvent.key === 'Enter') && !keyEvent.ctrlKey && !keyEvent.altKey && !keyEvent.metaKey) {
+      if (keyEvent.key === 'Tab' && isTabFocusDeferred !== null && isTabFocusDeferred !== void 0 && isTabFocusDeferred()) return;
+      var resolveFocused = function resolveFocused() {
+        var _api$getFocusedCell, _ref$current$querySel, _ref$current;
+        var focused = (_api$getFocusedCell = api.getFocusedCell) === null || _api$getFocusedCell === void 0 ? void 0 : _api$getFocusedCell.call(api);
+        if (!focused) return null;
+        return (_ref$current$querySel = (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.querySelector(".ag-row[row-index=\"".concat(focused.rowIndex, "\"] .ag-cell[col-id=\"").concat(focused.column.getColId(), "\"]"))) !== null && _ref$current$querySel !== void 0 ? _ref$current$querySel : null;
+      };
+      var request = beginFocusRequest(resolveFocused);
+      request.schedule(function () {
+        var _api$getFocusedCell2, _api$getDisplayedRowA;
+        // 懒挂载格先激活挂树，再给挂载留出时间。
+        var focused = (_api$getFocusedCell2 = api.getFocusedCell) === null || _api$getFocusedCell2 === void 0 ? void 0 : _api$getFocusedCell2.call(api);
+        var focusedNode = focused ? (_api$getDisplayedRowA = api.getDisplayedRowAtIndex) === null || _api$getDisplayedRowA === void 0 ? void 0 : _api$getDisplayedRowA.call(api, focused.rowIndex) : undefined;
+        var justActivated = !!(activateCell && focused && focusedNode && activateCell(api, focusedNode, focused.column.getColId()));
+        request.schedule(function () {
+          var cell = resolveFocused();
+          if (cell !== null && cell !== void 0 && cell.isConnected) focusInputInCell(cell, undefined, 'keyboard');
+        }, justActivated ? 150 : 10);
+      }, 10);
+      return;
+    }
+
+    // 处理上下左右键导航
+    if (keyEvent.key === 'ArrowDown' || keyEvent.key === 'ArrowUp' || keyEvent.key === 'ArrowLeft' || keyEvent.key === 'ArrowRight') {
+      var currentRowIndex = node.rowIndex;
+      var currentColId = colDef.field;
+      var targetRowIndex = currentRowIndex;
+      var targetColId = currentColId;
+
+      // 确定目标位置
+      if (keyEvent.key === 'ArrowDown') {
+        targetRowIndex = currentRowIndex + 1;
+      } else if (keyEvent.key === 'ArrowUp') {
+        targetRowIndex = currentRowIndex - 1;
+      } else if (keyEvent.key === 'ArrowLeft' || keyEvent.key === 'ArrowRight') {
+        // 对于左右键,使用AG-Grid的API获取列信息
+        var visibleColumns = api.getAllDisplayedColumns();
+        if (visibleColumns && visibleColumns.length > 0) {
+          // 找到当前列的索引
+          var currentColIndex = visibleColumns.findIndex(function (col) {
+            return col.getColId() === currentColId;
+          });
+          var targetColIndex;
+          if (keyEvent.key === 'ArrowLeft') {
+            targetColIndex = currentColIndex - 1;
+          } else {
+            targetColIndex = currentColIndex + 1;
+          }
+
+          // 检查目标列索引是否有效
+          if (targetColIndex >= 0 && targetColIndex < visibleColumns.length) {
+            targetColId = visibleColumns[targetColIndex].getColId();
+          } else {
+            return; // 无法移动到目标列
+          }
+        } else {
+          return; // 无列信息
+        }
+      }
+
+      // 检查目标位置是否有效
+      var isValidTarget = keyEvent.key === 'ArrowLeft' || keyEvent.key === 'ArrowRight' || targetRowIndex >= 0 && targetRowIndex < dataSource.length;
+      if (isValidTarget) {
+        var _api$getDisplayedRowA2;
+        var targetNode = (_api$getDisplayedRowA2 = api.getDisplayedRowAtIndex) === null || _api$getDisplayedRowA2 === void 0 ? void 0 : _api$getDisplayedRowA2.call(api, targetRowIndex);
+        var navigated = false;
+        var resolveTarget = function resolveTarget() {
+          var _ref$current2;
+          return (_ref$current2 = ref.current) === null || _ref$current2 === void 0 ? void 0 : _ref$current2.querySelector(".ag-row[row-index=\"".concat(targetRowIndex, "\"] .ag-cell[col-id=\"").concat(targetColId, "\"]"));
+        };
+        var _isTargetCurrent = function _isTargetCurrent() {
+          var _ref$current3, _api$isDestroyed, _api$getDisplayedRowA3;
+          if (!((_ref$current3 = ref.current) !== null && _ref$current3 !== void 0 && _ref$current3.isConnected) || (_api$isDestroyed = api.isDestroyed) !== null && _api$isDestroyed !== void 0 && _api$isDestroyed.call(api)) return false;
+          if (targetNode && ((_api$getDisplayedRowA3 = api.getDisplayedRowAtIndex) === null || _api$getDisplayedRowA3 === void 0 ? void 0 : _api$getDisplayedRowA3.call(api, targetRowIndex)) !== targetNode) return false;
+          if (navigated && api.getFocusedCell) {
+            var _focused$column;
+            var focused = api.getFocusedCell();
+            return (focused === null || focused === void 0 ? void 0 : focused.rowIndex) === targetRowIndex && ((_focused$column = focused.column) === null || _focused$column === void 0 ? void 0 : _focused$column.getColId()) === targetColId;
+          }
+          return true;
+        };
+        var _request = beginFocusRequest(resolveTarget, _isTargetCurrent);
+        // 延迟执行以确保当前编辑完成
+        _request.schedule(function () {
+          api.setFocusedCell(targetRowIndex, targetColId);
+          navigated = true;
+
+          // 懒挂载:目标格若是懒列存量格,先激活挂树(refreshCells),下方 150ms 内完成挂载再聚焦 @author nokecy
+          if (activateCell && targetNode) {
+            activateCell(api, targetNode, targetColId);
+          }
+
+          // 不使用原生startEditingCell,而是手动触发编辑状态
+          // v33 themeQuartz 容器不再有 .ag-theme-alpine 类;且行虚拟化下 DOM 顺序与 rowIndex 不一致,
+          // 改为直接在 ref 容器内按 row-index + col-id 属性定位目标单元格 @author nokecy
+          _request.schedule(function () {
+            var targetCell = resolveTarget();
+            if (targetCell !== null && targetCell !== void 0 && targetCell.isConnected) {
+              focusInputInCell(targetCell, _isTargetCurrent, 'keyboard');
+            }
+          }, 150);
+        }, 10);
+      }
+      keyEvent.preventDefault();
+      keyEvent.stopPropagation();
+    }
+  }, [dataSource, focusInputInCell, ref, activateCell, beginFocusRequest]);
+  return {
+    handleCellKeyDown: handleCellKeyDown
+  };
+};
+
+/**
+ * 行拖拽 Hook
+ * 处理行拖拽排序逻辑
+ */
+var useRowDrag = exports.useRowDrag = function useRowDrag(field) {
+  var handleRowDragMove = (0, _react.useCallback)(function (event) {
+    var movingNode = event.node;
+    var overNode = event.overNode;
+    var rowNeedsToMove = movingNode !== overNode;
+    if (rowNeedsToMove) {
+      var movingData = movingNode.data;
+      var overData = overNode.data;
+      var dataSourceCopy = Array.isArray(field.value) ? field.value.slice() : [];
+      var fromIndex = dataSourceCopy.indexOf(movingData);
+      var toIndex = dataSourceCopy.indexOf(overData);
+      // 防护:任一索引未命中(引用不一致)时直接返回,避免 splice(-1) 误删末行 @author nokecy
+      if (fromIndex < 0 || toIndex < 0) return;
+      var newStore = dataSourceCopy.slice();
+
+      // 移动数组元素
+      var element = newStore[fromIndex];
+      newStore.splice(fromIndex, 1);
+      newStore.splice(toIndex, 0, element);
+      field.setValue(newStore);
+    }
+  }, [field]);
+  return {
+    handleRowDragMove: handleRowDragMove
+  };
+};
+
+/**
+ * 这个按键该不该交给单元格里的输入框自己处理(浏览器原生行为),而不是当成表格的快捷键/单元格导航。
+ *
+ * AG-Grid 把 Ctrl+A 当成「选中所有单元格」、Home/End 当成「跳到行首/行尾单元格」并 preventDefault;
+ * 我们的 handleCellKeyDown 又把方向键一律当成「跳到相邻单元格」——输入框里全选、用方向键移动光标、
+ * Shift+方向键扩选文字就全都做不了。规则:
+ *  - Ctrl/Cmd+A、Home/End、带 Shift/Ctrl/Alt/Cmd 的方向键、输入法组字期间的按键 -> 输入框自己处理;
+ *  - 左右方向键:光标还能动就移动光标(有选区时先收起选区),已经在最左/最右再按才跳到相邻单元格;
+ *  - 上下方向键:单行输入框没有纵向光标,照旧在行间导航;多行文本域在首行/末行才导航;
+ *  - 焦点不在输入框里(在单元格本身)、只读输入框(如下拉选择)、不支持光标的输入框:照旧导航。
+ * 复制/粘贴/剪切/撤销 AG-Grid 本来就没拦,不必处理。@author nokecy
+ */
+var isNativeInputKey = exports.isNativeInputKey = function isNativeInputKey(event) {
+  var _target$matches;
+  var target = event.target;
+  if (!(target !== null && target !== void 0 && (_target$matches = target.matches) !== null && _target$matches !== void 0 && _target$matches.call(target, 'input, textarea, [contenteditable="true"]'))) return false;
+  var key = event.key;
+  if (event.isComposing) return true;
+  if ((event.ctrlKey || event.metaKey) && key.toLowerCase() === 'a') return true;
+  // 复制/剪切/粘贴交给输入框的原生行为：AG-Grid 不应拦走单元格内输入框的 Ctrl/Cmd+C/X/V（允许粘贴，规范 §11）。
+  if ((event.ctrlKey || event.metaKey) && !event.altKey && ['c', 'x', 'v'].includes(key.toLowerCase())) return true;
+  if (key === 'Home' || key === 'End') return true;
+  if (!key.startsWith('Arrow')) return false;
+  if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey) return true;
+  var el = target;
+  var start = el.selectionStart,
+    end = el.selectionEnd,
+    value = el.value;
+  // 不支持光标的输入框(如 checkbox)、只读输入框:没有光标可动,方向键用来导航
+  if (start == null || end == null || el.readOnly || el.disabled) return false;
+  var collapsed = start === end;
+  if (key === 'ArrowLeft') return !(collapsed && start === 0);
+  if (key === 'ArrowRight') return !(collapsed && end === value.length);
+  if (el.tagName !== 'TEXTAREA') return false;
+  // 多行文本域:光标不在首行才能往上移,不在末行才能往下移
+  return key === 'ArrowUp' ? value.slice(0, start).includes('\n') : value.slice(end).includes('\n');
+};
+
+/**
+ * keydown 当时的判定。AG-Grid 的 onCellKeyDown 回调是在 setTimeout(0) 里才触发的,那时浏览器已经执行完默认动作、
+ * 光标被挪过了:光标从 1 挪到最左、选区收起到末尾之后再算,会误当成「本来就在边缘」而跳格。
+ * suppressKeyboardEvent 是 keydown 时同步调用的,状态还没变,所以在那里记下,回调里直接用。
+ */
+var nativeKeyDecisions = new WeakMap();
+
+/** AG-Grid 的 suppressKeyboardEvent:让 AG-Grid 不再拦截输入框自己处理的按键,并记下这次按键的判定 */
+var suppressNativeInputKeys = exports.suppressNativeInputKeys = function suppressNativeInputKeys(_ref2) {
+  var event = _ref2.event;
+  var native = isNativeInputKey(event);
+  nativeKeyDecisions.set(event, native);
+  return native;
+};
+/**
+ * 行已在行模型里：滚到可见、设焦点格、必要时激活懒挂载格，等格子渲染出来后把焦点落进输入控件。
+ * 行进入模型后 DOM 还要再渲染一拍（懒挂载格还要挂载），所以分多次轮询，直到格子出现；
+ * 返回的 Promise 在落焦完成（返回获得焦点的控件）、或请求被用户操作取消 / 超时（返回 undefined）时结束。@author nokecy
+ */
+var focusGridCell = exports.focusGridCell = function focusGridCell(params) {
+  var _api$getDisplayedRowA4, _api$isDestroyed2, _api$ensureIndexVisib, _api$ensureColumnVisi;
+  var api = params.api,
+    root = params.root,
+    rowIndex = params.rowIndex,
+    colId = params.colId,
+    beginFocusRequest = params.beginFocusRequest,
+    focusInputInCell = params.focusInputInCell,
+    activateCell = params.activateCell;
+  var node = (_api$getDisplayedRowA4 = api.getDisplayedRowAtIndex) === null || _api$getDisplayedRowA4 === void 0 ? void 0 : _api$getDisplayedRowA4.call(api, rowIndex);
+  if (!node || (_api$isDestroyed2 = api.isDestroyed) !== null && _api$isDestroyed2 !== void 0 && _api$isDestroyed2.call(api)) return Promise.resolve(undefined);
+  var resolveCell = function resolveCell() {
+    var _root$current;
+    return (_root$current = root.current) === null || _root$current === void 0 ? void 0 : _root$current.querySelector(".ag-row[row-index=\"".concat(rowIndex, "\"] .ag-cell[col-id=\"").concat(colId, "\"]"));
+  };
+  var isTargetCurrent = function isTargetCurrent() {
+    var _root$current2, _api$isDestroyed3, _api$getFocusedCell3;
+    if (!((_root$current2 = root.current) !== null && _root$current2 !== void 0 && _root$current2.isConnected) || (_api$isDestroyed3 = api.isDestroyed) !== null && _api$isDestroyed3 !== void 0 && _api$isDestroyed3.call(api)) return false;
+    var focused = (_api$getFocusedCell3 = api.getFocusedCell) === null || _api$getFocusedCell3 === void 0 ? void 0 : _api$getFocusedCell3.call(api);
+    return !focused || focused.rowIndex === rowIndex && focused.column.getColId() === colId;
+  };
+  var request = beginFocusRequest(resolveCell, isTargetCurrent);
+  (_api$ensureIndexVisib = api.ensureIndexVisible) === null || _api$ensureIndexVisib === void 0 || _api$ensureIndexVisib.call(api, rowIndex);
+  if (params.ensureColumnVisible) (_api$ensureColumnVisi = api.ensureColumnVisible) === null || _api$ensureColumnVisi === void 0 || _api$ensureColumnVisi.call(api, colId);
+  api.setFocusedCell(rowIndex, colId);
+  var activated = activateCell ? activateCell(api, node, colId) : false;
+  return new Promise(function (resolve) {
+    var attempt = function attempt(remaining) {
+      if (!request.isCurrent()) return resolve(undefined);
+      var cell = resolveCell();
+      if (cell !== null && cell !== void 0 && cell.isConnected) {
+        focusInputInCell(cell, isTargetCurrent, 'keyboard');
+        var active = document.activeElement;
+        return resolve(active instanceof HTMLElement && cell.contains(active) ? active : undefined);
+      }
+      if (remaining <= 0) return resolve(undefined);
+      setTimeout(function () {
+        return attempt(remaining - 1);
+      }, 50);
+    };
+    setTimeout(function () {
+      return attempt(8);
+    }, activated ? 150 : 30);
+  });
+};
+
+// 按行 id 记录：排序时新行的显示行号与数据下标不一致，落焦必须取行节点的显示行号。
+
+/**
+ * 新增行进入 AG-Grid 行模型之后，把焦点落到它的首个可编辑格。
+ *
+ * 新行是 field.push 之后经 React 重渲、rowData 更新才进入行模型的，push 当下 getDisplayedRowAtIndex 还取不到它，
+ * 所以由 onRowDataUpdated 调用本函数；行模型里还没有该行时返回 false，调用方保留待办等下一次。@author nokecy
+ */
+var focusAddedRow = exports.focusAddedRow = function focusAddedRow(params) {
+  var _rest$api$isDestroyed, _rest$api, _rest$api$getRowNode, _rest$api2;
+  var pending = params.pending,
+    rest = _objectWithoutProperties(params, _excluded);
+  if ((_rest$api$isDestroyed = (_rest$api = rest.api).isDestroyed) !== null && _rest$api$isDestroyed !== void 0 && _rest$api$isDestroyed.call(_rest$api)) return true;
+  var rowIndex = (_rest$api$getRowNode = (_rest$api2 = rest.api).getRowNode) === null || _rest$api$getRowNode === void 0 || (_rest$api$getRowNode = _rest$api$getRowNode.call(_rest$api2, pending.rowId)) === null || _rest$api$getRowNode === void 0 ? void 0 : _rest$api$getRowNode.rowIndex;
+  if (typeof rowIndex !== 'number') return false;
+  void focusGridCell(_objectSpread(_objectSpread({}, rest), {}, {
+    rowIndex: rowIndex,
+    colId: pending.colId
+  }));
+  return true;
+};
+
+/** 不应被 Tab 停留的列：默认序号列与勾选列（规范 §7.6.3：Tab 只在可编辑格之间移动）。@author nokecy */
+var isTabSkippedColumn = function isTabSkippedColumn(colId) {
+  return colId === _indexColumn.ARRAY_TABLE_INDEX_FIELD || colId === 'ag-Grid-SelectionColumn';
+};
+
+/**
+ * AG-Grid `tabToNextCell`：跳过序号列/勾选列；末行末格再按 Tab 时，传了 `onTabPastEnd` 就由它新增一行并落焦，
+ * 否则保持默认（焦点离开表格）。返回值语义见 AG-Grid：位置=去那格，true=留在原格，false=交浏览器。@author nokecy
+ */
+var createTabToNextCell = exports.createTabToNextCell = function createTabToNextCell(onTabPastEnd) {
+  return function (params) {
+    var _params$api$getAllDis, _params$api$getAllDis2, _params$api, _params$api$getDispla, _params$api$getDispla2, _params$api2;
+    var columns = (_params$api$getAllDis = (_params$api$getAllDis2 = (_params$api = params.api).getAllDisplayedColumns) === null || _params$api$getAllDis2 === void 0 ? void 0 : _params$api$getAllDis2.call(_params$api)) !== null && _params$api$getAllDis !== void 0 ? _params$api$getAllDis : [];
+    var step = params.backwards ? -1 : 1;
+    var rowCount = (_params$api$getDispla = (_params$api$getDispla2 = (_params$api2 = params.api).getDisplayedRowCount) === null || _params$api$getDispla2 === void 0 ? void 0 : _params$api$getDispla2.call(_params$api2)) !== null && _params$api$getDispla !== void 0 ? _params$api$getDispla : 0;
+    var next = params.nextCellPosition;
+    var prev = params.previousCellPosition;
+    // AG-Grid 在行首/行尾会折到相邻行；统一在这里按列序重新找下一个可停留的格。
+    if (next && isTabSkippedColumn(next.column.getColId())) {
+      var rowIndex = next.rowIndex;
+      var colIndex = columns.indexOf(next.column) + step;
+      for (;;) {
+        if (colIndex < 0 || colIndex >= columns.length) {
+          rowIndex += step;
+          if (rowIndex < 0 || rowIndex >= rowCount) {
+            next = null;
+            break;
+          }
+          colIndex = step > 0 ? 0 : columns.length - 1;
+          continue;
+        }
+        if (!isTabSkippedColumn(columns[colIndex].getColId())) {
+          next = _objectSpread(_objectSpread({}, next), {}, {
+            rowIndex: rowIndex,
+            column: columns[colIndex]
+          });
+          break;
+        }
+        colIndex += step;
+      }
+    }
+    if (next) return next;
+    // 没有下一格：前进方向且正处在最后一格 -> 新增行
+    if (!params.backwards && onTabPastEnd && prev && prev.rowIndex === rowCount - 1) {
+      onTabPastEnd();
+      return true;
+    }
+    return false;
+  };
+};
+
+/**
+ * Esc 放弃本格修改（规范 §7.6.3）：Formily 受控值是实时写入的，没有「进入时的值」，
+ * 所以在输入框获得焦点时记下当时的文本，Esc 时用原生 setter + input 事件写回，值照常经 Formily 回流。
+ * 下拉/日期等自带 Esc 语义的控件不处理。@author nokecy
+ */
+var useCellEscapeRevert = exports.useCellEscapeRevert = function useCellEscapeRevert(ref) {
+  (0, _react.useEffect)(function () {
+    var root = ref.current;
+    if (!root) return;
+    var snapshots = new WeakMap();
+    var isPlainInput = function isPlainInput(el) {
+      return el instanceof HTMLInputElement && !el.readOnly && !el.disabled && !el.closest('.ant-select, .ant-picker') && /^(text|search|url|tel|number)$/i.test(el.type || 'text');
+    };
+    var onFocusIn = function onFocusIn(event) {
+      if (isPlainInput(event.target)) snapshots.set(event.target, event.target.value);
+    };
+    var onKeyDown = function onKeyDown(event) {
+      var _Object$getOwnPropert;
+      if (event.key !== 'Escape' || event.isComposing || !isPlainInput(event.target)) return;
+      var snapshot = snapshots.get(event.target);
+      if (snapshot === undefined || snapshot === event.target.value) return;
+      var setter = (_Object$getOwnPropert = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')) === null || _Object$getOwnPropert === void 0 ? void 0 : _Object$getOwnPropert.set;
+      setter === null || setter === void 0 || setter.call(event.target, snapshot);
+      event.target.dispatchEvent(new Event('input', {
+        bubbles: true
+      }));
+      event.target.select();
+      event.stopPropagation();
+    };
+    root.addEventListener('focusin', onFocusIn);
+    root.addEventListener('keydown', onKeyDown, true);
+    return function () {
+      root.removeEventListener('focusin', onFocusIn);
+      root.removeEventListener('keydown', onKeyDown, true);
+    };
+  }, [ref]);
+};

package/dist/cjs/array-table/index.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { AgGridReactProps } from "ag-grid-react";
+declare const _default: React.ForwardRefExoticComponent<Partial<AgGridReactProps<any> & {
+    height?: string | number | undefined;
+    minRows?: number | undefined;
+    maxRows?: number | undefined;
+    gridKey: string;
+    title?: React.ReactNode;
+    onRowDrag?: boolean | undefined;
+    disabled?: boolean | undefined;
+    batchRemove?: boolean | undefined;
+    onRemove?: ((index: number) => void) | undefined;
+    fixedColumnsMaxRatio?: number | undefined;
+    tabAddsRow?: boolean | undefined;
+    openDateOnKeyboard?: boolean | undefined;
+    summary?: import("./summary").ArrayTableSummary | undefined;
+} & {
+    children?: React.ReactNode;
+}> & React.RefAttributes<any>>;
+export default _default;