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

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

@@ -0,0 +1,890 @@
+import {DataGenerator} from "./DataGenerator.js";
+import {CollectionDict} from "./CollectionDict.js";
+
+/** @private
+* @param {Object} subA
+* @param {Object} subB
+* @return {string}
+*/
+let _joinSubKeys = function(subA, subB) {
+	return subA.ric + "_" + subB.ric;
+};
+
+/** @private
+* @param {string} ric
+* @return {boolean}
+*/
+let _isDynamicChain = function(ric) {
+	// Dynamic chain will be 2 . (dot) for example .PG.PA
+	let matching = ric.match(/\./g); // Can be null when doesn't found dot(.)
+	if(matching) {
+		return matching.length > 1;
+	}
+	return false;
+};
+
+/** @private
+* @param {Array<Object>} arr sub children
+* @return {Array<Object>}
+*/
+let _shuffleArray = function(arr) {
+	let arrayShuffled = arr; // Modify original array
+	let i, randNumber, tmp;
+	// Shuffle the array randomly using the Fisher-Yates algorithm
+	for (i = arrayShuffled.length - 1; i > 0; i--) {
+		randNumber = Math.floor(Math.random() * (i + 1)); // TODO: it can be use this._dataGen.randInt(min, max) range
+		tmp = arrayShuffled[i];
+		arrayShuffled[i] = arrayShuffled[randNumber];
+		arrayShuffled[randNumber] = tmp;
+	}
+
+	// TODO: merge into 1 loop
+	// Update the CHILD_ORDER property based on the new index
+	arrayShuffled.forEach(_assignChildOrder);
+	arrayShuffled = arrayShuffled.sort(_childOrderSort);
+
+	return arrayShuffled;
+};
+
+let _assignChildOrder = function(obj, index) {
+	obj["CHILD_ORDER"] = index;
+};
+
+let _childOrderSort = function(a, b) {
+	return a["CHILD_ORDER"] - b["CHILD_ORDER"];
+};
+
+/** @constructor */
+let MockQuotes2 = function() {
+
+};
+/** @private
+* @type {*}
+*/
+MockQuotes2.prototype._lastSub = null;
+/** @private
+* @type {Object}
+*/
+MockQuotes2.prototype._configObj = null;
+
+/** @public
+* @param {Object=} options
+*/
+MockQuotes2.prototype.config = function(options) {
+	if(options) {
+		this._configObj = options;
+	}
+	if(this._lastSub && this._configObj) {
+		this._lastSub.config(this._configObj);
+	}
+};
+/** @public
+* @param {Object=} options
+* @return {MockSubscriptions}
+*/
+MockQuotes2.prototype.create = function(options) {
+	this._lastSub = new MockSubscriptions(options || this._configObj);
+	return this._lastSub;
+};
+
+/** @public
+* @return {boolean}
+*/
+MockQuotes2.prototype.isSkipHeaderSupported = function() {
+	return true;
+};
+
+/** @public
+* @param {number=} min
+* @param {number=} max
+*/
+MockQuotes2.prototype.setUpdateInterval = function(min, max) {
+	if(this._lastSub) {
+		this._lastSub.setUpdateInterval(min, max);
+	} else {
+		if(!this._configObj) {
+			this._configObj = {};
+		}
+		this._configObj.minInterval = min;
+		this._configObj.maxInterval = max;
+	}
+};
+/** @public
+* @param {number=} percent
+*/
+MockQuotes2.prototype.setPercentageDataUpdate = function(percent) {
+	if(this._lastSub) {
+		this._lastSub.setPercentageDataUpdate(percent);
+	} else {
+		if(!this._configObj) {
+			this._configObj = {};
+		}
+		this._configObj.percentageDataUpdate = percent;
+	}
+};
+
+
+/** @constructor
+* @param {Object=} options
+*/
+let MockSubscriptions = function(options) {
+	this._onSubscriptionResponse = this._onSubscriptionResponse.bind(this);
+
+	this._subMap = {};
+	this._dataMap = new CollectionDict();
+	this._fields = {};
+	this._events = {};
+	this._dataGen = new DataGenerator();
+
+	this.config(options);
+};
+
+/** @private
+* @type {number}
+*/
+MockSubscriptions.prototype._minInterval = 750;
+/** @private
+* @type {number}
+*/
+MockSubscriptions.prototype._maxInterval = 850;
+/** @private
+* @type {number}
+*/
+MockSubscriptions.prototype._percentageDataUpdate = 0.1; // 10% by default
+/** @private
+* @type {number}
+*/
+MockSubscriptions.prototype._percentageOrderChange = 1; // 100%
+/** @private
+* @type {boolean}
+*/
+MockSubscriptions.prototype._constituentCache = false;
+
+/** @public
+* @param {Object=} options
+*/
+MockSubscriptions.prototype.config = function(options) {
+	if(!options) {
+		return;
+	}
+	let num = options.minInterval;
+	if(typeof num === "number") {
+		this._minInterval = num;
+		if(this._minInterval > this._maxInterval) {
+			this._maxInterval = this._minInterval;
+		}
+	}
+
+	num = options.maxInterval;
+	if(typeof num === "number") {
+		this._maxInterval = num;
+		if(this._minInterval > this._maxInterval) {
+			this._minInterval = this._maxInterval;
+		}
+	}
+
+	num = options.percentageDataUpdate;
+	if(typeof num === "number") {
+		this._percentageDataUpdate = num / 100;
+	}
+
+	num = options.percentageOrderChange;
+	if(typeof num === "number") {
+		this._percentageOrderChange = num / 100;
+	}
+
+	let value = options.constituentCache;
+	if(value != null) {
+		this._constituentCache = value;
+	}
+
+};
+/** @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=} percent
+*/
+MockSubscriptions.prototype.setPercentageOrderChanged = function(percent) {
+	if(typeof percent === "number") {
+		this._percentageOrderChange = 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];
+	}
+	let len = fields.length;
+	for(let i = 0; i < len; ++i) {
+		this._fields[fields[i]] = true;
+	}
+};
+
+/** @public
+* @param {string} subId
+*/
+MockSubscriptions.prototype.removeSubscription = function(subId) {
+	let 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"]) {
+		let children = sub["children"];
+		let len = children.length;
+		for(let i = 0; i < len; ++i) {
+			let child = children[i];
+			this._dataMap.removeItem(_joinSubKeys(sub, child), child);
+			child["parent"] = null;
+		}
+		sub["children"] = null;
+		sub["ricList"] = 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
+	let working = this._working;
+	this.stop();
+
+	if(this._hasListener("subscriptionRemoved")) {
+		let subs = [];
+		for(let 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];
+	}
+	let len = fields.length;
+	for(let i = 0; i < len; ++i) {
+		let field = fields[i];
+		if(this._fields[field]) {
+			delete this._fields[field];
+		}
+	}
+};
+/** @public */
+MockSubscriptions.prototype.removeAllFields = function() {
+	let dirty = false;
+	for(let 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) {
+		window.clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+};
+
+/** @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; }
+
+	let 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) {
+	let listeners = (this._events) ? this._events[type] : null;
+	if(!listeners) { return; }
+
+	let 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) {
+	let 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
+*/
+let copyValues = function(fromObj, toObj) {
+	for(let 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
+	}
+	let sub = {};
+	sub["ric"] = ric;
+	sub["chain"] = asChain;
+	sub["id"] = subId;
+	sub["dataId"] = subId + ric;
+	this._subMap[subId] = sub; // Collect all user subscriptions
+	this._dataMap.addItem(ric, sub);
+	let subs = this._dataMap.getItems(ric);
+	let subCount = subs.length;
+
+	this._dispatch("subscriptionAdded", {"subs": [sub]});
+
+	let childSub = null;
+	let childCount = 0;
+	let i;
+	if(asChain) {
+		// 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
+		if(subCount === 1) { // The first chain detected
+			sub["children"] = [];
+			childCount = MockSubscriptions.simpleDigest(ric) % 10 + 4;
+			for(i = 0; i < childCount; ++i) {
+				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);
+				childSub["CHILD_ORDER"] = i;
+				this._dataMap.addItem(_joinSubKeys(sub, childSub), childSub);
+			}
+		} else { // Duplicate chain
+			let firstSub = subs[0];
+			let constituents = firstSub["children"];
+			childCount = constituents.length;
+			sub["children"] = new Array(childCount);
+
+			for(i = 0; i < childCount; ++i) {
+				childSub = {};
+				childSub["ric"] = constituents[i]["ric"];
+				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"][i] = childSub;
+
+				this._dataMap.addItem(_joinSubKeys(sub, childSub), childSub);
+			}
+		}
+	}
+	if(subCount > 1) { // Duplicate RIC/CHAIN detected
+		if(this._working) {
+			setTimeout(this._updateDuplicateSymbol.bind(this, ric), 10);
+		}
+	}
+
+	this._connect();
+	return subId;
+};
+/** @public
+* @param {string} str
+* @return {number}
+*/
+MockSubscriptions.simpleDigest = function(str) {
+	let len = str.length;
+	let sum = 0;
+	for(let i = 0; i < len; ++i) {
+		sum += str.charCodeAt(i);
+	}
+	return sum;
+};
+
+/** @private */
+MockSubscriptions.prototype._connect = function() {
+	if(this._working && !this._timerId) {
+		let delay = this._dataGen.randInt(this._minInterval, this._maxInterval);
+		this._timerId = window.setTimeout(this._onSubscriptionResponse, delay); // This will be async for fire event to user
+	}
+};
+
+MockSubscriptions.prototype._onSubscriptionResponse = function() {
+	this._timerId = 0;
+
+	let keys = this._dataMap.getAllKeys(); // list of all rics
+	let len = keys ? keys.length : 0; // len include all row index (Constituent and normal ric)
+	if(!len) { // No symbol has been added
+		this._connect();
+		return;
+	}
+
+	let minRow = (this._percentageDataUpdate - 0.02) * len;
+	minRow = minRow > 0 ? minRow : 1; // update at least 1 row
+	let maxRow = (this._percentageDataUpdate + 0.02) * len;
+	maxRow = maxRow < len ? maxRow : len; // not more than all rows
+	let numRows = this._dataGen.randInt(minRow, maxRow);
+	let fields = this._fields;
+
+	let updateCount = 0;
+	let childOrderChange;
+	for(let i = 0; i < numRows; i++) {
+		// find key to random subs (key is subId)
+		let key = keys[this._dataGen.randIndex(len)]; // WARNING: Same sub could be picked more than once
+		let subs = this._dataMap.getItems(key); // Get all subs with the same RIC
+		let subCount = subs.length;
+
+		let j;
+		let firstSub = subs[0]; // Only the first sub is need to generate data
+		let subParent = firstSub.parent;
+		let updatePosition = this._dataGen.randInt(0, 100) < this._percentageOrderChange * 100 ? true : false; // Random chance to change dynamic chain position (2% to change)
+
+		let values = this._generateQuoteData(firstSub, fields);
+		if(_isDynamicChain(key) && subParent && updatePosition) { // subParent in header of dynamic chain behaves like a normal ric
+			let children = subParent.children;
+			let childCount = children.length;
+
+			children = _shuffleArray(children); // Random swap children in array
+			let newOrder = children.indexOf(firstSub);
+			firstSub["CHILD_ORDER"] = newOrder; // This is bad
+			values["CHILD_ORDER"] = newOrder;
+
+			childOrderChange = true;
+			for(j = 0; j < subCount; ++j) { // It could be same ric and it need to dispatch with same ric number
+				this._dispatchDataChanged(subs[j], values);
+				// Update child order for all children with the same parent
+				for (let k = 0; k < childCount; k++) { // This is not correct, if there is a duplicate dynamic chain
+					if(k !== newOrder) {
+						this._dispatchDataChanged(children[k], {
+							X_RIC_NAME: children[k].ric,
+							CHILD_ORDER: k
+						});
+					}
+				}
+			}
+		} else {
+			if(subCount > 1) { // Duplicate CHILD_ORDER from the first sub for other sub with the same RIC (not entirely correct)
+				let childOrder = firstSub["CHILD_ORDER"];
+				if(childOrder != null) { // Children of chain will have a CHILD_ORDER
+					values["CHILD_ORDER"] = childOrder;
+				}
+			}
+			for(j = 0; j < subCount; ++j) { // It could be same ric and it need to dispatch with same ric number
+				this._dispatchDataChanged(subs[j], values);
+				updateCount++;
+			}
+		}
+	}
+
+	let postObj = {};
+	if(childOrderChange != null) {
+		postObj["childOrderChange"] = childOrderChange;
+	}
+	if(updateCount != null) {
+		postObj["updateCount"] = updateCount;
+	}
+
+	this._dispatchPostUpdate(postObj);
+
+	this._connect();
+};
+
+/** @private
+* @param {Object} obj
+*/
+MockSubscriptions.prototype._dispatchPostUpdate = function (obj) {
+	// TODO: handlded another property of "postUpdate" event
+	this._dispatch("postUpdate", obj);
+};
+
+/** @private
+* @param {Object} sub
+* @param {Object} fields
+* @return {!Object}
+*/
+MockSubscriptions.prototype._generateQuoteData = function(sub, fields) {
+	let ric = sub.ric;
+	let prevData = sub.prevData;
+
+	let values = {};
+	let options = {
+		text: ric,
+		prefix: sub["parent"] ? sub["parent"]["ric"] : "" // prefix for constituents
+	};
+	for(let field in fields){
+		let fInfo = this._dataGen.generateQuoteData(field, options);
+		if(fInfo.ignore) {
+			continue;
+		}
+
+		let formattedField = field + "_FORMATTED";
+		if(prevData) {
+			if(fInfo.changeOnly) {
+				if(prevData[field] === fInfo.value) {
+					continue;
+				}
+			}
+			prevData[field] = fInfo.value;
+			prevData[formattedField] = fInfo.formattedValue;
+		}
+
+		values[field] = fInfo.value;
+		values[formattedField] = fInfo.formattedValue;
+	}
+
+	// The delay symbol for X_RIC_NAME will depend on the INDICATOR field.
+	if(values["X_RIC_NAME"] != null && values["INDICATOR"] != null) {
+		if(values["INDICATOR"] > 0) {
+			values["X_RIC_NAME"] = "/" + values["X_RIC_NAME"];
+		}
+	}
+	return values;
+};
+
+
+/** @private
+* @param {Object} parentSub
+* @param {string} ric
+* @return {Object}
+*/
+MockSubscriptions.prototype._getChildSubByRic = function(parentSub, ric) {
+	let children = parentSub["children"];
+	if(children) {
+		let childCount = children.length;
+		for(let i = 0; i < childCount; ++i) {
+			let child = children[i];
+			if(child["ric"] === ric) {
+				return child;
+			}
+		}
+	}
+	return null;
+};
+/** @private
+* @param {string} ric
+*/
+MockSubscriptions.prototype._updateDuplicateSymbol = function(ric) {
+	let subs = this._dataMap.getItems(ric);
+	if(!subs) {
+		return;
+	}
+	let subCount = subs.length;
+	if(subCount < 2) {
+		return;
+	}
+	let firstSub = subs[0];
+	let prevData = firstSub["prevData"];
+	let isChain = firstSub["chain"] ? true : false;
+	let i;
+	if(prevData) {
+		for(i = 1; i < subCount; ++i) {
+			let sub = subs[i];
+			if(!sub["prevData"]) {
+				// TODO: check in duplicate dynamic chain
+				this._dispatchDataChanged(sub, prevData);
+			}
+		}
+	}
+
+
+	if(!isChain) {
+		return;
+	}
+	if(!this._constituentCache) {
+		return;
+	}
+	let ricList = firstSub["ricList"];
+	if(!ricList) {
+		return;
+	}
+	let childCount = ricList.length;
+
+	for(i = 1; i < subCount; ++i) {
+		let sub2 = subs[i];
+		let ricList2 = sub2["ricList"];
+		let childCount2 = ricList2 ? ricList2.length : 0;
+		for(let j = childCount2; j < childCount; ++j) {
+			let childRic = ricList[j];
+			let childSub = this._getChildSubByRic(firstSub, childRic);
+			let childSub2 = this._getChildSubByRic(sub2, childRic);
+			if(childSub && childSub2) {
+				if(childSub["prevData"]) {
+					// TODO: check in duplicate dynamic chain
+					this._dispatchDataChanged(childSub2, childSub["prevData"]);
+				}
+			}
+		}
+	}
+};
+/** @private
+* @param {Object} sub
+* @param {Object} dataUpdates
+*/
+MockSubscriptions.prototype._dispatchDataChanged = function(sub, dataUpdates) {
+	let values = copyValues(dataUpdates, {});
+	let evtArg = {};
+	evtArg["ric"] = sub["ric"];
+	evtArg["values"] = values;
+	evtArg["subId"] = sub["id"];
+
+	let 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);
+
+		let parentSub = sub.parent;
+		if(parentSub) { // This is the first time constituent have the data
+			let ricList = parentSub["ricList"];
+			if(!ricList) {
+				ricList = parentSub["ricList"] = [];
+			}
+			parentSub["ricList"].push(sub["ric"]);
+		}
+	}
+	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) {
+	let listeners = this._events[type];
+	return listeners ? (listeners.length > 0) : false;
+};
+/** @private
+* @param {string} type
+* @param {Object} eventArg
+*/
+MockSubscriptions.prototype._dispatch = function(type, eventArg) {
+	let listeners = this._events[type];
+	if(!listeners) { return; }
+	let len = listeners.length;
+	for(let 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 = 0;
+
+/** @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};