@zat-design/sisyphus-react 4.4.1-beta.2 → 4.4.1-beta.3

package/es/ProConfigProvider/index.d.ts

@@ -5,5 +5,5 @@ export declare const ProConfigContext: React.Context<ConfigContext>;
 export declare function useProConfig(): ConfigContext;
 export declare function useProConfig(name: keyof ConfigContext['state']): ConfigContext['state'][keyof ConfigContext['state']];
 export declare const ProConfigProvider: FC<ProConfigProviderProps>;
-export type { ProConfigProviderType, ProConfigProviderProps } from './propsType';
+export type { ProConfigProviderType, ProConfigProviderProps, GlobalConfig, ProTableGlobalConfig, StorageType, } from './propsType';
 export default ProConfigProvider;

package/es/ProConfigProvider/index.js

@@ -113,16 +113,15 @@ const ThemeAwareConfigProvider = ({
 };
 export const ProConfigProvider = props => {
   const [state, dispatch] = useReducer(reducer, initialState);
-  const enumRes = useEnumRequest({
+
+  // globalConfig（含 storage）合并进 ProEnum 配置，useEnumRequest 内部对所有字段均有默认值
+  const enumEnv = {
     ...state.ProEnum,
     ...props?.value?.ProEnum,
     ...props?.value?.globalConfig
-  }, dispatch);
-  const frequentEnumRes = useFrequentEnumRequest({
-    ...state.ProEnum,
-    ...props?.value?.ProEnum,
-    ...props?.value?.globalConfig
-  }, dispatch);
+  };
+  const enumRes = useEnumRequest(enumEnv, dispatch);
+  const frequentEnumRes = useFrequentEnumRequest(enumEnv, dispatch);
   const cacheLang = localStorage.getItem('locale');
   const lang = state?.locale ?? cacheLang ?? props?.locale ?? 'zh-CN';
   useEffect(() => {

package/es/ProConfigProvider/propsType.d.ts

@@ -4,9 +4,31 @@ import type { PropSelectType } from '../ProSelect/propsType';
 import type { ProModalSelectType } from '../ProForm/components/combination/ProModalSelect/propsType';
 import type { ProCascaderType } from '../ProForm/components/combination/ProCascader/propsType';
 import type { ProEnumConfigType } from '../ProEnum/propsType';
+/** 浏览器缓存类型，与 ProEnum / ProTable 的 StorageType 定义一致 */
+export type StorageType = 'localStorage' | 'sessionStorage' | 'indexedDB';
+/** 项目级全局配置（一处配置，全局生效） */
+export interface GlobalConfig {
+    /** 缓存存储位置，影响 ProTable 列配置缓存与 ProEnum 枚举缓存，默认由各组件自身决定 */
+    storage?: StorageType;
+}
+/** ProTable 组件全局默认配置，通过 ProConfigProvider 统一设置，无需每个实例单独声明 */
+export interface ProTableGlobalConfig {
+    /** 是否开启可伸缩列功能，默认 false */
+    resizeColumn?: boolean;
+    /** 是否开启列配置功能，开启时默认同步开启缓存，默认 false */
+    columnConfig?: boolean | {
+        onColumnOk?: (catchColumns: any, columns: any[]) => Promise<void>;
+    };
+    /** 是否开启列配置缓存，单位为天，true 时缓存一天，默认 false */
+    cacheTime?: number | boolean;
+}
 /** 对外配置项类型（value、内部 state 均为此类型，字段均可选） */
 export interface ProConfigProviderType {
     locale?: string;
+    /** 项目级全局配置：缓存位置等跨组件通用配置 */
+    globalConfig?: GlobalConfig;
+    /** ProTable 组件全局默认配置 */
+    ProTable?: ProTableGlobalConfig;
     ProEnum?: Partial<ProEnumConfigType>;
     ProSelect?: Partial<PropSelectType> & Record<string, any>;
     ProModalSelect?: Partial<ProModalSelectType> & Record<string, any>;

package/es/ProEditTable/components/RcTable/DraggableTable.js

@@ -1,10 +1,9 @@
 import { Table } from 'antd';
 import React, { memo, useCallback } from 'react';
-import { DndContext } from '@dnd-kit/core';
-import { arrayMove, useSortable, SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable';
-import { CSS } from '@dnd-kit/utilities';
+import { arrayMove } from '@dnd-kit/sortable';
 import dragSvg from "../../../assets/drag.svg";
 import ProIcon from "../../../ProIcon";
+import { SortableTableContext, useDraggableRowState } from "../../../hooks/useDraggableRow";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const Row = props => {
   const {
@@ -12,37 +11,25 @@ const Row = props => {
     children,
     ...restProps
   } = props;
-  const data = useSortable({
+  const {
+    setNodeRef,
+    style,
+    listeners,
+    attributes
+  } = useDraggableRowState({
     id: props['data-row-key'],
     disabled
   });
-  const {
-    attributes,
-    listeners,
-    setNodeRef,
-    transform,
-    transition,
-    isDragging
-  } = data;
-  const style = {
-    ...props.style,
-    transform: CSS.Transform.toString(transform && {
-      ...transform,
-      scaleY: 1
-    }),
-    transition,
-    ...(isDragging ? {
-      position: 'relative',
-      zIndex: 2
-    } : {})
-  };
 
   // 检查是否是空状态占位行
   const isPlaceholderRow = restProps.className?.includes('ant-table-placeholder');
   return /*#__PURE__*/_jsx("tr", {
     ...restProps,
     ref: setNodeRef,
-    style: style,
+    style: {
+      ...props.style,
+      ...style
+    },
     ...attributes,
     children: React.Children.map(children, (child, index) => {
       // 在第一列（通常是rowSelection列）显示拖拽图标
@@ -101,14 +88,13 @@ const DndWrapper = ({
       onChange(nextValue);
     }
   };
-  return draggable && !disabled ? /*#__PURE__*/_jsx(DndContext, {
+  return /*#__PURE__*/_jsx(SortableTableContext, {
+    draggable: draggable,
+    disabled: disabled,
+    items: value?.[0]?.rowKey ? value.map(i => i.rowKey) : [],
     onDragEnd: onDragEndtInside,
-    children: /*#__PURE__*/_jsx(SortableContext, {
-      items: value?.[0]?.rowKey ? value.map(i => i.rowKey) : [],
-      strategy: verticalListSortingStrategy,
-      children: children
-    })
-  }) : children;
+    children: children
+  });
 };
 const DraggableTable = ({
   tableProps,

package/es/ProEditTable/index.js

@@ -69,6 +69,12 @@ const ProEditTable = ({
     disabled = formFieldProps?.disabled || disabled; // formFieldProps?.disabled可能是函数？？
   }
   const tableRef = useRef(null);
+  // shouldCellUpdate 缓存按表格实例隔离，避免 module-level Map 在多实例间交叉污染
+  const cellCachesRef = useRef({
+    dataSourceRef: new Map(),
+    componentRef: new Map(),
+    listLength: new Map()
+  });
   // const valueChangeRef = useRef<number>(0);
   // valueChangeRef.current = 0;
 
@@ -312,7 +318,7 @@ const ProEditTable = ({
     return null;
   };
   const _columns = useMemo(() => {
-    return transformColumns(columns, config);
+    return transformColumns(columns, config, cellCachesRef.current);
   }, [disabled, forceUpdate, columns, page, actionProps, editingKeys, config]);
   const initDataSource = () => {
     // 检查每一项是否有 rowKey 或通过 rowKey 字段获取的 key

package/es/ProEditTable/style/index.less

@@ -71,11 +71,6 @@
     }
   }
 
-  .is-hidden {
-    position: absolute;
-    left: -9999px;
-  }
-
   .pro-edit-table-drag-wrapper {
     display: flex;
     align-items: center;

package/es/ProEditTable/utils/config.js

@@ -91,6 +91,8 @@ export const actions = {
     // 防止value引用不变, 值不更新 - (自定义组件)
     const values = form.getFieldsValue();
     _set(values, rowName, record);
+    // 同步清理虚拟路径上的 _addFlag，避免再次编辑→取消时把已保存行误删
+    _set(values, virtualRowName, record);
     form.setFieldsValue(values);
     setState({
       editingKeys: nextEditingKeys

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

@@ -1,3 +1,17 @@
+/**
+ * shouldCellUpdate 缓存容器：跟踪 dataSource/component 引用与 filterInList 列表长度。
+ * 调用方（ProEditTable 顶层）通过 useRef 持有按实例隔离的容器，避免 module-level Map
+ * 在多实例场景下交叉污染；实例卸载后缓存随宿主一起释放。
+ * 未传 caches 时退化为单次内联 Map（不缓存历史，shouldCellUpdate 始终首次比较）。
+ */
+export interface CellCacheRefs {
+    /** 跟踪 fieldProps.dataSource 引用变化 */
+    dataSourceRef: Map<string, any>;
+    /** 跟踪 column.component 函数引用变化（外部 list 异步加载时闭包刷新） */
+    componentRef: Map<string, any>;
+    /** 跟踪 filterInList 列长度变化（行增删导致索引偏移） */
+    listLength: Map<string, number>;
+}
 /**
  * 编辑模式分为 多行和单行两种
  * 单行模式下，render 分为component和viewRender两种，对应编辑和非编辑状态下，edit状态不对外
@@ -6,4 +20,4 @@
  * @param columns 表格配置数据
  * @param config
  */
-export declare const transformColumns: (columns: any[], config: any) => any[];
+export declare const transformColumns: (columns: any[], config: any, caches?: CellCacheRefs) => any[];

package/es/ProEditTable/utils/index.js

@@ -14,13 +14,14 @@ import { filterInternalFields } from "../../ProForm/utils";
 import ProTooltip from "../../ProTooltip";
 import { RenderField, ActionButton } from "../components";
 import locale from "../../locale";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const columnDataSourceRefCache = new Map();
-/** 追踪 component 函数引用，用于检测外部状态（如异步 list）变化导致的闭包更新 */
-const columnComponentRefCache = new Map();
-/** 追踪 filterInList 列表长度，用于检测行增删导致的索引偏移 */
-const columnListLengthCache = new Map();
 
+/**
+ * shouldCellUpdate 缓存容器：跟踪 dataSource/component 引用与 filterInList 列表长度。
+ * 调用方（ProEditTable 顶层）通过 useRef 持有按实例隔离的容器，避免 module-level Map
+ * 在多实例场景下交叉污染；实例卸载后缓存随宿主一起释放。
+ * 未传 caches 时退化为单次内联 Map（不缓存历史，shouldCellUpdate 始终首次比较）。
+ */
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // 渲染操作栏
 const getActionColumn = config => {
   const {
@@ -180,7 +181,7 @@ const getActionColumn = config => {
  * @param config
  */
 
-export const transformColumns = (columns = [], config) => {
+export const transformColumns = (columns = [], config, caches) => {
   const {
     mode,
     form,
@@ -193,6 +194,13 @@ export const transformColumns = (columns = [], config) => {
     setState,
     page
   } = config;
+
+  // 未传 caches 时退化为单次内联 Map（每次 transform 新建，不持久化）
+  const cellCaches = caches ?? {
+    dataSourceRef: new Map(),
+    componentRef: new Map(),
+    listLength: new Map()
+  };
   let nextColumns = columns.map(item => cloneDeepFilterNode(item));
   const pageNum = tools.calc(page.pageNum, '-', 1);
   const firstIndex = tools.calc(pageNum, '*', page.pageSize);
@@ -261,9 +269,13 @@ export const transformColumns = (columns = [], config) => {
       required = false;
     }
 
-    // 样式处理
+    // 列隐藏使用 antd 原生 column.hidden（antd 5.13+ 支持），不再依赖 is-hidden 错位定位 hack
+    if (hidden) {
+      item.hidden = true;
+    }
+
+    // 样式处理（不再写 is-hidden className）
     item.className = classnames({
-      'is-hidden': hidden,
       'is-required': required || labelRequired,
       'is-required-left': requiredAlign === 'left',
       'is-required-right': requiredAlign === 'right',
@@ -338,10 +350,10 @@ export const transformColumns = (columns = [], config) => {
       // cloneDeepFilterNode 每次产生新引用，在 shouldCellUpdate 内更新 cache 只会让第一行触发更新，其余行跳过
       const originalFieldProps = columns[index]?.fieldProps;
       const originalDataSourceRef = !_isFunction(originalFieldProps) ? originalFieldProps?.dataSource : undefined;
-      const prevDataSourceRef = columnDataSourceRefCache.get(columnCacheKey);
+      const prevDataSourceRef = cellCaches.dataSourceRef.get(columnCacheKey);
       const dataSourceChanged = originalDataSourceRef !== undefined && prevDataSourceRef !== originalDataSourceRef;
       if (dataSourceChanged) {
-        columnDataSourceRefCache.set(columnCacheKey, originalDataSourceRef);
+        cellCaches.dataSourceRef.set(columnCacheKey, originalDataSourceRef);
       }
 
       // Fix 问题2：检测 filterInList 列的行增删，避免行索引移位时 shouldUpdate 闭包中 index 失效
@@ -349,10 +361,10 @@ export const transformColumns = (columns = [], config) => {
       let filterListChanged = false;
       if (filterInListEnabled) {
         const currentListLen = config.tableLength ?? 0;
-        const prevListLen = columnListLengthCache.get(columnCacheKey) ?? -1;
+        const prevListLen = cellCaches.listLength.get(columnCacheKey) ?? -1;
         if (prevListLen !== currentListLen) {
           filterListChanged = true;
-          columnListLengthCache.set(columnCacheKey, currentListLen);
+          cellCaches.listLength.set(columnCacheKey, currentListLen);
         }
       }
       item.shouldCellUpdate = (record, prevRecord) => {
@@ -379,10 +391,10 @@ export const transformColumns = (columns = [], config) => {
         if (hasComponent) {
           // component 函数引用变化说明外部依赖（如异步 list）已更新，必须重渲染
           // 即使行数据未变，旧闭包仍持有过时的外部状态
-          const prevComponentRef = columnComponentRefCache.get(columnCacheKey);
+          const prevComponentRef = cellCaches.componentRef.get(columnCacheKey);
           const currentComponentRef = item.component;
           if (prevComponentRef !== currentComponentRef) {
-            columnComponentRefCache.set(columnCacheKey, currentComponentRef);
+            cellCaches.componentRef.set(columnCacheKey, currentComponentRef);
             return true;
           }
           // 同引用时 isEqual 恒为 true，无法感知原地修改，必须重渲染

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

@@ -75,19 +75,19 @@ 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>;
-    vertical?: boolean;
-    isView?: boolean;
-    hidden?: boolean;
-    className?: string;
-    trim?: boolean;
-    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
-    children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     prefixCls?: string;
-    trigger?: string;
+    htmlFor?: string;
+    className?: string;
+    hidden?: boolean;
     id?: string;
     style?: React.CSSProperties;
-    htmlFor?: string;
+    children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     onReset?: () => void;
+    trim?: boolean;
+    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
+    vertical?: boolean;
+    isView?: boolean;
+    trigger?: string;
     toISOString?: boolean;
     toCSTString?: boolean;
     switchValue?: [any, any];

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

@@ -1,12 +1,22 @@
 import { FormInstance } from 'antd/es/form/Form';
 import { NamePath } from 'antd/es/form/interface';
-export declare function toArray<T>(value?: T | T[] | null): T[];
+/**
+ * selector 函数：接收所有表单值，返回派生值
+ * 与 antd 5.12.0+ Form.useWatch selector 行为一致
+ */
+export type WatchSelector<T = any> = (values: any) => T;
 /**
  * ProForm的useWatch hook，用于监听表单字段变化
- * @param dependencies 监听的字段路径
+ * 支持三种依赖形式：
+ *   1. 字符串路径：useWatch('fieldName', form)
+ *   2. 路径数组：useWatch(['a', 'b'], form) 或 useWatch([['a', 'b'], 'c'], form)
+ *   3. selector 函数：useWatch((values) => values.a + values.b, form)
+ *
+ * @param dependencies 监听的字段路径或 selector 函数
  * @param form 表单实例
  * @param wait 防抖等待时间
- * @returns 表单值
+ * @returns 表单值或 selector 返回的派生值
  */
-declare function useWatch(dependencies: string | NamePath[], form?: FormInstance, wait?: number): any;
+declare function useWatch<T = any>(selector: WatchSelector<T>, form?: FormInstance, wait?: number): T;
+declare function useWatch(dependencies: string | NamePath[], form?: FormInstance, wait?: number): Record<string, any>;
 export default useWatch;

package/es/ProForm/utils/useWatch.js

@@ -3,12 +3,7 @@ import warning from 'rc-util/lib/warning';
 import { useState, useEffect, useRef, useMemo } from 'react';
 import isEqual from 'lodash/isEqual';
 import cloneDeep from 'lodash/cloneDeep';
-export function toArray(value) {
-  if (value === undefined || value === null) {
-    return [];
-  }
-  return Array.isArray(value) ? value : [value];
-}
+import { toArray } from "./index";
 
 // 从一个对象或Form值中获取特定路径的值
 function get(source, path) {
@@ -53,37 +48,58 @@ function setValueByPath(obj, path, value) {
 }
 
 // 创建之后namepath就不可变的警告
+// selector 模式（dependencies 为函数）下跳过：函数引用每次渲染不同，无法稳定 stringify
 const useWatchWarning = process.env.NODE_ENV !== 'production' ? dependencies => {
-  const depsStr = JSON.stringify(dependencies);
+  const isSelector = typeof dependencies === 'function';
+  const depsStr = isSelector ? '__selector__' : JSON.stringify(dependencies);
   const depsStrRef = useRef(depsStr);
-  warning(depsStrRef.current === depsStr, '`useWatch` is not support dynamic `namePath`. Please provide static instead.');
+  if (!isSelector) {
+    warning(depsStrRef.current === depsStr, '`useWatch` is not support dynamic `namePath`. Please provide static instead.');
+  }
 } : () => {};
 
+/**
+ * selector 函数：接收所有表单值，返回派生值
+ * 与 antd 5.12.0+ Form.useWatch selector 行为一致
+ */
+
 /**
  * ProForm的useWatch hook，用于监听表单字段变化
- * @param dependencies 监听的字段路径
+ * 支持三种依赖形式：
+ *   1. 字符串路径：useWatch('fieldName', form)
+ *   2. 路径数组：useWatch(['a', 'b'], form) 或 useWatch([['a', 'b'], 'c'], form)
+ *   3. selector 函数：useWatch((values) => values.a + values.b, form)
+ *
+ * @param dependencies 监听的字段路径或 selector 函数
  * @param form 表单实例
  * @param wait 防抖等待时间
- * @returns 表单值
+ * @returns 表单值或 selector 返回的派生值
  */
+
 function useWatch(dependencies, form, wait) {
-  // 处理开发环境警告
-  useWatchWarning(dependencies);
+  const isSelector = typeof dependencies === 'function';
+
+  // selector 模式跳过依赖字符串化警告（函数引用每次都不同，无法稳定比较）
+  if (!isSelector) {
+    useWatchWarning(dependencies);
+  }
 
   // 获取表单实例
   const formInstance = form;
 
-  // 用于存储最终结果
-  const [state, setState] = useState({});
+  // 用于存储最终结果（selector 模式下值类型由 selector 决定）
+  const [state, setState] = useState(isSelector ? undefined : {});
 
   // 使用ref存储中间状态，避免不必要的渲染
-  const valueRef = useRef({});
-  const prevStateRef = useRef({});
+  const valueRef = useRef(isSelector ? undefined : {});
+  const prevStateRef = useRef(isSelector ? undefined : {});
 
-  // 标准化依赖为路径数组的数组
+  // 标准化依赖为路径数组的数组（selector 模式下为空数组，不参与）
   const namePaths = useMemo(() => {
-    // 将依赖标准化为数组的数组形式
     const paths = [];
+    if (isSelector) {
+      return paths;
+    }
 
     // 字符串形式: 'fieldName'
     if (typeof dependencies === 'string') {
@@ -107,6 +123,12 @@ function useWatch(dependencies, form, wait) {
     /* dependencies 故意忽略，与原实现一致 */
   ]);
 
+  // selector 函数 ref：使最新 selector 始终被调用，但不触发 useEffect 重订阅
+  const selectorRef = useRef(null);
+  if (isSelector) {
+    selectorRef.current = dependencies;
+  }
+
   // 保存防抖函数引用，避免重复创建
   const debouncedFn = useMemo(() => {
     if (wait) {
@@ -133,6 +155,14 @@ function useWatch(dependencies, form, wait) {
     // 创建更新状态的函数
     const updateState = () => {
       const values = formInstance.getFieldsValue(true);
+
+      // selector 模式：直接调用 selector 计算派生值
+      if (isSelector && selectorRef.current) {
+        const next = selectorRef.current(values);
+        valueRef.current = next;
+        debouncedFn(next);
+        return;
+      }
       const newState = {};
 
       // 处理每个监听路径

package/es/ProTable/components/EditableCell/index.js

@@ -5,18 +5,18 @@ import * as componentMap from "../../../ProForm/components";
 import EditIcon from "./EditIcon";
 import styles from "./index.less";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const EditableCell = ({
+const InternalCell = ({
   value,
   record,
   index,
-  dataIndex,
   editConfig,
-  displayContent
+  displayContent,
+  form,
+  fieldName,
+  wrapInForm
 }) => {
   const [editing, setEditing] = useState(false);
-  const [form] = Form.useForm();
   const snapshotRef = useRef(value);
-  const fieldName = Array.isArray(dataIndex) ? dataIndex.join('_') : dataIndex;
   const {
     type = 'Input',
     fieldProps = {},
@@ -31,15 +31,13 @@ const EditableCell = ({
   const Component = componentMap[type] ?? componentMap.Input;
   const handleEditIconClick = () => {
     snapshotRef.current = value;
-    form.setFieldsValue({
-      [fieldName]: value
-    });
+    form.setFieldValue(fieldName, value);
     setEditing(true);
   };
   const handleBlur = async () => {
     try {
-      const values = await form.validateFields();
-      const newValue = values[fieldName];
+      await form.validateFields([fieldName]);
+      const newValue = form.getFieldValue(fieldName);
       if (_isEqual(newValue, snapshotRef.current)) {
         setEditing(false);
         return;
@@ -67,21 +65,56 @@ const EditableCell = ({
       })]
     });
   }
+  const formItem = /*#__PURE__*/_jsx(Form.Item, {
+    name: fieldName,
+    rules: rules,
+    required: required,
+    noStyle: true,
+    children: /*#__PURE__*/_jsx(Component, {
+      ...restFieldProps,
+      valueType: valueType,
+      autoFocus: true,
+      onBlur: handleBlur
+    })
+  });
+  if (!wrapInForm) {
+    return formItem;
+  }
   return /*#__PURE__*/_jsx(Form, {
     form: form,
     component: false,
-    children: /*#__PURE__*/_jsx(Form.Item, {
-      name: fieldName,
-      rules: rules,
-      required: required,
-      noStyle: true,
-      children: /*#__PURE__*/_jsx(Component, {
-        ...restFieldProps,
-        valueType: valueType,
-        autoFocus: true,
-        onBlur: handleBlur
-      })
-    })
+    children: formItem
+  });
+};
+const PerCellEditableCell = props => {
+  const [form] = Form.useForm();
+  const fieldName = Array.isArray(props.dataIndex) ? props.dataIndex.join('_') : props.dataIndex;
+  return /*#__PURE__*/_jsx(InternalCell, {
+    ...props,
+    form: form,
+    fieldName: fieldName,
+    wrapInForm: true
+  });
+};
+const SharedFormEditableCell = props => {
+  const fieldName = props.sharedFieldName ?? (Array.isArray(props.dataIndex) ? props.dataIndex.join('_') : props.dataIndex);
+  return /*#__PURE__*/_jsx(InternalCell, {
+    ...props,
+    form: props.sharedForm,
+    fieldName: fieldName,
+    wrapInForm: false
+  });
+};
+const EditableCell = props => {
+  // editMode 默认 'per-cell-form'，与重构前完全一致
+  // 'shared-form'：外层 ProTable 提供共享 Form，跳过内部 useForm
+  if (props.editMode === 'shared-form' && props.sharedForm) {
+    return /*#__PURE__*/_jsx(SharedFormEditableCell, {
+      ...props
+    });
+  }
+  return /*#__PURE__*/_jsx(PerCellEditableCell, {
+    ...props
   });
 };
 export default EditableCell;

package/es/ProTable/components/EditableCell/propsType.d.ts

@@ -1,5 +1,8 @@
 import type { ReactNode } from 'react';
+import type { FormInstance } from 'antd/es/form/Form';
+import type { NamePath } from 'antd/es/form/interface';
 import type { EditTableCellConfig } from '../../propsType';
+export type EditableCellEditMode = 'per-cell-form' | 'shared-form';
 export interface EditableCellProps {
     value: any;
     record: any;
@@ -7,4 +10,15 @@ export interface EditableCellProps {
     dataIndex: string | string[];
     editConfig: EditTableCellConfig;
     displayContent: ReactNode;
+    /**
+     * 编辑态 Form 模式
+     * @default 'per-cell-form'
+     * - 'per-cell-form'：每个 cell 独立 Form 实例（默认，与重构前一致）
+     * - 'shared-form'：使用外层 ProTable 顶层共享 Form（性能优化，需配合 ProTable.editMode='shared-form'）
+     */
+    editMode?: EditableCellEditMode;
+    /** shared-form 模式下外层共享的 Form 实例 */
+    sharedForm?: FormInstance;
+    /** shared-form 模式下字段路径（如 ['__editable__', rowKey, dataIndex]） */
+    sharedFieldName?: NamePath;
 }

package/es/ProTable/components/FormatColumn/index.d.ts

@@ -3,16 +3,18 @@
  * 重构优化：提取公共逻辑，修复 key prop 警告
  */
 import React from 'react';
+import type { FormInstance } from 'antd/es/form/Form';
 import type { ProTableColumnType } from '../../propsType';
-export declare const formatColumn: ({ column, originalObj, rowKey, wrapToolTipProps, scroll, onUpdateMinWidth, isInNewRow, diffConfig, }: {
+export declare const formatColumn: ({ column, originalObj, rowKey, wrapToolTipProps, scroll, isInNewRow, diffConfig, editMode, sharedForm, }: {
     column: ProTableColumnType;
     originalObj: any;
     rowKey: any;
     wrapToolTipProps?: any;
     scroll?: any;
-    onUpdateMinWidth?: any;
     isInNewRow?: any;
     diffConfig: any;
+    editMode?: 'per-cell-form' | 'shared-form';
+    sharedForm?: FormInstance;
 }) => void;
 /**
  * 查找最近的父级className