@zat-design/sisyphus-react 4.4.3-beta.2 → 4.5.0-beta.1

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

@@ -1,5 +1,4 @@
 import _get from "lodash/get";
-import _isEqualWith from "lodash/isEqualWith";
 import _isFunction from "lodash/isFunction";
 import _omit from "lodash/omit";
 import _debounce from "lodash/debounce";
@@ -10,10 +9,10 @@ import _cloneDeep from "lodash/cloneDeep";
 import React, { useEffect, useCallback, useMemo, memo, useRef } from 'react';
 import { Form } from 'antd';
 import classNames from 'classnames';
-import { compatStartTransition, customEqualForFunction } from "../../../utils";
+import { compatStartTransition } from "../../../utils";
 import valueTypeMap from "../../../ProForm/utils/valueType";
 import transformMap from "../../utils/transform";
-import { getNamePath, difference, getDisabled } from "../../utils/tools";
+import { getNamePath, difference, getDisabled, resolveChangedFields, syncGroupCombinedValues } from "../../utils/tools";
 import * as componentMap from "../../../ProForm/components";
 import { useProConfig } from "../../../ProConfigProvider";
 import Container from "../../../ProForm/components/Container";
@@ -26,11 +25,8 @@ import ConfirmWrapper from "../../../ProForm/components/render/ConfirmWrapper";
 import { getDefaultProps } from "../../utils/getDefaultProps";
 import ListChangedWrapper from "./ListChangedWrapper";
 import useShouldUpdateForTable from "../../utils/useShouldUpdateForTable";
-
-/** 列配置中不应透传到 Form.Item 或 DOM 的字段（与 ProForm Render 保持一致） */
+import { OMIT_FORM_ITEM_AND_DOM_KEYS, arePropsEqual } from "./tools";
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-const OMIT_FORM_ITEM_AND_DOM_KEYS = ['format', 'toISOString', 'toCSTString', 'switchValue', 'precision', 'clearNotShow', 'dependNames', 'shouldCellUpdate' // 表格内部性能优化属性，不应传递给 Form.Item
-];
 const RenderField = ({
   text: value,
   record,
@@ -65,7 +61,7 @@ const RenderField = ({
   const {
     mode,
     cellName,
-    _isEditing,
+    _isEditing: isEditing,
     form,
     setState,
     name,
@@ -78,15 +74,18 @@ const RenderField = ({
     otherProps,
     diffConfig,
     getIsNew,
-    shouldUpdateDebounce
+    shouldUpdateDebounce,
+    virtual,
+    errorStore,
+    columns
   } = config;
-  let _fieldProps = fieldProps || {};
-  let _rules = rules || [];
-  let _required = required;
-  let _valueType = valueType;
-  let _disabled = false;
-  let _desensitization = desensitization || [];
-  let _component = component || editRender;
+  let lastFieldProps = fieldProps || {};
+  let lastRules = rules || [];
+  let lastRequired = required;
+  let lastValueType = valueType;
+  let lastDisabled = false;
+  let lastDesensitization = desensitization || [];
+  let lastComponent = component || editRender;
   const isSingleMode = mode === 'single';
 
   // type类型 首字母转大写
@@ -130,16 +129,16 @@ const RenderField = ({
   // required & rules & fieldProps & disabled & valueType 函数化处理
   // 优先使用 hook 返回的值，fallback 到原始值
   if (_isFunction(required)) {
-    _required = dynamicProps.required ?? required(rowData, reactiveParams);
+    lastRequired = dynamicProps.required ?? required(rowData, reactiveParams);
   }
   if (_isFunction(fieldProps)) {
-    _fieldProps = dynamicProps.fieldProps ?? fieldProps(rowData, reactiveParams);
+    lastFieldProps = dynamicProps.fieldProps ?? fieldProps(rowData, reactiveParams);
   }
   if (_isFunction(rules)) {
-    _rules = dynamicProps.rules ?? rules(rowData, reactiveParams);
+    lastRules = dynamicProps.rules ?? rules(rowData, reactiveParams);
   }
   if (_isFunction(valueType)) {
-    _valueType = dynamicProps.valueType ?? valueType(currentValue, rowData, {
+    lastValueType = dynamicProps.valueType ?? valueType(currentValue, rowData, {
       index,
       form,
       namePath: [...namePath, index],
@@ -147,16 +146,16 @@ const RenderField = ({
     });
   }
   if (_isFunction(desensitization)) {
-    _desensitization = dynamicProps.desensitization ?? desensitization(rowData, reactiveParams);
+    lastDesensitization = dynamicProps.desensitization ?? desensitization(rowData, reactiveParams);
   }
 
   // 获取最终的disabled
-  _disabled = getDisabled({
+  lastDisabled = getDisabled({
     globalControl: otherProps?.globalControl,
     formDisabled: otherProps?.formDisabled,
     column,
     tabledDisabled: config?.disabled,
-    columnFieldProps: _fieldProps,
+    columnFieldProps: lastFieldProps,
     params: rowParams
   });
 
@@ -166,26 +165,28 @@ const RenderField = ({
   }
 
   // component 处理 - 优先使用 hook 返回的值
-  if (_isFunction(_component)) {
-    _component = dynamicProps.component ?? _component(rowData, reactiveParams);
+  if (_isFunction(lastComponent)) {
+    lastComponent = dynamicProps.component ?? lastComponent(rowData, reactiveParams);
   }
 
-  // 更新 _editRender 为处理后的 _component
-  const _editRender = _component;
+  // 更新 lastEditRender 为处理后的 lastComponent
+  const lastEditRender = lastComponent;
 
   // 是否只读文本
-  const isView = !isEditable || record?.['is-view'] || config.isView || virtualKey && !_isEditing || getDisabled({
+  const isView = !isEditable || record?.['is-view'] || config.isView || virtualKey && !isEditing || getDisabled({
     globalControl: otherProps?.globalControl,
     formDisabled: otherProps?.formDisabled,
     column,
     tabledDisabled: config?.disabled,
-    columnFieldProps: _fieldProps,
+    columnFieldProps: lastFieldProps,
     params: rowParams,
     rowDisabled: rowDisabled || 'empty'
   });
 
   // 只读文本时，采用当前formItem的name，单行编辑时，使用生成的虚拟的name
   const baseName = isView ? name : namePath;
+
+  // 多态：可能是内置组件类型、自定义 component，或已渲染的 ReactElement（lastEditRender），保留显式 any
   let TargetComponent;
 
   // 将Hooks调用移到组件顶层
@@ -196,18 +197,18 @@ const RenderField = ({
     names,
     label: label,
     labelRequired,
-    required: _required,
-    rules: _rules,
+    required: lastRequired,
+    rules: lastRules,
     isSelect: isSelect({
-      dataSource: _fieldProps?.dataSource,
+      dataSource: lastFieldProps?.dataSource,
       type
     }),
     type
   });
 
-  // 分离form item参数，防止对于参数透传（如onChange,防止重复触发）并优先级高于 _fieldProps 内部参数
+  // 分离form item参数，防止对于参数透传（如onChange,防止重复触发）并优先级高于 lastFieldProps 内部参数
   const formItemChildProps = {
-    ..._fieldProps
+    ...lastFieldProps
   };
 
   // 使用useMemo优化defaultProps计算
@@ -219,7 +220,7 @@ const RenderField = ({
   }), [name, formNamePath, cellName, column?.type, column?.fieldProps]);
 
   // 允许formItem的属性放在column最外层 - 使用useMemo优化（剔除会透传到 DOM 的字段）
-  const _formItemProps = useMemo(() => ({
+  const lastFormItemProps = useMemo(() => ({
     ...defaultProps,
     ..._omit(resetProps, OMIT_FORM_ITEM_AND_DOM_KEYS),
     ...internalRule,
@@ -230,7 +231,7 @@ const RenderField = ({
   // 当这些函数类型存在时，自动添加 shouldUpdate
   // 因为这些函数依赖行数据，当行数据变化时需要重新计算
   // 扩展到所有模式（single/multiple/cell），统一行为
-  // 注意：需要检查原始的 component/editRender，而不是处理后的 _component
+  // 注意：需要检查原始的 component/editRender，而不是处理后的 lastComponent
   const hasFunctionDependency = _isFunction(column?.disabled) ||
   // disabled 是函数
   _isFunction(fieldProps) ||
@@ -251,7 +252,7 @@ const RenderField = ({
   // 性能优化已通过 useShouldUpdateForTable hook 的缓存和防抖机制实现
   if (hasFunctionDependency) {
     // 使用 shouldUpdate 监听同一行的数据变化；shouldUpdate 与 dependencies 互斥，始终优先 shouldUpdate
-    _formItemProps.shouldUpdate = (prevValues, currentValues) => {
+    lastFormItemProps.shouldUpdate = (prevValues, currentValues) => {
       const prevRow = _get(prevValues, [...namePath, index]);
       const currentRow = _get(currentValues, [...namePath, index]);
       // 如果行数据发生变化，则重新渲染
@@ -259,8 +260,8 @@ const RenderField = ({
     };
   }
   if (['Switch', 'SwitchCheckbox'].includes(type)) {
-    _formItemProps.valuePropName = 'checked';
-    _valueType = 'switch';
+    lastFormItemProps.valuePropName = 'checked';
+    lastValueType = 'switch';
   }
 
   /**
@@ -269,11 +270,11 @@ const RenderField = ({
    */
   const defaultTransform = useCallback(() => {
     const types = ['DatePicker', 'RangePicker'];
-    if (!_valueType && types.includes(type)) {
-      return transformMap?.[type]?.(_fieldProps || {});
+    if (!lastValueType && types.includes(type)) {
+      return transformMap?.[type]?.(lastFieldProps || {});
     }
     return {};
-  }, [_valueType, type, _fieldProps]);
+  }, [lastValueType, type, lastFieldProps]);
 
   /**
    * 配置valueType时，基于formItem的normalize与getValueProps进行值类型转换
@@ -282,14 +283,15 @@ const RenderField = ({
   const valueTypeTransform = useCallback(() => {
     // SwitchCheckbox默认YN, 兼容已有组件
     if (type === 'SwitchCheckbox') {
-      _valueType = 'switch';
+      lastValueType = 'switch';
     }
     const params = {
       ...column,
-      mode: _fieldProps?.mode
+      mode: lastFieldProps?.mode
     };
-    return _isFunction(valueTypeMap[_valueType]) ? valueTypeMap[_valueType](params) : {};
-  }, [type, _valueType, column, _fieldProps?.mode]);
+    const valueTypeKey = lastValueType;
+    return _isFunction(valueTypeMap[valueTypeKey]) ? valueTypeMap[valueTypeKey](params) : {};
+  }, [type, lastValueType, column, lastFieldProps?.mode]);
   if (names?.length) {
     // 支持names配置，临时生成对应的formItem，用来存储单个对应的值
     names = names.map(key => {
@@ -318,22 +320,23 @@ const RenderField = ({
     }
     const namesStr = [...baseName, index, dataIndex];
     return transformNames({
-      ..._formItemProps,
+      ...lastFormItemProps,
       ...valueTypeTransform()
     }, form, names, namesStr, type);
-  }, [names, baseName, index, dataIndex, _formItemProps, type]);
-  if (!_editRender && typeof type === 'string') {
+  }, [names, baseName, index, dataIndex, lastFormItemProps, type]);
+  if (!lastEditRender && typeof type === 'string') {
+    // componentMap 为内置组件命名空间，按字符串 type 动态取用，保留显式 any 索引
     TargetComponent = componentMap[type] ?? /*#__PURE__*/_jsx(_Fragment, {});
   }
-  if (isEditable && _isEditing) {
-    // _editRender 已经是处理后的值（通过 dynamicProps.component 或直接计算）
-    // 如果原本是函数，此时 _editRender 已经是执行后的 ReactNode
-    // 如果原本是 ReactElement，_editRender 就是 ReactElement
-    if ( /*#__PURE__*/React.isValidElement(_editRender)) {
-      TargetComponent = _editRender;
-    } else if (_editRender) {
+  if (isEditable && isEditing) {
+    // lastEditRender 已经是处理后的值（通过 dynamicProps.component 或直接计算）
+    // 如果原本是函数，此时 lastEditRender 已经是执行后的 ReactNode
+    // 如果原本是 ReactElement，lastEditRender 就是 ReactElement
+    if ( /*#__PURE__*/React.isValidElement(lastEditRender)) {
+      TargetComponent = lastEditRender;
+    } else if (lastEditRender) {
       // 其他情况（可能是字符串或其他类型的 ReactNode）
-      TargetComponent = _editRender;
+      TargetComponent = lastEditRender;
     }
   }
 
@@ -398,9 +401,13 @@ const RenderField = ({
   const debounceRef = useRef(null);
 
   // 使用 useCallback 创建稳定的 onChange 函数
-  const _onChange = useCallback(async (...args) => {
+  const handleChange = useCallback(async (...args) => {
     const executeChange = async (...innerArgs) => {
-      let _args = [...innerArgs];
+      // 虚拟表格：用户编辑本单元格 → 清掉旧的常驻报错，提交时再以最新值统一重校
+      if (virtual && errorStore && record?.rowKey != null) {
+        errorStore.clearCell(record.rowKey, String(column?.dataIndex));
+      }
+      let callArgs = [...innerArgs];
       const rowPath = [...namePath, index];
       if (!onFieldChange && !onChange) {
         if (dependencies?.length) {
@@ -409,15 +416,15 @@ const RenderField = ({
             form.validateFields(validateFieldKeys);
           }, 100);
         }
-        return null;
+        return;
       }
       const row = form.getFieldValue(rowPath, true);
       const orgRow = _cloneDeep(row);
       if (onFieldChange) {
-        _args = formatArgs(innerArgs);
-        _args[1] = row;
-        TargetComponent?.props?.onFieldChange && (await TargetComponent.props.onFieldChange(..._args));
-        onFieldChange && (await onFieldChange(..._args));
+        callArgs = formatArgs(innerArgs);
+        callArgs[1] = row;
+        TargetComponent?.props?.onFieldChange && (await TargetComponent.props.onFieldChange(...callArgs));
+        onFieldChange && (await onFieldChange(...callArgs));
 
         // onFieldChange 内已通过 form.setFieldValue(子路径) 或原地改 record 更新 store；此处再整行 setFieldValue(rowPath, rowAfter) 易用滞后快照覆盖 Field 刚写入的新值（如 formType）。仅延后读表做校验与 forceUpdate，不再整行回写。
         setTimeout(() => {
@@ -425,7 +432,16 @@ const RenderField = ({
           if (validateTrigger && validateTrigger.includes('onChange')) {
             if (!_isEqual(orgRow, rowAfter)) {
               const diff = difference(rowAfter, orgRow) || {};
-              const validateFieldKeys = Object.keys(diff)?.map?.(key => [...rowPath, key]).concat(dependencies || []);
+              const changedKeys = Object.keys(diff);
+              // 联动回填只写了子键，names 组合列的合并字段值未同步 → 先按子键组合写回，确保校验读到最新值
+              syncGroupCombinedValues(form, rowPath, changedKeys, columns);
+              // 把变更子键映射回所属列字段名（names 组合列 → 合并名），否则 group 列重校验路径对不上、旧报错不清
+              const changedFields = resolveChangedFields(changedKeys, columns);
+              // 虚拟表格：联动改写到的列同步清掉常驻报错，避免滚动重挂载后回填旧错
+              if (virtual && errorStore && record?.rowKey != null) {
+                changedFields.forEach(id => errorStore.clearCell(record.rowKey, id));
+              }
+              const validateFieldKeys = changedFields.map(id => [...rowPath, id]).concat(dependencies || []);
               if (validateFieldKeys?.length) {
                 debounceValidate(validateFieldKeys);
               }
@@ -442,15 +458,23 @@ const RenderField = ({
           }
         }, 0);
       } else {
-        _args = _args.concat([row, index, form]);
-        TargetComponent?.props?.onChange && (await TargetComponent.props.onChange(..._args));
-        onChange && (await onChange(..._args));
+        callArgs = callArgs.concat([row, index, form]);
+        TargetComponent?.props?.onChange && (await TargetComponent.props.onChange(...callArgs));
+        onChange && (await onChange(...callArgs));
         const rowAfter = row;
         form.setFieldValue(rowPath, rowAfter);
         if (validateTrigger && validateTrigger.includes('onChange')) {
           if (!_isEqual(orgRow, rowAfter)) {
             const diff = difference(rowAfter, orgRow) || {};
-            const validateFieldKeys = Object.keys(diff)?.map?.(key => [...rowPath, key]).concat(dependencies || []);
+            const changedKeys = Object.keys(diff);
+            // 联动回填只写了子键，names 组合列的合并字段值未同步 → 先按子键组合写回，确保校验读到最新值
+            syncGroupCombinedValues(form, rowPath, changedKeys, columns);
+            // 把变更子键映射回所属列字段名（names 组合列 → 合并名），否则 group 列重校验路径对不上、旧报错不清
+            const changedFields = resolveChangedFields(changedKeys, columns);
+            if (virtual && errorStore && record?.rowKey != null) {
+              changedFields.forEach(id => errorStore.clearCell(record.rowKey, id));
+            }
+            const validateFieldKeys = changedFields.map(id => [...rowPath, id]).concat(dependencies || []);
             if (validateFieldKeys?.length) {
               debounceValidate(validateFieldKeys);
             }
@@ -483,18 +507,36 @@ const RenderField = ({
     };
   }, []);
 
-  // 使用useCallback优化_onblur函数
-  const _onblur = useCallback(async (...args) => {
+  // 虚拟表格：单元格（重新）挂载时，回填 errorStore 中已存储的真实报错，实现报错常驻。
+  // 虚拟滚动会卸载视口外行的 Field 实体导致 antd 报错丢失，重新挂载后由此恢复红字。
+  useEffect(() => {
+    if (!virtual || !errorStore || record?.rowKey == null) {
+      return;
+    }
+    const cellKey = String(column?.dataIndex);
+    const errs = errorStore.get(record.rowKey, cellKey);
+    if (errs?.length) {
+      const fieldName = formNamePath ? cellName.slice(formNamePath?.length - 1) : cellName;
+      form.setFields([{
+        name: fieldName,
+        errors: errs
+      }]);
+    }
+    // 仅在挂载或行/列标识变化时回填
+  }, [virtual, record?.rowKey, column?.dataIndex]);
+
+  // 使用useCallback优化handleBlur函数
+  const handleBlur = useCallback(async (...args) => {
     if (!onBlur) {
-      return null;
+      return;
     }
-    let _args = formatArgs(...args);
+    let callArgs = formatArgs(...args);
     const rowPath = [...namePath, index];
     const row = form.getFieldValue(rowPath, true);
     const orgRow = _cloneDeep(row);
-    _args[1] = row;
-    TargetComponent?.props?.onBlur && (await TargetComponent.props.onBlur(..._args));
-    onBlur && (await onBlur(..._args));
+    callArgs[1] = row;
+    TargetComponent?.props?.onBlur && (await TargetComponent.props.onBlur(...callArgs));
+    onBlur && (await onBlur(...callArgs));
     // 判断属性是否变动
     form.setFieldValue(rowPath, row);
     if (validateTrigger && validateTrigger.includes('onBlur')) {
@@ -520,15 +562,15 @@ const RenderField = ({
   let componentProps = useMemo(() => ({
     form,
     name: cellName,
-    ..._fieldProps,
+    ...lastFieldProps,
     ...TargetComponent?.props,
     namePath: [...namePath, index],
-    disabled: _disabled,
-    onChange: _onChange,
-    onBlur: _onblur,
+    disabled: lastDisabled,
+    onChange: handleChange,
+    onBlur: handleBlur,
     index,
     confirm,
-    desensitization: _desensitization,
+    desensitization: lastDesensitization,
     otherProps: {
       form,
       names,
@@ -537,15 +579,15 @@ const RenderField = ({
       listName: cellName,
       // 用于下拉框去重消费，保持和formlist一致
       viewEmpty,
-      valueType: _valueType,
+      valueType: lastValueType,
       isView,
       desensitizationKey: otherProps?.desensitizationKey,
       source: 'ProEditTable'
     }
-  }), [cellName, _fieldProps, TargetComponent?.props, namePath, index, _disabled, _onChange, _onblur, confirm, _desensitization, names, originalName, viewEmpty, _valueType, isView, otherProps?.desensitizationKey]);
+  }), [cellName, lastFieldProps, TargetComponent?.props, namePath, index, lastDisabled, handleChange, handleBlur, confirm, lastDesensitization, names, originalName, viewEmpty, lastValueType, isView, otherProps?.desensitizationKey]);
   componentProps = _omit(componentProps, ['onFieldChange', 'namePath', 'index', ...OMIT_FORM_ITEM_AND_DOM_KEYS]);
   if (['Switch', 'SwitchCheckbox'].includes(type)) {
-    _formItemProps.valuePropName = 'checked';
+    lastFormItemProps.valuePropName = 'checked';
   }
 
   // 可编辑表格默认关闭scrollFollowParent
@@ -560,9 +602,9 @@ const RenderField = ({
     const trimProps = isTrim(type, trim, proConfig); // 使用顶层调用的proConfig
 
     const transformNormalize = namesTransformProps?.normalize ?? defaultTransformProps?.normalize;
-    const userNormalize = _formItemProps?.normalize;
+    const userNormalize = lastFormItemProps?.normalize;
     const transformGetValueProps = namesTransformProps?.getValueProps ?? defaultTransformProps?.getValueProps;
-    const userGetValueProps = _formItemProps?.getValueProps;
+    const userGetValueProps = lastFormItemProps?.getValueProps;
     const finalNormalize = transformNormalize && userNormalize ? (value, prevValue, allValues, isDiffMode) => {
       // 用户 normalize 需要拿到组件原始值（如 DatePicker 的 dayjs）
       const userValue = userNormalize(value, prevValue, allValues, isDiffMode);
@@ -583,203 +625,205 @@ const RenderField = ({
       };
     } : userGetValueProps || transformGetValueProps;
     return {
-      ..._formItemProps,
+      ...lastFormItemProps,
       ...defaultTransformProps,
       ...namesTransformProps,
       ...trimProps,
       normalize: finalNormalize,
       getValueProps: finalGetValueProps
     };
-  }, [_formItemProps, defaultTransform, namesTransform, type, trim, proConfig]);
+  }, [lastFormItemProps, defaultTransform, namesTransform, type, trim, proConfig]);
 
   // rules 的 isView 过滤已移至 getFieldItem 内处理（支持 shouldUpdate 模式下的动态 isEditable）
 
-  const _className = useMemo(() => classNames({
+  const cellClassName = useMemo(() => classNames({
     [className]: className
   }), [className]);
 
-  // 使用useCallback优化getFieldItem函数
-  const getFieldItem = (shouldUpdateMode = false) => {
-    // 如果处于 shouldUpdate 模式，需要重新获取最新的行数据并重新计算依赖值
-    let finalComponentProps = componentProps;
-    // shouldUpdate 模式下会被更新为最新值，供外层 FieldProvider 消费
-    let latestIsView = isView;
-    // 用于在 shouldUpdate 模式下重建正确的 Form.Item rules（外层 finalFormItemProps 是旧闭包）
-    let effectiveRequired = _required;
-    let effectiveRules = _rules;
-    let effectiveFieldProps = _fieldProps;
-    if (shouldUpdateMode) {
-      // 重新获取最新的行数据（shouldUpdate 触发时，通过 getFieldValue 拿到最新值）
-      const latestRowData = form.getFieldValue([...namePath, index]) || record || {};
-      const latestReactiveParams = {
-        form,
-        index,
-        namePath: [...namePath, index]
-      };
-      const latestRowParams = [latestRowData, latestReactiveParams];
+  // shouldUpdate 模式下重新获取最新行数据并重算所有响应式属性，返回最新渲染状态（不修改外层闭包）
+  const recalcShouldUpdateState = () => {
+    // 重新获取最新的行数据（shouldUpdate 触发时，通过 getFieldValue 拿到最新值）
+    const latestRowData = form.getFieldValue([...namePath, index]) || record || {};
+    const latestReactiveParams = {
+      form,
+      index,
+      namePath: [...namePath, index]
+    };
+    const latestRowParams = [latestRowData, latestReactiveParams];
 
-      // ⭐ 关键修改：shouldUpdate 模式下，跳过缓存，直接重新计算所有响应式属性
-      let latestFieldProps = fieldProps || {};
-      if (_isFunction(fieldProps)) {
-        latestFieldProps = fieldProps(latestRowData, latestReactiveParams);
-      }
+    // ⭐ 关键修改：shouldUpdate 模式下，跳过缓存，直接重新计算所有响应式属性
+    let latestFieldProps = fieldProps || {};
+    if (_isFunction(fieldProps)) {
+      latestFieldProps = fieldProps(latestRowData, latestReactiveParams);
+    }
 
-      // 重新计算 required（用于可能的后续逻辑）
-      let latestRequired = required;
-      if (_isFunction(required)) {
-        latestRequired = required(latestRowData, latestReactiveParams);
-      }
+    // 重新计算 required（用于可能的后续逻辑）
+    let latestRequired = required;
+    if (_isFunction(required)) {
+      latestRequired = required(latestRowData, latestReactiveParams);
+    }
 
-      // 重新计算 rules（用于可能的后续逻辑）
-      let latestRules = rules;
-      if (_isFunction(rules)) {
-        latestRules = rules(latestRowData, latestReactiveParams);
-      }
+    // 重新计算 rules（用于可能的后续逻辑）
+    let latestRules = rules;
+    if (_isFunction(rules)) {
+      latestRules = rules(latestRowData, latestReactiveParams);
+    }
 
-      // 同步到外层变量，用于后续构建 activeFinalFormItemProps
-      effectiveRequired = latestRequired;
-      effectiveRules = latestRules;
-      effectiveFieldProps = latestFieldProps;
+    // 重新计算 desensitization
+    let latestDesensitization = desensitization || [];
+    if (_isFunction(desensitization)) {
+      latestDesensitization = desensitization(latestRowData, latestReactiveParams);
+    }
 
-      // 重新计算 desensitization
-      let latestDesensitization = desensitization || [];
-      if (_isFunction(desensitization)) {
-        latestDesensitization = desensitization(latestRowData, latestReactiveParams);
-      }
+    // 重新计算 component
+    let latestComponent = component || editRender;
+    if (_isFunction(latestComponent)) {
+      latestComponent = latestComponent(latestRowData, latestReactiveParams);
+    }
 
-      // 重新计算 component
-      let latestComponent = component || editRender;
-      if (_isFunction(latestComponent)) {
-        latestComponent = latestComponent(latestRowData, latestReactiveParams);
-      }
+    // 重新计算 isEditable（使用原始的 column.isEditable，而不是处理后的 isEditable）
+    let latestIsEditable = column.isEditable ?? true;
+    if (_isFunction(column.isEditable)) {
+      latestIsEditable = column.isEditable(latestRowData, latestReactiveParams);
+    }
 
-      // 重新计算 isEditable（使用原始的 column.isEditable，而不是处理后的 isEditable）
-      let latestIsEditable = column.isEditable ?? true;
-      if (_isFunction(column.isEditable)) {
-        latestIsEditable = column.isEditable(latestRowData, latestReactiveParams);
-      }
+    // 重新计算 disabled
+    const latestDisabled = getDisabled({
+      globalControl: otherProps?.globalControl,
+      formDisabled: otherProps?.formDisabled,
+      column,
+      tabledDisabled: config?.disabled,
+      columnFieldProps: latestFieldProps,
+      params: latestRowParams
+    });
 
-      // 重新计算 disabled
-      const latestDisabled = getDisabled({
-        globalControl: otherProps?.globalControl,
-        formDisabled: otherProps?.formDisabled,
-        column,
-        tabledDisabled: config?.disabled,
-        columnFieldProps: latestFieldProps,
-        params: latestRowParams
-      });
+    // 更新 componentProps 中的所有响应式属性
+    // latestTargetComponent 稍后计算，此处先占位；最终会在下方合并 latestTargetComponent?.props
+    let latestComponentProps = {
+      ...componentProps,
+      ...latestFieldProps,
+      disabled: latestDisabled,
+      desensitization: latestDesensitization,
+      // shouldUpdate 模式下，确保事件包装函数不被 fieldProps 覆盖
+      onChange: handleChange,
+      onBlur: handleBlur
+    };
 
-      // 更新 componentProps 中的所有响应式属性
-      // latestTargetComponent 稍后计算，此处先占位；最终 finalComponentProps 会在下方合并 latestTargetComponent?.props
-      finalComponentProps = {
-        ...componentProps,
-        ...latestFieldProps,
-        disabled: latestDisabled,
-        desensitization: latestDesensitization,
-        // shouldUpdate 模式下，确保事件包装函数不被 fieldProps 覆盖
-        onChange: _onChange,
-        onBlur: _onblur
-      };
+    // ⭐ 关键修改：在 shouldUpdate 模式下，需要重新设置 TargetComponent
+    // 因为 component 函数可能返回不同的结果
+    let latestTargetComponent = TargetComponent;
 
-      // ⭐ 关键修改：在 shouldUpdate 模式下，需要重新设置 TargetComponent
-      // 因为 component 函数可能返回不同的结果
-      let latestTargetComponent = TargetComponent;
+    // 首先检查是否有内置type
+    if (!latestComponent && typeof type === 'string') {
+      latestTargetComponent = componentMap[type] ?? /*#__PURE__*/_jsx(_Fragment, {});
+    }
 
-      // 首先检查是否有内置type
-      if (!latestComponent && typeof type === 'string') {
-        latestTargetComponent = componentMap[type] ?? /*#__PURE__*/_jsx(_Fragment, {});
+    // 然后处理自定义 component
+    const latestIsView = !latestIsEditable || record?.['is-view'] || config.isView || virtualKey && !isEditing || getDisabled({
+      globalControl: otherProps?.globalControl,
+      formDisabled: otherProps?.formDisabled,
+      column,
+      tabledDisabled: config?.disabled,
+      columnFieldProps: latestFieldProps,
+      params: latestRowParams,
+      rowDisabled: rowDisabled || 'empty'
+    });
+    if (latestIsEditable && isEditing) {
+      if ( /*#__PURE__*/React.isValidElement(latestComponent)) {
+        latestTargetComponent = latestComponent;
+      } else if (latestComponent) {
+        latestTargetComponent = latestComponent;
       }
+    }
 
-      // 然后处理自定义 component
-      latestIsView = !latestIsEditable || record?.['is-view'] || config.isView || virtualKey && !_isEditing || getDisabled({
-        globalControl: otherProps?.globalControl,
-        formDisabled: otherProps?.formDisabled,
-        column,
-        tabledDisabled: config?.disabled,
-        columnFieldProps: latestFieldProps,
-        params: latestRowParams,
-        rowDisabled: rowDisabled || 'empty'
-      });
-      if (latestIsEditable && _isEditing) {
-        if ( /*#__PURE__*/React.isValidElement(latestComponent)) {
-          latestTargetComponent = latestComponent;
-        } else if (latestComponent) {
-          latestTargetComponent = latestComponent;
-        }
+    // 查看模式
+    if (latestIsView) {
+      if (typeof viewRender === 'function') {
+        const latestCurrentValue = dataIndex ? latestRowData?.[dataIndex] : null;
+        const View = viewRender(latestCurrentValue, latestRowData || {}, options);
+        latestTargetComponent = /*#__PURE__*/_jsx(Container, {
+          viewEmpty: viewEmpty,
+          children: View
+        });
       }
-
-      // 查看模式
-      if (latestIsView) {
-        if (typeof viewRender === 'function') {
-          const latestCurrentValue = dataIndex ? latestRowData?.[dataIndex] : null;
-          const View = viewRender(latestCurrentValue, latestRowData || {}, options);
-          latestTargetComponent = /*#__PURE__*/_jsx(Container, {
-            viewEmpty: viewEmpty,
-            children: View
-          });
-        }
-        if ( /*#__PURE__*/React.isValidElement(viewRender)) {
-          latestTargetComponent = viewRender;
-        }
+      if ( /*#__PURE__*/React.isValidElement(viewRender)) {
+        latestTargetComponent = viewRender;
       }
+    }
 
-      // 使用重新计算的 TargetComponent
-      TargetComponent = latestTargetComponent;
-
-      // shouldUpdate 触发时外层 componentProps.otherProps.isView 是旧快照，需用最新值覆盖
-      finalComponentProps = {
-        ...finalComponentProps,
-        otherProps: {
-          ...finalComponentProps.otherProps,
-          isView: latestIsView
-        }
-      };
+    // shouldUpdate 触发时外层 componentProps.otherProps.isView 是旧快照，需用最新值覆盖
+    latestComponentProps = {
+      ...latestComponentProps,
+      otherProps: {
+        ...latestComponentProps.otherProps,
+        isView: latestIsView
+      }
+    };
 
-      // componentProps 里展开了外层旧 TargetComponent?.props（如 { formType: "Input" }），
-      // 用 latestTargetComponent?.props 覆盖，确保不会被旧 cloneElement props 污染
-      if ( /*#__PURE__*/React.isValidElement(latestTargetComponent)) {
-        const componentProps = latestTargetComponent.props;
-        // 确保 props 是对象类型才进行展开
-        if (componentProps && typeof componentProps === 'object') {
-          finalComponentProps = {
-            ...finalComponentProps,
-            ...componentProps,
-            // 始终保证事件处理函数不被覆盖
-            onChange: _onChange,
-            onBlur: _onblur
-          };
-        }
+    // componentProps 里展开了外层旧 TargetComponent?.props（如 { formType: "Input" }），
+    // 用 latestTargetComponent?.props 覆盖，确保不会被旧 cloneElement props 污染
+    if ( /*#__PURE__*/React.isValidElement(latestTargetComponent)) {
+      const elementProps = latestTargetComponent.props;
+      // 确保 props 是对象类型才进行展开
+      if (elementProps && typeof elementProps === 'object') {
+        latestComponentProps = {
+          ...latestComponentProps,
+          ...elementProps,
+          // 始终保证事件处理函数不被覆盖
+          onChange: handleChange,
+          onBlur: handleBlur
+        };
       }
     }
+    return {
+      finalComponentProps: latestComponentProps,
+      targetComponent: latestTargetComponent,
+      latestIsView,
+      effectiveRequired: latestRequired,
+      effectiveRules: latestRules,
+      effectiveFieldProps: latestFieldProps
+    };
+  };
 
-    // 根据 latestIsView 和最新的 required/rules 构建正确的 Form.Item props
-    // 解决 shouldUpdate 触发时外层 finalFormItemProps 是旧闭包（rules 基于旧 isView 计算）的问题
-    let activeFinalFormItemProps = finalFormItemProps;
+  // 根据 latestIsView 和最新 required/rules 构建正确的 Form.Item props
+  // 解决 shouldUpdate 触发时外层 finalFormItemProps 是旧闭包（rules 基于旧 isView 计算）的问题
+  const buildActiveFormItemProps = ({
+    latestIsView,
+    shouldUpdateMode,
+    effectiveRequired,
+    effectiveRules,
+    effectiveFieldProps
+  }) => {
     if (latestIsView) {
       // 查看模式：移除 rules 不做校验
-      activeFinalFormItemProps = _omit(finalFormItemProps, ['rules']);
-    } else if (shouldUpdateMode) {
+      return _omit(finalFormItemProps, ['rules']);
+    }
+    if (shouldUpdateMode) {
       // shouldUpdate 模式下 finalFormItemProps 是旧闭包，需用最新 effectiveRequired/effectiveRules 重建 rules
       const activeRules = Array.isArray(effectiveRules) ? [...effectiveRules] : [];
       const hasRequiredRule = activeRules.some(r => r?.required === true);
       if (effectiveRequired && !hasRequiredRule) {
-        const _isSelectVal = isSelect({
+        const isSelectVal = isSelect({
           dataSource: effectiveFieldProps?.dataSource,
           type
         });
         activeRules.push({
           required: true,
-          message: `${_isSelectVal ? locale.ProForm.selectPlaceHolder : locale.ProForm.inputPlaceholder}${label || ''}`
+          message: `${isSelectVal ? locale.ProForm.selectPlaceHolder : locale.ProForm.inputPlaceholder}${label || ''}`
         });
       }
-      activeFinalFormItemProps = {
+      return {
         ...finalFormItemProps,
         rules: activeRules.length > 0 ? activeRules : [{
           required: false
         }]
       };
     }
-    let FormItem = null;
+    return finalFormItemProps;
+  };
+
+  // 组装字段组件：DOM 透传字段过滤、克隆/创建目标元素、原始值对比包裹（ListChangedWrapper）、确认弹窗包裹（ConfirmWrapper）
+  const assembleFieldComponent = finalComponentProps => {
     // 当 viewRender 存在时，需要排除 finalComponentProps 中的 children，避免覆盖 Container 的 children
     let propsForTarget = isView && typeof viewRender === 'function' ? _omit(finalComponentProps, ['children']) : finalComponentProps;
     // 当目标为原生 DOM 元素（如 viewRender 返回 <div>）时，剔除 disabled、toCSTString 等，避免 React 警告
@@ -810,8 +854,8 @@ const RenderField = ({
         form: form,
         onDiff: onDiff,
         type: type,
-        onChange: _onChange,
-        onBlur: _onblur,
+        onChange: handleChange,
+        onBlur: handleBlur,
         valuePropName: finalFormItemProps.valuePropName,
         normalize: finalFormItemProps.normalize,
         getValueProps: finalFormItemProps.getValueProps,
@@ -827,11 +871,42 @@ const RenderField = ({
         children: FieldComponent
       });
     }
-    FormItem = TargetComponent ? /*#__PURE__*/_jsx(Form.Item, {
+    return FieldComponent;
+  };
+
+  // 使用useCallback优化getFieldItem函数
+  const getFieldItem = (shouldUpdateMode = false) => {
+    // 如果处于 shouldUpdate 模式，需要重新获取最新的行数据并重新计算依赖值
+    let finalComponentProps = componentProps;
+    // shouldUpdate 模式下会被更新为最新值，供外层 FieldProvider 消费
+    let latestIsView = isView;
+    // 用于在 shouldUpdate 模式下重建正确的 Form.Item rules（外层 finalFormItemProps 是旧闭包）
+    let effectiveRequired = lastRequired;
+    let effectiveRules = lastRules;
+    let effectiveFieldProps = lastFieldProps;
+    if (shouldUpdateMode) {
+      const recomputed = recalcShouldUpdateState();
+      finalComponentProps = recomputed.finalComponentProps;
+      // shouldUpdate 模式下用重算结果覆盖外层 TargetComponent，供下方组装逻辑消费
+      TargetComponent = recomputed.targetComponent;
+      latestIsView = recomputed.latestIsView;
+      effectiveRequired = recomputed.effectiveRequired;
+      effectiveRules = recomputed.effectiveRules;
+      effectiveFieldProps = recomputed.effectiveFieldProps;
+    }
+    const activeFinalFormItemProps = buildActiveFormItemProps({
+      latestIsView,
+      shouldUpdateMode,
+      effectiveRequired,
+      effectiveRules,
+      effectiveFieldProps
+    });
+    const FieldComponent = assembleFieldComponent(finalComponentProps);
+    let FormItem = TargetComponent ? /*#__PURE__*/_jsx(Form.Item, {
       validateFirst: true,
-      ..._omit(activeFinalFormItemProps, ['render', 'key', 'width', 'hiddenNames', 'name', 'onCell', 'disabled', _formItemProps.shouldUpdate ? 'shouldUpdate' : null]),
+      ..._omit(activeFinalFormItemProps, ['render', 'key', 'width', 'hiddenNames', 'name', 'onCell', 'disabled', lastFormItemProps.shouldUpdate ? 'shouldUpdate' : null]),
       // 移除非必要字段，但保留 dependencies
-      className: _className,
+      className: cellClassName,
       name: formNamePath ? cellName.slice(formNamePath?.length - 1) : cellName,
       children: FieldComponent
     }) : /*#__PURE__*/_jsx(Container, {
@@ -875,132 +950,4 @@ const RenderField = ({
     })
   });
 };
-export default /*#__PURE__*/memo(RenderField, (prevProps, nextProps) => {
-  // 自定义比较函数，只有关键props变化时才重新渲染
-  const {
-    text: prevText,
-    record: prevRecord,
-    index: prevIndex,
-    column: prevColumn,
-    config: prevConfig
-  } = prevProps;
-  const {
-    text: nextText,
-    record: nextRecord,
-    index: nextIndex,
-    column: nextColumn,
-    config: nextConfig
-  } = nextProps;
-
-  // 函数型动态属性（component/editRender/fieldProps/rules/required/disabled/isEditable/valueType）
-  // 可能依赖行内兄弟字段；行对象为同引用（原地修改）时，浅比较无法区分，需强制重渲染
-  const hasFunctionDependency = _isFunction(prevColumn?.component) || _isFunction(prevColumn?.editRender) || _isFunction(prevColumn?.fieldProps) || _isFunction(prevColumn?.rules) || _isFunction(prevColumn?.required) || _isFunction(prevColumn?.disabled) || _isFunction(prevColumn?.isEditable) || _isFunction(prevColumn?.valueType) || _isFunction(nextColumn?.component) || _isFunction(nextColumn?.editRender) || _isFunction(nextColumn?.fieldProps) || _isFunction(nextColumn?.rules) || _isFunction(nextColumn?.required) || _isFunction(nextColumn?.disabled) || _isFunction(nextColumn?.isEditable) || _isFunction(nextColumn?.valueType);
-  if (hasFunctionDependency && prevRecord === nextRecord) {
-    return false;
-  }
-
-  // 构建新的参数格式（与 ProForm 保持一致）
-  const prevNamePath = getNamePath(prevConfig?.name, prevConfig?.virtualKey);
-  const nextNamePath = getNamePath(nextConfig?.name, nextConfig?.virtualKey);
-  const prevReactiveParams = {
-    form: prevConfig?.form,
-    index: prevIndex,
-    namePath: [...prevNamePath, prevIndex]
-  };
-  const nextReactiveParams = {
-    form: nextConfig?.form,
-    index: nextIndex,
-    namePath: [...nextNamePath, nextIndex]
-  };
-  const prevRowParams = [prevRecord, prevReactiveParams];
-  const nextRowParams = [nextRecord, nextReactiveParams];
-  if (_isFunction(prevColumn?.disabled) && _isFunction(nextColumn?.disabled)) {
-    if (prevColumn?.disabled(prevRecord, prevReactiveParams) !== nextColumn?.disabled(nextRecord, nextReactiveParams)) {
-      return false;
-    }
-  }
-
-  // fieldProps 函数化直接更新，无法比对返回值是否一致
-  // 优化：不直接调用函数，而是比较输入参数（record 和 reactiveParams）
-  // 如果输入参数相同，fieldProps 的返回值应该相同（纯函数假设）
-  if (_isFunction(prevColumn?.fieldProps) && _isFunction(nextColumn?.fieldProps)) {
-    // 比较 record 数据是否变化
-    if (!_isEqualWith(prevRecord, nextRecord, customEqualForFunction)) {
-      return false;
-    }
-    // reactiveParams 中的 form、index、namePath 已经在外层比较过了，无需重复比较
-  }
-  // fieldProps 为对象时，必须比较配置变化（如 dataSource 异步更新）
-  if (!_isFunction(prevColumn?.fieldProps) && !_isFunction(nextColumn?.fieldProps)) {
-    const isFieldPropsEqual = _isEqualWith(prevColumn?.fieldProps, nextColumn?.fieldProps, customEqualForFunction);
-    if (!isFieldPropsEqual) {
-      return false;
-    }
-  }
-
-  // 通用函数比较方法
-  // 优化：不直接调用函数，而是比较函数引用和输入参数
-  const compareFunctionResult = (prevColumn, nextColumn, prevValues, nextValues, prevReactiveParams, nextReactiveParams, functionName) => {
-    const prevFunc = prevColumn?.[functionName];
-    const nextFunc = nextColumn?.[functionName];
-    if (_isFunction(prevFunc) && _isFunction(nextFunc)) {
-      // 函数引用变化说明闭包可能捕获了新的外部状态（如异步加载的 list），必须重渲染
-      if (prevFunc !== nextFunc) return false;
-      // 同引用函数，比较输入参数（纯函数假设：输入相同则输出相同）
-      return _isEqualWith(prevValues, nextValues, customEqualForFunction);
-    }
-    return true; // 如果不是函数或只有一个是函数，认为相等
-  };
-
-  // 使用简化后的比较逻辑
-  const functionFields = ['rules', 'component', 'desensitization', 'isEditable', 'required'];
-  if (functionFields.some(field => !compareFunctionResult(prevColumn, nextColumn, prevRecord, nextRecord, prevReactiveParams, nextReactiveParams, field))) {
-    return false;
-  }
-
-  // 基本props比较
-  if (!_isEqual(prevText, nextText) || prevIndex !== nextIndex) {
-    return false;
-  }
-
-  // 记录关键字段比较（避免完整对象比较的性能开销）
-  if (prevRecord?.rowKey !== nextRecord?.rowKey || prevRecord?._addFlag !== nextRecord?._addFlag) {
-    return false;
-  }
-
-  // 列配置比较（只比较关键字段）,required,disabled为函数时，需要重新计算
-  if (prevColumn?.dataIndex !== nextColumn?.dataIndex || prevColumn?.type !== nextColumn?.type || prevColumn?.name !== nextColumn?.name) {
-    return false;
-  }
-
-  // config中关键字段比较
-  if (prevConfig?._isEditing !== nextConfig?._isEditing || prevConfig?.mode !== nextConfig?.mode) {
-    return false;
-  }
-
-  // 当前单元格的值比较
-  const prevDataIndex = prevColumn?.dataIndex;
-  const nextDataIndex = nextColumn?.dataIndex;
-  if (prevDataIndex && nextDataIndex && prevDataIndex === nextDataIndex) {
-    if (prevRecord?.[prevDataIndex] !== nextRecord?.[nextDataIndex]) {
-      return false;
-    }
-  }
-
-  // 特殊处理：当使用自定义 component 函数时，比较整个 record 对象
-  // 因为自定义组件可能依赖 record 中的其他字段（不只是当前列的 dataIndex）
-  if (_isFunction(prevColumn?.component) || _isFunction(nextColumn?.component)) {
-    // 浅比较 record 的所有属性
-    const prevKeys = Object.keys(prevRecord || {});
-    const nextKeys = Object.keys(nextRecord || {});
-    if (prevKeys.length !== nextKeys.length) {
-      return false;
-    }
-
-    // 使用 some 方法代替 for 循环
-    if (prevKeys.some(key => prevRecord?.[key] !== nextRecord?.[key])) {
-      return false;
-    }
-  }
-  return true;
-});
+export default /*#__PURE__*/memo(RenderField, arePropsEqual);