@refinitiv-ui/efx-grid 6.0.43 → 6.0.45

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

@@ -274,6 +274,8 @@ declare class DataView extends EventDispatcher {
 
     public sortSegments(compare: ((...params: any[]) => any)|null): void;
 
+    public enableEmptySegmentFiltering(enabled?: boolean|null): void;
+
     public setSegmentClassification(segmentRef: string|number|null, fields: string|(string)[]|null): boolean;
 
     public getWrapSize(): number;

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

@@ -68,6 +68,8 @@ 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 = {};
@@ -121,6 +123,15 @@ 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>}
 */
@@ -817,8 +828,6 @@ 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){
@@ -829,11 +838,19 @@ 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(!!hiddenRids[rid] !== hidden) {
-				hiddenRids[rid] = hidden;
+			if(hidden) {
+				if(!hiddenRids[rid]) {
+					hiddenRids[rid] = true;
+					dirty = true;
+				}
+			} else if(hiddenRids[rid]) {
+				delete hiddenRids[rid];
 				dirty = true;
 			}
 		}
@@ -842,11 +859,9 @@ DataView.prototype.hideRows = function(rowRefs, hidden) {
 	if(dirty) {
 		if(!hidden) {
 			var hasHiddenRow = false;
-			for(var key in hiddenRids) {
-				if(hiddenRids[key]) {
-					hasHiddenRow = true;
-					break;
-				}
+			for(var key in hiddenRids) { // eslint-disable-line
+				hasHiddenRow = true;
+				break;
 			}
 			if(!hasHiddenRow) {
 				hiddenRids = this._hiddenRids = null;
@@ -935,23 +950,14 @@ 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 = {};
-	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(!this._getRemovalMap(
+		removalMap,
+		checker,
+		(opt_filteringOut === true)
+	)) {
+		return;
 	}
-	if(totalRem <= 0) { return; }
 
 	var firstChange = this._removeRowIds(removalMap);
 
@@ -974,13 +980,13 @@ DataView.prototype.filterOutOnce = function(cid, value) {
 	this.filterInOnce(cid, value, true);
 };
 /** @private
-* @param {!Object.<string, *>} removalMap
+* @param {!Object} removalMap
 * @return {number}
 */
 DataView.prototype._removeRowIds = function(removalMap) {
-	var firstChange = this._removeArrayItems(this._rids, removalMap);
+	var firstChange = DataView._removeArrayItems(this._rids, removalMap);
 	if(this._groupView) {
-		firstChange = this._removeArrayItems(this._groupView, removalMap);
+		firstChange = DataView._removeArrayItems(this._groupView, removalMap);
 	}
 
 	if(this._groupMembers) {
@@ -2549,6 +2555,19 @@ 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
@@ -2709,26 +2728,35 @@ 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
 
-	if(this._hiddenRids) {
-		this._removeArrayItems(this._rids, this._hiddenRids);
-	}
+	this._dispatch("beforeFiltering", {});
+
+	this._excludedRids = {};
+	var exclusionCount = 0;
+	exclusionCount += DataView._copyObjectKeys(this._excludedRids, this._hiddenRids);
+
+	// Segment separators should not be filtered out (hidden)
 	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) {
-		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);
+		if(userRemoval && this._emptySegmentFiltering) {
+			exclusionCount += this._getEmptySegments(this._excludedRids, filterExceptions);
 		}
+		this._collapsedRids = segments.getCollapsedRows();
+		 // Children of collapsed segments must be filtered out (hidden)
+		exclusionCount += DataView._copyObjectKeys(this._excludedRids, this._collapsedRids);
 	}
 
-	this._dispatch("beforeFiltering", {});
-	this._quickFilter(this._userFilter, this._filteringOut, filterExceptions);
-
-	if(this._groupLevel > 0 && !opt_rowIds) {
-		this._quickFilter(this._groupFilterLogic, false); // Filter In
+	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._excludedRids = null;
 
 	if(this._groupMembers) { // Has grouping
 		this._populateGroups(); // View will be properly re-populate inside _populateGroups()
@@ -3000,9 +3028,9 @@ DataView.prototype._onRowUpdated = function(e) { // onUpdate
 
 		if(this._groupLevel > 0) {
 			if(processingFlag === 1) { // The row is moved to the other group
-				if(this._removeArrayItem(this._rids, rid) >= 0) {
+				if(DataView._removeArrayItem(this._rids, rid) >= 0) {
 					if(this._groupView) {
-						this._removeArrayItem(this._groupView, rid);
+						DataView._removeArrayItem(this._groupView, rid);
 					}
 				}
 				if(this._shared.multiGroupRow) {
@@ -3202,34 +3230,31 @@ DataView.prototype._getRowIndex = function(rids, opt_nextRid, opt_fallback) {
 * @returns {number}
 */
 DataView.prototype._removeDataRow = function(rid) {
-	var at = this._removeArrayItem(this._rids, rid);
+	var at = DataView._removeArrayItem(this._rids, rid);
 	if(this._groupView && at >= 0) {
-		at = this._removeArrayItem(this._groupView, rid);
+		at = DataView._removeArrayItem(this._groupView, rid);
 	}
 	return at;
 };
 /** @private
-* @param {Array} ary
+* @param {!Array} ary
 * @param {*} item
 * @return {number} Index of the removed item
 */
-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;
-		}
+DataView._removeArrayItem = function(ary, item) {
+	var at = ary.indexOf(item);
+	if(at >= 0) {
+		ary.splice(at, 1);
 	}
-	return -1;
+	return at;
 };
 /** Remove multiple array items
 * @private
 * @param {Array.<string>} ary
-* @param {Object.<string, *>} items
+* @param {Object} items
 * @return {number} First item index that is being removed. NaN if no item is removed
 */
-DataView.prototype._removeArrayItems = function(ary, items) {
+DataView._removeArrayItems = function(ary, items) {
 	var f = NaN;
 	var c = 0;
 	for(var i = ary.length; --i >= 0;) {
@@ -3248,6 +3273,23 @@ DataView.prototype._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}
@@ -3281,9 +3323,6 @@ 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;
@@ -3325,40 +3364,90 @@ 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._quickFilter = function(checker, filteringOut, exceptions) {
+DataView.prototype._getRemovalMap = function(removalMap, checker, filteringOut, exceptions) {
 	if(!checker) {
-		return;
+		return 0;
 	}
 
 	var rids = this._rids; // Make local variable to speed up the process
-	var len = rids.length;
 	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);
+	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);
 			if (values) {
-				removed = checker(rid, values) === filteringOut;
+				if(checker(rid, values) === filteringOut) {
+					removalMap[rid] = 1;
+					++count;
+				}
 			} else {
-				removed = true;
+				removalMap[rid] = 1;
+				++count;
 			}
 		}
-		if(removed) {
-			++spliceCount;
-		} else if(spliceCount > 0) {
-			rids.splice(i + 1, spliceCount);
-			spliceCount = 0;
-		}
 	}
-	if(spliceCount > 0) {
-		rids.splice(0, spliceCount);
+	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;
+			}
+		}
 	}
+
+	return count;
 };
 /** @private
 * @param {string|Function|undefined} cid
@@ -3638,13 +3727,13 @@ DataView.prototype._removeGroupMember = function (groupIndex, groupId) {
 };
 /** @private
 * @param {string} cid
-* @param {Object.<string, *>} values
+* @param {Object} values
 * @return {Array.<string>}
 */
 DataView.prototype._defaultGroupCriteria = function(cid, values) {
 	var val = values[cid];
 	if(Array.isArray(val)) {
-		return val.map(function(data) {
+		return val.map(function(data) { // TODO: this is very slow
 			return data + "";
 		});
 	} else {
@@ -3653,11 +3742,11 @@ DataView.prototype._defaultGroupCriteria = function(cid, values) {
 };
 /** @private
 * @param {string|null} rid
-* @param {Object.<string, *>} values
+* @param {Object} values
 * @return {boolean}
 */
 DataView.prototype._groupFilterLogic = function(rid, values) {
-	var gids = this._groupCriteria[this._groupLevel - 1](values);
+	var gids = this._groupCriteria[this._groupLevel - 1](values); // TODO: this is very slow
 	return gids.indexOf(this._groupId) >= 0;
 };
 

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

@@ -27,6 +27,8 @@ 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,6 +292,12 @@ 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,10 +405,6 @@ 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;