@nokecy/qc-ui 1.1.87 → 1.1.88

package/dist/esm/array-table/batchRemove.js

@@ -0,0 +1,289 @@
+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 _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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _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 _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; }
+import React, { useEffect, useMemo, useState } from 'react';
+import { Button, Modal, Space } from 'antd';
+import { DeleteOutlined } from '@ant-design/icons';
+import { batch } from '@formily/reactive';
+
+/** 标准删除控件在行内的字段路径与静态约束。@author nokecy */
+
+/** 收集标准删除入口，保留列级显隐约束，不把其他业务按钮当成删除。@author nokecy */
+export function collectRemovalActions(sources) {
+  var actions = [];
+  var _iterator = _createForOfIteratorHelper(sources),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var column = _step.value;
+      if (column.display && column.display !== 'visible') return 1; // continue
+      var visit = function visit(schema, path, ancestors) {
+        if (!schema) return;
+        var schemas = [].concat(_toConsumableArray(ancestors), [schema]);
+        if (typeof schema['x-component'] === 'string' && /^(?:ArrayTable|ArrayBase)\.Remove$/.test(schema['x-component'])) {
+          actions.push({
+            path: path,
+            schemas: schemas,
+            column: column
+          });
+          return;
+        }
+        Object.entries(schema.properties || {}).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            key = _ref2[0],
+            child = _ref2[1];
+          return visit(child, [].concat(_toConsumableArray(path), [key]), schemas);
+        });
+      };
+      // 列本身不进入行地址；AgField 使用 onlyRenderProperties 挂载列内字段。
+      Object.entries(column.schema.properties || {}).forEach(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          child = _ref4[1];
+        return visit(child, [key], []);
+      });
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      if (_loop()) continue;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return actions;
+}
+var permitsRemoval = function permitsRemoval(field) {
+  var _field$componentProps, _field$componentProps2;
+  return !field || field.display === 'visible' && field.pattern === 'editable' && !field.disabled && ((_field$componentProps = field.componentProps) === null || _field$componentProps === void 0 ? void 0 : _field$componentProps.disabled) !== true && ((_field$componentProps2 = field.componentProps) === null || _field$componentProps2 === void 0 ? void 0 : _field$componentProps2.readOnly) !== true;
+};
+
+/**
+ * 与行内删除共用字段的运行时权限；未挂载的普通行采用静态规则。
+ * 含动态权限且尚未求值的行保持不可删除，避免绕过业务禁用条件。@author nokecy
+ */
+export function findRemovalAction(field, index, actions) {
+  if (field.pattern !== 'editable' || field.disabled || !Array.isArray(field.value) || !field.value[index]) return;
+  return actions.find(function (action) {
+    if (!permitsRemoval(action.column.field)) return false;
+    if (action.column.schema['x-visible'] === false || action.column.schema['x-hidden'] === true) return false;
+    var _loop2 = function _loop2() {
+        var schema = action.schemas[depth];
+        var runtime = field.query(field.address.concat(index).concat(action.path.slice(0, depth + 1))).take();
+        if (runtime) {
+          if (!permitsRemoval(runtime)) return {
+            v: false
+          };
+        } else {
+          var _schema$xComponentP, _schema$xComponentP2;
+          if (schema['x-visible'] === false || schema['x-hidden'] === true || schema['x-display'] && schema['x-display'] !== 'visible' || schema['x-pattern'] && schema['x-pattern'] !== 'editable' || schema['x-disabled'] === true || schema['x-read-only'] === true || (_schema$xComponentP = schema['x-component-props']) !== null && _schema$xComponentP !== void 0 && _schema$xComponentP.disabled || (_schema$xComponentP2 = schema['x-component-props']) !== null && _schema$xComponentP2 !== void 0 && _schema$xComponentP2.readOnly || schema['x-reactions'] || ['x-visible', 'x-hidden', 'x-disabled', 'x-read-only'].some(function (key) {
+            return typeof schema[key] === 'string';
+          })) return {
+            v: false
+          };
+        }
+      },
+      _ret;
+    for (var depth = 0; depth < action.path.length; depth++) {
+      _ret = _loop2();
+      if (_ret) return _ret.v;
+    }
+    return true;
+  });
+}
+
+/**
+ * 把选择时的稳定行标识转换为当前表单索引；确认前全部复核，倒序删除保持数组地址正确。
+ * 返回 false 表示所选行已删除或变为不可删除，整个批次不执行。@author nokecy
+ */
+export function removeSelectedRows(field, ids, actions, getId, onRemove, event) {
+  var rows = Array.isArray(field.value) ? field.value : [];
+  var indices = new Map(rows.map(function (row, index) {
+    return [getId(row), index];
+  }));
+  var targets = Array.from(new Set(ids)).map(function (id) {
+    var _indices$get;
+    var index = (_indices$get = indices.get(id)) !== null && _indices$get !== void 0 ? _indices$get : -1;
+    return {
+      index: index,
+      action: index < 0 ? undefined : findRemovalAction(field, index, actions)
+    };
+  });
+  if (!targets.length || targets.some(function (target) {
+    return !target.action;
+  })) return false;
+  // 先固定已求值的回调，数组删除会让后续字段索引迁移。
+  var removals = targets.sort(function (a, b) {
+    return b.index - a.index;
+  }).map(function (_ref5) {
+    var _field$query$take$com, _field$query$take, _schemas$xComponent;
+    var index = _ref5.index,
+      action = _ref5.action;
+    return {
+      index: index,
+      onClick: (_field$query$take$com = (_field$query$take = field.query(field.address.concat(index).concat(action.path)).take()) === null || _field$query$take === void 0 || (_field$query$take = _field$query$take.componentProps) === null || _field$query$take === void 0 ? void 0 : _field$query$take.onClick) !== null && _field$query$take$com !== void 0 ? _field$query$take$com : (_schemas$xComponent = action.schemas[action.schemas.length - 1]['x-component-props']) === null || _schemas$xComponent === void 0 ? void 0 : _schemas$xComponent.onClick
+    };
+  });
+  batch(function () {
+    return removals.forEach(function (_ref6) {
+      var index = _ref6.index,
+        onClick = _ref6.onClick;
+      field.remove(index);
+      onRemove === null || onRemove === void 0 || onRemove(index);
+      if (typeof onClick === 'function') onClick(event);
+    });
+  });
+  return true;
+}
+
+/** 公共明细表格的勾选及批量删除，沿用业务行权限、行标识与删除通知。@author nokecy */
+export function useArrayTableBatchRemove(field, sources, props, apiRef, getId) {
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    selectedCount = _useState2[0],
+    setSelectedCount = _useState2[1];
+  var _Modal$useModal = Modal.useModal(),
+    _Modal$useModal2 = _slicedToArray(_Modal$useModal, 2),
+    modal = _Modal$useModal2[0],
+    contextHolder = _Modal$useModal2[1];
+  var actions = collectRemovalActions(sources);
+  var enabled = props.batchRemove !== false && !props.disabled && field.pattern === 'editable' && !field.disabled && actions.length > 0;
+  var indices = new Map((field.value || []).map(function (row, index) {
+    return [getId(row), index];
+  }));
+  var removableIds = new Set(Array.from(indices).filter(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2),
+      index = _ref8[1];
+    return !!findRemovalAction(field, index, actions);
+  }).map(function (_ref9) {
+    var _ref10 = _slicedToArray(_ref9, 1),
+      id = _ref10[0];
+    return id;
+  }));
+  var eligibilityKey = JSON.stringify(Array.from(removableIds));
+  var canRemove = function canRemove(node) {
+    if (node.rowPinned || !node.data) return false;
+    return removableIds.has(getId(node.data));
+  };
+  var businessSelectable = _typeof(props.rowSelection) === 'object' ? props.rowSelection.isRowSelectable : undefined;
+  var latest = React.useRef({
+    actions: actions,
+    enabled: enabled,
+    canRemove: canRemove,
+    onRemove: props.onRemove,
+    businessSelectable: businessSelectable
+  });
+  latest.current = {
+    actions: actions,
+    enabled: enabled,
+    canRemove: canRemove,
+    onRemove: props.onRemove,
+    businessSelectable: businessSelectable
+  };
+  var rowSelection = useMemo(function () {
+    var _configured$mode;
+    if (!enabled) return props.rowSelection;
+    var configured = _typeof(props.rowSelection) === 'object' ? props.rowSelection : undefined;
+    var businessSelectable = configured === null || configured === void 0 ? void 0 : configured.isRowSelectable;
+    var multiple = ((_configured$mode = configured === null || configured === void 0 ? void 0 : configured.mode) !== null && _configured$mode !== void 0 ? _configured$mode : props.rowSelection === 'single' ? 'singleRow' : 'multiRow') === 'multiRow';
+    return _objectSpread(_objectSpread(_objectSpread({
+      mode: multiple ? 'multiRow' : 'singleRow',
+      checkboxes: true,
+      enableClickSelection: false
+    }, multiple ? {
+      headerCheckbox: true,
+      selectAll: 'filtered'
+    } : {}), configured), {}, {
+      isRowSelectable: function isRowSelectable(node) {
+        return latest.current.canRemove(node) && (!businessSelectable || businessSelectable(node));
+      }
+    });
+  }, [enabled, props.rowSelection, eligibilityKey]);
+  var syncSelection = function syncSelection(api) {
+    return setSelectedCount(api.getSelectedNodes().filter(function (node) {
+      return latest.current.canRemove(node);
+    }).length);
+  };
+  useEffect(function () {
+    var api = apiRef.current;
+    if (api && !api.isDestroyed() && enabled) {
+      syncSelection(api);
+    }
+  }, [enabled, rowSelection]);
+  var confirmRemove = function confirmRemove(event) {
+    var api = apiRef.current;
+    if (!api || !latest.current.enabled) return;
+    var ids = api.getSelectedNodes().filter(function (node) {
+      return latest.current.canRemove(node);
+    }).map(function (node) {
+      return getId(node.data);
+    });
+    if (!ids.length) return;
+    modal.confirm({
+      title: '确认批量删除明细',
+      content: "\u5C06\u4ECE\u5F53\u524D\u8868\u5355\u79FB\u9664\u9009\u4E2D\u7684 ".concat(ids.length, " \u6761\u660E\u7EC6\uFF0C\u4FDD\u5B58\u540E\u4E0D\u53EF\u6062\u590D\u3002\u662F\u5426\u5220\u9664\uFF1F"),
+      okText: '删除',
+      okButtonProps: {
+        danger: true
+      },
+      onOk: function onOk() {
+        var current = latest.current;
+        if (api.isDestroyed()) return;
+        var stillSelectable = ids.every(function (id) {
+          var node = api.getRowNode(id);
+          return node && current.canRemove(node) && (!current.businessSelectable || current.businessSelectable(node));
+        });
+        if (!current.enabled || !stillSelectable || !removeSelectedRows(field, ids, current.actions, getId, current.onRemove, event)) {
+          modal.warning({
+            title: '明细已发生变化',
+            content: '部分明细已删除或不可删除，请重新选择后操作。'
+          });
+          return;
+        }
+        if (!api.isDestroyed()) api.deselectAll();
+        setSelectedCount(0);
+      }
+    });
+  };
+  return {
+    rowSelection: rowSelection,
+    selectionColumnDef: enabled ? _objectSpread({
+      pinned: 'left',
+      lockPosition: true,
+      width: 46,
+      resizable: false,
+      suppressHeaderMenuButton: true
+    }, props.selectionColumnDef) : props.selectionColumnDef,
+    onSelectionChanged: function onSelectionChanged(event) {
+      var _props$onSelectionCha;
+      syncSelection(event.api);
+      (_props$onSelectionCha = props.onSelectionChanged) === null || _props$onSelectionCha === void 0 || _props$onSelectionCha.call(props, event);
+    },
+    toolbar: /*#__PURE__*/React.createElement(React.Fragment, null, contextHolder, enabled && /*#__PURE__*/React.createElement(Space, null, selectedCount > 0 && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", null, "\u5DF2\u9009 ", selectedCount, " \u9879"), /*#__PURE__*/React.createElement(Button, {
+      type: "link",
+      onClick: function onClick() {
+        var _apiRef$current;
+        return (_apiRef$current = apiRef.current) === null || _apiRef$current === void 0 ? void 0 : _apiRef$current.deselectAll();
+      }
+    }, "\u53D6\u6D88\u9009\u62E9")), /*#__PURE__*/React.createElement(Button, {
+      danger: true,
+      icon: /*#__PURE__*/React.createElement(DeleteOutlined, null),
+      disabled: !selectedCount,
+      onClick: confirmRemove
+    }, "\u6279\u91CF\u5220\u9664")))
+  };
+}

package/dist/esm/array-table/cellFocusScope.js

@@ -1,4 +1,5 @@
-import React, { useCallback, useEffect, useRef } from 'react';
+import React, { useCallback, useContext, useEffect, useRef } from 'react';
+import { CellInteractionLockContext } from "./cellInteractionLock";
 
 /**
  * 判断「焦点离开了这个单元格」的作用域,给懒挂载格「用完卸回纯文本」用。
@@ -22,10 +23,13 @@ export var CellFocusScope = function CellFocusScope(_ref) {
     children = _ref.children;
   var rootRef = useRef(null);
   var timerRef = useRef();
+  var dateTimerRef = useRef();
+  var acquireParentInteractionLock = useContext(CellInteractionLockContext);
   // 通过 React portal 渲染到 body 的弹层仍属于当前格；记录经过本作用域的指针事件，
   // 避免日期/下拉弹层中的点击被 document 级离开检测误判。@author nokecy
   var pointerEventsInScopeRef = useRef(new WeakSet());
   var focusWithinRef = useRef(false);
+  var interactionLocksRef = useRef(new Set());
   // 每次焦点回到格内、或卸载时递增;进行中的异步判定拿它判断自己是否已过期
   var generationRef = useRef(0);
   var onLeaveRef = useRef(onLeave);
@@ -33,14 +37,22 @@ export var CellFocusScope = function CellFocusScope(_ref) {
   var cancel = useCallback(function () {
     generationRef.current += 1;
     window.clearTimeout(timerRef.current);
+    window.clearTimeout(dateTimerRef.current);
   }, []);
   var scheduleLeave = useCallback(function () {
     var pointerLeftScope = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     var hadFocus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : focusWithinRef.current;
+    var pointerEvent = arguments.length > 2 ? arguments[2] : undefined;
     cancel();
     var generation = generationRef.current;
     timerRef.current = window.setTimeout(function () {
       var _rootRef$current;
+      // 对话框仍打开时，按钮 loading、候选清空等引起的暂时失焦不结束整次选择交互。
+      // 结束条件由弹层自身关闭控制，避免连同弹窗一起卸成静默文本。@author nokecy
+      if (interactionLocksRef.current.size > 0) return;
+      // document 捕获先于 React portal 的捕获处理；到任务末再按完整的 React 作用域判定。
+      // 选择器弹层内的点击不结束当前格的编辑。@author nokecy
+      if (pointerEvent && pointerEventsInScopeRef.current.has(pointerEvent)) return;
       // blur 后 activeElement 仍在本格通常是窗口切走或格内弹层切焦点，不算离开。
       // 指针明确点到本格/其弹层之外时，即使目标不可聚焦导致 activeElement 没变，也应离开。
       if (!pointerLeftScope && (_rootRef$current = rootRef.current) !== null && _rootRef$current !== void 0 && _rootRef$current.contains(document.activeElement)) return;
@@ -49,6 +61,20 @@ export var CellFocusScope = function CellFocusScope(_ref) {
       }, hadFocus);
     }, 0);
   }, [cancel]);
+  var acquireInteractionLock = useCallback(function () {
+    var lock = Symbol('cell-popup');
+    interactionLocksRef.current.add(lock);
+    cancel();
+    // Editable 与懒挂载格可以嵌套；弹层同时占用所有父格，防止外层先卸掉选择器。@author nokecy
+    var releaseParent = acquireParentInteractionLock === null || acquireParentInteractionLock === void 0 ? void 0 : acquireParentInteractionLock();
+    return function () {
+      if (!interactionLocksRef.current.delete(lock)) return;
+      releaseParent === null || releaseParent === void 0 || releaseParent();
+      // 弹层关闭后恢复通常的校验与静默流程；不是永久屏蔽失焦。
+      // 卸载时 ref 已移除，不为已经销毁的单元格再排任务。@author nokecy
+      if (interactionLocksRef.current.size === 0 && rootRef.current) scheduleLeave(true, true);
+    };
+  }, [cancel, scheduleLeave, acquireParentInteractionLock]);
   var handleFocus = function handleFocus() {
     focusWithinRef.current = true;
     cancel();
@@ -60,6 +86,8 @@ export var CellFocusScope = function CellFocusScope(_ref) {
   };
   var handlePointerDownCapture = function handlePointerDownCapture(event) {
     pointerEventsInScopeRef.current.add(event.nativeEvent);
+    // 再次点击原输入框不一定产生 focus，仍须作废此前离开时发起的异步校验。@author nokecy
+    cancel();
   };
   var handleClickCapture = function handleClickCapture(event) {
     var target = event.target;
@@ -70,7 +98,10 @@ export var CellFocusScope = function CellFocusScope(_ref) {
     var selected = target.closest('.ant-picker-dropdown .ant-picker-cell-inner, .ant-picker-dropdown .ant-picker-ok, .ant-picker-dropdown .ant-picker-today-btn, .ant-picker-dropdown .ant-picker-now-btn');
     if (!selected) return;
     var dropdown = selected.closest('.ant-picker-dropdown');
-    window.setTimeout(function () {
+    window.clearTimeout(dateTimerRef.current);
+    var generation = generationRef.current;
+    dateTimerRef.current = window.setTimeout(function () {
+      if (generation !== generationRef.current || !rootRef.current) return;
       if (dropdown !== null && dropdown !== void 0 && dropdown.isConnected && !dropdown.classList.contains('ant-picker-dropdown-hidden')) return;
       scheduleLeave(true, true);
     }, 0);
@@ -84,22 +115,27 @@ export var CellFocusScope = function CellFocusScope(_ref) {
       if (target instanceof Node && root.contains(target) || pointerEventsInScopeRef.current.has(event)) return;
       // 新增行的必填空格也会预先挂载控件，但可能从未获得焦点；同样需要响应离开，
       // 由 onLeave 根据 hadFocus 决定是否校验未触碰的空必填格。@author nokecy
-      scheduleLeave(true, focusWithinRef.current);
+      scheduleLeave(true, focusWithinRef.current, event);
     };
-    document.addEventListener('pointerdown', handleDocumentPointerDown);
+
+    // 捕获阶段也能收到被表单控件阻止冒泡的点击，避免必须点工具栏才退出编辑。
+    // portal 的归属在延迟任务中确认。@author nokecy
+    document.addEventListener('pointerdown', handleDocumentPointerDown, true);
     return function () {
-      document.removeEventListener('pointerdown', handleDocumentPointerDown);
+      document.removeEventListener('pointerdown', handleDocumentPointerDown, true);
       cancel();
     };
   }, [cancel, scheduleLeave]);
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React.createElement(CellInteractionLockContext.Provider, {
+    value: acquireInteractionLock
+  }, /*#__PURE__*/React.createElement("div", {
     ref: rootRef,
     style: {
       display: 'contents'
     },
-    onFocus: handleFocus,
-    onBlur: handleBlur,
+    onFocusCapture: handleFocus,
+    onBlurCapture: handleBlur,
     onClickCapture: handleClickCapture,
     onPointerDownCapture: handlePointerDownCapture
-  }, children);
+  }, children));
 };

package/dist/esm/array-table/cellInteractionLock.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+/**
+ * 单元格弹层的交互占用。最后一个弹层关闭前，暂时失焦不能卸载单元格。
+ * 不在懒单元格中使用时无需任何额外处理。
+ * @author nokecy
+ */
+export declare const CellInteractionLockContext: import("react").Context<(() => () => void) | undefined>;
+/**
+ * 将弹层的打开状态绑定到所属单元格，支持嵌套弹层并在关闭或卸载时释放。
+ * 使用布局阶段同步占用，避免打开弹层的同一次交互产生的失焦任务先卸载控件。
+ * @author nokecy
+ */
+export declare const useCellInteractionLock: (open: boolean) => void;

package/dist/esm/array-table/cellInteractionLock.js

@@ -0,0 +1,21 @@
+import { createContext, useContext, useLayoutEffect } from 'react';
+
+/**
+ * 单元格弹层的交互占用。最后一个弹层关闭前，暂时失焦不能卸载单元格。
+ * 不在懒单元格中使用时无需任何额外处理。
+ * @author nokecy
+ */
+export var CellInteractionLockContext = /*#__PURE__*/createContext(undefined);
+
+/**
+ * 将弹层的打开状态绑定到所属单元格，支持嵌套弹层并在关闭或卸载时释放。
+ * 使用布局阶段同步占用，避免打开弹层的同一次交互产生的失焦任务先卸载控件。
+ * @author nokecy
+ */
+export var useCellInteractionLock = function useCellInteractionLock(open) {
+  var acquire = useContext(CellInteractionLockContext);
+  useLayoutEffect(function () {
+    if (open) return acquire === null || acquire === void 0 ? void 0 : acquire();
+    return undefined;
+  }, [acquire, open]);
+};

package/dist/esm/array-table/hooks.d.ts

@@ -1,18 +1,22 @@
 import { RefObject } from 'react';
 import { GridApi } from 'ag-grid-community';
 import { ArrayField } from '@formily/core';
-/**
- * 单元格聚焦 Hook
- * 处理 Editable 包装和普通输入框的聚焦逻辑
- */
+type CellFocusRequest = {
+    isCurrent: () => boolean;
+    schedule: (callback: () => void, delay: number) => void;
+};
+type BeginCellFocusRequest = (resolveCell: () => Element | null | undefined, isTargetCurrent?: () => boolean) => CellFocusRequest;
+/** 单元格聚焦；已获得焦点的控件保留用户光标，等待挂载的请求可被新操作取消。@author nokecy */
 export declare const useCellFocus: () => {
-    focusInputInCell: (cell: Element) => void;
+    focusInputInCell: (cell: Element, isTargetCurrent?: () => boolean) => void;
+    scheduleCellFocus: (resolveCell: () => Element | null | undefined, delay: number, isTargetCurrent?: () => boolean) => void;
+    beginFocusRequest: BeginCellFocusRequest;
 };
 /**
  * 键盘导航 Hook
  * 处理方向键在表格单元格间的导航
  */
-export declare const useKeyboardNavigation: (ref: RefObject<any>, dataSource: any[], focusInputInCell: (cell: Element) => void, activateCell?: ((api: GridApi, node: any, colId: string) => boolean) | undefined) => {
+export declare const useKeyboardNavigation: (ref: RefObject<any>, dataSource: any[], focusInputInCell: (cell: Element, isTargetCurrent?: () => boolean) => void, activateCell?: ((api: GridApi, node: any, colId: string) => boolean) | undefined, beginSharedFocusRequest?: BeginCellFocusRequest) => {
     handleCellKeyDown: (event: any) => void;
 };
 /**
@@ -39,3 +43,4 @@ export declare const isNativeInputKey: (event: KeyboardEvent) => boolean;
 export declare const suppressNativeInputKeys: ({ event }: {
     event: KeyboardEvent;
 }) => boolean;
+export {};