awing-library 2.1.2-dev.99 → 2.1.2-stable.2

package/lib/AWING/LogicExpression/script.js

@@ -0,0 +1,1038 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExpression = exports.convertToNodes = exports.extractFunctionParams = exports.getNewNode = exports.getParameterDataType = exports.getFunctionParams = exports.getArrayFieldDef = exports.isArrayField = exports.getFunctionDataType = exports.isKeyword = exports.isFunction = exports.isField = exports.isComparator = exports.isOperator = exports.isDate = exports.isString = exports.isBoolean = exports.isNumber = exports.ignoreParentheses = exports.trimSpaceBrackets = exports.getEnumData = exports.getArrayType = exports.getFunctionReturn = exports.getFunctionSuggestions = exports.mergeObj = exports.flattenObj = exports.reverseObjMapping = void 0;
+var constants_1 = require("./constants");
+var moment_1 = __importDefault(require("moment"));
+//Common functions
+var isVoidFunction = function (node) {
+    return node.nodeType === constants_1.NODE_TYPE.FUNCTION && node.dataType === 'void';
+};
+var reverseObjMapping = function (obj) {
+    var reversed = {};
+    Object.keys(obj).forEach(function (key) {
+        reversed[obj[key]] = reversed[obj[key]] || [];
+        reversed[obj[key]].push(key);
+    });
+    return reversed;
+};
+exports.reverseObjMapping = reverseObjMapping;
+var flattenObj = function (obj, parent, res, name) {
+    if (res === void 0) { res = {}; }
+    for (var key in obj) {
+        var propName = parent ? "".concat(parent, ".").concat(key) : key;
+        if (typeof obj[key] === 'object') {
+            res["".concat(name, ".").concat(propName)] = Array.isArray(obj[key]) ? 'array' : 'object';
+            (0, exports.flattenObj)(obj[key], propName, res, name);
+        }
+        else {
+            res["".concat(name, ".").concat(propName)] = obj[key];
+        }
+        ;
+    }
+    return res;
+};
+exports.flattenObj = flattenObj;
+var mergeObj = function (c, o, f) {
+    var res = {};
+    Object.keys(c).forEach(function (key) {
+        var _a;
+        res[key] = res[key] || [];
+        (_a = res[key]).push.apply(_a, c[key]);
+    });
+    Object.keys(o).forEach(function (key) {
+        var _a;
+        res[key] = res[key] || [];
+        (_a = res[key]).push.apply(_a, o[key]);
+    });
+    var func = (0, exports.reverseObjMapping)(f);
+    Object.keys(func).forEach(function (key) {
+        var _a;
+        res[key] = res[key] || [];
+        (_a = res[key]).push.apply(_a, func[key]);
+    });
+    return res;
+};
+exports.mergeObj = mergeObj;
+var getFunctionSuggestions = function (obj) {
+    var res = {};
+    Object.keys(obj).forEach(function (key) {
+        res[key] = constants_1.FUNCTION_TYPE.FUNCTION;
+    });
+    return res;
+};
+exports.getFunctionSuggestions = getFunctionSuggestions;
+var getFunctionReturn = function (obj) {
+    var res = {};
+    Object.keys(obj).forEach(function (key) {
+        res[key] = obj[key].return;
+    });
+    return res;
+};
+exports.getFunctionReturn = getFunctionReturn;
+var getArrayType = function (word, suggestions) {
+    var tmp = word.split('[')[0], txt = suggestions[tmp], init = txt.indexOf('('), fin = txt.indexOf(')');
+    return txt.substring(init + 1, fin);
+};
+exports.getArrayType = getArrayType;
+var getEnumData = function (enumType) {
+    if (enumType === '')
+        return [];
+    var init = enumType.indexOf('['), fin = enumType.indexOf(']');
+    return enumType.substring(init + 1, fin).split(',').map(function (item) { return item.trim(); });
+};
+exports.getEnumData = getEnumData;
+var trimSpaceBrackets = function (exp) {
+    return exp === null || exp === void 0 ? void 0 : exp.replace(/([([])\s+|\s+([)\]])/g, "$1$2");
+};
+exports.trimSpaceBrackets = trimSpaceBrackets;
+var ignoreParentheses = function (word) {
+    if (word === void 0) { word = ''; }
+    return word === null || word === void 0 ? void 0 : word.split(new RegExp(/[()]/)).filter(function (x) { return x; });
+};
+exports.ignoreParentheses = ignoreParentheses;
+var isNumber = function (s) {
+    var numberRegex = /^\s*[+-]?(\d+|\d*\.\d+|\d+\.\d*)([Ee][+-]?\d+)?\s*$/;
+    return numberRegex.test(s);
+};
+exports.isNumber = isNumber;
+var isBoolean = function (s) {
+    s = s.toLowerCase();
+    return s === 'false' || s === 'true';
+};
+exports.isBoolean = isBoolean;
+var isString = function (s) {
+    return !!s && s.trim().length > 0 && s.startsWith('"');
+};
+exports.isString = isString;
+var isDate = function (s) {
+    var isDateValid = false;
+    for (var i = 0; i < constants_1.DATE_FORMATS.length; i++) {
+        if ((0, moment_1.default)(s.replaceAll('"', '').replaceAll('\'', '').trim(), constants_1.DATE_FORMATS[i].trim(), true).isValid()) {
+            isDateValid = true;
+            break;
+        }
+    }
+    return isDateValid;
+};
+exports.isDate = isDate;
+var isOperator = function (s) {
+    var oper = constants_1.MATH_OPERATORS.find(function (x) { return x === s; });
+    return !!oper;
+};
+exports.isOperator = isOperator;
+var isComparator = function (s) {
+    var oper = constants_1.COMPARE_OPERATORS.find(function (x) { return x === s; });
+    return !!oper;
+};
+exports.isComparator = isComparator;
+var isField = function (s, oc) {
+    var field = oc[s];
+    return !!field;
+};
+exports.isField = isField;
+var isFunction = function (s, f) {
+    var fc = f[s];
+    return !!fc;
+};
+exports.isFunction = isFunction;
+var isKeyword = function (s) {
+    var oper = constants_1.KEYWORDS.find(function (x) { return x === s; });
+    return !!oper;
+};
+exports.isKeyword = isKeyword;
+var getFunctionDataType = function (s, f) {
+    for (var key in f) {
+        if (s.startsWith(key))
+            return f[key];
+    }
+    return undefined;
+};
+exports.getFunctionDataType = getFunctionDataType;
+var isArrayField = function (s, oc) {
+    var field = s.split('[')[0];
+    if (!(0, exports.isField)(field, oc))
+        return false;
+    if (!s.endsWith(']') || s.replaceAll('[', '').length !== s.length - 1)
+        return false;
+    return true;
+};
+exports.isArrayField = isArrayField;
+var getArrayFieldDef = function (s, oc) {
+    var field = s.split('[')[0];
+    var type = oc[field].replace('array(', '').replaceAll(')', '').trim();
+    return {
+        type: type,
+        operand: field
+    };
+};
+exports.getArrayFieldDef = getArrayFieldDef;
+var getFunctionParams = function (fn, functionList) {
+    var arg = functionList[fn];
+    if (!arg)
+        return [];
+    var arrayReturn = [];
+    Object.keys(arg).forEach(function (key) {
+        if (key !== 'return') {
+            arrayReturn.push(arg[key]);
+        }
+    });
+    return arrayReturn;
+};
+exports.getFunctionParams = getFunctionParams;
+var getParameterDataType = function (pram, oc, fl) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var fieldDataTypes = [];
+    var field = oc[pram];
+    if (field) { //pram is a field
+        return field;
+    }
+    else if ((0, exports.isNumber)(pram)) { //pram is constant number
+        return constants_1.DATA_TYPE_MAPPING.NUMBER;
+    }
+    else if ((0, exports.isDate)(pram)) { //pram is constant date
+        return constants_1.DATA_TYPE_MAPPING.DATE;
+    }
+    else if ((0, exports.isBoolean)(pram)) { //pram is constant boolean
+        return constants_1.DATA_TYPE_MAPPING.BOOLEAN;
+    }
+    else if ((0, exports.isString)(pram)) { //pram is constant string
+        return constants_1.DATA_TYPE_MAPPING.STRING;
+    }
+    else if ((0, exports.getFunctionDataType)(pram, fl)) { //pram is function
+        return (0, exports.getFunctionDataType)(pram, fl);
+    }
+    else if ((0, exports.isArrayField)(pram, oc)) { //pram is an array field
+        var fdef = (0, exports.getArrayFieldDef)(pram, oc);
+        return fdef.type;
+    }
+    else {
+        return false;
+    }
+};
+exports.getParameterDataType = getParameterDataType;
+//Create a new node, default is an operator
+var getNewNode = function () {
+    var rootNode = {
+        name: 'ROOT',
+        body: '',
+        dataType: undefined,
+        nodeType: constants_1.NODE_TYPE.OPERATOR,
+        leftNode: undefined,
+        rightNode: undefined,
+        parentNode: undefined
+    };
+    return rootNode;
+};
+exports.getNewNode = getNewNode;
+var extractFunctionParams = function (s, refNumber) {
+    var openCounter = 0;
+    var funcStr = '';
+    var paramCounter = 0;
+    var i = refNumber.index;
+    for (i = refNumber.index; i < s.length; i++) {
+        if (s[i] === '(') {
+            openCounter++;
+        }
+        else if (s[i] === ')') {
+            console.log('extractFunctionParams openCounter: ', openCounter);
+            openCounter--;
+            if (openCounter < 0) {
+                console.log("Looks bad: function parameters are not valid!");
+                return false;
+            }
+            else if (openCounter === 0) {
+                //Finished function parameters
+                console.log("Looks good: function parameters");
+                funcStr = "".concat(funcStr).concat(s[i]);
+                var pars = funcStr;
+                var parArr = pars.split(',').filter(function (x) { return x; });
+                if (parArr.length !== paramCounter + 1) {
+                    console.log("Looks bad: number of parameters are not valid!");
+                    return false;
+                }
+                refNumber.index = i;
+                return funcStr;
+            }
+        }
+        else if (s[i] === ',') {
+            paramCounter++;
+        }
+        funcStr = "".concat(funcStr).concat(s[i]);
+    }
+    refNumber.index = i;
+    console.log("Looks bad: cannot extract function parameters!");
+    return false;
+};
+exports.extractFunctionParams = extractFunctionParams;
+//Step 1: Scan all characters to converting to nodes
+var convertToNodes = function (elements, currentNode, nodeStack, f) {
+    var word = '';
+    for (var i = 0; i < elements.length; i++) {
+        if (elements[i] === '(') {
+            if (word.trim().length > 0) {
+                if ((0, exports.isFunction)(word, f)) {
+                    //Start extracting function
+                    var ref = {
+                        index: i
+                    };
+                    var pr = (0, exports.extractFunctionParams)(elements, ref);
+                    i = ref.index;
+                    if (pr !== false) {
+                        //Good! => Validate parameters of the function
+                        //Then Create new node to store for open/close tag ( )
+                        var fNode = (0, exports.getNewNode)();
+                        fNode.name = constants_1.NODE_TYPE.FUNCTION;
+                        fNode.nodeType = constants_1.NODE_TYPE.FUNCTION;
+                        fNode.body = "".concat(word).concat(pr);
+                        fNode.parentNode = currentNode;
+                        word = '';
+                        nodeStack.push(fNode);
+                        continue;
+                    }
+                    else {
+                        console.log("Looks bad: cannot extract function parameters from exp: ".concat(elements.substring(i, elements.length)));
+                        return false;
+                    }
+                }
+            }
+            //Create new node to store for open/close tag ( )
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = '(';
+            newNode.nodeType = constants_1.NODE_TYPE.OPENTAG;
+            newNode.parentNode = currentNode;
+            newNode.body = '(';
+            nodeStack.push(newNode);
+        }
+        else if (elements[i] === ')') {
+            console.log('convertToNodes word: ', word);
+            if (word.trim().length > 0) {
+                //Then Create new node to store operand
+                var newNode = (0, exports.getNewNode)();
+                newNode.name = word.trim();
+                newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode.body = word.trim();
+                newNode.parentNode = currentNode;
+                word = '';
+                nodeStack.push(newNode);
+            }
+            //Create new node to store for open/close tag ( )
+            var closeNode = (0, exports.getNewNode)();
+            closeNode.name = ')';
+            closeNode.nodeType = constants_1.NODE_TYPE.CLOSETAG;
+            closeNode.parentNode = currentNode;
+            closeNode.body = ')';
+            word = '';
+            nodeStack.push(closeNode);
+        }
+        else if (elements[i] === '"') {
+            if (i === elements.length - 1) {
+                console.log("Looks bad: expression did not finish the string from item ".concat(i, " for started \""));
+                return false;
+            }
+            //Extract string from ""
+            word = elements[i];
+            var finishedString = false;
+            for (var j = i + 1; j < elements.length; j++) {
+                word = "".concat(word).concat(elements[j]);
+                if (elements[j] === '"') {
+                    finishedString = true;
+                    i = j;
+                    break;
+                }
+            }
+            if (!finishedString) {
+                console.log("Looks bad: expression did not finish the string from item ".concat(i, " for started \""));
+                return false;
+            }
+            //Create new node to store for the string
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = word;
+            newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+            newNode.parentNode = currentNode;
+            newNode.body = word;
+            word = '';
+            nodeStack.push(newNode);
+        }
+        else if ((0, exports.isComparator)(elements[i])) {
+            if (i >= elements.length - 1) {
+                console.log("Looks bad: The operator is wrong here: index: ".concat(i, " in ").concat(elements));
+                return false;
+            }
+            //Try to check if this is comparator >=, <=, !=, ...
+            var opr = "".concat(elements[i]).concat(elements[i + 1]);
+            if ((0, exports.isComparator)(opr)) {
+                i++;
+            }
+            else {
+                opr = elements[i];
+            }
+            if (word.trim().length > 0) {
+                //Create new node to store for operand
+                var newNode_1 = (0, exports.getNewNode)();
+                newNode_1.name = word.trim();
+                newNode_1.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode_1.parentNode = currentNode;
+                newNode_1.body = word.trim();
+                nodeStack.push(newNode_1);
+            }
+            word = '';
+            //Create new node to store for comparator >=, <=, !=, ...
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = opr;
+            newNode.nodeType = constants_1.NODE_TYPE.COMPARATOR;
+            newNode.parentNode = currentNode;
+            newNode.dataType = constants_1.DATA_TYPE_MAPPING.BOOLEAN;
+            newNode.body = opr;
+            nodeStack.push(newNode);
+        }
+        else if ((0, exports.isOperator)(elements[i])) {
+            if (i >= elements.length - 1) {
+                console.log("Looks bad: The operator is wrong here: index: ".concat(i, " in ").concat(elements));
+                return false;
+            }
+            if (word.trim().length > 0) {
+                //Create new node to store for operand
+                var newNode_2 = (0, exports.getNewNode)();
+                newNode_2.name = word.trim();
+                newNode_2.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode_2.parentNode = currentNode;
+                newNode_2.body = word.trim();
+                nodeStack.push(newNode_2);
+            }
+            word = '';
+            //Create new node to store for operator: + - * /
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = elements[i].trim();
+            newNode.nodeType = constants_1.NODE_TYPE.OPERATOR;
+            newNode.parentNode = currentNode;
+            newNode.body = elements[i].trim();
+            nodeStack.push(newNode);
+        }
+        else if (elements[i] === ' ') {
+            word = word.trim();
+            if (word.length > 0) {
+                if ((0, exports.isComparator)(word)) {
+                    //Create new node to store for comparator: < <= > >=..
+                    var newNode = (0, exports.getNewNode)();
+                    newNode.name = word;
+                    newNode.nodeType = constants_1.NODE_TYPE.COMPARATOR;
+                    newNode.parentNode = currentNode;
+                    newNode.body = word;
+                    nodeStack.push(newNode);
+                    word = '';
+                }
+                else if ((0, exports.isKeyword)(word)) {
+                    //Create new node to store for comparator: < <= > >=..
+                    var newNode = (0, exports.getNewNode)();
+                    newNode.name = word;
+                    newNode.nodeType = constants_1.NODE_TYPE.KEYWORD;
+                    newNode.parentNode = currentNode;
+                    newNode.body = word;
+                    nodeStack.push(newNode);
+                    word = '';
+                }
+                else {
+                    //Create new node to store for operand
+                    var newNode = (0, exports.getNewNode)();
+                    newNode.name = word;
+                    newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+                    newNode.parentNode = currentNode;
+                    newNode.body = word;
+                    nodeStack.push(newNode);
+                    word = '';
+                }
+            }
+            else {
+                //Skip white chars
+            }
+        }
+        else {
+            word = "".concat(word).concat(elements[i]);
+            if (i === elements.length - 1) {
+                //Create new node to store for operand
+                var newNode = (0, exports.getNewNode)();
+                newNode.name = word;
+                newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode.parentNode = currentNode;
+                newNode.body = word;
+                nodeStack.push(newNode);
+                word = '';
+            }
+        }
+    }
+};
+exports.convertToNodes = convertToNodes;
+var validateExpression = function (oc, f, functionList, expression) {
+    if (expression === false) {
+        console.log("Look bad the expression is boolean: ".concat(expression));
+        return false;
+    }
+    var elements = expression.trim();
+    var rootNode = (0, exports.getNewNode)();
+    var currentNode = rootNode;
+    var nodeStack = [];
+    var tempStack = [];
+    var word = '';
+    //Step 1: Scan all characters to converting to nodes
+    for (var i = 0; i < elements.length; i++) {
+        if (elements[i] === '(') {
+            if (word.trim().length > 0) {
+                if ((0, exports.isFunction)(word, f)) {
+                    //Start extracting function
+                    var ref = {
+                        index: i
+                    };
+                    var pr = (0, exports.extractFunctionParams)(expression, ref);
+                    i = ref.index;
+                    if (pr !== false) {
+                        //Good! => Validate parameters of the function
+                        //Then Create new node to store for open/close tag ( )
+                        var fNode = (0, exports.getNewNode)();
+                        fNode.name = constants_1.NODE_TYPE.FUNCTION;
+                        fNode.nodeType = constants_1.NODE_TYPE.FUNCTION;
+                        fNode.body = "".concat(word).concat(pr);
+                        fNode.parentNode = currentNode;
+                        word = '';
+                        nodeStack.push(fNode);
+                        continue;
+                    }
+                    else {
+                        console.log("Looks bad: cannot extract function parameters from exp: ".concat(elements.substring(i, elements.length)));
+                        return false;
+                    }
+                }
+            }
+            //Create new node to store for open/close tag ( )
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = '(';
+            newNode.nodeType = constants_1.NODE_TYPE.OPENTAG;
+            newNode.parentNode = currentNode;
+            newNode.body = '(';
+            nodeStack.push(newNode);
+        }
+        else if (elements[i] === ')') {
+            console.log("validateExpression word: ".concat(word));
+            if (word.trim().length > 0) {
+                //Then Create new node to store operand
+                var newNode = (0, exports.getNewNode)();
+                newNode.name = word.trim();
+                newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode.body = word.trim();
+                newNode.parentNode = currentNode;
+                word = '';
+                nodeStack.push(newNode);
+            }
+            //Create new node to store for open/close tag ( )
+            var closeNode = (0, exports.getNewNode)();
+            closeNode.name = ')';
+            closeNode.nodeType = constants_1.NODE_TYPE.CLOSETAG;
+            closeNode.parentNode = currentNode;
+            closeNode.body = ')';
+            word = '';
+            nodeStack.push(closeNode);
+        }
+        else if (elements[i] === '"') {
+            // if(word.trim().length >0){
+            //     //Then Create new node to store operand
+            //     let newNode = getNewNode();
+            //     newNode.name = word.trim();
+            //     newNode.nodeType = NODE_TYPE.OPERAND;
+            //     newNode.body = word.trim();
+            //     newNode.parentNode = currentNode;
+            //     word = '';
+            //     nodeStack.push(newNode);
+            // }
+            if (i === elements.length - 1) {
+                console.log("Looks bad: expression did not finish the string from item ".concat(i, " for started \""));
+                return false;
+            }
+            //Extract string from ""
+            word = elements[i];
+            var finishedString = false;
+            for (var j = i + 1; j < elements.length; j++) {
+                word = "".concat(word).concat(elements[j]);
+                if (elements[j] === '"') {
+                    finishedString = true;
+                    i = j;
+                    break;
+                }
+            }
+            if (!finishedString) {
+                console.log("Looks bad: expression did not finish the string from item ".concat(i, " for started \""));
+                return false;
+            }
+            //Create new node to store for the string
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = word;
+            newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+            newNode.parentNode = currentNode;
+            newNode.body = word;
+            word = '';
+            nodeStack.push(newNode);
+        }
+        else if ((0, exports.isComparator)(elements[i])) {
+            if (i >= elements.length - 1) {
+                console.log("Looks bad: The operator is wrong here: index: ".concat(i, " in ").concat(elements));
+                return false;
+            }
+            //Try to check if this is comparator >=, <=, !=, ...
+            var opr = "".concat(elements[i]).concat(elements[i + 1]);
+            if ((0, exports.isComparator)(opr)) {
+                i++;
+            }
+            else {
+                opr = elements[i];
+            }
+            if (word.trim().length > 0) {
+                //Create new node to store for operand
+                var newNode_3 = (0, exports.getNewNode)();
+                newNode_3.name = word.trim();
+                newNode_3.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode_3.parentNode = currentNode;
+                newNode_3.body = word.trim();
+                nodeStack.push(newNode_3);
+            }
+            word = '';
+            //Create new node to store for comparator >=, <=, !=, ...
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = opr;
+            newNode.nodeType = constants_1.NODE_TYPE.COMPARATOR;
+            newNode.parentNode = currentNode;
+            newNode.dataType = constants_1.DATA_TYPE_MAPPING.BOOLEAN;
+            newNode.body = opr;
+            nodeStack.push(newNode);
+        }
+        else if ((0, exports.isOperator)(elements[i])) {
+            if (i >= elements.length - 1) {
+                console.log("Looks bad: The operator is wrong here: index: ".concat(i, " in ").concat(elements));
+                return false;
+            }
+            if (word.trim().length > 0) {
+                //Create new node to store for operand
+                var newNode_4 = (0, exports.getNewNode)();
+                newNode_4.name = word.trim();
+                newNode_4.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode_4.parentNode = currentNode;
+                newNode_4.body = word.trim();
+                nodeStack.push(newNode_4);
+            }
+            word = '';
+            //Create new node to store for operator: + - * /
+            var newNode = (0, exports.getNewNode)();
+            newNode.name = elements[i].trim();
+            newNode.nodeType = constants_1.NODE_TYPE.OPERATOR;
+            newNode.parentNode = currentNode;
+            newNode.body = elements[i].trim();
+            nodeStack.push(newNode);
+        }
+        else if (elements[i] === ' ') {
+            word = word.trim();
+            if (word.length > 0) {
+                if ((0, exports.isComparator)(word)) {
+                    //Create new node to store for comparator: < <= > >=..
+                    var newNode = (0, exports.getNewNode)();
+                    newNode.name = word;
+                    newNode.nodeType = constants_1.NODE_TYPE.COMPARATOR;
+                    newNode.parentNode = currentNode;
+                    newNode.body = word;
+                    nodeStack.push(newNode);
+                    word = '';
+                }
+                else if ((0, exports.isKeyword)(word)) {
+                    //Create new node to store for comparator: < <= > >=..
+                    var newNode = (0, exports.getNewNode)();
+                    newNode.name = word;
+                    newNode.nodeType = constants_1.NODE_TYPE.KEYWORD;
+                    newNode.parentNode = currentNode;
+                    newNode.body = word;
+                    nodeStack.push(newNode);
+                    word = '';
+                }
+                else {
+                    //Create new node to store for operand
+                    var newNode = (0, exports.getNewNode)();
+                    newNode.name = word;
+                    newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+                    newNode.parentNode = currentNode;
+                    newNode.body = word;
+                    nodeStack.push(newNode);
+                    word = '';
+                }
+            }
+            else {
+                //Skip white chars
+            }
+        }
+        else {
+            word = "".concat(word).concat(elements[i]);
+            if (i === elements.length - 1) {
+                //Create new node to store for operand
+                var newNode = (0, exports.getNewNode)();
+                newNode.name = word;
+                newNode.nodeType = constants_1.NODE_TYPE.OPERAND;
+                newNode.parentNode = currentNode;
+                newNode.body = word;
+                nodeStack.push(newNode);
+                word = '';
+            }
+        }
+    }
+    //Step 2: Iterate each node to fill in data type
+    for (var i = 0; i < nodeStack.length; i++) {
+        if (nodeStack[i].nodeType === constants_1.NODE_TYPE.OPERAND || nodeStack[i].nodeType === constants_1.NODE_TYPE.FUNCTION) {
+            var dtype = (0, exports.getParameterDataType)(nodeStack[i].body, oc, f);
+            if (dtype === false) {
+                console.log("Looks bad. Cannot get data type of the node ".concat(i, " with body: ").concat(nodeStack[i].body));
+                return false;
+            }
+            nodeStack[i].dataType = dtype;
+        }
+    }
+    //If expression starts or ends with operator/comparator/keyword (without dataType = 'void') => invalid
+    var nodeStackLength = nodeStack.length;
+    if (nodeStackLength <= 1 && !nodeStack.some(function (x) { return isVoidFunction(x); })) {
+        return false;
+    }
+    if (nodeStack[0].nodeType === constants_1.NODE_TYPE.OPERATOR ||
+        nodeStack[0].nodeType === constants_1.NODE_TYPE.COMPARATOR ||
+        nodeStack[0].nodeType === constants_1.NODE_TYPE.KEYWORD ||
+        nodeStack[nodeStackLength - 1].nodeType === constants_1.NODE_TYPE.OPERATOR ||
+        nodeStack[nodeStackLength - 1].nodeType === constants_1.NODE_TYPE.COMPARATOR ||
+        nodeStack[nodeStackLength - 1].nodeType === constants_1.NODE_TYPE.KEYWORD) {
+        console.log("Looks bad. Expression cannot starts or ends with operator/comparator");
+        return false;
+    }
+    //Step 3: Remove open/close tag on single operand
+    var cont = true;
+    while (cont === true) {
+        var node = nodeStack.pop();
+        if (node) {
+            var rightNode = tempStack.pop();
+            if (!rightNode) {
+                tempStack.push(node);
+                continue;
+            }
+            var leftNode = nodeStack.pop();
+            if (!leftNode) {
+                console.log("Uhm node stack is empty now");
+                tempStack.push(rightNode);
+                tempStack.push(node);
+                break;
+            }
+            if (node.nodeType === constants_1.NODE_TYPE.OPERAND &&
+                leftNode.nodeType === constants_1.NODE_TYPE.OPENTAG &&
+                rightNode.nodeType === constants_1.NODE_TYPE.CLOSETAG) {
+                tempStack.push(node);
+            }
+            else {
+                tempStack.push(rightNode);
+                tempStack.push(node);
+                nodeStack.push(leftNode);
+            }
+        }
+        else {
+            cont = false;
+        }
+    }
+    //Step 4: Contruct the tree for operators * and /
+    cont = true;
+    nodeStack = tempStack;
+    tempStack = [];
+    while (cont === true) {
+        var node = nodeStack.pop();
+        if (node) {
+            if (node.nodeType === constants_1.NODE_TYPE.OPERATOR && (node.body === '*' || node.body === '/')) {
+                var rightNode = nodeStack.pop();
+                if (!rightNode) {
+                    console.log("Looks bad. Found a node is operator/comparator but not found a LEFT operand for");
+                    tempStack.push(node);
+                    return false;
+                }
+                var leftNode = tempStack.pop();
+                if (!leftNode) {
+                    console.log("Looks bad. Found a node is operator/comparator but not found a RIGHT operand for");
+                    tempStack.push(node);
+                    tempStack.push(rightNode);
+                    return false;
+                }
+                if (leftNode.body === '(' && rightNode.body === ')') {
+                    //console.log(`Skip the node ${node.body} cause of next node is: ${rightNode.body}`);
+                    console.log("Removed () from node: ".concat(node.body));
+                    tempStack.push(node);
+                    continue;
+                }
+                if (rightNode.body === '(') {
+                    console.log("Skip the node ".concat(node.body, " cause of next node is: ").concat(rightNode.body));
+                    tempStack.push(node);
+                    tempStack.push(rightNode);
+                    continue;
+                }
+                if (rightNode.body === '(' && leftNode.body === ')') {
+                    console.log("Skip the node ".concat(node.body, " cause of next node is: ").concat(rightNode.body));
+                    tempStack.push(leftNode);
+                    tempStack.push(node);
+                    tempStack.push(rightNode);
+                    continue;
+                }
+                //Combine left and right node into a parent
+                if (leftNode.dataType !== rightNode.dataType) {
+                    console.log("Looks bad on * / combination. Left node and Right node is not the same datatype: left: ".concat(leftNode.body, "-").concat(leftNode.nodeType, ", right: ").concat(rightNode.body, "-").concat(rightNode.nodeType));
+                    return false;
+                }
+                node.dataType = leftNode.dataType;
+                node.rightNode = rightNode;
+                node.rightNode.parentNode = node;
+                node.leftNode = leftNode;
+                node.leftNode.parentNode = leftNode;
+                tempStack.push(node);
+            }
+            else {
+                tempStack.push(node);
+            }
+        }
+        else {
+            cont = false;
+        }
+    }
+    //Step 5: Contruct the tree for operators + and -
+    cont = true;
+    nodeStack = tempStack.reverse();
+    tempStack = [];
+    while (cont === true) {
+        var node = nodeStack.pop();
+        if (node) {
+            if (node.nodeType === constants_1.NODE_TYPE.OPERATOR && (node.body === '+' || node.body === '-')) {
+                var rightNode = nodeStack.pop();
+                if (!rightNode) {
+                    console.log("Looks bad. Found a node is operator/comparator but not found a LEFT operand for");
+                    tempStack.push(node);
+                    return false;
+                }
+                var leftNode = tempStack.pop();
+                if (!leftNode) {
+                    console.log("Looks bad. Found a node is operator/comparator but not found a RIGHT operand for");
+                    tempStack.push(node);
+                    tempStack.push(rightNode);
+                    return false;
+                }
+                if (leftNode.body === '(' && rightNode.body === ')') {
+                    //console.log(`Skip the node ${node.body} cause of next node is: ${rightNode.body}`);
+                    console.log("Removed () from node: ".concat(node.body));
+                    tempStack.push(node);
+                    continue;
+                }
+                if (rightNode.body === '(') {
+                    console.log("Skip the node ".concat(node.body, " cause of next node is: ").concat(rightNode.body));
+                    tempStack.push(node);
+                    tempStack.push(rightNode);
+                    continue;
+                }
+                if (rightNode.body === '(' && leftNode.body === ')') {
+                    console.log("Skip the node ".concat(node.body, " cause of next node is: ").concat(rightNode.body));
+                    tempStack.push(leftNode);
+                    tempStack.push(node);
+                    tempStack.push(rightNode);
+                    continue;
+                }
+                //Combine left and right node into a parent
+                if (leftNode.dataType !== rightNode.dataType) {
+                    console.log("Looks bad on = - combination. Left node and Right node is not the same datatype: left: ".concat(leftNode.body, "-").concat(leftNode.nodeType, ", right: ").concat(rightNode.body, "-").concat(rightNode.nodeType));
+                    return false;
+                }
+                node.dataType = leftNode.dataType;
+                node.rightNode = rightNode;
+                node.rightNode.parentNode = node;
+                node.leftNode = leftNode;
+                node.leftNode.parentNode = leftNode;
+                tempStack.push(node);
+            }
+            else {
+                tempStack.push(node);
+            }
+        }
+        else {
+            cont = false;
+        }
+    }
+    //Step 6: Remove open/close tag on single operators
+    cont = true;
+    nodeStack = tempStack;
+    tempStack = [];
+    while (cont === true) {
+        var node = nodeStack.pop();
+        if (node) {
+            var rightNode = tempStack.pop();
+            if (!rightNode) {
+                tempStack.push(node);
+                continue;
+            }
+            var leftNode = nodeStack.pop();
+            if (!leftNode) {
+                console.log("Uhm node stack is empty now");
+                tempStack.push(rightNode);
+                tempStack.push(node);
+                break;
+            }
+            if (node.nodeType === constants_1.NODE_TYPE.OPERATOR &&
+                leftNode.nodeType === constants_1.NODE_TYPE.OPENTAG &&
+                rightNode.nodeType === constants_1.NODE_TYPE.CLOSETAG) {
+                tempStack.push(node);
+            }
+            else {
+                tempStack.push(rightNode);
+                tempStack.push(node);
+                nodeStack.push(leftNode);
+            }
+        }
+        else {
+            cont = false;
+        }
+    }
+    //Step 7: Contruct the tree for comparators
+    nodeStack = tempStack;
+    tempStack = [];
+    cont = true;
+    while (cont === true) {
+        var node = nodeStack.pop();
+        if (node) {
+            if (node.nodeType === constants_1.NODE_TYPE.COMPARATOR) {
+                var rightNode = nodeStack.pop();
+                var leftNode = tempStack.pop();
+                if (!rightNode) {
+                    console.log("Looks bad. Found a node is operator/comparator but not found a RIGHT operand for");
+                    return false;
+                }
+                if (!leftNode) {
+                    console.log("Looks bad. Found a node is operator/comparator but not found a LEFT operand for");
+                    return false;
+                }
+                if (leftNode.nodeType === constants_1.NODE_TYPE.CLOSETAG ||
+                    leftNode.nodeType === constants_1.NODE_TYPE.OPENTAG ||
+                    leftNode.nodeType === constants_1.NODE_TYPE.COMPARATOR ||
+                    leftNode.nodeType === constants_1.NODE_TYPE.KEYWORD ||
+                    rightNode.nodeType === constants_1.NODE_TYPE.CLOSETAG ||
+                    rightNode.nodeType === constants_1.NODE_TYPE.OPENTAG ||
+                    rightNode.nodeType === constants_1.NODE_TYPE.COMPARATOR ||
+                    rightNode.nodeType === constants_1.NODE_TYPE.KEYWORD) {
+                    console.log("Looks bad. Invalid expression on node: ".concat(node.body, " with left: ").concat(leftNode.body, " and right ").concat(rightNode.body));
+                    return false;
+                }
+                node.rightNode = rightNode;
+                node.rightNode.parentNode = node;
+                node.leftNode = leftNode;
+                node.leftNode.parentNode = leftNode;
+                tempStack.push(node);
+            }
+            else {
+                tempStack.push(node);
+            }
+        }
+        else {
+            cont = false;
+        }
+    }
+    //Step 8: Remove open/close tag from single comparators
+    cont = true;
+    nodeStack = tempStack;
+    tempStack = [];
+    while (cont === true) {
+        var node = nodeStack.pop();
+        if (node) {
+            var rightNode = tempStack.pop();
+            if (!rightNode) {
+                tempStack.push(node);
+                continue;
+            }
+            var leftNode = nodeStack.pop();
+            if (!leftNode) {
+                console.log("Uhm node stack is empty now");
+                tempStack.push(rightNode);
+                tempStack.push(node);
+                break;
+            }
+            if (node.nodeType === constants_1.NODE_TYPE.COMPARATOR &&
+                leftNode.nodeType === constants_1.NODE_TYPE.OPENTAG &&
+                rightNode.nodeType === constants_1.NODE_TYPE.CLOSETAG) {
+                tempStack.push(node);
+            }
+            else {
+                tempStack.push(rightNode);
+                tempStack.push(node);
+                nodeStack.push(leftNode);
+            }
+        }
+        else {
+            cont = false;
+        }
+    }
+    //Step 9: Unbox open/close tag of expressions
+    cont = true;
+    nodeStack = tempStack;
+    tempStack = [];
+    var subExpStack = [];
+    while (cont === true) {
+        var node = nodeStack.pop();
+        if (node) {
+            if (node.nodeType === constants_1.NODE_TYPE.CLOSETAG) {
+                while (true) {
+                    var nextNode = tempStack.pop();
+                    if (nextNode && nextNode.nodeType === constants_1.NODE_TYPE.OPENTAG) {
+                        if ((!isVoidFunction(subExpStack[0]) && subExpStack[0].nodeType !== constants_1.NODE_TYPE.COMPARATOR) ||
+                            (!isVoidFunction(subExpStack[subExpStack.length - 1]) && subExpStack[subExpStack.length - 1].nodeType !== constants_1.NODE_TYPE.COMPARATOR)) {
+                            console.log("Looks bad on sub expression. Invalid structure.");
+                            return false;
+                        }
+                        for (var idx = 0; idx < subExpStack.length; idx++) {
+                            if (subExpStack[idx].nodeType === constants_1.NODE_TYPE.KEYWORD) {
+                                if ((!isVoidFunction(subExpStack[idx - 1]) && subExpStack[idx - 1].dataType !== constants_1.DATA_TYPE_MAPPING.BOOLEAN) ||
+                                    (!isVoidFunction(subExpStack[idx + 1]) && subExpStack[idx + 1].dataType !== constants_1.DATA_TYPE_MAPPING.BOOLEAN)) {
+                                    console.log("Looks bad on sub expression. Invalid structure.");
+                                    return false;
+                                }
+                            }
+                        }
+                        var newNode = (0, exports.getNewNode)();
+                        newNode.nodeType = constants_1.NODE_TYPE.COMPARATOR;
+                        newNode.dataType = constants_1.DATA_TYPE_MAPPING.BOOLEAN;
+                        newNode.body = '=';
+                        tempStack.push(newNode);
+                        break;
+                    }
+                    else if (nextNode) {
+                        subExpStack.push(nextNode);
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            else {
+                tempStack.push(node);
+            }
+        }
+        else {
+            cont = false;
+        }
+    }
+    //Validate final nodes
+    if ((!isVoidFunction(tempStack[0]) && tempStack[0].nodeType !== constants_1.NODE_TYPE.COMPARATOR) ||
+        (!isVoidFunction(tempStack[tempStack.length - 1]) && tempStack[tempStack.length - 1].nodeType !== constants_1.NODE_TYPE.COMPARATOR)) {
+        console.log("Looks bad on the main expression. Invalid structure.");
+        return false;
+    }
+    for (var idx = 0; idx < tempStack.length; idx++) {
+        if (tempStack[idx].nodeType === constants_1.NODE_TYPE.KEYWORD) {
+            if ((!isVoidFunction(tempStack[idx - 1]) && tempStack[idx - 1].dataType !== constants_1.DATA_TYPE_MAPPING.BOOLEAN) ||
+                (!isVoidFunction(tempStack[idx + 1]) && tempStack[idx + 1].dataType !== constants_1.DATA_TYPE_MAPPING.BOOLEAN)) {
+                console.log("Looks bad on sub expression. Invalid structure: node ".concat(idx, " is Comparator but LEFT is: \"").concat(tempStack[idx - 1].nodeType, "\" and RIGHT is: \"").concat(tempStack[idx + 1].nodeType, "\""));
+                return false;
+            }
+        }
+    }
+    //DONE
+    return true;
+};
+exports.validateExpression = validateExpression;