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

package/lib/core/es6/data/Segment.d.ts

@@ -0,0 +1,38 @@
+
+
+declare class Segment {
+
+    constructor(rid: string);
+
+    public getId(): string;
+
+    public addChild(rid: string, objMap?: any): boolean;
+
+    public addChildren(rids: (string)[], objMap?: any): boolean;
+
+    public containsChild(rid: string): boolean;
+
+    public removeChild(rid: string, objMap?: any): boolean;
+
+    public removeChildren(rids: (string)[], objMap?: any): boolean;
+
+    public removeAllChildren(objMap?: any): boolean;
+
+    public getChildIds(): (string)[];
+
+    public collapse(bool?: boolean): boolean;
+
+    public expand(bool?: boolean): boolean;
+
+    public isCollapsed(): boolean;
+
+    public getCollapsingStates(objMap?: any): any;
+
+    public getValue(): number;
+
+    public setValue(val: number): void;
+
+}
+
+export default Segment;
+export { Segment };

package/lib/core/es6/data/Segment.js

@@ -0,0 +1,193 @@
+/** @constructor
+* @param {string} rid
+*/
+var Segment = function(rid) {
+	this._rid = rid;
+	this._children = {};
+};
+
+
+/** @type {string}
+* @private
+*/
+Segment.prototype._rid;
+/** @type {!Object}
+* @private
+*/
+Segment.prototype._children;
+/** @type {number}
+* @private
+*/
+Segment.prototype._childCount = 0;
+/** @type {boolean}
+* @private
+*/
+Segment.prototype._collapsed = false;
+/** @type {number}
+* @private
+*/
+Segment.prototype._value = 0;
+
+
+/** @public
+* @return {string}
+*/
+Segment.prototype.getId = function() {
+	return this._rid;
+};
+/** @public
+* @param {string} rid
+* @param {Object=} objMap
+* @return {boolean}
+*/
+Segment.prototype.addChild = function(rid, objMap) {
+	if(rid && !this._children[rid]) {
+		if(objMap) {
+			objMap[rid] = this._rid;
+		}
+		this._children[rid] = 1;
+		++this._childCount;
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {Array.<string>} rids
+* @param {Object=} objMap
+* @return {boolean}
+*/
+Segment.prototype.addChildren = function(rids, objMap) {
+	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], objMap);
+	}
+	return dirty ? true : false;
+};
+/** @public
+* @param {string} rid
+* @return {boolean}
+*/
+Segment.prototype.containsChild = function(rid) {
+	return this._children[rid] ? true : false;
+};
+/** @public
+* @param {string} rid
+* @param {Object=} objMap
+* @return {boolean}
+*/
+Segment.prototype.removeChild = function(rid, objMap) {
+	if(this._childCount && this._children[rid]) {
+		if(objMap) {
+			delete objMap[rid];
+		}
+		delete this._children[rid]; // Slow
+		--this._childCount;
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {Array.<string>} rids
+* @param {Object=} objMap
+* @return {boolean}
+*/
+Segment.prototype.removeChildren = function(rids, objMap) {
+	if(!this._childCount) {
+		return false;
+	}
+	var rowIds = Array.isArray(rids) ? rids : [rids];
+	var rowCount = rowIds.length;
+	var dirty = 0;
+	for(var i = 0; i < rowCount; ++i) {
+		dirty |= this.removeChild(rowIds[i], objMap);
+	}
+	return dirty ? true : false;
+};
+/** @public
+* @param {Object=} objMap
+* @return {boolean}
+*/
+Segment.prototype.removeAllChildren = function(objMap) {
+	if(this._childCount) {
+		if(objMap) {
+			var chdr = this._children;
+			for(var rid in chdr) {
+				if(objMap[rid]) {
+					delete objMap[rid];
+				}
+			}
+		}
+		this._children = {};
+		this._childCount = 0;
+		return true;
+	}
+	return false;
+};
+/** @public
+* @return {!Array.<string>}
+*/
+Segment.prototype.getChildIds = function() {
+	return this._childCount ? Object.keys(this._children) : [];
+};
+
+
+/** @public
+* @param {boolean=} bool
+* @return {boolean}
+*/
+Segment.prototype.collapse = function(bool) {
+	bool = (bool !== false);
+	if(this._collapsed !== bool) {
+		this._collapsed = bool;
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {boolean=} bool
+* @return {boolean}
+*/
+Segment.prototype.expand = function(bool) {
+	return this.collapse(bool === false);
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.isCollapsed = function() {
+	return this._collapsed;
+};
+/** @public
+* @param {Object=} objMap
+* @return {!Object}
+*/
+Segment.prototype.getCollapsingStates = function(objMap) {
+	if(!objMap) {
+		objMap = {};
+	}
+	if(this._childCount) {
+		var chdr = this._children;
+		var collapsed = this._collapsed;
+		for(var rid in chdr) {
+			objMap[rid] = collapsed;
+		}
+	}
+	return objMap;
+};
+/** @public
+* @return {number}
+*/
+Segment.prototype.getValue = function() {
+	return this._value;
+};
+/** @public
+* @param {number} val
+*/
+Segment.prototype.setValue = function(val) {
+	this._value = val;
+};
+
+
+export default Segment;
+export { Segment };

package/lib/core/es6/data/SegmentCollection.d.ts

@@ -0,0 +1,58 @@
+import Segment from "./Segment.js";
+
+declare class SegmentCollection {
+
+    constructor();
+
+    public addSegment(rid: string): boolean;
+
+    public addSegments(rids: (string)[]): boolean;
+
+    public containsSegment(rid: string): boolean;
+
+    public getParentRowId(rid: string): string;
+
+    public removeSegment(rid: string): boolean;
+
+    public removeAllSegments(): boolean;
+
+    public getSegmentCount(): number;
+
+    public getSegment(rid: string): Segment;
+
+    public getSegments(): { [key: string]:  Segment };
+
+    public getSegmentIds(): (string)[];
+
+    public collapseSegment(segmentId: string, bool?: boolean): boolean;
+
+    public expandSegment(segmentId: string, bool?: boolean): boolean;
+
+    public expandAllSegments(): boolean;
+
+    public isCollapsedSegment(segmentId: string): boolean;
+
+    public getCollapsedRows(): any;
+
+    public addSegmentChild(segmentId: string, rid: string): boolean;
+
+    public addSegmentChildren(segmentId: string, rids: (string)[]): boolean;
+
+    public containsSegmentChild(segmentId: string, rid: string): boolean;
+
+    public removeSegmentChild(segmentId: string, rid: string): boolean;
+
+    public removeSegmentChildren(segmentId: string, rids: (string)[]): boolean;
+
+    public removeAllSegmentChildren(): boolean;
+
+    public fillSegment(segmentId: string, rids: (string)[]): void;
+
+    public fillSegments(rids: (string)[]): boolean;
+
+    public getSegmentValues(rids: (string)[]): (number)[];
+
+}
+
+export default SegmentCollection;
+export { SegmentCollection };

package/lib/core/es6/data/SegmentCollection.js

@@ -0,0 +1,431 @@
+import Segment from "./Segment.js";
+
+/** @constructor
+*/
+var SegmentCollection = function() {
+	this._segments = {};
+	this._childToSegmentId = {};
+};
+
+
+/** @type {!Object.<string, Segment>}
+* @private
+*/
+SegmentCollection.prototype._segments;
+/** @type {number}
+* @private
+*/
+SegmentCollection.prototype._segmentCount = 0;
+/** @type {Object}
+* @private
+*/
+SegmentCollection.prototype._collapsedRids = null;
+/** @type {boolean}
+* @private
+*/
+SegmentCollection.prototype._dirtyCollapsingState = false;
+/** @type {!Object.<string, string>}
+* @private
+*/
+SegmentCollection.prototype._childToSegmentId;
+
+
+/** @public
+* @param {string} rid
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.addSegment = function(rid) {
+	if(rid && !this._segments[rid]) {
+		if(this._childToSegmentId[rid]) {
+			console.log("child of a segment cannot be set as a segment separator");
+		}
+		this._segments[rid] = new Segment(rid);
+		++this._segmentCount;
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {Array.<string>} rids
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.addSegments = function(rids) {
+	var rowIds = Array.isArray(rids) ? rids : [rids];
+	var rowCount = rowIds.length;
+	var dirty = 0;
+	for(var i = 0; i < rowCount; ++i) {
+		dirty |= this.addSegment(rowIds[i]);
+	}
+	return dirty ? true : false;
+};
+/** @public
+* @param {string} rid
+* @return {boolean}
+*/
+SegmentCollection.prototype.containsSegment = function(rid) {
+	return this._segments[rid] ? true : false;
+};
+/** @public
+* @param {string} rid
+* @return {string} parent row id of this segmentation. If the parent row id for this segmentation cannot be found, return ""
+*/
+SegmentCollection.prototype.getParentRowId = function(rid) {
+	return this._childToSegmentId[rid] || "";
+};
+/** @public
+* @param {string} rid
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeSegment = function(rid) {
+	var segment = this._segments[rid];
+	if(segment) {
+		if(segment.isCollapsed()) {
+			this._dirtyCollapsingState = true;
+		}
+		segment.removeAllChildren(this._childToSegmentId);
+		delete this._segments[rid]; // Slow
+		--this._segmentCount;
+		return true;
+	}
+	return false;
+};
+/** @public
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeAllSegments = function() {
+	if(this._segmentCount) {
+		this._segments = {};
+		this._childToSegmentId = {};
+		this._segmentCount = 0;
+		this._dirtyCollapsingState = true;
+		return true;
+	}
+	return false;
+};
+
+/** @public
+* @return {number}
+*/
+SegmentCollection.prototype.getSegmentCount = function() {
+	return this._segmentCount;
+};
+/** @public
+* @param {string} rid
+* @return {Segment}
+*/
+SegmentCollection.prototype.getSegment = function(rid) {
+	return this._segments[rid] || null;
+};
+/** @public
+* @return {Object.<string, Segment>}
+*/
+SegmentCollection.prototype.getSegments = function() {
+	return this._segmentCount ? this._segments : null; // WARNING: Return private member
+};
+/** @public
+* @return {!Array.<string>}
+*/
+SegmentCollection.prototype.getSegmentIds = function() {
+	return Object.keys(this._segments);
+};
+
+
+/** @public
+* @param {string} segmentId
+* @param {boolean=} bool
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.collapseSegment = function(segmentId, bool) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		var dirty = segment.collapse(bool);
+		if(dirty) {
+			this._dirtyCollapsingState = true;
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @param {boolean=} bool
+* @return {boolean}
+*/
+SegmentCollection.prototype.expandSegment = function(segmentId, bool) {
+	return this.collapseSegment(segmentId, bool === false);
+};
+/** @public
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.expandAllSegments = function() {
+	if(this._segmentCount) {
+		var segmentSeparators = this._segments;
+		var dirty = 0;
+		for(var rid in segmentSeparators) {
+			dirty |= segmentSeparators[rid].expand();
+		}
+		if(dirty) {
+			this._dirtyCollapsingState = true;
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.isCollapsedSegment = function(segmentId) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		return segment.isCollapsed();
+	}
+	return false;
+};
+/** @public
+* @return {Object}
+*/
+SegmentCollection.prototype.getCollapsedRows = function() {
+	if(this._dirtyCollapsingState) {
+		this._dirtyCollapsingState = false;
+		var collapsedRids = null;
+		var count = 0;
+		if(this._segmentCount) {
+			var segmentSeparators = this._segments;
+			collapsedRids = {};
+			for(var rid in segmentSeparators) {
+				if(segmentSeparators[rid].isCollapsed()) {
+					segmentSeparators[rid].getCollapsingStates(collapsedRids);
+					++count;
+				}
+			}
+		}
+		this._collapsedRids = count ? collapsedRids : null;
+	}
+	return this._collapsedRids;
+};
+
+/** @public
+* @param {string} segmentId
+* @param {string} rid
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.addSegmentChild = function(segmentId, rid) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		var dirty = segment.addChild(rid, this._childToSegmentId);
+		if(dirty) {
+			if(segment.isCollapsed()) {
+				this._dirtyCollapsingState = true;
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @param {Array.<string>} rids
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		var dirty = segment.addChildren(rids, this._childToSegmentId);
+		if(dirty) {
+			if(segment.isCollapsed()) {
+				this._dirtyCollapsingState = true;
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @param {string} rid
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.containsSegmentChild = function(segmentId, rid) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		return segment.containsChild(rid);
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @param {string} rid
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		var dirty = segment.removeChild(rid, this._childToSegmentId);
+		if(dirty) {
+			if(segment.isCollapsed()) {
+				this._dirtyCollapsingState = true;
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @param {Array.<string>} rids
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeSegmentChildren = function(segmentId, rids) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		var dirty = segment.removeChildren(rids, this._childToSegmentId);
+		if(dirty) {
+			if(segment.isCollapsed()) {
+				this._dirtyCollapsingState = true;
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeAllSegmentChildren = function() {
+	this._childToSegmentId = {};
+	var segmentSeparators = this._segments;
+	var dirtyCollapsingState = this._dirtyCollapsingState;
+	var dirty = false;
+	for(var rid in segmentSeparators) {
+		var segment = this._segments[rid];
+		if(segment.removeAllChildren()) {
+			dirty = true;
+			if(!dirtyCollapsingState && segment.isCollapsed()) {
+				dirtyCollapsingState = this._dirtyCollapsingState = true;
+			}
+		}
+	}
+
+	return dirty;
+};
+
+/** @public
+* @param {string} segmentId
+* @param {Array.<string>} rids
+*/
+SegmentCollection.prototype.fillSegment = function(segmentId, rids) {
+	var rowCount = Array.isArray(rids) ? rids.length : 0;
+	if(!rowCount) {
+		return;
+	}
+	var segmentSeparators = this._segments;
+	var childToSegmentId = this._childToSegmentId;
+	var curSegment = segmentSeparators[segmentId];
+	if(curSegment) {
+		var segmentAt = rids.indexOf(segmentId);
+		if(segmentAt >= 0) {
+			if(curSegment.isCollapsed()) {
+				this._dirtyCollapsingState = true;
+			}
+			curSegment.removeAllChildren(childToSegmentId);
+			for(var r = segmentAt + 1; r < rowCount; ++r) {
+				var rid = rids[r];
+				var segmentSeparator = segmentSeparators[rid];
+				if(segmentSeparator) {
+					break;
+				}
+				curSegment.addChild(rid, childToSegmentId);
+			}
+		}
+	}
+};
+/** @public
+* @param {Array.<string>} rids
+* @return {boolean} Return true if the fill segments have changed, otherwise return false
+*/
+SegmentCollection.prototype.fillSegments = function(rids) {
+	var rowCount = Array.isArray(rids) ? rids.length : 0;
+	this._childToSegmentId = {};
+	var segmentSeparators = this._segments;
+	var childToSegmentId = this._childToSegmentId;
+	var curSegment = null;
+	var change = false;
+	for(var r = 0; r < rowCount; ++r) {
+		var rid = rids[r];
+		var segmentSeparator = segmentSeparators[rid];
+		if(segmentSeparator) {
+			curSegment = segmentSeparator;
+			if(curSegment.isCollapsed()) {
+				this._dirtyCollapsingState = true;
+			}
+			curSegment.removeAllChildren();
+		} else if(curSegment) {
+			curSegment.addChild(rid, childToSegmentId);
+			change = true;
+		}
+	}
+	return change;
+};
+/** @public
+* @param {!Array.<string>} rids Array of row ids
+* @return {Array.<number>} Returns Array of segment values, if there are at least two segments, otherwise returns null
+*/
+SegmentCollection.prototype.getSegmentValues = function(rids) {
+	var rowCount = rids ? rids.length : 0;
+	if(!rowCount) {
+		return null;
+	}
+	var segmentSeparators = this._segments;
+	var childToSegmentId = this._childToSegmentId;
+	var curSegment = null;
+	var segmentValues = new Array(rowCount);
+	var curSegmentCount = 0;
+	var segmentVal = 0;
+	var r = 0;
+	var childToIndex = {};
+	while(r < rowCount) {
+		var rid = rids[r];
+		if(segmentSeparators[rid]) {
+			++curSegmentCount;
+			curSegment = segmentSeparators[rid];
+			segmentVal += 100;
+			segmentValues[r] = segmentVal;
+			curSegment.setValue(segmentVal);
+			if(curSegmentCount >= this._segmentCount) {
+				++r;
+				break;
+			}
+		} else {
+			if(curSegmentCount) {
+				segmentValues[r] = segmentVal + 10;
+			} else {
+				segmentValues[r] = 0;
+			}
+			if(childToSegmentId[rid]) {
+				childToIndex[rid] = r;
+			}
+		}
+		++r;
+	}
+	if(curSegmentCount) {
+		while(r < rowCount) {
+			rid = rids[r];
+			segmentValues[r] = segmentVal + 10;
+			if(childToSegmentId[rid]) {
+				childToIndex[rid] = r;
+			}
+			++r;
+		}
+		for(var childId in childToIndex) {
+			curSegment = segmentSeparators[childToSegmentId[childId]];
+			segmentValues[childToIndex[childId]] = curSegment.getValue() + 1;
+		}
+	}
+
+	return curSegmentCount ? segmentValues : null;
+};
+
+
+export default SegmentCollection;
+export { SegmentCollection };