@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/docxtemplater/js/modules/expand-pair-trait.js

@@ -0,0 +1,257 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var traitName = "expandPair";
+var mergeSort = require("../merge-sort.js");
+var _require = require("../doc-utils.js"),
+  getLeft = _require.getLeft,
+  getRight = _require.getRight,
+  pushArray = _require.pushArray;
+var wrapper = require("../module-wrapper.js");
+var _require2 = require("../traits.js"),
+  getExpandToDefault = _require2.getExpandToDefault;
+var _require3 = require("../errors.js"),
+  getUnmatchedLoopException = _require3.getUnmatchedLoopException,
+  getClosingTagNotMatchOpeningTag = _require3.getClosingTagNotMatchOpeningTag,
+  getUnbalancedLoopException = _require3.getUnbalancedLoopException;
+function getOpenCountChange(part) {
+  switch (part.location) {
+    case "start":
+      return 1;
+    case "end":
+      return -1;
+  }
+}
+function match(start, end) {
+  return start != null && end != null && (start.part.location === "start" && end.part.location === "end" && start.part.value === end.part.value || end.part.value === "");
+}
+function transformer(traits) {
+  var i = 0;
+  var errors = [];
+  while (i < traits.length) {
+    var part = traits[i].part;
+    if (part.location === "end") {
+      if (i === 0) {
+        traits.splice(0, 1);
+        errors.push(getUnmatchedLoopException(part));
+        return {
+          traits: traits,
+          errors: errors
+        };
+      }
+      var endIndex = i;
+      var startIndex = i - 1;
+      var offseter = 1;
+      if (match(traits[startIndex], traits[endIndex])) {
+        traits.splice(endIndex, 1);
+        traits.splice(startIndex, 1);
+        return {
+          errors: errors,
+          traits: traits
+        };
+      }
+      while (offseter < 50) {
+        var startCandidate = traits[startIndex - offseter];
+        var endCandidate = traits[endIndex + offseter];
+        if (match(startCandidate, traits[endIndex])) {
+          traits.splice(endIndex, 1);
+          traits.splice(startIndex - offseter, 1);
+          return {
+            errors: errors,
+            traits: traits
+          };
+        }
+        if (match(traits[startIndex], endCandidate)) {
+          traits.splice(endIndex + offseter, 1);
+          traits.splice(startIndex, 1);
+          return {
+            errors: errors,
+            traits: traits
+          };
+        }
+        offseter++;
+      }
+      errors.push(getClosingTagNotMatchOpeningTag({
+        tags: [traits[startIndex].part, traits[endIndex].part]
+      }));
+      traits.splice(endIndex, 1);
+      traits.splice(startIndex, 1);
+      return {
+        traits: traits,
+        errors: errors
+      };
+    }
+    i++;
+  }
+  for (var _i2 = 0; _i2 < traits.length; _i2++) {
+    var _part = traits[_i2].part;
+    errors.push(getUnmatchedLoopException(_part));
+  }
+  return {
+    traits: [],
+    errors: errors
+  };
+}
+function getPairs(traits) {
+  var levelTraits = {};
+  var errors = [];
+  var pairs = [];
+  var transformedTraits = [];
+  pushArray(transformedTraits, traits);
+  while (transformedTraits.length > 0) {
+    var result = transformer(transformedTraits);
+    pushArray(errors, result.errors);
+    transformedTraits = result.traits;
+  }
+
+  // Stryker disable all : because this check makes the function return quicker
+  if (errors.length > 0) {
+    return {
+      pairs: pairs,
+      errors: errors
+    };
+  }
+  // Stryker restore all
+  var countOpen = 0;
+  for (var _i4 = 0; _i4 < traits.length; _i4++) {
+    var currentTrait = traits[_i4];
+    var part = currentTrait.part;
+    var change = getOpenCountChange(part);
+    countOpen += change;
+    if (change === 1) {
+      levelTraits[countOpen] = currentTrait;
+    } else {
+      var startTrait = levelTraits[countOpen + 1];
+      if (countOpen === 0) {
+        pairs.push([startTrait, currentTrait]);
+      }
+    }
+    countOpen = countOpen >= 0 ? countOpen : 0;
+  }
+  return {
+    pairs: pairs,
+    errors: errors
+  };
+}
+var ExpandPairTrait = /*#__PURE__*/function () {
+  function ExpandPairTrait() {
+    _classCallCheck(this, ExpandPairTrait);
+    this.name = "ExpandPairTrait";
+  }
+  return _createClass(ExpandPairTrait, [{
+    key: "optionsTransformer",
+    value: function optionsTransformer(options, docxtemplater) {
+      if (docxtemplater.options.paragraphLoop) {
+        pushArray(docxtemplater.fileTypeConfig.expandTags, docxtemplater.fileTypeConfig.onParagraphLoop);
+      }
+      this.expandTags = docxtemplater.fileTypeConfig.expandTags;
+      return options;
+    }
+  }, {
+    key: "postparse",
+    value: function postparse(postparsed, _ref) {
+      var _this = this;
+      var getTraits = _ref.getTraits,
+        _postparse = _ref.postparse,
+        fileType = _ref.fileType;
+      var traits = getTraits(traitName, postparsed);
+      traits = traits.map(function (trait) {
+        return trait || [];
+      });
+      traits = mergeSort(traits);
+      var _getPairs = getPairs(traits),
+        pairs = _getPairs.pairs,
+        errors = _getPairs.errors;
+      var lastRight = 0;
+      var lastPair = null;
+      var expandedPairs = pairs.map(function (pair) {
+        var expandTo = pair[0].part.expandTo;
+        if (expandTo === "auto" && fileType !== "text") {
+          var result = getExpandToDefault(postparsed, pair, _this.expandTags);
+          if (result.error) {
+            errors.push(result.error);
+          }
+          expandTo = result.value;
+        }
+        if (!expandTo || fileType === "text") {
+          var _left = pair[0].offset;
+          var _right = pair[1].offset;
+          if (_left < lastRight) {
+            errors.push(getUnbalancedLoopException(pair, lastPair));
+          }
+          lastPair = pair;
+          lastRight = _right;
+          return [_left, _right];
+        }
+        var left, right;
+        try {
+          left = getLeft(postparsed, expandTo, pair[0].offset);
+        } catch (e) {
+          errors.push(e);
+        }
+        try {
+          right = getRight(postparsed, expandTo, pair[1].offset);
+        } catch (e) {
+          errors.push(e);
+        }
+        if (left < lastRight) {
+          errors.push(getUnbalancedLoopException(pair, lastPair));
+        }
+        lastRight = right;
+        lastPair = pair;
+        return [left, right];
+      });
+
+      // Stryker disable all : because this check makes the function return quicker
+      if (errors.length > 0) {
+        return {
+          postparsed: postparsed,
+          errors: errors
+        };
+      }
+      // Stryker restore all
+
+      var currentPairIndex = 0;
+      var innerParts;
+      var newParsed = postparsed.reduce(function (newParsed, part, i) {
+        var inPair = currentPairIndex < pairs.length && expandedPairs[currentPairIndex][0] <= i && i <= expandedPairs[currentPairIndex][1];
+        var pair = pairs[currentPairIndex];
+        var expandedPair = expandedPairs[currentPairIndex];
+        if (!inPair) {
+          newParsed.push(part);
+          return newParsed;
+        }
+        if (expandedPair[0] === i) {
+          innerParts = [];
+        }
+        if (pair[0].offset !== i && pair[1].offset !== i) {
+          innerParts.push(part);
+        }
+        if (expandedPair[1] === i) {
+          var basePart = postparsed[pair[0].offset];
+          basePart.subparsed = _postparse(innerParts, {
+            basePart: basePart
+          });
+          basePart.endLindex = pair[1].part.lIndex;
+          delete basePart.location;
+          delete basePart.expandTo;
+          newParsed.push(basePart);
+          currentPairIndex++;
+        }
+        return newParsed;
+      }, []);
+      return {
+        postparsed: newParsed,
+        errors: errors
+      };
+    }
+  }]);
+}();
+module.exports = function () {
+  return wrapper(new ExpandPairTrait());
+};

package/dist/node_modules/docxtemplater/js/modules/fix-doc-pr-corruption.js

@@ -0,0 +1,85 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var _require = require("../doc-utils.js"),
+  setSingleAttribute = _require.setSingleAttribute,
+  isTagStart = _require.isTagStart;
+
+// We use a class here because this object is storing "state" in this.Lexer,
+// this.zip, this.xmlDocuments
+//
+// In version 3.34.3 and before, the state could be overwritten if the module
+// was attached to two docxtemplater instances
+//
+// Now, since the module will be cloned if already attached, it should work
+// correctly even on multiple instances in parallel
+var FixDocPRCorruptionModule = /*#__PURE__*/function () {
+  function FixDocPRCorruptionModule() {
+    _classCallCheck(this, FixDocPRCorruptionModule);
+    this.name = "FixDocPRCorruptionModule";
+  }
+  return _createClass(FixDocPRCorruptionModule, [{
+    key: "clone",
+    value: function clone() {
+      return new FixDocPRCorruptionModule();
+    }
+  }, {
+    key: "set",
+    value: function set(options) {
+      if (options.Lexer) {
+        this.Lexer = options.Lexer;
+      }
+      if (options.zip) {
+        this.zip = options.zip;
+      }
+      if (options.xmlDocuments) {
+        this.xmlDocuments = options.xmlDocuments;
+      }
+    }
+  }, {
+    key: "on",
+    value: function on(event) {
+      // Stryker disable all : because this is an optimisation that won't make any tests fail
+      if (event !== "syncing-zip") {
+        return;
+      }
+      this.attached = false;
+      // Stryker restore all
+      var zip = this.zip;
+      var Lexer = this.Lexer;
+      var prId = 1;
+      for (var _i2 = 0, _zip$file2 = zip.file(/.xml$/); _i2 < _zip$file2.length; _i2++) {
+        var f = _zip$file2[_i2];
+        var xmlDoc = this.xmlDocuments[f.name];
+        if (xmlDoc) {
+          for (var _i4 = 0, _xmlDoc$getElementsBy2 = xmlDoc.getElementsByTagName("wp:docPr"); _i4 < _xmlDoc$getElementsBy2.length; _i4++) {
+            var pr = _xmlDoc$getElementsBy2[_i4];
+            pr.setAttribute("id", prId++);
+          }
+          continue;
+        }
+        var text = f.asText();
+        var xmllexed = Lexer.xmlparse(text, {
+          text: [],
+          other: ["wp:docPr"]
+        });
+        if (xmllexed.length > 1) {
+          /* eslint-disable-next-line no-loop-func */
+          text = xmllexed.reduce(function (fullText, part) {
+            if (isTagStart("wp:docPr", part)) {
+              return fullText + setSingleAttribute(part.value, "id", prId++);
+            }
+            return fullText + part.value;
+          }, "");
+        }
+        zip.file(f.name, text);
+      }
+    }
+  }]);
+}();
+module.exports = new FixDocPRCorruptionModule();