@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

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

@@ -0,0 +1,580 @@
+import { FilterOperators, OperatorFunctions } from "./FilterOperators.js";
+import { ExpressionParser } from "./ExpressionParser.js";
+
+/** @typedef {Object} FilterBuilder~Options
+* @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
+* @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, number>}
+* @const
+*/
+let connectorMap = {
+	"or": 1,
+	"OR": 1,
+	"Or": 1,
+	"oR": 1,
+	"||": 1
+};
+
+/** @private
+* @function
+* @param {*} val
+* @return {number}
+*/
+let convertToNumber = function(val) {
+	if(typeof val === "number") {
+		return val;
+	}
+	if(val) {
+		// WARNING: spaces (" ") and newline ("\n") characters could be parsed as 0
+		// Date object will have value of Date.getTime(). True value will be converted to 1
+		// TODO: Check if we need to use parseFloat instead of Number
+		return Number(val); // Could return NaN.
+	}
+	if(val === false) {
+		return 0;
+	}
+	return NaN; // null, NaN, undefined, empty string
+};
+/** @private
+* @type {RegExp}
+*/
+let _dateStringRule = /^\w{3} \w{3}/;
+/** Convert default string natively generated from a Date object to a Date object. For instance, string "Sun Sep 09 2001 08:46:40 GMT+0700 (Indochina Time)" can be converted, while string "2001-09-09" cannot be converted.
+* @public
+* @function
+* @param {*} str
+* @return {*} Return Date object for successful conversion, otherwise the same input string
+*/
+let stringToDateObject = function(str) {
+	if(typeof str === "string") {
+		let dateObj = new Date(str);
+		let t = dateObj.getTime();
+		if(t === t) {
+			if(_dateStringRule.test(str)) {
+				return dateObj;
+			}
+		}
+	}
+	return str; // Return the user input for unsuccessful conversion
+};
+/** @private
+* @function
+* @param {*} val
+* @return {string}
+*/
+let 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}
+*/
+let 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}
+*/
+let _filterByConditions = function(ctx, rowData) {
+	let conds = ctx._conds;
+	let condCount = conds ? conds.length : 0;
+
+	if(!condCount) {
+		return true; // There is no filter condition
+	}
+
+	let fieldName = ctx._fieldName;
+	let fmtFieldName = ctx._formattedFieldName;
+
+	let val = rowData[fieldName];
+	if(ctx._rawDataAccessor) {
+		val = ctx._rawDataAccessor(val);
+	}
+	let str, lowercasedStr, num, dateVal; // intentionally left undefined
+	let finalResult = false;
+	for(let i = 0; i < condCount; ++i) {
+		let 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
+			}
+		}
+
+		let cond = conds[i];
+		let opDef = FilterOperators[cond.operatorId];
+		let result = false;
+
+		let opType = opDef.type;
+		let opId = opDef.id;
+		let 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) {
+				result = opFunc(str, cond.value);
+			} else {
+				if(lowercasedStr == null) {
+					lowercasedStr = str.toLowerCase();
+				}
+				result = opFunc(lowercasedStr, 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}
+*/
+let _filterByObjectMap = function(ctx, rowData) {
+	let val = rowData[ctx._fieldName];
+	if(ctx._rawDataAccessor) {
+		val = ctx._rawDataAccessor(val);
+	}
+
+	return ctx._itemMap[val] ? true : false;
+};
+
+/** @private
+* @function
+* @param {Object} cond Internal condition object
+* @return {FilterBuilder~Condition}
+*/
+let conditionToArray = function(cond) {
+	return [
+		cond.operatorId,
+		cond.origValue,
+		cond.connector
+	];
+};
+
+/** FilterBuilder helps client build filter function from various types of input
+* @constructor
+* @param {FilterBuilder~Options=} options
+*/
+let FilterBuilder = function (options) {
+	this._initStaticVariables();
+
+	this._conditions = [];
+
+	this.init(options);
+};
+
+/** @private */
+FilterBuilder.prototype._initStaticVariables = function() {
+	if(!FilterBuilder._initStatic) {
+		FilterBuilder._initStatic = true;
+
+		FilterBuilder._updateTimezoneOffset();
+		let 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 {boolean}
+* @private
+*/
+FilterBuilder.prototype._useUTCTime = false;
+/** @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;
+	}
+	let field = options["field"];
+	if(field) {
+		this.setFieldDefinition(field, options["formatter"], options["formattedField"]);
+	} else if(field != null) {
+		this.setFieldDefinition("");
+	}
+
+	let useUTCTime = options["useUTCTime"];
+	if(useUTCTime != null) {
+		this._useUTCTime = useUTCTime ? true : false;
+	}
+
+	let rawDataAccessor = options["rawDataAccessor"];
+	let formattedDataAccessor = options["formattedDataAccessor"];
+	if(rawDataAccessor != null || formattedDataAccessor != null) {
+		this.setDataAccessors(rawDataAccessor, formattedDataAccessor);
+	}
+};
+
+/** @public
+* @param {string} fieldName
+* @param {Function=} formatter
+* @param {string=} formattedField
+*/
+FilterBuilder.prototype.setFieldDefinition = function(fieldName, formatter, formattedField) {
+	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.
+*/
+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|boolean|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 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) {
+	let opId = oper ? oper.toUpperCase() : "";
+	let opDef = FilterOperators[opId];
+	if (!opDef) {
+		return false; // Unknown operation
+	}
+
+	if (value === "{}" || value === "{*}") { // ignore operator if the value is BLANK or NON-BLANK
+		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)
+		}
+	}
+	let cond = {
+		operatorId: opId,
+		origValue: value,
+		connector: connector || ""
+	};
+	if(useUTCTime != null) {
+		cond.useUTCTime = useUTCTime;
+	}
+	this._conditions.push(cond);
+
+	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) {
+	let count = 0;
+	if(Array.isArray(conditions)) {
+		let len = conditions.length;
+		for(let i = 0; i < len; ++i) {
+			let condition = conditions[i];
+			if(Array.isArray(condition)) {
+				if(this.addCondition(condition[0], condition[1], condition[2], condition[3])) {
+					++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;
+	}
+	let condCount = this._conditions.length;
+	if(!condCount) {
+		return null;
+	}
+
+	// Prepare user value to be in ready to use form to boost performance
+	let formatter = this._formatter;
+	let conds = this._conditions.slice();
+	for(let i = 0; i < condCount; ++i) {
+		let cond = conds[i];
+		let opDef = FilterOperators[cond.operatorId];
+		let opType = opDef.type;
+		let value = cond.origValue;
+
+		if(opType === "number") {
+			value = stringToDateObject(value);
+			value = convertToNumber(value);
+		} else if(opType === "date") {
+			let dateObj = null;
+			if(value instanceof Date) {
+				dateObj = value;
+			} else if(typeof value === "number" || typeof value === "string") {
+				dateObj = new Date(value);
+			}
+			value = convertToDateValue(
+				dateObj,
+				cond.useUTCTime != null ? cond.useUTCTime : this._useUTCTime
+			);
+		} else if(opType === "string") {
+			// There is no need to format user input in the user condition
+			value = convertToString(value);
+			if(!opDef.caseSensitive) {
+				value = value.toLowerCase();
+			}
+		}
+		cond.value = value;
+	}
+
+	let 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 _filterByConditions.bind(null, ctx);
+};
+
+/** @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);
+	let needConvertValue = (field.lastIndexOf("_LOCAL") === field.length - 6); // _LOCAL field is special monitor field which convert time value to local timezone (idn)
+
+	let conds = filterStr.split("♣");
+	for (let i = 0; i < conds.length; i++) {
+		let 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}
+*/
+let buildFilterFromObjectMap = function(obj, field, rawDataAccessor) {
+	if(!obj || !field) {
+		return null;
+	}
+	let ctx = {
+		_fieldName: field,
+		_itemMap: obj
+	};
+	if(rawDataAccessor) {
+		ctx._rawDataAccessor = rawDataAccessor;
+	}
+
+	return _filterByObjectMap.bind(null, ctx);
+};
+
+/** @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) {
+	let type = typeof(condition);
+	if(type === "string") {
+		if(condition.indexOf("♦") >= 0) {
+			return this.buildMonitorFilter(condition, field, formatter, formattedField);
+		} else {
+			return ExpressionParser.parse(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;
+};
+
+export default FilterBuilder;
+export { FilterBuilder, buildFilterFromObjectMap, stringToDateObject };

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

@@ -0,0 +1,56 @@
+
+
+declare namespace FilterOperators {
+
+    type Operator = {
+        id: string,
+        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,
+        NEQ_BLANK: FilterOperators.Operator,
+        GREATER_THAN: FilterOperators.Operator,
+        GREATER_THAN_OR_EQUAL_TO: FilterOperators.Operator,
+        EQUAL_TO: FilterOperators.Operator,
+        LESS_THAN: FilterOperators.Operator,
+        LESS_THAN_OR_EQUAL_TO: FilterOperators.Operator,
+        TEXT_THAT_CONTAINS: FilterOperators.Operator,
+        TEXT_THAT_NOT_CONTAINS: FilterOperators.Operator,
+        TEXT_IS: FilterOperators.Operator,
+        NOT_BLANK: FilterOperators.Operator
+    };
+
+}
+
+declare const FilterOperators: FilterOperators.Operators;
+
+declare const OperatorFunctions: { [key: string]:  ((...params: any[]) => any) };
+
+export default FilterOperators;
+export { FilterOperators, OperatorFunctions };