@refinitiv-ui/efx-grid 6.0.32 → 6.0.34

package/lib/core/dist/core.js

@@ -6,9 +6,10 @@
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Qr": () => (/* binding */ isEmptyObject),
 /* harmony export */   "kI": () => (/* binding */ cloneObject)
 /* harmony export */ });
-/* unused harmony exports Util, extendObject, arrayToObject, extendProperty, extendArrayProperty, parseCondition, prettifyCss, getShadowRoot, injectCss, isIE, isMac, isTouchDevice, nestedObjectToArray, rgb2Hex, prepareTSVContent */
+/* unused harmony exports Util, extendObject, deepEqual, arrayToObject, extendProperty, extendArrayProperty, parseCondition, prettifyCss, getShadowRoot, injectCss, isIE, isMac, isTouchDevice, nestedObjectToArray, rgb2Hex, prepareTSVContent */
 /** @namespace */
 var Util = {};
 
@@ -149,6 +150,20 @@ var extendObject = function (obj, extender, limiters) {
 var cloneObject = function (obj, limiters) {
 	return extendObject({}, obj, limiters);
 };
+
+/** Check empty object
+* @public
+* @function
+* @param {Object} obj
+* @return {boolean}=true, if the obj is empty
+*/
+var isEmptyObject = function (obj) {
+	for (var key in obj) {
+		return false;
+	}
+	return true;
+};
+
 /** @public
 * @param {Array=} data
 * @param {Array.<string>=} fields In case of the given data is an array, this param will be used for mapping index to field
@@ -197,6 +212,58 @@ var extendProperty = function (obj, extender, propName) {
 		}
 	}
 };
+
+
+/** Compare the values of obj1 and obj2. if they are the same object or have the same value, the result will be true. Otherwise, it will return false.
+* @public
+* @param {*} obj1
+* @param {*} obj2
+* @return {boolean}
+*/
+var deepEqual = function (obj1, obj2) {
+
+	if(obj1 === obj2) {
+		return true;
+	}
+
+	if (typeof obj1 !== typeof obj2) {
+		return false;
+	}
+
+	if (typeof obj1 === "object") {
+
+		// We need to split array and object for performance reason
+		if(Array.isArray(obj1)) {
+			if(obj1.length !== obj2.length) {
+				return false;
+			}
+
+			for (var i = 0; i < obj1.length; i++) {
+				if (!deepEqual(obj1[i], obj2[i])) { // The array may not be a match if the elements are not sorted, so it will not be considered equal if there is a mismatch.
+					return false;
+				}
+			}
+
+		} else {
+
+			if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+				return false;
+			}
+
+			for (var key in obj1) {
+				if (!deepEqual(obj1[key], obj2[key])) {
+					return false;
+				}
+			}
+		}
+
+
+		return true;
+	}
+
+	return false;
+
+};
 /** Array.push() is much faster than Array.concat(). The downside is the parameters must be an array, whereas concat() has no such requirement. <br>
 * This method excels in extending known array property in an object.
 * @public
@@ -11843,7 +11910,22 @@ GroupDefinitions.prototype.setGroupChildren = function (groupId, newChildList) {
 	}
 	return false;
 };
+/** @public
+* @param {string} groupId
+* @param {string} groupName
+* @return {boolean}
+*/
+GroupDefinitions.prototype.setGroupName = function (groupId, groupName) {
+	var groupDef = this._groupMap[groupId];
+	if(groupDef) {
+		if(groupDef.name !== groupName) {
+			groupDef.name = groupName;
+			return true;
+		}
+	}
 
+	return false;
+};
 /* harmony default export */ const es6_GroupDefinitions = ((/* unused pure expression or super */ null && (GroupDefinitions)));
 
 
@@ -14030,6 +14112,22 @@ Segment.prototype.getOrder = function() {
 	}
 	return this._order * 10000;
 };
+/** Get the last (highest) order from the entire tree regardless of the current position segment in the hierachy
+* @public
+* @return {number}
+*/
+Segment.prototype.getLastOrder = function() {
+	if(this._subSegDef) {
+		var subSegments = this._subSegDef.subSegments;
+		if(subSegments) {
+			var lastSegment = subSegments[subSegments.length - 1];
+			if(lastSegment) {
+				return lastSegment.getOrder();
+			}
+		}
+	}
+	return this.getOrder();
+};
 /** @public
 * @param {number} val
 */
@@ -14151,9 +14249,10 @@ SegmentCollection.prototype.dispose = function() {
 };
 /** @public
 * @param {string} rid
+* @param {Array.<string>=} childRids Children of the newly added segment. This is a shorthand to addSegmentChildren method
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
-SegmentCollection.prototype.addSegment = function(rid) {
+SegmentCollection.prototype.addSegment = function(rid, childRids) {
 	if(rid && !this._segments[rid]) {
 		if(this.getParentRowId(rid)) {
 			console.log("child of a segment cannot be set as a segment separator");
@@ -14164,6 +14263,10 @@ SegmentCollection.prototype.addSegment = function(rid) {
 		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
 		++this._segmentCount;
 		this._segmentList = null; // order could be changed
+
+		if(childRids && childRids.length) {
+			segment.addChildren(childRids);
+		}
 		return true;
 	}
 	return false;
@@ -14511,9 +14614,10 @@ SegmentCollection.prototype.calcSegmentOrder = function(rids) {
 };
 /** @public
 * @param {!Array.<string>} rids Array of row ids
+* @param {boolean=} partial Indicating that the given ids are not the whole list
 * @return {Array.<number>} Returns Array of segment values, if there are at least one segment, otherwise returns null
-*/
-SegmentCollection.prototype.getSegmentValues = function(rids) {
+*/ //
+SegmentCollection.prototype.getSegmentValues = function(rids, partial) {
 	var rowCount = rids ? rids.length : 0;
 	if(!rowCount) {
 		return null;
@@ -14530,29 +14634,30 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 		var rid = rids[r];
 		curSegment = segmentSeparators[rid];
 		if(curSegment) { // segment separator
-			if(prevSegment !== curSegment) {
-				prevSegment = curSegment;
-				segmentVal = curSegment.getOrder() * 100;
-				if(segmentVal > highestVal) {
-					highestVal = segmentVal;
+			segmentVal = curSegment.getOrder() * 100;
+			offset = 0;
+			if(!curSegment.isSubSegment()) {
+				if(prevSegment !== curSegment) {
+					prevSegment = curSegment;
+					highestVal = curSegment.getLastOrder() * 100;
 				}
 			}
-			offset = 0;
 		} else {
 			var parentId = childToSegmentId[rid];
 			if(parentId) { // segment member
 				curSegment = segmentSeparators[parentId];
-				if(prevSegment !== curSegment) {
-					prevSegment = curSegment;
-					segmentVal = curSegment.getOrder() * 100;
-					if(segmentVal > highestVal) {
-						highestVal = segmentVal;
-					}
-				}
+				segmentVal = curSegment.getOrder() * 100;
 				offset = 1;
+				if(partial) {
+					highestVal = curSegment.getLastOrder() * 100;
+				}
 			} else { // row outside of segments
-				segmentVal = highestVal;
-				offset = 10;
+				if(highestVal) {
+					segmentVal = highestVal;
+					offset = 10;
+				} else {
+					segmentVal = offset = 0;
+				}
 			}
 		}
 
@@ -15734,11 +15839,12 @@ DataTable.prototype.getSegmentParentRowId = function(rid) {
 /**
 * @public
 * @param {Array.<string>=} rids If no row id is given, row ids of this data table is used instead
+* @param {boolean=} partial Indicating that the given ids are not the whole list
 * @return {Array.<number>} Return null if there is no segmentation
 */
-DataTable.prototype.getSegmentValues = function(rids) {
+DataTable.prototype.getSegmentValues = function(rids, partial) {
 	if(this._segments) {
-		return this._segments.getSegmentValues(rids || this._rids);
+		return this._segments.getSegmentValues(rids || this._rids, partial);
 	}
 	return null;
 };
@@ -15821,9 +15927,9 @@ DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	if(this._segments) {
 		var dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
 		if(dirty) {
-			if(this._sort(null)) {
-				this._dispatchPositionChange();
-			}
+			this._sort(null);
+			this._dispatchPositionChange(); // Force rerendering, even if there is no position change
+
 			this.requestClassifying();
 			return true;
 		}
@@ -15840,9 +15946,9 @@ DataTable.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
 	if(this._segments) {
 		var dirty = this._segments.addSegmentChildren(segmentId, rids, dataIds);
 		if(dirty) {
-			if(this._sort(null)) {
-				this._dispatchPositionChange();
-			}
+			this._sort(null);
+			this._dispatchPositionChange(); // Force rerendering, even if there is no position change
+
 			this.requestClassifying();
 			return true;
 		}
@@ -21834,7 +21940,7 @@ DataView.prototype._sort = function() {
 	if(this._dt._getSegmentSeparators() || this.isSorting()) {
 		var rids = this._rids;
 		var dataRows = this._dt.getMultipleRowData(rids);
-		var segmentValues = this._dt.getSegmentValues(rids);
+		var segmentValues = this._dt.getSegmentValues(rids, true); // WARNING: This does not work well for hidden/filtered rows
 		var change = data_DataTable._performMultiLevelSorting(dataRows, this._sortingDefs, segmentValues);
 
 		if(change) {
@@ -25588,7 +25694,7 @@ Core_Core.prototype._groupDefs = null;
 * @return {string}
 */
 Core_Core.getVersion = function () {
-	return "5.1.41";
+	return "5.1.45";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -25724,10 +25830,10 @@ Core_Core.prototype.getConfigObject = function (gridOptions) {
 		}
 	}
 
-	if(this._rowHighlighting) {
-		obj["rowHighlighting"] = true;
-	}
-	obj["columnVirtualization"] = this._colVirtualizer.isEnabled();
+	// It will be overwrite in rt-grid or atlas-blotter
+	obj["rowVirtualization"] = this.isRowVirtualizationEnabled();
+	obj["columnVirtualization"] = this.isColumnVirtualizationEnabled();
+	obj["rowHighlighting"] = this._rowHighlighting;
 
 	if(this._fixFrozenTopSections) {
 		obj["topFreezingCount"] = this._startVScrollbarIndex >= 0 ? (this._startVScrollbarIndex + 1) : false;
@@ -25740,7 +25846,13 @@ Core_Core.prototype.getConfigObject = function (gridOptions) {
 	if(this._rowScrollingStep) {
 		obj["stepScroll"] = (this._rowScrollingStep === 1) ? true : this._rowScrollingStep;
 	}
-	obj["autoHideScrollbar"] = this._vscrollbar.getAutoHide(); // this._hscrollbar has the same settings
+
+	var val = this._vscrollbar.getAutoHide();
+	if(val !== true) {
+		// TODO: check this._hscrollbar and this._vscrollbar can be difference config
+		obj["autoHideScrollbar"] = val; // this._hscrollbar has the same settings
+	}
+
 	var wheelSpeed = this._vscrollbar.getMouseWheelSpeed();
 	if(wheelSpeed) {
 		obj["linearWheelScrolling"] = wheelSpeed;
@@ -28713,6 +28825,14 @@ Core_Core.prototype.enableRowVirtualization = function (opt_enabled) {
 		this._rowVirtualizer.deactivate();
 	}
 };
+
+/** @public
+* @return {boolean}
+*/
+Core_Core.prototype.isRowVirtualizationEnabled = function () {
+	return this._rowVirtualizer.isEnabled();
+};
+
 /** No runtime support
 * @public
 * @param {boolean=} opt_enabled
@@ -28727,6 +28847,13 @@ Core_Core.prototype.enableColumnVirtualization = function (opt_enabled) {
 	}
 };
 
+/** @public
+* @return {boolean}
+*/
+Core_Core.prototype.isColumnVirtualizationEnabled = function () {
+	return this._colVirtualizer.isEnabled();
+};
+
 /** Scrolling step will be multiple of the default row height in pixels. For example, if default row height is 32 pixel and row scrolling step is 2, <br>
 * then the actual scrolling step for vertical scrollbar will be (32 * 2) = 64 pixels
 * @public
@@ -30732,6 +30859,7 @@ Core_Core._proto = Core_Core.prototype;
 
 
 
+
 /* eslint-enable */
 
 /** Fired when user click and before the sorting operation.
@@ -31191,7 +31319,10 @@ SortableTitlePlugin.prototype.getConfigObject = function (gridOptions) {
 		}
 		field = opt["field"];
 		if (field) {
-			col["sortBy"] = field;
+			if(col["field"] !== field) {
+				col["sortBy"] = field;
+			} // else The default value is an empty sortBy, which refers to the same column field by default.
+
 			if (this._sortingSequenceMap && this._sortingSequenceMap[field]) {
 				col["sortingSequence"] = this._sortingSequenceMap[field];
 			}
@@ -31204,16 +31335,32 @@ SortableTitlePlugin.prototype.getConfigObject = function (gridOptions) {
 		extOptions = obj["sorting"] = {};
 	}
 
-	extOptions["initialSort"] = this.getSortedColumns();
-	extOptions["sortableIndicator"] = this._sortableIndicator;
+	var val = this.getSortedColumns();
+	if(val != null) {
+		extOptions["initialSort"] = val;
+	}
+
+	val = this._sortableIndicator;
+	if(val !== false) {
+		extOptions["sortableIndicator"] = val;
+	}
+
 	if(this._maxCount !== 1) {
 		extOptions["multiColumn"] = this._maxCount === -1 ? true : this._maxCount;
 	}
 	if(this._dblClickAllowed) {
 		extOptions["disableDoubleClickToSort"] = !this._dblClickAllowed;
 	}
-	extOptions["sortableColumns"] = this._sortableColumns;
-	extOptions["indicatorOnly"] = !this._dataSorting;
+
+	val = this._sortableColumns;
+	if(val !== true) {
+		extOptions["sortableColumns"] = val;
+	}
+
+	val = this._dataSorting;
+	if(val !== true) {
+		extOptions["indicatorOnly"] = val;
+	}
 	// extOptions["mode"] = this._mode;
 	if(this._disabled) {
 		extOptions["disabled"] = true;
@@ -31230,6 +31377,10 @@ SortableTitlePlugin.prototype.getConfigObject = function (gridOptions) {
 		extOptions["sortingSequence"] = sortingSeq.slice();
 	}
 
+	if((0,es6_Util/* isEmptyObject */.Qr)(obj["sorting"])) {
+		delete obj["sorting"];
+	}
+
 	return obj;
 };
 
@@ -32367,16 +32518,16 @@ SortableTitlePlugin.prototype._updateSortableIndicator = function (hostIndex) {
 					symbol = t._createIconElem(icon, textContent);
 					symbol.className = "sort-symbol";
 					cell["insertFloatingIcon"](symbol, 0);
-
-					if (t._sortStates.length > 1) {
-						symbol = document.createElement("span");
-						symbol.className = "priority-symbol";
-						symbol.textContent = priority + 1;
-						cell["insertFloatingIcon"](symbol, 1);
-					}
 				} else {
 					cell["addClass"]("edge-indicator");
 				}
+
+				if (t._sortStates.length > 1) {
+					symbol = document.createElement("span");
+					symbol.className = "priority-symbol";
+					symbol.textContent = priority + 1;
+					cell["insertFloatingIcon"](symbol, 1);
+				}
 			} else if (t._sortableIndicator) { // Can sort but currently not sorting
 				icon = SortableTitlePlugin._icons["sortable"];
 				symbol = t._createIconElem(icon, CODE_DIAMOND);