272 lines
9.4 KiB
JavaScript
272 lines
9.4 KiB
JavaScript
"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 _readOnlyError(r) { throw new TypeError('"' + r + '" is read-only'); }
|
|
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, options) {
|
|
var _this = this;
|
|
var getTraits = options.getTraits,
|
|
postparse = options.postparse,
|
|
fileType = options.fileType;
|
|
var traits = getTraits(traitName, postparsed, options);
|
|
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 && !_this.docxtemplater.options.syntax.allowUnbalancedLoops) {
|
|
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 && !_this.docxtemplater.options.syntax.allowUnbalancedLoops) {
|
|
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;
|
|
}
|
|
// We're inside the pair
|
|
if (expandedPair[0] === i) {
|
|
// Start pair
|
|
innerParts = [];
|
|
}
|
|
if (pair[0].offset !== i && pair[1].offset !== i) {
|
|
// Exclude inner pair indexes
|
|
innerParts.push(part);
|
|
}
|
|
if (expandedPair[1] === i) {
|
|
// End pair
|
|
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++;
|
|
var _expandedPair = expandedPairs[currentPairIndex];
|
|
while (_expandedPair && _expandedPair[0] < i) {
|
|
/*
|
|
* If we have :
|
|
* expandedPairs =[[5,72],[51,67],[90,106]]
|
|
* Then after treating [5,72], we need to treat [90,106]
|
|
* Fixed since v3.58.4
|
|
*/
|
|
currentPairIndex++;
|
|
_expandedPair = expandedPairs[currentPairIndex];
|
|
}
|
|
}
|
|
return newParsed;
|
|
}, []);
|
|
return {
|
|
postparsed: newParsed,
|
|
errors: errors
|
|
};
|
|
}
|
|
}]);
|
|
}();
|
|
module.exports = function () {
|
|
return wrapper(new ExpandPairTrait());
|
|
}; |