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

package/lib/tr-grid-util/es6/GroupDefinitions.d.ts

@@ -0,0 +1,74 @@
+import { cloneObject } from "./Util.js";
+
+declare class GroupDefinitions {
+
+    constructor();
+
+    public static getGroupId(groupDef: any): string;
+
+    public static calcTreeDepth(groupMap: { [key: string]:  any }|null, groupDef: any): number;
+
+    public static getLeafDescendants(groupMap: { [key: string]:  any }|null, groupId: string): (string)[]|null;
+
+    public toString(): string;
+
+    public getGroup(groupId: string): any;
+
+    public getDefinition(groupId: string): any;
+
+    public getGroups(): (any)[];
+
+    public getGroupIds(): (string)[];
+
+    public getGroupMap(): { [key: string]:  any };
+
+    public cloneGroupMap(): { [key: string]:  any };
+
+    public rebuildMap(): void;
+
+    public getGroupChildren(groupId: string): (string)[]|null;
+
+    public getLeafDescendants(groupId: string): (string)[]|null;
+
+    public getGroupLevel(groupId: string): number;
+
+    public getRootGroup(groupId: string): any;
+
+    public getParentGroup(childId: string): any;
+
+    public getParentIds(childId: string): (string)[]|null;
+
+    public getParentId(childId: string, groupLevel?: number|null): string;
+
+    public removeAllGroups(): boolean;
+
+    public setGroups(groupDefs?: (any)[]|null): void;
+
+    public addGroup(groupDef: any): string;
+
+    public removeGroup(groupId: string): boolean;
+
+    public setGroup(groupId: string, groupDef?: ((string)[]|any)|null): string;
+
+    public hasGroupChild(parentId: string, childId: string): boolean;
+
+    public contains(groupId: string, childId: string): boolean;
+
+    public addGroupChild(parentId: string, childId: string, position?: number|null): boolean;
+
+    public removeGroupChild(parentId: string, childId?: string|null): boolean;
+
+    public unsetParent(childId: string): boolean;
+
+    public removeAllChildren(groupId: string): boolean;
+
+    public setGroupChildren(groupId: string, newChildList: (string)[]|null): boolean;
+
+    public getGroupName(groupId: string): string;
+
+    public setGroupName(groupId: string, groupName: string): boolean;
+
+}
+
+export default GroupDefinitions;
+export { GroupDefinitions };

package/lib/tr-grid-util/es6/GroupDefinitions.js

@@ -0,0 +1,642 @@
+import { cloneObject } from "./Util.js";
+
+/** @constructor
+*/
+let GroupDefinitions = function () {
+	this._groupMap = {};
+	this._childToParent = {};
+};
+
+/** @type {!Object.<string, Object>}
+* @description A map of group id to group defintion
+* @private
+*/
+GroupDefinitions.prototype._groupMap;
+/** @type {!Object.<string, string>}
+* @description A map of child id to parent id
+* @private
+*/
+GroupDefinitions.prototype._childToParent;
+
+
+/** @public
+* @function
+* @param {Object} groupDef
+* @return {string}
+*/
+GroupDefinitions.getGroupId = function(groupDef) {
+	if(groupDef) {
+		return groupDef.id || "";
+	}
+	return "";
+};
+/** @public
+* @param {Object.<string, Object>} groupMap
+* @param {Object} groupDef
+* @return {number} Return total number of parents. Return 0 if there is no parent.
+*/
+GroupDefinitions.calcTreeDepth = function (groupMap, groupDef) {
+	let curDepth = -1;
+	let curNode = groupDef;
+	while(curNode) { // WARNING: infinite loop could occured, if parentId is cycle back to one of the child group
+		if(++curDepth > 15) {
+			console.log("WARNING: Infinite loop detected during column group creation");
+			break;
+		}
+		let parentId = curNode.parentId;
+		curNode = groupMap[parentId];
+	}
+	return curDepth;
+};
+/** @public
+* @param {Object.<string, Object>} groupMap
+* @param {string} groupId
+* @return {Array.<string>}
+*/
+GroupDefinitions.getLeafDescendants = function (groupMap, groupId) {
+	let groupDef = groupMap[groupId];
+	if(!groupDef) {
+		return null;
+	}
+
+	let leaves = [];
+	let unvisitedGroups = [groupDef];
+	let visitedCount = 0;
+	let visitedMap = {};
+	while(visitedCount < unvisitedGroups.length) {
+		groupDef = unvisitedGroups[visitedCount++];
+		visitedMap[groupDef.id] = true;
+		let chdr = groupDef.children;
+		let len = chdr ? chdr.length : 0;
+		for(let i = 0; i < len; ++i) {
+			let childId = chdr[i];
+			groupDef = groupMap[childId];
+			if(groupDef) {
+				if(!visitedMap[groupDef.id]) { // Prevent infinite loop
+					unvisitedGroups.push(groupDef);
+				}
+			} else {
+				leaves.push(childId);
+			}
+		}
+	}
+	return leaves;
+};
+
+
+/** @private
+* @function
+* @param {Object} obj
+* @return {Object} Return a new object with guaranteed children property
+*/
+GroupDefinitions._cloneObject = function(obj) {
+	let newObj = cloneObject(obj);
+	if(Array.isArray(newObj.children)) { // This is to prevent modification from the outside source
+		newObj.children = newObj.children.slice();
+	} else {
+		newObj.children = [];
+	}
+	return newObj;
+};
+
+/** @private
+* @function
+* @param {Array.<string>|Object} obj
+* @param {string=} groupId
+* @return {Object} Return a new object with guaranteed children property
+*/
+GroupDefinitions._toGroupDefinition = function(obj, groupId) {
+	let groupDef = null;
+	if(obj) {
+		if(Array.isArray(obj)) {
+			groupDef = {
+				children: obj.slice()
+			};
+		} else {
+			groupDef = GroupDefinitions._cloneObject(obj);
+		}
+		if(groupId) {
+			if(!groupDef.name) {
+				groupDef.name = groupId;
+			}
+			groupDef.id = groupId;
+		}
+	}
+	return groupDef;
+};
+
+/** @public
+* @return {string}
+*/
+GroupDefinitions.prototype.toString = function() {
+	let groupMap = this._groupMap;
+	let lines = [];
+	lines.push("=== groupDefs ===");
+	for(let key in groupMap) {
+		let group = groupMap[key];
+		lines.push(key + ": " + JSON.stringify(group, ["id", "parentId", "children"]));
+	}
+
+	lines.push("=== childToParent ===");
+	lines.push(JSON.stringify(this._childToParent, null, 2));
+	lines.push("");
+
+	return lines.join("\n");
+};
+
+/** Get group definition object. This method can be used to check whether the given id is a group id or not (i.e., isGroupId).
+* @public
+* @param {string} groupId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getGroup = function (groupId) {
+	if(groupId) {
+		return this._groupMap[groupId] || null;
+	}
+	return null;
+};
+/** @public
+* @function
+* @param {string} groupId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getDefinition = GroupDefinitions.prototype.getGroup;
+/** Get array of all existing group definitions
+* @public
+* @return {!Array.<Object>}
+*/
+GroupDefinitions.prototype.getGroups = function () {
+	let groupDefs = [];
+	let groupMap = this._groupMap;
+	for(let key in groupMap) {
+		groupDefs.push(groupMap[key]);
+	}
+	return groupDefs;
+};
+/** Get array of all existing group ids
+* @public
+* @return {!Array.<string>}
+*/
+GroupDefinitions.prototype.getGroupIds = function () {
+	return Object.keys(this._groupMap);
+};
+/** @public
+* @return {!Object.<string, Object>}
+*/
+GroupDefinitions.prototype.getGroupMap = function () {
+	return this._groupMap; // WARNING: Allow access to private member
+};
+/** @public
+* @return {!Object.<string, Object>}
+*/
+GroupDefinitions.prototype.cloneGroupMap = function () {
+	let groupMap = this._groupMap;
+	let outMap = {};
+	for(let groupId in groupMap) {
+		let groupDef = groupMap[groupId];
+		let obj = GroupDefinitions._cloneObject(groupDef);
+		outMap[groupId] = obj;
+	}
+	return outMap;
+};
+/** In case of a children array has been modified outside of GroupDefinitions, this method is needed to re-create internal maps to reflect existing structure
+* @public
+*/
+GroupDefinitions.prototype.rebuildMap = function () {
+	let groupMap = this._groupMap;
+	let childToParent = this._childToParent = {};
+
+	// Create child to parent map
+	let groupIds = Object.keys(groupMap);
+	let grpCount = groupIds.length;
+	let i, groupId;
+	for(i = 0; i < grpCount; ++i) {
+		groupId = groupIds[i];
+		let chdr = groupMap[groupId].children;
+		let childCount = chdr ? chdr.length : 0;
+		for (let j = 0; j < childCount; j++) {
+			childToParent[chdr[j]] = groupId;
+		}
+	}
+
+	// Apply a parent id to group definition to make it easier to find depth
+	for(i = 0; i < grpCount; ++i) {
+		groupId = groupIds[i];
+		let parentId = childToParent[groupId];
+		if(parentId) {
+			groupMap[groupId].parentId = parentId;
+		}
+	}
+};
+
+/** Get immediate child ids of the specified group. The returned array can contain both child ids and group ids
+* @public
+* @param {string} groupId
+* @return {Array.<string>}
+*/
+GroupDefinitions.prototype.getGroupChildren = function (groupId) {
+	let groupDef = this._groupMap[groupId];
+	return groupDef ? groupDef.children : null;
+};
+/** Get all non-group descendants of the given group id.
+* @public
+* @param {string} groupId
+* @return {Array.<string>}
+*/
+GroupDefinitions.prototype.getLeafDescendants = function (groupId) {
+	return GroupDefinitions.getLeafDescendants(this._groupMap, groupId);
+};
+/** @public
+* @param {string} groupId
+* @return {number} Return -1 if the given groupDef is null. Return 0 if there is no parent. Return 1 or more if it has a parent
+*/
+GroupDefinitions.prototype.getGroupLevel = function (groupId) {
+	return GroupDefinitions.calcTreeDepth(this._groupMap, this._groupMap[groupId]);
+};
+/** @public
+* @param {string} groupId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getRootGroup = function (groupId) {
+	if (!groupId) {
+		return null;
+	}
+	let groupMap = this._groupMap;
+	let groupDef = groupMap[groupId] || null;
+	// TODO: Support column id
+	if(groupDef) {
+		while (groupDef.parentId) {
+			let parentDef = groupMap[groupDef.parentId];
+			if(parentDef) {
+				groupDef = parentDef;
+			} else {
+				break;
+			}
+		}
+	}
+	return groupDef;
+};
+/** @public
+* @param {string} childId
+* @return {Object}
+*/
+GroupDefinitions.prototype.getParentGroup = function (childId) {
+	return this.getGroup(this._childToParent[childId]);
+};
+/** @public
+* @param {string} childId
+* @return {Array.<string>}
+*/
+GroupDefinitions.prototype.getParentIds = function(childId) {
+	if (childId && typeof childId === "string") {
+		let groupId = this._childToParent[childId];
+		if (groupId) {
+			let groupIds = [groupId];
+			let group = this._groupMap[groupId];
+			while (group && group.parentId) {
+				group = this._groupMap[group.parentId];
+				if (group) {
+					groupIds.push(group.id);
+				}
+			}
+			return groupIds;
+		}
+	}
+	return null;
+};
+/** @public
+* @param {string} childId
+* @param {number=} groupLevel Default is to retrieve immediate parent id. Use 0 to get root (topmost) group id
+* @return {string}
+*/
+GroupDefinitions.prototype.getParentId = function (childId, groupLevel) {
+	let parentId = this._childToParent[childId];
+	if(groupLevel != null) {
+		let currentLevel = this.getGroupLevel(parentId);
+		while(currentLevel > groupLevel && parentId){
+			parentId = this._childToParent[parentId];
+			currentLevel--;
+		}
+	}
+
+	return parentId || "";
+};
+
+/** Remove all existing group definitions
+* @public
+* @return {boolean}
+*/
+GroupDefinitions.prototype.removeAllGroups = function () {
+	for(let groupId in this._groupMap) { // eslint-disable-line
+		this._groupMap = {};
+		this._childToParent = {};
+		return true;
+	}
+	return false;
+};
+/** Remove all existing group definitions and replace them with the given definitions. Note that this method does not check for circular referencing nor duplication of ids
+* @public
+* @param {Array.<Object>=} groupDefs Use null or empty array to remove all existing groups
+*/
+GroupDefinitions.prototype.setGroups = function (groupDefs) {
+	// Clear existing group structure
+	let groupMap = this._groupMap = {};
+
+	// Create group map
+	let grpCount = groupDefs ? groupDefs.length : 0;
+	for (let i = 0; i < grpCount; i++) {
+		let groupDef = groupDefs[i];
+		let groupId = groupDef.id;
+		if(groupId) {
+			groupMap[groupId] = GroupDefinitions._cloneObject(groupDef);
+		}
+	}
+
+	this.rebuildMap();
+};
+/** Add new group definition to existing group structure. Existing group with the same id will be replaced.
+* @public
+* @param {Object} groupDef Group definition object
+* @return {string} Return group ID
+*/
+GroupDefinitions.prototype.addGroup = function (groupDef) {
+	let groupId = GroupDefinitions.getGroupId(groupDef);
+	if(groupId) {
+		return this.setGroup(groupId, groupDef);
+	}
+	return groupId;
+};
+/** @public
+* @param {string} groupId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.removeGroup = function (groupId) {
+	let curDef = this._groupMap[groupId];
+	if(curDef) {
+		this.removeAllChildren(groupId);
+		this.unsetParent(groupId);
+		delete this._groupMap[groupId];
+
+		return true;
+	}
+	return false;
+};
+/** Replace and update existing group definition. A new group will be added, only if the given id has no match. Existing group will be removed of no new definition is given.
+* @public
+* @param {string} groupId
+* @param {(Array.<string>|Object)=} groupDef
+* @return {string} Return group Id. Return empty string, if nothing has been changed
+*/
+GroupDefinitions.prototype.setGroup = function (groupId, groupDef) {
+	if(!groupId) {
+		return "";
+	}
+
+	if(groupDef) {
+		let newDef = GroupDefinitions._toGroupDefinition(groupDef, groupId);
+		this._ungroupChildren(newDef.children);
+
+		let curDef = this._groupMap[groupId];
+		if(curDef) { // Replace
+			this.removeAllChildren(groupId);
+		}
+		let parentId = this._childToParent[groupId];
+		if(parentId) {
+			newDef.parentId = parentId;
+		}
+		this._groupMap[groupId] = newDef;
+
+		let chdr = newDef.children; // newDef is guaranteed to have children property
+		let len = chdr.length;
+		for(let i = 0; i < len; ++i) {
+			let childId = chdr[i];
+			this._childToParent[childId] = groupId;
+			let childDef = this._groupMap[childId];
+			if(childDef) {
+				childDef.parentId = groupId;
+			}
+		}
+	} else { // Remove
+		if(!this.removeGroup(groupId)) {
+			return "";
+		}
+	}
+
+	return groupId;
+};
+
+/** Remove each child from any group
+ * @private
+ * @param {Array.<string>} children
+ */
+GroupDefinitions.prototype._ungroupChildren = function(children) {
+	if (Array.isArray(children)) {
+		let len = children.length;
+		for(let i = 0; i < len; ++i) {
+			this.unsetParent(children[i]);
+		}
+	}
+};
+
+/** Check if the given child id is an immediate child of the given group
+* @public
+* @param {string} parentId Group id
+* @param {string} childId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.hasGroupChild = function (parentId, childId) {
+	let groupDef = this._groupMap[parentId];
+	if(childId && groupDef) {
+		let chdr = groupDef.children;
+		if(chdr) {
+			return chdr.indexOf(childId) >= 0; // TODO: Use childToParent map to improve performance
+		}
+	}
+	return false;
+};
+/** Check if the specified id is contained within the given group regardless of any group level that the id is in
+* @public
+* @param {string} groupId
+* @param {string} childId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.contains = function (groupId, childId) {
+	if(groupId && childId) {
+		if(groupId === childId) {
+			return true;
+		}
+		let levelLimit = 20;
+		let parentId = this._childToParent[childId];
+		while(parentId && levelLimit) { // WARNING: Circular dependency could happen
+			if(groupId === parentId) {
+				return true;
+			}
+			--levelLimit;
+			parentId = this._childToParent[parentId];
+		}
+	}
+	return false;
+};
+/** @public
+* @param {string} parentId Group id
+* @param {string} childId
+* @param {number=} position
+* @return {boolean}
+*/
+GroupDefinitions.prototype.addGroupChild = function (parentId, childId, position) {
+	let groupDef = this._groupMap[parentId];
+
+	if(childId && groupDef) {
+		let chdr = groupDef.children;
+		if(chdr && chdr.indexOf(childId) < 0) {
+			this.unsetParent(childId); // Remove previous parent
+			// Add new child to group structures
+			this._childToParent[childId] = parentId;
+			let childDef = this._groupMap[childId];
+			if(childDef) {
+				childDef.parentId = parentId;
+			}
+			if(position != null && position >= 0) {
+				chdr.splice(position, 0, childId);
+			} else {
+				chdr.push(childId);
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** Remove the given child from the specified parent. If childId is not given, unsetParent will be used on parentId instead of childId.
+* @public
+* @param {string} parentId Group id
+* @param {string=} childId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.removeGroupChild = function (parentId, childId) {
+	if(childId == null) {
+		return this.unsetParent(parentId);
+	}
+	if(this.hasGroupChild(parentId, childId)) {
+		return this.unsetParent(childId);
+	}
+	return false;
+};
+/** Remove the given child from its own parent (i.e., unset Parent of the given child).
+* @public
+* @param {string} childId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.unsetParent = function (childId) {
+	let parentId = this._childToParent[childId];
+	if(!parentId) {
+		return false;
+	}
+	this._childToParent[childId] = "";
+	let childDef = this._groupMap[childId];
+	if(childDef) {
+		childDef.parentId = "";
+	}
+	let parentDef = this._groupMap[parentId];
+	if(parentDef) {
+		let chdr = parentDef.children;
+		if(chdr && chdr.length) {
+			let at = chdr.indexOf(childId);
+			if (at >= 0) {
+				chdr.splice(at, 1); // splice is slow
+			}
+		}
+	}
+	return true;
+};
+/** Remove all children from the specified group
+* @public
+* @param {string} groupId
+* @return {boolean}
+*/
+GroupDefinitions.prototype.removeAllChildren = function(groupId) {
+	let grpDef = this._groupMap[groupId];
+	if(grpDef) {
+		let chdr = grpDef.children;
+		let len = chdr ? chdr.length : 0;
+		if(len) {
+			grpDef.children = [];
+			for(let i = 0; i < len; ++i) {
+				let childId = chdr[i];
+				if(this._childToParent[childId]) {
+					this._childToParent[childId] = "";
+				}
+				let childDef = this._groupMap[childId];
+				if(childDef) {
+					childDef.parentId = "";
+				}
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** Replace and update existing group definition.
+* @public
+* @param {string} groupId
+* @param {Array.<string>} newChildList If null is given, all existing children in the group will be removed
+* @return {boolean}
+*/
+GroupDefinitions.prototype.setGroupChildren = function (groupId, newChildList) {
+	let groupDef = this._groupMap[groupId];
+	if(groupDef) {
+		if(Array.isArray(newChildList)) {
+			let chdr = newChildList.slice();
+			this._ungroupChildren(chdr);
+			this.removeAllChildren(groupId);
+			groupDef.children = chdr;
+
+			let parentId = groupDef.id;
+			let len = chdr.length;
+			for(let i = 0; i < len; ++i) {
+				let childId = chdr[i];
+				this._childToParent[childId] = parentId;
+				let childDef = this._groupMap[childId];
+				if(childDef) {
+					childDef.parentId = parentId;
+				}
+			}
+
+			return true;
+		} else if(!newChildList && groupDef.children.length) {
+			this.removeAllChildren(groupId);
+			return true;
+		}
+	}
+	return false;
+};
+
+/** @public
+* @param {string} groupId
+* @return {string}
+*/
+GroupDefinitions.prototype.getGroupName = function (groupId) {
+	let groupDef = this._groupMap[groupId];
+	if(groupDef) {
+		return groupDef.name || "";
+	}
+	return "";
+};
+/** @public
+* @param {string} groupId
+* @param {string} groupName
+* @return {boolean}
+*/
+GroupDefinitions.prototype.setGroupName = function (groupId, groupName) {
+	let groupDef = this._groupMap[groupId];
+	if(groupDef) {
+		if(groupDef.name !== groupName) {
+			groupDef.name = groupName;
+			return true;
+		}
+	}
+
+	return false;
+};
+
+export default GroupDefinitions;
+export { GroupDefinitions };