cloud-web-corejs 1.0.54-dev.781 → 1.0.54-dev.783

package/src/components/xform/form-render/container-item/data-table-mixin.js

@@ -33,15 +33,30 @@ import {
   isEmptyCellValueInRow,
   shouldSkipCellValidation,
 } from "../../../../components/xform/utils/tableCellValidateUtil";
-import {
-  buildDynamicSchemaRequestData,
-  getDynamicSchemaOption,
-  isActionColumnFormat,
-  isNonDataExportColumn,
-  normalizeDynamicColumns as normalizeDynamicColumnList,
-  resolveDynamicSchemaResponse,
-} from "../../utils/dynamicSchemaUtil";
-import { tableTreeMixins } from "../../../../mixins/tableTree/index.js";
+import {
+  buildDynamicSchemaRequestData,
+  getDynamicSchemaOption,
+  isActionColumnFormat,
+  isNonDataExportColumn,
+  normalizeDynamicColumns as normalizeDynamicColumnList,
+  resolveDynamicSchemaResponse,
+} from "../../utils/dynamicSchemaUtil";
+import {
+  resolveTreeFields,
+  resolveTreeIdentityConfig,
+  resolveTreeCopyConfig,
+  resolveTreeSubmitConfig,
+  canonicalizeTreeInput,
+  isRootParent,
+  normalizeTreeKey,
+  treeKeyEquals,
+  makeTreeTempKey,
+  markTemporaryTreeKey,
+  isTemporaryTreeKey,
+  syncTreeKeyReferences,
+  sanitizeTreeRow,
+} from "../../utils/treeTableUtil";
+import { tableTreeMixins } from "../../../../mixins/tableTree/index.js";
 
 let modules = {};
 const baseRefUtil = {
@@ -148,9 +163,17 @@ modules = {
       dynamicTableColumns: [],
       dynamicColumnsPreloaded: false,
       dynamicColumnsInitResolved: false,
-      dynamicColumnsInitSkipped: false,
-      // 列/网格未就绪时 setValue 只缓存数据，置此标志延后行 schema 构建
-      pendingSchemaInit: false,
+      dynamicColumnsInitSkipped: false,
+      resolvedTreeConfig: null,
+      resolvedTreeIdentityConfig: null,
+      resolvedTreeCopyConfig: null,
+      resolvedTreeSubmitConfig: null,
+      treeTemporaryKeyRegistry: new Set(),
+      treeKnownFormalKeyRegistry: new Set(),
+      treeSingleSavePending: false,
+      treeSingleSaveReconcileTask: null,
+      // 列/网格未就绪时 setValue 只缓存数据，置此标志延后行 schema 构建
+      pendingSchemaInit: false,
     };
   },
   watch: {
@@ -608,16 +631,22 @@ modules = {
       this.initRowIdData(true);
       this.initFieldSchemaData();
     },
-    /** @param {Array} val 外部传入数据。@returns {Array} 表单与 VXE 共用的标准化行。 */
-    initValue(val) {
-      // this.clearRowWidgets()
-      let rows = this.normalizeTableRows(val || [], false);
-      // this.handleNullValue(rows);
-      rows.forEach((row, index) => {
-        row._X_ROW_KEY = "row_" + generateId();
-      });
-      this.formModel[this.fieldKeyName] = rows;
-      this.fieldModel = rows;
+    /** @param {Array} val 外部传入数据。@returns {Array} 表单与 VXE 共用的标准化行。 */
+    initValue(val) {
+      // this.clearRowWidgets()
+      if (this.widget.options.isTreeTable) {
+        this.treeTemporaryKeyRegistry.clear();
+        this.treeKnownFormalKeyRegistry.clear();
+      }
+      let rows = this.canonicalizeTreeRows(val || []);
+      rows = this.normalizeTableRows(rows, false);
+      // this.handleNullValue(rows);
+      rows.forEach((row) => {
+        row._X_ROW_KEY = "row_" + generateId();
+      });
+      this.registerTreeKeys(rows);
+      this.formModel[this.fieldKeyName] = rows;
+      this.fieldModel = rows;
       this.initRowIdData(true);
       this.initFieldSchemaData(true);
       return rows;
@@ -627,33 +656,38 @@ modules = {
      * @param {Array} rows 原始行数据。
      * @returns {Array|undefined} 根节点优先、子节点紧随父节点的扁平数组。
      */
-    handleTreeData(rows) {
-      let isTreeTable = this.widget.options.isTreeTable;
-      if (isTreeTable) {
-        let $grid = this.getGridTable();
-        if (!$grid) return rows;
-        let parentField = $grid.treeConfig.parentField;
-        if (parentField) {
+    handleTreeData(rows) {
+      let isTreeTable = this.widget.options.isTreeTable;
+      if (isTreeTable) {
+        let $grid = this.getGridTable();
+        rows = this.canonicalizeTreeRows(rows || [], $grid);
+        let { rowField, parentField } = this.getTreeFields($grid);
+        if (parentField) {
           // 构建树结构并排序
           let sortedRows = [];
           let nodeMap = new Map();
 
-          // 第一步：构建节点映射
-          rows.forEach((row) => {
-            if (row.id !== undefined && row.id !== null) {
-              nodeMap.set(row.id, row);
-            }
-          });
+          // 第一步：构建节点映射
+          rows.forEach((row) => {
+            if (row[rowField] !== undefined && row[rowField] !== null) {
+              nodeMap.set(row[rowField], row);
+            }
+          });
 
           // 第二步：按层次排序，先根节点，然后子节点
           rows.forEach((row) => {
-            let parentValue = row[parentField];
-            // 根节点（parentField为null、undefined、空字符串、0或"0"）
-            if ([null, undefined, "", 0, "0"].includes(parentValue)) {
-              sortedRows.push(row);
-              // 递归添加子节点
-              this.addChildNodes(row.id, nodeMap, parentField, sortedRows);
-            }
+            let parentValue = row[parentField];
+            // 根节点读取口径统一由树工具维护。
+            if (isRootParent(parentValue)) {
+              sortedRows.push(row);
+              // 递归添加子节点
+              this.addChildNodes(
+                row[rowField],
+                nodeMap,
+                parentField,
+                sortedRows
+              );
+            }
           });
 
           // 如果没有找到根节点，返回原始数组
@@ -678,21 +712,12 @@ modules = {
       return rows;
     },
     /** @param {*} parentId 父节点 id。@param {Map} nodeMap 节点映射。@param {String} parentField 父字段。@param {Array} sortedRows 输出数组。 */
-    addChildNodes(parentId, nodeMap, parentField, sortedRows) {
-      // 遍历所有节点，找出当前父节点的子节点
-      for (let [id, node] of nodeMap.entries()) {
-        // 处理parentField值的类型转换，确保比较正确
-        let nodeParentValue = node[parentField];
-        let targetParentId = parentId;
-
-        // 转换为相同类型进行比较
-        if (typeof nodeParentValue !== typeof targetParentId) {
-          nodeParentValue = String(nodeParentValue);
-          targetParentId = String(targetParentId);
-        }
-
-        if (nodeParentValue === targetParentId) {
-          sortedRows.push(node);
+    addChildNodes(parentId, nodeMap, parentField, sortedRows) {
+      // 遍历所有节点，找出当前父节点的子节点
+      for (let [id, node] of nodeMap.entries()) {
+        let nodeParentValue = node[parentField];
+        if (treeKeyEquals(nodeParentValue, parentId)) {
+          sortedRows.push(node);
           // 递归添加子节点的子节点
           this.addChildNodes(id, nodeMap, parentField, sortedRows);
         }
@@ -704,7 +729,7 @@ modules = {
      * @param {Boolean} defaultValueEnabled 是否应用字段默认值。
      * @returns {Array} 标准化后的新数组。
      */
-    normalizeTableRows(rows, defaultValueEnabled = false) {
+    normalizeTableRows(rows, defaultValueEnabled = false) {
       if (!Array.isArray(rows) || !rows.length) {
         return rows || [];
       }
@@ -720,17 +745,44 @@ modules = {
           nextRow._X_ROW_KEY = "row_" + generateId();
         }
         return nextRow;
-      });
-    },
+      });
+    },
+    /**
+     * 树数据进入 VXE 前统一转换为唯一平铺模型；非树表保持原样。
+     * @param {Array} rows 原始平铺或嵌套数据。
+     * @param {Object} $grid 可选的 VXE Grid。
+     * @returns {Array} 规范化后的行数组。
+     */
+    canonicalizeTreeRows(rows, $grid) {
+      if (!this.widget.options.isTreeTable) {
+        return rows || [];
+      }
+      let treeConfig = this.resolvedTreeConfig
+        || $grid?.treeConfig
+        || $grid?.params?.originOption?.config?.treeConfig;
+      if (!treeConfig) {
+        return rows || [];
+      }
+      let context = this.getTreeContext($grid);
+      let nextRows = canonicalizeTreeInput(rows || [], context);
+      this.registerTreeKeys(nextRows, context);
+      return nextRows;
+    },
     /**
      * 全量替换表格数据并重建行级 schema。
-     * 注意：该操作会触发 vxe-grid 重载，不用于编辑表的临时新增、保存或删除。
+     * 注意：该操作会触发 vxe-grid 重载；编辑表仅在服务端正式身份回填后使用。
      * @param {Array} val 新的完整数据集。
      */
-    setValue(val) {
-      // console.log("rows:",val);
-      this.clearRowWidgets();
-      let rows = this.normalizeTableRows(val || [], false);
+    setValue(val) {
+      // console.log("rows:",val);
+      this.clearRowWidgets();
+      if (this.widget.options.isTreeTable) {
+        this.treeTemporaryKeyRegistry.clear();
+        this.treeKnownFormalKeyRegistry.clear();
+      }
+      let rows = this.canonicalizeTreeRows(val || []);
+      rows = this.normalizeTableRows(rows, false);
+      this.registerTreeKeys(rows);
       this.formModel[this.fieldKeyName] = rows;
       let $grid = this.getGridTable();
       this.fieldModel = rows;
@@ -2084,15 +2136,15 @@ modules = {
             this.widget.options.editDefaultRow
           );
         }
-        treeNodeParam = (row) => {
-          return {
-            [this.widget.options.parentField]: row.id,
-          };
-        };
         treeConfig = {
           lazy: false,
-          children: "f_children",
-          hasChild: "f_has_child", // 设置是否有子节点标识
+          // 树表主键列显式声明为唯一事实源：vxe transform 建树(toArrayTree)
+          // 以 rowField 为 key，父子关联代码一律经 getTreeFields 取列名，
+          // 不允许在别处写死 id，否则配置变化时两条链分叉、层级错乱。
+          rowField: "id",
+          children: "f_children",
+          mapChildren: "_X_ROW_CHILD",
+          hasChild: "f_has_child", // 设置是否有子节点标识
           parentField: "f_parent",
           transform: true,
           expandAll: true,
@@ -2101,18 +2153,18 @@ modules = {
           // 恢复展开状态（克隆保留该键），查询重载会重新生成键，互不干扰。
           reserve: true,
           loadMethod: ({ $table, row }) => {
-            // 模拟后台接口
-            let $grid = that.getGridTable();
-            let parentField = $grid.treeConfig.parentField;
+            // 模拟后台接口
+            let $grid = that.getGridTable();
+            let { rowField, parentField } = that.getTreeFields($grid);
             return new Promise((resolve, reject) => {
               let treeParam = tableConfig?.treeNodeParam;
               let reqPram = {};
               if (treeParam) {
                 reqPram = treeParam(row) || {};
-              }
-              Object.assign(reqPram, {
-                [parentField]: row.id,
-              });
+              }
+              Object.assign(reqPram, {
+                [parentField]: row[rowField],
+              });
               let accessParam = that.getAccessParam() || {};
               let defaultOption = that.getHttpConfigForUser();
               that.formHttp({
@@ -2126,62 +2178,126 @@ modules = {
                     ...otherParam,
                     ...accessParam,
                   },
-                },
-                callback: (res) => {
-                  if (res.type === "success") {
-                    let items = this.handleTreeData(
-                      res.objx?.records || res.objx || []
-                    );
-                    if (res.objx?.records !== undefined) {
-                      res.objx.records = items;
-                    } else {
-                      res.objx = items;
-                    }
-                    let rows = res.objx
-                      ? res.objx.records || res.objx || []
-                      : [];
-                    // let rows = res.objx
-                    //   ? res.objx.records || res.objx || []
-                    //   : [];
-                    // that.handleNullValue(rows);
-                    that.initExportFieldSchemaData(rows);
-                    /* rows.forEach((row, index) => {
-                      if (!row._X_ROW_KEY) {
-                        row._X_ROW_KEY = "row_" + generateId();
-                      }
-                    }); */
-
-                    let hasChildField = $grid.treeConfig.hasChild;
-                    if (row[hasChildField] && !rows.length) {
-                      row[hasChildField] = false;
-                    }
-
-                    resolve(rows);
-                    /* let treeCallback = tableConfig?.treeCallback;
-                    if (treeCallback) {
-                      that.$nextTick(() => {
-                        setTimeout(function () {
-                          treeCallback(rows);
-                        }, 0);
-                      });
-                    } */
-                    that.$nextTick(() => {
-                      setTimeout(function () {
-                        dataTableConfig.callback &&
-                          dataTableConfig.callback(rows);
-                        tableOption.callback && tableOption.callback(rows);
-                        tableConfig.treeCallback &&
-                          tableConfig.treeCallback(rows);
-                      }, 0);
-                    });
-                  } else {
-                    reject(res);
-                  }
+                },
+                callback: (res) => {
+                  if (res.type === "success") {
+                    let rows;
+                    try {
+                      let treeContext = that.getTreeContext($grid);
+                      rows = canonicalizeTreeInput(
+                        res.objx?.records || res.objx || [],
+                        treeContext
+                      );
+                      rows.forEach((childRow) => {
+                        let parentValue = childRow[parentField];
+                        if (isRootParent(parentValue)) {
+                          childRow[parentField] = row[rowField];
+                          return;
+                        }
+                        if (treeKeyEquals(parentValue, row[rowField])) {
+                          childRow[parentField] = row[rowField];
+                          return;
+                        }
+                        let batchParent = rows.find((item) =>
+                          treeKeyEquals(item[rowField], parentValue)
+                        );
+                        if (!batchParent) {
+                          throw new Error(
+                            `懒加载节点 ${childRow[rowField]} 的父键 ${parentValue} 与请求父节点不一致`
+                          );
+                        }
+                        childRow[parentField] = batchParent[rowField];
+                      });
+
+                      let currentRows
+                        = that.formModel[that.fieldKeyName] || [];
+                      let currentCanonical = canonicalizeTreeInput(
+                        currentRows,
+                        treeContext
+                      );
+                      rows.forEach((childRow) => {
+                        if (
+                          currentCanonical.some((item) =>
+                            treeKeyEquals(
+                              item[rowField],
+                              childRow[rowField]
+                            )
+                          )
+                        ) {
+                          throw new Error(
+                            `懒加载节点 ${childRow[rowField]} 已存在`
+                          );
+                        }
+                      });
+                      let candidateRows = canonicalizeTreeInput(
+                        currentRows.concat(rows),
+                        treeContext
+                      );
+                      let newRowKeys = new Set(
+                        rows.map((item) =>
+                          normalizeTreeKey(item[rowField])
+                        )
+                      );
+                      // canonicalizeTreeInput 已深克隆并移除 children /
+                      // mapChildren。formModel 只保存这份扁平快照，不能重新
+                      // 填回 VXE 的活动行对象，否则其内部树容器会泄漏到提交数据。
+                      let canonicalRows = candidateRows;
+                      rows = canonicalRows.filter((item) =>
+                        newRowKeys.has(normalizeTreeKey(item[rowField]))
+                      );
+                      that.initExportFieldSchemaData(rows);
+                      that.formModel[that.fieldKeyName] = canonicalRows;
+                      that.registerTreeKeys(rows, treeContext);
+                    } catch (error) {
+                      reject(error);
+                      return;
+                    }
+
+                    if (res.objx?.records !== undefined) {
+                      res.objx.records = rows;
+                    } else {
+                      res.objx = rows;
+                    }
+
+                    let hasChildField = $grid.treeConfig.hasChild;
+                    if (row[hasChildField] && !rows.length) {
+                      row[hasChildField] = false;
+                    }
+
+                    resolve(rows);
+                    /* let treeCallback = tableConfig?.treeCallback;
+                    if (treeCallback) {
+                      that.$nextTick(() => {
+                        setTimeout(function () {
+                          treeCallback(rows);
+                        }, 0);
+                      });
+                    } */
+                    that.$nextTick(() => {
+                      setTimeout(function () {
+                        dataTableConfig.callback &&
+                          dataTableConfig.callback(rows);
+                        tableConfig.treeCallback &&
+                          tableConfig.treeCallback(rows);
+                      }, 0);
+                    });
+                  } else {
+                    reject(res);
+                  }
                 },
               });
             });
           },
         };
+        // 懒加载子节点的请求参数：父键/主键列名取自 treeConfig。
+        // （此前误读 widget.options.parentField——该选项不存在，恒为 undefined，
+        // 会生成 {undefined: id} 的脏参数）
+        treeNodeParam = (row) => {
+          let fields = this.getTreeFields();
+          return {
+            [fields.parentField]: row[fields.rowField],
+          };
+        };
       }
       let editOpts = {};
       if (this.widget.options.isEditTable) {
@@ -2334,7 +2450,30 @@ modules = {
         rowConfig.height = this.widget.options.tableRowHeight;
       }
 
-      tableOption = {
+      // 宿主经 dataTableOption.config 覆写时，treeConfig 必须深合并而不是整体
+      // 替换：宿主通常只想改单个键（如 expandAll），整体替换会把 rowField/
+      // parentField/children 一并丢掉，使树主键链与建树逻辑分叉。
+      // 不直接改 dataTableConfig——它是宿主经 $attrs 传入的对象。
+      let hostTableConfig = dataTableConfig.config || {};
+      if (treeConfig && hostTableConfig.treeConfig) {
+        hostTableConfig = {
+          ...hostTableConfig,
+          treeConfig: { ...treeConfig, ...hostTableConfig.treeConfig },
+        };
+      }
+      let hostTreeIdentityConfig = {
+        ...(dataTableConfig.otherConfig?.treeIdentityConfig || {}),
+        ...(dataTableConfig.treeIdentityConfig || {}),
+      };
+      let hostTreeCopyConfig = {
+        ...(dataTableConfig.otherConfig?.treeCopyConfig || {}),
+        ...(dataTableConfig.treeCopyConfig || {}),
+      };
+      let hostTreeSubmitConfig = {
+        ...(dataTableConfig.otherConfig?.treeSubmitConfig || {}),
+        ...(dataTableConfig.treeSubmitConfig || {}),
+      };
+      tableOption = {
         // vue: this,
         tableRef: tableRef,
         tableName: this.getGridTableName(),
@@ -2345,11 +2484,18 @@ modules = {
         isQueryAllPage,
         exportItemConfig,
         vform: true,
-        ...(this.getDynamicColumnSourceType() !== "none"
-          ? { visibleSync: false }
-          : {}),
-        ...(dataTableConfig.otherConfig || {}),
-        config: {
+        ...(this.getDynamicColumnSourceType() !== "none"
+          ? { visibleSync: false }
+          : {}),
+        ...(dataTableConfig.otherConfig || {}),
+        ...(isTreeTable
+          ? {
+              treeIdentityConfig: hostTreeIdentityConfig,
+              treeCopyConfig: hostTreeCopyConfig,
+              treeSubmitConfig: hostTreeSubmitConfig,
+            }
+          : {}),
+        config: {
           height: height,
           showFooter,
           pagerConfig,
@@ -2357,7 +2503,7 @@ modules = {
           rowConfig,
           headerCellStyle,
           ...editOpts,
-          ...dataTableConfig.config,
+          ...hostTableConfig,
 
           /*rowConfig:{
             height: 40
@@ -2503,19 +2649,26 @@ modules = {
                       if (res.type === "success") {
                         if (that.widget.options.isTreeTable) {
                           if (rows.length > 0) {
-                            let fullAllDataRowMap =
-                              $grid.$refs.xTable.fullAllDataRowMap;
-                            let parentField = $grid.treeConfig.parentField;
+                            let fullAllDataRowMap =
+                              $grid.$refs.xTable.fullAllDataRowMap;
+                            let treeFields = that.getTreeFields($grid);
+                            let rowField = treeFields.rowField;
+                            let parentField = treeFields.parentField;
                             let expandAll = $grid.treeConfig.expandAll || false;
-                            let isLazy = $grid.treeConfig.lazy;
-                            let expandIds = rows
-                              .filter((item) => item[parentField])
-                              .map((item) => item[parentField]);
-                            let expandRows = expandIds.length
-                              ? rows.filter((item) =>
-                                  expandIds.includes(item.id)
-                                )
-                              : [];
+                            let isLazy = $grid.treeConfig.lazy;
+                            let expandIds = rows
+                              .filter(
+                                (item) =>
+                                  !isRootParent(item[parentField])
+                              )
+                              .map((item) => item[parentField]);
+                            let expandRows = expandIds.length
+                              ? rows.filter((item) =>
+                                  expandIds.some((id) =>
+                                    treeKeyEquals(id, item[rowField])
+                                  )
+                                )
+                              : [];
                             if (expandAll && expandRows.length) {
                               that.$nextTick(() => {
                                 setTimeout(function () {
@@ -2538,11 +2691,16 @@ modules = {
                               });
                             }
 
-                            let row = rows.find((item) => !item[parentField]);
-                            if (
-                              row &&
-                              (!expandAll || !expandIds.includes(row.id))
-                            ) {
+                            let row = rows.find((item) =>
+                              isRootParent(item[parentField])
+                            );
+                            if (
+                              row
+                              && (!expandAll
+                                || !expandIds.some((id) =>
+                                  treeKeyEquals(id, row[rowField])
+                                ))
+                            ) {
                               let hasChild = $grid.treeConfig.hasChild;
                               if (row[hasChild]) {
                                 that.$nextTick(() => {
@@ -2590,17 +2748,63 @@ modules = {
             },
           },
         };
-        tableOption.callback = (rows) => {
-          // this.fieldModel = rows;
-          this.formModel[this.fieldKeyName] = rows;
-        };
-      }
-
-      if (isTreeTable) {
-        tableOption.filterType = false;
-      }
-      tableOption = extendDeeply(tableOption, tableConfig);
-      /* if (this.widget.options.tableConfig) {
+        tableOption.callback = (rows) => {
+          // this.fieldModel = rows;
+          this.formModel[this.fieldKeyName] = rows;
+        };
+      }
+
+      if (isTreeTable) {
+        tableOption.filterType = false;
+      }
+      tableOption = extendDeeply(tableOption, tableConfig);
+      if (isTreeTable) {
+        let mergedTreeConfig = {
+          ...(tableOption.config?.treeConfig || {}),
+        };
+        if (mergedTreeConfig.transform !== true) {
+          // eslint-disable-next-line no-console
+          console.error(
+            "[xform tree-table] transform 必须为 true，已恢复为规范平铺模式。"
+          );
+        }
+        mergedTreeConfig.transform = true;
+        let resolvedFields = resolveTreeFields(mergedTreeConfig, {
+          strict: true,
+        });
+        let resolvedTreeConfig = {
+          ...mergedTreeConfig,
+          rowField: resolvedFields.rowField,
+          parentField: resolvedFields.parentField,
+          children: resolvedFields.childrenField,
+          mapChildren: resolvedFields.mapChildrenField,
+          hasChild: resolvedFields.hasChildField,
+          lazy: resolvedFields.lazy,
+          transform: true,
+        };
+        let resolvedIdentityConfig = resolveTreeIdentityConfig(
+          resolvedTreeConfig,
+          tableOption.treeIdentityConfig || {}
+        );
+        let resolvedCopyConfig = resolveTreeCopyConfig(
+          resolvedFields,
+          resolvedIdentityConfig,
+          tableOption.treeCopyConfig || {}
+        );
+        let resolvedSubmitConfig = resolveTreeSubmitConfig(
+          tableOption.treeSubmitConfig || {}
+        );
+
+        this.resolvedTreeConfig = resolvedTreeConfig;
+        this.resolvedTreeIdentityConfig = resolvedIdentityConfig;
+        this.resolvedTreeCopyConfig = resolvedCopyConfig;
+        this.resolvedTreeSubmitConfig = resolvedSubmitConfig;
+        tableOption.config.treeConfig = resolvedTreeConfig;
+        tableOption.treeIdentityConfig = resolvedIdentityConfig;
+        tableOption.treeCopyConfig = resolvedCopyConfig;
+        tableOption.treeSubmitConfig = resolvedSubmitConfig;
+      }
+      /* if (this.widget.options.tableConfig) {
         let tableConfig =
           this.handleCustomEvent(this.widget.options.tableConfig) || {};
         tableOption = extendDeeply(tableOption, tableConfig);
@@ -2658,10 +2862,15 @@ modules = {
       if (mergeRowEnabled && unikey) {
         tableOption.config.spanMethod = this.mergeRowMethod;
       }
-      this.$vxeTableUtil.initVxeTable(tableOption).then((opts) => {
-        this.vxeOption = opts;
-        this.applyCompareRowClassName();
-        // 列已就绪，补建 created 阶段被延后的行 schema
+      this.$vxeTableUtil.initVxeTable(tableOption).then((opts) => {
+        this.vxeOption = opts;
+        this.applyCompareRowClassName();
+        if (isTreeTable) {
+          this.$nextTick(() => {
+            this.validateResolvedTreeConfig(this.getGridTable());
+          });
+        }
+        // 列已就绪，补建 created 阶段被延后的行 schema
         this.flushPendingSchemaInit();
         this.tryAutoLoadDynamicColumns().finally(() => {
           if (!isQueryTable) {
@@ -3341,6 +3550,411 @@ modules = {
       let $grid = this.$refs[this.getTableRef()];
       return $grid;
     },
+    /**
+     * 树表字段统一读取口。rowField 是树关系键，idField 仅作为旧调用方别名保留。
+     * @param {Object} $grid VXE Grid 实例；缺省取当前组件的表格。
+     * @returns {Object} 解析后的树字段以及兼容别名 idField。
+     */
+    getTreeFields($grid) {
+      let grid = $grid || this.getGridTable();
+      let treeConfig = this.resolvedTreeConfig
+        || grid?.treeConfig
+        || grid?.params?.originOption?.config?.treeConfig
+        || {};
+      let fields = resolveTreeFields(treeConfig, {
+        strict: !!this.widget.options.isTreeTable,
+      });
+      return {
+        ...fields,
+        // 兼容存量调用；新增代码只使用 rowField。
+        idField: fields.rowField,
+      };
+    },
+    /**
+     * 汇总当前树表纯函数所需上下文。挂载后优先读取 originOption 中的已解析配置。
+     * @param {Object} $grid 可选的 VXE Grid。
+     * @param {Object} extra 调用场景附加上下文。
+     * @returns {Object} 树工具上下文。
+     */
+    getTreeContext($grid, extra) {
+      let grid = $grid || this.getGridTable();
+      let originOption = grid?.params?.originOption || grid?.originOption || {};
+      let treeConfig = this.resolvedTreeConfig
+        || grid?.treeConfig
+        || originOption.config?.treeConfig
+        || {};
+      let fields = this.getTreeFields(grid);
+      let identityConfig = this.resolvedTreeIdentityConfig
+        || originOption.treeIdentityConfig
+        || resolveTreeIdentityConfig(treeConfig, {});
+      let copyConfig = this.resolvedTreeCopyConfig
+        || originOption.treeCopyConfig
+        || resolveTreeCopyConfig(fields, identityConfig, {});
+      let submitConfig = this.resolvedTreeSubmitConfig
+        || originOption.treeSubmitConfig
+        || resolveTreeSubmitConfig({});
+      return {
+        treeConfig,
+        fields,
+        identityConfig,
+        copyConfig,
+        submitConfig,
+        temporaryKeyRegistry: this.treeTemporaryKeyRegistry,
+        knownFormalKeyRegistry: this.treeKnownFormalKeyRegistry,
+        ...(extra || {}),
+      };
+    },
+    /**
+     * VXE 挂载后确认实际字段没有偏离初始化阶段唯一解析结果。
+     * @param {Object} $grid VXE Grid。
+     * @returns {Boolean} 校验通过或尚未挂载。
+     */
+    validateResolvedTreeConfig($grid) {
+      if (!$grid || !this.resolvedTreeConfig) {
+        return true;
+      }
+      let actual = resolveTreeFields($grid.treeConfig || {}, {
+        strict: true,
+      });
+      let expected = resolveTreeFields(this.resolvedTreeConfig, {
+        strict: true,
+      });
+      let fieldNames = [
+        "rowField",
+        "parentField",
+        "childrenField",
+        "mapChildrenField",
+        "hasChildField",
+      ];
+      let mismatch = fieldNames.filter(
+        (name) => actual[name] !== expected[name]
+      );
+      if (
+        mismatch.length
+        || $grid.treeConfig?.transform !== true
+      ) {
+        throw new Error(
+          `[xform tree-table] VXE 树配置与 resolvedTreeConfig 不一致：${mismatch.join(
+            ", "
+          ) || "transform"}`
+        );
+      }
+      return true;
+    },
+    /**
+     * 记录当前表已知的临时键和正式键，供单行保存的外部父引用守卫使用。
+     * @param {Array} rows 规范平铺行。
+     * @param {Object} context 可选树上下文。
+     */
+    registerTreeKeys(rows, context) {
+      if (!this.widget.options.isTreeTable || !Array.isArray(rows)) {
+        return;
+      }
+      let grid = this.getGridTable();
+      if (
+        !context
+        && !grid?.treeConfig
+        && !this.resolvedTreeConfig
+      ) {
+        return;
+      }
+      let treeContext = context || this.getTreeContext();
+      let { rowField, parentField } = treeContext.fields;
+      rows.forEach((row) => {
+        if (!row) return;
+        let rowValue = row[rowField];
+        if (isTemporaryTreeKey(row, rowField, treeContext.identityConfig)) {
+          this.treeTemporaryKeyRegistry.add(rowValue);
+        } else if (!isRootParent(rowValue)) {
+          this.treeKnownFormalKeyRegistry.add(rowValue);
+        }
+        let parentValue = row[parentField];
+        if (
+          !isRootParent(parentValue)
+          && !this.registryHasTreeKey(
+            this.treeTemporaryKeyRegistry,
+            parentValue
+          )
+        ) {
+          this.treeKnownFormalKeyRegistry.add(parentValue);
+        }
+      });
+    },
+    /** @param {Set} registry 键注册表。@param {*} value 待匹配值。 */
+    registryHasTreeKey(registry, value) {
+      if (!registry || isRootParent(value)) {
+        return false;
+      }
+      return Array.from(registry).some((item) =>
+        treeKeyEquals(item, value)
+      );
+    },
+    /** @param {Set} registry 键注册表。@param {*} value 待注销值。 */
+    unregisterTreeKey(registry, value) {
+      if (!registry) return;
+      Array.from(registry).forEach((item) => {
+        if (treeKeyEquals(item, value)) {
+          registry.delete(item);
+        }
+      });
+    },
+    /**
+     * 确保新增树行具有有效关系键；只有实际生成临时值时才写临时标记。
+     * @param {Object} row 新行。
+     * @param {Object} context 树上下文。
+     * @returns {*} 最终 rowField 值。
+     */
+    ensureNewTreeRowKey(row, context) {
+      let treeContext = context || this.getTreeContext();
+      let rowField = treeContext.fields.rowField;
+      let rowValue = row[rowField];
+      let isMarkedTemporary = isTemporaryTreeKey(
+        row,
+        rowField,
+        treeContext.identityConfig
+      );
+      if (
+        isRootParent(rowValue)
+        || (rowField === treeContext.identityConfig.physicalIdField
+          && !isMarkedTemporary)
+      ) {
+        rowValue = makeTreeTempKey();
+        markTemporaryTreeKey(row, rowField, rowValue);
+      } else if (
+        row._X_TREE_TEMP_KEY != null
+        && !treeKeyEquals(row._X_TREE_TEMP_KEY, rowValue)
+      ) {
+        delete row._X_TREE_TEMP_KEY;
+      }
+      if (isTemporaryTreeKey(row, rowField, treeContext.identityConfig)) {
+        this.treeTemporaryKeyRegistry.add(rowValue);
+      } else {
+        this.treeKnownFormalKeyRegistry.add(rowValue);
+      }
+      return rowValue;
+    },
+    /**
+     * 在修改当前表数组前验证新增行不会造成树键冲突、父边冲突或环。
+     * @param {Array} rows 待插入行。
+     * @param {Object} context 树上下文。
+     */
+    validateNewTreeRows(rows, context) {
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+      canonicalizeTreeInput(tableRows.concat(rows || []), context);
+    },
+    /**
+     * 树关系键变更唯一入口。负责持久化策略、唯一性、临时标记和直接子引用同步。
+     * 业务选择器可直接 await 调用；单行保存也会用编辑快照兜底调用。
+     * @param {Object} row 当前行。
+     * @param {*} newValue 新树键。
+     * @param {Object} options 可传 oldValue、$grid 和 reason。
+     * @returns {Promise<Object>} 变更结果。
+     */
+    async changeTreeRowField(row, newValue, options = {}) {
+      if (!this.widget.options.isTreeTable || !row) {
+        return { changed: false, transactional: false };
+      }
+      let $grid = options.$grid || this.getGridTable();
+      let context = this.getTreeContext($grid);
+      let { rowField } = context.fields;
+      let hasExplicitOldValue = Object.prototype.hasOwnProperty.call(
+        options,
+        "oldValue"
+      );
+      let oldValue = hasExplicitOldValue
+        ? options.oldValue
+        : row[rowField];
+      if (
+        !hasExplicitOldValue
+        && row._X_TREE_TEMP_KEY != null
+        && !treeKeyEquals(row._X_TREE_TEMP_KEY, newValue)
+      ) {
+        oldValue = row._X_TREE_TEMP_KEY;
+      }
+      let rejectChange = async (messageOrError) => {
+        row[rowField] = oldValue;
+        if ($grid?.updateData) {
+          await $grid.updateData();
+        }
+        throw messageOrError instanceof Error
+          ? messageOrError
+          : new Error(messageOrError);
+      };
+      if (isRootParent(newValue)) {
+        return rejectChange(`${rowField} 不能为空或根哨兵值。`);
+      }
+      if (treeKeyEquals(oldValue, newValue)) {
+        row[rowField] = newValue;
+        if (
+          row._X_TREE_TEMP_KEY != null
+          && !treeKeyEquals(row._X_TREE_TEMP_KEY, newValue)
+        ) {
+          delete row._X_TREE_TEMP_KEY;
+        }
+        return { changed: false, transactional: false };
+      }
+
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+      let conflict = tableRows.some(
+        (item) =>
+          item !== row
+          && treeKeyEquals(item?.[rowField], newValue)
+      );
+      if (conflict) {
+        return rejectChange(`树键 ${newValue} 已存在。`);
+      }
+
+      let physicalIdField = context.identityConfig.physicalIdField;
+      let physicalId = row[physicalIdField];
+      let persisted = physicalId !== undefined
+        && physicalId !== null
+        && physicalId !== "";
+      if (
+        physicalIdField === rowField
+        && treeKeyEquals(physicalId, oldValue)
+        && isTemporaryTreeKey(
+          {
+            ...row,
+            [rowField]: oldValue,
+          },
+          rowField,
+          context.identityConfig
+        )
+      ) {
+        persisted = false;
+      }
+
+      let transactional = false;
+      if (physicalIdField === rowField) {
+        return rejectChange(
+          persisted
+            ? "已持久化的物理主键不可修改。"
+            : "物理主键兼作树键时只能由保存响应回填正式值。"
+        );
+      }
+      if (persisted) {
+        if (
+          context.identityConfig
+            .persistedRowFieldChangeStrategy !== "transactional"
+        ) {
+          return rejectChange("已持久化节点的树键不允许直接修改。");
+        }
+        let changeHandler = context.identityConfig.changePersistedRowField;
+        try {
+          let result = await changeHandler({
+            row: this.$baseLodash.cloneDeep(row),
+            oldValue,
+            newValue,
+            fields: context.fields,
+            reason: options.reason || "edit",
+          });
+          if (result === false) {
+            throw new Error("树键事务更新未成功。");
+          }
+          transactional = true;
+        } catch (error) {
+          return rejectChange(error);
+        }
+      }
+
+      row[rowField] = newValue;
+      syncTreeKeyReferences(tableRows, oldValue, newValue, {
+        fields: context.fields,
+      });
+      delete row._X_TREE_TEMP_KEY;
+      this.unregisterTreeKey(
+        this.treeTemporaryKeyRegistry,
+        oldValue
+      );
+      this.treeKnownFormalKeyRegistry.add(newValue);
+      if ($grid?.updateData) {
+        await $grid.updateData();
+      }
+      if (transactional) {
+        let formRef = this.getFormRef();
+        let reloadMethod
+          = typeof formRef?.reloadSavedFormData === "function"
+          ? formRef.reloadSavedFormData
+          : formRef?.reloadForm;
+        if (typeof reloadMethod === "function") {
+          try {
+            await reloadMethod.call(formRef);
+          } catch (error) {
+            let reloadError = error instanceof Error
+              ? error
+              : new Error(error || "树表重新加载失败。");
+            reloadError.treeReloadFailed = true;
+            throw reloadError;
+          }
+        }
+      }
+      return { changed: true, transactional };
+    },
+    /**
+     * 单行保存前确认父节点已持久化，或外部父键已被登记为正式键。
+     * @param {Object} row 当前行。
+     * @param {Object} $grid VXE Grid。
+     * @returns {String|null} 阻断原因。
+     */
+    getTreeSingleSaveBlockReason(row, $grid) {
+      if (!this.widget.options.isTreeTable || !row) {
+        return null;
+      }
+      let context = this.getTreeContext($grid);
+      let { rowField, parentField } = context.fields;
+      let parentValue = row[parentField];
+      if (isRootParent(parentValue)) {
+        return null;
+      }
+      let tableRows = this.formModel[this.fieldKeyName] || [];
+      let parentRow = tableRows.find(
+        (item) =>
+          item && treeKeyEquals(item[rowField], parentValue)
+      );
+      if (parentRow) {
+        let physicalId = parentRow[context.identityConfig.physicalIdField];
+        if (
+          physicalId == null
+          || physicalId === ""
+          || isTemporaryTreeKey(
+            parentRow,
+            rowField,
+            context.identityConfig
+          )
+        ) {
+          return "请先保存父节点，再保存当前子节点。";
+        }
+        return null;
+      }
+      if (
+        this.registryHasTreeKey(
+          this.treeTemporaryKeyRegistry,
+          parentValue
+        )
+      ) {
+        return "当前行引用了尚未保存的父节点，请先保存父节点。";
+      }
+      if (
+        this.registryHasTreeKey(
+          this.treeKnownFormalKeyRegistry,
+          parentValue
+        )
+      ) {
+        return null;
+      }
+      let validator = context.identityConfig.validateExternalParentKey;
+      if (typeof validator === "function") {
+        let result = validator(parentValue, row, "single");
+        if (result && typeof result.then === "function") {
+          return "外部父节点校验必须同步完成。";
+        }
+        if (result === true) {
+          this.treeKnownFormalKeyRegistry.add(parentValue);
+          return null;
+        }
+      }
+      return "无法确认当前行的父节点已保存，请先保存或加载父节点。";
+    },
     /** @param {Object} e 容器组件 schema。@returns {String} 动态组件名称。 */
     getContainerWidgetName: function (e) {
       return "grid" === e.type ? "grid-item" : e.type + "-item";
@@ -3415,84 +4029,431 @@ modules = {
 
     //editTable begin
     /**
-     * 保存当前编辑行。成功后仅合并服务端字段，保留 VXE 行引用和 _X_ROW_KEY。
+     * 保存当前编辑行。持久化行原位合并；新身份以回查结果重建树关系。
      * @param {Object} obj VXE 插槽参数，必须包含 row 和 $table。
      */
-    async saveEditRow(obj) {
-      let formRef = this.getFormRef();
-      let formConfig = this.formConfig;
-      let entity = formConfig.entity;
-      if (!entity) return;
-      let dataId = formRef?.dataId;
-      let reportTemplate = formRef?.reportTemplate;
-      let formCode = reportTemplate?.formCode;
-      let scriptCode = formConfig.saveScriptCode || "saveUpdate";
-
-      let $grid = obj.$table.$xegrid;
-      let originOption = $grid.params.originOption;
-
-      let formModel = this.formModel;
-      let dataMap = this.getGridTable().getTableData();
-
-      /* const errMap = await $grid.validate(obj.row).catch(errMap => errMap)
-      if (errMap) {
-        let title = errMap[Object.keys(errMap)[0]][0].column.title
-        this.$message.error(`[${title}]不能为空`)
-        return
-      } */
-
-      formRef.validate((valid) => {
-        if (valid) {
-          $grid.clearActived().then(() => {
-            $grid.setActiveRow(obj.row);
-            let mainData = commonDataUtil.handleForm(obj.row);
-
-            delete mainData._createNickName;
-            delete mainData._createMobile;
-            delete mainData._modifyNickName;
-            delete mainData._modifyMobile;
-            delete mainData._createBy;
-            delete mainData._modifyBy;
-
-            let formData = {
-              [entity]: mainData,
-            };
-
-            Object.keys(mainData).forEach((key) => {
-              if (key.startsWith("attachments_")) {
-                formData[key] = mainData[key];
-              }
-            });
-
-            let reqData = {
-              formCode: formCode,
-              formVersion: reportTemplate.formVersion,
-              taBm: entity,
-              data: formData,
-            };
-
-            this.formHttp({
-              scriptCode: scriptCode,
-              data: reqData,
-              successMsg: true,
-              isConfirm: true,
-              confirmText: "您确定要保存吗？",
-              success: (res0) => {
-                this.getRowData(res0.objx, (res) => {
-                  $grid.clearActived().then(() => {
-                    // 保留 vxe 内部行引用和 _X_ROW_KEY，仅同步服务端字段。
-                    Object.assign(obj.row, res.objx);
-                  });
-                  delete obj.$table.editCloneRow;
-                });
-              },
-            });
-          });
-        }
-      });
-    },
-    /** @param {*} dataId 行数据 id。@param {Function} callback 查询成功回调。加载保存后的完整行。 */
-    getRowData(dataId, callback) {
+    async saveEditRow(obj) {
+      let formRef = this.getFormRef();
+      let formConfig = this.formConfig;
+      let entity = formConfig.entity;
+      if (!entity) return;
+      let reportTemplate = formRef?.reportTemplate;
+      let formCode = reportTemplate?.formCode;
+      let scriptCode = formConfig.saveScriptCode || "saveUpdate";
+
+      let $grid = obj.$table.$xegrid;
+      if (typeof this.treeSingleSaveReconcileTask === "function") {
+        return this.treeSingleSaveReconcileTask();
+      }
+      if (this.treeSingleSavePending) {
+        this.$message.warning("当前行正在保存，请勿重复操作。");
+        return false;
+      }
+      this.treeSingleSavePending = true;
+      let keepSaveLocked = false;
+      let reloadMethod
+        = typeof formRef.reloadSavedFormData === "function"
+        ? formRef.reloadSavedFormData
+        : formRef.reloadForm;
+      let installReloadRetry = () => {
+        let retryPromise = null;
+        this.treeSingleSaveReconcileTask = () => {
+          if (retryPromise) return retryPromise;
+          retryPromise = (async () => {
+            try {
+              await reloadMethod.call(formRef);
+              delete obj.$table.editCloneRow;
+              this.treeSingleSaveReconcileTask = null;
+              this.treeSingleSavePending = false;
+              return true;
+            } catch (error) {
+              this.$message.error(
+                "重新加载仍未成功，请手动刷新后再操作。"
+              );
+              return false;
+            } finally {
+              retryPromise = null;
+            }
+          })();
+          return retryPromise;
+        };
+      };
+      let isTreeTable = this.widget.options.isTreeTable || false;
+      let treeContext = isTreeTable
+        ? this.getTreeContext($grid, { mode: "single" })
+        : null;
+      let oldTreeKey = null;
+      let rebuildTreeAfterSave = false;
+      let treePhysicalIdWasMissing = false;
+      let treeKeyWasTemporary = false;
+      let treeSnapshotApplied = false;
+      let logicalRowKey = obj.row?._X_ROW_KEY || null;
+      let originalPhysicalId = null;
+      try {
+        let valid = await new Promise((resolve, reject) => {
+          try {
+            formRef.validate(resolve);
+          } catch (error) {
+            reject(error);
+          }
+        });
+        if (!valid) return false;
+
+        let requestRow = obj.row;
+        if (treeContext) {
+          let blockReason = this.getTreeSingleSaveBlockReason(
+            obj.row,
+            $grid
+          );
+          if (blockReason) {
+            this.$message.error(blockReason);
+            return false;
+          }
+          let rowField = treeContext.fields.rowField;
+          let currentTreeKey = obj.row[rowField];
+          let editCloneRow = obj.$table.editCloneRow;
+          let previousTreeKey = editCloneRow?.[rowField];
+          if (
+            obj.row._X_TREE_TEMP_KEY != null
+            && !treeKeyEquals(
+              obj.row._X_TREE_TEMP_KEY,
+              currentTreeKey
+            )
+          ) {
+            previousTreeKey = obj.row._X_TREE_TEMP_KEY;
+          }
+          if (
+            previousTreeKey !== undefined
+            && previousTreeKey !== null
+            && !treeKeyEquals(previousTreeKey, currentTreeKey)
+          ) {
+            let changeResult = await this.changeTreeRowField(
+              obj.row,
+              currentTreeKey,
+              {
+                oldValue: previousTreeKey,
+                $grid,
+                reason: "single-save",
+              }
+            );
+            if (changeResult.transactional) {
+              delete obj.$table.editCloneRow;
+              return true;
+            }
+          }
+          oldTreeKey = obj.row[rowField];
+          let physicalIdField
+            = treeContext.identityConfig.physicalIdField;
+          let physicalId = obj.row[physicalIdField];
+          originalPhysicalId = physicalId;
+          treeKeyWasTemporary = isTemporaryTreeKey(
+            obj.row,
+            rowField,
+            treeContext.identityConfig
+          );
+          treePhysicalIdWasMissing
+            = physicalId == null
+              || physicalId === ""
+              || (
+                physicalIdField === rowField
+                && treeKeyWasTemporary
+              );
+          rebuildTreeAfterSave
+            = treePhysicalIdWasMissing
+            || treeKeyWasTemporary;
+          requestRow = sanitizeTreeRow(
+            this.$baseLodash.cloneDeep(obj.row),
+            treeContext
+          );
+        }
+
+        try {
+          await this.$baseConfirm("您确定要保存吗？");
+        } catch (error) {
+          return false;
+        }
+
+        await $grid.clearActived();
+        await $grid.setActiveRow(obj.row);
+        let mainData = commonDataUtil.handleForm(requestRow);
+
+        delete mainData._createNickName;
+        delete mainData._createMobile;
+        delete mainData._modifyNickName;
+        delete mainData._modifyMobile;
+        delete mainData._createBy;
+        delete mainData._modifyBy;
+
+        let formData = {
+          [entity]: mainData,
+        };
+        Object.keys(mainData).forEach((key) => {
+          if (key.startsWith("attachments_")) {
+            formData[key] = mainData[key];
+          }
+        });
+
+        let reqData = {
+          formCode: formCode,
+          formVersion: reportTemplate.formVersion,
+          taBm: entity,
+          data: formData,
+        };
+        let saveResponse = await new Promise((resolve, reject) => {
+          let requestTask = this.formHttp({
+            scriptCode: scriptCode,
+            data: reqData,
+            successMsg: true,
+            isConfirm: false,
+            success: resolve,
+            fail: (res) => {
+              reject(new Error(res?.content || "当前行保存失败。"));
+            },
+            error: reject,
+          });
+          if (requestTask && typeof requestTask.catch === "function") {
+            requestTask.catch(reject);
+          }
+        });
+
+        let querySavedRow = () =>
+          new Promise((resolve, reject) => {
+            let requestTask = this.getRowData(
+              saveResponse.objx,
+              resolve,
+              (res) => {
+                reject(new Error(res?.content || "保存结果重新查询失败。"));
+              },
+              reject
+            );
+            if (requestTask && typeof requestTask.catch === "function") {
+              requestTask.catch(reject);
+            }
+          });
+        let reconcileSavedRow = async (rowResponse) => {
+          let responseRow = { ...(rowResponse?.objx || {}) };
+          if (treeContext) {
+            let { rowField } = treeContext.fields;
+            let physicalIdField
+              = treeContext.identityConfig.physicalIdField;
+            let hasIdentityValue = (value) =>
+              value !== null
+              && value !== undefined
+              && value !== "";
+            if (
+              treePhysicalIdWasMissing
+              && !hasIdentityValue(responseRow[physicalIdField])
+            ) {
+              throw new Error(
+                `保存响应未返回正式物理 ID 字段 ${physicalIdField}。`
+              );
+            }
+
+            let treeTableRows = this.formModel[this.fieldKeyName] || [];
+            let currentLogicalRow = null;
+            if (hasIdentityValue(logicalRowKey)) {
+              currentLogicalRow = treeTableRows.find(
+                (item) => item?._X_ROW_KEY === logicalRowKey
+              );
+            }
+            if (!currentLogicalRow && treeTableRows.includes(obj.row)) {
+              currentLogicalRow = obj.row;
+            }
+            if (!currentLogicalRow) {
+              let physicalCandidates = [
+                originalPhysicalId,
+                responseRow[physicalIdField],
+                obj.row?.[physicalIdField],
+              ].filter(hasIdentityValue);
+              currentLogicalRow = treeTableRows.find(
+                (item) =>
+                  item
+                  && physicalCandidates.some((physicalId) =>
+                    treeKeyEquals(
+                      item[physicalIdField],
+                      physicalId
+                    )
+                  )
+              );
+            }
+            if (!currentLogicalRow) {
+              throw new Error("无法定位保存响应对应的当前树表行。");
+            }
+            if (!hasIdentityValue(logicalRowKey)) {
+              logicalRowKey = currentLogicalRow._X_ROW_KEY || null;
+            }
+            obj.row = currentLogicalRow;
+
+            let responseHasTreeKey = Object.prototype.hasOwnProperty.call(
+              responseRow,
+              rowField
+            );
+            let nextTreeKey = responseHasTreeKey
+              ? responseRow[rowField]
+              : currentLogicalRow[rowField];
+            let wasTemporary
+              = treeKeyWasTemporary
+                || isTemporaryTreeKey(
+                  currentLogicalRow,
+                  rowField,
+                  treeContext.identityConfig
+                );
+            if (
+              wasTemporary
+              && treeContext.identityConfig.serverGeneratesRowField
+              && (isRootParent(nextTreeKey)
+                || treeKeyEquals(nextTreeKey, oldTreeKey))
+            ) {
+              throw new Error(
+                `保存响应未返回正式树键字段 ${rowField}。`
+              );
+            }
+
+            let isCurrentLogicalRow = (item) =>
+              item === currentLogicalRow
+              || (
+                hasIdentityValue(logicalRowKey)
+                && item?._X_ROW_KEY === logicalRowKey
+              );
+            let keyConflict = treeTableRows.some(
+              (item) =>
+                !isCurrentLogicalRow(item)
+                && treeKeyEquals(item?.[rowField], nextTreeKey)
+            );
+            if (keyConflict) {
+              throw new Error(
+                `保存响应中的树键 ${nextTreeKey} 已存在。`
+              );
+            }
+
+            let currentTreeKey = currentLogicalRow[rowField];
+            let treeKeyChanged = !treeKeyEquals(
+              currentTreeKey,
+              nextTreeKey
+            );
+            rebuildTreeAfterSave
+              = rebuildTreeAfterSave || treeKeyChanged;
+            if (
+              responseHasTreeKey
+              && currentTreeKey !== nextTreeKey
+              && !treeKeyChanged
+            ) {
+              responseRow[rowField] = currentTreeKey;
+              nextTreeKey = currentTreeKey;
+            }
+            let responsePhysicalId = responseRow[physicalIdField];
+            let responseAlreadyApplied
+              = treeSnapshotApplied
+                && !treeKeyChanged
+                && (
+                  !hasIdentityValue(responsePhysicalId)
+                  || treeKeyEquals(
+                    currentLogicalRow[physicalIdField],
+                    responsePhysicalId
+                  )
+                )
+                && currentLogicalRow._X_TREE_TEMP_KEY == null;
+            let stableRowKey
+              = currentLogicalRow._X_ROW_KEY || logicalRowKey;
+            Object.assign(currentLogicalRow, responseRow);
+            if (hasIdentityValue(stableRowKey)) {
+              currentLogicalRow._X_ROW_KEY = stableRowKey;
+              logicalRowKey = stableRowKey;
+            }
+            if (treeKeyChanged) {
+              syncTreeKeyReferences(
+                treeTableRows,
+                currentTreeKey,
+                nextTreeKey,
+                { fields: treeContext.fields }
+              );
+            }
+            delete currentLogicalRow._X_TREE_TEMP_KEY;
+            this.unregisterTreeKey(
+              this.treeTemporaryKeyRegistry,
+              oldTreeKey
+            );
+            this.treeKnownFormalKeyRegistry.add(
+              currentLogicalRow[rowField]
+            );
+
+            let reconcileGrid = this.getGridTable?.() || $grid;
+            if (reconcileGrid?.clearActived) {
+              await reconcileGrid.clearActived();
+            }
+            if (rebuildTreeAfterSave && !responseAlreadyApplied) {
+              this.setValue(treeTableRows);
+              treeSnapshotApplied = true;
+              await new Promise((resolve) => this.$nextTick(resolve));
+            }
+            reconcileGrid = this.getGridTable?.() || reconcileGrid;
+            if (reconcileGrid?.updateData) {
+              await reconcileGrid.updateData();
+            }
+          } else {
+            Object.assign(obj.row, responseRow);
+            await $grid.clearActived();
+            await $grid.updateData();
+          }
+          delete obj.$table.editCloneRow;
+          return true;
+        };
+        let runRowReconcile = async () =>
+          reconcileSavedRow(await querySavedRow());
+        try {
+          return await runRowReconcile();
+        } catch (error) {
+          keepSaveLocked = true;
+          let retryPromise = null;
+          this.treeSingleSaveReconcileTask = () => {
+            if (retryPromise) return retryPromise;
+            retryPromise = runRowReconcile()
+              .then((result) => {
+                this.treeSingleSaveReconcileTask = null;
+                this.treeSingleSavePending = false;
+                return result;
+              })
+              .catch((retryError) => {
+                this.$message.error(
+                  retryError?.message
+                    || "保存结果仍未能重新加载，请手动刷新后再操作。"
+                );
+                return false;
+              })
+              .finally(() => {
+                retryPromise = null;
+              });
+            return retryPromise;
+          };
+          this.$message.error(
+            error?.message
+              || "保存已成功，但结果重新加载失败，请重试。"
+          );
+          return false;
+        }
+      } catch (error) {
+        if (error?.treeReloadFailed) {
+          keepSaveLocked = true;
+          installReloadRetry();
+          this.$message.error(
+            "树键已更新，但重新加载失败，请手动刷新后再操作。"
+          );
+          return false;
+        }
+        if (!keepSaveLocked) {
+          this.$message.error(
+            error?.message || "当前行保存失败。"
+          );
+        }
+        return false;
+      } finally {
+        if (!keepSaveLocked) {
+          this.treeSingleSavePending = false;
+        }
+      }
+    },
+    /** @param {*} dataId 行数据 id。@param {Function} callback 查询成功回调。加载保存后的完整行。 */
+    getRowData(dataId, callback, fail, error) {
       let reportTemplate = this.getFormRef()?.reportTemplate;
       let formCode = reportTemplate.formCode;
       let formConfig = this.formConfig;
@@ -3500,7 +4461,7 @@ modules = {
       let entity = formConfig.entity;
       let scriptCode = formConfig.formScriptCode || "getOne";
       let defaultOption = this.getHttpConfigForUser();
-      this.formHttp({
+      return this.formHttp({
         scriptCode: scriptCode,
         data: {
           formCode: formCode,
@@ -3511,10 +4472,12 @@ modules = {
           },
         },
         ...defaultOption,
-        success: (res) => {
-          callback && callback(res);
-        },
-      });
+        success: (res) => {
+          callback && callback(res);
+        },
+        fail,
+        error,
+      });
     },
     /** @param {Object} rowData 新行数据。@param {Object} obj 父行参数。@param {Boolean} toTop 是否插到顶部。 */
     addChildTreeRow(rowData, obj, toTop) {
@@ -3541,11 +4504,12 @@ modules = {
       let isEditTable = this.widget.options.isEditTable || false;
       let parent = obj?.row;
       let $grid = this.getGridTable();
-      if (isEditTable && this.hasEditingRow($grid, 1)) {
-        return false;
-      }
-      let parentField = $grid.treeConfig.parentField;
-      let newRow = {};
+      if (isEditTable && this.hasEditingRow($grid, 1)) {
+        return false;
+      }
+      let treeContext = this.getTreeContext($grid);
+      let { rowField, parentField } = treeContext.fields;
+      let newRow = {};
       let originOption = $grid.params.originOption;
       let editDefaultRow;
       if (originOption.editDefaultRow) {
@@ -3556,21 +4520,27 @@ modules = {
         }
       }
 
-      // Object.assign(newRow, editDefaultRow, rowData);
-      newRow.id =
-        "row_" + new Date().valueOf() + Math.floor(Math.random() * 1000000);
-      if (!toSibling) {
-        newRow[parentField] = parent?.id || 0;
-      } else {
-        newRow[parentField] = obj?.row[parentField] || 0;
-      }
-
-      let newData = this.createNewTableData(isEditTable);
-      // editDefaultRow 只提供业务默认值，不允许覆盖计算好的 id/parentField，
-      // 否则默认行里配了 f_parent 会把新增的子节点打回一级节点。
-      newRow = Object.assign({}, newData, editDefaultRow, newRow, rowData);
-
-      let tableRows = this.formModel[this.fieldKeyName] || [];
+      let newData = this.createNewTableData(isEditTable);
+      newRow = Object.assign({}, newData, editDefaultRow, rowData);
+      newRow[treeContext.identityConfig.physicalIdField] = null;
+      this.ensureNewTreeRowKey(newRow, treeContext);
+      if (!toSibling) {
+        if (parent && isRootParent(parent[rowField])) {
+          this.$message.error("父节点缺少有效树键，无法新增子节点。");
+          return false;
+        }
+        newRow[parentField] = parent
+          ? parent[rowField]
+          : treeContext.identityConfig.rootParentValue;
+      } else {
+        let siblingParentValue = obj?.row[parentField];
+        newRow[parentField] = isRootParent(siblingParentValue)
+          ? treeContext.identityConfig.rootParentValue
+          : siblingParentValue;
+      }
+      this.validateNewTreeRows([newRow], treeContext);
+
+      let tableRows = this.formModel[this.fieldKeyName] || [];
       if (!parent) {
         if (toEnd === true) {
           tableRows.push(newRow);
@@ -3586,9 +4556,9 @@ modules = {
         }
         this.setValue(tableRows);
         this.$nextTick(() => {
-          this.handleWbs();
-          if (isEditTable) {
-            this.setActiveRowById($grid, newRow.id);
+          this.handleWbs();
+          if (isEditTable) {
+            this.setActiveRowById($grid, newRow[rowField]);
           }
         });
 
@@ -3610,9 +4580,9 @@ modules = {
           this.$nextTick(() => {
             this.handleWbs();
             // setValue 已浅克隆所有行，obj.row 是失效引用，须按 _X_ROW_KEY 找回新行
-            this.setTreeExpandByRowKey($grid, obj.row._X_ROW_KEY);
-            if (isEditTable) {
-              this.setActiveRowById($grid, newRow.id);
+            this.setTreeExpandByRowKey($grid, obj.row._X_ROW_KEY);
+            if (isEditTable) {
+              this.setActiveRowById($grid, newRow[rowField]);
             }
           });
         });
@@ -3646,11 +4616,16 @@ modules = {
     addTreeRows(rowsData, obj, field, sanitize) {
       if (!Array.isArray(rowsData) || !rowsData.length) {
         return;
-      }
-      let $grid = this.getGridTable();
-      let parent = obj?.row;
-      let parentField = $grid.treeConfig?.parentField;
-      let tableRows = this.formModel[this.fieldKeyName] || [];
+      }
+      let $grid = this.getGridTable();
+      let parent = obj?.row;
+      let treeContext = this.getTreeContext($grid);
+      let { rowField, parentField } = treeContext.fields;
+      if (parent && isRootParent(parent[rowField])) {
+        this.$message.error("父节点缺少有效树键，无法新增子节点。");
+        return false;
+      }
+      let tableRows = this.formModel[this.fieldKeyName] || [];
       let items = rowsData;
       if (field) {
         let keys = tableRows.map((item) => item[field] + "");
@@ -3667,28 +4642,29 @@ modules = {
         } else {
           editDefaultRow = originOption.editDefaultRow || {};
         }
-      }
-      let newData = this.createNewTableData(false);
-      let baseId = new Date().valueOf();
-      let extraStrip = Array.isArray(sanitize) ? sanitize : null;
-      items.forEach((rowData, index) => {
-        // 复制来的数据先剔除系统字段，避免旧审计/外键随 assign 泄入
-        let source = rowData;
-        if (sanitize) {
-          source = this.stripRowSystemFields(rowData, extraStrip);
-        }
-        // 批量场景下拼上序号，避免同毫秒生成的临时 id 碰撞
-        let randomId = Math.floor(Math.random() * 1000000);
-        let newRow = {
-          id: `row_${baseId}_${index}_${randomId}`,
-        };
-        if (parentField) {
-          newRow[parentField] = parent?.id || 0;
-        }
-        newRow = Object.assign({}, newData, editDefaultRow, newRow, source);
-        tableRows.push(newRow);
-      });
-      this.setValue(tableRows);
+      }
+      let newData = this.createNewTableData(false);
+      let extraStrip = Array.isArray(sanitize) ? sanitize : null;
+      let newRows = [];
+      items.forEach((rowData) => {
+        // 复制来的数据先剔除系统字段，避免旧审计/外键随 assign 泄入
+        let source = rowData;
+        if (sanitize) {
+          source = this.stripRowSystemFields(rowData, extraStrip);
+        }
+        let newRow = Object.assign({}, newData, editDefaultRow, source);
+        newRow[treeContext.identityConfig.physicalIdField] = null;
+        this.ensureNewTreeRowKey(newRow, treeContext);
+        if (parentField) {
+          newRow[parentField] = parent
+            ? parent[rowField]
+            : treeContext.identityConfig.rootParentValue;
+        }
+        newRows.push(newRow);
+      });
+      this.validateNewTreeRows(newRows, treeContext);
+      tableRows.push(...newRows);
+      this.setValue(tableRows);
       this.$nextTick(() => {
         this.handleWbs();
         if (parent) {
@@ -3705,25 +4681,36 @@ modules = {
      * @returns {Set} 后代行的 _X_ROW_KEY 集合。
      */
     collectDescendantKeys(row, tableRows) {
-      let $grid = this.getGridTable();
-      let isTreeTable = this.widget.options.isTreeTable || false;
-      let childrenField = $grid.treeConfig?.children;
-      let keys = new Set();
-      // 若数据是嵌套结构，收集 children 下的子节点
-      let loopDo = (item) => {
-        if (childrenField && item && item[childrenField]) {
-          item[childrenField].forEach((subItem) => {
-            if (subItem && subItem._X_ROW_KEY) keys.add(subItem._X_ROW_KEY);
-            loopDo(subItem);
-          });
-        }
-      };
+      let $grid = this.getGridTable();
+      let isTreeTable = this.widget.options.isTreeTable || false;
+      let treeFields = this.getTreeFields($grid);
+      let childFields = [
+        treeFields.childrenField,
+        treeFields.mapChildrenField,
+      ].filter((field, index, values) => field && values.indexOf(field) === index);
+      let keys = new Set();
+      let visited = new WeakSet();
+      // 若数据是嵌套结构，收集 children 下的子节点
+      let loopDo = (item) => {
+        if (!item || typeof item !== "object" || visited.has(item)) {
+          return;
+        }
+        visited.add(item);
+        childFields.forEach((childrenField) => {
+          if (!item || !Array.isArray(item[childrenField])) {
+            return;
+          }
+          item[childrenField].forEach((subItem) => {
+            if (subItem && subItem._X_ROW_KEY) keys.add(subItem._X_ROW_KEY);
+            loopDo(subItem);
+          });
+        });
+      };
       loopDo(row);
       // 树表使用扁平数据(transform)，子节点通过 parentField 关联，
-      // 需按 parentField 递归收集所有后代，避免删除父节点后子节点残留
-      if (isTreeTable && $grid.treeConfig) {
-        let parentField = $grid.treeConfig.parentField;
-        let rowField = $grid.treeConfig.rowField || "id";
+      // 需按 parentField 递归收集所有后代，避免删除父节点后子节点残留
+      if (isTreeTable && $grid.treeConfig) {
+        let { rowField, parentField } = treeFields;
         let pending = [row];
         while (pending.length) {
           let cur = pending.shift();
@@ -3735,13 +4722,9 @@ modules = {
             // 数据成环时防止把起始节点收进后代集合
             if (item._X_ROW_KEY === row._X_ROW_KEY) {
               return;
-            }
-            let parentValue = item[parentField];
-            let matched = parentValue === curId;
-            if (!matched && parentValue != null && curId != null) {
-              matched = String(parentValue) === String(curId);
-            }
-            if (matched) {
+            }
+            let parentValue = item[parentField];
+            if (treeKeyEquals(parentValue, curId)) {
               keys.add(item._X_ROW_KEY);
               pending.push(item);
             }
@@ -3756,8 +4739,19 @@ modules = {
      * @param {Array} tableRows 当前扁平数据。
      * @param {Set} delKeys 待删除行的 _X_ROW_KEY 集合。
      */
-    removeTreeRowsByKeys(tableRows, delKeys) {
-      let newRows = tableRows.filter((item) => !delKeys.has(item._X_ROW_KEY));
+    removeTreeRowsByKeys(tableRows, delKeys) {
+      if (this.widget.options.isTreeTable) {
+        let { rowField } = this.getTreeFields();
+        tableRows.forEach((item) => {
+          if (item && delKeys.has(item._X_ROW_KEY)) {
+            this.unregisterTreeKey(
+              this.treeTemporaryKeyRegistry,
+              item[rowField]
+            );
+          }
+        });
+      }
+      let newRows = tableRows.filter((item) => !delKeys.has(item._X_ROW_KEY));
       this.setValue(newRows);
       this.$nextTick(() => {
         this.handleWbs();
@@ -3911,23 +4905,43 @@ modules = {
         }
       }
 
-      newRow.id =
-        "row_" + new Date().valueOf() + Math.floor(Math.random() * 1000000);
-      if (isTreeTable) {
-        let parentField = $grid.treeConfig.parentField;
-        if (!toSibling) {
-          newRow[parentField] = parent?.id || 0;
-        } else {
-          newRow[parentField] = obj?.row[parentField] || 0;
-        }
-      }
-
-      let newData = this.createNewTableData(isEditTable);
-      // editDefaultRow 只提供业务默认值，不允许覆盖计算好的 id/parentField，
-      // 否则默认行里配了 f_parent 会把新增的子节点打回一级节点。
-      newRow = Object.assign({}, newData, editDefaultRow, newRow, rowData);
-
-      let tableRows = this.formModel[this.fieldKeyName] || [];
+      let treeContext = isTreeTable
+        ? this.getTreeContext($grid)
+        : null;
+      let { rowField, parentField } = treeContext
+        ? treeContext.fields
+        : this.getTreeFields($grid);
+
+      let newData = this.createNewTableData(isEditTable);
+      newRow = Object.assign({}, newData, editDefaultRow, rowData);
+      if (isTreeTable) {
+        newRow[treeContext.identityConfig.physicalIdField] = null;
+        this.ensureNewTreeRowKey(newRow, treeContext);
+        if (!toSibling) {
+          if (parent && isRootParent(parent[rowField])) {
+            this.$message.error("父节点缺少有效树键，无法新增子节点。");
+            return false;
+          }
+          newRow[parentField] = parent
+            ? parent[rowField]
+            : treeContext.identityConfig.rootParentValue;
+        } else {
+          let siblingParentValue = obj?.row[parentField];
+          newRow[parentField] = isRootParent(siblingParentValue)
+            ? treeContext.identityConfig.rootParentValue
+            : siblingParentValue;
+        }
+      } else {
+        // 普通编辑表沿用原有临时 id 协议。
+        newRow[rowField] = "row_"
+          + new Date().valueOf()
+          + Math.floor(Math.random() * 1000000);
+      }
+      if (treeContext) {
+        this.validateNewTreeRows([newRow], treeContext);
+      }
+
+      let tableRows = this.formModel[this.fieldKeyName] || [];
       // 编辑表统一使用 vxe 内部插入，避免 setValue 重载整表并丢失编辑状态。
       if (isEditTable) {
         let insertTarget = toEnd === true ? -1 : null;
@@ -3939,12 +4953,15 @@ modules = {
             // 目标行找不到时追加到末尾，避免 slice(0) 误配到首个同级行
             insertTarget = -1;
           } else if (isTreeTable) {
-            let parentField = $grid.treeConfig.parentField;
             let nextSibling = tableRows
-              .slice(currentIndex + 1)
-              .find(
-                (item) => item[parentField] === obj.row[parentField]
-              );
+              .slice(currentIndex + 1)
+              .find(
+                (item) =>
+                  treeKeyEquals(
+                    item[parentField],
+                    obj.row[parentField]
+                  )
+              );
             insertTarget = nextSibling || -1;
           } else {
             insertTarget = tableRows[currentIndex + 1] || -1;
@@ -4030,9 +5047,10 @@ modules = {
       if (!$grid || rowId == null) {
         return;
       }
-      let sourceRow = (this.getValue() || []).find(
-        (item) => item && item.id === rowId
-      );
+      let { rowField } = this.getTreeFields($grid);
+      let sourceRow = (this.getValue() || []).find(
+        (item) => item && treeKeyEquals(item[rowField], rowId)
+      );
       if (!sourceRow) {
         return;
       }
@@ -4088,11 +5106,18 @@ modules = {
      * @param {Object} obj VXE 行参数。
      */
     async removeEditRow(obj) {
-      let row = obj.row;
-      let $grid = this.getGridTable();
-      await $grid.remove(row);
-
-      // 临时编辑行由 vxe 内部删除；仅同步表单模型，避免 setValue 重载整表。
+      let row = obj.row;
+      let $grid = this.getGridTable();
+      await $grid.remove(row);
+      if (this.widget.options.isTreeTable) {
+        let { rowField } = this.getTreeFields($grid);
+        this.unregisterTreeKey(
+          this.treeTemporaryKeyRegistry,
+          row[rowField]
+        );
+      }
+
+      // 临时编辑行由 vxe 内部删除；仅同步表单模型，避免 setValue 重载整表。
       let tableRows = this.getValue() || [];
       this.formModel[this.fieldKeyName] = tableRows.filter(
         (item) => item._X_ROW_KEY !== row._X_ROW_KEY
@@ -4122,9 +5147,9 @@ modules = {
      * @returns {Promise} VXE 数据刷新结果。
      */
     updateWbs() {
-      let that = this;
-      let $grid = that.getGridTable();
-      let childrenField = $grid.treeConfig.children;
+      let that = this;
+      let $grid = that.getGridTable();
+      let { childrenField, mapChildrenField } = this.getTreeFields($grid);
       let fullData = $grid.getTableData().fullData;
       let isEditTable = this.widget.options.isEditTable || false;
       let isTreeTable = this.widget.options.isTreeTable || false;
@@ -4136,16 +5161,26 @@ modules = {
         fullData = $grid.$refs.xTable.tableFullTreeData;
       }
       let tableRows = this.formModel[that.fieldKeyName] || [];
-      let map = {};
-      let loopDo = (item, wbs) => {
-        item.f_wbs = wbs;
-        map[item._X_ROW_KEY] = wbs;
-        item[childrenField] &&
-          item[childrenField].forEach((subitem, subindex) => {
-            let sub_wbs = wbs + "." + (subindex + 1) + "";
-            loopDo(subitem, sub_wbs);
-          });
-      };
+      let map = {};
+      let loopDo = (item, wbs) => {
+        item.f_wbs = wbs;
+        map[item._X_ROW_KEY] = wbs;
+        let mappedChildren = mapChildrenField
+          && Array.isArray(item[mapChildrenField])
+          ? item[mapChildrenField]
+          : [];
+        let sourceChildren = childrenField
+          && Array.isArray(item[childrenField])
+          ? item[childrenField]
+          : [];
+        let children = mappedChildren.length
+          ? mappedChildren
+          : sourceChildren;
+        children.forEach((subitem, subindex) => {
+          let sub_wbs = wbs + "." + (subindex + 1) + "";
+          loopDo(subitem, sub_wbs);
+        });
+      };
       fullData.forEach((item, index) => {
         let wbs = index + 1 + "";
         loopDo(item, wbs);
@@ -4167,26 +5202,26 @@ modules = {
       let row = obj.row;
       let $grid = this.getGridTable();
       let tableRows = this.formModel[this.fieldKeyName] || [];
-      let isTreeTable = this.widget.options.isTreeTable;
-      if (isTreeTable) {
-        let parentField = $grid.treeConfig.parentField;
-        let rowField = $grid.treeConfig.rowField || "id";
-        let paretValue = row[parentField];
-        let siblingRows = tableRows.filter(
-          (item) => item[parentField] === paretValue
-        );
-        if (siblingRows.length > 1) {
-          let currentIndex = tableRows.findIndex(
-            (item) => item[rowField] === row[rowField]
-          );
-          let index1 = siblingRows.findIndex(
-            (item) => item[rowField] === row[rowField]
-          );
+      let isTreeTable = this.widget.options.isTreeTable;
+      if (isTreeTable) {
+        let { rowField, parentField } = this.getTreeFields($grid);
+        let paretValue = row[parentField];
+        let siblingRows = tableRows.filter(
+          (item) => treeKeyEquals(item[parentField], paretValue)
+        );
+        if (siblingRows.length > 1) {
+          let currentIndex = tableRows.findIndex(
+            (item) => treeKeyEquals(item[rowField], row[rowField])
+          );
+          let index1 = siblingRows.findIndex(
+            (item) => treeKeyEquals(item[rowField], row[rowField])
+          );
           if (index1 > 0) {
-            let prevRow = siblingRows[index1 - 1];
-            let prevIndex = tableRows.findIndex(
-              (item) => item[rowField] === prevRow[rowField]
-            );
+            let prevRow = siblingRows[index1 - 1];
+            let prevIndex = tableRows.findIndex(
+              (item) =>
+                treeKeyEquals(item[rowField], prevRow[rowField])
+            );
             tableRows.splice(currentIndex, 1);
             tableRows.splice(prevIndex, 0, row);
             this.setValue(tableRows);
@@ -4216,26 +5251,26 @@ modules = {
       let row = obj.row;
       let $grid = this.getGridTable();
       let tableRows = this.formModel[this.fieldKeyName] || [];
-      let isTreeTable = this.widget.options.isTreeTable;
-      if (isTreeTable) {
-        let parentField = $grid.treeConfig.parentField;
-        let rowField = $grid.treeConfig.rowField || "id";
-        let paretValue = row[parentField];
-        let siblingRows = tableRows.filter(
-          (item) => item[parentField] === paretValue
-        );
-        if (siblingRows.length > 1) {
-          let currentIndex = tableRows.findIndex(
-            (item) => item[rowField] === row[rowField]
-          );
-          let index1 = siblingRows.findIndex(
-            (item) => item[rowField] === row[rowField]
-          );
+      let isTreeTable = this.widget.options.isTreeTable;
+      if (isTreeTable) {
+        let { rowField, parentField } = this.getTreeFields($grid);
+        let paretValue = row[parentField];
+        let siblingRows = tableRows.filter(
+          (item) => treeKeyEquals(item[parentField], paretValue)
+        );
+        if (siblingRows.length > 1) {
+          let currentIndex = tableRows.findIndex(
+            (item) => treeKeyEquals(item[rowField], row[rowField])
+          );
+          let index1 = siblingRows.findIndex(
+            (item) => treeKeyEquals(item[rowField], row[rowField])
+          );
           if (index1 < siblingRows.length - 1) {
-            let nextRow = siblingRows[index1 + 1];
-            let nextIndex = tableRows.findIndex(
-              (item) => item[rowField] === nextRow[rowField]
-            );
+            let nextRow = siblingRows[index1 + 1];
+            let nextIndex = tableRows.findIndex(
+              (item) =>
+                treeKeyEquals(item[rowField], nextRow[rowField])
+            );
             tableRows.splice(currentIndex, 1);
             tableRows.splice(nextIndex, 0, row);
             this.setValue(tableRows);
@@ -4258,19 +5293,19 @@ modules = {
     },
 
     /** @param {Object} obj VXE 行参数。打开当前层级的树节点排序弹窗。 */
-    openSortRowDialog(obj) {
-      let $grid = this.getGridTable();
-      let parentField = $grid.treeConfig.parentField;
-      let rowField = $grid.treeConfig.rowField || "id";
+    openSortRowDialog(obj) {
+      let $grid = this.getGridTable();
+      let { rowField, parentField } = this.getTreeFields($grid);
       let row = obj.row;
       let tableRows = this.formModel[this.fieldKeyName] || [];
 
-      let sortParentRow = tableRows.find(
-        (item) => item[rowField] === row[parentField]
-      );
-      let sortRows = tableRows.filter(
-        (item) => item[parentField] === row[parentField]
-      );
+      let sortParentRow = tableRows.find(
+        (item) => treeKeyEquals(item[rowField], row[parentField])
+      );
+      let sortRows = tableRows.filter(
+        (item) =>
+          treeKeyEquals(item[parentField], row[parentField])
+      );
       this.sortRows = sortRows;
       this.sortParentRow = sortParentRow;
       this.showTreeMoveDialog = true;
@@ -4298,14 +5333,20 @@ modules = {
             this.getGridTable().reloadTreeExpand(this.sortParentRow);
           },
         });
-      } else {
-        let $grid = this.getGridTable();
-        let rowField = $grid.treeConfig.rowField || "id";
-        let tableRows = this.formModel[this.fieldKeyName] || [];
-
-        let ids = rows.map((item) => item[rowField]);
-        let index = tableRows.findIndex((item) => ids.includes(item[rowField]));
-        let items = tableRows.filter((item) => !ids.includes(item[rowField]));
+      } else {
+        let $grid = this.getGridTable();
+        let { rowField } = this.getTreeFields($grid);
+        let tableRows = this.formModel[this.fieldKeyName] || [];
+
+        let ids = rows.map((item) => item[rowField]);
+        let hasRowKey = (value) =>
+          ids.some((id) => treeKeyEquals(id, value));
+        let index = tableRows.findIndex((item) =>
+          hasRowKey(item[rowField])
+        );
+        let items = tableRows.filter(
+          (item) => !hasRowKey(item[rowField])
+        );
         rows.forEach((row, index1) => {
           items.splice(index + index1, 0, row);
         });