@sapui5/sap.fe.core 1.102.3 → 1.105.0

package/src/sap/fe/core/converters/objectPage/HeaderAndFooterAction.ts

@@ -1,28 +1,13 @@
-import { EntityType } from "@sap-ux/annotation-converter";
-import { DataFieldForActionTypes, DataFieldForIntentBasedNavigationTypes, PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
-import {
-	AnnotationAction,
-	BaseAction,
-	ButtonType,
-	getEnabledForAnnotationAction,
-	getSemanticObjectMapping
-} from "sap/fe/core/converters/controls/Common/Action";
+import type { EntityType, PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
+import type { DataFieldForActionTypes, DataFieldForIntentBasedNavigationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
+import type { AnnotationAction, BaseAction } from "sap/fe/core/converters/controls/Common/Action";
+import { ButtonType, getEnabledForAnnotationAction, getSemanticObjectMapping } from "sap/fe/core/converters/controls/Common/Action";
 import { Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
-import {
-	and,
-	annotationExpression,
-	BindingExpression,
-	compileBinding,
-	constant,
-	equal,
-	Expression,
-	fn,
-	ifElse,
-	not
-} from "sap/fe/core/helpers/BindingExpression";
+import type { BindingToolkitExpression, CompiledBindingToolkitExpression } from "sap/fe/core/helpers/BindingToolkit";
+import { and, compileExpression, constant, equal, fn, getExpressionFromAnnotation, ifElse, not } from "sap/fe/core/helpers/BindingToolkit";
 import { isPathDeletable } from "sap/fe/core/templating/DataModelPathHelper";
-import ConverterContext from "../ConverterContext";
+import type ConverterContext from "../ConverterContext";
 import { Draft, singletonPathVisitor, UI } from "../helpers/BindingHelper";
 import { ActionType } from "../ManifestSettings";
 
@@ -32,9 +17,9 @@ import { ActionType } from "../ManifestSettings";
  * - Not statically hidden
  * - Either linked to an Unbound action or to an action which has an OperationAvailable that is not set to false statically.
  *
- * @param {EntityType} entityType The current entity type
- * @param {boolean} bDetermining The flag which denotes whether or not the action is a determining action
- * @returns {DataFieldForActionTypes[]} An array of DataField for action respecting the input parameter 'bDetermining'
+ * @param entityType The current entity type
+ * @param bDetermining The flag which denotes whether or not the action is a determining action
+ * @returns An array of DataField for action respecting the input parameter 'bDetermining'
  */
 export function getIdentificationDataFieldForActions(entityType: EntityType, bDetermining: boolean): DataFieldForActionTypes[] {
 	return (entityType.annotations?.UI?.Identification?.filter((identificationDataField) => {
@@ -57,9 +42,9 @@ export function getIdentificationDataFieldForActions(entityType: EntityType, bDe
  * They must be
  * - Not statically hidden.
  *
- * @param {EntityType} entityType The current entitytype
- * @param {boolean} bDetermining Whether or not the action should be determining
- * @returns {DataFieldForIntentBasedNavigationTypes[]} An array of data field for action respecting the bDetermining property.
+ * @param entityType The current entitytype
+ * @param bDetermining Whether or not the action should be determining
+ * @returns An array of data field for action respecting the bDetermining property.
  */
 function getIdentificationDataFieldForIBNActions(entityType: EntityType, bDetermining: boolean): DataFieldForIntentBasedNavigationTypes[] {
 	return (entityType.annotations?.UI?.Identification?.filter((identificationDataField) => {
@@ -86,19 +71,19 @@ const IMPORTANT_CRITICALITIES = [
 /**
  * Method to determine the 'visible' property binding for the Delete button on an object page.
  *
- * @param {ConverterContext} converterContext Instance of the converter context.
- * @param {PropertyAnnotationValue<boolean> | undefined} deleteHidden The value of the UI.DeleteHidden annotation on the entity set / type.
- * @returns {Expression<boolean>} The binding expression for the 'visible' property of the Delete button.
+ * @param converterContext Instance of the converter context.
+ * @param deleteHidden The value of the UI.DeleteHidden annotation on the entity set / type.
+ * @returns The binding expression for the 'visible' property of the Delete button.
  */
 export function getDeleteButtonVisibility(
 	converterContext: ConverterContext,
 	deleteHidden: PropertyAnnotationValue<boolean> | undefined
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const dataModelObjectPath = converterContext.getDataModelObjectPath(),
 		visitedNavigationPaths = dataModelObjectPath.navigationProperties.map((navProp) => navProp.name),
 		// Set absolute binding path for Singleton references, otherwise the configured annotation path itself.
 		// For e.g. /com.sap.namespace.EntityContainer/Singleton/Property to /Singleton/Property
-		deleteHiddenExpression: Expression<boolean | undefined> = annotationExpression(
+		deleteHiddenExpression: BindingToolkitExpression<boolean | undefined> = getExpressionFromAnnotation(
 			deleteHidden,
 			visitedNavigationPaths,
 			undefined,
@@ -109,7 +94,7 @@ export function getDeleteButtonVisibility(
 		// Delete button is visible
 		// In OP 		-->  when not in edit mode
 		// In sub-OP 	-->  when in edit mode
-		editableExpression: Expression<boolean> = viewLevel > 1 ? UI.IsEditable : not(UI.IsEditable);
+		editableExpression: BindingToolkitExpression<boolean> = viewLevel > 1 ? UI.IsEditable : not(UI.IsEditable);
 
 	// If UI.DeleteHidden annotation on entity set or type is either not defined or explicitly set to false,
 	// Delete button is visible based on editableExpression.
@@ -125,14 +110,14 @@ export function getDeleteButtonVisibility(
 /**
  * Method to determine the 'enabled' property binding for the Delete button on an object page.
  *
- * @param {PropertyAnnotationValue<boolean>|undefined} isDeletable The delete restriction configured
- * @param {Expression<boolean>} isParentDeletable The delete restriction configured on the parent entity
- * @returns {Expression<boolean>} The binding expression for the 'enabled' property of the Delete button
+ * @param isDeletable The delete restriction configured
+ * @param isParentDeletable The delete restriction configured on the parent entity
+ * @returns The binding expression for the 'enabled' property of the Delete button
  */
 export function getDeleteButtonEnabled(
 	isDeletable: PropertyAnnotationValue<Boolean> | undefined,
-	isParentDeletable: Expression<boolean>
-): Expression<boolean> {
+	isParentDeletable: BindingToolkitExpression<boolean>
+): BindingToolkitExpression<boolean> {
 	return ifElse(
 		isParentDeletable !== undefined,
 		isParentDeletable,
@@ -143,33 +128,33 @@ export function getDeleteButtonEnabled(
 /**
  * Method to determine the 'visible' property binding for the Edit button on an object page.
  *
- * @param {ConverterContext} converterContext Instance of the converter context.
- * @param {PropertyAnnotationValue<boolean> | undefined} updateHidden The value of the UI.UpdateHidden annotation on the entity set / type.
- * @returns {Expression<boolean>} The binding expression for the 'visible' property of the Edit button.
+ * @param converterContext Instance of the converter context.
+ * @param updateHidden The value of the UI.UpdateHidden annotation on the entity set / type.
+ * @returns The binding expression for the 'visible' property of the Edit button.
  */
 export function getEditButtonVisibility(
 	converterContext: ConverterContext,
 	updateHidden: PropertyAnnotationValue<boolean> | undefined
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const entitySet = converterContext.getEntitySet(),
 		bIsDraftRoot = entitySet && entitySet.annotations.Common?.DraftRoot ? true : false,
 		dataModelObjectPath = converterContext.getDataModelObjectPath(),
 		visitedNavigationPaths = dataModelObjectPath.navigationProperties.map((navProp) => navProp.name),
 		// Set absolute binding path for Singleton references, otherwise the configured annotation path itself.
 		// For e.g. /com.sap.namespace.EntityContainer/Singleton/Property to /Singleton/Property
-		updateHiddenExpression: Expression<boolean | undefined> = annotationExpression(
+		updateHiddenExpression: BindingToolkitExpression<boolean | undefined> = getExpressionFromAnnotation(
 			updateHidden,
 			visitedNavigationPaths,
 			undefined,
 			(path: string) => singletonPathVisitor(path, converterContext.getConvertedTypes(), visitedNavigationPaths)
 		),
-		notEditableExpression: Expression<boolean> = not(UI.IsEditable);
+		notEditableExpression: BindingToolkitExpression<boolean> = not(UI.IsEditable);
 
 	// If UI.UpdateHidden annotation on entity set or type is either not defined or explicitly set to false,
 	// Edit button is visible in display mode.
 	// else,
 	// Edit button is visible based on both annotation path and in display mode.
-	const resultantExpression: Expression<boolean> = ifElse(
+	const resultantExpression: BindingToolkitExpression<boolean> = ifElse(
 		updateHidden === undefined || updateHidden.valueOf() === false,
 		notEditableExpression,
 		and(notEditableExpression, equal(updateHiddenExpression, false))
@@ -180,10 +165,10 @@ export function getEditButtonVisibility(
 /**
  * Method to determine the 'enabled' property binding for the Edit button on an object page.
  *
- * @param {ConverterContext} converterContext Instance of the converter context.
- * @returns {Expression<boolean>} The binding expression for the 'enabled' property of the Edit button.
+ * @param converterContext Instance of the converter context.
+ * @returns The binding expression for the 'enabled' property of the Edit button.
  */
-export function getEditButtonEnabled(converterContext: ConverterContext): BindingExpression<boolean> {
+export function getEditButtonEnabled(converterContext: ConverterContext): CompiledBindingToolkitExpression {
 	const entitySet = converterContext.getEntitySet(),
 		isDraftRoot = entitySet && entitySet.annotations.Common?.DraftRoot ? true : false,
 		isSticky = entitySet && entitySet.annotations.Session?.StickySessionSupported ? true : false;
@@ -195,24 +180,17 @@ export function getEditButtonEnabled(converterContext: ConverterContext): Bindin
 		editActionName = entitySet?.annotations.Session?.StickySessionSupported?.EditAction as string;
 	}
 	if (editActionName) {
-		const editActionAnnotationPath = converterContext.getAbsoluteAnnotationPath(editActionName as string),
-			editActions = (converterContext.getEntityTypeAnnotation(editActionAnnotationPath)?.annotation as any)?.actions;
-		if (editActions?.length) {
-			const editAction = editActions[0];
-			if (editAction?.annotations?.Core?.OperationAvailable === null) {
-				return "{= ${#" + editActionName + "} ? true : false }";
-			} else {
-				return getEnabledForAnnotationAction(converterContext, editAction);
-			}
+		const editActionAnnotationPath = converterContext.getAbsoluteAnnotationPath(editActionName);
+		const editAction = converterContext.getEntityTypeAnnotation(editActionAnnotationPath).annotation;
+		if (editAction?.annotations?.Core?.OperationAvailable === null) {
+			return "{= ${#" + editActionName + "} ? true : false }";
+		} else {
+			return getEnabledForAnnotationAction(converterContext, editAction);
 		}
 	}
-	return true;
+	return "true";
 }
 
-/**
- * @param converterContext
- * @returns {BaseAction[]}
- */
 export function getHeaderDefaultActions(converterContext: ConverterContext): BaseAction[] {
 	const entitySet = converterContext.getEntitySet(),
 		entityType = converterContext.getEntityType(),
@@ -225,7 +203,7 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 			pathVisitor: (path: string, navigationPaths: string[]) =>
 				singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths)
 		}),
-		bParentEntitySetDeletable = isParentDeletable ? compileBinding(isParentDeletable) : isParentDeletable,
+		bParentEntitySetDeletable = isParentDeletable ? compileExpression(isParentDeletable) : isParentDeletable,
 		headerDataFieldForActions = getIdentificationDataFieldForActions(converterContext.getEntityType(), false);
 
 	// Initialize actions and start with draft actions if available since they should appear in the first
@@ -248,7 +226,7 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 				type: ActionType.DataFieldForAction,
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileBinding(not(equal(annotationExpression(dataField.annotations?.UI?.Hidden), true))),
+				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
 				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
 				isNavigable: true
 			});
@@ -264,7 +242,7 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 		headerActions.push({
 			type: ActionType.Primary,
 			key: "EditAction",
-			visible: compileBinding(getEditButtonVisibility(converterContext, updateHidden)),
+			visible: compileExpression(getEditButtonVisibility(converterContext, updateHidden)),
 			enabled: getEditButtonEnabled(converterContext)
 		});
 	}
@@ -281,8 +259,8 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 		headerActions.push({
 			type: ActionType.Secondary,
 			key: "DeleteAction",
-			visible: compileBinding(getDeleteButtonVisibility(converterContext, deleteHidden)),
-			enabled: compileBinding(getDeleteButtonEnabled(oEntityDeleteRestrictions?.Deletable, isParentDeletable)),
+			visible: compileExpression(getDeleteButtonVisibility(converterContext, deleteHidden)),
+			enabled: compileExpression(getDeleteButtonEnabled(oEntityDeleteRestrictions?.Deletable, isParentDeletable)),
 			parentEntityDeleteEnabled: bParentEntitySetDeletable
 		});
 	}
@@ -299,32 +277,32 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 			};
 
 			if (dataField.RequiresContext?.valueOf() === true) {
-				throw new Error("RequiresContext property should not be true for header IBN action : " + dataField.Label);
+				throw new Error(`RequiresContext property should not be true for header IBN action : ${dataField.Label}`);
 			} else if (dataField.Inline?.valueOf() === true) {
-				throw new Error("Inline property should not be true for header IBN action : " + dataField.Label);
+				throw new Error(`Inline property should not be true for header IBN action : ${dataField.Label}`);
 			}
 			headerActions.push({
 				type: ActionType.DataFieldForIntentBasedNavigation,
 				text: dataField.Label?.toString(),
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 				buttonType: ButtonType.Ghost,
-				visible: compileBinding(not(equal(annotationExpression(dataField.annotations?.UI?.Hidden?.valueOf()), true))),
+				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden?.valueOf()), true))),
 				enabled:
 					dataField.NavigationAvailable !== undefined
-						? compileBinding(equal(annotationExpression(dataField.NavigationAvailable?.valueOf()), true))
+						? compileExpression(equal(getExpressionFromAnnotation(dataField.NavigationAvailable?.valueOf()), true))
 						: true,
 				key: KeyHelper.generateKeyFromDataField(dataField),
 				isNavigable: true,
-				press: compileBinding(
+				press: compileExpression(
 					fn("._intentBasedNavigation.navigate", [
-						annotationExpression(dataField.SemanticObject),
-						annotationExpression(dataField.Action),
+						getExpressionFromAnnotation(dataField.SemanticObject),
+						getExpressionFromAnnotation(dataField.Action),
 						oNavigationParams
 					])
 				),
-				customData: compileBinding({
-					semanticObject: annotationExpression(dataField.SemanticObject),
-					action: annotationExpression(dataField.Action)
+				customData: compileExpression({
+					semanticObject: getExpressionFromAnnotation(dataField.SemanticObject),
+					action: getExpressionFromAnnotation(dataField.Action)
 				})
 			} as AnnotationAction);
 		});
@@ -338,7 +316,7 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 				type: ActionType.DataFieldForAction,
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileBinding(not(equal(annotationExpression(dataField.annotations?.UI?.Hidden), true))),
+				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
 				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
 				isNavigable: true
 			} as AnnotationAction);
@@ -347,10 +325,6 @@ export function getHeaderDefaultActions(converterContext: ConverterContext): Bas
 	return headerActions;
 }
 
-/**
- * @param converterContext
- * @returns {BaseAction[]}
- */
 export function getHiddenHeaderActions(converterContext: ConverterContext): BaseAction[] {
 	const entityType = converterContext.getEntityType();
 	const hiddenActions = (entityType.annotations?.UI?.Identification?.filter((identificationDataField) => {
@@ -364,11 +338,6 @@ export function getHiddenHeaderActions(converterContext: ConverterContext): Base
 	});
 }
 
-/**
- * @param viewLevel
- * @param converterContext
- * @returns {BaseAction[]}
- */
 export function getFooterDefaultActions(viewLevel: number, converterContext: ConverterContext): BaseAction[] {
 	const entitySet = converterContext.getEntitySet();
 	const entityType = converterContext.getEntityType();
@@ -396,7 +365,7 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 				type: ActionType.DataFieldForAction,
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileBinding(not(equal(annotationExpression(dataField.annotations?.UI?.Hidden), true))),
+				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
 				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
 				isNavigable: true
 			};
@@ -422,7 +391,7 @@ export function getFooterDefaultActions(viewLevel: number, converterContext: Con
 				type: ActionType.DataFieldForAction,
 				annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
 				key: KeyHelper.generateKeyFromDataField(dataField),
-				visible: compileBinding(not(equal(annotationExpression(dataField.annotations?.UI?.Hidden), true))),
+				visible: compileExpression(not(equal(getExpressionFromAnnotation(dataField.annotations?.UI?.Hidden), true))),
 				enabled: getEnabledForAnnotationAction(converterContext, dataField.ActionTarget),
 				isNavigable: true
 			} as AnnotationAction);