@refinitiv-ui/efx-grid 6.0.24 → 6.0.25

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

@@ -14343,6 +14343,17 @@ FieldDefinition.get = function(field) {
 	}
 	return null;
 };
+
+/** @public
+* @function
+* @param {string} field
+* @return {boolean}
+*/
+FieldDefinition.hasFieldInfo = function(field) {
+	var val = FieldDefinition.get(field);
+	return val && val.field; // Already preventing an error caused by accessing a property on a null value
+};
+
 /** @public
 * @function
 * @param {string} field
@@ -14505,8 +14516,8 @@ FieldDefinition.loadFieldInfo = function (field) {
 		defer.resolve(null);
 	}
 	// already have field definition then return
-	else if (FieldDefinition._defs[field]) {
-		defer.resolve(FieldDefinition._defs[field]);
+	else if (FieldDefinition.hasFieldInfo(field)) {
+		defer.resolve(FieldDefinition.get(field));
 	}
 	// in debug using mock data instead
 	else if (synapse.debug) {
@@ -14765,7 +14776,7 @@ PredefinedFormula.remove = function(field) {
 * @property {string=} headerAlignment="" Text alignment for column header. This will override `textAlign` option for column header.
 * @property {string=} titleAlignment="" Alias to `headerAlignment`
 * @property {boolean=} hidden=false
-* @property {string=} id Id for unique identifier
+* @property {string=} id A unique identifier for the column
 * @property {boolean=} textSelect=false If enabled, user can select text in this column
 * @property {boolean=} keepModel If enabled, initial column's options will be kept
 * @property {boolean=} stationary=false If enabled, the column order cannot be changed (i.e., this column and any column to its left cannot be moved)
@@ -16353,6 +16364,546 @@ SnapshotFiller.prototype._onRTKTimeSeriesSuccess = function (fields, serverResul
 
 /* harmony default export */ var js_SnapshotFiller = (SnapshotFiller);
 
+// CONCATENATED MODULE: ./node_modules/tr-grid-util/es6/GroupDefinitions.js
+
+
+/** @constructor
+*/
+var GroupDefinitions = function () {
+	this._groupMap = {};
+	this._childToParent = {};
+};
+
+/** @type {!Object.<string, Object>}
+* @description A map of group id to group defintion
+* @private
+*/
+GroupDefinitions.prototype._groupMap;
+/** @type {!Object.<string, string>}
+* @description A map of child id to parent id
+* @private
+*/
+GroupDefinitions.prototype._childToParent;
+
+
+/** @public
+* @function
+* @param {Object} groupDef
+* @return {string}
+*/
+GroupDefinitions.getGroupId = function(groupDef) {
+	if(groupDef) {
+		return groupDef.id || "";
+	}
+	return "";
+};
+/** @public
+* @param {Object.<string, Object>} groupMap
+* @param {Object} groupDef
+* @return {number} Return total number of parents. Return 0 if there is no parent.
+*/
+GroupDefinitions.calcTreeDepth = function (groupMap, groupDef) {
+	var curDepth = -1;
+	var curNode = groupDef;
+	while(curNode) { // WARNING: infinite loop could occured, if parentId is cycle back to one of the child group
+		if(++curDepth > 15) {
+			console.log("WARNING: Infinite loop detected during column group creation");
+			break;
+		}
+		var parentId = curNode.parentId;
+		curNode = groupMap[parentId];
+	}
+	return curDepth;
+};
+/** @public
+* @param {Object.<string, Object>} groupMap
+* @param {string} groupId
+* @return {Array.<string>}
+*/
+GroupDefinitions.getLeafDescendants = function (groupMap, groupId) {
+	var groupDef = groupMap[groupId];
+	if(!groupDef) {
+		return null;
+	}
+
+	var leaves = [];
+	var unvisitedGroups = [groupDef];
+	var visitedCount = 0;
+	var visitedMap = {};
+	while(visitedCount < unvisitedGroups.length) {
+		groupDef = unvisitedGroups[visitedCount++];
+		visitedMap[groupDef.id] = true;
+		var chdr = groupDef.children;
+		var len = chdr.length;
+		for(var i = 0; i < len; ++i) {
+			var childId = chdr[i];
+			groupDef = groupMap[childId];
+			if(groupDef) {
+				if(!visitedMap[groupDef.id]) { // Prevent infinite loop
+					unvisitedGroups.push(groupDef);
+				}
+			} else {
+				leaves.push(childId);
+			}
+		}
+	}
+	return leaves;
+};
+
+
+/** @private
+* @function
+* @param {Object} obj
+* @return {Object}
+*/
+GroupDefinitions._cloneObject = function(obj) {
+	var newObj = Object(Util["b" /* cloneObject */])(obj);
+	if(Array.isArray(newObj.children)) {
+		newObj.children = newObj.children;
+	} else {
+		newObj.children = [];
+	}
+	return newObj;
+};
+/** @private
+* @param {Object} groupMap
+* @return {!Object}
+*/
+GroupDefinitions._cloneGroupMap = function (groupMap) {
+	var outMap = {};
+	for(var groupId in groupMap) {
+		var groupDef = groupMap[groupId];
+		var obj = GroupDefinitions._cloneObject(groupDef);
+		obj.children = groupDef.children.slice();
+		outMap[groupId] = obj;
+	}
+	return outMap;
+};
+
+/** @private
+* @function
+* @param {Array.<string>|Object} obj
+* @param {string=} groupId
+* @return {Object}
+*/
+GroupDefinitions._toGroupDefinition = function(obj, groupId) {
+	var groupDef = null;
+	if(obj) {
+		if(Array.isArray(obj)) {
+			groupDef = {
+				children: obj
+			};
+		} else {
+			groupDef = GroupDefinitions._cloneObject(obj);
+		}
+		if(groupId) {
+			if(!groupDef.id) {
+				groupDef.name = groupId;
+			}
+			groupDef.id = groupId;
+		}
+	}
+	return groupDef;
+};
+
+/** @public
+* @return {string}
+*/
+GroupDefinitions.prototype.toString = function() {
+	var groupMap = this._groupMap;
+	var lines = [];
+	lines.push("=== groupDefs ===");
+	for(var key in groupMap) {
+		var group = groupMap[key];
+		lines.push(key + ": " + JSON.stringify(group, ["id", "parentId", "children"]));
+	}
+
+	lines.push("=== childToParent ===");
+	lines.push(JSON.stringify(this._childToParent, null, 2));
+	lines.push("");
+
+	return lines.join("\n");
+};
+
+/** Get group definition object. This method can be used to check whether the given id is a group id or not (i.e., isGroupId).
+* @public
+* @param {string} groupId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getGroup = function (groupId) {
+	if(groupId) {
+		return this._groupMap[groupId] || null;
+	}
+	return null;
+};
+/** @public
+* @function
+* @param {string} groupId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getDefinition = GroupDefinitions.prototype.getGroup;
+/** Get array of all existing group definitions
+* @public
+* @return {!Array.<Object>}
+*/
+GroupDefinitions.prototype.getGroups = function () {
+	var groupDefs = [];
+	var groupMap = this._groupMap;
+	for(var key in groupMap) {
+		groupDefs.push(groupMap[key]);
+	}
+	return groupDefs;
+};
+/** @public
+* @return {!Object.<string, Object>}
+*/
+GroupDefinitions.prototype.getGroupMap = function () {
+	return this._groupMap; // WARNING: Allow access to private member
+};
+/** @public
+* @return {!Object.<string, Object>}
+*/
+GroupDefinitions.prototype.cloneGroupMap = function () {
+	return GroupDefinitions._cloneGroupMap(this._groupMap);
+};
+
+/** Get immediate child ids of the specified group. The returned array can contain both child ids and group ids
+* @public
+* @param {string} groupId
+* @return {Array.<string>}
+*/
+GroupDefinitions.prototype.getGroupChildren = function (groupId) {
+	var groupDef = this._groupMap[groupId];
+	return groupDef ? groupDef.children : null;
+};
+/** Get all non-group descendants of the given group id.
+* @public
+* @param {string} groupId
+* @return {Array.<string>}
+*/
+GroupDefinitions.prototype.getLeafDescendants = function (groupId) {
+	return GroupDefinitions.getLeafDescendants(this._groupMap, groupId);
+};
+/** @public
+* @param {string} groupId
+* @return {number} Return -1 if the given groupDef is null. Return 0 if there is no parent. Return 1 or more if it has a parent
+*/
+GroupDefinitions.prototype.getGroupLevel = function (groupId) {
+	return GroupDefinitions.calcTreeDepth(this._groupMap, this._groupMap[groupId]);
+};
+/** @public
+* @param {string} groupId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getRootGroup = function (groupId) {
+	if (!groupId) {
+		return null;
+	}
+	var groupMap = this._groupMap;
+	var groupDef = groupMap[groupId] || null;
+	// TODO: Support column id
+	if(groupDef) {
+		while (groupDef.parentId) {
+			var parentDef = groupMap[groupDef.parentId];
+			if(parentDef) {
+				groupDef = parentDef;
+			} else {
+				break;
+			}
+		}
+	}
+	return groupDef;
+};
+/** @public
+* @param {string} childId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getParentGroup = function (childId) {
+	return this.getGroup(this._childToParent[childId]);
+};
+/** @public
+* @param {string} childId
+* @return {Array.<string>}
+*/
+GroupDefinitions.prototype.getParentIds = function(childId) {
+	if (childId && typeof childId === "string") {
+		var groupId = this._childToParent[childId];
+		if (groupId) {
+			var groupIds = [groupId];
+			var group = this._groupMap[groupId];
+			while (group && group.parentId) {
+				group = this._groupMap[group.parentId];
+				if (group) {
+					groupIds.push(group.id);
+				}
+			}
+			return groupIds;
+		}
+	}
+	return null;
+};
+/** @public
+* @param {string} childId
+* @param {number=} groupLevel
+* @return {string}
+*/
+GroupDefinitions.prototype.getParentId = function (childId, groupLevel) {
+	var parentId = this._childToParent[childId];
+	if(groupLevel != null) {
+		var currentLevel = this.getGroupLevel(parentId);
+		while(currentLevel > groupLevel && parentId){
+			parentId = this._childToParent[parentId];
+			currentLevel--;
+		}
+	}
+
+	return parentId || "";
+};
+
+
+/** Remove all existing group definitions and replace them with the given definitions.
+* @public
+* @param {Array.<Object>=} groupDefs Use null or empty array to remove all existing groups
+*/
+GroupDefinitions.prototype.setGroups = function (groupDefs) {
+	// Clear existing group structure
+	var groupMap = this._groupMap = {};
+	var childToParent = this._childToParent = {};
+
+	// Create group map
+	var i;
+	var grpCount = groupDefs ? groupDefs.length : 0;
+	var groupId = "";
+	for (i = 0; i < grpCount; i++) {
+		var groupDef = groupDefs[i];
+		groupId = groupDef.id;
+		if(groupId) {
+			groupMap[groupId] = groupDef;
+		}
+	}
+
+	// Create child to parent map
+	var groupIds = Object.keys(groupMap);
+	grpCount = groupIds.length;
+	for(i = 0; i < grpCount; ++i) {
+		groupId = groupIds[i];
+		var children = groupMap[groupId].children;
+		var childCount = children.length;
+		for (var j = 0; j < childCount; j++) {
+			childToParent[children[j]] = groupId;
+		}
+	}
+
+	// Apply a parent id to group definition to make it easier to find depth
+	for(i = 0; i < grpCount; ++i) {
+		groupId = groupIds[i];
+		var parentId = childToParent[groupId];
+		if(parentId) {
+			groupMap[groupId].parentId = parentId;
+		}
+	}
+};
+/** Add new group definition to existing group structure. Existing group with the same id will be replaced.
+* @public
+* @param {Object} groupDef Group definition object
+* @return {string} Return group ID
+*/
+GroupDefinitions.prototype.addGroup = function (groupDef) {
+	var groupId = GroupDefinitions.getGroupId(groupDef);
+	if(groupId) {
+		return this.setGroup(groupId, groupDef);
+	}
+	return groupId;
+};
+/** @public
+* @param {string} groupId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.removeGroup = function (groupId) {
+	var curDef = this._groupMap[groupId];
+	if(curDef) {
+		this.removeAllChildren(groupId);
+		this.removeGroupChild(groupId);
+		delete this._groupMap[groupId];
+
+		return true;
+	}
+	return false;
+};
+/** Replace and update existing group definition. New group is added if the given id has no match. Existing group will be removed of no new definition is given.
+* @public
+* @param {string} groupId
+* @param {Array.<string>|Object=} groupDef
+* @return {string} Return group Id. Return empty string if nothing has been changed.
+*/
+GroupDefinitions.prototype.setGroup = function (groupId, groupDef) {
+	if(!groupId) {
+		return "";
+	}
+
+	if(groupDef) {
+		var newDef = GroupDefinitions._toGroupDefinition(groupDef, groupId);
+		this._ungroupChildren(newDef.children);
+
+		var curDef = this._groupMap[groupId];
+		if(curDef) { // Replace
+			this.removeAllChildren(groupId);
+		}
+		var parentDef = this._childToParent[groupId];
+		if(parentDef) {
+			newDef.parentId = parentDef.id;
+		}
+		this._groupMap[groupId] = newDef;
+
+		var chdr = newDef.children;
+		var len = chdr.length;
+		for(var i = 0; i < len; ++i) {
+			var childId = chdr[i];
+			this._childToParent[childId] = groupId;
+			var childDef = this._groupMap[childId];
+			if(childDef) {
+				childDef.parentId = groupId;
+			}
+		}
+	} else { // Remove
+		if(!this.removeGroup(groupId)) {
+			return "";
+		}
+	}
+
+	return groupId;
+};
+
+/** Remove each child from any group
+ * @private
+ * @param {Array.<string>} children
+ */
+GroupDefinitions.prototype._ungroupChildren = function(children) {
+	if (Array.isArray(children)) {
+		var len = children.length;
+		for(var i = 0; i < len; ++i) {
+			this.removeGroupChild(children[i]);
+		}
+	}
+};
+
+
+/** @public
+* @param {string} parentId Group id
+* @param {string} childId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.addGroupChild = function (parentId, childId) {
+	var groupDef = this._groupMap[parentId];
+
+	if(childId && groupDef) {
+		var chdr = groupDef.children;
+		if(chdr && chdr.indexOf(childId) < 0) {
+			this.removeGroupChild(childId); // Remove previous parent
+			// Add new child to group structures
+			this._childToParent[childId] = parentId;
+			var childDef = this._groupMap[childId];
+			if(childDef) {
+				childDef.parentId = parentId;
+			}
+			chdr.push(childId);
+			return true;
+		}
+	}
+	return false;
+};
+/** Remove the given child from its own parent (i.e., unset Parent of the given child).
+* @public
+* @param {string} childId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.removeGroupChild = function (childId) {
+	var parentId = this._childToParent[childId];
+	if(!parentId) {
+		return false;
+	}
+	this._childToParent[childId] = "";
+	var childDef = this._groupMap[childId];
+	if(childDef) {
+		childDef.parentId = "";
+	}
+	var parentDef = this._groupMap[parentId];
+	if(parentDef) {
+		var chdr = parentDef.children;
+		if(chdr.length) {
+			var at = chdr.indexOf(childId);
+			if (at >= 0) {
+				chdr.splice(at, 1); // splice is slow
+			}
+		}
+	}
+	return true;
+};
+/** Remove all children from the specified group
+* @public
+* @param {string} groupId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.removeAllChildren = function(groupId) {
+	var grpDef = this._groupMap[groupId];
+	if(grpDef) {
+		var chdr = grpDef.children;
+		var len = chdr.length;
+		if(len) {
+			grpDef.children = [];
+			for(var i = 0; i < len; ++i) {
+				var childId = chdr[i];
+				if(this._childToParent[childId]) {
+					this._childToParent[childId] = "";
+				}
+				var childDef = this._groupMap[childId];
+				if(childDef) {
+					childDef.parentId = "";
+				}
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** Replace and update existing group definition.
+* @public
+* @param {string} groupId
+* @param {Array.<string>} newChildList If null is given, all existing children in the group will be removed
+* @return {boolean}
+*/
+GroupDefinitions.prototype.setGroupChildren = function (groupId, newChildList) {
+	var groupDef = this._groupMap[groupId];
+	if(groupDef) {
+		if(Array.isArray(newChildList)) {
+			var chdr = newChildList.slice();
+			this._ungroupChildren(chdr);
+			this.removeAllChildren(groupId);
+			groupDef.children = chdr;
+
+			var parentId = groupDef.id;
+			var len = chdr.length;
+			for(var i = 0; i < len; ++i) {
+				var childId = chdr[i];
+				this._childToParent[childId] = parentId;
+				var childDef = this._groupMap[childId];
+				if(childDef) {
+					childDef.parentId = parentId;
+				}
+			}
+
+			return true;
+		} else if(!newChildList && groupDef.children.length) {
+			this.removeAllChildren(groupId);
+			return true;
+		}
+	}
+	return false;
+};
+
+/* harmony default export */ var es6_GroupDefinitions = (GroupDefinitions);
+
+
 // CONCATENATED MODULE: ./node_modules/@grid/core/es6/grid/components/ElementWrapper.js
 
 
@@ -34184,6 +34735,7 @@ VirtualizedLayoutGrid._proto = VirtualizedLayoutGrid.prototype;
 
 // CONCATENATED MODULE: ./node_modules/@grid/core/es6/grid/Core.js
 
+ // eslint-disable-line
 
  // eslint-disable-line
 
@@ -34706,6 +35258,10 @@ Core.prototype._preserveGridSize = false;
 * @private
 */
 Core.prototype._rowHeightTimerId = 0;
+/** @type {GroupDefinitions}
+* @private
+*/
+Core.prototype._groupDefs = null;
 //#region Public Methods
 
 /**
@@ -34713,7 +35269,7 @@ Core.prototype._rowHeightTimerId = 0;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.32";
+	return "5.1.33";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -35841,7 +36397,7 @@ Core.prototype._moveColumn = function (fromCol, destCol) {
 		vEnd = this._colVirtualizer.getLastIndexInView();
 	}
 
-	var colId = this._getColumnId(fromCol);
+	var colId = this.getColumnId(fromCol);
 	this._layoutX.moveLane(fromCol, destCol);
 	var sectionCount = this._settings.length;
 	for (var i = 0; i < sectionCount; ++i) {
@@ -35961,6 +36517,11 @@ Core.prototype._deserializeColumn = function (index, jsonObj) {
 	// TODO: Load specific styles for each column type (e.g. "content", "title", "header")
 
 	var colDef = this._getColumnDef(index);
+	var colId = jsonObj["id"];
+	if(colId && typeof colId === "string") {
+		colDef["id"] = colId; // WARNING: We do not guarantee uniqueness of user id
+	}
+
 	var value = jsonObj["dataColumnName"];
 	if (value != null) {
 		colDef["dataColumnName"] = value;
@@ -37404,14 +37965,19 @@ Core.prototype.getRelativePosition = function (obj, context) {
 	return ret_obj;
 };
 
-/** @public
-* @param {string} str data column name
-* @return {number} Return negative if the mouse is not hit
+/** Find column index by column id or data column name
+* @public
+* @param {string} str Column id or data column name
+* @return {number} Return negative value if there is no match
 */
 Core.prototype.getColumnIndex = function (str) {
-	for(var c = this.getColumnCount(); --c >= 0;) {
-		if(str === this.getDataColumnName(c)) {
-			return c;
+	if(str) {
+		var colCount = this.getColumnCount();
+		for(var c = 0; c < colCount; ++c) {
+			var colDef = this._getColumnDef(c);
+			if(str === colDef["id"] || str === colDef["dataColumnName"]) {
+				return c;
+			}
 		}
 	}
 	return -1;
@@ -38296,6 +38862,37 @@ Core.prototype.normalizeConfig = function (configObj) {
 
 	return configObj;
 };
+/** @public
+* @param {GroupDefinitions} groupDefs
+*/
+Core.prototype.setColumnGrouping = function (groupDefs) {
+	this._groupDefs = groupDefs || null;
+};
+/** @public
+* @param {string|number} colRef
+* @return {string} Return group id of immediate group parent. Return empty string, if no parent is found.
+*/
+Core.prototype.getColumnGroupParentId = function (colRef) {
+	if(this._groupDefs) {
+		var colId = (typeof colRef === "number") ? this.getColumnId(colRef) : colRef;
+		return this._groupDef.getParentId(colId);
+	}
+	return "";
+};
+
+/** @public
+* @param {string} groupId
+* @return {Array.<string>} Return array of column id. Return null if the specified group has no child
+*/
+Core.prototype.getColumnGroupChildIds = function (groupId) {
+	if(this._groupDefs) {
+		var ary = this._groupDef.getLeafDescendants(colId);
+		if(ary && ary.length > 0) {
+			return ary;
+		}
+	}
+	return null;
+};
 //#endregion Public Methods
 
 //#region Private Methods
@@ -38953,13 +39550,35 @@ Core.prototype._getNestedColumnDef = function (colIndex, firstLvl, secondLvl) {
 	}
 	return def;
 };
+
 /** @public
+* @param {number} colIndex
+* @return {string} Return empty string if the specified column does not exist
+*/
+Core.prototype.getColumnId = function (colIndex) {
+	if(colIndex >= 0 && colIndex < this.getColumnCount()) {
+		return this._getColumnDef(colIndex)["id"] || "";
+	}
+	return "";
+};
+/** @deprecated
+* @public
+* @function
 * @ignore
 * @param {number} colIndex
 * @return {string}
 */
-Core.prototype._getColumnId = function (colIndex) {
-	return this._getColumnDef(colIndex)["id"];
+Core.prototype._getColumnId = Core.prototype.getColumnId;
+/** @public
+* @return {!Array.<string>} Return all column ids from existing column
+*/
+Core.prototype.getColumnIds = function () {
+	var colCount = this.getColumnCount();
+	var ary = new Array(colCount);
+	for(var c = 0; c < colCount; ++c) {
+		ary[c] = this._getColumnDef(c)["id"] || "";
+	}
+	return ary;
 };
 
 
@@ -43312,7 +43931,9 @@ Grid.prototype._onFieldAdded = function(e) {
 	// JET
 	if (this._subs) {
 		var realtimeFields = addedFields.filter(js_FieldDefinition.isRealTimeField);
-		this._subs["addFields"](realtimeFields);
+		if(realtimeFields.length > 0) {
+			this._subs["addFields"](realtimeFields);
+		}
 	}
 
 	this._dispatch(e.type, e);
@@ -43604,19 +44225,31 @@ Grid.prototype._setScrollbarParent = function (host) {
 /**
 * @private
 * @param {string} field
-* @param {boolean} isRealTime
 * @returns {boolean}
 */
-Grid.prototype._shouldLoadFieldInfo = function (field, isRealTime) {
-	var fieldDef = js_FieldDefinition.get(field);
-	if (!fieldDef &&
-		field !== 'X_RIC_NAME' && // ignore X_RIC_NAME
-		(isRealTime || js_FieldDefinition.isAdc(field)) && // realtime field or adc field (Without static field)
-		(this._RTK || window["JET"]) // have rtk instance or window jet sub
-	) {
-		return true;
+Grid.prototype._shouldLoadFieldInfo = function (field) {
+
+	var val = this._RTK || window["JET"]; // Fastest checking can be performed by checking the first condition.
+	if(!val) {
+		return false;
 	}
-	return false;
+
+	// WARNING: If field caching is disabled, it shouldn't load field info
+	if(!this._fieldCaching) {
+		return false;
+	}
+
+	val = js_FieldDefinition.hasFieldInfo(field);
+	if(val) {
+		return false;
+	}
+
+	val = js_FieldDefinition.isAdc(field) || js_FieldDefinition.isRealTimeField(field);
+	if(!val) {
+		return false;
+	}
+
+	return true;
 };
 /** Remove all existing columns and add new columns based on the given objects
 * @public
@@ -43718,11 +44351,10 @@ Grid.prototype._onColumnAdded = function(e) {
 	var fields = colDef.getAllFields();
 	var referrer = colDef.getId();
 	var len = fields.length;
-	var field, dataType, prom, isRealTimeField, onLoaded;
+	var field, dataType, prom, onLoaded;
 	for(i = 0; i < len; i++) {
 		field = fields[i];
-		isRealTimeField = js_FieldDefinition.isRealTimeField(field);
-		if(this._shouldLoadFieldInfo(field, isRealTimeField)) {
+		if(this._shouldLoadFieldInfo(field)) {
 			if(field === colField) {
 				dataType = colDef.getDataType(); // Data-type from user's column options
 			} else { // Other required fields
@@ -43891,6 +44523,15 @@ Grid.prototype.moveColumnById = function (srcCol, destCol) {
 	if(destIndex < 0) {
 		destIndex = colCount;
 	}
+	return this._moveColumnByIndex(srcIndex, destIndex);
+};
+/** Move column without verification for better performance
+* @private
+* @param {number} srcIndex Column index
+* @param {number} destIndex Column index of the destination
+* @return {boolean} Return true if there is any change, and false otherwise
+*/
+Grid.prototype._moveColumnByIndex = function (srcIndex, destIndex) {
 	if(srcIndex < destIndex) { // Ensure that the source column is put in front of the destination index
 		--destIndex;
 	}
@@ -43912,23 +44553,31 @@ Grid.prototype.reorderColumns = function (colRefs, destCol) {
 		var srcLen = colRefs.length;
 		if(srcLen > 1) {
 			var colIds = this.getColumnIds();
+			var colCount = colIds.length;
 			var srcIds = [];
 			var invalidDest = false;
-			var i;
+			var i, srcId, srcIdx;
 			for(i = 0; i < srcLen; ++i) {
 				var colRef = colRefs[i];
-				var srcId = (typeof colRef === "number") ? colIds[colRef] : colRef;
-				if(srcId) {
+				if(typeof colRef === "number") {
+					srcIdx = colRef;
+					srcId = colIds[colRef] || "";
+				} else {
+					srcId = colRef;
+					srcIdx = colIds.indexOf(srcId);
+				}
+				if(srcId && srcIdx >= 0) {
 					srcIds.push(srcId);
 					if(destId === srcId) {
 						invalidDest = true; // Destination must not exist in source columns
 					}
 				}
 			}
+
+			var destIdx;
 			srcLen = srcIds.length;
 			if(invalidDest) { // Find the next valid destination where it is not contained in the source columns
-				var colCount = colIds.length;
-				var destIdx = this.getColumnIndex(destId);
+				destIdx = this.getColumnIndex(destId);
 				if(destIdx >= 0) {
 					while(++destIdx < colCount) {
 						destId = colIds[destIdx];
@@ -43943,10 +44592,16 @@ Grid.prototype.reorderColumns = function (colRefs, destCol) {
 			}
 
 			var dirty = 0;
-			for(i = 0; i < srcLen; ++i) {
-				dirty |= this.moveColumnById(srcIds[i], destId);
+			for(i = srcLen; --i >= 0;) {
+				srcId = srcIds[i]; // Only valid source columns are left at this point
+				srcIdx = this.getColumnIndex(srcId);
+				destIdx = this.getColumnIndex(destId);
+				if(destIdx < 0) { // Insert to the back when id is not found
+					destIdx = colCount;
+				}
+				dirty |= this._moveColumnByIndex(srcIdx, destIdx);
+				destId = srcId;
 			}
-			// TODO: Handle the case where all columns stay in the same place
 			return dirty ? true : false;
 		} else {
 			return this.moveColumnById(colRefs[0], destId);
@@ -44023,11 +44678,10 @@ Grid.prototype.addDataFields = function(fieldRef, referrer) {
 
 	var fields = Array.isArray(fieldRef) ? fieldRef : [fieldRef];
 	var len = fields.length;
-	var i, field, dataType, prom, isRealTimeField, onLoaded;
+	var i, field, dataType, prom, onLoaded;
 	for(i = 0; i < len; i++) {
 		field = fields[i];
-		isRealTimeField = js_FieldDefinition.isRealTimeField(field);
-		if(this._shouldLoadFieldInfo(field, isRealTimeField)) {
+		if(this._shouldLoadFieldInfo(field)) {
 			dataType = ColumnDefinition.getDataType(field);
 			prom = js_FieldDefinition.loadFieldInfo(field)
 				.catch(this._onFieldLoadedError);
@@ -44991,20 +45645,22 @@ Grid.prototype.getColumnIndex = function(colRef) {
 		return colRef;
 	}
 
-	var colCount = this.getColumnCount();
-	var i, colDef;
-	if(colRef instanceof ColumnDefinition) {
-		for(i = 0; i < colCount; ++i) {
-			colDef = this.getColumnDefinition(i);
-			if(colDef === colRef) {
-				return i;
+	if(colRef) {
+		var colCount = this.getColumnCount();
+		var i, colDef;
+		if(colRef instanceof ColumnDefinition) {
+			for(i = 0; i < colCount; ++i) {
+				colDef = this.getColumnDefinition(i);
+				if(colDef === colRef) {
+					return i;
+				}
 			}
-		}
-	} else if(typeof colRef === "string") {
-		for(i = 0; i < colCount; ++i) {
-			colDef = this.getColumnDefinition(i);
-			if(_hasFieldOrId(colDef, colRef)) {
-				return i; // Return the first found field
+		} else if(typeof colRef === "string") {
+			for(i = 0; i < colCount; ++i) {
+				colDef = this.getColumnDefinition(i);
+				if(_hasFieldOrId(colDef, colRef)) {
+					return i; // Return the first found field
+				}
 			}
 		}
 	}