@jcyao/print-sdk 1.0.1 → 1.1.0

package/dist/index.esm.js

@@ -48,8 +48,8 @@ const TABLE_DEFAULT = {
     HEADER_HEIGHT: 10,
     /** 数据行最小高度（mm） */
     MIN_ROW_HEIGHT: 8,
-    /** 行高计算系数（考虑文本换行） */
-    ROW_HEIGHT_FACTOR: 1.3,
+    /** 行高计算系数（用于 min-height，实际高度由内容撑开） */
+    ROW_HEIGHT_FACTOR: 1.0,
 };
 /**
  * 样式默认值
@@ -604,7 +604,11 @@ class TableRenderer {
         // 表头配置，过滤隐藏列
         const allColumns = (props === null || props === void 0 ? void 0 : props.columns) || [];
         const visibleColumns = allColumns.filter((col) => !col.hidden);
-        const showHeader = (props === null || props === void 0 ? void 0 : props.showHeader) !== false;
+        // 支持分页传入的 _showHeader 标记，优先于 props.showHeader
+        const explicitShowHeader = props && typeof props._showHeader === 'boolean'
+            ? props._showHeader
+            : undefined;
+        const showHeader = explicitShowHeader !== undefined ? explicitShowHeader : (props === null || props === void 0 ? void 0 : props.showHeader) !== false;
         const bordered = (props === null || props === void 0 ? void 0 : props.bordered) !== false;
         // 计算表格宽度
         let tableWidthMm;
@@ -633,9 +637,17 @@ class TableRenderer {
             // 备用：使用默认值
             tableWidthMm = COMPONENT_DEFAULT_SIZE.TABLE_WIDTH;
         }
+        // ✅ 检查 xMm 是否已超过可用宽度
+        const availableWidth = context.pageInfo
+            ? context.pageInfo.widthMm - context.pageInfo.marginMm.left - context.pageInfo.marginMm.right
+            : COMPONENT_DEFAULT_SIZE.TABLE_WIDTH;
+        if (xMm >= availableWidth) {
+            console.error(`[TableRenderer] 表格位置错误：xMm(${xMm.toFixed(2)}mm) 已超过页面可用宽度(${availableWidth.toFixed(2)}mm)，` +
+                `表格将无法正常显示。请调整表格的 x 位置，使其小于 ${availableWidth.toFixed(2)}mm`);
+        }
         // 最小宽度保护
         if (tableWidthMm < 10) {
-            console.warn(`表格宽度过小 (${tableWidthMm.toFixed(2)}mm)，强制设置为最小宽度 10mm`);
+            console.warn(`[TableRenderer] 表格宽度过小 (${tableWidthMm.toFixed(2)}mm)，强制设置为最小宽度 10mm`);
             tableWidthMm = 10;
         }
         console.log(tableWidthMm, "tableWidthMm");
@@ -647,20 +659,26 @@ class TableRenderer {
         // 单元格样式
         const cellBorder = bordered ? `border: 1px solid ${TABLE_STYLE_DEFAULT.BORDER_COLOR};` : '';
         const cellPadding = `padding: ${TABLE_STYLE_DEFAULT.CELL_PADDING};`;
-        const cellTextStyle = `white-space: normal; word-break: break-word; line-height: ${STYLE_DEFAULT.LINE_HEIGHT}; vertical-align: top;`;
+        const cellTextStyle = `white-space: normal; word-break: break-word; line-height: ${STYLE_DEFAULT.LINE_HEIGHT}; vertical-align: middle;`;
         const textAlign = (style === null || style === void 0 ? void 0 : style.textAlign) || 'left'; // 对齐方式
+        // ✅ 计算均分列宽（简化方案：按列数均分表格宽度）
+        const colCount = visibleColumns.length || 1;
+        const colWidthPercent = (100 / colCount).toFixed(2);
         // ✅ 计算表头和数据行的高度（mm 转 px）
-        const headerHeightPx = TABLE_DEFAULT.HEADER_HEIGHT * context.mmToPx; // 10mm * 3.78 = 37.8px
-        const rowHeightPx = TABLE_DEFAULT.MIN_ROW_HEIGHT * TABLE_DEFAULT.ROW_HEIGHT_FACTOR * context.mmToPx; // 10.4mm * 3.78 = 39.3px
+        // 使用全局常量 ROW_HEIGHT_FACTOR，实际高度由内容自然撑开（min-height）
+        const headerHeightPx = TABLE_DEFAULT.HEADER_HEIGHT * context.mmToPx;
+        const rowHeightPx = TABLE_DEFAULT.MIN_ROW_HEIGHT * TABLE_DEFAULT.ROW_HEIGHT_FACTOR * context.mmToPx;
         // 渲染表头
         let headerHtml = '';
         if (showHeader && visibleColumns.length > 0) {
             const headerCells = visibleColumns
                 .map((col) => {
                 const title = col.title || col.dataIndex;
-                return `<th style="${cellBorder} ${cellPadding} ${cellTextStyle} background: ${TABLE_STYLE_DEFAULT.HEADER_BACKGROUND}; font-weight: 600; text-align: ${textAlign}; height: ${headerHeightPx}px; box-sizing: border-box;">${title}</th>`;
+                // 使用百分比宽度实现均分，min-height 允许自然扩展
+                return `<th style="${cellBorder} ${cellPadding} ${cellTextStyle} background: ${TABLE_STYLE_DEFAULT.HEADER_BACKGROUND}; font-weight: 600; text-align: ${textAlign}; width: ${colWidthPercent}%; min-height: ${headerHeightPx}px; box-sizing: border-box;">${title}</th>`;
             })
                 .join('');
+            // 表头使用固定高度，表体使用 min-height
             headerHtml = `<thead class="table-header-repeat"><tr style="height: ${headerHeightPx}px;">${headerCells}</tr></thead>`;
         }
         // 渲染表体
@@ -671,17 +689,19 @@ class TableRenderer {
                 const cells = visibleColumns
                     .map((col) => {
                     const value = row[col.dataIndex] || '';
-                    return `<td style="${cellBorder} ${cellPadding} ${cellTextStyle} text-align: ${textAlign}; height: ${rowHeightPx}px; box-sizing: border-box;">${value}</td>`;
+                    // 使用百分比宽度，min-height 允许内容换行时自然扩展
+                    return `<td style="${cellBorder} ${cellPadding} ${cellTextStyle} text-align: ${textAlign}; width: ${colWidthPercent}%; min-height: ${rowHeightPx}px; box-sizing: border-box;">${value}</td>`;
                 })
                     .join('');
-                return `<tr style="height: ${rowHeightPx}px;">${cells}</tr>`;
+                // 行使用 min-height 而非固定 height
+                return `<tr style="min-height: ${rowHeightPx}px;">${cells}</tr>`;
             })
                 .join('');
             bodyHtml = `<tbody>${rows}</tbody>`;
         }
         else {
             const colspan = visibleColumns.length || 1;
-            bodyHtml = `<tbody><tr style="height: ${rowHeightPx}px;"><td colspan="${colspan}" style="${cellBorder} ${cellPadding} text-align: center; color: #999; height: ${rowHeightPx}px; box-sizing: border-box;">暂无数据</td></tr></tbody>`;
+            bodyHtml = `<tbody><tr style="min-height: ${rowHeightPx}px;"><td colspan="${colspan}" style="${cellBorder} ${cellPadding} text-align: center; color: #999; min-height: ${rowHeightPx}px; box-sizing: border-box;">暂无数据</td></tr></tbody>`;
         }
         // 渲染合计行（新增）
         const showSummary = (props === null || props === void 0 ? void 0 : props.showSummary) === true;
@@ -696,14 +716,14 @@ class TableRenderer {
             ? props._totalData
             : tableData;
         const summaryHtml = shouldShowSummary
-            ? this.renderSummary(summaryData, visibleColumns, props, cellBorder, cellPadding, cellTextStyle, rowHeightPx, textAlign)
+            ? this.renderSummary(summaryData, visibleColumns, props, cellBorder, cellPadding, cellTextStyle, rowHeightPx, textAlign, colWidthPercent)
             : '';
         return `<table class="print-table" style="${tableStyleStr}">${headerHtml}${bodyHtml}${summaryHtml}</table>`;
     }
     /**
      * 渲染合计行
      */
-    renderSummary(data, columns, props, cellBorder, cellPadding, cellTextStyle, rowHeightPx, defaultTextAlign) {
+    renderSummary(data, columns, props, cellBorder, cellPadding, cellTextStyle, rowHeightPx, defaultTextAlign, colWidthPercent = 'auto') {
         if (!columns.length)
             return '';
         const summaryLabel = props.summaryLabel || '合计';
@@ -726,7 +746,8 @@ class TableRenderer {
         ${cellPadding}
         ${cellTextStyle}
         text-align: ${col.align || defaultTextAlign};
-        height: ${rowHeightPx}px;
+        width: ${colWidthPercent}%;
+        min-height: ${rowHeightPx}px;
         box-sizing: border-box;
         background: ${bgColor};
         font-weight: ${fontWeight};
@@ -734,7 +755,7 @@ class TableRenderer {
       `.trim().replace(/\s+/g, ' ');
             return `<td style="${cellStyle}">${content}</td>`;
         }).join('');
-        return `<tfoot><tr style="height: ${rowHeightPx}px;">${cells}</tr></tfoot>`;
+        return `<tfoot><tr style="min-height: ${rowHeightPx}px;">${cells}</tr></tfoot>`;
     }
     /**
      * 计算单列合计值（使用 Decimal.js 解决精度问题）
@@ -780,25 +801,38 @@ class TableRenderer {
             }
         }
         catch (error) {
-            console.error('Summary calculation error:', error);
+            console.error('[TableRenderer] 合计计算错误:', error);
+            // ✅ 返回友好的错误提示，而不是静默失败
+            return '计算错误';
+        }
+        // ✅ 格式化前检查结果是否有效
+        if (!result || typeof result.toFixed !== 'function') {
+            console.warn('[TableRenderer] 合计结果无效:', result);
             return '-';
         }
         // 格式化
-        const precision = (_a = summary.precision) !== null && _a !== void 0 ? _a : 2;
-        const formatted = result.toFixed(precision);
-        const prefix = summary.prefix || '';
-        const suffix = summary.suffix || '';
-        return `${prefix}${formatted}${suffix}`;
+        try {
+            const precision = (_a = summary.precision) !== null && _a !== void 0 ? _a : 2;
+            const formatted = result.toFixed(precision);
+            const prefix = summary.prefix || '';
+            const suffix = summary.suffix || '';
+            return `${prefix}${formatted}${suffix}`;
+        }
+        catch (formatError) {
+            console.error('[TableRenderer] 格式化合计结果失败:', formatError);
+            return '-';
+        }
     }
     calculateHeight(component, context) {
         var _a, _b, _c;
-        // 表格高度：根据数据行数估算
+        // 表格高度：简单估算（用于初始布局计算，实际分页使用 measureTableRowHeights）
         if ((_a = component.binding) === null || _a === void 0 ? void 0 : _a.path) {
             const data = context.getValueByPath(component.binding.path);
             if (Array.isArray(data) && data.length > 0) {
                 const headerHeight = ((_b = component.props) === null || _b === void 0 ? void 0 : _b.showHeader) !== false ? TABLE_DEFAULT.HEADER_HEIGHT : 0;
-                const rowHeight = TABLE_DEFAULT.MIN_ROW_HEIGHT * TABLE_DEFAULT.ROW_HEIGHT_FACTOR;
-                const summaryHeight = ((_c = component.props) === null || _c === void 0 ? void 0 : _c.showSummary) === true ? rowHeight : 0; // 新增：合计行高度
+                // 使用基础行高（不乘系数），实际高度由渲染后测量决定
+                const rowHeight = TABLE_DEFAULT.MIN_ROW_HEIGHT;
+                const summaryHeight = ((_c = component.props) === null || _c === void 0 ? void 0 : _c.showSummary) === true ? rowHeight : 0;
                 return headerHeight + data.length * rowHeight + summaryHeight;
             }
         }
@@ -1187,6 +1221,11 @@ class PrintEngine {
      * 计算表头高度（mm）
      */
     calculateTableHeaderHeight(comp) {
+        var _a;
+        // 如果用户设置 showHeader: false，则表头高度为 0
+        if (((_a = comp.props) === null || _a === void 0 ? void 0 : _a.showHeader) === false) {
+            return 0;
+        }
         // 使用 TABLE_DEFAULT.HEADER_HEIGHT 作为表头高度
         return TABLE_DEFAULT.HEADER_HEIGHT;
     }
@@ -1307,7 +1346,7 @@ class PrintEngine {
      * 2. 按顺序累加高度，遇到表格就拆分
      * 3. 换页时从 marginTop 开始，忽略原 gap
      */
-    calculatePages(components) {
+    async calculatePages(components) {
         var _a, _b, _c;
         const { page } = this.template;
         const { heightMm } = this.getPageSize();
@@ -1327,8 +1366,10 @@ class PrintEngine {
                 return { comp, gap: (comp.layout.yMm || 0) };
             }
             const prevComp = sortedComponents[index - 1];
+            // ✅ 使用设计高度计算相对间距（保留负数，表示组件重叠）
+            // 注意：表格的实际高度会在 splitTableWithGap 中重新计算
             const prevBottom = (prevComp.layout.yMm || 0) + (prevComp.layout.heightMm || 0);
-            const gap = (comp.layout.yMm || 0) - prevBottom;
+            const gap = (comp.layout.yMm || 0) - prevBottom; // 保留负数，表示组件重叠
             return { comp, gap };
         });
         // 3. 遍历组件，累加高度
@@ -1338,8 +1379,13 @@ class PrintEngine {
         let currentPageHeight = marginTop; // 当前页的累计高度
         let isFirstComponentInPage = true; // 标记当前页是否是第一个组件
         for (let i = 0; i < componentsWithGaps.length; i++) {
-            const { comp, gap } = componentsWithGaps[i];
+            const { comp, gap: designGap } = componentsWithGaps[i];
             const compHeightMm = comp.layout.heightMm || 50;
+            // ✅ 使用设计时的相对间距（保留负数，表示组件重叠）
+            // designGap 是设计时计算的：组件B.yMm - (组件A.yMm + 组件A.heightMm)
+            // 这代表了设计意图中的"组件A底部到组件B顶部的间距"
+            // 负数表示组件重叠，这是设计时允许的布局方式
+            const actualGap = designGap;
             // 边界检查：组件高度接近页面高度时输出警告
             if (compHeightMm > availableHeightMm * 0.8) {
                 console.warn(`组件 ${comp.id} (${comp.type}) 高度 ${compHeightMm.toFixed(2)}mm 接近页面可用高度 ${availableHeightMm.toFixed(2)}mm，可能影响分页效果`);
@@ -1348,14 +1394,16 @@ class PrintEngine {
             if (comp.type === 'table' && ((_c = comp.binding) === null || _c === void 0 ? void 0 : _c.path)) {
                 const tableData = context.getValueByPath(comp.binding.path);
                 if (Array.isArray(tableData) && tableData.length > 0) {
-                    const result = this.splitTableWithGap(comp, tableData, gap, isFirstComponentInPage, availableHeightMm, currentPageHeight, pages, currentPage);
+                    const result = await this.splitTableWithGap(comp, tableData, actualGap, isFirstComponentInPage, availableHeightMm, currentPageHeight, pages, currentPage);
                     currentPage = result.currentPage;
-                    currentPageHeight = result.currentPageHeight;
-                    isFirstComponentInPage = false; // 表格后不再是第一个
+                    // ✅ 对于紧跟表格的组件，使用表格实际底部位置作为参考
+                    // 这样可以确保无论表格是否跨页，后续组件与表格的相对间距保持一致
+                    currentPageHeight = result.lastTableFragmentBottom;
+                    isFirstComponentInPage = false; // 表格后的组件不是页面第一个组件
                 }
                 else {
                     // 空表格：按普通组件处理
-                    if (this.shouldBreakPage(currentPageHeight, compHeightMm, gap, availableHeightMm, isFirstComponentInPage) && currentPage.length > 0) {
+                    if (this.shouldBreakPage(currentPageHeight, compHeightMm, actualGap, availableHeightMm, isFirstComponentInPage) && currentPage.length > 0) {
                         // 换页
                         pages.push(currentPage);
                         currentPage = [];
@@ -1371,7 +1419,7 @@ class PrintEngine {
                     }
                     else {
                         // 同一页：应用 gap
-                        currentPageHeight += gap;
+                        currentPageHeight += actualGap;
                         compCopy.layout.yMm = currentPageHeight;
                         currentPageHeight += compHeightMm;
                     }
@@ -1382,7 +1430,7 @@ class PrintEngine {
             // 4.2 普通组件：按相对间距累加高度
             else {
                 // 使用辅助方法判断是否需要换页
-                if (this.shouldBreakPage(currentPageHeight, compHeightMm, gap, availableHeightMm, isFirstComponentInPage) && currentPage.length > 0) {
+                if (this.shouldBreakPage(currentPageHeight, compHeightMm, actualGap, availableHeightMm, isFirstComponentInPage) && currentPage.length > 0) {
                     // 换页
                     pages.push(currentPage);
                     currentPage = [];
@@ -1392,13 +1440,15 @@ class PrintEngine {
                 // 创建组件副本，避免修改原数据
                 const compCopy = Object.assign(Object.assign({}, comp), { layout: Object.assign({}, comp.layout) });
                 if (isFirstComponentInPage) {
-                    // 新页面第一个组件：忽略 gap
+                    // 新页面第一个组件：应用 gap（从页面顶部开始的相对间距）
+                    // 注意：即使在新页面，也应该保持设计时的相对间距
+                    currentPageHeight += actualGap;
                     compCopy.layout.yMm = currentPageHeight;
                     currentPageHeight += compHeightMm;
                 }
                 else {
                     // 同一页：应用 gap
-                    currentPageHeight += gap;
+                    currentPageHeight += actualGap;
                     compCopy.layout.yMm = currentPageHeight;
                     currentPageHeight += compHeightMm;
                 }
@@ -1413,24 +1463,140 @@ class PrintEngine {
         // 6. 返回分页结果
         return pages.length > 0 ? pages : [components];
     }
+    /**
+     * 测量表格实际行高（渲染后测量方案）
+     * 将表格渲染到隐藏容器，测量表头、数据行和合计行的实际高度
+     */
+    async measureTableRowHeights(tableComponent, tableData) {
+        var _a;
+        // 检查是否在浏览器环境
+        if (typeof document === 'undefined') {
+            // 服务器端：使用估算值
+            const baseRowHeight = this.calculateTableRowHeight(tableComponent);
+            return {
+                headerHeight: this.calculateTableHeaderHeight(tableComponent),
+                rowHeights: tableData.map(() => baseRowHeight),
+                summaryHeight: baseRowHeight
+            };
+        }
+        const renderer = this.renderers.get('table');
+        if (!renderer) {
+            const baseRowHeight = this.calculateTableRowHeight(tableComponent);
+            return {
+                headerHeight: this.calculateTableHeaderHeight(tableComponent),
+                rowHeights: tableData.map(() => baseRowHeight),
+                summaryHeight: baseRowHeight
+            };
+        }
+        // 计算与 TableRenderer 一致的表格宽度
+        const context = this.createRenderContext();
+        const xMm = tableComponent.layout.xMm || 0;
+        let tableWidthMm;
+        if (tableComponent.layout.widthMm) {
+            tableWidthMm = tableComponent.layout.widthMm;
+            if (context.pageInfo) {
+                const availableWidth = context.pageInfo.widthMm - context.pageInfo.marginMm.left - context.pageInfo.marginMm.right;
+                const totalOccupied = xMm + tableWidthMm;
+                if (totalOccupied > availableWidth) {
+                    tableWidthMm = availableWidth - xMm;
+                }
+            }
+        }
+        else if (context.pageInfo) {
+            const availableWidth = context.pageInfo.widthMm - context.pageInfo.marginMm.left - context.pageInfo.marginMm.right;
+            tableWidthMm = availableWidth - xMm;
+        }
+        else {
+            tableWidthMm = COMPONENT_DEFAULT_SIZE.TABLE_WIDTH;
+        }
+        // 创建隐藏测量容器
+        const measureContainer = document.createElement('div');
+        measureContainer.style.cssText = `
+      position: absolute;
+      visibility: hidden;
+      left: -9999px;
+      top: 0;
+      width: ${tableWidthMm}mm;
+      pointer-events: none;
+    `;
+        // 创建完整的表格组件用于测量（包含合计行）
+        // 使用用户实际的 showHeader 和 bordered 设置，确保测量准确
+        const measureComponent = Object.assign(Object.assign({}, tableComponent), { props: Object.assign(Object.assign({}, tableComponent.props), { _pageData: tableData, _showHeader: ((_a = tableComponent.props) === null || _a === void 0 ? void 0 : _a.showHeader) !== false, _isLastPage: true }) });
+        // 渲染表格
+        const tableHtml = renderer.render(measureComponent, context);
+        measureContainer.innerHTML = `
+      <div style="width: ${tableWidthMm}mm; position: relative;">
+        ${tableHtml}
+      </div>
+    `;
+        document.body.appendChild(measureContainer);
+        try {
+            // ✅ 测量表头高度（如果存在）
+            let headerHeight = 0;
+            const headerRow = measureContainer.querySelector('thead tr');
+            if (headerRow) {
+                headerHeight = headerRow.offsetHeight / this.mmToPx;
+            }
+            // 测量数据行高度
+            const rows = measureContainer.querySelectorAll('tbody tr');
+            const rowHeights = [];
+            rows.forEach((row) => {
+                const heightPx = row.offsetHeight;
+                const heightMm = heightPx / this.mmToPx;
+                rowHeights.push(heightMm);
+            });
+            // ✅ 测量合计行高度（如果存在）
+            let summaryHeight = 0;
+            const summaryRow = measureContainer.querySelector('tfoot tr');
+            if (summaryRow) {
+                summaryHeight = summaryRow.offsetHeight / this.mmToPx;
+            }
+            // 如果测量失败，使用估算值
+            if (rowHeights.length === 0) {
+                const baseRowHeight = this.calculateTableRowHeight(tableComponent);
+                return {
+                    headerHeight: this.calculateTableHeaderHeight(tableComponent),
+                    rowHeights: tableData.map(() => baseRowHeight),
+                    summaryHeight: baseRowHeight
+                };
+            }
+            return { headerHeight, rowHeights, summaryHeight };
+        }
+        finally {
+            // 确保无论成功或失败，都清理测量容器
+            if (measureContainer.parentNode) {
+                document.body.removeChild(measureContainer);
+            }
+        }
+    }
     /**
      * 表格跨页拆分（基于相对间距）
-     * 支持 repeatHeader 配置、精确行高计算、空表格检查
+     * 支持 repeatHeader 配置、渲染后测量、空表格检查
      */
-    splitTableWithGap(tableComponent, tableData, gap, isFirstComponentInPage, availableHeightMm, currentPageHeight, pages, currentPage) {
+    async splitTableWithGap(tableComponent, tableData, gap, isFirstComponentInPage, availableHeightMm, currentPageHeight, pages, currentPage) {
         var _a, _b, _c, _d, _e;
         // 读取配置：是否重复表头（默认 true）
         const repeatHeader = ((_b = (_a = tableComponent.props) === null || _a === void 0 ? void 0 : _a.pagination) === null || _b === void 0 ? void 0 : _b.repeatHeader) !== false;
-        // 使用精确计算的高度
-        const headerHeight = this.calculateTableHeaderHeight(tableComponent);
-        const rowHeight = this.calculateTableRowHeight(tableComponent);
         const marginTop = ((_c = this.template.page.marginMm) === null || _c === void 0 ? void 0 : _c.top) || 0;
+        // 记录初始页面数，用于判断表格是否跨页
+        const initialPagesLength = pages.length;
         // 空表格检查
         if (tableData.length === 0) {
             console.info('表格无数据，跳过渲染');
-            return { currentPage, currentPageHeight };
+            return { currentPage, currentPageHeight, isTableSplitAcrossPages: false, lastTableFragmentBottom: currentPageHeight };
+        }
+        // ✅ 渲染后测量：获取表头、数据行和合计行的实际高度
+        let { headerHeight, rowHeights, summaryHeight: measuredSummaryHeight } = await this.measureTableRowHeights(tableComponent, tableData);
+        // 检查测量结果是否有效（防止所有列 hidden 等情况导致长度不一致）
+        if (rowHeights.length !== tableData.length) {
+            console.warn(`[PrintEngine] 表格测量结果异常：rowHeights.length (${rowHeights.length}) != tableData.length (${tableData.length})，` +
+                `可能所有列均为 hidden，使用估算行高继续分页`);
+            // 使用估算行高替换测量结果
+            const fallbackRowHeight = this.calculateTableRowHeight(tableComponent);
+            rowHeights = tableData.map(() => fallbackRowHeight);
         }
         let remainingData = [...tableData];
+        let remainingRowHeights = [...rowHeights];
         let workingPage = [...currentPage];
         let workingPageHeight = currentPageHeight;
         let isFirstFragment = true;
@@ -1442,11 +1608,22 @@ class PrintEngine {
             if (isFirstFragment && !isFirstComponentInPage) {
                 remainingHeight -= gap;
             }
-            // 计算能放多少行
             // 如果 repeatHeader = false 且是第一个片段，则表头已经在第一页了，后续页不需要表头
             const needHeader = isFirstFragment || repeatHeader;
-            const availableForRows = remainingHeight - (needHeader ? headerHeight : 0);
-            const rowsCanFit = Math.floor(availableForRows / rowHeight);
+            let availableForRows = remainingHeight - (needHeader ? headerHeight : 0);
+            // ✅ 使用实际测量的行高计算能放多少行
+            let rowsCanFit = 0;
+            let accumulatedHeight = 0;
+            for (let i = 0; i < remainingRowHeights.length; i++) {
+                const rowHeight = remainingRowHeights[i];
+                if (accumulatedHeight + rowHeight <= availableForRows) {
+                    accumulatedHeight += rowHeight;
+                    rowsCanFit++;
+                }
+                else {
+                    break;
+                }
+            }
             // 确保至少有 1 行数据（避免只有表头的空页面）
             if (rowsCanFit <= 0) {
                 // 当前页放不下，换页
@@ -1460,25 +1637,28 @@ class PrintEngine {
             }
             // 取出当前页能放的数据
             const dataForThisPage = remainingData.slice(0, rowsCanFit);
+            const rowHeightsForThisPage = remainingRowHeights.slice(0, rowsCanFit);
             remainingData = remainingData.slice(rowsCanFit);
+            remainingRowHeights = remainingRowHeights.slice(rowsCanFit);
             // 判断是否为最后一页（用于合计行）
             const isLastPage = remainingData.length === 0;
             // 创建当前页的表格片段
             const tableFragmentYMm = isFirstFragment
                 ? (isFirstComponentInPage ? workingPageHeight : workingPageHeight + gap)
                 : marginTop;
-            const tableFragment = Object.assign(Object.assign({}, tableComponent), { layout: Object.assign(Object.assign({}, tableComponent.layout), { yMm: tableFragmentYMm }), props: Object.assign(Object.assign({}, tableComponent.props), { _pageData: dataForThisPage, _showHeader: needHeader, _isLastPage: isLastPage, _totalData: tableData // 传递全量数据（用于 total 模式合计）
+            const tableFragment = Object.assign(Object.assign({}, tableComponent), { layout: Object.assign(Object.assign({}, tableComponent.layout), { yMm: tableFragmentYMm }), props: Object.assign(Object.assign({}, tableComponent.props), { _pageData: dataForThisPage, _showHeader: needHeader, _isLastPage: isLastPage, _totalData: tableData, _rowHeights: rowHeightsForThisPage // 传递实际行高到渲染器
                  }) });
             workingPage.push(tableFragment);
             // 计算合计行高度（如果启用合计功能）
             const showSummary = ((_d = tableComponent.props) === null || _d === void 0 ? void 0 : _d.showSummary) === true;
             const summaryMode = ((_e = tableComponent.props) === null || _e === void 0 ? void 0 : _e.summaryMode) || 'total';
-            const shouldShowSummaryOnThisPage = showSummary && (summaryMode === 'page' || // 每页都显示合计
-                (summaryMode === 'total' && isLastPage) // 仅最后一页显示合计
-            );
-            const summaryHeight = shouldShowSummaryOnThisPage ? rowHeight : 0; // 合计行高度等于一行高度
-            // 更新当前页高度（包含合计行）
-            const tableFragmentHeight = (needHeader ? headerHeight : 0) + dataForThisPage.length * rowHeight + summaryHeight;
+            const shouldShowSummaryOnThisPage = showSummary && (summaryMode === 'page' ||
+                (summaryMode === 'total' && isLastPage));
+            // ✅ 使用测量的合计行高度，如果没有测量值则使用平均行高
+            const avgRowHeight = rowHeightsForThisPage.reduce((a, b) => a + b, 0) / rowHeightsForThisPage.length;
+            const summaryHeight = shouldShowSummaryOnThisPage ? (measuredSummaryHeight || avgRowHeight) : 0;
+            // 更新当前页高度（使用实际测量的行高累加）
+            const tableFragmentHeight = (needHeader ? headerHeight : 0) + accumulatedHeight + summaryHeight;
             if (isFirstFragment && !isFirstComponentInPage) {
                 workingPageHeight += gap + tableFragmentHeight;
             }
@@ -1493,15 +1673,19 @@ class PrintEngine {
                 isFirstFragment = false;
             }
         }
+        // 判断表格是否跨页（即是否产生了多个页面片段）
+        const isTableSplitAcrossPages = pages.length > initialPagesLength;
         return {
             currentPage: workingPage,
-            currentPageHeight: workingPageHeight
+            currentPageHeight: workingPageHeight,
+            isTableSplitAcrossPages, // ✅ 返回表格是否跨页的信息
+            lastTableFragmentBottom: workingPageHeight // ✅ 返回最后一个表格片段的底部位置
         };
     }
     /**
      * 生成打印 HTML
      */
-    generatePrintHTML() {
+    async generatePrintHTML() {
         var _a, _b, _c, _d;
         const { page, components } = this.template;
         const { widthMm, heightMm } = this.getPageSize();
@@ -1530,7 +1714,7 @@ class PrintEngine {
             });
         }
         // 标准页面模式：虚拟分页，生成多个独立的页面
-        const pages = this.calculatePages(components);
+        const pages = await this.calculatePages(components);
         const totalPages = pages.length;
         // 渲染每个页面
         const pagesHTML = pages.map((pageComponents, index) => {
@@ -1563,8 +1747,8 @@ function createPrintEngine(template, data) {
         /**
          * 生成完整打印 HTML
          */
-        generatePrintHTML() {
-            return engine.generatePrintHTML();
+        async generatePrintHTML() {
+            return await engine.generatePrintHTML();
         },
         /**
          * 注册自定义渲染器
@@ -1663,6 +1847,32 @@ async function waitForPrintResourcesReady(doc, timeout = 10000) {
  * 提供完整的打印功能封装
  * 解耦设计：直接接收模板数据，不依赖模板服务
  */
+/**
+ * ✅ 使用 DOMParser 提取 HTML body 内容（比正则更健壮）
+ * @param html 完整的 HTML 字符串
+ * @returns body 内的内容，如果解析失败返回 null
+ */
+function extractBodyContent(html) {
+    var _a, _b, _c;
+    try {
+        // 使用 DOMParser 解析 HTML
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(html, 'text/html');
+        // 获取 body 内容
+        const bodyContent = (_b = (_a = doc.body) === null || _a === void 0 ? void 0 : _a.innerHTML) === null || _b === void 0 ? void 0 : _b.trim();
+        if (!bodyContent) {
+            console.warn('[PrintSDK] 无法提取 body 内容');
+            return null;
+        }
+        return bodyContent;
+    }
+    catch (error) {
+        console.error('[PrintSDK] 解析 HTML 失败:', error);
+        // 兜底：使用正则提取
+        const bodyMatch = html.match(/<body[^>]*>([\s\S]*)<\/body>/i);
+        return ((_c = bodyMatch === null || bodyMatch === void 0 ? void 0 : bodyMatch[1]) === null || _c === void 0 ? void 0 : _c.trim()) || null;
+    }
+}
 class PrintSDK {
     // 无需配置和缓存，完全解耦
     /**
@@ -1682,7 +1892,7 @@ class PrintSDK {
             if (!printWindow) {
                 throw new Error('Failed to open print window. Please check browser settings.');
             }
-            const html = engine.generatePrintHTML();
+            const html = await engine.generatePrintHTML();
             printWindow.document.write(html);
             printWindow.document.close();
             // 等待所有图片加载完成后再打印
@@ -1696,7 +1906,7 @@ class PrintSDK {
             iframe.style.top = '-9999px';
             iframe.style.left = '-9999px';
             document.body.appendChild(iframe);
-            const html = engine.generatePrintHTML();
+            const html = await engine.generatePrintHTML();
             const iframeDoc = (_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.document;
             if (!iframeDoc) {
                 throw new Error('Failed to access iframe document');
@@ -1706,11 +1916,25 @@ class PrintSDK {
             // 等待所有图片加载完成后再打印
             // 注意：二维码和条形码已同步生成为base64，主要等待外部图片资源
             await waitForImagesLoaded(iframeDoc);
+            // ✅ 监听打印完成事件后再移除 iframe
+            const cleanup = () => {
+                if (iframe.parentNode) {
+                    document.body.removeChild(iframe);
+                }
+            };
+            // 优先使用 afterprint 事件（现代浏览器支持）
+            if (iframe.contentWindow) {
+                iframe.contentWindow.addEventListener('afterprint', cleanup, { once: true });
+            }
+            // 触发打印
             (_b = iframe.contentWindow) === null || _b === void 0 ? void 0 : _b.print();
-            // 打印完成后移除 iframe
+            // 兜底：如果 afterprint 事件未触发（如用户取消打印），5秒后清理
             setTimeout(() => {
-                document.body.removeChild(iframe);
-            }, 1000);
+                if (iframe.parentNode) {
+                    console.warn('[PrintSDK] afterprint 事件未触发，执行兜底清理');
+                    cleanup();
+                }
+            }, 5000);
         }
     }
     /**
@@ -1737,7 +1961,7 @@ class PrintSDK {
      */
     async generateHTML(template, data) {
         const engine = createPrintEngine(template, data);
-        return engine.generatePrintHTML();
+        return await engine.generatePrintHTML();
     }
     /**
      * 批量打印（同模板多数据）
@@ -1766,11 +1990,11 @@ class PrintSDK {
             onProgress === null || onProgress === void 0 ? void 0 : onProgress(progress);
             try {
                 const engine = createPrintEngine(template, data);
-                const html = engine.generatePrintHTML();
-                // 提取 <body> 标签中的内容（即所有 .print-page）
-                const bodyMatch = html.match(/<body[^>]*>([\s\S]*)<\/body>/i);
-                if (bodyMatch && bodyMatch[1]) {
-                    allPagesHTML.push(bodyMatch[1].trim());
+                const html = await engine.generatePrintHTML();
+                // ✅ 提取 <body> 标签中的内容（使用 DOMParser 代替正则，更健壮）
+                const bodyContent = extractBodyContent(html);
+                if (bodyContent) {
+                    allPagesHTML.push(bodyContent);
                 }
                 progress.completed++;
                 onProgress === null || onProgress === void 0 ? void 0 : onProgress(progress);