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

package/es/ProEditTable/components/RenderField/propsType.d.ts

@@ -0,0 +1,30 @@
+import { FormInstance } from 'antd';
+import { InternalNamePath, NamePath } from 'antd/lib/form/interface';
+import { DiffOriginalParams } from '../../utils/diffOriginal';
+export interface GetOriginalValueParams {
+    namePath: InternalNamePath;
+    originalName: InternalNamePath;
+    originalNames?: InternalNamePath[];
+    originalValues?: any;
+    rowKeyPath?: InternalNamePath;
+    form: FormInstance;
+}
+export interface Props {
+    name?: NamePath;
+    names?: NamePath[];
+    originalName?: NamePath;
+    originalNames?: NamePath[];
+    namesStr?: NamePath;
+    originalValues?: any;
+    form: FormInstance;
+    onDiff?: DiffOriginalParams['onDiff'];
+    [name: string]: any;
+}
+/** RenderField 的 props 多为表格运行期动态结构（column/config/record），保留显式 any */
+export interface RenderFieldComparableProps {
+    text?: any;
+    record?: any;
+    index: number;
+    column?: any;
+    config?: any;
+}

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

@@ -0,0 +1 @@
+export {};

package/es/ProEditTable/components/RenderField/tools.d.ts

@@ -0,0 +1,22 @@
+import { InternalNamePath, NamePath } from 'antd/lib/form/interface';
+import { GetOriginalValueParams, RenderFieldComparableProps } from './propsType';
+/** 列配置中不应透传到 Form.Item 或 DOM 的字段（与 ProForm Render 保持一致） */
+export declare const OMIT_FORM_ITEM_AND_DOM_KEYS: string[];
+/** 克隆子元素时需从 props 中剔除，避免透传到 div 等 DOM 导致 React 警告 */
+export declare const OMIT_FROM_DOM_KEYS: string[];
+export declare const toNamePath: (name: NamePath) => InternalNamePath;
+export declare const toNamePaths: (names: NamePath[]) => InternalNamePath[];
+export declare const getOriginalValue: ({ namePath, originalName, originalNames, originalValues, rowKeyPath, form, }: GetOriginalValueParams) => {
+    originalValue: any;
+    originRecord: any;
+    record: any;
+} | {
+    originalValue: any;
+    originRecord: any;
+    record?: undefined;
+};
+/**
+ * memo 自定义比较函数：只有关键 props 变化时才重新渲染。
+ * 从 RenderField 拆出，行为与原内联实现保持一致。
+ */
+export declare const arePropsEqual: (prevProps: RenderFieldComparableProps, nextProps: RenderFieldComparableProps) => boolean;

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

@@ -0,0 +1,203 @@
+import _isFunction from "lodash/isFunction";
+import _isEqualWith from "lodash/isEqualWith";
+import _isEqual from "lodash/isEqual";
+import _get from "lodash/get";
+import { customEqualForFunction } from "../../../utils";
+import { getNamePath } from "../../utils/tools";
+/** 列配置中不应透传到 Form.Item 或 DOM 的字段（与 ProForm Render 保持一致） */
+export const OMIT_FORM_ITEM_AND_DOM_KEYS = ['format', 'toISOString', 'toCSTString', 'switchValue', 'precision', 'clearNotShow', 'dependNames', 'shouldCellUpdate' // 表格内部性能优化属性，不应传递给 Form.Item
+];
+
+/** 克隆子元素时需从 props 中剔除，避免透传到 div 等 DOM 导致 React 警告 */
+export const OMIT_FROM_DOM_KEYS = ['disabled',
+// div 不支持 disabled，且值可能非 string/number
+'toCSTString', 'toISOString', 'format', 'switchValue', 'precision', 'clearNotShow', 'dependNames'];
+export const toNamePath = name => {
+  if (Array.isArray(name)) {
+    return name;
+  }
+  return [name];
+};
+export const toNamePaths = names => {
+  return names.map(name => toNamePath(name));
+};
+export const getOriginalValue = ({
+  namePath,
+  originalName,
+  originalNames,
+  originalValues,
+  rowKeyPath,
+  form
+}) => {
+  if (!originalValues) {
+    return undefined;
+  }
+  let originRecord;
+  if (rowKeyPath) {
+    const rowValueNamePath = namePath.slice(0, rowKeyPath.length - 1); // 表单中变动值所在行
+    const rowKeyName = rowKeyPath[rowKeyPath.length - 1]; // rowKey在行内的name
+
+    const rowValue = form.getFieldValue(rowValueNamePath);
+    if (!rowValue) return undefined;
+    const keyValue = rowValue[rowKeyName]; // 获取表单中rowKey值
+    if (!keyValue) return undefined;
+    const originalValueList = _get(originalValues, originalName.slice(0, rowKeyPath.length - 2));
+    originRecord = originalValueList?.find(item => {
+      return item[rowKeyPath[rowKeyPath.length - 1]] === keyValue;
+    });
+    let originalValue;
+    if (originalNames?.length) {
+      const originalNamesValue = originalNames.map(originalName => {
+        return _get(originRecord, originalName.slice(rowKeyPath.length - 1));
+      });
+
+      // 有可能出现数组中全是undefined的情况  视为没有值
+      const fillUndefined = originalNamesValue.every(valItem => valItem === undefined);
+      originalValue = fillUndefined ? undefined : originalNamesValue;
+    } else {
+      originalValue = _get(originRecord, originalName.slice(rowKeyPath.length - 1));
+    }
+    return {
+      originalValue,
+      originRecord,
+      record: rowValue
+    };
+  }
+
+  // 这个方法是给editTable专用的  暂时不存在不传rowKey的情况
+  return {
+    originalValue: originalNames?.length ? originalNames.map(originalName => _get(originalValues, originalName)) : _get(originalValues, originalName),
+    originRecord
+  };
+};
+
+/**
+ * memo 自定义比较函数：只有关键 props 变化时才重新渲染。
+ * 从 RenderField 拆出，行为与原内联实现保持一致。
+ */
+export const arePropsEqual = (prevProps, nextProps) => {
+  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]
+  };
+  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 = (prevCol, nextCol, prevValues, nextValues, _prevReactiveParams, _nextReactiveParams, functionName) => {
+    const prevFunc = prevCol?.[functionName];
+    const nextFunc = nextCol?.[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;
+};

package/es/ProEditTable/components/Validator/index.d.ts

@@ -1,10 +1,19 @@
 /// <reference types="react" />
 import type { NamePath } from 'antd/es/form/interface';
+import { type ErrorStore } from '../../utils/validateAll';
 interface ValidatorProps {
     name?: NamePath;
     virtualKey?: string;
     editingKeys?: string[];
     onlyOneLineMsg?: string;
+    /** antd6 虚拟表格开关：开启时注册聚合校验字段，覆盖视口外未挂载的行 */
+    virtual?: boolean;
+    /** 原始列配置（含 name/names/rules/required/label 等），用于全量真实规则校验 */
+    columns?: any[];
+    /** 表格内部 config（提供 form/name/disabled/isView/otherProps 等） */
+    config?: any;
+    /** 外部错误存储，承载「报错常驻」的真实文案来源 */
+    errorStore?: ErrorStore;
 }
 declare const _default: import("react").NamedExoticComponent<ValidatorProps>;
 export default _default;

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

@@ -1,14 +1,56 @@
-import { memo } from 'react';
+import { memo, useCallback } from 'react';
 import { Form, message } from 'antd';
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { runUnifiedValidation } from "../../utils/validateAll";
+import { scrollVirtualToErrorColumn } from "../../utils/tools";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const Validator = ({
   name,
   virtualKey,
   editingKeys,
-  onlyOneLineMsg
+  onlyOneLineMsg,
+  virtual,
+  columns,
+  config,
+  errorStore
 }) => {
-  return /*#__PURE__*/_jsx(_Fragment, {
-    children: name && virtualKey ? /*#__PURE__*/_jsx(Form.Item, {
+  // 聚合校验：在 form.validateFields()（提交）时对全量数据跑真实规则，
+  // 既拦截视口外非法行（统一校验），又把真实报错写入 errorStore 供滚动到该行时回填（报错常驻）。
+  const aggregateValidator = useCallback(async () => {
+    if (!errorStore || !config?.form) {
+      return Promise.resolve();
+    }
+    const {
+      hasError,
+      firstErrorIndex,
+      firstErrorRowKey
+    } = await runUnifiedValidation({
+      form: config.form,
+      name: config.name,
+      columns: columns || [],
+      config,
+      errorStore
+    });
+    if (hasError) {
+      // 滚动首个错误行进入视口 → 其单元格挂载后由 RenderField 回填红字
+      if (firstErrorIndex != null) {
+        requestAnimationFrame(() => {
+          // 纵向：scrollTo({ index }) 仅定位行
+          config?.tableRef?.current?.scrollTo?.({
+            index: firstErrorIndex
+          });
+          // 横向：等错误行渲染后，下一帧把错误列滚入视口（虚拟表格横向需 scrollTo({ left })）
+          requestAnimationFrame(() => {
+            scrollVirtualToErrorColumn(config?.tableRef, firstErrorRowKey);
+          });
+        });
+      }
+      return Promise.reject(new Error(''));
+    }
+    return Promise.resolve();
+  }, [errorStore, config, columns]);
+  const nameKey = Array.isArray(name) ? name.filter(Boolean).join('-') : String(name);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [name && virtualKey ? /*#__PURE__*/_jsx(Form.Item, {
       noStyle: true,
       validateFirst: true,
       name: `${name}-${virtualKey}`,
@@ -23,7 +65,15 @@ const Validator = ({
         }
       }],
       children: /*#__PURE__*/_jsx(_Fragment, {})
-    }) : null
+    }) : null, name && virtual && !config?.isView && !config?.disabled ? /*#__PURE__*/_jsx(Form.Item, {
+      noStyle: true,
+      validateFirst: true,
+      name: `${nameKey}-virtual-validator`,
+      rules: [{
+        validator: aggregateValidator
+      }],
+      children: /*#__PURE__*/_jsx(_Fragment, {})
+    }) : null]
   });
 };
 export default /*#__PURE__*/memo(Validator);

package/es/ProEditTable/index.js

@@ -8,6 +8,7 @@ import { useLocalStorageState, useSetState } from 'ahooks';
 import { ConfigProvider, Form, Affix } from 'antd';
 import classnames from 'classnames';
 import { transformColumns } from "./utils";
+import { createErrorStore } from "./utils/validateAll";
 import { getRandom, getNamePath, handleScrollToError, onPageCheck, buildTableRowKey } from "./utils/tools";
 import { Validator, Summary, RenderToolbar } from "./components";
 import ProForm from "../ProForm";
@@ -69,6 +70,12 @@ const ProEditTable = ({
     disabled = formFieldProps?.disabled || disabled; // formFieldProps?.disabled可能是函数？？
   }
   const tableRef = useRef(null);
+  // 虚拟表格错误存储：脱离 antd Field 生命周期持久化真实报错文案，
+  // 解决滚动卸载后报错丢失（报错常驻）。按表格实例隔离。
+  const errorStoreRef = useRef(undefined);
+  if (!errorStoreRef.current) {
+    errorStoreRef.current = createErrorStore();
+  }
   // shouldCellUpdate 缓存按表格实例隔离，避免 module-level Map 在多实例间交叉污染
   const cellCachesRef = useRef({
     dataSourceRef: new Map(),
@@ -207,11 +214,14 @@ const ProEditTable = ({
     name: _isArray(name) ? name : [name],
     // name需要处理成namePath形式，为兼容多路径
     namePath,
+    columns,
+    // 原始列配置：供单元格变更后按所属列（含 names 合并名）重校验/清理常驻报错
     tableRef,
     max,
     tableLength: value?.length,
     page,
     originalValues,
+    errorStore: errorStoreRef.current,
     prefixCls,
     rowDisabled,
     actionDirection,
@@ -223,7 +233,7 @@ const ProEditTable = ({
     getIsNew,
     handlePageChange,
     ...resetProps
-  }), [actionDirection, actionProps, actionWidth, deletePoConfirmMsg, diffConfig, editingKeys, emptyBtnText, form,
+  }), [actionDirection, actionProps, actionWidth, columns, deletePoConfirmMsg, diffConfig, editingKeys, emptyBtnText, form,
   // forceUpdate 不应该作为依赖项，因为它是触发刷新的信号，而非用于比较的数据
   getIsNew, handlePageChange, insertType, isView, max, mode, mulDeletePoConfirmMsg, name, namePath, onlyOneLineMsg, originalValues, prefixCls, requiredAlign, resetProps, rowDisabled, selectedRowKeys, selectedRows, shouldUpdateDebounce, tableRef, toolbarProps, value?.length, viewEmpty, virtualKey, page]);
 
@@ -467,7 +477,11 @@ const ProEditTable = ({
       name: name,
       virtualKey: virtualKey,
       editingKeys: editingKeys,
-      onlyOneLineMsg: onlyOneLineMsg
+      onlyOneLineMsg: onlyOneLineMsg,
+      virtual: resetProps?.virtual,
+      columns: columns,
+      config: config,
+      errorStore: errorStoreRef.current
     })]
   });
 };

package/es/ProEditTable/utils/config.d.ts

@@ -20,6 +20,6 @@ export declare const actions: {
     save: ({ record, editingKeys, setState, form, rowName, virtualRowName, result }: any) => Promise<void>;
     cancel: ({ name, record, editingKeys, setState, form, virtualRowName, virtualKey, rowName, }: any) => void;
     delete: ({ name, record, editingKeys, setState, form, virtualKey, onlyOneLineMsg }: any) => boolean;
-    add: ({ result, insertType, editingKeys, setState, form, name, virtualName, virtualKey, onlyOneLineMsg, tableRef, prefixCls, page, handlePageChange, }: any) => Promise<boolean>;
+    add: ({ result, insertType, editingKeys, setState, form, name, virtualName, virtualKey, onlyOneLineMsg, tableRef, prefixCls, page, handlePageChange, virtual, }: any) => Promise<boolean>;
     mulDelete: ({ form, name, virtualKey, setState, selectedRowKeys, editingKeys }: any) => void;
 };

package/es/ProEditTable/utils/config.js

@@ -179,7 +179,8 @@ export const actions = {
     tableRef,
     prefixCls = 'ant',
     page,
-    handlePageChange
+    handlePageChange,
+    virtual
   }) => {
     const nextData = [...(form.getFieldValue(name) || [])];
     // 单行编辑时，需要先保存，才能进行下面的编辑
@@ -223,15 +224,25 @@ export const actions = {
       });
     }
     form.setFieldValue(name, nextData);
-    const tableBody = tableRef.current?.children[0]?.querySelector(`.${prefixCls}-table-body`);
-    if (tableBody) {
-      // 等待新行渲染完毕再读取 scrollHeight，确保能滚动到真正的底部
+    if (virtual) {
+      // 虚拟表格无 .ant-table-body 原生滚动容器，使用 antd Table ref 的 scrollTo 按行索引定位
+      // 不传 align：新增行在视口外时虚拟列表会自动贴边（尾部插入贴底、头部插入贴顶）
       requestAnimationFrame(() => {
-        tableBody.scrollTo?.({
-          top: insertType === 'before' ? 0 : tableBody.scrollHeight,
-          behavior: 'smooth'
+        tableRef.current?.scrollTo?.({
+          index: insertType === 'before' ? 0 : nextData.length - 1
         });
       });
+    } else {
+      const tableBody = tableRef.current?.children[0]?.querySelector(`.${prefixCls}-table-body`);
+      if (tableBody) {
+        // 等待新行渲染完毕再读取 scrollHeight，确保能滚动到真正的底部
+        requestAnimationFrame(() => {
+          tableBody.scrollTo?.({
+            top: insertType === 'before' ? 0 : tableBody.scrollHeight,
+            behavior: 'smooth'
+          });
+        });
+      }
     }
     if (virtualKey) {
       await form.validateFields([name]);

package/es/ProEditTable/utils/tools.d.ts

@@ -1,4 +1,4 @@
-import { Key } from 'react';
+import React, { Key } from 'react';
 import { FormInstance } from 'antd/es/form';
 import { NamePath } from 'antd/es/form/interface';
 /**
@@ -34,6 +34,24 @@ export declare const customValidate: (validateKeys: string[], form: FormInstance
  * @returns 拆解后的字符串
  */
 export declare const splitNames: (names: any[]) => string;
+/**
+ * 把行内变更的子键映射回「所属列的字段标识」，并去重。
+ * - names 组合列：任一子键命中 → 该列合并名（splitNames(names)），与 Form.Item 注册名/dataIndex 对齐
+ * - 普通列：原键本身
+ *
+ * 用于行数据被联动改写（兄弟列 onFieldChange 回填）后，按真实字段名重校验与清理常驻报错，
+ * 修复 group 列旧报错不清的问题。
+ */
+export declare const resolveChangedFields: (changedKeys: string[], columns?: any[]) => string[];
+/**
+ * 把联动回填后的子键，重新组合并写回 names 组合列的合并字段（store）。
+ *
+ * 背景：names 组合列真正被校验的是合并字段（splitNames(names)，如 certType-certNo），
+ * 其值仅在渲染期由 getValueProps 从子键组合后写回 store。联动回填（兄弟列 onFieldChange）
+ * 只直接写入子键，不经过该字段的 normalize/渲染，导致合并字段 store 值未更新 →
+ * 按合并名校验时读到旧空值、红字不清。这里按当前行子键即时组合并写回，确保 validateFields 读到最新值。
+ */
+export declare const syncGroupCombinedValues: (form: FormInstance, rowPath: (string | number)[], changedKeys: string[], columns?: any[]) => void;
 /**
  * 获取中间formItem的name
  * @param name 名称路径
@@ -71,6 +89,17 @@ export declare const getDisabled: ({ globalControl, formDisabled, column, tabled
  * 表格自动滚动到报错位置
  */
 export declare const handleScrollToError: () => void;
+/**
+ * 虚拟表格：横向滚动定位到「首个错误行」内的报错单元格。
+ *
+ * 背景：虚拟表格的横向滚动不是原生 DOM scroll（holder 的 overflow-x 为 hidden），
+ * 由 rc-virtual-list 用 transform 模拟，只能通过 antd Table ref 的 scrollTo({ left }) 驱动；
+ * 而 scrollTo({ index }) 仅做纵向行定位。保存校验失败后纵向已滚到错误行，但错误列可能仍在
+ * 横向视口外（如错误列靠左、表格当前滚到最右）→ 看不到红字。此函数补齐横向定位。
+ *
+ * 目标 scrollLeft = 错误单元格前置兄弟列宽累计 - fixed-left 列宽（fixed 列悬浮，不占滚动偏移）。
+ */
+export declare const scrollVirtualToErrorColumn: (tableRef: React.MutableRefObject<any>, rowKey?: string | null) => void;
 /**
  * 深copy一个对象，并过滤掉其中的React节点
  * @param value 需要深拷贝的对象

package/es/ProEditTable/utils/tools.js

@@ -89,6 +89,59 @@ export const splitNames = names => {
   return result;
 };
 
+/**
+ * 判断值是否为空
+ * @param value 需要判断的值
+ * @returns 是否为空
+ */
+const isNull = value => {
+  if (Array.isArray(value) && value.length) {
+    return value.some(item => isNull(item));
+  }
+  return value === '' || value === undefined || value === null || Array.isArray(value) && value.length === 0;
+};
+
+/**
+ * 把行内变更的子键映射回「所属列的字段标识」，并去重。
+ * - names 组合列：任一子键命中 → 该列合并名（splitNames(names)），与 Form.Item 注册名/dataIndex 对齐
+ * - 普通列：原键本身
+ *
+ * 用于行数据被联动改写（兄弟列 onFieldChange 回填）后，按真实字段名重校验与清理常驻报错，
+ * 修复 group 列旧报错不清的问题。
+ */
+export const resolveChangedFields = (changedKeys, columns = []) => {
+  const result = new Set();
+  (changedKeys || []).forEach(key => {
+    const groupCol = columns?.find?.(col => Array.isArray(col?.names) && col.names.includes(key));
+    result.add(groupCol ? splitNames(groupCol.names) : key);
+  });
+  return Array.from(result);
+};
+
+/**
+ * 把联动回填后的子键，重新组合并写回 names 组合列的合并字段（store）。
+ *
+ * 背景：names 组合列真正被校验的是合并字段（splitNames(names)，如 certType-certNo），
+ * 其值仅在渲染期由 getValueProps 从子键组合后写回 store。联动回填（兄弟列 onFieldChange）
+ * 只直接写入子键，不经过该字段的 normalize/渲染，导致合并字段 store 值未更新 →
+ * 按合并名校验时读到旧空值、红字不清。这里按当前行子键即时组合并写回，确保 validateFields 读到最新值。
+ */
+export const syncGroupCombinedValues = (form, rowPath, changedKeys, columns = []) => {
+  const row = form.getFieldValue(rowPath) || {};
+  (columns || []).forEach(col => {
+    if (!Array.isArray(col?.names)) {
+      return;
+    }
+    const touched = col.names.some(key => changedKeys.includes(key));
+    if (!touched) {
+      return;
+    }
+    const combined = col.names.map(key => _get(row, key));
+    const isAllEmpty = combined.every(item => isNull(item));
+    form.setFieldValue([...rowPath, splitNames(col.names)], isAllEmpty ? undefined : combined);
+  });
+};
+
 /**
  * 获取中间formItem的name
  * @param name 名称路径
@@ -272,6 +325,48 @@ export const handleScrollToError = () => {
   }, 0);
 };
 
+/**
+ * 虚拟表格：横向滚动定位到「首个错误行」内的报错单元格。
+ *
+ * 背景：虚拟表格的横向滚动不是原生 DOM scroll（holder 的 overflow-x 为 hidden），
+ * 由 rc-virtual-list 用 transform 模拟，只能通过 antd Table ref 的 scrollTo({ left }) 驱动；
+ * 而 scrollTo({ index }) 仅做纵向行定位。保存校验失败后纵向已滚到错误行，但错误列可能仍在
+ * 横向视口外（如错误列靠左、表格当前滚到最右）→ 看不到红字。此函数补齐横向定位。
+ *
+ * 目标 scrollLeft = 错误单元格前置兄弟列宽累计 - fixed-left 列宽（fixed 列悬浮，不占滚动偏移）。
+ */
+export const scrollVirtualToErrorColumn = (tableRef, rowKey) => {
+  const ref = tableRef?.current;
+  const root = ref?.nativeElement;
+  if (!ref?.scrollTo || !root || rowKey == null) {
+    return;
+  }
+  const rowEl = root.querySelector(`[data-row-key="${rowKey}"]`);
+  // 取错误行内首个报错单元格（DOM 顺序 = 列顺序，首个即最靠左的错误列）
+  const errorCell = rowEl?.querySelector('[class*="form-item-has-error"]')?.closest('[class*="table-cell"]');
+  if (!errorCell) {
+    return;
+  }
+  let offsetLeft = 0;
+  let fixedLeft = 0;
+  let previousSibling = errorCell.previousElementSibling;
+  while (previousSibling) {
+    if (previousSibling.nodeType === 1) {
+      const {
+        width = 0
+      } = previousSibling.getBoundingClientRect() || {};
+      offsetLeft += width;
+      if (previousSibling.classList?.contains?.('ant-table-cell-fix-left')) {
+        fixedLeft += width;
+      }
+    }
+    previousSibling = previousSibling.previousElementSibling;
+  }
+  ref.scrollTo({
+    left: Math.max(0, offsetLeft - fixedLeft)
+  });
+};
+
 /**
  * 深copy一个对象，并过滤掉其中的React节点
  * @param value 需要深拷贝的对象
@@ -284,18 +379,6 @@ export function cloneDeepFilterNode(value) {
     }
   });
 }
-
-/**
- * 判断值是否为空
- * @param value 需要判断的值
- * @returns 是否为空
- */
-const isNull = value => {
-  if (Array.isArray(value) && value.length) {
-    return value.some(item => isNull(item));
-  }
-  return value === '' || value === undefined || value === null || Array.isArray(value) && value.length === 0;
-};
 const handleCheckCellValue = async (column, record) => {
   let value = null;
   if (column.name) {