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

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

@@ -0,0 +1,161 @@
+/** Abstract base class that provides event management methods for derived class
+* @constructor
+*/
+let EventDispatcher = function () {};
+
+/** @type {Object.<string, Function>}
+* @protected
+* @ignore
+*/
+EventDispatcher.prototype._events = null;
+/** @type {number}
+* @protected
+* @ignore
+*/
+EventDispatcher.prototype._listenerCount = 0;
+
+//#region public function of event
+/** Add the function handler into the specific event.
+* @public
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+EventDispatcher.prototype.addEventListener = function(type, handler) {
+	if(!type || !handler) { return; }
+	if(!this._events) {
+		this._events = {};
+	}
+
+	let listeners = this._events[type];
+	if(listeners) {
+		if(listeners.indexOf(handler) < 0) {
+			listeners.push(handler);
+			++this._listenerCount;
+		}
+	} else {
+		this._events[type] = [handler];
+		++this._listenerCount;
+	}
+};
+/** Remove the function handler from the specific event.
+* @public
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+EventDispatcher.prototype.removeEventListener = function(type, handler) {
+	let listeners = (this._events) ? this._events[type] : null;
+	if(listeners) {
+		let at = listeners.indexOf(handler);
+		if(at >= 0) {
+			listeners.splice(at, 1);
+			--this._listenerCount;
+		}
+	}
+};
+/** Remove all function handlers from all events.
+* @public
+*/
+EventDispatcher.prototype.removeAllEventListeners = function() {
+	this._events = null;
+	this._listenerCount = 0;
+};
+
+/** Check whether the specified event has a function handler.
+* @public
+* @param {string} type Event name
+* @return {boolean}
+*/
+EventDispatcher.prototype.hasListener = function(type) {
+	if(this._listenerCount) {
+		if(type) {
+			let listeners = this._events ? this._events[type] : null;
+			return listeners ? (listeners.length > 0) : false;
+		} else {
+			return true;
+		}
+	} else {
+		return false;
+	}
+};
+/** Get event listener (function handler) from the specified event.
+* @public
+* @param {string} type Event name
+* @param {number=} idx=0 Index of the listener to be retrieved. This is used when there are multiple event listeners
+* @return {Function}
+*/
+EventDispatcher.prototype.getListener = function(type, idx) {
+	if(type) {
+		let listeners = this._events ? this._events[type] : null;
+		if(listeners) {
+			if(!idx) {
+				idx = 0;
+			}
+			return listeners[idx] || null;
+		}
+	}
+	return null;
+};
+/** A shorthand to retrieve function from an object and add it as an Eventlistener
+* @public
+* @function
+* @param {Object} obj Object that contains a handler with the same name as the given `type`
+* @param {string} type Event name
+* @example
+* let obj = {"mouseUp": function(e) { console.log(e); }};
+* plugin.addListener(obj, "mouseUp");
+* plugin.addListener(obj, "mouseDown");
+*/
+EventDispatcher.prototype.addListener = function(obj, type) {
+	let func = obj ? obj[type] : null;
+	if(typeof func === "function") {
+		this.addEventListener(type, func);
+	}
+};
+
+/** Executed before dispatching, allowing modification of user's event argument object
+* @protected
+* @ignore
+* @param {string} type Event name
+* @param {Object} eventArg User's event argument object
+* @return {Object} New event argument object
+*/
+EventDispatcher.prototype._prepareEventArguments = function(type, eventArg) {
+	return eventArg;
+};
+
+/** Publish the data to the listener.
+* @protected
+* @ignore
+* @param {string} type Event name
+* @param {Object} eventArg Event arguments
+*/
+EventDispatcher.prototype._dispatch = function(type, eventArg) {
+	let listeners = this._events ? this._events[type] : null;
+	if(listeners) {
+		eventArg = this._prepareEventArguments(type, eventArg);
+		let len = listeners.length;
+		for(let i = 0; i < len; ++i) {
+			listeners[i](eventArg);
+		}
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+*/
+let preventDefault = function(e) {
+	if(e && e.preventDefault) {
+		e.preventDefault();
+		e.stopPropagation();
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+*/
+EventDispatcher.preventDefault = preventDefault;
+
+export default EventDispatcher;
+export {EventDispatcher, preventDefault};

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

@@ -0,0 +1,24 @@
+import { Ext } from "./Ext.js";
+import { ElementWrapper } from "./ElementWrapper.js";
+import { ElfUtil } from "./ElfUtil.js";
+
+declare class ExpanderIcon extends ElementWrapper {
+
+    constructor();
+
+    public static loadExpanderStyles(): void;
+
+    public expand(): void;
+
+    public collapse(): void;
+
+    public isExpanded(): boolean;
+
+    public isCollapsed(): boolean;
+
+    public toggle(collapsed?: boolean|null): void;
+
+}
+
+export default ExpanderIcon;
+export { ExpanderIcon };

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

@@ -0,0 +1,120 @@
+import { Ext } from "./Ext.js";
+import { ElementWrapper } from "./ElementWrapper.js";
+import { ElfUtil } from "./ElfUtil.js";
+
+/**
+* @constructor
+* @extends {ElementWrapper}
+*/
+let ExpanderIcon = function () {
+	let elem;
+	if (ExpanderIcon._iconName) {
+		elem = document.createElement("ef-icon");
+		elem.setAttribute("icon", ExpanderIcon._iconName);
+	} else {
+		elem = document.createElement("span");
+		let fallback = document.createElement("span");
+		fallback.className = "fallback-arrow";
+		fallback.textContent = "\u25bc";
+		elem.appendChild(fallback);
+	}
+	this._elem = elem;
+	elem.classList.add("expander");
+
+	elem.addEventListener("mousedown", ExpanderIcon._stopPropagation, false);
+	elem.addEventListener("click", ExpanderIcon._stopPropagation, false);
+};
+Ext.inherits(ExpanderIcon, ElementWrapper);
+
+/** @type {string}
+* @private
+*/
+ExpanderIcon._iconName = ""; // static variable
+
+/** @private
+* @param {Event} e
+*/
+ExpanderIcon._stopPropagation = function(e) {
+	e.stopPropagation();
+};
+/** @private
+*/
+ExpanderIcon._onThemeLoaded = function() {
+	if(ElfUtil.isHaloTheme()) {
+		ExpanderIcon._iconName = "down";
+	}
+};
+
+/** @public
+*/
+ExpanderIcon.loadExpanderStyles = function() {
+	if(!ExpanderIcon._iconName) {
+		let themeName = ElfUtil.getThemeName();
+
+		if(themeName) {
+			ExpanderIcon._onThemeLoaded(); // synchronous
+		} else {
+			ElfUtil.getThemeColors().then(ExpanderIcon._onThemeLoaded).catch(ExpanderIcon._onThemeLoaded); // asynchronous
+		}
+	}
+};
+
+/** @private
+* @param {Object} cell
+* @param {boolean=} removal
+* @return {ExpanderIcon} Return ExpanderIcon object only if Expander is newly created
+*/
+ExpanderIcon.renderOn = function (cell, removal) {
+	let newExpander = null;
+	if (removal) {
+		cell.removeIcon();
+	} else {
+		let expander = cell._expanderIcon;
+		if (!expander) {
+			expander = cell._expanderIcon = newExpander = new ExpanderIcon();
+		}
+
+		cell.updateIcon(expander.getElement());
+	}
+	return newExpander;
+};
+
+/** @public
+*/
+ExpanderIcon.prototype.expand = function () {
+	this._elem.classList.remove("closed");
+};
+/** @public
+*/
+ExpanderIcon.prototype.collapse = function () {
+	this._elem.classList.add("closed");
+};
+/** @public
+* @return {boolean}
+*/
+ExpanderIcon.prototype.isExpanded = function () {
+	return !this._elem.classList.contains("closed");
+};
+/** @public
+* @return {boolean}
+*/
+ExpanderIcon.prototype.isCollapsed = function () {
+	return this._elem.classList.contains("closed");
+};
+/** @public
+* @param {boolean=} collapsed Set to true to force collapsing state. Set to false to force expanding state
+*/
+ExpanderIcon.prototype.toggle = function (collapsed) {
+	if(collapsed == null) {
+		collapsed = !this.isCollapsed();
+	}
+	if(collapsed) {
+		this.collapse();
+	} else {
+		this.expand();
+	}
+};
+
+
+export default ExpanderIcon;
+export { ExpanderIcon };

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

@@ -0,0 +1,10 @@
+
+
+declare namespace ExpressionParser {
+
+    function parse(expression: string|((...params: any[]) => any)|null): ((...params: any[]) => any)|null;
+
+}
+
+export default ExpressionParser;
+export {ExpressionParser};

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

@@ -0,0 +1,408 @@
+/** @type {Object.<string, number>}
+* @private
+* @const
+*/
+let OperatorPrecedences = {
+	"||": 1,
+	"&&": 2,
+	"<": 3,
+	">": 3,
+	"<=": 3,
+	">=": 3,
+	"!=": 3,
+	"=": 3,
+	"==": 3,
+	"===": 3,
+	"+": 4,
+	"-": 4,
+	"*": 5,
+	"%": 6,
+	"/": 6,
+	"!": 7,
+	"!!": 7
+};
+/** @type {Object.<string, Function>}
+* @private
+* @const
+*/
+let 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; },
+	"!": function(lhs, rhs){ return !lhs; },
+	"!!": function(lhs, rhs){ return !!lhs; }
+};
+/** @type {Object.<string, number>}
+* @private
+* @const
+*/
+let OperandRequirements = {
+	"+": 2,
+	"-": 2,
+	"*": 2,
+	"/": 2,
+	"%": 2,
+	"<": 2,
+	">": 2,
+	"<=": 2,
+	">=": 2,
+	"==": 2,
+	"!=": 2,
+	"&&": 2,
+	"||": 2,
+	"!": 1,
+	"!!": 1
+};
+/** @private
+* @function
+* @param {Array.<Object>} ary
+* @param {string|number} value
+* @param {string} type
+* @param {string=} dataType
+* @return {number}
+*/
+let _addToken = function(ary, value, type, dataType) {
+	let tok = {
+		value: value,
+		type: type
+	};
+	if(dataType) {
+		tok.dataType = dataType;
+	}
+	if(type === "operator") {
+		tok.precedence = OperatorPrecedences[value];
+	} else if(type === "parenthesis") {
+		tok.precedence = 0;
+	}
+	ary.push(tok);
+	return ary.length - 1;
+};
+/** @private
+* @function
+* @param {Object} obj
+* @returns {*}
+*/
+let _toValue = function(obj) { // eslint-disable-line
+	return obj.value;
+};
+
+/** @public
+* @namespace
+*/
+let ExpressionParser = {};
+/** @type {Array.<Object>}
+* @private
+* @const
+*/
+ExpressionParser._tokens = [];
+
+
+/** @private
+* @function
+* @param {string} str
+* @return {string}
+*/
+ExpressionParser._withString = function(str) {
+	let 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) {
+	let 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) {
+	let num = +numStr;
+	if(num === num) {
+		let 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 = "==";
+		}
+		let tokId = _addToken(ExpressionParser._tokens, opStr, "operator");
+		return "#" + tokId + "#";
+	}
+	return "";
+};
+/** @private
+* @function
+* @param {string} paStr
+* @return {string}
+*/
+ExpressionParser._withParenthesis = function(paStr) {
+	let 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) {
+	let rpn = ctx._rpn;
+	let inputCount = rpn.length;
+	let operandCount = 0;
+	let maxStack = 0;
+	for(let i = 0; i < inputCount; ++i) {
+		let tok = rpn[i];
+		if(tok.type !== "literal") {
+			let requiredCount = OperandRequirements[tok.value];
+			if(operandCount >= requiredCount) {
+				operandCount -= requiredCount;
+			} 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) {
+	let rpn = ctx._rpn;
+	let results = new Array(ctx._stackSize);
+	let inputCount = rpn.length;
+	let operandCount = 0;
+	let curRes;
+	for(let i = 0; i < inputCount; ++i) {
+		let tok = rpn[i];
+		let tokValue = tok.value;
+		if(tok.type === "literal") {
+			if(tok.dataType !== "variable") {
+				curRes = tokValue;
+			}	else {
+				curRes = rowData ? rowData[tokValue] : null;
+			}
+		} else { // operator
+			if(OperandRequirements[tokValue] === 1) {
+				curRes = OperatorFunctions[tokValue](
+					results[operandCount - 1]
+				);
+				operandCount -= 1;
+			} else { // 2
+				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;
+	}
+
+	let 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
+
+	let tokens = ExpressionParser._tokens;
+	let tokCount = tokens.length;
+	if(!tokCount) {
+		return null; // There is no recognizable character
+	}
+
+	// Generate infix token list
+	let infixTokens = [];
+	let matches = tokExp.match(/#[0-9]+#/g);
+	let i, tok, tokType;
+	for(i = 0; i < tokCount; ++i) {
+		let tokId = matches[i];
+		let tokIdx = +(tokId.substring(1, tokId.length - 1));
+		tok = tokens[tokIdx];
+		tokType = tok.type;
+		if(tokType === "literal") {
+			let 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);
+	}
+	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;
+	let rpn = [];
+	let operators = [];
+	let lastOp = null;
+	let 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
+			while(operators.length) {
+				if(tok.precedence > operators[operators.length - 1].precedence) {
+					break;
+				}
+				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");
+	}
+
+	let inputCount = rpn.length;
+	if(!inputCount) {
+		return null; // The expression contains nothing but parentheses
+	}
+
+	let ctx = {
+		_rpn: rpn
+	};
+
+	if(ExpressionParser._tester(ctx)) {
+		return null; // Insufficient number of operands
+	}
+
+	return ExpressionParser._filter.bind(null, ctx);
+};
+
+export default ExpressionParser;
+export {ExpressionParser};