@sapui5/sap.fe.core 1.102.0 → 1.103.0

package/src/sap/fe/core/converters/controls/Common/table/StandardActions.ts

@@ -1,30 +1,30 @@
-import { PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
+import type { PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
 import tableFormatters from "sap/fe/core/formatters/TableFormatter";
+import type { BindingToolkitExpression, CompiledBindingToolkitExpression } from "sap/fe/core/helpers/BindingToolkit";
 import {
 	and,
-	annotationExpression,
-	bindingExpression,
-	BindingExpression,
-	compileBinding,
+	compileExpression,
 	constant,
 	equal,
-	Expression,
 	formatResult,
+	getExpressionFromAnnotation,
 	greaterOrEqual,
 	greaterThan,
 	ifElse,
-	isBinding,
 	isConstant,
+	isPathInModelExpression,
 	length,
 	not,
 	notEqual,
-	or
-} from "sap/fe/core/helpers/BindingExpression";
+	or,
+	pathInModel
+} from "sap/fe/core/helpers/BindingToolkit";
 import { getTargetObjectPath, isPathDeletable, isPathInsertable, isPathUpdatable } from "sap/fe/core/templating/DataModelPathHelper";
-import ConverterContext from "../../../ConverterContext";
+import type ConverterContext from "../../../ConverterContext";
 import { singletonPathVisitor, UI } from "../../../helpers/BindingHelper";
-import { CreationMode, TemplateType, ViewPathConfiguration } from "../../../ManifestSettings";
-import { TableControlConfiguration } from "../Table";
+import type { ViewPathConfiguration } from "../../../ManifestSettings";
+import { CreationMode, TemplateType } from "../../../ManifestSettings";
+import type { TableControlConfiguration } from "../Table";
 
 enum AnnotationHiddenProperty {
 	CreateHidden = "CreateHidden",
@@ -33,30 +33,30 @@ enum AnnotationHiddenProperty {
 }
 
 export type StandardActionConfigType = {
-	isTemplated?: BindingExpression<boolean>;
-	visible: BindingExpression<boolean>;
-	enabled: BindingExpression<boolean>;
+	isTemplated?: CompiledBindingToolkitExpression;
+	visible: CompiledBindingToolkitExpression;
+	enabled: CompiledBindingToolkitExpression;
 };
 
 type ExpressionRestrictionsType = {
-	expression: Expression<boolean>;
-	navigationExpression: Expression<boolean>;
+	expression: BindingToolkitExpression<boolean>;
+	navigationExpression: BindingToolkitExpression<boolean>;
 };
 type StandardActionsRestrictionsType = Record<string, ExpressionRestrictionsType>;
 
 export type StandardActionsContext = {
 	collectionPath: string;
 	hiddenAnnotation: {
-		create: Expression<boolean>;
-		"delete": Expression<boolean>;
-		update: Expression<boolean>;
+		create: BindingToolkitExpression<boolean>;
+		"delete": BindingToolkitExpression<boolean>;
+		update: BindingToolkitExpression<boolean>;
 	};
 	creationMode: CreationMode;
 	isDraftOrStickySupported: boolean;
 	isViewWithMultipleVisualizations: boolean;
 	newAction?: {
 		name?: string;
-		available?: Expression<boolean>;
+		available?: BindingToolkitExpression<boolean>;
 	};
 	tableManifestConfiguration: TableControlConfiguration;
 	restrictions: StandardActionsRestrictionsType;
@@ -65,10 +65,10 @@ export type StandardActionsContext = {
 /**
  * Generates the context for the standard actions.
  *
- * @param {ConverterContext} converterContext
- * @param {NavigationSettingsConfiguration} creationMode
- * @param {TableControlConfiguration} tableManifestConfiguration
- * @param {ViewPathConfiguration} viewConfiguration
+ * @param converterContext
+ * @param creationMode
+ * @param tableManifestConfiguration
+ * @param viewConfiguration
  * @returns  The context for table actions
  */
 export function generateStandardActionsContext(
@@ -98,8 +98,8 @@ export function generateStandardActionsContext(
 /**
  * Checks if draft is supported.
  *
- * @param {ConverterContext} converterContext
- * @returns {boolean}
+ * @param converterContext
+ * @returns `true` if it is supported
  */
 export function isDraftSupported(converterContext: ConverterContext): boolean {
 	const currentEntitySet = converterContext.getEntitySet();
@@ -118,8 +118,8 @@ export function isDraftSupported(converterContext: ConverterContext): boolean {
 /**
  * Checks if sticky or draft is supported.
  *
- * @param {ConverterContext} converterContext
- * @returns {boolean}
+ * @param converterContext
+ * @returns `true` if it is supported
  */
 export function isDraftOrStickySupported(converterContext: ConverterContext): boolean {
 	const bIsDraftSupported = isDraftSupported(converterContext);
@@ -134,12 +134,12 @@ export function isDraftOrStickySupported(converterContext: ConverterContext): bo
 /**
  * Gets the configured newAction into annotation.
  *
- * @param {ConverterContext} converterContext
- * @returns {any}
+ * @param converterContext
+ * @returns The new action info
  */
 export function getNewAction(converterContext: ConverterContext): any {
 	const currentEntitySet = converterContext.getEntitySet();
-	const newActionName: BindingExpression<string> = (
+	const newActionName: CompiledBindingToolkitExpression = (
 		currentEntitySet?.annotations?.Common?.DraftRoot?.NewAction ||
 		currentEntitySet?.annotations?.Session?.StickySessionSupported?.NewAction
 	)?.toString();
@@ -148,7 +148,7 @@ export function getNewAction(converterContext: ConverterContext): any {
 		availableProperty = availableProperty !== undefined ? availableProperty : true;
 		return {
 			name: newActionName,
-			available: annotationExpression(availableProperty)
+			available: getExpressionFromAnnotation(availableProperty)
 		};
 	}
 	return undefined;
@@ -157,16 +157,16 @@ export function getNewAction(converterContext: ConverterContext): any {
 /**
  * Gets the binding expression for the action visibility configured into annotation.
  *
- * @param {ConverterContext} converterContext
- * @param {string} sAnnotationTerm
- * @param {boolean} bWithNavigationPath
- * @returns {Expression<boolean>}
+ * @param converterContext
+ * @param sAnnotationTerm
+ * @param bWithNavigationPath
+ * @returns The binding expression for the action visibility
  */
 export function isActionAnnotatedHidden(
 	converterContext: ConverterContext,
 	sAnnotationTerm: string,
 	bWithNavigationPath = true
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const currentEntitySet = converterContext.getEntitySet();
 	const dataModelObjectPath = converterContext.getDataModelObjectPath();
 	// Consider only the last level of navigation. The others are already considered in the element binding of the page.
@@ -178,7 +178,7 @@ export function isActionAnnotatedHidden(
 		((currentEntitySet?.annotations.UI as any)?.[sAnnotationTerm] as PropertyAnnotationValue<boolean>) || false;
 
 	return currentEntitySet
-		? annotationExpression(actionAnnotationValue, visitedNavigationPaths, undefined, (path: string) =>
+		? getExpressionFromAnnotation(actionAnnotationValue, visitedNavigationPaths, undefined, (path: string) =>
 				singletonPathVisitor(path, converterContext.getConvertedTypes(), visitedNavigationPaths)
 		  )
 		: constant(false);
@@ -187,8 +187,8 @@ export function isActionAnnotatedHidden(
 /**
  * Gets the annotated restrictions for the actions.
  *
- * @param {ConverterContext} converterContext
- * @returns {StandardActionsRestrictionsType}
+ * @param converterContext
+ * @returns The restriction information
  */
 export function getRestrictions(converterContext: ConverterContext): StandardActionsRestrictionsType {
 	const dataModelObjectPath = converterContext.getDataModelObjectPath();
@@ -234,10 +234,10 @@ export function getRestrictions(converterContext: ConverterContext): StandardAct
 /**
  * Checks if templating for insert/update actions is mandatory.
  *
- * @param {StandardActionsContext} standardActionsContext
- * @param {boolean} isDraftOrSticky
- * @param {boolean} isCreateAlwaysHidden
- * @returns {boolean}
+ * @param standardActionsContext
+ * @param isDraftOrSticky
+ * @param isCreateAlwaysHidden
+ * @returns The
  */
 export function getInsertUpdateActionsTemplating(
 	standardActionsContext: StandardActionsContext,
@@ -250,9 +250,9 @@ export function getInsertUpdateActionsTemplating(
 /**
  * Gets the binding expressions for the properties of the action Create.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @returns {StandardActionConfigType}
+ * @param converterContext
+ * @param standardActionsContext
+ * @returns The standard action info
  */
 export function getStandardActionCreate(
 	converterContext: ConverterContext,
@@ -260,18 +260,18 @@ export function getStandardActionCreate(
 ): StandardActionConfigType {
 	const createVisibility = getCreateVisibility(converterContext, standardActionsContext);
 	return {
-		isTemplated: compileBinding(getCreateTemplating(standardActionsContext, createVisibility)),
-		visible: compileBinding(createVisibility),
-		enabled: compileBinding(getCreateEnablement(converterContext, standardActionsContext, createVisibility))
+		isTemplated: compileExpression(getCreateTemplating(standardActionsContext, createVisibility)),
+		visible: compileExpression(createVisibility),
+		enabled: compileExpression(getCreateEnablement(converterContext, standardActionsContext, createVisibility))
 	};
 }
 
 /**
  * Gets the binding expressions for the properties of the action Delete.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @returns {StandardActionConfigType}
+ * @param converterContext
+ * @param standardActionsContext
+ * @returns The binding expressions for the properties of the action Delete.
  */
 export function getStandardActionDelete(
 	converterContext: ConverterContext,
@@ -280,9 +280,9 @@ export function getStandardActionDelete(
 	const deleteVisibility = getDeleteVisibility(converterContext, standardActionsContext);
 
 	return {
-		isTemplated: compileBinding(getDefaultTemplating(deleteVisibility)),
-		visible: compileBinding(deleteVisibility),
-		enabled: compileBinding(getDeleteEnablement(converterContext, standardActionsContext, deleteVisibility))
+		isTemplated: compileExpression(getDefaultTemplating(deleteVisibility)),
+		visible: compileExpression(deleteVisibility),
+		enabled: compileExpression(getDeleteEnablement(converterContext, standardActionsContext, deleteVisibility))
 	};
 }
 
@@ -298,19 +298,19 @@ export function getCreationRow(
 	const creationRowVisibility = getCreateVisibility(converterContext, standardActionsContext, true);
 
 	return {
-		isTemplated: compileBinding(getCreateTemplating(standardActionsContext, creationRowVisibility, true)),
-		visible: compileBinding(creationRowVisibility),
-		enabled: compileBinding(getCreationRowEnablement(converterContext, standardActionsContext, creationRowVisibility))
+		isTemplated: compileExpression(getCreateTemplating(standardActionsContext, creationRowVisibility, true)),
+		visible: compileExpression(creationRowVisibility),
+		enabled: compileExpression(getCreationRowEnablement(converterContext, standardActionsContext, creationRowVisibility))
 	};
 }
 
 /**
  * Gets the binding expressions for the properties of the action Paste.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @param {boolean} isInsertUpdateActionsTemplated
- * @returns {StandardActionConfigType}
+ * @param converterContext
+ * @param standardActionsContext
+ * @param isInsertUpdateActionsTemplated
+ * @returns The binding expressions for the properties of the action Paste.
  */
 export function getStandardActionPaste(
 	converterContext: ConverterContext,
@@ -321,17 +321,17 @@ export function getStandardActionPaste(
 	const createEnablement = getCreateEnablement(converterContext, standardActionsContext, createVisibility);
 	const pasteVisibility = getPasteVisibility(converterContext, standardActionsContext, createVisibility, isInsertUpdateActionsTemplated);
 	return {
-		visible: compileBinding(pasteVisibility),
-		enabled: compileBinding(getPasteEnablement(pasteVisibility, createEnablement))
+		visible: compileExpression(pasteVisibility),
+		enabled: compileExpression(getPasteEnablement(pasteVisibility, createEnablement))
 	};
 }
 
 /**
  * Gets the binding expressions for the properties of the action MassEdit.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @returns {StandardActionConfigType}
+ * @param converterContext
+ * @param standardActionsContext
+ * @returns The binding expressions for the properties of the action MassEdit.
  */
 export function getStandardActionMassEdit(
 	converterContext: ConverterContext,
@@ -340,25 +340,25 @@ export function getStandardActionMassEdit(
 	const massEditVisibility = getMassEditVisibility(converterContext, standardActionsContext);
 
 	return {
-		isTemplated: compileBinding(getDefaultTemplating(massEditVisibility)),
-		visible: compileBinding(massEditVisibility),
-		enabled: compileBinding(getMassEditEnablement(converterContext, standardActionsContext, massEditVisibility))
+		isTemplated: compileExpression(getDefaultTemplating(massEditVisibility)),
+		visible: compileExpression(massEditVisibility),
+		enabled: compileExpression(getMassEditEnablement(converterContext, standardActionsContext, massEditVisibility))
 	};
 }
 
 /**
  * Gets the binding expression for the templating of the action Create.
  *
- * @param {StandardActionsContext} standardActionsContext
- * @param {Expression<boolean>} createVisibility
- * @param {boolean} isForCreationRow
- * @returns {Expression<boolean> }
+ * @param standardActionsContext
+ * @param createVisibility
+ * @param isForCreationRow
+ * @returns The create binding expression
  */
 export function getCreateTemplating(
 	standardActionsContext: StandardActionsContext,
-	createVisibility: Expression<boolean>,
+	createVisibility: BindingToolkitExpression<boolean>,
 	isForCreationRow = false
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	//Templating of Create Button is not done:
 	// 	 - If Button is never visible(covered the External create button, new Action)
 	//	 - or CreationMode is on CreationRow for Create Button
@@ -377,26 +377,26 @@ export function getCreateTemplating(
 /**
  * Gets the binding expression for the templating of the non-Create actions.
  *
- * @param {Expression<boolean>} actionVisibility
- * @returns {Expression<boolean> }
+ * @param actionVisibility
+ * @returns The binding expression for the templating of the non-Create actions.
  */
-export function getDefaultTemplating(actionVisibility: Expression<boolean>): Expression<boolean> {
+export function getDefaultTemplating(actionVisibility: BindingToolkitExpression<boolean>): BindingToolkitExpression<boolean> {
 	return or(not(isConstant(actionVisibility)), actionVisibility);
 }
 
 /**
  * Gets the binding expression for the property visible of the action Create.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @param {boolean} isForCreationRow
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @param isForCreationRow
+ * @returns The binding expression for the property visible of the action Create.
  */
 export function getCreateVisibility(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
 	isForCreationRow = false
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
 	const isCreateHidden = isForCreationRow
 		? isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.CreateHidden, false)
@@ -438,7 +438,7 @@ export function getCreateVisibility(
 			false,
 			ifElse(
 				converterContext.getTemplateType() === TemplateType.ListReport,
-				or(not(isBinding(isCreateHidden)), not(isCreateHidden)),
+				or(not(isPathInModelExpression(isCreateHidden)), not(isCreateHidden)),
 				and(not(isCreateHidden), UI.IsEditable)
 			)
 		)
@@ -448,14 +448,14 @@ export function getCreateVisibility(
 /**
  * Gets the binding expression for the property visible of the action Delete.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @returns The binding expression for the property visible of the action Delete.
  */
 export function getDeleteVisibility(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const isDeleteHidden = standardActionsContext.hiddenAnnotation.delete;
 	const pathDeletableExpression = standardActionsContext.restrictions.isDeletable.expression;
 
@@ -484,7 +484,7 @@ export function getDeleteVisibility(
 				ifElse(
 					converterContext.getTemplateType() !== TemplateType.ListReport,
 					and(not(isDeleteHidden), UI.IsEditable),
-					not(and(isBinding(isDeleteHidden), isDeleteHidden))
+					not(and(isPathInModelExpression(isDeleteHidden), isDeleteHidden))
 				)
 			)
 		)
@@ -494,18 +494,18 @@ export function getDeleteVisibility(
 /**
  * Gets the binding expression for the property visible of the action Paste.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @param {Expression<boolean>} createVisibility
- * @param {boolean} isInsertUpdateActionsTemplated
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @param createVisibility
+ * @param isInsertUpdateActionsTemplated
+ * @returns The binding expression for the property visible of the action Paste.
  */
 export function getPasteVisibility(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
-	createVisibility: Expression<boolean>,
+	createVisibility: BindingToolkitExpression<boolean>,
 	isInsertUpdateActionsTemplated: boolean
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	// If Create is visible, enablePaste is not disabled into manifest and we are on OP/blocks outside Fiori elements templates
 	// Then button will be visible according to insertable restrictions and create visibility
 	// Otherwise it's not visible
@@ -521,14 +521,14 @@ export function getPasteVisibility(
 /**
  * Gets the binding expression for the property visible of the action MassEdit.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @returns The binding expression for the property visible of the action MassEdit
  */
 export function getMassEditVisibility(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const isUpdateHidden = standardActionsContext.hiddenAnnotation.update,
 		pathUpdatableExpression = standardActionsContext.restrictions.isUpdatable.expression,
 		bMassEditEnabledInManifest: boolean = standardActionsContext.tableManifestConfiguration?.enableMassEdit || false;
@@ -554,16 +554,16 @@ export function getMassEditVisibility(
 /**
  * Gets the binding expression for the property enabled of the creationRow.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @param {Expression<boolean>} creationRowVisibility
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @param creationRowVisibility
+ * @returns The binding expression for the property enabled of the creationRow.
  */
 export function getCreationRowEnablement(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
-	creationRowVisibility: Expression<boolean>
-): Expression<boolean> {
+	creationRowVisibility: BindingToolkitExpression<boolean>
+): BindingToolkitExpression<boolean> {
 	const restrictionsInsertable = isPathInsertable(converterContext.getDataModelObjectPath(), {
 		ignoreTargetCollection: true,
 		authorizeUnresolvable: true,
@@ -594,7 +594,7 @@ export function getCreationRowEnablement(
 		isInsertable,
 		or(
 			!standardActionsContext.tableManifestConfiguration.disableAddRowButtonForEmptyData,
-			formatResult([bindingExpression("creationRowFieldValidity", "internal")], tableFormatters.validateCreationRowFields)
+			formatResult([pathInModel("creationRowFieldValidity", "internal")], tableFormatters.validateCreationRowFields)
 		)
 	);
 }
@@ -602,16 +602,16 @@ export function getCreationRowEnablement(
 /**
  * Gets the binding expression for the property enabled of the action Create.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @param {Expression<boolean>} createVisibility
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @param createVisibility
+ * @returns The binding expression for the property enabled of the action Create.
  */
 export function getCreateEnablement(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
-	createVisibility: Expression<boolean>
-): Expression<boolean> {
+	createVisibility: BindingToolkitExpression<boolean>
+): BindingToolkitExpression<boolean> {
 	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
 	const CollectionType = converterContext.resolveAbsolutePath<any>(standardActionsContext.collectionPath).target?._type;
 	return and(
@@ -626,22 +626,22 @@ export function getCreateEnablement(
 /**
  * Gets the binding expression for the property enabled of the action Delete.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @param {Expression<boolean>} deleteVisibility
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @param deleteVisibility
+ * @returns The binding expression for the property enabled of the action Delete.
  */
 export function getDeleteEnablement(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
-	deleteVisibility: Expression<boolean>
-): Expression<boolean> {
+	deleteVisibility: BindingToolkitExpression<boolean>
+): BindingToolkitExpression<boolean> {
 	const isDeletable = standardActionsContext.restrictions.isDeletable.expression;
 	const isOnlyDynamicOnCurrentEntity =
 		!isConstant(isDeletable) && standardActionsContext.restrictions.isDeletable.navigationExpression._type === "Unresolvable";
-	const numberOfSelectedContexts = bindingExpression("numberOfSelectedContexts", "internal");
-	const numberOfDeletableContexts = bindingExpression("deletableContexts", "internal");
-	const numberOfUnSavedContexts = bindingExpression("unSavedContexts", "internal");
+	const numberOfSelectedContexts = pathInModel("numberOfSelectedContexts", "internal");
+	const numberOfDeletableContexts = pathInModel("deletableContexts", "internal");
+	const numberOfUnSavedContexts = pathInModel("unSavedContexts", "internal");
 
 	return and(
 		deleteVisibility,
@@ -652,7 +652,7 @@ export function getDeleteEnablement(
 					and(notEqual(numberOfDeletableContexts, undefined), greaterThan(length(numberOfDeletableContexts), 0)),
 					and(notEqual(numberOfUnSavedContexts, undefined), greaterThan(length(numberOfUnSavedContexts), 0))
 				),
-				bindingExpression("deleteEnabled", "internal")
+				pathInModel("deleteEnabled", "internal")
 			),
 			and(notEqual(numberOfSelectedContexts, 0), isDeletable)
 		)
@@ -662,33 +662,36 @@ export function getDeleteEnablement(
 /**
  * Gets the binding expression for the property enabled of the action Paste.
  *
- * @param {Expression<boolean>} pasteVisibility
- * @param {Expression<boolean>} createEnablement
- * @returns {Expression<boolean> }
+ * @param pasteVisibility
+ * @param createEnablement
+ * @returns The binding expression for the property enabled of the action Paste.
  */
-export function getPasteEnablement(pasteVisibility: Expression<boolean>, createEnablement: Expression<boolean>): Expression<boolean> {
+export function getPasteEnablement(
+	pasteVisibility: BindingToolkitExpression<boolean>,
+	createEnablement: BindingToolkitExpression<boolean>
+): BindingToolkitExpression<boolean> {
 	return and(pasteVisibility, createEnablement);
 }
 
 /**
  * Gets the binding expression for the property enabled of the action MassEdit.
  *
- * @param {ConverterContext} converterContext
- * @param {StandardActionsContext} standardActionsContext
- * @param {Expression<boolean>} massEditVisibility
- * @returns {Expression<boolean> }
+ * @param converterContext
+ * @param standardActionsContext
+ * @param massEditVisibility
+ * @returns The binding expression for the property enabled of the action MassEdit.
  */
 export function getMassEditEnablement(
 	converterContext: ConverterContext,
 	standardActionsContext: StandardActionsContext,
-	massEditVisibility: Expression<boolean>
-): Expression<boolean> {
+	massEditVisibility: BindingToolkitExpression<boolean>
+): BindingToolkitExpression<boolean> {
 	const pathUpdatableExpression = standardActionsContext.restrictions.isUpdatable.expression;
 	const isOnlyDynamicOnCurrentEntity: any =
 		!isConstant(pathUpdatableExpression) &&
 		standardActionsContext.restrictions.isUpdatable.navigationExpression._type === "Unresolvable";
-	const numberOfSelectedContexts = greaterOrEqual(bindingExpression("numberOfSelectedContexts", "internal"), 1);
-	const numberOfUpdatableContexts = greaterOrEqual(length(bindingExpression("updatableContexts", "internal")), 1);
+	const numberOfSelectedContexts = greaterOrEqual(pathInModel("numberOfSelectedContexts", "internal"), 1);
+	const numberOfUpdatableContexts = greaterOrEqual(length(pathInModel("updatableContexts", "internal")), 1);
 	const bIsDraftSupported = isDraftSupported(converterContext);
 	const bDisplayMode = isInDisplayMode(converterContext);
 
@@ -708,9 +711,9 @@ export function getMassEditEnablement(
 /**
  * Tells if the table in template is in display mode.
  *
- * @param {ConverterContext} converterContext
- * @param {ViewPathConfiguration} viewConfiguration
- * @returns {boolean}
+ * @param converterContext
+ * @param viewConfiguration
+ * @returns `true` if the table is in display mode
  */
 export function isInDisplayMode(converterContext: ConverterContext, viewConfiguration?: ViewPathConfiguration): boolean {
 	const templateType = converterContext.getTemplateType();