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

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

@@ -0,0 +1,890 @@
+import Ext from "../Ext.js";
+import VariableToken from "./VariableToken.js";
+import EventDispatcher from "../EventDispatcher.js";
+
+/** Trigger when data within the realtime formula has been changed
+* @event Formula#dataCacheChanged
+*/
+
+/** @constructor
+* @extends {EventDispatcher}
+* @param {string=} expression
+* @param {Object=} context
+*/
+let Formula = function(expression, context) {
+	this._input = expression || "";
+	if(context != null) {
+		this._context = context;
+		if (context["_DATA"]) { // _DATA is an internal context used for getting cached data
+			this["__D"] = context["_DATA"];
+		}
+	}
+	this["__F"] = [];
+	this._fnTokens = [];
+	this._fields = [];
+	this._fieldMap = {};
+	this._dataCache = {};
+	this._intervalServices = {};
+	this._formulaCount = 1; // Initial count
+	// this._addEvent("dataCacheChanged");
+	// this._addEvent("dataRequired");
+	// this._addEvent("formulaChanged");
+	this._onDataCacheChanged = this._onDataCacheChanged.bind(this);
+	this.dispatchDataChanged = this.dispatchDataChanged.bind(this);
+
+	this._parse(this._input);
+};
+Ext.inherits(Formula, EventDispatcher);
+
+/** @type {Object.<string, boolean>}
+* @const
+* @public
+*/
+Formula._isBoundFormula = {
+	"RECORD": true,
+	"TR": true,
+	"MTXSERIES": true,
+	"NOW": true,
+	"TODAY": true,
+	// Adfin - StylesFunction
+	"ADSTYLEATTRIBUTE": true,
+	// Adfin - BdFunction
+	"ADBONDDERIV": true,
+	"ADBONDYIELD": true,
+	"BDSETTLE": true,
+	"ACCRUED": true,
+	// Adfin - CfFunction
+	"CFYLD": true,
+	// Adfin - DfFunction
+	"DFFORMATDATE": true,
+	"DFADDPERIOD": true,
+	"DFADDWD": true,
+	"DFADDMONTHS": true,
+	"DFADDYEARS": true,
+	"DFADJUSTTOWD": true,
+	"DFLASTWD": true,
+	"DFFINDDATED": true,
+	"DFCOUNTDAYS": true,
+	"DFCOUNTWD": true,
+	// Adfin - FxFunction
+	"ADFXSWPTODEP": true,
+	"FXCALCPERIOD": true,
+	// Adfin - OpFunction
+	"OPCALCDERIV": true,
+	"OPIMPLIEDVOL": true,
+	// Adfin - UtFunction
+	"ADFORMAT": true,
+	"ADHISTORYVALUE": true
+
+
+};
+/** @private
+* @type {string}
+*/
+Formula.prototype._input = ""; // Initial user input
+/** @private
+* @type {string}
+*/
+Formula.prototype._expression = ""; // Evaluated expression
+/** @private
+* @type {string}
+*/
+Formula.prototype._alias = ""; // Alias name of formula
+/** @private
+* @type {Function}
+*/
+Formula.prototype._main = null; // Function resulted from resolving an expression
+
+/** @private
+* @type {Array.<Function>}
+*/
+Formula.prototype["__F"] = null; // Sub-methods that is used by this formula
+/** @private
+* @type {Array.<VariableToken>}
+*/
+Formula.prototype._fnTokens = null; // Sub-methods meta-data
+/** @private
+* @type {Array.<string>}
+*/
+Formula.prototype._fields = null; // Required field names from the expression
+/** @private
+* @type {Object.<string, boolean>}
+*/
+Formula.prototype._fieldMap = null; // Required field names from the expression
+
+/** @private
+* @type {string}
+*/
+Formula.prototype._reference = "";
+
+/** @private
+* @type {Object.<string, Function>}
+*/
+Formula.prototype._context = null;
+
+/** @private
+* @type {*}
+*/
+Formula.prototype._rtService = null;
+
+/** @private
+* @type {Object.<string, *>}
+*/
+Formula.prototype._intervalServices = null;
+
+/** @private
+* @type {Object.<string, *>}
+*/
+Formula.prototype._dataCache = null;
+
+/** @private
+* @type {string}
+*/
+Formula.prototype._dataLastError = "";
+
+/** @private
+* @type {string}
+*/
+Formula.prototype._inputWithTokenField = "";
+
+/** @private
+* @type {number}
+*/
+Formula.prototype._formulaCount = 0;
+
+/** @private
+* @type {Object.<string, Function>}
+*/
+Formula._invalidOps = {
+	"+=": true,
+	"-=": true,
+	"*=": true,
+	"/=": true,
+	"|=": true,
+	"&=": true,
+	"^=": true
+};
+
+/** @public
+*/
+Formula.prototype.dispose = function() {
+	if(this._rtService) {
+		this._rtService["dispose"]();
+		this._rtService = null;
+	}
+	for(let serviceName in this._intervalServices) {
+		// No need to dispose the static object
+		this._intervalServices[serviceName]["removeEventListener"]("dataChanged", this.dispatchDataChanged);
+	}
+	this._intervalServices = null;
+	this.unlistenAll();
+};
+
+/** @public
+* @param {Object.<string, *>} rowData
+* @return {*}
+*/
+Formula.prototype.calculate = function(rowData) {
+	if (this._main) {
+		this._dataLastError = ""; // Clear last realtime error message
+		let res = this._main(rowData);
+		switch(this._dataLastError) {
+		case "Pending data":		// Don't show data if realtime data is still pending
+			res = null;
+			break;
+		case "Pending - no erase":
+			res = "...";			// Data update is pending - do not erase previous value
+			break;
+		}
+		return res;
+	}
+	return null;
+};
+
+/** Function resulted from resolving an expression
+* @public
+* @return {Function} Returns function that takes an JSON object as a parameter. Return null if function is not valid JavaScript codes.
+*/
+Formula.prototype.getFunction = function() { return this._main; };
+/** @public
+* @return {Array.<string>}
+*/
+Formula.prototype.getFieldNames = function() { return this._fields; };
+
+/** For internal use only
+* @public
+* @ignore
+* @param {string} str
+*/
+Formula.prototype._setReference = function(str) {
+	this._reference = str;
+};
+/** @public
+* @return {string}
+*/
+Formula.prototype.getReference = function() {
+	return this._reference;
+};
+
+/** Evaluated expression
+* @public
+* @return {string}
+*/
+Formula.prototype.getExpression = function() {
+	return this._expression;
+};
+/** @public
+* @function
+* @return {string}
+*/
+Formula.prototype.toString = Formula.prototype.getReference;
+
+/** Initial user input
+* @public
+* @return {string}
+*/
+Formula.prototype.getInput = function() { return this._input; };
+
+/** Get alias name of formula. If alias does not exist, user input is returned instead
+* @public
+* @return {string}
+*/
+Formula.prototype.getAlias = function() { return this._alias || this._input; };
+/** Set alias name of formula
+* @public
+* @param {string} str
+*/
+Formula.prototype.setAlias = function(str) {
+	this._alias = str;
+};
+/** Add formula count
+* @public
+*/
+Formula.prototype.addFormulaCount = function() {
+	this._formulaCount++;
+};
+/** Subtract formula count. Return true if formula count is zero.
+* @public
+* @return {boolean}
+*/
+Formula.prototype.subtractFormulaCount = function() {
+	return --this._formulaCount === 0;
+};
+
+/** @public
+*/
+Formula.prototype.updateContext = function() {
+	if(!this._context) { return; }
+
+	let len = this._fnTokens.length;
+	for(let i = 0; i < len; ++i) {
+		let fname = this._fnTokens[i].getFunctionName();
+		this["__F"][i] = this._context[fname] || Formula._emptyFunction;
+		if (Formula._isBoundFormula[fname]) {
+			this["__F"][i] = this["__F"][i].bind(this);
+		}
+		//this.__F[i] = this._logger.bind(this, i);
+	}
+};
+
+/** @private
+* @param {number} index
+*/
+Formula.prototype._logger = function(index) {
+	console.log("[" + index + "] " + this._fnTokens[index].getFunctionName() + " is executed" );
+};
+/** @private
+*/
+Formula._emptyFunction = function() {};
+
+/** @private
+* @param {string} str
+* @return {boolean}
+*/
+Formula.prototype._detectCodeInjection = function(str) {
+	let injection = false;
+
+	if(str.match(/\+\+|--/)) { // ++ and -- which modifies current variable is not allowed
+		injection = true;
+	}
+
+	if(!injection) {
+		let matches = str.match(/([^=]=+)/g) || [];
+		for (let i = matches.length; --i >= 0;) {
+			let m = matches[i];
+			let lastTwoChars = m.substring(m.length - 2);
+			if (Formula._invalidOps[lastTwoChars]) {
+				injection = true;
+				break;
+			}
+		}
+	}
+
+	// if(injection) {
+	// console.log("WARNING: Code injection detected");
+	// }
+
+	return injection;
+};
+/** Upper case only formula expression. All other cases are ignored
+* @public
+* @param {string} exp
+* @return {string}
+*/
+Formula.toUpperCase = function(exp) {
+	if(!exp || exp.charAt(0) !== "=") { //Prevent impacting to UDIP search field
+		return exp || "";
+	}
+
+	let tokens = [];
+	let calcHierarchy = [];
+
+	// Tokenize string constants first because they has enclosure (single quotes and double quotes)
+	exp = Formula.tokenizeQuotes(exp, tokens, calcHierarchy);
+
+	exp = exp.toUpperCase(); // Upper case the remaining
+
+	// May have the new string token from ADC field with parameter
+	// Regex for adc fileds
+	// TR 				: start with tr
+	// (\.[\w]+)+ 		: dot follow by any character at least 1
+	// \( 				: start parentheses
+	// [^\(\)]* 		: any except parentheses
+	// \) 				: end parentheses
+	// (\.[a-zA-Z]+)* 	: dot follow by any character (optional)
+
+	exp = exp.replace(/TR(\.[\w ]+)+\([^\(\)]*\)(\.[a-zA-Z]+)*/g, Formula._encloseWithTR);
+
+	exp = Formula.resolveTokens(exp, tokens, calcHierarchy); // Restore the string
+
+	return exp;
+};
+/** @description Wrap TR function to ADC field with parameter e.g.
+* TR.Revenue(Scale=2)
+* TR.Revenue(Scale=2).calcdate,
+* TR.Revenue(Period=FY0,Scale=2)
+* @private
+* @param {string} adcField
+* @return {string}
+*/
+Formula._encloseWithTR = function(adcField) {
+	return "TR(\"" + adcField + "\")";
+};
+/** @public
+* @ignore
+* @param {string} exp
+* @param {Array.<VariableToken>=} tokens
+* @param {Array.<Array.<number>>=} calcHierarchy
+* @return {string}
+*/
+Formula.tokenizeQuotes = function(exp, tokens, calcHierarchy) {
+	if(!tokens) {
+		tokens = [];
+	}
+	if(!calcHierarchy) {
+		calcHierarchy = [];
+	}
+
+	let index;
+	let matched = false;
+	let tokenIndices = [];
+	do {
+		matched = false;
+		exp = exp.replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, function(str) { // eslint-disable-line
+			matched = true;
+			index = tokens.length;
+			tokens.push(new VariableToken(str, index));
+			tokenIndices.push(index);
+			return "♦" + index + "♦";
+		});
+	} while(matched);
+	calcHierarchy.push(tokenIndices);
+	return exp;
+};
+/** @public
+* @ignore
+* @param {string} exp
+* @param {Array.<VariableToken>=} tokens
+* @param {Array.<Array.<number>>=} calcHierarchy
+* @return {string}
+*/
+Formula.tokenizeAdcWithParams = function(exp, tokens, calcHierarchy) {
+	if(!tokens) {
+		tokens = [];
+	}
+	if(!calcHierarchy) {
+		calcHierarchy = [];
+	}
+
+	let index;
+	let matched = false;
+	let tokenIndices = [];
+	do {
+		matched = false;
+		exp = exp.replace(/TR\.\w+\([^\)]*\)+/g, function(str) { // eslint-disable-line
+			matched = true;
+			index = tokens.length;
+			tokens.push(new VariableToken(str, index));
+			tokenIndices.push(index);
+			return "♦" + index + "♦";
+		});
+	} while(matched);
+	calcHierarchy.push(tokenIndices);
+	return exp;
+};
+/** @public
+* @ignore
+* @param {string} exp
+* @param {Array.<VariableToken>=} tokens
+* @param {Array.<Array.<number>>=} calcHierarchy
+* @return {string}
+*/
+Formula.replaceUnwantedCharacters = function(exp, tokens, calcHierarchy) {
+	// Replace all double spaces with single space
+	while(exp.indexOf("  ") >= 0) {
+		exp = exp.replace(/ {2}/g, " ");
+	}
+
+	// Remove all dollar signs (e.g. $CF_BID + $CF_ASK)
+	exp = exp.replace(/\$/g, "");
+
+	// Replace single ampersand with plus sign to support string concatenation with ampersand
+	exp = exp.replace(/\&+/g, function(str) {
+		if(str === "&") {
+			return "+";
+		}
+		return str;
+	});
+
+	/**
+	 * Replace all assignment operator with equality operator, by using
+	 * regular expression for detecting only "=" that is not a starting point of a formula,
+	 * so the character "=" is not replaced with "==" during conversion.
+	 *
+	 * @example
+	 * =ABS(COL5+COL6) -> =ABS(COL5+COL6)
+	 * =(COL5=COL6)    -> =(COL5==COL6)
+	 */
+	exp = exp.replace(/(<=|>=|!=|!==|===|==|=(?!([\w]*\([^()]*\))))/g, function(m) {
+		if (m === "=") {
+			return "==";
+		}
+
+		return m;
+	});
+
+	return exp;
+};
+/** @private
+* @param {string} exp
+* @param {Array.<VariableToken>=} tokens
+* @param {Array.<Array.<number>>=} calcHierarchy
+* @return {string}
+*/
+Formula.prototype._tokenizeParentheses = function(exp, tokens, calcHierarchy) {
+	if (!tokens) {
+		tokens = [];
+	}
+
+	if(!calcHierarchy) {
+		calcHierarchy = [];
+	}
+
+	let fnStrToIndex = {}; // To avoid duplicate function
+
+	/**
+	 * It is better to not duplicate content of regular expressions to avoid any possible typos
+	 * or discrepancies.
+	 * Therefore we copy existing regular expression and assign new flags to it instead.
+	 */
+	let firstMatchRE = /[\w._]*(?:=|=[\w]*)?\([^()]*\)/;
+	let globalRE = new RegExp(firstMatchRE.source, 'g');
+
+	while (exp.match(firstMatchRE)) {
+		let tokenIndices = [];
+
+		exp = exp.replace(globalRE, function (fnStr, group) { // eslint-disable-line
+			// Remove the first equal sign.
+			if (fnStr.charAt(0) === "=") {
+				fnStr = fnStr.substr(1, fnStr.length);
+			}
+
+			let index = fnStrToIndex[fnStr];
+
+			if (index == null) {
+				index = tokens.length;
+				tokens.push(new VariableToken(fnStr, index));
+				fnStrToIndex[fnStr] = index;
+			}
+
+			tokenIndices.push(index);
+
+			return "♦" + index + "♦";
+		});
+
+		calcHierarchy.push(tokenIndices);
+	}
+
+	return exp;
+};
+/** @private
+* @param {string} exp
+* @param {Array.<VariableToken>=} tokens
+* @param {Array.<Array.<number>>=} calcHierarchy
+* @return {string}
+*/
+Formula.prototype._tokenizeConstants = function(exp, tokens, calcHierarchy) {
+	if(!tokens) {
+		tokens = [];
+	}
+	if(!calcHierarchy) {
+		calcHierarchy = [];
+	}
+
+	let tokenIndices = [];
+	exp = exp.replace(/[\w._♦]+/g, function(varStr) {
+		if (varStr.charAt(0) === "♦") {
+			return varStr;
+		}
+		let index = tokens.length;
+		tokens.push(new VariableToken(varStr, index));
+		tokenIndices.push(index);
+		return "♦" + index + "♦";
+	});
+	calcHierarchy.push(tokenIndices);
+	return exp;
+};
+/** @public
+* @param {string} exp
+* @param {Array.<VariableToken>} tokens
+* @param {Array.<Array.<number>>} calcHierarchy
+* @return {string}
+*/
+Formula.resolveTokens = function(exp, tokens, calcHierarchy) {
+	for(let i = calcHierarchy.length; --i >= 0;) { // Must be done in reverse order
+		let indices = calcHierarchy[i];
+		let len = indices.length;
+		for(let j = 0; j < len; ++j) {
+			let index = indices[j];
+			let token = tokens[index];
+			exp = exp.replace(new RegExp("♦" + index + "♦", "g"), function() { // eslint-disable-line
+				return token.getExpression();
+			});
+		}
+	}
+	return exp;
+};
+
+/** @private
+* @param {string} exp
+* @param {Array.<VariableToken>} tokens
+* @param {Array.<Array.<number>>} calcHierarchy
+* @return {string}
+*/
+Formula._getInputWithTokenField = function(exp, tokens, calcHierarchy) {
+	for(let i = calcHierarchy.length; --i >= 0;) { // Must be done in reverse order
+		let indices = calcHierarchy[i];
+		let len = indices.length;
+		for(let j = 0; j < len; ++j) {
+			let index = indices[j];
+			let token = tokens[index];
+			exp = exp.replace(new RegExp("♦" + index + "♦", "g"), function() { // eslint-disable-line
+				return token.getInputWithTokenField();
+			});
+		}
+	}
+	return "=" + exp;
+};
+
+/** @private
+* @param {string} exp
+* @return {Function}
+*/
+Formula.prototype._parse = function(exp) {
+	this._expression = "";
+	this._main = null;
+
+	this["__F"].length = 0;
+	this._fnTokens.length = 0;
+	this._fields.length = 0;
+
+	if(!exp) { return null; }
+
+	if(exp.charAt(0) === "=") { // Remove the first equal sign
+		exp = exp.substr(1);
+	}
+	exp = exp.trim();
+	exp = exp.replace(/<>/g, "!=");
+	exp = exp.replace(/‛|‘|’/g, "'"); // Left and right single quote will be converted to simple single quote
+	exp = exp.replace(/‟|“|”/g, '"'); // Left and right double quote will be converted to simple double quote
+
+	if(!exp || this._detectCodeInjection(exp)) { return null; }
+
+	let tokens = [];
+	let calcHierarchy = [];
+
+	exp = Formula.tokenizeQuotes(exp, tokens, calcHierarchy); // Tokenize string constants first because they has enclosure (single quotes and double quotes)
+
+	exp = Formula.tokenizeAdcWithParams(exp, tokens, calcHierarchy);
+
+	exp = Formula.replaceUnwantedCharacters(exp, tokens, calcHierarchy);
+
+	exp = this._tokenizeParentheses(exp, tokens, calcHierarchy); // Tokenize all methods and parenthesis group
+
+	exp = this._tokenizeConstants(exp, tokens, calcHierarchy); // Tokenize the rest of the constants and dynamic values
+
+	// Used for change field name in formula
+	this._inputWithTokenField = Formula._getInputWithTokenField(exp, tokens, calcHierarchy);
+
+	// Resolve each function tokens into valid JavaScript codes
+	exp = Formula.resolveTokens(exp, tokens, calcHierarchy);
+
+	// Re-organize function structure and index, and retrieve field data
+	let fields = {};
+	let len = tokens.length;
+	for(let i = 0; i < len; ++i) {
+		let token = tokens[i];
+		if(token.getFunctionName()) {
+			let fIndex = this._fnTokens.length;
+			exp = exp.replace(new RegExp("this\\.__F\\[" + i + "\\]", "g"), "this.__F[" + fIndex + "]");
+			token.setIndex(fIndex);
+			this._fnTokens.push(token);
+		}
+		token.getFieldNames(fields);
+	}
+
+	this._expression = exp; // The expression has been finalized
+	this.updateContext();
+
+	this._main = this._createFunction(this._expression);
+	if(!this._main) {
+		return null;
+	}
+
+	this._fieldMap = fields;
+	this._fields = Object.keys(fields);
+	return this._main;
+};
+
+/** @private
+* @param {string} expression
+* @return {Function}
+*/
+Formula.prototype._createFunction = function (expression) {
+	let func = null;
+	try {
+		func = new Function("__R", "return " + expression + ";");
+		func = func.bind(this);
+		func({}); // Try to execute the method once to check error
+	} catch(err) {
+		func = null;
+		// window.console.log('Expression: "' + this._input + '" contains the following error: \n' + err.message);
+	}
+	return func;
+};
+
+/** @private
+* @param {string} colName
+* @param {Object.<string, *>} rowData
+* @return {*}
+*/
+Formula.prototype["__D"] = function (colName, rowData) {
+	return rowData[colName];
+};
+/** @public
+* @param {string} field
+* @param {string=} opt_src
+* @returns {boolean}
+*/
+Formula.prototype.addField = function(field, opt_src) {
+	if(this._fieldMap[field]) { // Existing in this._fields
+		return false;
+	}
+	if(field.indexOf("undefined") >= 0) { // We can remove this block if the ADC service can ignore the invalid requested field.
+		// REMARK: ADC cannot support the invalid parameter. It will respond with ERROR and do not return any ADC data anymore.
+		return false; // WORKAROUND: Field name must not contain with string 'undefined'
+	}
+
+	this._fields.push(field);
+	this._fieldMap[field] = true;
+	this._dispatch("dataRequired", { "field": field, "src": opt_src || "adc" });
+	return true;
+};
+
+/** Change field in formula
+* @public
+* @param {string} oldName
+* @param {string} newName
+* @return {boolean}
+*/
+Formula.prototype.changeField = function (oldName, newName) {
+	let index = this._fields.indexOf(oldName);
+	if (index < 0) {
+		return false;
+	}
+	this._fields.splice(index, 1);
+	if (this._fields.indexOf(newName) < 0) {
+		this._fields.push(newName);
+	}
+	let oldInput = this._input;
+	let oldTokenField = "♠" + oldName + "♥";
+	let newTokenField = "♠" + newName + "♥";
+	this._inputWithTokenField = this._inputWithTokenField.replace(new RegExp("♠[^♠]*♥", "g"), function(str) {
+		return (str === oldTokenField) ? newTokenField : str;
+	});
+	this._input = this._inputWithTokenField.replace(new RegExp("♠[^♠]*♥", "g"), function(str) {
+		return str.substr(1, str.length - 2); // Remove "♠" and "♥"
+	});
+	this._expression = this._expression.replace(new RegExp('this\\.__D\\("' + oldName + '", __R\\)', "g"), 'this.__D("' + newName + '", __R)');
+	this._main = this._createFunction(this._expression);
+	this._dispatch("formulaChanged", { "oldInput": oldInput, "formula": this });
+	return true;
+};
+/** Change multiple field in formula
+* @public
+* @param {Array.<string>} oldNames
+* @param {Array.<string>} newNames
+* @return {boolean}
+*/
+Formula.prototype.changeFields = function (oldNames, newNames) {
+	if(!Array.isArray(oldNames) || !Array.isArray(newNames)) {
+		return false;
+	}
+	if(oldNames.length !== newNames.length) {
+		return false;
+	}
+
+	let oldInput = this._input;
+	for(let i = oldNames.length; --i >= 0;) {
+		let oldName = oldNames[i];
+		let newName = newNames[i];
+
+		let index = this._fields.indexOf(oldName);
+		if (index < 0) {
+			continue;
+		}
+
+		this._fields.splice(index, 1);
+		if (this._fields.indexOf(newName) < 0) {
+			this._fields.push(newName);
+		}
+
+		let oldTokenField = "♠" + oldName + "♥";
+		let newTokenField = "♠" + newName + "♥";
+
+		this._inputWithTokenField = this._inputWithTokenField.replace(new RegExp("♠[^♠]*♥", "g"), function(str) { // eslint-disable-line
+			return (str === oldTokenField) ? newTokenField : str;
+		});
+		this._input = this._inputWithTokenField.replace(new RegExp("♠[^♠]*♥", "g"), function(str) { // eslint-disable-line
+			return str.substr(1, str.length - 2); // Remove "♠" and "♥"
+		});
+		this._expression = this._expression.replace(new RegExp('this\\.__D\\("' + oldName + '", __R\\)', "g"), 'this.__D("' + newName + '", __R)');
+	}
+
+	this._main = this._createFunction(this._expression);
+	this._dispatch("formulaChanged", { "oldInput": oldInput, "formula": this });
+	return true;
+};
+
+//#region Realtime service
+/** @public
+* @return {*}
+*/
+Formula.prototype.getRealtimeService = function() {
+	return this._rtService;
+};
+
+/** @public
+* @param {Object} rtService
+*/
+Formula.prototype.setRealtimeService = function(rtService) {
+	if (this._rtService) {
+		this._rtService["dispose"]();
+	}
+	this._rtService = rtService;
+	this._rtService["addEventListener"]("dataChanged", this._onDataCacheChanged);
+};
+//#endregion Realtime service
+
+//#region Interval service
+/** @public
+ * @param {string} funcName
+* @return {*}
+*/
+Formula.prototype.getIntervalService = function(funcName) {
+	return this._intervalServices[funcName];
+};
+
+/** @public
+* @param {string} funcName
+* @param {Object} newService
+*/
+Formula.prototype.setIntervalService = function(funcName, newService) {
+	if(!newService) {
+		return;
+	}
+
+	let service = this._intervalServices[funcName];
+	if (service) {
+		service["removeEventListener"]("dataChanged", this.dispatchDataChanged); // Service will stop only if no event listener anymore
+	}
+	this._intervalServices[funcName] = newService;
+	newService["addEventListener"]("dataChanged", this.dispatchDataChanged);
+};
+//#endregion Interval service
+
+//#region formula data cache
+/** @public
+ * @param {string} symbol
+* @return {*}
+*/
+Formula.prototype.getCachedData = function(symbol) {
+	return this._dataCache[symbol];
+};
+
+/** @public
+* @param {string} symbol
+* @param {Object.<string,*>} values
+*/
+Formula.prototype.setCachedData = function(symbol, values) {
+	this._dataCache[symbol] = values;
+};
+
+/** @public
+* @param {string} msg
+*/
+Formula.prototype.setDataError = function(msg) {
+	this._dataLastError = msg;
+};
+
+/** @public
+* @param {Object=} e
+*/
+Formula.prototype.dispatchDataChanged = function(e) {
+	// Just dispatch the event. No need to cache any data in formula.
+	this._dispatch("dataCacheChanged", {});
+};
+
+/** @public
+* @param {Object} e
+*/
+Formula.prototype._onDataCacheChanged = function(e) {
+	// Cache data for real-time function since real-time function has its own RIC list. Then dispatch the event.
+	let symbol = e['ric'];
+	let values = /** @type{Object.<string, *>} */(e['values']);
+	let data = this._dataCache[symbol];
+	if (data) {
+		for (let field in values) {
+			data[field] = values[field];
+		}
+	} else {
+		this._dataCache[symbol] = values;
+	}
+	this._dispatch("dataCacheChanged", {});
+};
+//#endregion formula data cache
+
+Formula._proto = Formula.prototype;
+
+export default Formula;
+export { Formula };