@refinitiv-ui/efx-grid 6.0.154 → 6.0.155

package/lib/core/es6/data/DataTable.d.ts

@@ -66,7 +66,7 @@ declare class DataTable extends DataCache {
 
     public setDataSource(source: any): void;
 
-    public sortOnce(cid: string|(string)[]|null, sortOrders?: string|number|(string|number)[]|null, customComparer?: DataTable.SortLogic|null, contextObj?: any): boolean;
+    public sortOnce(cid: string|(string)[]|null, sortOrders?: (string|number|(string|number)[])|null, customComparer?: DataTable.SortLogic|null, contextObj?: any): boolean;
 
     public setSortingLogic(func: DataTable.SortLogic|null): void;
 
@@ -122,7 +122,7 @@ declare class DataTable extends DataCache {
 
     public getSegmentChildIds(segmentId: string): (string)[]|null;
 
-    public sortSeparators(sortLogics: ((...params: any[]) => any)|(((...params: any[]) => any))[]|any|null, sortOrders?: (number)[]|null, cids?: (string)[]|null): boolean;
+    public sortSeparators(sortLogics: ((...params: any[]) => any)|(((...params: any[]) => any))[]|any|null, sortOrders?: (number|string)[]|null, cids?: (string)[]|null): boolean;
 
     public sortSegments(compare: ((...params: any[]) => any)|null): boolean;
 

package/lib/core/es6/data/DataTable.js

@@ -911,7 +911,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
@@ -1421,50 +1421,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
@@ -1479,40 +1480,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;
 		}
 	}
@@ -1521,9 +1515,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
@@ -1806,7 +1799,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

package/lib/core/es6/data/DataView.d.ts

@@ -294,7 +294,7 @@ declare class DataView extends EventDispatcher {
 
     public getSegmentChildIds(segmentRef: string|number|null): (string)[]|null;
 
-    public sortSeparators(sortLogics: ((...params: any[]) => any)|(((...params: any[]) => any))[]|any|null, sortOrders?: (number)[]|null, cids?: (string)[]|null): void;
+    public sortSeparators(sortLogics: ((...params: any[]) => any)|(((...params: any[]) => any))[]|any|null, sortOrders?: (number|(number)[])|null, cids?: (string|(string)[])|null): void;
 
     public sortSegments(compare: ((...params: any[]) => any)|null): void;
 

package/lib/core/es6/data/DataView.js

@@ -2697,10 +2697,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

package/lib/core/es6/data/Segment.d.ts

@@ -63,6 +63,10 @@ declare class Segment extends EventDispatcher {
 
     public getSubSegmentName(row?: any): string;
 
+    public sortSegments(comparer: ((...params: any[]) => any)): boolean;
+
+    public getFlattenTreeIds(ary: (string)[]|null): (string)[];
+
     public collapse(bool?: boolean|null): boolean;
 
     public expand(bool?: boolean|null): boolean;

package/lib/core/es6/data/Segment.js

@@ -366,7 +366,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;
 	}
 };
@@ -760,6 +760,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

package/lib/core/es6/data/SegmentCollection.d.ts

@@ -30,6 +30,8 @@ declare class SegmentCollection extends EventDispatcher {
 
     public getSegmentIds(): (string)[];
 
+    public sortSegments(comparer: ((...params: any[]) => any)): (Segment)[];
+
     public collapseSegments(segmentIds: (string)[]|null, bool?: boolean|null): boolean;
 
     public collapseSegment(segmentId: string, bool?: boolean|null): boolean;

package/lib/core/es6/data/SegmentCollection.js

@@ -213,6 +213,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

package/lib/core/es6/grid/Core.js

@@ -622,7 +622,7 @@ Core.prototype._hasPendingRowChange = false;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.139";
+	return "5.1.140";
 };
 /** {@link ElementWrapper#dispose}
 * @override

package/lib/grid/index.js

@@ -1,3 +1,3 @@
 import {Grid} from "./lib/efx-grid.js";
 export {Grid}
-window.EFX_GRID = { version: "6.0.154" };
+window.EFX_GRID = { version: "6.0.155" };