@refinitiv-ui/efx-grid 6.0.33 → 6.0.35

package/lib/column-dragging/es6/ColumnDragging.js

@@ -75,11 +75,17 @@ var ColumnDraggingPlugin = function (options) {
 	t._hosts = [];
 
 	t._guideline = document.createElement("div");
-	t._guideline.className = "guideline";
 	t._dragBox = document.createElement("div");
-	t._dragBox.className = "drag-box-disabled"; // defualt disable dragbox
+	t._dragBox.classList.add("drag-box-disabled"); // defualt disable dragbox
 	t._dragBoxIcon = document.createElement("ef-icon");
-	t._dragBoxIcon.className = "drag-box-icon";
+	t._dragBoxIcon.classList.add("drag-box-icon");
+
+	if(ElfUtil.getElfVersion() < 4) {
+		t._dragBox.classList.add("tr-dragbox");
+		t._guideline.classList.add("tr-guideline");
+	} else {
+		t._guideline.classList.add("guideline");
+	}
 
 	if(options) {
 		this.config({ "columnDragging": options });
@@ -284,7 +290,8 @@ ColumnDraggingPlugin.prototype.config = function (options) {
 
 	if (typeof extOptions["dragBoxRenderer"] === "function") {
 		this._dragBoxRenderer = extOptions["dragBoxRenderer"];
-		this._dragBox.className = "drag-box";
+		this._dragBox.classList.add("drag-box");
+		this._dragBox.classList.remove("drag-box-disabled");
 	}
 	this.addListener(extOptions, "dragStart");
 	this.addListener(extOptions, "drag");
@@ -607,47 +614,38 @@ ColumnDraggingPlugin.prototype._onDragEnd = function (e) {
 	if (!operationCancelled) {
 		if (!this._noColumnMoving) {
 			var cgp = this._getPlugin("ColumnGroupingPlugin");
+			var csp = this._getPlugin("ColumnStackPlugin");
+			var destIndex = this._destColumn;
+			var groupId, stackId;
+
+			// Move operation always move to the left of destination column
+			// When moving forward, destnation need to added by 1 to move correctly
+			if (this._startColumn < this._destColumn) {
+				destIndex = this._destColumn + 1;
+			}
+
+			// TODO: support multi column dragging
+			if(csp) {
+				stackId = csp.getStackId(this._startColumn);
+			}
 			if(cgp){
 				var cellInfo = cgp.getCellInfo(this._startPos);
-				var srcId = cellInfo["groupId"] || cellInfo["columnId"];
-				var destIndex = this._destColumn;
+				groupId = cellInfo["groupId"] || cellInfo["columnId"];
+			}
 
-				// Move group always move to the left of destination
-				// When moving forward, destnation need to added by 1 to move correctly
-				if (this._startColumn < this._destColumn) {
-					destIndex = this._destColumn + 1;
-				}
-				if(srcId){
-					cgp.moveGroup(srcId, destIndex);
-				}
+			if(stackId && this._startColumn === this._endColumn){
+				csp.moveStack(stackId, destIndex);
+			} else if(groupId) {
+				cgp.moveGroup(groupId, destIndex);
 			} else {
-				var shiftStart = -1;
-				var shiftEnd = -1;
-				var moveSize = -1;
-				if (this._startColumn > this._destColumn) { //Move backward
-					shiftStart = this._destColumn;
-					shiftEnd = this._startColumn - 1;
-					moveSize = -1 * (this._startColumn - this._destColumn); //Move to the left
-				} else
-				if (this._startColumn < this._destColumn) { //Move foward
-					shiftStart = this._endColumn + 1;
-					shiftEnd = this._destColumn;
-					moveSize = ((shiftEnd - shiftStart) + 1); //Move to the right
+				var colList = [];
+				var i;
+				for(i = this._startColumn; i <= this._endColumn; i++){
+					colList.push(i);
 				}
-
-				//Perform moving all columns in the range
-				for(var j = this._hosts.length; --j >= 0;) {
-					var host = this._hosts[j];
-					var i;
-					if (moveSize > 0) { //Move forward
-						for (i = this._startColumn; i <= this._endColumn; i++) {
-							host.moveColumn(this._startColumn, this._destColumn);
-						}
-					} else { //Move backward
-						for (i = this._startColumn; i <= this._endColumn; i++) {
-							host.moveColumn(this._startColumn + (i - this._startColumn), this._destColumn + (i - this._startColumn));
-						}
-					}
+				for(i = this._hosts.length; --i >= 0;) {
+					var host = this._hosts[i];
+					host.reorderColumns(colList, destIndex);
 				}
 			}
 		}
@@ -756,6 +754,18 @@ ColumnDraggingPlugin.prototype._renderGuideline = function() {
 	var rightHand = this._pos["x"] > colLeft + colWidth / 2;
 	var destColumn = (rightHand) ? colEnd + 1 : colStart;
 
+	var csp = this._getPlugin("ColumnStackPlugin");
+	if(csp){
+		var stackId = csp.getStackId(destColumn);
+		if(stackId){
+			var members = csp.getStackMemberIndices(stackId);
+			var memberCount = members.length;
+			if(members && memberCount){
+				destColumn = rightHand ? members[memberCount - 1] + 1 : members[0];
+			}
+		}
+	}
+
 	colLeft = this._clickedGrid.getColumnLeft(this._destColumn);
 	// If destination exceeds the specified bounds
 	if (destColumn < this._leftMovableBorder) {

package/lib/core/dist/core.js

@@ -9,7 +9,7 @@
 /* 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 = {};
 
@@ -212,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
@@ -14060,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
 */
@@ -14181,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");
@@ -14194,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;
@@ -14541,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;
@@ -14560,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;
+				}
 			}
 		}
 
@@ -15601,7 +15676,24 @@ DataTable.prototype.setSortingLogic = function(func) {
 * @param {DataTable.SortLogic} func Use null to remove current sorting logic
 */
 DataTable.prototype.setColumnSortingLogic = function(cid, func) {
-	this._compMap[cid] = func;
+	if(cid) {
+		this._compMap[cid] = func;
+	}
+};
+/** Get sorting logic for the specified field. Default logic is returned, if no logic is specified for the column
+* @public
+* @param {string=} cid
+* @return {DataTable.SortLogic}
+*/
+DataTable.prototype.getColumnSortingLogic = function(cid) {
+	if(cid) {
+		var logic = this._compMap[cid];
+		if(logic) {
+			return logic;
+		}
+	}
+
+	return this._compMap["_default"] || null;
 };
 
 /** Freeze data table so that no event is fired for data processing until executing {@link DataTable#unfreeze} method
@@ -15764,11 +15856,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;
 };
@@ -15851,9 +15944,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;
 		}
@@ -15870,9 +15963,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;
 		}
@@ -19347,6 +19440,17 @@ DataView.prototype.setColumnSortingLogic = function(cid, func) {
 		this._dt.setColumnSortingLogic(cid, func);
 	}
 };
+/** Get sorting logic for the specified field. Default logic is returned, if no logic is specified for the column
+* @public
+* @param {string=} cid
+* @return {DataTable.SortLogic}
+*/
+DataView.prototype.getColumnSortingLogic = function(cid) {
+	if(this._dt) {
+		return this._dt.getColumnSortingLogic(cid);
+	}
+	return null;
+};
 /** Check if this view is in sorting mode
 * @public
 * @return {boolean}
@@ -21864,7 +21968,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) {
@@ -25083,6 +25187,7 @@ VirtualizedLayoutGrid._proto = VirtualizedLayoutGrid.prototype;
 
  // eslint-disable-line
 
+
  // eslint-disable-line
 
 
@@ -25282,7 +25387,9 @@ var Core_Core = function (opt_initializer) {
 		"rowRemoved",
 		"columnPositionChanged",
 		"rowPositionChanged",
-		"beforeColumnBoundUpdate"
+		"beforeColumnBoundUpdate",
+		"beforeBatchOperation",
+		"afterBatchOperation"
 	);
 
 	// For debugging in advanced optimization mode
@@ -25357,6 +25464,15 @@ Core_Core.SectionReference;
 */
 Core_Core.MouseInfo;
 
+/** @typedef {Object} Core~BatchInfo
+* @private
+* @property {string=} reset //set columns
+* @property {string=} insertion //add cols
+* @property {string=} removal //remove cols
+* @property {string=} moving //reorder
+*/
+Core_Core.BatchInfo;
+
 /** @typedef {Core.MouseInfo|ElementWrapper|Element} Core~CellReference
 * @description A section in core grid can be refered by the following object <br>
 * `{Core.MouseInfo}` : Object with valid x, y coordinates and section index <br>
@@ -25611,6 +25727,10 @@ Core_Core.prototype._rowHeightTimerId = 0;
 * @private
 */
 Core_Core.prototype._groupDefs = null;
+/** @type {BatchInfo}
+* @private
+*/
+Core_Core.prototype._batches = null;
 //#region Public Methods
 
 /**
@@ -25618,7 +25738,7 @@ Core_Core.prototype._groupDefs = null;
 * @return {string}
 */
 Core_Core.getVersion = function () {
-	return "5.1.42";
+	return "5.1.48";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -26557,6 +26677,10 @@ Core_Core.prototype.removeColumnAt = function (index) {
 
 	if (this._hasListener("columnRemoved")) {
 		var e = {};
+		var batches = this._batches;
+		if(batches){
+			e["batches"] = batches;
+		}
 		e["atTheMiddle"] = true;
 		e["colIndex"] = index;
 		e["columns"] = "deprecated";
@@ -29401,6 +29525,40 @@ Core_Core.prototype.getColumnGroupChildIds = function (groupId) {
 	}
 	return null;
 };
+
+/** @public
+* @param {string} batchType
+* @return {boolean}
+* @fires Core#beforeBatchOperation
+*/
+Core_Core.prototype.startBatch = function (batchType) {
+	if(!batchType){
+		return false;
+	}
+	if(!this._batches){
+		this._batches = {};
+	}
+	this._batches[batchType] = batchType;
+	this._dispatch("beforeBatchOperation", { batches: this._batches, batchType: batchType });
+	return true;
+};
+/** @public
+* @param {string} batchType
+* @return {boolean}
+* @fires Core#afterBatchOperation
+*/
+Core_Core.prototype.stopBatch = function (batchType) {
+	if(!batchType){
+		return false;
+	}
+	this._dispatch("afterBatchOperation", { batches: this._batches, batchType: batchType });
+
+	delete this._batches[batchType];
+	if((0,es6_Util/* isEmptyObject */.Qr)(this._batches)){
+		this._batches = null;
+	}
+	return true;
+};
 //#endregion Public Methods
 
 //#region Private Methods
@@ -29644,6 +29802,10 @@ Core_Core.prototype._dispatchColumnAddedEvent = function (at, count, atTheMiddle
 	if (this._hasListener("columnAdded")) {
 		var e = {};
 		e["atTheMiddle"] = atTheMiddle;
+		var batches = this._batches;
+		if(batches){
+			e["batches"] = batches;
+		}
 		if(count === 1) {
 			e["colIndex"] = at;
 			e["context"] = ctx;
@@ -29795,6 +29957,10 @@ Core_Core.prototype._removeColumn = function (num) {  // TODO: change the logic
 
 	if (this._hasListener("columnRemoved")) {
 		var e = {};
+		var batches = this._batches;
+		if(batches){
+			e["batches"] = batches;
+		}
 		for (var c = colCount; --c >= newCount; ) {
 			var colDef = removedCols[c - newCount];
 			e["colIndex"] = c;
@@ -32319,6 +32485,9 @@ SortableTitlePlugin.prototype._sortDataView = function (opt_action) {
 	if (!this._dataSorting) { return; }
 
 	var sortCount = this._sortStates.length;
+	if(this._userManagedLogic && sortCount > 1) { // The logic is managed by the user. There is no point in using multi-column sorting
+		sortCount = 1;
+	}
 	var orders = null;
 	var sortLogics = null;
 	var c_ref = null;
@@ -32334,6 +32503,9 @@ SortableTitlePlugin.prototype._sortDataView = function (opt_action) {
 		} else {
 			c_ref = this.getColumnSortingFields();
 		}
+		if(this._userManagedLogic && c_ref.length > 1) {
+			c_ref = c_ref.slice(0, 1);
+		}
 	}
 
 	// Perform sorting even if there is no sort state
@@ -32442,16 +32614,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);