udp-react-enterprise-component-library 25.18.1-beta.1 → 25.18.1-beta.10

package/dist/ActionWrapper-47uvDDnB.js

@@ -0,0 +1,891 @@
+import { t as Form } from "./Form-DbOA5j38.js";
+import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
+import { n as SubmitButton, t as FormButtons } from "./FormButtons-BTCO-pzW.js";
+import { a as getPrimaryKeyValues, r as getPathObject } from "./CrudBrowserUtilities-C9nVmUR3.js";
+import { t as ConfigService } from "./configService-C4uoG3wj.js";
+import { t as useUser } from "./useUser-wpHGo6jU.js";
+import { t as apiMutate } from "./useAxiosMutate-q_ZpG98Z.js";
+import { i as toLowerFirstChar } from "./StringUtilities-u-cxAW6-.js";
+import { r as getSanitizedName } from "./entityUtilities-_8w-Zjs3.js";
+import { t as useCrudActions } from "./crudActions-Bl1NmJtO.js";
+import { b as PanelPositionEnums, g as NodeActionEnums, n as CardinalityTypeEnums } from "./unitySystemEnums-DQSkCr3D.js";
+import { t as ActionSummaryPopover } from "./actionSummary-BOSgduAE.js";
+import { t as UnityFluentIcon } from "./UnityFluentIcon-DrASIcTF.js";
+import { n as getSuccessAction } from "./actionUtils-99XIoiDI.js";
+import { r as useActionStore } from "./inquiryStore-BMYKf5MP.js";
+import { n as useShellStore } from "./shellStore-C8zfPsZ-.js";
+import { n as useActions } from "./useActions-CBGNxEKr.js";
+import { i as mapRule, t as evaluateRule } from "./RuleUtilities-D5ACzikQ.js";
+import { t as PrimaryActionButton } from "./PrimaryActionButton-Dk8zvDAW.js";
+import { r as getSearchObject } from "./SearchUtilities-Df1gkDw9.js";
+import { S as getIconFromName } from "./TreeUtilities-C6e2dd4g.js";
+import { t as getUnityIconFromName } from "./UnityIconLibrary-CjIwzfjv.js";
+import { t as PAHAdditionalRightComponent } from "./PAHAdditionalRightComponent-DMOU9Mho.js";
+import { t as SiteHeaderRightComponent } from "./SiteHeaderRightComponent-BwFUg3ur.js";
+import { n as ToolBarButton } from "./AmbientPopoverMenuItem-BZuX43zJ.js";
+import { t as LayoutUnit } from "./LayoutUnit-D4jJvonh.js";
+import { n as SideSheet } from "./SideSheet-C-rILQqR.js";
+import { t as useAxiosGet } from "./useAxiosGet-BMoXHfLN.js";
+import { t as PageContainer } from "./PageContainer-BgNeJt3S.js";
+import { t as executeQueryAdHoc } from "./methodUtils-DEk9B4A8.js";
+import { t as ActionSplitScreen } from "./ActionSplitScreen-KVa5olgd.js";
+import { t as usePromotedMethodEntity } from "./usePromotedMethodEntity-wRBkHT3x.js";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { Dialog, DialogActions, DialogContent, DialogContentText, DialogTitle, Typography, makeStyles } from "@material-ui/core";
+import { useSnackbar } from "notistack";
+import PropTypes from "prop-types";
+import { cloneDeep } from "lodash";
+import { useTranslation } from "react-i18next";
+import SpeedDial from "@material-ui/lab/SpeedDial";
+import SpeedDialIcon from "@material-ui/lab/SpeedDialIcon";
+import SpeedDialAction from "@material-ui/lab/SpeedDialAction";
+import AddIcon from "@material-ui/icons/esm/Add";
+import { makeStyles as makeStyles$1 } from "@material-ui/core/styles";
+import { Skeleton } from "@material-ui/lab";
+import { DndProvider } from "react-dnd";
+import { HTML5Backend } from "react-dnd-html5-backend";
+
+//#region src/actions/ActionForm.jsx
+const useStyles$5 = makeStyles((theme) => ({
+	root: { marginTop: theme.spacing(-2) },
+	body: { marginTop: theme.spacing(2) },
+	actions: {
+		marginTop: theme.spacing(2),
+		marginBottom: theme.spacing(2),
+		display: "flex",
+		flexDirection: "row"
+	},
+	title: { flexGrow: 1 },
+	divider: { marginTop: theme.spacing(2) },
+	subject: {
+		marginLeft: theme.spacing(1),
+		display: "flex",
+		flexDirection: "row",
+		flexGrow: 1
+	},
+	switchRoot: { marginLeft: theme.spacing(1) },
+	input: {
+		height: 34,
+		padding: 0
+	},
+	formTextInput: { fontSize: 13 },
+	labelRoot: { fontSize: 13 }
+}));
+const ActionForm = (props) => {
+	const { entityAttributes, foreignKeyData, onCreate, closeSideSheet, onUpdate, crudTableEditionData, crudTableFormData, udpFieldInfos } = props;
+	const classes = useStyles$5();
+	const { renderInputByFieldType } = useCrudActions();
+	const primaryKeyValues = useMemo(() => getPrimaryKeyValues(entityAttributes, crudTableEditionData), [entityAttributes, crudTableEditionData]);
+	const manyToManyPropertyList = useMemo(() => {
+		if (!entityAttributes?.length) return [];
+		const mtmPropertyList = /* @__PURE__ */ new Set();
+		entityAttributes.forEach((attr) => {
+			if (attr?.extendedProperties?.childEntity) Object.keys(attr.extendedProperties.childEntityAssoc || {}).length && attr.extendedProperties.childEntityAssoc.Cardinality === CardinalityTypeEnums.Many_To_Many && attr.extendedProperties.childEntityAssoc.Keys.forEach((value, i) => {
+				const name = value.split(",")[0];
+				if (name) mtmPropertyList.add(name.toLowerCase());
+			});
+		});
+		return mtmPropertyList;
+	}, [entityAttributes]);
+	const handleSubmit = async (values) => {
+		let newTableData = {
+			...crudTableFormData,
+			...values
+		};
+		entityAttributes.filter((ea) => ea?.extendedProperties?.identifier).forEach((ea) => {
+			delete newTableData[ea.name];
+		});
+		foreignKeyData.forEach((fkd) => {
+			Object.keys(newTableData).forEach((key) => {
+				if (key === fkd.fieldName) newTableData[key] = fkd.data.find((d) => d.id === newTableData[key].id)?.id;
+			});
+		});
+		if (!crudTableEditionData) onCreate && await onCreate(newTableData);
+		else onUpdate && await onUpdate(newTableData, primaryKeyValues);
+		closeSideSheet && closeSideSheet();
+	};
+	const isNewEntry = useMemo(() => !crudTableEditionData, [crudTableEditionData]);
+	return /* @__PURE__ */ React.createElement(Form, { onSubmit: handleSubmit }, /* @__PURE__ */ React.createElement("div", null, entityAttributes?.map((schemaAttribute, index) => {
+		const fieldInfo = udpFieldInfos?.find((fi) => fi?.name.toLowerCase() === schemaAttribute?.name?.toLowerCase());
+		if (fieldInfo?.isPrimaryKey && !isNewEntry) schemaAttribute.disabled = true;
+		if (fieldInfo?.isPrimaryKey && isNewEntry && !fieldInfo?.isIdentity) schemaAttribute.disabled = false;
+		return !schemaAttribute?.extendedProperties?.identifier && /* @__PURE__ */ React.createElement(React.Fragment, { key: `${schemaAttribute.name}-${index}` }, /* @__PURE__ */ React.createElement(Typography, {
+			variant: "subtitle2",
+			style: { marginTop: 8 }
+		}, schemaAttribute.friendlyName), renderInputByFieldType(schemaAttribute, index, entityAttributes, fieldInfo, foreignKeyData, null, crudTableFormData, classes, false, null, manyToManyPropertyList));
+	})), /* @__PURE__ */ React.createElement(FormButtons, null, /* @__PURE__ */ React.createElement(SubmitButton, {
+		variant: "contained",
+		color: "secondary",
+		disablePristine: false,
+		disabled: false,
+		style: { marginTop: 15 }
+	}, "Save")));
+};
+ActionForm.propTypes = {
+	entityAttributes: PropTypes.array,
+	foreignKeyData: PropTypes.array,
+	crudTableEditionData: PropTypes.array,
+	closeSideSheet: PropTypes.func,
+	onCreate: PropTypes.func,
+	onUpdate: PropTypes.func
+};
+
+//#endregion
+//#region src/actions/ActionModal.jsx
+const useStyles$4 = makeStyles((theme) => ({}));
+const ActionModal = (props) => {
+	const { open, action, title, message = "Are you sure you want to delete this row?", confirmAction = () => {}, handleOnClose } = props;
+	useStyles$4();
+	return /* @__PURE__ */ React.createElement(Dialog, {
+		open,
+		onClose: handleOnClose,
+		"aria-labelledby": "alert-dialog-title",
+		"aria-describedby": "alert-dialog-description"
+	}, /* @__PURE__ */ React.createElement(DialogTitle, { id: "alert-dialog-title" }, title), /* @__PURE__ */ React.createElement(DialogContent, null, /* @__PURE__ */ React.createElement(DialogContentText, { id: "alert-dialog-description" }, message)), /* @__PURE__ */ React.createElement(DialogActions, null, /* @__PURE__ */ React.createElement(FluentButton, {
+		onClick: handleOnClose,
+		color: "secondary",
+		variant: "contained"
+	}, "Cancel"), /* @__PURE__ */ React.createElement(FluentButton, {
+		onClick: action,
+		onMouseUp: () => {
+			confirmAction();
+			handleOnClose();
+		},
+		autoFocus: true,
+		variant: "outlined"
+	}, "Confirm")));
+};
+
+//#endregion
+//#region src/actions/ActionSpeedDial.tsx
+const useStyles$3 = makeStyles$1((theme) => {
+	return {
+		wrapper: {
+			position: "fixed",
+			right: theme.spacing(0),
+			bottom: theme.spacing(0),
+			zIndex: 1200
+		},
+		speedDial: {
+			position: "absolute",
+			"&.MuiSpeedDial-directionUp, &.MuiSpeedDial-directionLeft": {
+				bottom: theme.spacing(2),
+				right: theme.spacing(2)
+			}
+		},
+		speedDialFab: {
+			backgroundColor: "black",
+			borderRadius: 1,
+			margin: 0,
+			opacity: .75,
+			"&:hover": { backgroundColor: "black" },
+			"&:focus": { backgroundColor: "black" }
+		},
+		speadDialFabExpanded: {
+			backgroundColor: "black",
+			borderRadius: 1,
+			margin: 0,
+			"&:hover": { backgroundColor: "black" },
+			"&:focus": { backgroundColor: "black" }
+		},
+		speedDialActions: {
+			"&.MuiSpeedDial-directionUp, &.MuiSpeedDial-actions": {
+				paddingBottom: 0,
+				marginBottom: 0,
+				opacity: .75
+			},
+			"&:hover": { opacity: 1 },
+			"&:focus": { opacity: 1 }
+		},
+		speedDialActionFab: {
+			backgroundColor: "black",
+			borderRadius: 1,
+			margin: 0,
+			color: "white",
+			width: 56,
+			height: 56
+		}
+	};
+});
+const ActionSpeedDial = (props) => {
+	const [expanded, setExpanded] = useState(false);
+	const classes = useStyles$3(expanded);
+	const { open, ariaLabel, actions, ...otherProps } = props;
+	if (!actions.length) return null;
+	return /* @__PURE__ */ React.createElement("div", { className: classes.wrapper }, /* @__PURE__ */ React.createElement(SpeedDial, {
+		id: "udpRecord-ActionSpeedDial",
+		udprecordid: "udpRecord-ActionSpeedDial",
+		className: classes.speedDial,
+		ariaLabel: "Fluent Speed Dial",
+		classes: {
+			fab: expanded ? classes.speadDialFabExpanded : classes.speedDialFab,
+			actions: classes.speedDialActions
+		},
+		icon: /* @__PURE__ */ React.createElement(SpeedDialIcon, { icon: /* @__PURE__ */ React.createElement(AddIcon, null) }),
+		onClose: () => setExpanded(false),
+		onOpen: () => setExpanded(true),
+		open: expanded,
+		...otherProps
+	}, actions.map((action) => /* @__PURE__ */ React.createElement(SpeedDialAction, {
+		id: "udpRecord-ActionSpeedDial-" + action.name,
+		udprecordid: "udpRecord-ActionSpeedDial-" + action.name,
+		key: action.name,
+		icon: /* @__PURE__ */ React.createElement(UnityFluentIcon, {
+			type: action.icon.type,
+			icon: action.icon.type === "unity" ? getUnityIconFromName(action.icon.name) : getIconFromName(action.icon.name)
+		}),
+		open: false,
+		onClick: (e) => action.onClick(e),
+		classes: { fab: classes.speedDialActionFab },
+		tooltipTitle: action.name
+	}))));
+};
+
+//#endregion
+//#region src/actions/ActionPanelPlacement.jsx
+const useStyles$2 = makeStyles((theme) => ({
+	root: {},
+	actionsMenu: { color: theme?.palette?.getContrastText(theme?.palette?.primary?.main) },
+	additionalRightComponent: {
+		display: "flex",
+		alignItems: "center"
+	}
+}));
+const ActionPanelPlacement = (props) => {
+	const { actionPanels, showInquiryHeaderActions, selectedNode, globalActions } = props;
+	const classes = useStyles$2();
+	const { triggerAction } = useActions();
+	const hideActions = useActionStore((state) => state.hideActions);
+	const handleTriggerAction = useCallback((actionId) => {
+		triggerAction(actionId, selectedNode?.nodeObj);
+	}, [triggerAction, selectedNode]);
+	const panelsMap = useMemo(() => {
+		if (!actionPanels || !actionPanels?.length) return {};
+		return actionPanels.reduce((panelsObj, panel) => {
+			const panelPositionId = panel?.panelPositionId;
+			panelsObj[panelPositionId] = panel?.panelActions;
+			return panelsObj;
+		}, {});
+	}, [actionPanels]);
+	const siteHeaderRightComponent = useMemo(() => {
+		const siteHeaderActions = panelsMap[PanelPositionEnums.Site_Header];
+		const siteHeaderSummaryActions = panelsMap[PanelPositionEnums.Site_Header_Summary];
+		let siteHeaderActionsComponent1 = null;
+		let siteHeaderActionsComponent2 = null;
+		let siteHeaderSummaryComponent = null;
+		if (siteHeaderActions?.length) siteHeaderActionsComponent1 = siteHeaderActions.map((panelAction) => {
+			const passRule = panelAction.action.actionRules?.reduce((boolValue, rule) => {
+				const ruleExpression = mapRule(rule.mapping, rule.jsonLogic);
+				return boolValue && evaluateRule(ruleExpression, selectedNode?.nodeObj, selectedNode?.properties?.joiningEntityCatalogObjectKey, selectedNode?.wasLazyLoaded);
+			}, true) ?? true;
+			if (!passRule && panelAction?.hideAction) return null;
+			return /* @__PURE__ */ React.createElement(ToolBarButton, {
+				key: panelAction?.actionId,
+				label: panelAction?.action?.name,
+				aria: panelAction?.action?.name,
+				icon: false,
+				component: panelAction?.icon?.type === "unity" ? getUnityIconFromName(panelAction?.icon?.name) : getIconFromName(panelAction?.icon?.name),
+				click: () => handleTriggerAction(panelAction?.actionId),
+				disabled: !passRule
+			});
+		});
+		if (siteHeaderSummaryActions?.length) if (!siteHeaderActions?.length && siteHeaderSummaryActions?.length <= 2) siteHeaderActionsComponent2 = siteHeaderSummaryActions.map((panelAction) => {
+			const passRule = panelAction.action.actionRules?.reduce((boolValue, rule) => {
+				const ruleExpression = mapRule(rule.mapping, rule.jsonLogic);
+				return boolValue && evaluateRule(ruleExpression, selectedNode?.nodeObj, selectedNode?.properties?.joiningEntityCatalogObjectKey, selectedNode?.wasLazyLoaded);
+			}, true) ?? true;
+			if (!passRule && panelAction?.hideAction) return null;
+			return /* @__PURE__ */ React.createElement(ToolBarButton, {
+				key: panelAction?.actionId,
+				label: panelAction?.action?.name,
+				aria: panelAction?.action?.name,
+				icon: false,
+				component: panelAction?.icon?.type === "unity" ? getUnityIconFromName(panelAction?.icon?.name) : getIconFromName(panelAction?.icon?.name),
+				click: () => handleTriggerAction(panelAction?.actionId),
+				disabled: !passRule
+			});
+		});
+		else siteHeaderSummaryComponent = /* @__PURE__ */ React.createElement(ActionSummaryPopover, {
+			panelActions: siteHeaderSummaryActions,
+			selectedNode
+		});
+		return /* @__PURE__ */ React.createElement(SiteHeaderRightComponent, null, /* @__PURE__ */ React.createElement("div", { className: classes.additionalRightComponent }, siteHeaderActionsComponent1, siteHeaderActionsComponent2, siteHeaderSummaryComponent));
+	}, [
+		panelsMap,
+		handleTriggerAction,
+		classes,
+		selectedNode
+	]);
+	const inquiryHeaderComponent = useMemo(() => {
+		const panelsMapCopy = cloneDeep(panelsMap);
+		const inquiryHeaderActions = panelsMapCopy[PanelPositionEnums.Inquiry_Header];
+		const inquiryHeaderSummaryActions = panelsMapCopy[PanelPositionEnums.Inquiry_Header_Summary];
+		let inquiryHeaderActionsComponent = null;
+		let inquiryHeaderSummaryComponent = null;
+		let inquiryHeaderPrimaryAction = null;
+		const showActionsAsSecondary = !inquiryHeaderSummaryActions?.length || !inquiryHeaderActions?.length && inquiryHeaderSummaryActions?.length <= 2;
+		if (inquiryHeaderActions?.length) {
+			const actionList = [];
+			inquiryHeaderActions.forEach((action) => {
+				const passRule = action.action.actionRules?.reduce((boolValue, rule) => {
+					const ruleExpression = mapRule(rule.mapping, rule.jsonLogic);
+					return boolValue && evaluateRule(ruleExpression, selectedNode?.nodeObj, selectedNode?.properties?.joiningEntityCatalogObjectKey, selectedNode?.wasLazyLoaded);
+				}, true) ?? true;
+				if (!passRule && !action?.hideAction) actionList.push({
+					...action,
+					disabled: true
+				});
+				else if (passRule) actionList.push(action);
+			});
+			inquiryHeaderActionsComponent = actionList?.filter((pa) => {
+				return showActionsAsSecondary ? !pa.isPrimary && pa.enabled : pa.enabled;
+			})?.map((panelAction, i) => /* @__PURE__ */ React.createElement("div", { key: i }, /* @__PURE__ */ React.createElement(ToolBarButton, {
+				label: panelAction?.action?.name,
+				aria: panelAction?.action?.name,
+				icon: false,
+				component: panelAction?.icon?.type === "unity" ? getUnityIconFromName(panelAction?.icon?.name) : getIconFromName(panelAction?.icon?.name),
+				click: () => {
+					handleTriggerAction(panelAction?.actionId);
+				},
+				disabled: panelAction?.disabled ?? false
+			})));
+			if (showActionsAsSecondary) {
+				const primaryAction = actionList?.find((panelAction) => panelAction.isPrimary);
+				inquiryHeaderPrimaryAction = primaryAction ? /* @__PURE__ */ React.createElement(PrimaryActionButton, {
+					onClick: () => handleTriggerAction(primaryAction?.actionId),
+					disabled: primaryAction?.disabled ?? false
+				}, /* @__PURE__ */ React.createElement(Typography, { style: { marginRight: 5 } }, primaryAction?.action?.name)) : null;
+			}
+		}
+		if (inquiryHeaderSummaryActions?.length) if (showActionsAsSecondary) inquiryHeaderActionsComponent = inquiryHeaderSummaryActions.map((panelAction) => {
+			const passRule = panelAction.action.actionRules?.reduce((boolValue, rule) => {
+				const ruleExpression = mapRule(rule.mapping, rule.jsonLogic);
+				return boolValue && evaluateRule(ruleExpression, selectedNode?.nodeObj, selectedNode?.properties?.joiningEntityCatalogObjectKey, selectedNode?.wasLazyLoaded);
+			}, true) ?? true;
+			if (!passRule && panelAction?.hideAction) return null;
+			return /* @__PURE__ */ React.createElement(ToolBarButton, {
+				key: panelAction?.actionId,
+				label: panelAction?.action?.name,
+				icon: false,
+				component: panelAction?.icon?.type === "unity" ? getUnityIconFromName(panelAction?.icon?.name) : getIconFromName(panelAction?.icon?.name),
+				click: () => handleTriggerAction(panelAction?.actionId),
+				disabled: !passRule
+			});
+		});
+		else inquiryHeaderSummaryComponent = /* @__PURE__ */ React.createElement(ActionSummaryPopover, {
+			panelActions: inquiryHeaderSummaryActions,
+			noContrastColor: true,
+			selectedNode
+		});
+		return /* @__PURE__ */ React.createElement(PAHAdditionalRightComponent, null, showInquiryHeaderActions && !hideActions && /* @__PURE__ */ React.createElement("div", { className: classes.additionalRightComponent }, inquiryHeaderActionsComponent, inquiryHeaderPrimaryAction, inquiryHeaderSummaryComponent));
+	}, [
+		panelsMap,
+		handleTriggerAction,
+		classes,
+		showInquiryHeaderActions,
+		selectedNode,
+		hideActions
+	]);
+	const inquirySpeedDialComponent = useMemo(() => {
+		const enabledSortedActions = cloneDeep(panelsMap)[PanelPositionEnums.Speed_Dial]?.filter((action) => action.enabled && (action.action.actionRules?.reduce((boolValue, rule) => {
+			const ruleExpression = mapRule(rule.mapping, rule.jsonLogic);
+			return boolValue && evaluateRule(ruleExpression, selectedNode?.nodeObj, selectedNode?.properties?.joiningEntityCatalogObjectKey, selectedNode?.wasLazyLoaded);
+		}, true) ?? true)).sort((a, b) => a.sequence - b.sequence) ?? [];
+		let parsedGlobalActions = [];
+		if (globalActions?.length) parsedGlobalActions = globalActions.map((action) => {
+			return {
+				icon: {
+					name: JSON.parse(action.parameters).icon,
+					type: "fluent"
+				},
+				action: { name: action.name },
+				...action
+			};
+		});
+		return (!!enabledSortedActions?.length || !!parsedGlobalActions?.length) && !hideActions && /* @__PURE__ */ React.createElement(ActionSpeedDial, { actions: [...enabledSortedActions, ...parsedGlobalActions].map((action) => ({
+			icon: action.icon,
+			onClick: () => handleTriggerAction(action.actionId),
+			name: action.action.name
+		})) });
+	}, [
+		panelsMap,
+		handleTriggerAction,
+		selectedNode,
+		globalActions,
+		hideActions
+	]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, siteHeaderRightComponent, inquiryHeaderComponent, inquirySpeedDialComponent);
+};
+ActionPanelPlacement.propTypes = {
+	actionPanels: PropTypes.array,
+	showInquiryHeaderActions: PropTypes.bool,
+	selectedNode: PropTypes.object
+};
+
+//#endregion
+//#region src/actions/ActionSideSheet.jsx
+const useStyles$1 = makeStyles((theme) => ({ root: {} }));
+const ActionSideSheet = (props) => {
+	const { open, action, actionPanel, selectedNodeObj, executeAction, selectedEntity, handleOnClose, entityAttributes, foreignKeyData, loadingContent, fetchEntityData, skeleton, showError, crudTableEditionData, crudTableFormData, selectedNode, selectedNodeParent, refreshTree, udpFieldInfos } = props;
+	const classes = useStyles$1();
+	const [width, setWidth] = useState(600);
+	const [buttonLabel, setButtonLabel] = useState("");
+	const [onSubmit, setOnSubmit] = useState(() => () => console.warn("onSubmit not set"));
+	const [additionalOnClose, setAdditionalOnClose] = useState();
+	const [otherSideSheetProps, setOtherSideSheetProps] = useState({});
+	const { enqueueSnackbar, closeSnackbar } = useSnackbar();
+	const successAction = getSuccessAction(closeSnackbar);
+	const { t } = useTranslation();
+	const user = useUser();
+	const setSelectedNodeForStore = useActionStore((state) => state.setSelectedNode);
+	const selectedNodeFromStore = useActionStore((state) => state.selectedNode);
+	const promotedMethodPageId = useMemo(() => {
+		if (action?.value) {
+			if (selectedEntity?.unityBaseUpdateMethod?.apiMethodId === action.value) return selectedEntity.unityBaseUpdateMethod.pageId;
+			else if (selectedEntity?.unityBaseCreateMethod?.apiMethodId === action.value) return selectedEntity.unityBaseCreateMethod.pageId;
+		}
+		return "";
+	}, [selectedEntity, action]);
+	const [{ data: page, loading: loadingPage }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `page/${action?.parameters?.pageId || promotedMethodPageId}`, {}, !!!action?.parameters?.pageId && !!!promotedMethodPageId, false);
+	const onCreate = useCallback(async (data) => {
+		if (selectedEntity?.unityBaseCreateMethod && action?.value) if (selectedEntity.unityBaseCreateMethod.apiMethodId === action.value) return await executeAction(data, action.value);
+		else showError();
+	}, [
+		action,
+		executeAction,
+		selectedEntity,
+		showError
+	]);
+	const onUpdate = useCallback(async (data) => {
+		if (selectedEntity?.unityBaseUpdateMethod && action?.value) if (selectedEntity.unityBaseUpdateMethod.apiMethodId === action.value) return await executeAction(data, action.value);
+		else showError();
+	}, [
+		action,
+		executeAction,
+		selectedEntity,
+		showError
+	]);
+	const handleFetchEntityData = useCallback(async () => {
+		if (selectedEntity?.unityBaseGetAllMethod) {
+			const response = await fetchEntityData({ data: {} }).catch((res) => {
+				enqueueSnackbar(res.message, {
+					variant: "error",
+					anchorOrigin: {
+						vertical: "top",
+						horizontal: "center"
+					}
+				});
+			});
+			if (response?.status === 200 && selectedNodeObj) {
+				const updatedNode = response.data.find((d) => d.id === selectedNodeObj.id);
+				const updatedSelectedNode = { ...selectedNodeFromStore };
+				updatedSelectedNode.nodeObj = updatedNode;
+				setSelectedNodeForStore(updatedSelectedNode);
+			}
+		}
+	}, [
+		enqueueSnackbar,
+		fetchEntityData,
+		selectedEntity,
+		selectedNodeObj,
+		setSelectedNodeForStore,
+		selectedNodeFromStore
+	]);
+	const handleOnCreate = useCallback(async (values) => {
+		if (selectedEntity && selectedEntity?.unityBaseCreateMethod) {
+			const entityName = selectedEntity?.entityName;
+			if (selectedEntity.unityBaseCreateMethod) {
+				if ((await onCreate({ data: { requestBody: values } }).catch((res) => {
+					enqueueSnackbar(res.message, {
+						variant: "error",
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						}
+					});
+				}))?.status === 200) enqueueSnackbar(entityName ? t(`${entityName} has been created`) : t(`Entity has been created`), {
+					anchorOrigin: {
+						vertical: "top",
+						horizontal: "center"
+					},
+					action: successAction
+				});
+			}
+		} else enqueueSnackbar(t(`Unable to retrieve entity methods`), {
+			variant: "error",
+			anchorOrigin: {
+				vertical: "top",
+				horizontal: "center"
+			}
+		});
+	}, [
+		enqueueSnackbar,
+		onCreate,
+		selectedEntity,
+		successAction,
+		t
+	]);
+	const handleOnUpdate = useCallback(async (values, primaryKeyValues) => {
+		if (selectedEntity && selectedEntity?.unityBaseUpdateMethod) {
+			const entityName = selectedEntity?.entityName;
+			if (selectedEntity.unityBaseUpdateMethod) {
+				if ((await onUpdate({ data: {
+					...getPathObject(selectedEntity.unityBaseUpdateMethod.pathParameters, primaryKeyValues),
+					requestBody: values
+				} }).catch((res) => {
+					enqueueSnackbar(res.message, {
+						variant: "error",
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						}
+					});
+				}))?.status === 200) {
+					enqueueSnackbar(entityName ? t(`${entityName} has been updated`) : t(`Entity has been updated`), {
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						},
+						action: successAction
+					});
+					handleFetchEntityData();
+				}
+			}
+		} else enqueueSnackbar(t(`Unable to retrieve entity methods`), {
+			variant: "error",
+			anchorOrigin: {
+				vertical: "top",
+				horizontal: "center"
+			}
+		});
+	}, [
+		selectedEntity,
+		onUpdate,
+		enqueueSnackbar,
+		t,
+		successAction,
+		handleFetchEntityData
+	]);
+	const handleOnCloseSideSheet = useCallback(() => {
+		if (additionalOnClose) additionalOnClose();
+		handleOnClose();
+	}, [additionalOnClose, handleOnClose]);
+	const content = useMemo(() => {
+		if (page) return /* @__PURE__ */ React.createElement(DndProvider, { backend: HTML5Backend }, /* @__PURE__ */ React.createElement(PageContainer, {
+			user,
+			key: action?.actionId,
+			pageData: page,
+			widgetParams: {
+				pageId: page?.pageId,
+				contentId: selectedNode?.properties?.searchValue,
+				nodeObj: selectedNode?.nodeObj,
+				parentNodeObj: selectedNodeParent?.nodeObj,
+				inquiryParams: selectedNode?.inquiryParams,
+				refreshTree,
+				requiredFieldsMap: action?.parameters?.requiredFieldMapping || {},
+				setSideSheetWidth: setWidth,
+				setSideSheetButtonLabel: setButtonLabel,
+				setSideSheetOnSubmit: setOnSubmit,
+				setSideSheetAdditionalOnClose: setAdditionalOnClose,
+				setSideSheetProps: setOtherSideSheetProps,
+				closeSideSheet: handleOnClose,
+				onCreate,
+				onUpdate
+			},
+			disableMargins: true
+		}));
+		else return /* @__PURE__ */ React.createElement(ActionForm, {
+			key: action?.actionId,
+			entityAttributes,
+			foreignKeyData,
+			onCreate: handleOnCreate,
+			closeSideSheet: handleOnClose,
+			onUpdate: handleOnUpdate,
+			crudTableEditionData,
+			crudTableFormData,
+			udpFieldInfos
+		});
+	}, [
+		action,
+		crudTableEditionData,
+		crudTableFormData,
+		entityAttributes,
+		foreignKeyData,
+		handleOnClose,
+		handleOnCreate,
+		handleOnUpdate,
+		selectedNode,
+		selectedNodeParent,
+		refreshTree,
+		user,
+		page,
+		onCreate,
+		onUpdate,
+		udpFieldInfos
+	]);
+	const sideSheetTitle = useMemo(() => {
+		if (action?.parameters?.pageDisplayName) return action.parameters.pageDisplayName;
+		else if (page) return page?.name;
+		else return (action?.actionTypeId === NodeActionEnums.Create ? "Add new " : "Edit ") + (action?.parameters?.entityName ?? actionPanel?.entityName);
+	}, [
+		action,
+		actionPanel,
+		page
+	]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open,
+		title: t(sideSheetTitle),
+		buttonLabel: t(buttonLabel),
+		onSubmit,
+		onClose: handleOnCloseSideSheet,
+		width,
+		...otherSideSheetProps
+	}, loadingContent || loadingPage ? /* @__PURE__ */ React.createElement(React.Fragment, null, skeleton.map((sk) => sk), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "md" }), /* @__PURE__ */ React.createElement(Skeleton, {
+		variant: "rect",
+		className: classes.skeletonButton
+	})) : content);
+};
+ActionSideSheet.propTypes = {
+	user: PropTypes.object,
+	open: PropTypes.bool,
+	dispatch: PropTypes.func,
+	action: PropTypes.object,
+	actionPanels: PropTypes.array,
+	catalog: PropTypes.object,
+	selectedNodeObj: PropTypes.object
+};
+
+//#endregion
+//#region src/actions/ActionWrapper.jsx
+const useStyles = makeStyles((theme) => ({}));
+const FIELD_NUMBER = 10;
+const ActionWrapper = (props) => {
+	const { actionState, actionPanel, dispatch, catalog, executeAction, splitScreenBody, entityAttributes, foreignKeyData, setForeignKeyData, crudTableEditionData, crudTableFormData, globalActions } = props;
+	const classes = useStyles();
+	const { getFKData } = useCrudActions();
+	const { enqueueSnackbar, closeSnackbar } = useSnackbar();
+	const successAction = getSuccessAction(closeSnackbar);
+	const { t } = useTranslation();
+	const [fkMethodEntities, setFKMethodEntities] = useState([]);
+	const [loadingContent, setLoadingContent] = useState(true);
+	const [udpFieldInfos, setUdpFieldInfos] = useState([]);
+	const selectedNode = useActionStore((state) => state.selectedNode);
+	const currentContainerId = useShellStore((state) => state.currentContainerId);
+	const { data: udpOjectFieldInfo } = usePromotedMethodEntity("UdpObjectFieldInfo", true);
+	const entityName = useMemo(() => {
+		return actionPanel ? actionPanel.entityName : actionState?.inquiryParams[currentContainerId || 0]?.selectedNode?.properties?.catalogReturnObject;
+	}, [
+		actionPanel,
+		actionState,
+		currentContainerId
+	]);
+	const [{ data: selectedEntity }] = useAxiosGet(ConfigService.integrationV1ApiUrl, `apicatalog/${catalog?.apiCatalogId}/promotedMethodEntities/${entityName}/product/${ConfigService.config.UNITY_PRODUCT_ID}`, {}, !!!catalog?.apiCatalogId || !!!entityName, false);
+	const getMetaDataForUdpField = useCallback(async (entityName$1) => {
+		let fieldInfos = [];
+		if (udpOjectFieldInfo?.unityBaseSearchMethod?.apiMethodId) await executeQueryAdHoc({ data: getSearchObject([{
+			searchField: "ObjectInfo.SanitizedName",
+			searchOperator: "=",
+			searchValue: getSanitizedName(entityName$1)
+		}], 1, 50, true) }, udpOjectFieldInfo.unityBaseSearchMethod.apiMethodId).then((resp) => {
+			fieldInfos = resp.data?.pageList;
+		});
+		return fieldInfos;
+	}, [udpOjectFieldInfo]);
+	const fetchEntityData = useCallback(async (data) => {
+		if (selectedEntity?.unityBaseGetAllMethod) return await executeAction(data, selectedEntity.unityBaseGetAllMethod.apiMethodId);
+	}, [executeAction, selectedEntity]);
+	const showError = useCallback(() => {
+		enqueueSnackbar(t(`Invalid action value.`), {
+			variant: "error",
+			anchorOrigin: {
+				vertical: "top",
+				horizontal: "center"
+			}
+		});
+	}, [enqueueSnackbar, t]);
+	const getFKMethodEntities = useCallback(async (attributes) => {
+		if (!attributes || !catalog) return [];
+		let fkData = [];
+		for (const attr of attributes) if (attr?.extendedProperties?.childEntity) {
+			const ceFieldsArr = [];
+			Object.keys(attr.extendedProperties.childEntityAssoc || {}).length && !attr.extendedProperties.childEntityAssoc.UdpType && attr.extendedProperties.childEntityAssoc.Keys.forEach((value, i) => {
+				const name = value.split(",")[0];
+				if (name) ceFieldsArr.push({
+					idx: i,
+					name: /^[A-Z]*$/.test(name) ? name.toLowerCase() : toLowerFirstChar(name)
+				});
+			});
+			const ceAttr = attributes.find((p) => ceFieldsArr.find((cef) => cef.name === p.name && !p?.extendedProperties?.identifier));
+			if (ceAttr) await apiMutate(ConfigService.integrationV1ApiUrl, `apicatalog/${catalog.apiCatalogId}/promotedMethodEntities/${attr.reference}/product/${ConfigService.config.UNITY_PRODUCT_ID}`, { method: "get" }, {}).then((resp) => {
+				if (resp && resp.data) fkData.push({
+					fkName: ceAttr.name,
+					entity: resp.data
+				});
+			});
+		}
+		setFKMethodEntities(fkData);
+	}, [catalog]);
+	const handleOnClose = useCallback((type, entity) => {
+		dispatch({
+			type,
+			entity
+		});
+	}, [dispatch]);
+	const onDelete = useCallback(async (data) => {
+		if (selectedEntity?.unityBaseDeleteMethod) if (selectedEntity.unityBaseDeleteMethod.apiMethodId === actionState?.modal?.action?.value) return await executeAction(data, actionState?.modal?.action?.value);
+		else showError();
+	}, [
+		actionState,
+		executeAction,
+		selectedEntity,
+		showError
+	]);
+	const handleOnDelete = useCallback(async (value) => {
+		if (selectedEntity) {
+			const entityName$1 = selectedEntity?.entityName;
+			const primaryKeyValues = getPrimaryKeyValues(entityAttributes, value);
+			const pathObject = getPathObject(selectedEntity?.unityBaseDeleteMethod.pathParameters, primaryKeyValues);
+			if (selectedEntity?.unityBaseDeleteMethod) {
+				if ((await onDelete({ data: { ...pathObject } }).catch((res) => {
+					enqueueSnackbar(res.message, {
+						variant: "error",
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						}
+					});
+				}))?.status === 200) {
+					enqueueSnackbar(entityName$1 ? t(`${entityName$1} has been deleted`) : t(`Entity has been deleted`), {
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						},
+						action: successAction
+					});
+					if (actionState?.menuListState && actionState?.menuListState?.menuList.length > 0) {
+						const handleRemoveMenuItem = actionState?.menuListState?.handleRemoveMenuItem;
+						if (handleRemoveMenuItem) handleRemoveMenuItem(actionState?.menuListState?.menuList);
+					}
+					fetchEntityData({ data: {} });
+				}
+			}
+		}
+	}, [
+		actionState,
+		enqueueSnackbar,
+		entityAttributes,
+		fetchEntityData,
+		onDelete,
+		selectedEntity,
+		successAction,
+		t
+	]);
+	const skeleton = useMemo(() => {
+		const skeletonArr = [];
+		for (let i = 0; i < FIELD_NUMBER; i++) skeletonArr.push(/* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Skeleton, {
+			key: i,
+			variant: "rect",
+			className: classes.skeleton
+		}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "xxs" })));
+		return skeletonArr;
+	}, [classes]);
+	useEffect(() => {
+		if (entityAttributes) {
+			getFKMethodEntities(entityAttributes);
+			setLoadingContent(false);
+		}
+	}, [entityAttributes, getFKMethodEntities]);
+	useEffect(() => {
+		if (entityAttributes && fkMethodEntities && fkMethodEntities.length > 0) getFKData(fkMethodEntities, setForeignKeyData, enqueueSnackbar);
+	}, [
+		enqueueSnackbar,
+		entityAttributes,
+		fkMethodEntities,
+		getFKData,
+		setForeignKeyData
+	]);
+	useEffect(() => {
+		const setFieldInfos = async () => {
+			if (!entityName) return;
+			setUdpFieldInfos(await getMetaDataForUdpField(entityName));
+		};
+		if (udpOjectFieldInfo?.unityBaseSearchMethod?.apiMethodId) setFieldInfos();
+	}, [
+		getMetaDataForUdpField,
+		udpOjectFieldInfo,
+		entityName
+	]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ActionSplitScreen, {
+		body: /* @__PURE__ */ React.createElement(React.Fragment, null, splitScreenBody, /* @__PURE__ */ React.createElement(ActionPanelPlacement, {
+			actionPanels: actionState?.actionPanels[currentContainerId || 0],
+			showInquiryHeaderActions: actionState?.showInquiryHeaderActions,
+			selectedNode: actionState?.inquiryParams[currentContainerId || 0]?.selectedNode,
+			globalActions
+		})),
+		open: actionState?.splitScreen?.open,
+		action: actionState?.splitScreen?.action,
+		type: actionState?.splitScreen?.type,
+		params: actionState?.splitScreen?.params,
+		executeAction,
+		actionPanel,
+		selectedNodeObj: selectedNode?.nodeObj,
+		menuNodeList: actionState?.menuListState?.menuList,
+		sidebarEntity: selectedEntity,
+		selectedNode: actionState?.inquiryParams[currentContainerId || 0]?.selectedNode,
+		selectedNodeParent: actionState?.inquiryParams[currentContainerId || 0]?.selectedNodeParent,
+		refreshTree: actionState?.inquiryParams[currentContainerId || 0]?.refreshTree
+	}), /* @__PURE__ */ React.createElement(ActionSideSheet, {
+		key: actionState?.sideSheet?.action?.actionId,
+		open: actionState?.sideSheet?.open,
+		dispatch,
+		action: actionState?.sideSheet?.action,
+		actionPanel,
+		selectedNodeObj: selectedNode?.nodeObj,
+		executeAction,
+		selectedEntity,
+		handleOnClose: () => {
+			handleOnClose("OPEN_SIDESHEET", {
+				open: false,
+				action: null
+			});
+		},
+		entityAttributes,
+		foreignKeyData,
+		loadingContent,
+		fetchEntityData,
+		skeleton,
+		showError,
+		crudTableEditionData,
+		crudTableFormData,
+		selectedNode: actionState?.inquiryParams[currentContainerId || 0]?.selectedNode,
+		selectedNodeParent: actionState?.inquiryParams[currentContainerId || 0]?.selectedNodeParent,
+		refreshTree: actionState?.inquiryParams[currentContainerId || 0]?.refreshTree,
+		udpFieldInfos
+	}), /* @__PURE__ */ React.createElement(ActionModal, {
+		open: actionState?.modal?.open,
+		action: actionState?.modal?.action,
+		title: actionState?.modal?.title + selectedEntity?.entityName,
+		message: t(`Are you sure you want to delete this ${selectedEntity?.entityName}?`),
+		confirmAction: () => handleOnDelete(selectedNode?.nodeObj),
+		handleOnClose: () => {
+			handleOnClose("OPEN_MODAL", {
+				open: false,
+				action: null
+			});
+		},
+		showError
+	}));
+};
+ActionWrapper.propTypes = {
+	actionState: PropTypes.object,
+	actionPanel: PropTypes.object,
+	dispatch: PropTypes.func,
+	catalog: PropTypes.object,
+	executeAction: PropTypes.func,
+	user: PropTypes.object,
+	splitScreenBody: PropTypes.object
+};
+
+//#endregion
+export { ActionModal as a, ActionSpeedDial as i, ActionSideSheet as n, ActionForm as o, ActionPanelPlacement as r, ActionWrapper as t };
+//# sourceMappingURL=ActionWrapper-47uvDDnB.js.map