cloud-web-corejs 1.1.0-dev.6 → 1.1.0-dev.60

package/src/components/excelExport/mixins.js

@@ -1,11 +1,23 @@
 /**version-1.0*/
 let tmixins = {};
+import axios from "axios";
 import { getToken } from "../../utils/auth";
 import indexUtil from "../../utils/index.js";
 import exportFieldDialog from "./exportFieldDialog.vue";
 import { getCellValue } from "@base/components/table/util/index";
-import { isItemExport, isRowExport, requiresCheckedRows } from "./exportType";
-import { getExportItemColumns } from "./exportItemConfigUtil";
+import {
+  isConditionExport,
+  isItemExport,
+  isRowExport,
+  requiresCheckedRows,
+} from "./exportType";
+import { getExportItemColumns } from "./exportItemConfigUtil";
+import { viewKey } from "@base/utils/repeatOpen";
+import {
+  DEFAULT_CONDITION_EXPORT_CONFIG,
+  loadConditionExportConfig,
+  resolveConditionExportConfig,
+} from "./conditionExportConfig";
 
 let configUtil = {
   baseUrl: process.env.VUE_APP_BASE_API,
@@ -13,6 +25,45 @@ let configUtil = {
   indexUtil,
 };
 
+/** 取值转换每处理多少行让出一次主线程，见 getExcelData。 */
+const EXPORT_YIELD_ROWS = 200;
+
+/**
+ * 让出主线程一个宏任务，给渲染与用户交互留出机会。
+ * 必须是宏任务：微任务（Promise.resolve()）不会让浏览器插入渲染帧，进度条照样不动。
+ * @returns {Promise<void>}
+ */
+function yieldToBrowser() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+/**
+ * 可以直接当文件存下来的响应体类型（前缀匹配）。
+ */
+const DOWNLOAD_BINARY_TYPES = [
+  "application/vnd.openxmlformats",
+  "application/vnd.ms-excel",
+  "application/octet-stream",
+  "application/zip",
+];
+
+/**
+ * 这份响应体是不是真的文件流。
+ * 用白名单而不是「排除 application/json」：网关拦截、登录态失效这类失败常见的是
+ * 200 + text/html，黑名单会把一张 HTML 错误页原样存成打不开的 .xlsx，用户看到的是
+ * 一个损坏文件而不是回退后的正常下载。
+ * 后端不给 Content-Type 时 blob.type 是空串，按二进制放行 —— 旧的表单 POST 本来也是
+ * 这么下的，不能因为这次改造反而下不动。
+ * @param {Blob} res 响应体。
+ * @returns {Boolean}
+ */
+function isDownloadableBlob(res) {
+  if (!res) return false;
+  let type = (res.type || "").toLowerCase();
+  if (!type) return true;
+  return DOWNLOAD_BINARY_TYPES.some((item) => type.indexOf(item) === 0);
+}
+
 function getGrid(that, tableRef) {
   let $grid;
   if (Array.isArray(that.$refs[tableRef])) {
@@ -41,6 +92,8 @@ function getGrid(that, tableRef) {
         CURRENT_PREFIX: "",
         option: {},
         uuid: "",
+        // createExcelTemplate 返回的本次导出时间快照，随每页取数请求下发（见 loopToDo）
+        nowDate: null,
         fileRows: [],
         title: this.$t2("导出", "components.excelExport.title"),
         tableTarget: null,
@@ -87,23 +140,81 @@ function getGrid(that, tableRef) {
         showExportFieldDialog: false,
         leafColumns: [],
         columns: [],
-        queryParam: {},
-        isMinimize: false,
+        queryParam: {},
+        isMinimize: false,
+        // 条件导出在本次任务内使用的配置快照。逻辑参数只在开始时读取一次，避免中途变更
+        // 导致前后页使用不同的分页/分卷口径。
+        conditionExportMode: false,
+        conditionExportConfig: { ...DEFAULT_CONDITION_EXPORT_CONFIG },
+        // 不查总数时，处理过程中分母显示「...」；文件合并成功后才回填实际完成数。
+        totalSizeKnown: true,
         // 定时器必须放实例上：模块级共享会导致并发导出互相清除对方的定时器
         exportTimer: null,
         countTimer: null,
         exportError: false,
-      };
-    },
+        // 用户点「取消」/组件被销毁的终止标记。此前取消只是停掉定时器 + 销毁组件，
+        // 已经发出去的那几页请求照样会回调下来继续上送、继续合并，甚至最后弹出一个
+        // 半截文件的下载。所有异步续点都要先问 isExportStopped()。
+        aborted: false,
+        // 本次导出全部请求共用的取消令牌源，取消时一次性掐断在途请求
+        cancelSource: null,
+        // lockMenu 实际锁上的那一个页签。必须记下来：解锁若再按「当时的
+        // $route.path」现查，用户在导出期间切了页签（弹框可最小化，切走完全合法）
+        // 解的就是另一把锁 —— 原页签会永久 affix，而 tagsView 的 delOthersViews /
+        // delAllViews 都保留 affix，「关闭其他」「全部关闭」也删不掉它，只能刷新页面。
+        lockedView: null,
+      };
+    },
+    computed: {
+      exportTotalText() {
+        return this.totalSizeKnown ? this.tTotalSize : "...";
+      },
+    },
     created() {},
     mounted() {
       // this.exc();
     },
     beforeDestroy() {
+      this.aborted = true;
       this.clearExportTimer();
+      this.cancelPendingRequests();
       this.unlockMenu();
     },
     methods: {
+      /**
+       * 导出是否已终止：用户取消、组件销毁、或失败中止。
+       * 每一个跨越 await / .then / setTimeout 的续点都必须先问它，否则在途请求的回调
+       * 会在导出早已"取消"之后继续推进流程。
+       * @returns {Boolean}
+       */
+      isExportStopped() {
+        if (this.aborted === true) return true;
+        if (this.exportError === true) return true;
+        return this._isDestroyed === true;
+      },
+      /**
+       * 本次导出共用的取消令牌，首次取用时创建。
+       * 每次导出都是一个全新的组件实例（index.js 的 initInstance 会先销毁旧实例），
+       * 所以一个 source 覆盖一次导出的全部请求，不存在跨导出串味。
+       * @returns {Object} axios CancelToken
+       */
+      getCancelToken() {
+        if (!this.cancelSource) {
+          this.cancelSource = axios.CancelToken.source();
+        }
+        return this.cancelSource.token;
+      },
+      /**
+       * 掐断本次导出全部在途请求。
+       * request.js 的错误拦截器已对 axios.isCancel 短路返回，不会弹错误框；
+       * 各调用点的 .catch 也都会先问 isExportStopped() 再决定要不要提示。
+       */
+      cancelPendingRequests() {
+        if (this.cancelSource) {
+          this.cancelSource.cancel("export-cancelled");
+          this.cancelSource = null;
+        }
+      },
       exc() {
         this.option = this.param;
         let $grid = getGrid(this.option.vue, this.option.targetRef);
@@ -149,6 +260,9 @@ function getGrid(that, tableRef) {
       },
       dialogClose2() {
         if (this.isMinimize) return;
+        // 最小化不是取消，只有真正关闭才置终止标记
+        this.aborted = true;
+        this.cancelPendingRequests();
         let loadingObj = window.$vueRoot.$baseLoading({
           target: document.body,
           background: "unset",
@@ -163,13 +277,29 @@ function getGrid(that, tableRef) {
           this.param.destroyComponent(loadingObj);
         }, 0);
       },
-      dialogPrimary2() {
+      dialogPrimary2() {
         // this.showUserDialog=false
         this.$emit("confirm");
         this.$emit("close");
-        this.clearExportTimer();
-      },
-      startProcess() {
+        this.clearExportTimer();
+      },
+      /**
+       * 读取并固化本次条件导出的全局配置。单次按钮/脚本参数已经在 option 中完成合并，
+       * resolveConditionExportConfig 会让它们覆盖同名的全局配置。
+       */
+      prepareConditionExportConfig() {
+        this.conditionExportMode = isConditionExport(this.option.type);
+        this.totalSizeKnown = true;
+        if (!this.conditionExportMode) return Promise.resolve();
+        return loadConditionExportConfig().then((globalConfig) => {
+          this.conditionExportConfig = resolveConditionExportConfig(
+            globalConfig,
+            this.option
+          );
+          this.totalSizeKnown = this.conditionExportConfig.searchCount;
+        });
+      },
+      startProcess() {
         this.lockMenu();
         this.createCountTimer();
         this.tableTarget = getGrid(this.option.vue, this.option.targetRef);
@@ -202,42 +332,63 @@ function getGrid(that, tableRef) {
           this.abortExport(
             this.$t1("无法确定导出服务前缀，请在导出配置中指定 prefix")
           );
-          this.unlockMenu();
           return;
-        }
-        this.CURRENT_PREFIX = options.prefix;
-
-        this.title = title;
-        that.tTotalPage = 0;
-        that.tTotalSize = 0;
-        that
-          .createExcelFile()
-          .then((resultMsg) => {
-            if (resultMsg.type === "success") {
-              let aObj = resultMsg.objx;
-              that.uuid = aObj.uuid;
-              that.nowDate = aObj.nowDate;
-              that.ippaaapp = aObj.ippaaapp;
-              setTimeout(function () {
-                /*num = 1;
-              loopToDo(0, num);*/
-                that.handleLoopToDo();
-              }, 300);
-            } else {
-              that.abortExport();
-              that.showImportDialog = false;
-              that.showImportDialog2 = false;
-            }
-          })
-          .catch((error) => {
-            console.error(error);
-            that.abortExport(that.$t1("创建导出文件失败，导出已中止"));
-            that.showImportDialog = false;
-            that.showImportDialog2 = false;
-          });
-      },
-      getExportPageSize() {
-        let pageSize = Math.min(this.option.pageSize || 1000, 1000);
+        }
+        this.CURRENT_PREFIX = options.prefix;
+        this.title = title;
+        that.tTotalPage = 0;
+        that.tTotalSize = 0;
+        that.prepareConditionExportConfig().then(() => {
+          if (that.isExportStopped()) return;
+          // 取数走 originOption.exportAjax 时请求由 xform 侧构造，前端拿不到那个 config，
+          // 只能把令牌顺着导出参数带过去（data-table-mixin 的 exportAjax 会塞进
+          // customParam.config，最终由 formHttp 的 ...opts 透传给 axios）
+          options.cancelToken = that.getCancelToken();
+          that
+            .createExcelFile()
+            .then((resultMsg) => {
+              if (that.isExportStopped()) return;
+              if (resultMsg.type === "success") {
+                let aObj = resultMsg.objx;
+                that.uuid = aObj.uuid;
+                that.nowDate = aObj.nowDate;
+                that.ippaaapp = aObj.ippaaapp;
+                setTimeout(function () {
+                  if (that.isExportStopped()) return;
+                  that.handleLoopToDo();
+                }, 300);
+              } else {
+                that.abortExport();
+                that.showImportDialog = false;
+                that.showImportDialog2 = false;
+              }
+            })
+            .catch((error) => {
+              if (that.isExportStopped()) return;
+              console.error(error);
+              that.abortExport(that.$t1("创建导出文件失败，导出已中止"));
+              that.showImportDialog = false;
+              that.showImportDialog2 = false;
+            });
+        });
+      },
+      getExportPageSize() {
+        let configuredPageSize = this.conditionExportMode
+          ? this.conditionExportConfig.pageSize
+          : this.option.pageSize || 1000;
+        // 条件导出的按钮/脚本值已经按优先级写进配置快照，不再用全局默认值 1000
+        // 反向封顶；非条件导出保持原有最多 1000 的行为。
+        let pageSize = this.conditionExportMode
+          ? configuredPageSize
+          : Math.min(configuredPageSize, 1000);
+        if (this.conditionExportMode) {
+          // 单页本身不能突破总量或单文件上限，否则无法在页级合并时兑现硬上限。
+          pageSize = Math.min(
+            pageSize,
+            this.conditionExportConfig.maxQueryTotal,
+            this.conditionExportConfig.limitFileSize
+          );
+        }
         let showImageAtTable = this.option.showImageAtTable || false;
         let hasExportImage = !!this.leafColumns.find((item) => {
           let exportType = item?.params?.exportType;
@@ -250,18 +401,29 @@ function getGrid(that, tableRef) {
         if (hasExportImage || (hasExportImage2 && showImageAtTable)) {
           pageSize = Math.min(pageSize, 150);
         }
+        // 单页压力取决于「行数 × 列数」，此前只按有无图片列降档，宽表（100+ 列）一页
+        // 的请求体与同步转换耗时是窄表的十几倍，同样的 1000 行/页天差地别。
+        let columnNum = this.leafColumns.length;
+        if (columnNum > 100) {
+          pageSize = Math.min(pageSize, 200);
+        } else if (columnNum > 50) {
+          pageSize = Math.min(pageSize, 500);
+        }
         return pageSize;
       },
-      hadleMergeExcel(pPageSize) {
+      hadleMergeExcel(pPageSize) {
+        if (this.isExportStopped()) return;
         let that = this;
         let title = this.title;
         let options = this.option;
         // let pPageSize = this.getExportPageSize();
-        let limitFileSize = options.limitFileSize || 100000;
+        let limitFileSize = this.conditionExportMode
+          ? this.conditionExportConfig.limitFileSize
+          : options.limitFileSize || 100000;
         let limitThreadNum = options.limitThreadNum || 5;
         let totalPages = this.tTotalPage || 1;
 
-        let kTotalPages = parseInt(limitFileSize / pPageSize);
+        let kTotalPages = Math.max(parseInt(limitFileSize / pPageSize), 1);
 
         let fileNum = parseInt(totalPages / kTotalPages);
         if (totalPages % kTotalPages !== 0) {
@@ -290,6 +452,9 @@ function getGrid(that, tableRef) {
             that
               .mergeExcel(startPage, endPage)
               .then(function (resultMsg3) {
+                // 取消后组件与进度弹框都已销毁，下面 $refs["exportTable"].insertAt
+                // 会直接抛错
+                if (that.isExportStopped()) return;
                 if (resultMsg3.type === "success") {
                   mtExcedSuccessNum++;
                   let fileInfo = resultMsg3.objx;
@@ -311,89 +476,246 @@ function getGrid(that, tableRef) {
                   // that.fileRows.push(dataMap);
                   if (mtExcedNum < fileNum) {
                     loopDo();
-                  } else if (
-                    mtExcedNum >= fileNum &&
-                    mtExcedSuccessNum >= fileNum
-                  ) {
-                    setTimeout(function () {
-                      that.percentageNum = parseInt(100);
-                    }, 100);
-                    that.clearExportTimer();
                   } else if (mtExcedSuccessNum >= fileNum) {
-                    setTimeout(function () {
-                      that.percentageNum = parseInt(100);
-                    }, 100);
-                    that.clearExportTimer();
+                    // 走到 else 分支时 mtExcedNum >= fileNum 必然成立，
+                    // 原先拆成的两个 else-if 条件与分支体完全相同，合并为一处
+                    that.completeExport();
                   }
                 } else {
                   that.abortExport();
                 }
               })
               .catch(function (e) {
+                if (that.isExportStopped()) return;
                 console.error(e);
                 that.abortExport(that.$t1("文件合并异常，导出已中止"));
               });
             // 注意：此处不能同步 clearExportTimer，否则计时统计会在合并完成前被提前停掉
           }
-        };
-        loopDo();
-      },
-      handleLoopToDo() {
-        let that = this;
-        let uuid;
-        let num = 0;
-        let title = this.title;
-
-        let options = this.option;
-
-        let pPageSize = this.getExportPageSize();
-        let limitFileSize = options.limitFileSize || 100000;
-        let limitThreadNum = options.limitThreadNum || 5;
+        };
+        loopDo();
+      },
+      /** 统一组装一页条件导出的取数请求，保证两种查总数模式使用完全相同的查询条件。 */
+      async requestExportPage(pageNumber, pageSize, searchCount) {
+        let options = this.option;
+        let originOption = this.tableTarget.params.originOption;
+        let url = originOption.exportPath || originOption.path;
+        let params = this.$baseLodash.cloneDeep(this.queryParam);
+        let aParam = {
+          current: pageNumber,
+          size: pageSize,
+          nowDate: this.nowDate ?? options.nowDate,
+          searchCount,
+        };
+        let cpParam;
+        if (originOption.vform === true) {
+          params.conditions = params.conditions || {};
+          cpParam = params.conditions;
+        } else {
+          cpParam = params;
+        }
+        Object.assign(cpParam, aParam);
+
+        if (originOption.exportAjax) {
+          return originOption.exportAjax(aParam, {
+            ...options,
+            exportQuerySnapshot: this.$baseLodash.cloneDeep(this.queryParam),
+          });
+        }
+        // URL 上若写死 searchCount，会与本次模式冲突；实际值统一由请求体控制。
+        let resolvedUrl = typeof url === "function" ? url() : url;
+        if (typeof resolvedUrl !== "string" || !resolvedUrl) {
+          throw new Error("无效的导出查询地址");
+        }
+        let requestUrl = resolvedUrl
+          .replace("searchCount=false", "1=1")
+          .replace("searchCount=true", "1=1");
+        let finalParams = params;
+        if (originOption.paramHandle) {
+          finalParams = originOption.paramHandle(params) || {};
+        }
+        return this.$commonHttp({
+          aes: originOption.aes || false,
+          url: requestUrl,
+          method: "post",
+          data: finalParams,
+          modal: false,
+          queryCreateInfo: originOption.queryCreateInfo,
+          addCreateInfo: originOption.addCreateInfo,
+          cancelToken: this.getCancelToken(),
+        });
+      },
+      /** 导出尚在取数/合并时最多显示 99%，100% 只由 completeExport 设置。 */
+      updateExportProgress(doneSize, progressTotal) {
+        this.doneSize = parseInt(doneSize);
+        let percentage = progressTotal > 0 ? (doneSize * 100) / progressTotal : 99;
+        if (percentage > 0 && percentage < 1) percentage = 1;
+        if (percentage >= 100) percentage = 99;
+        this.percentageNum = parseInt(percentage);
+      },
+      /**
+       * 不查询总数：每页都发 searchCount=false，以 records.length < pageSize 判定末页。
+       * 取数与写入按页串行，确保发现末页或达到最大查询总数后不会继续派发多余请求。
+       */
+      handleLoopWithoutCount(pageSize) {
+        let that = this;
+        let maxQueryTotal = this.conditionExportConfig.maxQueryTotal;
+        let maxPages = Math.max(Math.ceil(maxQueryTotal / pageSize), 1);
+        let doneSize = 0;
+        this.tTotalPage = 0;
+        this.tTotalSize = 0;
+        this.totalSizeKnown = false;
+
+        let finish = function (lastPage) {
+          if (that.isExportStopped()) return;
+          that.tTotalPage = Math.max(lastPage, 1);
+          that.hadleMergeExcel(pageSize);
+        };
+
+        let fetchPage = function (pageNumber, retryCount = 0) {
+          if (that.isExportStopped()) return Promise.resolve(null);
+          return that
+            .requestExportPage(pageNumber, pageSize, false)
+            .then((resultMsg) => {
+              if (resultMsg && resultMsg.type === "success") return resultMsg;
+              if (retryCount < 1) {
+                return new Promise((resolve) => {
+                  setTimeout(
+                    () => resolve(fetchPage(pageNumber, retryCount + 1)),
+                    500
+                  );
+                });
+              }
+              that.abortExport();
+              return null;
+            })
+            .catch((error) => {
+              if (that.isExportStopped()) return null;
+              if (retryCount < 1) {
+                return new Promise((resolve) => {
+                  setTimeout(
+                    () => resolve(fetchPage(pageNumber, retryCount + 1)),
+                    500
+                  );
+                });
+              }
+              console.error(error);
+              that.abortExport(
+                that.$t1("第{n}页数据拉取失败，导出已中止", {
+                  n: pageNumber,
+                })
+              );
+              return null;
+            });
+        };
+
+        let appendPage = function (pageNumber) {
+          fetchPage(pageNumber).then((resultMsg) => {
+            if (!resultMsg || that.isExportStopped()) return;
+            let page = resultMsg.objx || {};
+            let actualSize = Number(page.size || page.pageSize || pageSize);
+            if (!Number.isSafeInteger(actualSize) || actualSize <= 0
+              || actualSize > pageSize || (pageNumber > 1 && actualSize !== pageSize)) {
+              that.abortExport(that.$t1("服务端分页大小发生变化，导出已中止"));
+              return;
+            }
+            pageSize = actualSize;
+            maxPages = Math.max(Math.ceil(maxQueryTotal / pageSize), 1);
+            let rawRows = Array.isArray(page.records) ? page.records : [];
+            let hasNext = rawRows.length >= pageSize;
+
+            // 整页数据需要再探测一页；探测到的空页不写入，也不参与合并。
+            if (pageNumber > 1 && rawRows.length === 0) {
+              finish(pageNumber - 1);
+              return;
+            }
+
+            let remaining = Math.max(maxQueryTotal - doneSize, 0);
+            let rows = rawRows.slice(0, remaining);
+            let reachedLimit = rows.length >= remaining;
+            page.current = pageNumber;
+            page.pageNumber = pageNumber;
+            page.size = pageSize;
+            page.pageSize = pageSize;
+            page.records = rows;
+
+            that
+              .addExcelData({ rows, pageNumber })
+              .then((appendResult) => {
+                if (that.isExportStopped()) return;
+                if (!appendResult || appendResult.type !== "success") {
+                  if (appendResult && appendResult.type === "abort") return;
+                  that.abortExport();
+                  return;
+                }
+                doneSize += rows.length;
+                that.updateExportProgress(doneSize, maxQueryTotal);
+                if (reachedLimit || !hasNext || pageNumber >= maxPages) {
+                  finish(pageNumber);
+                  return;
+                }
+                appendPage(pageNumber + 1);
+              })
+              .catch((error) => {
+                if (that.isExportStopped()) return;
+                console.error(error);
+                that.abortExport(that.$t1("导出数据写入失败，导出已中止"));
+              });
+          });
+        };
+
+        appendPage(1);
+      },
+      handleLoopToDo() {
+        let that = this;
+        let num = 0;
+        let options = this.option;
+
+        let pPageSize = this.getExportPageSize();
+        let limitThreadNum = options.limitThreadNum || 5;
+
+        if (
+          this.conditionExportMode
+          && this.conditionExportConfig.searchCount === false
+        ) {
+          this.handleLoopWithoutCount(pPageSize);
+          return;
+        }
 
         /**处理返回值*/
         this.doneSize = 0;
         let excedNum = 0;
         let cSize = this.doneSize;
 
-        let handleData = function (resultMsg) {
+        let handleData = function (resultMsg, flag) {
+          // 取消之后到达的在途响应直接丢弃，不再进入上送/合并流程
+          if (that.isExportStopped()) return;
           let pageNumber = resultMsg.objx.pageNumber || 1;
+          // 并发窗口在"该页上送完成"后才释放，而不是"该页拉取完成"就释放。
+          // addExcelData 此前完全不受闸门约束：上送慢于拉取时 pending 的 POST 会无限
+          // 堆积（每个都攥着一份几 MB 的 JSON body），加上浏览器每域名 6 连接会让上送
+          // 排到拉取后面，这种反压对调度器完全不可见 —— 大数据量导出的内存曲线因此
+          // 始终只涨不落。
+          let released = flag !== 1; // 首页(flag=0)不占窗口，无需释放
+          let releaseWindow = function () {
+            if (released) return;
+            released = true;
+            if (waitReqNum > 0) waitReqNum--;
+          };
           that
             .addExcelData({
               rows: resultMsg.objx.records,
               pageNumber: pageNumber,
             })
-            .then(function (resultMsg2) {
-              let data = resultMsg.objx;
-              let total = data.total;
-
-              let pageNumber = data.pageNumber || 1;
-              let totalPages = that.tTotalPage || 1;
-              if (resultMsg2.type === "success") {
-                excedNum++;
-                let pageNumber = data.pageNumber || 1;
-                let k = (excedNum * 100) / totalPages;
-                if (k > 0 && k < 1) {
-                  k = 1;
-                }
-                if (k > 100) k = 100;
-                let cTotal = that.tTotalSize;
-                let pageSize = data.pageSize;
-                // let datas = data.records;
-                let size = data.records.length;
-                cSize = cSize + size;
-
-                let ttNum = cSize + "/" + cTotal;
-                let percentageStr = parseInt(k) + "%";
-
-                let percentageNum = k;
-                if (percentageNum >= 100) {
-                  percentageNum = 99;
-                }
-                // that.$set(that, "doneSize", parseInt(cSize));
-                // that.$set(that, "percentageNum", parseInt(percentageNum));
-
-                that.doneSize = parseInt(cSize);
-                that.percentageNum = parseInt(percentageNum);
+            .then(function (resultMsg2) {
+              releaseWindow();
+              let data = resultMsg.objx;
+              let totalPages = that.tTotalPage || 1;
+              if (resultMsg2.type === "success") {
+                excedNum++;
+                let size = data.records.length;
+                cSize = cSize + size;
+                that.updateExportProgress(cSize, that.tTotalSize);
 
                 if (totalPages === 0 || excedNum >= totalPages) {
                   that.hadleMergeExcel(data.pageSize);
@@ -481,101 +803,56 @@ function getGrid(that, tableRef) {
               }
             })
             .catch(function (e) {
+              releaseWindow();
+              if (that.isExportStopped()) return;
               console.error(e);
               that.abortExport(that.$t1("导出数据写入失败，导出已中止"));
             });
         };
 
-        let waitReqNum = 0;
-        let promise;
-        let loopToDo = function (flag, pageNumber, retryCount = 0) {
-          let maxWaitNum = limitThreadNum;
-          let nowDate = options.nowDate;
-          if (flag === 1) {
-            /*if (num > that.tTotalPage) {
-              let size = page.records.length;
-              if (size === 0 || page.totalPages === 0 || (page.pageNumber >= page.totalPages)) {
-                that.clearExportTimer();
-                return;
-              }
-            }*/
-          } else {
-            waitReqNum = 0;
-          }
-
-          let target = that.tableTarget;
-          let originOption = target.params.originOption;
-          let url = originOption.exportPath || originOption.path;
-
-          // let params = originOption.param() || {};
-          let params = that.queryParam;
-          let aParam = {
-            current: pageNumber,
-            size: pPageSize,
-            nowDate: nowDate,
-            searchCount: flag !== 1,
-          };
-          let cpParam;
-          if (originOption.vform === true) {
-            params.conditions = params.conditions || {};
-            cpParam = params.conditions;
-          } else {
-            cpParam = params;
-          }
-          Object.assign(cpParam, aParam);
-
-          if (!originOption.exportAjax) {
-            let turl = url.replace("searchCount=false", "1=1");
-            let finaParams = params;
-            if (originOption.paramHandle) {
-              finaParams = originOption.paramHandle
-                ? originOption.paramHandle(params) || {}
-                : {};
-            }
-            promise = that.$commonHttp({
-              aes: originOption.aes || false,
-              url: turl,
-              method: "post",
-              data: finaParams,
-              modal: false,
-              queryCreateInfo: originOption.queryCreateInfo,
-              addCreateInfo: originOption.addCreateInfo,
-            });
-          } else {
-            promise = originOption.exportAjax(aParam, options);
-          }
-
-          promise
-            .then(function (resultMsg) {
-              if (resultMsg.type === "success") {
-                let objx = resultMsg.objx;
-                objx.pageNumber = objx.current || 1;
-                objx.totalPages = objx.pages || 1;
-                objx.pageSize = objx.size;
-                let size = objx.records.length;
-                if (flag === 0) {
-                  that.tTotalPage = objx.pages;
-                  // that.tTotalSize = objx.total;
-                  setTimeout(function () {
-                    that.$set(that, "tTotalSize", objx.total);
-                  }, 0);
-                  let tTotalPage = objx.pages;
-                  let tTotalSize = objx.total;
-                  let ttNum = 0 + "/" + objx.total;
-
-                  let opNum = limitFileSize;
-                  let kTotalPages = parseInt(opNum / objx.size);
-
-                  let fileNum = parseInt(tTotalPage / kTotalPages);
-                  if (tTotalPage % kTotalPages !== 0) {
-                    fileNum = fileNum + 1;
-                  }
-                  if (
-                    size > 0 ||
-                    objx.totalPages > 0 ||
-                    objx.pageNumber < objx.totalPages
-                  ) {
-                    that.exportTimer = setInterval(function () {
+        let waitReqNum = 0;
+        let loopToDo = function (flag, pageNumber, retryCount = 0) {
+          // 取消后不再发起新页，也不再重试（重试是从 .catch 里递归回来的）
+          if (that.isExportStopped()) return;
+          let maxWaitNum = limitThreadNum;
+          if (flag !== 1) waitReqNum = 0;
+
+          that
+            .requestExportPage(pageNumber, pPageSize, flag !== 1)
+            .then(function (resultMsg) {
+              if (resultMsg.type === "success") {
+                let objx = resultMsg.objx || {};
+                objx.records = Array.isArray(objx.records) ? objx.records : [];
+                objx.pageNumber = objx.current || pageNumber;
+                objx.pageSize = objx.size || pPageSize;
+                let actualSize = Number(objx.pageSize);
+                if (!Number.isSafeInteger(actualSize) || actualSize <= 0
+                  || actualSize > pPageSize || (flag !== 0 && actualSize !== pPageSize)) {
+                  that.abortExport(that.$t1("服务端分页大小发生变化，导出已中止"));
+                  return;
+                }
+                pPageSize = actualSize;
+                objx.pageSize = actualSize;
+                let size = objx.records.length;
+                if (flag === 0) {
+                  let rawTotal = Number(objx.total);
+                  if (!Number.isFinite(rawTotal) || rawTotal < 0) {
+                    rawTotal = size;
+                  }
+                  let exportTotal = that.conditionExportMode
+                    ? Math.min(
+                        rawTotal,
+                        that.conditionExportConfig.maxQueryTotal
+                      )
+                    : rawTotal;
+                  that.tTotalPage = that.conditionExportMode
+                    ? Math.max(Math.ceil(exportTotal / pPageSize), 1)
+                    : objx.pages;
+                  objx.totalPages = that.tTotalPage || 1;
+                  that.tTotalSize = exportTotal;
+                  let tTotalPage = that.tTotalPage || 1;
+                  if (tTotalPage > 1) {
+                    that.exportTimer = setInterval(function () {
                       if (waitReqNum < maxWaitNum && num < tTotalPage) {
                         waitReqNum++;
                         num++;
@@ -590,11 +867,17 @@ function getGrid(that, tableRef) {
                     }, 100);
                   } else {
                     clearInterval(that.exportTimer);
-                    that.exportTimer = null;
-                  }
-                } else {
-                  if (waitReqNum > 0) waitReqNum--;
-                }
+                    that.exportTimer = null;
+                  }
+                }
+                if (that.conditionExportMode) {
+                  // 总数超过有效上限时，最后一页只写允许范围内的数据。
+                  let rowOffset = (pageNumber - 1) * pPageSize;
+                  let allowedRows = Math.max(that.tTotalSize - rowOffset, 0);
+                  objx.records = objx.records.slice(0, allowedRows);
+                }
+                // 注意：此处不再释放并发窗口。拉取完成只是这一页做完了一半，
+                // 窗口由 handleData 在上送(addExcelData)落地后释放，见那里的注释。
 
                 setTimeout(function () {
                   handleData(resultMsg, flag);
@@ -611,6 +894,8 @@ function getGrid(that, tableRef) {
               }
             })
             .catch(function (e) {
+              // 取消导致的 reject 不是失败，也不该重试或弹提示
+              if (that.isExportStopped()) return;
               console.error(e);
               if (retryCount < 1) {
                 setTimeout(function () {
@@ -641,6 +926,7 @@ function getGrid(that, tableRef) {
           data: datas,
           modal: loading || false,
           isLoading: loading,
+          cancelToken: this.getCancelToken(),
         });
       },
       /*getExportTitleJson() {
@@ -742,21 +1028,31 @@ function getGrid(that, tableRef) {
         }
         return titleArr;
       },
-      addExcelData(opts, loading) {
+      async addExcelData(opts, loading) {
         let target = opts.target;
         let pageNumber = opts.pageNumber || 1;
         let callback = opts.callback;
-        let datas = this.getExcelData(opts.rows);
+        // 已取消就不要再算、更不要再发。这里是所有上送的唯一入口，卡住它等于卡住
+        // 取消之后的全部后续动作。
+        if (this.isExportStopped()) {
+          return { type: "abort" };
+        }
+        let datas = await this.getExcelData(opts.rows);
+        // 取值过程中导出已被中止（getExcelData 让出主线程时会检查），不再上送这一页。
+        // 返回非 success 让调用方走它自己的中止分支，abortExport 幂等不会重复弹窗。
+        if (datas === null) {
+          return { type: "abort" };
+        }
         let cUUid = this.uuid;
         let ippaaapp = this.ippaaapp;
-        let url1 =
-          this.CURRENT_PREFIX +
-          "/excel/appendExcelData?uuid=" +
-          cUUid +
-          "&ippaaapp=" +
-          ippaaapp +
-          "&pageNumber=" +
-          pageNumber;
+        let url1
+          = this.CURRENT_PREFIX
+          + "/excel/appendExcelData?uuid="
+          + cUUid
+          + "&ippaaapp="
+          + ippaaapp
+          + "&pageNumber="
+          + pageNumber;
         return this.$http({
           url: url1,
           method: "post",
@@ -766,20 +1062,22 @@ function getGrid(that, tableRef) {
           data: datas,
           modal: loading || false,
           isLoading: loading || false,
+          cancelToken: this.getCancelToken(),
         });
       },
       mergeExcel(startPage, endPage, loading) {
-        let url1 =
-          this.CURRENT_PREFIX +
-          "/excel/mergeExcel?uuid=" +
-          this.uuid +
-          "&ippaaapp=" +
-          this.ippaaapp;
+        let url1
+          = this.CURRENT_PREFIX
+          + "/excel/mergeExcel?uuid="
+          + this.uuid
+          + "&ippaaapp="
+          + this.ippaaapp;
         return this.$http({
           url: url1 + "&startPage=" + startPage + "&endPage=" + endPage,
           method: "post",
           modal: loading || false,
           isLoading: loading || false,
+          cancelToken: this.getCancelToken(),
         });
       },
       createCountTimer() {
@@ -797,13 +1095,36 @@ function getGrid(that, tableRef) {
         this.exportTimer = null;
         this.countTimer = null;
       },
+      /**
+       * 导出全部文件合并成功：进度置满、停掉计时，并**立刻解开页签锁**。
+       * 锁只保护取数期间。文件已经生成之后弹框还开着（用户在看列表、点下载）是完全
+       * 合法的状态，那时页签必须能正常关闭 —— 解锁此前只挂在 beforeDestroy 上，
+       * 用户不点「取消/确定」就永远解不开，正是「导出完成后页签关不掉」的来源。
+       */
+      completeExport() {
+        if (!this.totalSizeKnown) {
+          this.tTotalSize = this.doneSize;
+          this.totalSizeKnown = true;
+        }
+        setTimeout(() => {
+          if (this.isExportStopped()) return;
+          this.percentageNum = parseInt(100);
+        }, 100);
+        this.clearExportTimer();
+        this.unlockMenu();
+      },
       /**
        * 中止导出：停止全部定时器并把进度条置为错误态。
        * @param {String} [msg] 需要额外弹给用户的提示；服务端已 toast 过的失败不传，避免重复提示。
        */
       abortExport(msg) {
         this.clearExportTimer();
+        // 必须先置标志再取消：取消会让其余在途请求 reject，它们的 .catch 先问
+        // isExportStopped() 才不会重复弹提示
         this.exportError = true;
+        this.cancelPendingRequests();
+        // 中止后弹框可能还挂在那儿（错误态进度条），页签没有理由继续锁着
+        this.unlockMenu();
         if (msg) this.$baseAlert(msg);
       },
       isPicture: function (suffix) {
@@ -841,10 +1162,10 @@ function getGrid(that, tableRef) {
           return column.slots.filterVal(params);
         }
         let slotDefault = column.slots && column.slots.default;
-        let hasRenderFn =
-          !!column.renderCell ||
-          typeof slotDefault === "function" ||
-          typeof slotDefault === "string";
+        let hasRenderFn
+          = !!column.renderCell
+          || typeof slotDefault === "function"
+          || typeof slotDefault === "string";
         if (!hasRenderFn) {
           let cellValue = params.row[column.field];
           if (typeof column.formatter === "function") {
@@ -858,7 +1179,7 @@ function getGrid(that, tableRef) {
         }
         return getCellValue(params);
       },
-      getExcelData(rows) {
+      async getExcelData(rows) {
         let that = this;
 
         let showImageAtTable = this.option.showImageAtTable || false;
@@ -875,8 +1196,19 @@ function getGrid(that, tableRef) {
         let contents;
         let params;
         let resultStr;
-        // 批量取值期间复用 vNode 渲染的临时实例，结束时统一销毁
-        rows.forEach(function (row, index) {
+        let index = -1;
+        for (const row of rows) {
+          index++;
+          // 每 EXPORT_YIELD_ROWS 行让出一次主线程。取值本身是同步的双层遍历，一页
+          // 默认 1000 行、渲染兜底列还要逐单元格挂载组件，整页跑完可达数秒；并发几页
+          // 几乎同时到达时主线程被连续占死，进度条不动、「取消」点不动，浏览器还可能
+          // 直接判定页面无响应而杀掉标签页。让出不减少总工作量，只保证 UI 活着。
+          if (index > 0 && index % EXPORT_YIELD_ROWS === 0) {
+            await yieldToBrowser();
+            // 让出期间用户可能已取消/导出已中止，此时继续算完这一页没有意义，
+            // 且合并根本不会发生，返回 null 让调用方跳过上送。
+            if (that.isExportStopped()) return null;
+          }
           contents = [];
           columns.forEach((column) => {
             if (column.title) {
@@ -891,27 +1223,38 @@ function getGrid(that, tableRef) {
                 //  _columnIndex
               };
               let exportType = column.params?.exportType;
-              let exportVal =
-                column.params && column.params.exportVal
+              let exportVal
+                = column.params && column.params.exportVal
                   ? column.params.exportVal
                   : null;
               if (exportVal) {
                 resultStr = exportVal(params);
+              } else if (column.params?.exportBlank && !exportType) {
+                // 列保留、格留空：没配导出类型的附件列没有可写的内容，更不该为此
+                // 逐单元格挂载附件组件去爬文件名。判定见 xform 的 isBlankExportColumn。
+                // 放在 exportVal 之后：调用方显式写了取值函数就以它为准。
+                // 必须再判一次 exportType：exportBlank 是建列时按 t.exportType 算死的，
+                // 而 params.exportType 之后还会被 tableColumnConfig 脚本覆盖，只认
+                // exportBlank 会把运行期才拿到导出类型的图片列错误地导成空。
+                resultStr = null;
               } else if (exportType === "Number") {
                 resultStr = that.getExportCellValue(params);
                 if (
-                  resultStr !== null &&
-                  resultStr !== undefined &&
-                  resultStr !== "" &&
-                  !(resultStr + "").startsWith("[EXPNUM]")
+                  resultStr !== null
+                  && resultStr !== undefined
+                  && resultStr !== ""
+                  && !(resultStr + "").startsWith("[EXPNUM]")
                 ) {
                   resultStr = "[EXPNUM]" + resultStr;
                 }
               } else if (
-                exportType === "Image" ||
-                (showImageAtTable && exportType === "Image2")
+                exportType === "Image"
+                || (showImageAtTable && exportType === "Image2")
               ) {
-                resultStr = that.getExportCellValue(params);
+                // 取值刻意延到"确实用得上"的那条分支才做：附件的正常形态是数组，
+                // 那条分支会用 row[column.field] 自己拼 [EXPIMG]，把取值结果整个覆盖；
+                // 空值分支同样直接给 null。而附件列没有 filterVal，取值会落到
+                // getCellValue 的 vNode 挂载兜底——等于每个单元格白挂一次附件组件。
                 let attachments = row[column.field];
                 if (attachments) {
                   if (Array.isArray(attachments)) {
@@ -919,9 +1262,9 @@ function getGrid(that, tableRef) {
                       that.isPicture(item.extension)
                     );
                     if (items.length > 0) {
-                      resultStr =
-                        "[EXPIMG]" +
-                        items
+                      resultStr
+                        = "[EXPIMG]"
+                        + items
                           .map((item) => {
                             let url = item.large || item.medium;
                             return item.domain + url;
@@ -931,16 +1274,18 @@ function getGrid(that, tableRef) {
                       resultStr = null;
                     }
                   } else {
+                    // 单值形态（字段里直接存 URL）才需要取值来嗅后缀
+                    resultStr = that.getExportCellValue(params);
                     if (
                       that.isPicture(
                         that.$commonFileUtil.getFileSuffix(resultStr)
                       )
                     ) {
                       if (
-                        resultStr !== null &&
-                        resultStr !== undefined &&
-                        resultStr !== "" &&
-                        !(resultStr + "").startsWith("[EXPIMG]")
+                        resultStr !== null
+                        && resultStr !== undefined
+                        && resultStr !== ""
+                        && !(resultStr + "").startsWith("[EXPIMG]")
                       ) {
                         resultStr = "[EXPIMG]" + resultStr;
                       }
@@ -959,20 +1304,45 @@ function getGrid(that, tableRef) {
             }
           });
           arr.push(contents);
-        });
+        }
         return arr;
       },
+      /**
+       * 从响应头解析下载文件名，取不到时用导出标题兜底。
+       * @param {Object} response axios 原始响应。
+       * @param {String} fallbackName 兜底文件名（不含扩展名）。
+       * @returns {String}
+       */
+      resolveDownloadFileName(response, fallbackName) {
+        let headers = response?.headers || {};
+        let disposition = headers["content-disposition"] || headers["Content-Disposition"];
+        if (disposition) {
+          // filename*=UTF-8''xxx 优先，其次 filename="xxx"
+          let starMatch = /filename\*=(?:UTF-8'')?([^;]+)/i.exec(disposition);
+          let plainMatch = /filename="?([^";]+)"?/i.exec(disposition);
+          let raw = (starMatch && starMatch[1]) || (plainMatch && plainMatch[1]);
+          if (raw) {
+            try {
+              return decodeURIComponent(raw.trim());
+            } catch (e) {
+              return raw.trim();
+            }
+          }
+        }
+        return fallbackName + ".xlsx";
+      },
       exportAll(row) {
+        let that = this;
         let cUUid = encodeURIComponent(row.uuid);
         let ippaaapp = this.ippaaapp;
         let fileName = row.title;
-        let fileUrl =
-          configUtil.baseUrl +
-          this.CURRENT_PREFIX +
-          "/excel/download?uuid=" +
-          cUUid +
-          "&ippaaapp=" +
-          ippaaapp;
+        let fileUrl
+          = configUtil.baseUrl
+          + this.CURRENT_PREFIX
+          + "/excel/download?uuid="
+          + cUUid
+          + "&ippaaapp="
+          + ippaaapp;
 
         function downLoadFile2() {
           let params = {
@@ -982,8 +1352,8 @@ function getGrid(that, tableRef) {
 
           let form = document.createElement("form");
 
-          let randomNum =
-            new Date().valueOf() + Math.floor(Math.random() * 1000000);
+          let randomNum
+            = new Date().valueOf() + Math.floor(Math.random() * 1000000);
           let formId = "formId-" + randomNum;
           let formName = "formName-" + randomNum;
 
@@ -1006,14 +1376,70 @@ function getGrid(that, tableRef) {
           document.body.removeChild(form);
         }
 
-        downLoadFile2();
+        /**
+         * 优先走 axios blob 下载：token 由 request.js 的请求拦截器注入
+         * X-Token / Authorization 头，不必再把 access_token 塞进表单字段随请求体
+         * 明文提交；失败时也能拿到响应体做判断，而表单 POST 打开新窗口后失败只会给
+         * 用户看一个空白页或一坨错误 JSON。
+         *
+         * 后端若尚未放开该接口的头鉴权（此前只认表单里的 access_token），这里会拿到
+         * JSON 错误体或直接报错 —— 一律回退到原来的表单 POST，保证下载不会因为这次
+         * 改造而失效。同体系的 /export_ins/download 已经是 blob + 头鉴权的用法
+         * （见 components/baseInputExport/mixins.js），大概率是通的，但**需联调确认**。
+         */
+        let fallbackToFormPost = function (reason) {
+          console.warn("[excelExport] blob 下载不可用，回退表单 POST：", reason);
+          downLoadFile2();
+        };
+
+        let apiUrl = `${this.CURRENT_PREFIX}/excel/download?uuid=${cUUid}&ippaaapp=${ippaaapp}&n=${encodeURIComponent(fileName)}`;
+
+        this.$http({
+          url: apiUrl,
+          method: "post",
+          data: {},
+          responseType: "blob",
+          resultType: "other",
+          modal: false,
+          // 失败要静默回退，不能先弹一个错误框
+          errorMsg: false,
+          // 刻意**不带**本次导出的取消令牌。下载不是导出流水线的一环，而是用户单独
+          // 发起的动作：分卷文件大时点完「下载」要等几秒，此时关掉进度弹框（「取消」
+          // 和「确定」都走 dialogClose2 → cancelPendingRequests）会掐断这个请求，而
+          // 下面的 isCancel 分支又刻意不回退表单 POST —— 结果是文件静默地下不下来，
+          // 且没有任何提示。旧的表单 POST 脱离组件生命周期，本就不受关弹框影响。
+          callback: (res, response) => {
+            // 后端把错误当 200 返回时，body 是 JSON / HTML 错误页而不是 xlsx 流
+            if (!isDownloadableBlob(res)) {
+              fallbackToFormPost("响应不是文件流：" + (res && res.type));
+              return;
+            }
+            let blobUrl = window.URL.createObjectURL(res);
+            let a = document.createElement("a");
+            a.href = blobUrl;
+            a.download = that.resolveDownloadFileName(response, fileName);
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            // 不释放会一直占着这份文件的内存，大导出下很可观
+            setTimeout(() => window.URL.revokeObjectURL(blobUrl), 0);
+          },
+        }).catch((e) => {
+          // 只挡真正的取消：取消后回退表单 POST 会在取消之后又弹出一次下载。
+          // 本方法已不带取消令牌，这里是防御性保留（组件销毁等外部因素仍可能取消）。
+          // 这里**不能**用 isExportStopped()——它含 exportError，而 exportAll 同时是
+          // 进度弹框里的手动下载按钮：导出中途失败后用户手动下载已生成的分卷，正是最
+          // 需要回退兜底的场景，用它拦会变成点了毫无反应。
+          if (axios.isCancel(e)) return;
+          fallbackToFormPost(e && e.message);
+        });
       },
       startProcess2(datas) {
         this.tableTarget = getGrid(this.option.vue, this.option.targetRef);
         let that = this;
         let options = this.option;
-        let title =
-          options.title || this.$t2("导出", "components.excelExport.title");
+        let title
+          = options.title || this.$t2("导出", "components.excelExport.title");
         if (!options.prefix && options.prefix !== "") {
           let originOption = this.tableTarget.params.originOption;
           let path = originOption.exportPath || originOption.path;
@@ -1035,20 +1461,49 @@ function getGrid(that, tableRef) {
         }
         this.CURRENT_PREFIX = options.prefix;
 
-        let handleData = function () {
-          let total = datas.length;
-          that
+        // 勾选/当前页导出此前把全部行塞进**一个**请求上送。`getCheckboxRecords(true)`
+        // 是跨页全量勾选，选得多时请求体轻易超限（后端/网关直接拒），而且整批取值转换
+        // 与 JSON 序列化一次性压在主线程上。改为复用条件导出那套「分页 append + 一次
+        // merge」：按 getExportPageSize() 切片顺序上送。
+        // 注意页数 ≤ 1 时（勾选量不超过一页，即绝大多数场景）请求序列与旧实现完全一致，
+        // 不引入任何行为变化；这里刻意保持**串行**，避免把条件导出那边"上送无并发闸门"
+        // 的老问题原样复制过来。
+        let pageSize = this.getExportPageSize();
+        let totalPages = Math.max(Math.ceil(datas.length / pageSize), 1);
+
+        let appendPage = function (pageNumber) {
+          let start = (pageNumber - 1) * pageSize;
+          return that
             .addExcelData(
               {
-                rows: datas,
-                pageNumber: 1,
+                rows: datas.slice(start, start + pageSize),
+                pageNumber: pageNumber,
               },
               true
             )
             .then((resultMsg2) => {
-              if (resultMsg2.type === "success") {
-                setTimeout(() => {
-                  that.mergeExcel(1, 1, true).then((resultMsg3) => {
+              if (resultMsg2.type !== "success") {
+                // "abort" 是取值过程中组件已销毁/已中止，无需再提示；
+                // 其余失败服务端已 toast 过，abortExport 不带 msg 避免重复弹
+                if (resultMsg2.type !== "abort") that.abortExport();
+                return false;
+              }
+              if (pageNumber >= totalPages) return true;
+              return appendPage(pageNumber + 1);
+            });
+        };
+
+        let handleData = function () {
+          appendPage(1)
+            .then((completed) => {
+              // 缺页合并会静默丢行，任一页失败都必须停在这里
+              if (!completed) return;
+              setTimeout(() => {
+                that
+                  .mergeExcel(1, totalPages, true)
+                  .then((resultMsg3) => {
+                    // 取消后不能再自动弹下载：那会是一个半截文件
+                    if (that.isExportStopped()) return;
                     if (resultMsg3.type === "success") {
                       let fileInfo = resultMsg3.objx;
                       let fileName = fileInfo.fileName;
@@ -1056,28 +1511,49 @@ function getGrid(that, tableRef) {
 
                       let dataMap = {};
                       dataMap["startPage"] = 1;
-                      dataMap["endPage"] = 1;
+                      dataMap["endPage"] = totalPages;
                       dataMap["title"] = title;
                       dataMap["uuid"] = fileName;
                       dataMap["fileSize"] = fileSize;
                       that.exportAll(dataMap);
+                    } else {
+                      that.abortExport();
                     }
+                  })
+                  .catch((e) => {
+                    if (that.isExportStopped()) return;
+                    console.error(e);
+                    that.abortExport(that.$t1("文件合并异常，导出已中止"));
                   });
-                }, 0);
-              }
+              }, 0);
+            })
+            .catch((e) => {
+              if (that.isExportStopped()) return;
+              console.error(e);
+              that.abortExport(that.$t1("导出数据写入失败，导出已中止"));
             });
         };
-        that.createExcelFile(true).then((resultMsg) => {
-          if (resultMsg.type === "success") {
-            let aObj = resultMsg.objx;
-            that.uuid = aObj.uuid;
-            that.nowDate = aObj.nowDate;
-            that.ippaaapp = aObj.ippaaapp;
-            setTimeout(() => {
-              handleData();
-            }, 0);
-          }
-        });
+        that
+          .createExcelFile(true)
+          .then((resultMsg) => {
+            if (that.isExportStopped()) return;
+            if (resultMsg.type === "success") {
+              let aObj = resultMsg.objx;
+              that.uuid = aObj.uuid;
+              that.nowDate = aObj.nowDate;
+              that.ippaaapp = aObj.ippaaapp;
+              setTimeout(() => {
+                handleData();
+              }, 0);
+            } else {
+              that.abortExport();
+            }
+          })
+          .catch((error) => {
+            if (that.isExportStopped()) return;
+            console.error(error);
+            that.abortExport(that.$t1("创建导出文件失败，导出已中止"));
+          });
       },
       closeExportFieldDialog() {
         this.dialogClose2();
@@ -1122,29 +1598,42 @@ function getGrid(that, tableRef) {
           }
         });
       },
+      /**
+       * 导出期间锁住当前页签（不让关），并记下锁的是哪一个，见 lockedView。
+       * 本就是固定页签（affix）的不接管 —— 那不是我们加的锁，解的时候也不能动它。
+       *
+       * 只写 user_affix，**绝不能再写 meta.affix**：isRepeatable() 见到 affix 就返回
+       * false，可重复打开的页签的 viewKey 会从 fullPath 塌成 path，于是 AppMain 的
+       * router-view key 与 BaseKeepAlive 的缓存名同时错位 —— 切走再切回整页重建。
+       * 「不让批量关闭」的语义由 tagsView 的 isPinned 认 user_affix 兜住。
+       *
+       * 定位页签用 viewKey 而不是 path：可重复打开时同一 path 会有多个页签，
+       * 按 path 找到的可能是另一个实例。
+       */
       lockMenu() {
         let vueTarget = window.$vueRoot;
-        let path = vueTarget.$route.path;
+        let key = viewKey(vueTarget.$route);
         let visitedViews = vueTarget.$store.state.tagsView.visitedViews;
-        if (visitedViews) {
-          let currentItem = visitedViews.find((item) => item.path === path);
-          if (currentItem && !currentItem.meta.affix) {
-            this.$set(currentItem.meta, "affix", true);
-            this.$set(currentItem.meta, "user_affix", true);
-          }
+        if (!visitedViews) return;
+        let currentItem = visitedViews.find((item) => viewKey(item) === key);
+        if (currentItem && !currentItem.meta.affix) {
+          this.$set(currentItem.meta, "user_affix", true);
+          this.lockedView = currentItem;
         }
       },
+      /**
+       * 解开自己锁的那一个页签。
+       * **不能**再按当前路由去查：解锁的时机是组件销毁（取消、或下一次导出把上一个
+       * 实例顶掉），那时的当前路由未必还是上锁时那一个。典型漏锁路径：A 页开始条件
+       * 导出 → 切到 B 页 → 在 B 页再点一次导出，initInstance 先销毁旧实例，旧实例按
+       * $route.path 查到的是 B（B 还没锁，什么也没做），于是 A 永久锁死。
+       * 页签可能已被别处删掉，此时改的是一个游离对象，无副作用。
+       */
       unlockMenu() {
-        let vueTarget = window.$vueRoot;
-        let path = vueTarget.$route.path;
-        let visitedViews = vueTarget.$store.state.tagsView.visitedViews;
-        if (visitedViews) {
-          let currentItem = visitedViews.find((item) => item.path === path);
-          if (currentItem && currentItem.meta.user_affix) {
-            currentItem.meta.affix = false;
-            currentItem.meta.user_affix = false;
-          }
-        }
+        let view = this.lockedView;
+        this.lockedView = null;
+        if (!view || !view.meta.user_affix) return;
+        view.meta.user_affix = false;
       },
     },
   };