cloud-web-corejs 1.0.54-dev.738 → 1.0.54-dev.739

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cloud-web-corejs",
   "private": false,
-  "version": "1.0.54-dev.738",
+  "version": "1.0.54-dev.739",
   "scripts": {
     "dev": "vue-cli-service serve",
     "lint": "eslint --ext .js,.vue src",

package/src/components/xform/docs//345/257/271/346/257/224/345/212/237/350/203/275/350/220/275/345/234/260/346/226/271/346/241/210.md

@@ -122,6 +122,36 @@ f.enableCompareBySource(sourceId, { compareRowKey: 'uuid' });
 ```
 > 手动版：`f.loadOldData(sourceId).then(old => f.enableCompare(old, { compareRowKey:'uuid' }))`。
 
+### 模式 B 变体：搜索框选原单 → 点「对比」
+支持，**无需额外开发**。本质仍是模式 B，只是 `sourceId` 的来源从「变更单里存的原单引用」换成「搜索框(关联组件)当前选中的值」。
+
+关联组件（vabSearch / autocomplete 等）选中后，**原单 id 就存在它绑定的字段**（`formModel[该字段keyName]`，label 存在伴随字段）。只要「搜索框绑定的字段名」= 「对比按钮读取 sourceId 的字段名」（如都用 `f_source_id`），现有代码原样跑通：
+
+```js
+// 「对比」按钮 onClick（GlobalConfig）
+enableCompareBySource(that) {
+  let f = that.getFormRef();
+  let sourceId = that.formModel.f_source_id;   // ← 搜索框绑定的字段，选中即有值
+  if (!sourceId) {
+    that.$message.warning('请先选择原单');
+    return;
+  }
+  if (f.isCompare) f.disableCompare();        // 换原单时先关掉上一轮对比，避免残留 hData
+  f.enableCompareBySource(sourceId, {
+    compareRowKey: compareRowKey,
+    excludeFields: excludeFields,
+    // sourceFormCode: '原单formCode',        // 原单与变更单模板不同时必填
+  });
+  this.handleCompareButton(that, true);
+}
+```
+
+注意事项：
+1. **切换原单**：重新选一张原单再点「对比」，`enableCompareBySource` 会重新拉数并覆盖 `oldFormData`、重做行快照。稳妥起见先 `disableCompare()` 再重新对比（如上），清掉上一轮遗留的行快照 `hData`。
+2. **模板不同必须传 `sourceFormCode`**：否则会用变更单模板去枚举子表发包，取不到原单数据。
+3. **搜索框字段本身要排除对比**：把它加入 `excludeFields`（如 `f_source_id`），否则它自己会被判为「变更」。
+4. 与模式 A 不冲突：新增时走 `getFormParam().sourceId` → `initChangeFromSource`；手选走本节。两条路最终都落到同一个原单引用字段。
+
 ### 其它按钮
 - 关闭对比：`this.getFormRef().disableCompare();`
 - 查看删除数据：`this.getFormRef().openCompareDelList('子表字段名');`（要中文列头传第二参 `[{field,title},...]`）
@@ -129,7 +159,18 @@ f.enableCompareBySource(sourceId, { compareRowKey: 'uuid' });
 ### 全局配置项（可选）
 - `formConfig.compareRowKey`：子表行匹配主键，默认 `uuid`；也可 `enableCompare(old,{compareRowKey})` 覆盖。
 - `formConfig.compareExcludeTypes` / `enableCompare(old,{excludeTypes})`：不参与对比的字段类型（附件/上传类已默认排除）。
-- `formConfig.compareExcludeFields` / `enableCompare(old,{excludeFields})`：按**字段名**不参与对比；`create_by/create_date/modify_by/modify_date/id/head_table_id/alias_id/object_foreign_id` 等系统字段已默认排除。
+- **对比字段名单（主表 / 明细分开配置）**：
+
+  | | 黑名单（不对比） | 白名单（只对比） |
+  |---|---|---|
+  | 主表 | `excludeFields: ['f_type', ...]` | `includeFields: ['f_qty', ...]` |
+  | 明细 | `subExcludeFields: { 明细keyName: ['f_x', ...] }` | `subIncludeFields: { 明细keyName: ['f_qty', ...] }` |
+
+  - 都通过 `initChangeFromSource / enableCompareBySource / enableCompare` 的 options 传；兜底位 `formConfig.compareExcludeFields / compareSubExcludeFields / compareIncludeFields / compareSubIncludeFields`。
+  - **主表名单与明细名单互不干涉**：主表字段只看 `excludeFields/includeFields`，明细字段只看 `subExcludeFields[表]/subIncludeFields[表]`。主表名单**不会下渗到明细**（两者字段空间不同，同名字段语义也可能不同）；明细字段要排除，就必须写进该表的 `subExcludeFields`。
+  - **白名单优先于黑名单**：某张表一旦配了白名单，该表的黑名单整体失效，别同时配。这个优先关系按表独立生效——主表用白名单、明细用黑名单是允许的。
+  - 系统字段（`id/create_by/create_date/modify_by/modify_date/head_table_id/alias_id/object_foreign_id` 等）、附件字段（`attachments_` 前缀）、`subSourceFields` 回填字段，**已默认排除**，不用写。
+  - 跨表场景（compareMapping）下白名单**自动推导**：主表白名单来自 `mapping.master[].to`，每张明细的白名单来自该表 `fields[].to` —— 主表与各明细互不串味，无需手写。
 - `sanitize.defaultFields`（主表）/ `sanitize.subDefaultFields`（明细表 `{keyName:[列prop]}`）：这些字段**不吃原单值**，保留变更单自身值/默认值。
 - `sanitize.subExtraClearFields`：子表额外清空的外键字段，默认 `head_table_id/headTableId/alias_id/object_foreign_id`。
 - `sanitize.attachmentKeepFields`：附件文件对象保留字段白名单，默认 `name/thumbnail/extension/large/fileSize/domain/source/medium/url`（表头附件、data-table 单元格附件都按此精简；`sanitize.cleanAttachment:false` 可整体关闭）。
@@ -139,9 +180,13 @@ f.enableCompareBySource(sourceId, { compareRowKey: 'uuid' });
   - `{ fromHeader:'表头字段', to:'目标字段' }` → 原单表头字段回填
   - `[ {..}, {..} ]` → 多字段
   - `(row, header) => {...}` → 自定义函数（row 原明细行、header 原单表头；均为原始值，早于清 id/树表重生成执行）
+
+  > **回填字段自动排除对比**：回填出的字段（如 `f_source_item_id`）只存在于新单行，原单行没有 → 逐字段比较时是「空 → 有值」，会把整表行判成**变更行（黄）**。`sanitizeChangeData` 已自动把回填目标字段登记进 `compareAutoExcludeFields`（函数式配置也支持：通过比对函数执行前后新增的 key 捕获），无需手工配置。
+  > **但模式 A（打开已保存的变更单点「对比」）不会走 sanitize**，此时请把这些字段一并写进 `excludeFields`，例如 `excludeFields: ['f_type', 'f_source_id', 'f_source_item_id']`。
 - `sanitize.treeSubTables`：树表配置 `[{ name, idField, parentField }]`，id/parent_id 会重新生成并保留层级。
 - **保存**：提交时 `getReqFormData` 自动剥除对比快照字段 `hData`，无需业务处理。
-- **行级高亮**：变更行橙色、新增行绿色（各带左侧色条），新增行不逐格显示感叹号；系统字段/`compareExcludeFields`/附件列不参与行级判定。
+- **行级高亮**：变更行橙色、新增行绿色（各带左侧色条），新增行不逐格显示感叹号；行级判定与单元格判定走**同一个** `isCompareExcludeField(字段名, 明细表名)`，名单口径完全一致。
+  > 附件恒不对比：新单附件已按 `attachmentKeepFields` 白名单精简（9 个字段），原单快照里是完整对象（含 id/createDate/sn…），直接比必然不等。故按 `attachments_` 前缀（设计器 `keyNamePrefixMap` 固定前缀）在行级判定里整体跳过。
 
 ### 完整接入示例（GlobalConfig）
 把对比相关逻辑收敛到 `getGlobalConfig()` 返回对象里，详情页脚本按需调用。
@@ -561,6 +606,153 @@ f.setOldSubData('子表字段名', 子表旧行);              // 子表旧数
 4. ✅ `sanitizeChangeData`（系统字段/外键/自定义/默认值/树表 id 重生成）。
 5. ✅ 通用多包 `loadOldData`（读原单模板自动发包）+ 一行式 `initChangeFromSource` / `enableCompareBySource`。
 
+## 十·五、跨单据对比（场景 B：订单 → 变更单，不同数据表/不同字段）
+
+> **状态：已落地。** 在原「同结构对齐」（源单与变更单同表同字段名）基础上，新增支持**源单与变更单是不同数据表、字段名不同**的场景。
+>
+> 落地方法（`form-render/indexMixin.js`）：`normalizeBySourceMapping`（源→目标键空间归一化）、`applyCompareSourceTransform`（归一化 + `transformOldData` 钩子统一入口）、`getCompareRowKeyOf`（按子表行主键）、`isCompareSubTable`（未映射子表不参与对比）；状态新增 `compareIncludeFields`（白名单）、`compareSubRowKeys`；`loadOldData` 改为「主表先查 → 用真实 id 查明细」并支持 `subParams/commonParams`；`enableCompare / enableCompareBySource / initChangeFromSource` 全部接入。
+
+### 10.5.1 业务前提（已确认）
+| # | 事项 | 结论 |
+|---|------|------|
+| 1 | 单据关系 | **订单 → 变更单**。可能是同一张数据表，也可能**不是同一张表、字段名不同** |
+| 2 | 明细行配对 | **有稳定业务键**可配对（如物料编码/行号） |
+| 3 | 对比范围 | **白名单**：只比映射表里明确列出的关键字段 |
+| 4 | 文案 | 「变更前」暂不改 |
+| 5 | 搜索框绑定值 | **可能是编码，也可能是 ID**；业务侧不做反查 |
+| 6 | 明细读脚本 | `getList`，**可能有额外查询参数** |
+| 7 | 明细外键 | `head_table_id` → **主表的 `id` 字段** |
+
+### 10.5.2 核心思路
+从**「结构对齐」**（隐式按同名字段比）改为**「语义映射」**（显式声明源↔目标字段对应关系）：
+
+1. 用 `sourceFormCode` 拉**源单模板**取数（已支持）；
+2. 按 **`compareMapping`** 把源单数据**归一化到变更单的键空间**（字段名、子表 keyName、明细列、行匹配键）；
+3. 归一化之后，现有的 diff / `hData` 快照 / 行级高亮 / 删除行逻辑**几乎不用改**——它们只认变更单的键名。
+
+**映射表可选**：同表同字段时不配，自动退化为现在的「结构对齐 + 黑名单」模式，**完全向后兼容**。
+
+| 是否配 `compareMapping` | 对齐方式 | 对比范围 |
+|---|---|---|
+| 否（同表） | 隐式同名对齐（现状） | 黑名单 `excludeFields` |
+| 是（跨表） | 语义映射 | **白名单**（由 mapping 的 `to` 自动推导） |
+
+### 10.5.3 映射表形态
+```js
+compareMapping: {
+  // 主表：源字段 → 变更单字段
+  master: [
+    { from: 'f_order_amount',  to: 'f_amount' },
+    { from: 'f_delivery_date', to: 'f_ship_date' },
+  ],
+  // 明细：源子表 → 变更单子表
+  subs: [
+    {
+      from: 'order_item',        // 订单明细 keyName（源）
+      to:   'change_item',       // 变更单明细 keyName（目标）
+      rowKey: { from: 'f_material_code', to: 'f_mat_no' },  // 业务键，两边可不同名
+      fields: [
+        { from: 'f_qty',   to: 'f_change_qty' },
+        { from: 'f_price', to: 'f_unit_price' },
+      ],
+    },
+  ],
+}
+```
+> **白名单自动推导**：所有 `to` 字段（主表 + 各明细列）自动组成对比白名单，业务无需再写一遍 `includeFields`。未列出的字段一律不参与对比、不显示感叹号、不参与行级高亮判定。
+
+### 10.5.4 行匹配（关键技巧：不改 `matchCompareRowKey`）
+归一化明细行时：
+```
+归一化旧行[变更单业务键字段] = 源行[源业务键字段]     // 如 旧行.f_mat_no = 订单行.f_material_code
+归一化旧行[变更单列名]       = 源行[源列名]           // 按 fields 映射
+```
+再把该子表的 `compareRowKey` 设为 `f_mat_no`（**变更单侧**的业务键字段）。于是：
+- 当前变更单明细行本来就有 `f_mat_no`；
+- 归一化后的旧行也被写入了 `f_mat_no`；
+- `matchCompareRowKey(o, row, 'f_mat_no')` → **直接匹配成功，现有逻辑零改动**。
+
+> **多字段组合键**（如 物料+批次）：归一化时生成合成键字段（如 `_cmpKey = 'M001|B01'`），并在开启对比时对**当前明细行也注入同样的合成键**，`compareRowKey='_cmpKey'`。单字段业务键则用不上。
+
+### 10.5.5 取数流程（必须「主表先查」）
+**为什么**：明细外键 `head_table_id → 主表.id`，而搜索框存的**可能是编码**。若沿用现在的并行发包（主表和明细同时用搜索框的值查），**存编码时明细必然查空**——明细表里没有"编码"这个关联字段。
+
+```
+1. 按 sourceFormCode 拉源单模板
+2. 【串行】主表包：getOne, taBm=源单entity, data:{ [sourceKeyField]: 搜索框的值 }
+       ↓  sourceKeyField 默认 'id'（后端 getOne 只认 id 时，编码场景可配成 'f_order_no'）
+   masterId = 主表响应.objx[sourceIdField]      // sourceIdField 默认 'id'
+       ↓  查不到主表 / 拿不到 id → 中止并提示
+3. 【并行】用 masterId 发：
+     - 表头附件包 × N：getList, taBm=附件字段keyName, data:{ id: masterId }
+     - 明细包     × N：getList, taBm=明细keyName,     data:{ id: masterId, attachmentType, thirdtabm, ...subParams }
+4. 组装 → 归一化(compareMapping) → enableCompare
+```
+
+**向后兼容**：搜索框存的就是 id 时，主表返回的 `objx.id` 就是同一个值，明细包参数与现在完全一致 —— 现有模式 A **行为不变**，只多一次串行等待（一个 RTT）。可用 `sourceIdIsKey: true` 保留并行快路径。
+
+### 10.5.6 明细额外查询参数
+**为什么不能直接复用源模板的 `formScriptParam`**：那段脚本在**该 data-table 组件实例**上下文里执行（`this` = 表格组件）。对比取数时源单模板只是一份 JSON，**没有对应组件实例**，跨实例执行有风险。
+
+**方案：显式配置（安全可控）**
+```js
+subParams: {
+  '订单明细keyName': { f_status: 1, f_type: 'A' },              // 静态参数
+  '订单附件明细':     (ctx) => ({ f_biz: ctx.masterData.f_biz }), // 函数：可读主表数据
+},
+commonParams: { ... },   // 所有明细包都带的公共参数
+```
+merge 进明细包的 `data`（与 `{id, attachmentType, thirdtabm}` 合并）。
+> 函数形态可拿到 `ctx.masterData`（第 2 步取回的主表数据）—— 这是「主表先查」顺带带来的能力。
+>
+> 兜底开关（可选）：`useSourceScriptParam: true` 尝试在 form-render 上下文执行源模板 data-table 的 `formScriptParam`，`try/catch` 失败则忽略；不作为默认。
+
+### 10.5.7 配置全貌
+```js
+formRef.enableCompareBySource(搜索框的值, {
+  sourceFormCode: '订单formCode',     // ★ 跨表必填，否则按变更单模板枚举子表 → 明细取不到
+
+  // 主表定位（兼容编码/ID）
+  sourceKeyField: 'id',               // 主表包用哪个字段查，默认 'id'
+  sourceIdField:  'id',               // 从主表响应取真实主键的字段名，默认 'id'
+  // sourceIdIsKey: true,             // 明确传的就是 id → 走并行快路径
+
+  // 明细额外查询参数
+  subParams: { '订单明细': { f_status: 1 } },
+  // commonParams: {...},
+
+  // 跨表映射（场景B）
+  compareMapping: { master: [...], subs: [...] },
+  // transformOldData: (oldData, sourceTpl) => 归一化后的oldData,   // 值转换兜底
+});
+```
+模式 A（`initChangeFromSource`）同样接收上述选项 —— 跨表时**填充变更单也必须走映射**，否则字段名对不上、数据填不进去。
+
+### 10.5.8 语义/边界
+| 情况 | 处理 |
+|---|---|
+| 源单有、变更单没有的字段 | 映射表不写 → 白名单天然忽略 |
+| 变更单有、源单没有的字段 | 不写就不比；写了 `to` 但源无 `from` → 旧值空 → 显示「变更前：(空)」 |
+| 源明细有、变更单未匹配上 | → 进「查看删除明细」（源单有、当前未引用） |
+| 变更单明细有、源单未匹配上 | → 标「新增行」（绿） |
+| **未映射的子表** | **完全不参与对比**（不高亮、删除列表为空）——不做这条会**满屏绿** |
+| 值需要转换（单位/币种/编码体系） | 用 `transformOldData` 钩子 |
+| 清洗 `sanitizeChangeData` | 作用在**归一化后**的数据上，系统字段清理/树表 id 重生成/附件白名单照常工作；`subSourceFields` 回填订单明细 id 依然推荐（给出硬引用，将来行匹配可从业务键切到来源明细 id） |
+
+### 10.5.9 改动清单（8 项，已全部实现）
+| # | 改动 | 落地方法 |
+|---|------|----------|
+| 1 | ✅ `compareMapping` + 源数据归一化到变更单键空间 | `normalizeBySourceMapping(srcData, mapping)` → `{ data, includeFields, rowKeyMap }` |
+| 2 | ✅ 白名单对比（由 mapping 的 `to` 自动推导） | 状态 `compareIncludeFields`；`isCompareExcludeField` 改为「白名单优先：设了白名单则不在名单内一律排除，黑名单失效」。wrapper 的 `compareExcluded` 与行级 `isCompareRowValuesChanged` 都走这一个判定 |
+| 3 | ✅ `compareRowKey` 按子表配置 | 状态 `compareSubRowKeys`（由 `rowKey.to` 自动推导，可被 `options.subRowKeys` 覆盖）；新增 `getCompareRowKeyOf(subFormName)`，`applyCompareSubSnapshot / getCompareRowClass / getDelData` 全部改用它 |
+| 4 | ✅ 未映射子表不参与对比 | 新增 `isCompareSubTable(subFormName)`（判据：旧数据里有无该子表数组）；`getCompareRowClass` 返回 `''`、`getDelData` 返回 `[]`。单元格侧因 `hData` 缺失 → `compareRowIsNew` → 天然不显示感叹号 |
+| 5 | ✅ `initChangeFromSource` 接入映射 | 先 `applyCompareSourceTransform` 归一化，再 `sanitizeChangeData` → `setFormData` → `enableCompare` |
+| 6 | ✅ `transformOldData` 钩子 | `applyCompareSourceTransform` 里，归一化之后调用 `options.transformOldData(data, srcData)` |
+| 7 | ✅ `loadOldData` 主表先查 → 用真实 id 查明细 | 串行：主表包 `data:{[sourceKeyField]: 入参}` → `masterId = objx[sourceIdField]` → 再并行发表头附件包/明细包。`sourceIdIsKey:true` 可走并行快路径；主表查不到或取不到主键则不发明细包 |
+| 8 | ✅ 明细额外查询参数透传 | `commonParams` + `subParams`（对象或 `(ctx)=>对象`，`ctx.masterData/masterId`）merge 进明细包 `data` |
+
+**向后兼容**：不配 `compareMapping` 时 `applyCompareSourceTransform` 原样返回，`compareIncludeFields=null` → 走黑名单，`compareSubRowKeys={}` → 走全局 `compareRowKey`，`isCompareSubTable` 对已有子表恒为 true。**同表场景（现有模式A/B）行为不变**，仅 `loadOldData` 多一次串行等待（可用 `sourceIdIsKey:true` 消除）。
+
 ## 十一、说明 / 注意事项
 - **对比图标注入点**：统一在 `form-item-wrapper.vue`，覆盖主表字段与三类表格容器的单元格（均经 field-widget + tableParam.row 渲染）；仅对比态包裹 compareView，非对比态零改动。
 - **「查看删除数据」按钮**：未在容器工具栏内置，由业务按钮 onClick 调 `openCompareDelList('子表名')` 触发（更灵活）。

package/src/components/xform/form-designer/form-widget/field-widget/form-item-wrapper.vue

@@ -370,15 +370,22 @@ export default {
     },
 
     // ===================== 表单对比 =====================
+    // 所在明细表的属性名(keyName)；主表字段为空。用于按表取黑/白名单
+    compareSubName() {
+      if (!this.tableParam || !this.tableParam.row) return "";
+      let opts = this.parentWidget && this.parentWidget.options;
+      if (!opts) return "";
+      return (opts.keyNameEnabled && opts.keyName) || opts.name || "";
+    },
     compareExcluded() {
       // 按类型排除
       let types = this.getCompareExcludeTypes() || [];
       if (types.indexOf(this.field.type) !== -1) return true;
-      // 按字段名排除（系统审计字段 + 业务配置 compareExcludeFields）
+      // 按字段名排除（系统字段 + 主表黑白名单 + 所在明细表的黑白名单）
       let fieldKeyName =
         (this.field.options.keyNameEnabled && this.field.options.keyName) ||
         this.field.options.name;
-      return !!this.isCompareExcludeField(fieldKeyName);
+      return !!this.isCompareExcludeField(fieldKeyName, this.compareSubName);
     },
     isCompareOn() {
       return !this.designer && !this.compareExcluded && !!this.getIsCompare();

package/src/components/xform/form-render/container-item/tab-item.vue

@@ -14,8 +14,8 @@
         }"
       >
         <el-tab-pane
-          v-for="(tab, index) in visibleTabs"
-          :key="index"
+          v-for="tab in visibleTabs"
+          :key="tab.options.name"
           :label="getI18nLabel(tab.options.label)"
           :disabled="tab.options.disabled"
           :name="tab.options.name"
@@ -25,7 +25,7 @@
               <component
                 :is="subWidget.type + '-item'"
                 :widget="subWidget"
-                :key="swIdx"
+                :key="subWidget.id || swIdx"
                 :parent-list="tab.widgetList"
                 :index-of-parent-list="swIdx"
                 :parent-widget="widget"
@@ -42,7 +42,7 @@
               <component
                 :is="subWidget.type + '-widget'"
                 :field="subWidget"
-                :key="swIdx"
+                :key="subWidget.id || swIdx"
                 :parent-list="tab.widgetList"
                 :index-of-parent-list="swIdx"
                 :parent-widget="widget"

package/src/components/xform/form-render/indexMixin.js

@@ -190,8 +190,9 @@ modules = {
       getOldFormData: () => e.oldFormData,
       getCompareRowKey: () => e.compareRowKey,
       getCompareExcludeTypes: () => e.compareExcludeTypes,
-      // 字段级排除判定（系统审计字段默认排除 + 业务配置的 compareExcludeFields）
-      isCompareExcludeField: (name) => e.isCompareExcludeField(name),
+      // 字段级排除判定。subFormName 为明细表属性名(keyName)，主表字段传空。
+      isCompareExcludeField: (name, subFormName) =>
+        e.isCompareExcludeField(name, subFormName),
     };
   },
   data() {
@@ -261,8 +262,19 @@ modules = {
         "vabUpload2",
         "singleUpload",
       ],
-      // 按「字段名(keyName)」不参与对比，可被 enableCompare(options.excludeFields)/formConfig 覆盖追加
+      // 主表黑名单：按「字段名(keyName)」不参与对比。只作用于主表字段，不下渗明细
       compareExcludeFields: [],
+      // 明细黑名单：{ 子表keyName: [字段名] }，只作用于该明细表
+      compareSubExcludeFields: {},
+      // 主表白名单——设置后主表只对比这些字段，主表黑名单失效。跨表(场景B)由 compareMapping 自动推导
+      compareIncludeFields: null,
+      // 明细白名单：{ 子表keyName: [字段名] }，设置后该明细表只对比这些字段，该表黑名单失效
+      compareSubIncludeFields: {},
+      // 跨表(场景B)：{ 子表keyName: 行主键字段 }，按子表覆盖全局 compareRowKey
+      compareSubRowKeys: {},
+      // sanitize 阶段由 subSourceFields 回填出来的字段（如 f_source_item_id）。
+      // 这些字段原单行里没有，参与对比会被误判为"变更"，故自动排除。
+      compareAutoExcludeFields: [],
       showCompareDelList: false,
       compareDelListOption: {},
     };
@@ -2149,8 +2161,13 @@ modules = {
     // ===================== 表单对比（变更前/变更后）=====================
     /**
      * 开启对比。可只传主表旧值，也可传"主表+任意数量子表数组"的整单旧值。
-     * @param {Object} oldData 旧整单数据（结构与 getFormData 一致）
-     * @param {Object} [options] { compareRowKey, excludeTypes }
+     * @param {Object} oldData 旧整单数据（结构与 getFormData 一致；跨表时为归一化后的数据）
+     * @param {Object} [options]
+     *   compareRowKey  全局子表行主键（默认 uuid）
+     *   subRowKeys     { 子表keyName: 行主键字段 } 按子表覆盖（跨表场景由 mapping 自动推导）
+     *   excludeTypes   不参与对比的字段类型
+     *   excludeFields  不参与对比的字段名（黑名单，同表场景）
+     *   includeFields  只参与对比的字段名（白名单，跨表场景由 mapping 自动推导；一旦设置，黑名单失效）
      */
     enableCompare: function (oldData, options) {
       options = options || {};
@@ -2160,16 +2177,35 @@ modules = {
         (this.formConfig && this.formConfig.compareRowKey) ||
         this.compareRowKey;
       this.compareRowKey = rowKey;
+      // 按子表行主键（跨表场景每张明细的业务键不同）
+      this.compareSubRowKeys = options.subRowKeys || {};
       if (Array.isArray(options.excludeTypes)) {
         this.compareExcludeTypes = options.excludeTypes;
       }
-      // 字段级排除：优先 options.excludeFields，其次 formConfig.compareExcludeFields
+      // 主表黑名单：优先 options.excludeFields，其次 formConfig.compareExcludeFields
       let excludeFields =
         options.excludeFields ||
         (this.formConfig && this.formConfig.compareExcludeFields);
       if (Array.isArray(excludeFields)) {
         this.compareExcludeFields = excludeFields;
       }
+      // 明细黑名单：{ 子表keyName: [字段名] }，只作用于该明细表
+      this.compareSubExcludeFields =
+        options.subExcludeFields ||
+        (this.formConfig && this.formConfig.compareSubExcludeFields) ||
+        {};
+      // 主表白名单：设置后只比白名单内字段，黑名单失效
+      let includeFields =
+        options.includeFields ||
+        (this.formConfig && this.formConfig.compareIncludeFields);
+      this.compareIncludeFields = Array.isArray(includeFields)
+        ? includeFields
+        : null;
+      // 明细白名单：{ 子表keyName: [字段名] }，只作用于该明细表
+      this.compareSubIncludeFields =
+        options.subIncludeFields ||
+        (this.formConfig && this.formConfig.compareSubIncludeFields) ||
+        {};
       this.oldFormData = deepClone(oldData);
       this.isCompare = true;
       // 对旧数据中已带的子表数组，逐个做行快照（单包/混用场景）
@@ -2179,6 +2215,13 @@ modules = {
         }
       });
     },
+    /** 取某子表的行匹配主键：按子表配置优先，否则用全局 compareRowKey */
+    getCompareRowKeyOf: function (subFormName) {
+      return (
+        (this.compareSubRowKeys && this.compareSubRowKeys[subFormName]) ||
+        this.compareRowKey
+      );
+    },
     /**
      * 增量设置某子表的旧数据（多包场景，各子表旧数据回包后分别调用）。
      * 可被任意次调用，重复设置以最后一次为准（幂等）。
@@ -2194,7 +2237,7 @@ modules = {
      * 当前子表尚未加载时仅保留旧数据，待其加载后可再次调用本方法补做。
      */
     applyCompareSubSnapshot: function (subFormName) {
-      let rowKey = this.compareRowKey;
+      let rowKey = this.getCompareRowKeyOf(subFormName);
       let oldRows = this.oldFormData[subFormName] || [];
       let curRows = this.formDataModel[subFormName];
       if (!Array.isArray(curRows)) return;
@@ -2210,7 +2253,6 @@ modules = {
     },
     /** 关闭对比，复位状态并移除各行 hData */
     disableCompare: function () {
-      let rowKey = this.compareRowKey;
       Object.keys(this.oldFormData || {}).forEach((key) => {
         let curRows = this.formDataModel[key];
         if (Array.isArray(curRows)) {
@@ -2223,6 +2265,11 @@ modules = {
       });
       this.isCompare = false;
       this.oldFormData = {};
+      this.compareIncludeFields = null;
+      this.compareSubIncludeFields = {};
+      this.compareSubExcludeFields = {};
+      this.compareSubRowKeys = {};
+      this.compareAutoExcludeFields = [];
       this.showCompareDelList = false;
       this.compareDelListOption = {};
     },
@@ -2291,14 +2338,50 @@ modules = {
         "object_foreign_id",
       ];
     },
-    /** 字段是否排除对比：系统默认排除字段 + 业务配置的 compareExcludeFields。 */
-    isCompareExcludeField: function (name) {
+    /**
+     * 字段是否排除对比。主表与明细的名单**互不干涉**：
+     *   主表字段(subFormName 为空) 只看 includeFields / excludeFields
+     *   明细字段                    只看 subIncludeFields[表] / subExcludeFields[表]
+     * 主表名单不会下渗到明细——两者字段空间不同，同名字段语义也可能不同。
+     * 单表内：配了白名单则只比白名单内字段，该表黑名单失效；否则走系统字段 + 黑名单。
+     * @param {String} name 字段名(keyName)
+     * @param {String} [subFormName] 所在明细表属性名；主表字段不传
+     */
+    isCompareExcludeField: function (name, subFormName) {
       if (!name) return false;
+      // 附件不参与对比：新单附件按白名单精简过(name/url/...)，原单附件是完整对象，
+      // 直接比会必然不等。keyNamePrefixMap 里 vabUpload/baseAttachment 前缀固定为 attachments_。
+      if (name.indexOf("attachments_") === 0) return true;
+      // subSourceFields 回填出来的来源引用字段：原单行没有该字段，比较会误判为“变更”
+      if ((this.compareAutoExcludeFields || []).indexOf(name) !== -1) return true;
+      // 取本表(主表 or 该明细表)的名单
+      let include = subFormName
+        ? (this.compareSubIncludeFields || {})[subFormName]
+        : this.compareIncludeFields;
+      let exclude = subFormName
+        ? (this.compareSubExcludeFields || {})[subFormName]
+        : this.compareExcludeFields;
+      // 白名单模式：不在名单内 = 排除
+      if (Array.isArray(include) && include.length) {
+        return include.indexOf(name) === -1;
+      }
+      // 黑名单模式
       if (this.compareSysExcludeFields().indexOf(name) !== -1) return true;
-      return (this.compareExcludeFields || []).indexOf(name) !== -1;
+      return Array.isArray(exclude) && exclude.indexOf(name) !== -1;
+    },
+    /**
+     * 该子表是否参与对比。跨表场景下，未在 compareMapping.subs 里映射的子表
+     * 不应参与对比（否则整表行会被判成「新增」而满屏高亮）。
+     * 判据：旧数据里有没有这张子表的数组。
+     */
+    isCompareSubTable: function (subFormName) {
+      return (
+        !!this.oldFormData &&
+        Array.isArray(this.oldFormData[subFormName])
+      );
     },
     /** 行级差异：比较当前行与原单行的标量字段（跳过内部字段、排除字段与附件列） */
-    isCompareRowValuesChanged: function (oldRow, row, skipKeys) {
+    isCompareRowValuesChanged: function (oldRow, row, skipKeys, subFormName) {
       let skip = skipKeys || {};
       let keys = {};
       Object.keys(oldRow || {}).forEach((k) => (keys[k] = 1));
@@ -2308,7 +2391,7 @@ modules = {
           k === "hData" ||
           k.charAt(0) === "_" ||
           skip[k] ||
-          this.isCompareExcludeField(k)
+          this.isCompareExcludeField(k, subFormName)
         ) {
           return false;
         }
@@ -2321,8 +2404,10 @@ modules = {
      */
     getCompareRowClass: function (subFormName, row) {
       if (!this.isCompare || !row) return "";
-      let rowKey = this.compareRowKey;
-      let oldRows = (this.oldFormData && this.oldFormData[subFormName]) || [];
+      // 未映射/不参与对比的子表：不高亮（否则整表会被判成新增而满屏绿）
+      if (!this.isCompareSubTable(subFormName)) return "";
+      let rowKey = this.getCompareRowKeyOf(subFormName);
+      let oldRows = this.oldFormData[subFormName] || [];
       let old = oldRows.find((o) => this.matchCompareRowKey(o, row, rowKey));
       if (!old) return "xform-compare-row-new";
       // 附件列不参与对比：从子表实例收集需跳过的附件 prop（系统字段由 isCompareExcludeField 统一处理）
@@ -2331,14 +2416,16 @@ modules = {
       if (inst && typeof inst.getAttachmentType === "function") {
         (inst.getAttachmentType() || []).forEach((p) => (skip[p] = 1));
       }
-      return this.isCompareRowValuesChanged(old, row, skip)
+      return this.isCompareRowValuesChanged(old, row, skip, subFormName)
         ? "xform-compare-row-changed"
         : "";
     },
     /** 返回某子表被删除的行（旧有、当前按主键找不到）。实时计算。 */
     getDelData: function (subFormName) {
-      let rowKey = this.compareRowKey;
-      let oldRows = (this.oldFormData && this.oldFormData[subFormName]) || [];
+      // 未映射/不参与对比的子表：没有"删除行"概念
+      if (!this.isCompareSubTable(subFormName)) return [];
+      let rowKey = this.getCompareRowKeyOf(subFormName);
+      let oldRows = this.oldFormData[subFormName] || [];
       let curRows = this.getSubTableCurrentRows(subFormName);
       return oldRows.filter(
         (o) => !curRows.some((c) => this.matchCompareRowKey(o, c, rowKey))
@@ -2547,16 +2634,29 @@ modules = {
       });
     },
     /**
-     * 通用：按「原单模板」自动多包获取原单整单数据（主表 + 所有 data-table 子表），
-     * 组装成与 getFormData 一致的对象返回。默认复用当前表单模板（变更单通常与原单
-     * 结构一致）；跨模板可用 options 覆盖。
-     * @param {String|Number} sourceId 原单 id
-     * @param {Object} [options] { reportTemplate, formCode, formVersion, entity, masterScriptCode, isLoading }
+     * 通用：按「原单模板」自动多包获取原单整单数据（主表 + 表头附件 + 所有 data-table 子表），
+     * 组装成与 getFormData 一致的对象返回。默认复用当前表单模板；跨模板用 sourceFormCode。
+     *
+     * 取数顺序：**主表先查 → 用主表返回的真实 id 查明细/附件**。
+     * 因为明细外键 head_table_id 关联的是主表 id，而入参 sourceId 可能是「编码」
+     * （搜索框绑定字段可能存编码），并行发包会导致明细查空。
+     *
+     * @param {String|Number} sourceId 原单主键值（id 或编码）
+     * @param {Object} [options]
+     *   sourceFormCode  原单 formCode（跨模板必填）
+     *   sourceKeyField  主表包用哪个字段查，默认 'id'
+     *   sourceIdField   从主表响应取真实主键的字段名，默认 'id'
+     *   sourceIdIsKey   true=明确传的就是明细外键主键 → 走并行快路径
+     *   subParams       { 子表keyName: 对象 | (ctx)=>对象 } 明细额外查询参数（ctx.masterData）
+     *   commonParams    所有明细包都带的公共参数
+     *   reportTemplate/formCode/formVersion/entity/masterScriptCode/isLoading
      * @returns {Promise<Object>} 原单整单数据
      */
     loadOldData: function (sourceId, options) {
       options = options || {};
       let isLoading = options.isLoading !== false;
+      let sourceKeyField = options.sourceKeyField || "id";
+      let sourceIdField = options.sourceIdField || "id";
       // 解析「原单模板」：优先按 sourceFormCode 拉原单模板；否则复用当前模板
       let resolveTpl = options.sourceFormCode
         ? this.fetchTemplateByFormCode(options.sourceFormCode)
@@ -2574,94 +2674,224 @@ modules = {
         let masterScript =
           options.masterScriptCode || tplFormConfig.formScriptCode || "getOne";
         let result = {};
-        let tasks = [];
-        // 主表（含 sub-form/table2 内嵌数组）
-        tasks.push(
-          this.formHttp({
-            vue: this,
-            scriptCode: masterScript,
-            data: {
-              formCode: formCode,
-              formVersion: formVersion,
-              taBm: entity,
-              data: { id: sourceId },
-            },
-            isLoading: isLoading,
-          }).then((res) => {
-            Object.assign(result, (res && res.objx) || {});
-          })
-        );
-        // 表头附件：每个附件字段按 taBm=keyName 独立发 getList 包（getOne 不返回表头附件）
-        this.getHeaderAttachmentFields(tpl.widgetList).forEach((att) => {
-          tasks.push(
-            this.formHttp({
-              vue: this,
-              scriptCode: att.scriptCode,
-              data: {
-                formCode: formCode,
-                formVersion: formVersion,
-                taBm: att.name,
-                data: { id: sourceId },
-              },
-              isLoading: isLoading,
-            }).then((res) => {
-              let o = res && res.objx;
-              result[att.name] = (o && o.records) || o || [];
-            })
-          );
+
+        // ---- 1) 主表包（含 sub-form/table2 内嵌数组）----
+        let masterData = {};
+        masterData[sourceKeyField] = sourceId;
+        let masterTask = this.formHttp({
+          vue: this,
+          scriptCode: masterScript,
+          data: {
+            formCode: formCode,
+            formVersion: formVersion,
+            taBm: entity,
+            data: masterData,
+          },
+          isLoading: isLoading,
+        }).then((res) => {
+          let objx = (res && res.objx) || {};
+          Object.assign(result, objx);
+          return objx;
         });
-        // 各 data-table 子表独立发包（按原单模板枚举），附件/三级表列随包上送
-        this.getCompareSubTablesFrom(tpl.widgetList).forEach((sub) => {
-          let subData = { id: sourceId };
-          if (sub.attachmentType && sub.attachmentType.length) {
-            subData.attachmentType = sub.attachmentType;
-          }
-          if (sub.thirdtabm && sub.thirdtabm.length) {
-            subData.thirdtabm = sub.thirdtabm;
+
+        // ---- 2) 用主表返回的真实主键发明细/附件包 ----
+        let loadDetails = (master) => {
+          // sourceIdIsKey：明确传的就是明细外键主键 → 直接用入参（并行快路径已在下方处理）
+          let masterId = options.sourceIdIsKey
+            ? sourceId
+            : master && master[sourceIdField];
+          if (masterId === null || masterId === undefined || masterId === "") {
+            // 主表没查到或取不到主键，明细无从查起
+            return Promise.resolve(result);
           }
-          tasks.push(
-            this.formHttp({
-              vue: this,
-              scriptCode: sub.scriptCode,
-              data: {
-                formCode: formCode,
-                formVersion: formVersion,
-                taBm: sub.name,
-                data: subData,
-              },
-              isLoading: isLoading,
-            }).then((res) => {
-              let o = res && res.objx;
-              result[sub.name] = (o && o.records) || o || [];
-            })
-          );
+          let ctx = { masterData: master || {}, masterId: masterId };
+          let tasks = [];
+
+          // 表头附件：每个附件字段按 taBm=keyName 独立发 getList 包（getOne 不返回表头附件）
+          this.getHeaderAttachmentFields(tpl.widgetList).forEach((att) => {
+            tasks.push(
+              this.formHttp({
+                vue: this,
+                scriptCode: att.scriptCode,
+                data: {
+                  formCode: formCode,
+                  formVersion: formVersion,
+                  taBm: att.name,
+                  data: { id: masterId },
+                },
+                isLoading: isLoading,
+              }).then((res) => {
+                let o = res && res.objx;
+                result[att.name] = (o && o.records) || o || [];
+              })
+            );
+          });
+
+          // 各 data-table 子表独立发包（按原单模板枚举），附件/三级表列 + 额外参数随包上送
+          this.getCompareSubTablesFrom(tpl.widgetList).forEach((sub) => {
+            let subData = { id: masterId };
+            if (sub.attachmentType && sub.attachmentType.length) {
+              subData.attachmentType = sub.attachmentType;
+            }
+            if (sub.thirdtabm && sub.thirdtabm.length) {
+              subData.thirdtabm = sub.thirdtabm;
+            }
+            // 额外查询参数：公共 + 按子表配置（对象或函数，函数可读主表数据）
+            Object.assign(subData, options.commonParams || {});
+            let sp = (options.subParams || {})[sub.name];
+            if (typeof sp === "function") sp = sp(ctx);
+            Object.assign(subData, sp || {});
+
+            tasks.push(
+              this.formHttp({
+                vue: this,
+                scriptCode: sub.scriptCode,
+                data: {
+                  formCode: formCode,
+                  formVersion: formVersion,
+                  taBm: sub.name,
+                  data: subData,
+                },
+                isLoading: isLoading,
+              }).then((res) => {
+                let o = res && res.objx;
+                result[sub.name] = (o && o.records) || o || [];
+              })
+            );
+          });
+          return Promise.all(tasks).then(() => result);
+        };
+
+        // sourceIdIsKey：入参即明细外键主键 → 主表与明细并行（快路径）
+        if (options.sourceIdIsKey) {
+          return Promise.all([masterTask, loadDetails(null)]).then(() => result);
+        }
+        // 默认：主表先查 → 拿真实主键 → 再查明细（兼容编码/ID）
+        return masterTask.then(loadDetails);
+      });
+    },
+    /**
+     * 跨单据对比（场景B）：把「源单键空间」的数据归一化成「当前表单键空间」。
+     * 归一化后，现有 diff / hData / 行级高亮 / 删除行逻辑无需改动（它们只认当前表单键名）。
+     *
+     * compareMapping = {
+     *   master: [{ from:'源字段', to:'目标字段' }, ...],
+     *   subs:   [{ from:'源子表keyName', to:'目标子表keyName',
+     *              rowKey: { from:'源业务键', to:'目标业务键' },
+     *              fields: [{ from:'源列', to:'目标列' }, ...] }, ...]
+     * }
+     * 行匹配技巧：把源行的业务键值写到「目标业务键字段」上，再把该子表 compareRowKey 设为
+     * 目标业务键字段 —— matchCompareRowKey 即可直接匹配，无需改动。
+     *
+     * @returns {Object} { data: 归一化后的旧数据, includeFields: 主表白名单,
+     *                     subIncludeFields: {子表:白名单}, rowKeyMap: {子表:rowKey} }
+     */
+    normalizeBySourceMapping: function (srcData, mapping) {
+      srcData = srcData || {};
+      mapping = mapping || {};
+      let data = {};
+      let includeFields = [];
+      let subIncludeFields = {};
+      let rowKeyMap = {};
+
+      // 主表字段映射
+      (mapping.master || []).forEach((m) => {
+        if (!m || !m.to) return;
+        data[m.to] = srcData[m.from];
+        includeFields.push(m.to);
+      });
+
+      // 明细映射
+      (mapping.subs || []).forEach((s) => {
+        if (!s || !s.from || !s.to) return;
+        let srcRows = srcData[s.from];
+        if (!Array.isArray(srcRows)) srcRows = [];
+        let rk = s.rowKey || {};
+        let rkFrom = rk.from || "id";
+        let rkTo = rk.to || rkFrom;
+        rowKeyMap[s.to] = rkTo;
+        // 该明细表的白名单只含自己映射到的列，不与主表/其他明细混在一起
+        subIncludeFields[s.to] = (s.fields || [])
+          .filter((f) => f && f.to)
+          .map((f) => f.to);
+        data[s.to] = srcRows.map((row) => {
+          let out = {};
+          // 行匹配键：源业务键值 → 目标业务键字段
+          out[rkTo] = row ? row[rkFrom] : null;
+          (s.fields || []).forEach((f) => {
+            if (f && f.to) out[f.to] = row ? row[f.from] : null;
+          });
+          return out;
         });
-        return Promise.all(tasks).then(() => result);
       });
+
+      return {
+        data: data,
+        includeFields: includeFields,
+        subIncludeFields: subIncludeFields,
+        rowKeyMap: rowKeyMap,
+      };
     },
     /**
      * 通用：自动获取原单并开启对比（模式 B「对比」按钮一行接入）。
-     * @returns {Promise<Object>} 原单数据
+     * 跨表场景传 compareMapping / transformOldData，内部自动归一化。
+     * @returns {Promise<Object>} 归一化后的旧数据（对比基准）
      */
     enableCompareBySource: function (sourceId, options) {
       options = options || {};
-      return this.loadOldData(sourceId, options).then((oldData) => {
+      return this.loadOldData(sourceId, options).then((srcData) => {
+        let oldData = this.applyCompareSourceTransform(srcData, options);
         this.enableCompare(oldData, options);
         return oldData;
       });
     },
+    /**
+     * 统一的「源数据 → 当前表单键空间」转换入口：先 compareMapping 归一化，再 transformOldData 钩子。
+     * 未配 mapping 与 钩子时原样返回（同表场景，行为与之前一致）。
+     * 归一化时把白名单与按子表行主键写入 options，供 enableCompare 消费。
+     */
+    applyCompareSourceTransform: function (srcData, options) {
+      options = options || {};
+      let data = srcData;
+      if (options.compareMapping) {
+        let r = this.normalizeBySourceMapping(srcData, options.compareMapping);
+        data = r.data;
+        // 主表白名单：由 mapping.master 的 to 自动推导（业务未显式指定时）
+        if (!options.includeFields) options.includeFields = r.includeFields;
+        // 明细白名单：由 mapping.subs[].fields 的 to 按表自动推导（与业务显式配置合并）
+        options.subIncludeFields = Object.assign(
+          {},
+          r.subIncludeFields,
+          options.subIncludeFields
+        );
+        // 按子表行主键：由 rowKey.to 自动推导（与业务显式配置合并）
+        options.subRowKeys = Object.assign({}, r.rowKeyMap, options.subRowKeys);
+      }
+      if (typeof options.transformOldData === "function") {
+        data = options.transformOldData(data, srcData) || data;
+      }
+      return data;
+    },
     /**
      * 通用：新建变更单时，自动获取原单 → 清洗 → 填充新单 → 开启对比（模式 A 一行接入）。
-     * @param {String|Number} sourceId 原单 id
-     * @param {Object} [options] loadOldData 的选项 + { sanitize } 传给 sanitizeChangeData
-     * @returns {Promise<Object>} 原单数据（对比基准）
+     * @param {String|Number} sourceId 原单主键值（id 或编码）
+     * @param {Object} [options] loadOldData 的选项 + enableCompare 的选项，另加：
+     *   sanitize  传给 sanitizeChangeData 的清洗选项
+     *   compare   默认 true 自动开启对比；传 false 则只用原单数据填充新单、不开启对比
+     *             （可用返回的 oldData 稍后手动 enableCompare(oldData, options)）
+     * @returns {Promise<Object>} 归一化后的原单数据（对比基准）
      */
     initChangeFromSource: function (sourceId, options) {
       options = options || {};
-      return this.loadOldData(sourceId, options).then((oldData) => {
+      return this.loadOldData(sourceId, options).then((srcData) => {
+        // 跨表：先归一化到当前表单键空间，否则字段名对不上、数据填不进变更单
+        let oldData = this.applyCompareSourceTransform(srcData, options);
         let newData = this.sanitizeChangeData(oldData, options.sanitize || {});
         this.setFormData(newData);
-        this.enableCompare(oldData, options);
+        // compare:false → 只用原单数据填充新单，不开启对比（可稍后手动 enableCompare(oldData)）
+        if (options.compare !== false) {
+          this.enableCompare(oldData, options);
+        }
         return oldData;
       });
     },
@@ -2795,10 +3025,17 @@ modules = {
       let subSourceFields =
         options.subSourceFields || options.subSourceIdFields || {};
       let header = data;
+      // 回填出来的字段只存在于新单行、原单行没有，必须排除对比，否则整表都会被判成「变更行」。
+      // 函数式配置无法静态解析目标字段，故比对函数执行前后新增的 key 来捕获。
+      let autoExclude = {};
       let applySourceField = (row, cfg) => {
         if (!row || typeof row !== "object" || !cfg) return;
         if (typeof cfg === "function") {
+          let before = Object.keys(row);
           cfg(row, header);
+          Object.keys(row).forEach((k) => {
+            if (before.indexOf(k) === -1) autoExclude[k] = 1;
+          });
         } else if (Array.isArray(cfg)) {
           cfg.forEach((c) => applySourceField(row, c));
         } else if (typeof cfg === "object") {
@@ -2806,9 +3043,11 @@ modules = {
             row[cfg.to] = cfg.fromHeader
               ? header[cfg.fromHeader]
               : row[cfg.from || "id"];
+            autoExclude[cfg.to] = 1;
           }
         } else {
           row[cfg] = row.id; // 字符串简写：id → 该字段
+          autoExclude[cfg] = 1;
         }
       };
       // 所有子表数组
@@ -2840,6 +3079,8 @@ modules = {
           });
         }
       });
+      // 交给 isCompareExcludeField：这些字段不参与行级/字段级差异判定
+      this.compareAutoExcludeFields = Object.keys(autoExclude);
 
       // 「不被原单值覆盖」的字段：保留变更单自身的值，不用原单值。主表与明细表分开指定：
       //   defaultFields    主表字段名数组，如 ['f_status', 'f_no']