@refinitiv-ui/efx-grid 6.0.0-next.0

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

@@ -0,0 +1,521 @@
+import { parseCondition } from "./Util.js";
+import { DateTime } from "./DateTime.js";
+import { FilterOperators } from "./FilterOperators.js";
+
+/** @typedef {Object} FilterBuilder~Options
+* @property {string} field
+* @property {Function=} formatter
+* @property {string=} formattedField
+*/
+
+/** @typedef {Array} FilterBuilder~Condition
+* @description An array with 3 items, representing parameters for FilterBuilder.addCondition method:<br>
+* The first item is operator Id (string)<br>
+* The second item is value (string|number)<br>
+* The third item is connector (string)
+*/
+
+/** @typedef {Array.<FilterBuilder~Condition>} FilterBuilder~Conditions
+* @description A two-dimensional array represents a collection of FilterBuilder~Condition.
+*/
+
+/** @private
+* @type {Object.<string, string>}
+* @const
+*/
+var connectorMap = {
+	"or": 1,
+	"OR": 1,
+	"Or": 1,
+	"oR": 1,
+	"||": 1
+};
+
+/** @private
+* @function
+* @param {string|null} str
+* @return {string}
+*/
+var toJsConnector = function(str) {
+	return connectorMap[str] ? "||" : "&&";
+};
+
+/** @private
+* @function
+* @param {Object} cond Internal condition object
+* @return {FilterBuilder~Condition}
+*/
+var conditionToArray = function(cond) {
+	return [
+		cond.operatorId,
+		cond.value,
+		cond.connector
+	];
+};
+
+/** FilterBuilder helps client build filter function from various types of input
+* @constructor
+* @param {FilterBuilder~Options=} options
+*/
+var FilterBuilder = function (options) {
+	this._initStaticVariables();
+
+	this._conditions = [];
+
+	this.init(options);
+};
+
+/** @private */
+FilterBuilder.prototype._initStaticVariables = function() {
+	if(!FilterBuilder._initStatic) {
+		FilterBuilder._initStatic = true;
+
+		FilterBuilder._updateTimezoneOffset();
+		var timeUntilNextDay = 86400000 - (new Date() % 86400000);
+		setTimeout(FilterBuilder._setUpdateInterval, timeUntilNextDay);
+	}
+};
+/** @type {boolean}
+* @private
+*/
+FilterBuilder._initStatic = false; // For checking initialization stage
+
+/** @type {string}
+* @private
+*/
+FilterBuilder.prototype._fieldName = "";
+/** @type {string}
+* @private
+*/
+FilterBuilder.prototype._formattedFieldName = "";
+/** @type {Function}
+* @private
+*/
+FilterBuilder.prototype._formatter = null;
+/** @type {Function}
+* @private
+*/
+FilterBuilder.prototype._rawDataAccessor = null;
+/** @type {Function}
+* @private
+*/
+FilterBuilder.prototype._formattedDataAccessor = null;
+/** @type {!Array.<Object>}
+* @private
+*/
+FilterBuilder.prototype._conditions;
+
+
+/** @type {number}
+* @private
+*/
+FilterBuilder._timezoneOffset = 0; // in milliseconds
+/** @private
+* @function
+*/
+FilterBuilder._updateTimezoneOffset = function() {
+	FilterBuilder._timezoneOffset = (new Date()).getTimezoneOffset() * 60;
+};
+/** @private
+* @function
+*/
+FilterBuilder._setUpdateInterval = function() {
+	FilterBuilder._updateTimezoneOffset();
+	setInterval(FilterBuilder._updateTimezoneOffset, 86400000); // 24 hours
+	// TODO: Add a way to remove this interval
+};
+
+
+/** @public
+* @description Clear existing field and conditions
+*/
+FilterBuilder.prototype.reset = function() {
+	this.setFieldDefinition("");
+	this._rawDataAccessor = this._formattedDataAccessor = null;
+};
+/** @public
+* @param {FilterBuilder~Options=} options
+*/
+FilterBuilder.prototype.init = function(options) {
+	if(!options) {
+		return;
+	}
+	var field = options["field"];
+	if(field) {
+		this.setFieldDefinition(field, options["formatter"], options["formattedField"]);
+	}
+};
+
+/** @public
+* @param {string} fieldName
+* @param {Function=} formatter
+* @param {string=} formattedField
+*/
+FilterBuilder.prototype.setFieldDefinition = function(fieldName, formatter, formattedField) {
+	this._fieldName = fieldName;
+	this._formattedFieldName = (formattedField) ? formattedField : fieldName + "_FORMATTED";
+	this._formatter = formatter || null;
+	this._conditions.length = 0;
+};
+/** @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.
+*/
+FilterBuilder.prototype.setDataAccessors = function(rawDataAccessor, formattedDataAccessor) {
+	this._rawDataAccessor = (typeof rawDataAccessor === "function") ? rawDataAccessor : null;
+	this._formattedDataAccessor = (typeof formattedDataAccessor === "function") ? formattedDataAccessor : null;
+};
+/** @public
+* @param {string} oper Operator id (e.g., "GT", "CONT", "EQ")
+* @param {string|number} value
+* @param {string=} connector Possible values are "OR" and "AND"
+* @return {boolean} Return true, if the new condition is added
+*/
+FilterBuilder.prototype.addCondition = function (oper, value, connector) {
+	oper = oper ? oper.toUpperCase() : "";
+	var opDef = FilterOperators[oper];
+	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) {
+		if(value !== 0 && value !== false) {
+			return false; // Invalid comparer value ("", null, undefined, NaN)
+		}
+	}
+
+	this._conditions.push({
+		operatorId: oper,
+		value: value,
+		connector: connector || ""
+	});
+
+	return true;
+};
+/** @public
+* @param {FilterBuilder~Conditions} conditions Two dimensional array representing conditions
+* @return {number} Return number of conditions being added.
+*/
+FilterBuilder.prototype.addConditions = function (conditions) {
+	var count = 0;
+	if(Array.isArray(conditions)) {
+		var len = conditions.length;
+		for(var i = 0; i < len; ++i) {
+			var condition = conditions[i];
+			if(Array.isArray(condition)) {
+				if(this.addCondition(condition[0], condition[1], condition[2])) {
+					++count;
+				}
+			}
+		}
+		// To support one dimensional array as an input
+		if(len > 1 && !count && !Array.isArray(conditions[0])) {
+			if(this.addCondition(conditions[0], conditions[1], conditions[2])) {
+				++count;
+			}
+		}
+	}
+	return count;
+};
+/** @public
+* @return {FilterBuilder~Conditions} Return null, if no condition has been added.
+*/
+FilterBuilder.prototype.getConditions = function () {
+	if(this._conditions.length) {
+		return this._conditions.map(conditionToArray);
+	}
+	return null;
+};
+/** @public
+* @description After setting field and adding conditions, use this method to build a filter 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;
+		}
+	}
+	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);");
+	}
+
+	// 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
+			}
+
+			if(hasCaseInsensitiveOp) {
+				filterStr.push("if(str) { str = str.toLowerCase(); };");
+			}
+		}
+		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("} else {");
+		filterStr.push("  ts = val.getTime();");
+		filterStr.push("  if(ts !== ts) {");
+		filterStr.push("    return false;");
+		filterStr.push("  }");
+		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 = "";
+				}
+			}
+
+			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.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) + ")");
+	}
+
+	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
+
+	// Release all resources after building the filter whether success or not
+	this._conditions.length = 0;
+	return func;
+};
+/** @public
+* @param {string} filterStr For instance, GT♦100♦AND♣LTE♦200
+* @param {string} field
+* @param {Function=} formatter
+* @param {string=} formattedField
+* @return {Function}
+*/
+FilterBuilder.prototype.buildMonitorFilter = function(filterStr, field, formatter, formattedField) {
+	this.setFieldDefinition(field, formatter, formattedField);
+	var needConvertValue = (field.lastIndexOf("_LOCAL") === field.length - 6); // _LOCAL field is special monitor field which convert time value to local timezone (idn)
+
+	var conds = filterStr.split("♣");
+	for (var i = 0; i < conds.length; i++) {
+		var tokens = conds[i].split("♦");
+		if(needConvertValue) {
+			tokens[1] = ((tokens[1] - FilterBuilder._timezoneOffset) % 86400) + ""; // Convert to local timezone value for range filtering
+		}
+		this.addCondition(tokens[0], tokens[1], tokens[2]);
+	}
+
+	return this.buildFilter();
+};
+/** @public
+* @function
+* @param {Object} obj
+* @param {string} field
+* @param {Function=} rawDataAccessor Raw data getter for custom data type
+* @return {Function}
+*/
+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 + '"]');
+	if(rawDataAccessor) {
+		if(!contextObj) {
+			contextObj = {};
+		}
+		contextObj["rawDataAccessor"] = rawDataAccessor;
+		funcAry.push("  val = this.rawDataAccessor(val);");
+	}
+	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;
+};
+
+/** @public
+* @param {*} condition This can be string, array, or function
+* @param {string=} field Field to be used as input for the filter
+* @param {Function=} formatter
+* @param {string=} formattedField
+* @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.
+* @return {Function} Filter function that takes rowData object
+*/
+FilterBuilder.prototype.parse = function(condition, field, formatter, formattedField, rawDataAccessor, formattedDataAccessor) {
+	var type = typeof(condition);
+	if(type === "string") {
+		if(condition.indexOf("♦") >= 0) {
+			return this.buildMonitorFilter(condition, field, formatter, formattedField);
+		} else {
+			return parseCondition(condition);
+		}
+	} else if(type === "function") {
+		return condition;
+	} else if(Array.isArray(condition)) {
+		if(field) {
+			this.setFieldDefinition(field, formatter, formattedField);
+			this.setDataAccessors(rawDataAccessor, formattedDataAccessor);
+		}
+		this.addConditions(condition);
+		return this.buildFilter();
+	} else if(type === "object") {
+		return buildFilterFromObjectMap(condition, field, rawDataAccessor);
+	}
+	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

@@ -0,0 +1,41 @@
+
+
+declare namespace FilterOperators {
+
+    type Operator = {
+        name: string,
+        type: string,
+        positive: number,
+        caseSensitive: number,
+        formula: string
+    };
+
+    type Operators = {
+        EQ: FilterOperators.Operator,
+        NEQ: FilterOperators.Operator,
+        NUMEQ: FilterOperators.Operator,
+        NUMNEQ: FilterOperators.Operator,
+        GT: FilterOperators.Operator,
+        GTE: FilterOperators.Operator,
+        LT: FilterOperators.Operator,
+        LTE: FilterOperators.Operator,
+        BEGIN: FilterOperators.Operator,
+        NBEGIN: FilterOperators.Operator,
+        END: FilterOperators.Operator,
+        NEND: FilterOperators.Operator,
+        CONT: FilterOperators.Operator,
+        NCONT: FilterOperators.Operator,
+        EQ_BLANK: FilterOperators.Operator,
+        EQ_NBLANK: FilterOperators.Operator,
+        DT: FilterOperators.Operator,
+        DTA: FilterOperators.Operator,
+        DTB: FilterOperators.Operator,
+        TXTEQ: FilterOperators.Operator,
+        BLANK: FilterOperators.Operator,
+        NBLANK: FilterOperators.Operator
+    };
+
+}
+
+export default FilterOperators;
+export { FilterOperators };