@refinitiv-ui/efx-grid 6.0.7 → 6.0.9

package/lib/rt-grid/dist/rt-grid.js

@@ -9826,6 +9826,10 @@ Segment.prototype._collapsed = false;
 * @private
 */
 Segment.prototype._value = 0;
+/** @type {number}
+* @private
+*/
+Segment.prototype._order = 0;
 
 
 /** @public
@@ -9993,6 +9997,18 @@ Segment.prototype.getValue = function() {
 Segment.prototype.setValue = function(val) {
 	this._value = val;
 };
+/** @public
+* @return {number}
+*/
+Segment.prototype.getOrder = function() {
+	return this._order;
+};
+/** @public
+* @param {number} val
+*/
+Segment.prototype.setOrder = function(val) {
+	this._order = val;
+};
 
 
 /* harmony default export */ var data_Segment = (Segment);
@@ -10039,6 +10055,7 @@ SegmentCollection.prototype.addSegment = function(rid) {
 	if(rid && !this._segments[rid]) {
 		if(this._childToSegmentId[rid]) {
 			console.log("child of a segment cannot be set as a segment separator");
+			return false;
 		}
 		this._segments[rid] = new data_Segment(rid);
 		++this._segmentCount;
@@ -10369,8 +10386,27 @@ SegmentCollection.prototype.fillSegments = function(rids) {
 	return change;
 };
 /** @public
+* @param {Array.<string>} rids
+*/
+SegmentCollection.prototype.calcSegmentOrder = function(rids) {
+	var ridCount = rids ? rids.length : 0;
+	var segmentSeparators = this._segments;
+	var segmentCount = this._segmentCount;
+	var order = 0;
+	for(var i = 0; i < ridCount; ++i) {
+		var rid = rids[i];
+		var segment = segmentSeparators[rid];
+		if(segment) {
+			segment.setOrder(++order);
+			if(order >= segmentCount) {
+				break;
+			}
+		}
+	}
+};
+/** @public
 * @param {!Array.<string>} rids Array of row ids
-* @return {Array.<number>} Returns Array of segment values, if there are at least two segments, otherwise returns null
+* @return {Array.<number>} Returns Array of segment values, if there are at least one segment, otherwise returns null
 */
 SegmentCollection.prototype.getSegmentValues = function(rids) {
 	var rowCount = rids ? rids.length : 0;
@@ -10380,51 +10416,33 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 	var segmentSeparators = this._segments;
 	var childToSegmentId = this._childToSegmentId;
 	var curSegment = null;
+	var prevSegment = null;
 	var segmentValues = new Array(rowCount);
-	var curSegmentCount = 0;
 	var segmentVal = 0;
-	var r = 0;
-	var childToIndex = {};
-	while(r < rowCount) {
+	var offset = 0;
+	for(var r = 0; r < rowCount; ++r) {
 		var rid = rids[r];
-		if(segmentSeparators[rid]) {
-			++curSegmentCount;
-			curSegment = segmentSeparators[rid];
-			segmentVal += 100;
-			segmentValues[r] = segmentVal;
-			curSegment.setValue(segmentVal);
-			if(curSegmentCount >= this._segmentCount) {
-				++r;
-				break;
-			}
+		curSegment = segmentSeparators[rid];
+		if(curSegment) {
+			offset = 0;
 		} else {
-			if(curSegmentCount) {
-				segmentValues[r] = segmentVal + 10;
+			var parentId = childToSegmentId[rid];
+			if(parentId) {
+				curSegment = segmentSeparators[parentId];
+				offset = 1;
 			} else {
-				segmentValues[r] = 0;
-			}
-			if(childToSegmentId[rid]) {
-				childToIndex[rid] = r;
-			}
-		}
-		++r;
-	}
-	if(curSegmentCount) {
-		while(r < rowCount) {
-			rid = rids[r];
-			segmentValues[r] = segmentVal + 10;
-			if(childToSegmentId[rid]) {
-				childToIndex[rid] = r;
+				offset = prevSegment ? 10 : 0;
 			}
-			++r;
 		}
-		for(var childId in childToIndex) {
-			curSegment = segmentSeparators[childToSegmentId[childId]];
-			segmentValues[childToIndex[childId]] = curSegment.getValue() + 1;
+
+		if(curSegment && prevSegment !== curSegment) {
+			prevSegment = curSegment;
+			segmentVal = curSegment.getOrder() * 100;
 		}
+		segmentValues[r] = segmentVal + offset;
 	}
 
-	return curSegmentCount ? segmentValues : null;
+	return prevSegment ? segmentValues : null;
 };
 
 
@@ -10996,6 +11014,7 @@ DataTable.prototype.removeRows = function(refs) {
 			this._prevData[rid] = this._rows[rid];
 			this._removedRows[rid] = 1;
 			delete this._rows[rid];
+			// TODO: remove segments
 			dirty = true;
 		}
 	}
@@ -11092,6 +11111,7 @@ DataTable.prototype.moveRow = function(fromIndex, toIndex, suppressEvent) {
 
 	if(output) {
 		if(this._segments) {
+			this._segments.calcSegmentOrder(this._rids);
 			this._sort(null); // Reorder segment members
 		}
 		this._dispatchPositionChange(suppressEvent);
@@ -11321,12 +11341,19 @@ DataTable.prototype.isFrozen = function() {
 DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 	var change = false;
 	var memberCount = 0;
-	if(typeof rid === "string") {
+	if(rid && typeof rid === "string") {
 		if(enabled !== false) {
 			if(!this._segments) {
 				this._segments = new data_SegmentCollection();
 			}
+			if(this._autoSegmentFilling) {
+				var parentId = this._segments.getParentRowId(rid);
+				if(parentId) {
+					this._segments.removeSegmentChild(parentId, rid);
+				}
+			}
 			if(this._segments.addSegment(rid)) {
+				this._segments.calcSegmentOrder(this._rids);
 				change = true;
 			}
 		} else if(this._segments) {
@@ -11628,6 +11655,7 @@ DataTable.prototype.sortSegments = function (compare) {
 	}
 
 	if(dirty) {
+		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
 	}
@@ -15676,6 +15704,13 @@ CellFloatingPanel.prototype._items = [];
 CellFloatingPanel.prototype.hasItem = function () {
 	return !!this._items.length;
 };
+/** @public
+ * @param {Element} icon Element of item
+ * @returns {boolean}
+*/
+CellFloatingPanel.prototype.containItem = function (icon) {
+	return this._items.indexOf(icon) > -1;
+};
 /** @public
 * @param {Element} item
 * @param {number=} opt_order The greater the order, the farther the position to the right
@@ -16160,6 +16195,9 @@ Cell.prototype.updateIcon = function(icon) {
 
 	var fi = this._frontIcon;
 	if (fi) {
+		if(fi.containItem(icon)) { // Check same icon which duplicate with insertItem in _frontIcon
+			return;
+		}
 		fi.clearItems();
 	}
 	this.insertFrontIcon(icon, 0);
@@ -18904,7 +18942,11 @@ StretchedCells.prototype.setCellCount = function (count) {
 * @return {Cell}
 */
 StretchedCells.prototype.getCell = function (rowIndex) {
-	return this._cells[rowIndex] || null;
+	var cell = this._cells[rowIndex];
+	if(cell && cell["getParent"]()) {
+		return cell;
+	}
+	return null;
 };
 /** @public
 * @ignore
@@ -18951,13 +18993,13 @@ StretchedCells.prototype.getColumnIndex = function (cellRef) {
 StretchedCells.prototype.getRowIndex = function (cellRef) {
 	if(cellRef) {
 		if(cellRef["getElement"]) {
-			return this._cells.indexOf(cellRef);
+			return cellRef["getParent"]() ? this._cells.indexOf(cellRef) : -1;
 		} else {
 			var cells = this._cells;
 			var rowCount = cells.length;
 			for(var r = 0; r < rowCount; ++r) {
 				var cell = cells[r];
-				if(cell && cell["getElement"]() === cellRef) {
+				if(cell && cell["getParent"]() && cell["getElement"]() === cellRef) {
 					return r;
 				}
 			}
@@ -33221,7 +33263,7 @@ Core.prototype._rowHeightTimerId = 0;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.15";
+	return "5.1.20";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -43067,6 +43109,32 @@ Grid.prototype.setRowData = function(rowRef, values) {
 		rowDef.setRowData(values);
 	}
 };
+
+/**
+* @public
+* @param {Grid~RowReference} rowRef
+* @param {Object} values
+*/
+Grid.prototype.setStaticRowData = function(rowRef, values) {
+	var rowDef = this._getRowDefinition(rowRef);
+	if(rowDef) {
+		rowDef.setStaticRowData(values);
+	}
+};
+
+/**
+* @public
+* @param {Grid~RowReference} rowRef
+* @param {string} field
+* @param {*} value
+*/
+Grid.prototype.setStaticData = function(rowRef, field, value) {
+	var rowDef = this._getRowDefinition(rowRef);
+	if(rowDef) {
+		rowDef.setStaticData(field, value);
+	}
+};
+
 /** @private
 * @param {Grid~RowReference=} rowRef
 * @return {string}
@@ -45296,13 +45364,33 @@ var _joinSubKeys = function(subA, subB) {
 var 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) {
-	return new MockSubscriptions(options);
+	this._lastSub = new MockSubscriptions(options || this._configObj);
+	return this._lastSub;
 };
 
 /** @public
@@ -45312,30 +45400,40 @@ 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
 */
 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 = {};
@@ -45343,21 +45441,51 @@ var MockSubscriptions = function(options) {
 	this._fields = {};
 	this._events = {};
 	this._dataGen = new DataGenerator();
+
+	this.config(options);
 };
 
-/* @private
+/** @private
 * @type {number}
 */
 MockSubscriptions.prototype._minInterval = 750;
-/* @private
+/** @private
 * @type {number}
 */
 MockSubscriptions.prototype._maxInterval = 850;
-/* @private
-* @type {float}
+/** @private
+* @type {number}
 */
 MockSubscriptions.prototype._percentageDataUpdate = 0.1; // 10% by default
 
+/** @public
+* @param {Object=} options
+*/
+MockSubscriptions.prototype.config = function(options) {
+	if(!options) {
+		return;
+	}
+	var 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;
+	}
+};
 /** @public
 * @param {number=} min
 * @param {number=} max
@@ -46140,20 +46268,28 @@ mockDataAPI.setInvalidFields = setInvalidFields;
 
 
 
-/** @constructor */
-var MockJET = function() {
+/** @constructor
+* @param {Object=} options
+*/
+var MockJET = function(options) {
 	this["Quotes"] = new MockQuotes();
 	this["Quotes2"] = new MockQuotes2();
 	this["Archive"] = new MockArchive();
 	this["ContainerDescription"] = true;
 	this["Data"] = mockDataAPI;
+	if(options) {
+		this["Quotes2"].config(options);
+	}
 };
 
 /** @public
-* @param {Object=} opt_obj
+* @param {Object=} options
 * @return {MockJET}
 */
-MockJET.prototype.init = function(opt_obj) {
+MockJET.prototype.init = function(options) {
+	if(options) {
+		this["Quotes2"].config(options);
+	}
 	return this;
 };