409 lines
15 KiB
JavaScript
409 lines
15 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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
|
|
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
|
|
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, 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("./utils.js"),
|
|
last = _require.last,
|
|
first = _require.first;
|
|
function XTError(message) {
|
|
this.name = "GenericError";
|
|
this.message = message;
|
|
this.stack = new Error(message).stack;
|
|
}
|
|
XTError.prototype = Error.prototype;
|
|
function XTTemplateError(message) {
|
|
this.name = "TemplateError";
|
|
this.message = message;
|
|
this.stack = new Error(message).stack;
|
|
}
|
|
XTTemplateError.prototype = new XTError();
|
|
function XTRenderingError(message) {
|
|
this.name = "RenderingError";
|
|
this.message = message;
|
|
this.stack = new Error(message).stack;
|
|
}
|
|
XTRenderingError.prototype = new XTError();
|
|
function XTScopeParserError(message) {
|
|
this.name = "ScopeParserError";
|
|
this.message = message;
|
|
this.stack = new Error(message).stack;
|
|
}
|
|
XTScopeParserError.prototype = new XTError();
|
|
function XTInternalError(message) {
|
|
this.name = "InternalError";
|
|
this.properties = {
|
|
explanation: "InternalError"
|
|
};
|
|
this.message = message;
|
|
this.stack = new Error(message).stack;
|
|
}
|
|
XTInternalError.prototype = new XTError();
|
|
function XTAPIVersionError(message) {
|
|
this.name = "APIVersionError";
|
|
this.properties = {
|
|
explanation: "APIVersionError"
|
|
};
|
|
this.message = message;
|
|
this.stack = new Error(message).stack;
|
|
}
|
|
XTAPIVersionError.prototype = new XTError();
|
|
function throwApiVersionError(msg, properties) {
|
|
var err = new XTAPIVersionError(msg);
|
|
err.properties = _objectSpread({
|
|
id: "api_version_error"
|
|
}, properties);
|
|
throw err;
|
|
}
|
|
function throwMultiError(errors) {
|
|
var err = new XTTemplateError("Multi error");
|
|
err.properties = {
|
|
errors: errors,
|
|
id: "multi_error",
|
|
explanation: "The template has multiple errors"
|
|
};
|
|
throw err;
|
|
}
|
|
function getUnopenedTagException(options) {
|
|
var err = new XTTemplateError("Unopened tag");
|
|
err.properties = {
|
|
xtag: last(options.xtag.split(" ")),
|
|
id: "unopened_tag",
|
|
context: options.xtag,
|
|
offset: options.offset,
|
|
lIndex: options.lIndex,
|
|
explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" is unopened")
|
|
};
|
|
return err;
|
|
}
|
|
function getDuplicateOpenTagException(options) {
|
|
var err = new XTTemplateError("Duplicate open tag, expected one open tag");
|
|
err.properties = {
|
|
xtag: first(options.xtag.split(" ")),
|
|
id: "duplicate_open_tag",
|
|
context: options.xtag,
|
|
offset: options.offset,
|
|
lIndex: options.lIndex,
|
|
explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" has duplicate open tags")
|
|
};
|
|
return err;
|
|
}
|
|
function getDuplicateCloseTagException(options) {
|
|
var err = new XTTemplateError("Duplicate close tag, expected one close tag");
|
|
err.properties = {
|
|
xtag: first(options.xtag.split(" ")),
|
|
id: "duplicate_close_tag",
|
|
context: options.xtag,
|
|
offset: options.offset,
|
|
lIndex: options.lIndex,
|
|
explanation: "The tag ending with \"".concat(options.xtag.substr(0, 10), "\" has duplicate close tags")
|
|
};
|
|
return err;
|
|
}
|
|
function getUnclosedTagException(options) {
|
|
var err = new XTTemplateError("Unclosed tag");
|
|
err.properties = {
|
|
xtag: first(options.xtag.split(" ")).substr(1),
|
|
id: "unclosed_tag",
|
|
context: options.xtag,
|
|
offset: options.offset,
|
|
lIndex: options.lIndex,
|
|
explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" is unclosed")
|
|
};
|
|
return err;
|
|
}
|
|
function throwXmlTagNotFound(options) {
|
|
var err = new XTTemplateError("No tag \"".concat(options.element, "\" was found at the ").concat(options.position));
|
|
var part = options.parsed[options.index];
|
|
err.properties = {
|
|
id: "no_xml_tag_found_at_".concat(options.position),
|
|
explanation: "No tag \"".concat(options.element, "\" was found at the ").concat(options.position),
|
|
offset: part.offset,
|
|
part: part,
|
|
parsed: options.parsed,
|
|
index: options.index,
|
|
element: options.element
|
|
};
|
|
throw err;
|
|
}
|
|
function getCorruptCharactersException(_ref) {
|
|
var tag = _ref.tag,
|
|
value = _ref.value,
|
|
offset = _ref.offset;
|
|
var err = new XTRenderingError("There are some XML corrupt characters");
|
|
err.properties = {
|
|
id: "invalid_xml_characters",
|
|
xtag: tag,
|
|
value: value,
|
|
offset: offset,
|
|
explanation: "There are some corrupt characters for the field ".concat(tag)
|
|
};
|
|
return err;
|
|
}
|
|
function getInvalidRawXMLValueException(_ref2) {
|
|
var tag = _ref2.tag,
|
|
value = _ref2.value,
|
|
offset = _ref2.offset;
|
|
var err = new XTRenderingError("Non string values are not allowed for rawXML tags");
|
|
err.properties = {
|
|
id: "invalid_raw_xml_value",
|
|
xtag: tag,
|
|
value: value,
|
|
offset: offset,
|
|
explanation: "The value of the raw tag : '".concat(tag, "' is not a string")
|
|
};
|
|
return err;
|
|
}
|
|
function throwExpandNotFound(options) {
|
|
var _options$part = options.part,
|
|
value = _options$part.value,
|
|
offset = _options$part.offset,
|
|
_options$id = options.id,
|
|
id = _options$id === void 0 ? "raw_tag_outerxml_invalid" : _options$id,
|
|
_options$message = options.message,
|
|
message = _options$message === void 0 ? "Raw tag not in paragraph" : _options$message;
|
|
var part = options.part;
|
|
var _options$explanation = options.explanation,
|
|
explanation = _options$explanation === void 0 ? "The tag \"".concat(value, "\" is not inside a paragraph") : _options$explanation;
|
|
if (typeof explanation === "function") {
|
|
explanation = explanation(part);
|
|
}
|
|
var err = new XTTemplateError(message);
|
|
err.properties = {
|
|
id: id,
|
|
explanation: explanation,
|
|
rootError: options.rootError,
|
|
xtag: value,
|
|
offset: offset,
|
|
postparsed: options.postparsed,
|
|
expandTo: options.expandTo,
|
|
index: options.index
|
|
};
|
|
throw err;
|
|
}
|
|
function throwRawTagShouldBeOnlyTextInParagraph(options) {
|
|
var err = new XTTemplateError("Raw tag should be the only text in paragraph");
|
|
var tag = options.part.value;
|
|
err.properties = {
|
|
id: "raw_xml_tag_should_be_only_text_in_paragraph",
|
|
explanation: "The raw tag \"".concat(tag, "\" should be the only text in this paragraph. This means that this tag should not be surrounded by any text or spaces."),
|
|
xtag: tag,
|
|
offset: options.part.offset,
|
|
paragraphParts: options.paragraphParts
|
|
};
|
|
throw err;
|
|
}
|
|
function getUnmatchedLoopException(part) {
|
|
var location = part.location,
|
|
offset = part.offset,
|
|
square = part.square;
|
|
var t = location === "start" ? "unclosed" : "unopened";
|
|
var T = location === "start" ? "Unclosed" : "Unopened";
|
|
var err = new XTTemplateError("".concat(T, " loop"));
|
|
var tag = part.value;
|
|
err.properties = {
|
|
id: "".concat(t, "_loop"),
|
|
explanation: "The loop with tag \"".concat(tag, "\" is ").concat(t),
|
|
xtag: tag,
|
|
offset: offset
|
|
};
|
|
if (square) {
|
|
err.properties.square = square;
|
|
}
|
|
return err;
|
|
}
|
|
function getUnbalancedLoopException(pair, lastPair) {
|
|
var err = new XTTemplateError("Unbalanced loop tag");
|
|
var lastL = lastPair[0].part.value;
|
|
var lastR = lastPair[1].part.value;
|
|
var l = pair[0].part.value;
|
|
var r = pair[1].part.value;
|
|
err.properties = {
|
|
id: "unbalanced_loop_tags",
|
|
explanation: "Unbalanced loop tags {#".concat(lastL, "}{/").concat(lastR, "}{#").concat(l, "}{/").concat(r, "}"),
|
|
offset: [lastPair[0].part.offset, pair[1].part.offset],
|
|
lastPair: {
|
|
left: lastPair[0].part.value,
|
|
right: lastPair[1].part.value
|
|
},
|
|
pair: {
|
|
left: pair[0].part.value,
|
|
right: pair[1].part.value
|
|
}
|
|
};
|
|
return err;
|
|
}
|
|
function getClosingTagNotMatchOpeningTag(_ref3) {
|
|
var tags = _ref3.tags;
|
|
var err = new XTTemplateError("Closing tag does not match opening tag");
|
|
err.properties = {
|
|
id: "closing_tag_does_not_match_opening_tag",
|
|
explanation: "The tag \"".concat(tags[0].value, "\" is closed by the tag \"").concat(tags[1].value, "\""),
|
|
openingtag: first(tags).value,
|
|
offset: [first(tags).offset, last(tags).offset],
|
|
closingtag: last(tags).value
|
|
};
|
|
if (first(tags).square) {
|
|
err.properties.square = [first(tags).square, last(tags).square];
|
|
}
|
|
return err;
|
|
}
|
|
function getScopeCompilationError(_ref4) {
|
|
var tag = _ref4.tag,
|
|
rootError = _ref4.rootError,
|
|
offset = _ref4.offset;
|
|
var err = new XTScopeParserError("Scope parser compilation failed");
|
|
err.properties = {
|
|
id: "scopeparser_compilation_failed",
|
|
offset: offset,
|
|
xtag: tag,
|
|
explanation: "The scope parser for the tag \"".concat(tag, "\" failed to compile"),
|
|
rootError: rootError
|
|
};
|
|
return err;
|
|
}
|
|
function getScopeParserExecutionError(_ref5) {
|
|
var tag = _ref5.tag,
|
|
scope = _ref5.scope,
|
|
error = _ref5.error,
|
|
offset = _ref5.offset;
|
|
var err = new XTScopeParserError("Scope parser execution failed");
|
|
err.properties = {
|
|
id: "scopeparser_execution_failed",
|
|
explanation: "The scope parser for the tag ".concat(tag, " failed to execute"),
|
|
scope: scope,
|
|
offset: offset,
|
|
xtag: tag,
|
|
rootError: error
|
|
};
|
|
return err;
|
|
}
|
|
function getLoopPositionProducesInvalidXMLError(_ref6) {
|
|
var tag = _ref6.tag,
|
|
offset = _ref6.offset;
|
|
var err = new XTTemplateError("The position of the loop tags \"".concat(tag, "\" would produce invalid XML"));
|
|
err.properties = {
|
|
xtag: tag,
|
|
id: "loop_position_invalid",
|
|
explanation: "The tags \"".concat(tag, "\" are misplaced in the document, for example one of them is in a table and the other one outside the table"),
|
|
offset: offset
|
|
};
|
|
return err;
|
|
}
|
|
function throwUnimplementedTagType(part, index) {
|
|
var errorMsg = "Unimplemented tag type \"".concat(part.type, "\"");
|
|
if (part.module) {
|
|
errorMsg += " \"".concat(part.module, "\"");
|
|
}
|
|
var err = new XTTemplateError(errorMsg);
|
|
err.properties = {
|
|
part: part,
|
|
index: index,
|
|
id: "unimplemented_tag_type"
|
|
};
|
|
throw err;
|
|
}
|
|
function throwMalformedXml() {
|
|
var err = new XTInternalError("Malformed xml");
|
|
err.properties = {
|
|
explanation: "The template contains malformed xml",
|
|
id: "malformed_xml"
|
|
};
|
|
throw err;
|
|
}
|
|
function throwResolveBeforeCompile() {
|
|
var err = new XTInternalError("You must run `.compile()` before running `.resolveData()`");
|
|
err.properties = {
|
|
id: "resolve_before_compile",
|
|
explanation: "You must run `.compile()` before running `.resolveData()`"
|
|
};
|
|
throw err;
|
|
}
|
|
function throwRenderInvalidTemplate() {
|
|
var err = new XTInternalError("You should not call .render on a document that had compilation errors");
|
|
err.properties = {
|
|
id: "render_on_invalid_template",
|
|
explanation: "You should not call .render on a document that had compilation errors"
|
|
};
|
|
throw err;
|
|
}
|
|
function throwRenderTwice() {
|
|
var err = new XTInternalError("You should not call .render twice on the same docxtemplater instance");
|
|
err.properties = {
|
|
id: "render_twice",
|
|
explanation: "You should not call .render twice on the same docxtemplater instance"
|
|
};
|
|
throw err;
|
|
}
|
|
function throwFileTypeNotIdentified(zip) {
|
|
var files = Object.keys(zip.files).slice(0, 10);
|
|
var msg = "";
|
|
if (files.length === 0) {
|
|
msg = "Empty zip file";
|
|
} else {
|
|
msg = "Zip file contains : ".concat(files.join(","));
|
|
}
|
|
var err = new XTInternalError("The filetype for this file could not be identified, is this file corrupted ? ".concat(msg));
|
|
err.properties = {
|
|
id: "filetype_not_identified",
|
|
explanation: "The filetype for this file could not be identified, is this file corrupted ? ".concat(msg)
|
|
};
|
|
throw err;
|
|
}
|
|
function throwXmlInvalid(content, offset) {
|
|
var err = new XTTemplateError("An XML file has invalid xml");
|
|
err.properties = {
|
|
id: "file_has_invalid_xml",
|
|
content: content,
|
|
offset: offset,
|
|
explanation: "The docx contains invalid XML, it is most likely corrupt"
|
|
};
|
|
throw err;
|
|
}
|
|
function throwFileTypeNotHandled(fileType) {
|
|
var err = new XTInternalError("The filetype \"".concat(fileType, "\" is not handled by docxtemplater"));
|
|
err.properties = {
|
|
id: "filetype_not_handled",
|
|
explanation: "The file you are trying to generate is of type \"".concat(fileType, "\", but only docx and pptx formats are handled"),
|
|
fileType: fileType
|
|
};
|
|
throw err;
|
|
}
|
|
module.exports = {
|
|
XTError: XTError,
|
|
XTTemplateError: XTTemplateError,
|
|
XTInternalError: XTInternalError,
|
|
XTScopeParserError: XTScopeParserError,
|
|
XTAPIVersionError: XTAPIVersionError,
|
|
// Remove this alias in v4
|
|
RenderingError: XTRenderingError,
|
|
XTRenderingError: XTRenderingError,
|
|
getClosingTagNotMatchOpeningTag: getClosingTagNotMatchOpeningTag,
|
|
getLoopPositionProducesInvalidXMLError: getLoopPositionProducesInvalidXMLError,
|
|
getScopeCompilationError: getScopeCompilationError,
|
|
getScopeParserExecutionError: getScopeParserExecutionError,
|
|
getUnclosedTagException: getUnclosedTagException,
|
|
getUnopenedTagException: getUnopenedTagException,
|
|
getUnmatchedLoopException: getUnmatchedLoopException,
|
|
getDuplicateCloseTagException: getDuplicateCloseTagException,
|
|
getDuplicateOpenTagException: getDuplicateOpenTagException,
|
|
getCorruptCharactersException: getCorruptCharactersException,
|
|
getInvalidRawXMLValueException: getInvalidRawXMLValueException,
|
|
getUnbalancedLoopException: getUnbalancedLoopException,
|
|
throwApiVersionError: throwApiVersionError,
|
|
throwFileTypeNotHandled: throwFileTypeNotHandled,
|
|
throwFileTypeNotIdentified: throwFileTypeNotIdentified,
|
|
throwMalformedXml: throwMalformedXml,
|
|
throwMultiError: throwMultiError,
|
|
throwExpandNotFound: throwExpandNotFound,
|
|
throwRawTagShouldBeOnlyTextInParagraph: throwRawTagShouldBeOnlyTextInParagraph,
|
|
throwUnimplementedTagType: throwUnimplementedTagType,
|
|
throwXmlTagNotFound: throwXmlTagNotFound,
|
|
throwXmlInvalid: throwXmlInvalid,
|
|
throwResolveBeforeCompile: throwResolveBeforeCompile,
|
|
throwRenderInvalidTemplate: throwRenderInvalidTemplate,
|
|
throwRenderTwice: throwRenderTwice
|
|
}; |