udp-react-enterprise-component-library 25.14.1-beta.8 → 25.16.0

package/dist/InquirySearchContainer-OBvUoZxU.js

@@ -1,837 +0,0 @@
-import { AgTable, useAgGridApi } from "./AgTable-BapmVuyC.js";
-import { Form as Form$1, FormButtons, SubmitButton } from "./FormButtons-Bstnb0d-.js";
-import { FluentButton } from "./FluentButton-h_8VjXGT.js";
-import { FluentTextFieldAutoComplete } from "./FluentTextFieldAutoComplete-BQvVv8m_.js";
-import { PropertyTypeEnum } from "./propertyTypeEnums-VqSmSIfe.js";
-import { camelToPascalCaseWithSpace } from "./StringUtilities-DyjYA5pU.js";
-import { FluentIconButton } from "./FluentIconButton-le92OnEc.js";
-import { getSanitizedName } from "./entityUtilities-D7_FeTEd.js";
-import { LogicalSearchOperatorEnums, LookupTypeEnums, SearchGroupingType, SearchSortDirection } from "./unitySystemEnums-BIMR5AWe.js";
-import { getSearchIdentifiers, getSearchObject } from "./SearchUtilities-CzmJ6hI2.js";
-import { PrimaryActionHeader } from "./PrimaryActionHeader-D9vn0zfH.js";
-import { AmbientCard } from "./AmbientCard-Cp-eNzrW.js";
-import { useExport, useGridFormat } from "./GridFunctions-B6oVb2o3.js";
-import { FilterOperators, SearchOperators } from "./SearchOperator-BLSwbmXG.js";
-import { useSearchFilterParamsMap } from "./useSearchFilterParamsMap-C2uVXRCY.js";
-import { PropertyField } from "./PropertyFields-BOhyMi0i.js";
-import { csvStrToArrayOfObjects } from "./SelectUtilities-BCLrDhpD.js";
-import React, { useCallback, useEffect, useMemo, useState } from "react";
-import { Divider, LinearProgress, Typography, makeStyles } from "@material-ui/core";
-import { useForm } from "react-final-form";
-import clsx from "clsx";
-import { ClearIcon } from "@fluentui/react-icons";
-import { orderBy, sortBy } from "lodash";
-import { v4 } from "uuid";
-import { ServerSideRowModelModule } from "@ag-grid-enterprise/server-side-row-model";
-
-//#region src/inquiry/search/InquiryAdvancedSearchForm.jsx
-const useStyles$3 = makeStyles((theme) => ({
-	root: {
-		marginRight: theme.spacing(1),
-		marginLeft: theme.spacing(1),
-		overflowX: "auto"
-	},
-	fieldRow: {
-		display: "flex",
-		alignItems: "center"
-	},
-	dividerContainer: {
-		display: "flex",
-		justifyContent: "space-between",
-		alignItems: "center",
-		width: "100%"
-	},
-	divider: {
-		width: "100%",
-		marginTop: theme.spacing(1)
-	},
-	autocompleteRoot: {
-		width: "38%",
-		marginRight: theme.spacing(1)
-	}
-}));
-const InquiryAdvancedSearchForm = (props) => {
-	const { advancedSearchFields, selectedSearchOperators, setSelectedSearchOperators, catalogProperties, entityType, lookupPropertyNames, classes: classProps, executeQueryWithParameters, setForm } = props;
-	const { root } = classProps || {};
-	const classes = useStyles$3();
-	const form = useForm();
-	const handleSearchOperatorChange = useCallback((value, fieldName) => {
-		if (fieldName) {
-			let updatedSelectedSearchOps = {};
-			if (selectedSearchOperators) updatedSelectedSearchOps = { ...selectedSearchOperators };
-			updatedSelectedSearchOps[fieldName] = value;
-			setSelectedSearchOperators(updatedSelectedSearchOps);
-		}
-	}, [selectedSearchOperators, setSelectedSearchOperators]);
-	const getPropertyWidgetType = (type, useLookup) => {
-		if (!type) return null;
-		let propertyWidgetType = "";
-		switch (type) {
-			case PropertyTypeEnum.Int:
-			case PropertyTypeEnum.Long:
-				propertyWidgetType = "IntegerWidget";
-				break;
-			case PropertyTypeEnum.DateTime:
-				propertyWidgetType = "DateTimeWidget";
-				break;
-			case PropertyTypeEnum.Boolean:
-				propertyWidgetType = "BooleanWidget";
-				break;
-			default: propertyWidgetType = "TextWidget";
-		}
-		if (useLookup === LookupTypeEnums.Api || useLookup === LookupTypeEnums.Csv) propertyWidgetType = "AutoCompleteWidget";
-		return propertyWidgetType;
-	};
-	const getPropertyTypeSearchOperators = useCallback((type) => {
-		if (!type) return [];
-		switch (type) {
-			case PropertyTypeEnum.Boolean: return SearchOperators.filter((operator) => operator.value === "=");
-			default: return SearchOperators;
-		}
-	}, []);
-	const fieldRows = useMemo(() => {
-		if (!advancedSearchFields || !catalogProperties) return [];
-		return Object.keys(advancedSearchFields).reduce((list, key) => {
-			const groupedItems = advancedSearchFields[key];
-			let groupHeader = "";
-			const foundGroupItem = groupedItems.find((item) => !!item.groupHeader);
-			if (foundGroupItem) groupHeader = foundGroupItem.groupHeader;
-			list.push({
-				groupHeader,
-				isDivider: true,
-				id: v4()
-			});
-			groupedItems.forEach(async (item) => {
-				const foundProperty = catalogProperties.find((property) => property.name === item.name);
-				const propertyWidgetType = getPropertyWidgetType(foundProperty?.type, foundProperty?.extendedProperties?.useLookup);
-				let apiLookupOptions = null;
-				if (!item.searchable && !foundProperty?.extendedProperties?.searchable) return;
-				if (lookupPropertyNames.includes(foundProperty?.name) && foundProperty?.extendedProperties?.useLookup === LookupTypeEnums.Api) {}
-				list.push({
-					...item,
-					isDivider: false,
-					type: foundProperty?.type,
-					propertyWidgetType,
-					useLookup: foundProperty?.extendedProperties?.useLookup,
-					lookup: foundProperty?.extendedProperties?.lookup,
-					apiLookupOptions
-				});
-			});
-			return list;
-		}, []);
-	}, [
-		advancedSearchFields,
-		catalogProperties,
-		lookupPropertyNames
-	]);
-	const getPropertyFields = useCallback((config) => {
-		const searchOperator = selectedSearchOperators ? selectedSearchOperators[config?.name]?.value : null;
-		let options = [];
-		if (config?.useLookup === LookupTypeEnums.Csv) options = csvStrToArrayOfObjects(config?.lookup);
-		if (searchOperator === "BETWEEN") return /* @__PURE__ */ React.createElement("div", { style: {
-			display: "block",
-			width: "100%"
-		} }, /* @__PURE__ */ React.createElement(PropertyField, {
-			propertyType: entityType,
-			property: {
-				key: config?.name,
-				label: `${config?.columnName} (From)`,
-				type: config?.propertyWidgetType,
-				options: options || [],
-				valueName: "value"
-			}
-		}), /* @__PURE__ */ React.createElement(PropertyField, {
-			propertyType: entityType,
-			property: {
-				key: `${config?.name}:between`,
-				label: `${config?.columnName} (To)`,
-				type: config?.propertyWidgetType,
-				options: options || [],
-				valueName: "value"
-			}
-		}));
-		return /* @__PURE__ */ React.createElement(PropertyField, {
-			propertyType: entityType,
-			property: {
-				key: config?.name,
-				label: config?.columnName,
-				type: config?.propertyWidgetType,
-				options: options || [],
-				valueName: "value"
-			}
-		});
-	}, [entityType, selectedSearchOperators]);
-	const fieldComponents = useMemo(() => {
-		if (!fieldRows || !fieldRows.length) return null;
-		return fieldRows.map((config) => {
-			return /* @__PURE__ */ React.createElement("div", { key: config?.id }, !config?.isDivider && /* @__PURE__ */ React.createElement("div", { className: classes.fieldRow }, /* @__PURE__ */ React.createElement(FluentTextFieldAutoComplete, {
-				id: "udpRecord-InquiryAdvancedSearchForm-Text",
-				udprecordid: "udpRecord-InquiryAdvancedSearchForm-Text",
-				label: "Operator",
-				name: "searchOperator",
-				variant: "outlined",
-				margin: "dense",
-				size: "small",
-				options: getPropertyTypeSearchOperators(config?.type) || [],
-				optionKey: "label",
-				value: selectedSearchOperators && selectedSearchOperators[config?.name] || "",
-				onChange: (value) => handleSearchOperatorChange(value, config?.name),
-				classes: { autocompleteRoot: classes.autocompleteRoot }
-			}), getPropertyFields(config)), config?.isDivider && /* @__PURE__ */ React.createElement("div", { className: classes.dividerContainer }, /* @__PURE__ */ React.createElement("div", { className: classes.divider }, /* @__PURE__ */ React.createElement(Divider, { orientation: "horizontal" })), config?.groupHeader && /* @__PURE__ */ React.createElement("div", { style: {
-				marginRight: 8,
-				marginLeft: 8,
-				textAlign: "center",
-				whiteSpace: "nowrap"
-			} }, /* @__PURE__ */ React.createElement(Typography, { variant: "caption" }, config?.groupHeader)), /* @__PURE__ */ React.createElement("div", { className: classes.divider }, /* @__PURE__ */ React.createElement(Divider, { orientation: "horizontal" }))));
-		});
-	}, [
-		fieldRows,
-		classes,
-		handleSearchOperatorChange,
-		selectedSearchOperators,
-		getPropertyTypeSearchOperators,
-		getPropertyFields
-	]);
-	useEffect(() => {
-		if (form) setForm(form);
-	}, [form, setForm]);
-	return /* @__PURE__ */ React.createElement("div", { className: clsx(classes.root, root) }, fieldComponents);
-};
-
-//#endregion
-//#region src/inquiry/search/InquiryAdvancedSearch.jsx
-const useStyles$2 = makeStyles((theme) => ({
-	root: {},
-	entitySelect: {
-		marginRight: theme.spacing(1),
-		marginLeft: theme.spacing(1)
-	},
-	fieldsRoot: { height: (props) => "calc(100vh - 288px)" },
-	title: {
-		display: "flex",
-		justifyContent: "space-between",
-		margin: theme.spacing(1)
-	},
-	buttonWrapper: { textAlign: "center" },
-	button: {
-		textTransform: "none",
-		padding: 0,
-		"&:hover": { backgroundColor: "rgba(0, 0, 0, 0)" },
-		color: theme.palette.secondary
-	}
-}));
-const InquiryAdvancedSearch = (props) => {
-	const { entityList, onSubmit, currentNodeCatalogReturnObject, catalogObjects, entityValue, setEntityValue, changeSideBarView, tree, executeQueryWithParameters } = props;
-	const classes = useStyles$2(props);
-	const [initialSelectedSearchOperators, setInitialSelectedSearchOperators] = useState(null);
-	const [selectedSearchOperators, setSelectedSearchOperators] = useState(null);
-	const [form, setForm] = useState(null);
-	const entityTree = useMemo(() => {
-		if (!entityValue || !tree) return null;
-		const matchingEntityTree = tree.treeStructure.find((node) => node.properties.catalogReturnObject === entityValue.value);
-		let nodeTree = tree;
-		if (matchingEntityTree?.properties?.associatedInquiryTree) nodeTree = matchingEntityTree?.properties?.associatedInquiryTree;
-		return nodeTree;
-	}, [tree, entityValue]);
-	const catalogProperties = useMemo(() => {
-		if (!entityValue || !catalogObjects) return [];
-		return catalogObjects.find((catalog) => catalog.catalogObjectName === entityValue.value)?.properties || [];
-	}, [catalogObjects, entityValue]);
-	const advancedSearchFields = useMemo(() => {
-		if (!entityTree) return null;
-		const advancedSearchConfiguration = entityTree.treeStructure.find((node) => !node.parentId)?.properties?.searchConfiguration?.filter((config) => config.advancedSearch);
-		advancedSearchConfiguration?.forEach((config) => config.advancedSearch = Number.parseFloat(config.advancedSearch));
-		const orderedSearchConfiguration = orderBy(advancedSearchConfiguration, ["advancedSearch"], ["asc"]);
-		const groupedAndOrderdFields = {};
-		orderedSearchConfiguration.forEach((config) => {
-			const wholeInt = Math.floor(config.advancedSearch);
-			if (!groupedAndOrderdFields[wholeInt]) groupedAndOrderdFields[wholeInt] = [config];
-			else groupedAndOrderdFields[wholeInt].push(config);
-		});
-		return groupedAndOrderdFields;
-	}, [entityTree]);
-	const asCatalogLookupPropertyNames = useMemo(() => {
-		if (!entityTree) return [];
-		const advancedSearchPropertyName = entityTree.treeStructure.find((node) => !node.parentId)?.properties?.searchConfiguration?.filter((config) => config.advancedSearch).map((asConfig) => asConfig.name);
-		const filteredProperties = catalogProperties.filter((property) => advancedSearchPropertyName?.includes(property.name));
-		const lookupPropertyNames = [];
-		filteredProperties.forEach((property) => {
-			if (property?.extendedProperties?.useLookup !== LookupTypeEnums.No_Lookup || !property?.extendedProperties?.useLookup) lookupPropertyNames.push(property.name);
-		});
-		return lookupPropertyNames;
-	}, [catalogProperties, entityTree]);
-	const handleEntityChange = (value) => {
-		setEntityValue(value);
-	};
-	const handleOnSubmit = useCallback((values) => {
-		if (onSubmit) onSubmit(values, selectedSearchOperators, entityValue?.value, asCatalogLookupPropertyNames);
-	}, [
-		onSubmit,
-		selectedSearchOperators,
-		entityValue,
-		asCatalogLookupPropertyNames
-	]);
-	const handleClearFilter = useCallback(() => {
-		if (form) form.reset();
-		setSelectedSearchOperators(initialSelectedSearchOperators);
-	}, [initialSelectedSearchOperators, form]);
-	useEffect(() => {
-		if (entityList?.length) {
-			const foundEntity = entityList.find((entity) => entity.value === currentNodeCatalogReturnObject);
-			if (foundEntity) setEntityValue(foundEntity);
-		}
-	}, [
-		entityList,
-		currentNodeCatalogReturnObject,
-		setEntityValue
-	]);
-	useEffect(() => {
-		if (advancedSearchFields) {
-			const initialSearchOperators = [].concat.apply([], Object.values(advancedSearchFields)).reduce((operators, field) => {
-				if (field.advancedSearchOperator) {
-					const foundOperator = SearchOperators.find((op) => op.value === field.advancedSearchOperator);
-					operators[field.name] = foundOperator ?? SearchOperators[0];
-				} else operators[field.name] = SearchOperators[0];
-				return operators;
-			}, {});
-			setInitialSelectedSearchOperators(initialSearchOperators);
-			setSelectedSearchOperators(initialSearchOperators);
-		}
-	}, [advancedSearchFields]);
-	return /* @__PURE__ */ React.createElement("div", { className: classes.root }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(Divider, null)), /* @__PURE__ */ React.createElement("div", { className: classes.title }, /* @__PURE__ */ React.createElement(Typography, { variant: "subtitle1" }, "Advanced Search"), /* @__PURE__ */ React.createElement(FluentIconButton, {
-		id: "udpRecord-InquiryAdvancedSearch-ClearIcon",
-		udprecordid: "udpRecord-InquiryAdvancedSearch-ClearIcon",
-		icon: ClearIcon,
-		onClick: () => changeSideBarView(0)
-	})), /* @__PURE__ */ React.createElement("div", { className: classes.entitySelect }, /* @__PURE__ */ React.createElement(FluentTextFieldAutoComplete, {
-		id: "udpRecord-InquiryAdvancedSearch-TextField",
-		udprecordid: "udpRecord-InquiryAdvancedSearch-TextField",
-		label: "Entity",
-		variant: "outlined",
-		margin: "normal",
-		size: "small",
-		fullWidth: true,
-		options: entityList,
-		optionKey: "label",
-		value: entityValue,
-		onChange: handleEntityChange
-	})), /* @__PURE__ */ React.createElement(Form$1, { onSubmit: handleOnSubmit }, /* @__PURE__ */ React.createElement(InquiryAdvancedSearchForm, {
-		advancedSearchFields,
-		selectedSearchOperators,
-		setSelectedSearchOperators,
-		catalogProperties,
-		entityType: getSanitizedName(entityValue?.value),
-		lookupPropertyNames: asCatalogLookupPropertyNames,
-		classes: { root: classes.fieldsRoot },
-		executeQueryWithParameters,
-		setForm
-	}), /* @__PURE__ */ React.createElement("div", { className: classes.submitWrapper }, /* @__PURE__ */ React.createElement("div", { className: classes.buttonWrapper }, /* @__PURE__ */ React.createElement(FluentButton, {
-		id: "udpRecord-InquiryAdvancedSearch-ClearFilter",
-		udprecordid: "udpRecord-InquiryAdvancedSearch-ClearFilter",
-		onClick: handleClearFilter,
-		className: classes.button
-	}, /* @__PURE__ */ React.createElement(Typography, { variant: "subtitle1" }, "Clear Filter")), /* @__PURE__ */ React.createElement(FormButtons, null, /* @__PURE__ */ React.createElement(SubmitButton, {
-		id: "udpRecord-InquiryAdvancedSearch-Search",
-		udprecordid: "udpRecord-InquiryAdvancedSearch-Search",
-		variant: "contained",
-		color: "primary",
-		disablePristine: false,
-		disabled: !entityValue,
-		fullWidth: true,
-		style: {
-			marginRight: 8,
-			marginLeft: 8
-		}
-	}, "Search"))))));
-};
-
-//#endregion
-//#region src/inquiry/search/InquirySearchDatasource.js
-const InquirySearchDatasource = (queryData, apiMethodId, searchFilterElements, logicalSearchOperator = LogicalSearchOperatorEnums.And, executeQuery, searchFilterGroups) => {
-	return { async getRows(params) {
-		const { startRow, endRow, rowGroupCols, groupKeys, valueCols, filterModel, sortModel } = params.request;
-		const page = endRow / 20;
-		const searchObject = getSearchObject(searchFilterElements, page, null, false, logicalSearchOperator, searchFilterGroups);
-		if (sortModel.length) {
-			const orderElements = searchObject.orderElements;
-			sortModel.forEach((sortItem) => {
-				const formattedPropertyName = sortItem.colId.charAt(0).toUpperCase() + sortItem.colId.slice(1);
-				const element = orderElements.find((element$1) => element$1.sortColumn === formattedPropertyName);
-				if (element) element.sortDirection = sortItem.sort.toUpperCase();
-				else orderElements.push({
-					sortColumn: formattedPropertyName,
-					sortDirection: sortItem.sort.toUpperCase()
-				});
-			});
-		}
-		if (Object.keys(filterModel).length) {
-			const filterElements = searchObject.filterElements;
-			Object.keys(filterModel).forEach((key) => {
-				const filterItem = filterModel[key];
-				const formattedPropertyName = key.charAt(0).toUpperCase() + key.slice(1);
-				const element = filterElements.find((element$1) => element$1.searchField === formattedPropertyName);
-				if (element) {
-					element.searchValue = filterItem.filter;
-					element.searchOperator = FilterOperators[filterItem.type];
-				} else filterElements.push({
-					searchField: formattedPropertyName,
-					searchValue: filterItem.filter,
-					searchOperator: FilterOperators[filterItem.type]
-				});
-			});
-		}
-		if (rowGroupCols.length && !groupKeys.length) {
-			const formattedPropertyName = rowGroupCols[0].field.charAt(0).toUpperCase() + rowGroupCols[0].field.slice(1);
-			searchObject.groupingType = SearchGroupingType.Distinct;
-			if (!searchObject.groupProperty.includes(formattedPropertyName)) {
-				searchObject.groupProperty.push(formattedPropertyName);
-				const orderElements = searchObject.orderElements;
-				if (!orderElements.find((element) => element.sortColumn === formattedPropertyName)) orderElements.push({
-					sortColumn: formattedPropertyName,
-					sortDirection: SearchSortDirection.Asc
-				});
-			}
-		}
-		if (groupKeys.length) if (groupKeys.length === rowGroupCols.length) {
-			searchObject.groupingType = "";
-			const filterElements = searchObject.filterElements;
-			groupKeys.forEach((key, index) => {
-				const rowGroupCol = rowGroupCols[index];
-				const formattedPropertyName = rowGroupCol.field.charAt(0).toUpperCase() + rowGroupCol.field.slice(1);
-				const element = filterElements.find((element$1) => element$1.searchField === formattedPropertyName);
-				if (element) {
-					element.searchValue = key;
-					element.searchOperator = "=";
-				} else filterElements.push({
-					searchField: formattedPropertyName,
-					searchValue: key,
-					searchOperator: "="
-				});
-			});
-		} else {
-			groupKeys.forEach((key, index) => {
-				const formattedPropertyNameForSearch = rowGroupCols[index].field.charAt(0).toUpperCase() + rowGroupCols[index].field.slice(1);
-				searchObject.filterElements.push({
-					searchField: formattedPropertyNameForSearch,
-					searchValue: key,
-					searchOperator: "="
-				});
-			});
-			searchObject.groupingType = SearchGroupingType.Distinct;
-			const searchIndex = groupKeys.length;
-			const rowGroupCol = rowGroupCols[searchIndex];
-			const formattedPropertyName = rowGroupCol.field.charAt(0).toUpperCase() + rowGroupCol.field.slice(1);
-			if (!searchObject.groupProperty.includes(formattedPropertyName)) {
-				searchObject.groupProperty.push(formattedPropertyName);
-				const orderElements = searchObject.orderElements;
-				if (!orderElements.find((element) => element.sortColumn === formattedPropertyName)) orderElements.push({
-					sortColumn: formattedPropertyName,
-					sortDirection: SearchSortDirection.Asc
-				});
-			}
-		}
-		if (!startRow && rowGroupCols.length === 0 && !sortModel.length && !Object.keys(filterModel).length && !groupKeys.length && queryData) if (queryData.pageList && queryData.pageList) params.successCallback(queryData.pageList, queryData.total);
-		else params.successCallback([], 0);
-		else {
-			let response = null;
-			if (executeQuery) response = await executeQuery({ data: searchObject }, apiMethodId);
-			const rowData = response?.data;
-			if (rowData) if (rowData?.pageList?.length > 0) params.successCallback(rowData.pageList, rowData.total);
-			else params.successCallback([], 0);
-			else params.successCallback([], 0);
-		}
-	} };
-};
-
-//#endregion
-//#region src/inquiry/search/InquirySearchTable.jsx
-const useStyles$1 = makeStyles((theme) => ({ root: { height: (props) => {
-	const rowCount = props?.queryData?.pageList?.length > 10 ? 10 : props?.queryData?.pageList?.length ?? 0;
-	const topResultsOnlyHeight = rowCount * 48 + 60;
-	const moreResultsHeight = rowCount * 48 + 116;
-	return props.topResultsOnly ? topResultsOnlyHeight : moreResultsHeight;
-} } }));
-const InquirySearchTable = (props) => {
-	const { apiMethodId, associatedInquiryTree, catalogReturnObject, catalogObjects, columns, executeQuery, queryColumnsData, isAdvancedSearch, onRowDoubleClick, queryData, searchFilterElements, searchFilterGroups, setSelectedSearchRows, treeStructure, topResultsOnly = false, topResultsSize = 50 } = props;
-	const classes = useStyles$1(props);
-	const { gridApi, onGridReady } = useAgGridApi();
-	const [agGridOptions] = useState({});
-	const [gridFormat] = useGridFormat();
-	const [exportGrid] = useExport();
-	const searchIdentifier = useMemo(() => {
-		return (getSearchIdentifiers(catalogObjects, catalogReturnObject) || []).toString();
-	}, [catalogObjects, catalogReturnObject]);
-	const columnDefs = useMemo(() => {
-		let commonCols = columns.map((column) => {
-			let matchingColumnIndex = null;
-			const matchingColumn = queryColumnsData.find((c, index) => {
-				if (c.name === column?.name) matchingColumnIndex = index;
-				return c.name === column?.name;
-			});
-			let def = {
-				headerName: column.alias || camelToPascalCaseWithSpace(column.name),
-				field: column.name
-			};
-			if (matchingColumn) def = {
-				headerName: matchingColumn.alias || camelToPascalCaseWithSpace(matchingColumn.name),
-				field: matchingColumn.name
-			};
-			if (column?.extendedProperties?.searchable) def = {
-				...def,
-				filter: "agTextColumnFilter",
-				filterParams: {
-					suppressAndOrCondition: true,
-					filterOptions: [
-						"equals",
-						"contains",
-						"notEqual",
-						"greaterThan",
-						"lessThan",
-						"greaterThanOrEqual",
-						"lessThanOrEqual"
-					]
-				},
-				enableRowGroup: true
-			};
-			if (column?.extendedProperties?.orderable) def = {
-				...def,
-				sortable: true
-			};
-			def.hide = !matchingColumn;
-			def.index = matchingColumnIndex;
-			return def;
-		});
-		const searchConfiguration = treeStructure.find((node) => node.properties?.catalogReturnObject === catalogReturnObject)?.properties?.searchConfiguration || null;
-		let requiresOrdering = false;
-		if (searchConfiguration) requiresOrdering = searchConfiguration.some((config) => !!config.results.trim());
-		if (requiresOrdering) {
-			const searchConfigWithResults = searchConfiguration.filter((config) => !!config.results);
-			commonCols.forEach((col) => {
-				col.index = null;
-				const foundSearchConfig = searchConfigWithResults.find((config) => config.name === col.field);
-				if (foundSearchConfig) col.index = parseFloat(foundSearchConfig.results);
-			});
-		}
-		commonCols = sortBy(commonCols, (col) => col.index);
-		return commonCols;
-	}, [
-		columns,
-		queryColumnsData,
-		treeStructure,
-		catalogReturnObject
-	]);
-	const defaultColDef = useMemo(() => ({
-		resizable: true,
-		editable: false,
-		enableValue: true,
-		allowedAggFuncs: [
-			"sum",
-			"min",
-			"max",
-			"count",
-			"avg",
-			"first",
-			"last"
-		]
-	}), []);
-	const rowData = useMemo(() => {
-		if (!queryData) return [];
-		return queryData?.pageList?.slice(0, topResultsSize);
-	}, [queryData, topResultsSize]);
-	const handleSelectionChanged = useCallback(() => {
-		const selectedRows = gridApi.getSelectedRows();
-		setSelectedSearchRows(catalogReturnObject, selectedRows, searchIdentifier, apiMethodId, treeStructure, associatedInquiryTree);
-	}, [
-		gridApi,
-		catalogReturnObject,
-		setSelectedSearchRows,
-		searchIdentifier,
-		apiMethodId,
-		treeStructure,
-		associatedInquiryTree
-	]);
-	const handleRowDoubleClicked = useCallback((event) => {
-		if (!gridApi) return;
-		if (onRowDoubleClick) onRowDoubleClick(event.node.data, catalogReturnObject);
-	}, [
-		gridApi,
-		onRowDoubleClick,
-		catalogReturnObject
-	]);
-	useEffect(() => {
-		if (!gridApi) return;
-		gridApi.sizeColumnsToFit();
-		let datasource = InquirySearchDatasource(queryData, apiMethodId, searchFilterElements, isAdvancedSearch ? LogicalSearchOperatorEnums.And : LogicalSearchOperatorEnums.Or, executeQuery, searchFilterGroups);
-		gridApi?.setServerSideDatasource(datasource);
-	}, [
-		gridApi,
-		apiMethodId,
-		searchFilterElements,
-		queryData,
-		isAdvancedSearch,
-		executeQuery,
-		searchFilterGroups
-	]);
-	return /* @__PURE__ */ React.createElement("div", null, !topResultsOnly && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(PrimaryActionHeader, {
-		hidePAB: true,
-		hideActionRow: true,
-		expandAllItems: () => gridFormat(gridApi, "expand"),
-		collapse: () => gridFormat(gridApi, "collapse"),
-		resizeGrid: () => gridFormat(gridApi, "resize"),
-		exportGrid: () => exportGrid(gridApi, "csv"),
-		grid: true
-	}), /* @__PURE__ */ React.createElement(AgTable, {
-		className: classes.root,
-		modules: [ServerSideRowModelModule],
-		rowModelType: "serverSide",
-		serverSideStoreType: "partial",
-		pagination: true,
-		paginationPageSize: 20,
-		cacheOverflowSize: 2,
-		maxConcurrentDatasourceRequests: 1,
-		cacheBlockSize: 20,
-		onGridReady,
-		columnDefs,
-		defaultColDef,
-		onRowDoubleClicked: handleRowDoubleClicked,
-		rowSelection: "multiple",
-		rowMultiSelectWithClick: true,
-		onSelectionChanged: handleSelectionChanged,
-		api: gridApi,
-		dynamicSizing: true,
-		...agGridOptions
-	})), topResultsOnly && /* @__PURE__ */ React.createElement(AgTable, {
-		className: classes.root,
-		rowData: rowData || [],
-		onGridReady,
-		columnDefs,
-		defaultColDef,
-		onRowDoubleClicked: handleRowDoubleClicked,
-		rowSelection: "multiple",
-		rowMultiSelectWithClick: true,
-		onSelectionChanged: handleSelectionChanged,
-		animateRows: true,
-		api: gridApi,
-		dynamicSizing: true,
-		...agGridOptions
-	}));
-};
-
-//#endregion
-//#region src/inquiry/search/InquirySearchContainer.jsx
-const useStyles = makeStyles((theme) => ({
-	root: { overflowX: "auto" },
-	searchCard: { paddingBottom: theme.spacing(2) },
-	emptyStateWrapper: {
-		display: "flex",
-		justifyContent: "center",
-		paddingTop: "25vh"
-	}
-}));
-const InquirySearchContainer = (props) => {
-	const { advancedSearchItems, catalogObjects, classes: classProps, executeQueryAdHoc, isAdvancedSearch, loadSingleNode, onRowDoubleClick, searchItems, setSelectedSearchRows, apiMethodInstanceId } = props;
-	const { root } = classProps || {};
-	const classes = useStyles();
-	const [searchList, setSearchList] = useState(null);
-	const [loading, setLoading] = useState(false);
-	const { getQueryFilterElements, getQueryFilterGroups, getQuerySearchOperator } = useSearchFilterParamsMap();
-	const getQueryColumnsData = useCallback((apiMethodInstance) => {
-		if (!apiMethodInstance) return [];
-		let catalogMods = [];
-		try {
-			const catalogModificationStr = apiMethodInstance.catalogModification;
-			catalogMods = JSON.parse(catalogModificationStr);
-		} catch {
-			console.warn("Error parsing apiMethodInstance catalogModification");
-		}
-		return catalogMods;
-	}, []);
-	useEffect(() => {
-		if (!catalogObjects) setLoading(true);
-		if (!searchItems || !catalogObjects?.length) return;
-		setLoading(true);
-		const promises = [];
-		let list = [];
-		const promiseIndexMap = {};
-		(!isAdvancedSearch ? searchItems : advancedSearchItems || []).forEach((item, index) => {
-			let filterElementsFromQuery = getQueryFilterElements(item.apiMethodInstance);
-			let filterGroups = getQueryFilterGroups(item.apiMethodInstance);
-			const logicalOperatorFromQuery = getQuerySearchOperator(item.apiMethodInstance);
-			item.queryColumnsData = getQueryColumnsData(item.apiMethodInstance);
-			let outerQueryGroupId = 0;
-			let queryOuterGroup = null;
-			if (!!filterElementsFromQuery.length) {
-				outerQueryGroupId = filterGroups.length + 1;
-				queryOuterGroup = {
-					groupId: outerQueryGroupId,
-					logicalSearchOperator: logicalOperatorFromQuery
-				};
-			}
-			let outerTreeBuilderGroupId = 0;
-			let inquiryOuterGroup = null;
-			if (!!item?.searchFilterElements?.length) {
-				outerTreeBuilderGroupId = outerQueryGroupId + 1;
-				inquiryOuterGroup = {
-					groupId: outerTreeBuilderGroupId,
-					logicalSearchOperator: isAdvancedSearch ? LogicalSearchOperatorEnums.And : LogicalSearchOperatorEnums.Or
-				};
-			}
-			filterGroups = filterGroups.map((group) => {
-				if (!group.parentGroupId) group.parentGroupId = outerQueryGroupId;
-				return group;
-			});
-			filterElementsFromQuery = filterElementsFromQuery.map((element) => {
-				if (!element.groupId) element.groupId = outerQueryGroupId;
-				return element;
-			});
-			item.searchFilterElements = item.searchFilterElements.map((element) => {
-				element.groupId = outerTreeBuilderGroupId;
-				return element;
-			});
-			const searchFilterElements = filterElementsFromQuery.concat(item.searchFilterElements || []);
-			item.searchFilterElements = searchFilterElements;
-			if (!!inquiryOuterGroup) filterGroups.push(inquiryOuterGroup);
-			if (!!queryOuterGroup) filterGroups.push(queryOuterGroup);
-			item.searchFilterGroups = filterGroups;
-			const searchObject = getSearchObject(searchFilterElements, 1, null, false, LogicalSearchOperatorEnums.And, filterGroups);
-			let shouldSearch = true;
-			if (!searchFilterElements.some((sfe) => sfe.searchOperator !== "=")) {
-				const equalsSearchFilterElements = searchFilterElements.filter((sfe) => sfe.searchOperator === "=");
-				if (!!equalsSearchFilterElements.length) {
-					const coProperties = catalogObjects.find((co) => co.catalogObjectName === item.catalogReturnObject)?.properties || [];
-					if (!!coProperties.length) equalsSearchFilterElements.forEach((esfe) => {
-						if (!shouldSearch) return;
-						const matchingProperty = coProperties.find((cop) => cop.name?.toLowerCase() === esfe.searchField?.toLowerCase());
-						if (matchingProperty?.type) {
-							let compareNumber = true;
-							let parsedValue = esfe.searchValue;
-							switch (matchingProperty.type) {
-								case "int":
-									if (/[^0-9]/.test(esfe.searchValue)) parsedValue = NaN;
-									else parsedValue = parseInt(esfe.searchValue);
-									break;
-								case "double":
-								case "decimal":
-								case "float":
-									if (/[^0-9.]/.test(esfe.searchValue)) parsedValue = NaN;
-									else parsedValue = parseFloat(esfe.searchValue);
-									break;
-								default:
-									compareNumber = false;
-									break;
-							}
-							if (compareNumber && isNaN(parsedValue)) shouldSearch = false;
-						}
-					});
-				}
-			}
-			if (shouldSearch && executeQueryAdHoc) {
-				const data = { data: searchObject };
-				promiseIndexMap[promises.length] = index;
-				promises.push(executeQueryAdHoc(data, item.apiMethodId));
-			}
-			list.push({
-				queryData: null,
-				searchItem: item
-			});
-		});
-		Promise.all(promises.map((p) => p.catch((e) => e))).then((responses) => {
-			responses.forEach((response, i) => {
-				const index = promiseIndexMap[i];
-				if (response.status === 200) {
-					const querySearchObj = list[index];
-					querySearchObj.queryData = response.data;
-				} else if (!response.status) {
-					const querySearchObj = list[index];
-					console.error(`Retrieval Error Occured for ${querySearchObj?.searchItem?.catalogReturnObject}`);
-				}
-			});
-			let matchingItem = list.find((item) => item?.searchItem?.apiMethodInstance?.apiMethodInstanceId === apiMethodInstanceId && item?.queryData?.pageList?.length === 1);
-			if (!matchingItem) matchingItem = list.find((item) => item?.queryData?.pageList?.length === 1);
-			if (matchingItem) {
-				const querySearchObj = matchingItem;
-				const node = {};
-				const searchItem = querySearchObj?.searchItem;
-				const identifiers = getSearchIdentifiers(catalogObjects, searchItem.catalogReturnObject) || [];
-				node[searchItem.catalogReturnObject] = {
-					rows: matchingItem?.queryData?.pageList,
-					apiMethodId: searchItem.apiMethodId,
-					searchIdentifier: identifiers.toString(),
-					treeStructure: searchItem.treeStructure
-				};
-				loadSingleNode(node);
-			}
-			setSearchList(list);
-			setLoading(false);
-		});
-	}, [
-		searchItems,
-		isAdvancedSearch,
-		advancedSearchItems,
-		loadSingleNode,
-		catalogObjects,
-		executeQueryAdHoc,
-		getQueryFilterElements,
-		getQueryColumnsData,
-		getQueryFilterGroups,
-		getQuerySearchOperator,
-		apiMethodInstanceId
-	]);
-	return /* @__PURE__ */ React.createElement("div", { className: clsx(classes.root, root) }, loading && /* @__PURE__ */ React.createElement(LinearProgress, null), searchList?.map((searchObj) => {
-		return /* @__PURE__ */ React.createElement("div", {
-			key: searchObj.searchItem.catalogReturnObject,
-			className: classes.searchCard
-		}, /* @__PURE__ */ React.createElement(AmbientCard, {
-			key: `${searchObj.searchItem.catalogReturnObject}-${searchObj?.queryData?.total}`,
-			title: `${getSanitizedName(searchObj.searchItem.catalogReturnObject)} - ${searchObj.error ? searchObj.error : searchObj?.queryData?.total || "0"}`,
-			moreMessage: "Top 10 results...",
-			moreButton: "Load More",
-			moreButtonExpanded: "Minimize",
-			more: !!searchObj?.queryData?.pageList?.length,
-			header: true,
-			fullWidth: true,
-			globalToggle: true,
-			collapseChildrenWhenExpanded: true,
-			toggleGlobalExpanded: !!searchObj?.queryData?.total,
-			extendedList: /* @__PURE__ */ React.createElement(InquirySearchTable, {
-				key: searchObj.searchItem.id,
-				queryData: searchObj.queryData || [],
-				columns: searchObj.searchItem.columns,
-				apiMethodId: searchObj.searchItem.apiMethodId,
-				searchFilterElements: searchObj.searchItem.searchFilterElements,
-				searchFilterGroups: searchObj.searchItem.searchFilterGroups,
-				catalogReturnObject: searchObj.searchItem.catalogReturnObject,
-				setSelectedSearchRows,
-				catalogObjects,
-				treeStructure: searchObj.searchItem.treeStructure,
-				associatedInquiryTree: searchObj.searchItem.associatedInquiryTree || null,
-				onRowDoubleClick,
-				isAdvancedSearch,
-				executeQuery: executeQueryAdHoc,
-				queryColumnsData: searchObj.searchItem.queryColumnsData
-			})
-		}, !!searchObj?.queryData?.pageList?.length && /* @__PURE__ */ React.createElement(InquirySearchTable, {
-			key: searchObj.searchItem.id,
-			queryData: searchObj.queryData || [],
-			columns: searchObj.searchItem.columns,
-			apiMethodId: searchObj.searchItem.apiMethodId,
-			searchFilterElements: searchObj.searchItem.searchFilterElements,
-			searchFilterGroups: searchObj.searchItem.searchFilterGroups,
-			catalogReturnObject: searchObj.searchItem.catalogReturnObject,
-			setSelectedSearchRows,
-			catalogObjects,
-			treeStructure: searchObj.searchItem.treeStructure,
-			associatedInquiryTree: searchObj.searchItem.associatedInquiryTree || null,
-			onRowDoubleClick,
-			topResultsOnly: true,
-			topResultsSize: 10,
-			isAdvancedSearch,
-			executeQuery: executeQueryAdHoc,
-			queryColumnsData: searchObj.searchItem.queryColumnsData
-		})));
-	}));
-};
-
-//#endregion
-export { InquiryAdvancedSearch, InquiryAdvancedSearchForm, InquirySearchContainer, InquirySearchDatasource, InquirySearchTable };
-//# sourceMappingURL=InquirySearchContainer-OBvUoZxU.js.map