@refinitiv-ui/efx-grid 6.0.46 → 6.0.48

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

@@ -112,6 +112,8 @@ declare class DataTable extends DataCache {
 
     public getSegmentChildIds(segmentId: string): (string)[]|null;
 
+    public sortSeparators(sortLogics: ((...params: any[]) => any)|(((...params: any[]) => any))[]|null, sortOrders: (number)[]|null, cids: (string)[]|null): boolean;
+
     public sortSegments(compare: ((...params: any[]) => any)|null): boolean;
 
     public setClassificationSource(dc: DataCache|null): void;

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

@@ -76,6 +76,14 @@ DataTable.prototype._removedRows = null;
 */
 DataTable.prototype._userSegmentComparer = null;
 /** @private
+* @type {number}
+*/
+DataTable.prototype._segmentSortOrder = 0;
+/** @private
+* @type {*}
+*/
+DataTable.prototype._segmentSortContext = null;
+/** @private
 * @type {Object.<string, Object>}
 */
 DataTable.prototype._clsSource = null;
@@ -1248,6 +1256,51 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 	}
 	return null;
 };
+/** Sort all of existing segments by multiple sort logics
+* @public
+* @param {Function|Array.<Function>} sortLogics
+* @param {Array.<number>} sortOrders
+* @param {Array.<string>} cids
+* @return {boolean}
+*/
+DataTable.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
+	var dirty = false;
+	if(!this._segments){
+		return false;
+	}
+	if(typeof sortLogics === "function"){
+		return this.sortSegments(sortLogics);
+	}
+	var sortingDefs = DataTable._buildSortContext(
+		[],
+		cids,
+		sortOrders,
+		sortLogics
+	);
+	var defCount = sortingDefs ? sortingDefs.length : 0;
+	if(!defCount){
+		return dirty;
+	}
+
+	var sortOrder = 0;
+	var sortLogic, sortContext;
+	if(defCount > 1) {
+		sortLogic = DataTable._multiColumnSeparatorCompareLogic;
+		sortContext = sortingDefs;
+		sortOrder = 1; // sortOrder is not used by _multiColumnSeparatorCompareLogic
+	} else { // Single level sorting
+		sortLogic = DataTable._singleColumnSeparatorCompareLogic;
+		sortContext = sortingDefs[0];
+		sortOrder = /** @type{number} */(sortContext[3]);
+	}
+	this._segmentSortOrder = sortOrder;
+	this._segmentSortContext = sortContext;
+	dirty = this.sortSegments(sortLogic);
+	this._segmentSortOrder = 0;
+	this._segmentSortContext = null;
+
+	return dirty;
+};
 /** Sort all of existing segments by given compare function
 * @public
 * @param {Function} compare
@@ -1316,7 +1369,9 @@ DataTable.prototype.sortSegments = function (compare) {
 DataTable.prototype._bySegmentSeparator = function (segmentA, segmentB) {
 	return /** @type{number} */(this._userSegmentComparer(
 		this.getRowData(segmentA.getId()),
-		this.getRowData(segmentB.getId())
+		this.getRowData(segmentB.getId()),
+		this._segmentSortOrder,
+		this._segmentSortContext
 	));
 };
 
@@ -1657,6 +1712,47 @@ DataTable._singleColumnCompareLogic = function(a, b, order, sortingDef) {
 		sortingDef[4] // Context object
 	));
 };
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {*} a
+* @param {*} b
+* @param {number} order Not used by in this method
+* @param {Array.<Array>} sortingDefs
+* @return {number}
+*/
+DataTable._multiColumnSeparatorCompareLogic = function(a, b, order, sortingDefs) {
+	var count = sortingDefs.length;
+	var result = 0;
+	for(var c = 0; c < count; ++c) {
+		var sortingDef = sortingDefs[c];
+		result = DataTable._singleColumnSeparatorCompareLogic(a, b, sortingDef[3], sortingDef);
+		if(result) {
+			return result;
+		}
+	}
+	return result;
+};
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {*} a
+* @param {*} b
+* @param {number} order
+* @param {Array} sortingDef
+* @return {number}
+*/
+DataTable._singleColumnSeparatorCompareLogic = function(a, b, order, sortingDef) {
+	var key = /** @type{string} */(sortingDef[0]);
+	return /** @type{number} */(sortingDef[2](
+		a[key], // Value1
+		b[key], // Value2
+		order, // Sort order (3)
+		sortingDef[4] // Context object
+	));
+};
 /** @public
 * @function
 * @ignore

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

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

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

@@ -68,8 +68,6 @@ var DataView = function(source) {
 	t._onRefreshTimeout = t._onRefreshTimeout.bind(t);
 	t._updateWrapCount = t._updateWrapCount.bind(t);
 
-	t._byRemovalMap = t._byRemovalMap.bind(t);
-
 	t._rids = [];
 	t._sortingDefs = [];
 	t._columnStats = {};
@@ -123,15 +121,6 @@ DataView.prototype._hiddenRids = null;
 * @type {Object.<string, boolean>}
 */
 DataView.prototype._collapsedRids = null; // for segmentation
-/** @private
-* @type {Object.<string, number>}
-*/
-DataView.prototype._excludedRids = null;
-/** @private
-* @type {boolean}
-*/
-DataView.prototype._emptySegmentFiltering = false;
-
 /** @private
 * @type {Object.<string, number>}
 */
@@ -828,6 +817,8 @@ DataView.prototype.hideRow = function(rId, hidden) {
  */
 DataView.prototype.hideRows = function(rowRefs, hidden) {
 	hidden = hidden !== false;
+	var dirty = false;
+	var rids = this._toRowIds(rowRefs);
 	var hiddenRids = this._hiddenRids;
 
 	if(hidden){
@@ -838,19 +829,11 @@ DataView.prototype.hideRows = function(rowRefs, hidden) {
 		return; // All rows are visible
 	}
 
-	var rids = this._toRowIds(rowRefs);
-	var dirty = false;
-
 	for(var i = rids.length; --i >= 0;) {
 		var rid = rids[i];
 		if(rid) { // undefined, null, and an empty string value are not a valid row id
-			if(hidden) {
-				if(!hiddenRids[rid]) {
-					hiddenRids[rid] = true;
-					dirty = true;
-				}
-			} else if(hiddenRids[rid]) {
-				delete hiddenRids[rid];
+			if(!!hiddenRids[rid] !== hidden) {
+				hiddenRids[rid] = hidden;
 				dirty = true;
 			}
 		}
@@ -859,9 +842,11 @@ DataView.prototype.hideRows = function(rowRefs, hidden) {
 	if(dirty) {
 		if(!hidden) {
 			var hasHiddenRow = false;
-			for(var key in hiddenRids) { // eslint-disable-line
-				hasHiddenRow = true;
-				break;
+			for(var key in hiddenRids) {
+				if(hiddenRids[key]) {
+					hasHiddenRow = true;
+					break;
+				}
 			}
 			if(!hasHiddenRow) {
 				hiddenRids = this._hiddenRids = null;
@@ -950,14 +935,23 @@ DataView.prototype.filterOut = function(cid, value) {
 */
 DataView.prototype.filterInOnce = function(cid, value, opt_filteringOut) {
 	var checker = this._getFilterLogic(cid, value);
+	if(!checker) { return; }
+
+	var filteringOut = (opt_filteringOut === true);
+	var rids = this._rids;
+	var dt = this._dt;
 	var removalMap = {};
-	if(!this._getRemovalMap(
-		removalMap,
-		checker,
-		(opt_filteringOut === true)
-	)) {
-		return;
+	var totalRem = 0;
+	var len = rids.length;
+	for(var i = len; --i >= 0;) {
+		var rid = rids[i];
+		var values = dt.getRowData(rid);
+		if (!values || checker(rid, values) === filteringOut) {
+			removalMap[rid] = true;
+			++totalRem;
+		}
 	}
+	if(totalRem <= 0) { return; }
 
 	var firstChange = this._removeRowIds(removalMap);
 
@@ -980,13 +974,13 @@ DataView.prototype.filterOutOnce = function(cid, value) {
 	this.filterInOnce(cid, value, true);
 };
 /** @private
-* @param {!Object} removalMap
+* @param {!Object.<string, *>} removalMap
 * @return {number}
 */
 DataView.prototype._removeRowIds = function(removalMap) {
-	var firstChange = DataView._removeArrayItems(this._rids, removalMap);
+	var firstChange = this._removeArrayItems(this._rids, removalMap);
 	if(this._groupView) {
-		firstChange = DataView._removeArrayItems(this._groupView, removalMap);
+		firstChange = this._removeArrayItems(this._groupView, removalMap);
 	}
 
 	if(this._groupMembers) {
@@ -2548,6 +2542,15 @@ DataView.prototype.getSegmentIds = function() {
 DataView.prototype.getSegmentChildIds = function(segmentRef) {
 	return this._dt.getSegmentChildIds(this._toRowId(segmentRef));
 };
+/** Sort all of existing segments by multiple sort logics
+* @public
+* @param {Array.<Function>} sortLogics
+* @param {Array.<number>} sortOrders
+* @param {Array.<string>} cids
+*/
+DataView.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
+	this._dt.sortSeparators(sortLogics, sortOrders, cids);
+};
 /** Sort all of existing segments by given compare function
 * @public
 * @param {Function} compare
@@ -2555,19 +2558,6 @@ DataView.prototype.getSegmentChildIds = function(segmentRef) {
 DataView.prototype.sortSegments = function (compare) {
 	this._dt.sortSegments(compare);
 };
-/** Automatically hide empty segment when all of its member are filtered out. An empty segment will not be hidden, if there is no active filter. Collapsed segment does not count as filtering.
-* @public
-* @param {boolean=} enabled
-*/
-DataView.prototype.enableEmptySegmentFiltering = function (enabled) {
-	enabled = enabled !== false;
-	if(this._emptySegmentFiltering !== enabled) {
-		this._emptySegmentFiltering = enabled;
-		if(this._userFilter) {
-			this._refreshAndNotify();
-		}
-	}
-};
 
 /**
 * @public
@@ -2728,35 +2718,26 @@ DataView.prototype._updateRowIds = function(opt_rowIds) {
 	// Perform the following sequences: parent view cloning >> row hiding >> row filtering >> row grouping >> sorting >> paging
 	this._rids = opt_rowIds || this._parent.getAllRowIds(); // Get all data ids
 
-	this._dispatch("beforeFiltering", {});
-
-	this._excludedRids = {};
-	var exclusionCount = 0;
-	exclusionCount += DataView._copyObjectKeys(this._excludedRids, this._hiddenRids);
-
-	// Segment separators should not be filtered out (hidden)
+	if(this._hiddenRids) {
+		this._removeArrayItems(this._rids, this._hiddenRids);
+	}
 	var segments = this._dt._getSegmentSeparators();
-	var filterExceptions = segments ? segments.getSegments() : null;
-	var userRemoval = this._getRemovalMap(this._excludedRids, this._userFilter, this._filteringOut, filterExceptions);
-	exclusionCount += userRemoval;
-
 	this._collapsedRids = null;
+	var filterExceptions = null;
 	if(segments) {
-		if(userRemoval && this._emptySegmentFiltering) {
-			exclusionCount += this._getEmptySegments(this._excludedRids, filterExceptions);
+		filterExceptions = segments.getSegments(); // Segment separators should not be filtered out (hidden)
+		var collapsedRows = this._collapsedRids = segments.getCollapsedRows(); // Children of collapsed segments must be filtered out (hidden)
+		if(collapsedRows) {
+			this._removeArrayItems(this._rids, collapsedRows);
 		}
-		this._collapsedRids = segments.getCollapsedRows();
-		 // Children of collapsed segments must be filtered out (hidden)
-		exclusionCount += DataView._copyObjectKeys(this._excludedRids, this._collapsedRids);
 	}
 
-	if(this._groupLevel > 0 && !opt_rowIds) { // WARNING: The line below is quite slow
-		exclusionCount += this._getRemovalMap(this._excludedRids, this._groupFilterLogic, false); // Filter In
-	}
-	if(exclusionCount) {
-		this._rids = this._rids.filter(this._byRemovalMap);
+	this._dispatch("beforeFiltering", {});
+	this._quickFilter(this._userFilter, this._filteringOut, filterExceptions);
+
+	if(this._groupLevel > 0 && !opt_rowIds) {
+		this._quickFilter(this._groupFilterLogic, false); // Filter In
 	}
-	this._excludedRids = null;
 
 	if(this._groupMembers) { // Has grouping
 		this._populateGroups(); // View will be properly re-populate inside _populateGroups()
@@ -3028,9 +3009,9 @@ DataView.prototype._onRowUpdated = function(e) { // onUpdate
 
 		if(this._groupLevel > 0) {
 			if(processingFlag === 1) { // The row is moved to the other group
-				if(DataView._removeArrayItem(this._rids, rid) >= 0) {
+				if(this._removeArrayItem(this._rids, rid) >= 0) {
 					if(this._groupView) {
-						DataView._removeArrayItem(this._groupView, rid);
+						this._removeArrayItem(this._groupView, rid);
 					}
 				}
 				if(this._shared.multiGroupRow) {
@@ -3230,31 +3211,34 @@ DataView.prototype._getRowIndex = function(rids, opt_nextRid, opt_fallback) {
 * @returns {number}
 */
 DataView.prototype._removeDataRow = function(rid) {
-	var at = DataView._removeArrayItem(this._rids, rid);
+	var at = this._removeArrayItem(this._rids, rid);
 	if(this._groupView && at >= 0) {
-		at = DataView._removeArrayItem(this._groupView, rid);
+		at = this._removeArrayItem(this._groupView, rid);
 	}
 	return at;
 };
 /** @private
-* @param {!Array} ary
+* @param {Array} ary
 * @param {*} item
 * @return {number} Index of the removed item
 */
-DataView._removeArrayItem = function(ary, item) {
-	var at = ary.indexOf(item);
-	if(at >= 0) {
-		ary.splice(at, 1);
+DataView.prototype._removeArrayItem = function(ary, item) {
+	var len = ary.length;
+	for(var i = 0; i < len; ++i) {
+		if(ary[i] === item) {
+			ary.splice(i, 1);
+			return i;
+		}
 	}
-	return at;
+	return -1;
 };
 /** Remove multiple array items
 * @private
 * @param {Array.<string>} ary
-* @param {Object} items
+* @param {Object.<string, *>} items
 * @return {number} First item index that is being removed. NaN if no item is removed
 */
-DataView._removeArrayItems = function(ary, items) {
+DataView.prototype._removeArrayItems = function(ary, items) {
 	var f = NaN;
 	var c = 0;
 	for(var i = ary.length; --i >= 0;) {
@@ -3273,23 +3257,6 @@ DataView._removeArrayItems = function(ary, items) {
 	return f;
 };
 /** @private
-* @param {Object} baseObj
-* @param {Object} masterObj
-* @returns {number}
-*/
-DataView._copyObjectKeys = function(baseObj, masterObj) {
-	if(masterObj) {
-		var count = 0;
-
-		for(var key in masterObj) {
-			baseObj[key] = 1;
-			++count; // WARNING: duplicated key can be counted more than once
-		}
-		return count;
-	}
-	return 0;
-};
-/** @private
 * @param {string|null} rid
 * @param {Object} rowData
 * @return {boolean}
@@ -3323,6 +3290,9 @@ DataView.prototype.isRowFiltered = function(rid, rowData) {
 			return true;
 		}
 	}
+	if(this.isSegmentSeparator(rid)) {
+		return false; // Segment separator cannot be filtered
+	}
 	if(this._collapsedRids) {
 		if(this._collapsedRids[rid]) {
 			return true;
@@ -3364,90 +3334,40 @@ DataView.prototype._sort = function() {
 };
 
 /** @private
-* @param {string} rid
-* @returns {boolean}
-*/
-DataView.prototype._byRemovalMap = function(rid) {
-	return !this._excludedRids[rid];
-};
-/** @private
-* @param {Object} removalMap
 * @param {Function} checker
 * @param {boolean} filteringOut
 * @param {Object=} exceptions
-* @returns {number} Number of rids that would be filtered out
 */
-DataView.prototype._getRemovalMap = function(removalMap, checker, filteringOut, exceptions) {
+DataView.prototype._quickFilter = function(checker, filteringOut, exceptions) {
 	if(!checker) {
-		return 0;
+		return;
 	}
 
 	var rids = this._rids; // Make local variable to speed up the process
-	var dt = this._dt;
-	var count = 0;
-	var rid, i, values;
 	var len = rids.length;
-
-	if(exceptions) {
-		for(i = len; --i >= 0;) {
-			rid = rids[i];
-			if(!exceptions[rid]) {
-				values = dt.getRowData(rid);
-				if (values) {
-					if(checker(rid, values) === filteringOut) {
-						removalMap[rid] = 1;
-						++count;
-					}
-				} else {
-					removalMap[rid] = 1;
-					++count;
-				}
-			}
-		}
-	} else {
-		for(i = len; --i >= 0;) {
-			rid = rids[i];
-			values = dt.getRowData(rid);
+	var dt = this._dt;
+	var spliceCount = 0;
+	for(var i = len; --i >= 0;) {
+		var rid = rids[i];
+		var removed = false;
+		if(!exceptions || !exceptions[rid]) {
+			var values = dt.getRowData(rid);
 			if (values) {
-				if(checker(rid, values) === filteringOut) {
-					removalMap[rid] = 1;
-					++count;
-				}
+				removed = checker(rid, values) === filteringOut;
 			} else {
-				removalMap[rid] = 1;
-				++count;
+				removed = true;
 			}
 		}
-	}
-	return count;
-};
-/** @private
-* @param {Object} removalMap
-* @param {Object} segmentRids
-* @returns {number} Number of rids that would be filtered out
-*/
-DataView.prototype._getEmptySegments = function(removalMap, segmentRids) {
-	var segments = this._dt._getSegmentSeparators();
-	var count = 0;
-	for(var segmentId in segmentRids) {
-		var segment = segments.getSegment(segmentId);
-		if(segment) {
-			var chdr = segment.getChildren();
-			var emptySegment = true;
-			for(var childId in chdr) {
-				if(!removalMap[childId]) {
-					emptySegment = false;
-					break;
-				}
-			}
-			if(emptySegment) {
-				removalMap[segmentId] = 1;
-				++count;
-			}
+		if(removed) {
+			++spliceCount;
+		} else if(spliceCount > 0) {
+			rids.splice(i + 1, spliceCount);
+			spliceCount = 0;
 		}
 	}
-
-	return count;
+	if(spliceCount > 0) {
+		rids.splice(0, spliceCount);
+	}
 };
 /** @private
 * @param {string|Function|undefined} cid
@@ -3727,13 +3647,13 @@ DataView.prototype._removeGroupMember = function (groupIndex, groupId) {
 };
 /** @private
 * @param {string} cid
-* @param {Object} values
+* @param {Object.<string, *>} values
 * @return {Array.<string>}
 */
 DataView.prototype._defaultGroupCriteria = function(cid, values) {
 	var val = values[cid];
 	if(Array.isArray(val)) {
-		return val.map(function(data) { // TODO: this is very slow
+		return val.map(function(data) {
 			return data + "";
 		});
 	} else {
@@ -3742,11 +3662,11 @@ DataView.prototype._defaultGroupCriteria = function(cid, values) {
 };
 /** @private
 * @param {string|null} rid
-* @param {Object} values
+* @param {Object.<string, *>} values
 * @return {boolean}
 */
 DataView.prototype._groupFilterLogic = function(rid, values) {
-	var gids = this._groupCriteria[this._groupLevel - 1](values); // TODO: this is very slow
+	var gids = this._groupCriteria[this._groupLevel - 1](values);
 	return gids.indexOf(this._groupId) >= 0;
 };
 

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

@@ -27,8 +27,6 @@ declare class Segment extends EventDispatcher {
 
     public getChildIds(): (string)[];
 
-    public getChildren(): any;
-
     public getChildCount(): number;
 
     public getClassification(): (string)[]|null;

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

@@ -292,12 +292,6 @@ Segment.prototype.getChildIds = function() {
 	return this._childCount ? Object.keys(this._children) : [];
 };
 /** @public
-* @return {!Object}
-*/
-Segment.prototype.getChildren = function() {
-	return this._children;
-};
-/** @public
 * @return {number}
 */
 Segment.prototype.getChildCount = function() {

package/lib/core/es6/grid/Core.d.ts

@@ -405,6 +405,10 @@ declare class Core extends ElementWrapper {
 
     public getColumnGroupChildIds(groupId: string): (string)[]|null;
 
+    public getValidColumnList(colIds: (string)[]|null, columnMap?: any): (string)[];
+
+    public createColumnMap(colIds?: (string)[]|null): any;
+
     public startBatch(batchType: string): boolean;
 
     public stopBatch(batchType: string): boolean;