node-pptx-templater 1.0.9 → 1.0.11

package/src/managers/ShapeManager.js

@@ -47,6 +47,76 @@ class ShapeManager {
     logger.debug(`Updated text for shape "${shapeId}" on slide ${slideIndex}`)
   }
 
+  /**
+   * Updates an existing shape's position and/or dimensions.
+   *
+   * @param {number} slideIndex
+   * @param {string} shapeId
+   * @param {Object} options Position and dimensions configuration.
+   * @param {number} [options.x] Absolute X offset coordinate (in EMUs).
+   * @param {number} [options.y] Absolute Y offset coordinate (in EMUs).
+   * @param {number} [options.width] Bounding box width (in EMUs).
+   * @param {number} [options.height] Bounding box height (in EMUs).
+   * @param {SlideManager} slideManager
+   */
+  updateShapePosition(slideIndex, shapeId, options = {}, slideManager) {
+    const slideXml = slideManager.getSlideXml(slideIndex)
+    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
+    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+    const res = this.findShapeRecursive(spTree, shapeId)
+
+    if (!res) {
+      throw new PPTXError(`Shape "${shapeId}" not found in slide ${slideIndex}`)
+    }
+
+    const xfrm = res.shape['p:spPr']?.['a:xfrm']
+    if (xfrm) {
+      if (options.x !== undefined) {
+        if (!xfrm['a:off']) xfrm['a:off'] = {}
+        xfrm['a:off']['@_x'] = String(Math.round(options.x))
+      }
+      if (options.y !== undefined) {
+        if (!xfrm['a:off']) xfrm['a:off'] = {}
+        xfrm['a:off']['@_y'] = String(Math.round(options.y))
+      }
+      if (options.width !== undefined) {
+        if (!xfrm['a:ext']) xfrm['a:ext'] = {}
+        xfrm['a:ext']['@_cx'] = String(Math.round(options.width))
+      }
+      if (options.height !== undefined) {
+        if (!xfrm['a:ext']) xfrm['a:ext'] = {}
+        xfrm['a:ext']['@_cy'] = String(Math.round(options.height))
+      }
+    }
+
+    const decl = this.#xmlParser.extractDeclaration(slideXml)
+    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    logger.debug(`Updated position/dimensions for shape "${shapeId}" on slide ${slideIndex}`)
+  }
+
+  /**
+   * Updates an existing textbox shape's position and/or dimensions.
+   *
+   * @param {number} slideIndex
+   * @param {string} textBoxId
+   * @param {Object} options Position and dimensions configuration.
+   * @param {number} [options.x] Absolute X offset coordinate (in EMUs).
+   * @param {number} [options.y] Absolute Y offset coordinate (in EMUs).
+   * @param {number} [options.width] Bounding box width (in EMUs).
+   * @param {number} [options.height] Bounding box height (in EMUs).
+   * @param {SlideManager} slideManager
+   */
+  updateTextBoxPosition(slideIndex, textBoxId, options = {}, slideManager) {
+    try {
+      this.updateShapePosition(slideIndex, textBoxId, options, slideManager)
+    } catch (err) {
+      if (err.message.includes('not found')) {
+        throw new PPTXError(`Textbox "${textBoxId}" not found in slide ${slideIndex}`)
+      }
+      throw err
+    }
+  }
+
   /**
    * Clones a shape and adds it with offsets.
    *

package/src/managers/charts/ChartCacheGenerator.js

@@ -154,58 +154,124 @@ class ChartCacheGenerator {
   }
 
   /**
-   * Updates the chart title text in chart XML while preserving all existing
-   * styling (spPr, txPr, overlay, layout) from the template.
+   * Updates the chart title text while fully preserving all existing styling.
    *
-   * Because <c:txPr> is ignored by PowerPoint once <c:tx><c:rich> is present,
-   * this method extracts <a:defRPr> from <c:txPr> and injects it as <a:rPr>
-   * into the run, and uses <a:bodyPr> from <c:txPr> inside <c:rich>, so that
-   * the template's font, size, and color are faithfully applied to the title text.
+   * Three strategies in priority order:
+   *
+   * 1. If <c:tx><c:rich> already exists (title was previously set via PowerPoint or this
+   *    library): ONLY replace <a:t> text values in-place, mapped by \n-split lines to
+   *    existing runs in document order. This preserves alignment, bold/italic/underline,
+   *    font sizes, paragraph structure, and any other per-run or per-paragraph properties.
+   *
+   * 2. If <c:title> exists but has no <c:tx> (title text comes from <c:txPr> default
+   *    properties): Build a new <c:tx><c:rich> by extracting <a:bodyPr>, <a:pPr> (including
+   *    algn), and <a:defRPr>→<a:rPr> from <c:txPr>. Supports multi-line via \n splitting
+   *    into separate <a:p> paragraphs, each inheriting the same pPr and rPr.
+   *
+   * 3. If no <c:title> block exists at all: create a minimal one.
+   */
+  /**
+   * Extracts parts of <c:txPr> block (bodyPr, pPr, and converts defRPr to rPr)
+   * to use when creating custom rich text components.
+   *
+   * @param {string} txPrXml - The <c:txPr> XML string or block content.
+   * @returns {Object} { bodyPr, pPrXml, rPrXml }
    */
+  static extractTxPrParts(txPrXml) {
+    let bodyPr = '<a:bodyPr/>'
+    let pPrXml = ''
+    let rPrXml = ''
+
+    if (!txPrXml) {
+      return { bodyPr, pPrXml, rPrXml }
+    }
+
+    let txPrContent = txPrXml
+    const txPrInnerMatch = /<c:txPr>([\s\S]*?)<\/c:txPr>/.exec(txPrXml)
+    if (txPrInnerMatch) {
+      txPrContent = txPrInnerMatch[1]
+    }
+
+    // Extract <a:bodyPr>
+    const bodyPrMatch = /(<a:bodyPr[^>]*\/>|<a:bodyPr[^>]*>[\s\S]*?<\/a:bodyPr>)/.exec(txPrContent)
+    if (bodyPrMatch) bodyPr = bodyPrMatch[1]
+
+    // Extract <a:defRPr> → convert to <a:rPr> for the run
+    const defRPrMatch = /(<a:defRPr[\s\S]*?<\/a:defRPr>|<a:defRPr[^>]*\/>)/.exec(txPrContent)
+    if (defRPrMatch) {
+      rPrXml = defRPrMatch[1].replace(/^<a:defRPr/, '<a:rPr').replace(/<\/a:defRPr>$/, '</a:rPr>')
+    }
+
+    // Extract <a:pPr> (keeps algn, indent, etc.) but strip <a:defRPr> from it
+    const pPrBlockMatch = /(<a:pPr[^>]*>)([\s\S]*?)(<\/a:pPr>)/.exec(txPrContent)
+    if (pPrBlockMatch) {
+      const innerContent = pPrBlockMatch[2]
+        .replace(/<a:defRPr(?:[^>]*\/>|[\s\S]*?<\/a:defRPr>)/g, '')
+        .trim()
+      const attrs = pPrBlockMatch[1].slice(7, -1).trim()
+      if (attrs || innerContent) {
+        pPrXml = innerContent
+          ? `${pPrBlockMatch[1]}${innerContent}${pPrBlockMatch[3]}`
+          : `<a:pPr ${attrs}/>`
+      }
+    } else {
+      const scPPrMatch = /(<a:pPr[^>]*\/>)/.exec(txPrContent)
+      if (scPPrMatch) pPrXml = scPPrMatch[1]
+    }
+
+    return { bodyPr, pPrXml, rPrXml }
+  }
+
   static updateTitle(xml, title) {
-    const escapedTitle = this.#escapeXml(title)
+    // Split by \n so callers can drive multi-paragraph titles
+    const titleLines = title.split('\n')
+
+    if (!xml.includes('<c:title>')) {
+      // Strategy 3 – no title block yet, create minimal
+      const escapedText = this.#escapeXml(titleLines[0])
+      const titleBlock = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapedText}</a:t></a:r></a:p></c:rich></c:tx><c:layout/></c:title>`
+      return xml.replace(/(<c:chart>)/, `$1${titleBlock}`)
+    }
 
-    if (xml.includes('<c:title>')) {
-      return xml.replace(/<c:title>([\s\S]*?)<\/c:title>/, (match, titleContent) => {
-        // Extract <a:bodyPr .../> from existing <c:txPr> to use in <c:rich>
-        let bodyPr = '<a:bodyPr/>'
-        const txPrMatch = /<c:txPr>([\s\S]*?)<\/c:txPr>/.exec(titleContent)
-        if (txPrMatch) {
-          const bodyPrMatch = /(<a:bodyPr[^>]*\/>|<a:bodyPr[^>]*>[\s\S]*?<\/a:bodyPr>)/.exec(
-            txPrMatch[1]
+    return xml.replace(/<c:title>([\s\S]*?)<\/c:title>/, (match, titleContent) => {
+      // ── Strategy 1 ──────────────────────────────────────────────────────────────
+      // Existing <c:tx><c:rich> is present: preserve every element, just swap text.
+      if (titleContent.includes('<c:tx>')) {
+        const txMatch = /<c:tx>([\s\S]*?)<\/c:tx>/.exec(titleContent)
+        if (txMatch && txMatch[1].includes('<c:rich>')) {
+          let lineIndex = 0
+          // Replace each <a:t>…</a:t> in document order with the next line.
+          // Any run that maps beyond the supplied lines gets an empty string.
+          const updatedTx = txMatch[1].replace(/<a:t>[^<]*<\/a:t>/g, () => {
+            const text = lineIndex < titleLines.length ? this.#escapeXml(titleLines[lineIndex]) : ''
+            lineIndex++
+            return `<a:t>${text}</a:t>`
+          })
+          const updatedContent = titleContent.replace(
+            /<c:tx>[\s\S]*?<\/c:tx>/,
+            `<c:tx>${updatedTx}</c:tx>`
           )
-          if (bodyPrMatch) bodyPr = bodyPrMatch[1]
+          return `<c:title>${updatedContent}</c:title>`
         }
+      }
 
-        // Extract <a:defRPr .../> from <c:txPr><a:p><a:pPr> to use as <a:rPr> in the run
-        let rPr = ''
-        if (txPrMatch) {
-          const defRPrMatch = /(<a:defRPr[\s\S]*?<\/a:defRPr>|<a:defRPr[^>]*\/>)/.exec(txPrMatch[1])
-          if (defRPrMatch) {
-            // Convert <a:defRPr ...> to <a:rPr ...> (same attributes, different tag name)
-            rPr = defRPrMatch[1]
-              .replace(/^<a:defRPr/, '<a:rPr')
-              .replace(/<\/a:defRPr>$/, '</a:rPr>')
-          }
-        }
+      // ── Strategy 2 ──────────────────────────────────────────────────────────────
+      // No <c:tx> yet – build one from <c:txPr> styles.
+      const { bodyPr, pPrXml, rPrXml: rPr } = this.extractTxPrParts(titleContent)
 
-        const newTxBlock = `<c:tx><c:rich>${bodyPr}<a:lstStyle/><a:p><a:r>${rPr}<a:t>${escapedTitle}</a:t></a:r></a:p></c:rich></c:tx>`
+      // Build one <a:p> per title line, each with the same pPr + rPr
+      const paragraphs = titleLines
+        .map(line => {
+          const escapedLine = this.#escapeXml(line)
+          return `<a:p>${pPrXml}<a:r>${rPr}<a:t>${escapedLine}</a:t></a:r></a:p>`
+        })
+        .join('')
 
-        if (titleContent.includes('<c:tx>')) {
-          // Replace existing c:tx, keep all other siblings intact
-          const updatedContent = titleContent.replace(/<c:tx>[\s\S]*?<\/c:tx>/, newTxBlock)
-          return `<c:title>${updatedContent}</c:title>`
-        } else {
-          // No c:tx yet – prepend before first existing sibling
-          return `<c:title>${newTxBlock}${titleContent}</c:title>`
-        }
-      })
-    } else {
-      // No title block exists yet – create a minimal one
-      const titleBlock = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapedTitle}</a:t></a:r></a:p></c:rich></c:tx><c:layout/></c:title>`
-      const chartPattern = /(<c:chart>)/
-      return xml.replace(chartPattern, `$1${titleBlock}`)
-    }
+      const newTxBlock = `<c:tx><c:rich>${bodyPr}<a:lstStyle/>${paragraphs}</c:rich></c:tx>`
+
+      // Prepend <c:tx> before the first existing sibling (overlay, spPr, txPr, etc.)
+      return `<c:title>${newTxBlock}${titleContent}</c:title>`
+    })
   }
 
   static updateDataLabelsInXml(xml, seriesIndex, options, categories = [], seriesData = {}) {
@@ -333,7 +399,15 @@ class ChartCacheGenerator {
     existingSpPr = '',
     existingDLblSpPrs = {}
   ) {
-    const { labels, labelsFromCells, template, position, labelStyle, labelMap } = options
+    const {
+      labels,
+      labelsFromCells,
+      template,
+      position,
+      labelStyle,
+      labelMap,
+      showSeriesNameInBar,
+    } = options
 
     let xml = '<c:dLbls>'
 
@@ -348,7 +422,10 @@ class ChartCacheGenerator {
       top: 't',
       bottom: 'b',
     }
-    const openxmlPos = position ? posMap[position] : null
+    let openxmlPos = position ? posMap[position] : null
+    if (!openxmlPos && showSeriesNameInBar) {
+      openxmlPos = 'ctr'
+    }
 
     const values = seriesData.values || []
     const sumValues = values.reduce((sum, v) => sum + (Number(v) || 0), 0)
@@ -430,15 +507,29 @@ class ChartCacheGenerator {
             xml += `</c:strRef>`
             xml += `</c:tx>`
           } else {
+            let bodyPr = '<a:bodyPr/>'
+            let pPrXml = ''
+            let rPrXml = ''
+            if (existingTxPr) {
+              const extracted = this.extractTxPrParts(existingTxPr)
+              bodyPr = extracted.bodyPr
+              pPrXml = extracted.pPrXml
+              rPrXml = extracted.rPrXml
+            }
+
+            const labelLines = String(textContent).split('\n')
+            const paragraphs = labelLines
+              .map(line => {
+                const escapedLine = this.#escapeXml(line)
+                return `<a:p>${pPrXml}<a:r>${rPrXml}<a:t>${escapedLine}</a:t></a:r></a:p>`
+              })
+              .join('')
+
             xml += `<c:tx>`
             xml += `<c:rich>`
-            xml += `<a:bodyPr/>`
+            xml += bodyPr
             xml += `<a:lstStyle/>`
-            xml += `<a:p>`
-            xml += `<a:r>`
-            xml += `<a:t>${this.#escapeXml(textContent)}</a:t>`
-            xml += `</a:r>`
-            xml += `</a:p>`
+            xml += paragraphs
             xml += `</c:rich>`
             xml += `</c:tx>`
           }
@@ -516,7 +607,9 @@ class ChartCacheGenerator {
 
     // showVal
     const defaultShowVal = hasCustomLabels ? '0' : '1'
-    if (existingShowTags['showVal'] && !hasCustomLabels) {
+    if (showSeriesNameInBar) {
+      xml += `<c:showVal val="0"/>`
+    } else if (existingShowTags['showVal'] && !hasCustomLabels) {
       xml += existingShowTags['showVal']
     } else {
       xml += `<c:showVal val="${defaultShowVal}"/>`
@@ -530,7 +623,9 @@ class ChartCacheGenerator {
     }
 
     // showSerName
-    if (existingShowTags['showSerName']) {
+    if (showSeriesNameInBar) {
+      xml += `<c:showSerName val="1"/>`
+    } else if (existingShowTags['showSerName']) {
       xml += existingShowTags['showSerName']
     } else {
       xml += `<c:showSerName val="0"/>`