udp-react-enterprise-component-library 25.18.1-beta.5 → 25.18.1-beta.51

package/dist/TreeUtilities-jEhtZNg5.js

@@ -0,0 +1,1130 @@
+import { i as toLowerFirstChar, o as toUpperFirstChar } from "./StringUtilities-u-cxAW6-.js";
+import { b as NodeGroupTypeEnums, n as CardinalityTypeEnums, y as NodeGroupOutlierEnums } from "./unitySystemEnums-CZDCsD5t.js";
+import { i as mapRule, t as evaluateRule } from "./RuleUtilities-D5ACzikQ.js";
+import { n as getSearchIdentifiers, r as getSearchObject } from "./SearchUtilities-DUW0kaw_.js";
+import { t as GroupNode } from "./GroupNode-CZX--ble.js";
+import * as Icons from "@fluentui/react-icons";
+import { cloneDeep, orderBy } from "lodash";
+import { v4 } from "uuid";
+
+//#region src/utilities/tree/TreeUtilities.js
+const makeTreeStructure = (treeData, key, parentKey, parentGroupKey = "parentGroupId") => {
+	if (!treeData) return [];
+	const keys = [];
+	treeData.forEach((node) => {
+		node.children = [];
+		if (node["isExpanded"] === void 0 && !node.isGroupNode) if (node.properties.defaultDisplay === "collapsed" || node.properties.lazyLoad) node.isExpanded = false;
+		else node.isExpanded = true;
+		keys.push(node[key]);
+	});
+	const roots = treeData.filter((node) => {
+		return !(node?.isGroupNode ? node[parentGroupKey] : node[parentKey]);
+	});
+	const nodes = [];
+	const existingGroups = [];
+	roots.forEach((root) => {
+		nodes.push(root);
+	});
+	while (nodes.length > 0) {
+		const node = nodes.pop();
+		treeData.filter((data) => data[parentKey] === node[key] || data[parentGroupKey] === node[key]).forEach((child) => {
+			if (child?.isGroupNode) {
+				if (!existingGroups.find((eg) => eg.id === child.id && eg.parentGroupId === child.parentGroupId)) {
+					existingGroups.push(child);
+					node.children.push(child);
+					nodes.push(child);
+				}
+			} else if (node.isGroupNode && child.parentGroupId || !node.isGroupNode && !child.parentGroupId) {
+				node.children.push(child);
+				nodes.push(child);
+			}
+		});
+	}
+	const removeEmptyGroupNodes = (node) => {
+		if (node?.isGroupNode && node?.hideEmptyGroups && !node?.children?.length) return null;
+		node.children = node.children.map(removeEmptyGroupNodes).filter((child) => child !== null);
+		return node;
+	};
+	const filteredRoots = roots.map(removeEmptyGroupNodes).filter((root) => root !== null);
+	if (filteredRoots.length === 1) return filteredRoots[0];
+	return filteredRoots;
+};
+const makeTreeStaticGroupStructure = (treeData, key, parentKey, groupType = NodeGroupTypeEnums.Static, hideEmptyGroups) => {
+	if (!treeData) return [];
+	const keys = [];
+	treeData.forEach((node, index) => {
+		const { id, hideEmptyGroups: hideEmptyGroups$1, children, apiMethodInstanceId, parentGroupId, order, isExpanded, ...groupProperties } = node;
+		treeData[index] = new GroupNode({
+			id,
+			groupType,
+			children,
+			parentId: parentGroupId,
+			parentGroupId,
+			isExpanded,
+			properties: { ...groupProperties }
+		});
+		keys.push(node[key]);
+	});
+	const roots = treeData.filter((node) => keys.indexOf(node[parentKey]) === -1);
+	const nodes = [];
+	roots.forEach((root) => {
+		nodes.push(root);
+	});
+	while (nodes.length > 0) {
+		const node = nodes.pop();
+		treeData.filter((data) => data[parentKey] === node[key]).forEach((child) => {
+			node.children.push(child);
+			nodes.push(child);
+		});
+	}
+	if (roots.length === 1) return roots[0];
+	return roots;
+};
+const makeDynamicGroupStructures = (treeStructure, results) => {
+	if (!treeStructure) return [];
+	const groupStructures = [];
+	results.forEach((item) => {
+		processDynamicGroupForCurrentNodeLevel(item, treeStructure, groupStructures, groupStructures);
+	});
+	return groupStructures;
+};
+const processDynamicGroupForCurrentNodeLevel = (item, node, groupStructures, previousFilteredGroups = []) => {
+	const { property, id } = node;
+	const label = property ? getLabelFromProperty(item, property) : null;
+	let filteredGroups = [];
+	previousFilteredGroups.forEach((group) => {
+		if (group) {
+			const foundGroups = findNodesByIdAndLabel(group, id, label);
+			if (foundGroups.length) filteredGroups = filteredGroups.concat(foundGroups);
+		}
+	});
+	if (filteredGroups.length) {
+		if (node?.children?.length) node.children.forEach((child) => processDynamicGroupForCurrentNodeLevel(item, child, groupStructures, filteredGroups));
+	} else if (label) {
+		const dynamicGroupTree = makeDynamicGroupTree(node, item);
+		if (node.parentGroupId) previousFilteredGroups.forEach((filteredGroup) => {
+			const matchingGroupNode = findNodeById(filteredGroup, node.parentGroupId);
+			if (matchingGroupNode) {
+				dynamicGroupTree.parentGroupId = matchingGroupNode.id;
+				matchingGroupNode.children.push(dynamicGroupTree);
+			}
+		});
+		else groupStructures.push(dynamicGroupTree);
+	}
+};
+const makeDynamicGroupTree = (node, item, parentGroupNode) => {
+	const { id, children, apiMethodInstanceId, parentGroupId, order, property, label, isExpanded, ...groupProperties } = node;
+	const updatedLabel = property ? getLabelFromProperty(item, property) : null;
+	if (updatedLabel) {
+		const groupNode = new GroupNode({
+			id: `${id}`,
+			groupType: NodeGroupTypeEnums.Dynamic,
+			children: [],
+			parentGroupId: parentGroupNode?.id || null,
+			isExpanded,
+			properties: {
+				label: updatedLabel,
+				...groupProperties,
+				propertyKey: property
+			}
+		});
+		if (parentGroupNode) parentGroupNode.children.push(groupNode);
+		if (children?.length) children.forEach((child) => makeDynamicGroupTree(child, item, groupNode));
+		return groupNode;
+	}
+};
+const makeDynamicTreeStructure = (treeData, key, parentKey) => {
+	if (!treeData) return [];
+	const keys = [];
+	treeData.forEach((node, index) => {
+		keys.push(node[key]);
+	});
+	const roots = treeData.filter((node) => keys.indexOf(node[parentKey]) === -1);
+	const nodes = [];
+	roots.forEach((root) => {
+		nodes.push(root);
+	});
+	while (nodes.length > 0) {
+		const node = nodes.pop();
+		treeData.filter((data) => data[parentKey] === node[key]).forEach((child) => {
+			node.children.push(child);
+			nodes.push(child);
+		});
+	}
+	if (roots.length === 1) return roots[0];
+	return roots;
+};
+const getIconFromName = (name) => {
+	if (!name) return null;
+	if (name.slice(-4).toLowerCase() !== "icon") return Icons[`${name}Icon`] || null;
+	else return Icons[name] || null;
+};
+const findLastNode = (tree) => {
+	let result = null;
+	if (!tree?.children?.length) return tree;
+	else {
+		if (tree?.children) tree.children.forEach((node) => result = findLastNode(node));
+		return result;
+	}
+};
+const searchTree = (tree, id) => {
+	let result = null;
+	if (tree.id === id) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = searchTree(node, id));
+		return result;
+	}
+};
+const deleteNode = (treeData, nodeId) => {
+	const updatedTreeData = [...treeData];
+	const foundNode = updatedTreeData.find((node) => node.id === nodeId);
+	const nodeIndex = updatedTreeData.findIndex((node) => node.id === nodeId);
+	if (!foundNode.parentId || !updatedTreeData.some((node) => node.parentId === nodeId)) {
+		if (nodeIndex > -1) updatedTreeData.splice(nodeIndex, 1);
+		const immediateChild = updatedTreeData.find((node) => node.parentId === nodeId);
+		if (immediateChild) immediateChild.parentId = null;
+	} else {
+		foundNode.isDeleted = true;
+		foundNode.properties = {};
+	}
+	return updatedTreeData;
+};
+const deleteNodeAndChildren = (treeData, nodeId) => {
+	const updatedTreeData = [...treeData];
+	const nodeIdsToDelete = [];
+	nodeIdsToDelete.push(nodeId);
+	getAllChildrenNodesToDelete(updatedTreeData, nodeId, nodeIdsToDelete);
+	return updatedTreeData.filter((node) => !nodeIdsToDelete.includes(node.id));
+};
+const getAllChildrenNodesToDelete = (treeData, nodeId, nodeIdsToDelete) => {
+	treeData.filter((node) => node.parentId === nodeId).forEach((node) => {
+		nodeIdsToDelete.push(node.id);
+		getAllChildrenNodesToDelete(treeData, node.id, nodeIdsToDelete);
+	});
+};
+const processCatalogObjectKeysInOrder = (tree, keys) => {
+	if (!tree?.children?.length) keys.push(tree?.properties?.catalogObjectKey);
+	else if (tree?.children) {
+		if (tree?.properties?.catalogObjectKey) keys.push(tree?.properties?.catalogObjectKey);
+		tree.children.forEach((node) => processCatalogObjectKeysInOrder(node, keys));
+	}
+};
+const processOrderedTreeData = (tree, treeData) => {
+	if (!tree?.children?.length) treeData.push(tree);
+	else if (tree?.children) {
+		treeData.push(tree);
+		tree.children.forEach((node) => processOrderedTreeData(node, treeData));
+	}
+};
+const processObjectToTree = (result, treeData, objectReferenceKeys, treeList, catalogObjects, promotedEntities, wasLazyLoaded) => {
+	processReferences(result, objectReferenceKeys, { ...treeData }, 0, treeList, null, catalogObjects, promotedEntities, wasLazyLoaded);
+};
+const processReferences = (reference, objectReferenceKeys, treeData, index, treeList, parentId, catalogObjects, promotedEntities, wasLazyLoaded) => {
+	const newIndex = index + 1;
+	if (reference) {
+		let node = parentId ? treeData[newIndex] : treeData[0];
+		let nodeGroups = [];
+		if (parentId) {
+			if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Static) nodeGroups = constructStaticNodeGroups(node, true);
+			else if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Dynamic) nodeGroups = constructDynamicNodeGroups(reference, node, true);
+		}
+		if (Array.isArray(reference) && reference.length) reference.forEach((ref, i) => {
+			if (node) {
+				const nodeCopy = cloneDeep(node);
+				processObjIndex(nodeCopy, ref, i, parentId, catalogObjects, promotedEntities, wasLazyLoaded);
+				if (nodeGroups.length) {
+					if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Static) {
+						const groupedItemIndexes = /* @__PURE__ */ new Set();
+						let processedItem = {
+							itemAdded: false,
+							nodeChildren: []
+						};
+						nodeGroups.forEach((nodeGroup) => {
+							let nodeGroupChildren = [];
+							processedItem = processItemForStaticNodeGroup(nodeGroup, ref, groupedItemIndexes, nodeCopy, i, /* @__PURE__ */ new Set(), treeList);
+							nodeGroupChildren = nodeGroupChildren.concat(processedItem.nodeChildren);
+							mapNodeGroupChildren(nodeGroup, nodeGroupChildren);
+							nodeGroup.parentGroupId = nodeCopy.parentId;
+						});
+						if (!processedItem.itemAdded && node?.properties?.groupConfiguration?.outlier === NodeGroupOutlierEnums.Individual) !checkNodeIsHidden(nodeCopy, ref, wasLazyLoaded) && treeList.push(nodeCopy);
+					} else if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Dynamic) nodeGroups.forEach((nodeGroup) => {
+						nodeGroup.parentGroupId = nodeCopy.parentId;
+						nodeGroup.parentId = nodeCopy.parentId;
+						processGroupNodesAndAddToTreeList(nodeGroup, treeList, nodeCopy.parentId, ref, wasLazyLoaded);
+					});
+				} else !checkNodeIsHidden(nodeCopy, ref, wasLazyLoaded) && treeList.push(nodeCopy);
+				if (nodeCopy?.children?.length) {
+					const objectReferenceKeysCopy = [...objectReferenceKeys];
+					nodeCopy.children.forEach((childNode, i$1) => {
+						const catalogObjectKey = childNode?.properties?.catalogObjectKey;
+						const nextIndex = objectReferenceKeysCopy.indexOf(catalogObjectKey);
+						if (!parentId) objectReferenceKeysCopy[nextIndex] = null;
+						processReferences(ref[catalogObjectKey], objectReferenceKeys, treeData, nextIndex, treeList, nodeCopy.id, catalogObjects, promotedEntities, nodeCopy.properties.lazyLoad);
+					});
+				}
+			}
+		});
+		else if (typeof reference === "object" && !Array.isArray(reference)) {
+			processObjIndex(node, reference, 0, parentId, catalogObjects, promotedEntities, wasLazyLoaded);
+			if (node) {
+				const nodeCopy = cloneDeep(node);
+				!checkNodeIsHidden(nodeCopy, reference, wasLazyLoaded) && treeList.push(nodeCopy);
+				if (nodeCopy?.children?.length) {
+					const objectReferenceKeysCopy = [...objectReferenceKeys];
+					nodeCopy.children.forEach((childNode, i) => {
+						const catalogObjectKey = childNode?.properties?.catalogObjectKey;
+						const nextIndex = parentId ? newIndex : objectReferenceKeysCopy.indexOf(catalogObjectKey);
+						if (!parentId) objectReferenceKeysCopy[nextIndex] = null;
+						processReferences(reference[catalogObjectKey], objectReferenceKeys, treeData, nextIndex, treeList, nodeCopy.id, catalogObjects, promotedEntities, nodeCopy.properties.lazyLoad);
+					});
+				}
+			}
+		}
+	}
+};
+const processObjIndex = (node, obj, index, parentId, catalogObjects, promotedEntities, wasLazyLoaded) => {
+	if (node.properties.conditionalNodeIconExpression) {
+		const conditionalNodeIcon = evaluateRule(node.properties.conditionalNodeIconExpression, obj, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded);
+		if (conditionalNodeIcon) {
+			node.properties["conditionalNodeIconName"] = conditionalNodeIcon?.name || "";
+			node.properties["conditionalNodeIconColor"] = conditionalNodeIcon?.iconColor?.hex;
+			node.properties["conditionalNodeIconType"] = conditionalNodeIcon?.type || "";
+		} else {
+			node.properties["conditionalNodeIconName"] = "";
+			node.properties["conditionalNodeIconColor"] = "";
+			node.properties["conditionalNodeIconType"] = "";
+		}
+	}
+	if (node.properties.conditionalNodeAdornmentExpression || node.properties.conditionalIconExpression) {
+		const conditionalNodeAdornment = node.properties.conditionalNodeAdornmentExpression ? evaluateRule(node.properties.conditionalNodeAdornmentExpression, obj, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded) : evaluateRule(node.properties.conditionalIconExpression, obj, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded);
+		if (conditionalNodeAdornment) {
+			node.properties["conditionalNodeAdornmentName"] = conditionalNodeAdornment?.name || "";
+			node.properties["conditionalNodeAdornmentColor"] = conditionalNodeAdornment?.iconColor?.hex;
+			node.properties["conditionalNodeAdornmentType"] = conditionalNodeAdornment?.type || "";
+		} else {
+			node.properties["conditionalNodeAdornmentName"] = "";
+			node.properties["conditionalNodeAdornmentColor"] = "";
+			node.properties["conditionalNodeAdornmentType"] = "";
+		}
+	}
+	if (node.properties.catalogReturnObject) {
+		let searchIdentifiers = getSearchIdentifiers(catalogObjects, node.properties.catalogReturnObject);
+		node.properties["searchIdentifier"] = searchIdentifiers?.join(",");
+		const associatedTreePrimaryKeyMap = node.properties.associatedTreePrimaryKeyMap;
+		if (!!associatedTreePrimaryKeyMap) {
+			searchIdentifiers = Object.keys(associatedTreePrimaryKeyMap);
+			node.properties["searchIdentifier"] = searchIdentifiers;
+		}
+		node.properties["filterElements"] = [];
+		const searchValues = [];
+		const joiningEntityCatalogObjectKey = node?.properties?.joiningEntityCatalogObjectKey;
+		searchIdentifiers.forEach((searchIdentifier) => {
+			const searchField = searchIdentifier ? searchIdentifier.charAt(0).toUpperCase() + searchIdentifier.slice(1) : "";
+			let searchValue = "";
+			let si = associatedTreePrimaryKeyMap?.[searchIdentifier] ? associatedTreePrimaryKeyMap?.[searchIdentifier] : searchIdentifier;
+			if (obj[si]) searchValue = obj[si];
+			else if (joiningEntityCatalogObjectKey) searchValue = obj[joiningEntityCatalogObjectKey] ? obj[joiningEntityCatalogObjectKey][si] : "";
+			node.properties["filterElements"].push({
+				searchField,
+				searchOperator: "=",
+				searchValue: searchValue ?? ""
+			});
+			searchValues.push(searchValue);
+		});
+		node.properties["searchValue"] = searchValues.toString();
+	}
+	node.properties["nodeLabel"] = getDisplayName(node, obj);
+	node.properties["nodeSubLabel"] = getDisplayDetails(node, obj);
+	node.properties["headerTitle"] = getHeaderTitle(node, obj);
+	node.parentId = parentId;
+	node["entityNodeParentId"] = parentId;
+	node.id = v4();
+	node.nodeObj = obj;
+	if (node?.properties?.lazyLoad) node.lazyLoadChildrenArr = getLazyLoadChildrenArr(node, catalogObjects, promotedEntities);
+};
+const getEntityAssoc = (nodeEntity, node) => {
+	let entityAssoc = null;
+	if (nodeEntity) {
+		const referenceProperty = nodeEntity.properties.find((property) => {
+			if (node.properties?.joiningEntityName) return property.reference === node.properties?.joiningEntityName;
+			else return property.reference === node.properties?.catalogReturnObject;
+		});
+		entityAssoc = referenceProperty ? referenceProperty.extendedProperties?.childEntityAssoc : null;
+	}
+	return entityAssoc;
+};
+const getLazyLoadChildrenArr = (node, catalogObjects, promotedEntities) => {
+	const lazyLoadChildrenArr = [];
+	let defaultSearchIdentifiers = [];
+	if (node?.properties?.catalogReturnObject) defaultSearchIdentifiers = getSearchIdentifiers(catalogObjects, node.properties.catalogReturnObject);
+	node && node.children && node.children.forEach((childNode) => {
+		const lazyNodeSearchObj = {
+			apiMethodId: null,
+			data: null,
+			parentNodeRefKey: childNode.properties?.catalogObjectKey,
+			catalogReturnObject: childNode.properties?.catalogReturnObject
+		};
+		const entityName = childNode.properties?.catalogReturnObject;
+		const promotedEntity = promotedEntities?.find((pe) => pe.entityName === entityName);
+		let searchIdentifiers = [];
+		const filterElements = [];
+		if (promotedEntity) {
+			let baseSearch = promotedEntity.unityBaseSearchMethod;
+			let childBaseSearch = promotedEntity.unityBaseSearchMethod;
+			const nodeEntity = catalogObjects?.find((co) => co.catalogObjectName === node.properties?.catalogReturnObject);
+			let isManyToManySearch = false;
+			let usingJoiningTableForSearch = false;
+			if (nodeEntity) {
+				const childEntityAssoc = getEntityAssoc(nodeEntity, childNode);
+				let joiningEntityName = null;
+				let promotedEntityForJoiningTable = null;
+				if (childEntityAssoc.Cardinality === CardinalityTypeEnums.Many_To_Many) {
+					isManyToManySearch = true;
+					lazyNodeSearchObj["manyToManyKeys"] = [];
+					joiningEntityName = childNode.properties?.joiningEntityName;
+					promotedEntityForJoiningTable = promotedEntities?.find((pe) => pe.entityName === joiningEntityName);
+					if (promotedEntityForJoiningTable?.unityBaseSearchMethod) {
+						baseSearch = promotedEntityForJoiningTable.unityBaseSearchMethod;
+						lazyNodeSearchObj.manyToManyJointEntityApiMethodId = childBaseSearch?.apiMethodId;
+						usingJoiningTableForSearch = true;
+					}
+					const entityAssoc = getEntityAssoc(catalogObjects.find((co) => co.catalogObjectName === childNode.properties?.catalogReturnObject), childNode);
+					if (entityAssoc && Object.keys(entityAssoc).length) entityAssoc.Keys.forEach((keyVal) => {
+						const keyValArr = keyVal.split(",");
+						const foreignKeyName = keyValArr[0] ? keyValArr[0].trim() : "";
+						const parentIdentifierName = keyValArr[1] ? keyValArr[1].trim() : "";
+						const searchValueKey = /^[A-Z]*$/.test(parentIdentifierName) ? parentIdentifierName.toLowerCase() : toLowerFirstChar(parentIdentifierName);
+						lazyNodeSearchObj["manyToManyKeys"].push({
+							searchItemIdentifier: usingJoiningTableForSearch ? /^[A-Z]*$/.test(foreignKeyName) ? foreignKeyName.toLowerCase() : toLowerFirstChar(foreignKeyName) : searchValueKey,
+							searchNameKey: foreignKeyName,
+							searchValueKey
+						});
+					});
+				}
+				if (childEntityAssoc && Object.keys(childEntityAssoc).length) childEntityAssoc.Keys.forEach((keyVal) => {
+					const keyValArr = keyVal.split(",");
+					let searchJoiningEntity = "";
+					if (!isManyToManySearch && node.nodeObj.hasOwnProperty(node.properties.joiningEntityCatalogObjectKey)) searchJoiningEntity = node.properties.joiningEntityCatalogObjectKey;
+					const foreignKeyName = keyValArr[0] ? keyValArr[0].trim() : "";
+					let siObj = {
+						searchNameKey: keyValArr[1] ? keyValArr[1].trim() : "",
+						searchValueKey: /^[A-Z]*$/.test(foreignKeyName) ? foreignKeyName.toLowerCase() : toLowerFirstChar(foreignKeyName),
+						searchJoiningEntity
+					};
+					if (isManyToManySearch && !usingJoiningTableForSearch) siObj = {
+						searchNameKey: foreignKeyName,
+						searchValueKey: /^[A-Z]*$/.test(foreignKeyName) ? foreignKeyName.toLowerCase() : toLowerFirstChar(foreignKeyName)
+					};
+					if (isManyToManySearch) {
+						if (childNode.properties?.catalogObjectKey && childNode.properties?.joiningEntityCatalogObjectLeftKey) {
+							siObj["joiningEntityKeyName"] = toUpperFirstChar(!usingJoiningTableForSearch ? childNode.properties?.joiningEntityChildKey : childNode.properties?.catalogObjectKey);
+							siObj["joiningEntityCatalogObjectLeftKeyName"] = toUpperFirstChar(childNode.properties?.joiningEntityCatalogObjectLeftKey);
+						}
+						if (promotedEntityForJoiningTable?.unityBaseSearchMethod) {
+							siObj["joiningEntityKeyName"] = null;
+							siObj["joiningEntityCatalogObjectLeftKeyName"] = null;
+						}
+					}
+					searchIdentifiers.push(siObj);
+				});
+			}
+			if (!searchIdentifiers.length) defaultSearchIdentifiers.forEach((searchIdentifier) => {
+				const siObj = {
+					searchNameKey: searchIdentifier,
+					searchValueKey: searchIdentifier
+				};
+				if (childNode.properties?.catalogObjectKey && childNode.properties?.joiningEntityCatalogObjectLeftKey) {
+					siObj["joiningEntityKeyName"] = toUpperFirstChar(childNode.properties?.catalogObjectKey);
+					siObj["joiningEntityCatalogObjectLeftKeyName"] = toUpperFirstChar(childNode.properties?.joiningEntityCatalogObjectLeftKey);
+				}
+				searchIdentifiers.push(siObj);
+			});
+			searchIdentifiers.forEach((si) => {
+				let searchValue = "";
+				if (si?.searchJoiningEntity) searchValue = node.nodeObj[si.searchJoiningEntity][si.searchValueKey];
+				else if (usingJoiningTableForSearch) {
+					const joiningEntityCatalogObjectKey = node?.properties?.joiningEntityCatalogObjectKey;
+					const value = node?.nodeObj?.[joiningEntityCatalogObjectKey];
+					searchValue = value ? value[si.searchValueKey] : node.nodeObj[si.searchValueKey];
+				} else searchValue = node.nodeObj[si.searchValueKey];
+				let formattedPropertyName = toUpperFirstChar(si.searchNameKey);
+				if (si["joiningEntityKeyName"] && si["joiningEntityCatalogObjectLeftKeyName"]) formattedPropertyName = `${si["joiningEntityKeyName"]}.${si["joiningEntityCatalogObjectLeftKeyName"]}.${formattedPropertyName}`;
+				filterElements.push({
+					searchField: formattedPropertyName,
+					searchValue,
+					searchOperator: "="
+				});
+			});
+			lazyNodeSearchObj.data = getSearchObject(filterElements, 1, 50);
+			lazyNodeSearchObj.apiMethodId = baseSearch?.apiMethodId || null;
+			lazyLoadChildrenArr.push(lazyNodeSearchObj);
+		} else {
+			console.log("Error: Promote " + entityName + " entity");
+			node.errorRetrievingChildren = "Error: Promote " + entityName + " child entity";
+		}
+	});
+	return lazyLoadChildrenArr;
+};
+const formatTreeMenuItem = (responseObject, treeStructure, catalogObjects, promotedEntities, associatedInquiryTree, wasLazyLoaded) => {
+	if (!responseObject) return null;
+	const tree = cloneDeep(treeStructure);
+	const orderedKeys = [];
+	const orderedTreeData = [];
+	const treeArr = [];
+	processCatalogObjectKeysInOrder(tree, orderedKeys);
+	processOrderedTreeData(tree, orderedTreeData);
+	processObjectToTree(responseObject, orderedTreeData, orderedKeys, treeArr, catalogObjects, promotedEntities, wasLazyLoaded);
+	const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+	displayTree["associatedInquiryTree"] = associatedInquiryTree;
+	displayTree["wasLazyLoaded"] = wasLazyLoaded;
+	return displayTree;
+};
+const expandAllNodes = (tree) => {
+	tree.isExpanded = true;
+	if (tree?.children) tree.children.forEach((node) => expandAllNodes(node));
+};
+const collapseAllNodes = (tree) => {
+	tree.isExpanded = false;
+	if (tree?.children) tree.children.forEach((node) => collapseAllNodes(node));
+};
+const findAllParentIds = (menuItems, currentParentNode, allParentIds = []) => {
+	if (currentParentNode?.parentId) {
+		allParentIds.push(currentParentNode?.parentId);
+		findAllParentIds(menuItems, searchTree(menuItems, currentParentNode?.parentId), allParentIds);
+	}
+	return allParentIds;
+};
+const formatTreeLabel = (label, obj) => {
+	const keys = (label?.split("+"))?.map((field) => field.trim());
+	if (keys) {
+		const skippableKeys = [];
+		const updatedKeys = keys.map((key, index) => {
+			if (key.charAt(0) === "\"") {
+				skippableKeys.push(index);
+				key = key.replace(/"/g, "");
+			}
+			return key;
+		});
+		const values = [];
+		for (let j = 0; j < keys.length; j++) {
+			let property = keys[j];
+			if (property) {
+				const splitProperties = property.split(".");
+				if (splitProperties.length > 1) {
+					let constructedValue = null;
+					splitProperties.forEach((property$1) => {
+						const matches = property$1.match(/\[(.*?)\]/);
+						let objIndex = null;
+						let arrIndex = null;
+						if (matches) {
+							arrIndex = parseInt(matches[1]);
+							objIndex = matches.index;
+						}
+						if (typeof arrIndex === "number" && objIndex) {
+							const formattedProperty = property$1.substring(0, objIndex);
+							if (!constructedValue) {
+								if (obj[formattedProperty]) constructedValue = obj[formattedProperty][arrIndex];
+							} else if (constructedValue[formattedProperty]) constructedValue = constructedValue[formattedProperty][arrIndex];
+						} else if (!constructedValue) constructedValue = obj[property$1];
+						else constructedValue = constructedValue[property$1];
+					});
+					if (typeof constructedValue === "boolean" || typeof constructedValue === "number") constructedValue = constructedValue.toString();
+					values.push(constructedValue);
+					continue;
+				}
+			}
+			let value = obj[property];
+			if (typeof value === "boolean" || typeof value === "number") value = value.toString();
+			values.push(value);
+		}
+		let displayName = updatedKeys.join("+");
+		for (let k = 0; k < updatedKeys.length; k++) if (!skippableKeys.includes(k)) if (values[k]) displayName = displayName.replace(`${updatedKeys[k]}`, values[k]);
+		else displayName = displayName.replace(`${updatedKeys[k]}`, "");
+		return displayName.replaceAll("+", " ");
+	} else return label;
+};
+const getDisplayName = (node, obj) => {
+	return formatTreeLabel(node.properties["displayName"], obj);
+};
+const getDisplayDetails = (node, obj) => {
+	return formatTreeLabel(node.properties["displayDetails"], obj);
+};
+const getHeaderTitle = (node, obj) => {
+	return formatTreeLabel(node.properties["headerName"], obj);
+};
+const searchForMatchingNode = (tree, nodeObj = {}, searchIdentifiers = []) => {
+	let result = null;
+	let match = true;
+	searchIdentifiers.forEach((searchIdentifier) => {
+		if (tree?.nodeObj[searchIdentifier] !== nodeObj[searchIdentifier]) match = false;
+	});
+	if (match && searchIdentifiers.length) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = searchForMatchingNode(node, nodeObj, searchIdentifiers));
+		return result;
+	}
+};
+const getNodeIdForRightBorder = (expandedNodeIds, node, parentId) => {
+	if (!expandedNodeIds.includes(node?.id)) return node.id;
+	if (!expandedNodeIds.includes(parentId)) {
+		const foundParentNode = node.children.find((item) => item.id === parentId);
+		if (foundParentNode) if (expandedNodeIds.includes(foundParentNode?.parentId)) return parentId;
+		else return getNodeIdForRightBorder(expandedNodeIds, foundParentNode, foundParentNode?.parentId);
+	} else return parentId;
+};
+const findNodeById = (tree, id) => {
+	let result = null;
+	if (tree?.id === id) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = findNodeById(node, id));
+		return result;
+	}
+};
+const findNodeByIdAndLabel = (tree, id, label) => {
+	let result = null;
+	if (tree?.id === id && tree?.properties?.label === label) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = findNodeById(node, id, label));
+		return result;
+	}
+};
+const findNodesByIdAndLabel = (tree, id, label) => {
+	let results = [];
+	if (tree?.id === id && tree?.properties?.label === label) results.push(tree);
+	if (tree.children) tree.children.forEach((node) => {
+		results = results.concat(findNodesByIdAndLabel(node, id, label));
+	});
+	return results;
+};
+const updateNodeForStaticGrouping = (displayTree, nodeGroup, nodeChildren, treeList, scopedGroupItemIndexes, groupedItemIndexes, index, item) => {
+	const updatedDisplayTree = { ...displayTree };
+	if (!checkNodeIsHidden(updatedDisplayTree, item, false)) {
+		updatedDisplayTree.children = displayTree.children ? cloneDeep(displayTree.children) : displayTree.children;
+		updatedDisplayTree["parentId"] = nodeGroup.id;
+		updatedDisplayTree["parentGroupId"] = nodeGroup.id;
+		updatedDisplayTree["parentGroupName"] = nodeGroup.properties.label;
+		if (updatedDisplayTree.isGroupNode) nodeGroup.children.push(updatedDisplayTree);
+		else nodeChildren.push(updatedDisplayTree);
+		if (treeList) treeList.push(updatedDisplayTree);
+		scopedGroupItemIndexes.add(index);
+		groupedItemIndexes.add(index);
+	}
+};
+const processItemForStaticNodeGroup = (nodeGroup, item, groupedItemIndexes, displayTree, index, scopedGroupItemIndexes = /* @__PURE__ */ new Set(), treeList, nodeChildren = []) => {
+	if (nodeGroup?.properties?.propertyMapping && nodeGroup?.properties?.jsonLogic) {
+		const rule = mapRule(nodeGroup?.properties?.propertyMapping, nodeGroup?.properties?.jsonLogic);
+		if (rule && evaluateRule(rule, item, item.properties?.joiningEntityCatalogObjectKey, false)) {
+			let itemAdded = false;
+			nodeGroup.children.forEach((childGroup) => {
+				if (childGroup.isGroupNode) itemAdded = (processItemForStaticNodeGroup(childGroup, item, groupedItemIndexes, displayTree, index, childGroup.children.length ? /* @__PURE__ */ new Set() : scopedGroupItemIndexes, treeList, nodeChildren) || { itemAdded })?.itemAdded;
+			});
+			if (!itemAdded) {
+				updateNodeForStaticGrouping(displayTree, nodeGroup, nodeChildren, treeList, scopedGroupItemIndexes, groupedItemIndexes, index, item);
+				itemAdded = true;
+			}
+		}
+	} else if (nodeGroup.isOutlierGroup && !groupedItemIndexes.has(index)) updateNodeForStaticGrouping(displayTree, nodeGroup, nodeChildren, treeList, scopedGroupItemIndexes, groupedItemIndexes, index, item);
+	if (treeList && nodeGroup.isGroupNode) {
+		if (!treeList.filter((node) => node.isGroupNode).find((eg) => eg.id === nodeGroup.id)) !checkNodeIsHidden(nodeGroup, item, false) && treeList.push(nodeGroup);
+	}
+	return {
+		itemAdded: groupedItemIndexes.has(index),
+		nodeChildren
+	};
+};
+const constructStaticNodeGroups = (tree, shouldUseNewId = false) => {
+	const nodeGroups = [];
+	const groupConfiguration = tree?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Static;
+	const hideEmptyGroups = groupConfiguration?.hideEmptyGroups;
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) {
+		groupConfiguration.groupings[groupType].forEach((grouping) => {
+			const orderedGroups = orderByGroupOrder(grouping?.groups);
+			const newIdMap = {};
+			orderedGroups.forEach((group) => {
+				if (shouldUseNewId) newIdMap[group.id] = v4();
+				group["children"] = [];
+			});
+			if (Object.keys(newIdMap).length) orderedGroups.forEach((group) => {
+				if (newIdMap[group.id]) group.id = newIdMap[group.id];
+				if (newIdMap[group.parentGroupId]) group.parentGroupId = newIdMap[group.parentGroupId];
+			});
+			if (orderedGroups?.length) {
+				const firstGroup = orderedGroups.find((group) => !group.parentGroupId) || orderedGroups[0];
+				orderedGroups.shift();
+				const displayTree = makeTreeStaticGroupStructure(orderedGroups, "id", "parentGroupId", groupType, hideEmptyGroups);
+				const { id, isExpanded, ...firstGroupProperties } = firstGroup;
+				const groupNode = new GroupNode({
+					id,
+					hideEmptyGroups,
+					groupType,
+					children: Array.isArray(displayTree) ? displayTree : [displayTree],
+					isExpanded,
+					properties: { ...firstGroupProperties }
+				});
+				nodeGroups.push(groupNode);
+			}
+		});
+		if (groupConfiguration?.outlier === "group") {
+			const outlierGroup = new GroupNode({
+				groupType,
+				isOutlierGroup: true,
+				properties: {
+					label: groupConfiguration?.outlierGroupLabel || "Unlabeled Outlier Group",
+					icon: groupConfiguration?.outlierIcon
+				}
+			});
+			nodeGroups.push(outlierGroup);
+		}
+	}
+	return nodeGroups;
+};
+const getOrderedDynamicGroups = (tree, shouldUseNewId = false) => {
+	const groupConfiguration = tree?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Dynamic;
+	let orderedGroups = [];
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) groupConfiguration.groupings[groupType].forEach((grouping) => {
+		orderedGroups = orderByGroupOrder(grouping?.groups);
+		const newIdMap = {};
+		orderedGroups.forEach((group) => {
+			if (shouldUseNewId) newIdMap[group.id] = v4();
+			group["children"] = [];
+		});
+		if (Object.keys(newIdMap).length) orderedGroups.forEach((group) => {
+			if (newIdMap[group.id]) group.id = newIdMap[group.id];
+			if (newIdMap[group.parentGroupId]) group.parentGroupId = newIdMap[group.parentGroupId];
+		});
+	});
+	return orderedGroups;
+};
+const constructDynamicNodeGroups = (results, tree, shouldUseNewId = false) => {
+	let nodeGroups = [];
+	const groupConfiguration = tree?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Dynamic;
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) groupConfiguration.groupings[groupType].forEach((grouping) => {
+		const orderedGroups = orderByGroupOrder(grouping?.groups);
+		const newIdMap = {};
+		orderedGroups.forEach((group) => {
+			if (shouldUseNewId) newIdMap[group.id] = v4();
+			group["children"] = [];
+		});
+		if (Object.keys(newIdMap).length) orderedGroups.forEach((group) => {
+			if (newIdMap[group.id]) group.id = newIdMap[group.id];
+			if (newIdMap[group.parentGroupId]) group.parentGroupId = newIdMap[group.parentGroupId];
+		});
+		if (orderedGroups?.length) {
+			const isSingleGroup = orderedGroups.length === 1;
+			const dynamicTreeStructure = makeDynamicTreeStructure(orderedGroups, "id", "parentGroupId");
+			const groupSet = makeDynamicGroupStructures(dynamicTreeStructure, results);
+			results.forEach((item, index) => {
+				const orderedKeys = [];
+				const orderedTreeData = [];
+				const treeArr = [];
+				const innerGroupList = [];
+				processCatalogObjectKeysInOrder(tree, orderedKeys);
+				processOrderedTreeData(tree, orderedTreeData);
+				processObjectToTree(item, orderedTreeData, orderedKeys, treeArr, null, null, false, innerGroupList);
+				const updatedDisplayTree = cloneDeep(makeTreeStructure(treeArr, "id", "parentId"));
+				!checkNodeIsHidden(updatedDisplayTree, item, false) && processItemForDynamicNodeGroups(updatedDisplayTree, dynamicTreeStructure, groupSet, groupSet, isSingleGroup);
+			});
+			groupSet.forEach((group) => updateTreeIds(group, null, v4(), v4(), null));
+			nodeGroups = nodeGroups.concat(groupSet);
+		}
+	});
+	return nodeGroups;
+};
+const getLabelFromProperty = (item, property) => {
+	const splitProperties = property.split(".");
+	if (splitProperties.length) {
+		let constructedValue = null;
+		splitProperties.forEach((property$1) => {
+			const matches = property$1.match(/\[(.*?)\]/);
+			let objIndex = null;
+			let arrIndex = null;
+			if (matches) {
+				arrIndex = parseInt(matches[1]);
+				objIndex = matches.index;
+			}
+			if (typeof arrIndex === "number" && objIndex) {
+				const formattedProperty = property$1.substring(0, objIndex);
+				if (!constructedValue) {
+					if (item[formattedProperty]) constructedValue = item[formattedProperty][arrIndex];
+				} else if (constructedValue[formattedProperty]) constructedValue = constructedValue[formattedProperty][arrIndex];
+			} else if (!constructedValue) constructedValue = item ? item[property$1] : "";
+			else constructedValue = constructedValue[property$1];
+		});
+		return constructedValue;
+	}
+	return null;
+};
+const constructBusinessObjectArrFromTree = (node, businessObjects = []) => {
+	if (node?.nodeObj) {
+		const businessObject = {
+			label: "",
+			value: "",
+			domainObject: ""
+		};
+		const joiningEntityCatalogObjectKey = node.properties?.joiningEntityCatalogObjectKey;
+		const displayName = node.properties?.displayName;
+		if (joiningEntityCatalogObjectKey) {
+			const jointEntity = node.nodeObj[joiningEntityCatalogObjectKey];
+			businessObject.label = formatTreeLabel(displayName, node.nodeObj) || jointEntity?.businessObjectKey;
+			businessObject.value = jointEntity?.businessObjectKey;
+			businessObject.domainObject = node.properties?.catalogReturnObject;
+		} else {
+			const entity = node.nodeObj;
+			businessObject.label = formatTreeLabel(displayName, node.nodeObj) || entity?.businessObjectKey;
+			businessObject.value = entity?.businessObjectKey;
+			businessObject.domainObject = node.properties?.catalogReturnObject;
+		}
+		businessObjects.push(businessObject);
+	}
+	if (node?.children?.length) node.children.forEach((childNode) => constructBusinessObjectArrFromTree(childNode, businessObjects));
+	return businessObjects;
+};
+const processItemForDynamicNodeGroups = (displayTree, node, groupNodes, previousFilteredGroups = [], isSingleGroup = false) => {
+	const { property, id } = node;
+	const item = displayTree?.nodeObj;
+	const label = property ? getLabelFromProperty(item, property) : null;
+	let filteredGroups = [];
+	previousFilteredGroups.forEach((group) => {
+		if (group) {
+			const foundGroups = findNodesByIdAndLabel(group, id, label);
+			if (foundGroups.length) filteredGroups = filteredGroups.concat(foundGroups);
+		}
+	});
+	if (filteredGroups.length) if (node?.children?.length) node.children.forEach((child) => processItemForDynamicNodeGroups(displayTree, child, groupNodes, filteredGroups, isSingleGroup));
+	else filteredGroups.forEach((filteredGroup) => {
+		const matchingGroupNode = findNodeByIdAndLabel(filteredGroup, node.id, label);
+		if (matchingGroupNode) {
+			displayTree["parentGroupId"] = matchingGroupNode.id;
+			matchingGroupNode.children.push(displayTree);
+		}
+	});
+	else if (isSingleGroup) groupNodes.push(displayTree);
+	else previousFilteredGroups.forEach((filteredGroup) => {
+		if (filteredGroup) {
+			displayTree["parentGroupId"] = filteredGroup.id;
+			filteredGroup.children.push(displayTree);
+		}
+	});
+};
+const orderByGroupOrder = (groups = []) => {
+	return orderBy(groups, ["order"], ["asc"]);
+};
+const updateTreeIds = (node, lastEntityNodeId, newId = v4(), newParentId = v4(), parentGroupName = null) => {
+	let entityNodeParentId = lastEntityNodeId;
+	if (node) {
+		node.id = newId;
+		if (node.parentId || node.parentGroupId) {
+			node.parentId = newParentId;
+			node.parentGroupId = newParentId;
+		}
+		if (parentGroupName) node["parentGroupName"] = parentGroupName;
+		if (!node.isGroupNode && entityNodeParentId) node["entityNodeParentId"] = entityNodeParentId;
+		if (!node.isGroupNode) entityNodeParentId = node.id;
+	}
+	if (node?.children?.length) node.children.forEach((child) => updateTreeIds(child, entityNodeParentId, v4(), newId, parentGroupName));
+};
+const processGroupNodesAndAddToTreeList = (node, treeList, lastEntityNodeId, item, wasLazyLoaded) => {
+	let entityNodeParentId = lastEntityNodeId;
+	if (treeList) {
+		if (!treeList.find((tree) => tree.id === node.id)) {
+			if (!node.isGroupNode && entityNodeParentId) node["entityNodeParentId"] = entityNodeParentId;
+			if (!node.isGroupNode) entityNodeParentId = node.id;
+			!checkNodeIsHidden(node, item, wasLazyLoaded) && treeList.push(node);
+		}
+	}
+	if (node?.children?.length) node.children.forEach((child) => processGroupNodesAndAddToTreeList(child, treeList, entityNodeParentId, item, wasLazyLoaded));
+};
+const mapNodeGroupChildren = (nodeGroup, nodeGroupChildren = []) => {
+	nodeGroupChildren.forEach((node) => {
+		if (nodeGroup.id === node.parentGroupId) nodeGroup.children.push(node);
+	});
+	if (nodeGroup?.children?.length) nodeGroup.children.forEach((childGroup) => {
+		if (childGroup.isGroupNode) mapNodeGroupChildren(childGroup, nodeGroupChildren);
+	});
+	return nodeGroup;
+};
+const checkNodeIsHidden = (node, item, wasLazyLoaded = false) => {
+	if (!node || node && !Object.keys(node).length) return true;
+	let rule = null;
+	if (node.isGroupNode) {
+		if (node.properties?.hiddenNode?.enabled) {}
+	} else if (node.properties?.hiddenNode?.enabled) {
+		rule = mapRule(node.properties.hiddenNode.propertyMapping, node.properties.hiddenNode.jsonLogic);
+		if (rule && evaluateRule(rule, item, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded)) return true;
+	}
+	return false;
+};
+const constructPreloadedTree = (treeStructure, pageList, catalogObjects) => {
+	if (!pageList) return null;
+	let preloadedList = [];
+	const tree = cloneDeep(treeStructure);
+	if (tree.properties?.groupConfiguration?.enabled && tree.properties?.groupConfiguration.groupType === NodeGroupTypeEnums.Static && tree.properties?.groupConfiguration?.groupings?.static?.length) {
+		const topNodeGroups = constructStaticNodeGroups(tree);
+		const groupedItemIndexes = /* @__PURE__ */ new Set();
+		topNodeGroups.forEach((nodeGroup) => {
+			let nodeGroupChildren = [];
+			pageList.forEach((item, index) => {
+				const orderedKeys = [];
+				const orderedTreeData = [];
+				const treeArr = [];
+				const innerGroupList = [];
+				processCatalogObjectKeysInOrder(tree, orderedKeys);
+				processOrderedTreeData(tree, orderedTreeData);
+				processObjectToTree(item, orderedTreeData, orderedKeys, treeArr, catalogObjects, null, false, innerGroupList);
+				const processedItem = processItemForStaticNodeGroup(nodeGroup, item, groupedItemIndexes, makeTreeStructure(treeArr, "id", "parentId"), index, /* @__PURE__ */ new Set());
+				nodeGroupChildren = nodeGroupChildren.concat(processedItem?.nodeChildren || []);
+			});
+			const updatedNodeGroup = mapNodeGroupChildren(nodeGroup, nodeGroupChildren);
+			updatedNodeGroup.children.forEach((child) => {
+				updateTreeIds(child, null, v4(), updatedNodeGroup.id || v4(), updatedNodeGroup?.properties.label || null);
+			});
+			preloadedList.push(updatedNodeGroup);
+		});
+		if (tree.properties?.groupConfiguration?.outlier === NodeGroupOutlierEnums.Individual) pageList.forEach((item, index) => {
+			if (!groupedItemIndexes.has(index)) {
+				const orderedKeys = [];
+				const orderedTreeData = [];
+				const treeArr = [];
+				processCatalogObjectKeysInOrder(tree, orderedKeys);
+				processOrderedTreeData(tree, orderedTreeData);
+				processObjectToTree(item, orderedTreeData, orderedKeys, treeArr, null, null, false);
+				const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+				if (!checkNodeIsHidden(displayTree, item, false)) {
+					updateTreeIds(displayTree, null, v4(), v4(), null);
+					preloadedList.push(displayTree);
+				}
+			}
+		});
+	} else if (tree.properties?.groupConfiguration?.enabled && tree.properties?.groupConfiguration.groupType === NodeGroupTypeEnums.Dynamic && tree.properties?.groupConfiguration?.groupings?.dynamic?.length) {
+		const nodeGroups = constructDynamicNodeGroups2(pageList, tree);
+		preloadedList = preloadedList.concat(nodeGroups);
+	} else pageList.forEach((item) => {
+		const orderedKeys = [];
+		const orderedTreeData = [];
+		const treeArr = [];
+		processCatalogObjectKeysInOrder(tree, orderedKeys);
+		processOrderedTreeData(tree, orderedTreeData);
+		processObjectToTree(item, orderedTreeData, orderedKeys, treeArr);
+		const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+		!checkNodeIsHidden(displayTree, item, false) && preloadedList.push(displayTree);
+	});
+	return preloadedList;
+};
+const CompareGroupByOrder = (a, b) => {
+	if (a.order > b.order) return 1;
+	if (a.order < b.order) return -1;
+	return 0;
+};
+const CompareSiblingNodes = (a, b) => {
+	if (a.hasOwnProperty("isGroupNode") && !b.hasOwnProperty("isGroupNode")) return -1;
+	if (!a.hasOwnProperty("isGroupNode") && b.hasOwnProperty("isGroupNode")) return 1;
+	if (a.hasOwnProperty("isGroupNode") && b.hasOwnProperty("isGroupNode")) {
+		if (a.properties?.order > b.properties?.order) return 1;
+		if (a.properties?.order < b.properties?.order) return -1;
+	}
+	return 0;
+};
+const GetGroupChildMap = (_map, groupKey) => {
+	if (_map[groupKey] === void 0) _map[groupKey] = [];
+	return _map[groupKey];
+};
+const AddGroupToChildMap = (_map, groupKey, groupNode) => {
+	let childMap = GetGroupChildMap(_map, groupKey);
+	childMap.push(groupNode);
+	childMap.sort(CompareGroupByOrder);
+};
+const createDynamicGroups2 = (_treeConfig, _groupConfig, _item, _curItem, _pList, _siblings, _parentId) => {
+	let _groupCreated = false;
+	if (_pList.length > 0) {
+		let tmpProp = _pList[0];
+		if (_curItem.hasOwnProperty(tmpProp)) {
+			let newItem = _curItem[tmpProp];
+			if (_pList.length > 1) {
+				if (Array.isArray(newItem)) for (let i = 0, numOfItems = newItem.length; i < numOfItems; i++) {
+					let aGroupWasCreated = createDynamicGroups2(_treeConfig, _groupConfig, _item, newItem[i], _pList.slice(1), _siblings, _parentId);
+					_groupCreated = aGroupWasCreated ? aGroupWasCreated : _groupCreated;
+				}
+				else if (typeof newItem === "object" && newItem !== null) {
+					let aGroupWasCreated = createDynamicGroups2(_treeConfig, _groupConfig, _item, newItem, _pList.slice(1), _siblings, _parentId);
+					_groupCreated = aGroupWasCreated ? aGroupWasCreated : _groupCreated;
+				}
+			} else if (typeof newItem !== "object" && newItem !== null && newItem !== "") {
+				let groupName = newItem.toString();
+				let groupNode = null;
+				for (let siblingIdx = 0, numOfSiblings = _siblings.length; siblingIdx < numOfSiblings; siblingIdx++) {
+					let sibling = _siblings[siblingIdx];
+					if (sibling.hasOwnProperty("isGroupNode") && sibling.isGroupNode === true) {
+						if (sibling.properties.label === groupName) {
+							groupNode = sibling;
+							break;
+						}
+					}
+				}
+				if (groupNode == null) {
+					groupNode = new GroupNode({
+						id: `${v4()}`,
+						groupType: NodeGroupTypeEnums.Dynamic,
+						children: [],
+						parentGroupId: _parentId,
+						parentId: _parentId,
+						isExpanded: _groupConfig.isExpanded,
+						properties: {
+							label: groupName,
+							propertyIsCustom: _groupConfig.propertyIsCustom,
+							propertyKey: _groupConfig.property,
+							order: _groupConfig.order
+						}
+					});
+					_siblings.push(groupNode);
+				}
+				_groupCreated = true;
+				let subGroupWasCreated = false;
+				for (let subGroupIdx = 0, numOfSubGroups = _groupConfig.children.length; subGroupIdx < numOfSubGroups; subGroupIdx++) {
+					let subGroupConfig = _groupConfig.children[subGroupIdx];
+					let subGroupCreated = createDynamicGroups2(_treeConfig, subGroupConfig, _item, _item, subGroupConfig.property ? subGroupConfig.property.split(".") : [], groupNode.children, groupNode.id);
+					subGroupWasCreated = subGroupCreated ? subGroupCreated : subGroupWasCreated;
+				}
+				if (!subGroupWasCreated) {
+					let tmpNode = cloneDeep(_treeConfig);
+					processObjIndex(tmpNode, _item, null, groupNode.id, null, null, false);
+					groupNode.children.push(tmpNode);
+					let newChildNodes = [];
+					for (let childNodeIdx = 0, numOfChildNodes = tmpNode.children.length; childNodeIdx < numOfChildNodes; childNodeIdx++) {
+						let childConfigNode = tmpNode.children[childNodeIdx];
+						let propToGetRecords = childConfigNode.properties.catalogObjectKey;
+						if (propToGetRecords && propToGetRecords != null && _item.hasOwnProperty(propToGetRecords)) {
+							let newResultSet = _item[propToGetRecords];
+							if (newResultSet && newResultSet != null) if (Array.isArray(newResultSet)) newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+							else {
+								[].push(newResultSet);
+								newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+							}
+						}
+					}
+					tmpNode.children = newChildNodes;
+				}
+				groupNode.children.sort(CompareSiblingNodes);
+			}
+		}
+	}
+	return _groupCreated;
+};
+const constructDynamicGroupConfigTrees2 = (configNode) => {
+	let topLevelConfigGroupNodes = [];
+	const groupConfiguration = configNode?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Dynamic;
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) {
+		let dynamicGroupings = groupConfiguration.groupings[groupType];
+		for (let groupingIdx = 0, numOfGroupings = dynamicGroupings.length; groupingIdx < numOfGroupings; groupingIdx++) {
+			let grouping = dynamicGroupings[groupingIdx];
+			if (grouping.groups === void 0 || grouping.groups === null) continue;
+			let groupChildMap = {};
+			for (let groupIdx = 0, numOfGroups = grouping.groups.length; groupIdx < numOfGroups; groupIdx++) {
+				let group = grouping.groups[groupIdx];
+				group["children"] = GetGroupChildMap(groupChildMap, group.id);
+				if (group.parentGroupId === void 0 || group.parentGroupId === null) topLevelConfigGroupNodes.push(group);
+				else AddGroupToChildMap(groupChildMap, group.parentGroupId, group);
+			}
+		}
+	}
+	for (let configIdx = 0, numOfChildConfigNodes = configNode.children.length; configIdx < numOfChildConfigNodes; configIdx++) {
+		let childConfigNode = configNode.children[configIdx];
+		constructDynamicGroupConfigTrees2(childConfigNode);
+	}
+	configNode.groupConfigTrees = topLevelConfigGroupNodes;
+};
+const constructDynamicNodeGroups2 = (results, configNode, parentId = null) => {
+	let levelNodes = [];
+	if (!configNode.groupConfigTrees) constructDynamicGroupConfigTrees2(configNode);
+	for (let rIdx = 0, numOfResults = results.length; rIdx < numOfResults; rIdx++) {
+		let item = results[rIdx];
+		let groupCreated = false;
+		for (let ctlIdx = 0, numOfGroupConfigTrees = configNode.groupConfigTrees.length; ctlIdx < numOfGroupConfigTrees; ctlIdx++) {
+			let groupConfigNode = configNode.groupConfigTrees[ctlIdx];
+			let aGroupWasCreated = createDynamicGroups2(configNode, groupConfigNode, item, item, groupConfigNode.property ? groupConfigNode.property.split(".") : [], levelNodes, parentId);
+			groupCreated = aGroupWasCreated ? aGroupWasCreated : groupCreated;
+		}
+		if (!groupCreated) {
+			let tmpNode = cloneDeep(configNode);
+			processObjIndex(tmpNode, item, null, parentId, null, null, false);
+			levelNodes.push(tmpNode);
+			let newChildNodes = [];
+			for (let childNodeIdx = 0, numOfChildNodes = tmpNode.children.length; childNodeIdx < numOfChildNodes; childNodeIdx++) {
+				let childConfigNode = tmpNode.children[childNodeIdx];
+				let propToGetRecords = childConfigNode.properties.catalogObjectKey;
+				if (propToGetRecords && propToGetRecords != null && item.hasOwnProperty(propToGetRecords)) {
+					let newResultSet = item[propToGetRecords];
+					if (newResultSet && newResultSet != null) if (Array.isArray(newResultSet)) newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+					else {
+						[].push(newResultSet);
+						newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+					}
+				}
+			}
+			tmpNode.children = newChildNodes;
+		}
+	}
+	levelNodes.sort(CompareSiblingNodes);
+	return levelNodes;
+};
+const transformMenuPageTree = (node) => {
+	if (!node?.menuItemInstance?.isActive) return null;
+	const parameters = node.menuItemInstance?.parameters && JSON.parse(node.menuItemInstance.parameters);
+	const label = node.title || "";
+	const expanded = parameters?.defaultDisplay === "expanded";
+	const updatedNode = {
+		id: node.menuStructureId,
+		parentId: node.parentId,
+		isExpanded: expanded,
+		properties: {
+			defaultIcon: {
+				type: "",
+				name: parameters?.FluentIcon,
+				color: ""
+			},
+			nodeLabel: label,
+			nodeSubLabel: "",
+			itemCount: parameters?.itemCount ?? node.menuItemInstance?.itemCount ?? null,
+			page: {
+				id: parameters?.PageId,
+				entity: { entityName: parameters?.entityName },
+				pbiReportCode: parameters?.pbiReportCode,
+				udpTagId: parameters?.udpTagId,
+				queryId: parameters?.queryId,
+				inquiryTreeId: parameters?.InquiryTreeId,
+				requiredFieldMapping: parameters?.requiredFieldMapping
+			},
+			aggregateThresholdId: parameters?.aggregateThresholdId || ""
+		},
+		children: []
+	};
+	for (const child of node.menuItemInstanceStructures) {
+		const updatedChild = transformMenuPageTree(child);
+		if (updatedChild) updatedNode.children.push(updatedChild);
+	}
+	return updatedNode;
+};
+const mapNodeObjValuesToSearchParameters = (nodeObj, aggregateThresholdParamMappings) => {
+	if (!aggregateThresholdParamMappings || !nodeObj) return {};
+	const mappings = { ...aggregateThresholdParamMappings };
+	Object.keys(mappings).forEach((key) => {
+		const nodeObjKey = mappings[key];
+		if (nodeObjKey) mappings[key] = nodeObj[nodeObjKey] || "";
+	});
+	return mappings;
+};
+const getSearchValueString = (nodeObj, searchIdentifier) => {
+	const searchIdentifiers = searchIdentifier.split(",");
+	const searchValues = [];
+	searchIdentifiers.forEach((searchIdentifier$1) => {
+		searchValues.push(nodeObj[searchIdentifier$1]);
+	});
+	return searchValues.toString();
+};
+
+//#endregion
+export { makeTreeStructure as A, searchForMatchingNode as B, getLazyLoadChildrenArr as C, makeDynamicGroupStructures as D, getSearchValueString as E, processItemForStaticNodeGroup as F, transformMenuPageTree as H, processObjIndex as I, processObjectToTree as L, mapNodeObjValuesToSearchParameters as M, processCatalogObjectKeysInOrder as N, makeDynamicTreeStructure as O, processItemForDynamicNodeGroups as P, processOrderedTreeData as R, getIconFromName as S, getOrderedDynamicGroups as T, updateTreeIds as U, searchTree as V, formatTreeMenuItem as _, constructDynamicNodeGroups2 as a, getDisplayName as b, deleteNode as c, findAllParentIds as d, findLastNode as f, formatTreeLabel as g, findNodesByIdAndLabel as h, constructDynamicNodeGroups as i, mapNodeGroupChildren as j, makeTreeStaticGroupStructure as k, deleteNodeAndChildren as l, findNodeByIdAndLabel as m, collapseAllNodes as n, constructPreloadedTree as o, findNodeById as p, constructBusinessObjectArrFromTree as r, constructStaticNodeGroups as s, checkNodeIsHidden as t, expandAllNodes as u, getAllChildrenNodesToDelete as v, getNodeIdForRightBorder as w, getHeaderTitle as x, getDisplayDetails as y, processReferences as z };
+//# sourceMappingURL=TreeUtilities-jEhtZNg5.js.map