node-pptx-templater 1.0.17 → 1.0.18

package/src/managers/ZipManager.js

@@ -82,6 +82,18 @@ class ZipManager {
    */
   #removedFiles = new Set()
 
+  /**
+   * @private
+   * @type {Map<string, { type: string, content: string|Buffer|Uint8Array }>|null}
+   */
+  #cachedFiles = null
+
+  async loadFromCache(cachedFilesMap) {
+    this.#cachedFiles = cachedFilesMap
+    await this.#loadCoreProperties()
+    logger.debug(`Loaded from cache. Files: ${cachedFilesMap.size}`)
+  }
+
   async load(source) {
     try {
       const path = require('path')
@@ -221,6 +233,19 @@ class ZipManager {
       return this.#dirtyFiles.get(normalPath)
     }
 
+    if (this.#cachedFiles && this.#cachedFiles.has(normalPath)) {
+      const entry = this.#cachedFiles.get(normalPath)
+      let content
+      if (entry.type === 'text') {
+        content = entry.content
+      } else {
+        const { TextDecoder } = require('util')
+        content = new TextDecoder('utf-8').decode(entry.content)
+      }
+      this.#xmlCache.set(normalPath, content)
+      return content
+    }
+
     if (this.#isFolderMode) {
       const path = require('path')
       const fs = require('fs-extra')
@@ -234,6 +259,7 @@ class ZipManager {
       return content
     }
 
+    if (!this.#zip) return null
     const file = this.#zip.file(normalPath)
     if (!file) {
       logger.debug(`File not found in ZIP: ${normalPath}`)
@@ -256,7 +282,22 @@ class ZipManager {
     if (this.#dirtyFiles.has(normalPath)) {
       return this.#dirtyFiles.get(normalPath)
     }
-    return this.#xmlCache.get(normalPath) || null
+    if (this.#xmlCache.has(normalPath)) {
+      return this.#xmlCache.get(normalPath)
+    }
+    if (this.#cachedFiles && this.#cachedFiles.has(normalPath)) {
+      const entry = this.#cachedFiles.get(normalPath)
+      let content
+      if (entry.type === 'text') {
+        content = entry.content
+      } else {
+        const { TextDecoder } = require('util')
+        content = new TextDecoder('utf-8').decode(entry.content)
+      }
+      this.#xmlCache.set(normalPath, content)
+      return content
+    }
+    return null
   }
 
   /**
@@ -270,6 +311,10 @@ class ZipManager {
     if (this.#dirtyBinaryFiles.has(normalPath)) {
       return this.#dirtyBinaryFiles.get(normalPath)
     }
+    if (this.#cachedFiles && this.#cachedFiles.has(normalPath)) {
+      const entry = this.#cachedFiles.get(normalPath)
+      return entry.content
+    }
     if (this.#isFolderMode) {
       const path = require('path')
       const fs = require('fs-extra')
@@ -277,6 +322,7 @@ class ZipManager {
       if (!(await fs.pathExists(diskPath))) return null
       return fs.readFile(diskPath)
     }
+    if (!this.#zip) return null
     const file = this.#zip.file(normalPath)
     if (!file) return null
     return file.async('uint8array')
@@ -354,10 +400,11 @@ class ZipManager {
     const normalPath = zipPath.replace(/\\/g, '/')
     if (this.#removedFiles.has(normalPath)) return false
     if (this.#dirtyFiles.has(normalPath) || this.#dirtyBinaryFiles.has(normalPath)) return true
+    if (this.#cachedFiles && this.#cachedFiles.has(normalPath)) return true
     if (this.#isFolderMode) {
       return this.#folderFiles.has(normalPath)
     }
-    return this.#zip.file(normalPath) !== null
+    return this.#zip && this.#zip.file(normalPath) !== null
   }
 
   /**
@@ -367,6 +414,14 @@ class ZipManager {
    * @returns {string[]} Array of matching file paths.
    */
   listFiles(prefix = '') {
+    if (this.#cachedFiles) {
+      const allFiles = new Set([
+        ...this.#cachedFiles.keys(),
+        ...this.#dirtyFiles.keys(),
+        ...this.#dirtyBinaryFiles.keys(),
+      ])
+      return Array.from(allFiles).filter(f => !this.#removedFiles.has(f) && f.startsWith(prefix))
+    }
     if (this.#isFolderMode) {
       const allFiles = new Set([
         ...this.#folderFiles,
@@ -375,6 +430,7 @@ class ZipManager {
       ])
       return Array.from(allFiles).filter(f => !this.#removedFiles.has(f) && f.startsWith(prefix))
     }
+    if (!this.#zip) return []
     return Object.keys(this.#zip.files).filter(f => !this.#zip.files[f].dir && f.startsWith(prefix))
   }
 
@@ -384,23 +440,43 @@ class ZipManager {
    *
    * @returns {Promise<Buffer>} Compressed PPTX as a Buffer.
    */
-  async toBuffer() {
+  async toBuffer(options = {}) {
     await this.#ensureZipForExport()
-    return this.#zip.generateAsync({
-      type: 'nodebuffer',
-      compression: 'DEFLATE',
-      compressionOptions: { level: 6 },
-    })
+    const zipOptions = this.#getZipOptions(options)
+    return this.#zip.generateAsync(zipOptions)
   }
 
-  async toStream() {
+  async toStream(options = {}) {
     await this.#ensureZipForExport()
-    return this.#zip.generateNodeStream({
+    const zipOptions = this.#getZipOptions(options)
+    zipOptions.streamFiles = true
+    return this.#zip.generateNodeStream(zipOptions)
+  }
+
+  #getZipOptions(options = {}) {
+    const compression = options.compression || 'balanced'
+    let method = 'DEFLATE'
+    let level = 6
+
+    if (compression === 'none' || compression === 'store') {
+      method = 'STORE'
+      level = 0
+    } else if (compression === 'fast') {
+      method = 'DEFLATE'
+      level = 1
+    } else if (compression === 'balanced') {
+      method = 'DEFLATE'
+      level = 6
+    } else if (compression === 'maximum') {
+      method = 'DEFLATE'
+      level = 9
+    }
+
+    return {
       type: 'nodebuffer',
-      compression: 'DEFLATE',
-      compressionOptions: { level: 6 },
-      streamFiles: true,
-    })
+      compression: method,
+      compressionOptions: method === 'DEFLATE' ? { level } : undefined,
+    }
   }
 
   /**
@@ -594,6 +670,36 @@ class ZipManager {
 
     const zip = new JSZip()
 
+    if (this.#cachedFiles) {
+      // 1. Read all files from cache (that are not removed)
+      for (const [relPath, entry] of this.#cachedFiles.entries()) {
+        if (this.#removedFiles.has(relPath)) continue
+
+        if (this.#dirtyFiles.has(relPath)) {
+          zip.file(relPath, this.#dirtyFiles.get(relPath))
+        } else if (this.#dirtyBinaryFiles.has(relPath)) {
+          zip.file(relPath, this.#dirtyBinaryFiles.get(relPath))
+        } else {
+          zip.file(relPath, entry.content)
+        }
+      }
+
+      // 2. Write any new files that were added (and not already in cache)
+      for (const [relPath, content] of this.#dirtyFiles.entries()) {
+        if (!this.#cachedFiles.has(relPath) && !this.#removedFiles.has(relPath)) {
+          zip.file(relPath, content)
+        }
+      }
+      for (const [relPath, data] of this.#dirtyBinaryFiles.entries()) {
+        if (!this.#cachedFiles.has(relPath) && !this.#removedFiles.has(relPath)) {
+          zip.file(relPath, data)
+        }
+      }
+
+      this.#zip = zip
+      return zip
+    }
+
     // 1. Read all files from the original folder structure (that are not removed)
     for (const relPath of this.#folderFiles) {
       if (this.#removedFiles.has(relPath)) continue

package/src/managers/charts/ChartWorkbookUpdater.js

@@ -184,7 +184,7 @@ class ChartWorkbookUpdater {
   static #serializeSheetXml(sheetXml, cells) {
     // Group cells by row
     const rows = {}
-    for (const [ref, val] of Object.entries(cells)) {
+    for (const ref of Object.keys(cells)) {
       const rowMatch = /\d+$/.exec(ref)
       if (!rowMatch) continue
       const r = parseInt(rowMatch[0], 10)

package/src/utils/contentTypesHelper.js

@@ -70,10 +70,9 @@ class ContentTypesHelper {
    */
   addMediaDefault(zipManager, extension, mimeType) {
     this.#updateQueue = this.#updateQueue.then(async () => {
-      const xmlFile = zipManager.rawZip.file('[Content_Types].xml')
-      if (!xmlFile) return
+      const content = await zipManager.readFile('[Content_Types].xml')
+      if (!content) return
 
-      const content = await xmlFile.async('text')
       const entry = `Extension="${extension}" ContentType="${mimeType}"`
       if (!content.includes(entry)) {
         const updated = content.replace('</Types>', `  <Default ${entry}/>\n</Types>`)
@@ -92,12 +91,11 @@ class ContentTypesHelper {
    */
   #addOverride(zipManager, partName, contentType) {
     this.#updateQueue = this.#updateQueue.then(async () => {
-      const xmlFile = zipManager.rawZip.file('[Content_Types].xml')
-      if (!xmlFile) {
+      const content = await zipManager.readFile('[Content_Types].xml')
+      if (!content) {
         logger.warn('[Content_Types].xml not found')
         return
       }
-      const content = await xmlFile.async('text')
       const entry = `PartName="${partName}"`
       if (!content.includes(entry)) {
         const override = `<Override PartName="${partName}" ContentType="${contentType}"/>`
@@ -115,12 +113,11 @@ class ContentTypesHelper {
    */
   #removeOverride(zipManager, partName) {
     this.#updateQueue = this.#updateQueue.then(async () => {
-      const xmlFile = zipManager.rawZip.file('[Content_Types].xml')
-      if (!xmlFile) {
+      const content = await zipManager.readFile('[Content_Types].xml')
+      if (!content) {
         logger.warn('[Content_Types].xml not found')
         return
       }
-      const content = await xmlFile.async('text')
       const regex = new RegExp(`<Override[^>]*PartName="${partName}"[^>]*/>\\s*`, 'g')
       if (regex.test(content)) {
         const updated = content.replace(regex, '')

package/src/utils/imageMetadata.js

@@ -0,0 +1,227 @@
+/**
+ * @fileoverview imageMetadata - Pure JS helper to read image dimensions without full file reads.
+ */
+
+const fs = require('fs')
+const { promisify } = require('util')
+const openAsync = promisify(fs.open)
+const readAsync = promisify(fs.read)
+const closeAsync = promisify(fs.close)
+
+/**
+ * Reads image dimensions and aspect ratio from a file path or buffer.
+ *
+ * @param {string|Buffer} source - File path or image Buffer.
+ * @returns {Promise<{ width: number, height: number, aspectRatio: number, type: string }>}
+ */
+async function getImageMetadata(source) {
+  let buffer
+  const isBuffer = Buffer.isBuffer(source) || source instanceof Uint8Array
+
+  if (isBuffer) {
+    buffer = Buffer.isBuffer(source) ? source : Buffer.from(source)
+  } else if (typeof source === 'string') {
+    // Read only the first 8KB of the file
+    let fd
+    try {
+      fd = await openAsync(source, 'r')
+      const tempBuffer = Buffer.alloc(8192)
+      const { bytesRead } = await readAsync(fd, tempBuffer, 0, 8192, 0)
+      buffer = tempBuffer.subarray(0, bytesRead)
+    } finally {
+      if (fd !== undefined) {
+        await closeAsync(fd).catch(() => {})
+      }
+    }
+  } else {
+    throw new Error('Unsupported image source type')
+  }
+
+  if (buffer.length < 4) {
+    throw new Error('Image file is too small or corrupt')
+  }
+
+  // Detect image type by magic bytes
+  if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
+    return parsePng(buffer)
+  }
+
+  if (buffer[0] === 0xff && buffer[1] === 0xd8) {
+    return parseJpeg(buffer)
+  }
+
+  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
+    return parseGif(buffer)
+  }
+
+  if (buffer[0] === 0x42 && buffer[1] === 0x4d) {
+    return parseBmp(buffer)
+  }
+
+  // Check for SVG (starts with XML declaration or <svg)
+  const textContent = buffer.toString('utf8').trim()
+  if (
+    textContent.startsWith('<svg') ||
+    textContent.includes('<svg') ||
+    textContent.startsWith('<?xml')
+  ) {
+    return parseSvg(textContent)
+  }
+
+  throw new Error('Unsupported image format or unrecognized signature')
+}
+
+function parsePng(buffer) {
+  if (buffer.length < 24) {
+    throw new Error('PNG header too short')
+  }
+  // Width is at offset 16 (4 bytes, big endian)
+  const width = buffer.readUInt32BE(16)
+  // Height is at offset 20 (4 bytes, big endian)
+  const height = buffer.readUInt32BE(20)
+
+  return {
+    width,
+    height,
+    aspectRatio: width / height,
+    type: 'png',
+  }
+}
+
+function parseGif(buffer) {
+  if (buffer.length < 10) {
+    throw new Error('GIF header too short')
+  }
+  // Width is at offset 6 (2 bytes, little endian)
+  const width = buffer.readUInt16LE(6)
+  // Height is at offset 8 (2 bytes, little endian)
+  const height = buffer.readUInt16LE(8)
+
+  return {
+    width,
+    height,
+    aspectRatio: width / height,
+    type: 'gif',
+  }
+}
+
+function parseBmp(buffer) {
+  if (buffer.length < 26) {
+    throw new Error('BMP header too short')
+  }
+  // Width is at offset 18 (4 bytes, little endian)
+  const width = buffer.readInt32LE(18)
+  // Height is at offset 22 (4 bytes, little endian)
+  const height = buffer.readInt32LE(22)
+
+  return {
+    width: Math.abs(width),
+    height: Math.abs(height),
+    aspectRatio: Math.abs(width) / Math.abs(height),
+    type: 'bmp',
+  }
+}
+
+function parseJpeg(buffer) {
+  let offset = 2 // Skip SOI marker (FF D8)
+
+  while (offset < buffer.length - 8) {
+    // Check marker signature
+    if (buffer[offset] !== 0xff) {
+      // Not a valid marker, search next FF
+      offset++
+      continue
+    }
+
+    // Skip extra FF padding
+    while (buffer[offset] === 0xff && offset < buffer.length) {
+      offset++
+    }
+
+    if (offset >= buffer.length) break
+
+    const marker = buffer[offset]
+    offset++
+
+    // SOI, EOI, TEM have no length
+    if (marker === 0xd8 || marker === 0xd9 || marker === 0x01) {
+      continue
+    }
+
+    // Read segment length (2 bytes, big endian)
+    const length = buffer.readUInt16BE(offset)
+
+    // Check SOF markers: C0-C3, C5-CB, CD-CF
+    const isSOF =
+      (marker >= 0xc0 && marker <= 0xc3) ||
+      (marker >= 0xc5 && marker <= 0xcb) ||
+      (marker >= 0xcd && marker <= 0xcf)
+
+    if (isSOF) {
+      // SOF structure:
+      // Offset 0: precision (1 byte)
+      // Offset 1: height (2 bytes, big endian)
+      // Offset 3: width (2 bytes, big endian)
+      const height = buffer.readUInt16BE(offset + 3)
+      const width = buffer.readUInt16BE(offset + 5)
+
+      return {
+        width,
+        height,
+        aspectRatio: width / height,
+        type: 'jpg',
+      }
+    }
+
+    // Advance to next marker
+    offset += length
+  }
+
+  throw new Error('Could not find JPEG SOF marker')
+}
+
+function parseSvg(text) {
+  // Try finding <svg ...> tag
+  const svgMatch = /<svg([^>]+)>/i.exec(text)
+  if (!svgMatch) {
+    throw new Error('Invalid SVG: missing <svg> tag')
+  }
+
+  const svgAttr = svgMatch[1]
+
+  const widthMatch = /width\s*=\s*["']([^"']+)["']/i.exec(svgAttr)
+  const heightMatch = /height\s*=\s*["']([^"']+)["']/i.exec(svgAttr)
+  const viewBoxMatch = /viewBox\s*=\s*["']([^"']+)["']/i.exec(svgAttr)
+
+  let width = 0
+  let height = 0
+
+  if (widthMatch) width = parseFloat(widthMatch[1])
+  if (heightMatch) height = parseFloat(heightMatch[1])
+
+  // If width/height missing or using units, fallback to viewBox
+  if ((!width || !height || isNaN(width) || isNaN(height)) && viewBoxMatch) {
+    const parts = viewBoxMatch[1].trim().split(/\s+/)
+    if (parts.length === 4) {
+      const vbWidth = parseFloat(parts[2])
+      const vbHeight = parseFloat(parts[3])
+      if (!isNaN(vbWidth) && !isNaN(vbHeight)) {
+        width = width || vbWidth
+        height = height || vbHeight
+      }
+    }
+  }
+
+  // Default fallbacks if everything fails
+  width = width || 800
+  height = height || 600
+
+  return {
+    width,
+    height,
+    aspectRatio: width / height,
+    type: 'svg',
+  }
+}
+
+module.exports = { getImageMetadata }