node-pptx-templater 1.0.6 → 1.0.8

package/src/core/ValidationEngine.js

@@ -318,6 +318,185 @@ class ValidationEngine {
       warnings,
     }
   }
+
+  /**
+   * Validates data label configurations for a chart.
+   *
+   * @param {PPTXTemplater} ppt
+   * @param {number} slideIndex
+   * @param {string} chartId
+   * @param {Object} options
+   * @returns {Promise<Object>} report
+   */
+  static async validateDataLabels(ppt, slideIndex, chartId, options = {}) {
+    const errors = []
+    const warnings = []
+
+    try {
+      const chartInfo = ppt.chartManager.findChartInSlide(
+        slideIndex,
+        chartId,
+        ppt.slideManager,
+        ppt.relationshipManager
+      )
+
+      if (!chartInfo) {
+        errors.push(`Chart "${chartId}" not found in slide ${slideIndex}`)
+        return { valid: false, errors, warnings }
+      }
+
+      const chartType = await ppt.chartManager.getChartTypeAsync(
+        slideIndex,
+        chartId,
+        ppt.slideManager,
+        ppt.relationshipManager
+      )
+
+      const supportedTypes = [
+        'bar',
+        'column',
+        'line',
+        'pie',
+        'doughnut',
+        'area',
+        'scatter',
+        'combo',
+        'unknown',
+      ]
+      if (!supportedTypes.includes(chartType)) {
+        errors.push(`Unsupported chart type "${chartType}" for data labels`)
+      }
+
+      const xml = await ppt.zipManager.readFile(chartInfo.zipPath)
+      let ptsCount = 0
+      const catMatch = /<c:cat>([\s\S]*?)<\/c:cat>/.exec(xml)
+      const valMatch = /<c:val>([\s\S]*?)<\/c:val>/.exec(xml)
+      const targetBlock = catMatch ? catMatch[1] : valMatch ? valMatch[1] : ''
+      const ptCountMatch = /<c:ptCount val="(\d+)"\/>/.exec(targetBlock)
+      if (ptCountMatch) {
+        ptsCount = parseInt(ptCountMatch[1], 10)
+      }
+
+      if (options.labels) {
+        if (ptsCount > 0 && options.labels.length !== ptsCount) {
+          errors.push(
+            `Label count (${options.labels.length}) does not match chart data points count (${ptsCount})`
+          )
+        }
+
+        options.labels.forEach((lbl, i) => {
+          if (lbl === null || lbl === undefined || String(lbl).trim() === '') {
+            warnings.push(`Label at index ${i} is empty`)
+          }
+        })
+      }
+
+      if (options.labelsFromCells) {
+        const range = options.labelsFromCells
+        const parts = range.split('!')
+        const rangePart = parts.length > 1 ? parts[1] : parts[0]
+
+        const rangeRegex = /^\$?[A-Z]+\$?\d+(?::\$?[A-Z]+\$?\d+)?$/i
+        if (!rangeRegex.test(rangePart)) {
+          errors.push(`Invalid range format: "${options.labelsFromCells}"`)
+        }
+      }
+    } catch (err) {
+      errors.push(`Data labels validation error: ${err.message}`)
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+    }
+  }
+
+  /**
+   * Validates a list structure and values.
+   *
+   * @param {Object|Array} data - List config object or array of items.
+   * @returns {Object} Report containing errors and warnings.
+   */
+  static validateList(data) {
+    const errors = []
+    const warnings = []
+
+    if (!data) {
+      errors.push('List data must be provided')
+      return { valid: false, errors, warnings }
+    }
+
+    const listArray = Array.isArray(data) ? data : data.list
+    if (!listArray) {
+      errors.push('List data must contain an array under the "list" property or be an array')
+      return { valid: false, errors, warnings }
+    }
+
+    const checkItem = (item, level) => {
+      if (level < 0 || level > 8) {
+        errors.push(`Level ${level} is out of supported range (0 to 8)`)
+      }
+
+      if (typeof item === 'string') {
+        if (item.trim() === '') {
+          errors.push('Empty list item text is not allowed')
+        }
+      } else if (typeof item === 'object' && item !== null) {
+        if (item.text === undefined || item.text === null || String(item.text).trim() === '') {
+          errors.push('Empty list item text is not allowed')
+        }
+        if (item.children) {
+          if (!Array.isArray(item.children)) {
+            errors.push('Children property must be an array of items')
+          } else {
+            item.children.forEach(child => {
+              checkItem(child, level + 1)
+            })
+          }
+        }
+      } else {
+        errors.push(`Invalid list item type: "${typeof item}"`)
+      }
+    }
+
+    listArray.forEach(item => {
+      checkItem(item, 0)
+    })
+
+    if (data.style) {
+      const style = data.style
+      if (style.fontSize !== undefined) {
+        if (typeof style.fontSize !== 'number' || style.fontSize <= 0) {
+          errors.push('fontSize must be a positive number')
+        }
+      }
+      if (style.color !== undefined) {
+        if (typeof style.color !== 'string' || !/^#(?:[0-9a-fA-F]{3}){1,2}$/.test(style.color)) {
+          errors.push(`Invalid color format: "${style.color}" (expected hex e.g. #FF0000)`)
+        }
+      }
+      if (style.bulletColor !== undefined) {
+        if (
+          typeof style.bulletColor !== 'string' ||
+          !/^#(?:[0-9a-fA-F]{3}){1,2}$/.test(style.bulletColor)
+        ) {
+          errors.push(`Invalid bulletColor format: "${style.bulletColor}"`)
+        }
+      }
+      if (style.bulletSize !== undefined) {
+        if (typeof style.bulletSize !== 'number' || style.bulletSize <= 0) {
+          errors.push('bulletSize must be a positive number')
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+    }
+  }
 }
 
 module.exports = { ValidationEngine }

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,22 @@ 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
+    let updatedXml = this.#applyChartData(xml, cleanNumericData, chartZipPath)
+    if (data.title !== undefined) {
+      updatedXml = require('./charts/ChartCacheGenerator.js').ChartCacheGenerator.updateTitle(
+        updatedXml,
+        data.title
+      )
+    }
     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 +280,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 +290,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 +345,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 +373,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 +399,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 +474,333 @@ 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 (data.title !== undefined && typeof data.title !== 'string') {
+      throw new Error('Chart title must be a string')
+    }
+    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'
+      if (!ser.values) {
+        ser.values = []
+      }
+
+      // Check if there is any label in the series to determine padding style
+      let seriesHasLabels = false
+      for (const val of ser.values) {
+        if (typeof val === 'object' && val !== null && val.label !== undefined) {
+          seriesHasLabels = true
+          break
+        }
+      }
+
+      // Pad or truncate values to match expectedLen
+      if (ser.values.length < expectedLen) {
+        while (ser.values.length < expectedLen) {
+          if (seriesHasLabels) {
+            ser.values.push({ value: null, label: '' })
+          } else {
+            ser.values.push(null)
+          }
+        }
+      } else if (ser.values.length > expectedLen) {
+        ser.values = ser.values.slice(0, expectedLen)
+      }
+
+      const len = ser.values.length
+
+      // 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 or null
+          if (numVal !== null && (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) or null
+          if (val !== null && (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 : null
+              cleanValues.push(val)
+              labels.push(v.label)
+              if (v.label !== undefined) hasLabel = true
+            } else {
+              cleanValues.push(v === null || v === undefined ? null : 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 }