@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

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

@@ -0,0 +1,1478 @@
+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 {string=} permId="" Organization PermId to be used instead of ric for private company.
+* @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 Chain is collapsed by default. Segment is expanded by default.
+* @property {(string|null)=} label=null
+* @property {boolean=} hidden=true When this row is hidden
+* @property {boolean=} realTime=true Realtime row, able to request for JET/RTK
+* @property {Object=} info=null For storing any additional information to the row
+* @property {string=} rowId Row identifier used for referencing the row. The value cannot be in "_x_" format.
+*/
+
+/** @typedef {Object} RowDefinition~RowTypes
+* @property {string} CONTENT="CONTENT" Regular row
+* @property {string} CHAIN="CHAIN" Chain RIC row
+* @property {string} CONSTITUENT="CONSTITUENT" Constituent row
+* @property {string} GROUP_HEADER="GROUP_HEADER" Row of segment separator at the very top
+* @property {string} SUBGROUP_HEADER="SUBGROUP_HEADER" Row of nested segment separator
+* @property {string} GROUP_MEMBER="GROUP_MEMBER" Child row displayed under segment separator
+*/
+
+/** @type {string}
+* @public
+* @const
+*/
+const ROW_DEF = "ROW_DEF";
+
+/** @type {!RowDefinition~RowTypes}
+* @public
+* @const
+*/
+const ROW_TYPES = {
+	CONTENT: "CONTENT",
+	CHAIN: "CHAIN",
+	CONSTITUENT: "CONSTITUENT",
+	GROUP_HEADER: "GROUP_HEADER",
+	SUBGROUP_HEADER: "SUBGROUP_HEADER",
+	GROUP_MEMBER: "GROUP_MEMBER"
+};
+
+/** @private
+* @function
+* @param {Object} obj
+* @returns {!Object} Always returns a new object
+*/
+let _cloneObject = function(obj) {
+	let newObj = {};
+	for(let key in obj) {
+		newObj[key] = obj[key];
+	}
+	return newObj;
+};
+
+/** @constructor
+* @param {RowDefinition~Options=} rowOptions
+*/
+let RowDefinition = function(rowOptions) {
+	this._changes = {};
+	if(rowOptions && rowOptions["segmentId"]) { // This row will be classified header row (subsegment header row)
+		this._rowId = rowOptions["segmentId"];
+		this._autoGenerated = true;
+		this._subSegment = true;
+		return;
+	}
+
+	this._rowId = "_" + RowDefinition._runningId++ + "_";
+
+	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;
+/** @type {string}
+* @private
+*/
+RowDefinition._childDataField = "CHILD_VALUES";
+/** @type {RegExp}
+* @private
+* @const
+*/
+RowDefinition.ROW_ID_PATTERN = /^_[^_]+_$/;
+//#region Private Members
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._userInput = "";
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._ric = ""; // Contains no 0#
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._permId = "";
+/** @type {string|null}
+* @private
+*/
+RowDefinition.prototype._label = null; // Label overrides _ric and _permId
+/** @type {boolean|null}
+* @private
+*/
+RowDefinition.prototype._isChain = null;
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._asSegment = false;
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._realTime = true;
+
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._rowId = ""; // Row Id must be unique
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._userId = false;
+/** @type {DataCache}
+* @private
+*/
+RowDefinition.prototype._dc = null;
+/** Quotes2 subscription object
+* @type {Object}
+* @private
+*/
+RowDefinition.prototype._subs = null;
+/** @type {DataView}
+* @private
+*/
+RowDefinition.prototype._view = null;
+
+/** @type {string}
+* @private
+*/
+RowDefinition.prototype._subId = "";
+
+/** @type {boolean|null}
+* @private
+*/
+RowDefinition.prototype._collapsed = null;
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._autoGenerated = false;
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._subSegment = 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;
+/** @type {Object}
+* @private
+*/
+RowDefinition.prototype._info = null;
+
+//#endregion Private Members
+
+/** @public
+*/
+RowDefinition.prototype.dispose = function() {
+	if(this.isDisposed()) {
+		return;
+	}
+
+	if(this._children) {
+		this._children.forEach(RowDefinition.dispose);
+		this._children = null;
+	}
+
+	if(this._dc) {
+		this._dc.setRowData(this._rowId, null); // Clear all data held by this row def
+		this._dc = 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();
+	this._subs = null;
+	this._view = null; // WARNING: This does not remove this row from the UI view
+
+	this._subId = this._rowId = "";
+	this._userId = false;
+	this._autoGenerated = false;
+	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;
+	}
+
+	if(!this._autoGenerated) {
+		let userRowId = rowOptions["rowId"];
+		if(userRowId && typeof userRowId === "string") {
+			if(userRowId.match(RowDefinition.ROW_ID_PATTERN)) {
+				console.warn("Please change the rowId format to avoid duplicated rows' id causing unexpected behavior.");
+			} else {
+				this._rowId = userRowId;
+				this._userId = true;
+			}
+		}
+	}
+
+	let extractedOptions = RowDefinition.extractRowOptions(rowOptions);
+
+	let val = rowOptions["permId"];
+	if(val != null) {
+		this._permId = val;
+	}
+	val = rowOptions["ric"];
+	if(val != null) {
+		this._ric = val;
+	}
+	val = rowOptions["label"];
+	// eslint-disable-next-line no-undefined
+	if(val !== undefined) { // Empty string and null are allowed
+		this._label = val;
+	}
+	val = rowOptions["chainRic"];
+	if(val != null) {
+		this._chainRic = val;
+	}
+
+	val = extractedOptions["asChain"];
+	if(val != null) {
+		this._isChain = val ? true : false;
+	}
+
+	val = rowOptions["realTime"];
+	if(val != null) {
+		this._realTime = val;
+	}
+
+	val = rowOptions["asSegment"];
+	if(val != null) {
+		this._asSegment = val ? true : false;
+	}
+
+	if(this._isChain || this._asSegment) {
+		this._collapsed = extractedOptions["collapsed"]; // Temporary state
+	}
+
+	val = rowOptions["keepModel"];
+	if(val) {
+		this._userModel = rowOptions;
+	}
+	val = rowOptions["info"];
+	if(val) {
+		this._info = val;
+	}
+
+	let symbol = this._ric || this._chainRic;
+	if(symbol || this._permId){
+		this.setContent(symbol, extractedOptions);
+	}
+
+	val = rowOptions["values"];
+	// eslint-disable-next-line no-undefined
+	if(val !== undefined) {
+		this.setStaticRowData(val, rowOptions["fields"]);
+	}
+};
+/** @description Constituents will have subscription id, but have no subscription. It's row id will be different from subscription id. It will have a reference to its parent. It cannot be generated by themselve -- always be autogenerated.
+* @private
+* @param {!Object} rowOptions
+*/
+RowDefinition.prototype._initializeAsConstituent = function(rowOptions) {
+	this._autoGenerated = true;
+	let parentDef = /** @type{RowDefinition} */(rowOptions["parent"]);
+	if(this.setParent(parentDef)) {
+		this._ric = /** @type{string} */(rowOptions["ric"]);
+		this._dc = parentDef._dc; // Parent chain must have data cache
+		this._subId = parentDef._subId; // Child constituent uses the same subscription as its parent
+	}
+	this._staticValues = rowOptions["values"] || null;
+	this.resetRowData();
+};
+/** @private
+* @param {DataView} view
+* @param {string} rowId
+* @returns {string}
+*/
+let _getEndOfSegmentRowId = function(view, rowId) {
+	let rowIndex = view.getRowIndex(rowId);
+	do {
+		rowId = view.getRowId(++rowIndex);
+		if(rowId && !view.getSegmentParentRowId(rowId)) {
+			break;
+		}
+	} while(rowId);
+	return rowId;
+};
+
+/** @private
+* @param {DataView} view
+* @param {boolean} newState
+* @param {boolean} prevState
+* @returns {boolean} Current state
+*/
+let _stallSorting = function(view, newState, prevState) {
+	if(view && view.isSorting()) {
+		newState = newState ? true : false;
+		if(newState !== prevState) {
+			if(newState) {
+				view.synchronizeRowOrder();
+			}
+			view.stallSorting(newState);
+		}
+		return newState;
+	}
+	return false;
+};
+/** @public
+* @ignore
+* @param {string} userInput RIC
+* @param {Object} extractedOptions
+* @return {boolean} True if there is any change otherwise false
+*/
+RowDefinition.prototype.setContent = function(userInput, extractedOptions) {
+	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 += "";
+	}
+
+	let dirty = (this._userInput !== userInput);
+	let permId = extractedOptions["permId"] || "";
+	if(this._permId !== permId){
+		this._permId = permId;
+		dirty = true;
+	}
+	if(!dirty) {
+		return false;
+	}
+
+	let asChain = extractedOptions["asChain"];
+	let realtimeRow = true;
+	if(userInput.charAt(0) === "'") { // Single quote is used as a marker for non realtime row
+		realtimeRow = false;
+		this._ric = this._chainRic = ""; // No ric for realtime request
+	}
+
+	let dv = this._view;
+	let stalledSorting = _stallSorting(dv, realtimeRow && asChain, false); // To preserve current position of the segment/chain
+
+	this.unsubscribeForUpdates(); // Static data remains intact
+
+	this._userInput = userInput;
+	let collapsed = extractedOptions["collapsed"];
+	if(realtimeRow) {
+		let chainRic = extractedOptions["chainRic"];
+		if(asChain === true){
+			this._ric = collapsed === true ? userInput : userInput.replace("0#", "");
+		} else {
+			this._ric = userInput;
+		}
+		this._isChain = asChain != null ? asChain : null; // this could be null or undefined
+		this._chainRic = chainRic || "";
+	}
+
+	if(dv) {
+		let segmentId = dv.getSegmentParentRowId(this._rowId);
+		if(segmentId) {
+			if(this._isChain){ // If the row was a normal row and has been changed to a chain, remove it from existing segment
+				let targetRowId = _getEndOfSegmentRowId(dv, this._rowId);
+				dv.removeSegmentChild(segmentId, this._rowId);
+				dv.moveRow(this._rowId, targetRowId);
+
+				segmentId = "";
+			}
+		} else if(dv.getSegment(this._rowId)) {
+			dv.setSegmentSeparator(this._rowId, false); // Remove existing segment
+		}
+		if(this._isChain) {
+			dv.setSegmentSeparator(this._rowId, true);
+		}
+
+		if(collapsed !== this.isChainCollapsed()) { // WARNING: This is not optimizsed
+			dv.collapseSegment(this._rowId, collapsed);
+		}
+		this._collapsed = null;
+
+		_stallSorting(dv, false, stalledSorting);
+		if(segmentId) { // If data id is changed and the row is a child of a segment, then segment child data id must be updated
+			dv.addSegmentChild(segmentId, this._rowId);
+		}
+	}
+
+	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;
+};
+/** @public
+* @param {RowDefinition~Options=} rowOptions
+* @return {RowDefinition~Options}
+*/
+RowDefinition.prototype.getConfigObject = function(rowOptions) {
+	let obj = rowOptions || {};
+
+	if(this._userId) {
+		obj["rowId"] = this._rowId;
+	}
+
+	let val = this._ric;
+	if(val) {
+		obj["ric"] = val;
+	}
+
+	// The user passed a single quote (') case
+	if(!this._ric && this._userInput.charAt(0) === "'") {
+		obj["ric"] = this._userInput;
+	}
+
+	val = this._realTime;
+	if(!val) {
+		obj["realTime"] = false;
+	}
+
+	val = this._permId;
+	if(val) {
+		obj["permId"] = val;
+	}
+
+	val = this._chainRic;
+	if(val) {
+		obj["chainRic"] = val;
+	}
+
+	val = this._label;
+	if(val) {
+		obj["label"] = val;
+	}
+
+	val = this._userModel;
+	if(val) {
+		obj["keepModel"] = obj; // This is bad
+	}
+
+	val = this._isChain;
+	if(val != null) {
+		obj["asChain"] = val;
+	}
+
+	val = this._collapsed;
+	if(val != null) {
+		obj["collapsed"] = val;
+	}
+
+	val = this._view ? this._view.isHiddenRow(this._rowId) : false;
+	if(val) {
+		obj["hidden"] = val;
+	}
+
+	val = this._info;
+	if(val) {
+		obj["info"] = this._info;
+	}
+
+	val = this._cloneStaticRowData();
+	if(val) {
+		obj["values"] = val;
+	}
+
+	// obtain the static values of constituent rows
+	if(this.isChain()) {
+		let children = this.getChildren();
+		if(children) {
+			let childValues = val ? val[RowDefinition._childDataField] : {};
+			if(!childValues) {
+				childValues = {};
+			}
+			let dirty = false;
+			let len = children.length;
+			let i, rowDef, staticValues;
+			for(i = 0; i < len; i++) {
+				rowDef = children[i];
+				staticValues = rowDef._cloneStaticRowData();
+				if(staticValues) {
+					dirty = true;
+					childValues[rowDef.getRic()] = staticValues;
+				}
+			}
+
+			if(dirty) {
+				if(!obj["values"]) {
+					obj["values"] = {};
+				}
+				obj["values"][RowDefinition._childDataField] = childValues;
+			}
+		}
+	}
+
+	return obj;
+};
+/** Data id is deprecated
+* @public
+* @return {string} Always return empty string
+*/
+RowDefinition.prototype.getDataId = function() {
+	return "";
+};
+/** @public
+* @return {string}
+*/
+RowDefinition.prototype.getType = function() {
+	if(this._isChain) {
+		return ROW_TYPES.CHAIN;
+	} else if(this._parent) {
+		return ROW_TYPES.CONSTITUENT;
+	} else {
+		let dv = this._view;
+		if(dv) {
+			let rid = this.getRowId();
+			let separator = dv.isSegmentSeparator(rid);
+			let level = dv.getSegmentLevel(rid);
+			if(separator) {
+				if(level === 1) {
+					return ROW_TYPES.GROUP_HEADER;
+				} else {
+					return ROW_TYPES.SUBGROUP_HEADER;
+				}
+			} else {
+				if(dv.getSegmentParentRowId(rid)) {
+					return ROW_TYPES.GROUP_MEMBER;
+				}
+			}
+		} else {
+			return "";
+		}
+	}
+	return ROW_TYPES.CONTENT;
+};
+/** This method should always be called right after the initialization
+* @public
+* @param {DataCache} dataSource
+* @param {Object=} subs Quotes2 subscription object
+* @return {boolean} Returns true if there is an data update
+*/
+RowDefinition.prototype.setDataSource = function(dataSource, subs) {
+	this._dc = dataSource || null;
+	let dataUpdated = false;
+	if(this._dc) {
+		if(this._staticValues) {
+			let rowData = _cloneObject(this._staticValues);
+			dataUpdated = this.addUpdate(rowData);
+			this._dc.setRowData(this._rowId, rowData, {
+				"rowDef": this, // The _onDataChanged and _onDataComposed handlers cannot get rowDef from DT because row does not register to view yet.
+				"initialChanges": this.getUpdates() // Used by _onDataComposed to keep backward compatibility.
+			}); // Trigger dataComposed and add updates
+		} else {
+			this._dc.setRowData(this._rowId, {});
+		}
+	}
+
+	this._subs = subs || null;
+	// This will work for runtime row insertion, but not for first initilization.
+	this.subscribeForUpdates();
+	return dataUpdated;
+};
+/** @public
+* @return {DataCache} dataSource
+*/
+RowDefinition.prototype.getDataSource = function() {
+	return this._dc;
+};
+
+/** @public
+* @return {Object} rowData
+*/
+RowDefinition.prototype.getRowData = function() {
+	return this._dc ? this._dc.getRowData(this._rowId) : {};
+};
+/** @public
+* @param {string} field
+* @return {*} data
+*/
+RowDefinition.prototype.getData = function(field) {
+	return this._dc ? this._dc.getData(this._rowId, field) : null;
+};
+
+/** This method replaces all existing static data by the given data -- all existing static data are removed.
+* @public
+* @param {Object.<string, *>|Array} data
+* @param {Array.<string>=} indexToFieldMap In case of the given data is an array, this param will be used for mapping index to field
+*/
+RowDefinition.prototype.setStaticRowData = function(data, indexToFieldMap) {
+	this._clearStaticData();
+
+	if(Array.isArray(data)) { // Convert array to object
+		data = arrayToObject(data, indexToFieldMap);
+	}
+
+	this._staticValues = (typeof data === "object") ? data : null;
+
+	if(this._staticValues) {
+		this.setRowData(data);
+	}
+};
+/** @private
+* @return {Object.<string, *>}
+*/
+RowDefinition.prototype._cloneStaticRowData = function() {
+	return this._staticValues ? _cloneObject(this._staticValues) : null;
+};
+/** @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, *>|Array} data
+* @param {Array.<string>=} indexToFieldMap In case of the given data is an array, this param will be used for mapping index to field
+*/
+RowDefinition.prototype.updateRowData = function(data, indexToFieldMap) {
+	if(Array.isArray(data)) { // Convert array to object
+		data = arrayToObject(data, indexToFieldMap);
+	}
+
+	if(data) {
+		this.setRowData(data);
+	}
+};
+/** @public
+* @param {RowDefinition} srcRowDef Original source of row data to be copied from
+*/
+RowDefinition.prototype.copyRowData = function(srcRowDef) {
+	if(srcRowDef && srcRowDef !== this) {
+		let rowData = this.getRowData();
+		srcRowDef.cloneRowData(rowData, this._staticValues);
+	}
+};
+/** @public
+ * @param {Object=} obj
+ * @param {Object=} exceptionObj
+ * @return {!Object}
+*/
+RowDefinition.prototype.cloneRowData = function(obj, exceptionObj) {
+	let rowObj = obj || {};
+	let field;
+	let uncopiable_fields = {
+		"ROW_DEF": 1,
+		"SUB_ID": 1
+	};
+	let staticValues = this._staticValues;
+	for(field in staticValues) {
+		uncopiable_fields[field] = 1;
+	}
+
+	for(field in exceptionObj) {
+		uncopiable_fields[field] = 1;
+	}
+
+	let rowData = this.getRowData();
+	for(field in rowData) {
+		if(!uncopiable_fields[field]) {
+			rowObj[field] = rowData[field];
+		}
+	}
+	return rowObj;
+};
+/** @public
+* @param {Object.<string, *>} data
+*/
+RowDefinition.prototype.setRowData = function(data) {
+	if(this._dc) {
+		this._dc.setRowData(this._rowId, data);
+	}
+};
+/** @public
+*/
+RowDefinition.prototype.resetRowData = function() {
+	let dc = this._dc;
+	if(dc) {
+		let rowId = this._rowId;
+		dc.setRowData(rowId, null);
+		dc.setRowData(rowId, {}); // Row data is guaranteed to be existed
+		if(this._staticValues) {
+			dc.setRowData(rowId, this._staticValues);  // Trigger dataComposed and add updates
+		}
+	}
+};
+/** @public
+* @param {string} field
+* @param {*} value
+*/
+RowDefinition.prototype.setData = function(field, value) {
+	if(this._dc) {
+		this._dc.setData(this._rowId, field, value);
+	}
+};
+/** @private
+*/
+RowDefinition.prototype._clearStaticData = function() {
+	let staticValues = this._staticValues;
+	if(staticValues) {
+		if(this._dc) {
+			let obj = {};
+			for(let key in staticValues) {
+				obj[key] = null;
+			}
+			this._dc.setRowData(this._rowId, obj);
+		}
+		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.getPermId = function() {
+	return this._permId;
+};
+/** @public
+* @return {string}
+*/
+RowDefinition.prototype.getSymbol = function() {
+	return this._ric || this._permId;
+};
+/** @public
+* @return {string}
+*/
+RowDefinition.prototype.getDisplayText = function() {
+	if(this._label != null) { // Empty string is allowed
+		return this._label;
+	}
+
+	if(this._ric) { // Use chainRic instead if this is a chain
+		return this._ric;
+	}
+
+	if(this._permId) {
+		return this._permId;
+	}
+
+	return this._userInput;
+};
+/** @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
+* @return {boolean}
+*/
+RowDefinition.prototype.isConstituent = function() {
+	return (this._autoGenerated && this._subId && this._rowId !== this._subId) ? true : false;
+};
+/** @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.getRic()) { // Empty row
+		return false;
+	}
+	if(!this._realTime) {
+		return false;
+	}
+
+	if(this._autoGenerated) { // Constituents in chain are not real-time row
+		return false;
+	}
+
+	if(this.isRowHeader()) {
+		return false;
+	}
+
+	return true;
+};
+
+/** @public
+* @param {Object=} subs
+* @return {boolean} If a subscription is made, return true.
+*/
+RowDefinition.prototype.subscribeForUpdates = function(subs) {
+	if(!(subs  || this._subs)) {
+		return false;
+	}
+	if(!this.isRealTimeRow() && !this.getPermId()) {
+		return false;
+	}
+	// TODO: Check if the same subscription is being made.
+	this.unsubscribeForUpdates();
+	if(subs) {
+		this._subs = subs;
+	} else {
+		subs = this._subs;
+	}
+	if(this.isChain()) {
+		let symbol = this._chainRic;
+		if(!symbol){
+			symbol = this._ric;
+			if(symbol.indexOf("0#") < 0){
+				let count = (symbol.match(/\./g) || []).length;
+				if(count < 2){
+					symbol = "0#" + symbol;
+				}
+			}
+		}
+		this._subId = subs["addChain"](symbol, this._rowId); // Some chain require 0# symbol to populate its constituents
+	} else if(this._ric) {
+		this._subId = subs["addRic"](this._ric, this._rowId);
+	}
+
+	let xRicName = this.getDisplayText(); // WARNING: This does not cover real-time X_RIC_NAME updates
+	this.setRowData({"X_RIC_NAME": xRicName}); // Trigger data update immediately
+
+	return true;
+};
+/** Unsubscribe existing real-time data service. Static data is maintained
+* @public
+* @param {boolean=} keepData
+* @returns {null} Always return null
+*/
+RowDefinition.prototype.unsubscribeForUpdates = function(keepData) {
+	if(this.isSubscribing()) { // Only normal real-time rows and chains have both subId and subscription object
+		this._subs["removeSubscription"](this._subId);
+		this._subId = "";
+		if(!keepData) {
+			this.resetUpdates();
+			this.resetRowData(); // Real-time data is removed while static data is maintained
+		}
+	}
+	return null;
+};
+/** @public
+* @return {boolean}
+*/
+RowDefinition.prototype.isSubscribing = function() {
+	return (this._subId && this._subs) ? true : false;
+};
+/** @public
+* @return {string}
+*/
+RowDefinition.prototype.getSubId = function() {
+	return this._subId;
+};
+
+/** Take event argument from streaming update with "changes" array property
+* @public
+* @param {Object} changes
+* @return {boolean} Returns true if there is any change
+*/
+RowDefinition.prototype.addUpdate = function(changes) {
+	if(changes) {
+		let dirty = 0;
+		for(let 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 {DataView} view
+* @param {string=} destRowId Destination position where the row will be placed BEFORE the specified position
+* @returns {boolean} Returns true for successful registration
+*/
+RowDefinition.prototype.registerToView = function(view, destRowId) {
+	if(!view || this._view === view) {
+		return false; // Already in the view
+	}
+
+	this._view = view;
+	let rowId = this._rowId;
+	let rowData = view.getRowData(rowId);
+	if(rowData && rowData[ROW_DEF]) {
+		console.warn("Duplicate row id detected");
+		return false;
+	}
+
+	if(this._subSegment) {
+		if(rowData) { // Row data for sub segment has been created by data view
+			rowData[ROW_DEF] = this; // It only needs to register row def to the row data
+		}
+		return true;
+	}
+
+	rowData = {};
+	rowData[ROW_DEF] = this;
+
+	let parentRowId = "";
+	let isSegment = this._isChain || this._asSegment;
+	if(destRowId) {
+		parentRowId = view.getSegmentParentRowId(destRowId);
+		if(parentRowId) {
+			if(isSegment) { // A chain or a segment cannot be put inside another segment
+				destRowId = _getEndOfSegmentRowId(view, destRowId);
+			} else if(!this.isConstituent()) { // Normal row cannot be put inside another chain
+				let parentRowDef = view.getData(parentRowId, ROW_DEF);
+				if(parentRowDef.isChain()) {
+					parentRowId = null;
+					destRowId = _getEndOfSegmentRowId(view, destRowId);
+				} // else { // Normal row is inserted into a segment
+			} // Constituent can be inserted inside a chain
+		}
+	}
+
+	let stalledSorting = _stallSorting(view, isSegment, false);
+	view.insertRow(destRowId, rowData, rowId);
+
+	if(isSegment) {
+		view.setSegmentSeparator(rowId);
+		_stallSorting(view, false, stalledSorting);
+		if(this._collapsed != null) {
+			view.collapseSegment(rowId, this._collapsed);
+			this._collapsed = null;
+		}
+	} else if(!this._parent && parentRowId) { // Constituent cannot be added to another segment
+		view.addSegmentChild(parentRowId, rowId);
+	}
+
+	return true;
+};
+/** @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 "";
+};
+/** Deprecated.
+* @public
+* @ignore
+* @function
+* @param {Array.<string>} rowIds
+* @param {RowDefinition} rowDef
+* @return {Array.<string>}
+* @example
+* let rowIds = descendants.reduce(RowDefinition.deregisterFromView, []);
+*/
+RowDefinition.deregisterFromView = function(rowIds, rowDef) {
+	rowDef._deregisterFromView(rowIds);
+	return rowIds;
+};
+
+/** @public
+* @ignore
+* @param {string} ric
+* @return {RowDefinition}
+*/
+RowDefinition.prototype.getConstituent = function(ric) {
+	if(this._children && ric) {
+		for(let i = this._children.length; --i >= 0;) {
+			if(this._children[i]._ric === ric) {
+				return this._children[i];
+			}
+		}
+	}
+	return null;
+};
+
+/** Check whether the given ric can be a constituent of this row definition. WARNING: permId is not handled by this method
+* @public
+* @ignore
+* @param {string} ric
+* @return {boolean} Returns true if the given ric can be its constituent
+*/
+RowDefinition.prototype.verifyConstituent = function(ric) {
+	if(this._isChain && ric) { // A constituent must have a valid ric
+		if(this._ric !== ric) { // A constituent cannot have the same ric as its parent
+			if(this._ric !== ("0#" + ric)) { // Real-time service may return ric without 0#
+				return this._ric !== ("/" + ric); // Real-time service may return ric with slash (delayed ric)
+			}
+		}
+	}
+	return false;
+};
+/** verifyConstituent should be called before calling this method
+* @public
+* @ignore
+* @param {string} ric
+* @return {RowDefinition} Return newly created child definition, if success
+*/
+RowDefinition.prototype.addConstituent = function(ric) {
+	if(!(this._rowId && this._subId && this._isChain)) { // Chain must be alive (has not been disposed). Chain must be subscribed as chain
+		return null;
+	}
+
+	if(!this._children) {
+		this._children = [];
+	}
+
+	let rowOptions = {
+		"asConstituent": true,
+		"ric": ric,
+		"parent": this
+	};
+
+	// Get child static values stored in this row
+	if(this._staticValues) {
+		let children = this._staticValues[RowDefinition._childDataField];
+		if(children) {
+			let childValues = children[ric];
+			if(childValues) {
+				rowOptions["values"] = childValues;
+				children[ric] = null;
+			}
+		}
+	}
+
+	return new RowDefinition(rowOptions); // childDef is added to this._children in the constructor
+};
+
+/** Used to convert autogenerated row to regular real-time row
+* @public
+* @ignore
+* @param {string=} userRowId
+*/
+RowDefinition.prototype.toRealTimeRow = function(userRowId) {
+	if(!this.isConstituent()) {
+		return; // Only a constituent can be converted to a real-time row
+	}
+
+	let subs = this._parent._subs;
+	this._realTime = true;
+	this._autoGenerated = false;
+	this._parent = null;
+	this._depthLevel = 0;
+
+	if(userRowId) {
+		this._rowId = userRowId;
+		this._userId = true;
+	}
+
+	this.subscribeForUpdates(subs); // Static data remains intact
+};
+
+/** @public
+*/
+RowDefinition.prototype.unlinkChain = function() {
+	if(!this._isChain) {
+		return;
+	}
+
+	this.unsubscribeForUpdates(true); // Static data remains intact
+
+	let view = this._view;
+	if(view) {
+		let rid = this.getRowId();
+		let segment = view.getSegment(rid);
+		if(segment) {
+			segment.setClassification(null);
+		}
+		view.setSegmentSeparator(rid, false);
+	}
+
+	this._isChain = false;
+	this._chainRic = "";
+	this._userInput = this._ric;
+	this._children = null;
+
+	this.subscribeForUpdates();
+};
+
+/** @public
+* @return {boolean} Returns true if there is a change in view
+*/
+RowDefinition.prototype.collapseChain = function() {
+	if(this._isChain && this._view) {
+		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) {
+		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.isChainExpanded()) {
+		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) {
+		let chdr = this._children;
+		let len = chdr.length;
+		for(let i = 0; i < len; ++i) {
+			let 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() {
+	let 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 {number}
+*/
+RowDefinition.prototype.countChildInView = function() {
+	if(this._children) {
+		let viewCount = 0;
+		let childCount = this._children.length;
+		for(let i = 0; i < childCount; ++i) {
+			if(this._children[i]._view) {
+				++viewCount;
+			}
+		}
+		return viewCount;
+	}
+	return 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
+		let 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
+* @ignore
+* @return {Object}
+*/
+RowDefinition.prototype.getUserModel = function() {
+	return this._userModel;
+};
+
+/** @public
+* @param {Object} obj
+*/
+RowDefinition.prototype.setRowInfo = function(obj) {
+	this._info = obj;
+};
+/** @public
+* @return {Object}
+*/
+RowDefinition.prototype.getRowInfo = function() {
+	return this._info;
+};
+
+/** 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 transforming row options into standard format
+* @public
+* @ignore
+* @function
+* @param {RowDefinition~Options} rowOptions
+* @return {RowDefinition~Options}
+*/
+RowDefinition.extractRowOptions = function(rowOptions) {
+	let ric = rowOptions["ric"];
+	let permId = rowOptions["permId"];
+	let chainRic = rowOptions["chainRic"];
+	let collapsed = rowOptions["collapsed"];
+	let asSegment = rowOptions["asSegment"];
+	let asChain = rowOptions["asChain"];
+	if(asChain == null && chainRic){
+		asChain = true;
+	}
+	let expanded = null;
+	if(ric && ric.indexOf("0#") >= 0){
+		if(asChain == null){
+			asChain = true;
+		}
+		expanded = true;
+	} else if(asChain) {
+		expanded = false;
+	} else if(asSegment) {
+		expanded = true;
+	}
+
+	let extractedOptions = {};
+	if(collapsed == null) {
+		extractedOptions["collapsed"] = !expanded;
+	} else {
+		extractedOptions["collapsed"] = collapsed;
+	}
+	extractedOptions["ric"] = ric;
+	extractedOptions["permId"] = permId || "";
+	extractedOptions["chainRic"] = chainRic;
+	extractedOptions["asChain"] = asChain;
+	return extractedOptions;
+};
+/** For mapping row Id by Array.map()
+* @public
+* @function
+* @param {RowDefinition} rowDef
+*/
+RowDefinition.dispose = function(rowDef) {
+	rowDef.dispose();
+};
+
+export {RowDefinition, ROW_DEF, ROW_TYPES};
+export default RowDefinition;