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

package/lib/tr-grid-util/es6/jet/MockQuotes2.js

@@ -0,0 +1,564 @@
+import {DataGenerator} from "./DataGenerator.js";
+import {CollectionDict} from "./CollectionDict.js";
+
+/** @private
+* @param {Object} subA
+* @param {Object} subB
+* @return {string}
+*/
+var _joinSubKeys = function(subA, subB) {
+	return subA.ric + "_" + subB.ric;
+};
+
+/** @constructor */
+var MockQuotes2 = function() {
+
+};
+
+/** @public
+* @param {Object=} options
+* @return {MockSubscriptions}
+*/
+MockQuotes2.prototype.create = function(options) {
+	return new MockSubscriptions(options);
+};
+
+/** @public
+* @return {boolean}
+*/
+MockQuotes2.prototype.isSkipHeaderSupported = function() {
+	return true;
+};
+
+
+/** @constructor
+* @param {Object=} options
+*/
+var MockSubscriptions = function(options) {
+	if(options) {
+		if(typeof options.minInterval === "number") {
+			this._minInterval = options.minInterval;
+			if(this._minInterval > this._maxInterval) {
+				this._maxInterval = this._minInterval;
+			}
+		}
+
+		if(typeof options.maxInterval === "number") {
+			this._maxInterval = options.maxInterval;
+			if(this._minInterval > this._maxInterval) {
+				this._minInterval = this._maxInterval;
+			}
+		}
+
+		if(typeof options.percentageDataUpdate === "number") {
+			this._percentageDataUpdate = options.percentageDataUpdate / 100;
+		}
+	}
+	this._onSubscriptionResponse = this._onSubscriptionResponse.bind(this);
+
+	this._subMap = {};
+	this._dataMap = new CollectionDict();
+	this._fields = {};
+	this._events = {};
+	this._dataGen = new DataGenerator();
+};
+
+/* @private
+* @type {number}
+*/
+MockSubscriptions.prototype._minInterval = 750;
+/* @private
+* @type {number}
+*/
+MockSubscriptions.prototype._maxInterval = 850;
+/* @private
+* @type {float}
+*/
+MockSubscriptions.prototype._percentageDataUpdate = 0.1; // 10% by default
+
+/** @public
+* @param {number=} min
+* @param {number=} max
+*/
+MockSubscriptions.prototype.setUpdateInterval = function(min, max) {
+	if(typeof min === "number") {
+		this._minInterval = min;
+	}
+
+	if(typeof max === "number") {
+		this._maxInterval = max;
+	}
+};
+/** @public
+* @param {number=} percent
+*/
+MockSubscriptions.prototype.setPercentageDataUpdate = function(percent) {
+	if(typeof percent === "number") {
+		this._percentageDataUpdate = Math.round(percent / 100);
+	}
+};
+
+/** @public
+* @param {number} seed
+*/
+MockSubscriptions.prototype.setSeed = function(seed) {
+	this._dataGen.setSeed(seed);
+};
+
+
+/** @public
+* @param {string} ric
+* @param {string=} subId
+* @return {string|null} subscription Id
+*/
+MockSubscriptions.prototype.addRic = function(ric, subId) {
+	return this._addSymbol(ric, false, subId);
+};
+/** @public
+* @param {string} ric
+* @param {string=} subId
+* @return {string|null} subscription Id
+*/
+MockSubscriptions.prototype.addChain = function(ric, subId) {
+	return this._addSymbol(ric, true, subId);
+};
+/** @public
+* @param {string|Array.<string>} fields
+*/
+MockSubscriptions.prototype.addFields = function(fields) {
+	if(!fields) { return; }
+
+	if(typeof fields === "string") {
+		fields = [fields];
+	}
+	var len = fields.length;
+	for(var i = 0; i < len; ++i) {
+		this._fields[fields[i]] = true;
+	}
+};
+
+/** @public
+* @param {string} subId
+*/
+MockSubscriptions.prototype.removeSubscription = function(subId) {
+	var sub = this._subMap[subId];
+	if(!sub) {
+		return;
+	}
+	this._dispatch("subscriptionRemoved", {"subs": [sub]});
+	delete this._subMap[subId];
+	this._dataMap.removeItem(sub["ric"], sub);
+	if(sub["chain"]) {
+		var children = sub["children"];
+		var len = children.length;
+		for(var i = 0; i < len; ++i) {
+			var child = children[i];
+			this._dataMap.removeItem(_joinSubKeys(sub, child), child);
+			child["parent"] = null;
+		}
+		sub["children"] = null;
+	}
+};
+/** @public
+* @function
+*/
+MockSubscriptions.prototype.removeRic = MockSubscriptions.prototype.removeSubscription;
+/** @public
+* @function
+*/
+MockSubscriptions.prototype.removeChain = MockSubscriptions.prototype.removeSubscription;
+/** @public */
+MockSubscriptions.prototype.removeAllSubscriptions = function() { // All channels will also be closed
+	var working = this._working;
+	this.stop();
+
+	if(this._hasListener("subscriptionRemoved")) {
+		var subs = [];
+		for(var subId in this._subMap) {
+			subs.push(this._subMap[subId]);
+		}
+		if(subs.length > 0) {
+			this._dispatch("subscriptionRemoved", {"subs": subs});
+		}
+	}
+
+	this._subMap = {};
+	this._dataMap.removeAllItems();
+	if(working) {
+		this.start();
+	}
+};
+
+/** @public
+* @param {string|Array.<string>} fields
+*/
+MockSubscriptions.prototype.removeFields = function(fields) {
+	if(typeof fields === "string") {
+		fields = [fields];
+	}
+	var len = fields.length;
+	for(var i = 0; i < len; ++i) {
+		var field = fields[i];
+		if(this._fields[field]) {
+			delete this._fields[field];
+		}
+	}
+};
+/** @public */
+MockSubscriptions.prototype.removeAllFields = function() {
+	var dirty = false;
+	for(var field in this._fields) { // eslint-disable-line no-unused-vars
+		dirty = true;
+		break;
+	}
+	if(!dirty) { return; }
+	this._fields = {};
+};
+
+/** @public */
+MockSubscriptions.prototype.start = function() {
+	this._working = true;
+	this._connect();
+};
+/** @public */
+MockSubscriptions.prototype.stop = function() {
+	this._working = false;
+	if(this._timerId >= 0) {
+		window.clearTimeout(this._timerId);
+		this._timerId = -1;
+	}
+};
+
+/** @public */
+MockSubscriptions.prototype.dispose = function() {
+	this.stop();
+
+	this._subMap = null;
+	if(this._dataMap) {
+		this._dataMap.removeAllItems();
+		this._dataMap = null;
+	}
+
+	this._fields = null;
+	this._events = null;
+};
+
+/** @public
+* @param {string} type
+* @param {Function} handler
+*/
+MockSubscriptions.prototype.addEventListener = function(type, handler) {
+	if(!handler) { return; }
+
+	var listeners = this._events[type];
+	if(listeners) {
+		if(listeners.indexOf(handler) < 0) {
+			listeners.push(handler);
+		}
+	} else {
+		this._events[type] = [handler];
+	}
+};
+/** @public
+* @param {string} type
+* @param {Function} handler
+*/
+MockSubscriptions.prototype.removeEventListener = function(type, handler) {
+	var listeners = (this._events) ? this._events[type] : null;
+	if(!listeners) { return; }
+
+	var at = listeners.indexOf(handler);
+	if(at >= 0) {
+		listeners.splice(at, 1);
+	}
+};
+/** @public */
+MockSubscriptions.prototype.removeAllEventListeners = function() {
+	this._events = {};
+};
+
+/** @public
+* @param {string} subId
+* @return {Object} subscription object
+*/
+MockSubscriptions.prototype.getSubscription = function(subId) {
+	return this._subMap[subId] || null;
+};
+/** @public
+* @param {string} subId
+* @return {string} string
+*/
+MockSubscriptions.prototype.getRic = function(subId) {
+	var sub = this._subMap[subId];
+	if(sub) {
+		return sub["ric"];
+	}
+	return "";
+};
+/** @public
+* @return {Object.<string, boolean>} field map
+*/
+MockSubscriptions.prototype.getAllFields = function() {
+	return this._fields;
+};
+/** @public
+* @param {string} field
+* @return {boolean}
+*/
+MockSubscriptions.prototype.hasField = function(field) {
+	return this._fields[field] || false;
+};
+/** @public
+* @param {number} start
+* @param {number} count
+* @return {MockSubscriptions}
+*/
+MockSubscriptions.prototype.filter = function (start, count) {
+	return this;
+};
+
+/** Object.assign is not available in IE. This method is equivalent to Object.assign(toObject, fromObject);
+* @private
+* @function
+* @param {Object} fromObj
+* @param {!Object} toObj
+* @return {!Object} Return toObj
+*/
+var copyValues = function(fromObj, toObj) {
+	for(var key in fromObj) {
+		toObj[key] = fromObj[key];
+	}
+	return toObj;
+};
+/** @private
+* @param {string} ric
+* @param {boolean} asChain
+* @param {(string|number)=} subId
+* @return {string|null} subscription id
+*/
+MockSubscriptions.prototype._addSymbol = function(ric, asChain, subId) {
+	if(!ric) { return null; }
+
+	if(!subId && subId !== 0) {
+		do {
+			subId = "_" + (this._runningSubId++) + "_";
+		} while(this._subMap[subId]);
+	} else {
+		subId += ""; // Convert to string
+	}
+	if(this._subMap[subId]) {
+		window.console.log("WARNING: Cannot add ric with duplicate id");
+		return null;
+	}
+
+	if(asChain) {
+		ric = ric.replace("0#", ""); // The receiver is not expecting 0# symbol
+	}
+	var sub = {};
+	sub["ric"] = ric;
+	sub["chain"] = asChain;
+	sub["id"] = subId;
+	sub["dataId"] = subId + sub["ric"];
+	this._subMap[subId] = sub; // Collect all user subscriptions
+	this._dataMap.addItem(sub["ric"], sub);
+	if(asChain) {
+		sub["children"] = [];
+		var childCount = MockSubscriptions.simpleDigest(ric) % 10 + 4;
+		for(var i = 0; i < childCount; ++i) {
+			// Note that constituents should have no subscription object. They should share the same subscription as their parent. Hence we does not register it to the _subMap
+			var childSub = {};
+			childSub["ric"] = "Child_" + String.fromCharCode(65 + i);
+			childSub["id"] = subId; // Child shares the same sub id as its chain parent
+			childSub["dataId"] = subId + childSub["ric"];
+			childSub["parent"] = sub; // This does not exist in real subscription
+			sub["children"].push(childSub);
+
+			this._dataMap.addItem(_joinSubKeys(sub, childSub), childSub);
+		}
+	}
+
+	this._dispatch("subscriptionAdded", {"subs": [sub]});
+
+	this._connect();
+	return subId;
+};
+/** @public
+* @param {string} str
+* @return {number}
+*/
+MockSubscriptions.simpleDigest = function(str) {
+	var len = str.length;
+	var sum = 0;
+	for(var i = 0; i < len; ++i) {
+		sum += str.charCodeAt(i);
+	}
+	return sum;
+};
+
+/** @private */
+MockSubscriptions.prototype._connect = function() {
+	if(!this._working || this._timerId >= 0) { return; }
+	var delay = this._dataGen.randInt(this._minInterval, this._maxInterval);
+	this._timerId = window.setTimeout(this._onSubscriptionResponse, delay);
+};
+
+/** @private */
+MockSubscriptions.prototype._onSubscriptionResponse = function() {
+	this._timerId = -1;
+
+	var keys = this._dataMap.getAllKeys(); // list of all rics
+	var len = keys ? keys.length : 0;
+	if(!len) { // No symbol has been added
+		this._connect();
+		return;
+	}
+
+	var minRow = (this._percentageDataUpdate - 0.02) * len;
+	minRow = minRow > 0 ? minRow : 1; // update at least 1 row
+	var maxRow = (this._percentageDataUpdate + 0.02) * len;
+	maxRow = maxRow < len ? maxRow : len; // not more than all rows
+	var numRows = this._dataGen.randInt(minRow, maxRow);
+
+	for(var i = 0; i < numRows; i++) {
+		var key = keys[this._dataGen.randIndex(len)]; // WARNING: Same sub could be picked more than once
+		var subs = this._dataMap.getItems(key);
+
+		var sub = subs[0];
+		var ric = sub.ric;
+		var prevData = sub.prevData;
+
+		var values = {};
+		var options = {
+			text: ric,
+			prefix: sub["parent"] ? sub["parent"]["ric"] : ""
+		};
+		for(var field in this._fields){
+			var data = this._dataGen.generateQuoteData(field, options);
+			if(prevData) {
+				if(data.changeOnly) {
+					if(prevData[field] === data.value) {
+						continue;
+					}
+				}
+				prevData[field] = data.value;
+			}
+
+			values[field] = data.value;
+			values[field + "_FORMATTED"] = data.formattedValue;
+		}
+
+		var jLen = subs.length;
+		for(var j = 0; j < jLen; ++j) {
+			this._dispatchDataChanged(subs[j], values);
+		}
+	}
+
+	this._connect();
+};
+/** @private
+* @param {Object} sub
+* @param {Object} dataUpdates
+*/
+MockSubscriptions.prototype._dispatchDataChanged = function(sub, dataUpdates) {
+	var values = copyValues(dataUpdates, {});
+	var evtArg = {};
+	evtArg["ric"] = sub["ric"];
+	evtArg["values"] = values;
+	evtArg["subId"] = sub["id"];
+
+	var prevData = sub.prevData; // For data generation on the next update
+	if(!prevData) {
+		prevData = {};
+		sub.prevData = prevData;
+		evtArg["type"] = "statusUpdated";
+
+		values["STATUS"] =  1;
+		values["STATUS_FORMATTED"] = this._statusMap["1"];
+		values["SUB_ID"] = sub["id"];
+		copyValues(values, prevData);
+	}
+	this._dispatch("dataChanged", evtArg);
+};
+
+/** @public
+* @param {Array.<string>} feedNames
+* @param {Function} handler
+* @return {MockSubscriptions}
+*/
+MockSubscriptions.prototype.onFeedStatusChanged = function(feedNames, handler) {
+	window.setTimeout(function() {
+		handler([{"key": "Q", "name": "IDN_RDF", "state": "up"}]);
+	}, 1000);
+	return this;
+};
+
+/** @private
+* @param {string} type
+* @return {boolean}
+*/
+MockSubscriptions.prototype._hasListener = function(type) {
+	var listeners = this._events[type];
+	return listeners ? (listeners.length > 0) : false;
+};
+/** @private
+* @param {string} type
+* @param {Object} eventArg
+*/
+MockSubscriptions.prototype._dispatch = function(type, eventArg) {
+	var listeners = this._events[type];
+	if(!listeners) { return; }
+	var len = listeners.length;
+	for(var i = 0; i < len; ++i) {
+		listeners[i](eventArg);
+	}
+};
+
+/** @type {Object.<string, Object>}
+* @private
+*/
+MockSubscriptions.prototype._subMap = null;
+/** @type {Object.<string, boolean>}
+* @private
+*/
+MockSubscriptions.prototype._fields = null;
+/** @type {Object.<string, Array.<Function>>}
+* @private
+*/
+MockSubscriptions.prototype._events = null;
+
+/** @type {boolean}
+* @private
+*/
+MockSubscriptions.prototype._working = false;
+/** @type {number}
+* @private
+*/
+MockSubscriptions.prototype._timerId = -1;
+
+/** @type {number}
+* @private
+*/
+MockSubscriptions.prototype._runningSubId = 0;
+
+/** @type {Object.<string, string>}
+* @private
+*/
+MockSubscriptions.prototype._statusMap = {
+	"0": "PENDING",
+	"1": "OK",
+	"2": "STALE",
+	"3": "INFO",
+	"4": "CLOSED",
+	"5": "DELAYED",
+	"6": "NOPERM",
+	"7": "REACHLIMIT",
+	"8": "C_COMPLETE",
+	"9": "C_CLOSE",
+	"10": "C_EMPTY",
+	"11": "C_NOTCHAIN",
+	"12": "C_ERR",
+	"13": "C_NOBEGIN",
+	"14": "C_NOEND"
+};
+
+export {MockQuotes2, MockSubscriptions};

package/lib/tr-grid-util/es6/jet/MockRTK.d.ts

@@ -0,0 +1,8 @@
+import { DataGrid, setInvalidFields } from "./mockDataAPI.js";
+import { MockQuotes2 } from "./MockQuotes2.js";
+import { cloneObject } from "../Util.js";
+
+declare function init(opt_obj?: any): MockRTK;
+
+export default MockRTK;
+export { MockRTK };

package/lib/tr-grid-util/es6/jet/MockRTK.js

@@ -0,0 +1,43 @@
+import { DataGrid, setInvalidFields } from "./mockDataAPI.js";
+import { MockQuotes2 } from "./MockQuotes2.js";
+import { cloneObject } from "../Util.js";
+
+var RTKDataGrid = cloneObject(DataGrid);
+
+/** @public
+* @param {Object} payload
+* @return {*}
+*/
+RTKDataGrid.request = function (payload) {
+	var p = DataGrid.request(payload);
+	return p.then(function (res) {
+		return JSON.parse(res);
+	});
+};
+
+var MockRTK = {
+	Quotes: new MockQuotes2(),
+	Data: {
+		DataGrid: RTKDataGrid,
+		setInvalidFields: setInvalidFields
+	},
+	init: init,
+	ready: function () {
+		return this.init();
+	}
+};
+
+/** @public
+* @param {Object=} opt_obj
+* @return {MockRTK}
+*/
+function init(opt_obj) {
+	return new Promise(function (resolve, reject) {
+		setTimeout(function(){
+			resolve(MockRTK);
+		}, 300);
+	});
+}
+
+export default MockRTK;
+export { MockRTK };

package/lib/tr-grid-util/es6/jet/index.d.ts

@@ -0,0 +1,9 @@
+import { MockJET } from "./MockJET.js";
+import { DataGenerator } from "./DataGenerator.js";
+import { MockRTK } from "./MockRTK.js";
+
+export {
+	MockJET,
+	DataGenerator,
+	MockRTK
+};

package/lib/tr-grid-util/es6/jet/index.js

@@ -0,0 +1,18 @@
+import { MockJET } from "./MockJET.js";
+import { DataGenerator } from "./DataGenerator.js";
+import { MockRTK } from "./MockRTK.js";
+
+var tr = window["tr"];
+if(!tr) {
+	tr = window["tr"] = {};
+}
+
+tr.MockJET = MockJET;
+tr.DataGenerator = DataGenerator;
+tr.MockRTK = MockRTK;
+
+export {
+	MockJET,
+	DataGenerator,
+	MockRTK
+};

package/lib/tr-grid-util/es6/jet/mockDataAPI.d.ts

@@ -0,0 +1,11 @@
+import { DataGenerator } from "./DataGenerator.js";
+
+declare namespace DataGrid {
+
+}
+
+declare function setInvalidFields(fields: (string)[]|string): void;
+
+declare function mockDataAPI(dataType: string): Promise<any>;
+
+export { mockDataAPI, DataGrid, setInvalidFields };