@refinitiv-ui/efx-grid 6.0.118 → 6.0.120

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

@@ -13628,28 +13628,38 @@ RowDefinition.prototype.updateRowData = function(data, indexToFieldMap) {
 */
 RowDefinition.prototype.copyRowData = function(srcRowDef) {
 	if(srcRowDef && srcRowDef !== this) {
-		let field;
-		let uncopiable_fields = {
-			"ROW_DEF": 1,
-			"SUB_ID": 1
-		};
-		let staticValues = this._staticValues;
-		for(field in staticValues) {
-			uncopiable_fields[field] = 1;
-		}
-		staticValues = srcRowDef._staticValues;
-		for(field in staticValues) {
-			uncopiable_fields[field] = 1;
-		}
-
-		let srcRowData = srcRowDef.getRowData();
 		let rowData = this.getRowData();
-		for(field in srcRowData) {
-			if(!uncopiable_fields[field]) {
-				rowData[field] = srcRowData[field]; // There is no dataChanged event fired
-			}
+		srcRowDef.cloneRowData(rowData, this._staticValues);
+	}
+};
+/** @public
+ * @param {Object=} obj
+ * @param {Object=} exceptionObj
+ * @return {!Object}
+*/
+RowDefinition.prototype.cloneRowData = function(obj, exceptionObj) {
+	let rowObj = obj || {};
+	let field;
+	let uncopiable_fields = {
+		"ROW_DEF": 1,
+		"SUB_ID": 1
+	};
+	let staticValues = this._staticValues;
+	for(field in staticValues) {
+		uncopiable_fields[field] = 1;
+	}
+
+	for(field in exceptionObj) {
+		uncopiable_fields[field] = 1;
+	}
+
+	let rowData = this.getRowData();
+	for(field in rowData) {
+		if(!uncopiable_fields[field]) {
+			rowObj[field] = rowData[field];
 		}
 	}
+	return rowObj;
 };
 /** @public
 * @param {Object.<string, *>} data
@@ -15512,6 +15522,13 @@ ColumnDefinition.getDataType = function(field) {
 	return "";
 };
 /** @public
+* @ignore
+* @return {boolean|string|null}
+*/
+ColumnDefinition.prototype.getTooltipValue = function() {
+	return this._tooltip;
+};
+/** @public
 * @return {string}
 */
 ColumnDefinition.prototype.getTooltip = function() {
@@ -16812,7 +16829,7 @@ GroupDefinitions._toGroupDefinition = function(obj, groupId) {
 			groupDef = GroupDefinitions._cloneObject(obj);
 		}
 		if(groupId) {
-			if(!groupDef.id) {
+			if(!groupDef.name) {
 				groupDef.name = groupId;
 			}
 			groupDef.id = groupId;
@@ -18264,6 +18281,10 @@ Cell.prototype._floatingPanel = null;
 * @type {CellFloatingPanel}
 */
 Cell.prototype._frontIcon = null;
+/** @type {Object}
+* @private
+*/
+Cell.prototype._tooltipInfo = null;
 
 //#region ElementWrapper
 /** {@link ElementWrapper#getContent}
@@ -18856,6 +18877,91 @@ Cell.prototype.getClientWidth = function () {
 Cell.prototype.getClientHeight = function () {
 	return (this._element) ? this._element.clientHeight : this.getHeight();
 };
+
+/** To remove the tooltip, pass str as an empty string. To allow cell calculation for the correct tooltip, set str to null.
+* @public
+* @param {string|null} str
+*/
+Cell.prototype.setTooltip = function(str) {
+	this.setTooltipInfo("userTooltip", str);
+	this.updateTooltip();
+};
+/** @public
+* @ignore
+* @param {string} type
+* @param {*=} tooltip
+*/
+Cell.prototype.setTooltipInfo = function(type, tooltip) {
+	let tooltipInfo = this._tooltipInfo;
+	if(!tooltipInfo) {
+		tooltipInfo = this._tooltipInfo = {};
+	}
+
+	tooltipInfo[type] = tooltip;
+};
+/** @public
+* @ignore
+*/
+Cell.prototype.updateTooltip = function() {
+	let tooltipInfo = this._tooltipInfo;
+	if(!tooltipInfo) {
+		return;
+	}
+
+	let defaultTooltip = "";
+	let customizedTooltip = null;
+
+	// Clipped text tooltip takes precedence over default group header and column tooltip
+	if(tooltipInfo["clippedText"]) { // boolean
+		defaultTooltip = customizedTooltip = tooltipInfo["clippedTextTooltip"];
+	}
+
+	if(tooltipInfo["groupHeaderTooltip"] == null) {
+		if(tooltipInfo["columnDefault"] !== false) {
+			if(tooltipInfo["columnDefault"] != null) { // true, "", string
+				customizedTooltip = tooltipInfo["columnTooltip"];
+			} else { // null
+				defaultTooltip = tooltipInfo["columnTooltip"];
+			}
+		}
+	} else { // Group header tooltip takes precedence over column tooltip
+		if(tooltipInfo["groupHeaderDefault"] !== false) {
+			if(tooltipInfo["groupHeaderDefault"] != null) {
+				customizedTooltip = tooltipInfo["groupHeaderTooltip"];
+			} else {
+				defaultTooltip = tooltipInfo["groupHeaderTooltip"];
+			}
+		}
+	}
+
+	// User tooltip take the highest precedence
+	if(tooltipInfo["userTooltip"] != null) { // "", string
+		customizedTooltip = tooltipInfo["userTooltip"];
+	}
+
+	if(customizedTooltip == null) {
+		customizedTooltip = defaultTooltip;
+	}
+
+	if(customizedTooltip) {
+		if(this.getAttribute("title") !== customizedTooltip) {
+			this.setAttribute("title", customizedTooltip);
+		}
+	} else if(this.getAttribute("title") != null) {
+		this.removeAttribute("title");
+	}
+};
+/** @public
+* @ignore
+* @param {string} type
+* @return {*}
+*/
+Cell.prototype.getTooltipInfo = function(type) {
+	if(this._tooltipInfo) {
+		return this._tooltipInfo[type];
+	}
+	return null;
+};
 //#region Internal Public Methods
 
 //#region Private Methods
@@ -32007,7 +32113,7 @@ DataView.prototype._updateRowIds = function(opt_rowIds) {
 
 	this._excludedRids = {};
 	let exclusionCount = 0;
-	exclusionCount += DataView._copyObjectKeys(this._excludedRids, this._hiddenRids);
+	exclusionCount += DataView._copyValidObjectKeys(this._excludedRids, this._hiddenRids);
 
 	// Segment separators should not be filtered out (hidden)
 	let segments = this._dt._getSegmentSeparators();
@@ -32027,7 +32133,7 @@ DataView.prototype._updateRowIds = function(opt_rowIds) {
 		}
 		this._collapsedRids = segments.getCollapsedRows();
 		 // Children of collapsed segments must be filtered out (hidden)
-		exclusionCount += DataView._copyObjectKeys(this._excludedRids, this._collapsedRids);
+		exclusionCount += DataView._copyValidObjectKeys(this._excludedRids, this._collapsedRids);
 	}
 
 	if(this._groupLevel > 0 && !opt_rowIds) { // WARNING: The line below is quite slow
@@ -32557,13 +32663,15 @@ DataView._removeArrayItems = function(ary, items) {
 * @param {Object} masterObj
 * @returns {number}
 */
-DataView._copyObjectKeys = function(baseObj, masterObj) {
+DataView._copyValidObjectKeys = function(baseObj, masterObj) {
 	if(masterObj) {
 		let count = 0;
 
 		for(let key in masterObj) {
-			baseObj[key] = 1;
-			++count; // WARNING: duplicated key can be counted more than once
+			if(masterObj[key]) {
+				baseObj[key] = 1;
+				++count; // WARNING: duplicated key can be counted more than once
+			}
 		}
 		return count;
 	}
@@ -36457,7 +36565,7 @@ Core.prototype._hasPendingRowChange = false;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.117";
+	return "5.1.121";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -45033,11 +45141,11 @@ let _hasFieldOrId = function(colDef, str) {
 };
 
 /** Compare the difference in the 'id' property.
- * @private
- * @param {Object} obj1
- * @param {Object} obj2
- * @returns {boolean} If the id property of two objects is equal, the return will be true, otherwise it will be false.
- */
+* @private
+* @param {Object} obj1
+* @param {Object} obj2
+* @returns {boolean} If the id property of two objects is equal, the return will be true, otherwise it will be false.
+*/
 let _hasMatchingId = function(obj1, obj2) {
 	if(!obj1 || !obj2 || !obj1.id || !obj2.id) { // Handle nullable, if the object or id have null, it's means difference value
 		return false;
@@ -45045,6 +45153,25 @@ let _hasMatchingId = function(obj1, obj2) {
 	return obj1.id === obj2.id;
 };
 
+/** @private
+* @param {Object} e
+*/
+let _preventDefault = function(e) {
+	if(e) {
+		e.preventDefault();
+	}
+};
+/** @private
+* @param {number=} id
+* @returns {number} Always return 0
+*/
+let _clearTimeout = function(id) {
+	if(id) {
+		clearTimeout(id);
+	}
+	return 0;
+};
+
 /** @constructor
 * @extends {EventDispatcher}
 * @param {(Element|null)=} placeholder
@@ -45355,10 +45482,6 @@ Grid.prototype._topSection = true;
 * @private
 */
 Grid.prototype._focusingArgs = null;
-/** @type {number}
-* @private
-*/
-Grid.prototype._scrolledRow = -1;
 /** @type {boolean}
 * @private
 */
@@ -45373,10 +45496,8 @@ Grid.prototype.dispose = function() {
 		clearInterval(this._autoLayoutTimer);
 		this._autoLayoutTimer = 0;
 	}
-	if(this._pollingTimerId) {
-		clearTimeout(this._pollingTimerId);
-		this._pollingTimerId = 0;
-	}
+	this._pollingTimerId = _clearTimeout(this._pollingTimerId);
+
 	this.removeAllColumns(); // Some conflators are reset
 	this.removeAllRows(); // Some conflators are reset
 	this._sorter.dispose();
@@ -45399,9 +45520,8 @@ Grid.prototype.dispose = function() {
 	}
 
 	if(this._focusingArgs) {
-		if(this._focusingArgs.id) {
-			clearTimeout(this._focusingArgs.id);
-		}
+		_clearTimeout(this._focusingArgs.id);
+		_clearTimeout(this._focusingArgs.timeoutId);
 		this._focusingArgs = null;
 	}
 };
@@ -45706,6 +45826,7 @@ Grid.prototype.initialize = function(gridOption) {
 	this.addListener(gridOption, "beforeContentBinding");
 	this.addListener(gridOption, "firstRendered");
 	this.addListener(gridOption, "afterContentBinding");
+	this.addListener(gridOption, "tabNavigation");
 
 	if(gridOption["autoDateConversion"]) {
 		t._autoDateConversion = true;
@@ -47049,9 +47170,46 @@ Grid.prototype.setColumnSorter = function(colRef, func) {
 * @param {!RowDefinition} rowDef
 */
 Grid.prototype._initDuplicateRicData = function(rowDef) {
+	if(!rowDef) {
+		return;
+	}
+	let rowDefs = this._connector.getRowDefByRic(rowDef.getSymbol());
+	if(rowDefs && rowDefs.length > 0) { // Found at least 1 Duplicate chain/ric data
+		let firstRowDef = rowDefs[0];
+		rowDef.copyRowData(firstRowDef);
+		if(rowDef.isChain()) {
+			let children = firstRowDef.getChildren();
+			if(children && children.length > 0) {
+				setTimeout(this._cloneChain.bind(this, rowDef), 0); // Need to delay to wait row inserted
+			}
+		}
+	}
+};
+
+/** @private
+* @param {Object} rowDef
+* @param {Array<Object>} children
+*/
+Grid.prototype._cloneChain = function(rowDef) {
 	let rowDefs = this._connector.getRowDefByRic(rowDef.getSymbol());
-	if(rowDefs) {
-		rowDef.copyRowData(rowDefs[0]);
+	let firstRowDef = rowDefs ? rowDefs[0] : null;
+	let constituents = firstRowDef ? firstRowDef.getChildren() : null;
+
+	if(!constituents) {
+		return;
+	}
+	let count = constituents.length;
+	if(count < 0 ) {
+		return;
+	}
+
+	let subId = rowDef.getData(SUB_ID);
+	for (let i = 0; i < count; i++) {
+		let childRowDef = constituents[i];
+		let rowData = childRowDef.cloneRowData();
+		rowData["SUB_ID"] = subId;
+		let rid = subId + rowData["RIC"];
+		this._dc.setRowData(rid, rowData);
 	}
 };
 /** @public
@@ -48185,12 +48343,15 @@ Grid.prototype._renderColumnHeader = function(colIndex, arg) {
 	let colName = colDef.getName();
 	let colTooltip = colDef.getTooltip();
 	let headerAlignment = colDef.getHeaderAlignment();
+	let tooltipValue = colDef.getTooltipValue();
 
 	for(let r = 0; r < rowCount; ++r) {
 		let tCell = tSection.getCell(colIndex, r, false);
 		// Default behaviors
 		tCell.setContent(colName);
-		tCell.setTooltip(colTooltip);
+		tCell.setTooltipInfo("columnDefault", tooltipValue);
+		tCell.setTooltipInfo("columnTooltip", colTooltip);
+		tCell.updateTooltip();
 		tCell.setStyle("textAlign", headerAlignment);
 
 		if(customRenderer) {
@@ -48938,38 +49099,49 @@ Grid.prototype.getVScrollView = function () {
 	return this._grid.getVScrollView();
 };
 
-/** @private
-* @param {Element} el
-* @return {boolean}
-*/
-function isFocusableContent(el) {
-	if(el) {
-		return (el.tagName !== "SPAN" && !el.disabled);
-	}
-	return false;
-}
 /** @private
 * @param {Object} cell
+* @param {Object} args
 * @return {boolean}
 */
-function focusCell(cell) {
+Grid.prototype._focusCell = function(cell, args) {
 	if(cell) {
 		let cellContent = cell.getContent();
-		if(cellContent && isFocusableContent(cellContent)) {
-			cellContent.focus();
-			return true;
+		if(cellContent) {
+			let nfe = null;
+			if(this.hasListener("tabNavigation")) {
+				let tabNavArg = {
+					"shiftKey": args.shiftKey,
+					"activeElement": args.activeElement,
+					"cellContent": cellContent,
+					"cell": cell,
+					"colIndex": args.colIndex,
+					"rowIndex": args.rowIndex,
+					"field": args.fields ? args.fields[args.colIndex] : ""
+				};
+				this._dispatch("tabNavigation", tabNavArg);
+				nfe = tabNavArg.nextFocusableElement;
+			} else if(cellContent.tagName !== "SPAN") {
+				nfe = cellContent;
+			}
+
+			if(nfe && nfe !== args.activeElement && !nfe.disabled) {
+				nfe.focus();
+				return true;
+			}
 		}
 	}
 	return false;
-}
+};
 /** @private
 */
 Grid.prototype._onVScroll = function() {
 	let args = this._focusingArgs;
 	if(args) {
+		args.timeoutId = _clearTimeout(args.timeoutId);
 		this._focusingArgs = null;
 		let cell = this._grid.getCell("content", args.colIndex, args.rowIndex);
-		if(!focusCell(cell)) {
+		if(!this._focusCell(cell, args)) {
 			if(args.shiftKey) {
 				this._focusPrevCellContent(args);
 			} else {
@@ -48980,6 +49152,11 @@ Grid.prototype._onVScroll = function() {
 };
 /** @private
 */
+Grid.prototype._onScrollTimeout = function() {
+	this._focusingArgs = null;
+};
+/** @private
+*/
 Grid.prototype._selfScrollToRow = function() {
 	let args = this._focusingArgs;
 	if(args) {
@@ -48989,20 +49166,14 @@ Grid.prototype._selfScrollToRow = function() {
 };
 /** @private
 * @param {Object} args
-* @param {number} colIndex
-* @param {number} rowIndex
 */
-Grid.prototype._requestScroll = function(args, colIndex, rowIndex) {
-	if(this._focusingArgs || this._scrolledRow === args.rowIndex) {
-		return; // Avoid infinite loop
+Grid.prototype._requestScroll = function(args) {
+	if(!this._focusingArgs) {
+		this._focusingArgs = args;
+		args.event = null; // The event is invalid after the scroll
+		args.id = setTimeout(this._selfScrollToRow, 0); // Avoid event loop protection
+		args.timeoutId = setTimeout(this._onScrollTimeout, 100); // To avoid a fail case where scroll cannot be performed
 	}
-
-	this._scrolledRow = args.rowIndex;
-	this._focusingArgs = args;
-	args.colIndex = colIndex;
-	args.rowIndex = rowIndex;
-	args.event = null; // The event is invalid after the scroll
-	args.id = setTimeout(this._selfScrollToRow); // Avoid event loop protection
 };
 /** @private
 * @param {Object} args
@@ -49026,28 +49197,27 @@ Grid.prototype._focusNextCellContent = function(args) {
 			startIdx = i;
 		}
 	}
-	// If the current focus is on a valid content, starts on the next cell
-	if(args.event && args.validContent) {
-		startIdx++;
-	}
 
 	let grid = this._grid;
 	let section = grid.getSection("content");
 	let viewInfo = grid.getVerticalViewInfo();
 	let lastFullRow = viewInfo.lastFullRow;
 	let rowCount = this.getRowCount();
+
+	args.fields = grid.getColumnFields();
 	for(let r = rowIndex; r < rowCount; r++) {
+		args.rowIndex = r;
 		for(i = startIdx; i < len; i++) {
 			let c = focusableColIndices[i];
+			args.colIndex = c;
 			if(r > lastFullRow) {
-				this._requestScroll(args, c, r);
+				_preventDefault(args.event);
+				this._requestScroll(args);
 				return;
 			} else {
 				let cell = section.getCell(c, r);
-				if(focusCell(cell)) {
-					if(args.event) {
-						args.event.preventDefault();
-					}
+				if(this._focusCell(cell, args)) {
+					_preventDefault(args.event);
 					return;
 				}
 			}
@@ -49055,9 +49225,8 @@ Grid.prototype._focusNextCellContent = function(args) {
 		startIdx = 0;
 	}
 
-	if(args.validContent) { // The current focus on the last focusable content
-		this._grid.getHiddenInput().focus();
-	}
+	// The current focus on the last focusable content
+	this._grid.getHiddenInput().focus();
 };
 /** @private
 * @param {Object} args
@@ -49081,27 +49250,26 @@ Grid.prototype._focusPrevCellContent = function(args) {
 			startIdx = i;
 		}
 	}
-	// If the current focus is on a valid content, starts on the next cell
-	if(args.event && args.validContent) {
-		--startIdx;
-	}
 
 	let grid = this._grid;
 	let section = grid.getSection("content");
 	let viewInfo = grid.getVerticalViewInfo();
 	let firstFullRow = viewInfo.firstFullRow;
+
+	args.fields = this.getColumnFields();
 	for(let r = rowIndex; r >= 0; r--) {
+		args.rowIndex = r;
 		for(i = startIdx; i >= 0; i--) {
 			let c = focusableColIndices[i];
+			args.colIndex = c;
 			if(r < firstFullRow) {
-				this._requestScroll(args, c, r);
+				_preventDefault(args.event);
+				this._requestScroll(args);
 				return;
 			} else {
 				let cell = section.getCell(c, r);
-				if(focusCell(cell)) {
-					if(args.event) {
-						args.event.preventDefault();
-					}
+				if(this._focusCell(cell, args)) {
+					_preventDefault(args.event);
 					return;
 				}
 			}
@@ -49109,15 +49277,18 @@ Grid.prototype._focusPrevCellContent = function(args) {
 		startIdx = len - 1;
 	}
 
-	if(args.validContent) { // The current focus on the last focusable content
-		this._grid.getHiddenInput(true).focus();
-	}
+	// The current focus on the last focusable content
+	this._grid.getHiddenInput(true).focus();
 };
 
 /** @private
 * @param {Object} e
 */
 Grid.prototype._onTabNavigation = function(e) {
+	if(this._focusingArgs) {
+		return; // Cannot do another tab navigation while waiting for scrolling
+	}
+
 	let colDefs = this.getColumnDefinitions();
 	let colCount = colDefs.length;
 
@@ -49132,19 +49303,8 @@ Grid.prototype._onTabNavigation = function(e) {
 		return;
 	}
 
-	this._scrolledRow = -1; // Reset the scroll loop protector
 	let keyEvt = e.event;
 	let pos = this.getRelativePosition(keyEvt);
-	let validContent = true;
-	let activeElement = e.activeElement;
-	if(activeElement) {
-		validContent = !activeElement.classList.contains("valigner");
-	}
-
-	if(validContent) {
-		let content = pos["cell"] ? pos["cell"].getContent() : null;
-		validContent = isFocusableContent(content);
-	}
 	let startingRowIndex = pos["rowIndex"];
 	if(e.onTheEdge) {
 		let viewInfo = this._grid.getVerticalViewInfo();
@@ -49156,7 +49316,7 @@ Grid.prototype._onTabNavigation = function(e) {
 		colIndex: pos["colIndex"],
 		rowIndex: startingRowIndex,
 		focusableColIndices: focusableColIndices,
-		validContent: validContent
+		activeElement: e.activeElement
 	};
 
 	if(keyEvt.shiftKey) {
@@ -49166,6 +49326,16 @@ Grid.prototype._onTabNavigation = function(e) {
 	}
 };
 
+/** @public
+* @ignore
+* @return {!Object}
+*/
+Grid.prototype._getEventHandlers = function() {
+	return {
+		"tabNavigation": this._onTabNavigation
+	};
+};
+
 
 /* harmony default export */ var js_Grid = (Grid);
 
@@ -50910,6 +51080,10 @@ MockSubscriptions.prototype._maxInterval = 850;
 * @type {number}
 */
 MockSubscriptions.prototype._percentageDataUpdate = 0.1; // 10% by default
+/** @private
+* @type {boolean}
+*/
+MockSubscriptions.prototype._constituentCache = false;
 
 /** @public
 * @param {Object=} options
@@ -50938,6 +51112,12 @@ MockSubscriptions.prototype.config = function(options) {
 	if(typeof num === "number") {
 		this._percentageDataUpdate = num / 100;
 	}
+
+	let value = options.constituentCache;
+	if(value != null) {
+		this._constituentCache = value;
+	}
+
 };
 /** @public
 * @param {number=} min
@@ -51465,6 +51645,9 @@ MockSubscriptions.prototype._updateDuplicateSymbol = function(ric) {
 	if(!isChain) {
 		return;
 	}
+	if(!this._constituentCache) {
+		return;
+	}
 	let ricList = firstSub["ricList"];
 	if(!ricList) {
 		return;