@ant-design/pro-components 3.0.2-0 → 3.1.1-0

package/es/utils/transformKeySubmitValue/index.js

@@ -1,7 +1,5 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 import { get } from '@rc-component/util';
+import { cloneDeep } from 'lodash-es';
 import React from 'react';
 import { isNil } from "../isNil";
 /**
@@ -13,7 +11,7 @@ import { isNil } from "../isNil";
  */
 export function isPlainObj(itemValue) {
   // 如果不是对象类型，直接返回 false
-  if (_typeof(itemValue) !== 'object') {
+  if (typeof itemValue !== 'object') {
     return false;
   }
 
@@ -42,7 +40,7 @@ export function isPlainObj(itemValue) {
  * @returns 路径数组，数字会被转换为数字类型
  */
 function parseDotPath(dotPath) {
-  return dotPath.split('.').map(function (segment) {
+  return dotPath.split('.').map(segment => {
     // 如果是纯数字，转换为数字类型用于数组索引
     return /^\d+$/.test(segment) ? parseInt(segment, 10) : segment;
   });
@@ -55,9 +53,9 @@ function parseDotPath(dotPath) {
  * @returns 过滤后的转换配置
  */
 function filterNilTransforms(dataFormatMapRaw) {
-  var filtered = {};
-  for (var key in dataFormatMapRaw) {
-    var value = dataFormatMapRaw[key];
+  const filtered = {};
+  for (const key in dataFormatMapRaw) {
+    const value = dataFormatMapRaw[key];
     if (!isNil(value)) {
       filtered[key] = value;
     }
@@ -72,10 +70,10 @@ function filterNilTransforms(dataFormatMapRaw) {
  * @returns 包含两种格式转换配置的对象
  */
 function separateTransformFormats(dataFormatMapRaw) {
-  var dotPathTransforms = {};
-  var objectTransforms = {};
-  for (var key in dataFormatMapRaw) {
-    var value = dataFormatMapRaw[key];
+  const dotPathTransforms = {};
+  const objectTransforms = {};
+  for (const key in dataFormatMapRaw) {
+    const value = dataFormatMapRaw[key];
     if (isNil(value)) continue;
     if (key.includes('.')) {
       dotPathTransforms[key] = value;
@@ -84,8 +82,8 @@ function separateTransformFormats(dataFormatMapRaw) {
     }
   }
   return {
-    dotPathTransforms: dotPathTransforms,
-    objectTransforms: objectTransforms
+    dotPathTransforms,
+    objectTransforms
   };
 }
 
@@ -97,37 +95,37 @@ function separateTransformFormats(dataFormatMapRaw) {
  * @param dotPathTransforms - 点号路径转换配置
  */
 function processDotPathTransforms(result, dotPathTransforms) {
-  for (var dotPath in dotPathTransforms) {
-    var transform = dotPathTransforms[dotPath];
+  for (const dotPath in dotPathTransforms) {
+    const transform = dotPathTransforms[dotPath];
     if (typeof transform !== 'function') continue;
 
     // 将点号路径转换为数组路径
-    var pathArray = parseDotPath(dotPath);
+    const pathArray = parseDotPath(dotPath);
 
     // 获取要转换的值
-    var currentValue = get(result, pathArray);
+    const currentValue = get(result, pathArray);
     if (currentValue === undefined) continue;
 
     // 执行转换
-    var transformed = transform(currentValue, pathArray.map(String), result);
-    if (_typeof(transformed) === 'object' && transformed !== null && !Array.isArray(transformed)) {
+    const transformed = transform(currentValue, pathArray.map(String), result);
+    if (typeof transformed === 'object' && transformed !== null && !Array.isArray(transformed)) {
       // 如果返回对象，删除原键并将对象的键值对合并到父级
-      var parentPath = pathArray.slice(0, -1);
-      var parentObj = parentPath.length > 0 ? get(result, parentPath) : result;
-      if (parentObj && _typeof(parentObj) === 'object') {
-        var keyToDelete = pathArray[pathArray.length - 1];
+      const parentPath = pathArray.slice(0, -1);
+      const parentObj = parentPath.length > 0 ? get(result, parentPath) : result;
+      if (parentObj && typeof parentObj === 'object') {
+        const keyToDelete = pathArray[pathArray.length - 1];
         delete parentObj[keyToDelete];
         Object.assign(parentObj, transformed);
       }
     } else {
       // 如果返回原始值，直接替换
       // 手动设置嵌套路径的值，确保数组索引正确处理
-      var current = result;
-      for (var i = 0; i < pathArray.length - 1; i++) {
-        var key = pathArray[i];
+      let current = result;
+      for (let i = 0; i < pathArray.length - 1; i++) {
+        const key = pathArray[i];
         if (current[key] === undefined) {
           // 如果下一个键是数字，创建数组，否则创建对象
-          var nextKey = pathArray[i + 1];
+          const nextKey = pathArray[i + 1];
           current[key] = typeof nextKey === 'number' ? [] : {};
         }
         current = current[key];
@@ -146,24 +144,15 @@ function processDotPathTransforms(result, dotPathTransforms) {
  * @returns 找到的转换函数或 undefined
  */
 function findNestedTransformFunction(currentTransforms, parentsKey, entityKey) {
-  var nestedTransforms = currentTransforms;
-  var _iterator = _createForOfIteratorHelper(parentsKey),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var parentKey = _step.value;
-      var parentKeyStr = String(parentKey);
-      if (nestedTransforms && _typeof(nestedTransforms[parentKeyStr]) === 'object') {
-        nestedTransforms = nestedTransforms[parentKeyStr];
-      } else {
-        nestedTransforms = null;
-        break;
-      }
+  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;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   if (nestedTransforms && typeof nestedTransforms[entityKey] === 'function') {
     return nestedTransforms[entityKey];
@@ -178,9 +167,7 @@ function findNestedTransformFunction(currentTransforms, parentsKey, entityKey) {
  * @returns 如果包含数组索引返回 true
  */
 function isInArrayPath(parentsKey) {
-  return parentsKey.some(function (key) {
-    return !isNaN(Number(key));
-  });
+  return parentsKey.some(key => !isNaN(Number(key)));
 }
 
 /**
@@ -190,77 +177,73 @@ function isInArrayPath(parentsKey) {
  * @param parentsKey - 父级路径
  * @param currentTransforms - 当前转换配置
  * @param rootMergeObjects - 存储需要在根级别合并的对象
+ * @param visited - 存储已经访问过的对象，防止循环引用
  * @returns 处理后的结果
  */
-function processNestedObjectTransforms(tempValues, parentsKey, currentTransforms, rootMergeObjects) {
-  var isArrayValues = Array.isArray(tempValues);
-  var tempResult = isArrayValues ? [] : {};
+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;
   }
 
   // 确定要处理的键
-  var keysToProcess = isArrayValues ? tempValues.map(function (_, index) {
-    return index.toString();
-  }) : Object.keys(tempValues);
-  var _iterator2 = _createForOfIteratorHelper(keysToProcess),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var entityKey = _step2.value;
-      var key = parentsKey ? [].concat(_toConsumableArray(parentsKey), [entityKey]) : [entityKey];
-      var itemValue = tempValues[entityKey];
+  const keysToProcess = isArrayValues ? tempValues.map((_, index) => index.toString()) : Object.keys(tempValues);
+  for (const entityKey of keysToProcess) {
+    const key = parentsKey ? [...parentsKey, entityKey] : [entityKey];
+    const itemValue = tempValues[entityKey];
 
-      // 查找转换函数
-      var transformFunction = currentTransforms[entityKey];
+    // 查找转换函数
+    let transformFunction = currentTransforms[entityKey];
 
-      // 如果没找到并且是嵌套路径，尝试在嵌套对象中查找
-      if (!transformFunction && parentsKey) {
-        transformFunction = findNestedTransformFunction(currentTransforms, parentsKey, entityKey);
-      }
-      if (transformFunction && typeof transformFunction === 'function') {
-        // 执行转换
-        var transformed = transformFunction(itemValue, entityKey, tempValues);
-        if (_typeof(transformed) === 'object' && transformed !== null && !Array.isArray(transformed)) {
-          // 检查当前项是否在数组中
-          var isInArray = parentsKey ? isInArrayPath(parentsKey) : false;
-          if (isInArray) {
-            // 如果是数组元素内的转换，直接合并到当前结果
-            Object.assign(tempResult, transformed);
-          } else {
-            // 如果不是数组元素，将其存储到 rootMergeObjects 以便在根级别合并
-            rootMergeObjects.push(transformed);
-          }
+    // 如果没找到并且是嵌套路径，尝试在嵌套对象中查找
+    if (!transformFunction && parentsKey) {
+      transformFunction = findNestedTransformFunction(currentTransforms, parentsKey, entityKey);
+    }
+    if (transformFunction && typeof transformFunction === 'function') {
+      // 执行转换
+      const transformed = transformFunction(itemValue, entityKey, tempValues);
+      if (typeof transformed === 'object' && transformed !== null && !Array.isArray(transformed)) {
+        // 检查当前项是否在数组中
+        const isInArray = parentsKey ? isInArrayPath(parentsKey) : false;
+        if (isInArray) {
+          // 如果是数组元素内的转换，直接合并到当前结果
+          Object.assign(tempResult, transformed);
         } else {
-          // 如果返回原始值，用新键替换
-          tempResult[entityKey] = transformed;
+          // 如果不是数组元素，将其存储到 rootMergeObjects 以便在根级别合并
+          rootMergeObjects.push(transformed);
         }
-      } else if (isPlainObj(itemValue) && !isNil(itemValue)) {
-        // 递归处理嵌套对象（但跳过 null 值）
-        var nestedTransforms = currentTransforms[entityKey];
-        if (nestedTransforms && _typeof(nestedTransforms) === 'object') {
-          // 如果当前键有嵌套转换配置，传递嵌套配置
-          var nested = processNestedObjectTransforms(itemValue, key, nestedTransforms, rootMergeObjects);
-          // 检查是否有任何子属性被转换为对象（会被添加到 rootMergeObjects）
-          // 如果 nested 为空或只包含被转换的属性，我们不保留这个对象
-          var hasRemainingContent = Object.keys(nested).length > 0;
-          if (hasRemainingContent) {
-            tempResult[entityKey] = nested;
-          }
-        } else {
-          // 否则继续使用当前转换配置递归
-          var _nested = processNestedObjectTransforms(itemValue, key, currentTransforms, rootMergeObjects);
-          tempResult[entityKey] = _nested;
+      } else {
+        // 如果返回原始值，用新键替换
+        tempResult[entityKey] = transformed;
+      }
+    } else if (isPlainObj(itemValue) && !isNil(itemValue)) {
+      // 递归处理嵌套对象（但跳过 null 值）
+      const nestedTransforms = currentTransforms[entityKey];
+      if (nestedTransforms && typeof nestedTransforms === 'object') {
+        // 如果当前键有嵌套转换配置，传递嵌套配置
+        const nested = processNestedObjectTransforms(itemValue, key, nestedTransforms, rootMergeObjects, visited);
+        // 检查是否有任何子属性被转换为对象（会被添加到 rootMergeObjects）
+        // 如果 nested 为空或只包含被转换的属性，我们不保留这个对象
+        const hasRemainingContent = Object.keys(nested).length > 0;
+        if (hasRemainingContent) {
+          tempResult[entityKey] = nested;
         }
-      } else if (!isNil(itemValue)) {
-        // 保留非 null/undefined 原始值
-        tempResult[entityKey] = itemValue;
+      } else {
+        // 否则继续使用当前转换配置递归
+        const nested = processNestedObjectTransforms(itemValue, key, currentTransforms, rootMergeObjects, visited);
+        tempResult[entityKey] = nested;
       }
+    } else if (!isNil(itemValue)) {
+      // 保留非 null/undefined 原始值
+      tempResult[entityKey] = itemValue;
     }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
   }
   return tempResult;
 }
@@ -275,9 +258,9 @@ function processNestedObjectTransforms(tempValues, parentsKey, currentTransforms
  * @param dataFormatMapRaw - 转换配置映射
  * @returns 转换后的值对象
  */
-export var transformKeySubmitValue = function transformKeySubmitValue(values, dataFormatMapRaw) {
+export const transformKeySubmitValue = (values, dataFormatMapRaw) => {
   // 过滤掉空值的转换配置
-  var dataFormatMap = filterNilTransforms(dataFormatMapRaw);
+  const dataFormatMap = filterNilTransforms(dataFormatMapRaw);
 
   // 如果没有有效的转换配置，直接返回原值
   if (Object.keys(dataFormatMap).length < 1) {
@@ -292,32 +275,32 @@ export var transformKeySubmitValue = function transformKeySubmitValue(values, da
   // 如果 value 是 string | null | Array | Blob 类型其中之一，直接返回
   // 形如 {key: [File, File]} 的表单字段当进行第二次递归时会导致其直接越过 typeof value !== 'object' 这一判断
   // https://github.com/ant-design/pro-components/issues/2071
-  if (_typeof(values) !== 'object' || isNil(values) || values instanceof Blob) {
+  if (typeof values !== 'object' || isNil(values) || values instanceof Blob) {
     return values;
   }
 
   // 创建一个深拷贝来避免修改原始数据
-  var result = JSON.parse(JSON.stringify(values));
+  let result = cloneDeep(values);
 
   // 分别处理不同格式的转换配置
-  var _separateTransformFor = separateTransformFormats(dataFormatMapRaw),
-    dotPathTransforms = _separateTransformFor.dotPathTransforms,
-    objectTransforms = _separateTransformFor.objectTransforms;
+  const {
+    dotPathTransforms,
+    objectTransforms
+  } = separateTransformFormats(dataFormatMapRaw);
 
   // 处理点号路径格式的转换（如 'users.0.name'）
   processDotPathTransforms(result, dotPathTransforms);
 
   // 存储需要在根级别合并的对象
-  var rootMergeObjects = [];
+  const rootMergeObjects = [];
 
   // 处理传统的嵌套对象格式转换（向后兼容）
   if (Object.keys(objectTransforms).length > 0) {
-    result = processNestedObjectTransforms(result, undefined, objectTransforms, rootMergeObjects);
+    result = processNestedObjectTransforms(result, undefined, objectTransforms, rootMergeObjects, new Set());
   }
 
   // 将所有根级别合并对象合并到最终结果
-  for (var _i = 0, _rootMergeObjects = rootMergeObjects; _i < _rootMergeObjects.length; _i++) {
-    var obj = _rootMergeObjects[_i];
+  for (const obj of rootMergeObjects) {
     Object.assign(result, obj);
   }
   return result;

package/es/utils/typing.d.ts

@@ -60,7 +60,7 @@ export type ProFormBaseGroupProps = {
     /**
      * @name 子项的排列方式
      */
-    direction?: SpaceProps['direction'];
+    direction?: SpaceProps['orientation'];
     /**
      * @name 布局方式，键值对模式和两行模式
      * @default inline

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

@@ -106,6 +106,11 @@ export type ActionRenderConfig<T, LineConfig = NewLineConfig<T>> = {
     editableKeys?: RowEditableConfig<T>['editableKeys'];
     recordKey: RecordKey;
     preEditRowRef: React.MutableRefObject<T | null>;
+    /**
+     * 多行编辑场景下，按 recordKey 缓存每一行进入编辑前的快照（允许为 null，用于标记“新建行”）
+     * 用于避免 preEditRowRef（单引用）在多行编辑时被覆盖导致取消误删/误还原的问题
+     */
+    preEditRowRefs?: React.MutableRefObject<Map<string, T | null>>;
     index?: number;
     cancelEditable: (key: RecordKey) => void;
     onSave: RowEditableConfig<T>['onSave'];
@@ -119,9 +124,6 @@ export type ActionRenderConfig<T, LineConfig = NewLineConfig<T>> = {
 } & ActionTypeText<T>;
 /**
  * 使用map 来删除数据，性能一般 但是准确率比较高
- *
- * @param keyProps
- * @param action
  */
 export declare function editableRowByKey<RecordType>(keyProps: {
     data: RecordType[];
@@ -174,19 +176,19 @@ export declare function useEditableArray<RecordType extends AnyObject>(props: Ro
     setDataSource: (dataSource: RecordType[]) => void;
 }): {
     editableKeys: React.Key[] | undefined;
-    setEditableRowKeys: (updater: React.Key[] | ((origin: React.Key[] | undefined) => React.Key[] | undefined) | undefined, ignoreDestroy?: boolean | undefined) => void;
+    setEditableRowKeys: (updater: React.Key[] | ((prev: React.Key[] | undefined) => React.Key[] | undefined) | undefined) => void;
     isEditable: (row: RecordType & {
         index: number;
     }) => {
         recordKey: string;
-        isEditable: any;
-        preIsEditable: any;
+        isEditable: boolean;
+        preIsEditable: boolean;
     };
     actionRender: (row: RecordType & {
         index: number;
     }) => React.ReactNode[] | (import("react/jsx-runtime").JSX.Element | undefined)[];
     startEditable: (recordKey: React.Key, record?: RecordType | undefined) => boolean;
-    cancelEditable: (recordKey: RecordKey, needReTry?: boolean | undefined) => Promise<true | undefined>;
+    cancelEditable: (recordKey: RecordKey, needReTry?: boolean | undefined) => Promise<boolean>;
     addEditRecord: (row: RecordType, options?: AddLineOptions | undefined) => boolean;
     saveEditable: (recordKey: RecordKey, needReTry?: boolean | undefined) => Promise<boolean>;
     newLineRecord: NewLineConfig<RecordType> | undefined;