@refinitiv-ui/efx-grid 6.0.0-next.0

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

@@ -0,0 +1,873 @@
+import { arrayToObject } from "../../tr-grid-util/es6/Util.js";
+/* eslint-disable */
+import { DataCache } from "../../core/es6/data/DataCache.js";
+import { DataTable } from "../../core/es6/data/DataTable.js";
+/* eslint-enable */
+
+/** @typedef {Object} RowDefinition~Options
+* @description RowDefinition options
+* @property {string=} ric="" RIC for real-time fields. Prefixing 0# to the ric is equivalent to specifying asChain property.
+* @property {(Array|Object)=} values=null Values for static data
+* @property {Array.<string>=} fields=null Field that corresponds to the given static values
+* @property {boolean=} asChain=false The given ric will be treated as a chain
+* @property {string=} chainRic="" RIC to be used for chain request (overiding ric property)
+* @property {boolean=} collapsed=false Chain is expanded by default
+* @property {(string|null)=} label=null
+*/
+
+/** @type {string}
+* @public
+* @const
+*/
+var ROW_DEF = "ROW_DEF";
+
+/** @constructor
+* @param {RowDefinition~Options=} rowOptions
+*/
+var RowDefinition = function(rowOptions) {
+	this._changes = {};
+	this._rowId = "_" + RowDefinition._runningId++ + "_";
+	this._dataId = this._rowId;
+
+	if(rowOptions) {
+		if(rowOptions["asConstituent"]) { // Create row definition as a constituent of a chain
+			this._initializeAsConstituent(rowOptions); // WARNING: This does not follow normal initialization process
+		} else {
+			this.initialize(rowOptions);
+		}
+	}
+};
+
+/** @type {number}
+* @private
+*/
+RowDefinition._runningId = 0;
+//#region Private Members
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._userInput = "";
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._ric = ""; // Contains no 0#
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._displayText = "";
+/** @type {string|null}
+* @private
+*/
+RowDefinition.prototype._label = null; // Label overrides _ric and _displayText
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._isChain = false;
+
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._rowId = ""; // Row Id must be unique
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._dataId = ""; // Data id can be different from rowId for constituents of a chain
+/** @type {DataCache}
+* @private
+*/
+RowDefinition.prototype._dc = null;
+/** @type {DataTable}
+* @private
+*/
+RowDefinition.prototype._view = null;
+
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._subId = "";
+
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._expanded = false;
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._autoGenerated = false;
+/** @type {Object.<string, *>}
+* @private
+*/
+RowDefinition.prototype._staticValues = null;
+/** @type {!Object.<string, number>}
+* @private
+*/
+RowDefinition.prototype._changes;
+/** @type {number}
+* @private
+*/
+RowDefinition.prototype._updateCount = 0;
+
+/** @type {Array.<RowDefinition>}
+* @private
+*/
+RowDefinition.prototype._children = null;
+/** @type {RowDefinition}
+* @private
+*/
+RowDefinition.prototype._parent = null;
+/** @type {number}
+* @private
+*/
+RowDefinition.prototype._groupOrder = 0; // For group sorting
+/** @type {number}
+* @private
+*/
+RowDefinition.prototype._depthLevel = 0;
+
+/** @type {Object}
+* @private
+*/
+RowDefinition.prototype._userModel = null;
+//#endregion Private Members
+
+/** @public
+*/
+RowDefinition.prototype.dispose = function() {
+	if(this.isDisposed()) {
+		return;
+	}
+
+	if(this._children) {
+		this._children.forEach(RowDefinition.dispose);
+		this._children = null;
+	}
+
+	this._staticValues = null; // Static values contain user data
+	this._parent = null; // WARNING: This does not impact children count of the parent. A child must be destroyed by its parent only
+	this._depthLevel = 0;
+	this.unsubscribeForUpdates();
+	if(this._dc) {
+		var rowData = this.getRowData();
+		if(rowData) {
+			rowData[ROW_DEF] = null;
+		}
+		this._dc = null;
+	}
+	if(this._view) {
+		this._view = null;
+	}
+	this._rowId = this._dataId = "";
+	this._userModel = null;
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isDisposed = function() {
+	return !this._rowId;
+};
+/** @public
+* @param {RowDefinition~Options=} rowOptions
+*/
+RowDefinition.prototype.initialize = function(rowOptions) {
+	if(!rowOptions) {
+		return;
+	}
+
+	var val = rowOptions["ric"];
+	if(val != null) {
+		this.setContent(/** @type{string} */(val)); // this._dataId is modified
+	}
+	val = rowOptions["chainRic"];
+	if(val != null) {
+		this._chainRic = val;
+	}
+
+	val = rowOptions["values"];
+	// eslint-disable-next-line no-undefined
+	if(val !== undefined) {
+		this.setStaticRowData(val, rowOptions["fields"]);
+	}
+
+	val = rowOptions["asChain"];
+	if(val) {
+		this._isChain = true;
+		this._expanded = !rowOptions["collapsed"];
+	} else if(this._isChain) {
+		var collapsed = rowOptions["collapsed"];
+		if(collapsed != null) {
+			this._expanded = !collapsed;
+		}
+	}
+
+	val = rowOptions["label"];
+	// eslint-disable-next-line no-undefined
+	if(val !== undefined) { // Empty string and null are allowed
+		this._label = val;
+	}
+
+	val = rowOptions["keepModel"];
+	if(val) {
+		this._userModel = rowOptions;
+	}
+};
+/** @private
+* @param {!Object} rowOptions
+*/
+RowDefinition.prototype._initializeAsConstituent = function(rowOptions) {
+	this._autoGenerated = true;
+	var parentDef = /** @type{RowDefinition} */(rowOptions["parent"]);
+	if(this.setParent(parentDef)) {
+		this._dataId = /** @type{string} */(rowOptions["dataId"]); // Constituent will have the same subId as its parent but with different ric
+		this._displayText = this._ric = /** @type{string} */(rowOptions["ric"]);
+
+		this._dc = parentDef._dc; // Parent chain must have data cache
+		if(this._dc) {
+			var rowData = this.getRowData(); // Do not trigger any data update
+			if(rowData) { // Row data from data cache must exist beforehand
+				rowData[ROW_DEF] = this;  // This is for easy referencing from data streaming, also for preventing duplication
+			}
+		}
+	}
+	// TODO: Allow constituent to have predefined static values
+};
+/** @public
+* @param {string} userInput
+* @return {boolean} True if there is any change otherwise false
+*/
+RowDefinition.prototype.setContent = function(userInput) {
+	if(this._autoGenerated) { // AutoGenerated RowDefinition cannot be changed by user input
+		return false;
+	}
+
+	if(!userInput) { // 0 is not a valid input
+		userInput = "";
+	} else if(typeof userInput !== "string") {
+		userInput += "";
+	}
+
+	if(this._userInput === userInput) {
+		return false;
+	}
+
+	this.unsubscribeForUpdates();
+	this.resetUpdates(); // Remove all previous data updates because a new content is just entered
+
+	this._userInput = userInput;
+	if(this._userInput.charAt(0) === "'") { // This is a row header
+		this._displayText = this._userInput.substr(1);
+		this._ric = this._chainRic = ""; // No ric for realtime request
+	} else {
+		if(this._userInput.indexOf("0#") >= 0) {
+			this._ric = this._userInput.replace("0#", "");
+			this._isChain = this._expanded = true; // Only chain can be expanded by 0# TODO: RIC with 0# is not necessarily a chain
+			this._chainRic = this._userInput;
+		} else {
+			this._ric = this._userInput;
+			this._chainRic = "";
+		}
+		this._displayText = this._ric; // No 0#
+	}
+
+	this._dataId = this._rowId + this._ric; // JET/RTK will generate data id to be rowId (given from this rowDef) + ric;
+
+	// This will work for runtime ric modification, but not for first initilization.
+	this.subscribeForUpdates();
+	return true;
+};
+/** @public
+* @return {string} Row Id will never be empty string unless the row has been removed
+*/
+RowDefinition.prototype.getRowId = function() {
+	return this._rowId;
+};
+/** Since an index chain (e.g. .FTSE) can automatically produce rows for its constituent, we need to separate rowId and dataId, so that the constituents still use the same data Id as that of its parent.
+* @public
+* @return {string} Data Id will never be empty string unless the row has been removed
+*/
+RowDefinition.prototype.getDataId = function() {
+	return this._dataId;
+};
+
+/** This method should always be called right after the initialization
+* @public
+* @param {DataCache} dataSource
+*/
+RowDefinition.prototype.setDataSource = function(dataSource) {
+	this._dc = dataSource || null;
+	if(!this._dc) {
+		return;
+	}
+
+	var rowData = this.getRowData();
+	if(!rowData) {
+		rowData = {};
+		rowData[ROW_DEF] = this; // Enable tracking back and updating data
+		this.setRowData(rowData); // TODO: This will dispatch dataChanged event and caused update to be added, which should not happen
+	}
+
+	// Add static value to the new source
+	if(this._staticValues) {
+		this.setRowData(this._staticValues);
+	}
+
+	// This will work for runtime row insertion, but not for first initilization.
+	this.subscribeForUpdates();
+};
+
+/** @public
+* @return {Object} rowData
+*/
+RowDefinition.prototype.getRowData = function() {
+	return this._dc.getRowData(this._dataId);
+};
+/** @public
+* @param {string} field
+* @return {*} data
+*/
+RowDefinition.prototype.getData = function(field) {
+	return this._dc.getData(this._dataId, field);
+};
+
+/** @public
+* @param {Object.<string, *>|Array} data
+* @param {Array.<string>=} opt_fields In case of the given data is an array, this param will be used for mapping index to field
+*/
+RowDefinition.prototype.setStaticRowData = function(data, opt_fields) {
+	this._clearStaticData();
+
+	if(Array.isArray(data)) { // Convert array to object
+		data = arrayToObject(data, opt_fields);
+	}
+
+	this._staticValues = (typeof data === "object") ? data : null;
+
+	if(this._staticValues) {
+		this.setRowData(data);
+	}
+};
+/** @public
+* @param {Object.<string, *>|Array} data
+* @param {Array.<string>=} opt_fields In case of the given data is an array, this param will be used for mapping index to field
+*/
+RowDefinition.prototype.updateRowData = function(data, opt_fields) {
+	if(Array.isArray(data)) { // Convert array to object
+		data = arrayToObject(data, opt_fields);
+	}
+
+	if(data) {
+		this.setRowData(data);
+	}
+};
+/** @public
+* @param {string} field
+* @param {*} value
+*/
+RowDefinition.prototype.setStaticData = function(field, value) {
+	if(!this._staticValues) {
+		this._staticValues = {};
+	}
+	this._staticValues[field] = value;
+
+	this.setData(field, value);
+};
+/** @public
+* @param {Object.<string, *>} data
+*/
+RowDefinition.prototype.setRowData = function(data) {
+	if(this._dc) {
+		this._dc.setRowData(this._dataId, data);
+	}
+};
+/** @public
+* @param {string} field
+* @param {*} value
+*/
+RowDefinition.prototype.setData = function(field, value) {
+	if(this._dc) {
+		this._dc.setData(this._dataId, field, value);
+	}
+};
+/** @private
+*/
+RowDefinition.prototype._clearStaticData = function() {
+	if(this._staticValues) {
+		for(var key in this._staticValues) {
+			this._staticValues[key] = null;
+		}
+		if(this._dc) {
+			this._dc.setRowData(this._dataId, this._staticValues);
+		}
+		this._staticValues = null;
+	}
+};
+
+/** @public
+* @return {string}
+*/
+RowDefinition.prototype.getUserInput = function() {
+	return this._userInput;
+};
+/** @public
+* @return {string}
+*/
+RowDefinition.prototype.getRic = function() {
+	return this._ric;
+};
+/** @public
+* @return {string}
+*/
+RowDefinition.prototype.getDisplayText = function() {
+	if(this._label != null) { // Empty string is allowed
+		return this._label;
+	}
+	return this._displayText;
+};
+/** @public
+* @return {string|null}
+*/
+RowDefinition.prototype.getLabel = function() {
+	return this._label;
+};
+
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isRowHeader = function() {
+	return (this._userInput.charAt(0) === "'");
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isChain = function() {
+	return this._isChain;
+};
+/** @public
+* @function
+* @param {RowDefinition} rowDef
+* @return {boolean}
+*/
+RowDefinition.hasChain = function(rowDef) {
+	return rowDef.isChain();
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isChainCollapsed = function() {
+	if(this._view) {
+		return this._view.isSegmentCollapsed(this._rowId);
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isChainExpanded = function() {
+	return !this.isChainCollapsed();
+};
+/** @public
+* @ignore
+* @return {boolean}
+*/
+RowDefinition.prototype.isFixedPosition = function() {
+	return this._isChain && this.isChainExpanded();
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isAutoGenerated = function() {
+	return this._autoGenerated;
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isRealTimeRow = function() {
+	if(!this._ric) { // Empty row
+		return false;
+	}
+	if(this.isRowHeader()) {
+		return false;
+	}
+	if(this._autoGenerated) { // Constituents in chain are not real-time row
+		return false;
+	}
+
+	return true;
+};
+
+/** @public
+*/
+RowDefinition.prototype.subscribeForUpdates = function() {
+	if(!this.isRealTimeRow()) {
+		return;
+	}
+
+	var subs = this._dc ? this._dc.getSubscriptions() : null;
+	if(!subs) {
+		return;
+	}
+	// TODO: Check if the same subscription is being made.
+	var prevRowData = this.unsubscribeForUpdates();
+
+	if(this.isChain()) {
+		this._subId = subs["addChain"](this._chainRic || this._ric, this._rowId); // Some chain require 0# symbol to populate its constituents
+		// TODO: Handle Dynamic chain such as .PG.PA
+	} else {
+		this._subId = subs["addRic"](this._ric, this._rowId);
+	}
+
+	if(prevRowData) {
+		this._dc.setRowData(this._dataId, prevRowData); // TODO: We may need to create a new object instead of prevRowData for data correctness
+	} else {
+		this._dc.setRowData(this._dataId, {"X_RIC_NAME": this._ric, "ROW_DEF": this}); // Trigger data update immediately
+	}
+};
+/** @public
+ * @returns {*}
+*/
+RowDefinition.prototype.unsubscribeForUpdates = function() {
+	if(!this._subId) {
+		return;
+	}
+
+	var subs = this._dc.getSubscriptions();
+	var prevRowData = this.getRowData();
+
+	subs["removeSubscription"](this._subId);
+	this._subId = "";
+	this.resetUpdates();
+	// TODO: Reset only if this is the last ric
+	this._dc.setRowData(this._dataId, null); // Trigger data update immediately
+	// TODO: Handle static values
+	// eslint-disable-next-line consistent-return
+	return prevRowData;
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isSubscribing = function() {
+	return this._subId ? true : false;
+};
+
+/** Take event argument from streaming update with "changes" array property
+* @public
+* @param {Object} e Object with changes property
+* @return {boolean} Returns true if there is any change
+*/
+RowDefinition.prototype.addUpdate = function(e) {
+	if(e) {
+		var changes = e["changes"];
+		if(changes) {
+			var dirty = 0;
+			for(var field in changes) {
+				this._changes[field] = dirty = 1;
+			}
+			if(dirty) {
+				++this._updateCount;
+				return true;
+			}
+		}
+	}
+	return false;
+};
+/** If there is no update, this method returns null
+* @public
+* @return {Object.<string, number>}
+*/
+RowDefinition.prototype.getUpdates = function() {
+	return this._updateCount ? this._changes : null;
+};
+/** @public
+*/
+RowDefinition.prototype.resetUpdates = function() {
+	if(this._updateCount) {
+		this._changes = {};
+		this._updateCount = 0;
+	}
+};
+
+/** @public
+* @param {DataTable} view
+* @param {string=} rowId
+*/
+RowDefinition.prototype.registerToView = function(view, rowId) {
+	if(!view || this._view === view) {
+		return; // Already in the view
+	}
+	this._view = view;
+
+	var rowData = {};
+	rowData[ROW_DEF] = this;
+
+	var newRowId = this._view.insertRow(rowId, rowData, this.getRowId());
+	this._rowId = newRowId; // In case there is some duplicate row id.
+
+	if(this._isChain) {
+		view.setSegmentSeparator(this._rowId);
+		if(!this._expanded) {
+			this.collapseChain();
+		}
+	}
+};
+/** @private
+* @param {Array.<string>=} rowIds
+* @return {string}
+*/
+RowDefinition.prototype._deregisterFromView = function(rowIds) {
+	if(this._view) {
+		if(rowIds) {
+			rowIds.push(this._rowId);
+		}
+
+		this._view = null;
+		return this._rowId;
+	}
+	return "";
+};
+/** @public
+* @function
+* @param {Array.<string>} rowIds
+* @param {RowDefinition} rowDef
+* @return {Array.<string>}
+* @example
+* var rowIds = descendants.reduce(RowDefinition.deregisterFromView, []);
+*/
+RowDefinition.deregisterFromView = function(rowIds, rowDef) {
+	rowDef._deregisterFromView(rowIds);
+	return rowIds;
+};
+/** @public
+* @ignore
+* @param {string} ric
+* @return {RowDefinition} Return newly created child definition, if success
+*/
+RowDefinition.prototype.addConstituent = function(ric) {
+	if(!ric || this._ric === ric) { // Parent cannot have a child with no name or the same name as itself
+		return null;
+	}
+	if(!(this._rowId && this._subId && this._isChain)) { // Chain must be alive (has not been disposed). Chain must be subscribed as chain
+		return null;
+	}
+
+	var childDef = null;
+	if(this._children) {
+		for(var i = this._children.length; --i >= 0;) {
+			if(this._children[i]._ric === ric) {
+				childDef = this._children[i]; // Constituent has already been added
+				break;
+			}
+		}
+	} else {
+		this._children = [];
+	}
+
+	var newChild = !childDef;
+	if(newChild) {
+		childDef = new RowDefinition({
+			"asConstituent": true,
+			"dataId": this._subId + ric,
+			"ric": ric,
+			"parent": this
+		});
+	}
+
+	if(this._view) {
+		// WARNING: ChildCount may not be enough to determine proper inserting position
+		// TODO: Handle nested children
+		var rowId = this.getRowId();
+		var rowIndex = this._view.getRowIndex(rowId) + this.getChildCount(); // Children must be directly under its parent
+		childDef.registerToView(this._view, this._view.getRowId(rowIndex));
+		this._view.addSegmentChild(rowId, childDef.getRowId());
+	}
+
+	return newChild ? childDef : null;
+};
+/** @public
+* @return {boolean} Returns true if there is a change in view
+*/
+RowDefinition.prototype.collapseChain = function() {
+	if(this._isChain && this._view) {
+		this._expanded = false;
+		return this._view.collapseSegment(this._rowId, true);
+	}
+	return false;
+	// if(this._children) {
+	// this._children.forEach(RowDefinition.dispose); // All descendants will be removed too
+	// this._children = null;
+	// }
+	// unsub chain
+	// resub index
+};
+/** @public
+* @return {boolean} Returns true if there is a change in view
+*/
+RowDefinition.prototype.expandChain = function() {
+	if(this._isChain && this._view) {
+		this._expanded = true;
+		return this._view.collapseSegment(this._rowId, false);
+	}
+	return false;
+	// unsub index
+	// resub chain
+};
+
+/** Toggle between chain expanding and collapsing
+* @public
+* @return {boolean} Returns true if there is a change in view
+*/
+RowDefinition.prototype.toggleChain = function() {
+	if(this._expanded) {
+		return this.collapseChain();
+	} else {
+		return this.expandChain();
+	}
+};
+
+/** @public
+* @ignore
+* @param {RowDefinition} childDef
+* @return {boolean} Returns true if success
+*/
+RowDefinition.prototype.addChild = function(childDef) {
+	if(!childDef) {
+		return false;
+	}
+	return childDef.setParent(this);
+};
+/** @public
+* @return {Array.<RowDefinition>}
+*/
+RowDefinition.prototype.getChildren = function() {
+	return this._children;
+};
+/** Get all descendants (i.e. children and nested children).
+* @public
+* @param {Array.<RowDefinition>=} ary
+* @return {!Array.<RowDefinition>} Flat list of row definitions. The order is corresponded to the order of the rows in the view
+*/
+RowDefinition.prototype.getDescendants = function(ary) {
+	if(!ary) {
+		ary = [];
+	}
+	if(this._children) {
+		var chdr = this._children;
+		var len = chdr.length;
+		for(var i = 0; i < len; ++i) {
+			var ch = chdr[i];
+			ary.push(ch);
+			ch.getDescendants(ary);
+		}
+	}
+	return ary;
+};
+/** Get rowIds of all descendants (i.e. children and nested children).
+* @public
+* @return {Array.<string>} Null if there is no row Id
+*/
+RowDefinition.prototype.getAllDescendantIds = function() {
+	var descendants = this.getDescendants();
+	if(descendants.length) {
+		return descendants.map(RowDefinition.toRowId);
+	} else {
+		return null;
+	}
+};
+/** @public
+* @return {number}
+*/
+RowDefinition.prototype.getChildCount = function() {
+	return (this._children) ? this._children.length : 0;
+};
+/** @public
+* @return {RowDefinition}
+*/
+RowDefinition.prototype.getParent = function() {
+	return this._parent;
+};
+/** @public
+* @ignore
+* @param {RowDefinition} parentDef
+* @return {boolean} Returns true if success
+*/
+RowDefinition.prototype.setParent = function(parentDef) {
+	if(this._parent === parentDef || parentDef === this) { // The same parent is given
+		return false;
+	}
+	if(this._parent) { // Release from previous parent
+		var at = this._parent._children.lastIndexOf(this);
+		if(at >= 0) {
+			this._parent._children.splice(at, 1);
+		}
+		this._parent = null;
+		this._depthLevel = 0; // TODO: Update depth of children
+	}
+
+	if(parentDef) {
+		if(!parentDef._children) {
+			parentDef._children = [];
+		}
+		// WARNING: No duplication checking
+		parentDef._children.push(this);
+		this._parent = parentDef;
+		this._depthLevel = parentDef._depthLevel + 1; // TODO: Update depth of children
+		return true;
+	}
+	return false;
+};
+/** @public
+* @return {number}
+*/
+RowDefinition.prototype.getDepthLevel = function() {
+	return this._depthLevel;
+};
+/** @public
+* @ignore
+* @return {number}
+*/
+RowDefinition.prototype.getGroupOrder = function() {
+	if(this._parent) {
+		return this._parent.getGroupOrder() + 0.1; // Plus level. TODO: Support nested level
+	}
+	return this._groupOrder;
+};
+/** @public
+* @ignore
+* @param {number} num
+* @return {boolean} Return true if there is any change
+*/
+RowDefinition.prototype.setGroupOrder = function(num) {
+	if(!this._parent) { // Only root node can have group order
+		if(this._groupOrder !== num) {
+			this._groupOrder = num;
+			return true;
+		}
+	}
+	return false;
+};
+
+/** @public
+* @return {Object}
+*/
+RowDefinition.prototype.getUserModel = function() {
+	return this._userModel;
+};
+
+/** For mapping row Id by Array.map()
+* @public
+* @function
+* @param {RowDefinition} rowDef
+* @return {string} Row Id will never be empty string unless the row has been removed
+*/
+RowDefinition.toRowId = function(rowDef) {
+	return rowDef.getRowId();
+};
+/** For mapping row Id by Array.map()
+* @public
+* @function
+* @param {RowDefinition} rowDef
+*/
+RowDefinition.dispose = function(rowDef) {
+	rowDef.dispose();
+};
+
+export {RowDefinition, ROW_DEF};
+export default RowDefinition;