node-pptx-templater 1.1.4 → 1.1.7

package/CHANGELOG.md

@@ -5,22 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [1.1.3] - 2026-06-22
-
-### Fixed
-
-- **Layout Preservation in `addCellShape()`**: Fixed a critical layout bug where querying cell bounds or adding cell shapes dynamically (via `addCellShape()` or `updateCellShape()`) mutated table row heights inside the XML. The sizing/positioning logic now runs in a layout-only mode, keeping the table XML completely untouched and respecting original template custom row heights.
-
-## [1.1.2] - 2026-06-22
-
-### Fixed
-
-- **Slide Link Relationships Target Paths**: Fixed PowerPoint "Repair Mode" errors when adding slide-to-slide hyperlinks (via `addSlideLink` or `addImageLink`). The relative target path resolves correctly to the sibling filename `slideX.xml` instead of using the redundant parent prefix `../slides/slideX.xml` (which exited and re-entered the same directory, violating PowerPoint's relative path resolution rules).
-
-### Added
-
-- **Redundant Traversal Validation**: Added automated check in `ValidationEngine` to identify and error on redundant relative path traversals inside relationship files (e.g. referencing `../slides/slideX.xml` from a source slide file already located in `ppt/slides/`).
-
 ## [1.1.0] - 2026-06-12
 
 ### Added

package/README.md

@@ -172,51 +172,27 @@ const meta = await ppt.getTableRows('SalesTable', { includeMetadata: true });
 ```
 
 ### Table Cell Shapes
-Cell shapes are overlay graphics anchored within table cells. They are positioned absolutely based on cell bounds, and **never** modify row heights, column widths, cell margins, or trigger table reflow.
-
-#### Merged Cell Support
-When targeting a merged cell (spanned using `rowSpan` or `colSpan`), `addCellShape()` dynamically resolves the **actual rendered bounds** of the entire merged cell region (summing the width and height of the spanned rows/columns). The shape is positioned and aligned relative to this final merged boundary. Any offset `x` and `y` specified is interpreted relative to the top-left corner of the resolved merged cell region.
-
-#### Alignment & Presets
-Shapes can be aligned dynamically within the cell (or merged region) using preset positions or explicit alignments:
-* **Presets**: Use `position` values like `'top-left'`, `'center'`, `'bottom-right'`, etc.
-* **Alignment Options**: Set `alignX: 'left' | 'center' | 'right'` and `alignY: 'top' | 'middle' | 'bottom'`. If no alignments or offsets are provided, shapes default to true centering (`'center'`/`'middle'`).
-* **Offsets & Padding**: Offsets (`x`, `y`) are applied relative to the resolved alignment. For instance, when `alignX: 'right'` is used, the shape is placed at `cellRight - shapeWidth - x` (defaulting to a `5px` padding if `x` is omitted).
+Cell shapes are overlay graphics anchored within table cells. They are positioned absolutely based on cell bounds, and **never** modify row heights, column widths, cell margins, or trigger table reflow. Offsets (`x`, `y`) are relative to the cell's top-left corner. Oversized shapes are scaled down proportionally to fit inside the cell.
 
 ```javascript
-// Add a status icon centered in a merged cell (rowSpan=2, colSpan=2)
-await ppt.addCellShape('StatusTable', 1, 1, {
+// Add a simple indicator
+await ppt.addCellShape('SalesTable', 2, 1, {
   type: 'circle',
   width: 12,
   height: 12,
-  fill: '#10B981', // Green status dot
-  alignX: 'center',
-  alignY: 'middle' // Visually centered in the merged cell
+  fill: '#10B981' // Green status dot
 });
 
-// Add a badge with text and explicit offsets inside a merged cell
-await ppt.addCellShape('StatusTable', 1, 1, {
+// Add a badge with text and custom offsets
+await ppt.addCellShape('SalesTable', 1, 2, {
   type: 'badge',
-  text: 'Urgent',
-  fill: '#EF4444',
-  alignX: 'left',
-  alignY: 'top',
-  x: 5,
-  y: 3,
+  text: 'Active',
+  fill: '#3B82F6',
+  x: 4,
+  y: 2,
   width: 50,
   height: 16
 });
-
-// Add an indicator with bottom-right alignment and custom padding
-await ppt.addCellShape('StatusTable', 1, 1, {
-  type: 'icon',
-  icon: 'up',
-  size: 14,
-  alignX: 'right',
-  alignY: 'bottom',
-  x: 4,
-  y: 2
-});
 ```
 
 ### XML Folder Workflow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-pptx-templater",
-  "version": "1.1.4",
+  "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",
@@ -37,8 +37,6 @@
     "example:table-extraction": "node examples/table-extraction.js",
     "example:nested-rows": "node examples/nested-table-rows.js",
     "example:xml-folder": "node examples/xml-folder-workflow.js",
-    "example:shape-cells": "node examples/shape-cells.js",
-    "example:all": "node scripts/run-examples-check.js",
     "prepublishOnly": "npm run lint && npm run test"
   },
   "keywords": [

package/src/core/PPTXTemplater.js

@@ -473,10 +473,14 @@ class PPTXTemplater {
         throw new PPTXError(`Destination is a file: ${outputPath}`)
       }
       const files = fs.readdirSync(resolvedOut)
-      if (files.length > 0 && !options.overwrite) {
-        throw new PPTXError(
-          `Destination directory "${outputPath}" is not empty. Set overwrite: true to overwrite.`
-        )
+      if (files.length > 0) {
+        if (!options.overwrite) {
+          throw new PPTXError(
+            `Destination directory "${outputPath}" is not empty. Set overwrite: true to overwrite.`
+          )
+        } else {
+          await fs.emptyDir(resolvedOut)
+        }
       }
     } else {
       await fs.ensureDir(resolvedOut)
@@ -1569,30 +1573,11 @@ class PPTXTemplater {
   }
 
   /**
-   * Appends one or more rows to a table. Supports flat arrays, nested arrays
-   * for rowspan-merged cells, and **Shape Cell** configuration objects that insert
-   * a graphic indicator directly inside a cell.
-   *
-   * ### Shape Cell Object
-   * Instead of a string value you may pass an object with the following keys:
-   *
-   * | Key | Type | Default | Description |
-   * |-----|------|---------|-------------|
-   * | `type` | `string` | **required** | Shape preset: `'circle'`, `'square'`, `'rectangle'`, `'triangle'`, `'diamond'`, `'hexagon'`, `'line'`. |
-   * | `text` | `string` | `''` | Optional label rendered next to the shape. |
-   * | `color` | `string` | `'#4CAF50'` | Fill colour of the shape (hex). |
-   * | `width` | `number` | `14` | Shape width in points. |
-   * | `height` | `number` | `14` | Shape height in points. |
-   * | `position` | `string` | `'center'` | Alignment inside the cell: `'center'`, `'left'`, `'right'`, `'top'`, `'bottom'`, `'top-left'`, `'top-right'`, `'bottom-left'`, `'bottom-right'`. |
-   * | `offsetX` | `number` | `0` | Additional horizontal offset from the resolved anchor (pt). |
-   * | `offsetY` | `number` | `0` | Additional vertical offset from the resolved anchor (pt). |
-   *
-   * The shape is added as a floating overlay anchored to the cell; the table
-   * dimensions (row heights, column widths) are **never mutated**.
+   * Appends one or more rows to a table. Supports flat arrays and nested arrays
+   * for rowspan-merged cells.
    *
    * @param {string} tableId - Table name or shape ID.
-   * @param {Array<string|Array<string>|Object>} rowData - Row data. Each element may be
-   *   a plain string, a nested array (rowspan), or a Shape Cell configuration object.
+   * @param {Array<string|Array<string>>} rowData - Row data. Nested arrays create rowspan cells.
    * @param {Object} [options] - Row insertion options.
    * @param {'rowspan'|'auto'|'none'} [options.mergeStrategy='rowspan'] - How to handle nested arrays.
    *   `'rowspan'` creates OpenXML vertical spans, `'auto'` merges identical adjacent values,
@@ -1605,20 +1590,6 @@ class PPTXTemplater {
    *
    * // Nested row with rowspan
    * ppt.addTableRow('SalesTable', ['Region', ['Q1', 'Q2'], '$5K'], { mergeStrategy: 'rowspan' });
-   *
-   * // KPI indicator – green circle placed in the cell centre, no label
-   * await ppt.addTableRow('StatusTable', [
-   *   'Alice',
-   *   'Engineering',
-   *   { type: 'circle', color: '#4CAF50', width: 12, height: 12, position: 'center' },
-   * ]);
-   *
-   * // Status badge – shape with accompanying text label, aligned to the left
-   * await ppt.addTableRow('StatusTable', [
-   *   'Bob',
-   *   'Design',
-   *   { type: 'circle', color: '#F44336', text: 'Blocked', position: 'left' },
-   * ]);
    */
   addTableRow(tableId, rowData, options = {}) {
     this.#assertLoaded()
@@ -1745,7 +1716,8 @@ class PPTXTemplater {
         colIndex,
         value,
         options,
-        this.#slideManager
+        this.#slideManager,
+        this.#shapeManager
       )
     }
     return this

package/src/managers/ShapeManager.js

@@ -433,6 +433,14 @@ class ShapeManager {
     if (!options) return options
     const normalized = { ...options }
 
+    // Fallback mapping between id and name for compatibility
+    if (normalized.id === undefined && normalized.name !== undefined) {
+      normalized.id = normalized.name
+    }
+    if (normalized.name === undefined && normalized.id !== undefined) {
+      normalized.name = normalized.id
+    }
+
     // 1. Map color alias to fill
     const fillVal = options.fill !== undefined ? options.fill : options.color
     if (fillVal !== undefined) {

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
@@ -1719,40 +1756,52 @@ class TableManager {
     }
 
     // 2. Determine alignment settings
-    let alignX = undefined
-    let alignY = undefined
-
-    const pos = String(config.position || '')
-      .toLowerCase()
-      .trim()
-    if (pos) {
-      if (pos === 'left') {
-        alignX = 'left'
-        alignY = 'middle'
-      } else if (pos === 'right') {
-        alignX = 'right'
-        alignY = 'middle'
-      } else if (pos === 'center' || pos === 'middle') {
-        alignX = 'center'
-        alignY = 'middle'
-      } else if (pos === 'top') {
-        alignX = 'center'
-        alignY = 'top'
-      } else if (pos === 'bottom') {
-        alignX = 'center'
-        alignY = 'bottom'
-      } else if (pos === 'top-left') {
-        alignX = 'left'
-        alignY = 'top'
-      } else if (pos === 'top-right') {
-        alignX = 'right'
-        alignY = 'top'
-      } else if (pos === 'bottom-left') {
-        alignX = 'left'
-        alignY = 'bottom'
-      } else if (pos === 'bottom-right') {
-        alignX = 'right'
-        alignY = 'bottom'
+    let alignX = config.alignX
+    let alignY = config.alignY
+
+    if (config.position) {
+      switch (config.position) {
+        case 'top-left':
+          if (!alignX) alignX = 'left'
+          if (!alignY) alignY = 'top'
+          break
+        case 'top-center':
+        case 'top':
+          if (!alignX) alignX = 'center'
+          if (!alignY) alignY = 'top'
+          break
+        case 'top-right':
+          if (!alignX) alignX = 'right'
+          if (!alignY) alignY = 'top'
+          break
+        case 'middle-left':
+        case 'left':
+          if (!alignX) alignX = 'left'
+          if (!alignY) alignY = 'middle'
+          break
+        case 'center':
+        case 'middle-center':
+          if (!alignX) alignX = 'center'
+          if (!alignY) alignY = 'middle'
+          break
+        case 'middle-right':
+        case 'right':
+          if (!alignX) alignX = 'right'
+          if (!alignY) alignY = 'middle'
+          break
+        case 'bottom-left':
+          if (!alignX) alignX = 'left'
+          if (!alignY) alignY = 'bottom'
+          break
+        case 'bottom-center':
+        case 'bottom':
+          if (!alignX) alignX = 'center'
+          if (!alignY) alignY = 'bottom'
+          break
+        case 'bottom-right':
+          if (!alignX) alignX = 'right'
+          if (!alignY) alignY = 'bottom'
+          break
       }
     }
 
@@ -2056,8 +2105,7 @@ class TableManager {
     cellShapes,
     slideManager,
     shapeManager,
-    tblObj,
-    _frameObj
+    tblObj
   ) {
     if (!cellShapes || !shapeManager) return
 
@@ -2506,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.
    */
@@ -2555,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',
+      }
+    }
+
+    const getFontAspect = tf => {
+      if (!tf) return 0.55
+      const name = String(tf).toLowerCase()
+      if (name.includes('algerian')) return 0.85
+      return 0.55
     }
 
-    // Helper to wrap text
-    const wrapText = (text, availWidth_px, fontSize) => {
-      const charWidth = fontSize * 0.65
+    const wrapText = (text, availWidth_px, fontSize, aspect = 0.55) => {
+      const charWidth = fontSize * aspect
       const words = text.split(/(\s+)/)
       let linesCount = 0
       let currentLineLen = 0
@@ -2616,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
@@ -2626,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++) {
@@ -2639,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
@@ -2649,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']]
@@ -2666,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']) {
@@ -2687,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++) {
@@ -2706,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'] || []
@@ -2716,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++) {
@@ -2733,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
   }