@ant-design/pro-components 3.0.2-0 → 3.1.1-0

package/es/utils/useEditableArray/index.js

@@ -1,145 +1,209 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
-import _toArray from "@babel/runtime/helpers/esm/toArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-var _excluded = ["map_row_parentKey"],
-  _excluded2 = ["map_row_parentKey", "map_row_key"],
-  _excluded3 = ["map_row_key"];
 /* eslint-disable react-hooks/exhaustive-deps */import { LoadingOutlined } from '@ant-design/icons';
-import { get, warning as rcWarning, set, useMergedState } from '@rc-component/util';
+import { get, warning as rcWarning, set, useControlledState } from '@rc-component/util';
 import { Form, Popconfirm, message } from 'antd';
 import useLazyKVMap from 'antd/lib/table/hooks/useLazyKVMap';
-import React, { createRef, forwardRef, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
+import React, { createRef, forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
 import { useDebounceFn, useRefFunction } from '..';
 import { useIntl } from "../../provider";
 import { ProFormContext } from "../components/ProFormContext";
 import { useDeepCompareEffectDebounce } from "../hooks/useDeepCompareEffect";
 import { usePrevious } from "../hooks/usePrevious";
 import { merge } from "../merge";
-import { useMountMergeState } from "../useMountMergeState";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
-var noteOnce = rcWarning.noteOnce;
+const {
+  noteOnce
+} = rcWarning;
 
 /**
  * 显示警告信息
  * @param messageStr
  */
-var warning = function warning(messageStr) {
+const warning = messageStr => {
   return message.warning(messageStr);
 };
-export var recordKeyToString = function recordKeyToString(rowKey) {
+export const recordKeyToString = rowKey => {
   if (Array.isArray(rowKey)) return rowKey.join(',');
   return rowKey;
 };
+
 /**
- * 使用map 来删除数据，性能一般 但是准确率比较高
+ * Normalize antd Form `NamePath` segments.
  *
- * @param keyProps
- * @param action
+ * - Preserve `0` (number) and other falsy-but-valid segments
+ * - Flatten nested arrays (e.g. `name={['a','b']}`)
+ * - Convert number segments to string to align with `spellNamePath` behavior
  */
-export function editableRowByKey(keyProps, action) {
-  var _recordKeyToString;
-  var getRowKey = keyProps.getRowKey,
-    row = keyProps.row,
-    data = keyProps.data,
-    _keyProps$childrenCol = keyProps.childrenColumnName,
-    childrenColumnName = _keyProps$childrenCol === void 0 ? 'children' : _keyProps$childrenCol;
-  var key = (_recordKeyToString = recordKeyToString(keyProps.key)) === null || _recordKeyToString === void 0 ? void 0 : _recordKeyToString.toString();
-  var kvMap = new Map();
-
-  /**
-   * 打平这个数组
-   *
-   * @param records
-   * @param parentKey
-   */
-  function dig(records, map_row_parentKey, map_row_index) {
-    records.forEach(function (record, index) {
-      var eachIndex = (map_row_index || 0) * 10 + index;
-      var recordKey = getRowKey(record, eachIndex).toString();
-      // children 取在前面方便拼的时候按照反顺序放回去
-      if (record && _typeof(record) === 'object' && childrenColumnName in record) {
-        dig(record[childrenColumnName] || [], recordKey, eachIndex);
-      }
-      var newRecord = _objectSpread(_objectSpread({}, record), {}, {
-        map_row_key: recordKey,
-        children: undefined,
-        map_row_parentKey: map_row_parentKey
-      });
-      delete newRecord.children;
-      if (!map_row_parentKey) {
-        delete newRecord.map_row_parentKey;
-      }
-      kvMap.set(recordKey, newRecord);
-    });
-  }
-  if (action === 'top') {
-    kvMap.set(key, _objectSpread(_objectSpread({}, kvMap.get(key)), row));
-  }
-  dig(data);
-  if (action === 'update') {
-    kvMap.set(key, _objectSpread(_objectSpread({}, kvMap.get(key)), row));
-  }
-  if (action === 'delete') {
-    kvMap.delete(key);
-  }
-  var fill = function fill(map) {
-    var kvArrayMap = new Map();
-    var kvSource = [];
-    var fillNewRecord = function fillNewRecord() {
-      var fillChildren = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      map.forEach(function (value) {
-        if (value.map_row_parentKey && !value.map_row_key) {
-          var map_row_parentKey = value.map_row_parentKey,
-            rest = _objectWithoutProperties(value, _excluded);
-          if (!kvArrayMap.has(map_row_parentKey)) {
-            kvArrayMap.set(map_row_parentKey, []);
-          }
-          if (fillChildren) {
-            var _kvArrayMap$get;
-            (_kvArrayMap$get = kvArrayMap.get(map_row_parentKey)) === null || _kvArrayMap$get === void 0 || _kvArrayMap$get.push(rest);
-          }
-        }
-      });
+const normalizeNamePath = (...segments) => {
+  return segments.flat(1).filter(key => key !== undefined && key !== null).map(key => typeof key === 'number' ? key.toString() : key);
+};
+/**
+ * 扁平化记录树结构为 Map
+ */
+function flattenRecordsToMap(records, getRowKey, childrenColumnName, parentKey, parentIndex) {
+  const kvMap = new Map();
+  records.forEach((record, index) => {
+    const eachIndex = (parentIndex || 0) * 10 + index;
+    const recordKey = getRowKey(record, eachIndex).toString();
+    const hasChildren = record && typeof record === 'object' && childrenColumnName in record;
+    if (hasChildren) {
+      const children = record[childrenColumnName] || [];
+      const childrenMap = flattenRecordsToMap(children, getRowKey, childrenColumnName, recordKey, eachIndex);
+      childrenMap.forEach((value, key) => kvMap.set(key, value));
+    }
+    const newRecord = {
+      ...record,
+      map_row_key: recordKey,
+      map_row_parentKey: parentKey
     };
-    fillNewRecord(action === 'top');
-    map.forEach(function (value) {
-      if (value.map_row_parentKey && value.map_row_key) {
-        var _kvArrayMap$get2;
-        var map_row_parentKey = value.map_row_parentKey,
-          map_row_key = value.map_row_key,
-          rest = _objectWithoutProperties(value, _excluded2);
-        if (kvArrayMap.has(map_row_key)) {
-          rest[childrenColumnName] = kvArrayMap.get(map_row_key);
+    delete newRecord.children;
+    if (!parentKey) {
+      delete newRecord.map_row_parentKey;
+    }
+    kvMap.set(recordKey, newRecord);
+  });
+  return kvMap;
+}
+
+/**
+ * 重建树结构
+ */
+function rebuildTreeStructure(map, childrenColumnName, action) {
+  const childrenMap = new Map();
+  const result = [];
+  const addNewRecordToChildren = fillChildren => {
+    map.forEach(value => {
+      if (value.map_row_parentKey != null && !value.map_row_key) {
+        const {
+          map_row_parentKey,
+          ...rest
+        } = value;
+        const parentKeyStr = String(map_row_parentKey);
+        if (!childrenMap.has(parentKeyStr)) {
+          childrenMap.set(parentKeyStr, []);
         }
-        if (!kvArrayMap.has(map_row_parentKey)) {
-          kvArrayMap.set(map_row_parentKey, []);
+        if (fillChildren) {
+          childrenMap.get(parentKeyStr)?.push(rest);
         }
-        (_kvArrayMap$get2 = kvArrayMap.get(map_row_parentKey)) === null || _kvArrayMap$get2 === void 0 || _kvArrayMap$get2.push(rest);
       }
     });
-    fillNewRecord(action === 'update');
-    map.forEach(function (value) {
-      if (!value.map_row_parentKey) {
-        var map_row_key = value.map_row_key,
-          rest = _objectWithoutProperties(value, _excluded3);
-        if (map_row_key && kvArrayMap.has(map_row_key)) {
-          var item = _objectSpread(_objectSpread({}, rest), {}, _defineProperty({}, childrenColumnName, kvArrayMap.get(map_row_key)));
-          kvSource.push(item);
-          return;
+  };
+  addNewRecordToChildren(action === 'top');
+
+  // 第一步：将所有有 parentKey 的节点添加到 childrenMap
+  // 这一步不获取 children，只是添加节点到对应的父节点下
+  map.forEach(value => {
+    if (value.map_row_parentKey != null && value.map_row_key) {
+      const {
+        map_row_parentKey,
+        map_row_key,
+        isNewRecord,
+        ...rest
+      } = value;
+      const record = {
+        ...rest,
+        map_row_key
+      };
+      // 确保 parentKey 的类型转换与 flattenRecordsToMap 中的 recordKey 一致
+      // 在 flattenRecordsToMap 中，recordKey 被转换为字符串：getRowKey(record, eachIndex).toString()
+      // 所以这里也需要确保 parentKey 被转换为字符串，并且类型一致
+      const parentKeyStr = map_row_parentKey != null ? String(map_row_parentKey) : null;
+      if (!parentKeyStr) {
+        return;
+      }
+      if (!childrenMap.has(parentKeyStr)) {
+        childrenMap.set(parentKeyStr, []);
+      }
+
+      // 如果是新记录且 action 为 'top'，添加到数组开头；否则添加到末尾
+      if (isNewRecord && action === 'top') {
+        childrenMap.get(parentKeyStr)?.unshift(record);
+      } else {
+        childrenMap.get(parentKeyStr)?.push(record);
+      }
+    }
+  });
+
+  // 第二步：为所有节点获取 children
+  // 这一步确保所有子节点都已经被添加到 childrenMap，所以可以正确获取 children
+  map.forEach(value => {
+    if (value.map_row_parentKey != null && value.map_row_key) {
+      const {
+        map_row_parentKey,
+        map_row_key
+      } = value;
+      const parentKeyStr = map_row_parentKey != null ? String(map_row_parentKey) : null;
+      if (!parentKeyStr) {
+        return;
+      }
+      const children = childrenMap.get(parentKeyStr);
+      if (children && children.length > 0) {
+        // 找到对应的 record 并添加 children
+        const recordIndex = children.findIndex(r => {
+          // 比较时需要确保类型一致
+          const recordKey = r.map_row_key || r.id;
+          return String(recordKey) === String(map_row_key);
+        });
+        if (recordIndex >= 0 && childrenMap.has(map_row_key)) {
+          children[recordIndex] = {
+            ...children[recordIndex],
+            [childrenColumnName]: childrenMap.get(map_row_key)
+          };
         }
-        kvSource.push(rest);
       }
-    });
-    return kvSource;
-  };
-  return fill(kvMap);
+    }
+  });
+  addNewRecordToChildren(action === 'update');
+  map.forEach(value => {
+    if (!value.map_row_parentKey) {
+      const {
+        map_row_key,
+        ...rest
+      } = value;
+      const record = map_row_key && childrenMap.has(map_row_key) ? {
+        ...rest,
+        [childrenColumnName]: childrenMap.get(map_row_key)
+      } : rest;
+      result.push(record);
+    }
+  });
+  return result;
+}
+
+/**
+ * 使用map 来删除数据，性能一般 但是准确率比较高
+ */
+export function editableRowByKey(keyProps, action) {
+  const {
+    getRowKey,
+    row,
+    data,
+    childrenColumnName = 'children'
+  } = keyProps;
+  const key = recordKeyToString(keyProps.key)?.toString();
+  const kvMap = flattenRecordsToMap(data, getRowKey, childrenColumnName);
+  if (action === 'delete') {
+    kvMap.delete(key);
+  } else if (action === 'top' || action === 'update') {
+    const existingRecord = kvMap.get(key);
+    if (existingRecord) {
+      kvMap.set(key, {
+        ...existingRecord,
+        ...row
+      });
+    } else {
+      // 如果记录不存在，创建一个新记录（用于新增场景）
+      // 保留 map_row_parentKey 以便正确处理嵌套子节点
+      // 添加标记以便在 rebuildTreeStructure 中识别新记录
+      kvMap.set(key, {
+        ...row,
+        map_row_key: key,
+        map_row_parentKey: row.map_row_parentKey,
+        isNewRecord: true
+      });
+    }
+  }
+  return rebuildTreeStructure(kvMap, childrenColumnName, action);
 }
 
 /**
@@ -147,99 +211,83 @@ export function editableRowByKey(keyProps, action) {
  *
  * @param ActionRenderConfig
  */
-export function SaveEditableAction(_ref, ref) {
-  var recordKey = _ref.recordKey,
-    onSave = _ref.onSave,
-    row = _ref.row,
-    children = _ref.children,
-    newLineConfig = _ref.newLineConfig,
-    editorType = _ref.editorType,
-    tableName = _ref.tableName;
-  var context = useContext(ProFormContext);
-  var form = Form.useFormInstance();
-  var _useMountMergeState = useMountMergeState(false),
-    _useMountMergeState2 = _slicedToArray(_useMountMergeState, 2),
-    loading = _useMountMergeState2[0],
-    setLoading = _useMountMergeState2[1];
-  var save = useRefFunction( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-    var _context$getFieldForm, isMapEditor, namePath, fields, _recordKey, recordKeyPath, curValue, data, res;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _context.prev = 0;
-          isMapEditor = editorType === 'Map'; // 为了兼容类型为 array 的 dataIndex,当 recordKey 是一个数组时，用于获取表单值的 key 只取第一项，
-          // 从表单中获取回来之后，再根据 namepath 获取具体的某个字段并设置
-          namePath = [tableName, Array.isArray(recordKey) ? recordKey[0] : recordKey].map(function (key) {
-            return key === null || key === void 0 ? void 0 : key.toString();
-          }).flat(1).filter(Boolean);
-          setLoading(true);
-          _context.next = 6;
-          return form.validateFields(namePath, {
-            recursive: true
-          });
-        case 6:
-          fields = (context === null || context === void 0 || (_context$getFieldForm = context.getFieldFormatValue) === null || _context$getFieldForm === void 0 ? void 0 : _context$getFieldForm.call(context, namePath)) || form.getFieldValue(namePath); // 处理 dataIndex 为数组的情况
-          if (Array.isArray(recordKey) && recordKey.length > 1) {
-            // 获取 namepath
-            _recordKey = _toArray(recordKey), recordKeyPath = _recordKey.slice(1); // 将目标值获取出来并设置到 fields 当中
-            curValue = get(fields, recordKeyPath);
-            set(fields, recordKeyPath, curValue);
-          }
-          data = isMapEditor ? set({}, namePath, fields) : fields; // 获取数据并保存
-          _context.next = 11;
-          return onSave === null || onSave === void 0 ? void 0 : onSave(recordKey,
-          // 如果是 map 模式，fields 就是一个值，所以需要set 到对象中
-          // 数据模式 fields 是一个对象，所以不需要
-          merge({}, row, data), row, newLineConfig);
-        case 11:
-          res = _context.sent;
-          setLoading(false);
-          return _context.abrupt("return", res);
-        case 16:
-          _context.prev = 16;
-          _context.t0 = _context["catch"](0);
-          setLoading(false);
-          throw _context.t0;
-        case 20:
-        case "end":
-          return _context.stop();
+export function SaveEditableAction({
+  recordKey,
+  onSave,
+  row,
+  children,
+  newLineConfig,
+  editorType,
+  tableName
+}, ref) {
+  const context = useContext(ProFormContext);
+  const form = Form.useFormInstance();
+  const [loading, setLoading] = useState(false);
+  const save = useRefFunction(async () => {
+    try {
+      const isMapEditor = editorType === 'Map';
+      // 为了兼容类型为 array 的 dataIndex,当 recordKey 是一个数组时，用于获取表单值的 key 只取第一项，
+      // 从表单中获取回来之后，再根据 namepath 获取具体的某个字段并设置
+      const namePath = normalizeNamePath(tableName, Array.isArray(recordKey) ? recordKey[0] : recordKey);
+      setLoading(true);
+      try {
+        await form.validateFields(namePath, {
+          recursive: true
+        });
+      } catch (error) {
+        setLoading(false);
+        // 重新抛出验证错误，让表单显示错误信息
+        // validateFields 抛出错误时，表单会自动设置错误状态并显示错误
+        // 错误对象包含 errorFields，表单会根据这些字段显示错误
+        // 确保错误被正确传播，这样表单可以正确显示验证错误
+        throw error;
+      }
+      const fields = (() => {
+        // `getFieldFormatValue` will unwrap object results (by returning the first value),
+        // which breaks editable row save when `namePath` points to a row object.
+        // Prefer `getFieldFormatValueObject` and then pick the row by `namePath`.
+        const formattedObject = context?.getFieldFormatValueObject?.(namePath);
+        const formattedRow = formattedObject != null ? get(formattedObject, namePath) : null;
+        return formattedRow ?? form.getFieldValue(namePath);
+      })();
+      // 处理 dataIndex 为数组的情况
+      if (Array.isArray(recordKey) && recordKey.length > 1) {
+        // 获取 namepath
+        const [, ...recordKeyPath] = recordKey;
+        // 将目标值获取出来并设置到 fields 当中
+        const curValue = get(fields, recordKeyPath);
+        set(fields, recordKeyPath, curValue);
       }
-    }, _callee, null, [[0, 16]]);
-  })));
+      const data = isMapEditor ? set({}, namePath, fields) : fields;
+
+      // 获取数据并保存
+      const res = await onSave?.(recordKey,
+      // 如果是 map 模式，fields 就是一个值，所以需要set 到对象中
+      // 数据模式 fields 是一个对象，所以不需要
+      merge({}, row, data), row, newLineConfig);
+      setLoading(false);
+      return res;
+    } catch (error) {
+      setLoading(false);
+      throw error;
+    }
+  });
 
   // 保存数据
-  useImperativeHandle(ref, function () {
-    return {
-      save: save
-    };
-  }, [save]);
+  useImperativeHandle(ref, () => ({
+    save
+  }), [save]);
   return /*#__PURE__*/_jsxs("a", {
-    onClick: ( /*#__PURE__*/function () {
-      var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(e) {
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              e.stopPropagation();
-              e.preventDefault();
-              _context2.prev = 2;
-              _context2.next = 5;
-              return save();
-            case 5:
-              _context2.next = 9;
-              break;
-            case 7:
-              _context2.prev = 7;
-              _context2.t0 = _context2["catch"](2);
-            case 9:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, null, [[2, 7]]);
-      }));
-      return function (_x) {
-        return _ref3.apply(this, arguments);
-      };
-    }()),
+    onClick: async e => {
+      e.stopPropagation();
+      e.preventDefault();
+      try {
+        await save();
+      } catch {
+        // 验证错误会被 form.validateFields 抛出，这里不需要处理
+        // 错误会被表单自动显示
+      }
+    },
     children: [loading ? /*#__PURE__*/_jsx(LoadingOutlined, {
       style: {
         marginInlineEnd: 8
@@ -252,52 +300,41 @@ export function SaveEditableAction(_ref, ref) {
  *
  * @param ActionRenderConfig
  */
-export var DeleteEditableAction = function DeleteEditableAction(_ref4) {
-  var recordKey = _ref4.recordKey,
-    onDelete = _ref4.onDelete,
-    preEditRowRef = _ref4.preEditRowRef,
-    row = _ref4.row,
-    children = _ref4.children,
-    deletePopconfirmMessage = _ref4.deletePopconfirmMessage;
-  var _useMountMergeState3 = useMountMergeState(function () {
-      return false;
-    }),
-    _useMountMergeState4 = _slicedToArray(_useMountMergeState3, 2),
-    loading = _useMountMergeState4[0],
-    setLoading = _useMountMergeState4[1];
-  var _onConfirm = useRefFunction( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-    var res;
-    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-      while (1) switch (_context3.prev = _context3.next) {
-        case 0:
-          _context3.prev = 0;
-          setLoading(true);
-          _context3.next = 4;
-          return onDelete === null || onDelete === void 0 ? void 0 : onDelete(recordKey, row);
-        case 4:
-          res = _context3.sent;
-          setLoading(false);
-          return _context3.abrupt("return", res);
-        case 9:
-          _context3.prev = 9;
-          _context3.t0 = _context3["catch"](0);
-          setLoading(false);
-          return _context3.abrupt("return", null);
-        case 13:
-          _context3.prev = 13;
-          if (preEditRowRef) preEditRowRef.current = null;
-          return _context3.finish(13);
-        case 16:
-        case "end":
-          return _context3.stop();
+export const DeleteEditableAction = ({
+  recordKey,
+  onDelete,
+  preEditRowRef,
+  preEditRowRefs,
+  row,
+  children,
+  deletePopconfirmMessage
+}) => {
+  const [loading, setLoading] = useState(false);
+  const onConfirm = useRefFunction(async () => {
+    try {
+      setLoading(true);
+      const res = await onDelete?.(recordKey, row);
+      setLoading(false);
+      // 如果返回 false，阻止删除操作
+      if (res === false) {
+        return false;
+      }
+      return res;
+    } catch {
+      setLoading(false);
+      return null;
+    } finally {
+      const recordKeyStr = recordKeyToString(recordKey)?.toString();
+      if (recordKeyStr) {
+        preEditRowRefs?.current?.delete(recordKeyStr);
       }
-    }, _callee3, null, [[0, 9, 13, 16]]);
-  })));
+      if (preEditRowRef) preEditRowRef.current = null;
+    }
+  });
   return children !== false ? /*#__PURE__*/_jsx(Popconfirm, {
-    title: deletePopconfirmMessage,
-    onConfirm: function onConfirm() {
-      return _onConfirm();
-    },
+    title: deletePopconfirmMessage || '确定要删除这条记录吗？',
+    onConfirm: onConfirm,
+    getPopupContainer: triggerNode => triggerNode.parentElement || document.body,
     children: /*#__PURE__*/_jsxs("a", {
       children: [loading ? /*#__PURE__*/_jsx(LoadingOutlined, {
         style: {
@@ -307,86 +344,91 @@ export var DeleteEditableAction = function DeleteEditableAction(_ref4) {
     })
   }, "delete") : null;
 };
-var CancelEditableAction = function CancelEditableAction(props) {
-  var recordKey = props.recordKey,
-    tableName = props.tableName,
-    newLineConfig = props.newLineConfig,
-    editorType = props.editorType,
-    onCancel = props.onCancel,
-    cancelEditable = props.cancelEditable,
-    row = props.row,
-    cancelText = props.cancelText,
-    preEditRowRef = props.preEditRowRef;
-  var context = useContext(ProFormContext);
-  var form = Form.useFormInstance();
+const CancelEditableAction = props => {
+  const {
+    recordKey,
+    tableName,
+    newLineConfig,
+    editorType,
+    onCancel,
+    cancelEditable,
+    row,
+    cancelText,
+    preEditRowRef,
+    preEditRowRefs
+  } = props;
+  const context = useContext(ProFormContext);
+  const form = Form.useFormInstance();
   return /*#__PURE__*/_jsx("a", {
-    onClick: ( /*#__PURE__*/function () {
-      var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(e) {
-        var _context$getFieldForm2;
-        var isMapEditor, namePath, fields, record, res, _props$onDelete;
-        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              e.stopPropagation();
-              e.preventDefault();
-              isMapEditor = editorType === 'Map';
-              namePath = [tableName, recordKey].flat(1).filter(Boolean);
-              fields = (context === null || context === void 0 || (_context$getFieldForm2 = context.getFieldFormatValue) === null || _context$getFieldForm2 === void 0 ? void 0 : _context$getFieldForm2.call(context, namePath)) || (form === null || form === void 0 ? void 0 : form.getFieldValue(namePath));
-              record = isMapEditor ? set({}, namePath, fields) : fields;
-              _context4.next = 8;
-              return onCancel === null || onCancel === void 0 ? void 0 : onCancel(recordKey, record, row, newLineConfig);
-            case 8:
-              res = _context4.sent;
-              _context4.next = 11;
-              return cancelEditable(recordKey);
-            case 11:
-              if (!((preEditRowRef === null || preEditRowRef === void 0 ? void 0 : preEditRowRef.current) !== null)) {
-                _context4.next = 15;
-                break;
-              }
-              form.setFieldsValue(set({}, namePath, preEditRowRef === null || preEditRowRef === void 0 ? void 0 : preEditRowRef.current));
-              _context4.next = 17;
-              break;
-            case 15:
-              _context4.next = 17;
-              return (_props$onDelete = props.onDelete) === null || _props$onDelete === void 0 ? void 0 : _props$onDelete.call(props, recordKey, row);
-            case 17:
-              if (preEditRowRef) preEditRowRef.current = null;
-              return _context4.abrupt("return", res);
-            case 19:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4);
-      }));
-      return function (_x2) {
-        return _ref6.apply(this, arguments);
-      };
-    }()),
+    onClick: async e => {
+      e.stopPropagation();
+      e.preventDefault();
+      const isMapEditor = editorType === 'Map';
+      const recordKeyStr = recordKeyToString(recordKey)?.toString();
+      const namePath = normalizeNamePath(tableName, recordKey);
+      const fields = (() => {
+        const formattedObject = context?.getFieldFormatValueObject?.(namePath);
+        const formattedRow = formattedObject != null ? get(formattedObject, namePath) : null;
+        return formattedRow ?? form?.getFieldValue(namePath);
+      })();
+      const record = isMapEditor ? set({}, namePath, fields) : fields;
+
+      // 在清理编辑态前，先捕获“编辑前快照”（多行编辑时必须按 key 取值）
+      const cachedPreEditRow = recordKeyStr != null ? preEditRowRefs?.current?.get(recordKeyStr) : undefined;
+      const isNewLineKeyMatch = (() => {
+        const newLineKey = newLineConfig?.options?.recordKey;
+        if (newLineKey == null || recordKey == null) return false;
+        const newLineKeyStr = recordKeyToString(newLineKey)?.toString();
+        const currentKeyStr = recordKeyToString(recordKey)?.toString();
+        if (!newLineKeyStr || !currentKeyStr) return false;
+        return newLineKeyStr === currentKeyStr;
+      })();
+      const res = await onCancel?.(recordKey, record, row, newLineConfig);
+      await cancelEditable(recordKey);
+      /** 重置为默认值，不然编辑的行会丢掉 */
+      const restoreRow = cachedPreEditRow ?? preEditRowRef?.current ?? row;
+      const shouldDeleteNewRow = cachedPreEditRow === null || cachedPreEditRow === undefined && preEditRowRef?.current === null && isNewLineKeyMatch;
+      if (shouldDeleteNewRow) {
+        // 如果不存在历史值，说明是新的行，干掉他
+        await props.onDelete?.(recordKey, row);
+      } else if (restoreRow != null) {
+        form.setFieldsValue(set({}, namePath, restoreRow));
+      }
+      if (recordKeyStr) {
+        preEditRowRefs?.current?.delete(recordKeyStr);
+      }
+      if (preEditRowRef) preEditRowRef.current = null;
+      return res;
+    },
     children: cancelText || '取消'
   }, "cancel");
 };
 export function defaultActionRender(row, config) {
-  var recordKey = config.recordKey,
-    newLineConfig = config.newLineConfig,
-    saveText = config.saveText,
-    deleteText = config.deleteText;
-  var SaveEditableActionRef = /*#__PURE__*/forwardRef(SaveEditableAction);
-  var saveRef = /*#__PURE__*/createRef();
+  const {
+    recordKey,
+    newLineConfig,
+    saveText,
+    deleteText
+  } = config;
+  const SaveEditableActionRef = /*#__PURE__*/forwardRef(SaveEditableAction);
+  const saveRef = /*#__PURE__*/createRef();
   return {
-    save: /*#__PURE__*/_jsx(SaveEditableActionRef, _objectSpread(_objectSpread({}, config), {}, {
+    save: /*#__PURE__*/_jsx(SaveEditableActionRef, {
+      ...config,
       row: row,
       ref: saveRef,
       children: saveText
-    }), 'save' + recordKey),
-    saveRef: saveRef,
-    delete: (newLineConfig === null || newLineConfig === void 0 ? void 0 : newLineConfig.options.recordKey) !== recordKey ? /*#__PURE__*/_jsx(DeleteEditableAction, _objectSpread(_objectSpread({}, config), {}, {
+    }, 'save' + recordKey),
+    saveRef,
+    delete: newLineConfig?.options.recordKey !== recordKey ? /*#__PURE__*/_jsx(DeleteEditableAction, {
+      ...config,
       row: row,
       children: deleteText
-    }), 'delete' + recordKey) : undefined,
-    cancel: /*#__PURE__*/_jsx(CancelEditableAction, _objectSpread(_objectSpread({}, config), {}, {
+    }, 'delete' + recordKey) : undefined,
+    cancel: /*#__PURE__*/_jsx(CancelEditableAction, {
+      ...config,
       row: row
-    }), 'cancel' + recordKey)
+    }, 'cancel' + recordKey)
   };
 }
 
@@ -397,470 +439,516 @@ export function defaultActionRender(row, config) {
  */
 export function useEditableArray(props) {
   // Internationalization
-  var intl = useIntl();
+  const intl = useIntl();
 
   /**
    * 点击开始编辑之前的保存数据用的
    */
-  var preEditRowRef = useRef(null);
-  var _useState = useState(undefined),
-    _useState2 = _slicedToArray(_useState, 2),
-    newLineRecordCache = _useState2[0],
-    setNewLineRecordCache = _useState2[1];
-  var resetMapRef = function resetMapRef() {
-    var map = new Map();
-    //存在children时会覆盖Map的key,导致使用数组索引查找key错误
-    var loopGetKey = function loopGetKey(dataSource, parentKey) {
-      dataSource === null || dataSource === void 0 || dataSource.forEach(function (record, index) {
-        var _recordKeyToString2;
-        var key = parentKey === undefined || parentKey === null ? index.toString() : parentKey + '_' + index.toString();
-        map.set(key, recordKeyToString(props.getRowKey(record, -1)));
-        map.set((_recordKeyToString2 = recordKeyToString(props.getRowKey(record, -1))) === null || _recordKeyToString2 === void 0 ? void 0 : _recordKeyToString2.toString(), key);
-        if (props.childrenColumnName && record !== null && record !== void 0 && record[props.childrenColumnName]) {
-          loopGetKey(record[props.childrenColumnName], key);
+  const preEditRowRef = useRef(null);
+  const preEditRowRefs = useRef(new Map());
+  const [newLineRecordCache, setNewLineRecordCache] = useState(undefined);
+
+  /**
+   * 构建数据源 key 索引映射表
+   */
+  const buildDataSourceKeyIndexMap = useRefFunction(() => {
+    const map = new Map();
+    const traverseRecords = (records, parentKey) => {
+      records?.forEach((record, index) => {
+        const indexKey = parentKey == null ? index.toString() : `${parentKey}_${index}`;
+        const recordKey = recordKeyToString(props.getRowKey(record, -1));
+
+        // 如果 recordKey 是 undefined 或 null，跳过
+        if (recordKey == null) {
+          return;
+        }
+        map.set(indexKey, recordKey);
+        map.set(recordKey.toString(), indexKey);
+        const children = props.childrenColumnName && record?.[props.childrenColumnName];
+        if (children) {
+          traverseRecords(children, indexKey);
         }
       });
     };
-    loopGetKey(props.dataSource);
+    traverseRecords(props.dataSource);
     return map;
-  };
-  var initDataSourceKeyIndexMap = useMemo(function () {
-    return resetMapRef();
-  }, []);
-  var dataSourceKeyIndexMapRef = useRef(initDataSourceKeyIndexMap);
-  var newLineRecordRef = useRef(undefined);
-  useDeepCompareEffectDebounce(function () {
-    dataSourceKeyIndexMapRef.current = resetMapRef();
+  });
+  const initDataSourceKeyIndexMap = useMemo(() => buildDataSourceKeyIndexMap(), []);
+  const dataSourceKeyIndexMapRef = useRef(initDataSourceKeyIndexMap);
+  const newLineRecordRef = useRef(undefined);
+  useDeepCompareEffectDebounce(() => {
+    dataSourceKeyIndexMapRef.current = buildDataSourceKeyIndexMap();
   }, [props.dataSource]);
 
   // 这里这么做是为了存上次的状态，不然每次存一下再拿
   newLineRecordRef.current = newLineRecordCache;
-  var editableType = props.type || 'single';
-  var _useLazyKVMap = useLazyKVMap(props.dataSource, 'children', props.getRowKey),
-    _useLazyKVMap2 = _slicedToArray(_useLazyKVMap, 1),
-    getRecordByKey = _useLazyKVMap2[0];
-  var _useMergedState = useMergedState([], {
-      value: props.editableKeys,
-      onChange: props.onChange ? function (keys) {
-        var _props$onChange, _keys$filter, _keys$map$filter;
-        props === null || props === void 0 || (_props$onChange = props.onChange) === null || _props$onChange === void 0 || _props$onChange.call(props, // 计算编辑的key
-        (_keys$filter = keys === null || keys === void 0 ? void 0 : keys.filter(function (key) {
-          return key !== undefined;
-        })) !== null && _keys$filter !== void 0 ? _keys$filter : [], // 计算编辑的行
-        (_keys$map$filter = keys === null || keys === void 0 ? void 0 : keys.map(function (key) {
-          return getRecordByKey(key);
-        }).filter(function (key) {
-          return key !== undefined;
-        })) !== null && _keys$map$filter !== void 0 ? _keys$map$filter : []);
-      } : undefined
-    }),
-    _useMergedState2 = _slicedToArray(_useMergedState, 2),
-    editableKeys = _useMergedState2[0],
-    setEditableRowKeys = _useMergedState2[1];
-
-  /** 一个用来标志的set 提供了方便的 api 来去重什么的 */
-  var editableKeysSet = useMemo(function () {
-    var keys = editableType === 'single' ? editableKeys === null || editableKeys === void 0 ? void 0 : editableKeys.slice(0, 1) : editableKeys;
-    return new Set(keys);
-  }, [(editableKeys || []).join(','), editableType]);
-  var editableKeysRef = usePrevious(editableKeys);
+  const editableType = props.type || 'single';
+  const [getRecordByKey] = useLazyKVMap(props.dataSource, 'children', props.getRowKey);
+  const [editableKeys, setEditableRowKeysInner] = useControlledState([], props.editableKeys);
+  const setEditableRowKeys = useCallback(updater => {
+    setEditableRowKeysInner(prev => {
+      const next = typeof updater === 'function' ? updater(prev) : updater;
+      props?.onChange?.(next?.filter(key => key !== undefined) ?? [], next?.map(key => getRecordByKey(key)).filter(k => k !== undefined) ?? []);
+      return next;
+    });
+  }, [props.onChange, getRecordByKey]);
+  const editableKeysRef = usePrevious(editableKeys);
+
+  /**
+   * 检查 key 是否在编辑列表中
+   */
+  const checkKeyInEditableList = useRefFunction((key, keysList) => {
+    return keysList.includes(key);
+  });
 
   /** 这行是不是编辑状态 */
-  var isEditable = useRefFunction(function (row) {
-    var _props$getRowKey, _props$getRowKey$toSt, _props$getRowKey2, _props$getRowKey2$toS;
-    // 为了兼容一下name 模式的 indexKey，所以需要判断两次，一次是index，一次是没有 index 的
-    var recordKeyOrIndex = (_props$getRowKey = props.getRowKey(row, row.index)) === null || _props$getRowKey === void 0 || (_props$getRowKey$toSt = _props$getRowKey.toString) === null || _props$getRowKey$toSt === void 0 ? void 0 : _props$getRowKey$toSt.call(_props$getRowKey);
-    // 这里是不设置 index 的地方
-    var recordKey = (_props$getRowKey2 = props.getRowKey(row, -1)) === null || _props$getRowKey2 === void 0 || (_props$getRowKey2$toS = _props$getRowKey2.toString) === null || _props$getRowKey2$toS === void 0 ? void 0 : _props$getRowKey2$toS.call(_props$getRowKey2);
-
-    // 都转化为了字符串，不然 number 和 string
-    var stringEditableKeys = editableKeys === null || editableKeys === void 0 ? void 0 : editableKeys.map(function (key) {
-      return key === null || key === void 0 ? void 0 : key.toString();
-    });
-    var stringEditableKeysRef = (editableKeysRef === null || editableKeysRef === void 0 ? void 0 : editableKeysRef.map(function (key) {
-      return key === null || key === void 0 ? void 0 : key.toString();
-    })) || [];
-    var preIsEditable = props.tableName && !!(stringEditableKeysRef !== null && stringEditableKeysRef !== void 0 && stringEditableKeysRef.includes(recordKey)) || !!(stringEditableKeysRef !== null && stringEditableKeysRef !== void 0 && stringEditableKeysRef.includes(recordKeyOrIndex));
+  const isEditable = useRefFunction(row => {
+    const recordKeyWithIndex = props.getRowKey(row, row.index)?.toString();
+    const recordKey = props.getRowKey(row, -1)?.toString();
+    const stringEditableKeys = editableKeys?.map(key => key?.toString()) || [];
+    const stringEditableKeysRef = editableKeysRef?.map(key => key?.toString()) || [];
+    const preIsEditable = checkKeyInEditableList(recordKey, stringEditableKeysRef) || checkKeyInEditableList(recordKeyWithIndex, stringEditableKeysRef);
     return {
-      recordKey: recordKey,
-      isEditable: props.tableName && (stringEditableKeys === null || stringEditableKeys === void 0 ? void 0 : stringEditableKeys.includes(recordKey)) || (stringEditableKeys === null || stringEditableKeys === void 0 ? void 0 : stringEditableKeys.includes(recordKeyOrIndex)),
-      preIsEditable: preIsEditable
+      recordKey,
+      isEditable: checkKeyInEditableList(recordKey, stringEditableKeys) || checkKeyInEditableList(recordKeyWithIndex, stringEditableKeys),
+      preIsEditable
     };
   });
 
   /**
-   * 进入编辑状态
-   *
-   * @param recordKey
+   * 验证是否可以开始编辑
    */
-  var startEditable = useRefFunction(function (recordKey, record) {
-    var _ref7, _props$dataSource;
-    // 如果是单行的话，不允许多行编辑
-    if (editableKeysSet.size > 0 && editableType === 'single' && props.onlyOneLineEditorAlertMessage !== false) {
+  const validateCanStartEdit = useRefFunction(() => {
+    const hasEditableKeys = editableKeys && editableKeys.length > 0;
+    if (hasEditableKeys && editableType === 'single' && props.onlyOneLineEditorAlertMessage !== false) {
       warning(props.onlyOneLineEditorAlertMessage || intl.getMessage('editableTable.onlyOneLineEditor', '只能同时编辑一行'));
       return false;
     }
-    editableKeysSet.add(recordKey);
-    setEditableRowKeys(Array.from(editableKeysSet));
+    return true;
+  });
 
-    // 这里是为了存上次的状态,不然取消的时候就丢掉了
-    preEditRowRef.current = (_ref7 = record !== null && record !== void 0 ? record : (_props$dataSource = props.dataSource) === null || _props$dataSource === void 0 ? void 0 : _props$dataSource.find(function (recordData, index) {
+  /**
+   * 查找记录
+   */
+  const findRecordByKey = useRefFunction(recordKey => {
+    return props.dataSource?.find((recordData, index) => {
       return props.getRowKey(recordData, index) === recordKey;
-    })) !== null && _ref7 !== void 0 ? _ref7 : null;
+    }) ?? null;
+  });
+
+  /**
+   * 进入编辑状态
+   */
+  const startEditable = useRefFunction((recordKey, record) => {
+    if (!validateCanStartEdit()) {
+      return false;
+    }
+    const isAlreadyEditable = editableKeys?.some(key => key === recordKey || key?.toString() === recordKey?.toString());
+    if (!isAlreadyEditable) {
+      const newKeys = editableKeys ? [...editableKeys, recordKey] : [recordKey];
+      setEditableRowKeys(newKeys);
+    }
+    preEditRowRef.current = record ?? findRecordByKey(recordKey) ?? null;
+    const recordKeyStr = recordKeyToString(recordKey)?.toString();
+    if (recordKeyStr) {
+      preEditRowRefs.current.set(recordKeyStr, preEditRowRef.current);
+    }
     return true;
   });
 
+  /**
+   * 清理编辑状态
+   */
+  const clearEditableState = useRefFunction(recordKey => {
+    const relayKey = recordKeyToString(recordKey);
+    const relayKeyStr = relayKey != null ? relayKey.toString() : null;
+    if (relayKeyStr == null) {
+      return;
+    }
+    const newKeys = editableKeys?.filter(key => key?.toString() !== relayKeyStr && key !== relayKey) ?? [];
+    setEditableRowKeys(newKeys);
+  });
+
   /**
    * 退出编辑状态
-   *
-   * @param recordKey
    */
-  var cancelEditable = useRefFunction( /*#__PURE__*/function () {
-    var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(recordKey, needReTry) {
-      var relayKey, key;
-      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-        while (1) switch (_context5.prev = _context5.next) {
-          case 0:
-            relayKey = recordKeyToString(recordKey).toString();
-            key = dataSourceKeyIndexMapRef.current.get(relayKey);
-            /** 如果没找到key，转化一下再去找 */
-            if (!(!editableKeysSet.has(relayKey) && key && (needReTry !== null && needReTry !== void 0 ? needReTry : true) && props.tableName)) {
-              _context5.next = 5;
-              break;
-            }
-            cancelEditable(key, false);
-            return _context5.abrupt("return");
-          case 5:
-            /** 如果这个是 new Line 直接删除 */
-            if (newLineRecordCache && newLineRecordCache.options.recordKey === recordKey) {
-              setNewLineRecordCache(undefined);
+  const cancelEditable = useRefFunction(async (recordKey, needReTry) => {
+    const relayKey = recordKeyToString(recordKey);
+    const relayKeyStr = relayKey != null ? relayKey.toString() : null;
+    const mappedKey = relayKeyStr != null ? dataSourceKeyIndexMapRef.current.get(relayKeyStr) : undefined;
+    const isInEditableSet = editableKeys?.some(key => {
+      if (relayKeyStr == null) return false;
+      return key?.toString() === relayKeyStr || key === relayKey;
+    });
+    if (!isInEditableSet && mappedKey && (needReTry ?? true) && props.tableName) {
+      return await cancelEditable(mappedKey, false);
+    }
+
+    // 如果提供了 onCancel，尝试调用它（用于测试场景）
+    // 注意：在实际使用中，onCancel 应该在 CancelEditableAction 中被调用
+    if (props.onCancel && isInEditableSet) {
+      const keyForFind = Array.isArray(recordKey) ? recordKey[0] : recordKey;
+      const record = findRecordByKey(keyForFind);
+      const originRow = preEditRowRef.current;
+      // 比较 recordKey 时需要考虑类型转换
+      // newLineRecordCache.options.recordKey 是 addEditRecord 时设置的 recordKey
+      // 而 recordKey 是 cancelEditable 的参数，需要确保它们匹配
+      const cacheRecordKey = newLineRecordCache?.options?.recordKey;
+      const cacheKey = cacheRecordKey != null ? recordKeyToString(cacheRecordKey) : null;
+      const cacheKeyStr = cacheKey != null ? cacheKey.toString() : null;
+      // 检查 newLineRecordCache 是否匹配当前的 recordKey
+      const newLineConfig = newLineRecordCache != null && cacheRecordKey != null && (cacheRecordKey === recordKey || cacheKeyStr != null && relayKeyStr != null && cacheKeyStr === relayKeyStr || cacheRecordKey?.toString() === recordKey?.toString() || String(cacheRecordKey) === String(recordKey)) ? newLineRecordCache : undefined;
+
+      // 调用 onCancel，即使找不到记录（新行编辑场景）
+      // 对于新行编辑，record 可能为 null，但 newLineConfig 应该包含 defaultValue
+      try {
+        await props.onCancel(recordKey, record || newLineConfig?.defaultValue || {}, originRow || record || newLineConfig?.defaultValue || {}, newLineConfig);
+      } catch (error) {
+        // 如果 onCancel 抛出异常，仍然继续清理状态
+        console.error('onCancel error:', error);
+      }
+    }
+
+    // 清理 newLineRecordCache，需要比较 recordKey（考虑类型转换）
+    if (newLineRecordCache) {
+      const cacheRecordKey = newLineRecordCache.options.recordKey;
+      // 重用之前计算的 relayKeyStr
+      const cacheKeyStr = cacheRecordKey != null ? recordKeyToString(cacheRecordKey)?.toString() : null;
+      if (cacheRecordKey === recordKey || cacheKeyStr != null && relayKeyStr != null && cacheKeyStr === relayKeyStr || cacheRecordKey?.toString() === recordKey?.toString() || String(cacheRecordKey) === String(recordKey)) {
+        setNewLineRecordCache(undefined);
+      }
+    }
+
+    // 先清理 preEditRowRef 并重置表单字段，然后再清除编辑状态
+    // 这样在清除编辑状态前，表单字段已经被清除，表格重新渲染时就不会显示输入框
+    const originRow = preEditRowRef.current;
+    if (originRow && props.getRowKey(originRow, -1) === recordKey && isInEditableSet) {
+      try {
+        // 尝试通过 formProps.formRef 访问 form
+        const formRef = props.formProps?.formRef;
+        const form = formRef?.current || props.form;
+        if (form) {
+          if (props.tableName) {
+            // name 模式：重置为原始值
+            const namePath = normalizeNamePath(props.tableName, recordKey);
+            form.setFieldsValue(set({}, namePath, originRow));
+          } else {
+            // 非 name 模式：清除该行的所有表单字段
+            // 在非 name 模式下，表单字段路径是 [recordKey, columnDataIndex]
+            // 如 [624748504, 'title']，需要清除所有以 recordKey 开头的字段
+            const recordKeyStr = recordKeyToString(recordKey)?.toString();
+            if (recordKeyStr) {
+              try {
+                // 在非 name 模式下，表单字段以嵌套对象的形式存储
+                // 比如 { '624748504': { 'title': 'value', 'state': 'value' } }
+                // 需要清除整个嵌套对象
+                // 先使用 resetFields 清除字段状态
+                form.resetFields([[recordKeyStr]]);
+
+                // 然后使用 setFieldsValue 清除字段值
+                // 这样可以确保字段被完全清除，表格重新渲染时不会显示输入框
+                form.setFieldsValue({
+                  [recordKeyStr]: undefined
+                });
+              } catch (error) {
+                // 如果清除失败，忽略错误
+                console.warn('Failed to clear form fields in cancelEditable:', error);
+              }
             }
-            editableKeysSet.delete(relayKey);
-            editableKeysSet.delete(recordKeyToString(recordKey));
-            setEditableRowKeys(Array.from(editableKeysSet));
-            return _context5.abrupt("return", true);
-          case 10:
-          case "end":
-            return _context5.stop();
-        }
-      }, _callee5);
-    }));
-    return function (_x3, _x4) {
-      return _ref8.apply(this, arguments);
-    };
-  }());
-  var propsOnValuesChange = useDebounceFn( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
-    var _props$onValuesChange;
-    var _len,
-      rest,
-      _key,
-      _args6 = arguments;
-    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-      while (1) switch (_context6.prev = _context6.next) {
-        case 0:
-          for (_len = _args6.length, rest = new Array(_len), _key = 0; _key < _len; _key++) {
-            rest[_key] = _args6[_key];
           }
-          //@ts-ignore
-          (_props$onValuesChange = props.onValuesChange) === null || _props$onValuesChange === void 0 || _props$onValuesChange.call.apply(_props$onValuesChange, [props].concat(rest));
-        case 2:
-        case "end":
-          return _context6.stop();
+        }
+      } catch (error) {
+        // 如果访问 form 失败，忽略错误
+        console.warn('Failed to reset form fields in cancelEditable:', error);
       }
-    }, _callee6);
-  })), 64);
-  var onValuesChange = useRefFunction(function (value, values) {
-    var _Object$keys$pop;
-    if (!props.onValuesChange) {
-      return;
+      preEditRowRef.current = null;
     }
-    var dataSource = props.dataSource;
-
-    // 这里是把正在编辑中的所有表单数据都修改掉
-    // 不然会用 props 里面的 dataSource，数据只有正在编辑中的
-    // Object.keys(get(values, [props.tableName || ''].flat(1)) || values).forEach((recordKey) => {
-    editableKeys === null || editableKeys === void 0 || editableKeys.forEach(function (eachRecordKey) {
-      if ((newLineRecordCache === null || newLineRecordCache === void 0 ? void 0 : newLineRecordCache.options.recordKey) === eachRecordKey) return;
-      var recordKey = eachRecordKey.toString();
-      // 如果数据在这个 form 中没有展示，也不显示
-      var editRow = get(values, [props.tableName || '', recordKey].flat(1).filter(function (key) {
-        return key || key === 0;
-      }));
-      if (!editRow) return;
-      dataSource = editableRowByKey({
-        data: dataSource,
+
+    // 最后清除编辑状态，这样表格会重新渲染，输入框会消失
+    clearEditableState(recordKey);
+    return true;
+  });
+  const propsOnValuesChange = useDebounceFn(async (...rest) => {
+    //@ts-ignore
+    props.onValuesChange?.(...rest);
+  }, 64);
+
+  /**
+   * 构建表单字段路径
+   */
+  const buildFormFieldPath = useRefFunction(recordKey => {
+    return [props.tableName || '', recordKey].flat(1).filter(key => key || key === 0);
+  });
+
+  /**
+   * 更新数据源中的编辑行
+   */
+  const updateDataSourceWithEditableRows = useRefFunction((dataSource, values) => {
+    let updatedDataSource = dataSource;
+    editableKeys?.forEach(eachRecordKey => {
+      if (newLineRecordCache?.options.recordKey === eachRecordKey) {
+        return;
+      }
+      const recordKey = eachRecordKey.toString();
+      const fieldPath = buildFormFieldPath(recordKey);
+      const editRow = get(values, fieldPath);
+      if (!editRow) {
+        return;
+      }
+      updatedDataSource = editableRowByKey({
+        data: updatedDataSource,
         getRowKey: props.getRowKey,
         row: editRow,
         key: recordKey,
         childrenColumnName: props.childrenColumnName || 'children'
       }, 'update');
     });
-    var relayValue = value;
-    var recordKey = (_Object$keys$pop = Object.keys(relayValue || {}).pop()) === null || _Object$keys$pop === void 0 ? void 0 : _Object$keys$pop.toString();
-
-    //从form 和 cache 中取得数据
-    var newLineRecordData = _objectSpread(_objectSpread({}, newLineRecordCache === null || newLineRecordCache === void 0 ? void 0 : newLineRecordCache.defaultValue), get(values, [props.tableName || '', recordKey.toString()].flat(1).filter(function (key) {
-      return key || key === 0;
-    })));
-
-    /** 如果已经在 dataSource 中存在了，直接 find */
-    var editRow = dataSourceKeyIndexMapRef.current.has(recordKeyToString(recordKey)) ? dataSource.find(function (item, index) {
-      var _props$getRowKey3;
-      var key = (_props$getRowKey3 = props.getRowKey(item, index)) === null || _props$getRowKey3 === void 0 ? void 0 : _props$getRowKey3.toString();
-      return key === recordKey;
-    }) : newLineRecordData;
-    propsOnValuesChange.run(editRow || newLineRecordData, dataSource);
+    return updatedDataSource;
+  });
+
+  /**
+   * 获取当前编辑的行数据
+   */
+  const getCurrentEditRow = useRefFunction((value, values, dataSource) => {
+    const valueKeys = Object.keys(value || {});
+    if (valueKeys.length === 0) {
+      return newLineRecordCache?.defaultValue || {};
+    }
+    const recordKey = valueKeys.pop()?.toString() || '';
+    if (!recordKey) {
+      return newLineRecordCache?.defaultValue || {};
+    }
+    const fieldPath = buildFormFieldPath(recordKey);
+    const newLineRecordData = {
+      ...newLineRecordCache?.defaultValue,
+      ...get(values, fieldPath)
+    };
+    const existsInDataSource = dataSourceKeyIndexMapRef.current.has(recordKeyToString(recordKey));
+    if (existsInDataSource) {
+      const foundRow = dataSource.find((item, index) => {
+        const key = props.getRowKey(item, index)?.toString();
+        return key === recordKey;
+      });
+      return foundRow || newLineRecordData;
+    }
+    return newLineRecordData;
+  });
+  const onValuesChange = useRefFunction((value, values) => {
+    if (!props.onValuesChange) {
+      return;
+    }
+    const updatedDataSource = updateDataSourceWithEditableRows(props.dataSource, values);
+    const editRow = getCurrentEditRow(value, values, updatedDataSource);
+    propsOnValuesChange.run(editRow, updatedDataSource);
   });
-  var saveRefsMap = useRef(new Map());
-  useEffect(function () {
-    // 确保只保留编辑状态的，其它的都删除掉
-    saveRefsMap.current.forEach(function (ref, key) {
-      if (!editableKeysSet.has(key)) {
+  const saveRefsMap = useRef(new Map());
+  useEffect(() => {
+    const editableKeysSet = new Set(editableKeys?.map(key => key?.toString()) ?? []);
+    saveRefsMap.current.forEach((ref, key) => {
+      if (!editableKeysSet.has(key?.toString())) {
         saveRefsMap.current.delete(key);
       }
     });
-  }, [saveRefsMap, editableKeysSet]);
+  }, [editableKeys]);
+
+  /**
+   * 获取保存引用
+   */
+  const getSaveRef = useRefFunction(recordKey => {
+    const relayKey = recordKeyToString(recordKey);
+    return saveRefsMap.current.get(relayKey) || saveRefsMap.current.get(relayKey.toString());
+  });
+
   /**
    * 保存编辑行
-   *
-   * @param recordKey
-   * @param needReTry
    */
-  var saveEditable = useRefFunction( /*#__PURE__*/function () {
-    var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(recordKey, needReTry) {
-      var relayKey, key, saveRef, _saveRef$current;
-      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
-        while (1) switch (_context7.prev = _context7.next) {
-          case 0:
-            relayKey = recordKeyToString(recordKey);
-            key = dataSourceKeyIndexMapRef.current.get(recordKey.toString());
-            /** 如果没找到key，转化一下再去找 */
-            if (!(!editableKeysSet.has(relayKey) && key && (needReTry !== null && needReTry !== void 0 ? needReTry : true) && props.tableName)) {
-              _context7.next = 6;
-              break;
-            }
-            _context7.next = 5;
-            return saveEditable(key, false);
-          case 5:
-            return _context7.abrupt("return", _context7.sent);
-          case 6:
-            saveRef = saveRefsMap.current.get(relayKey) || saveRefsMap.current.get(relayKey.toString());
-            _context7.prev = 7;
-            _context7.next = 10;
-            return saveRef === null || saveRef === void 0 || (_saveRef$current = saveRef.current) === null || _saveRef$current === void 0 ? void 0 : _saveRef$current.save();
-          case 10:
-            _context7.next = 15;
-            break;
-          case 12:
-            _context7.prev = 12;
-            _context7.t0 = _context7["catch"](7);
-            return _context7.abrupt("return", false);
-          case 15:
-            editableKeysSet.delete(relayKey);
-            editableKeysSet.delete(relayKey.toString());
-            setEditableRowKeys(Array.from(editableKeysSet));
-            return _context7.abrupt("return", true);
-          case 19:
-          case "end":
-            return _context7.stop();
-        }
-      }, _callee7, null, [[7, 12]]);
-    }));
-    return function (_x5, _x6) {
-      return _ref10.apply(this, arguments);
-    };
-  }());
+  const saveEditable = useRefFunction(async (recordKey, needReTry) => {
+    const relayKey = recordKeyToString(recordKey);
+    const relayKeyStr = relayKey.toString();
+    const mappedKey = dataSourceKeyIndexMapRef.current.get(relayKeyStr);
+    const isInEditableSet = editableKeys?.some(key => key?.toString() === relayKeyStr || key === relayKey);
+    if (!isInEditableSet && mappedKey && (needReTry ?? true) && props.tableName) {
+      return await saveEditable(mappedKey, false);
+    }
+    const saveRef = getSaveRef(recordKey);
+    if (!saveRef?.current) {
+      return false;
+    }
+    await saveRef.current.save();
+    clearEditableState(recordKey);
+    return true;
+  });
 
   /**
-   * 同时只能支持一行,取消之后数据消息，不会触发 dataSource
-   *
-   * @param row
-   * @param options
-   * @name 增加新的行
+   * 验证是否可以新增记录
    */
-  var addEditRecord = useRefFunction(function (row, options) {
-    if (options !== null && options !== void 0 && options.parentKey && !dataSourceKeyIndexMapRef.current.has(recordKeyToString(options === null || options === void 0 ? void 0 : options.parentKey).toString())) {
-      console.warn("can't find record by key", options === null || options === void 0 ? void 0 : options.parentKey);
+  const validateCanAddRecord = useRefFunction(options => {
+    if (options?.parentKey && !dataSourceKeyIndexMapRef.current.has(recordKeyToString(options?.parentKey).toString())) {
+      console.warn("can't find record by key", options?.parentKey);
       return false;
     }
-    // 暂时不支持多行新增
     if (newLineRecordRef.current && props.onlyAddOneLineAlertMessage !== false) {
       warning(props.onlyAddOneLineAlertMessage || intl.getMessage('editableTable.onlyAddOneLine', '只能新增一行'));
       return false;
     }
-    // 如果是单行的话，不允许多行编辑
-    if (editableKeysSet.size > 0 && editableType === 'single' && props.onlyOneLineEditorAlertMessage !== false) {
-      warning(props.onlyOneLineEditorAlertMessage || intl.getMessage('editableTable.onlyOneLineEditor', '只能同时编辑一行'));
+    if (!validateCanStartEdit()) {
       return false;
     }
-    // 防止多次渲染
-    var recordKey = props.getRowKey(row, -1);
-    if (!recordKey && recordKey !== 0) {
-      noteOnce(!!recordKey, '请设置 recordCreatorProps.record 并返回一个唯一的key  \n  https://procomponents.ant.design/components/editable-table#editable-%E6%96%B0%E5%BB%BA%E8%A1%8C');
+    return true;
+  });
+
+  /**
+   * 验证记录 key 是否有效
+   */
+  const validateRecordKey = useRefFunction(recordKey => {
+    if (recordKey == null && recordKey !== 0 && recordKey !== '') {
+      noteOnce(false, '请设置 recordCreatorProps.record 并返回一个唯一的key  \n  https://procomponents.ant.design/components/editable-table#editable-%E6%96%B0%E5%BB%BA%E8%A1%8C');
       throw new Error('请设置 recordCreatorProps.record 并返回一个唯一的key');
     }
-    editableKeysSet.add(recordKey);
-    setEditableRowKeys(Array.from(editableKeysSet));
+  });
+
+  /**
+   * 增加新的行
+   */
+  const addEditRecord = useRefFunction((row, options) => {
+    if (!validateCanAddRecord(options)) {
+      return false;
+    }
+    const recordKey = props.getRowKey(row, -1);
+    validateRecordKey(recordKey);
+    const recordKeyStr = recordKeyToString(recordKey)?.toString();
+    if (recordKeyStr) {
+      // 新建行：用 null 作为快照标记，避免多行编辑取消时误删其他行
+      preEditRowRefs.current.set(recordKeyStr, null);
+    }
+    const isAlreadyEditable = editableKeys?.some(key => key === recordKey || key?.toString() === recordKey?.toString());
+    if (!isAlreadyEditable) {
+      const newKeys = editableKeys ? [...editableKeys, recordKey] : [recordKey];
+      setEditableRowKeys(newKeys);
+    }
 
-    // 如果是dataSource 新增模式的话，取消再开始编辑，
-    // 这样就可以把新增到 dataSource的数据进入编辑模式了
-    // [a,b,cache] => [a,b,c]
-    if ((options === null || options === void 0 ? void 0 : options.newRecordType) === 'dataSource' || props.tableName) {
-      var _recordKeyToString3;
-      var actionProps = {
+    // 处理 parentKey：如果是函数，调用它
+    const parentKeyValue = typeof options?.parentKey === 'function' ? options.parentKey() : options?.parentKey;
+    const isDataSourceMode = options?.newRecordType === 'dataSource' || props.tableName && options?.newRecordType !== 'cache';
+    if (isDataSourceMode) {
+      const actionProps = {
         data: props.dataSource,
         getRowKey: props.getRowKey,
-        row: _objectSpread(_objectSpread({}, row), {}, {
-          map_row_parentKey: options !== null && options !== void 0 && options.parentKey ? (_recordKeyToString3 = recordKeyToString(options === null || options === void 0 ? void 0 : options.parentKey)) === null || _recordKeyToString3 === void 0 ? void 0 : _recordKeyToString3.toString() : undefined
-        }),
+        row: {
+          ...row,
+          map_row_parentKey: parentKeyValue ? recordKeyToString(parentKeyValue)?.toString() : undefined
+        },
         key: recordKey,
         childrenColumnName: props.childrenColumnName || 'children'
       };
-      props.setDataSource(editableRowByKey(actionProps, (options === null || options === void 0 ? void 0 : options.position) === 'top' ? 'top' : 'update'));
+      props.setDataSource(editableRowByKey(actionProps, options?.position === 'top' ? 'top' : 'update'));
     } else {
       setNewLineRecordCache({
         defaultValue: row,
-        options: _objectSpread(_objectSpread({}, options), {}, {
-          recordKey: recordKey
-        })
+        options: {
+          ...options,
+          parentKey: parentKeyValue,
+          recordKey
+        }
       });
     }
     return true;
   });
-  var saveText = (props === null || props === void 0 ? void 0 : props.saveText) || intl.getMessage('editableTable.action.save', '保存');
-  var deleteText = (props === null || props === void 0 ? void 0 : props.deleteText) || intl.getMessage('editableTable.action.delete', '删除');
-  var cancelText = (props === null || props === void 0 ? void 0 : props.cancelText) || intl.getMessage('editableTable.action.cancel', '取消');
-  var actionSaveRef = useRefFunction( /*#__PURE__*/function () {
-    var _ref11 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(recordKey, editRow, originRow, newLine) {
-      var _props$onSave, _recordKeyToString4, _options$parentKey;
-      var res, _ref12, options, actionProps;
-      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
-        while (1) switch (_context8.prev = _context8.next) {
-          case 0:
-            _context8.next = 2;
-            return props === null || props === void 0 || (_props$onSave = props.onSave) === null || _props$onSave === void 0 ? void 0 : _props$onSave.call(props, recordKey, editRow, originRow, newLine);
-          case 2:
-            res = _context8.sent;
-            _context8.next = 5;
-            return cancelEditable(recordKey);
-          case 5:
-            _ref12 = newLine || newLineRecordRef.current || {}, options = _ref12.options;
-            if (!(!(options !== null && options !== void 0 && options.parentKey) && (options === null || options === void 0 ? void 0 : options.recordKey) === recordKey)) {
-              _context8.next = 9;
-              break;
-            }
-            if ((options === null || options === void 0 ? void 0 : options.position) === 'top') {
-              props.setDataSource([editRow].concat(_toConsumableArray(props.dataSource)));
-            } else {
-              props.setDataSource([].concat(_toConsumableArray(props.dataSource), [editRow]));
-            }
-            return _context8.abrupt("return", res);
-          case 9:
-            actionProps = {
-              data: props.dataSource,
-              getRowKey: props.getRowKey,
-              row: options ? _objectSpread(_objectSpread({}, editRow), {}, {
-                map_row_parentKey: (_recordKeyToString4 = recordKeyToString((_options$parentKey = options === null || options === void 0 ? void 0 : options.parentKey) !== null && _options$parentKey !== void 0 ? _options$parentKey : '')) === null || _recordKeyToString4 === void 0 ? void 0 : _recordKeyToString4.toString()
-              }) : editRow,
-              key: recordKey,
-              childrenColumnName: props.childrenColumnName || 'children'
-            };
-            props.setDataSource(editableRowByKey(actionProps, (options === null || options === void 0 ? void 0 : options.position) === 'top' ? 'top' : 'update'));
-            _context8.next = 13;
-            return cancelEditable(recordKey);
-          case 13:
-            return _context8.abrupt("return", res);
-          case 14:
-          case "end":
-            return _context8.stop();
-        }
-      }, _callee8);
-    }));
-    return function (_x7, _x8, _x9, _x10) {
-      return _ref11.apply(this, arguments);
-    };
-  }());
-  var actionDeleteRef = useRefFunction( /*#__PURE__*/function () {
-    var _ref13 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(recordKey, editRow) {
-      var _props$onDelete2;
-      var actionProps, res;
-      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-        while (1) switch (_context9.prev = _context9.next) {
-          case 0:
-            actionProps = {
-              data: props.dataSource,
-              getRowKey: props.getRowKey,
-              row: editRow,
-              key: recordKey,
-              childrenColumnName: props.childrenColumnName || 'children'
-            };
-            _context9.next = 3;
-            return props === null || props === void 0 || (_props$onDelete2 = props.onDelete) === null || _props$onDelete2 === void 0 ? void 0 : _props$onDelete2.call(props, recordKey, editRow);
-          case 3:
-            res = _context9.sent;
-            _context9.next = 6;
-            return cancelEditable(recordKey, false);
-          case 6:
-            props.setDataSource(editableRowByKey(actionProps, 'delete'));
-            return _context9.abrupt("return", res);
-          case 8:
-          case "end":
-            return _context9.stop();
-        }
-      }, _callee9);
-    }));
-    return function (_x11, _x12) {
-      return _ref13.apply(this, arguments);
-    };
-  }());
-  var actionCancelRef = useRefFunction( /*#__PURE__*/function () {
-    var _ref14 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(recordKey, editRow, originRow, newLine) {
-      var _props$onCancel;
-      var res;
-      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-        while (1) switch (_context10.prev = _context10.next) {
-          case 0:
-            _context10.next = 2;
-            return props === null || props === void 0 || (_props$onCancel = props.onCancel) === null || _props$onCancel === void 0 ? void 0 : _props$onCancel.call(props, recordKey, editRow, originRow, newLine);
-          case 2:
-            res = _context10.sent;
-            return _context10.abrupt("return", res);
-          case 4:
-          case "end":
-            return _context10.stop();
-        }
-      }, _callee10);
-    }));
-    return function (_x13, _x14, _x15, _x16) {
-      return _ref14.apply(this, arguments);
+  const saveText = props?.saveText || intl.getMessage('editableTable.action.save', '保存');
+  const deleteText = props?.deleteText || intl.getMessage('editableTable.action.delete', '删除');
+  const cancelText = props?.cancelText || intl.getMessage('editableTable.action.cancel', '取消');
+  const actionSaveRef = useRefFunction(async (recordKey, editRow, originRow, newLine) => {
+    const res = await props?.onSave?.(recordKey, editRow, originRow, newLine);
+
+    // 如果 onSave 返回 false，阻止保存：不更新 dataSource，不触发 onChange
+    if (res === false) {
+      return res;
+    }
+    const {
+      options
+    } = newLine || newLineRecordRef.current || {};
+    const isNewLine = !options?.parentKey && options?.recordKey === recordKey;
+    if (isNewLine) {
+      if (options?.position === 'top') {
+        props.setDataSource([editRow, ...props.dataSource]);
+      } else {
+        props.setDataSource([...props.dataSource, editRow]);
+      }
+    } else {
+      const actionProps = {
+        data: props.dataSource,
+        getRowKey: props.getRowKey,
+        row: options ? {
+          ...editRow,
+          map_row_parentKey: recordKeyToString(options?.parentKey ?? '')?.toString()
+        } : editRow,
+        key: recordKey,
+        childrenColumnName: props.childrenColumnName || 'children'
+      };
+      props.setDataSource(editableRowByKey(actionProps, options?.position === 'top' ? 'top' : 'update'));
+    }
+
+    // 保存时解除编辑模式，统一在这里调用一次
+    await cancelEditable(recordKey);
+    const recordKeyStr = recordKeyToString(recordKey)?.toString();
+    if (recordKeyStr) {
+      preEditRowRefs.current.delete(recordKeyStr);
+    }
+    return res;
+  });
+  const actionDeleteRef = useRefFunction(async (recordKey, editRow) => {
+    const actionProps = {
+      data: props.dataSource,
+      getRowKey: props.getRowKey,
+      row: editRow,
+      key: recordKey,
+      childrenColumnName: props.childrenColumnName || 'children'
     };
-  }());
+    const res = await props?.onDelete?.(recordKey, editRow);
+    // 如果 onDelete 返回 false，阻止删除操作
+    if (res === false) {
+      return false;
+    }
+    // 不传递 false时，重新form.setFieldsValue同一份静态数据，会导致该行始终处于不可编辑状态
+    await cancelEditable(recordKey, false);
+    props.setDataSource(editableRowByKey(actionProps, 'delete'));
+    const recordKeyStr = recordKeyToString(recordKey)?.toString();
+    if (recordKeyStr) {
+      preEditRowRefs.current.delete(recordKeyStr);
+    }
+    return res;
+  });
+  const actionCancelRef = useRefFunction(async (recordKey, editRow, originRow, newLine) => {
+    const res = await props?.onCancel?.(recordKey, editRow, originRow, newLine);
+    return res;
+  });
 
   // 如果传入了自定义的actionRender，使用useRefFunction以确保内部的事件处理函数可以访问最新的state
-  var existCustomActionRender = props.actionRender && typeof props.actionRender === 'function';
-  var customActionRender = existCustomActionRender ? props.actionRender : function () {};
-  var customActionRenderRef = useRefFunction(customActionRender);
-  var actionRender = function actionRender(row) {
-    var key = props.getRowKey(row, row.index);
-    var config = {
-      saveText: saveText,
-      cancelText: cancelText,
-      deleteText: deleteText,
-      addEditRecord: addEditRecord,
+  const existCustomActionRender = props.actionRender && typeof props.actionRender === 'function';
+  const customActionRender = existCustomActionRender ? props.actionRender : () => {};
+  const customActionRenderRef = useRefFunction(customActionRender);
+  const actionRender = row => {
+    const key = props.getRowKey(row, row.index);
+    const config = {
+      saveText,
+      cancelText,
+      deleteText,
+      addEditRecord,
       recordKey: key,
-      cancelEditable: cancelEditable,
+      cancelEditable,
       index: row.index,
       tableName: props.tableName,
       newLineConfig: newLineRecordCache,
       onCancel: actionCancelRef,
       onDelete: actionDeleteRef,
       onSave: actionSaveRef,
-      editableKeys: editableKeys,
-      setEditableRowKeys: setEditableRowKeys,
-      preEditRowRef: preEditRowRef,
-      deletePopconfirmMessage: props.deletePopconfirmMessage || "".concat(intl.getMessage('deleteThisLine', '删除此项'), "?")
+      editableKeys,
+      setEditableRowKeys,
+      preEditRowRef,
+      preEditRowRefs,
+      deletePopconfirmMessage: props.deletePopconfirmMessage || `${intl.getMessage('deleteThisLine', '删除此项')}?`
     };
-    var renderResult = defaultActionRender(row, config);
+    const renderResult = defaultActionRender(row, config);
     // 缓存一下saveRef
     if (props.tableName) {
       saveRefsMap.current.set(dataSourceKeyIndexMapRef.current.get(recordKeyToString(key)) || recordKeyToString(key), renderResult.saveRef);
@@ -875,17 +963,17 @@ export function useEditableArray(props) {
     return [renderResult.save, renderResult.delete, renderResult.cancel];
   };
   return {
-    editableKeys: editableKeys,
-    setEditableRowKeys: setEditableRowKeys,
-    isEditable: isEditable,
-    actionRender: actionRender,
-    startEditable: startEditable,
-    cancelEditable: cancelEditable,
-    addEditRecord: addEditRecord,
-    saveEditable: saveEditable,
+    editableKeys,
+    setEditableRowKeys,
+    isEditable,
+    actionRender,
+    startEditable,
+    cancelEditable,
+    addEditRecord,
+    saveEditable,
     newLineRecord: newLineRecordCache,
     preEditableKeys: editableKeysRef,
-    onValuesChange: onValuesChange,
+    onValuesChange,
     getRealIndex: props.getRealIndex
   };
 }