cloud-web-corejs 1.1.0-dev.10 → 1.1.0-dev.13

package/src/components/excelExport/mixins.js

@@ -1,11 +1,13 @@
 /**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 { viewKey } from "@base/utils/repeatOpen";
 
 let configUtil = {
   baseUrl: process.env.VUE_APP_BASE_API,
@@ -13,6 +15,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])) {
@@ -93,6 +134,17 @@ function getGrid(that, tableRef) {
         exportTimer: null,
         countTimer: null,
         exportError: false,
+        // 用户点「取消」/组件被销毁的终止标记。此前取消只是停掉定时器 + 销毁组件，
+        // 已经发出去的那几页请求照样会回调下来继续上送、继续合并，甚至最后弹出一个
+        // 半截文件的下载。所有异步续点都要先问 isExportStopped()。
+        aborted: false,
+        // 本次导出全部请求共用的取消令牌源，取消时一次性掐断在途请求
+        cancelSource: null,
+        // lockMenu 实际锁上的那一个页签。必须记下来：解锁若再按「当时的
+        // $route.path」现查，用户在导出期间切了页签（弹框可最小化，切走完全合法）
+        // 解的就是另一把锁 —— 原页签会永久 affix，而 tagsView 的 delOthersViews /
+        // delAllViews 都保留 affix，「关闭其他」「全部关闭」也删不掉它，只能刷新页面。
+        lockedView: null,
       };
     },
     created() {},
@@ -100,10 +152,46 @@ function getGrid(that, tableRef) {
       // 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 +237,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",
@@ -202,10 +293,13 @@ function getGrid(that, tableRef) {
           this.abortExport(
             this.$t1("无法确定导出服务前缀，请在导出配置中指定 prefix")
           );
-          this.unlockMenu();
           return;
         }
         this.CURRENT_PREFIX = options.prefix;
+        // 取数走 originOption.exportAjax 时请求由 xform 侧构造，前端拿不到那个 config，
+        // 只能把令牌顺着导出参数带过去（data-table-mixin 的 exportAjax 会塞进
+        // customParam.config，最终由 formHttp 的 ...opts 透传给 axios）
+        options.cancelToken = this.getCancelToken();
 
         this.title = title;
         that.tTotalPage = 0;
@@ -213,6 +307,7 @@ function getGrid(that, tableRef) {
         that
           .createExcelFile()
           .then((resultMsg) => {
+            if (that.isExportStopped()) return;
             if (resultMsg.type === "success") {
               let aObj = resultMsg.objx;
               that.uuid = aObj.uuid;
@@ -221,6 +316,7 @@ function getGrid(that, tableRef) {
               setTimeout(function () {
                 /*num = 1;
               loopToDo(0, num);*/
+                if (that.isExportStopped()) return;
                 that.handleLoopToDo();
               }, 300);
             } else {
@@ -230,6 +326,7 @@ function getGrid(that, tableRef) {
             }
           })
           .catch((error) => {
+            if (that.isExportStopped()) return;
             console.error(error);
             that.abortExport(that.$t1("创建导出文件失败，导出已中止"));
             that.showImportDialog = false;
@@ -250,9 +347,18 @@ 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) {
+        if (this.isExportStopped()) return;
         let that = this;
         let title = this.title;
         let options = this.option;
@@ -290,6 +396,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,25 +420,17 @@ 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("文件合并异常，导出已中止"));
               });
@@ -355,14 +456,28 @@ function getGrid(that, tableRef) {
         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) {
+              releaseWindow();
               let data = resultMsg.objx;
               let total = data.total;
 
@@ -481,6 +596,8 @@ function getGrid(that, tableRef) {
               }
             })
             .catch(function (e) {
+              releaseWindow();
+              if (that.isExportStopped()) return;
               console.error(e);
               that.abortExport(that.$t1("导出数据写入失败，导出已中止"));
             });
@@ -489,6 +606,8 @@ function getGrid(that, tableRef) {
         let waitReqNum = 0;
         let promise;
         let loopToDo = function (flag, pageNumber, retryCount = 0) {
+          // 取消后不再发起新页，也不再重试（重试是从 .catch 里递归回来的）
+          if (that.isExportStopped()) return;
           let maxWaitNum = limitThreadNum;
           let nowDate = options.nowDate;
           if (flag === 1) {
@@ -508,7 +627,11 @@ function getGrid(that, tableRef) {
           let url = originOption.exportPath || originOption.path;
 
           // let params = originOption.param() || {};
-          let params = that.queryParam;
+          // 每页必须独立参数对象。此前所有页共享 that.queryParam 这一个对象，下面的
+          // Object.assign 把 current 写进去后，靠"派发间隔 100ms、微任务已 flush"侥幸
+          // 不冲突；请求拦截器一旦变成异步（token 续期等），并发的两页会带上同一个
+          // current —— 合并出的文件重复页 + 缺页，且全程不报错。
+          let params = that.$baseLodash.cloneDeep(that.queryParam);
           let aParam = {
             current: pageNumber,
             size: pPageSize,
@@ -540,6 +663,7 @@ function getGrid(that, tableRef) {
               modal: false,
               queryCreateInfo: originOption.queryCreateInfo,
               addCreateInfo: originOption.addCreateInfo,
+              cancelToken: that.getCancelToken(),
             });
           } else {
             promise = originOption.exportAjax(aParam, options);
@@ -592,9 +716,9 @@ function getGrid(that, tableRef) {
                     clearInterval(that.exportTimer);
                     that.exportTimer = null;
                   }
-                } else {
-                  if (waitReqNum > 0) waitReqNum--;
                 }
+                // 注意：此处不再释放并发窗口。拉取完成只是这一页做完了一半，
+                // 窗口由 handleData 在上送(addExcelData)落地后释放，见那里的注释。
 
                 setTimeout(function () {
                   handleData(resultMsg, flag);
@@ -611,6 +735,8 @@ function getGrid(that, tableRef) {
               }
             })
             .catch(function (e) {
+              // 取消导致的 reject 不是失败，也不该重试或弹提示
+              if (that.isExportStopped()) return;
               console.error(e);
               if (retryCount < 1) {
                 setTimeout(function () {
@@ -641,6 +767,7 @@ function getGrid(that, tableRef) {
           data: datas,
           modal: loading || false,
           isLoading: loading,
+          cancelToken: this.getCancelToken(),
         });
       },
       /*getExportTitleJson() {
@@ -742,11 +869,21 @@ 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 =
@@ -766,6 +903,7 @@ function getGrid(that, tableRef) {
           data: datas,
           modal: loading || false,
           isLoading: loading || false,
+          cancelToken: this.getCancelToken(),
         });
       },
       mergeExcel(startPage, endPage, loading) {
@@ -780,6 +918,7 @@ function getGrid(that, tableRef) {
           method: "post",
           modal: loading || false,
           isLoading: loading || false,
+          cancelToken: this.getCancelToken(),
         });
       },
       createCountTimer() {
@@ -797,13 +936,32 @@ function getGrid(that, tableRef) {
         this.exportTimer = null;
         this.countTimer = null;
       },
+      /**
+       * 导出全部文件合并成功：进度置满、停掉计时，并**立刻解开页签锁**。
+       * 锁只保护取数期间。文件已经生成之后弹框还开着（用户在看列表、点下载）是完全
+       * 合法的状态，那时页签必须能正常关闭 —— 解锁此前只挂在 beforeDestroy 上，
+       * 用户不点「取消/确定」就永远解不开，正是「导出完成后页签关不掉」的来源。
+       */
+      completeExport() {
+        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) {
@@ -858,7 +1016,7 @@ function getGrid(that, tableRef) {
         }
         return getCellValue(params);
       },
-      getExcelData(rows) {
+      async getExcelData(rows) {
         let that = this;
 
         let showImageAtTable = this.option.showImageAtTable || false;
@@ -875,8 +1033,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) {
@@ -897,6 +1066,14 @@ function getGrid(that, tableRef) {
                   : 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 (
@@ -911,7 +1088,10 @@ function getGrid(that, tableRef) {
                 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)) {
@@ -931,6 +1111,8 @@ function getGrid(that, tableRef) {
                       resultStr = null;
                     }
                   } else {
+                    // 单值形态（字段里直接存 URL）才需要取值来嗅后缀
+                    resultStr = that.getExportCellValue(params);
                     if (
                       that.isPicture(
                         that.$commonFileUtil.getFileSuffix(resultStr)
@@ -959,10 +1141,35 @@ 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;
@@ -1006,7 +1213,63 @@ 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);
@@ -1035,20 +1298,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 +1348,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 +1435,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;
       },
     },
   };