@ant-design/pro-components 3.1.12-0 → 3.1.13-0

package/lib/utils/transformKeySubmitValue/index.js

@@ -33,9 +33,14 @@ function isPlainObj(itemValue) {
   if (itemValue.constructor === RegExp) return false;
   if (itemValue instanceof Map) return false;
   if (itemValue instanceof Set) return false;
-  if (itemValue instanceof HTMLElement) return false;
-  if (itemValue instanceof Blob) return false;
-  if (itemValue instanceof File) return false;
+  // SSR 环境下 HTMLElement / Blob / File 这些 BOM 全局不存在，
+  // 直接 instanceof 会抛 ReferenceError。本函数已 export，外部可能在 node 端 import 使用，
+  // 必须用 typeof 守门确保 SSR 安全。
+  if (typeof HTMLElement !== 'undefined' && itemValue instanceof HTMLElement) {
+    return false;
+  }
+  if (typeof Blob !== 'undefined' && itemValue instanceof Blob) return false;
+  if (typeof File !== 'undefined' && itemValue instanceof File) return false;
   if (Array.isArray(itemValue)) return false;
   return true;
 }
@@ -103,7 +108,11 @@ function separateTransformFormats(dataFormatMapRaw) {
  * @param dotPathTransforms - 点号路径转换配置
  */
 function processDotPathTransforms(result, dotPathTransforms) {
-  for (const dotPath in dotPathTransforms) {
+  // 用 Object.keys 替代 for...in：
+  //  - for...in 会遍历到原型链上的 enumerable 属性（虽然这里上游已经过滤过，但守门更稳）
+  //  - Object.keys 在 ES2015+ 明确按「先整数升序、再字符串插入序」遍历，多个 transform
+  //    路径相互覆盖时（如 'a.b' 和 'a.c' 都返回对象 merge 到 a）顺序更可预期
+  for (const dotPath of Object.keys(dotPathTransforms)) {
     const transform = dotPathTransforms[dotPath];
     if (typeof transform !== 'function') continue;
 
@@ -117,28 +126,35 @@ function processDotPathTransforms(result, dotPathTransforms) {
     // 执行转换
     const transformed = transform(currentValue, pathArray.map(String), result);
     if (typeof transformed === 'object' && transformed !== null && !Array.isArray(transformed)) {
-      // 如果返回对象，删除原键并将对象的键值对合并到父级
+      // 如果返回对象，需要按父节点形状分别处理：
+      // - 父节点是数组（如 `'list.0' -> v => ({X: 'A'})`）：旧实现走 `delete list[0]`
+      //   + `Object.assign(list, {X:'A'})`，会把 list 变成 `[<empty>, ..., X:'A']`，
+      //   即在数组上加 string key、留下空 slot，破坏数组形状。改为直接把返回对象整体
+      //   赋值到该索引位置（`list[0] = {X:'A'}`）。
+      // - 父节点是对象（如 `'users.0.name' -> v => ({displayName:v})`，此时 parent 是
+      //   `users[0]` 这个对象元素）：保持现有协议 —— 删原 key + 合并新对象到该父对象。
+      //   这是测试 `transforms array values` 锁定的行为。
       const parentPath = pathArray.slice(0, -1);
       const parentObj = parentPath.length > 0 ? (0, _util.get)(result, parentPath) : result;
-      if (parentObj && typeof parentObj === 'object') {
-        const keyToDelete = pathArray[pathArray.length - 1];
-        delete parentObj[keyToDelete];
+      const lastKey = pathArray[pathArray.length - 1];
+      if (Array.isArray(parentObj)) {
+        // 父节点是数组：直接整体替换该索引位置的值
+        parentObj[lastKey] = transformed;
+      } else if (parentObj && typeof parentObj === 'object') {
+        // 父节点是对象：保持原协议（删旧 key + 合并新对象）
+        delete parentObj[lastKey];
         Object.assign(parentObj, transformed);
       }
     } else {
-      // 如果返回原始值，直接替换
-      // 手动设置嵌套路径的值，确保数组索引正确处理
-      let current = result;
-      for (let i = 0; i < pathArray.length - 1; i++) {
-        const key = pathArray[i];
-        if (current[key] === undefined) {
-          // 如果下一个键是数字，创建数组，否则创建对象
-          const nextKey = pathArray[i + 1];
-          current[key] = typeof nextKey === 'number' ? [] : {};
-        }
-        current = current[key];
-      }
-      current[pathArray[pathArray.length - 1]] = transformed;
+      // 如果返回原始值，直接替换。
+      // 用 lodash-es/set 替代手写的 setIn 循环：
+      //  - 旧实现 `if (current[key] === undefined)` 漏判 null / false 等假值，
+      //    遇到 `{ user: null }` + 路径 `'user.profile.name'` 会在 `null['profile']` 抛 TypeError；
+      //  - 旧实现 `typeof nextKey === 'number' ? [] : {}` 决定容器类型也是凭路径推断，
+      //    存在与点号路径段类型不一致时建错容器的问题。
+      // lodash set 内部会按目标路径段做安全合并（已存在则用已有值；为 nil 时按下一段是否数字
+      // 自动建 array/object），与历史行为兼容更稳妥。
+      (0, _lodashEs.set)(result, pathArray, transformed);
     }
   }
 }
@@ -146,66 +162,74 @@ function processDotPathTransforms(result, dotPathTransforms) {
 /**
  * 在嵌套转换配置中查找转换函数
  *
+ * 等价于沿 `[...parentsKey, entityKey]` 路径在 `currentTransforms` 上下钻：
+ *  - 中间任意一段不是对象（缺失 / null / 原始值 / 函数等） → 视为找不到，返回 undefined；
+ *  - 最终落点必须是 function 才返回，否则返回 undefined。
+ *
+ * 旧实现是 28 行手写循环，这里改用 `lodash-es/get` 一行实现：`get` 在路径走不下去时
+ * 返回 undefined，与原循环里 `nestedTransforms = null; break;` 行为等价。
+ *
  * @param currentTransforms - 当前转换配置
  * @param parentsKey - 父级路径
  * @param entityKey - 当前实体键
  * @returns 找到的转换函数或 undefined
  */
 function findNestedTransformFunction(currentTransforms, parentsKey, entityKey) {
-  let nestedTransforms = currentTransforms;
-  for (const parentKey of parentsKey) {
-    const parentKeyStr = String(parentKey);
-    if (nestedTransforms && typeof nestedTransforms[parentKeyStr] === 'object') {
-      nestedTransforms = nestedTransforms[parentKeyStr];
-    } else {
-      nestedTransforms = null;
-      break;
-    }
-  }
-  if (nestedTransforms && typeof nestedTransforms[entityKey] === 'function') {
-    return nestedTransforms[entityKey];
-  }
-  return undefined;
+  // React.Key = string | number | bigint，但 lodash get 的 path 段不接受 bigint，
+  // 所以这里把整条路径段都用 String() 归一化为字符串再传入。lodash get 内部会按
+  // 数字字符串自动处理数组索引，行为与原循环里 `String(parentKey)` 等价。
+  const path = [...parentsKey.map(String), entityKey];
+  const candidate = (0, _util.get)(currentTransforms, path);
+  return typeof candidate === 'function' ? candidate : undefined;
 }
 
 /**
- * 检查路径是否包含数组索引
+ * 判断 `parentsKey` 这条路径上是否曾经穿过一个数组节点。
+ *
+ * 旧实现用 `!isNaN(Number(key))` 来判断「这一段看起来像数字」就当成数组索引，会把
+ *  - 年份字段名 `'2024'`
+ *  - ID 字段名 `'0'` / `'007'`
  *
- * @param parentsKey - 父级路径数组
- * @returns 如果包含数组索引返回 true
+ * 这类「字符串字段名恰好可被解析为数字」的合法用户字段误判为数组索引，导致 transform
+ * 返回的对象被错误地合并到当前层而不是 root。这里改为按 `rootValues` 的真实形状逐段下钻，
+ * 只要中途任意一段父节点本身是数组就返回 true。
  */
-function isInArrayPath(parentsKey) {
-  return parentsKey.some(key => !isNaN(Number(key)));
+function isInArrayPath(rootValues, parentsKey) {
+  let cursor = rootValues;
+  for (const segment of parentsKey) {
+    if (Array.isArray(cursor)) return true;
+    if (cursor == null || typeof cursor !== 'object') return false;
+    cursor = cursor[segment];
+  }
+  return Array.isArray(cursor);
 }
 
 /**
  * 递归处理嵌套对象转换（传统格式）
  *
- * @param tempValues - 要处理的值
- * @param parentsKey - 父级路径
- * @param currentTransforms - 当前转换配置
- * @param rootMergeObjects - 存储需要在根级别合并的对象
- * @param visited - 存储已经访问过的对象，防止循环引用
+ * @param currentValues - 当前递归层要处理的 values 子树
+ * @param parentsKey - 当前递归层在 root values 上的父级路径
+ * @param currentTransforms - 当前递归层对应的 transforms 子树
+ * @param rootLevelMerges - 收集所有「应在 root 上合并」的 transform 返回对象
+ * @param rootAllValues - 根级表单对象（与 `SearchTransformKeyFn` 第三参一致），整次转换过程中保持不变引用
  * @returns 处理后的结果
+ *
+ * 设计说明：旧实现带有 `visited: Set<any>` 用于防止循环引用，但 `transformKeySubmitValue`
+ * 入口已经做过 `cloneDeep(values)`，且 antd Form 的 values 由用户输入序列化产生，必然
+ * 是 DAG / 树结构（无循环引用），该 Set 是 dead code，已删除以减少递归参数数量。
  */
-function processNestedObjectTransforms(tempValues, parentsKey, currentTransforms, rootMergeObjects, visited) {
-  if (tempValues != null && typeof tempValues === 'object') {
-    if (visited.has(tempValues)) {
-      return tempValues;
-    }
-    visited.add(tempValues);
-  }
-  const isArrayValues = Array.isArray(tempValues);
-  let tempResult = isArrayValues ? [] : {};
-  if (tempValues == null || tempValues === undefined) {
-    return tempResult;
+function processNestedObjectTransforms(currentValues, parentsKey, currentTransforms, rootLevelMerges, rootAllValues) {
+  const isArrayValues = Array.isArray(currentValues);
+  const currentResult = isArrayValues ? [] : {};
+  if (currentValues == null || currentValues === undefined) {
+    return currentResult;
   }
 
   // 确定要处理的键
-  const keysToProcess = isArrayValues ? tempValues.map((_, index) => index.toString()) : Object.keys(tempValues);
+  const keysToProcess = isArrayValues ? currentValues.map((_, index) => index.toString()) : Object.keys(currentValues);
   for (const entityKey of keysToProcess) {
-    const key = parentsKey ? [...parentsKey, entityKey] : [entityKey];
-    const itemValue = tempValues[entityKey];
+    const nextParentsKey = parentsKey ? [...parentsKey, entityKey] : [entityKey];
+    const itemValue = currentValues[entityKey];
 
     // 查找转换函数
     let transformFunction = currentTransforms[entityKey];
@@ -215,45 +239,49 @@ function processNestedObjectTransforms(tempValues, parentsKey, currentTransforms
       transformFunction = findNestedTransformFunction(currentTransforms, parentsKey, entityKey);
     }
     if (transformFunction && typeof transformFunction === 'function') {
-      // 执行转换
-      const transformed = transformFunction(itemValue, entityKey, tempValues);
+      const namePath = nextParentsKey.map(k => String(k));
+      const transformed = transformFunction(itemValue, namePath, rootAllValues);
       if (typeof transformed === 'object' && transformed !== null && !Array.isArray(transformed)) {
-        // 检查当前项是否在数组中
-        const isInArray = parentsKey ? isInArrayPath(parentsKey) : false;
+        // 检查当前项是否在数组中（按 root values 的真实数据形状判断，
+        // 而不是按路径段「看起来像数字」判断 —— 否则字段名 '2024' 这类会被误判）
+        const isInArray = parentsKey ? isInArrayPath(rootAllValues, parentsKey) : false;
         if (isInArray) {
           // 如果是数组元素内的转换，直接合并到当前结果
-          Object.assign(tempResult, transformed);
+          Object.assign(currentResult, transformed);
         } else {
-          // 如果不是数组元素，将其存储到 rootMergeObjects 以便在根级别合并
-          rootMergeObjects.push(transformed);
+          // 如果不是数组元素，将其存储到 rootLevelMerges 以便在根级别合并
+          rootLevelMerges.push(transformed);
         }
       } else {
         // 如果返回原始值，用新键替换
-        tempResult[entityKey] = transformed;
+        currentResult[entityKey] = transformed;
       }
     } else if (isPlainObj(itemValue) && !(0, _isNil.isNil)(itemValue)) {
       // 递归处理嵌套对象（但跳过 null 值）
       const nestedTransforms = currentTransforms[entityKey];
       if (nestedTransforms && typeof nestedTransforms === 'object') {
         // 如果当前键有嵌套转换配置，传递嵌套配置
-        const nested = processNestedObjectTransforms(itemValue, key, nestedTransforms, rootMergeObjects, visited);
-        // 检查是否有任何子属性被转换为对象（会被添加到 rootMergeObjects）
+        const nested = processNestedObjectTransforms(itemValue, nextParentsKey, nestedTransforms, rootLevelMerges, rootAllValues);
+        // 检查是否有任何子属性被转换为对象（会被添加到 rootLevelMerges）
         // 如果 nested 为空或只包含被转换的属性，我们不保留这个对象
         const hasRemainingContent = Object.keys(nested).length > 0;
         if (hasRemainingContent) {
-          tempResult[entityKey] = nested;
+          currentResult[entityKey] = nested;
         }
       } else {
         // 否则继续使用当前转换配置递归
-        const nested = processNestedObjectTransforms(itemValue, key, currentTransforms, rootMergeObjects, visited);
-        tempResult[entityKey] = nested;
+        const nested = processNestedObjectTransforms(itemValue, nextParentsKey, currentTransforms, rootLevelMerges, rootAllValues);
+        currentResult[entityKey] = nested;
       }
     } else if (!(0, _isNil.isNil)(itemValue)) {
-      // 保留非 null/undefined 原始值
-      tempResult[entityKey] = itemValue;
+      // 历史协议（"ignore null"，详见 tests/utils/index.test.tsx#943）：
+      // 没有 transform 配置且值为 null / undefined 的字段会被静默忽略，最终结果里
+      // 该字段为 undefined。如果想改成「保留原 null/undefined」需要先评估外部影响
+      // 并同步更新该测试，本轮不动。
+      currentResult[entityKey] = itemValue;
     }
   }
-  return tempResult;
+  return currentResult;
 }
 
 /**
@@ -299,16 +327,16 @@ const transformKeySubmitValue = (values, dataFormatMapRaw) => {
   // 处理点号路径格式的转换（如 'users.0.name'）
   processDotPathTransforms(result, dotPathTransforms);
 
-  // 存储需要在根级别合并的对象
-  const rootMergeObjects = [];
+  // 收集所有「应在 root 上合并」的 transform 返回对象
+  const rootLevelMerges = [];
 
   // 处理传统的嵌套对象格式转换（向后兼容）
   if (Object.keys(objectTransforms).length > 0) {
-    result = processNestedObjectTransforms(result, undefined, objectTransforms, rootMergeObjects, new Set());
+    result = processNestedObjectTransforms(result, undefined, objectTransforms, rootLevelMerges, result);
   }
 
-  // 将所有根级别合并对象合并到最终结果
-  for (const obj of rootMergeObjects) {
+  // 将所有根级合并对象合并到最终结果
+  for (const obj of rootLevelMerges) {
     Object.assign(result, obj);
   }
   return result;

package/lib/utils/typing.d.ts

@@ -15,8 +15,7 @@ export type ProFormBaseGroupProps = {
      */
     title?: React.ReactNode;
     /**
-     * @name 分组的标题
-     * @deprecated 尽量用 title
+     * @name 分组的标题，与 title 等价，兼容旧写法
      */
     label?: React.ReactNode;
     /**
@@ -224,21 +223,13 @@ export type ProFieldValueTypeWithFieldProps = {
  * @param jsonCode Json 的代码块，格式化了一下
  * @param color 颜色选择器
  */
-export type ProFieldValueType = Extract<keyof ProFieldValueTypeWithFieldProps, any>;
-/**
- * 这是一个泛型类型定义，用于定义 FieldPropsTypeBase 类型。该类型包含了以下类型参数：
-
- * Entity：表示表单项的数据实体类型，默认为 Record<string, any>。
- * ComponentsType：表示表单项对应的组件类型，默认为 'text'。
- * ExtraProps：表示表单项组件的额外属性类型，默认为 Record<string, any>。
- * FieldPropsType：表示表单项组件的属性类型，默认为 Record<string, any>。
- *
- * 该类型定义了一种联合类型，可以是一个函数类型，也可以是一个对象类型。具体来说：
- * 如果是一个函数类型，它接收两个参数 form 和 config，并返回一个对象类型，该对象类型可以是 FieldPropsType 或 Record<string, any>。
- * 其中，form 是 antd 的 FormInstance 类型，config 是 ProSchema 和其它额外属性的联合类型，并包含了一些表单项相关的信息。
- * 如果不是一个函数类型，它可以是 FieldPropsType 或 Record<string, any> 中的任意一个。
- * 该类型的作用是定义一个通用的表单项属性类型，使得在不同的表单项组件中，可以共用这个属性类型，提高了代码的重用性。
- */
+export type ProFieldValueType = keyof ProFieldValueTypeWithFieldProps;
+/** Schema 布局用（group、formList…）；与 {@link ProFieldBuiltinValueType} 并集为 {@link ProFieldValueType} */
+export declare const PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES: readonly ["group", "formList", "formSet", "divider", "dependency"];
+export type ProFieldSchemaLayoutValueType = (typeof PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES)[number];
+/** 内置 Field 映射键（= 全量 valueType 去掉布局类） */
+export type ProFieldBuiltinValueType = Exclude<ProFieldValueType, ProFieldSchemaLayoutValueType>;
+/** fieldProps：固定类型、函数 `(form, config) => …` 或宽松 Record */
 type FieldPropsTypeBase<Entity = Record<string, any>, ComponentsType = 'text', ExtraProps = Record<string, any>, FieldPropsType = ProFieldValueTypeWithFieldProps['text']> = ((form: FormInstance<any>, config: ProSchema<Entity, ExtraProps> & {
     type: ComponentsType;
     isEditable?: boolean;
@@ -246,22 +237,7 @@ type FieldPropsTypeBase<Entity = Record<string, any>, ComponentsType = 'text', E
     rowIndex: number;
     entity: Entity;
 }) => FieldPropsType | Record<string, any>) | FieldPropsType | Record<string, any>;
-/**
- * 这段代码定义了一个泛型类型 ProFieldValueObject<Type>，它的泛型参数 Type 必须是 'progress'、'money'、'percent'、'image' 中的一个。
- * 当 Type 为 'progress'、'money'、'percent'、'image' 中的一种时，这个类型将被定义为一个对象，包含以下属性：
- *
- * - type: Type 类型值，即 'progress'、'money'、'percent'、'image' 中的一种；
- * - status: 字符串类型，表示状态，可选值为 'normal'、'active'、'success'、'exception' 或 undefined；
- * - locale: 字符串类型，表示地区；
- * - showSymbol: 布尔类型或函数类型，表示是否显示符号；
- * - showColor: 布尔类型，表示是否显示颜色；
- * - precision: 数字类型，表示精度；
- * - moneySymbol: 布尔类型，表示是否显示货币符号；
- * - request: ProFieldRequestData 类型，表示请求数据；
- * - width: 数字类型，表示宽度。
- *
- * 如果 Type 不是 'progress'、'money'、'percent'、'image' 中的一种，那么 ProFieldValueObject<Type> 的类型为 never。
- */
+/** 泛型：仅 progress | money | percent | image 时有属性，否则 never */
 export type ProFieldValueObject<Type> = Type extends 'progress' | 'money' | 'percent' | 'image' ? {
     type: Type;
     status?: 'normal' | 'active' | 'success' | 'exception' | undefined;
@@ -275,36 +251,11 @@ export type ProFieldValueObject<Type> = Type extends 'progress' | 'money' | 'per
     /** Image */
     width?: number;
 } : never;
-/**
- * 这段代码定义了一个泛型类型 ValueTypeWithFieldPropsBase，它包含了以下属性：
- * - Entity：泛型类型，表示数据实体对象的类型；
- * - ComponentsType：泛型类型，表示组件的类型；
- * - ExtraProps：泛型类型，表示额外的属性；
- * - ValueType：泛型类型，表示字段的值类型，默认为字符串类型。
- *
- * 该类型的主要作用是用于定义 ProTable 组件的列属性 ProColumns 中的字段属性，包括字段的类型（valueType）和自定义属性（fieldProps）。其中：
- * - valueType 属性可以是字符串类型，也可以是 ProFieldValueType 枚举类型，也可以是一个对象类型 ProFieldValueObject，或者是一个返回值为这些类型之一的函数。它表示字段的类型，如文本、数字、日期等；
- * - fieldProps 属性是一个泛型类型 FieldPropsTypeBase，它表示该字段对应的组件的属性，用于定制组件的展示形式、校验规则、事件等等。根据字段类型的不同，其属性值也会有所不同。
- */
+/** ProColumns / ProSchema：`valueType` + 按类型收窄的 `fieldProps` */
 type ValueTypeWithFieldPropsBase<Entity = Record<string, any>, ComponentsType = 'form', ExtraProps = Record<string, any>, ValueType = 'text'> = {
     valueType?: ValueType | ProFieldValueType | ProFieldValueObject<ValueType | ProFieldValueType> | ((entity: Entity, type: ComponentsType) => ValueType | ProFieldValueType | ProFieldValueObject<ValueType | ProFieldValueType>);
     fieldProps?: FieldPropsTypeBase<Entity, ComponentsType, ExtraProps, ValueType extends ProFieldValueType ? ProFieldValueTypeWithFieldProps[ValueType] : ProFieldValueTypeWithFieldProps['text']>;
 };
-/**
- * 这段代码定义了一个泛型类型 ValueTypeWithFieldProps，它有四个类型参数。
- * 这个类型的作用是用来描述在一个数据表格中某个字段的值（value）以及可能需要传递给这个字段的其他属性（fieldProps），以便在 UI 上正确地展示这个字段。
- * 具体来说，这个类型有一个属性 valueType，表示字段的值的类型，可以是 'text'、'money'、'percent'、'image'、ProFieldValueType 中的一个，也可以是一个函数。
- *
- * 它的参数是该行数据和组件类型（例如 'table' 或 'form'），返回值为上述值中的一种。
- *
- * 此外，这个类型还有一个属性 fieldProps，表示需要传递给该字段的其他属性，它的类型是一个泛型 FieldPropsTypeBase。这个泛型有四个类型参数，
- * 分别是：
- *  - Entity 表示该字段所在行的数据类型；
- *  - ComponentsType 表示该字段所在的组件类型；
- *  - ExtraProps 表示传递给该字段的其他属性的类型；
- *  - ValueType 表示该字段的值的类型，可以是 'text'、'money'、'percent'、'image'、ProFieldValueType 中的一种。
- * 最终，fieldProps 属性的类型会根据 valueType 的不同，来选择特定的类型进行限制，以确保传递给该字段的其他属性符合它的值的类型。
- */
 export type ValueTypeWithFieldProps<Entity, ComponentsType, ExtraProps, ValueType = 'text'> = ValueTypeWithFieldPropsBase<Entity, ComponentsType, ExtraProps, ValueType>;
 export type PageInfo = {
     pageSize: number;
@@ -384,6 +335,8 @@ export type ProFieldValueObjectType = {
      */
     width?: number;
 };
+/** `PureProField` / `ProFormField` 的 `valueType`：全部字符串类型，或 money/percent 等对象简写 */
+export type ProFieldValueTypeInput = ProFieldValueType | ProFieldValueObjectType;
 /**
  * 支持 Map 和 Record<string,any>
  *
@@ -397,8 +350,12 @@ export type SearchConvertKeyFn = (value: any, field: NamePath) => string | boole
 export type ProTableEditableFnType<T> = (value: any, record: T, index: number) => boolean;
 /** 支持的变形，还未完全支持完毕 */
 export type ProSchemaComponentTypes = 'form' | 'list' | 'descriptions' | 'table' | 'cardList' | undefined;
-/** 操作类型 */
-export type ProCoreActionType<T = {}> = {
+/**
+ * Pro 系列组件 Action 公共字段。所有 Pro 组件 actionRef 暴露的最小集合，
+ * 不带任何编辑能力相关字段。table / descriptions 等场景通过第二个泛型 `EditableUtil`
+ * 注入对应的编辑工具方法（Array 编辑用 UseEditableUtilType，Map 编辑用 UseEditableMapUtilType）。
+ */
+export type ProCoreActionBase = {
     /** @name 刷新 */
     reload: (resetPageIndex?: boolean) => Promise<void>;
     /** @name 刷新并清空，只清空页面，不包括表单 */
@@ -409,7 +366,17 @@ export type ProCoreActionType<T = {}> = {
     clearSelected?: () => void;
     /** @name p页面的信息都在里面 */
     pageInfo?: PageInfo;
-} & Omit<UseEditableUtilType, 'newLineRecord' | 'editableKeys' | 'actionRender' | 'setEditableRowKeys'> & T;
+};
+/**
+ * 操作类型
+ *
+ * @template T          业务方扩展字段
+ * @template EditableUtil 编辑能力工具方法集合，默认走 Array 编辑（兼容历史调用方）
+ *   - Array 编辑（ProTable）：默认值 = `Omit<UseEditableUtilType, 'newLineRecord' | 'editableKeys' | 'actionRender' | 'setEditableRowKeys'>`
+ *   - Map 编辑（ProDescriptions）：显式传入 `Partial<UseEditableMapUtilType>`
+ *   - 无编辑（ProForm 等）：显式传入 `{}`
+ */
+export type ProCoreActionType<T = {}, EditableUtil = Omit<UseEditableUtilType, 'newLineRecord' | 'editableKeys' | 'actionRender' | 'setEditableRowKeys'>> = ProCoreActionBase & EditableUtil & T;
 export type ProSchemaFieldProps<T> = Record<string, any> | T | Partial<InputProps>;
 /** 各个组件公共支持的 render */
 export type ProSchema<Entity = Record<string, any>, ExtraProps = unknown, ComponentsType extends ProSchemaComponentTypes = 'form', ValueType = 'text', ExtraFormItemProps = unknown> = {

package/lib/utils/typing.js

@@ -2,4 +2,93 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+exports.PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES = void 0;
+// 兼容 antd 6.x 版本
+
+/**
+ * ProFieldValueTypeWithFieldProps
+ * 字段值类型与 ProFieldProps 的映射关系
+ */
+
+/**
+ * @param textarea 文本框
+ * @param password 密码框
+ * @param money 金额 option 操作 需要返回一个数组
+ * @param date 日期 YYYY-MM-DD
+ * @param dateWeek 周选择器
+ * @param dateMonth 月选择器
+ * @param dateQuarter 季度选择器
+ * @param dateYear 年选择器
+ * @param dateRange 日期范围 YYYY-MM-DD[]
+ * @param dateTime 日期和时间 YYYY-MM-DD HH:mm:ss
+ * @param dateTimeRange 范围日期和时间 YYYY-MM-DD HH:mm:ss[]
+ * @param time: 时间 HH:mm:ss
+ * @param timeRange: 时间区间 HH:mm:ss[]
+ * @param index：序列
+ * @param indexBorder：序列
+ * @param progress: 进度条
+ * @param percent: 百分比
+ * @param digit 数值
+ * @param second 秒速
+ * @param fromNow 相对于当前时间
+ * @param avatar 头像
+ * @param code 代码块
+ * @param image 图片设置
+ * @param jsonCode Json 的代码块，格式化了一下
+ * @param color 颜色选择器
+ */
+
+/** Schema 布局用（group、formList…）；与 {@link ProFieldBuiltinValueType} 并集为 {@link ProFieldValueType} */
+const PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES = exports.PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES = ['group', 'formList', 'formSet', 'divider', 'dependency'];
+
+/** 内置 Field 映射键（= 全量 valueType 去掉布局类） */
+
+/** fieldProps：固定类型、函数 `(form, config) => …` 或宽松 Record */
+
+/** 泛型：仅 progress | money | percent | image 时有属性，否则 never */
+
+/** ProColumns / ProSchema：`valueType` + 按类型收窄的 `fieldProps` */
+
+/**
+ * ProFieldValueObjectType 对象，用于描述值为 'progress' | 'money' | 'percent' | 'image' 类型的 ProField 的属性。
+ * @typedef {Object} ProFieldValueObjectType
+ * @property {('progress' | 'money' | 'percent' | 'image')} type - 值的类型。
+ * @property {('normal' | 'active' | 'success' | 'exception' | undefined)} [status] - 状态。
+ * @property {string} [locale] - 本地化语言。
+ * @property {((value: any) => boolean) | boolean} [showSymbol] - 是否显示符号。
+ * @property {boolean} [showColor] - 是否显示颜色。
+ * @property {number} [precision] - 精度。
+ * @property {boolean} [moneySymbol] - 是否显示货币符号。
+ * @property {ProFieldRequestData} [request] - 远程请求数据。
+ * @property {number} [width] - 图片的宽度。
+ */
+
+/** `PureProField` / `ProFormField` 的 `valueType`：全部字符串类型，或 money/percent 等对象简写 */
+
+/**
+ * 支持 Map 和 Record<string,any>
+ *
+ * @name ValueEnum 的类型
+ */
+
+// 支持的变形，还未完全支持完毕
+/** 支持的变形，还未完全支持完毕 */
+
+/**
+ * Pro 系列组件 Action 公共字段。所有 Pro 组件 actionRef 暴露的最小集合，
+ * 不带任何编辑能力相关字段。table / descriptions 等场景通过第二个泛型 `EditableUtil`
+ * 注入对应的编辑工具方法（Array 编辑用 UseEditableUtilType，Map 编辑用 UseEditableMapUtilType）。
+ */
+
+/**
+ * 操作类型
+ *
+ * @template T          业务方扩展字段
+ * @template EditableUtil 编辑能力工具方法集合，默认走 Array 编辑（兼容历史调用方）
+ *   - Array 编辑（ProTable）：默认值 = `Omit<UseEditableUtilType, 'newLineRecord' | 'editableKeys' | 'actionRender' | 'setEditableRowKeys'>`
+ *   - Map 编辑（ProDescriptions）：显式传入 `Partial<UseEditableMapUtilType>`
+ *   - 无编辑（ProForm 等）：显式传入 `{}`
+ */
+
+/** 各个组件公共支持的 render */

package/lib/utils/useEditableArray/index.d.ts

@@ -3,9 +3,21 @@ import type { AnyObject } from 'antd/lib/_util/type';
 import type { NamePath } from 'antd/lib/form/interface';
 import type { GetRowKey } from 'antd/lib/table/interface';
 import React from 'react';
+import { conversionMomentValue } from '../conversionMomentValue';
 export type RowEditableType = 'single' | 'multiple';
 export type RecordKey = React.Key | React.Key[];
 export declare const recordKeyToString: (rowKey: RecordKey) => React.Key;
+/**
+ * 判断两个 RecordKey 是否语义相等（容忍 number/string 与数组顺序差异）。
+ *
+ * 设计动机：直接 `===` 对 RecordKey 不安全：
+ *  - `1` !== `'1'`（number/string 混用场景常见）
+ *  - 数组永远是引用相等，例如 `['a'] !== ['a']`
+ *
+ * 实现：先用 recordKeyToString 拍平为标量，再做 `String(...)` 字符串比较，
+ * 双侧都为 null/undefined 时返回 true 视作"未指定 key"匹配。
+ */
+export declare const isSameRecordKey: (a: RecordKey | null | undefined, b: RecordKey | null | undefined) => boolean;
 export type AddLineOptions = {
     position?: 'top' | 'bottom';
     recordKey?: RecordKey;
@@ -94,6 +106,10 @@ export type RowEditableConfig<DataType> = {
      * @link https://github.com/ant-design/pro-components/issues/7790
      */
     getRealIndex?: (record: DataType) => number;
+    /**
+     * 与 ProTable `dateFormatter` 一致；合并到 dataSource 时把行内的 dayjs / 反序列化 dayjs 转为 string 或 number
+     */
+    dateFormatter?: Parameters<typeof conversionMomentValue>[1];
 };
 export type ActionTypeText<T> = {
     deleteText?: React.ReactNode;
@@ -140,7 +156,7 @@ export declare function editableRowByKey<RecordType>(keyProps: {
 export declare function SaveEditableAction<T>({ recordKey, onSave, row, children, newLineConfig, editorType, tableName, }: ActionRenderConfig<T> & {
     row: any;
     children: any;
-}, ref: React.Ref<SaveEditableActionRef<T>>): import("react/jsx-runtime").JSX.Element;
+}, ref: React.Ref<SaveEditableActionRef<T>>): React.JSX.Element;
 export type SaveEditableActionRef<T = any> = {
     /**
      * 直接触发保存动作
@@ -158,10 +174,10 @@ export declare const DeleteEditableAction: React.FC<ActionRenderConfig<any> & {
     row: any;
 }>;
 export declare function defaultActionRender<T>(row: T, config: ActionRenderConfig<T, NewLineConfig<T>>): {
-    save: import("react/jsx-runtime").JSX.Element;
+    save: React.JSX.Element;
     saveRef: React.RefObject<SaveEditableActionRef<T>>;
-    delete: import("react/jsx-runtime").JSX.Element | undefined;
-    cancel: import("react/jsx-runtime").JSX.Element;
+    delete: React.JSX.Element | undefined;
+    cancel: React.JSX.Element;
 };
 /**
  * 一个方便的hooks 用于维护编辑的状态
@@ -186,7 +202,7 @@ export declare function useEditableArray<RecordType extends AnyObject>(props: Ro
     };
     actionRender: (row: RecordType & {
         index: number;
-    }) => React.ReactNode[] | (import("react/jsx-runtime").JSX.Element | undefined)[];
+    }) => React.ReactNode[] | (React.JSX.Element | undefined)[];
     startEditable: (recordKey: React.Key, record?: RecordType | undefined) => boolean;
     cancelEditable: (recordKey: RecordKey, needReTry?: boolean | undefined) => Promise<boolean>;
     addEditRecord: (row: RecordType, options?: AddLineOptions | undefined) => boolean;