@refinitiv-ui/efx-grid 6.0.27 → 6.0.28

package/lib/core/dist/core.js

@@ -13389,14 +13389,23 @@ Segment.prototype.addChild = function(rid, dataId) {
 };
 /** @public
 * @param {Array.<string>} rids
+* @param {Array.<string>=} dataIds Row ids for retrieving data
 * @return {boolean}
 */
-Segment.prototype.addChildren = function(rids) {
+Segment.prototype.addChildren = function(rids, dataIds) {
 	var rowIds = Array.isArray(rids) ? rids : [rids];
 	var rowCount = rowIds.length;
 	var dirty = 0;
-	for(var i = 0; i < rowCount; ++i) {
-		dirty |= this.addChild(rowIds[i]);
+	var i;
+	if(dataIds != null) {
+		dataIds = Array.isArray(dataIds) ? dataIds : [dataIds];
+		for(i = 0; i < rowCount; ++i) {
+			dirty |= this.addChild(rowIds[i], dataIds[i]);
+		}
+	} else {
+		for(i = 0; i < rowCount; ++i) {
+			dirty |= this.addChild(rowIds[i]);
+		}
 	}
 	return dirty ? true : false;
 };
@@ -14222,12 +14231,13 @@ SegmentCollection.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 /** @public
 * @param {string} segmentId
 * @param {Array.<string>} rids
+* @param {Array.<string>=} dataIds Row ids for retrieving data
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
-SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids) {
+SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
 	var segment = this._segments[segmentId];
 	if(segment && !segment.isSubSegment()) {
-		return segment.addChildren(rids);
+		return segment.addChildren(rids, dataIds);
 	}
 	return false;
 };
@@ -15691,11 +15701,12 @@ DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 /** @public
 * @param {string} segmentId Row id
 * @param {Array.<string>} rids Row id
+* @param {Array.<string>=} dataIds Row ids for retrieving data
 * @return {boolean} Return true if there is any change
 */
-DataTable.prototype.addSegmentChildren = function(segmentId, rids) {
+DataTable.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
 	if(this._segments) {
-		var dirty = this._segments.addSegmentChildren(segmentId, rids);
+		var dirty = this._segments.addSegmentChildren(segmentId, rids, dataIds);
 		if(dirty) {
 			if(this._sort(null)) {
 				this._dispatchPositionChange();
@@ -20864,13 +20875,14 @@ DataView.prototype.addSegmentChild = function(segmentRef, rowRef, dataId) {
 /** @public
 * @param {string|number} segmentRef Row id or row index
 * @param {Array.<string|number>} rowRefs Array of row ids or row indices
+* @param {Array.<string>=} dataIds Row ids for retrieving data
 * @return {boolean} Return true if there is any change
 */
-DataView.prototype.addSegmentChildren = function(segmentRef, rowRefs) {
+DataView.prototype.addSegmentChildren = function(segmentRef, rowRefs, dataIds) {
 	if(this._dt._getSegmentSeparators()) {
 		var segmentId = this._toRowId(segmentRef);
 		var rowIds = this._toRowIds(rowRefs);
-		return this._dt.addSegmentChildren(segmentId, rowIds);
+		return this._dt.addSegmentChildren(segmentId, rowIds, dataIds);
 	}
 	return false;
 };
@@ -25407,7 +25419,7 @@ Core_Core.prototype._groupDefs = null;
 * @return {string}
 */
 Core_Core.getVersion = function () {
-	return "5.1.35";
+	return "5.1.38";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -25523,6 +25535,12 @@ Core_Core.prototype.getConfigObject = function (gridOptions) {
 		}
 
 		var columnDef = this._getColumnDef(colIndex);
+		if(columnDef["userId"]) {
+			column["id"] = columnDef["userId"];
+		}
+		if(columnDef["field"]) {
+			column["field"] = columnDef["field"];
+		}
 		if (columnDef["styles"]) {
 			column["styles"] = columnDef["styles"];
 		}
@@ -26607,6 +26625,126 @@ Core_Core.prototype._moveColumn = function (fromCol, destCol) {
 	return true;
 };
 
+/** If source column is not found, no operation is performed. If destination column is not found, the source column will be moved to the last position.<br>
+* Note: this method behaves slightly different from moveColumn method in that it always put source column at the position before the specified destination column, while moveColumn method will put column at exactly at the destination index.
+* @public
+* @param {number|string} srcCol Column Id or index
+* @param {(number|string)=} destCol Column Id or index of the destination
+* @return {boolean} Return true if there is any change, and false otherwise
+* @see {@link Core#moveColumn}
+* @example
+* grid.moveColumnById(3, 1); // Move column 3 to position before column 1
+* grid.moveColumnById(0, 2); // Move column 0 to position before column 2 (column index 1)
+* grid.moveColumnById(0, 1); // Nothing is moved
+* grid.moveColumnById("sourceColumnId", "anotherId");
+* grid.moveColumnById("sourceColumnId", ""); // move to the last position
+*/
+Core_Core.prototype.moveColumnById = function (srcCol, destCol) {
+	var colCount = this.getColumnCount();
+	var srcIndex = this.getColumnIndex(srcCol);
+	if(srcIndex < 0 || srcIndex >= colCount) {
+		return false;
+	}
+	var destIndex = destCol != null ? this.getColumnIndex(destCol) : -1;
+	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
+*/
+Core_Core.prototype._moveColumnByIndex = function (srcIndex, destIndex) {
+	if(srcIndex < destIndex) { // Ensure that the source column is put in front of the destination index
+		--destIndex;
+	}
+	if(srcIndex === destIndex) {
+		return false;
+	}
+	return this.moveColumn(srcIndex, destIndex);
+};
+/** @public
+* @param {number|string|Array.<number|string>} colRefs List of column index or column id to be moved
+* @param {(number|string)=} destCol Destination position where the moved columns will be placed BEFORE the specified position. This can be column id or index
+* @return {boolean} Return true if there is any change, and false otherwise
+*/
+Core_Core.prototype.reorderColumns = function (colRefs, destCol) {
+	var destId = "";
+	if(typeof destCol === "number") {
+		destId = this.getColumnId(destCol);
+	} else if(destCol) {
+		destId = destCol;
+	}
+
+	if(Array.isArray(colRefs)) {
+		var srcLen = colRefs.length;
+		if(srcLen > 1) {
+			var colIds = this.getColumnIds();
+			var colCount = colIds.length;
+			var srcIds = [];
+			var invalidDest = false;
+			var i, srcId, srcIdx;
+			for(i = 0; i < srcLen; ++i) {
+				var colRef = colRefs[i];
+				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
+				destIdx = this.getColumnIndex(destId);
+				if(destIdx >= 0) {
+					while(++destIdx < colCount) {
+						destId = colIds[destIdx];
+						if(srcIds.indexOf(destId) < 0) {
+							break;
+						}
+					}
+				}
+				if(destIdx < 0 || destIdx >= colCount) {
+					destId = "";
+				}
+			}
+
+			var dirty = 0;
+			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;
+			}
+			return dirty ? true : false;
+		} else {
+			return this.moveColumnById(colRefs[0], destId);
+		}
+	}
+
+	if(colRefs != null) {
+		// colRefs will be a number or string
+		return this.moveColumnById(colRefs, destId);
+	}
+	return false;
+};
+
 /** @public
 * @ignore
 * @return {!TrackLayout}
@@ -26658,9 +26796,14 @@ Core_Core.prototype._deserializeColumn = function (index, jsonObj) {
 	var colId = jsonObj["id"];
 	if(colId && typeof colId === "string") {
 		colDef["id"] = colId; // WARNING: We do not guarantee uniqueness of user id
+		colDef["userId"] = colId;
+	}
+	var field = jsonObj["field"];
+	if(field && typeof field === "string") {
+		colDef["field"] = field;
 	}
 
-	var value = jsonObj["dataColumnName"];
+	var value = jsonObj["dataColumnName"]; // Deprecated
 	if (value != null) {
 		colDef["dataColumnName"] = value;
 	}
@@ -28103,24 +28246,6 @@ Core_Core.prototype.getRelativePosition = function (obj, context) {
 	return ret_obj;
 };
 
-/** 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_Core.prototype.getColumnIndex = function (str) {
-	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;
-};
-
 /** @public
 * @return {!ElementWrapper}
 */
@@ -29719,6 +29844,99 @@ Core_Core.prototype.getColumnIds = function () {
 	return ary;
 };
 
+/** @public
+* @param {number} colIndex
+* @param {string} field
+*/
+Core_Core.prototype.setColumnField = function (colIndex, field) {
+	this._getColumnDef(colIndex)["field"] = field || "";
+};
+/** @public
+* @param {number} colIndex
+* @return {string} Return empty string if the specified column does not exist
+*/
+Core_Core.prototype.getColumnField = function (colIndex) {
+	if(colIndex >= 0 && colIndex < this.getColumnCount()) {
+		return this._getColumnDef(colIndex)["field"] || "";
+	}
+	return "";
+};
+/** @public
+* @return {!Array.<string>} Return all column ids from existing column
+*/
+Core_Core.prototype.getColumnFields = function () {
+	var colCount = this.getColumnCount();
+	var ary = new Array(colCount);
+	for(var c = 0; c < colCount; ++c) {
+		ary[c] = this._getColumnDef(c)["field"] || "";
+	}
+	return ary;
+};
+
+/** Get column index by column id or column field
+* @public
+* @param {string|number} colRef Column id or data column name
+* @return {number} Return negative value if there is no match
+*/
+Core_Core.prototype.getColumnIndex = function (colRef) {
+	if(typeof colRef === "number") {
+		return colRef;
+	} else if(colRef) {
+		var str = colRef;
+		var colCount = this.getColumnCount();
+		for(var c = 0; c < colCount; ++c) {
+			var colDef = this._getColumnDef(c);
+			if(str === colDef["id"] || str === colDef["field"]) {
+				return c;
+			}
+		}
+	}
+	return -1;
+};
+/** Any invalid column reference will be excluded from the output array
+* @public
+* @param {Array.<number|string>} colRefs
+* @return {!Array.<number>} Return negative value if there is no match
+*/
+Core_Core.prototype.getColumnIndices = function (colRefs) {
+	var ary = [];
+	var colCount = this.getColumnCount();
+	var inputAry = Array.isArray(colRefs) ? colRefs : [colRefs];
+	var len = inputAry.length;
+	// Verify user input
+	for(var i = 0; i < len; ++i) {
+		var colIndex = this.getColumnIndex(inputAry[i]);
+		if(colIndex >= 0 && colIndex < colCount) {
+			ary.push(colIndex); // WARNING: We have not check for duplication
+		}
+	}
+	return ary;
+};
+
+/** Get a map from column id and field to column index. This should be useful when finding multiple column indices.
+* @public
+* @return {!Object.<string, number>}
+*/
+Core_Core.prototype.getColumnIndexMap = function () {
+	var colCount = this.getColumnCount();
+	var obj = {};
+	var str = "";
+	for(var c = 0; c < colCount; ++c) {
+		var colDef = this._getColumnDef(c);
+
+		str = colDef["field"];
+		if(str) {
+			obj[str] = c;
+		}
+
+		str = colDef["id"];
+		if(str) {
+			obj[str] = c;
+		}
+	}
+	return obj;
+};
+
 
 /** @private */
 Core_Core.prototype._onWindowResize = function() {