@refinitiv-ui/efx-grid 6.0.157 → 6.0.159

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

@@ -9153,6 +9153,12 @@ let Segment = function(rid, sharedObj) {
 };
 es6_Ext.inherits(Segment, es6_EventDispatcher);
 
+/** @public
+* @type {string}
+* @constant
+*/
+const UNCATEGORY = "Uncategorized";
+
 /** @private
 * @function
 * @param {string} a
@@ -9160,10 +9166,10 @@ es6_Ext.inherits(Segment, es6_EventDispatcher);
 * @return {number}
 */
 Segment._subSegSortLogic = function(a, b) {
-	if(a === "Uncategorized") {
+	if(a === UNCATEGORY) {
 		return 1;
 	}
-	if(b === "Uncategorized") {
+	if(b === UNCATEGORY) {
 		return -1;
 	}
 
@@ -9640,7 +9646,7 @@ Segment.prototype.classify = function(rows) {
 
 			sharedObj.childToSegment[rid] = this._rid; // Relocate child in case of it has been moved to a non existence group
 
-			segmentName = "Uncategorized";
+			segmentName = UNCATEGORY;
 			if(val || val === 0 || val === false) { // Check for null, undefined, "", and NaN value
 				segmentName = val + "";
 			}
@@ -9716,13 +9722,6 @@ Segment.prototype.classify = function(rows) {
 		}
 	}
 
-	// Collecting all subsegments including all descendants and reassigning segment order.
-	if(rootSegment && this._subSegDef) {
-		if(segmentCount) {
-			this.calcSubSegmentOrder(0);
-		}
-		// this._subSegDef.classifierChanged = false;
-	}
 	return true;
 };
 /** SubSegment implies being classified
@@ -9790,65 +9789,68 @@ Segment.prototype.getAllSubSegments = function(out_ary) {
 /** This method sets order, last order, and depth to entire tree structure in the segment, including the segment itself
 * @public
 * @param {number} counter
-* @return {number}
+* @param {number} rootOrder
+* @param {Object} ridMap Row id map that stores row order of the entire tree
+* @return {number} Last order of the segment
 */
-Segment.prototype.updateTreeStructure = function(counter) {
+Segment.prototype.updateTreeStructure = function(counter, rootOrder, ridMap) {
 	if(!counter) {
 		counter = 0;
 		if(!this._subSegment) { // Subsegment's depth cannot be reset back to 0
 			this._depth = 0; // WARNING: this assumes counter at 0 is the root segment
 		}
 	}
-	if(this.hasSubSegments()) {
-		return this.setLastOrder(counter); // Sub segments has already been calculated
+	if(!rootOrder) {
+		rootOrder = 0;
 	}
-	let segmentSeparators = this._shared.segments;
-	let childCount = this._childIds.length;
-	let prevSeg = null;
-	for(let i = 0; i < childCount; ++i) {
-		let rid = this._childIds[i];
-		let segment = segmentSeparators[rid];
-		let segmentId = (segment) ? segment.getId() : "Uncategorized";
-		if(prevSeg !== segmentId) {
-			++counter; // 0 become 1
-			prevSeg = segmentId;
+	if(!ridMap) {
+		ridMap = {};
+	}
+
+	let i;
+	let segmentNames = this._subSegNames;
+	let subSegmentCount = segmentNames ? segmentNames.length : 0;
+	if(subSegmentCount) { // Classified segment
+		let segmentMap = this._subSegMap;
+		for(i = 0; i < subSegmentCount; ++i) {
+			let subSegment = segmentMap[segmentNames[i]];
+			++counter;
+			ridMap[subSegment.getId()] = rootOrder + counter;
+			subSegment.setOrder(counter);
+			counter = subSegment.updateTreeStructure(counter, rootOrder, ridMap);
 		}
-		if(segment) {
-			segment._depth = this._depth + 1;
-			segment.setOrder(counter);
-			counter = segment.updateTreeStructure(counter);
+	} else {
+		let childIds = this._childIds;
+		let childCount = childIds.length;
+		let segmentSeparators = this._shared.segments;
+		let prevSeg = "";
+		for(i = 0; i < childCount; ++i) {
+			let childId = childIds[i];
+			let childSegment = segmentSeparators[childId];
+			let segmentId = (childSegment) ? childSegment.getId() : UNCATEGORY;
+			if(prevSeg !== segmentId) {
+				++counter;
+				prevSeg = segmentId;
+			}
+			ridMap[childId] = rootOrder + counter;
+			if(childSegment) {
+				childSegment._depth = this._depth + 1;
+				childSegment.setOrder(counter);
+				counter = childSegment.updateTreeStructure(counter, rootOrder, ridMap);
+			}
 		}
 	}
 
 	return this.setLastOrder(counter);
 };
-/** @public
+/** Deprecated.
+* @ignore
+* @public
+* @function
 * @param {number} counter
 * @return {number}
 */
-Segment.prototype.calcSubSegmentOrder = function(counter) {
-	if(!this.hasSubSegments()) {
-		return this.setLastOrder(counter);
-	}
-
-	let segmentMap = this._subSegMap;
-	let childCount = this._subSegNames.length;
-	let prevSeg = null;
-	for(let i = 0; i < childCount; ++i) {
-		let segmentName = this._subSegNames[i];
-		let segment = segmentMap[segmentName];
-		let segmentId = (segment) ? segment.getId() : "Uncategorized";
-		if(prevSeg !== segmentId) {
-			++counter; // 0 become 1
-			prevSeg = segmentId;
-		}
-		if(segment) {
-			segment.setOrder(counter);
-			counter = segment.calcSubSegmentOrder(counter);
-		}
-	}
-	return this.setLastOrder(counter);
-};
+Segment.prototype.calcSubSegmentOrder = Segment.prototype.updateTreeStructure;
 /** @public
 * @return {number}
 */
@@ -9898,14 +9900,6 @@ 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
@@ -9915,26 +9909,17 @@ Segment.prototype.sortSegments = function(comparer) {
 		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(segments[childIds[i]]) {
+			this._childIds.sort(comparer); // Perform segment sorting only if children have at least one segment
+			return true;
 		}
 	}
-	if(segmentList.length < 2) {
-		return false;
-	}
-	segmentList.sort(comparer);
-	this._childIds = rids.concat(segmentList.map(_toSegmentId));
-	return true;
+
+	return false;
 };
 /** Get segment id and ids of children, including nested segments, but excluding sub segments
 * @public
@@ -10048,28 +10033,15 @@ Segment.prototype.getCollapsingStates = function(objMap, parentState) {
 	return dirty;
 };
 
-/** @private
-* @return {number}
-*/
-Segment.prototype._getOrder = function() {
-	return this._order * 10000;
-};
-/** @private
-* @return {number}
-*/
-Segment.prototype._getLastOrder = function() {
-	return this._getOrder() + this._offsetOrder;
-};
 /** @public
 * @return {number}
 */
 Segment.prototype.getOrder = function() {
 	let ancestor = this.getFirstAncestor();
 	if(ancestor) {
-		// WARNING: this._order cannot be greater than 9999
-		return ancestor._getOrder() + this._order;
+		return ancestor._order + this._order;
 	}
-	return this._getOrder();
+	return this._order; // This is root order
 };
 /** Get the last (highest) order from the entire tree regardless of the current position segment in the hierachy
 * @public
@@ -10078,10 +10050,9 @@ Segment.prototype.getOrder = function() {
 Segment.prototype.getLastOrder = function() {
 	let ancestor = this.getFirstAncestor();
 	if(ancestor) {
-		// WARNING: this._order cannot be greater than 9999
-		return ancestor._getLastOrder();
+		return ancestor.getLastOrder();
 	}
-	return this._getLastOrder();
+	return this._order + this._offsetOrder; // This is root last order
 };
 /** @public
 * @param {number} val
@@ -10089,12 +10060,13 @@ Segment.prototype.getLastOrder = function() {
 Segment.prototype.setOrder = function(val) {
 	this._order = val;
 };
-/** @public
+/** WARNING: This actually sets offset from the starting order
+* @public
 * @param {number} val
 * @returns {number} Returns the number set
 */
 Segment.prototype.setLastOrder = function(val) {
-	return (this._offsetOrder = val);
+	return (this._offsetOrder = val); // WARNING: this._offsetOrder cannot be greater than 9999
 };
 
 /** @private
@@ -10162,7 +10134,7 @@ Segment.prototype.log = function(lines, tabLevel) {
 };
 
 
-/* harmony default export */ const data_Segment = (Segment);
+/* harmony default export */ const data_Segment = ((/* unused pure expression or super */ null && (Segment)));
 
 
 ;// CONCATENATED MODULE: ./node_modules/@grid/core/es6/data/SegmentCollection.js
@@ -10210,7 +10182,7 @@ SegmentCollection.prototype._shared;
 /** @type {Array.<Segment>}
 * @private
 */
-SegmentCollection.prototype._segmentList = null; // Array of main segments
+SegmentCollection.prototype._segmentList = null; // Array of main/root segments
 /** @type {Array.<Segment>}
 * @private
 */
@@ -10227,6 +10199,10 @@ SegmentCollection.prototype._classification = false;
 * @private
 */
 SegmentCollection.prototype._classifierChanged = false;
+/** @type {Object.<string, number>}
+* @private
+*/
+SegmentCollection.prototype._rowOrders = null;
 
 /** @public
 */
@@ -10234,7 +10210,7 @@ SegmentCollection.prototype.dispose = function() {
 	this.removeAllSegments();
 	this.removeAllEventListeners();
 	this._collapsedRids = null;
-	this._segmentList = this._insertionList = this._removalList = null;
+	this._segmentList = this._rowOrders = this._insertionList = this._removalList = null;
 };
 /** @public
 * @param {string} rid
@@ -10243,11 +10219,11 @@ SegmentCollection.prototype.dispose = function() {
 */
 SegmentCollection.prototype.addSegment = function(rid, childRids) {
 	if(rid && !this._segments[rid]) {
-		let segment = this._segments[rid] = new data_Segment(rid, this._shared);
+		let segment = this._segments[rid] = new Segment(rid, this._shared);
 		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
 		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
 		++this._segmentCount;
-		this._segmentList = null; // order could be changed
+		this.invalidateSegmentOrder(); // order could be changed
 
 		if(childRids && childRids.length) {
 			segment.addChildren(childRids);
@@ -10323,6 +10299,7 @@ SegmentCollection.prototype.removeSegment = function(rid) {
 
 	delete this._segments[rid]; // Slow
 	--this._segmentCount;
+	this.invalidateSegmentOrder();
 	return true;
 };
 /** @public
@@ -10335,7 +10312,7 @@ SegmentCollection.prototype.removeAllSegments = function() {
 		}
 		this._segments = {};
 		this._segmentCount = 0;
-		this._segmentList = null;
+		this._segmentList = this._rowOrders = null;
 		this._shared.segments = this._segments;
 		this._shared.childToSegment = {};
 
@@ -10396,6 +10373,7 @@ SegmentCollection.prototype.sortSegments = function(comparer) {
 		}
 	}
 	rootSegments.sort(comparer);
+	this.invalidateSegmentOrder();
 	return rootSegments;
 };
 
@@ -10491,28 +10469,14 @@ SegmentCollection.prototype.getCollapsedRows = function() {
 	return this._collapsedRids;
 };
 
-/** Invalidate segment order cache, if the given row id is a segment separator
-* @private
-* @param {string|Array.<string>} segmentIds
+/** Invalidate segment order cache
+* @public
 * @returns {boolean} Returns true if there is any change
 */
-SegmentCollection.prototype._invalidateSegmentOrder = function(segmentIds) {
+SegmentCollection.prototype.invalidateSegmentOrder = function() {
 	if(this._segmentList) {
-		if(typeof segmentIds === "string") {
-			if(this._segments[segmentIds]) {
-				this._segmentList = null;
-				return true;
-			}
-		} else if(Array.isArray(segmentIds)) {
-			let len = segmentIds.length;
-			for(let i = 0; i < len; ++i) {
-				let segmentId = segmentIds[i];
-				if(this._segments[segmentId]) {
-					this._segmentList = null;
-					return true;
-				}
-			}
-		}
+		this._segmentList = this._rowOrders = null;
+		return true;
 	}
 	return false;
 };
@@ -10526,7 +10490,7 @@ SegmentCollection.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	let segment = this._segments[segmentId];
 	if(segment && !segment.isSubSegment()) {
 		// If a segment becomes a child of other segment, then the segment order needs to be recalculated
-		this._invalidateSegmentOrder(rid);
+		this.invalidateSegmentOrder();
 		return segment.addChild(rid, dataId);
 	}
 	return false;
@@ -10541,7 +10505,7 @@ SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids, dataI
 	let segment = this._segments[segmentId];
 	if(segment && !segment.isSubSegment()) {
 		// If a segment becomes a child of other segment, then the segment order needs to be recalculated
-		this._invalidateSegmentOrder(rids);
+		this.invalidateSegmentOrder();
 		return segment.addChildren(rids, dataIds);
 	}
 	return false;
@@ -10567,7 +10531,7 @@ SegmentCollection.prototype.containsSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 	let segment = this._segments[segmentId];
 	if(segment) {
-		this._invalidateSegmentOrder(rid);
+		this.invalidateSegmentOrder();
 		return segment.removeChild(rid);
 	}
 	return false;
@@ -10580,7 +10544,7 @@ SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChildren = function(segmentId, rids) {
 	let segment = this._segments[segmentId];
 	if(segment) {
-		this._invalidateSegmentOrder(rids);
+		this.invalidateSegmentOrder();
 		return segment.removeChildren(rids);
 	}
 	return false;
@@ -10600,7 +10564,7 @@ SegmentCollection.prototype.removeAllSegmentChildren = function() {
 	}
 
 	if(dirty) {
-		this._segmentList = null; // WARNING: not optimized
+		this.invalidateSegmentOrder();
 		this.classify(null);
 	}
 
@@ -10630,6 +10594,7 @@ SegmentCollection.prototype.fillSegment = function(segmentId, rids) {
 				}
 				curSegment.addChild(rid);
 			}
+			this.invalidateSegmentOrder();
 		}
 	}
 };
@@ -10655,8 +10620,19 @@ SegmentCollection.prototype.fillSegments = function(rids) {
 			change = true;
 		}
 	}
+	if(change) {
+		this.invalidateSegmentOrder();
+	}
 	return change;
 };
+
+/** The number represent maximum nested segments that can be created in a single segment
+* @private
+* @type {number}
+* @constant
+*/
+const SEGMENT_STEP = 10000;
+
 /** @public
 * @param {Array.<string>} rids
 * @param {boolean=} useCache=false If this is true, skip the calculation when there is already a cache for segment order
@@ -10672,21 +10648,29 @@ SegmentCollection.prototype.calcSegmentOrder = function(rids, useCache) {
 		segmentList = this._segmentList = [];
 	}
 
-	let ridCount = rids ? rids.length : 0;
+	this._rowOrders = {};
+	let rowOrders = this._rowOrders;
 	let segmentSeparators = this._segments;
-	let segmentCount = this._segmentCount;
+	let childToSegmentId = this._shared.childToSegment;
+	let prevSeg = UNCATEGORY;
+	let ridCount = rids ? rids.length : 0;
 	let order = 0;
 	for(let i = 0; i < ridCount; ++i) {
 		let rid = rids[i];
-		let segment = segmentSeparators[rid];
-		if(segment) {
-			if(segment.isRootSegment()) {
-				this._segmentList.push(segment);
-				segment.setOrder(++order); // WARNING: Segments and sub segments start with 1
-				segment.updateTreeStructure(0);
+		if(!childToSegmentId[rid]) {
+			let segment = segmentSeparators[rid];
+			let segmentId = (segment) ? segment.getId() : UNCATEGORY;
+			if(prevSeg !== segmentId) {
+				++order; // WARNING: Segments and sub segments start with 1
+				prevSeg = segmentId;
 			}
-			if(--segmentCount <= 0) {
-				break;
+
+			let rootOrder = order * SEGMENT_STEP;
+			rowOrders[rid] = rootOrder;
+			if(segment) {
+				this._segmentList.push(segment);
+				segment.setOrder(rootOrder);
+				segment.updateTreeStructure(0, rootOrder, rowOrders);
 			}
 		}
 	}
@@ -10695,57 +10679,33 @@ SegmentCollection.prototype.calcSegmentOrder = function(rids, useCache) {
 * @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, partial) {
 	let rowCount = rids ? rids.length : 0;
 	if(!rowCount) {
 		return null;
 	}
-	let segmentSeparators = this._segments;
-	let childToSegmentId = this._shared.childToSegment;
-	let curSegment = null;
-	let prevSegment = null;
+	let rowOrders = this._rowOrders;
+	if(!rowOrders) { // calcSegmentOrder has not been called (no cache detected)
+		return null;
+	}
+
 	let segmentValues = new Array(rowCount);
-	let segmentVal = 0;
 	let highestVal = 0;
-	let offset = 0;
 	for(let r = 0; r < rowCount; ++r) {
 		let rid = rids[r];
-		curSegment = segmentSeparators[rid];
-		if(curSegment) { // segment separator
-			segmentVal = curSegment.getOrder() * 100;
-			offset = 0;
-			if(curSegment.isRootSegment()) {
-				if(prevSegment !== curSegment) {
-					prevSegment = curSegment;
-					highestVal = curSegment.getLastOrder() * 100;
-				}
+		let segmentVal = rowOrders[rid];
+		if(segmentVal != null) {
+			if(highestVal < segmentVal) {
+				highestVal = segmentVal;
 			}
 		} else {
-			let parentId = childToSegmentId[rid];
-			if(parentId) { // segment member
-				curSegment = segmentSeparators[parentId];
-				segmentVal = curSegment.getOrder() * 100;
-				offset = 1;
-				if(partial) { // This fixes the out of order sub segment
-					highestVal = curSegment.getLastOrder() * 100;
-				}
-			} else { // row outside of segments
-				if(highestVal) {
-					if(segmentVal < highestVal) {
-						segmentVal = highestVal;
-					}
-					offset = 10;
-				} else {
-					segmentVal = offset = 0;
-				}
-			}
+			segmentVal = highestVal ? highestVal + SEGMENT_STEP : 0;
 		}
-
-		segmentValues[r] = segmentVal + offset;
+		segmentValues[r] = segmentVal;
 	}
 
-	return prevSegment ? segmentValues : null;
+	return highestVal ? segmentValues : null;
 };
 /** @public
 * @return {string}
@@ -10834,6 +10794,7 @@ SegmentCollection.prototype.classify = function(rows) {
 		}
 	}
 	if(this._insertionList.length || this._removalList.length) {
+		this.invalidateSegmentOrder();
 		this._dispatch("subSegmentChanged", {
 			"insertionList": this._insertionList,
 			"removalList": this._removalList
@@ -10990,7 +10951,6 @@ DataTable.prototype._classifyingTimer = 0;
 */
 DataTable.prototype._segmentDefaultCollapsing = false;
 
-
 /** @typedef {Function} DataTable~SortLogic
 * @description SortLogic function is used for comparison between two values during sorting. <br>
 * The function should return:<br>
@@ -11100,6 +11060,7 @@ DataTable.prototype.getPreviousData = function(rid, cid) {
 	return null;
 };
 
+
 /** Set data to individual cell
 * @override
 * @param {string} rid Row Id
@@ -11180,7 +11141,10 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 					this._rids.push(rid);
 				} else {
 					this._rids.splice(rowIndex, 0, rid);
-					segmentChanged = !this._isLastSegment(rowIndex);
+					if(this._segments) { // for no sorting case
+						this._segments.invalidateSegmentOrder();
+					}
+					segmentChanged = !this._isLastSegment(rowIndex); // This is slow. Check if this is required
 				}
 			} else {
 				this._rids.push(rid);
@@ -11625,7 +11589,7 @@ DataTable.prototype.moveRow = function(fromIndex, toIndex, suppressEvent) {
 
 	if(output) {
 		if(this._segments) {
-			this._segments.calcSegmentOrder(this._rids);
+			this._segments.invalidateSegmentOrder();
 			this._sort(null); // Reorder segment members
 		}
 		this._dispatchPositionChange(suppressEvent);
@@ -11882,6 +11846,9 @@ DataTable.prototype.freeze = function(bool) {
 	let prevState = this._frozen;
 	if(prevState !== bool) {
 		this._frozen = bool;
+		if(!bool && this._segments) { // for no sorting case
+			this._segments.invalidateSegmentOrder();
+		}
 		this._autoFillSegments();
 		this.dispatchGlobalChange();
 	}
@@ -11948,9 +11915,6 @@ DataTable.prototype.setSegmentSeparators = function(rids, enabled) {
 			}
 		}
 	}
-	if (segmentAdded) {
-		this._segments.calcSegmentOrder(this._rids);
-	}
 	let changed = segmentAdded || segmentRemoved;
 	if(changed && this._needFiring()) {
 		this.dispatchGlobalChange();
@@ -11978,7 +11942,6 @@ DataTable.prototype.setSegmentSeparator = function(rid, options) {
 			}
 			let children = (options && options["children"]) ? options["children"] : null;
 			if(this._segments.addSegment(rid, children)) {
-				this._segments.calcSegmentOrder(this._rids);
 				change = true;
 			}
 		} else if(this._segments) { // Remove the separator
@@ -12103,6 +12066,7 @@ DataTable.prototype.getSegmentParentRowId = function(rid) {
 */
 DataTable.prototype.getSegmentValues = function(rids, partial) {
 	if(this._segments) {
+		this._segments.calcSegmentOrder(this._rids, true); // use cache
 		return this._segments.getSegmentValues(rids || this._rids, partial);
 	}
 	return null;
@@ -12180,9 +12144,6 @@ DataTable.prototype.fillSegments = function() {
 * @param {boolean=} adding This indicates that segment is changed by adding a new child
 */
 DataTable.prototype._onSegmentChildChanged = function(adding) {
-	if(this._segments) {
-		this._segments.calcSegmentOrder(this._rids, true);
-	}
 	if(adding !== false) {
 		this._sort(null);
 	}
@@ -12371,7 +12332,6 @@ DataTable.prototype.sortSegments = function (compare) {
 		return false;
 	}
 	if(typeof compare !== "function") {
-		this._segments.calcSegmentOrder(this._rids);
 		return false;
 	}
 
@@ -12406,7 +12366,6 @@ DataTable.prototype.sortSegments = function (compare) {
 	}
 
 	if(dirty) {
-		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
 	}
@@ -12414,18 +12373,34 @@ DataTable.prototype.sortSegments = function (compare) {
 };
 /** Sort all of existing segments by given compare function
 * @private
-* @param {tr.Segment} segmentA
-* @param {tr.Segment} segmentB
+* @param {*} rowA
+* @param {*} rowB
 * @return {number}
 */
-DataTable.prototype._bySegmentSeparator = function (segmentA, segmentB) {
+DataTable.prototype._bySegmentSeparator = function (rowA, rowB) {
 	return /** @type{number} */(this._userSegmentComparer(
-		this.getRowData(segmentA.getId()),
-		this.getRowData(segmentB.getId()),
+		this._getRowDataFromSegment(rowA),
+		this._getRowDataFromSegment(rowB),
 		this._segmentSortOrder,
 		this._segmentSortContext
 	));
 };
+/** Get row data from either Segment or row id
+* @private
+* @param {*} obj
+* @return {Object}
+*/
+DataTable.prototype._getRowDataFromSegment = function (obj) {
+	var rowData = null;
+	if(obj) {
+		if(typeof obj == "string") {
+			rowData = this.getRowData(obj);
+		} else if(obj.getId) {
+			rowData = this.getRowData(obj.getId());
+		}
+	}
+	return rowData;
+};
 
 /** A data source to be used with segment classification
 * @public
@@ -29983,6 +29958,7 @@ DataView.prototype.getAllRowData = function() {
 	return this.getMultipleRowData(this.getAllRowIds(true));
 };
 
+
 /** @public
 * @param {string} rid
 * @param {string} cid
@@ -36834,7 +36810,7 @@ Core.prototype._hasPendingRowChange = false;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.140";
+	return "5.2.2";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -40504,6 +40480,9 @@ Core.prototype.initSimpleTable = function (columns) {
 		colCount = columns.length;
 		this.setColumnCount(colCount);
 		this.setDataColumnMap(columns);
+		for(let c = 0; c < colCount; ++c) {
+			this.setColumnField(c, columns[c]);
+		}
 	}
 
 	let titleSect = this.addSection("title");
@@ -43272,6 +43251,12 @@ RowDefSorter.prototype._multiColumnsSorter = function(rowDefA, rowDefB, primaryO
 * @property {Array.<string>} sortedFields An array of sortedField
 */
 
+/** @private
+* @type {string}
+*@constant
+*/
+const SortableTitlePlugin_ROW_DEF = "ROW_DEF";
+
 /** @constructor
 * @extends {EventDispatcher}
 * @param {SortableTitlePlugin.Options=} options
@@ -43287,6 +43272,7 @@ let SortableTitlePlugin = function (options) { // TODO: Extract SortableTitlePlu
 	_t._onColumnRemoved = _t._onColumnRemoved.bind(_t);
 	_t._onItemSortingClicked = _t._onItemSortingClicked.bind(_t);
 	_t.refresh = _t.refresh.bind(_t);
+	_t._rowDefSorter = _t._rowDefSorter.bind(_t);
 
 	_t._hosts = [];
 	_t._sortLogic = {};
@@ -43448,6 +43434,11 @@ SortableTitlePlugin.prototype._frozenIndicator = false;
 * @type {boolean}
 */
 SortableTitlePlugin.prototype._rowDefMode = false;
+/**
+* @private
+* @type {Function}
+*/
+SortableTitlePlugin.prototype._userComparer = null;
 
 /** @private
 * @type {!Object.<string, string>}
@@ -44624,6 +44615,21 @@ SortableTitlePlugin.prototype.setSortingSequence = function (sequence, colRef) {
 SortableTitlePlugin.prototype.clearAllColumnSortingSequences = function () {
 	this._sortingSequenceMap = null;
 };
+/** @private
+* @param {Object} rowA
+* @param {Object} rowB
+* @param {number} sortOrder
+* @param {*} context
+* @returns {number}
+*/
+SortableTitlePlugin.prototype._rowDefSorter = function (rowA, rowB, sortOrder, context) {
+	return this._userComparer(
+		rowA[SortableTitlePlugin_ROW_DEF].getRowData(),
+		rowB[SortableTitlePlugin_ROW_DEF].getRowData(),
+		sortOrder,
+		context
+	);
+};
 /** @public
 * @description Sorting all separators according to compare function. If compare function is not specified, separators will will be sort by current sorting states.
 * @param {Function} comparer Compare function
@@ -44632,16 +44638,21 @@ SortableTitlePlugin.prototype.sortSeparators = function (comparer) {
 	let host = this._hosts[0];
 	let dv = host.getDataSource();
 	if(comparer){
-		dv.sortSeparators(comparer);
+		if(this._rowDefMode) {
+			this._userComparer = comparer;
+			dv.sortSeparators(this._rowDefSorter);
+			this._userComparer = null;
+		} else {
+			dv.sortSeparators(comparer);
+		}
 	} else {
 		let sortLogics = dv.getSortingLogics();
 		let sortOrders = [];
 		let sortFields = [];
 		let sortStateCount = this._sortStates.length;
-		let rowDefField = SortableTitlePlugin._toRowDefField();
 		for(let i = 0; i < sortStateCount; i++){
 			let sortState = this._sortStates[i];
-			let field = this._rowDefMode ? rowDefField : sortState["field"];
+			let field = this._rowDefMode ? SortableTitlePlugin_ROW_DEF : sortState["field"];
 			sortOrders.push(sortState["sortOrder"]);
 			sortFields.push(field);
 		}
@@ -44891,11 +44902,10 @@ SortableTitlePlugin.prototype._onColumnRemoved = function (e) {
 };
 
 /** @private
-* @param {Object=} sortState
 * @return {string}
 */
-SortableTitlePlugin._toRowDefField = function(sortState) {
-	return "ROW_DEF";
+SortableTitlePlugin._toRowDefField = function() {
+	return SortableTitlePlugin_ROW_DEF;
 };
 /** @private
 * @param {Object=} opt_action Action that raised the sort. This is optional