@refinitiv-ui/efx-grid 6.0.49 → 6.0.51

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

@@ -11243,6 +11243,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;
@@ -12415,6 +12423,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
@@ -12483,7 +12536,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
 	));
 };
 
@@ -12824,6 +12879,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
@@ -16020,8 +16116,7 @@ ColumnDefinition.prototype._retrieveNestedFields = function(fields) {
 */
 ColumnDefinition.prototype._defaultRenderer = function(e) {
 	var rowDef = /** @type{RowDefinition} */(e["dataValue"]);
-	var data = rowDef.getData(this._field);
-	e["cell"].setContent(data);
+	e["cell"].setContent(rowDef ? rowDef.getData(this._field) : null);
 };
 /** @private
 * @param {Object} e
@@ -31351,6 +31446,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
@@ -35906,7 +36010,7 @@ Core.prototype._batches = null;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.63";
+	return "5.1.67";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -43415,6 +43519,28 @@ SortableTitlePlugin.prototype.setSortingSequence = function (sequence, colRef) {
 SortableTitlePlugin.prototype.clearAllColumnSortingSequences = function () {
 	this._sortingSequenceMap = null;
 };
+/** @public
+* @description Sorting all separators according to compare function. If compare function is not specified, separators will will be sort by current sorting states.
+* @param {Function} comparer Compare function
+*/
+SortableTitlePlugin.prototype.sortSeparators = function (comparer) {
+	var host = this._hosts[0];
+	var dv = host.getDataSource();
+	if(comparer){
+		dv.sortSeparators(comparer);
+	} else {
+		var sortLogics = dv.getSortingLogics();
+		var sortOrders = [];
+		var sortFields = [];
+		var sortStateCount = this._sortStates.length;
+		for(var i = 0; i < sortStateCount; i++){
+			var sortState =  this._sortStates[i];
+			sortOrders.push(sortState["sortOrder"]);
+			sortFields.push(sortState["field"]);
+		}
+		dv.sortSeparators(sortLogics, sortOrders, sortFields);
+	}
+};
 
 
 /** @private
@@ -43895,6 +44021,12 @@ SortableTitlePlugin.prototype._isCellSortable = function (section, colIndex, row
 	if (targetCell !== bottomCell) {
 		return false;
 	}
+	var parentCell = targetCell.getParent();
+	var classList = parentCell["classList"];
+	// "collapsed" class in column element only enable by column stack in spreading mode
+	if (classList.contains("collapsed")) { // HACK: unsortable for collapsed stack in spreading mode
+		return false;
+	}
 
 	return true; // By default all cells are sortable
 };
@@ -44059,6 +44191,12 @@ SortableTitlePlugin._proto = SortableTitlePlugin.prototype;
 * @property {Grid} grid
 * @property {RowDefinition} rowDef
 */
+
+/** @event Grid#beforeContentBinding
+* @property {Object} e Event of beforeContentBinding,  We can use e.actualUpdate to check the actual data update, otherwise It will be empty when it is rendered by row virtualization or only the UI changes.
+* @description Trigger before content binding.
+*/
+
 /** @event Grid#beforeRowRemoved
 * @description Fired only when a row will be removed through Grid's API and before occurring of the actual removal
 */
@@ -44209,6 +44347,7 @@ var Grid = function(placeholder, config) {
 	t.updateColumnTitle = t.updateColumnTitle.bind(t);
 	t._populateTimeSeriesChildren = t._populateTimeSeriesChildren.bind(t);
 
+	t._onBeforeContentBinding = t._onBeforeContentBinding.bind(t);
 	t._onPostSectionDataBinding = t._onPostSectionDataBinding.bind(t);
 	t._asyncClearDataUpdates = t._asyncClearDataUpdates.bind(t);
 	t._clearDataUpdates = t._clearDataUpdates.bind(t);
@@ -44301,6 +44440,7 @@ var Grid = function(placeholder, config) {
 		t._grid.loadPlugin(t._stp, config);
 	}
 
+	t._grid.listen("beforeContentBinding", t._onBeforeContentBinding);
 	t._grid.listen("preSectionRender", t._onColumnHeaderBinding);
 	t._grid.listen("postSectionDataBinding", t._onPostSectionDataBinding);
 
@@ -47420,6 +47560,13 @@ Grid.prototype._mainSorter = function (rowDefA, rowDefB, order) {
 	return this._columnSorter(rowDefA, rowDefB, order);
 };
 
+/** @private
+* @param {Object} e
+*/
+Grid.prototype._onBeforeContentBinding = function(e) {
+	this._dispatch("beforeContentBinding", e);
+};
+
 /** @private
 * @param {Object} e
 */
@@ -49517,6 +49664,46 @@ var _joinSubKeys = function(subA, subB) {
 	return subA.ric + "_" + subB.ric;
 };
 
+/** @private
+* @param {string} ric
+* @return {boolean}
+*/
+var _isDynamicChain = function(ric) {
+	// Dynamic chain will be 2 . (dot) for example .PG.PA
+	return ric.match(/\./g).length > 1;
+};
+
+/** @private
+* @param {Array<Object>} arr sub children
+* @return {Array<Object>}
+*/
+var _shuffleArray = function(arr) {
+	var arrayShuffled = arr; // Modify original array
+	var i, randNumber, tmp;
+	// Shuffle the array randomly using the Fisher-Yates algorithm
+	for (i = arrayShuffled.length - 1; i > 0; i--) {
+		randNumber = Math.floor(Math.random() * (i + 1)); // TODO: it can be use this._dataGen.randInt(min, max) range
+		tmp = arrayShuffled[i];
+		arrayShuffled[i] = arrayShuffled[randNumber];
+		arrayShuffled[randNumber] = tmp;
+	}
+
+	// TODO: merge into 1 loop
+	// Update the CHILD_ORDER property based on the new index
+	arrayShuffled.forEach(_assignChildOrder);
+	arrayShuffled = arrayShuffled.sort(_childOrderSort);
+
+	return arrayShuffled;
+};
+
+var _assignChildOrder = function(obj, index) {
+	obj["CHILD_ORDER"] = index;
+};
+
+var _childOrderSort = function(a, b) {
+	return a["CHILD_ORDER"] - b["CHILD_ORDER"];
+};
+
 /** @constructor */
 var MockQuotes2 = function() {
 
@@ -49949,7 +50136,7 @@ MockSubscriptions.prototype._addSymbol = function(ric, asChain, subId) {
 				childSub["dataId"] = subId + childSub["ric"];
 				childSub["parent"] = sub; // This does not exist in real subscription
 				sub["children"].push(childSub);
-
+				childSub["CHILD_ORDER"] = i;
 				this._dataMap.addItem(_joinSubKeys(sub, childSub), childSub);
 			}
 		} else {
@@ -49996,7 +50183,7 @@ MockSubscriptions.simpleDigest = function(str) {
 MockSubscriptions.prototype._connect = function() {
 	if(this._working && !this._timerId) {
 		var delay = this._dataGen.randInt(this._minInterval, this._maxInterval);
-		this._timerId = window.setTimeout(this._onSubscriptionResponse, delay);
+		this._timerId = window.setTimeout(this._onSubscriptionResponse, delay); // This will be async for fire event to user
 	}
 };
 
@@ -50005,7 +50192,7 @@ MockSubscriptions.prototype._onSubscriptionResponse = function() {
 	this._timerId = 0;
 
 	var keys = this._dataMap.getAllKeys(); // list of all rics
-	var len = keys ? keys.length : 0;
+	var len = keys ? keys.length : 0; // len include all row index (Constituent and normal ric)
 	if(!len) { // No symbol has been added
 		this._connect();
 		return;
@@ -50023,16 +50210,63 @@ MockSubscriptions.prototype._onSubscriptionResponse = function() {
 		var subs = this._dataMap.getItems(key); // Get all subs with the same RIC
 
 		var sub = subs[0]; // Only the first sub is need to generate data
-		var values = this._generateQuoteData(sub, fields);
+		var subParent = sub.parent;
+		var updatePosition = this._dataGen.randBoolean(); // Flag for change CHILD_ORDER position
+
+		var values, j, jLen;
+		if(_isDynamicChain(key) && subParent && updatePosition) { // subParent in header of dynamic chain is behavior like a normal ric
+			// TODO: support rate of ordering is changed
+			var children = subParent.children;
+
+			children = _shuffleArray(children);
+			var childrenLen = children.length;
+			var subIndex = children.indexOf(sub);
+			sub["CHILD_ORDER"] = subIndex;
+
+			values = this._generateQuoteData(sub, fields);
+
+			jLen = subs.length;
+			for(j = 0; j < jLen; ++j) { // It could be same ric and it need to dispatch with same ric number
+				for (var k = 0; k < childrenLen; k++) {
+					var child = children[k];
+					if(subs[j] === child) {
+						values["CHILD_ORDER"] = child["CHILD_ORDER"];
+						this._dispatchDataChanged(subs[j], values);
+					} else {
+						var currentChild = child["CHILD_ORDER"];
+						this._dispatchDataChanged(child, {
+							X_RIC_NAME: child.ric,
+							CHILD_ORDER: currentChild
+						});
+					}
+				}
+				this._dispatchPostUpdate({ childOrderChange: true });
+			}
 
-		var jLen = subs.length;
-		for(var j = 0; j < jLen; ++j) {
-			this._dispatchDataChanged(subs[j], values);
+		} else {
+			values = this._generateQuoteData(sub, fields);
+			jLen = subs.length;
+			for(j = 0; j < jLen; ++j) { // It could be same ric and it need to dispatch with same ric number
+				var childOrder = subs[j]["CHILD_ORDER"];
+				if(childOrder != null) { // Children of chain will have a CHILD_ORDER
+					values["CHILD_ORDER"] = childOrder;
+				}
+				this._dispatchDataChanged(subs[j], values);
+			}
 		}
 	}
 
 	this._connect();
 };
+
+/** @private
+* @param {Object} obj
+*/
+MockSubscriptions.prototype._dispatchPostUpdate = function (obj) {
+	// TODO: handlded another property of "postUpdate" event
+	this._dispatch("postUpdate", obj);
+};
+
 /** @private
 * @param {Object} sub
 * @param {Object} fields
@@ -50112,6 +50346,7 @@ MockSubscriptions.prototype._updateDuplicateSymbol = function(ric) {
 		for(i = 1; i < subCount; ++i) {
 			var sub = subs[i];
 			if(!sub["prevData"]) {
+				// TODO: check in duplicate dynamic chain
 				this._dispatchDataChanged(sub, prevData);
 			}
 		}
@@ -50137,6 +50372,7 @@ MockSubscriptions.prototype._updateDuplicateSymbol = function(ric) {
 			var childSub2 = this._getChildSubByRic(sub2, childRic);
 			if(childSub && childSub2) {
 				if(childSub["prevData"]) {
+					// TODO: check in duplicate dynamic chain
 					this._dispatchDataChanged(childSub2, childSub["prevData"]);
 				}
 			}
@@ -50318,15 +50554,12 @@ MockArchive.prototype.filter = function(func) {
 
 
 
-// CONCATENATED MODULE: ./node_modules/tr-grid-util/es6/jet/mockDataAPI.js
-
-
-
+// CONCATENATED MODULE: ./node_modules/tr-grid-util/es6/jet/MockUtil.js
 /**
-* @private
-* @type {object}
+* @public
+* @type {Object}
 */
-var _invalidFieldDict = {
+var invalidFieldDict = {
 	'TR.NonExistField': true,
 	'TR.NotExistField': true,
 	'CF_IGNORE_FIELD': true
@@ -50338,104 +50571,27 @@ var _invalidFieldDict = {
 */
 function setInvalidFields(fields) {
 	if (fields && typeof fields === 'string') {
-		_invalidFieldDict[fields] = true;
+		invalidFieldDict[fields] = true;
 	} else if (Array.isArray(fields)) {
 		for (var i = 0; i < fields.length; i++) {
-			_invalidFieldDict[fields[i]] = true;
+			invalidFieldDict[fields[i]] = true;
 		}
 	}
 }
 
 
-var dataGen = new DataGenerator();
-
-/** @private
-* @namespace
-*/
-var DataGrid = {};
-
-/** @private
-* @namespace
-*/
-var Adc = {};
-
-/** @private
-* @function
-* @param {Object} payload
-* @param {Object=} mockResponse
-* @return {Promise}
-*/
-DataGrid.request = function (payload, mockResponse) {
-	if (mockResponse) {
-		return Promise.resolve(JSON.stringify(mockResponse));
-	}
-
-	var i, f, len, row;
-	var instruments = payload.instruments;
-	var fields = payload.fields;
 
-	// _invalidFieldDict is a dictionary of non exist field
-	// so we must remove invalid field to make "mocking api" return result more like a "real api".
-	var invalidDict = _invalidFieldDict;
-	fields = [];
-	for (i = 0; i < payload.fields.length; i++) {
-		f = payload.fields[i];
-		if (!invalidDict[f.name]) {
-			fields.push(f);
-		}
-	}
+// CONCATENATED MODULE: ./node_modules/tr-grid-util/es6/jet/Adc.js
 
-	// for filter duplicate instrument
-	var rowMap = {};
 
-	// build data
-	len = instruments.length;
-	var data2D = [];
-	var rowData = dataGen.generate(fields, len);
-	for (i = 0; i < len; ++i) {
-		var inst = instruments[i];
-		row = rowMap[inst];
-		if (!row) {
-			row = rowMap[inst] = rowData[i];
-			row.unshift(inst); // prepend instrument on each row
-		}
-		data2D.push(row);
-	}
 
-	// There is a chance that rtk will return multiple row data per instrument
-	// so we must create mock up for this case
-	if (data2D.length > 0) {
-		var chance = dataGen.randInt(1, 10);
-		if (chance <= 3) { // chance 30%
-			var pos = dataGen.randInt(0, data2D.length - 1); // random row pos
-			row = data2D[pos];
-			len = row.length;
-			var mockupRow = new Array(len);
-			mockupRow[0] = row[0]; // 1st index is for instrument
-			for (i = 1; i < len; i++) {
-				mockupRow[i] = ''; // real case will return null or empty string
-			}
-			data2D.splice(pos + 1, 0, mockupRow);
-		}
-	}
 
-	// build header
-	var headers = [{
-		"displayName": "Instrument"
-	}];
-	for (i = 0; i < fields.length; i++) {
-		f = fields[i];
-		headers.push({
-			"displayName": f.name,
-			"field": f.name.toUpperCase() // server only return in uppercase
-		});
-	}
+var dataGen = new DataGenerator();
 
-	return Promise.resolve(JSON.stringify({
-		data: data2D,
-		headers: [headers]
-	}));
-};
+/** @private
+* @namespace
+*/
+var Adc = {};
 
 /** @private
 * @function
@@ -50458,9 +50614,9 @@ Adc.request = function (payload, mockResponse) {
 		formula =  payload.formula.trim().split(/(?=,TR.)/);// TODO: check each field with another way, this doesn't work when user use some comma (,) formula
 		fields = [];
 
-		// _invalidFieldDict is a dictionary of non exist field
+		// invalidFieldDict is a dictionary of non exist field
 		// so we must remove invalid field to make "mocking api" return result more like a "real api".
-		invalidDict = _invalidFieldDict;
+		invalidDict = invalidFieldDict;
 		for (i = 0; i < formula.length; i++) {
 			f = formula[i];
 			if (!invalidDict[f]) {
@@ -50590,9 +50746,9 @@ Adc.request = function (payload, mockResponse) {
 		formula = Adc.splitFields(payload.formula);
 		fields = [];
 
-		// _invalidFieldDict is a dictionary of non exist field
+		// invalidFieldDict is a dictionary of non exist field
 		// so we must remove invalid field to make "mocking api" return result more like a "real api".
-		invalidDict = _invalidFieldDict;
+		invalidDict = invalidFieldDict;
 		for (i = 0; i < formula.length; i++) {
 			f = formula[i];
 			if (!invalidDict[f]) {
@@ -50693,6 +50849,98 @@ Adc.splitFields = function(strFields) {
 	return fields;
 };
 
+
+
+// CONCATENATED MODULE: ./node_modules/tr-grid-util/es6/jet/mockDataAPI.js
+
+
+
+
+var mockDataAPI_dataGen = new DataGenerator();
+
+/** @private
+* @namespace
+*/
+var DataGrid = {};
+
+/** @private
+* @function
+* @param {Object} payload
+* @param {Object=} mockResponse
+* @return {Promise}
+*/
+DataGrid.request = function (payload, mockResponse) {
+	if (mockResponse) {
+		return Promise.resolve(JSON.stringify(mockResponse));
+	}
+
+	var i, f, len, row;
+	var instruments = payload.instruments;
+	var fields = payload.fields;
+
+	// _invalidFieldDict is a dictionary of non exist field
+	// so we must remove invalid field to make "mocking api" return result more like a "real api".
+	var invalidDict = invalidFieldDict;
+	fields = [];
+	for (i = 0; i < payload.fields.length; i++) {
+		f = payload.fields[i];
+		if (!invalidDict[f.name]) {
+			fields.push(f);
+		}
+	}
+
+	// for filter duplicate instrument
+	var rowMap = {};
+
+	// build data
+	len = instruments.length;
+	var data2D = [];
+	var rowData = mockDataAPI_dataGen.generate(fields, len);
+	for (i = 0; i < len; ++i) {
+		var inst = instruments[i];
+		row = rowMap[inst];
+		if (!row) {
+			row = rowMap[inst] = rowData[i];
+			row.unshift(inst); // prepend instrument on each row
+		}
+		data2D.push(row);
+	}
+
+	// There is a chance that rtk will return multiple row data per instrument
+	// so we must create mock up for this case
+	if (data2D.length > 0) {
+		var chance = mockDataAPI_dataGen.randInt(1, 10);
+		if (chance <= 3) { // chance 30%
+			var pos = mockDataAPI_dataGen.randInt(0, data2D.length - 1); // random row pos
+			row = data2D[pos];
+			len = row.length;
+			var mockupRow = new Array(len);
+			mockupRow[0] = row[0]; // 1st index is for instrument
+			for (i = 1; i < len; i++) {
+				mockupRow[i] = ''; // real case will return null or empty string
+			}
+			data2D.splice(pos + 1, 0, mockupRow);
+		}
+	}
+
+	// build header
+	var headers = [{
+		"displayName": "Instrument"
+	}];
+	for (i = 0; i < fields.length; i++) {
+		f = fields[i];
+		headers.push({
+			"displayName": f.name,
+			"field": f.name.toUpperCase() // server only return in uppercase
+		});
+	}
+
+	return Promise.resolve(JSON.stringify({
+		data: data2D,
+		headers: [headers]
+	}));
+};
+
 /** @public
 * @function
 * @param {string} dataType