@refinitiv-ui/efx-grid 6.0.40 → 6.0.42

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

@@ -1,11 +1,13 @@
-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";
 
 /** @typedef {Object} FilterBuilder~Options
-* @property {string} field
-* @property {Function=} formatter
-* @property {string=} formattedField
+* @property {(string|null)=} field=null
+* @property {Function=} formatter=null
+* @property {string=} formattedField=""
+* @property {boolean=} useUTCTime=false A flag used for selecting time between local time and UTC time from the given input in a filter condition. This flag does not apply to Date objects stored in a grid
+* @property {Function=} rawDataAccessor=null
+* @property {Function=} formattedDataAccessor=null
 */
 
 /** @typedef {Array} FilterBuilder~Condition
@@ -20,7 +22,7 @@ import { FilterOperators } from "./FilterOperators.js";
 */
 
 /** @private
-* @type {Object.<string, string>}
+* @type {Object.<string, number>}
 * @const
 */
 var connectorMap = {
@@ -33,11 +35,166 @@ var connectorMap = {
 
 /** @private
 * @function
-* @param {string|null} str
+* @param {*} val
+* @return {number}
+*/
+var convertToNumber = function(val) {
+	if(typeof val === "number") {
+		return val;
+	}
+	if(val) {
+		// WARNING: spaces (" ") and newline ("\n") characters could be parsed as 0
+		// TODO: Check if we need to use parseFloat instead of Number
+		return Number(val); // Could return NaN. true value will be converted to 1
+	}
+	if(val === false) {
+		return 0;
+	}
+	return NaN; // null, NaN, undefined, empty string
+};
+/** @private
+* @function
+* @param {*} val
 * @return {string}
 */
-var toJsConnector = function(str) {
-	return connectorMap[str] ? "||" : "&&";
+var convertToString = function(val) {
+	if(typeof val === "string") {
+		return val;
+	}
+	if(val) {
+		return val + "";
+	}
+	if(val === 0) {
+		return "0";
+	}
+	if(val === false) {
+		return "false";
+	}
+	return ""; // null, NaN, undefined
+};
+/** Retrieve date part and ignore time part from the Date object
+* @private
+* @function
+* @param {Date} dateObj
+* @param {boolean=} useUTCTime
+* @return {number}
+*/
+var convertToDateValue = function(dateObj, useUTCTime) {
+	if(dateObj && dateObj.getTime) {
+		if(useUTCTime) {
+			return dateObj.getUTCFullYear() * 10000 + dateObj.getUTCMonth() * 100 + dateObj.getUTCDate();
+		} else {
+			return dateObj.getFullYear() * 10000 + dateObj.getMonth() * 100 + dateObj.getDate();
+		}
+	}
+	return NaN;
+};
+/** @private
+* @function
+* @param {Object} ctx
+* @param {Object} rowData
+* @return {boolean}
+*/
+var _filterByConditions = function(ctx, rowData) {
+	var conds = ctx._conds;
+	var condCount = conds ? conds.length : 0;
+
+	if(!condCount) {
+		return true; // There is no filter condition
+	}
+
+	var fieldName = ctx._fieldName;
+	var fmtFieldName = ctx._formattedFieldName;
+
+	var val = rowData[fieldName];
+	if(ctx._rawDataAccessor) {
+		val = ctx._rawDataAccessor(val);
+	}
+	var str, num, dateVal; // intentionally left undefined
+	var finalResult = false;
+	var result = false;
+	for(var i = 0; i < condCount; ++i) {
+		var orConnector = 0;
+		if(i > 0) {
+			orConnector = connectorMap[conds[i - 1].connector];
+			// TODO: AND operator has higher precedence than OR operator
+			if(orConnector) {
+				if(finalResult) {
+					return true; // Since OR operator is performed last, it can basically override everything
+				}
+			} else if(!finalResult) { // And connector
+				continue; // AND operator has to be perfomed before OR operator
+			}
+		}
+
+		var cond = conds[i];
+		var opDef = FilterOperators[cond.operatorId];
+		result = false;
+
+		var opType = opDef.type;
+		var opId = opDef.id;
+		var opFunc = OperatorFunctions[opId];
+		if(opType === "blank") {
+			result = opFunc(val);
+		} else if(opType === "number") {
+			if(num == null) {
+				num = convertToNumber(val);
+			}
+
+			result = opFunc(num, cond.value);
+		} else if(opType === "date") {
+			if(dateVal == null) {
+				dateVal = convertToDateValue(val, false); // Even though date is stored as UTC time, we use local time for filtering
+			}
+
+			result = opFunc(dateVal, cond.value);
+		} else { // string type
+			if(str == null) {
+				if(ctx._formattedDataAccessor) {
+					str = ctx._formattedDataAccessor(rowData[fieldName]);
+				} else if(ctx._formatter) {
+					str = ctx._formatter(rowData);
+				} else if(fmtFieldName !== fieldName) {
+					str = rowData[fmtFieldName];
+					if(str == null) {
+						str = val;
+					}
+				} else {
+					str = val;
+				}
+				str = convertToString(str);
+				if(!opDef.caseSensitive) {
+					str = str.toLowerCase();
+				}
+			}
+
+			result = opFunc(str, cond.value);
+		}
+		if(i > 0) {
+			if(orConnector) {
+				finalResult = (finalResult || result);
+			} else {
+				finalResult = (finalResult && result);
+			}
+		} else {
+			finalResult = result;
+		}
+	}
+	return finalResult;
+};
+/** @private
+* @function
+* @param {Object} ctx
+* @param {Object} rowData
+* @return {boolean}
+*/
+var _filterByObjectMap = function(ctx, rowData) {
+	var val = rowData[ctx._fieldName];
+	if(ctx._rawDataAccessor) {
+		val = ctx._rawDataAccessor(val);
+	}
+
+	return ctx._itemMap[val] ? true : false;
 };
 
 /** @private
@@ -48,7 +205,7 @@ var toJsConnector = function(str) {
 var conditionToArray = function(cond) {
 	return [
 		cond.operatorId,
-		cond.value,
+		cond.origValue,
 		cond.connector
 	];
 };
@@ -92,6 +249,10 @@ FilterBuilder.prototype._formattedFieldName = "";
 * @private
 */
 FilterBuilder.prototype._formatter = null;
+/** @type {boolean}
+* @private
+*/
+FilterBuilder.prototype._useUTCTime = false;
 /** @type {Function}
 * @private
 */
@@ -143,6 +304,19 @@ FilterBuilder.prototype.init = function(options) {
 	var field = options["field"];
 	if(field) {
 		this.setFieldDefinition(field, options["formatter"], options["formattedField"]);
+	} else if(field != null) {
+		this.setFieldDefinition("");
+	}
+
+	var useUTCTime = options["useUTCTime"];
+	if(useUTCTime != null) {
+		this._useUTCTime = useUTCTime ? true : false;
+	}
+
+	var rawDataAccessor = options["rawDataAccessor"];
+	var formattedDataAccessor = options["formattedDataAccessor"];
+	if(rawDataAccessor != null || formattedDataAccessor != null) {
+		this.setDataAccessors(rawDataAccessor, formattedDataAccessor);
 	}
 };
 
@@ -152,11 +326,18 @@ FilterBuilder.prototype.init = function(options) {
 * @param {string=} formattedField
 */
 FilterBuilder.prototype.setFieldDefinition = function(fieldName, formatter, formattedField) {
-	this._fieldName = fieldName;
-	this._formattedFieldName = (formattedField) ? formattedField : fieldName + "_FORMATTED";
+	this._fieldName = fieldName; // Quote/doublequote characters don't need to be escaped as eval has been removed
+	this._formattedFieldName = (formattedField) ? formattedField : this._fieldName + "_FORMATTED";
 	this._formatter = formatter || null;
 	this._conditions.length = 0;
 };
+/** Set UTC usage flag. This flag is used for selecting time between local time and UTC time from the given input in a filter condition. This flag does not apply to Date objects stored in a grid
+* @public
+* @param {boolean} useUTCTime
+*/
+FilterBuilder.prototype.setDefaultUTCUsage = function(useUTCTime) {
+	this._useUTCTime = useUTCTime ? true : false;
+};
 /** @public
 * @param {Function=} rawDataAccessor Raw data getter for custom data type
 * @param {Function=} formattedDataAccessor Formatted data getter for custom data type. If this is specified, formatter and formattedField will be overriden.
@@ -167,33 +348,35 @@ FilterBuilder.prototype.setDataAccessors = function(rawDataAccessor, formattedDa
 };
 /** @public
 * @param {string} oper Operator id (e.g., "GT", "CONT", "EQ")
-* @param {string|number} value
+* @param {string|number|Date} value If date type operator is specified, this should be accompanied with useUTCTime flag to indicate whether local or UTC time to be used.
 * @param {string=} connector Possible values are "OR" and "AND"
-* @param {boolean=} useUTCTime If false use local time for filtering
+* @param {boolean=} useUTCTime If the value is not specified, the default setting will be used
 * @return {boolean} Return true, if the new condition is added
 */
 FilterBuilder.prototype.addCondition = function (oper, value, connector, useUTCTime) {
-	oper = oper ? oper.toUpperCase() : "";
-	var opDef = FilterOperators[oper];
+	var opId = oper ? oper.toUpperCase() : "";
+	var opDef = FilterOperators[opId];
 	if (!opDef) {
 		return false; // Unknown operation
 	}
 
 	if (value === "{}" || value === "{*}") { // ignore operator if the value is BLANK or NON-BLANK
-		oper = (opDef.positive ^ value === "{}") ? "EQ_NBLANK" : "EQ_BLANK";
-		opDef = FilterOperators[oper];
-	} else if (!value) {
+		opId = (opDef.positive ^ value === "{}") ? "EQ_NBLANK" : "EQ_BLANK";
+		opDef = FilterOperators[opId];
+	} else if (!value && opDef.type !== "blank") {
 		if(value !== 0 && value !== false) {
 			return false; // Invalid comparer value ("", null, undefined, NaN)
 		}
 	}
-
-	this._conditions.push({
-		operatorId: oper,
-		value: value,
-		connector: connector || "",
-		useUTCTime: useUTCTime
-	});
+	var cond = {
+		operatorId: opId,
+		origValue: value,
+		connector: connector || ""
+	};
+	if(useUTCTime != null) {
+		cond.useUTCTime = useUTCTime;
+	}
+	this._conditions.push(cond);
 
 	return true;
 };
@@ -236,192 +419,65 @@ FilterBuilder.prototype.getConditions = function () {
 * @return {Function} Filter function that takes rowData object
 */
 FilterBuilder.prototype.buildFilter = function() {
-	if (!this._fieldName) { return null; }
-	var len = this._conditions.length;
-	if(!len) { return null; }
-
-	var i, opDef;
-	var hasTextOp = 0; // EQ, NEQ, BEGIN, NBEGIN, END, NEND, CONT, NCONT
-	var hasCaseInsensitiveOp = 0; // BEGIN, NBEGIN, END, NEND, CONT, NCONT
-	var hasNumberOp = 0; // GT, GTE, LT, LTE
-	var hasDateOp = 0;
-	// var hasBlankOp = 0; // EQ_BLANK, EQ_NBLANK
-
-	// Collect filter info
-	for (i = 0; i < len; i++) {
-		opDef = FilterOperators[this._conditions[i].operatorId];
-		if(opDef.type === "string") {
-			++hasTextOp;
-		}
-		if(opDef.type === "number") {
-			++hasNumberOp;
-		}
-		if(opDef.type === "date") {
-			++hasDateOp;
-		}
-		if(!opDef.caseSensitive) {
-			++hasCaseInsensitiveOp;
-		}
+	if (!this._fieldName) {
+		return null;
 	}
-	var fieldName = this._fieldName;
-	var fmtFieldName = this._formattedFieldName;
-	var escapedFieldName = FilterBuilder._escapeQuotes(fieldName);
-
-	var contextObj = null;
-	var filterStr = ["var val = rowData['" + escapedFieldName + "'];"];
-
-	if(this._rawDataAccessor) {
-		if(!contextObj) {
-			contextObj = {};
-		}
-		contextObj["rawDataAccessor"] = this._rawDataAccessor;
-		filterStr.push("val = this.rawDataAccessor(val);");
+	var condCount = this._conditions.length;
+	if(!condCount) {
+		return null;
 	}
 
-	// Prepare row-data
-	if(hasTextOp || hasNumberOp) { // For mixed data type column
-		filterStr.push("if(!val && val !== 0) { val = NaN; }"); // TODO: support false boolean value
-		if(hasTextOp) {
-			if(this._formattedDataAccessor) {
-				if(!contextObj) {
-					contextObj = {};
-				}
-				contextObj["formattedDataAccessor"] = this._formattedDataAccessor;
-				filterStr.push("var str = this.formattedDataAccessor(rowData['" + escapedFieldName + "']);");
-			} else if(this._formatter) {
-				if(!contextObj) {
-					contextObj = {};
-				}
-				contextObj["format"] = this._formatter;
-				filterStr.push("var str = this.format(rowData);");
-			} else if(fmtFieldName !== fieldName) {
-				filterStr.push("var str = rowData['" + FilterBuilder._escapeQuotes(fmtFieldName) + "'];");
-				filterStr.push("if(!str && str !== 0) {"); // TODO: support false boolean value
-				filterStr.push("  str = (!val && val !== 0) ? '' : val + '';");
-				filterStr.push("}");
-			} else {
-				filterStr.push("var str = (!val && val !== 0) ? '' : val + '';"); // TODO: support false boolean value
+	// Prepare user value to be in ready to use form to boost performance
+	var formatter = this._formatter;
+	var conds = this._conditions.slice();
+	for(var i = 0; i < condCount; ++i) {
+		var cond = conds[i];
+		var opDef = FilterOperators[cond.operatorId];
+		var opType = opDef.type;
+		var value = cond.origValue;
+
+		if(opType === "number") {
+			value = convertToNumber(value);
+		} else if(opType === "date") {
+			var dateObj = null;
+			if(value instanceof Date) {
+				dateObj = value;
+			} else if(typeof value === "number" || typeof value === "string") {
+				dateObj = new Date(value);
 			}
-
-			if(hasCaseInsensitiveOp) {
-				filterStr.push("if(str) { str = str.toLowerCase(); };");
+			value = convertToDateValue(
+				dateObj,
+				cond.useUTCTime != null ? cond.useUTCTime : this._useUTCTime
+			);
+		} else if(opType === "string") {
+			if(formatter) { // WARNING: This is not in sync when _formattedDataAccessor exists
+				var dummyRow = {};
+				dummyRow[fieldName] = inputStr;
+				dummyRow[fmtFieldName] = inputStr;
+				value = formatter(dummyRow); // WARNING: dummyRow may not provide enough data for formatting correctly
 			}
-		}
-		if (hasNumberOp && fieldName.indexOf("FREE_TEXT") !== -1) {
-			filterStr.push("val = !isNaN(Number(val)) ? Number(val) : val;");
-		}
-	} else if(hasDateOp) {
-		filterStr.push("var ts = 0;");
-		filterStr.push("if(!val || val != val || !val.getTime) {");
-		filterStr.push("  return false;");
-		filterStr.push("}");
-	}
-
-	// Compose condition string
-	var condStr = [];
-	for (i = 0; i < len; i++) {
-		if (i > 0) {
-			condStr.push(toJsConnector(this._conditions[i - 1].connector));
-		}
-
-		var cond = this._conditions[i];
-		opDef = FilterOperators[cond.operatorId];
-
-		if(opDef.type === "blank") { // Blank checking operation (EQ_BLANK, and EQ_NBLANK) requires no data transformation
-			condStr.push("(" + opDef.formula + ")");
-			continue;
-		}
-
-		// Prepare input-value
-		var inputVal = cond.value; // Expect input value to already be formatted value or raw value
-		if(opDef.type === "string") {
-			if(typeof inputVal !== "string") {
-				if(this._formatter) {
-					var dummyRow = {};
-					dummyRow[fieldName] = inputVal;
-					dummyRow[fmtFieldName] = inputVal;
-					inputVal = this._formatter(dummyRow); // WARNING: dummyRow may not provide enough data for formatting correctly
-				} else if(inputVal) {
-					inputVal = inputVal + "";
-				} else if(inputVal === 0) {
-					inputVal = "0";
-				} else if(inputVal === false) {
-					inputVal = "false";
-				}
-
-				if(!inputVal) {
-					inputVal = "";
-				}
+			value = convertToString(value);
+			if(!opDef.caseSensitive) {
+				value = value.toLowerCase();
 			}
-
-			if(!opDef.caseSensitive && inputVal) {
-				inputVal = inputVal.toLowerCase();
-			}
-
-			// After data type conversion, add quotes to be parsed by eval method
-			inputVal = "'" + FilterBuilder._escapeQuotes(inputVal) + "'";
-		} else if(opDef.type === "date") {
-			if(DateTime.isValidDate(inputVal)) {
-				var varName;
-				if(!cond.useUTCTime){
-					filterStr.push("ts = new Date(val.getFullYear(),val.getMonth(),val.getDate())");
-				} else {
-					filterStr.push("ts = new Date(Date.UTC(val.getUTCFullYear(),val.getUTCMonth(),val.getUTCDate()))");
-				}
-				filterStr.push("ts = ts.getTime()");
-				filterStr.push("if(ts !== ts) {");
-				filterStr.push("  return false;");
-				filterStr.push("}");
-
-				if(cond.operatorId === "DT") {
-					varName = "ts" + (i + 1);
-					inputVal = inputVal.getTime();
-				} else {
-					varName = "date" + (i + 1);
-				}
-				if(!contextObj) {
-					contextObj = {};
-				}
-				contextObj[varName] = inputVal;
-				inputVal = "this." + varName;
-			} else {
-				inputVal = NaN;
-			}
-		} else if(opDef.type === "number" ) {
-			if(typeof inputVal !== "number") {
-				if(inputVal) {
-					if(inputVal === true) {
-						inputVal = 1;
-					} else {
-						inputVal = parseFloat(inputVal);
-					}
-				} else if(inputVal === false) {
-					inputVal = 0;
-				} else { // NaN, empty string, undefined, null
-					inputVal = NaN;
-				}
-			}
-		} // else case is blank operator type which requires no input value
-
-		// Build condition string
-		condStr.push("(" + opDef.formula.replace(/input/g, inputVal) + ")");
+		}
+		cond.value = value;
 	}
 
-	filterStr.push("return " + condStr.join(" ") + ";");
-	filterStr = filterStr.join("\n");
-
-	var func = null;
-	try {
-		func = /** @type{Function} */ (eval("(function(rowData) {\n" + filterStr + "\n})"));
-		if(contextObj) {
-			func = func.bind(contextObj);
-		}
-	} catch(err) {} // eslint-disable-line no-empty
+	var ctx = {
+		_conds: conds,
+		_fieldName: this._fieldName || "",
+		_formatter: formatter || null,
+		_formattedFieldName: this._formattedFieldName || "",
+		_rawDataAccessor: this._rawDataAccessor || null,
+		_formattedDataAccessor: this._formattedDataAccessor || null
+	};
 
 	// Release all resources after building the filter whether success or not
 	this._conditions.length = 0;
-	return func;
+	return _filterByConditions.bind(null, ctx);
 };
+
 /** @public
 * @param {string} filterStr For instance, GT♦100♦AND♣LTE♦200
 * @param {string} field
@@ -455,32 +511,15 @@ var buildFilterFromObjectMap = function(obj, field, rawDataAccessor) {
 	if(!obj || !field) {
 		return null;
 	}
-
-	var contextObj = null;
-	var funcAry = ["(function(itemMap, rowData) {"];
-
-	// TODO: Field name cannot contain double quote string. Handle this case
-	funcAry.push('  var val = rowData["' + field + '"]');
+	var ctx = {
+		_fieldName: field,
+		_itemMap: obj
+	};
 	if(rawDataAccessor) {
-		if(!contextObj) {
-			contextObj = {};
-		}
-		contextObj["rawDataAccessor"] = rawDataAccessor;
-		funcAry.push("  val = this.rawDataAccessor(val);");
+		ctx._rawDataAccessor = rawDataAccessor;
 	}
-	funcAry.push("  return itemMap[val] ? true : false;");
-	funcAry.push("})");
-
-	var funcStr = funcAry.join("\n");
-	var filterFunc = null;
-	try {
-		filterFunc = eval(funcStr);
-	} catch (err) {} // eslint-disable-line
 
-	if(filterFunc) {
-		return filterFunc.bind(contextObj, obj);
-	}
-	return null;
+	return _filterByObjectMap.bind(null, ctx);
 };
 
 /** @public
@@ -498,7 +537,7 @@ FilterBuilder.prototype.parse = function(condition, field, formatter, formattedF
 		if(condition.indexOf("♦") >= 0) {
 			return this.buildMonitorFilter(condition, field, formatter, formattedField);
 		} else {
-			return parseCondition(condition);
+			return ExpressionParser.parse(condition);
 		}
 	} else if(type === "function") {
 		return condition;
@@ -515,14 +554,5 @@ FilterBuilder.prototype.parse = function(condition, field, formatter, formattedF
 	return null;
 };
 
-/** @private
-* @function
-* @param {string} str
-* @return {string}
-*/
-FilterBuilder._escapeQuotes = function(str) {
-	return (str + '').replace(/[\\"']/g, '\\$&').replace(/\u0000/g, '\\0'); // eslint-disable-line no-control-regex
-};
-
 export default FilterBuilder;
 export { FilterBuilder, buildFilterFromObjectMap };

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

@@ -37,5 +37,7 @@ declare namespace FilterOperators {
 
 }
 
+declare const OperatorFunctions: { [key: string]:  ((...params: any[]) => any) }|null;
+
 export default FilterOperators;
-export { FilterOperators };
+export { FilterOperators, OperatorFunctions };