cloud-web-corejs 1.0.54-dev.714 → 1.0.54-dev.716

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

@@ -180,6 +180,13 @@ modules = {
       clearCETriggerFlag: () => {
         this.changeEventTriggerFlag = false;
       },
+      // ===== 表单对比：下发给字段侧(form-item-wrapper)=====
+      getIsCompare: () => e.isCompare,
+      getOldFormData: () => e.oldFormData,
+      getCompareRowKey: () => e.compareRowKey,
+      getCompareExcludeTypes: () => e.compareExcludeTypes,
+      // 字段级排除判定（系统审计字段默认排除 + 业务配置的 compareExcludeFields）
+      isCompareExcludeField: (name) => e.isCompareExcludeField(name),
     };
   },
   data() {
@@ -235,6 +242,24 @@ modules = {
       univerDialogOption: null,
       showUniverDialog: false,
       changeEventTriggerFlag: false, //记录onChange事件是否由用户操作触发
+
+      // ===== 表单对比（变更前/变更后）=====
+      isCompare: false, // 对比开关
+      oldFormData: {}, // 旧整单数据（主表字段 + 各子表数组）
+      compareRowKey: "uuid", // 子表行匹配主键，可被 enableCompare(options)/formConfig 覆盖
+      compareExcludeTypes: [
+        // 不参与对比的字段类型（附件/上传类等）
+        "file-upload",
+        "picture-upload",
+        "baseAttachment",
+        "vabUpload",
+        "vabUpload2",
+        "singleUpload",
+      ],
+      // 按「字段名(keyName)」不参与对比，可被 enableCompare(options.excludeFields)/formConfig 覆盖追加
+      compareExcludeFields: [],
+      showCompareDelList: false,
+      compareDelListOption: {},
     };
   },
   computed: {
@@ -2107,6 +2132,778 @@ modules = {
         ? baseRefUtil.getAllContainerWidgets(e)
         : baseRefUtil.getAllContainerWidgets(this.formJsonObj.widgetList);
     },
+
+    // ===================== 表单对比（变更前/变更后）=====================
+    /**
+     * 开启对比。可只传主表旧值，也可传"主表+任意数量子表数组"的整单旧值。
+     * @param {Object} oldData 旧整单数据（结构与 getFormData 一致）
+     * @param {Object} [options] { compareRowKey, excludeTypes }
+     */
+    enableCompare: function (oldData, options) {
+      options = options || {};
+      oldData = oldData || {};
+      let rowKey =
+        options.compareRowKey ||
+        (this.formConfig && this.formConfig.compareRowKey) ||
+        this.compareRowKey;
+      this.compareRowKey = rowKey;
+      if (Array.isArray(options.excludeTypes)) {
+        this.compareExcludeTypes = options.excludeTypes;
+      }
+      // 字段级排除：优先 options.excludeFields，其次 formConfig.compareExcludeFields
+      let excludeFields =
+        options.excludeFields ||
+        (this.formConfig && this.formConfig.compareExcludeFields);
+      if (Array.isArray(excludeFields)) {
+        this.compareExcludeFields = excludeFields;
+      }
+      this.oldFormData = deepClone(oldData);
+      this.isCompare = true;
+      // 对旧数据中已带的子表数组，逐个做行快照（单包/混用场景）
+      Object.keys(this.oldFormData).forEach((key) => {
+        if (Array.isArray(this.oldFormData[key])) {
+          this.applyCompareSubSnapshot(key);
+        }
+      });
+    },
+    /**
+     * 增量设置某子表的旧数据（多包场景，各子表旧数据回包后分别调用）。
+     * 可被任意次调用，重复设置以最后一次为准（幂等）。
+     */
+    setOldSubData: function (subFormName, oldRows) {
+      if (!subFormName) return;
+      if (!this.isCompare) this.isCompare = true;
+      this.$set(this.oldFormData, subFormName, deepClone(oldRows || []));
+      this.applyCompareSubSnapshot(subFormName);
+    },
+    /**
+     * 把 oldFormData[subFormName] 按主键匹配到当前行，写入每行 hData 快照。
+     * 当前子表尚未加载时仅保留旧数据，待其加载后可再次调用本方法补做。
+     */
+    applyCompareSubSnapshot: function (subFormName) {
+      let rowKey = this.compareRowKey;
+      let oldRows = this.oldFormData[subFormName] || [];
+      let curRows = this.formDataModel[subFormName];
+      if (!Array.isArray(curRows)) return;
+      curRows.forEach((row) => {
+        let old = oldRows.find((o) => this.matchCompareRowKey(o, row, rowKey));
+        this.$set(row, "hData", old ? deepClone(old) : {});
+      });
+    },
+    matchCompareRowKey: function (a, b, rowKey) {
+      rowKey = rowKey || this.compareRowKey;
+      if (!a || !b) return false;
+      return a[rowKey] != null && a[rowKey] === b[rowKey];
+    },
+    /** 关闭对比，复位状态并移除各行 hData */
+    disableCompare: function () {
+      let rowKey = this.compareRowKey;
+      Object.keys(this.oldFormData || {}).forEach((key) => {
+        let curRows = this.formDataModel[key];
+        if (Array.isArray(curRows)) {
+          curRows.forEach((row) => {
+            if (row && Object.prototype.hasOwnProperty.call(row, "hData")) {
+              this.$delete(row, "hData");
+            }
+          });
+        }
+      });
+      this.isCompare = false;
+      this.oldFormData = {};
+      this.showCompareDelList = false;
+      this.compareDelListOption = {};
+    },
+    /**
+     * 按「数据属性名称(keyName)」拿到 data-table 实例的实时行数据。
+     * data-table 删除行时 $grid.remove() 是异步的，formDataModel[subName] 可能滞后残留，
+     * 因此优先读表格实例的 getTableData().fullData（点击查看时 vxe 已结算），退回 formDataModel。
+     */
+    getSubTableInstance: function (subFormName) {
+      let refs = this.subFormRefList || {};
+      return (
+        Object.keys(refs)
+          .map((k) => refs[k])
+          .find((r) => r && r.fieldKeyName === subFormName) || null
+      );
+    },
+    getSubTableCurrentRows: function (subFormName) {
+      let inst = this.getSubTableInstance(subFormName);
+      if (inst && typeof inst.getGridTable === "function") {
+        let $grid = inst.getGridTable();
+        if ($grid && typeof $grid.getTableData === "function") {
+          let td = $grid.getTableData() || {};
+          return td.fullData || td.tableData || [];
+        }
+      }
+      return this.formDataModel[subFormName] || [];
+    },
+    /** 空值归一比较（与 fieldMixin.compareEquals 一致，供行级差异判定用） */
+    compareValueEquals: function (a, b) {
+      const isEmpty = (v) =>
+        v === null ||
+        v === undefined ||
+        v === "" ||
+        (Array.isArray(v) && v.length === 0);
+      if (isEmpty(a) && isEmpty(b)) return true;
+      if (isEmpty(a) || isEmpty(b)) return false;
+      if (typeof a === "object" || typeof b === "object") {
+        try {
+          return JSON.stringify(a) === JSON.stringify(b);
+        } catch (e) {
+          return a === b;
+        }
+      }
+      return String(a) === String(b);
+    },
+    /**
+     * 系统审计/外键字段：在变更单里被清空、原单仍有值，比较会误判为“变更”，默认不对比。
+     * create_date/modify_date 等即在此列表内。
+     */
+    compareSysExcludeFields: function () {
+      return [
+        "id",
+        "createBy",
+        "createDate",
+        "modifyBy",
+        "modifyDate",
+        "_createBy",
+        "_modifyBy",
+        "create_by",
+        "create_date",
+        "modify_by",
+        "modify_date",
+        "head_table_id",
+        "headTableId",
+        "alias_id",
+        "object_foreign_id",
+      ];
+    },
+    /** 字段是否排除对比：系统默认排除字段 + 业务配置的 compareExcludeFields。 */
+    isCompareExcludeField: function (name) {
+      if (!name) return false;
+      if (this.compareSysExcludeFields().indexOf(name) !== -1) return true;
+      return (this.compareExcludeFields || []).indexOf(name) !== -1;
+    },
+    /** 行级差异：比较当前行与原单行的标量字段（跳过内部字段、排除字段与附件列） */
+    isCompareRowValuesChanged: function (oldRow, row, skipKeys) {
+      let skip = skipKeys || {};
+      let keys = {};
+      Object.keys(oldRow || {}).forEach((k) => (keys[k] = 1));
+      Object.keys(row || {}).forEach((k) => (keys[k] = 1));
+      return Object.keys(keys).some((k) => {
+        if (
+          k === "hData" ||
+          k.charAt(0) === "_" ||
+          skip[k] ||
+          this.isCompareExcludeField(k)
+        ) {
+          return false;
+        }
+        return !this.compareValueEquals(oldRow[k], row[k]);
+      });
+    },
+    /**
+     * 返回某子表行的对比行级样式类：新增行 / 变更行 / 无。供 data-table 的 rowClassName 使用。
+     * @returns {String} 'xform-compare-row-new' | 'xform-compare-row-changed' | ''
+     */
+    getCompareRowClass: function (subFormName, row) {
+      if (!this.isCompare || !row) return "";
+      let rowKey = this.compareRowKey;
+      let oldRows = (this.oldFormData && this.oldFormData[subFormName]) || [];
+      let old = oldRows.find((o) => this.matchCompareRowKey(o, row, rowKey));
+      if (!old) return "xform-compare-row-new";
+      // 附件列不参与对比：从子表实例收集需跳过的附件 prop（系统字段由 isCompareExcludeField 统一处理）
+      let skip = {};
+      let inst = this.getSubTableInstance(subFormName);
+      if (inst && typeof inst.getAttachmentType === "function") {
+        (inst.getAttachmentType() || []).forEach((p) => (skip[p] = 1));
+      }
+      return this.isCompareRowValuesChanged(old, row, skip)
+        ? "xform-compare-row-changed"
+        : "";
+    },
+    /** 返回某子表被删除的行（旧有、当前按主键找不到）。实时计算。 */
+    getDelData: function (subFormName) {
+      let rowKey = this.compareRowKey;
+      let oldRows = (this.oldFormData && this.oldFormData[subFormName]) || [];
+      let curRows = this.getSubTableCurrentRows(subFormName);
+      return oldRows.filter(
+        (o) => !curRows.some((c) => this.matchCompareRowKey(o, c, rowKey))
+      );
+    },
+    /** 取某子表当前表格的展示列 [{ field, title }]（叶子列，走 $t1 国际化标题） */
+    getSubTableDisplayColumns: function (subFormName) {
+      let inst = this.getSubTableInstance(subFormName);
+      let tableColumns =
+        inst && inst.widget && inst.widget.options
+          ? inst.widget.options.tableColumns
+          : null;
+      if (!tableColumns) return [];
+      let result = [];
+      let walk = (cols) => {
+        (cols || []).forEach((item) => {
+          if (item.children && item.children.length) {
+            walk(item.children);
+          } else if (
+            item.prop &&
+            item.label &&
+            item.formatS !== "editAttachment" // 附件列为数组/对象，纯文本表格显示 undefined，排除
+          ) {
+            result.push({
+              field: item.prop,
+              title: this.$t1 ? this.$t1(item.label) : item.label,
+              width: item.width,
+              minWidth: item.minWidth,
+            });
+          }
+        });
+      };
+      walk(tableColumns);
+      return result;
+    },
+    /**
+     * 「变更」跳转：从原单跳到变更单列表并携带 sourceId 打开新增。
+     * 列表宿主(list.vue)按「路由最后一段=formCode、query.param(JSON)=打开参数」解析，
+     * 因此默认复用当前路由基路径、把最后一段替换为变更单 formCode（同基兄弟列表约定）。
+     * @param {String|Number} sourceId 原单 id（不传取当前 dataId）
+     * @param {String} formCode 变更单表单编号（作为目标列表路由最后一段）
+     * @param {Object} [options]
+     *   listPath  显式目标列表路由（覆盖默认的“替换最后一段”推导）
+     *   param     额外打开参数（与 { sourceId, autoAdd:1 } 合并，走 query.param）
+     *   query     额外 query 合并
+     */
+    goChangeBill: function (sourceId, formCode, options) {
+      let a = 1;
+      debugger;
+      options = options || {};
+      let router = this.$router || (window.$vueRoot && window.$vueRoot.$router);
+      let store = this.$store || (window.$vueRoot && window.$vueRoot.$store);
+      if (!router) return;
+      let sid = sourceId != null ? sourceId : this.dataId;
+      // 目标列表路径：优先 options.listPath；否则复用当前路径、替换最后一段为 formCode
+      let path = options.listPath;
+      if (!path) {
+        let curPath = (this.$route && this.$route.path) || "";
+        let segs = curPath.split("/");
+        if (segs.length) segs[segs.length - 1] = formCode;
+        path = segs.join("/");
+      }
+      let param = Object.assign({}, options.param, {
+        sourceId: sid,
+        autoAdd: 1,
+      });
+      let query = Object.assign({}, options.query, param);
+      let view = { path: path, query: query };
+      // 先清掉目标列表的缓存视图，再 replace，确保列表按新参数重新加载
+      let doNav = () => router.replace(view);
+      if (store) {
+        store.dispatch("tagsView/delCachedView", view).then(doNav, doNav);
+      } else {
+        doNav();
+      }
+    },
+    /** 打开"查看删除数据"弹窗。columns 不传时默认取当前数据表格的列。 */
+    openCompareDelList: function (subFormName, columns) {
+      this.compareDelListOption = {
+        subFormName: subFormName,
+        columns:
+          columns && columns.length
+            ? columns
+            : this.getSubTableDisplayColumns(subFormName),
+        data: this.getDelData(subFormName),
+      };
+      this.showCompareDelList = true;
+    },
+    /**
+     * 枚举需要独立发包获取的子表（data-table 容器）。sub-form/table2 的数组随主表
+     * objx 一并返回，无需单独发包。返回 [{ name, scriptCode }]。
+     */
+    getCompareSubTables: function () {
+      return this.getCompareSubTablesFrom(this.formJsonObj.widgetList);
+    },
+    getCompareSubTablesFrom: function (widgetList) {
+      let result = [];
+      this.getContainerWidgets(widgetList).forEach((c) => {
+        if (c.type === "data-table" && c.container && c.container.options) {
+          result.push({
+            // 与 data-table 实际发包(taBm)/表单存储键保持一致：优先「数据属性名称」keyName
+            name: this.getFieldKeyName(c.container),
+            scriptCode: c.container.options.formScriptCode || "getList",
+            // 与 loadDefaultViewList 一致：附件列/三级表列需随包上送，后端才会返回附件
+            attachmentType: this.collectAttachmentTypeFromColumns(
+              c.container.options.tableColumns
+            ),
+            thirdtabm: this.collectThirdtabmFromColumns(
+              c.container.options.tableColumns
+            ),
+          });
+        }
+      });
+      return result;
+    },
+    // 递归遍历数据表列，收集 formatS==='editAttachment' 的列 prop（附件列）
+    collectAttachmentTypeFromColumns: function (columns) {
+      let result = [];
+      let walk = (cols) => {
+        (cols || []).forEach((item) => {
+          if (item.children && item.children.length) {
+            walk(item.children);
+          } else if (
+            item.prop &&
+            item.label &&
+            item.formatS === "editAttachment"
+          ) {
+            result.push(item.prop);
+          }
+        });
+      };
+      walk(columns);
+      return result;
+    },
+    // 递归遍历数据表列，收集 editSearch + 多选(三级表)的列 prop
+    collectThirdtabmFromColumns: function (columns) {
+      let result = [];
+      let walk = (cols) => {
+        (cols || []).forEach((item) => {
+          if (item.children && item.children.length) {
+            walk(item.children);
+          } else if (
+            item.prop &&
+            item.label &&
+            item.formatS === "editSearch" &&
+            item.widget &&
+            item.widget.options &&
+            item.widget.options.multipleChoices
+          ) {
+            result.push(item.prop);
+          }
+        });
+      };
+      walk(columns);
+      return result;
+    },
+    // 递归遍历数据表列，把列 prop → 列组件 defaultValue 写入 map（供 defaultFields 取默认值）
+    collectColumnDefaults: function (columns, map) {
+      let walk = (cols) => {
+        (cols || []).forEach((item) => {
+          if (item.children && item.children.length) {
+            walk(item.children);
+          } else if (item.prop) {
+            let w = item.editWidget || item.widget;
+            if (w && w.options) map[item.prop] = w.options.defaultValue;
+          }
+        });
+      };
+      walk(columns);
+    },
+    // 收集表头(主表)附件字段。表头附件不随 getOne 返回，每个附件字段需按 taBm=keyName
+    // 独立发 getList 包（与 baseAttachment-widget.loadDataDefaultHandle 一致）。
+    getHeaderAttachmentFields: function (widgetList) {
+      let excludeTypes = this.compareExcludeTypes || [];
+      let result = [];
+      getAllFieldWidgets(widgetList).forEach((w) => {
+        if (w.field && excludeTypes.indexOf(w.type) !== -1) {
+          result.push({
+            name: this.getFieldKeyName(w.field),
+            scriptCode: w.field.options.formScriptCode || "getList",
+          });
+        }
+      });
+      return result;
+    },
+    /**
+     * 按 formCode 拉取表单模板定义，返回 { reportTemplate, formConfig, widgetList }。
+     * 用于「用原单模板拉原单数据」——原单与变更单模板不同时。
+     */
+    fetchTemplateByFormCode: function (formCode) {
+      return new Promise((resolve, reject) => {
+        this.$http({
+          url: USER_PREFIX + `/formTemplate/getByFormCode`,
+          method: `post`,
+          data: { stringOne: formCode },
+          isLoading: false,
+          success: (res) => {
+            let t = res.objx || {};
+            let fj = t.formViewContent ? JSON.parse(t.formViewContent) : {};
+            resolve({
+              reportTemplate: t,
+              formConfig: fj.formConfig || {},
+              widgetList: fj.widgetList || [],
+            });
+          },
+          error: reject,
+        });
+      });
+    },
+    /**
+     * 通用：按「原单模板」自动多包获取原单整单数据（主表 + 所有 data-table 子表），
+     * 组装成与 getFormData 一致的对象返回。默认复用当前表单模板（变更单通常与原单
+     * 结构一致）；跨模板可用 options 覆盖。
+     * @param {String|Number} sourceId 原单 id
+     * @param {Object} [options] { reportTemplate, formCode, formVersion, entity, masterScriptCode, isLoading }
+     * @returns {Promise<Object>} 原单整单数据
+     */
+    loadOldData: function (sourceId, options) {
+      options = options || {};
+      let isLoading = options.isLoading !== false;
+      // 解析「原单模板」：优先按 sourceFormCode 拉原单模板；否则复用当前模板
+      let resolveTpl = options.sourceFormCode
+        ? this.fetchTemplateByFormCode(options.sourceFormCode)
+        : Promise.resolve({
+            reportTemplate: options.reportTemplate || this.reportTemplate || {},
+            formConfig: this.formConfig || {},
+            widgetList: this.formJsonObj.widgetList,
+          });
+      return resolveTpl.then((tpl) => {
+        let rt = tpl.reportTemplate || {};
+        let tplFormConfig = tpl.formConfig || {};
+        let formCode = options.formCode || rt.formCode;
+        let formVersion = options.formVersion || rt.formVersion;
+        let entity = options.entity || tplFormConfig.entity;
+        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 || [];
+            })
+          );
+        });
+        // 各 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;
+          }
+          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);
+      });
+    },
+    /**
+     * 通用：自动获取原单并开启对比（模式 B「对比」按钮一行接入）。
+     * @returns {Promise<Object>} 原单数据
+     */
+    enableCompareBySource: function (sourceId, options) {
+      options = options || {};
+      return this.loadOldData(sourceId, options).then((oldData) => {
+        this.enableCompare(oldData, options);
+        return oldData;
+      });
+    },
+    /**
+     * 通用：新建变更单时，自动获取原单 → 清洗 → 填充新单 → 开启对比（模式 A 一行接入）。
+     * @param {String|Number} sourceId 原单 id
+     * @param {Object} [options] loadOldData 的选项 + { sanitize } 传给 sanitizeChangeData
+     * @returns {Promise<Object>} 原单数据（对比基准）
+     */
+    initChangeFromSource: function (sourceId, options) {
+      options = options || {};
+      return this.loadOldData(sourceId, options).then((oldData) => {
+        let newData = this.sanitizeChangeData(oldData, options.sanitize || {});
+        this.setFormData(newData);
+        this.enableCompare(oldData, options);
+        return oldData;
+      });
+    },
+    /**
+     * 「变更」时用原单据数据初始化新变更单前的清洗：返回清洗后的克隆，不修改入参。
+     * 清理主表与所有子表行的系统字段（id/创建人/创建时间/更新人/更新时间等），
+     * 子表额外清理外键 head_table_id；支持将指定字段重置为「变更单默认值」（不吃原单值）。
+     * @param {Object} oldData 原单据整单数据
+     * @param {Object} [options]
+     *   masterClearFields  覆盖主表默认清理字段
+     *   subExtraClearFields 仅子表额外清理的字段，默认 head_table_id/headTableId
+     *   defaultFields      主表：不吃原单值、取变更单默认值的字段名数组
+     *   subDefaultFields   明细表：{ 明细表keyName: ['列prop', ...] }，精确到某明细表的某列
+     * @returns {Object} 清洗后的数据克隆
+     */
+    sanitizeChangeData: function (oldData, options) {
+      options = options || {};
+      const SYS_FIELDS = [
+        "id",
+        "createBy",
+        "createDate",
+        "modifyBy",
+        "modifyDate",
+        "_createBy",
+        "_modifyBy",
+        "create_by",
+        "create_date",
+        "modify_by",
+        "modify_date",
+      ];
+      const SUB_FK_FIELDS = [
+        "head_table_id",
+        "headTableId",
+        "alias_id",
+        "object_foreign_id",
+      ];
+      let masterClear = options.masterClearFields || SYS_FIELDS;
+      let subExtra = options.subExtraClearFields || SUB_FK_FIELDS;
+      let data = deepClone(oldData || {});
+
+      let clearOn = (obj, fields) => {
+        if (!obj || typeof obj !== "object") return;
+        fields.forEach((f) => {
+          if (Object.prototype.hasOwnProperty.call(obj, f)) obj[f] = null;
+        });
+      };
+
+      // 附件字段：不参与对比、但需拷贝过来。拷到变更单时，附件内部的文件对象只保留
+      // 展示/存储必需字段（白名单），其余（id/外键/创建信息等）一律丢弃，让保存时生成新附件记录。
+      let cleanAttachment = options.cleanAttachment !== false;
+      // 文件对象保留字段白名单
+      const ATTACH_KEEP_FIELDS = options.attachmentKeepFields || [
+        "name",
+        "thumbnail",
+        "extension",
+        "large",
+        "fileSize",
+        "domain",
+        "source",
+        "medium",
+        "url",
+      ];
+      let attachKeySet = {};
+      if (cleanAttachment) {
+        let excludeTypes =
+          options.excludeTypes || this.compareExcludeTypes || [];
+        this.getFieldWidgets().forEach((w) => {
+          if (excludeTypes.indexOf(w.type) === -1) return;
+          attachKeySet[this.getFieldKeyName(w.field)] = true;
+        });
+      }
+      // 只保留白名单字段，返回精简后的新文件对象
+      let pickAttachFields = (f) => {
+        if (!f || typeof f !== "object") return f;
+        let picked = {};
+        ATTACH_KEEP_FIELDS.forEach((k) => {
+          if (Object.prototype.hasOwnProperty.call(f, k)) picked[k] = f[k];
+        });
+        return picked;
+      };
+      // 精简某对象上所有附件字段内部文件对象的字段。keySet 不传时用主表/子表单附件字段集。
+      let cleanAttachmentOn = (obj, keySet) => {
+        if (!cleanAttachment || !obj || typeof obj !== "object") return;
+        Object.keys(keySet || attachKeySet).forEach((key) => {
+          let val = obj[key];
+          if (Array.isArray(val)) {
+            obj[key] = val.map(pickAttachFields);
+          } else if (val && typeof val === "object") {
+            obj[key] = pickAttachFields(val);
+          }
+        });
+      };
+      // data-table 的附件是「列」(tableColumns 里 formatS==='editAttachment')，不在字段里，
+      // 需按每个 data-table 的 keyName 收集其附件列 prop，单独用于清理其行数据。
+      let subAttachMap = {}; // subKeyName -> { prop: true }
+      if (cleanAttachment) {
+        this.getContainerWidgets().forEach((c) => {
+          if (c.type !== "data-table" || !c.container.options) return;
+          let subName = this.getFieldKeyName(c.container);
+          let set = {};
+          this.collectAttachmentTypeFromColumns(
+            c.container.options.tableColumns
+          ).forEach((p) => (set[p] = true));
+          subAttachMap[subName] = set;
+        });
+      }
+
+      // 树表配置：{ name, idField='id', parentField='parent_id' }。这些子表的
+      // id/parent_id 不能简单清空，需重新生成 id 并把 parent_id 重映射到新 id 以保留层级。
+      let treeTables = options.treeSubTables || [];
+      let treeMap = {}; // subFormName -> { idField, parentField }
+      treeTables.forEach((t) => {
+        let cfg = typeof t === "string" ? { name: t } : t;
+        treeMap[cfg.name] = {
+          idField: cfg.idField || "id",
+          parentField: cfg.parentField || "parent_id",
+        };
+      });
+
+      // 主表
+      clearOn(data, masterClear);
+      cleanAttachmentOn(data);
+      // 从原明细行/原单表头回填/自定义赋值到明细业务字段。按明细keyName配置，值支持：
+      //   '目标字段'                            → 把原明细行 id 拷到目标字段
+      //   { from:'明细来源字段', to:'目标字段' }  → 明细字段回填（from 默认 'id'）
+      //   { fromHeader:'表头字段', to:'目标字段' } → 原单表头字段回填到明细
+      //   [ {..}, {..}, ... ]                    → 多字段回填
+      //   (row, header) => { ... }               → 自定义函数，row 原始明细行、header 原单表头，自行赋值
+      // 必须在清空 id / 树表重生成 id 之前执行，否则拿不到原始值。
+      // header 取 data 根对象：master 业务字段未被清理，仍是原单原值。
+      let subSourceFields =
+        options.subSourceFields || options.subSourceIdFields || {};
+      let header = data;
+      let applySourceField = (row, cfg) => {
+        if (!row || typeof row !== "object" || !cfg) return;
+        if (typeof cfg === "function") {
+          cfg(row, header);
+        } else if (Array.isArray(cfg)) {
+          cfg.forEach((c) => applySourceField(row, c));
+        } else if (typeof cfg === "object") {
+          if (cfg.to) {
+            row[cfg.to] = cfg.fromHeader
+              ? header[cfg.fromHeader]
+              : row[cfg.from || "id"];
+          }
+        } else {
+          row[cfg] = row.id; // 字符串简写：id → 该字段
+        }
+      };
+      // 所有子表数组
+      let subClear = masterClear.concat(subExtra);
+      Object.keys(data).forEach((k) => {
+        if (!Array.isArray(data[k])) return;
+        // ① 先回填原明细字段（早于 clearOn / regenerateTreeIds）
+        let srcCfg = subSourceFields[k];
+        if (srcCfg) {
+          data[k].forEach((row) => applySourceField(row, srcCfg));
+        }
+        // data-table 用其附件列集；sub-form/table2 行内字段用主表附件字段集(attachKeySet)
+        let rowAttachSet = subAttachMap[k] || attachKeySet;
+        let treeCfg = treeMap[k];
+        if (treeCfg) {
+          this.regenerateTreeIds(data[k], treeCfg.idField, treeCfg.parentField);
+          // 树表清理时排除 id/parent_id（已重映射），其余系统字段照清
+          let treeClear = subClear.filter(
+            (f) => f !== treeCfg.idField && f !== treeCfg.parentField
+          );
+          data[k].forEach((row) => {
+            clearOn(row, treeClear);
+            cleanAttachmentOn(row, rowAttachSet);
+          });
+        } else {
+          data[k].forEach((row) => {
+            clearOn(row, subClear);
+            cleanAttachmentOn(row, rowAttachSet);
+          });
+        }
+      });
+
+      // 「不被原单值覆盖」的字段：保留变更单自身的值，不用原单值。主表与明细表分开指定：
+      //   defaultFields    主表字段名数组，如 ['f_status', 'f_no']
+      //   subDefaultFields 明细表字段，按「明细表属性名(keyName)」分组：
+      //                    { 明细表keyName: ['列prop1', '列prop2'] }
+
+      // 主表：从清洗数据里删掉该 key。setFormData 用 Object.assign 合并，缺失的 key
+      // 不会覆盖 formDataModel，从而保留变更单已初始化的默认值。
+      let defaultFields = options.defaultFields || [];
+      defaultFields.forEach((f) => {
+        if (!Array.isArray(data[f])) delete data[f];
+      });
+
+      // 明细表：明细行整体来自原单（无变更单已有值可保留），故对指定列取「该列的变更单默认值」，
+      // 等同于新建一行时该列应有的值。精确到「哪个明细表」的「哪个列」。
+      let subDefaultFields = options.subDefaultFields || {};
+      if (Object.keys(subDefaultFields).length) {
+        this.getContainerWidgets().forEach((c) => {
+          if (c.type !== "data-table" || !c.container.options) return;
+          let subName = this.getFieldKeyName(c.container);
+          let cols = subDefaultFields[subName];
+          if (!cols || !cols.length || !Array.isArray(data[subName])) return;
+          let colMap = {};
+          this.collectColumnDefaults(c.container.options.tableColumns, colMap);
+          let takeDefault = (f) =>
+            Object.prototype.hasOwnProperty.call(colMap, f)
+              ? deepClone(colMap[f])
+              : null;
+          data[subName].forEach((row) => {
+            if (!row || typeof row !== "object") return;
+            cols.forEach((f) => {
+              row[f] = takeDefault(f);
+            });
+          });
+        });
+      }
+      return data;
+    },
+    /**
+     * 树表 id/parent_id 重新生成：为每行生成新 id，并把 parent_id 按旧→新映射重指向；
+     * 原父节点不在本表内（外部父级）的 parent_id 置空作为根。就地修改 rows。
+     */
+    regenerateTreeIds: function (rows, idField, parentField) {
+      idField = idField || "id";
+      parentField = parentField || "parent_id";
+      if (!Array.isArray(rows) || !rows.length) return;
+      let idMap = {}; // 旧id -> 新id
+      let used = {}; // 保证本表内新 id 唯一，避免碰撞破坏父子映射
+      let nextId = () => {
+        let id;
+        do {
+          id = "_row" + generateId(); // 以 _row 开头标识新建行
+        } while (used[id]);
+        used[id] = true;
+        return id;
+      };
+      rows.forEach((row) => {
+        if (!row || typeof row !== "object") return;
+        let oldId = row[idField];
+        let newId = nextId();
+        if (oldId !== null && oldId !== undefined) idMap[oldId] = newId;
+        row.__newId = newId;
+      });
+      rows.forEach((row) => {
+        if (!row || typeof row !== "object") return;
+        row[idField] = row.__newId;
+        delete row.__newId;
+        let oldParent = row[parentField];
+        row[parentField] =
+          oldParent != null &&
+          Object.prototype.hasOwnProperty.call(idMap, oldParent)
+            ? idMap[oldParent]
+            : null;
+      });
+    },
     addEC: function (e, t) {
       this.externalComponents[e] = t;
     },
@@ -2338,9 +3135,7 @@ modules = {
           typeof ref.getCurrentValue === "function"
             ? ref.getCurrentValue()
             : undefined;
-        if (
-          isEmptyArrayFieldValue(actualValue, field.type, field.options)
-        ) {
+        if (isEmptyArrayFieldValue(actualValue, field.type, field.options)) {
           error = ref.getRequiredHintMsg
             ? ref.getRequiredHintMsg()
             : this.$t2("必填项不能为空", "system.message.required");