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

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

@@ -12,7 +12,7 @@ import classNames from 'classnames';
 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";
@@ -74,7 +74,10 @@ const RenderField = ({
     otherProps,
     diffConfig,
     getIsNew,
-    shouldUpdateDebounce
+    shouldUpdateDebounce,
+    virtual,
+    errorStore,
+    columns
   } = config;
   let lastFieldProps = fieldProps || {};
   let lastRules = rules || [];
@@ -400,6 +403,10 @@ const RenderField = ({
   // 使用 useCallback 创建稳定的 onChange 函数
   const handleChange = useCallback(async (...args) => {
     const executeChange = async (...innerArgs) => {
+      // 虚拟表格：用户编辑本单元格 → 清掉旧的常驻报错，提交时再以最新值统一重校
+      if (virtual && errorStore && record?.rowKey != null) {
+        errorStore.clearCell(record.rowKey, String(column?.dataIndex));
+      }
       let callArgs = [...innerArgs];
       const rowPath = [...namePath, index];
       if (!onFieldChange && !onChange) {
@@ -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);
               }
@@ -450,7 +466,15 @@ 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);
             }
@@ -483,6 +507,24 @@ const RenderField = ({
     };
   }, []);
 
+  // 虚拟表格：单元格（重新）挂载时，回填 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) {

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) {

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

@@ -0,0 +1,86 @@
+import type { FormInstance } from 'antd';
+import type { NamePath } from 'antd/es/form/interface';
+/**
+ * 单元格规则装配 + 全量数据真实校验（脱离 DOM）。
+ *
+ * 背景：antd6 虚拟表格滚动时视口外的行会被卸载，其 Form.Item 字段未注册，
+ *       form.validateFields 无法覆盖；本模块用 form store 里的全量数据 + 真实规则
+ *       逐行逐列离屏校验，解决「统一校验」缺口，并产出可常驻的真实报错文案。
+ */
+interface BuildCellRulesParams {
+    column: any;
+    rowData: any;
+    index: number;
+    form: FormInstance;
+    name: (string | number)[];
+    config: any;
+}
+interface BuiltCellRule {
+    /** 单元格 Form.Item 的 namePath（用于定位/messageVariables） */
+    namePath: (string | number)[];
+    /** 列在行内的稳定标识（与 transformColumns 的 dataIndex/key 一致），用于错误存储归集 */
+    cellKey: string;
+    /** 待校验值（names 列为组合数组） */
+    value: any;
+    /** 真实规则集合 */
+    rules: any[];
+    /** 字段 label，供 ${label} 文案插值 */
+    label: string;
+}
+/**
+ * 为单行单列装配真实校验规则与取值。
+ * 当该单元格处于查看/禁用态、或无任何规则时返回 null（跳过校验）。
+ */
+export declare const buildCellRules: ({ column, rowData, index, form, name, config, }: BuildCellRulesParams) => BuiltCellRule | null;
+interface ValidateAllParams {
+    form: FormInstance;
+    name: NamePath;
+    columns: any[];
+    config: any;
+}
+export interface ValidateAllResult {
+    hasError: boolean;
+    /** rowKey -> { cellKey -> 错误文案数组 } */
+    errorMap: Record<string, Record<string, string[]>>;
+    /** 首个错误单元格的 namePath（用于滚动定位），无错误为 null */
+    firstErrorPath: (string | number)[] | null;
+    /** 首个错误行的 rowKey（用于横向滚动时定位错误行 DOM），无错误为 null */
+    firstErrorRowKey: string | null;
+}
+/**
+ * 对 form store 中 name 路径下的全量数组数据，逐行逐列用真实规则校验（脱离 DOM）。
+ */
+export declare const validateAllRows: ({ form, name, columns, config, }: ValidateAllParams) => Promise<ValidateAllResult>;
+/**
+ * 外部错误存储：以 rowKey + cellKey 为键持久化真实报错文案。
+ * 它是「报错常驻」的真实来源——脱离 antd Field 实体生命周期，
+ * 行卸载后仍保留，重新挂载时回填显示。
+ */
+export interface ErrorStore {
+    /** 读取某单元格错误文案 */
+    get(rowKey: string | number, cellKey: string): string[] | undefined;
+    /** 读取整行错误 */
+    getRow(rowKey: string | number): Record<string, string[]> | undefined;
+    /** 全量替换（来自一次完整校验） */
+    setAll(errorMap: Record<string, Record<string, string[]>>): void;
+    /** 清理某单元格（用户修正后调用），整行清空时移除该行 */
+    clearCell(rowKey: string | number, cellKey: string): void;
+    /** 清空所有 */
+    clearAll(): void;
+    /** 是否为空 */
+    isEmpty(): boolean;
+}
+export declare const createErrorStore: () => ErrorStore;
+interface RunUnifiedParams extends ValidateAllParams {
+    errorStore: ErrorStore;
+}
+/**
+ * 统一校验入口：对全量数据跑真实规则，写入 errorStore，返回是否有错与首个错误行索引。
+ * 供隐藏聚合校验字段在 form.validateFields() 时调用，从而覆盖视口外未挂载的行。
+ */
+export declare const runUnifiedValidation: ({ form, name, columns, config, errorStore, }: RunUnifiedParams) => Promise<{
+    hasError: boolean;
+    firstErrorIndex: number | null;
+    firstErrorRowKey: string | null;
+}>;
+export {};

package/es/ProEditTable/utils/validateAll.js

@@ -0,0 +1,319 @@
+import _isString from "lodash/isString";
+import _isFunction from "lodash/isFunction";
+import _isBoolean from "lodash/isBoolean";
+import _get from "lodash/get";
+// 复用 antd 内部（@rc-component/form）的真实校验内核：与每个 Form.Item 字段走的是同一套
+// async-validator 流程，保证脱离 DOM 校验时的文案/异步 validator 行为与渲染态完全一致。
+import { validateRules } from '@rc-component/form/es/utils/validateUtil';
+import { rulesCreator } from "../../ProForm/utils/rulesCreator";
+import { isSelect, isNullArray, isNotFullArray } from "../../ProForm/utils";
+import { getDisabled, splitNames } from "./tools";
+import locale from "../../locale";
+
+/**
+ * 单元格规则装配 + 全量数据真实校验（脱离 DOM）。
+ *
+ * 背景：antd6 虚拟表格滚动时视口外的行会被卸载，其 Form.Item 字段未注册，
+ *       form.validateFields 无法覆盖；本模块用 form store 里的全量数据 + 真实规则
+ *       逐行逐列离屏校验，解决「统一校验」缺口，并产出可常驻的真实报错文案。
+ */
+
+/**
+ * 纯函数版规则装配，镜像 ProForm/hooks/useRules（去掉 hook 外壳）+ 复用 rulesCreator，
+ * 确保与渲染态生成的 rules 完全一致，无文案漂移。
+ */
+const composeRules = ({
+  rules,
+  required,
+  isSelectField,
+  label,
+  names,
+  labelRequired
+}) => {
+  const _label = _isString(label) ? label : '';
+  const requiredRule = Array.isArray(rules) && rules.find(rule => rule?.required === true);
+  const allRequired = required === true || Array.isArray(required) && required.every(item => item === true);
+  let resultRules = rules || [];
+  if (allRequired) {
+    if (!requiredRule) {
+      const message = isSelectField ? `${locale.ProForm.selectPlaceHolder}${_label}` : `${locale.ProForm.inputPlaceholder}${_label}`;
+      const rule = {
+        required: allRequired,
+        message
+      };
+      // names 字段的必填校验（与 useRules 保持一致）
+      if (names?.length) {
+        rule.validator = (_, value) => {
+          if (!value || isNullArray(value)) {
+            return Promise.reject(new Error(`${locale.ProForm.inputPlaceholder}${_label}`));
+          }
+          return Promise.resolve();
+        };
+      }
+      resultRules = Array.isArray(rules) ? [...rules, rule] : [rule];
+    }
+  } else if (requiredRule && names?.length) {
+    // 不可变：克隆并替换 requiredRule 的 validator，避免污染外部 column.rules
+    resultRules = rules.map(rule => rule === requiredRule ? {
+      ...rule,
+      validator: (_, value) => {
+        if (!value || isNullArray(value)) {
+          return Promise.reject(new Error(`${locale.ProForm.inputPlaceholder}${_label}`));
+        }
+        return Promise.resolve();
+      }
+    } : rule);
+  }
+
+  // type → 内置 rules（直接复用 rulesCreator 纯函数）
+  let finalRules = rulesCreator({
+    rules: resultRules,
+    label: _label,
+    isSelect: isSelectField,
+    names,
+    required
+  });
+
+  // 完整性校验（镜像 useRules 的 useEffect 分支）
+  if (names && !_isBoolean(labelRequired)) {
+    const customRequired = {
+      validator: (_rules, value) => {
+        if (Array.isArray(value) && !isNullArray(value) && isNotFullArray(value, names.length, required)) {
+          return Promise.reject(new Error(`${locale.ProForm.completeText}${_label}`));
+        }
+        return Promise.resolve();
+      }
+    };
+    finalRules = [customRequired, ...finalRules];
+  }
+  return finalRules;
+};
+
+/**
+ * 为单行单列装配真实校验规则与取值。
+ * 当该单元格处于查看/禁用态、或无任何规则时返回 null（跳过校验）。
+ */
+export const buildCellRules = ({
+  column,
+  rowData,
+  index,
+  form,
+  name,
+  config
+}) => {
+  // 整表查看模式：不校验
+  if (config?.isView) {
+    return null;
+  }
+  const reactiveParams = {
+    form,
+    index,
+    namePath: [...name, index]
+  };
+
+  // 动态 required / rules / isEditable 按行求值
+  let lastRequired = column?.required ?? false;
+  if (_isFunction(column?.required)) {
+    lastRequired = column.required(rowData, reactiveParams);
+  }
+  let lastRules = column?.rules ?? [];
+  if (_isFunction(column?.rules)) {
+    lastRules = column.rules(rowData, reactiveParams);
+  }
+  let lastFieldProps = column?.fieldProps ?? {};
+  if (_isFunction(column?.fieldProps)) {
+    lastFieldProps = column.fieldProps(rowData, reactiveParams);
+  }
+  let isEditable = column?.isEditable ?? true;
+  if (_isFunction(column?.isEditable)) {
+    isEditable = column.isEditable(rowData, reactiveParams);
+  }
+
+  // 与 RenderField 一致的 type 首字母大写
+  const type = column?.type?.replace?.(column.type[0], column.type[0].toUpperCase());
+
+  // 查看/禁用单元格跳过（镜像 RenderField.isView 的核心判定）
+  const disabled = getDisabled({
+    globalControl: config?.otherProps?.globalControl,
+    formDisabled: config?.otherProps?.formDisabled,
+    column,
+    tabledDisabled: config?.disabled,
+    columnFieldProps: lastFieldProps,
+    params: [rowData, reactiveParams],
+    rowDisabled: config?.rowDisabled || 'empty'
+  });
+  if (!isEditable || rowData?.['is-view'] || disabled) {
+    return null;
+  }
+  const names = column?.names;
+  const columnName = column?.name || column?.dataIndex || column?.key;
+  const isSelectField = !!isSelect({
+    dataSource: lastFieldProps?.dataSource,
+    type
+  });
+  const rules = composeRules({
+    rules: lastRules,
+    required: lastRequired,
+    isSelectField,
+    label: column?.label,
+    names,
+    labelRequired: column?.labelRequired
+  });
+
+  // 无实际约束（仅 [{ required: false }] 兜底）时跳过
+  const hasRealRule = rules.some(rule => rule?.required === true || rule?.validator || rule?.type || rule?.pattern);
+  if (!hasRealRule) {
+    return null;
+  }
+
+  // 取值与 cellKey：names 列取组合数组，cellKey 用 splitNames（与 transformColumns 对齐）
+  let value;
+  let cellKey;
+  if (names?.length) {
+    value = names.map(key => _get(rowData, key));
+    cellKey = splitNames(names);
+  } else {
+    const path = Array.isArray(columnName) ? columnName : [columnName];
+    value = _get(rowData, path);
+    cellKey = String(columnName);
+  }
+  return {
+    namePath: [...name, index, ...(Array.isArray(columnName) ? columnName : [columnName])],
+    cellKey,
+    value,
+    rules,
+    label: _isString(column?.label) ? column.label : ''
+  };
+};
+/**
+ * 对 form store 中 name 路径下的全量数组数据，逐行逐列用真实规则校验（脱离 DOM）。
+ */
+export const validateAllRows = async ({
+  form,
+  name,
+  columns,
+  config
+}) => {
+  const namePath = Array.isArray(name) ? name : [name];
+  const list = form.getFieldValue(namePath) || [];
+  const errorMap = {};
+  let firstErrorPath = null;
+  let firstErrorRowKey = null;
+  for (let index = 0; index < list.length; index += 1) {
+    const rowData = list[index];
+    // 行可能为空位（单行编辑增删残留），跳过
+    if (!rowData) {
+      continue;
+    }
+    const rowKey = String(rowData.rowKey ?? index);
+    for (const column of columns) {
+      const built = buildCellRules({
+        column,
+        rowData,
+        index,
+        form,
+        name: namePath,
+        config
+      });
+      if (!built) {
+        continue;
+      }
+
+      // validateFirst=true：成功 resolve([])，首个失败 reject([{ errors, rule }])
+      // eslint-disable-next-line no-await-in-loop
+      const ruleErrors = await validateRules(built.namePath, built.value, built.rules, {
+        validateMessages: config?.validateMessages
+      }, true, {
+        label: built.label
+      }).then(() => [], err => Array.isArray(err) ? err : []);
+      const messages = [];
+      ruleErrors.forEach(({
+        errors = [],
+        rule
+      }) => {
+        // warningOnly 仅警告，不计入阻断性错误
+        if (!rule?.warningOnly) {
+          messages.push(...errors);
+        }
+      });
+      if (messages.length) {
+        if (!errorMap[rowKey]) {
+          errorMap[rowKey] = {};
+        }
+        errorMap[rowKey][built.cellKey] = messages;
+        if (!firstErrorPath) {
+          firstErrorPath = built.namePath;
+          firstErrorRowKey = rowKey;
+        }
+      }
+    }
+  }
+  return {
+    hasError: !!firstErrorPath,
+    errorMap,
+    firstErrorPath,
+    firstErrorRowKey
+  };
+};
+
+/**
+ * 外部错误存储：以 rowKey + cellKey 为键持久化真实报错文案。
+ * 它是「报错常驻」的真实来源——脱离 antd Field 实体生命周期，
+ * 行卸载后仍保留，重新挂载时回填显示。
+ */
+
+export const createErrorStore = () => {
+  const map = new Map();
+  return {
+    get: (rowKey, cellKey) => map.get(String(rowKey))?.[cellKey],
+    getRow: rowKey => map.get(String(rowKey)),
+    setAll: errorMap => {
+      map.clear();
+      Object.keys(errorMap || {}).forEach(rowKey => {
+        map.set(rowKey, errorMap[rowKey]);
+      });
+    },
+    clearCell: (rowKey, cellKey) => {
+      const row = map.get(String(rowKey));
+      if (row && cellKey in row) {
+        delete row[cellKey];
+        if (Object.keys(row).length === 0) {
+          map.delete(String(rowKey));
+        }
+      }
+    },
+    clearAll: () => map.clear(),
+    isEmpty: () => map.size === 0
+  };
+};
+/**
+ * 统一校验入口：对全量数据跑真实规则，写入 errorStore，返回是否有错与首个错误行索引。
+ * 供隐藏聚合校验字段在 form.validateFields() 时调用，从而覆盖视口外未挂载的行。
+ */
+export const runUnifiedValidation = async ({
+  form,
+  name,
+  columns,
+  config,
+  errorStore
+}) => {
+  const {
+    hasError,
+    errorMap,
+    firstErrorPath,
+    firstErrorRowKey
+  } = await validateAllRows({
+    form,
+    name,
+    columns,
+    config
+  });
+  errorStore.setAll(errorMap);
+  const namePath = Array.isArray(name) ? name : [name];
+  const firstErrorIndex = firstErrorPath && firstErrorPath.length > namePath.length ? Number(firstErrorPath[namePath.length]) : null;
+  return {
+    hasError,
+    firstErrorIndex,
+    firstErrorRowKey
+  };
+};

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

@@ -75,58 +75,58 @@ 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>;
+    isView?: boolean;
+    style?: React.CSSProperties;
+    children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     className?: string;
     hidden?: boolean;
     id?: string;
-    style?: React.CSSProperties;
-    children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     onReset?: () => void;
+    validateTrigger?: string | false | string[];
+    preserve?: boolean;
+    trim?: boolean;
+    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
+    clearNotShow?: boolean;
+    labelAlign?: import("antd/es/form/interface").FormLabelAlign;
     prefixCls?: string;
-    isView?: boolean;
-    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
+    colon?: boolean;
+    layout?: import("antd/es/form/Form").FormItemLayout;
+    labelCol?: import("antd").ColProps;
+    wrapperCol?: import("antd").ColProps;
     rootClassName?: string;
-    status?: "" | "warning" | "error" | "success" | "validating";
+    status?: "" | "validating" | "warning" | "error" | "success";
     vertical?: boolean;
-    getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
-    colon?: boolean;
     htmlFor?: string;
-    labelAlign?: import("antd/es/form/interface").FormLabelAlign;
-    labelCol?: import("antd").ColProps;
     getValueFromEvent?: (...args: import("@rc-component/form/lib/interface").EventArgs) => any;
-    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
     shouldUpdate?: import("@rc-component/form/lib/Field").ShouldUpdate<any>;
     trigger?: string;
-    validateTrigger?: string | false | string[];
     validateDebounce?: number;
     valuePropName?: string;
+    getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
     messageVariables?: Record<string, string>;
     initialValue?: any;
     onMetaChange?: (meta: import("@rc-component/form/lib/Field").MetaEvent) => void;
-    preserve?: boolean;
     isListField?: boolean;
     isList?: boolean;
     noStyle?: boolean;
     hasFeedback?: boolean | {
         icons: import("antd/es/form/FormItem").FeedbackIcons;
     };
-    validateStatus?: "" | "warning" | "error" | "success" | "validating";
-    layout?: import("antd/es/form/Form").FormItemLayout;
-    wrapperCol?: import("antd").ColProps;
+    validateStatus?: "" | "validating" | "warning" | "error" | "success";
     help?: React.ReactNode;
     fieldId?: string;
     valueType?: import("../../../render/propsType").ProFormValueType;
-    toISOString?: boolean;
-    toCSTString?: boolean;
     switchValue?: [any, any];
-    clearNotShow?: boolean;
-    trim?: boolean;
-    upperCase?: boolean;
     viewRender?: (value: any, record: any, { form, index, namePath, }: {
         [key: string]: any;
         form: FormInstance<any>;
         index?: number;
     }) => string | React.ReactElement<any, any>;
     viewType?: import("../../../render/propsType").ViewType;
+    upperCase?: boolean;
+    toISOString?: boolean;
+    toCSTString?: 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, "precision" | "valueType" | "toISOString" | "toCSTString" | "switchValue" | "format" | "clearNotShow" | "dependNames">;
+    componentProps: import("lodash").Omit<any, "clearNotShow" | "format" | "valueType" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "precision">;
     formItemTransform: {
         getValueProps: any;
         normalize: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zat-design/sisyphus-react",
-  "version": "4.4.3",
+  "version": "4.5.0-beta.1",
   "license": "MIT",
   "files": [
     "es",