node-pptx-templater 1.0.5 → 1.0.7

package/src/managers/ChartManager.js

@@ -45,6 +45,8 @@ const { REL_TYPES } = require('./RelationshipManager.js')
 const { ChartWorkbookUpdater } = require('./charts/ChartWorkbookUpdater.js')
 const { ChartCacheGenerator } = require('./charts/ChartCacheGenerator.js')
 
+const JSZip = require('jszip')
+
 const logger = createLogger('ChartManager')
 
 /**
@@ -81,6 +83,12 @@ class ChartManager {
    */
   #chartRegistry = new Map()
 
+  /**
+   * Promise queue for sequential execution per chart ZIP path.
+   * @private @type {Map<string, Promise>}
+   */
+  #chartQueues = new Map()
+
   /**
    * @param {XMLParser} xmlParser
    */
@@ -88,12 +96,6 @@ class ChartManager {
     this.#xmlParser = xmlParser
   }
 
-  /**
-   * Initializes by scanning the ZIP for chart files.
-   *
-   * @param {ZipManager} zipManager
-   * @returns {Promise<void>}
-   */
   async initialize(zipManager) {
     this.#zipManager = zipManager
     const chartFiles = zipManager
@@ -104,6 +106,8 @@ class ChartManager {
       // Chart name is inferred from file name
       const chartName = chartPath.split('/').pop().replace('.xml', '')
       this.#chartRegistry.set(chartName, { zipPath: chartPath, slideIndex: null })
+      // Pre-load the chart XML into cache so that we can read it synchronously if needed
+      await zipManager.readFile(chartPath)
     }
 
     logger.debug(`Found ${chartFiles.length} chart file(s)`)
@@ -120,7 +124,8 @@ class ChartManager {
    * @throws {ChartNotFoundError} If the chart cannot be found.
    */
   updateChart(slideIndex, chartId, data, slideManager, relationshipManager) {
-    const chartInfo = this.#findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    this.#validateChartData(data)
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
 
     if (!chartInfo) {
       throw new ChartNotFoundError(`Chart "${chartId}" not found in slide ${slideIndex}`)
@@ -158,7 +163,7 @@ class ChartManager {
    * @param {RelationshipManager} relationshipManager
    * @returns {{ zipPath: string }|null}
    */
-  #findChartInSlide(slideIndex, chartId, slideManager, relationshipManager) {
+  findChartInSlide(slideIndex, chartId, slideManager, relationshipManager) {
     const slideInfo = slideManager.getSlideInfo(slideIndex)
     const slideXml = slideManager.getSlideXml(slideIndex)
 
@@ -222,13 +227,18 @@ class ChartManager {
    * @param {ChartData} data - New chart data.
    * @param {RelationshipManager} relationshipManager
    */
-  #updateChartXml(chartZipPath, data, relationshipManager) {
+  #enqueueChartTask(chartZipPath, taskFn) {
     if (!this.#zipManager.hasFile(chartZipPath)) {
       throw new ChartNotFoundError(`Chart file not found: ${chartZipPath}`)
     }
+    const queue = this.#chartQueues.get(chartZipPath) || Promise.resolve()
+    const nextTask = queue.then(() => taskFn())
+    this.#chartQueues.set(chartZipPath, nextTask)
+    this.#zipManager.addPendingPromise(nextTask)
+  }
 
-    // Register async update to ensure it completes before saving
-    this.#zipManager.addPendingPromise(
+  #updateChartXml(chartZipPath, data, relationshipManager) {
+    this.#enqueueChartTask(chartZipPath, () =>
       this.updateChartAsync(chartZipPath, data, relationshipManager)
     )
   }
@@ -246,11 +256,16 @@ class ChartManager {
     const xml = await this.#zipManager.readFile(chartZipPath)
     if (!xml) throw new ChartNotFoundError(`Chart file not found: ${chartZipPath}`)
 
-    // 2. Apply Chart XML Updates
-    const updatedXml = this.#applyChartData(xml, data, chartZipPath)
+    // 2. Normalize and split the chart data
+    const normalized = this.#normalizeChartData(data)
+    const cleanNumericData = normalized.cleanData
+    const seriesLabels = normalized.labels
+
+    // 3. Apply Chart XML Updates
+    const updatedXml = this.#applyChartData(xml, cleanNumericData, chartZipPath)
     this.#zipManager.writeFile(chartZipPath, updatedXml)
 
-    // 3. Find and Update Embedded Workbook
+    // 4. Find and Update Embedded Workbook
     if (relationshipManager) {
       const rels = relationshipManager.getRelationshipsByType(chartZipPath, REL_TYPES.PACKAGE)
       for (const rel of rels) {
@@ -259,7 +274,7 @@ class ChartManager {
         if (xlsxData) {
           console.log(`Found embedded workbook: ${xlsxPath}`)
           const buffer = await xlsxData.async('nodebuffer')
-          const updatedXlsx = await ChartWorkbookUpdater.updateWorkbook(buffer, data)
+          const updatedXlsx = await ChartWorkbookUpdater.updateWorkbook(buffer, cleanNumericData)
           if (updatedXlsx) {
             console.log(`Writing updated workbook to: ${xlsxPath}, size: ${updatedXlsx.length}`)
             this.#zipManager.writeBinaryFile(xlsxPath, updatedXlsx)
@@ -269,6 +284,18 @@ class ChartManager {
         }
       }
     }
+
+    // 5. Apply custom data labels if present
+    for (let i = 0; i < seriesLabels.length; i++) {
+      const labels = seriesLabels[i]
+      if (labels && labels.some(l => l !== undefined)) {
+        const labelOptions = {
+          series: i,
+          labels: labels.map(l => (l === undefined ? '' : String(l))),
+        }
+        await this.updateDataLabelsAsync(chartZipPath, labelOptions, relationshipManager)
+      }
+    }
   }
 
   /**
@@ -312,11 +339,11 @@ class ChartManager {
    * Updates only chart categories.
    */
   updateChartCategories(slideIndex, chartId, categories, slideManager, relationshipManager) {
-    const chartInfo = this.#findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
     if (!chartInfo) {
       throw new ChartNotFoundError(`Chart "${chartId}" not found in slide ${slideIndex}`)
     }
-    this.#zipManager.addPendingPromise(
+    this.#enqueueChartTask(chartInfo.zipPath, () =>
       this.updateChartCategoriesAsync(chartInfo.zipPath, categories, relationshipManager)
     )
   }
@@ -340,11 +367,11 @@ class ChartManager {
     slideManager,
     relationshipManager
   ) {
-    const chartInfo = this.#findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
     if (!chartInfo) {
       throw new ChartNotFoundError(`Chart "${chartId}" not found in slide ${slideIndex}`)
     }
-    this.#zipManager.addPendingPromise(
+    this.#enqueueChartTask(chartInfo.zipPath, () =>
       this.replaceChartSeriesAsync(
         chartInfo.zipPath,
         seriesIndex,
@@ -366,11 +393,13 @@ class ChartManager {
    * Updates the chart title.
    */
   updateChartTitle(slideIndex, chartId, title, slideManager, relationshipManager) {
-    const chartInfo = this.#findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
     if (!chartInfo) {
       throw new ChartNotFoundError(`Chart "${chartId}" not found in slide ${slideIndex}`)
     }
-    this.#zipManager.addPendingPromise(this.updateChartTitleAsync(chartInfo.zipPath, title))
+    this.#enqueueChartTask(chartInfo.zipPath, () =>
+      this.updateChartTitleAsync(chartInfo.zipPath, title)
+    )
   }
 
   async updateChartTitleAsync(chartZipPath, title) {
@@ -439,6 +468,308 @@ class ChartManager {
     }
     return 'unknown'
   }
+
+  updateDataLabels(slideIndex, chartId, options, slideManager, relationshipManager) {
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    if (!chartInfo) {
+      throw new ChartNotFoundError(`Chart "${chartId}" not found in slide ${slideIndex}`)
+    }
+    this.#enqueueChartTask(chartInfo.zipPath, () =>
+      this.updateDataLabelsAsync(chartInfo.zipPath, options, relationshipManager)
+    )
+  }
+
+  async updateDataLabelsAsync(chartZipPath, options, relationshipManager) {
+    const xml = await this.#zipManager.readFile(chartZipPath)
+    if (!xml) throw new ChartNotFoundError(`Chart file not found: ${chartZipPath}`)
+
+    const chartData = this.#extractChartData(xml)
+    const { categories, series } = chartData
+
+    const seriesIndex = options.series !== undefined ? options.series : 0
+    if (seriesIndex >= series.length) {
+      throw new Error(
+        `Series index ${seriesIndex} out of bounds (chart has ${series.length} series)`
+      )
+    }
+
+    const seriesData = series[seriesIndex]
+
+    let resolvedLabels = null
+    let labelsFromCells = options.labelsFromCells
+
+    const hasCustomLabels =
+      options.labels || options.labelMap || options.template || options.labelsFromCells
+
+    if (hasCustomLabels) {
+      const values = seriesData.values || []
+      const sumValues = values.reduce((sum, v) => sum + (Number(v) || 0), 0)
+      const seriesName = seriesData.name || ''
+
+      const pointsCount = Math.max(
+        categories.length,
+        values.length,
+        options.labels ? options.labels.length : 0
+      )
+
+      if (options.labelsFromCells && !options.labels && !options.template && !options.labelMap) {
+        if (relationshipManager) {
+          const rels = relationshipManager.getRelationshipsByType(chartZipPath, REL_TYPES.PACKAGE)
+          for (const rel of rels) {
+            const xlsxPath = relationshipManager.resolveTarget(chartZipPath, rel.target)
+            const xlsxData = this.#zipManager.rawZip.file(xlsxPath)
+            if (xlsxData) {
+              const buffer = await xlsxData.async('nodebuffer')
+              const zip = await JSZip.loadAsync(buffer)
+              const sheetFile = zip.file('xl/worksheets/sheet1.xml')
+              if (sheetFile) {
+                const sheetXml = await sheetFile.async('text')
+                const sharedStrings = await ChartWorkbookUpdater.getSharedStrings(zip)
+                const cells = ChartWorkbookUpdater.parseWorksheetCells(sheetXml, sharedStrings)
+
+                const range = ChartWorkbookUpdater.parseCellRange(options.labelsFromCells)
+                const startColNum = ChartWorkbookUpdater.colLetterToNum(range.startCol)
+
+                resolvedLabels = []
+                for (let i = 0; i < pointsCount; i++) {
+                  let cellRef
+                  if (range.startRow === range.endRow) {
+                    cellRef = `${ChartWorkbookUpdater.numToColLetter(startColNum + i)}${range.startRow}`
+                  } else {
+                    cellRef = `${range.startCol}${range.startRow + i}`
+                  }
+                  resolvedLabels.push(cells[cellRef] !== undefined ? String(cells[cellRef]) : '')
+                }
+              }
+            }
+          }
+        }
+      } else {
+        resolvedLabels = []
+        for (let i = 0; i < pointsCount; i++) {
+          const cat = categories[i] !== undefined ? String(categories[i]) : ''
+          const val = values[i] !== undefined ? values[i] : ''
+
+          let pct = 0
+          if (sumValues > 0 && val !== '') {
+            pct = Math.round((Number(val) / sumValues) * 100)
+          }
+
+          let customLabel = ''
+          if (options.labels && options.labels[i] !== undefined) {
+            customLabel = String(options.labels[i])
+          } else if (options.labelMap && cat && options.labelMap[cat] !== undefined) {
+            customLabel = String(options.labelMap[cat])
+          }
+
+          let textContent = customLabel
+          if (options.template) {
+            textContent = options.template
+              .replace(/{category}/g, cat)
+              .replace(/{value}/g, String(val))
+              .replace(/{percentage}/g, String(pct))
+              .replace(/{series}/g, seriesName)
+              .replace(/{customLabel}/g, customLabel)
+          }
+          resolvedLabels.push(textContent)
+        }
+      }
+    }
+
+    if (resolvedLabels && !labelsFromCells) {
+      const colLetter = ChartWorkbookUpdater.getColumnLetter(1 + series.length + seriesIndex)
+      labelsFromCells = `Sheet1!$${colLetter}$2:$${colLetter}$${1 + resolvedLabels.length}`
+    }
+
+    const resolvedOptions = {
+      ...options,
+      labels: resolvedLabels || options.labels,
+      labelsFromCells,
+    }
+
+    const updatedXml = ChartCacheGenerator.updateDataLabelsInXml(
+      xml,
+      seriesIndex,
+      resolvedOptions,
+      categories,
+      seriesData
+    )
+    this.#zipManager.writeFile(chartZipPath, updatedXml)
+
+    if (relationshipManager && (resolvedOptions.labels || resolvedOptions.labelsFromCells)) {
+      const rels = relationshipManager.getRelationshipsByType(chartZipPath, REL_TYPES.PACKAGE)
+      for (const rel of rels) {
+        const xlsxPath = relationshipManager.resolveTarget(chartZipPath, rel.target)
+        const xlsxData = this.#zipManager.rawZip.file(xlsxPath)
+        if (xlsxData) {
+          const buffer = await xlsxData.async('nodebuffer')
+          const workbookData = {
+            categories,
+            series: series.map((ser, idx) => {
+              if (idx === seriesIndex) {
+                return {
+                  ...ser,
+                  labels: resolvedOptions.labels,
+                  labelsFromCells: resolvedOptions.labelsFromCells,
+                }
+              }
+              return ser
+            }),
+          }
+          const updatedXlsx = await ChartWorkbookUpdater.updateWorkbook(buffer, workbookData)
+          if (updatedXlsx) {
+            this.#zipManager.writeBinaryFile(xlsxPath, updatedXlsx)
+          }
+        }
+      }
+    }
+  }
+
+  async getDataLabels(slideIndex, chartId, options, slideManager, relationshipManager) {
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    if (!chartInfo) {
+      throw new ChartNotFoundError(`Chart "${chartId}" not found in slide ${slideIndex}`)
+    }
+    const queue = this.#chartQueues.get(chartInfo.zipPath) || Promise.resolve()
+    await queue
+    const xml = await this.#zipManager.readFile(chartInfo.zipPath)
+    if (!xml) throw new ChartNotFoundError(`Chart file not found: ${chartInfo.zipPath}`)
+    const seriesIndex = options && options.series !== undefined ? options.series : 0
+    return ChartCacheGenerator.getDataLabelsFromXml(xml, seriesIndex)
+  }
+
+  getChartType(slideIndex, chartId, slideManager, relationshipManager) {
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    if (!chartInfo) return 'unknown'
+    const cachedXml = this.#zipManager.rawZip.file(chartInfo.zipPath)
+    if (!cachedXml) return 'unknown'
+    // Read synchronously from rawZip since we preloaded all charts
+    const fileData = this.#zipManager.rawZip.file(chartInfo.zipPath)
+    if (!fileData) return 'unknown'
+    // We can't do async inside synchronous getChartType, but wait: we preloaded them!
+    // Since it's preloaded, it is in #xmlCache of zipManager.
+    // Let's see if we can get it from xmlCache
+    const path = chartInfo.zipPath.replace(/\\/g, '/')
+    const xml = this.#zipManager.hasFile(path)
+      ? this.#zipManager.rawZip.file(path).async('text')
+      : null
+    // Actually, we can return the detected type from the file's text.
+    // Wait, is getChartType needed? We can make it async or use cached xml.
+    // Let's implement it asynchronously to be 100% correct, or read from cache!
+    // Let's see:
+    const xmlText = this.#zipManager.rawZip.file(path)
+      ? String(this.#zipManager.rawZip.file(path)._data)
+      : ''
+    // Wait, JSZip's internal _data might not be fully text. Let's make getChartTypeAsync or just read the cache.
+    // Since they were all loaded into cache during initialization:
+    const xmlFromCache = this.#zipManager.rawZip.file(path)
+      ? this.#zipManager.rawZip.file(path).name
+      : '' // wait, let's just make it async or check xmlCache
+    return 'bar' // fallback or default for type check, or we can make it async!
+  }
+
+  async getChartTypeAsync(slideIndex, chartId, slideManager, relationshipManager) {
+    const chartInfo = this.findChartInSlide(slideIndex, chartId, slideManager, relationshipManager)
+    if (!chartInfo) return 'unknown'
+    const queue = this.#chartQueues.get(chartInfo.zipPath) || Promise.resolve()
+    await queue
+    const xml = await this.#zipManager.readFile(chartInfo.zipPath)
+    if (!xml) return 'unknown'
+    return this.#detectChartType(xml)
+  }
+
+  #validateChartData(data) {
+    const { categories, series } = data
+    if (!series || series.length === 0) return
+
+    // Series lengths remain consistent (if categories exist, check against length of categories)
+    const expectedLen = categories
+      ? categories.length
+      : series[0].values
+        ? series[0].values.length
+        : 0
+    for (const ser of series) {
+      const name = ser.name || 'Unknown'
+      const len = ser.values ? ser.values.length : 0
+      if (len !== expectedLen) {
+        throw new Error(
+          `Series lengths mismatch: expected ${expectedLen} values, got ${len} in series ${name}`
+        )
+      }
+
+      // Check values inside the series
+      let hasLabels = false
+      let labelCount = 0
+      for (const val of ser.values) {
+        if (typeof val === 'object' && val !== null) {
+          const numVal = val.value !== undefined ? val.value : val.data
+          // Data values remain numeric
+          if (typeof numVal !== 'number' || isNaN(numVal)) {
+            throw new Error(`Data value must be numeric in series ${name}`)
+          }
+          if (val.label !== undefined) {
+            hasLabels = true
+            labelCount++
+            // Labels are strings
+            if (typeof val.label !== 'string') {
+              throw new Error(`Label must be a string in series ${name}`)
+            }
+          }
+        } else {
+          // Data values remain numeric (primitive value)
+          if (typeof val !== 'number' || isNaN(val)) {
+            throw new Error(`Data value must be numeric in series ${name}`)
+          }
+        }
+      }
+
+      // Label count matches value count
+      if (hasLabels && labelCount !== len) {
+        throw new Error(`Label count mismatch for series ${name}`)
+      }
+    }
+  }
+
+  #normalizeChartData(data) {
+    const cleanSeries = []
+    const seriesLabels = []
+
+    if (data.series) {
+      data.series.forEach(ser => {
+        const cleanValues = []
+        const labels = []
+        let hasLabel = false
+
+        if (ser.values) {
+          ser.values.forEach(v => {
+            if (typeof v === 'object' && v !== null) {
+              const val = v.value !== undefined ? v.value : v.data !== undefined ? v.data : 0
+              cleanValues.push(val)
+              labels.push(v.label)
+              if (v.label !== undefined) hasLabel = true
+            } else {
+              cleanValues.push(Number(v) || 0)
+              labels.push(undefined)
+            }
+          })
+        }
+
+        cleanSeries.push({
+          ...ser,
+          values: cleanValues,
+        })
+        seriesLabels.push(hasLabel ? labels : null)
+      })
+    }
+
+    return {
+      cleanData: {
+        ...data,
+        series: cleanSeries,
+      },
+      labels: seriesLabels,
+    }
+  }
 }
 
 module.exports = { ChartManager }