@refinitiv-ui/efx-grid 6.0.154 → 6.0.155

package/lib/core/dist/core.js

@@ -13388,7 +13388,7 @@ Segment.prototype.getChildCount = function() {
 */
 Segment.prototype.markCollapsingStateDirty = function() {
 	// A segment can have a child and/or autogenerated segment (subsegment) to not be considered as empty.
-	if(this._childIds.length ||  this._subSegDef) {
+	if(this._childIds.length || this._subSegDef) {
 		this._shared.dirtyCollapsingState = true;
 	}
 };
@@ -13782,6 +13782,83 @@ Segment.prototype.getSubSegmentName = function(row) {
 	}
 	return this._subSegName;
 };
+/**
+* @private
+* @param {!Segment} segment
+* @returns {string}
+*/
+let _toSegmentId = function(segment) {
+	return segment.getId();
+};
+/**
+* @public
+* @param {!Function} comparer
+* @returns {boolean} Returns true if there is any change
+*/
+Segment.prototype.sortSegments = function(comparer) {
+	if(!comparer || this.hasSubSegments()) {
+		return false;
+	}
+
+	let segmentList = [];
+	let rids = [];
+	let childIds = this._childIds;
+	let childCount = childIds.length;
+	let segments = this._shared.segments;
+	for(let i = 0; i < childCount; ++i) {
+		let childId = childIds[i];
+		let childSegment = segments[childId];
+		if(childSegment) {
+			segmentList.push(childSegment);
+		} else {
+			rids.push(childId);
+		}
+	}
+	if(segmentList.length < 2) {
+		return false;
+	}
+	segmentList.sort(comparer);
+	this._childIds = rids.concat(segmentList.map(_toSegmentId));
+	return true;
+};
+/** Get segment id and ids of children, including nested segments, but excluding sub segments
+* @public
+* @param {Array.<string>} ary
+* @return {!Array.<string>}
+*/
+Segment.prototype.getFlattenTreeIds = function(ary) {
+	if(!ary) {
+		ary = [];
+	}
+
+	if(!this._subSegment) { // Sub segments are excluded from tree
+		ary.push(this._rid);
+	}
+	let i;
+	let segmentNames = this._subSegNames;
+	if(segmentNames) { // Classified segment
+		let segmentCount = segmentNames.length;
+		let segmentMap = this._subSegMap;
+		for(i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].getFlattenTreeIds(ary);
+		}
+	} else {
+		let childIds = this._childIds;
+		let childCount = childIds.length;
+		let segments = this._shared.segments;
+		for(i = 0; i < childCount; ++i) {
+			let childId = childIds[i];
+			let childSegment = segments[childId];
+			if(childSegment) {
+				childSegment.getFlattenTreeIds(ary);
+			} else {
+				ary.push(childId);
+			}
+		}
+	}
+
+	return ary;
+};
 
 /** @public
 * @param {boolean=} bool
@@ -14189,6 +14266,23 @@ SegmentCollection.prototype.getSegments = function() {
 SegmentCollection.prototype.getSegmentIds = function() {
 	return Object.keys(this._segments);
 };
+/** @public
+* @param {!Function} comparer
+* @return {!Array.<Segment>}
+*/
+SegmentCollection.prototype.sortSegments = function(comparer) {
+	let rootSegments = [];
+	let segmentSeparators = this._segments;
+	for(let rid in segmentSeparators) {
+		let segment = segmentSeparators[rid];
+		segment.sortSegments(comparer);
+		if(segment.isRootSegment()) {
+			rootSegments.push(segment);
+		}
+	}
+	rootSegments.sort(comparer);
+	return rootSegments;
+};
 
 
 /** @public
@@ -15596,7 +15690,7 @@ DataTable.prototype.getSortingLogics = function() {
 };
 /** @public
 * @param {string|Array.<string>} cid Column id
-* @param {string|number|Array.<string|number>=} sortOrders "a"|"d"|"n"
+* @param {(string|number|Array.<string|number>)=} sortOrders "a"|"d"|"n"
 * @param {DataTable.SortLogic=} customComparer
 * @param {*=} contextObj Context object that will be provided as the forth parameter of the given comparer method
 * @return {boolean} Return true if there is any change, otherwise false
@@ -16106,50 +16200,51 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 	}
 	return null;
 };
+/**
+* @private
+* @param {(Array|number)} sortOrder
+* @param {*} context
+*/
+DataTable.prototype._setSegmentSortContext = function (sortOrder, context) {
+	this._segmentSortOrder = sortOrder;
+	this._segmentSortContext = context;
+};
 /** Sort all of existing segments by multiple sort logics
 * @public
 * @param {Function|Array.<Function>|Object} sortLogics
-* @param {Array.<number>=} sortOrders
+* @param {Array.<number|string>=} sortOrders
 * @param {Array.<string>=} cids
 * @return {boolean}
 */
 DataTable.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
-	let dirty = false;
 	if(!this._segments){
 		return false;
 	}
 	if(typeof sortLogics === "function"){
+		this._setSegmentSortContext(DataTable._getSortOrder(sortOrders), cids);
 		return this.sortSegments(sortLogics);
 	}
+	if(!cids) {
+		return false;
+	}
 	let sortingDefs = DataTable._buildSortContext(
 		[],
 		cids,
 		sortOrders,
-		sortLogics
+		sortLogics || this._compMap
 	);
-	let defCount = sortingDefs ? sortingDefs.length : 0;
-	if(!defCount){
-		return dirty;
-	}
-
-	let sortOrder = 0;
-	let sortLogic, sortContext;
+	let defCount = sortingDefs.length;
+	let sortLogic = null;
 	if(defCount > 1) {
 		sortLogic = DataTable._multiColumnSeparatorCompareLogic;
-		sortContext = sortingDefs;
-		sortOrder = 1; // sortOrder is not used by _multiColumnSeparatorCompareLogic
-	} else { // Single level sorting
+		this._setSegmentSortContext(1, sortingDefs);
+	} else if(defCount === 1) { // Single level sorting
 		sortLogic = DataTable._singleColumnSeparatorCompareLogic;
-		sortContext = sortingDefs[0];
-		sortOrder = /** @type{number} */(sortContext[3]);
+		this._setSegmentSortContext(sortingDefs[0][3], sortingDefs[0]); // sortOrder and context
+	} else {
+		return false;
 	}
-	this._segmentSortOrder = sortOrder;
-	this._segmentSortContext = sortContext;
-	dirty = this.sortSegments(sortLogic);
-	this._segmentSortOrder = 0;
-	this._segmentSortContext = null;
-
-	return dirty;
+	return this.sortSegments(sortLogic);
 };
 /** Sort all of existing segments by given compare function
 * @public
@@ -16164,40 +16259,33 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(this._rids);
 		return false;
 	}
-	let rids = this._rids;
-	let segments = this._segments;
-	let segmentCount = segments.getSegmentCount();
-	let segmentList = [];
-	let origOrder = [];
-	let itemCount = 0;
-	let rowCount = rids.length;
-	let rid = "";
-	let segment = null;
-	let i;
-	for(i = 0; i < rowCount; ++i) {
-		rid = rids[i];
-		segment = segments.getSegment(rid);
-		if(segment) {
-			origOrder.push(i);
-			segmentList.push(segment);
-			if(++itemCount >= segmentCount) {
-				break;
-			}
-		}
-	}
 
 	this._userSegmentComparer = compare;
-	segmentList.sort(this._bySegmentSeparator);
+
+	let segments = this._segments;
+	let rootSegments = segments.sortSegments(this._bySegmentSeparator);
+
 	this._userSegmentComparer = null;
+	this._setSegmentSortContext(0, null);
 
+	let rids = this._rids;
+	let origRids = rids.slice();
+	let rowCount = rids.length;
+	rids.length = 0;
+
+	let segmentCount = 0;
 	let dirty = false;
-	for(i = 0; i < itemCount; ++i) {
-		let idx = origOrder[i];
-		rid = rids[idx];
-		segment = segmentList[i];
-		let newRid = segment.getId();
-		if(rid !== newRid) {
-			rids[idx] = newRid;
+	for(let i = 0; i < rowCount; ++i) {
+		let rid = origRids[i];
+		let segment = segments.getSegment(rid);
+		if(segment) {
+			if(segment.isRootSegment()) {
+				rootSegments[segmentCount++].getFlattenTreeIds(rids);
+			}
+		} else if(!segments.getParentRowId(rid)) {
+			rids.push(rid);
+		}
+		if(rid !== rids[i]) {
 			dirty = true;
 		}
 	}
@@ -16206,9 +16294,8 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
-		return true;
 	}
-	return false;
+	return dirty;
 };
 /** Sort all of existing segments by given compare function
 * @private
@@ -16491,7 +16578,7 @@ DataTable._positionChangeArg = {"globalChange": true, "positionChangeOnly": true
 * @function
 * @public
 * @ignore
-* @param {Array.<Array>} out_defs Output object. Array is used to optimize property accessing time.
+* @param {!Array.<Array>} out_defs Output object. Array is used to optimize property accessing time.
 * @param {string|Array.<string>} cids
 * @param {string|number|Array.<string|number>=} sortOrders
 * @param {Function|Array.<Function>|Object.<string, DataTable.SortLogic>=} logics
@@ -21530,10 +21617,22 @@ DataView.prototype.getSegmentChildIds = function(segmentRef) {
 /** Sort all of existing segments by multiple sort logics
 * @public
 * @param {Function|Array.<Function>|Object} sortLogics
-* @param {Array.<number>=} sortOrders
-* @param {Array.<string>=} cids
+* @param {(number|Array.<number>)=} sortOrders
+* @param {(string|Array.<string>)=} cids
 */
 DataView.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
+	let sortingDefs = this._sortingDefs;
+	if(sortingDefs.length) {
+		if(!cids) {
+			cids = sortingDefs[0][0]; // field
+		}
+		if(!sortOrders) {
+			sortOrders = sortingDefs[0][3];
+		}
+	} else if(!sortLogics) {
+		return;
+	}
+
 	this._dt.sortSeparators(sortLogics, sortOrders, cids);
 };
 /** Sort all of existing segments by given compare function
@@ -26188,7 +26287,7 @@ Core_Core.prototype._hasPendingRowChange = false;
 * @return {string}
 */
 Core_Core.getVersion = function () {
-	return "5.1.139";
+	return "5.1.140";
 };
 /** {@link ElementWrapper#dispose}
 * @override