node-pptx-templater 1.0.6 → 1.0.8

package/src/managers/TextManager.js

@@ -192,6 +192,277 @@ class TextManager {
       this.#collectTextElements(g, results)
     }
   }
+
+  /**
+   * Updates shape text or list content by placeholder tag or shape name/ID.
+   *
+   * @param {number} slideIndex
+   * @param {string} tag - Placeholder tag (e.g. '{{name}}') or shape name/ID.
+   * @param {string|Object} data - String value or list configuration object.
+   * @param {SlideManager} slideManager
+   * @param {TemplateEngine} templateEngine
+   */
+  updateText(slideIndex, tag, data, slideManager, templateEngine) {
+    const slideXml = slideManager.getSlideXml(slideIndex)
+    const normalizedTag = tag.startsWith('{{') && tag.endsWith('}}') ? tag : `{{${tag}}}`
+
+    // Option A: Tag exists as a placeholder in the slide XML
+    if (slideXml.includes(normalizedTag)) {
+      const replacements = { [normalizedTag]: data }
+      const updatedXml = templateEngine.replaceTextInXml(slideXml, replacements)
+      slideManager.setSlideXml(slideIndex, updatedXml)
+      logger.debug(`Updated text tag "${normalizedTag}" on slide ${slideIndex}`)
+      return
+    }
+
+    // Option B: Search for a shape whose name or ID matches the tag
+    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
+    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+    const res = this.findShapeRecursive(spTree, tag)
+
+    if (!res) {
+      const { PPTXError } = require('../utils/errors.js')
+      throw new PPTXError(`Text placeholder or shape "${tag}" not found in slide ${slideIndex}`)
+    }
+
+    // Replace the text body of the shape
+    const shape = res.shape
+    const listConfig =
+      typeof data === 'object' && data !== null
+        ? data.list !== undefined
+          ? data
+          : { list: [data] }
+        : { list: [String(data)] }
+
+    const { ValidationEngine } = require('../core/ValidationEngine.js')
+    const validation = ValidationEngine.validateList(listConfig)
+    if (!validation.valid) {
+      throw new Error(`List validation failed: ${validation.errors.join(', ')}`)
+    }
+
+    if (!shape['p:txBody']) {
+      shape['p:txBody'] = {
+        'a:bodyPr': {},
+        'a:lstStyle': {},
+        'a:p': [],
+      }
+    }
+
+    const txBody = shape['p:txBody']
+    const originalParas = Array.isArray(txBody['a:p']) ? txBody['a:p'] : [txBody['a:p']]
+    const templatePara = originalParas.length > 0 ? originalParas[0] : {}
+    const templateRuns = templatePara['a:r']
+      ? Array.isArray(templatePara['a:r'])
+        ? templatePara['a:r']
+        : [templatePara['a:r']]
+      : []
+    const firstRun = templateRuns.length > 0 ? templateRuns[0] : { 'a:rPr': {} }
+
+    const firstRunXml = this.#xmlParser.build({ 'a:r': firstRun })
+    const dummyParaXml = `<a:p>${firstRunXml}</a:p>`
+    const generatedXml = templateEngine.generateListParagraphs(
+      dummyParaXml,
+      { xml: firstRunXml },
+      listConfig
+    )
+
+    // Parse the generated XML paragraphs back to objects
+    const wrappedXml = `<root xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">${generatedXml}</root>`
+    const parsedObj = this.#xmlParser.parse(wrappedXml)
+    let newParas = parsedObj?.root?.['a:p'] || []
+    if (!Array.isArray(newParas)) {
+      newParas = [newParas]
+    }
+
+    txBody['a:p'] = newParas
+
+    const decl = this.#xmlParser.extractDeclaration(slideXml)
+    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    logger.debug(`Updated text content for shape "${tag}" on slide ${slideIndex}`)
+  }
+
+  /**
+   * Retrieves list items from a shape or text box by name or placeholder tag.
+   *
+   * @param {number} slideIndex
+   * @param {string} tag - Shape name/ID or placeholder tag.
+   * @param {SlideManager} slideManager
+   * @returns {Array} Nested list structure of items.
+   */
+  getList(slideIndex, tag, slideManager) {
+    const slideXml = slideManager.getSlideXml(slideIndex)
+    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
+    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+
+    // Step 1: Find shape by name or ID matching tag
+    let res = this.findShapeRecursive(spTree, tag)
+
+    // Step 2: If not found, look for any shape containing the placeholder string
+    if (!res) {
+      const collectMatchingShape = container => {
+        if (!container) return null
+
+        let shapes = container['p:sp'] || []
+        if (!Array.isArray(shapes)) shapes = [shapes]
+
+        for (const shape of shapes) {
+          const txBody = shape['p:txBody']
+          if (txBody && txBody['a:p']) {
+            const paras = Array.isArray(txBody['a:p']) ? txBody['a:p'] : [txBody['a:p']]
+            for (const p of paras) {
+              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.includes(tag)) {
+                return { shape, parent: container, type: 'sp' }
+              }
+            }
+          }
+        }
+
+        // Search in tables inside graphicFrames
+        let frames = container['p:graphicFrame'] || []
+        if (!Array.isArray(frames)) frames = [frames]
+
+        for (const frame of frames) {
+          const tbl = frame?.['a:graphic']?.['a:graphicData']?.['a:tbl']
+          if (tbl && tbl['a:tr']) {
+            const rows = Array.isArray(tbl['a:tr']) ? tbl['a:tr'] : [tbl['a:tr']]
+            for (const row of rows) {
+              const cells = Array.isArray(row['a:tc']) ? row['a:tc'] : [row['a:tc']]
+              for (const cell of cells) {
+                const txBody = cell['a:txBody']
+                if (txBody && txBody['a:p']) {
+                  const paras = Array.isArray(txBody['a:p']) ? txBody['a:p'] : [txBody['a:p']]
+                  for (const p of paras) {
+                    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.includes(tag)) {
+                      return { shape: cell, parent: row, type: 'cell' }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        let groups = container['p:grpSp'] || []
+        if (!Array.isArray(groups)) groups = [groups]
+
+        for (const group of groups) {
+          const matched = collectMatchingShape(group)
+          if (matched) return matched
+        }
+
+        return null
+      }
+      res = collectMatchingShape(spTree)
+    }
+
+    if (!res || !res.shape || !(res.shape['p:txBody'] || res.shape['a:txBody'])) {
+      return []
+    }
+
+    const txBody = res.shape['p:txBody'] || res.shape['a:txBody']
+    const paras = Array.isArray(txBody['a:p']) ? txBody['a:p'] : [txBody['a:p']]
+
+    const flatItems = []
+    for (const p of paras) {
+      let lvl = 0
+      if (p['a:pPr'] && p['a:pPr']['@_lvl'] !== undefined) {
+        lvl = parseInt(p['a:pPr']['@_lvl'], 10) || 0
+      }
+
+      let text = ''
+      if (p['a:r']) {
+        const runs = Array.isArray(p['a:r']) ? p['a:r'] : [p['a:r']]
+        const textParts = []
+        for (const r of runs) {
+          if (r['a:t']) textParts.push(String(r['a:t']))
+        }
+        text = textParts.join('')
+      }
+
+      if (text.trim() !== '') {
+        flatItems.push({ text: text.trim(), lvl })
+      }
+    }
+
+    if (flatItems.length === 0) {
+      return []
+    }
+
+    const result = []
+    const stack = []
+
+    for (const item of flatItems) {
+      const node = { text: item.text, children: [] }
+
+      while (stack.length > 0 && stack[stack.length - 1].lvl >= item.lvl) {
+        stack.pop()
+      }
+
+      if (stack.length === 0) {
+        result.push(node)
+      } else {
+        const parent = stack[stack.length - 1].node
+        parent.children.push(node)
+      }
+
+      stack.push({ lvl: item.lvl, node })
+    }
+
+    const cleanNode = n => {
+      if (n.children.length === 0) {
+        return n.text
+      }
+      return {
+        text: n.text,
+        children: n.children.map(cleanNode),
+      }
+    }
+
+    return result.map(cleanNode)
+  }
+
+  /**
+   * Helper to recursively scan a container for shapes.
+   */
+  findShapeRecursive(container, shapeId) {
+    if (!container) return null
+
+    let shapes = container['p:sp'] || []
+    if (!Array.isArray(shapes)) shapes = [shapes]
+
+    for (const shape of shapes) {
+      const cNvPr = shape?.['p:nvSpPr']?.['p:cNvPr']
+      if (cNvPr) {
+        if (cNvPr['@_name'] === shapeId || String(cNvPr['@_id']) === shapeId) {
+          return { shape, parent: container, type: 'sp' }
+        }
+      }
+    }
+
+    let groups = container['p:grpSp'] || []
+    if (!Array.isArray(groups)) groups = [groups]
+
+    for (const group of groups) {
+      const res = this.findShapeRecursive(group, shapeId)
+      if (res) return res
+    }
+
+    return null
+  }
 }
 
 module.exports = { TextManager }