@refinitiv-ui/efx-grid 6.0.157 → 6.0.159

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

@@ -96,7 +96,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>
@@ -206,6 +205,7 @@ DataTable.prototype.getPreviousData = function(rid, cid) {
 	return null;
 };
 
+
 /** Set data to individual cell
 * @override
 * @param {string} rid Row Id
@@ -286,7 +286,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);
@@ -731,7 +734,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);
@@ -988,6 +991,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();
 	}
@@ -1054,9 +1060,6 @@ DataTable.prototype.setSegmentSeparators = function(rids, enabled) {
 			}
 		}
 	}
-	if (segmentAdded) {
-		this._segments.calcSegmentOrder(this._rids);
-	}
 	let changed = segmentAdded || segmentRemoved;
 	if(changed && this._needFiring()) {
 		this.dispatchGlobalChange();
@@ -1084,7 +1087,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
@@ -1209,6 +1211,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;
@@ -1286,9 +1289,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);
 	}
@@ -1477,7 +1477,6 @@ DataTable.prototype.sortSegments = function (compare) {
 		return false;
 	}
 	if(typeof compare !== "function") {
-		this._segments.calcSegmentOrder(this._rids);
 		return false;
 	}
 
@@ -1512,7 +1511,6 @@ DataTable.prototype.sortSegments = function (compare) {
 	}
 
 	if(dirty) {
-		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
 	}
@@ -1520,18 +1518,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

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

@@ -516,6 +516,7 @@ DataView.prototype.getAllRowData = function() {
 	return this.getMultipleRowData(this.getAllRowIds(true));
 };
 
+
 /** @public
 * @param {string} rid
 * @param {string} cid

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

@@ -53,9 +53,7 @@ declare class Segment extends EventDispatcher {
 
     public getAllSubSegments(out_ary?: (Segment)[]|null): (Segment)[]|null;
 
-    public updateTreeStructure(counter: number): number;
-
-    public calcSubSegmentOrder(counter: number): number;
+    public updateTreeStructure(counter: number, rootOrder: number, ridMap: any): number;
 
     public getSegmentLevel(): number;
 
@@ -87,5 +85,7 @@ declare class Segment extends EventDispatcher {
 
 }
 
+declare const UNCATEGORY: string;
+
 export default Segment;
-export { Segment };
+export { Segment, UNCATEGORY };

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

@@ -16,6 +16,12 @@ let Segment = function(rid, sharedObj) {
 };
 Ext.inherits(Segment, EventDispatcher);
 
+/** @public
+* @type {string}
+* @constant
+*/
+const UNCATEGORY = "Uncategorized";
+
 /** @private
 * @function
 * @param {string} a
@@ -23,10 +29,10 @@ Ext.inherits(Segment, EventDispatcher);
 * @return {number}
 */
 Segment._subSegSortLogic = function(a, b) {
-	if(a === "Uncategorized") {
+	if(a === UNCATEGORY) {
 		return 1;
 	}
-	if(b === "Uncategorized") {
+	if(b === UNCATEGORY) {
 		return -1;
 	}
 
@@ -503,7 +509,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 + "";
 			}
@@ -579,13 +585,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
@@ -653,65 +652,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}
 */
@@ -761,14 +763,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
@@ -778,26 +772,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
@@ -911,28 +896,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
@@ -941,10 +913,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
@@ -952,12 +923,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
@@ -1026,4 +998,4 @@ Segment.prototype.log = function(lines, tabLevel) {
 
 
 export default Segment;
-export { Segment };
+export { Segment, UNCATEGORY };

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

@@ -1,6 +1,6 @@
 import Ext from "../../../tr-grid-util/es6/Ext.js";
 import EventDispatcher from "../../../tr-grid-util/es6/EventDispatcher.js";
-import Segment from "./Segment.js";
+import { Segment, UNCATEGORY } from "./Segment.js";
 
 declare class SegmentCollection extends EventDispatcher {
 
@@ -44,6 +44,8 @@ declare class SegmentCollection extends EventDispatcher {
 
     public getCollapsedRows(): any;
 
+    public invalidateSegmentOrder(): boolean;
+
     public addSegmentChild(segmentId: string, rid: string, dataId?: string|null): boolean;
 
     public addSegmentChildren(segmentId: string, rids: (string)[]|null, dataIds?: (string)[]|null): boolean;
@@ -62,6 +64,8 @@ declare class SegmentCollection extends EventDispatcher {
 
     public calcSegmentOrder(rids: (string)[]|null, useCache?: boolean|null): void;
 
+    public getSegmentValues(rids: (string)[], partial?: boolean|null): (number)[]|null;
+
     public logStructure(): string;
 
     public logRowIdMap(): string;