@zat-design/sisyphus-react 4.1.2-beta.2 → 4.1.2-beta.4

package/es/ProForm/components/combination/Group/style/index.less

@@ -4,6 +4,15 @@
   display: flex;
   width: unset !important;
 
+  &.pro-group-view {
+    .pro-group-form-item {
+      flex: 0 0 auto !important;
+   
+    }
+    .@{ant-prefix}-space-compact .pro-group-separator-compact{
+      color: #333 !important;
+    }
+  }
 
 
   &.pro-group-view {
@@ -385,6 +394,13 @@
       // margin: 0 !important;
     }
 
+    // 查看模式下，Form.Item不平分空间，而是根据内容自适应
+    &.pro-group-view {
+      .pro-group-form-item {
+        flex: 0 0 auto;
+      }
+    }
+
     // 当有自定义宽度时，只有设置了宽度的 Form.Item 不使用 flex:1
     &.pro-group-diy-width {
       // 覆盖 Space.Compact 内设置了宽度的 Form.Item
@@ -430,7 +446,7 @@
         }
 
         .@{ant-prefix}-input-number-input {
-          border-left: 1px solid #ff4d4f !important;
+          border-left: 0 !important;
         }
       }
 
@@ -467,6 +483,15 @@
     margin-left: -1px;
   }
 
+  // 查看模式下的分隔符样式 - 移除边框，使用简洁样式
+  .pro-group-separator-view {
+    border: none !important;
+    background: transparent !important;
+    padding: 0 2px !important;
+    margin-inline-start: 0 !important;
+    color: #999 !important;
+  }
+
 
   /* 1. 处理第一个子元素：左上、左下圆角 */
   > .pro-group-form-item:first-child{

package/es/ProForm/components/combination/Group/utils/index.d.ts

@@ -75,16 +75,15 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
     confirm?: boolean | import("antd").ModalFuncProps | import("../../../render/propsType").FunctionArgs<any, boolean | import("antd").ModalFuncProps>;
     show?: boolean | ReactiveFunction<any, boolean>;
     component?: React.ReactNode | ReactiveFunction<any, React.ReactNode>;
-    id?: string;
+    status?: "" | "success" | "warning" | "error" | "validating";
     className?: string;
     hidden?: boolean;
+    id?: string;
     style?: React.CSSProperties;
     children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     onReset?: () => void;
     prefixCls?: string;
-    status?: "" | "warning" | "error" | "success" | "validating";
     rootClassName?: string;
-    isView?: boolean;
     colon?: boolean;
     htmlFor?: string;
     labelAlign?: import("antd/es/form/interface").FormLabelAlign;
@@ -108,25 +107,26 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
     hasFeedback?: boolean | {
         icons: import("antd/es/form/FormItem").FeedbackIcons;
     };
-    validateStatus?: "" | "warning" | "error" | "success" | "validating";
+    validateStatus?: "" | "success" | "warning" | "error" | "validating";
     layout?: import("antd/es/form/Form").FormItemLayout;
     wrapperCol?: import("antd").ColProps;
     help?: React.ReactNode;
     fieldId?: string;
     valueType?: import("../../../render/propsType").ProFormValueType;
-    switchValue?: [any, any];
     viewRender?: (value: any, record: any, { form, index, namePath, }: {
         [key: string]: any;
         form: FormInstance<any>;
         index?: number;
     }) => string | React.ReactElement<any, any>;
+    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
+    isView?: boolean;
+    switchValue?: [any, any];
     viewType?: import("../../../render/propsType").ViewType;
     trim?: boolean;
     upperCase?: boolean;
     toISOString?: boolean;
     toCSTString?: boolean;
     clearNotShow?: boolean;
-    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
     name: any;
     dependencies: any[];
     tooltip: string | {
@@ -141,7 +141,7 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
  * 创建组件属性
  */
 export declare const createComponentProps: (column: FlexibleGroupColumnType, formItemProps: any) => {
-    componentProps: import("lodash").Omit<any, "format" | "valueType" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "clearNotShow" | "precision">;
+    componentProps: import("lodash").Omit<any, "valueType" | "precision" | "format" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "clearNotShow">;
     formItemTransform: {
         getValueProps: any;
         normalize: any;

package/es/ProForm/components/combination/ProCascader/propsType.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { DefaultOptionType } from 'rc-select/lib/Select';
+import { DefaultOptionType } from '@rc-component/select/es/Select';
 import { Service, Options } from 'ahooks/lib/useRequest/src/types';
 export interface FieldNamesType {
     label: string;

package/es/ProForm/propsType.d.ts

@@ -1,9 +1,9 @@
+import React, { ReactNode } from 'react';
 import { ButtonProps, ColProps, RowProps } from 'antd';
 import { FormProps, FormInstance } from 'antd/es/form/Form';
 import { NamePath } from 'antd/es/form/interface';
-import { StoreValue, Store } from 'rc-field-form/es/interface.d';
-import { ShouldUpdate } from 'rc-field-form/es/Field.d';
-import React, { ReactNode } from 'react';
+import type { StoreValue, Store } from '@rc-component/form/es/interface';
+import type { ShouldUpdate } from '@rc-component/form/es/Field';
 import type { ProFormColumnType, ViewType } from './components/render/propsType';
 import type { ProFormComponentType } from './components';
 export interface ButtonType extends ButtonProps {

package/es/ProForm/utils/transformValue.d.ts

@@ -1,6 +1,6 @@
 import { FormInstance, FormItemProps } from 'antd';
 import { NamePath } from 'antd/es/form/interface';
-import { StoreValue, Store } from 'rc-field-form/es/interface.d';
+import type { StoreValue, Store } from '@rc-component/form/es/interface';
 import type { TransformType } from '../propsType';
 export declare const transformValue: (names: NamePath[], form: FormInstance, fieldName: NamePath, normalize?: (value: StoreValue, prevValue: StoreValue, allValues: Store) => StoreValue, getValueProps?: FormItemProps['getValueProps']) => TransformType;
 export default transformValue;

package/es/ProForm/utils/useForm.d.ts

@@ -1,6 +1,6 @@
 import { FormInstance } from 'antd';
 import { NamePath } from 'antd/es/form/interface';
-import { ValuedNotifyInfo } from 'rc-field-form/es/interface';
+import type { ValuedNotifyInfo } from '@rc-component/form/es/interface';
 export type ModifiedFormInstanceType<T> = FormInstance<T> & {
     isModified?: boolean;
     /** 默认清空设置值的报错状态 */

package/es/ProForm/utils/useWatch.d.ts

@@ -1,4 +1,5 @@
-import { FormInstance, NamePath } from 'rc-field-form/es/interface';
+import { FormInstance } from 'antd/es/form/Form';
+import { NamePath } from 'antd/es/form/interface';
 export declare function toArray<T>(value?: T | T[] | null): T[];
 /**
  * ProForm的useWatch hook，用于监听表单字段变化

package/es/ProForm/utils/useWatch.js

@@ -112,7 +112,9 @@ function useWatch(dependencies, form, wait) {
       }
     }
     return paths;
-  }, [/* dependencies 故意忽略，与原实现一致 */]);
+  }, [
+    /* dependencies 故意忽略，与原实现一致 */
+  ]);
 
   // 保存防抖函数引用，避免重复创建
   var debouncedFn = useMemo(() => {

package/es/ProUpload/propsType.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { UploadFile } from 'antd/es/upload/interface';
-import { UploadRequestOption } from 'rc-upload/lib/interface';
+import type { UploadRequestOption } from '@rc-component/upload/es/interface';
 export type UploadType = 'drag' | 'button' | 'image';
 export interface UploadFileResType {
     /**

package/lib/ProEditTable/components/RenderField/index.js

@@ -100,9 +100,7 @@ var RenderField = _ref => {
   var _valueType = valueType;
   var _disabled = false;
   var _desensitization = desensitization || [];
-
-  // editRender弃用使用component同ProForm
-  var _editRender = component || editRender;
+  var _component = component || editRender;
   var isCell = mode === 'cell';
   var isSingleMode = mode === 'single';
   if (isCell) {
@@ -191,6 +189,15 @@ var RenderField = _ref => {
     isEditable = (_dynamicProps$isEdita = dynamicProps.isEditable) !== null && _dynamicProps$isEdita !== void 0 ? _dynamicProps$isEdita : isEditable(rowData, reactiveParams);
   }
 
+  // component 处理 - 优先使用 hook 返回的值
+  if ((0, _lodash.isFunction)(_component)) {
+    var _dynamicProps$compone;
+    _component = (_dynamicProps$compone = dynamicProps.component) !== null && _dynamicProps$compone !== void 0 ? _dynamicProps$compone : _component(rowData, reactiveParams);
+  }
+
+  // 更新 _editRender 为处理后的 _component
+  var _editRender = _component;
+
   // 是否只读文本
   var isView = !isEditable || (record === null || record === void 0 ? void 0 : record['is-view']) || config.isView || virtualKey && !_isEditing || (0, _tools.getDisabled)({
     globalControl: otherProps === null || otherProps === void 0 ? void 0 : otherProps.globalControl,
@@ -215,7 +222,7 @@ var RenderField = _ref => {
     label: label,
     labelRequired,
     required: !isView && _required,
-    rules: _isEditing ? _rules : [],
+    rules: !isView ? _rules : [],
     isSelect: (0, _utils2.isSelect)({
       dataSource: (_fieldProps2 = _fieldProps) === null || _fieldProps2 === void 0 ? void 0 : _fieldProps2.dataSource,
       type
@@ -239,8 +246,10 @@ var RenderField = _ref => {
     validateTrigger
   }), [defaultProps, resetProps, internalRule, validateTrigger]);
 
-  // 只在 single 模式下，当这些函数类型存在时，自动添加 shouldUpdate
+  // 当这些函数类型存在时，自动添加 shouldUpdate
   // 因为这些函数依赖行数据，当行数据变化时需要重新计算
+  // 扩展到所有模式（single/multiple/cell），统一行为
+  // 注意：需要检查原始的 component/editRender，而不是处理后的 _component
   var hasFunctionDependency = (0, _lodash.isFunction)(column === null || column === void 0 ? void 0 : column.disabled) ||
   // disabled 是函数
   (0, _lodash.isFunction)(fieldProps) ||
@@ -251,11 +260,15 @@ var RenderField = _ref => {
   // rules 是函数
   (0, _lodash.isFunction)(isEditable) ||
   // isEditable 是函数
-  (0, _lodash.isFunction)(_editRender) ||
-  // component/editRender 是函数
+  (0, _lodash.isFunction)(component) ||
+  // component 是函数
+  (0, _lodash.isFunction)(editRender) ||
+  // editRender 是函数
   (0, _lodash.isFunction)(viewRender); // viewRender 是函数
 
-  if (isSingleMode && hasFunctionDependency && !(column !== null && column !== void 0 && column.dependencies)) {
+  // 移除 isSingleMode 限制，让所有模式都支持响应式更新
+  // 性能优化已通过 useShouldUpdateForTable hook 的缓存和防抖机制实现
+  if (hasFunctionDependency && !(column !== null && column !== void 0 && column.dependencies)) {
     // 使用 shouldUpdate 监听同一行的数据变化
     _formItemProps.shouldUpdate = (prevValues, currentValues) => {
       var prevRow = (0, _lodash.get)(prevValues, [...namePath, index]);
@@ -334,11 +347,14 @@ var RenderField = _ref => {
     TargetComponent = (_componentMap$type = componentMap[type]) !== null && _componentMap$type !== void 0 ? _componentMap$type : /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {});
   }
   if (isEditable && _isEditing) {
-    if (typeof _editRender === 'function') {
-      TargetComponent = _editRender(...rowParams);
-    }
+    // _editRender 已经是处理后的值（通过 dynamicProps.component 或直接计算）
+    // 如果原本是函数，此时 _editRender 已经是执行后的 ReactNode
+    // 如果原本是 ReactElement，_editRender 就是 ReactElement
     if ( /*#__PURE__*/_react.default.isValidElement(_editRender)) {
       TargetComponent = _editRender;
+    } else if (_editRender) {
+      // 其他情况（可能是字符串或其他类型的 ReactNode）
+      TargetComponent = _editRender;
     }
   }
 
@@ -714,20 +730,50 @@ var RenderField = _ref => {
     // 如果处于 shouldUpdate 模式，需要重新获取最新的行数据并重新计算依赖值
     var finalComponentProps = componentProps;
     if (shouldUpdateMode) {
+      var _column$isEditable2;
       // 重新获取最新的行数据
       var latestRowData = form.getFieldValue([...namePath, index]) || record || {};
-      var latestOptions = {
-        index,
+      var latestReactiveParams = {
         form,
-        name: column === null || column === void 0 ? void 0 : column.name,
+        index,
         namePath: [...namePath, index]
       };
-      var latestRowParams = [latestRowData, latestOptions];
+      var latestRowParams = [latestRowData, latestReactiveParams];
 
-      // 重新计算 fieldProps
+      // ⭐ 关键修改：shouldUpdate 模式下，跳过缓存，直接重新计算所有响应式属性
       var latestFieldProps = fieldProps || formItemProps || {};
       if ((0, _lodash.isFunction)(fieldProps)) {
-        latestFieldProps = fieldProps(...latestRowParams);
+        latestFieldProps = fieldProps(latestRowData, latestReactiveParams);
+      }
+
+      // 重新计算 required（用于可能的后续逻辑）
+      var latestRequired = required;
+      if ((0, _lodash.isFunction)(required)) {
+        latestRequired = required(latestRowData, latestReactiveParams);
+      }
+
+      // 重新计算 rules（用于可能的后续逻辑）
+      var latestRules = rules;
+      if ((0, _lodash.isFunction)(rules)) {
+        latestRules = rules(latestRowData, latestReactiveParams);
+      }
+
+      // 重新计算 desensitization
+      var latestDesensitization = desensitization || [];
+      if ((0, _lodash.isFunction)(desensitization)) {
+        latestDesensitization = desensitization(latestRowData, latestReactiveParams);
+      }
+
+      // 重新计算 component
+      var latestComponent = component || editRender;
+      if ((0, _lodash.isFunction)(latestComponent)) {
+        latestComponent = latestComponent(latestRowData, latestReactiveParams);
+      }
+
+      // 重新计算 isEditable（使用原始的 column.isEditable，而不是处理后的 isEditable）
+      var latestIsEditable = (_column$isEditable2 = column.isEditable) !== null && _column$isEditable2 !== void 0 ? _column$isEditable2 : true;
+      if ((0, _lodash.isFunction)(column.isEditable)) {
+        latestIsEditable = column.isEditable(latestRowData, latestReactiveParams);
       }
 
       // 重新计算 disabled
@@ -740,10 +786,58 @@ var RenderField = _ref => {
         params: latestRowParams
       });
 
-      // 更新 componentProps 中的 disabled 和 fieldProps
-      finalComponentProps = _objectSpread(_objectSpread({}, componentProps), {}, {
+      // 更新 componentProps 中的所有响应式属性
+      finalComponentProps = _objectSpread(_objectSpread(_objectSpread({}, componentProps), {}, {
         disabled: latestDisabled
-      }, latestFieldProps);
+      }, latestFieldProps), {}, {
+        desensitization: latestDesensitization
+      });
+
+      // ⭐ 关键修改：在 shouldUpdate 模式下，需要重新设置 TargetComponent
+      // 因为 component 函数可能返回不同的结果
+      var latestTargetComponent = TargetComponent;
+
+      // 首先检查是否有内置type
+      if (!latestComponent && typeof type === 'string') {
+        var _componentMap$type2;
+        latestTargetComponent = (_componentMap$type2 = componentMap[type]) !== null && _componentMap$type2 !== void 0 ? _componentMap$type2 : /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {});
+      }
+
+      // 然后处理自定义 component
+      var latestIsView = !latestIsEditable || (record === null || record === void 0 ? void 0 : record['is-view']) || config.isView || virtualKey && !_isEditing || (0, _tools.getDisabled)({
+        globalControl: otherProps === null || otherProps === void 0 ? void 0 : otherProps.globalControl,
+        formDisabled: otherProps === null || otherProps === void 0 ? void 0 : otherProps.formDisabled,
+        column,
+        tabledDisabled: config === null || config === void 0 ? void 0 : config.disabled,
+        columnFieldProps: latestFieldProps,
+        params: latestRowParams,
+        rowDisabled: rowDisabled || 'empty'
+      });
+      if (latestIsEditable && _isEditing) {
+        if ( /*#__PURE__*/_react.default.isValidElement(latestComponent)) {
+          latestTargetComponent = latestComponent;
+        } else if (latestComponent) {
+          latestTargetComponent = latestComponent;
+        }
+      }
+
+      // 查看模式
+      if (latestIsView) {
+        if (typeof viewRender === 'function') {
+          var latestCurrentValue = dataIndex ? latestRowData === null || latestRowData === void 0 ? void 0 : latestRowData[dataIndex] : null;
+          var _View = viewRender(latestCurrentValue, latestRowData || {}, options);
+          latestTargetComponent = /*#__PURE__*/(0, _jsxRuntime.jsx)(_Container.default, {
+            viewEmpty: viewEmpty,
+            children: _View
+          });
+        }
+        if ( /*#__PURE__*/_react.default.isValidElement(viewRender)) {
+          latestTargetComponent = viewRender;
+        }
+      }
+
+      // 使用重新计算的 TargetComponent
+      TargetComponent = latestTargetComponent;
     }
     var FormItem = null;
     // 当 viewRender 存在时，需要排除 finalComponentProps 中的 children，避免覆盖 Container 的 children
@@ -753,7 +847,15 @@ var RenderField = _ref => {
     if (isTargetDomElement) {
       propsForTarget = (0, _lodash.omit)(propsForTarget, ['disabled', ...OMIT_FORM_ITEM_AND_DOM_KEYS]);
     }
-    var FieldComponent = /*#__PURE__*/_react.default.isValidElement(TargetComponent) ? ( /*#__PURE__*/_react.default.cloneElement(TargetComponent, propsForTarget)) : /*#__PURE__*/(0, _jsxRuntime.jsx)(TargetComponent, _objectSpread({}, propsForTarget));
+    // 当 TargetComponent 未定义时，使用空的占位组件避免渲染错误
+    var FieldComponent = null;
+    if ( /*#__PURE__*/_react.default.isValidElement(TargetComponent)) {
+      FieldComponent = /*#__PURE__*/_react.default.cloneElement(TargetComponent, propsForTarget);
+    } else if (TargetComponent) {
+      FieldComponent = /*#__PURE__*/(0, _jsxRuntime.jsx)(TargetComponent, _objectSpread({}, propsForTarget));
+    } else {
+      FieldComponent = /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {});
+    }
     if (originalValues && !getIsNew(record)) {
       FieldComponent = /*#__PURE__*/(0, _jsxRuntime.jsx)(_ListChangedWrapper.default, {
         name: cellName,
@@ -784,7 +886,7 @@ var RenderField = _ref => {
     }
     FormItem = TargetComponent ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Form.Item, _objectSpread(_objectSpread({
       validateFirst: true
-    }, (0, _lodash.omit)(finalFormItemProps, ['render', 'key', 'width', 'hiddenNames', 'name', 'onCell', _formItemProps.shouldUpdate ? 'shouldUpdate' : null])), {}, {
+    }, (0, _lodash.omit)(finalFormItemProps, ['render', 'key', 'width', 'hiddenNames', 'name', 'onCell', 'disabled', _formItemProps.shouldUpdate ? 'shouldUpdate' : null])), {}, {
       // 移除非必要字段，但保留 dependencies
       className: _className,
       name: formNamePath ? cellName.slice((formNamePath === null || formNamePath === void 0 ? void 0 : formNamePath.length) - 1) : cellName,
@@ -850,20 +952,26 @@ var _default = exports.default = /*#__PURE__*/(0, _react.memo)(RenderField, (pre
   }
 
   // fieldProps 函数化直接更新，无法比对返回值是否一致
+  // 优化：不直接调用函数，而是比较输入参数（record 和 reactiveParams）
+  // 如果输入参数相同，fieldProps 的返回值应该相同（纯函数假设）
   if ((0, _lodash.isFunction)(prevColumn === null || prevColumn === void 0 ? void 0 : prevColumn.fieldProps) && (0, _lodash.isFunction)(nextColumn === null || nextColumn === void 0 ? void 0 : nextColumn.fieldProps)) {
-    var prevFieldProps = prevColumn.fieldProps(prevRecord, prevReactiveParams);
-    var nextFieldProps = nextColumn.fieldProps(nextRecord, nextReactiveParams);
-    if (!(0, _lodash.isEqualWith)(prevFieldProps, nextFieldProps, _utils.customEqualForFunction)) {
+    // 比较 record 数据是否变化
+    if (!(0, _lodash.isEqualWith)(prevRecord, nextRecord, _utils.customEqualForFunction)) {
       return false;
     }
+    // reactiveParams 中的 form、index、namePath 已经在外层比较过了，无需重复比较
   }
 
   // 通用函数比较方法
+  // 优化：不直接调用函数，而是比较输入参数
+  // 对于纯函数，如果输入相同则输出相同
   var compareFunctionResult = (prevColumn, nextColumn, prevValues, nextValues, prevReactiveParams, nextReactiveParams, functionName) => {
     var prevFunc = prevColumn === null || prevColumn === void 0 ? void 0 : prevColumn[functionName];
     var nextFunc = nextColumn === null || nextColumn === void 0 ? void 0 : nextColumn[functionName];
     if ((0, _lodash.isFunction)(prevFunc) && (0, _lodash.isFunction)(nextFunc)) {
-      return (0, _lodash.isEqualWith)(prevFunc(prevValues, prevReactiveParams), nextFunc(nextValues, nextReactiveParams), _utils.customEqualForFunction);
+      // 比较输入参数而不是调用函数
+      // 如果 values 相同，则函数结果应该相同（纯函数假设）
+      return (0, _lodash.isEqualWith)(prevValues, nextValues, _utils.customEqualForFunction);
     }
     return true; // 如果不是函数或只有一个是函数，认为相等
   };

package/lib/ProEditTable/propsType.d.ts

@@ -130,6 +130,11 @@ export type RequiredFn<T = any> = ReactiveFunction<T, boolean | boolean[]>;
  * @template T 记录类型
  */
 export type viewRenderFn<T = any> = (text?: any, record?: T, options?: OptionsProps) => string | number | ReactNode | void;
+/**
+ * 组件渲染函数类型（与 ReactiveFunction 保持一致）
+ * @template T 记录类型
+ */
+export type ComponentRenderFn<T = any> = ReactiveFunction<T, string | number | ReactNode | void>;
 /**
  * 表格列属性接口
  * @template Values 值类型
@@ -153,7 +158,7 @@ export interface ProColumnsProps<Values = any, T = any> extends Omit<FormItemPro
         icon?: string | ReactNode;
     } & TooltipProps);
     /** 组件 */
-    component?: string | number | ReactNode | viewRenderFn<T>;
+    component?: string | number | ReactNode | ComponentRenderFn<T>;
     /** 视图渲染 */
     viewRender?: string | number | ReactNode | viewRenderFn<T>;
     /** 隐藏的字段名 */

package/lib/ProEditTable/utils/index.js

@@ -45,7 +45,8 @@ var getActionColumn = config => {
     actionProps = _cloneDeepWith.actionProps,
     page = _cloneDeepWith.page,
     rowDisabled = _cloneDeepWith.rowDisabled,
-    actionDirection = _cloneDeepWith.actionDirection;
+    actionDirection = _cloneDeepWith.actionDirection,
+    editingKeys = _cloneDeepWith.editingKeys;
   var pageNum = _utils.tools.calc(page.pageNum, '-', 1);
   var firstIndex = _utils.tools.calc(pageNum, '*', page.pageSize);
   // actionProps配置为false 默认不插入
@@ -93,7 +94,7 @@ var getActionColumn = config => {
     action.onEvent = /*#__PURE__*/function () {
       var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(record, _ref) {
         var _form$getFieldValue;
-        var index, form, name, namePath, tableLength, selectedRows, rowName, lastRecord, onEvent, result, actionHandler;
+        var index, form, name, namePath, tableLength, selectedRows, rowName, _isEditing, lastRecord, onEvent, result, actionHandler;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -101,33 +102,39 @@ var getActionColumn = config => {
               index = _utils.tools.calc(firstIndex, '+', index);
               rowName = [...virtualRowName, index];
               if (!(type === 'save')) {
-                _context.next = 13;
+                _context.next = 15;
                 break;
               }
-              _context.prev = 4;
-              _context.next = 7;
+              // 判断该行是否处于编辑状态
+              _isEditing = !virtualKey || editingKeys.includes(record.rowKey) || record._addFlag; // 只有编辑中的行才需要校验
+              if (!_isEditing) {
+                _context.next = 15;
+                break;
+              }
+              _context.prev = 6;
+              _context.next = 9;
               return (0, _tools.customValidate)(validateKeys, form, rowName);
-            case 7:
-              _context.next = 13;
-              break;
             case 9:
-              _context.prev = 9;
-              _context.t0 = _context["catch"](4);
+              _context.next = 15;
+              break;
+            case 11:
+              _context.prev = 11;
+              _context.t0 = _context["catch"](6);
               (0, _tools.handleScrollToError)();
               return _context.abrupt("return", Promise.reject(_context.t0));
-            case 13:
+            case 15:
               // 编辑状态使用自定义form值，非编辑状态直接使用行数据
               lastRecord = (0, _utils2.filterInternalFields)((_form$getFieldValue = form.getFieldValue(rowName)) !== null && _form$getFieldValue !== void 0 ? _form$getFieldValue : record); // 新增事件可以设置初始默认值，当做函数的出参导出
               onEvent = onClick || onHandle;
               if (onEvent) {
-                _context.next = 19;
+                _context.next = 21;
                 break;
               }
               result = true;
-              _context.next = 22;
+              _context.next = 24;
               break;
-            case 19:
-              _context.next = 21;
+            case 21:
+              _context.next = 23;
               return onEvent === null || onEvent === void 0 ? void 0 : onEvent(lastRecord, {
                 form,
                 index,
@@ -136,9 +143,9 @@ var getActionColumn = config => {
                 namePath,
                 selectedRows
               });
-            case 21:
+            case 23:
               result = _context.sent;
-            case 22:
+            case 24:
               if (result !== false && type !== 'custom') {
                 actionHandler = _config.actions[type];
                 actionHandler(_objectSpread(_objectSpread({}, config), {}, {
@@ -149,11 +156,11 @@ var getActionColumn = config => {
                   validateKeys
                 }));
               }
-            case 23:
+            case 25:
             case "end":
               return _context.stop();
           }
-        }, _callee, null, [[4, 9]]);
+        }, _callee, null, [[6, 11]]);
       }));
       return function (_x, _x2) {
         return _ref2.apply(this, arguments);

package/lib/ProEditTable/utils/useShouldUpdateForTable.d.ts

@@ -10,6 +10,7 @@ interface Result {
     fieldProps: any;
     desensitization: any;
     valueType: any;
+    component: any;
 }
 declare const useShouldUpdateForTable: (props: UseShouldUpdateForTableProps) => Result;
 export default useShouldUpdateForTable;