node-pptx-templater 1.1.6 → 1.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-pptx-templater",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "High-performance, low-level PowerPoint (PPTX) OpenXML template engine for Node.js. Dynamically replace text, insert images, update charts (with Excel workbook data caching), and merge table cells without PowerPoint corruption or Repair Mode prompts.",
   "main": "./src/index.js",
   "type": "commonjs",

package/src/core/PPTXTemplater.js

@@ -1716,7 +1716,8 @@ class PPTXTemplater {
         colIndex,
         value,
         options,
-        this.#slideManager
+        this.#slideManager,
+        this.#shapeManager
       )
     }
     return this

package/src/managers/TableManager.js

@@ -80,11 +80,7 @@ class TableManager {
    * @throws {TableNotFoundError} If the table is not found.
    */
   updateTable(slideIndex, tableId, data, slideManager, shapeManager) {
-    const { tblObj, frameObj, resolvedTableId } = this.#getTableContext(
-      slideIndex,
-      tableId,
-      slideManager
-    )
+    const { tblObj, resolvedTableId } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
     if (trs.length === 0) {
@@ -236,6 +232,7 @@ class TableManager {
       )
     }
 
+    this.#calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, true)
     this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, true)
 
     if (cellShapes) {
@@ -248,11 +245,14 @@ class TableManager {
         cellShapes,
         slideManager,
         shapeManager,
-        tblObj,
-        frameObj
+        tblObj
       )
     }
 
+    if (shapeManager) {
+      this.#repositionAllTableCellShapes(slideIndex, tableId, slideManager, shapeManager)
+    }
+
     logger.debug(
       `Updated table "${tableId}" with ${rowsData.length} rows and ${finalMerges.length} merges`
     )
@@ -484,6 +484,13 @@ class TableManager {
         )
       }
     }
+
+    this.#calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, true)
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, true)
+
+    if (shapeManager) {
+      this.#repositionAllTableCellShapes(slideIndex, tableId, slideManager, shapeManager)
+    }
   }
 
   /**
@@ -506,6 +513,9 @@ class TableManager {
 
     slideManager.markSlideObjDirty(slideIndex)
 
+    this.#calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, true)
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, true)
+
     if (shapeManager) {
       this.#adjustCellShapesAfterRowShift(
         slideIndex,
@@ -557,6 +567,9 @@ class TableManager {
 
     slideManager.markSlideObjDirty(slideIndex)
 
+    this.#calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, true)
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, true)
+
     if (shapeManager) {
       this.#adjustCellShapesAfterRowShift(
         slideIndex,
@@ -629,7 +642,16 @@ class TableManager {
    * @param {Object} options
    * @param {SlideManager} slideManager
    */
-  updateCell(slideIndex, tableId, rowIndex, colIndex, value, options = {}, slideManager) {
+  updateCell(
+    slideIndex,
+    tableId,
+    rowIndex,
+    colIndex,
+    value,
+    options = {},
+    slideManager,
+    shapeManager = null
+  ) {
     const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const row = tblObj['a:tr']?.[rowIndex]
@@ -680,6 +702,13 @@ class TableManager {
     }
 
     slideManager.markSlideObjDirty(slideIndex)
+
+    this.#calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, true)
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, true)
+
+    if (shapeManager) {
+      this.#repositionAllTableCellShapes(slideIndex, tableId, slideManager, shapeManager)
+    }
   }
 
   /**
@@ -840,6 +869,9 @@ class TableManager {
 
     slideManager.markSlideObjDirty(slideIndex)
 
+    this.#calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, true)
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, true)
+
     if (shapeManager) {
       this.#repositionCellShapesInRegion(
         slideIndex,
@@ -852,6 +884,7 @@ class TableManager {
         slideManager,
         shapeManager
       )
+      this.#repositionAllTableCellShapes(slideIndex, tableId, slideManager, shapeManager)
     }
   }
 
@@ -957,6 +990,13 @@ class TableManager {
       }
     }
 
+    this.#calculateColumnWidths(slideIndex, tableId, actualSlideManager, tblObj, true)
+    this.#calculateRowHeights(slideIndex, tableId, actualSlideManager, tblObj, true)
+
+    if (shapeManager) {
+      this.#repositionAllTableCellShapes(slideIndex, tableId, actualSlideManager, shapeManager)
+    }
+
     actualSlideManager.markSlideObjDirty(slideIndex)
   }
 
@@ -1126,11 +1166,8 @@ class TableManager {
     const tableX = xfrm?.['a:off']?.['@_x'] ? parseInt(xfrm['a:off']['@_x'], 10) : 0
     const tableY = xfrm?.['a:off']?.['@_y'] ? parseInt(xfrm['a:off']['@_y'], 10) : 0
 
-    const gridCols = tblObj['a:tblGrid']?.['a:gridCol'] || []
-    const gridColsArr = Array.isArray(gridCols) ? gridCols : [gridCols]
-    const colWidths = gridColsArr.map(col => parseInt(col['@_w'] || 0, 10))
-
-    const rowHeights = this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, false)
+    const colWidths = this.#calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, true)
+    const rowHeights = this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj, true)
 
     const R = this.getMergeRegion(slideIndex, tableId, rowIndex, colIndex, slideManager)
     let pr = rowIndex
@@ -2068,8 +2105,7 @@ class TableManager {
     cellShapes,
     slideManager,
     shapeManager,
-    tblObj,
-    frameObj
+    tblObj
   ) {
     if (!cellShapes || !shapeManager) return
 
@@ -2087,54 +2123,6 @@ class TableManager {
       }
     }
 
-    const xfrm = frameObj['p:xfrm']
-    const tableX = xfrm?.['a:off']?.['@_x'] ? parseInt(xfrm['a:off']['@_x'], 10) : 0
-    const tableY = xfrm?.['a:off']?.['@_y'] ? parseInt(xfrm['a:off']['@_y'], 10) : 0
-
-    const gridCols = tblObj['a:tblGrid']?.['a:gridCol'] || []
-    const gridColsArr = Array.isArray(gridCols) ? gridCols : [gridCols]
-    const colWidths = gridColsArr.map(col => parseInt(col['@_w'] || 0, 10))
-
-    const trsArr = tblObj['a:tr'] || []
-    const rowHeights = trsArr.map(row => parseInt(row['@_h'] || 0, 10))
-
-    const getCellBounds = (r, c) => {
-      const parent = this.getMergeParent(slideIndex, tableId, r, c, slideManager)
-      const pr = parent.row
-      const pc = parent.col
-
-      let cellLeft = tableX
-      for (let idx = 0; idx < pc; idx++) {
-        cellLeft += colWidths[idx] || 0
-      }
-
-      let cellTop = tableY
-      for (let idx = 0; idx < pr; idx++) {
-        cellTop += rowHeights[idx] || 0
-      }
-
-      const parentCell = trsArr[pr]?.['a:tc']?.[pc]
-      const gridSpan = parentCell?.['@_gridSpan'] ? parseInt(parentCell['@_gridSpan'], 10) : 1
-      const rowSpan = parentCell?.['@_rowSpan'] ? parseInt(parentCell['@_rowSpan'], 10) : 1
-
-      let cellWidth = 0
-      for (let idx = 0; idx < gridSpan; idx++) {
-        cellWidth += colWidths[pc + idx] || 0
-      }
-
-      let cellHeight = 0
-      for (let idx = 0; idx < rowSpan; idx++) {
-        cellHeight += rowHeights[pr + idx] || 0
-      }
-
-      return {
-        left: cellLeft,
-        top: cellTop,
-        width: cellWidth,
-        height: cellHeight,
-      }
-    }
-
     const shapesToCreate = []
     const headerNames = (tblObj['a:tr']?.[0]?.['a:tc'] || []).map(cell =>
       this.#getCellText(cell).trim()
@@ -2264,45 +2252,7 @@ class TableManager {
   }
 
   addCellShape(slideIndex, tableId, rowIndex, colIndex, options, slideManager, shapeManager) {
-    const { tblObj, frameObj, resolvedTableId } = this.#getTableContext(
-      slideIndex,
-      tableId,
-      slideManager
-    )
-
-    const xfrm = frameObj['p:xfrm']
-    const tableX = xfrm?.['a:off']?.['@_x'] ? parseInt(xfrm['a:off']['@_x'], 10) : 0
-    const tableY = xfrm?.['a:off']?.['@_y'] ? parseInt(xfrm['a:off']['@_y'], 10) : 0
-
-    const gridCols = tblObj['a:tblGrid']?.['a:gridCol'] || []
-    const gridColsArr = Array.isArray(gridCols) ? gridCols : [gridCols]
-    const colWidths = gridColsArr.map(col => parseInt(col['@_w'] || 0, 10))
-
-    const trsArr = tblObj['a:tr'] || []
-    const rowHeights = trsArr.map(row => parseInt(row['@_h'] || 0, 10))
-
-    const parent = this.getMergeParent(slideIndex, tableId, rowIndex, colIndex, slideManager)
-    const pr = parent.row
-    const pc = parent.col
-
-    let cellLeft = tableX
-    for (let idx = 0; idx < pc; idx++) {
-      cellLeft += colWidths[idx] || 0
-    }
-
-    let cellTop = tableY
-    for (let idx = 0; idx < pr; idx++) {
-      cellTop += rowHeights[idx] || 0
-    }
-
-    const parentCell = trsArr[pr]?.['a:tc']?.[pc]
-    const gridSpan = parentCell?.['@_gridSpan'] ? parseInt(parentCell['@_gridSpan'], 10) : 1
-    const rowSpan = parentCell?.['@_rowSpan'] ? parseInt(parentCell['@_rowSpan'], 10) : 1
-
-    let cellWidth = 0
-    for (let idx = 0; idx < gridSpan; idx++) {
-      cellWidth += colWidths[pc + idx] || 0
-    }
+    const { resolvedTableId } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const bounds = this.getCellBounds(slideIndex, tableId, rowIndex, colIndex, slideManager)
     if (!bounds) {
@@ -2357,11 +2307,7 @@ class TableManager {
     slideManager,
     shapeManager
   ) {
-    const { tblObj, frameObj, resolvedTableId } = this.#getTableContext(
-      slideIndex,
-      tableId,
-      slideManager
-    )
+    const { resolvedTableId } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const shapes = shapeManager.getShapes(slideIndex, slideManager)
     const prefix = `cellshape_${resolvedTableId}_${rowIndex}_${colIndex}_${shapeIndex}`
@@ -2608,6 +2554,253 @@ class TableManager {
     }
   }
 
+  #calculateColumnWidths(slideIndex, tableId, slideManager, tblObj, writeToXml = true) {
+    const trsArr = tblObj['a:tr'] || []
+    if (trsArr.length === 0) return []
+
+    const gridCols = tblObj['a:tblGrid']?.['a:gridCol'] || []
+    const gridColsArr = Array.isArray(gridCols) ? gridCols : [gridCols]
+    const originalWidths = gridColsArr.map(col => parseInt(col['@_w'] || 0, 10))
+    const totalTableWidth = originalWidths.reduce((sum, w) => sum + w, 0)
+    const numCols = originalWidths.length
+    if (numCols === 0) return []
+
+    // Helper to get paragraph font info
+    const getParagraphFontInfo = p => {
+      let maxSz = null
+      let typeface = null
+
+      const getTypeface = pr => {
+        if (!pr) return null
+        if (pr['a:latin']?.['@_typeface']) return pr['a:latin']['@_typeface']
+        if (pr['a:ea']?.['@_typeface']) return pr['a:ea']['@_typeface']
+        if (pr['a:cs']?.['@_typeface']) return pr['a:cs']['@_typeface']
+        return null
+      }
+
+      if (p['a:pPr']?.['a:defRPr']) {
+        const defRPr = p['a:pPr']['a:defRPr']
+        if (defRPr['@_sz']) {
+          maxSz = parseInt(defRPr['@_sz'], 10) / 100
+        }
+        typeface = getTypeface(defRPr)
+      }
+
+      if (p['a:r']) {
+        const runs = Array.isArray(p['a:r']) ? p['a:r'] : [p['a:r']]
+        for (const r of runs) {
+          if (r['a:rPr']) {
+            const rPr = r['a:rPr']
+            if (rPr['@_sz']) {
+              const szVal = parseInt(rPr['@_sz'], 10) / 100
+              if (maxSz === null || szVal > maxSz) {
+                maxSz = szVal
+              }
+            }
+            const tf = getTypeface(rPr)
+            if (tf) {
+              typeface = tf
+            }
+          }
+        }
+      }
+
+      if (maxSz === null && p['a:endParaRPr']) {
+        const endParaRPr = p['a:endParaRPr']
+        if (endParaRPr['@_sz']) {
+          maxSz = parseInt(endParaRPr['@_sz'], 10) / 100
+        }
+        const tf = getTypeface(endParaRPr)
+        if (tf) {
+          typeface = tf
+        }
+      }
+
+      return {
+        fontSize: maxSz !== null ? maxSz : 14,
+        typeface: typeface || 'Arial',
+      }
+    }
+
+    const getFontAspect = tf => {
+      if (!tf) return 0.55
+      const name = String(tf).toLowerCase()
+      if (name.includes('algerian')) return 0.85
+      return 0.55
+    }
+
+    const getCellMargins = cell => {
+      const tcPr = cell['a:tcPr']
+      const marL = tcPr?.['@_marL'] !== undefined ? parseInt(tcPr['@_marL'], 10) : 91440
+      const marR = tcPr?.['@_marR'] !== undefined ? parseInt(tcPr['@_marR'], 10) : 91440
+      return { marL, marR }
+    }
+
+    const colWeights = new Array(numCols).fill(0)
+    const hasText = new Array(numCols).fill(false)
+
+    for (let c = 0; c < numCols; c++) {
+      let maxCellWeight = 0
+
+      for (let r = 0; r < trsArr.length; r++) {
+        const row = trsArr[r]
+        const cell = row['a:tc']?.[c]
+        if (!cell || cell['@_hMerge']) continue
+
+        const gridSpan = cell['@_gridSpan'] ? parseInt(cell['@_gridSpan'], 10) : 1
+        if (gridSpan > 1) continue
+
+        const { marL, marR } = getCellMargins(cell)
+        let cellTextWidth = 0
+
+        const txBody = cell['a:txBody']
+        if (txBody) {
+          const paras = Array.isArray(txBody['a:p']) ? txBody['a:p'] : [txBody['a:p']]
+          for (const p of paras) {
+            const fontInfo = getParagraphFontInfo(p)
+            const aspect = getFontAspect(fontInfo.typeface)
+            let pText = ''
+            if (p['a:r']) {
+              const runs = Array.isArray(p['a:r']) ? p['a:r'] : [p['a:r']]
+              for (const r of runs) {
+                if (r['a:t']) {
+                  pText += String(r['a:t'])
+                }
+              }
+            }
+
+            if (pText.trim()) {
+              hasText[c] = true
+              const words = pText.split(/\s+/)
+              let longestWordLen = 0
+              for (const w of words) {
+                if (w.length > longestWordLen) longestWordLen = w.length
+              }
+
+              const minWordWidth = longestWordLen * fontInfo.fontSize * aspect * 9525 + marL + marR
+              const idealChars = Math.min(30, pText.length)
+              const idealTextWidth = idealChars * fontInfo.fontSize * aspect * 9525 + marL + marR
+
+              const cellIdeal = Math.max(minWordWidth, idealTextWidth)
+              if (cellIdeal > cellTextWidth) {
+                cellTextWidth = cellIdeal
+              }
+            }
+          }
+        }
+
+        const cellMin = cellTextWidth
+        if (cellMin > maxCellWeight) {
+          maxCellWeight = cellMin
+        }
+      }
+
+      colWeights[c] = maxCellWeight
+    }
+
+    const preferredWidths = new Array(numCols).fill(0)
+    for (let c = 0; c < numCols; c++) {
+      let floor = 500000
+      if (!hasText[c]) {
+        floor = Math.min(originalWidths[c] || 500000, 500000)
+      }
+      preferredWidths[c] = Math.max(colWeights[c], floor)
+    }
+
+    const sumPreferred = preferredWidths.reduce((sum, w) => sum + w, 0)
+
+    let finalWidths = [...preferredWidths]
+    if (sumPreferred > 0) {
+      const scale = totalTableWidth / sumPreferred
+      finalWidths = preferredWidths.map((w, idx) => {
+        const scaled = Math.round(w * scale)
+        const minAllowed = Math.min(originalWidths[idx] || 300000, 300000)
+        return Math.max(scaled, minAllowed)
+      })
+    }
+
+    const sumFinal = finalWidths.reduce((sum, w) => sum + w, 0)
+    const diff = totalTableWidth - sumFinal
+    if (diff !== 0 && finalWidths.length > 0) {
+      finalWidths[finalWidths.length - 1] += diff
+    }
+
+    if (writeToXml) {
+      const tblGrid = tblObj['a:tblGrid']
+      if (tblGrid) {
+        if (Array.isArray(tblGrid['a:gridCol'])) {
+          finalWidths.forEach((w, idx) => {
+            if (tblGrid['a:gridCol'][idx]) {
+              tblGrid['a:gridCol'][idx]['@_w'] = String(w)
+            }
+          })
+        } else if (tblGrid['a:gridCol'] && numCols === 1) {
+          tblGrid['a:gridCol']['@_w'] = String(finalWidths[0])
+        }
+      }
+    }
+
+    return finalWidths
+  }
+
+  #repositionAllTableCellShapes(slideIndex, tableId, slideManager, shapeManager) {
+    if (!shapeManager) return
+
+    const { resolvedTableId } = this.#getTableContext(slideIndex, tableId, slideManager)
+
+    const anchorsToReposition = []
+    for (const [name, anchor] of this.#cellShapeAnchors) {
+      if (anchor.slideIndex === slideIndex && anchor.resolvedTableId === resolvedTableId) {
+        anchorsToReposition.push({ name, anchor })
+      }
+    }
+
+    anchorsToReposition.sort((a, b) => {
+      if (a.anchor.rowIndex !== b.anchor.rowIndex) {
+        return a.anchor.rowIndex - b.anchor.rowIndex
+      }
+      if (a.anchor.colIndex !== b.anchor.colIndex) {
+        return a.anchor.colIndex - b.anchor.colIndex
+      }
+      const aBase =
+        typeof a.anchor.shapeIndex === 'string'
+          ? parseInt(a.anchor.shapeIndex.split('_')[0], 10)
+          : a.anchor.shapeIndex
+      const bBase =
+        typeof b.anchor.shapeIndex === 'string'
+          ? parseInt(b.anchor.shapeIndex.split('_')[0], 10)
+          : b.anchor.shapeIndex
+      return aBase - bBase
+    })
+
+    for (const { name } of anchorsToReposition) {
+      try {
+        shapeManager.deleteShape(slideIndex, name, slideManager)
+      } catch (e) {
+        logger.warn(`Failed to delete cell shape "${name}" during table reposition: ${e.message}`)
+      }
+      this.#cellShapeAnchors.delete(name)
+    }
+
+    for (const { anchor } of anchorsToReposition) {
+      try {
+        this.addCellShape(
+          slideIndex,
+          anchor.tableId,
+          anchor.rowIndex,
+          anchor.colIndex,
+          anchor.config,
+          slideManager,
+          shapeManager
+        )
+      } catch (e) {
+        logger.warn(
+          `Failed to reposition cell shape for (${anchor.rowIndex}, ${anchor.colIndex}): ${e.message}`
+        )
+      }
+    }
+  }
+
   /**
    * Generates a new rowId for the given row object.
    */
@@ -2657,35 +2850,76 @@ class TableManager {
     const numRows = trsArr.length
     const numCols = colWidths.length
 
-    // Initialize rowHeights with original height or a safe minimum floor of 228600 EMUs (~24px/pt)
     const rowHeights = trsArr.map(row => {
       const h = parseInt(row['@_h'] || 0, 10)
       return h > 0 ? h : 228600
     })
 
-    // Helper to get paragraph font size
-    const getParagraphFontSize = p => {
-      let maxSz = 14 // default 14pt
-      if (p['a:pPr']?.['a:defRPr']?.['@_sz']) {
-        maxSz = parseInt(p['a:pPr']['a:defRPr']['@_sz'], 10) / 100
+    const getParagraphFontInfo = p => {
+      let maxSz = null
+      let typeface = null
+
+      const getTypeface = pr => {
+        if (!pr) return null
+        if (pr['a:latin']?.['@_typeface']) return pr['a:latin']['@_typeface']
+        if (pr['a:ea']?.['@_typeface']) return pr['a:ea']['@_typeface']
+        if (pr['a:cs']?.['@_typeface']) return pr['a:cs']['@_typeface']
+        return null
       }
+
+      if (p['a:pPr']?.['a:defRPr']) {
+        const defRPr = p['a:pPr']['a:defRPr']
+        if (defRPr['@_sz']) {
+          maxSz = parseInt(defRPr['@_sz'], 10) / 100
+        }
+        typeface = getTypeface(defRPr)
+      }
+
       if (p['a:r']) {
         const runs = Array.isArray(p['a:r']) ? p['a:r'] : [p['a:r']]
         for (const r of runs) {
-          if (r['a:rPr']?.['@_sz']) {
-            const szVal = parseInt(r['a:rPr']['@_sz'], 10) / 100
-            if (szVal > maxSz) {
-              maxSz = szVal
+          if (r['a:rPr']) {
+            const rPr = r['a:rPr']
+            if (rPr['@_sz']) {
+              const szVal = parseInt(rPr['@_sz'], 10) / 100
+              if (maxSz === null || szVal > maxSz) {
+                maxSz = szVal
+              }
+            }
+            const tf = getTypeface(rPr)
+            if (tf) {
+              typeface = tf
             }
           }
         }
       }
-      return maxSz
+
+      if (maxSz === null && p['a:endParaRPr']) {
+        const endParaRPr = p['a:endParaRPr']
+        if (endParaRPr['@_sz']) {
+          maxSz = parseInt(endParaRPr['@_sz'], 10) / 100
+        }
+        const tf = getTypeface(endParaRPr)
+        if (tf) {
+          typeface = tf
+        }
+      }
+
+      return {
+        fontSize: maxSz !== null ? maxSz : 14,
+        typeface: typeface || 'Arial',
+      }
     }
 
-    // Helper to wrap text
-    const wrapText = (text, availWidth_px, fontSize) => {
-      const charWidth = fontSize * 0.65
+    const getFontAspect = tf => {
+      if (!tf) return 0.55
+      const name = String(tf).toLowerCase()
+      if (name.includes('algerian')) return 0.85
+      return 0.55
+    }
+
+    const wrapText = (text, availWidth_px, fontSize, aspect = 0.55) => {
+      const charWidth = fontSize * aspect
       const words = text.split(/(\s+)/)
       let linesCount = 0
       let currentLineLen = 0
@@ -2718,7 +2952,6 @@ class TableManager {
       return linesCount
     }
 
-    // Helper to get cell margins
     const getCellMargins = cell => {
       const tcPr = cell['a:tcPr']
       const marL = tcPr?.['@_marL'] !== undefined ? parseInt(tcPr['@_marL'], 10) : 91440
@@ -2728,7 +2961,6 @@ class TableManager {
       return { marL, marR, marT, marB }
     }
 
-    // Calculate required height for each cell
     const cellHeights = Array.from({ length: numRows }, () => new Array(numCols).fill(0))
 
     for (let r = 0; r < numRows; r++) {
@@ -2741,7 +2973,6 @@ class TableManager {
         const parent = this.getMergeParent(slideIndex, tableId, r, c, slideManager)
         const gridSpan = cell['@_gridSpan'] ? parseInt(cell['@_gridSpan'], 10) : 1
 
-        // Calculate cell width
         let cellWidth = 0
         for (let idx = 0; idx < gridSpan; idx++) {
           cellWidth += colWidths[parent.col + idx] || 0
@@ -2751,13 +2982,15 @@ class TableManager {
         const availWidth = cellWidth - marL - marR
         const availWidth_px = Math.max(1, availWidth / 9525)
 
-        // Calculate text height
         const txBody = cell['a:txBody']
         let textHeight_emu = 0
         if (txBody) {
           const paras = Array.isArray(txBody['a:p']) ? txBody['a:p'] : [txBody['a:p']]
           for (const p of paras) {
-            const fontSize = getParagraphFontSize(p)
+            const fontInfo = getParagraphFontInfo(p)
+            const fontSize = fontInfo.fontSize
+            const aspect = getFontAspect(fontInfo.typeface)
+
             let pText = ''
             if (p['a:r']) {
               const runs = Array.isArray(p['a:r']) ? p['a:r'] : [p['a:r']]
@@ -2768,8 +3001,8 @@ class TableManager {
               }
             }
 
-            const linesCount = wrapText(pText, availWidth_px, fontSize)
-            const lineHeight_emu = fontSize * 20780 // 1.4 line height multiplier
+            const linesCount = wrapText(pText, availWidth_px, fontSize, aspect)
+            const lineHeight_emu = fontSize * 20780
 
             let pHeight_emu = linesCount * lineHeight_emu
             if (p['a:pPr']?.['a:spcBef']?.['a:spcPts']?.['@_val']) {
@@ -2789,10 +3022,8 @@ class TableManager {
       }
     }
 
-    // Now resolve row heights based on required cell heights
-    // First, non-vertically-merged cells define row heights directly
     for (let r = 0; r < numRows; r++) {
-      let maxCellHeight = rowHeights[r] // Start with original template height as floor
+      let maxCellHeight = rowHeights[r]
       const row = trsArr[r]
       const tcs = row['a:tc'] || []
       for (let c = 0; c < numCols; c++) {
@@ -2808,7 +3039,6 @@ class TableManager {
       rowHeights[r] = maxCellHeight
     }
 
-    // Next, adjust for vertically merged cells (rowSpan > 1)
     for (let r = 0; r < numRows; r++) {
       const row = trsArr[r]
       const tcs = row['a:tc'] || []
@@ -2818,13 +3048,11 @@ class TableManager {
         const rowSpan = cell['@_rowSpan'] ? parseInt(cell['@_rowSpan'], 10) : 1
         if (rowSpan > 1) {
           const reqHeight = cellHeights[r][c]
-          // Sum currently allocated row heights for spanned rows
           let currentSpanHeight = 0
           for (let idx = 0; idx < rowSpan; idx++) {
             currentSpanHeight += rowHeights[r + idx] || 0
           }
           if (reqHeight > currentSpanHeight) {
-            // Distribute the extra required height equally across all spanned rows
             const diff = reqHeight - currentSpanHeight
             const extraPerRow = Math.ceil(diff / rowSpan)
             for (let idx = 0; idx < rowSpan; idx++) {
@@ -2835,13 +3063,11 @@ class TableManager {
       }
     }
 
-    // Update row heights in XML
     if (writeToXml) {
       for (let r = 0; r < numRows; r++) {
         trsArr[r]['@_h'] = String(rowHeights[r])
       }
     }
-
     return rowHeights
   }