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

package/lib/tr-grid-util/es6/formula/Engine.js

@@ -0,0 +1,592 @@
+import Ext from "../Ext.js";
+import Formula from "./Formula.js";
+import DateTime from "../DateTime.js";
+import Info from "./functions/Info.js";
+import Logic from "./functions/Logic.js";
+import Math from "./functions/Math.js";
+import Stat from "./functions/Statistics.js";
+import Text from "./functions/Text.js";
+// import Excel from "./functions/Excel.js";
+// import AdFin from "./functions/AdFin.js";
+import EventDispatcher from "../EventDispatcher.js";
+
+/** @constructor
+* @extends {EventDispatcher}
+*/
+var Engine = function() {
+	this._context = {};
+	Engine._addContext(this._context, Engine.getContext()); // Clone context for supporting more than one Engine in App
+	this._context["_DATA"] = this._getData.bind(this);  // _DATA is an internal context used for getting cached data
+	this._setData = this._defaultFormulaDataSetter.bind(this); // Default setter for adding the result into rowData
+	this._formulas = [];
+	this._formulaMap = {};
+	this._referenceMap = {};
+	// this.addEventListener("dataChanged");
+	// this.addEventListener("dataRequired");
+	// this.addEventListener("formulaChanged");
+};
+Ext.inherits(Engine, EventDispatcher);
+/** @private
+* @type {Object.<string, *>}
+*/
+Engine.prototype._context = null;
+/** @private
+* @type {Object.<string, *>}
+*/
+Engine.prototype._rowData = null;
+/** @private
+* @type {?Function}
+*/
+Engine.prototype._setData = null;
+/** @private
+* @type {Array.<Formula>}
+*/
+Engine.prototype._formulas = null;
+/** @private
+* @type {Object.<string, Formula>}
+*/
+Engine.prototype._formulaMap = null;
+
+/** @private
+* @type {Object.<string, string>}
+*/
+Engine.prototype._referenceMap = null;
+/** @private
+* @type {Object.<string, *>}
+*/
+Engine._context = null; // Static variable for all instances
+
+
+/** @public
+* @function
+* @return {!Object.<string, *>}
+*/
+Engine.getContext = function() {
+	var context = Engine._context;
+	if(!context) {
+		context = {};
+		Engine._context = context;
+
+		// Engine._addContext(context, AdFin);
+		Engine._addContext(context, DateTime);
+		// Engine._addContext(context, Excel);
+		Engine._addContext(context, Info);
+		Engine._addContext(context, Logic);
+		Engine._addContext(context, Math);
+		Engine._addContext(context, Stat);
+		Engine._addContext(context, Text);
+	}
+	return context;
+};
+/** @public
+* @param {Object.<string, Function>} funcs
+*/
+Engine.addContext = function(funcs) {
+	var context = Engine.getContext();
+	Engine._addContext(context, funcs);
+};
+/** @private
+* @param {Object} context
+* @param {Object.<string, Function>} funcs
+*/
+Engine._addContext = function(context, funcs) {
+	for(var key in funcs) {
+		context[key] = funcs[key];
+	}
+};
+
+/** @public
+* @param {Function} func
+*/
+Engine.prototype.setFormulaDataGetter = function(func) {
+	if(typeof func !== "function") {
+		return;
+	}
+	this._context["_DATA"] = func;
+};
+/** @public
+* @param {Function} func
+*/
+Engine.prototype.setFormulaDataSetter = function(func) {
+	if(typeof func !== "function") {
+		return;
+	}
+	this._setData = func;
+};
+/** @private
+* @param {Formula} formula
+* @param {*} result
+* @param {Object.<string, *>} rowData
+* @param {Object.<string, *>} opt_changes
+*/
+Engine.prototype._defaultFormulaDataSetter = function(formula, result, rowData, opt_changes) {
+	if(result !== "...") {			// Data update is pending - do not erase previous value
+		var alias = formula.getAlias();
+		rowData[alias] = result;
+		if (opt_changes) {
+			opt_changes[alias] = result;
+		}
+	}
+};
+
+/** @public
+* @param {Formula|string} userInput
+* @return {!Formula}
+*/
+Engine.prototype.addFormula = function(userInput) {
+	var f;
+	if(userInput instanceof Formula){
+		f = userInput;
+	} else {
+		this._rowData = {}; // Formula will be tested in the initialization process. So we need to mock the cached data.
+		f = new Formula(/** @type{string}*/(userInput), this._context);
+		this._rowData = null;
+	}
+
+	f.addEventListener("dataCacheChanged", this._dispatch.bind(this, "dataChanged"));
+	f.addEventListener("dataRequired", this._dispatch.bind(this, "dataRequired"));
+	f.addEventListener("formulaChanged", this._dispatch.bind(this, "formulaChanged"));
+	this._formulas.push(f); // The one in the back will be executed last
+	return f;
+};
+/** @public
+* @ignore
+* @param {Formula|string} userInput
+* @return {!Formula}
+*/
+Engine.prototype.mockFormula = function(userInput) {
+	var f;
+	if(userInput instanceof Formula){
+		f = new Formula(userInput.getInput(), this._context);
+	} else {
+		f = new Formula(/** @type{string}*/(userInput), this._context);
+	}
+
+	return f;
+};
+/** @public
+* @param {Formula|string|number=} ref
+* @return {Formula}
+*/
+Engine.prototype.removeFormula = function(ref) {
+	if(ref instanceof Formula) { // Convert Formula to index
+		ref = this._formulas.indexOf(/** @type{Formula} */(ref));
+	}
+
+	var f;
+	if(typeof ref === "number") {
+		f = this._formulas[ref];
+		if(f) {
+			this._formulas.splice(ref, 1);
+			if(f.getReference()) {
+				delete this._formulaMap[f.getReference()];
+				delete this._referenceMap[f.getReference()];
+			}
+			f.dispose();
+		}
+	} else if (typeof ref === "string") {
+		f = this._formulaMap[ref];
+		if(f) {
+			var at = this._formulas.indexOf(f);
+			if(at >= 0) {
+				this._formulas.splice(at, 1);
+				delete this._formulaMap[ref];
+				delete this._referenceMap[ref];
+			}
+			f.dispose();
+		}
+	}
+
+	return f || null;
+};
+/** @public
+*/
+Engine.prototype.removeAllFormulas = function() {
+	var formulas = this._formulas;
+	for(var i = formulas.length; --i >= 0;) {
+		delete this._referenceMap[formulas[i].getReference()];
+	}
+
+	this._formulas.length = 0;
+	this._formulaMap = {};
+};
+
+/** @public
+* @param {string|number} opt_ref Index (number) or formula reference (string)
+* @return {Formula}
+*/
+Engine.prototype.getFormula = function(opt_ref) {
+	var f;
+	if(typeof opt_ref === "number") {
+		f = this._formulas[opt_ref];
+	} else {
+		f = this._formulaMap[opt_ref];
+	}
+	return f || null;
+};
+/** @public
+* @param {string} exp E.g "CF_BID + CF_ASK"
+* @return {Formula}
+*/
+Engine.prototype.getFormulaByExpression = function(exp) {
+	var len = this._formulas.length;
+	for(var i = 0; i < len; ++i) {
+		var f = this._formulas[i];
+		if(f.getInput() === exp) {
+			return f;
+		}
+	}
+	return null;
+};
+/** @public
+* @return {Array.<Formula>}
+*/
+Engine.prototype.getAllFormulas = function() {
+	return this._formulas;
+};
+/** @public
+* @return {Object.<string, string>}
+*/
+Engine.prototype.getAllFormulaReferences = function() {
+	return this._referenceMap;
+};
+/** @public
+* @return {number}
+*/
+Engine.prototype.getFormulaCount = function() {
+	return this._formulas.length;
+};
+/** @private
+ * @param {string} ref
+ * @return {string}
+ */
+Engine.prototype._generateUniqueReference = function(ref) {
+	var uniRef = ref;
+	var index = 0;
+	while(this._referenceMap[uniRef] != null) {
+		uniRef = ref + "_" + ++index;
+	}
+	return uniRef;
+};
+/** @public
+ * @param {string|Formula} src
+ * @param {string} ref
+ * @return {string}
+ */
+Engine.prototype.addReference = function(src, ref) {
+	if (!src || !ref) {
+		return "";
+	}
+	ref = this._generateUniqueReference(ref);
+	var colName = "";
+	if (src instanceof Formula) {
+		var res = this._setFormulaReference(src, ref);
+		if (!res) {
+			return "";
+		}
+		colName = src.getAlias();
+	} else {
+		colName = /** @type{string} */(src);
+	}
+	this._referenceMap[ref] = colName;
+	return ref;
+};
+/** @public
+ * @param {string} oldRef
+ * @param {string} newRef
+ * @return {boolean}
+ */
+Engine.prototype.renameReference = function(oldRef, newRef) {
+	if (!newRef) {
+		return this.removeReference(oldRef);
+	}
+	if (!oldRef || this._referenceMap[oldRef] == null || oldRef === newRef) {
+		return false;
+	}
+	var f = this._formulaMap[oldRef];
+	if (f && !this.isValidReference(f, newRef)) {
+		return false;
+	}
+
+	// Change the reference being used in all formulas
+	for (var i = this._formulas.length; --i >= 0;) {
+		var formula = this._formulas[i];
+		if (formula.changeField(oldRef, newRef)) {
+			var ref = formula.getReference();
+			if (ref) {
+				this._referenceMap[ref] = formula.getAlias();
+			}
+		}
+	}
+
+	if (f) {
+		this._setFormulaReference(f, newRef);
+	}
+
+	this._referenceMap[newRef] = this._referenceMap[oldRef];
+	delete this._referenceMap[oldRef];
+	return true;
+};
+/** @public
+ * @param {string} ref
+ * @return {boolean}
+ */
+Engine.prototype.removeReference = function(ref) {
+	if (!ref || this._referenceMap[ref] == null) {
+		return false;
+	}
+	var f = this._formulaMap[ref];
+	if (f != null) {
+		f._setReference("");
+		delete this._formulaMap[ref];
+	}
+	delete this._referenceMap[ref];
+	return true;
+};
+/** @public
+ * @param {string} refName
+ * @return {string}
+ */
+Engine.prototype.resolveReference = function(refName) {
+	return this._referenceMap[refName] || refName;
+};
+
+/** Get value from cached row data
+ *  @private
+ * @param {string} refName
+ * @param {Object.<string, *>} rowData WARNING: This param will not be used!
+ * @return {*}
+ */
+Engine.prototype._getData = function(refName, rowData) {
+	//  TODO: Assign default value based on refName in case of non existing data
+	if (!this._rowData) {
+		return null;
+	}
+	var value = this._rowData[this.resolveReference(refName)];
+
+	if (value) {
+		var num = Number(value);
+
+		if (num === num) { // Convert text to number for formula calculation
+			value = num;
+		}
+	}
+
+	return value;
+};
+/** @private
+* @param {Formula} formula
+* @param {string} ref
+* @return {boolean}
+*/
+Engine.prototype._setFormulaReference = function(formula, ref) {
+	if(this._formulaMap[ref]) {
+		console.warn("Duplicate formula reference detected.");
+		return false;
+	}
+	var prevRef = formula.getReference();
+	if(prevRef === ref) {
+		return false;
+	}
+
+	if(ref) { // Empty string is no need to be in formula map
+		this._formulaMap[ref] = formula;
+	}
+	formula._setReference(ref);
+	var dependencies = this._sortDependencies(this._formulas, this._formulaMap);
+	if (!dependencies) { // Circular dependencies detected
+		formula._setReference(prevRef);
+		delete this._formulaMap[ref];
+		return false;
+	}
+
+	// Conclude
+	this._formulas = dependencies;
+
+	delete this._formulaMap[prevRef]; // Delete old reference of formula
+	return true;
+};
+/** @public
+* @param {Object.<string, *>} rowData
+* @param {Object.<string, *>=} opt_changes
+*/
+Engine.prototype.calculate = function(rowData, opt_changes) {
+	this._rowData = rowData; // Cache for resolving reference
+
+	var len =  this._formulas.length;
+	for(var i = 0; i < len; ++i) { // This must be done in normal order
+		var f = this._formulas[i];
+		// if opt_changes is undefined then recalculate all function
+		// if opt_changes is exist then check formula need to recalculate
+		if (opt_changes) {
+			// Don't recalculate formula if fields are not changed and not update from realtime formula
+			var needRecalculate = (opt_changes[f.getAlias()] != null); // Update from realtime formula
+			if (!needRecalculate) {
+				var fields = f.getFieldNames();
+				for (var j = fields.length; --j >= 0;) {
+					if (opt_changes[this.resolveReference(fields[j])] != null) {
+						needRecalculate = true;
+						break;
+					}
+				}
+				if (!needRecalculate) {
+					continue;
+				}
+			}
+		}
+
+		var result = f.calculate(rowData);
+		this._setData(f, result, rowData, opt_changes);
+	}
+
+	this._rowData = null;
+};
+
+/**
+ * @public
+ * @param {Formula} formula
+ * @param {string} ref
+ * @return {boolean}
+ */
+Engine.prototype.isValidReference = function(formula, ref) {
+	if(!ref) {
+		return true;
+	}
+	if(this._referenceMap[ref]) {
+		return false; // duplicate reference detected.
+	}
+
+	var prevRef = formula.getReference();
+	var parentChildrenMap = this._createParentChildrenMap(this._formulas);
+
+	// Replace the old reference with new reference
+	if (prevRef) {
+		delete parentChildrenMap[prevRef];
+		for (var parent in parentChildrenMap) {
+			var children = parentChildrenMap[parent];
+			var index = children.indexOf(prevRef);
+			if (index !== -1) {
+				children = children.slice(0); // Clone. The orignal children is an array in formula object. We should not modify it.
+				children.splice(index, 1);
+				index = children.indexOf(ref);
+				if (index === -1) {
+					children.push(ref);
+				}
+				parentChildrenMap[parent] = children;
+			}
+		}
+	}
+	parentChildrenMap[ref] = formula.getFieldNames();
+
+	return (!!this._sortParentChildrenMap(parentChildrenMap));
+};
+
+/** @private
+ * @param {Array.<Formula>} formulas
+ * @param {Object.<string, Formula>} formulaMap	Contains all initial formulas in a map form
+ * @return {Array.<Formula>}
+ */
+Engine.prototype._sortDependencies = function(formulas, formulaMap) {
+	var formulaCount = formulas.length;
+	if (formulaCount === 1) {
+		return formulas;
+	}
+
+	var parentChildrenMap = this._createParentChildrenMap(formulas);
+	var sortedParents = this._sortParentChildrenMap(parentChildrenMap);
+	if (!sortedParents) {
+		return null;
+	}
+
+	var noDepFormulas = formulas.filter(function(f) {
+		return (!f.getReference());
+	});
+
+	var results = [];
+	if (formulaMap) {
+		for(var i = sortedParents.length; --i >= 0;) {
+			var f = formulaMap[sortedParents[i]];
+			if(f) {
+				results.push(f); // The one in the back will be executed last
+			}
+		}
+		if(noDepFormulas.length > 0) {
+			results = results.concat(noDepFormulas);
+		}
+	}
+	return results;
+};
+
+/**
+ * @private
+ * @param {Array.<Formula>} formulas
+ * @return {Object.<string, Array.<string>>}
+ */
+Engine.prototype._createParentChildrenMap = function(formulas) {
+	var i, parentChildrenMap = {};
+	for (i = formulas.length; --i >= 0;) {
+		var f = formulas[i];
+		var ref = f.getReference();
+		if (ref) {
+			parentChildrenMap[ref] = f.getFieldNames();
+		}
+	}
+	return parentChildrenMap;
+};
+
+/** @description https://en.wikipedia.org/wiki/Topological_sorting
+ * @private
+ * @param {Object.<string, Array.<string>>} ParentChildrenMap
+ * @return {Array.<string>}
+ */
+Engine.prototype._sortParentChildrenMap = function(ParentChildrenMap) {
+	var edges = {};
+	var i, child, children, childCount;
+	var parent;
+	for (parent in ParentChildrenMap) {
+		children = ParentChildrenMap[parent];
+		childCount = children.length;
+		for(var j = 0; j < childCount; ++j) {
+			child = children[j];
+			edges[child] = (edges[child] + 1) || 1;
+		}
+	}
+
+	// Collect nodes with no edge (root nodes)
+	var rootNodes = [];
+	for(parent in ParentChildrenMap) {
+		if(!edges[parent]) {
+			rootNodes.push(parent);
+		}
+	}
+
+	// Navigate from root nodes down to all the leaf nodes
+	var sortedParents = [];
+	while(rootNodes.length > 0) {
+		parent = rootNodes.shift();
+		sortedParents.push(parent);
+
+		children = ParentChildrenMap[parent];
+		childCount = (children) ? children.length : 0;
+		for(i = 0; i < childCount; ++i) {
+			child = children[i];
+			if(!(--edges[child] > 0)) {
+				rootNodes.push(child); // This child has no more edge; and hence, it becomes root node
+			}
+		}
+	}
+
+	// Check for circular reference
+	for(child in edges) {
+		if(edges[child]) {
+			return null;
+		}
+	}
+
+	return sortedParents;
+};
+
+Engine._proto = Engine.prototype;
+
+export default Engine;
+export { Engine };

package/lib/tr-grid-util/es6/formula/Formula.d.ts

@@ -0,0 +1,68 @@
+import Ext from "../Ext.js";
+import VariableToken from "./VariableToken.js";
+import EventDispatcher from "../EventDispatcher.js";
+
+declare class Formula extends EventDispatcher {
+
+    constructor(expression?: string, context?: any);
+
+    public static readonly _isBoundFormula: { [key: string]:  boolean };
+
+    public dispose(): void;
+
+    public calculate(rowData: { [key: string]:  any }): any;
+
+    public getFunction(): ((...params: any[]) => any);
+
+    public getFieldNames(): (string)[];
+
+    public getReference(): string;
+
+    public getExpression(): string;
+
+    public toString(): string;
+
+    public getInput(): string;
+
+    public getAlias(): string;
+
+    public setAlias(str: string): void;
+
+    public addFormulaCount(): void;
+
+    public subtractFormulaCount(): boolean;
+
+    public updateContext(): void;
+
+    public static toUpperCase(exp: string): string;
+
+    public static resolveTokens(exp: string, tokens: (VariableToken)[], calcHierarchy: (number)[][]): string;
+
+    public addField(field: string, opt_src?: string): boolean;
+
+    public changeField(oldName: string, newName: string): boolean;
+
+    public changeFields(oldNames: (string)[], newNames: (string)[]): boolean;
+
+    public getRealtimeService(): any;
+
+    public setRealtimeService(rtService: any): void;
+
+    public getIntervalService(funcName: string): any;
+
+    public setIntervalService(funcName: string, newService: any): void;
+
+    public getCachedData(symbol: string): any;
+
+    public setCachedData(symbol: string, values: { [key: string]: any }): void;
+
+    public setDataError(msg: string): void;
+
+    public dispatchDataChanged(e?: any): void;
+
+    public _onDataCacheChanged(e: any): void;
+
+}
+
+export default Formula;
+export { Formula };