node-pptx-templater 1.0.21 → 1.1.1

package/src/index.js

@@ -51,7 +51,7 @@ const {
   analyzeXmlFile,
   reportXmlComplexity,
 } = require('./utils/xmlUtils.js')
-const { createLogger } = require('./utils/logger.js')
+const { createLogger, setGlobalLogLevel, resetLogLevel } = require('./utils/logger.js')
 const {
   PPTXError,
   SlideNotFoundError,
@@ -87,6 +87,8 @@ module.exports = {
   analyzeXmlFile,
   reportXmlComplexity,
   createLogger,
+  setGlobalLogLevel,
+  resetLogLevel,
   PPTXError,
   SlideNotFoundError,
   ChartNotFoundError,

package/src/managers/TableManager.js

@@ -845,13 +845,50 @@ class TableManager {
     }
   }
 
-  getCellPosition(slideIndex, tableId, rowIndex, colIndex, slideManager) {
+  getCellPosition(
+    slideIndex,
+    tableId,
+    rowIndex,
+    colIndex,
+    slideManager,
+    shapeWidthOrOptions,
+    shapeHeight
+  ) {
     const bounds = this.getCellBounds(slideIndex, tableId, rowIndex, colIndex, slideManager)
+    if (!bounds) return null
+
+    let shapeWidth
+    let shapeHeightVal
+
+    if (shapeWidthOrOptions && typeof shapeWidthOrOptions === 'object') {
+      shapeWidth =
+        shapeWidthOrOptions.width !== undefined
+          ? shapeWidthOrOptions.width
+          : shapeWidthOrOptions.shapeWidth
+      shapeHeightVal =
+        shapeWidthOrOptions.height !== undefined
+          ? shapeWidthOrOptions.height
+          : shapeWidthOrOptions.shapeHeight
+    } else {
+      shapeWidth = shapeWidthOrOptions
+      shapeHeightVal = shapeHeight
+    }
+
+    let x = bounds.x
+    let y = bounds.y
+
+    if (shapeWidth !== undefined && shapeHeightVal !== undefined) {
+      x = Math.round(bounds.x + (bounds.width - shapeWidth) / 2)
+      y = Math.round(bounds.y + (bounds.height - shapeHeightVal) / 2)
+    }
+
     return {
       row: rowIndex,
       column: colIndex,
-      x: bounds.x,
-      y: bounds.y,
+      x,
+      y,
+      width: bounds.width,
+      height: bounds.height,
     }
   }
 
@@ -1343,9 +1380,28 @@ class TableManager {
       }
     }
 
+    // Scale shape down proportionally to fit inside the cell if it exceeds the cell dimensions
+    if (shapeWidth > cellWidth_px || shapeHeight > cellHeight_px) {
+      logger.warn(
+        `Shape width (${shapeWidth}px) or height (${shapeHeight}px) exceeds cell dimensions (${cellWidth_px}px x ${cellHeight_px}px). Scaling shape to fit.`
+      )
+      const scale = Math.min(cellWidth_px / shapeWidth, cellHeight_px / shapeHeight)
+      shapeWidth = Math.max(1, Math.floor(shapeWidth * scale))
+      shapeHeight = Math.max(1, Math.floor(shapeHeight * scale))
+    }
+
     // 2. Determine alignment settings
-    let alignX = config.alignX
-    let alignY = config.alignY
+    let alignX = config.alignX || config.horizontal
+    let alignY = config.alignY || config.vertical
+
+    if (alignX) {
+      alignX = String(alignX).toLowerCase()
+      if (alignX === 'middle') alignX = 'center'
+    }
+    if (alignY) {
+      alignY = String(alignY).toLowerCase()
+      if (alignY === 'center') alignY = 'middle'
+    }
 
     if (config.position) {
       switch (config.position) {
@@ -1436,7 +1492,13 @@ class TableManager {
 
       // 4. Boundary Constraints Validation/Enforcement
       if (shapeWidth > cellWidth_px) {
-        shapeLeft = cellLeft_px
+        if (alignX === 'center') {
+          shapeLeft = cellLeft_px + (cellWidth_px - shapeWidth) / 2
+        } else if (alignX === 'right') {
+          shapeLeft = cellLeft_px + cellWidth_px - shapeWidth
+        } else {
+          shapeLeft = cellLeft_px
+        }
       } else {
         shapeLeft = Math.max(
           cellLeft_px,
@@ -1445,7 +1507,13 @@ class TableManager {
       }
 
       if (shapeHeight > cellHeight_px) {
-        shapeTop = cellTop_px
+        if (alignY === 'middle') {
+          shapeTop = cellTop_px + (cellHeight_px - shapeHeight) / 2
+        } else if (alignY === 'bottom') {
+          shapeTop = cellTop_px + cellHeight_px - shapeHeight
+        } else {
+          shapeTop = cellTop_px
+        }
       } else {
         shapeTop = Math.max(
           cellTop_px,
@@ -1695,8 +1763,6 @@ class TableManager {
       }
     }
 
-    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj)
-
     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
@@ -2103,8 +2169,11 @@ class TableManager {
     const numRows = trsArr.length
     const numCols = colWidths.length
 
-    // Initialize rowHeights with original height or 0
-    const rowHeights = trsArr.map(row => parseInt(row['@_h'] || 0, 10))
+    // 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 Math.max(h, 228600)
+    })
 
     // Helper to get paragraph font size
     const getParagraphFontSize = p => {
@@ -2226,7 +2295,7 @@ class TableManager {
         }
 
         const totalCellHeight_emu = marT + marB + textHeight_emu
-        cellHeights[r][c] = totalCellHeight_emu
+        cellHeights[r][c] = Math.max(totalCellHeight_emu, 228600)
       }
     }
 

package/src/utils/logger.js

@@ -2,10 +2,11 @@
  * @fileoverview Logger utility - lightweight structured logging.
  *
  * Provides contextual logging with module names.
- * Respects the PPTX_LOG_LEVEL environment variable.
+ * Respects the PPTX_LOG_LEVEL environment variable, or can be
+ * configured at runtime via setGlobalLogLevel().
  *
  * Log levels (lowest to highest severity):
- *   debug → info → warn → error
+ *   verbose → debug → info → warn → error → silent
  *
  * Usage:
  *   const logger = createLogger('MyModule');
@@ -14,21 +15,67 @@
  *   logger.warn('Watch out');
  *   logger.error('Something failed');
  *
- * Environment:
- *   PPTX_LOG_LEVEL=debug  → show all logs
- *   PPTX_LOG_LEVEL=info   → show info, warn, error (default)
- *   PPTX_LOG_LEVEL=warn   → show warn and error only
- *   PPTX_LOG_LEVEL=error  → show only errors
- *   PPTX_LOG_LEVEL=silent → suppress all logs
+ * Environment variable (set before process starts):
+ *   PPTX_LOG_LEVEL=debug   → show debug, info, warn, error
+ *   PPTX_LOG_LEVEL=info    → show info, warn, error
+ *   PPTX_LOG_LEVEL=warn    → show warn and error only (default)
+ *   PPTX_LOG_LEVEL=error   → show only errors
+ *   PPTX_LOG_LEVEL=silent  → suppress all output
+ *
+ * Runtime control (overrides env var):
+ *   const { setGlobalLogLevel } = require('./logger');
+ *   setGlobalLogLevel('debug');
  */
 
-const LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3, silent: 4 }
+/** @type {Object.<string, number>} */
+const LOG_LEVELS = { verbose: -1, debug: 0, info: 1, warn: 2, error: 3, silent: 4 }
+
+/** @type {number} Initial level from environment variable */
+const envLevel = LOG_LEVELS[(process.env.PPTX_LOG_LEVEL || 'warn').toLowerCase()] ?? LOG_LEVELS.warn
+
+/** @type {number|null} Runtime override — null means use envLevel */
+let runtimeLevel = null
 
-const currentLevel =
-  LOG_LEVELS[(process.env.PPTX_LOG_LEVEL || 'warn').toLowerCase()] ?? LOG_LEVELS.warn
+/**
+ * Gets the current effective log level.
+ * @returns {number}
+ */
+function getEffectiveLevel() {
+  return runtimeLevel !== null ? runtimeLevel : envLevel
+}
+
+/**
+ * Sets the global log level at runtime, overriding the environment variable.
+ * This affects all logger instances immediately.
+ *
+ * @param {string} level - One of: 'verbose', 'debug', 'info', 'warn', 'error', 'silent'
+ * @throws {Error} If an invalid level is provided.
+ *
+ * @example
+ * const { setGlobalLogLevel } = require('node-pptx-templater');
+ * setGlobalLogLevel('debug'); // Enable verbose output
+ * setGlobalLogLevel('silent'); // Suppress everything
+ */
+function setGlobalLogLevel(level) {
+  const normalized = String(level).toLowerCase()
+  if (LOG_LEVELS[normalized] === undefined) {
+    throw new Error(
+      `Invalid log level: "${level}". Valid levels: verbose, debug, info, warn, error, silent`
+    )
+  }
+  runtimeLevel = LOG_LEVELS[normalized]
+}
+
+/**
+ * Resets the log level back to the environment variable default.
+ */
+function resetLogLevel() {
+  runtimeLevel = null
+}
 
 /**
  * ANSI color codes for terminal output.
+ * @private
  */
 const COLORS = {
   reset: '\x1b[0m',
@@ -37,6 +84,7 @@ const COLORS = {
   green: '\x1b[32m',
   yellow: '\x1b[33m',
   red: '\x1b[31m',
+  magenta: '\x1b[35m',
 }
 
 /**
@@ -49,6 +97,7 @@ function timestamp() {
 
 /**
  * @typedef {Object} Logger
+ * @property {Function} verbose - Log verbose message (most detailed).
  * @property {Function} debug - Log debug message.
  * @property {Function} info - Log info message.
  * @property {Function} warn - Log warning.
@@ -64,16 +113,17 @@ function timestamp() {
  * @example
  * const logger = createLogger('SlideManager');
  * logger.info('Loaded 5 slides');
+ * logger.debug('Processing slide XML...');
  */
 function createLogger(moduleName) {
   const isTTY = process.stdout.isTTY
 
   const log = (level, levelNum, color, message, ...args) => {
-    if (levelNum < currentLevel) return
+    if (levelNum < getEffectiveLevel()) return
 
     const prefix = isTTY
-      ? `${COLORS.dim}${timestamp()}${COLORS.reset} ${color}[${level.toUpperCase().padEnd(5)}]${COLORS.reset} ${COLORS.cyan}[${moduleName}]${COLORS.reset}`
-      : `${timestamp()} [${level.toUpperCase().padEnd(5)}] [${moduleName}]`
+      ? `${COLORS.dim}${timestamp()}${COLORS.reset} ${color}[${level.toUpperCase().padEnd(7)}]${COLORS.reset} ${COLORS.cyan}[${moduleName}]${COLORS.reset}`
+      : `${timestamp()} [${level.toUpperCase().padEnd(7)}] [${moduleName}]`
 
     const output =
       args.length > 0
@@ -85,7 +135,15 @@ function createLogger(moduleName) {
 
   return {
     /**
-     * Logs a debug-level message. Only shown when PPTX_LOG_LEVEL=debug.
+     * Logs a verbose-level message. Only shown when level=verbose.
+     * @param {string} message
+     * @param {...*} args
+     */
+    verbose: (message, ...args) =>
+      log('verbose', LOG_LEVELS.verbose, COLORS.magenta, message, ...args),
+
+    /**
+     * Logs a debug-level message. Only shown when level=debug or lower.
      * @param {string} message
      * @param {...*} args
      */
@@ -116,4 +174,7 @@ function createLogger(moduleName) {
 
 module.exports = {
   createLogger,
+  setGlobalLogLevel,
+  resetLogLevel,
+  LOG_LEVELS,
 }