@refinitiv-ui/efx-grid 6.0.34 → 6.0.36

package/lib/rt-grid/es6/Grid.js

@@ -326,6 +326,7 @@ var Grid = function(placeholder, config) {
 		t._dc = new DataCache();
 		t._dc.listen("dataChanged", t._onDataChanged);
 		t._dc.listen("dataComposed", t._onDataComposed);
+		t._dc.addStaticFields([ROW_DEF, SUB_ID]); // Static fields are deprecated, set fields to be ignore during clone in DataCache
 
 		t._dt = new DataTable();
 		t._dt.setSortingLogic(/** @type{Function} */(t._mainSorter));
@@ -1526,8 +1527,11 @@ Grid.prototype.replaceColumn = function (columnOption, colRef) {
 	if(colDef.getChildren()) { // Parent time series field doesn't provide hidden property
 		colConfig["hidden"] = false;
 	}
+
+	this._grid.startBatch("reset");
 	this.insertColumn(colConfig, colIndex);
 	this.removeColumn(colIndex + 1); // remove existing column after insert
+	this._grid.stopBatch("reset");
 };
 
 /** to update column name when field info is loaded
@@ -1620,21 +1624,24 @@ Grid.prototype._shouldLoadFieldInfo = function (field) {
 * @param {Array.<Object>} columns Array of column options
 */
 Grid.prototype.setColumns = function(columns) {
+	var grid = this._grid;
 	var colCount = (columns) ? columns.length : 0;
 
+	grid.startBatch("reset");
 	this.removeAllColumns();
 	if(colCount > 0) {
 		var prevState = false;
 		if(colCount > 1) {
-			prevState = this._grid.freezeLayout(true); // Insert multiple columns can be a huge time consuming
+			prevState = grid.freezeLayout(true); // Insert multiple columns can be a huge time consuming
 		}
 		for(var i = 0; i < colCount; ++i) {
 			this.insertColumn(columns[i], i);
 		}
 		if(colCount > 1) {
-			this._grid.freezeLayout(prevState);
+			grid.freezeLayout(prevState);
 		}
 	}
+	grid.stopBatch("reset");
 };
 
 
@@ -1643,6 +1650,8 @@ Grid.prototype.setColumns = function(columns) {
 * @param {Array.<Object>} columns Array of column options
 */
 Grid.prototype.restoreColumns = function(columns) {
+	var grid = this._grid;
+	grid.startBatch("reset");
 	var configObj = this.getConfigObject();
 	var previousColumns = configObj.columns;
 
@@ -1706,7 +1715,8 @@ Grid.prototype.restoreColumns = function(columns) {
 		this._stp.sortColumns(sortingStates);
 	}
 
-	this._grid.reorderColumns(columnOrdering);
+	grid.reorderColumns(columnOrdering);
+	grid.stopBatch("reset");
 };
 
 /** Remove all existing columns and add new columns based on the given texts/fields
@@ -1782,11 +1792,6 @@ Grid.prototype._onColumnAdded = function(e) {
 		this._grid.enableColumnClass(idx, classes[i]);
 	}
 	var colField = colDef.getField();
-	if (!colDef.isRealTimeField()) {
-		if(this._dc) {
-			this._dc.addStaticFields([colField]);
-		}
-	}
 	this._grid.setDataColumnName(idx, ROW_DEF); // This make ColumnDefinition renderer work
 	var fields = colDef.getAllFields();
 	var referrer = colDef.getId();
@@ -3399,33 +3404,34 @@ Grid.prototype._updateStreamingData = function() {
 * @param {Object} e
 */
 Grid.prototype._onPreDataSorting = function (e) {
-	var field = "";
-	var rowSorting = false;
-	var sortLogic = null;
-
-	var states = this._stp.getSortingStates(); // WARNING: Use of deprecated function
-	var state = states ? states[0] : null; // TODO: Support multi-column sorting
-
-	if(state) {
-		field = state["field"] || "";
-		var colIndex = this._stp.getSortedColumnIndex(0);
-		var colDef = (colIndex >= 0) ? this.getColumnDefinition(colIndex) : null;
-		this._sorter.setContext("colIndex", colIndex);
-		this._sorter.setContext("colDef", colDef);
+	var objs = this._stp.getSortedColumns();
+
+	this._sorter.reset();
+	if(Array.isArray(objs)) {
+		var sortCount = objs.length;
+		for(var i = 0; i < sortCount; ++i) {
+			var obj = objs[i];
+			var field = obj["field"] || "";
+			var colIndex = obj["colIndex"];
+			var colDef = (colIndex >= 0) ? this.getColumnDefinition(colIndex) : null;
+
+			var rowSorting = false;
+			var sortLogic = null;
+			if(colDef) {
+				field = colDef.getField(); // WARNING: Field and logic could be out of sync
+				rowSorting = colDef.isRowSorting();
+				sortLogic = colDef.getSorter();
+			}
+			// TODO: get sortLogic from DataView
+			// if(!sortLogic && field) {
+			// sortLogic = state["sortLogic"];
+			// }
 
-		if(colDef) {
-			field = colDef.getField(); // WARNING: Field and logic could be out of sync
-			sortLogic = colDef.getSorter();
-			rowSorting = colDef.isRowSorting();
+			this._sorter.addColumnContext(field, sortLogic, rowSorting, obj["sortOrder"], colIndex, colDef);
 		}
 	}
-	if(!sortLogic && field) {
-		sortLogic = state["sortLogic"];
-	}
 
-	this._sorter.setField(field);
-	this._sorter.setSortLogic(sortLogic);
-	this._columnSorter = this._sorter.getSorter(rowSorting);
+	this._columnSorter = this._sorter.getSorter();
 };
 /** @private
 * @param {RowDefinition} rowDefA

package/lib/rt-grid/es6/RowDefSorter.d.ts

@@ -1,4 +1,4 @@
-
+import { cloneObject } from "../../tr-grid-util/es6/Util.js";
 
 declare class RowDefSorter {
 
@@ -6,14 +6,14 @@ declare class RowDefSorter {
 
     public dispose(): void;
 
-    public getSorter(rowSorting?: boolean|null): ((...params: any[]) => any)|null;
-
-    public setSortLogic(func?: ((...params: any[]) => any)|null): void;
+    public getSorter(): ((...params: any[]) => any)|null;
 
-    public setField(field: string): void;
+    public reset(key: string, value: any): void;
 
     public setContext(key: string, value: any): void;
 
+    public addColumnContext(field: string, logic: ((...params: any[]) => any)|null, rowSorting: boolean, order: string, colIndex: number, colDef: any): void;
+
 }
 
 export default RowDefSorter;

package/lib/rt-grid/es6/RowDefSorter.js

@@ -1,70 +1,147 @@
+import { cloneObject } from "../../tr-grid-util/es6/Util.js";
+
+/** @private
+* @param {*} a
+* @param {*} b
+* @param {number} order
+* @return {number}
+*/
+var _defaultCompare = function(a, b, order) {
+	if(a == null || a !== a) {
+		if(b == null || b !== b) {
+			return 0;
+		}
+		return 1;
+	}
+	if(b == null || b !== b) {
+		return -1;
+	}
+
+	if(a < b) {
+		return -order;
+	}
+	if(b < a) {
+		return order;
+	}
+	return 0;
+};
+
 /** @constructor
 */
 var RowDefSorter = function() {
 	this._defaultSorter = this._defaultSorter.bind(this);
 	this._dataSorter = this._dataSorter.bind(this);
 	this._rowDefSorter = this._rowDefSorter.bind(this);
+	this._multiColumnsSorter = this._multiColumnsSorter.bind(this);
 
-	this._sortContext = {};
+	this._globalContext = {};
+	this._sortParams = [];
+	this._ctxCaches = [];
 };
 
-
-/** @type {string}
+/** @type {!Object}
 * @private
 */
-RowDefSorter.prototype._field = "";
-/** @type {!Object}
+RowDefSorter.prototype._globalContext;
+/** @type {!Array.<Array>}
+* @private
+*/
+RowDefSorter.prototype._sortParams;
+/** @type {!Array.<Object>}
 * @private
 */
-RowDefSorter.prototype._sortContext;
-/** @type {Function}
+RowDefSorter.prototype._ctxCaches;
+/** @type {Array}
 * @private
 */
-RowDefSorter.prototype._sortLogic = null;
+RowDefSorter.prototype._primaryParams;
 
 
 /** @public
 */
 RowDefSorter.prototype.dispose = function() {
-	this._sortLogic = null;
-	this._sortContext = {}; // Clear any existing reference
+	this._globalContext = {}; // Clear any existing reference
+	this._sortParams.length = 0;
+	this._ctxCaches.length = 0;
+	this._primaryParams = null;
 };
 
 /** @public
-* @param {boolean=} rowSorting=false
 * @return {Function}
 */
-RowDefSorter.prototype.getSorter = function(rowSorting) {
-	if(this._sortLogic) {
-		return rowSorting ? this._rowDefSorter : this._dataSorter;
-	} else {
-		return this._defaultSorter;
+RowDefSorter.prototype.getSorter = function() {
+	this._primaryParams = null;
+	var sortCount = this._sortParams.length;
+	if(sortCount === 1) {
+		var params = this._primaryParams = this._sortParams[0];
+		var sortLogic = params[1];
+		if(sortLogic) {
+			var rowSorting = params[3];
+			return rowSorting ? this._rowDefSorter : this._dataSorter;
+		} else {
+			return this._defaultSorter;
+		}
+	} else if(sortCount > 1) {
+		return this._multiColumnsSorter;
 	}
-};
-/** @public
-* @param {Function=} func
-*/
-RowDefSorter.prototype.setSortLogic = function(func) {
-	this._sortLogic = (typeof func === "function") ? func : null;
-};
 
+	return RowDefSorter._noSorting;
+};
 
 /** @public
-* @param {string} field
+* @param {string} key
+* @param {*} value
 */
-RowDefSorter.prototype.setField = function(field) {
-	if(!field) {
-		field = "";
+RowDefSorter.prototype.reset = function() {
+	if(this._sortParams.length) {
+		this._sortParams.length = 0;
 	}
-	this._sortContext["field"] = this._field = field;
-	this._sortContext["formattedField"] = field + "_FORMATTED";
 };
 /** @public
 * @param {string} key
 * @param {*} value
 */
 RowDefSorter.prototype.setContext = function(key, value) {
-	this._sortContext[key] = value;
+	this._globalContext[key] = value;
+};
+/** @public
+* @param {string} field
+* @param {Function} logic
+* @param {boolean} rowSorting
+* @param {string} order
+* @param {number} colIndex
+* @param {*} colDef
+*/
+RowDefSorter.prototype.addColumnContext = function(field, logic, rowSorting, order, colIndex, colDef) {
+	if(!field) {
+		field = "";
+	}
+	var sortPriority = this._sortParams.length;
+	var ctx = this._ctxCaches[sortPriority];
+	if(!ctx) {
+		ctx = this._ctxCaches[sortPriority] = cloneObject(this._globalContext);
+	}
+	var orderNum = 0;
+	if(order === "a") {
+		orderNum = 1;
+	} else if(order === "d") {
+		orderNum = -1;
+	}
+
+	var params = [
+		field, // 0
+		(typeof logic === "function") ? logic : null,  // 1
+		ctx, // 2
+		rowSorting, // 3
+		orderNum  // 4
+	];
+
+	ctx["colIndex"] = colIndex;
+	ctx["field"] = field;
+	ctx["formattedField"] = field + "_FORMATTED";
+	ctx["colDef"] = colDef;
+
+	this._sortParams.push(params);
 };
 
 /** @private
@@ -73,32 +150,7 @@ RowDefSorter.prototype.setContext = function(key, value) {
 * @param {number} order
 * @return {number}
 */
-RowDefSorter.prototype._defaultSorter = function(rowDefA, rowDefB, order) {
-	var orderA = rowDefA.getGroupOrder();
-	var orderB = rowDefB.getGroupOrder();
-	if(orderA !== orderB) {
-		return orderA - orderB; // Regardless of sort order
-	}
-
-	var a = rowDefA.getData(this._field);
-	var b = rowDefB.getData(this._field);
-
-	if(a == null || a !== a) {
-		if(b == null || b !== b) {
-			return 0;
-		}
-		return 1;
-	}
-	if(b == null || b !== b) {
-		return -1;
-	}
-
-	if(a < b) {
-		return -order;
-	}
-	if(b < a) {
-		return order;
-	}
+RowDefSorter._noSorting = function(rowDefA, rowDefB, order) {
 	return 0;
 };
 /** @private
@@ -107,16 +159,30 @@ RowDefSorter.prototype._defaultSorter = function(rowDefA, rowDefB, order) {
 * @param {number} order
 * @return {number}
 */
+RowDefSorter.prototype._defaultSorter = function(rowDefA, rowDefB, order) {
+	var field = this._primaryParams[0];
+	return _defaultCompare(
+		rowDefA.getData(field),
+		rowDefB.getData(field),
+		order
+	);
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} order
+* @return {number}
+*/
 RowDefSorter.prototype._dataSorter = function(rowDefA, rowDefB, order) {
-	var orderA = rowDefA.getGroupOrder();
-	var orderB = rowDefB.getGroupOrder();
-	if(orderA !== orderB) {
-		return orderA - orderB; // Regardless of sort order
-	}
-
-	var a = rowDefA.getData(this._field);
-	var b = rowDefB.getData(this._field);
-	return this._sortLogic(a, b, order, this._sortContext);
+	var params = this._primaryParams;
+	var field = params[0];
+	var sortLogic = params[1];
+	return sortLogic(
+		rowDefA.getData(field),
+		rowDefB.getData(field),
+		order,
+		params[2]
+	);
 };
 /** @private
 * @param {RowDefinition} rowDefA
@@ -125,13 +191,41 @@ RowDefSorter.prototype._dataSorter = function(rowDefA, rowDefB, order) {
 * @return {number}
 */
 RowDefSorter.prototype._rowDefSorter = function(rowDefA, rowDefB, order) {
-	var orderA = rowDefA.getGroupOrder();
-	var orderB = rowDefB.getGroupOrder();
-	if(orderA !== orderB) {
-		return orderA - orderB; // Regardless of sort order
+	var params = this._primaryParams;
+	var sortLogic = params[1];
+	return sortLogic(rowDefA, rowDefB, order, params[2]);
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} primaryOrder
+* @return {number}
+*/
+RowDefSorter.prototype._multiColumnsSorter = function(rowDefA, rowDefB, primaryOrder) {
+	var sortParams = this._sortParams;
+	var sortCount = sortParams.length;
+	for(var i = 0; i < sortCount; ++i) {
+		var params = sortParams[i];
+		var field = params[0];
+		var sortLogic = params[1];
+		var ctx = params[2];
+		var rowSorting = params[3];
+		var orderNum = params[4];
+		var ret = 0;
+		if(sortLogic) {
+			if(rowSorting) {
+				ret = sortLogic(rowDefA, rowDefB, orderNum, ctx);
+			} else {
+				ret = sortLogic(rowDefA.getData(field), rowDefB.getData(field), orderNum, ctx);
+			}
+		} else {
+			ret = _defaultCompare(rowDefA.getData(field), rowDefB.getData(field), orderNum);
+		}
+		if(ret) {
+			return ret;
+		}
 	}
-
-	return this._sortLogic(rowDefA, rowDefB, order, this._sortContext);
+	return 0;
 };
 
 export default RowDefSorter;

package/lib/tr-grid-column-selection/es6/ColumnSelection.js

@@ -38,6 +38,8 @@ var ColumnSelectionPlugin = function ColumnSelectionPlugin(options) {
   t._onReselection = t._onReselection.bind(t);
   t._onThemeLoaded = t._onThemeLoaded.bind(t);
   t._onColumnPositionChanged = t._onColumnPositionChanged.bind(t);
+  t._onBeforeBatchOperation = t._onBeforeBatchOperation.bind(t);
+  t._onAfterBatchOperation = t._onAfterBatchOperation.bind(t);
   t._updateMenuIcon = t._updateMenuIcon.bind(t);
   t._hosts = [];
 
@@ -121,6 +123,12 @@ ColumnSelectionPlugin.prototype._menuPosition = "outside";
 
 ColumnSelectionPlugin.prototype._cgp = null; // Column grouping extension
 
+/** @type {Array.<string>}
+* @private
+*/
+
+ColumnSelectionPlugin.prototype._prevSelectedCols = {}; // previous selected columns during batch operation
+
 /** @public
 * @return {string}
 */
@@ -156,6 +164,8 @@ ColumnSelectionPlugin.prototype.initialize = function (host, options) {
   host.listen("columnRemoved", this._onColumnRemoved);
   host.listen("columnAdded", this._onColumnAdded);
   host.listen("columnPositionChanged", this._onColumnPositionChanged);
+  host.listen("beforeBatchOperation", this._onBeforeBatchOperation);
+  host.listen("afterBatchOperation", this._onAfterBatchOperation);
   this.config(options);
 
   if (ColumnSelectionPlugin._stylePromise) {
@@ -1098,6 +1108,62 @@ ColumnSelectionPlugin.prototype._onReselection = function (e) {
   this._activeGrid.focus();
 };
 /** @private
+* @param {Object} e
+*/
+
+
+ColumnSelectionPlugin.prototype._onBeforeBatchOperation = function (e) {
+  var host = this._activeGrid;
+
+  if (this._hasSelection && e["batchType"] === "reset") {
+    var colCount = this.getColumnCount();
+
+    for (var i = 0; i < colCount; ++i) {
+      if (this.isSelectedColumn(i)) {
+        var colId = host.getColumnId(i);
+        var field = host.getColumnField(i);
+
+        if (colId) {
+          this._prevSelectedCols[colId] = field;
+        } else {
+          this._prevSelectedCols[field] = "";
+        }
+      }
+    }
+
+    this.clearAllSelections(); //clear all to improve performance during add/remove operation
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+ColumnSelectionPlugin.prototype._onAfterBatchOperation = function (e) {
+  if (e["batchType"] === "reset") {
+    var prevSelectedCols = Object.keys(this._prevSelectedCols);
+    var prevSelectedCount = prevSelectedCols.length;
+
+    if (prevSelectedCount) {
+      this.clearAllSelections();
+
+      for (var i = 0; i < prevSelectedCount; i++) {
+        var colId = prevSelectedCols[i];
+        var field = this._prevSelectedCols[colId];
+        var prevSelectedIndex = this.getColumnIndex(colId);
+
+        if (prevSelectedIndex < 0) {
+          prevSelectedIndex = this.getColumnIndex(field);
+        }
+
+        this.setSelectedColumn(prevSelectedIndex, true);
+      }
+
+      this._prevSelectedCols = {};
+    }
+  }
+};
+/** @private
 * @param {KeyboardEvent} e
 * @return {boolean}
 */

package/lib/tr-grid-column-stack/es6/ColumnStack.d.ts

@@ -3,6 +3,7 @@ import { GridPlugin } from "../../tr-grid-util/es6/GridPlugin.js";
 import { Conflator } from "../../tr-grid-util/es6/Conflator.js";
 import { Icon } from "../../tr-grid-util/es6/Icon.js";
 import { ElfUtil } from "../../tr-grid-util/es6/ElfUtil.js";
+import { GroupDefinitions } from "../../tr-grid-util/es6/GroupDefinitions.js";
 import { Dom } from "../../tr-grid-util/es6/Dom.js";
 import { injectCss, prettifyCss } from "../../tr-grid-util/es6/Util.js";
 import { preventDefault } from "../../tr-grid-util/es6/EventDispatcher.js";
@@ -137,6 +138,8 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public isStackHidden(stackId: string): boolean|null|null;
 
+    public moveStack(stackId: string, destCol?: (number|string)|null): boolean;
+
 }
 
 export default ColumnStackPlugin;