easy-template-x 6.2.0 → 6.2.2

package/README.md

@@ -14,7 +14,7 @@ Generate docx documents from templates, in Node or in the browser.
 >
 > ✓ PDF support  
 > ✓ REST API integration  
-> ✓ Zapier integration  
+> ✓ Zapier and Make integration  
 > ✓ Live preview functionality  
 > ✓ Easy-to-use UI  
 >

package/dist/cjs/easy-template-x.cjs

@@ -404,6 +404,10 @@ function stringValue(val) {
 function normalizeDoubleQuotes(text) {
   return text.replace(nonStandardDoubleQuotesRegex, standardDoubleQuotes);
 }
+function countOccurrences(text, substring) {
+  // https://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string
+  return (text.match(new RegExp(substring, 'g')) || []).length;
+}
 
 class JsZipHelper {
   static toJsZipOutputType(binaryOrType) {
@@ -491,6 +495,71 @@ const XmlNodeType = Object.freeze({
 const TEXT_NODE_NAME = '#text'; // see: https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeName
 const COMMENT_NODE_NAME = '#comment';
 
+class XmlDepthTracker {
+  depth = 0;
+  constructor(maxDepth) {
+    this.maxDepth = maxDepth;
+  }
+  increment() {
+    this.depth++;
+    if (this.depth > this.maxDepth) {
+      throw new MaxXmlDepthError(this.maxDepth);
+    }
+  }
+  decrement() {
+    this.depth--;
+  }
+}
+
+class XmlTreeIterator {
+  get node() {
+    return this._current;
+  }
+  constructor(initial, maxDepth) {
+    if (!initial) {
+      throw new InternalError("Initial node is required");
+    }
+    if (!maxDepth) {
+      throw new InternalError("Max depth is required");
+    }
+    this._current = initial;
+    this.depthTracker = new XmlDepthTracker(maxDepth);
+  }
+  next() {
+    if (!this._current) {
+      return null;
+    }
+    this._current = this.findNextNode(this._current);
+    return this._current;
+  }
+  setCurrent(node) {
+    this._current = node;
+  }
+  findNextNode(node) {
+    // Children
+    if (node.childNodes && node.childNodes.length) {
+      this.depthTracker.increment();
+      return node.childNodes[0];
+    }
+
+    // Siblings
+    if (node.nextSibling) return node.nextSibling;
+
+    // Parent sibling
+    while (node.parentNode) {
+      if (node.parentNode.nextSibling) {
+        this.depthTracker.decrement();
+        return node.parentNode.nextSibling;
+      }
+
+      // Go up
+      this.depthTracker.decrement();
+      node = node.parentNode;
+    }
+    return null;
+  }
+}
+
 class XmlUtils {
   parser = new Parser();
   create = new Create();
@@ -690,16 +759,19 @@ let Query$1 = class Query {
   isTextNode(node) {
     if (node.nodeType === XmlNodeType.Text || node.nodeName === TEXT_NODE_NAME) {
       if (!(node.nodeType === XmlNodeType.Text && node.nodeName === TEXT_NODE_NAME)) {
-        throw new Error(`Invalid text node. Type: '${node.nodeType}', Name: '${node.nodeName}'.`);
+        throw new InternalError(`Invalid text node. Type: '${node.nodeType}', Name: '${node.nodeName}'.`);
       }
       return true;
     }
     return false;
   }
+  isGeneralNode(node) {
+    return node.nodeType === XmlNodeType.General;
+  }
   isCommentNode(node) {
     if (node.nodeType === XmlNodeType.Comment || node.nodeName === COMMENT_NODE_NAME) {
       if (!(node.nodeType === XmlNodeType.Comment && node.nodeName === COMMENT_NODE_NAME)) {
-        throw new Error(`Invalid comment node. Type: '${node.nodeType}', Name: '${node.nodeName}'.`);
+        throw new InternalError(`Invalid comment node. Type: '${node.nodeType}', Name: '${node.nodeName}'.`);
       }
       return true;
     }
@@ -778,6 +850,17 @@ let Query$1 = class Query {
     range.push(lastNode);
     return range;
   }
+  descendants(node, maxDepth, predicate) {
+    const result = [];
+    const it = new XmlTreeIterator(node, maxDepth);
+    while (it.node) {
+      if (predicate(it.node)) {
+        result.push(it.node);
+      }
+      it.next();
+    }
+    return result;
+  }
 };
 let Modify$1 = class Modify {
   /**
@@ -1030,22 +1113,6 @@ function recursiveRemoveEmptyTextNodes(node) {
 }
 const xml = new XmlUtils();
 
-class XmlDepthTracker {
-  depth = 0;
-  constructor(maxDepth) {
-    this.maxDepth = maxDepth;
-  }
-  increment() {
-    this.depth++;
-    if (this.depth > this.maxDepth) {
-      throw new MaxXmlDepthError(this.maxDepth);
-    }
-  }
-  decrement() {
-    this.depth--;
-  }
-}
-
 /**
  * The types of relationships that can be created in a docx file.
  * A non-comprehensive list.
@@ -1149,14 +1216,17 @@ class ContentTypesFile {
     this.zip = zip;
   }
   async ensureContentType(mime) {
-    // parse the content types file
+    // Parse the content types file
     await this.parseContentTypesFile();
 
-    // already exists
-    if (this.contentTypes[mime]) return;
-
-    // add new
+    // Extension already exists
+    //
+    // Multiple extensions may map to the same mime type, but a single
+    // extension must only map to one mime type.
     const extension = MimeTypeHelper.getDefaultExtension(mime);
+    if (this.contentTypes[extension]) return;
+
+    // Add new node
     const typeNode = xml.create.generalNode('Default');
     typeNode.attributes = {
       "Extension": extension,
@@ -1164,13 +1234,13 @@ class ContentTypesFile {
     };
     this.root.childNodes.push(typeNode);
 
-    // update state
+    // Update state
     this.addedNew = true;
-    this.contentTypes[mime] = true;
+    this.contentTypes[extension] = mime;
   }
-  async count() {
+  async xmlString() {
     await this.parseContentTypesFile();
-    return this.root.childNodes.filter(node => !xml.query.isTextNode(node)).length;
+    return xml.parser.serializeFile(this.root);
   }
 
   /**
@@ -1178,7 +1248,7 @@ class ContentTypesFile {
    * Called automatically by the holding `Docx` before exporting.
    */
   async save() {
-    // not change - no need to save
+    // Not change - no need to save
     if (!this.addedNew) return;
     const xmlContent = xml.parser.serializeFile(this.root);
     this.zip.setFile(ContentTypesFile.contentTypesFilePath, xmlContent);
@@ -1197,7 +1267,9 @@ class ContentTypesFile {
       const genNode = node;
       const contentTypeAttribute = genNode.attributes['ContentType'];
       if (!contentTypeAttribute) continue;
-      this.contentTypes[contentTypeAttribute] = true;
+      const extensionAttribute = genNode.attributes['Extension'];
+      if (!extensionAttribute) continue;
+      this.contentTypes[extensionAttribute] = contentTypeAttribute;
     }
   }
 }
@@ -1217,39 +1289,38 @@ class MediaFiles {
    * Returns the media file path.
    */
   async add(mediaFile, mime) {
-    // check if already added
+    // Check if already added
     if (this.files.has(mediaFile)) return this.files.get(mediaFile);
 
-    // hash existing media files
+    // Hash existing media files
     await this.hashMediaFiles();
 
-    // hash the new file
+    // Hash the new file
     // Note: Even though hashing the base64 string may seem inefficient
     // (requires extra step in some cases) in practice it is significantly
     // faster than hashing a 'binarystring'.
     const base64 = await Binary.toBase64(mediaFile);
     const hash = sha1(base64);
 
-    // check if file already exists
-    // note: this can be optimized by keeping both mapping by filename as well as by hash
+    // Check if file already exists
+    // Note: this can be optimized by keeping both mapping by filename as well as by hash
     let path = Object.keys(this.hashes).find(p => this.hashes[p] === hash);
     if (path) return path;
 
-    // generate unique media file name
+    // Generate unique media file name
+    const baseFilename = this.baseFilename(mime);
     const extension = MimeTypeHelper.getDefaultExtension(mime);
     do {
       this.nextFileId++;
-      path = `${MediaFiles.mediaDir}/media${this.nextFileId}.${extension}`;
+      path = `${MediaFiles.mediaDir}/${baseFilename}${this.nextFileId}.${extension}`;
     } while (this.hashes[path]);
 
-    // add media to zip
-    await this.zip.setFile(path, mediaFile);
+    // Add media to zip
+    this.zip.setFile(path, mediaFile);
 
-    // add media to our lookups
+    // Add media to our lookups
     this.hashes[path] = hash;
     this.files.set(mediaFile, path);
-
-    // return
     return path;
   }
   async count() {
@@ -1265,9 +1336,15 @@ class MediaFiles {
       if (!filename) continue;
       const fileData = await this.zip.getFile(path).getContentBase64();
       const fileHash = sha1(fileData);
-      this.hashes[filename] = fileHash;
+      this.hashes[path] = fileHash;
     }
   }
+  baseFilename(mime) {
+    // Naive heuristic.
+    // May need to be modified if we're going to support more mime types.
+    const parts = mime.split('/');
+    return parts[0];
+  }
 }
 
 /**
@@ -2168,30 +2245,30 @@ class DelimiterSearcher {
 
     const delimiters = [];
     const match = new MatchState();
-    const depth = new XmlDepthTracker(this.maxXmlDepth);
+    const it = new XmlTreeIterator(node, this.maxXmlDepth);
     let lookForOpenDelimiter = true;
-    while (node) {
+    while (it.node) {
       // Reset state on paragraph transition
-      if (officeMarkup.query.isParagraphNode(node)) {
+      if (officeMarkup.query.isParagraphNode(it.node)) {
         match.reset();
       }
 
       // Skip irrelevant nodes
-      if (!this.shouldSearchNode(node)) {
-        node = this.findNextNode(node, depth);
+      if (!this.shouldSearchNode(it)) {
+        it.next();
         continue;
       }
 
       // Search delimiters in text nodes
-      match.openNodes.push(node);
+      match.openNodes.push(it.node);
       let textIndex = 0;
-      while (textIndex < node.textContent.length) {
+      while (textIndex < it.node.textContent.length) {
         const delimiterPattern = lookForOpenDelimiter ? this.startDelimiter : this.endDelimiter;
-        const char = node.textContent[textIndex];
+        const char = it.node.textContent[textIndex];
 
         // No match
         if (char !== delimiterPattern[match.delimiterIndex]) {
-          [node, textIndex] = this.noMatch(node, textIndex, match);
+          textIndex = this.noMatch(it, textIndex, match);
           textIndex++;
           continue;
         }
@@ -2209,14 +2286,14 @@ class DelimiterSearcher {
         }
 
         // Full delimiter match
-        [node, textIndex, lookForOpenDelimiter] = this.fullMatch(node, textIndex, lookForOpenDelimiter, match, delimiters);
+        [textIndex, lookForOpenDelimiter] = this.fullMatch(it, textIndex, lookForOpenDelimiter, match, delimiters);
         textIndex++;
       }
-      node = this.findNextNode(node, depth);
+      it.next();
     }
     return delimiters;
   }
-  noMatch(node, textIndex, match) {
+  noMatch(it, textIndex, match) {
     //
     // Go back to first open node
     //
@@ -2226,25 +2303,26 @@ class DelimiterSearcher {
     // Delimiter is '{!' and template text contains the string '{{!'
     //
     if (match.firstMatchIndex !== -1) {
-      node = first(match.openNodes);
+      const node = first(match.openNodes);
+      it.setCurrent(node);
       textIndex = match.firstMatchIndex;
     }
 
     // Update state
     match.reset();
-    if (textIndex < node.textContent.length - 1) {
-      match.openNodes.push(node);
+    if (textIndex < it.node.textContent.length - 1) {
+      match.openNodes.push(it.node);
     }
-    return [node, textIndex];
+    return textIndex;
   }
-  fullMatch(node, textIndex, lookForOpenDelimiter, match, delimiters) {
+  fullMatch(it, textIndex, lookForOpenDelimiter, match, delimiters) {
     // Move all delimiters characters to the same text node
     if (match.openNodes.length > 1) {
       const firstNode = first(match.openNodes);
       const lastNode = last(match.openNodes);
       officeMarkup.modify.joinTextNodesRange(firstNode, lastNode);
-      textIndex += firstNode.textContent.length - node.textContent.length;
-      node = firstNode;
+      textIndex += firstNode.textContent.length - it.node.textContent.length;
+      it.setCurrent(firstNode);
     }
 
     // Store delimiter
@@ -2254,41 +2332,18 @@ class DelimiterSearcher {
     // Update state
     lookForOpenDelimiter = !lookForOpenDelimiter;
     match.reset();
-    if (textIndex < node.textContent.length - 1) {
-      match.openNodes.push(node);
+    if (textIndex < it.node.textContent.length - 1) {
+      match.openNodes.push(it.node);
     }
-    return [node, textIndex, lookForOpenDelimiter];
+    return [textIndex, lookForOpenDelimiter];
   }
-  shouldSearchNode(node) {
-    if (!xml.query.isTextNode(node)) return false;
-    if (!node.textContent) return false;
-    if (!node.parentNode) return false;
-    if (!officeMarkup.query.isTextNode(node.parentNode)) return false;
+  shouldSearchNode(it) {
+    if (!xml.query.isTextNode(it.node)) return false;
+    if (!it.node.textContent) return false;
+    if (!it.node.parentNode) return false;
+    if (!officeMarkup.query.isTextNode(it.node.parentNode)) return false;
     return true;
   }
-  findNextNode(node, depth) {
-    // Children
-    if (node.childNodes && node.childNodes.length) {
-      depth.increment();
-      return node.childNodes[0];
-    }
-
-    // Siblings
-    if (node.nextSibling) return node.nextSibling;
-
-    // Parent sibling
-    while (node.parentNode) {
-      if (node.parentNode.nextSibling) {
-        depth.decrement();
-        return node.parentNode.nextSibling;
-      }
-
-      // Go up
-      depth.decrement();
-      node = node.parentNode;
-    }
-    return null;
-  }
   createDelimiterMark(match, isOpenDelimiter) {
     return {
       index: match.firstMatchIndex,
@@ -2529,17 +2584,6 @@ class TemplatePlugin {
   }
 }
 
-/**
- * Apparently it is not that important for the ID to be unique...
- * Word displays two images correctly even if they both have the same ID.
- * Further more, Word will assign each a unique ID upon saving (it assigns
- * consecutive integers starting with 1).
- *
- * Note: The same principal applies to image names.
- *
- * Tested in Word v1908
- */
-let nextImageId = 1;
 class ImagePlugin extends TemplatePlugin {
   contentType = 'image';
   async simpleTagReplacements(tag, data, context) {
@@ -2556,12 +2600,47 @@ class ImagePlugin extends TemplatePlugin {
     await context.docx.contentTypes.ensureContentType(content.format);
 
     // Create the xml markup
-    const imageId = nextImageId++;
+    const imageId = await this.getNextImageId(context);
     const imageXml = this.createMarkup(imageId, relId, content);
     const wordTextNode = officeMarkup.query.containingTextNode(tag.xmlTextNode);
     xml.modify.insertAfter(imageXml, wordTextNode);
     officeMarkup.modify.removeTag(tag.xmlTextNode);
   }
+  async getNextImageId(context) {
+    // Init plugin context.
+    if (!context.pluginContext[this.contentType]) {
+      context.pluginContext[this.contentType] = {};
+    }
+    const pluginContext = context.pluginContext[this.contentType];
+    if (!pluginContext.lastDrawingObjectId) {
+      pluginContext.lastDrawingObjectId = {};
+    }
+    const lastIdMap = pluginContext.lastDrawingObjectId;
+    const lastIdKey = context.currentPart.path;
+
+    // Get next image ID if already initialized.
+    if (lastIdMap[lastIdKey]) {
+      lastIdMap[lastIdKey]++;
+      return lastIdMap[lastIdKey];
+    }
+
+    // Init next image ID.
+    const partRoot = await context.currentPart.xmlRoot();
+    const maxDepth = context.options.maxXmlDepth;
+
+    // Get all existing doc props IDs
+    // (docPr stands for "Drawing Object Non-Visual Properties", which isn't
+    // exactly a good acronym but that's how it's called nevertheless)
+    const docProps = xml.query.descendants(partRoot, maxDepth, node => {
+      return xml.query.isGeneralNode(node) && node.nodeName === 'wp:docPr';
+    });
+
+    // Start counting from the current max
+    const ids = docProps.map(prop => parseInt(prop.attributes.id)).filter(isNumber);
+    const maxId = Math.max(...ids, 0);
+    lastIdMap[lastIdKey] = maxId + 1;
+    return lastIdMap[lastIdKey];
+  }
   createMarkup(imageId, relId, content) {
     // http://officeopenxml.com/drwPicInline.php
 
@@ -4618,7 +4697,7 @@ class TemplateHandler {
   /**
    * Version number of the `easy-template-x` library.
    */
-  version = "6.2.0" ;
+  version = "6.2.2" ;
   constructor(options) {
     this.options = new TemplateHandlerOptions(options);
 
@@ -4666,7 +4745,11 @@ class TemplateHandler {
     scopeData.scopeDataResolver = this.options.scopeDataResolver;
     const context = {
       docx,
-      currentPart: null
+      currentPart: null,
+      pluginContext: {},
+      options: {
+        maxXmlDepth: this.options.maxXmlDepth
+      }
     };
     const contentParts = await docx.getContentParts();
     for (const part of contentParts) {
@@ -4759,6 +4842,7 @@ class TemplateHandler {
 exports.Base64 = Base64;
 exports.Binary = Binary;
 exports.COMMENT_NODE_NAME = COMMENT_NODE_NAME;
+exports.ChartPlugin = ChartPlugin;
 exports.DelimiterSearcher = DelimiterSearcher;
 exports.Delimiters = Delimiters;
 exports.Docx = Docx;
@@ -4806,9 +4890,11 @@ exports.UnsupportedFileTypeError = UnsupportedFileTypeError;
 exports.Xlsx = Xlsx;
 exports.XmlDepthTracker = XmlDepthTracker;
 exports.XmlNodeType = XmlNodeType;
+exports.XmlTreeIterator = XmlTreeIterator;
 exports.XmlUtils = XmlUtils;
 exports.Zip = Zip;
 exports.ZipObject = ZipObject;
+exports.countOccurrences = countOccurrences;
 exports.createDefaultPlugins = createDefaultPlugins;
 exports.first = first;
 exports.inheritsFrom = inheritsFrom;