@refinitiv-ui/efx-grid 6.0.40 → 6.0.41

package/lib/tr-grid-util/es6/ExpressionParser.js

@@ -0,0 +1,366 @@
+/** @type {Object.<string, number>}
+* @private
+* @const
+*/
+var OperatorPrecedences = {
+	"||": 1,
+	"&&": 2,
+	"<": 3,
+	">": 3,
+	"<=": 3,
+	">=": 3,
+	"!=": 3,
+	"=": 3,
+	"==": 3,
+	"===": 3,
+	"+": 4,
+	"-": 4,
+	"*": 5,
+	"%": 6,
+	"/": 6
+};
+/** @type {Object.<string, Function>}
+* @private
+* @const
+*/
+var OperatorFunctions = {
+	"+": function(lhs, rhs){ return lhs + rhs; },
+	"-": function(lhs, rhs){ return lhs - rhs; },
+	"*": function(lhs, rhs){ return lhs * rhs; },
+	"/": function(lhs, rhs){ return lhs / rhs; },
+	"%": function(lhs, rhs){ return lhs % rhs; },
+	"<": function(lhs, rhs){ return lhs < rhs; },
+	">": function(lhs, rhs){ return lhs > rhs; },
+	"<=": function(lhs, rhs){ return lhs <= rhs; },
+	">=": function(lhs, rhs){ return lhs >= rhs; },
+	"==": function(lhs, rhs){ return lhs == rhs; },
+	"!=": function(lhs, rhs){ return lhs != rhs; },
+	"&&": function(lhs, rhs){ return lhs && rhs; },
+	"||": function(lhs, rhs){ return lhs || rhs; }
+};
+/** @type {Object.<string, Function>}
+* @private
+* @function
+* @param {Array.<Object>} ary
+* @param {string|number} value
+* @param {string} type
+* @param {string=} dataType
+* @return {number}
+*/
+var _addToken = function(ary, value, type, dataType) {
+	var tok = {
+		value: value,
+		type: type
+	};
+	if(dataType) {
+		tok.dataType = dataType;
+	}
+	if(type === "operator") {
+		tok.precedence = OperatorPrecedences[value];
+	}
+	ary.push(tok);
+	return ary.length - 1;
+};
+
+/** @public
+* @namespace
+*/
+var ExpressionParser = {};
+/** @type {Array.<Object>}
+* @private
+* @const
+*/
+ExpressionParser._tokens = [];
+
+
+/** @private
+* @function
+* @param {string} str
+* @return {string}
+*/
+ExpressionParser._withString = function(str) {
+	var tokId = _addToken(ExpressionParser._tokens,
+		str.substring(1, str.length - 1),
+		"literal",
+		"string"
+	);
+	return " #" + tokId + "#";
+};
+/** @private
+* @function
+* @param {string} field
+* @return {string}
+*/
+ExpressionParser._withField = function(field) {
+	var tokId = _addToken(ExpressionParser._tokens,
+		field,
+		"literal",
+		"variable"
+	);
+	return " #" + tokId + "#";
+};
+/** @private
+* @function
+* @param {string} field
+* @return {string}
+*/
+ExpressionParser._withFieldInBrackets = function(field) {
+	return ExpressionParser._withField(field.substring(1, field.length - 1));
+};
+/** @private
+* @function
+* @param {string} numStr
+* @return {string}
+*/
+ExpressionParser._withNegativeNumber = function(numStr) {
+	var num = +numStr;
+	if(num === num) {
+		var tokId = _addToken(ExpressionParser._tokens,
+			num,
+			"literal",
+			"number"
+		);
+		return " #" + tokId + "#";
+	}
+	return "";
+};
+/** @private
+* @function
+* @param {string} numStr
+* @return {string}
+*/
+ExpressionParser._withPositiveNumber = function(numStr) {
+	if(numStr.charCodeAt(0) === 35) {
+		return numStr; // skip token (string with leading #)
+	}
+	return ExpressionParser._withNegativeNumber(numStr);
+};
+/** @private
+* @function
+* @param {string} opStr
+* @return {string}
+*/
+ExpressionParser._withOperator = function(opStr) {
+	if(OperatorPrecedences[opStr]) {
+		if(opStr == "=" || opStr == "===") {
+			opStr = "==";
+		}
+		var tokId = _addToken(ExpressionParser._tokens, opStr, "operator");
+		return "#" + tokId + "#";
+	}
+	return "";
+};
+/** @private
+* @function
+* @param {string} paStr
+* @return {string}
+*/
+ExpressionParser._withParenthesis = function(paStr) {
+	var tokId = _addToken(ExpressionParser._tokens, paStr, "parenthesis");
+	return "#" + tokId + "#";
+};
+
+
+/** @private
+* @function
+* @param {Object} ctx
+* @return {boolean} Returns true if there is any error, otherwise returns false (everything is OK)
+*/
+ExpressionParser._tester = function(ctx) {
+	var rpn = ctx._rpn;
+	var inputCount = rpn.length;
+	var operandCount = 0;
+	var maxStack = 0;
+	for(var i = 0; i < inputCount; ++i) {
+		var tok = rpn[i];
+		if(tok.type !== "literal") {
+			if(operandCount >= 2) {
+				operandCount -= 2;
+			} else {
+				console.warn("Cannot parse an expression with insufficient number of operands");
+				return true;
+			}
+		}
+		operandCount++;
+		if(operandCount > maxStack) {
+			maxStack = operandCount;
+		}
+	}
+
+	if(operandCount !== 1) {
+		return true;
+	}
+
+	ctx._stackSize = maxStack;
+	return false;
+};
+/** @private
+* @function
+* @param {Object} ctx
+* @param {Object} rowData
+* @return {boolean}
+*/
+ExpressionParser._filter = function(ctx, rowData) {
+	var rpn = ctx._rpn;
+	var results = new Array(ctx._stackSize);
+	var inputCount = rpn.length;
+	var operandCount = 0;
+	var curRes;
+	for(var i = 0; i < inputCount; ++i) {
+		var tok = rpn[i];
+		var tokValue = tok.value;
+		if(tok.type === "literal") {
+			if(tok.dataType !== "variable") {
+				curRes = tokValue;
+			}	else {
+				curRes = rowData ? rowData[tokValue] : null;
+			}
+		} else { // operator
+			curRes = OperatorFunctions[tokValue](
+				results[operandCount - 2],
+				results[operandCount - 1]
+			);
+			operandCount -= 2;
+		}
+		results[operandCount++] = curRes;
+	}
+	// return results[0];
+	return results[0] ? true : false;
+};
+
+/** Parse an expression into a filter function (returning boolean value)
+* @public
+* @param {string|Function} expression
+* @return {Function}
+* @example
+* func = ExpressionParser.parse("field1 >= 10");
+* func = ExpressionParser.parse("[field with space] != 'text'");
+* func = ExpressionParser.parse("(field1 + 1) / 2 < 10 && field2 - 10 > 3");
+*/
+ExpressionParser.parse = function(expression) {
+	if(typeof expression === "function") {
+		return  expression;
+	}
+	if(!expression || typeof expression !== "string") {
+		return null;
+	}
+
+	var tokExp = expression.trim();
+	if(!tokExp) {
+		return null;
+	}
+	ExpressionParser._tokens.length = 0;
+
+	tokExp = tokExp.replace(/".+?"/g, ExpressionParser._withString); // double quote string
+	tokExp = tokExp.replace(/'.+?'/g, ExpressionParser._withString); // single quote string
+	tokExp = tokExp.replace(/\[.+?\]/g, ExpressionParser._withFieldInBrackets); // field in square brackets
+	tokExp = tokExp.replace(/-[0-9.]+/g, ExpressionParser._withNegativeNumber);
+	tokExp = tokExp.replace(/[0-9.#]+/g, ExpressionParser._withPositiveNumber);
+	tokExp = tokExp.replace(/[a-zA-Z_]\w*/g, ExpressionParser._withField);
+	tokExp = tokExp.replace(/[\-\/+*%!=<>&|]+/g, ExpressionParser._withOperator);
+	tokExp = tokExp.replace(/[()]/g, ExpressionParser._withParenthesis); // round brackets
+
+	var tokens = ExpressionParser._tokens;
+	var tokCount = tokens.length;
+	if(!tokCount) {
+		return null; // There is no recognizable character
+	}
+
+	// Generate infix token list
+	var infixTokens = [];
+	var matches = tokExp.match(/#[0-9]+#/g);
+	var i, tok, tokType;
+	for(i = 0; i < tokCount; ++i) {
+		var tokId = matches[i];
+		var tokIdx = +(tokId.substring(1, tokId.length - 1));
+		tok = tokens[tokIdx];
+		tokType = tok.type;
+		if(tokType === "literal") {
+			var prevTok = infixTokens[infixTokens.length - 1];
+			if(prevTok && prevTok.type === "literal") { // Incorrect infix notation detected
+				if(tok.value < 0 && tok.dataType === "number") {
+					_addToken(infixTokens, "-", "operator");
+					tok.value *= -1;
+				} else {
+					console.warn("Cannot parse an expression with insufficient number of operators");
+					return null;
+				}
+			}
+		}
+		infixTokens.push(tok);
+	}
+	// TODO: Handle the case where subtraction operator is in front of a variable
+	ExpressionParser._tokens.length = 0;
+
+	// Convert Infix notation to Reverse Polish Notation (Postfix)
+	// See https://en.wikipedia.org/wiki/Shunting_yard_algorithm#The_algorithm_in_detail
+	tokCount = infixTokens.length;
+	var rpn = [];
+	var operators = [];
+	var lastOp = null;
+	var foundLeftPa = false;
+	for(i = 0; i < tokCount; ++i) {
+		tok = infixTokens[i];
+		tokType = tok.type;
+
+		if(tokType === "literal") {
+			rpn.push(tok);
+		} else if(tokType === "parenthesis") {
+			if(tok.value === "(") {
+				operators.push(tok);
+			} else { // When finding right parenthesis, pop all operators until left parenthesis
+				foundLeftPa = false;
+				while(operators.length) {
+					lastOp = operators.pop();
+					if(lastOp.value === "(" && lastOp.type === "parenthesis") {
+						foundLeftPa = true;
+						break;
+					} else {
+						rpn.push(lastOp);
+					}
+				}
+				if(!foundLeftPa) {
+					console.warn("No left parenthesis paired with the right one");
+				}
+			}
+		} else { // operator
+			lastOp = operators[operators.length - 1];
+			var prevPrecedence = lastOp ? lastOp.precedence : null;
+			if(prevPrecedence != null && tok.precedence <= prevPrecedence) {
+				rpn.push(operators.pop());
+			}
+			operators.push(tok);
+		}
+	}
+
+	foundLeftPa = false;
+	while(operators.length) {
+		lastOp = operators.pop();
+		if(lastOp.value === "(" && lastOp.type === "parenthesis") {
+			foundLeftPa = true;
+		} else {
+			rpn.push(lastOp);
+		}
+	}
+	if(foundLeftPa) {
+		console.warn("No right parenthesis paired with the left one");
+	}
+
+	var inputCount = rpn.length;
+	if(!inputCount) {
+		return null; // The expression contains nothing but parentheses
+	}
+
+	var ctx = {
+		_rpn: rpn
+	};
+
+	if(ExpressionParser._tester(ctx)) {
+		return null; // Insufficient number of operands
+	}
+
+	return ExpressionParser._filter.bind(null, ctx);
+};
+
+export default ExpressionParser;
+export {ExpressionParser};

package/lib/tr-grid-util/es6/FilterBuilder.d.ts

@@ -1,13 +1,15 @@
-import { parseCondition } from "./Util.js";
-import { DateTime } from "./DateTime.js";
-import { FilterOperators } from "./FilterOperators.js";
+import { FilterOperators, OperatorFunctions } from "./FilterOperators.js";
+import { ExpressionParser } from "./ExpressionParser.js";
 
 declare namespace FilterBuilder {
 
     type Options = {
-        field: string,
+        field?: (string|null)|null,
         formatter?: ((...params: any[]) => any)|null,
-        formattedField?: string|null
+        formattedField?: string|null,
+        useUTCTime?: boolean|null,
+        rawDataAccessor?: ((...params: any[]) => any)|null,
+        formattedDataAccessor?: ((...params: any[]) => any)|null
     };
 
     type Condition = any[]|null;
@@ -26,9 +28,11 @@ declare class FilterBuilder {
 
     public setFieldDefinition(fieldName: string, formatter?: ((...params: any[]) => any)|null, formattedField?: string|null): void;
 
+    public setDefaultUTCUsage(useUTCTime: boolean): void;
+
     public setDataAccessors(rawDataAccessor?: ((...params: any[]) => any)|null, formattedDataAccessor?: ((...params: any[]) => any)|null): void;
 
-    public addCondition(oper: string, value: string|number|null, connector?: string|null, useUTCTime?: boolean|null): boolean;
+    public addCondition(oper: string, value: string|number|Date|null, connector?: string|null, useUTCTime?: boolean|null): boolean;
 
     public addConditions(conditions: FilterBuilder.Conditions|null): number;