gm-printer 10.42.3-beta.0 → 10.42.3-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-printer",
-  "version": "10.42.3-beta.0",
+  "version": "10.42.3-beta.2",
   "description": "diy printer",
   "main": "src/index.js",
   "scripts": {

package/src/common/editor_store.js

@@ -263,24 +263,6 @@ class EditorStore {
     this.remainPageHeihgt = remainHeight
   }
 
-  @action
-  getFilledTableData(tableData) {
-    const { autoFillConfig } = this.config
-    if (!this.selectedRegion && !autoFillConfig?.checked) return []
-    let tr_count = 0
-
-    tr_count = Math.floor(
-      this.remainPageHeihgt / this.computedTableCustomerRowHeight
-    )
-    if (tr_count <= 0) return []
-
-    const sample = (tableData || []).find(item => item && !item._isEmptyData)
-    const dataKey =
-      this.computedTableSpecialConfig?.dataKey || autoFillConfig?.dataKey
-    const colNumber = detectColNumber(dataKey, tableData)
-    return createEmptyRows(tr_count, sample, colNumber)
-  }
-
   /** 多栏表缺失时（如双栏切三栏），从单栏/双栏源表现场打包到 mockData */
   @action
   ensureMockMultiTable(dataKey) {
@@ -345,18 +327,14 @@ class EditorStore {
       this.ensureMockMultiTable(getDataKey(dataKey, 'vertical'))
     }
 
+    // 开启时不在编辑器侧预推空行：预推依赖挂载时上报的剩余高度，布局（纸张/表格/
+    // 排列）变化后会过期，第一次开启填充会按旧基准多推，把已渲染完的表格撑到下一页。
+    // 空行统一由 Printer 侧「先分页拿基准 → 补空 → 重分页」写入（见 printer.js）
     const syncEmptyRows = key => {
       if (!this.mockData._table?.[key]) return
-      const list = this.mockData._table[key]
-      const hasHadEmptyData = _.some(list, data => data?._isEmptyData)
-      if (isAutoFilling && !hasHadEmptyData) {
-        list.push(...this.getFilledTableData(list))
-      }
       if (!isAutoFilling) {
         this.clearExtraTableData(key)
-        return
       }
-      this.mockData._table[key] = list
     }
 
     const numberEmptyRows = key => {
@@ -385,13 +363,12 @@ class EditorStore {
         const baseRowCount = sourceItems.length
           ? Math.max(1, Math.ceil(sourceItems.length / colNumber))
           : 0
-        // 钉死总行：repack 后 _isEmptyData 会变少，不能再用 emptyTable.length
+        // 钉死总行：repack 后 _isEmptyData 会变少，不能再用 emptyTable.length；
+        // 无空行时不预推，交由 Printer 按当前分页基准补
         const emptyCount = resolveVerticalEmptyCount(
           list.length,
           baseRowCount,
-          emptyTable.length > 0
-            ? emptyTable.length
-            : this.getFilledTableData(list).length,
+          emptyTable.length,
           emptyTable.length > 0
         )
         const dataRows = baseRowCount
@@ -497,6 +474,11 @@ class EditorStore {
   @action.bound
   setPageSize(field, value) {
     this.config.page.size[field] = value
+    // 页面几何变化会让预览 Printer 重挂载；行数填充开启时清掉按旧页高算出的空行，
+    // 重挂载后按新几何重补（对齐切换商品排列时的处理，见 setTableDataKeyEffect）
+    if (this.isAutoFilling || this.config?.autoFillConfig?.checked) {
+      this.clearAllTableEmptyData()
+    }
   }
 
   @computed
@@ -548,6 +530,10 @@ class EditorStore {
           height: size.width
         }
       }
+      // 可用页高变了，行数填充开启时清掉按旧方向算出的空行，重挂载后重补
+      if (this.isAutoFilling || this.config?.autoFillConfig?.checked) {
+        this.clearAllTableEmptyData()
+      }
     }
   }
 
@@ -588,6 +574,12 @@ class EditorStore {
       gap,
       name
     }
+    // 纸张类型/内边距变了，可用页高随之变化；行数填充开启时清掉按旧纸张算出的
+    // 空行（fillTableEmptyIndex 对已有空行沿用旧数量不重算，旧数量会把同页后续
+    // 表格挤到下一页），交给 Printer 重挂载后按新页高重补
+    if (this.isAutoFilling || this.config?.autoFillConfig?.checked) {
+      this.clearAllTableEmptyData()
+    }
   }
 
   @action

package/src/printer/compute_pages.js

@@ -62,7 +62,8 @@ function init() {
  *                                            影响合计行渲染与行高，进而影响分页边界）
  * @returns {Promise<{pages: Array, remainPageHeight: number, tableCustomerRowHeight: number}>}
  *          pages: [[{type, index, begin, end}, ...], ...] 对 data._table[contents[i].dataKey] 行号的切片
- *          remainPageHeight: 最后一页剩余高度（供行数填充换算）
+ *          remainPageHeight: 行数填充基准高度（填充表格最后一段所在页的剩余高度，
+ *                            无填充表格时为末页剩余；供行数填充换算）
  *          tableCustomerRowHeight: 表格行高（供行数填充换算）
  */
 function computePages({ data, config, isSomeSubtotalTr }) {

package/src/printer/multi_column.js

@@ -106,7 +106,8 @@ export const flattenHorizontalPackedRows = (rows, colNumber) => {
 export const flattenVerticalSegment = (rows, colNumber) => {
   const columns = Array.from({ length: colNumber }, () => [])
   rows.forEach(row => {
-    if (isSpecialTableRow(row)) return
+    // _isEmptyData 行的序号可能被填充过，必须显式跳过，否则会被当真实商品吸收
+    if (isSpecialTableRow(row) || row._isEmptyData) return
     splitPackedRow(row, colNumber).forEach((item, col) => {
       if (isRealItem(item)) {
         columns[col].push(stripMultiSuffixFields(item))
@@ -116,6 +117,37 @@ export const flattenVerticalSegment = (rows, colNumber) => {
   return columns.reduce((list, col) => list.concat(col), [])
 }
 
+/** 按特殊行（分类小计/标题等）把整表切成若干「组」：相邻非特殊行的 run */
+export const splitRowsIntoGroups = rows => {
+  const groups = []
+  let start = -1
+  for (let i = 0; i <= (rows || []).length; i++) {
+    const isBoundary = i === rows.length || isSpecialTableRow(rows[i])
+    if (!isBoundary && start < 0) {
+      start = i
+    }
+    if (isBoundary) {
+      if (start >= 0) {
+        groups.push({ begin: start, end: i })
+      }
+      start = -1
+    }
+  }
+  return groups
+}
+
+/**
+ * 源表（单栏/横向多栏）按特殊行分组后逐组拍平 → 每组一个商品队列。
+ * 源表不会被 repack 改写，队列是纯函数，重复执行结果不变（幂等）。
+ */
+export const buildSourceGroupQueues = (rows, colNumber) =>
+  splitRowsIntoGroups(rows).map(group =>
+    flattenHorizontalPackedRows(
+      (rows || []).slice(group.begin, group.end),
+      colNumber
+    )
+  )
+
 const assignItemToRow = (row, item, suffix) => {
   const clean = stripMultiSuffixFields(item) || {}
   Object.keys(clean).forEach(key => {
@@ -442,39 +474,34 @@ export const renumberSegmentSerialsColumnMajor = (
 
 /**
  * 按分页区间把纵向多栏数据改成「每页先左后右」。
- * - 商品按序号灌满当前段左列再排右列（含空行的整段行数）
- * - 每一行都是新建对象，清除旧右列残留
- * - fillIndex 时整段按列重编序号，有数据/无数据同一套规则
+ * - 按特殊行（分类小计等）把整表切成若干组，每组一个商品队列：
+ *   商品只从本组队列取数，永不跨组 —— 奇数商品的组余数留在本组末段空格，
+ *   不会挤占下一组（修复分类合并错位）
+ * - 每组队列优先用外部传入的源表顺序（groupQueues；源表不被 repack 改写，
+ *   重复执行幂等）；缺失时按「各页段贡献」从当前行拼接（重排的不动点，
+ *   同样幂等，但首趟不做每页重排）
+ * - 特殊行钉在原地；非特殊行都是新建对象，清除旧右列残留
+ * - fillIndex 时整段按列重编序号，有数据/无数据同一套规则，序号跨段跨组连续
  */
 export const repackVerticalTableByPageRanges = (
   rows,
   colNumber,
   pageRanges,
   fillIndex = false,
-  sourceItems
+  groupQueues = null
 ) => {
   if (!rows?.length || !pageRanges?.length || colNumber < 2) return rows
-  const items = (sourceItems && sourceItems.length
-    ? sourceItems
-    : flattenVerticalSegment(rows, colNumber)
-  ).map(stripMultiSuffixFields)
 
-  if (!items.length && !fillIndex) return rows
-
-  // 全新数组，避免与旧行对象共享引用
-  const result = new Array(rows.length)
-  for (let k = 0; k < rows.length; k++) {
-    result[k] = rows[k]
-  }
+  const groups = splitRowsIntoGroups(rows)
+  // 全新数组，避免与旧行对象共享引用；特殊行沿用原引用（钉原地）
+  const result = rows.slice()
 
-  let consumed = 0
-  let nextSerial = 1
-  pageRanges.forEach(({ begin, end }) => {
+  // 页 range 与组边界取交集得到页段，并记录所属组
+  const segments = pageRanges.reduce((list, { begin, end }) => {
     const packEnd = Math.min(end, rows.length)
     let i = begin
     while (i < packEnd) {
       if (isSpecialTableRow(rows[i])) {
-        result[i] = rows[i]
         i++
         continue
       }
@@ -482,32 +509,60 @@ export const repackVerticalTableByPageRanges = (
       while (j < packEnd && !isSpecialTableRow(rows[j])) {
         j++
       }
-
-      const rowCount = j - i
-      if (rowCount <= 0) {
-        i = j
-        continue
+      if (j > i) {
+        list.push({
+          begin: i,
+          end: j,
+          groupIndex: groups.findIndex(g => i >= g.begin && i < g.end)
+        })
       }
+      i = j
+    }
+    return list
+  }, [])
+
+  const externalQueues = groupQueues || []
+  const queues = groups.map((_, gi) => {
+    const external = externalQueues[gi]
+    if (external && external.length) {
+      return external
+    }
+    return segments
+      .filter(s => s.groupIndex === gi)
+      .reduce(
+        (list, s) =>
+          list.concat(
+            flattenVerticalSegment(rows.slice(s.begin, s.end), colNumber)
+          ),
+        []
+      )
+  })
 
-      const capacity = rowCount * colNumber
-      const chunk = items.slice(consumed, consumed + capacity)
-      const packed = packVerticalNewspaper(chunk, colNumber, rowCount, false)
-      packed.forEach((row, offset) => {
-        result[i + offset] = row
-      })
-      consumed += chunk.length
-
-      if (fillIndex) {
-        nextSerial = renumberSegmentSerialsColumnMajor(
-          result,
-          i,
-          j,
-          colNumber,
-          nextSerial
-        )
-      }
+  if (!queues.some(q => q.length) && !fillIndex) return rows
 
-      i = j
+  const consumed = groups.map(() => 0)
+  let nextSerial = 1
+  segments.forEach(({ begin, end, groupIndex }) => {
+    const rowCount = end - begin
+    const queue = queues[groupIndex]
+    const chunk = queue.slice(
+      consumed[groupIndex],
+      consumed[groupIndex] + rowCount * colNumber
+    )
+    consumed[groupIndex] += chunk.length
+    packVerticalNewspaper(chunk, colNumber, rowCount, false).forEach(
+      (row, offset) => {
+        result[begin + offset] = row
+      }
+    )
+    if (fillIndex) {
+      nextSerial = renumberSegmentSerialsColumnMajor(
+        result,
+        begin,
+        end,
+        colNumber,
+        nextSerial
+      )
     }
   })
   return result

package/src/printer/printer.js

@@ -100,6 +100,13 @@ class Printer extends React.Component {
       await this.props.printerStore.setFillIndex(nextProps.fillIndex)
       await this.props.printerStore.setData(nextProps.data)
       await this.props.printerStore.setReady(true)
+      // 与 componentDidMount 同序：先按当前数据分页拿到行数填充基准，再补空行、
+      // 按补空后的数据重新分页。缺前置分页时 changeTableData 只能用上一轮
+      // （可能已含空行）的 remainPageHeight 换算行数，开关填充时行数会偏小或偏大
+      await this.props.printerStore.computedPages()
+      // 把「未补空」基准回报给编辑器，与挂载流程同口径
+      this.props.getremainpageHeight &&
+        this.props.getremainpageHeight(this.props.printerStore.remainPageHeight)
       await this.props.printerStore.changeTableData()
       await this.props.printerStore.computedPages()
     }

package/src/printer/store.js

@@ -30,7 +30,9 @@ import {
   packHorizontalRowMajor,
   createEmptyRows,
   createEmptyRowSkeleton,
-  resolveVerticalEmptyCount
+  isSpecialTableRow,
+  splitRowsIntoGroups,
+  buildSourceGroupQueues
 } from './multi_column'
 
 export const TR_BASE_HEIGHT = 23
@@ -68,7 +70,7 @@ class PrinterStore {
 
   @observable pages = [] // [{type, index, begin, end}]
 
-  /** 当前页剩余空白高度 */
+  /** 行数填充基准：填充表格最后一段所在页的剩余空白高度；无填充表格时为末页剩余 */
   @observable remainPageHeight = 0
   @observable isSave = false
   /** data._table 非 observable，变更后递增以驱动预览重渲 */
@@ -327,6 +329,8 @@ class PrinterStore {
 
     // 使用本地数组累积分页结果，避免循环中反复触发 observable 更新
     const pages = []
+    // 各表格的行高数组（含明细拆分 splice 后的结果），供行数填充基准按同一口径复算
+    const splicedHeightsMap = {}
     // 每页必有 页眉header, 页脚footer , 签名
     const allPagesHaveThisHeight = heightMap.header + heightMap.footer
     // 退出计算! 因为页眉 + 页脚 > currentPageHeight,页面装不下其他东西
@@ -362,37 +366,9 @@ class PrinterStore {
           index++
           continue
         }
-        const {
-          subtotal,
-          dataKey,
-          summaryConfig,
-          overallOrder,
-          diySubtotal
-        } = content
-        // 如果显示每页合计,那么table高度多预留一行高度
-        const subtotalTrHeight = subtotal.show ? getSumTrHeight(subtotal) : 0
-        // 如果显示整单合计,那么table高度多预留一行高度
-        const overallOrderTrHeight = overallOrder?.show
-          ? getOverallOrderTrHeight(overallOrder)
-          : 0
-        // 如果每页合计(新的),那么table高度多预留一行高度
-        const pageSummaryTrHeight =
-          summaryConfig?.pageSummaryShow && !isMultiTable(dataKey) // 双栏table没有每页合计
-            ? getSumTrHeight(summaryConfig)
-            : 0
-
-        // 如果显示自定义每页合计,那么table高度多预留一行高度
-        const diySubtotalTrHeight = diySubtotal?.show
-          ? getOverallOrderTrHeight(diySubtotal) // 使用相同的计算方式
-          : 0
-
-        // 每个表格都具有的高度
-        const allTableHaveThisHeight =
-          table.head.height +
-          subtotalTrHeight +
-          pageSummaryTrHeight +
-          overallOrderTrHeight +
-          diySubtotalTrHeight
+        const { dataKey } = content
+        // 每个表格都具有的高度（表头 + 各类合计行），提取成方法供填充基准复用同一口径
+        const allTableHaveThisHeight = this.getTableAllHaveHeight(index)
 
         /** 当前page页面的最小高度 */
         const currentPageMinimumHeight =
@@ -408,6 +384,8 @@ class PrinterStore {
         const heights = [
           ...this.getNormalTableBodyHeights(table.body.heights, dataKey)
         ]
+        // 保留引用：该数组会被明细拆分 splice，填充基准需要用拆分后的行高
+        splicedHeightsMap[index] = heights
         const tableData = tableDataMap[dataKey] || []
         // 表格行的索引,用于table.slice(begin, end), 分割到不同页面中
         let begin = 0
@@ -609,14 +587,127 @@ class PrinterStore {
       currentPageHeight += this.getSignHeight()
     }
 
-    this.remainPageHeight = Math.round(
-      Math.max(0, pageHeight - currentPageHeight)
+    // 行数填充基准：优先取「填充表格最后一段所在页」的剩余高度（表格底部与该页
+    // 可用底边之间的空白）。旧口径固定取末页剩余，当填充表格不在末页（下方内容
+    // 被挤到下一页）时，行数按末页空间换算会超出所在页容量：多出的空行被切到
+    // 下一页渲染成空表格，或把同页后续表格挤到下一页。
+    // 填充基准不做 Math.round 向上取整，避免整行边界多算 ≤1px 导致重分页时溢出
+    const fillRemainHeight = this.computeFillTableRemainHeight(
+      pages,
+      pageHeight,
+      heightMap,
+      splicedHeightsMap
     )
+    this.remainPageHeight =
+      fillRemainHeight != null
+        ? Math.max(0, fillRemainHeight)
+        : Math.max(0, Math.round(pageHeight - currentPageHeight))
     this.isSave = false
     this.config.isSave = false
     this.repackVerticalMultiByPages()
   }
 
+  /** 表格固定高度：表头 + 每页/整单/自定义合计行（不含数据行），与 computedPages 分页口径一致 */
+  getTableAllHaveHeight(contentIndex) {
+    const table = this.tablesInfo[`contents.table.${contentIndex}`]
+    if (!table?.head) return 0
+    const content = this.config.contents[contentIndex]
+    const {
+      subtotal,
+      dataKey,
+      summaryConfig,
+      overallOrder,
+      diySubtotal
+    } = content
+    // 如果显示每页合计,那么table高度多预留一行高度
+    const subtotalTrHeight = subtotal.show ? getSumTrHeight(subtotal) : 0
+    // 如果显示整单合计,那么table高度多预留一行高度
+    const overallOrderTrHeight = overallOrder?.show
+      ? getOverallOrderTrHeight(overallOrder)
+      : 0
+    // 如果每页合计(新的),那么table高度多预留一行高度
+    const pageSummaryTrHeight =
+      summaryConfig?.pageSummaryShow && !isMultiTable(dataKey) // 双栏table没有每页合计
+        ? getSumTrHeight(summaryConfig)
+        : 0
+    // 如果显示自定义每页合计,那么table高度多预留一行高度
+    const diySubtotalTrHeight = diySubtotal?.show
+      ? getOverallOrderTrHeight(diySubtotal) // 使用相同的计算方式
+      : 0
+
+    return (
+      table.head.height +
+      subtotalTrHeight +
+      pageSummaryTrHeight +
+      overallOrderTrHeight +
+      diySubtotalTrHeight
+    )
+  }
+
+  /** 行数填充目标表格在 contents 中的索引（对齐 tableConfig 的解析口径），无法解析返回 null */
+  getFillTableContentIndex() {
+    const { autoFillConfig } = this.config
+    // checked 为 false 时 region 也保留着（编辑器开关来回切），此时同样能定位，
+    // 让基准在「未开启填充」的分页里也保持正确口径
+    if (!this.selectedRegion && !autoFillConfig?.region) return null
+    const region = this.selectedRegion || autoFillConfig.region
+    const contentIndex = Number(region.split('.')[2])
+    const content = this.config.contents[contentIndex]
+    if (!content || !_.has(content, 'dataKey')) return null
+    return contentIndex
+  }
+
+  /**
+   * 填充表格最后一段所在页的剩余高度（表格底部到该页可用底边的空白）。
+   * 高度口径与 computedPages 一致：页眉页脚 + 该页各内容
+   * （表格固定高度 + 分段行高 / panel 实测高），所在页为末页时再扣签名区。
+   * 定位不到填充表格（未配置 / 表格无数据被跳过）时返回 null，由调用方退回旧口径。
+   */
+  computeFillTableRemainHeight(
+    pages,
+    pageHeight,
+    heightMap,
+    splicedHeightsMap
+  ) {
+    const fillIndex = this.getFillTableContentIndex()
+    if (fillIndex == null || !pages?.length) return null
+
+    // 定位填充表格最后一个分段所在的页（一个表格每页至多一个分段）
+    let pageIndex = -1
+    for (let i = pages.length - 1; i >= 0; i--) {
+      if (
+        (pages[i] || []).some(
+          panel => panel?.type === 'table' && panel.index === fillIndex
+        )
+      ) {
+        pageIndex = i
+        break
+      }
+    }
+    if (pageIndex < 0) return null
+
+    // 按分页同一套口径累计该页已用高度：表格下方还有内容时一并计入，
+    // 填充就只会补「表格与后续内容之间」的空隙，不会把它们挤到下一页
+    let used = heightMap.header + heightMap.footer
+    ;(pages[pageIndex] || []).forEach(panel => {
+      if (panel.type === 'table') {
+        const heights = splicedHeightsMap[panel.index] || []
+        used += this.getTableAllHaveHeight(panel.index)
+        for (let r = panel.begin; r < panel.end; r++) {
+          used += heights[r] || 0
+        }
+      } else {
+        used += heightMap[`contents.panel.${panel.index}`] || 0
+      }
+    })
+
+    // 签名只渲染在最后一页，填充所在页为末页时同样要预留
+    const signReserve =
+      pageIndex === pages.length - 1 ? this.getSignHeight() : 0
+    const remain = pageHeight - used - signReserve
+    return Number.isFinite(remain) ? remain : null
+  }
+
   getTablePageRanges(contentIndex, rows) {
     const ranges = []
     this.pages.forEach(page => {
@@ -671,13 +762,28 @@ class PrinterStore {
       // 无商品时仍可能需要给空行按列编序号
       if (!sourceItems.length && !this.fillIndex) return
 
+      // 源表按特殊行分组 → 每组一个商品队列：商品永不跨分类小计行
+      const groupQueues = buildSourceGroupQueues(sourceRows, sourceColNumber)
+      const verticalGroups = splitRowsIntoGroups(verticalRows)
+      const lastGroup = verticalGroups[verticalGroups.length - 1]
+      const lastGroupAllEmpty =
+        lastGroup &&
+        verticalRows
+          .slice(lastGroup.begin, lastGroup.end)
+          .every(row => row?._isEmptyData)
+      // 组数对齐（允许纵向表多一个纯空行尾组=行数填充产物）才用源表队列；
+      // 否则退回「按页段贡献」兜底：最坏不做每页重排，绝不会跨组串货
+      const aligned =
+        groupQueues.length === verticalGroups.length ||
+        (groupQueues.length === verticalGroups.length - 1 && lastGroupAllEmpty)
+
       const pageRanges = this.getTablePageRanges(contentIndex, verticalRows)
       this.data._table[verticalKey] = repackVerticalTableByPageRanges(
         verticalRows,
         colNumber,
         pageRanges,
         this.fillIndex,
-        sourceItems
+        aligned ? groupQueues : null
       )
       this.dataRevision += 1
     })
@@ -983,44 +1089,16 @@ class PrinterStore {
     const emptyCount =
       emptyTable.length > 0 ? emptyTable.length : toFillEmptyCount
 
-    // 纵向多栏：源商品按对半行落位 + 追加空行；左列优先由 repack 按「数据行+空行」整段完成
+    // 纵向多栏：保留真实行（含分类小计等特殊行），仅追加空行补页；
+    // 每页先左后右、按组落位由随后的 repackVerticalMultiByPages 完成
     if (/_vertical$/.test(dataKey)) {
       const sourceKey = dataKey.replace(/_vertical$/, '')
-      const singleKey = sourceKey.replace(/_multi3?/, '')
       const colNumber = getMultiNumber(sourceKey)
-      // 横向源表缺失时先生成（双栏→三栏常见）
-      if (!this.data._table[sourceKey]?.length) {
-        this.ensureMultiTableData(sourceKey)
-      }
-      const sourceRows =
-        this.data._table[singleKey] || this.data._table[sourceKey] || []
-      const sourceColNumber = isMultiTable(singleKey)
-        ? getMultiNumber(singleKey)
-        : isMultiTable(sourceKey)
-        ? colNumber
-        : 1
-      const sourceItems = flattenHorizontalPackedRows(
-        sourceRows,
-        sourceColNumber
-      )
-      const baseRowCount = sourceItems.length
-        ? Math.max(1, Math.ceil(sourceItems.length / colNumber))
-        : 0
-      // 钉死总行：left-first repack 后 _isEmptyData 变少，不能用 emptyTable.length 回推
-      const emptyCount = resolveVerticalEmptyCount(
-        tableData.length,
-        baseRowCount,
-        emptyTable.length > 0
-          ? emptyTable.length
-          : this.getFilledTableData(table).length,
-        emptyTable.length > 0
+      const sample =
+        table.find(row => row && !isSpecialTableRow(row)) || tableData[0]
+      this.data._table[dataKey] = table.concat(
+        createEmptyRows(emptyCount, sample, colNumber)
       )
-      const dataRows = baseRowCount
-        ? packVerticalNewspaper(sourceItems, colNumber, baseRowCount, false)
-        : []
-      const sample = dataRows[0] || sourceRows[0]
-      const emptyRows = createEmptyRows(emptyCount, sample, colNumber)
-      this.data._table[dataKey] = dataRows.concat(emptyRows)
       return
     }