docxtemplater
Version:
Generate docx, pptx, and xlsx from templates (Word, Powerpoint and Excel documents), from Node.js, the Browser and the command line
1,691 lines (1,690 loc) • 83.9 kB
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("lodash"),
assign = _require.assign;
var expressionParser = require("../../expressions.js");
var expressionParserIE11 = require("../../expressions-ie11.js");
var Errors = require("../../errors.js");
var _require2 = require("../utils.js"),
wrapMultiError = _require2.wrapMultiError;
var nbsp = String.fromCharCode(160);
var _require3 = require("../utils.js"),
expect = _require3.expect;
expressionParser.filters.upper = function (str) {
if (!str) {
return str;
}
return str.toUpperCase();
};
expressionParser.filters.sum = function (num1, num2) {
return num1 + num2;
};
var noInternals = {
lexed: null,
parsed: null,
postparsed: null
};
var xmlSpacePreserveTag = {
type: "tag",
position: "start",
value: '<w:t xml:space="preserve">',
text: true,
tag: "w:t"
};
var startText = {
type: "tag",
position: "start",
value: "<w:t>",
text: true,
tag: "w:t"
};
var endText = {
type: "tag",
value: "</w:t>",
text: true,
position: "end",
tag: "w:t"
};
var startParagraph = {
type: "tag",
value: "<w:p>",
text: false,
position: "start",
tag: "w:p"
};
var endParagraph = {
type: "tag",
value: "</w:p>",
text: false,
position: "end",
tag: "w:p"
};
var tableRowStart = {
type: "tag",
position: "start",
text: false,
value: "<w:tr>",
tag: "w:tr"
};
var tableRowEnd = {
type: "tag",
value: "</w:tr>",
text: false,
position: "end",
tag: "w:tr"
};
var tableColStart = {
type: "tag",
position: "start",
text: false,
value: "<w:tc>",
tag: "w:tc"
};
var tableColEnd = {
type: "tag",
value: "</w:tc>",
text: false,
position: "end",
tag: "w:tc"
};
var delimiters = {
start: {
type: "delimiter",
position: "start"
},
end: {
type: "delimiter",
position: "end"
}
};
function content(value) {
return {
type: "content",
value: value,
position: "insidetag"
};
}
function externalContent(value) {
return {
type: "content",
value: value,
position: "outsidetag"
};
}
var fixtures = [{
it: "should handle {user} with tag",
contentText: "Hi {user}",
scope: {
user: "Foo"
},
resultText: "Hi Foo",
xmllexed: [{
position: "start",
tag: "w:t",
text: true,
type: "tag",
value: "<w:t>"
}, {
type: "content",
value: "Hi {user}"
}, {
position: "end",
tag: "w:t",
text: true,
type: "tag",
value: "</w:t>"
}],
lexed: [startText, content("Hi "), delimiters.start, content("user"), delimiters.end, endText],
parsed: [startText, content("Hi "), {
type: "placeholder",
value: "user"
}, endText],
postparsed: [xmlSpacePreserveTag, content("Hi "), {
type: "placeholder",
value: "user"
}, endText]
}, {
it: "should handle {.} with tag",
contentText: "Hi {.}",
scope: "Foo",
resultText: "Hi Foo",
lexed: [startText, content("Hi "), delimiters.start, content("."), delimiters.end, endText],
parsed: [startText, content("Hi "), {
type: "placeholder",
value: "."
}, endText],
postparsed: [xmlSpacePreserveTag, content("Hi "), {
type: "placeholder",
value: "."
}, endText]
}, _objectSpread(_objectSpread({
it: "should handle {userGreeting} with lambda function",
contentText: "{#users}{userGreeting}{/}",
resultText: "How is it going, John ? 1How is it going, Mary ? 1"
}, noInternals), {}, {
scope: {
userGreeting: function userGreeting(scope, sm) {
return "How is it going, " + scope.name + " ? " + sm.scopeLindex.length;
},
users: [{
name: "John"
}, {
name: "Mary"
}]
}
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should not add a new paragraph after a table if there is a bookmarkEnd after the table",
content: "\n <w:tbl>\n <w:tr>\n <w:tc>\n <w:p>\n <w:r>\n <w:t>{#users}{name}</w:t>\n </w:r>\n </w:p>\n </w:tc>\n <w:tc>\n <w:p w14:paraId=\"618916E2\" w14:textId=\"77777777\" w:rsidR=\"00FB7E94\" w:rsidRPr=\"00F32895\" w:rsidRDefault=\"00FB7E94\" w:rsidP=\"00A141BC\">\n <w:r>\n\t\t\t <w:t>{/}</w:t>\n </w:r>\n </w:p>\n </w:tc>\n </w:tr>\n </w:tbl>\n <w:bookmarkEnd w:id=\"0\"/>\n <w:p>\n <w:r>\n <w:t>After Text </w:t>\n </w:r>\n </w:p>\n\t\t",
scope: {
users: [{
name: "John"
}]
},
result: "\n <w:tbl>\n <w:tr>\n <w:tc>\n <w:p>\n <w:r>\n <w:t xml:space=\"preserve\">John</w:t>\n </w:r>\n </w:p>\n </w:tc>\n <w:tc>\n <w:p w14:paraId=\"618916E2\" w14:textId=\"77777777\" w:rsidR=\"00FB7E94\" w:rsidRPr=\"00F32895\" w:rsidRDefault=\"00FB7E94\" w:rsidP=\"00A141BC\">\n <w:r>\n\t\t\t <w:t/>\n </w:r>\n </w:p>\n </w:tc>\n </w:tr>\n </w:tbl>\n <w:bookmarkEnd w:id=\"0\"/>\n <w:p>\n <w:r>\n <w:t>After Text </w:t>\n </w:r>\n </w:p>\n\t\t"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle non breaking space in tag",
contentText: "{:foo".concat(nbsp).concat(nbsp, "bar").concat(nbsp, "bar} {:zing").concat(nbsp).concat(nbsp).concat(nbsp, "bang}"),
options: {
modules: function modules() {
return [{
name: "FooModule",
parse: function parse(placeHolderContent, options) {
if (options.match(":foo ", placeHolderContent)) {
return {
type: "placeholder",
value: options.getValue(":foo ", placeHolderContent)
};
}
if (options.match(/^:zing +(.*)/, placeHolderContent)) {
return {
type: "placeholder",
value: options.getValue(/^:zing +(.*)/, placeHolderContent)
};
}
}
}];
},
parser: function parser(tag) {
return {
get: function get() {
if (tag === "bar bar") {
return "Hey";
}
if (tag === "bang") {
return "Ho";
}
return "Bad";
}
};
}
},
resultText: "Hey Ho"
}), _objectSpread(_objectSpread({
it: "should be possible to implement a parser that loads nested data using {user.name}",
resultText: "Hello John, your age is 33. Date : 17/01/2000"
}, noInternals), {}, {
contentText: "Hello {user.name}, your age is {user.age}. Date : {date}",
options: {
parser: function parser(tag) {
var splitted = tag.split(".");
return {
get: function get(scope) {
if (tag === ".") {
return scope;
}
var s = scope;
for (var _i2 = 0; _i2 < splitted.length; _i2++) {
var item = splitted[_i2];
s = s[item];
}
return s;
}
};
}
},
scope: {
user: {
name: "John",
age: 33
},
date: "17/01/2000"
}
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should not parse as loop a tag that starts with a space : { #foo}, the same for raw tags : { @raw}",
contentText: "{ #foo} { @xx}",
scope: {
" #foo": "val",
" @xx": "val"
},
resultText: "val val"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should not throw error if nullGetter returns null",
contentText: "{#foo}{name}{/foo}",
options: {
nullGetter: function nullGetter(part) {
if (part.module === "loop") {
return [1];
}
}
},
resultText: ""
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to add nullGetter to module (and use the first nullGetter result)",
contentText: "{foo}",
options: {
modules: function modules() {
return [{
name: "MyModule",
nullGetter: function nullGetter() {
return "foo";
}
}, {
name: "MyModule2",
nullGetter: function nullGetter() {
return "bar";
}
}];
}
},
resultText: "foo"
}), _objectSpread(_objectSpread({
it: "should handle {#userGet} with lambda function",
contentText: "{#userGet}- {name}{/}",
resultText: "- John- Mary"
}, noInternals), {}, {
scope: {
userGet: function userGet() {
return [{
name: "John"
}, {
name: "Mary"
}];
}
}
}), _objectSpread(_objectSpread({
it: "should allow to call a function up one scope with expressions parser",
contentText: "{#users}{hi(.)}{/}",
resultText: "What's up, John ?What's up, Jackie ?"
}, noInternals), {}, {
options: {
parser: expressionParser
},
scope: {
hi: function hi(user) {
return "What's up, ".concat(user, " ?");
},
users: ["John", "Jackie"]
}
}), _objectSpread(_objectSpread({
it: "should not fail if calling expressionParser on nullish value",
contentText: "{#users}{name}{/}",
resultText: "undefined".repeat(9)
}, noInternals), {}, {
options: {
parser: expressionParser
},
scope: {
users: [undefined, false, true, 0, -1, null, [], {}, new Map()]
}
}), _objectSpread(_objectSpread({
it: "should not fail if calling expressionParserIE11 on nullish value",
contentText: "{#users}{name}{/}",
resultText: "undefined".repeat(9)
}, noInternals), {}, {
options: {
parser: expressionParserIE11
},
scope: {
users: [undefined, false, true, 0, -1, null, [], {}, new Map()]
}
}), {
it: "should xmlparse strange tags",
content: "<w:t>{name} {</w:t>FOO<w:t>age</w:t>BAR<w:t>}</w:t>",
scope: {
name: "Foo",
age: 12
},
result: '<w:t xml:space="preserve">Foo 12</w:t>FOO<w:t></w:t>BAR<w:t></w:t>',
xmllexed: [startText, {
type: "content",
value: "{name} {"
}, endText, {
type: "content",
value: "FOO"
}, startText, {
type: "content",
value: "age"
}, endText, {
type: "content",
value: "BAR"
}, startText, {
type: "content",
value: "}"
}, endText],
lexed: [startText, delimiters.start, content("name"), delimiters.end, content(" "), delimiters.start, endText, externalContent("FOO"), startText, content("age"), endText, externalContent("BAR"), startText, delimiters.end, endText],
parsed: [startText, {
type: "placeholder",
value: "name"
}, content(" "), {
type: "placeholder",
value: "age"
}, endText, externalContent("FOO"), startText, endText, externalContent("BAR"), startText, endText],
postparsed: null
}, _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with delimiters set to start:null, end:null",
contentText: "Hello {name}",
delimiters: {
start: null,
end: null
},
scope: {
name: "John Doe"
},
resultText: "Hello {name}"
}), {
it: "should work with custom delimiters",
contentText: "Hello [[[name]]",
delimiters: {
start: "[[[",
end: "]]"
},
scope: {
name: "John Doe"
},
resultText: "Hello John Doe",
lexed: [startText, content("Hello "), delimiters.start, content("name"), delimiters.end, endText],
parsed: [startText, content("Hello "), {
type: "placeholder",
value: "name"
}, endText],
postparsed: null
}, {
it: "should work with custom delimiters splitted",
content: '<w:t>Hello {name}</w:t><w:t foo="bar">}, how is it ?</w:t>',
delimiters: {
start: "{",
end: "}}"
},
scope: {
name: "John Doe"
},
result: '<w:t xml:space="preserve">Hello John Doe</w:t><w:t foo="bar">, how is it ?</w:t>',
lexed: [startText, content("Hello "), delimiters.start, content("name"), delimiters.end, endText, {
type: "tag",
value: '<w:t foo="bar">',
text: true,
position: "start",
tag: "w:t"
}, content(", how is it ?"), endText],
parsed: [startText, content("Hello "), {
type: "placeholder",
value: "name"
}, endText, {
type: "tag",
value: '<w:t foo="bar">',
text: true,
position: "start",
tag: "w:t"
}, content(", how is it ?"), endText],
postparsed: null
}, {
it: "should work with custom delimiters splitted over > 2 tags",
content: "<w:t>Hello {name}</w:t><w:t>}</w:t>TAG<w:t>}</w:t><w:t>}}foobar</w:t>",
delimiters: {
start: "{",
end: "}}}}}"
},
scope: {
name: "John Doe"
},
result: '<w:t xml:space="preserve">Hello John Doe</w:t><w:t></w:t>TAG<w:t></w:t><w:t>foobar</w:t>',
lexed: [startText, content("Hello "), delimiters.start, content("name"), delimiters.end, endText, startText, endText, externalContent("TAG"), startText, endText, startText, content("foobar"), endText],
parsed: [startText, content("Hello "), {
type: "placeholder",
value: "name"
}, endText, startText, endText, externalContent("TAG"), startText, endText, startText, content("foobar"), endText],
postparsed: null
}, _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work when having equal sign after closing tag",
content: "<w:r><w:t>{foo}====</w:t></w:r>",
scope: {
foo: "FOO"
},
result: '<w:r><w:t xml:space="preserve">FOO====</w:t></w:r>'
}), _objectSpread(_objectSpread({
it: "should fail when having two open text tags",
content: "<w:t><w:t>xxx"
}, noInternals), {}, {
error: {
message: "Malformed xml",
name: "InternalError",
properties: {
id: "malformed_xml",
explanation: "The template contains malformed xml"
}
},
errorType: Errors.XTInternalError
}), _objectSpread(_objectSpread({
it: "should fail when having two close text tags",
content: "<w:t></w:t></w:t>xxx"
}, noInternals), {}, {
error: {
message: "Malformed xml",
name: "InternalError",
properties: {
id: "malformed_xml",
explanation: "The template contains malformed xml"
}
},
errorType: Errors.XTInternalError
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should show multierror with loops",
contentText: "{#a}{b}{/a}",
options: {
parser: function parser() {
return {
get: function get() {
throw new Error("Foobar");
}
};
}
},
error: wrapMultiError({
name: "ScopeParserError",
message: "Scope parser execution failed",
properties: {
explanation: "The scope parser for the tag a failed to execute",
rootError: {
message: "Foobar"
},
file: "word/document.xml",
id: "scopeparser_execution_failed",
xtag: "a",
offset: 0
}
}),
errorType: Errors.XTTemplateError
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should show multierror with loops",
contentText: "{#a}{b}{/a}",
options: {
parser: function parser(tag) {
return {
get: function get(scope) {
if (tag === "a") {
return scope[tag];
}
throw new Error("Foobar");
}
};
}
},
scope: {
a: [1]
},
error: wrapMultiError({
name: "ScopeParserError",
message: "Scope parser execution failed",
properties: {
explanation: "The scope parser for the tag b failed to execute",
rootError: {
message: "Foobar"
},
file: "word/document.xml",
id: "scopeparser_execution_failed",
scope: 1,
xtag: "b",
offset: 4
}
}),
errorType: Errors.XTTemplateError
}), {
it: "should work with loops",
contentText: "Hello {#users}{name}, {/users}",
scope: {
users: [{
name: "John Doe"
}, {
name: "Jane Doe"
}, {
name: "Wane Doe"
}]
},
resultText: "Hello John Doe, Jane Doe, Wane Doe, ",
lexed: [startText, content("Hello "), delimiters.start, content("#users"), delimiters.end, delimiters.start, content("name"), delimiters.end, content(", "), delimiters.start, content("/users"), delimiters.end, endText],
parsed: [startText, content("Hello "), {
type: "placeholder",
value: "users",
location: "start",
module: "loop",
inverted: false,
expandTo: "auto"
}, {
type: "placeholder",
value: "name"
}, content(", "), {
type: "placeholder",
value: "users",
location: "end",
module: "loop"
}, endText],
postparsed: [xmlSpacePreserveTag, content("Hello "), {
type: "placeholder",
value: "users",
module: "loop",
inverted: false,
sectPrCount: 0,
subparsed: [{
type: "placeholder",
value: "name"
}, content(", ")]
}, endText]
}, {
it: "should work with paragraph loops",
content: "<w:p><w:t>Hello </w:t></w:p><w:p><w:t>{#users}</w:t></w:p><w:p><w:t>User {.}</w:t></w:p><w:p><w:t>{/users}</w:t></w:p>",
options: {
paragraphLoop: true
},
scope: {
users: ["John Doe", "Jane Doe", "Wane Doe"]
},
result: '<w:p><w:t>Hello </w:t></w:p><w:p><w:t xml:space="preserve">User John Doe</w:t></w:p><w:p><w:t xml:space="preserve">User Jane Doe</w:t></w:p><w:p><w:t xml:space="preserve">User Wane Doe</w:t></w:p>',
lexed: [startParagraph, startText, content("Hello "), endText, endParagraph, startParagraph, startText, delimiters.start, content("#users"), delimiters.end, endText, endParagraph, startParagraph, startText, content("User "), delimiters.start, content("."), delimiters.end, endText, endParagraph, startParagraph, startText, delimiters.start, content("/users"), delimiters.end, endText, endParagraph],
parsed: [startParagraph, startText, content("Hello "), endText, endParagraph, startParagraph, startText, {
type: "placeholder",
value: "users",
location: "start",
module: "loop",
inverted: false,
expandTo: "auto"
}, endText, endParagraph, startParagraph, startText, content("User "), {
type: "placeholder",
value: "."
}, endText, endParagraph, startParagraph, startText, {
type: "placeholder",
value: "users",
location: "end",
module: "loop"
}, endText, endParagraph],
postparsed: [startParagraph, startText, content("Hello "), endText, endParagraph, {
type: "placeholder",
value: "users",
module: "loop",
paragraphLoop: true,
sectPrCount: 0,
hasPageBreak: false,
hasPageBreakBeginning: false,
inverted: false,
subparsed: [startParagraph, xmlSpacePreserveTag, content("User "), {
type: "placeholder",
value: "."
}, endText, endParagraph]
}]
}, _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with paragraph loops and selfclosing paragraphs",
content: "<w:p><w:t>{#foo}</w:t></w:p><w:p/><w:xxx></w:xxx><w:p><w:t>{/}</w:t></w:p>",
options: {
paragraphLoop: true
},
scope: {
foo: true
},
result: "<w:p/><w:xxx></w:xxx>"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should not fail with nested loops if using paragraphLoop",
content: "<w:p><w:t>{#users} {#pets}</w:t></w:p><w:p><w:t>Pet {.}</w:t></w:p><w:p><w:t>{/pets}{/users}</w:t></w:p>",
options: {
paragraphLoop: true
},
scope: {
users: [{
pets: ["Cat", "Dog"]
}, {
pets: ["Cat", "Dog"]
}]
},
result: '<w:p><w:t xml:space="preserve"> </w:t></w:p><w:p><w:t xml:space="preserve">Pet Cat</w:t></w:p><w:p><w:t/></w:p><w:p><w:t xml:space="preserve">Pet Dog</w:t></w:p><w:p><w:t xml:space="preserve"> </w:t></w:p><w:p><w:t xml:space="preserve">Pet Cat</w:t></w:p><w:p><w:t/></w:p><w:p><w:t xml:space="preserve">Pet Dog</w:t></w:p><w:p><w:t/></w:p>'
}), {
it: "should work with spacing loops",
content: "<w:t>{#condition</w:t><w:t>} hello{/</w:t><w:t>condition}</w:t>",
scope: {
condition: true
},
result: '<w:t/><w:t xml:space="preserve"> hello</w:t><w:t></w:t>',
lexed: [startText, delimiters.start, content("#condition"), endText, startText, delimiters.end, content(" hello"), delimiters.start, content("/"), endText, startText, content("condition"), delimiters.end, endText],
parsed: [startText, {
type: "placeholder",
value: "condition",
location: "start",
module: "loop",
inverted: false,
expandTo: "auto"
}, endText, startText, content(" hello"), {
type: "placeholder",
value: "condition",
location: "end",
module: "loop"
}, endText, startText, endText],
postparsed: null
}, _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with spacing loops 2",
contentText: "{#condition}{text}{/condition}",
scope: {
condition: [{
text: " hello "
}]
},
resultText: " hello "
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with empty condition",
contentText: "{#a}A{/a}{^b}{/b}",
scope: {
a: true
},
resultText: "A"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with spacing loops 3",
content: "<w:t>{#condition}</w:t><w:t>{/condition} foo</w:t>",
scope: {
condition: false
},
result: '<w:t xml:space="preserve"> foo</w:t>'
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with spacing loops 4",
contentText: "{#condition}foo{/condition}",
scope: {
condition: false
},
result: "<w:t/>"
}), {
it: "should work with dashloops",
content: "<w:p><w:t>Hello {-w:p users}{name}, {/users}</w:t></w:p>",
scope: {
users: [{
name: "John Doe"
}, {
name: "Jane Doe"
}, {
name: "Wane Doe"
}]
},
result: '<w:p><w:t xml:space="preserve">Hello John Doe, </w:t></w:p><w:p><w:t xml:space="preserve">Hello Jane Doe, </w:t></w:p><w:p><w:t xml:space="preserve">Hello Wane Doe, </w:t></w:p>',
lexed: [startParagraph, startText, content("Hello "), delimiters.start, content("-w:p users"), delimiters.end, delimiters.start, content("name"), delimiters.end, content(", "), delimiters.start, content("/users"), delimiters.end, endText, endParagraph],
parsed: [startParagraph, startText, content("Hello "), {
type: "placeholder",
value: "users",
location: "start",
module: "loop",
inverted: false,
expandTo: "w:p"
}, {
type: "placeholder",
value: "name"
}, content(", "), {
type: "placeholder",
value: "users",
location: "end",
module: "loop"
}, endText, endParagraph],
postparsed: [{
type: "placeholder",
value: "users",
module: "loop",
inverted: false,
sectPrCount: 0,
subparsed: [startParagraph, xmlSpacePreserveTag, content("Hello "), {
type: "placeholder",
value: "name"
}, content(", "), endText, endParagraph]
}]
}, _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should drop table if it has no tc",
content: "<w:tbl><w:tr><w:tc><w:p><w:t>{-w:tr columns} Hello {-w:p users}{name}, {/users}</w:t><w:t>{/columns}</w:t></w:p></w:tc></w:tr></w:tbl>Other",
scope: {},
result: "<w:p/>Other"
}), {
it: "should work with dashloops nested",
content: "<w:tr><w:tc><w:p><w:t>{-w:tr columns} Hello {-w:p users}{name}, {/users}</w:t><w:t>{/columns}</w:t></w:p></w:tc></w:tr>",
scope: {
columns: [{
users: [{
name: "John Doe"
}, {
name: "Jane Doe"
}, {
name: "Wane Doe"
}]
}]
},
result: '<w:tr><w:tc><w:p><w:t xml:space="preserve"> Hello John Doe, </w:t><w:t/></w:p><w:p><w:t xml:space="preserve"> Hello Jane Doe, </w:t><w:t/></w:p><w:p><w:t xml:space="preserve"> Hello Wane Doe, </w:t><w:t/></w:p></w:tc></w:tr>',
lexed: [tableRowStart, tableColStart, startParagraph, startText, delimiters.start, content("-w:tr columns"), delimiters.end, content(" Hello "), delimiters.start, content("-w:p users"), delimiters.end, delimiters.start, content("name"), delimiters.end, content(", "), delimiters.start, content("/users"), delimiters.end, endText, startText, delimiters.start, content("/columns"), delimiters.end, endText, endParagraph, tableColEnd, tableRowEnd],
parsed: [tableRowStart, tableColStart, startParagraph, startText, {
type: "placeholder",
value: "columns",
location: "start",
module: "loop",
inverted: false,
expandTo: "w:tr"
}, content(" Hello "), {
type: "placeholder",
value: "users",
location: "start",
module: "loop",
inverted: false,
expandTo: "w:p"
}, {
type: "placeholder",
value: "name"
}, content(", "), {
type: "placeholder",
value: "users",
location: "end",
module: "loop"
}, endText, startText, {
type: "placeholder",
value: "columns",
location: "end",
module: "loop"
}, endText, endParagraph, tableColEnd, tableRowEnd],
postparsed: null
}, {
it: "should handle selfclose tag",
content: "<w:t />",
scope: {
user: "Foo"
},
result: "<w:t />",
lexed: [{
type: "tag",
value: "<w:t />",
text: true,
position: "selfclosing",
tag: "w:t"
}],
parsed: [{
type: "tag",
position: "selfclosing",
value: "<w:t />",
text: true,
tag: "w:t"
}],
postparsed: [{
type: "tag",
position: "selfclosing",
value: "<w:t />",
text: true,
tag: "w:t"
}]
}, {
it: "should handle {user} with tag with selfclosing",
content: "<w:t /><w:t>Hi {user}</w:t>",
scope: {
user: "Foo"
},
result: '<w:t /><w:t xml:space="preserve">Hi Foo</w:t>',
lexed: [{
type: "tag",
value: "<w:t />",
text: true,
position: "selfclosing",
tag: "w:t"
}, startText, content("Hi "), delimiters.start, content("user"), delimiters.end, endText],
parsed: [{
type: "tag",
position: "selfclosing",
value: "<w:t />",
text: true,
tag: "w:t"
}, startText, content("Hi "), {
type: "placeholder",
value: "user"
}, endText],
postparsed: [{
type: "tag",
position: "selfclosing",
value: "<w:t />",
text: true,
tag: "w:t"
}, xmlSpacePreserveTag, content("Hi "), {
type: "placeholder",
value: "user"
}, endText]
}, {
it: "should be possible to change the delimiters",
contentText: "Hi {=[[ ]]=}[[user]][[={ }=]] and {user2}",
scope: {
user: "John",
user2: "Jane"
},
resultText: "Hi John and Jane",
lexed: [startText, content("Hi "), delimiters.start, content("user"), delimiters.end, content(" and "), delimiters.start, content("user2"), delimiters.end, endText],
parsed: [startText, content("Hi "), {
type: "placeholder",
value: "user"
}, content(" and "), {
type: "placeholder",
value: "user2"
}, endText],
postparsed: [xmlSpacePreserveTag, content("Hi "), {
type: "placeholder",
value: "user"
}, content(" and "), {
type: "placeholder",
value: "user2"
}, endText]
}, {
it: "should be possible to change the delimiters",
contentText: "Hi {=a b c=}",
error: {
name: "TemplateError",
message: "New Delimiters cannot be parsed",
properties: {
id: "change_delimiters_invalid"
}
},
errorType: Errors.XTTemplateError
}, {
it: "should throw error if delimiters invalid",
contentText: "Hi {= =}",
error: {
name: "TemplateError",
message: "New Delimiters cannot be parsed",
properties: {
id: "change_delimiters_invalid"
}
},
errorType: Errors.XTTemplateError
}, {
it: "should throw error if delimiters invalid (2)",
contentText: "Hi {=[ =}",
error: {
name: "TemplateError",
message: "New Delimiters cannot be parsed",
properties: {
id: "change_delimiters_invalid"
}
},
errorType: Errors.XTTemplateError
}, {
it: "should throw error if delimiters invalid (3)",
contentText: "Hi {= ]=}",
error: {
name: "TemplateError",
message: "New Delimiters cannot be parsed",
properties: {
id: "change_delimiters_invalid"
}
},
errorType: Errors.XTTemplateError
}, {
it: "should be possible to change the delimiters with complex example",
contentText: "Hi {={{[ ]}}=}{{[user]}}{{[={{ ]=]}} and {{user2]",
scope: {
user: "John",
user2: "Jane"
},
resultText: "Hi John and Jane",
lexed: [startText, content("Hi "), delimiters.start, content("user"), delimiters.end, content(" and "), delimiters.start, content("user2"), delimiters.end, endText],
parsed: [startText, content("Hi "), {
type: "placeholder",
value: "user"
}, content(" and "), {
type: "placeholder",
value: "user2"
}, endText],
postparsed: [xmlSpacePreserveTag, content("Hi "), {
type: "placeholder",
value: "user"
}, content(" and "), {
type: "placeholder",
value: "user2"
}, endText]
}, _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should resolve the data correctly",
contentText: "{test}{#test}{label}{/test}{test}",
scope: {
label: "T1",
test: true
},
resolved: [{
tag: "test",
lIndex: 3,
value: true
}, {
tag: "test",
lIndex: 15,
value: true
}, {
tag: "test",
lIndex: 6,
value: [[{
tag: "label",
lIndex: 9,
value: "T1"
}]]
}],
resultText: "trueT1true"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should resolve 2 the data correctly",
contentText: "{^a}{label}{/a}",
scope: {
a: true
},
resolved: [{
tag: "a",
lIndex: 3,
value: []
}],
result: "<w:t/>"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should resolve 3 the data correctly",
contentText: "{#frames}{#true}{label}{#false}{label}{/false}{/true}{#false}{label}{/false}{/frames}",
scope: {
frames: [{
label: "T1",
"true": true
}]
},
resolved: [{
tag: "frames",
lIndex: 3,
value: [[{
tag: "false",
lIndex: 24,
value: []
}, {
tag: "true",
lIndex: 6,
value: [[{
tag: "label",
lIndex: 9,
value: "T1"
}, {
tag: "false",
lIndex: 12,
value: []
}]]
}]]
}],
resultText: "T1"
}), _objectSpread(_objectSpread({
it: "should resolve truthy data correctly",
contentText: "{#loop}L{#cond2}{label}{/cond2}{#cond3}{label}{/cond3}{/loop}",
resultText: "Linner"
}, noInternals), {}, {
scope: {
label: "outer",
loop: [{
cond2: true,
label: "inner"
}]
}
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should resolve truthy multi data correctly",
contentText: "{#loop}L{#cond2}{label}{/cond2}{#cond3}{label}{/cond3}{/loop}",
scope: {
label: "outer",
loop: [{
cond2: true,
label: "inner"
}, {
cond2: true,
label: "inner"
}, {
cond3: true,
label: "inner"
}, {
cond2: true,
cond3: true
}]
},
resultText: "LinnerLinnerLinnerLouterouter"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should resolve async loop",
contentText: "{#loop}{#cond1}{label}{/}{#cond2}{label}{/}{/loop}",
scope: {
label: "outer",
loop: [{
cond1: true,
label: "inner"
}, {
cond1: true,
cond2: true
}]
},
resultText: "innerouterouter"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with inversed loop simple",
contentText: "{^b}{label}{/}",
scope: {
b: false,
label: "hi"
},
resultText: "hi"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with nested inversed loop",
contentText: "{#a}{^b}{label}{/}{/}",
scope: {
a: [{
b: false,
label: "hi"
}]
},
resultText: "hi"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with deeply nested inversed loop nested",
contentText: "{#a}{^b}{^c}{label}{/}{/}{/}",
scope: {
a: [{
b: false,
label: "hi"
}]
},
resultText: "hi"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with true value for condition",
contentText: "{#cond}{#product.price > 10}high{/}{#product.price <= 10}low{/}{/cond}",
options: {
parser: expressionParser
},
scope: {
cond: true,
product: {
price: 2
}
},
resultText: "low"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {this+this+this} tag",
contentText: "Hi {this+this+this}",
options: {
parser: expressionParser
},
scope: "Foo",
resultText: "Hi FooFooFoo"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {((.+.+.)*.*0.5)|sum:.} tag",
contentText: "Hi {((((.+.+.)*.*0.5)|sum:.)-.)/.}",
options: {
parser: expressionParser
},
scope: 2,
/*
* = (((2 + 2 + 2)*2 * 0.5 | sum:2)-2)/2
* = (((6)*2 * 0.5 | sum:2)-2)/2
* = ((6 | sum:2)-2)/2
* = ((8)-2)/2
* = (6)/2
* = 3
*/
resultText: "Hi 3"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {.['user-name']} tag",
contentText: "Hi {.['user-name']}",
options: {
parser: expressionParser
},
scope: {
"user-name": "John"
},
resultText: "Hi John"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {#loop}{. | myFilter}{/loop} tag",
contentText: "Hi {#loop}{. | myFilter}{/loop}",
options: {
parser: expressionParser.configure({
filters: {
myFilter: function myFilter(input) {
expect(_typeof(input)).to.equal("number");
expect(input).to.equal(3);
return input + input;
}
}
})
},
scope: {
loop: [3]
},
resultText: "Hi 6"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to customize using postEvaluate for property access",
contentText: "Hi property access:{name}",
options: {
parser: expressionParser.configure({
postEvaluate: function postEvaluate(value, expr, scope, context) {
expect(expr).to.equal("name");
expect(context.meta.part.type).to.equal("placeholder");
expect(context.meta.part.value).to.equal("name");
expect(scope).to.deep.equal({
name: false
});
expect(context.meta.part.module).to.equal(undefined);
if (value === false) {
return "";
}
return value;
}
})
},
scope: {
name: false
},
resultText: "Hi property access:"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to customize using postEvaluate for addition",
contentText: "Hi addition:{name + name}",
options: {
parser: expressionParser.configure({
postEvaluate: function postEvaluate(value, expr) {
expect(expr).to.equal("name + name");
if (value === false) {
return "";
}
return value;
}
})
},
scope: {
name: false
},
resultText: "Hi addition:0"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to block access of parent scope with expressionParser",
contentText: "{name} {#companies}{name}-{revenue}{/}",
options: {
// https://docxtemplater.com/docs/deep-dive-into-the-parser-option/#parser-example-to-avoid-using-the-parent-scope-if-a-value-is-null-on-the-main-scope
parser: function parser(tag) {
var evaluator = expressionParser(tag);
return {
get: function get(scope, context) {
if (context.num < context.scopePath.length) {
return null;
}
var contextProxy = new Proxy({}, {
get: function get(target, name) {
if (name === "scopeList") {
return [];
}
return context[name];
}
});
return evaluator.get(scope, contextProxy);
}
};
}
},
scope: {
name: "John",
companies: [{
revenue: 30,
name: "Acme"
}, {
revenue: 30
}]
},
resultText: "John Acme-30undefined-30"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to customize using postEvaluate for addition for ie11",
contentText: "Hi addition:{name + name}",
options: {
parser: expressionParserIE11.configure({
postEvaluate: function postEvaluate(value, expr) {
expect(expr).to.equal("name + name");
if (value === false) {
return "";
}
return value;
}
})
},
scope: {
name: false
},
resultText: "Hi addition:0"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: 'should handle {this["a b"]} tag',
contentText: 'Hi {this["a b"]}',
options: {
parser: expressionParser
},
scope: {
"a b": "John"
},
resultText: "Hi John"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: 'should handle {this["length"]} tag',
contentText: 'Hi { this["length"]}',
options: {
parser: expressionParser
},
scope: "John",
resultText: "Hi 4"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: 'should handle {this["split"]} tag',
contentText: 'Hi {this["split"]}',
options: {
parser: expressionParser
},
scope: "John",
resultText: "Hi undefined"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {this.split} tag",
contentText: "Hi {this.split}",
options: {
parser: expressionParser
},
scope: "John",
resultText: "Hi undefined"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {(this+this+this)*this} tag",
contentText: "Hi {(this+this+this)*(this+this)}",
options: {
parser: expressionParser
},
scope: 1,
resultText: "Hi 6"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {(this+this+this)*(this+this)}, this=0 tag",
contentText: "Hi {( this + this + this)*(this+this)}",
options: {
parser: expressionParser
},
scope: 0,
resultText: "Hi 0"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should handle {#products}{# . }-{ . }-{/}{/}",
/*
* The space inside {# . } is important.
* It tests a regression that was fixed in version 3.37.12
*/
contentText: "Hi {#products}{# . }-{ . }-{/}{/}",
options: {
parser: expressionParser
},
scope: {
products: [[1, 2, 3, 4], [4, 5, 6, 7]]
},
resultText: "Hi -1--2--3--4--4--5--6--7-"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with int value for condition",
contentText: "{#cond}{#product.price > 10}high{/}{#product.price <= 10}low{/}{/cond}",
options: {
parser: expressionParser
},
scope: {
cond: 10,
product: {
price: 2
}
},
resultText: "low"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with empty string as result",
contentText: "{foo}",
options: {
parser: expressionParser
},
scope: {
foo: ""
},
result: "<w:t/>"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with str value for condition",
contentText: "{#cond}{#product.price > 10}high{/}{#product.price <= 10}low{/}{/cond}",
options: {
parser: expressionParser
},
scope: {
cond: "cond",
product: {
price: 2
}
},
resultText: "low"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with false value for condition",
contentText: "{^cond}{#product.price > 10}high{/}{#product.price <= 10}low{/}{/cond}",
options: {
parser: expressionParser
},
scope: {
cond: false,
product: {
price: 2
}
},
resultText: "low"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with multi level expression parser",
// This tag was designed to match /-([^\s]+)\s(.+)$/ which is the prefix of the dash loop
contentText: "{#users}{name} {date-age+ offset} {/}",
options: {
parser: expressionParser
},
scope: {
date: 2019,
offset: 1,
users: [{
name: "John",
age: 44
}, {
name: "Mary",
age: 22
}, {
date: 2100,
age: 22,
name: "Walt"
}]
},
resultText: "John 1976 Mary 1998 Walt 2079 "
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with $index expression parser",
contentText: "{#list}{#$index==0}FIRST {/}{text} {/list}",
options: {
parser: expressionParser
},
scope: {
list: [{
text: "Hello"
}, {
text: "Other item"
}]
},
resultText: "FIRST Hello Other item "
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with $index and array lookup wiht expression parser",
contentText: "{#products}{productNames[$index]}-{/}",
options: {
parser: expressionParser
},
scope: {
products: [1, 2, 3],
productNames: ["PRO", "LIGHT", "ULTIMATE"]
},
resultText: "PRO-LIGHT-ULTIMATE-"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with $index inside condition expression parser",
contentText: "{#list}{#important}!!{$index+1}{text}{/}{^important}?{$index+1}{text}{/}{/}",
options: {
parser: expressionParser
},
scope: {
list: [{
important: true,
text: "Hello"
}, {
text: "Other item"
}, {
important: true,
text: "Bye"
}]
},
resultText: "!!1Hello?2Other item!!3Bye"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with $index inside condition expression parser",
contentText: "{#list}{#important}!!{$index+1}{text}{/}{^important}?{$index+1}{text}{/}{/}",
options: {
parser: expressionParserIE11
},
scope: {
list: [{
important: true,
text: "Hello"
}, {
text: "Other item"
}, {
important: true,
text: "Bye"
}]
},
resultText: "!!1Hello?2Other item!!3Bye"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with nested conditions inside table",
content: "<w:tbl><w:tr><w:tc><w:p><w:r><w:t>{#cond}{#cond2}{name}</w:t></w:r></w:p></w:tc><w:tc><w:p><w:r><w:t>{/}{/}</w:t></w:r></w:p></w:tc></w:tr></w:tbl>",
options: {
paragraphLoop: true
},
scope: {
cond: true,
cond2: false
},
result: ""
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with -w:tr conditions inside table inside paragraphLoop condition",
content: "<w:p><w:r><w:t>{#cond}</w:t></w:r></w:p><w:tbl><w:tr><w:tc><w:p><w:r><w:t>{-w:tc cond}{val}{/}</w:t></w:r></w:p></w:tc></w:tr></w:tbl><w:p><w:r><w:t>{/}</w:t></w:r></w:p>",
options: {
paragraphLoop: true
},
scope: {
cond: true,
val: "yep"
},
result: '<w:tbl><w:tr><w:tc><w:p><w:r><w:t xml:space="preserve">yep</w:t></w:r></w:p></w:tc></w:tr></w:tbl>'
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work well with nested expressions parser",
contentText: "{v}{#c1}{v}{#c2}{v}{#c3}{v}{/}{/}{/}",
options: {
parser: expressionParser
},
scope: {
v: "0",
c1: {
v: "1",
c2: {
v: "2",
c3: {
v: "3"
}
}
}
},
resultText: "0123"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with this with expressions parser",
contentText: "{#hello}{this}{/hello}",
options: {
parser: expressionParser
},
scope: {
hello: ["world"]
},
resultText: "world"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to close loops with {/}",
contentText: "{#products}Product {name}{/}",
scope: {
products: [{
name: "Bread"
}]
},
resultText: "Product Bread"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should get parent prop if child is null",
contentText: "{#c}{label}{/c}",
options: {
parser: expressionParser
},
scope: {
c: {
label: null
},
label: "hello"
},
resultText: "hello"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work when using double nested arrays",
content: "<w:t>{#a}</w:t><w:t>{this}</w:t><w:t>{/}</w:t>",
options: {
parser: expressionParser
},
scope: {
a: [["first-part", "other-part"]]
},
result: '<w:t/><w:t xml:space="preserve">first-part,other-part</w:t><w:t/>'
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work when using accents or numbers in variable names, ...",
contentText: "{êtreîöò12áeêëẽ}",
options: {
parser: expressionParser
},
resultText: "undefined"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should fail when using € sign",
contentText: "{hello€}",
options: {
parser: expressionParser
},
error: wrapMultiError({
name: "ScopeParserError",
message: "Scope parser compilation failed",
properties: {
explanation: 'The scope parser for the tag "hello€" failed to compile',
rootError: {
message: "[$parse:lexerr] Lexer Error: Unexpected next character at columns 5-5 [\u20AC] in expression [hello\u20AC].\nhttp://errors.angularjs.org/\"NG_VERSION_FULL\"/$parse/lexerr?p0=Unexpected%20next%20character%20&p1=s%205-5%20%5B%E2%82%AC%5D&p2=hello%E2%82%AC"
},
file: "word/document.xml",
id: "scopeparser_compilation_failed",
xtag: "hello€",
offset: 0
}
}),
errorType: Errors.XTTemplateError,
resultText: "undefined"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should disallow access to internal property",
contentText: '{"".split.toString()}',
options: {
parser: expressionParser
},
resultText: "undefined"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should allow filters like | upper",
contentText: "{name | upper}",
options: {
parser: expressionParser
},
scope: {
name: "john"
},
resultText: "JOHN"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work when using assignment that is already in the scope",
contentText: "{b=a}{b}",
options: {
parser: expressionParser
},
scope: {
a: 10,
b: 5
},
resultText: "10"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should work with linebreaks",
contentText: "{b}",
options: {
linebreaks: true,
parser: expressionParser
},
scope: {
b: "Hello\n\nFoo\n\nBar\n\n"
},
result: '<w:t xml:space="preserve">Hello</w:t></w:r><w:r><w:br/></w:r><w:r><w:t/></w:r><w:r><w:br/></w:r><w:r><w:t xml:space="preserve">Foo</w:t></w:r><w:r><w:br/></w:r><w:r><w:t/></w:r><w:r><w:br/></w:r><w:r><w:t xml:space="preserve">Bar</w:t></w:r><w:r><w:br/></w:r><w:r><w:t/></w:r><w:r><w:br/></w:r><w:r><w:t/>'
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should not fail with no scope on expressionParser",
contentText: "{b}",
options: {
parser: expressionParser
},
resultText: "undefined"
}), _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to add filter for one instance of the expressionParser",
contentText: "{b|foo}",
options: {
parser: expressionParser.configure({
filters: {
foo: function foo() {
return "FOO";
}
}
})
},
resultText: "FOO"
}), function () {
var globalData = {
val: 0
};
return _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should be possible to configure expressionParser with set command",
contentText: "{#loop}{$$val = (cond ? 0 : $$val + 1); $$val}{/loop}",
options: {
parser: expressionParser.configure({
setIdentifier: function setIdentifier(tag, value) {
var matchGlobal = /^\$\$/g;
if (matchGlobal.test(tag)) {
globalData[tag] = value;
return true;
}
},
evaluateIdentifier: function evaluateIdentifier(tag) {
var matchGlobal = /^\$\$/g;
if (matchGlobal.test(tag)) {
if (globalData.hasOwnProperty(tag) && globalData[tag] != null) {
return globalData[tag];
}
}
}
})
},
scope: {
loop: [{
cond: true,
x: "foo"
}, {
cond: false,
x: "foo"
}, {
cond: false,
x: "foo"
}, {
cond: true,
x: "foo"
}, {
cond: false,
x: "foo"
}]
},
resultText: "01201"
});
}(), function () {
var count = 0;
return _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should only call evaluateIdentifier once",
contentText: "{user_age}",
options: {
parser: expressionParser.configure({
evaluateIdentifier: function evaluateIdentifier() {
count++;
return null;
}
})
},
scope: {
user_age: 21
},
resultText: "21",
assertBefore: function assertBefore() {
count = 0;
},
assertAfter: function assertAfter() {
expect(count).to.equal(1);
}
});
}(), function () {
var count = 0;
return _objectSpread(_objectSpread({}, noInternals), {}, {
it: "should only call evaluateIdentifier once for tag