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

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

@@ -0,0 +1,713 @@
+import Ext from "../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../../../tr-grid-util/es6/EventDispatcher.js";
+import { Segment, UNCATEGORY } from "./Segment.js";
+
+/** @constructor
+* @extends {EventDispatcher}
+*/
+let SegmentCollection = function() {
+	this._onSubSegmentAdded = this._onSubSegmentAdded.bind(this);
+	this._onSubSegmentRemoved = this._onSubSegmentRemoved.bind(this);
+
+	this._segments = {};
+	this._insertionList = [];
+	this._removalList = [];
+
+	this._shared = {
+		segments: this._segments,
+		childToSegment: {}, // child Id to segment Id
+		dirtyCollapsingState: false,
+		defaultCollapsing: false
+	};
+};
+Ext.inherits(SegmentCollection, EventDispatcher);
+
+
+/** @type {!Object.<string, Segment>}
+* @private
+*/
+SegmentCollection.prototype._segments; // Contains both segment and their sub segments
+/** @type {number}
+* @private
+*/
+SegmentCollection.prototype._segmentCount = 0;
+/** @type {Object}
+* @private
+*/
+SegmentCollection.prototype._collapsedRids = null;
+/** @type {!Object}
+* @private
+*/
+SegmentCollection.prototype._shared;
+/** @type {Array.<Segment>}
+* @private
+*/
+SegmentCollection.prototype._segmentList = null; // Array of main/root segments
+/** @type {Array.<Segment>}
+* @private
+*/
+SegmentCollection.prototype._insertionList = null; // Array of sub segments
+/** @type {Array.<string>}
+* @private
+*/
+SegmentCollection.prototype._removalList = null; // Array of sub segment ids
+/** @type {boolean}
+* @private
+*/
+SegmentCollection.prototype._classification = false;
+/** @type {boolean}
+* @private
+*/
+SegmentCollection.prototype._classifierChanged = false;
+/** @type {Object.<string, number>}
+* @private
+*/
+SegmentCollection.prototype._rowOrders = null;
+
+/** @public
+*/
+SegmentCollection.prototype.dispose = function() {
+	this.removeAllSegments();
+	this.removeAllEventListeners();
+	this._collapsedRids = null;
+	this._segmentList = this._rowOrders = this._insertionList = this._removalList = null;
+};
+/** @public
+* @param {string} rid
+* @param {Array.<string>=} childRids Children of the newly added segment. This is a shorthand to addSegmentChildren method
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.addSegment = function(rid, childRids) {
+	if(rid && !this._segments[rid]) {
+		let segment = this._segments[rid] = new Segment(rid, this._shared);
+		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
+		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
+		++this._segmentCount;
+		this.invalidateSegmentOrder(); // order could be changed
+
+		if(childRids && childRids.length) {
+			segment.addChildren(childRids);
+		}
+		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) {
+	let rowIds = Array.isArray(rids) ? rids : [rids];
+	let rowCount = rowIds.length;
+	let dirty = 0;
+	for(let 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._shared.childToSegment[rid] || "";
+};
+/** @public
+* @param {string} rid
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeSegment = function(rid) {
+	let segment = this._segments[rid];
+	if(!segment) {
+		return false;
+	}
+
+	if(this._segmentCount <= 1) {
+		return this.removeAllSegments();
+	}
+	let subSegment = segment.isSubSegment();
+	if(subSegment) {
+		this._removalList.push(segment.getId());
+	}
+	let subSegIds = segment.getSubSegmentIds();
+	if(subSegIds) {
+		let len = subSegIds.length;
+		for(let i = 0; i < len; ++i) {
+			let subSegId = subSegIds[i];
+			if(this._segments[subSegId]) {
+				this._removalList.push(subSegId);
+				delete this._segments[subSegId]; // Slow
+				--this._segmentCount;
+			}
+		}
+	}
+	if(!subSegment) {
+		let parentSeg = segment.getParent();
+		if(parentSeg) { // Move existing children to its parent
+			parentSeg.addChildren(segment.getChildIds()); // WARNING: passing private member
+		}
+	}
+	segment.removeAllChildren(); // This is important for updating childToSegment
+	segment.dispose();
+
+	delete this._segments[rid]; // Slow
+	--this._segmentCount;
+	this.invalidateSegmentOrder();
+	return true;
+};
+/** @public
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeAllSegments = function() {
+	if(this._segmentCount) {
+		for(let key in this._segments) {
+			this._segments[key].dispose();
+		}
+		this._segments = {};
+		this._segmentCount = 0;
+		this._segmentList = this._rowOrders = null;
+		this._shared.segments = this._segments;
+		this._shared.childToSegment = {};
+
+		this._classification = this._classifierChanged = false;
+		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
+* @param {string} rid
+* @return {Segment}
+*/
+SegmentCollection.prototype.getSegmentParent = function(rid) {
+	let parentRowId = this.getParentRowId(rid);
+	if(parentRowId) {
+		return this.getSegment(parentRowId);
+	}
+	return 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 {!Function} comparer
+* @return {!Array.<Segment>}
+*/
+SegmentCollection.prototype.sortSegments = function(comparer) {
+	let rootSegments = [];
+	let segmentSeparators = this._segments;
+	for(let rid in segmentSeparators) {
+		let segment = segmentSeparators[rid];
+		segment.sortSegments(comparer);
+		if(segment.isRootSegment()) {
+			rootSegments.push(segment);
+		}
+	}
+	rootSegments.sort(comparer);
+	this.invalidateSegmentOrder();
+	return rootSegments;
+};
+
+
+/** @public
+* @param {Array.<string>} segmentIds
+* @param {boolean=} bool
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.collapseSegments = function(segmentIds, bool) {
+	let dirty = 0;
+	if(this._segmentCount) {
+		let len = segmentIds.length;
+		for (let i = 0; i < len; i++) {
+			let segment = this._segments[segmentIds[i]];
+			if(segment) {
+				dirty |= segment.collapse(bool);
+			}
+		}
+	}
+	return dirty ? true : false;
+};
+
+/** @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) {
+	let segment = this._segments[segmentId];
+	if(segment) {
+		return segment.collapse(bool);
+	}
+	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) {
+		let segmentSeparators = this._segments;
+		let dirty = 0;
+		for(let rid in segmentSeparators) {
+			dirty |= segmentSeparators[rid].expand();
+		}
+		if(dirty) {
+			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) {
+	let segment = this._segments[segmentId];
+	if(segment) {
+		return segment.isCollapsed();
+	}
+	return false;
+};
+/** @public
+* @return {Object}
+*/
+SegmentCollection.prototype.getCollapsedRows = function() {
+	if(this._shared.dirtyCollapsingState) {
+		this._shared.dirtyCollapsingState = false;
+		let collapsedRids = null;
+		let count = 0;
+		if(this._segmentCount) {
+			let segmentSeparators = this._segments;
+			collapsedRids = {};
+			for(let rid in segmentSeparators) {
+				let segment = segmentSeparators[rid];
+				if(segment.isRootSegment()) {
+					if(segment.getCollapsingStates(collapsedRids)) {
+						++count;
+					}
+				}
+			}
+		}
+		this._collapsedRids = count ? collapsedRids : null;
+	}
+	return this._collapsedRids;
+};
+
+/** Invalidate segment order cache
+* @public
+* @returns {boolean} Returns true if there is any change
+*/
+SegmentCollection.prototype.invalidateSegmentOrder = function() {
+	if(this._segmentList) {
+		this._segmentList = this._rowOrders = null;
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @param {string} rid
+* @param {string=} dataId Row id for retrieving data
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.addSegmentChild = function(segmentId, rid, dataId) {
+	let segment = this._segments[segmentId];
+	if(segment && !segment.isSubSegment()) {
+		// If a segment becomes a child of other segment, then the segment order needs to be recalculated
+		this.invalidateSegmentOrder();
+		return segment.addChild(rid, dataId);
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId
+* @param {Array.<string>} rids
+* @param {Array.<string>=} dataIds Row ids for retrieving data
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
+	let segment = this._segments[segmentId];
+	if(segment && !segment.isSubSegment()) {
+		// If a segment becomes a child of other segment, then the segment order needs to be recalculated
+		this.invalidateSegmentOrder();
+		return segment.addChildren(rids, dataIds);
+	}
+	return false;
+};
+/** This only works for immediate children of the specified segment
+* @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) {
+	let 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) {
+	let segment = this._segments[segmentId];
+	if(segment) {
+		this.invalidateSegmentOrder();
+		return segment.removeChild(rid);
+	}
+	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) {
+	let segment = this._segments[segmentId];
+	if(segment) {
+		this.invalidateSegmentOrder();
+		return segment.removeChildren(rids);
+	}
+	return false;
+};
+/** @public
+* @return {boolean} Returns true if there is any change. Otherwise, returns false
+*/
+SegmentCollection.prototype.removeAllSegmentChildren = function() {
+	this._shared.childToSegment = {};
+	let segmentSeparators = this._segments;
+	let dirty = false;
+	for(let rid in segmentSeparators) {
+		let segment = segmentSeparators[rid];
+		if(segment.removeAllChildren()) {
+			dirty = true;
+		}
+	}
+
+	if(dirty) {
+		this.invalidateSegmentOrder();
+		this.classify(null);
+	}
+
+	return dirty;
+};
+
+/** @public
+* @param {string} segmentId
+* @param {Array.<string>} rids
+*/
+SegmentCollection.prototype.fillSegment = function(segmentId, rids) {
+	let rowCount = Array.isArray(rids) ? rids.length : 0;
+	if(!rowCount) {
+		return;
+	}
+	let segmentSeparators = this._segments;
+	let curSegment = segmentSeparators[segmentId];
+	if(curSegment && !curSegment.isSubSegment()) {
+		let segmentAt = rids.indexOf(segmentId);
+		if(segmentAt >= 0) {
+			curSegment.removeAllChildren();
+			for(let r = segmentAt + 1; r < rowCount; ++r) {
+				let rid = rids[r];
+				let segmentSeparator = segmentSeparators[rid];
+				if(segmentSeparator) {
+					break;
+				}
+				curSegment.addChild(rid);
+			}
+			this.invalidateSegmentOrder();
+		}
+	}
+};
+/** @public
+* @param {Array.<string>} rids
+* @return {boolean} Return true if the fill segments have changed, otherwise return false
+*/
+SegmentCollection.prototype.fillSegments = function(rids) {
+	this._shared.childToSegment = {};
+
+	let rowCount = Array.isArray(rids) ? rids.length : 0;
+	let segmentSeparators = this._segments;
+	let curSegment = null;
+	let change = false;
+	for(let r = 0; r < rowCount; ++r) {
+		let rid = rids[r];
+		let segmentSeparator = segmentSeparators[rid];
+		if(segmentSeparator && !segmentSeparator.isSubSegment()) {
+			curSegment = segmentSeparator;
+			curSegment.removeAllChildren();
+		} else if(curSegment && !curSegment.isSubSegment()) {
+			curSegment.addChild(rid);
+			change = true;
+		}
+	}
+	if(change) {
+		this.invalidateSegmentOrder();
+	}
+	return change;
+};
+
+/** The number represent maximum nested segments that can be created in a single segment
+* @private
+* @type {number}
+* @constant
+*/
+const SEGMENT_STEP = 10000;
+
+/** @public
+* @param {Array.<string>} rids
+* @param {boolean=} useCache=false If this is true, skip the calculation when there is already a cache for segment order
+*/
+SegmentCollection.prototype.calcSegmentOrder = function(rids, useCache) {
+	let segmentList = this._segmentList;
+	if(segmentList) {
+		if(useCache) {
+			return; // Use previous cache for segment order
+		}
+		segmentList.length = 0;
+	} else {
+		segmentList = this._segmentList = [];
+	}
+
+	this._rowOrders = {};
+	let rowOrders = this._rowOrders;
+	let segmentSeparators = this._segments;
+	let childToSegmentId = this._shared.childToSegment;
+	let prevSeg = UNCATEGORY;
+	let ridCount = rids ? rids.length : 0;
+	let order = 0;
+	for(let i = 0; i < ridCount; ++i) {
+		let rid = rids[i];
+		if(!childToSegmentId[rid]) {
+			let segment = segmentSeparators[rid];
+			let segmentId = (segment) ? segment.getId() : UNCATEGORY;
+			if(prevSeg !== segmentId) {
+				++order; // WARNING: Segments and sub segments start with 1
+				prevSeg = segmentId;
+			}
+
+			let rootOrder = order * SEGMENT_STEP;
+			rowOrders[rid] = rootOrder;
+			if(segment) {
+				this._segmentList.push(segment);
+				segment.setOrder(rootOrder);
+				segment.updateTreeStructure(0, rootOrder, rowOrders);
+			}
+		}
+	}
+};
+/** @public
+* @param {!Array.<string>} rids Array of row ids
+* @param {boolean=} partial Indicating that the given ids are not the whole list
+* @return {Array.<number>} Returns Array of segment values, if there are at least one segment, otherwise returns null
+*/
+SegmentCollection.prototype.getSegmentValues = function(rids, partial) {
+	let rowCount = rids ? rids.length : 0;
+	if(!rowCount) {
+		return null;
+	}
+	let rowOrders = this._rowOrders;
+	if(!rowOrders) { // calcSegmentOrder has not been called (no cache detected)
+		return null;
+	}
+
+	let segmentValues = new Array(rowCount);
+	let highestVal = 0;
+	for(let r = 0; r < rowCount; ++r) {
+		let rid = rids[r];
+		let segmentVal = rowOrders[rid];
+		if(segmentVal != null) {
+			if(highestVal < segmentVal) {
+				highestVal = segmentVal;
+			}
+		} else {
+			segmentVal = highestVal ? highestVal + SEGMENT_STEP : 0;
+		}
+		segmentValues[r] = segmentVal;
+	}
+
+	return highestVal ? segmentValues : null;
+};
+/** @public
+* @return {string}
+*/
+SegmentCollection.prototype.logStructure = function() {
+	let segmentList = this._segmentList;
+	if(!segmentList) {
+		return "";
+	}
+	let segmentCount = segmentList.length;
+	let lines = [];
+	for(let i = 0; i < segmentCount; ++i) {
+		let segment = segmentList[i];
+		if(segment.isRootSegment()) {
+			segment.log(lines);
+		}
+	}
+
+	return lines.join("\n");
+};
+/** @public
+* @return {string}
+*/
+SegmentCollection.prototype.logRowIdMap = function() {
+	let lines = [];
+	let segmentSeparators = this._segments;
+	let childToSegmentId = this._shared.childToSegment;
+	for(let rid in childToSegmentId) {
+		let segmentId = childToSegmentId[rid];
+		let segment = segmentSeparators[segmentId];
+		if(!segment || !segment.isSubSegment()) {
+			lines.push(rid + " > " + segmentId);
+		}
+	}
+
+	return lines.join("\n");
+};
+
+/** @public
+* @param {string} segmentId
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+SegmentCollection.prototype.setSegmentClassification = function(segmentId, fields) {
+	let segment = this._segments[segmentId];
+	if(segment) {
+		if(segment.setClassification(fields)) {
+			if(segment.getClassification()) {
+				this._classification = true;
+			}
+			this._classifierChanged = true;
+
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+SegmentCollection.prototype.hasClassification = function() {
+	// WARNING: This include the time when classification is removed
+	return this._classification || this._classifierChanged;
+};
+/** @public
+* @param {Object.<string, Object>} rows Object maps between row id and its record
+* @return {boolean}
+*/
+SegmentCollection.prototype.classify = function(rows) {
+	if(!this._segmentCount) {
+		return false;
+	}
+	if(!this.hasClassification()) {
+		return false;
+	}
+	this._classification = this._classifierChanged = false;
+
+	let segmentSeparators = this._segments;
+	for(let rid in segmentSeparators) {
+		let segment = this._segments[rid];
+		if(!segment.isSubSegment()) {
+			if(segment.getClassification()) {
+				this._classification = true;
+			}
+			segment.classify(rows);
+		}
+	}
+	if(this._insertionList.length || this._removalList.length) {
+		this.invalidateSegmentOrder();
+		this._dispatch("subSegmentChanged", {
+			"insertionList": this._insertionList,
+			"removalList": this._removalList
+		});
+		this._insertionList.length = 0;
+		this._removalList.length = 0;
+
+		this._dispatch("classified", {});
+		return true;
+	}
+
+	this._dispatch("classified", {});
+	return false;
+};
+
+/** @private
+* @param {!Object} e
+*/
+SegmentCollection.prototype._onSubSegmentAdded = function(e) {
+	let rid = e["rid"];
+	if(!this._segments[rid]) {
+		let segment = /** @type{Segment} */(e["segment"]);
+		this._insertionList.push(segment);
+		this._segments[rid] = segment;
+		this._segmentCount++;
+
+		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
+		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
+	} else {
+		console.log("Incorrect logic detected.");
+	}
+};
+/** @private
+* @param {!Object} e
+*/
+SegmentCollection.prototype._onSubSegmentRemoved = function(e) {
+	let rid = e["rid"];
+	this.removeSegment(rid);
+};
+
+/** @public
+* @param {boolean} bool
+* @return {boolean}
+*/
+SegmentCollection.prototype.setDefaultCollapsing = function(bool) {
+	let newVal = bool ? true : false;
+	if(this._shared.defaultCollapsing !== newVal) {
+		this._shared.defaultCollapsing = newVal;
+		return true;
+	}
+	return false;
+};
+
+
+export default SegmentCollection;
+export { SegmentCollection };