@sapui5/sap.fe.core 1.102.0 → 1.103.0

package/src/sap/fe/core/templating/UIFormatters.ts

@@ -1,31 +1,29 @@
-import { NavigationProperty, Property } from "@sap-ux/annotation-converter";
-import { DataFieldAbstractTypes } from "@sap-ux/vocabularies-types";
-import { PathAnnotationExpression } from "@sap-ux/vocabularies-types/types/Edm";
-import { UIAnnotationTypes } from "@sap-ux/vocabularies-types/types/generated/UI";
+import type { NavigationProperty, PathAnnotationExpression, Property } from "@sap-ux/vocabularies-types";
+import type { DataFieldAbstractTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
+import { UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
 import { singletonPathVisitor, UI } from "sap/fe/core/converters/helpers/BindingHelper";
 import { convertMetaModelContext, getInvolvedDataModelObjects } from "sap/fe/core/converters/MetaModelConverter";
 import valueFormatters from "sap/fe/core/formatters/ValueFormatter";
+import type { BindingToolkitExpression, CompiledBindingToolkitExpression, PathInModelExpression } from "sap/fe/core/helpers/BindingToolkit";
 import {
 	addTypeInformation,
 	and,
-	annotationExpression,
-	bindingExpression,
-	BindingExpression,
-	BindingExpressionExpression,
-	compileBinding,
+	compileExpression,
 	constant,
 	equal,
-	Expression,
-	ExpressionOrPrimitive,
 	formatResult,
+	getExpressionFromAnnotation,
 	ifElse,
 	isConstant,
 	isTruthy,
 	not,
-	or
-} from "sap/fe/core/helpers/BindingExpression";
+	notEqual,
+	or,
+	pathInModel
+} from "sap/fe/core/helpers/BindingToolkit";
 import {
 	DataModelObjectPath,
+	getContextRelativeTargetObjectPath,
 	getPathRelativeLocation,
 	getTargetObjectPath,
 	isPathUpdatable
@@ -47,7 +45,7 @@ import {
 	isPathExpression,
 	isProperty
 } from "sap/fe/core/templating/PropertyHelper";
-import Context from "sap/ui/model/odata/v4/Context";
+import type Context from "sap/ui/model/odata/v4/Context";
 
 // Import-export method used by the converter to use them in the templating through the UIFormatters.
 export type DisplayMode = DisplayModeFormatter.DisplayMode;
@@ -90,28 +88,41 @@ export type configType = {
 export const getDisplayMode = function (oDataModelObjectPath: DataModelObjectPath): DisplayMode {
 	return DisplayModeFormatter.getDisplayMode(oDataModelObjectPath.targetObject, oDataModelObjectPath);
 };
-
+export const getEditableExpressionAsObject = function (
+	oPropertyPath: PropertyOrPath<Property>,
+	oDataFieldConverted: any = null,
+	oDataModelObjectPath: DataModelObjectPath,
+	isEditable: BindingToolkitExpression<boolean> = UI.IsEditable
+): BindingToolkitExpression<boolean> {
+	return getEditableExpression(
+		oPropertyPath,
+		oDataFieldConverted,
+		oDataModelObjectPath,
+		true,
+		isEditable
+	) as BindingToolkitExpression<boolean>;
+};
 /**
  * Create the expression to generate an "editable" boolean value.
  *
- * @param {PropertyPath} oPropertyPath The input property
- * @param {object} oDataFieldConverted The DataFieldConverted object to read the fieldControl annotation
- * @param {DataModelObjectPath} oDataModelObjectPath The path to this property object
- * @param {boolean} bAsObject Whether or not this should be returned as an object or a binding string
- * @param {boolean} isEditable Whether or not UI.IsEditable be considered.
- * @returns {string} The binding expression used to determine if a property is editable or not
+ * @param oPropertyPath The input property
+ * @param oDataFieldConverted The DataFieldConverted object to read the fieldControl annotation
+ * @param oDataModelObjectPath The path to this property object
+ * @param bAsObject Whether or not this should be returned as an object or a binding string
+ * @param isEditable Whether or not UI.IsEditable be considered.
+ * @returns The binding expression used to determine if a property is editable or not
  */
 export const getEditableExpression = function (
 	oPropertyPath: PropertyOrPath<Property>,
 	oDataFieldConverted: any = null,
 	oDataModelObjectPath: DataModelObjectPath,
 	bAsObject: boolean = false,
-	isEditable: ExpressionOrPrimitive<boolean> = UI.IsEditable
-): BindingExpression<boolean> | ExpressionOrPrimitive<boolean> {
+	isEditable: BindingToolkitExpression<boolean> = UI.IsEditable
+): CompiledBindingToolkitExpression | BindingToolkitExpression<boolean> {
 	if (!oPropertyPath || typeof oPropertyPath === "string") {
-		return compileBinding(false);
+		return compileExpression(false);
 	}
-	let dataFieldEditableExpression: BindingExpression<boolean> | ExpressionOrPrimitive<boolean> = true;
+	let dataFieldEditableExpression: BindingToolkitExpression<boolean> = constant(true);
 	if (oDataFieldConverted !== null) {
 		dataFieldEditableExpression = ifElse(isNonEditableExpression(oDataFieldConverted), false, isEditable);
 	}
@@ -146,38 +157,46 @@ export const getEditableExpression = function (
 	if (bAsObject) {
 		return and(editableExpression, dataFieldEditableExpression);
 	}
-	return compileBinding(and(editableExpression, dataFieldEditableExpression));
+	return compileExpression(and(editableExpression, dataFieldEditableExpression));
 };
 
-export const getCollaborationExpression = function (dataModelObjectPath: DataModelObjectPath, formatter: any): BindingExpression<any> {
+export const getCollaborationExpression = function (
+	dataModelObjectPath: DataModelObjectPath,
+	formatter: any
+): BindingToolkitExpression<any> {
 	const objectPath = getTargetObjectPath(dataModelObjectPath);
-	const activityExpression = bindingExpression("/collaboration/activities" + objectPath, "internal");
+	const activityExpression = pathInModel(`/collaboration/activities${objectPath}`, "internal");
 	const keys = dataModelObjectPath?.targetEntityType?.keys;
-	const keysExpressions: BindingExpressionExpression<any>[] = [];
+	const keysExpressions: BindingToolkitExpression<any>[] = [];
 	keys?.forEach(function (key) {
-		const keyExpression = bindingExpression(key.name) as BindingExpressionExpression<any>;
+		const keyExpression = pathInModel(key.name);
 		keysExpressions.push(keyExpression);
 	});
 	return formatResult([activityExpression, ...keysExpressions], formatter);
 };
-
+export const getEnabledExpressionAsObject = function (
+	oPropertyPath: PropertyOrPath<Property>,
+	oDataFieldConverted?: any
+): BindingToolkitExpression<boolean> {
+	return getEnabledExpression(oPropertyPath, oDataFieldConverted, true) as BindingToolkitExpression<boolean>;
+};
 /**
  * Create the expression to generate an "enabled" boolean value.
  *
- * @param {PropertyPath} oPropertyPath The input property
- * @param {any} oDataFieldConverted The DataFieldConverted Object to read the fieldControl annotation
- * @param {boolean} bAsObject Whether or not this should be returned as an object or a binding string
- * @returns {string} The binding expression to determine if a property is enabled or not
+ * @param oPropertyPath The input property
+ * @param oDataFieldConverted The DataFieldConverted Object to read the fieldControl annotation
+ * @param bAsObject Whether or not this should be returned as an object or a binding string
+ * @returns The binding expression to determine if a property is enabled or not
  */
 export const getEnabledExpression = function (
 	oPropertyPath: PropertyOrPath<Property>,
 	oDataFieldConverted?: any,
 	bAsObject: boolean = false
-): BindingExpression<boolean> | ExpressionOrPrimitive<boolean> {
+): CompiledBindingToolkitExpression | BindingToolkitExpression<boolean> {
 	if (!oPropertyPath || typeof oPropertyPath === "string") {
-		return compileBinding(true);
+		return compileExpression(true);
 	}
-	let dataFieldEnabledExpression: BindingExpression<boolean> | ExpressionOrPrimitive<boolean> = true;
+	let dataFieldEnabledExpression: BindingToolkitExpression<boolean> = constant(true);
 	if (oDataFieldConverted !== null) {
 		dataFieldEnabledExpression = ifElse(isDisabledExpression(oDataFieldConverted), false, true);
 	}
@@ -189,19 +208,19 @@ export const getEnabledExpression = function (
 	if (bAsObject) {
 		return and(enabledExpression, dataFieldEnabledExpression);
 	}
-	return compileBinding(and(enabledExpression, dataFieldEnabledExpression));
+	return compileExpression(and(enabledExpression, dataFieldEnabledExpression));
 };
 
 /**
  * Create the expression to generate an "editMode" enum value.
  *
- * @param {PropertyPath} oPropertyPath The input property
- * @param {DataModelObjectPath} oDataModelObjectPath The list of data model objects that are involved to reach that property
- * @param {boolean} bMeasureReadOnly Whether we should set UoM / currency field mode to read only
- * @param {boolean} bAsObject Whether we should return this as an expression or as a string
- * @param {object} oDataFieldConverted The dataField object
- * @param {boolean} isEditable Whether or not UI.IsEditable be considered.
- * @returns {BindingExpression<string> | ExpressionOrPrimitive<string>} The binding expression representing the current property edit mode, compliant with the MDC Field definition of editMode.
+ * @param oPropertyPath The input property
+ * @param oDataModelObjectPath The list of data model objects that are involved to reach that property
+ * @param bMeasureReadOnly Whether we should set UoM / currency field mode to read only
+ * @param bAsObject Whether we should return this as an expression or as a string
+ * @param oDataFieldConverted The dataField object
+ * @param isEditable Whether or not UI.IsEditable be considered.
+ * @returns The binding expression representing the current property edit mode, compliant with the MDC Field definition of editMode.
  */
 export const getEditMode = function (
 	oPropertyPath: PropertyOrPath<Property>,
@@ -209,8 +228,8 @@ export const getEditMode = function (
 	bMeasureReadOnly: boolean = false,
 	bAsObject: boolean = false,
 	oDataFieldConverted: any = null,
-	isEditable: ExpressionOrPrimitive<boolean> = UI.IsEditable
-): BindingExpression<string> | ExpressionOrPrimitive<string> {
+	isEditable: BindingToolkitExpression<boolean> = UI.IsEditable
+): CompiledBindingToolkitExpression | BindingToolkitExpression<string> {
 	if (!oPropertyPath || typeof oPropertyPath === "string") {
 		return "Display";
 	}
@@ -221,18 +240,12 @@ export const getEditMode = function (
 	// If there is an associated unit, and it has a field control also use consider the following
 	// if the unit field control is readonly -> EditableReadOnly
 	// otherwise -> Editable
-	const editableExpression = getEditableExpression(
-		oPropertyPath,
-		oDataFieldConverted,
-		oDataModelObjectPath,
-		true,
-		isEditable
-	) as ExpressionOrPrimitive<boolean>;
+	const editableExpression = getEditableExpressionAsObject(oPropertyPath, oDataFieldConverted, oDataModelObjectPath, isEditable);
 
-	const enabledExpression = getEnabledExpression(oPropertyPath, oDataFieldConverted, true) as ExpressionOrPrimitive<boolean>;
+	const enabledExpression = getEnabledExpressionAsObject(oPropertyPath, oDataFieldConverted);
 	const associatedCurrencyProperty = getAssociatedCurrencyProperty(oProperty);
 	const unitProperty = associatedCurrencyProperty || getAssociatedUnitProperty(oProperty);
-	let resultExpression: ExpressionOrPrimitive<string> = "Editable";
+	let resultExpression: BindingToolkitExpression<string> = constant("Editable");
 	if (unitProperty) {
 		resultExpression = ifElse(
 			or(isReadOnlyExpression(unitProperty), isComputed(unitProperty), bMeasureReadOnly),
@@ -256,54 +269,56 @@ export const getEditMode = function (
 	if (bAsObject) {
 		return editModeExpression;
 	}
-	return compileBinding(editModeExpression);
+	return compileExpression(editModeExpression);
 };
 
-export const hasValidAnalyticalCurrencyOrUnit = function (oPropertyDataModelObjectPath: DataModelObjectPath): BindingExpression<string> {
+export const hasValidAnalyticalCurrencyOrUnit = function (
+	oPropertyDataModelObjectPath: DataModelObjectPath
+): CompiledBindingToolkitExpression {
 	const oPropertyDefinition = oPropertyDataModelObjectPath.targetObject as Property;
 	const currency = oPropertyDefinition.annotations?.Measures?.ISOCurrency;
 	const measure = currency ? currency : oPropertyDefinition.annotations?.Measures?.Unit;
 	if (measure) {
-		return compileBinding(or(isTruthy(annotationExpression(measure) as Expression<string>), not(UI.IsTotal)));
+		return compileExpression(or(isTruthy(getExpressionFromAnnotation(measure) as BindingToolkitExpression<string>), not(UI.IsTotal)));
 	} else {
-		return compileBinding(constant(true));
+		return compileExpression(constant(true));
 	}
 };
 
 export const ifUnitEditable = function (
 	oPropertyPath: PropertyOrPath<Property>,
-	sEditableValue: ExpressionOrPrimitive<string>,
-	sNonEditableValue: ExpressionOrPrimitive<string>
-): BindingExpression<string> {
+	sEditableValue: BindingToolkitExpression<string> | string,
+	sNonEditableValue: BindingToolkitExpression<string> | string
+): CompiledBindingToolkitExpression {
 	const oProperty = (isPathExpression(oPropertyPath) && oPropertyPath.$target) || (oPropertyPath as Property);
 	const unitProperty = getAssociatedCurrencyProperty(oProperty) || getAssociatedUnitProperty(oProperty);
 	if (!unitProperty) {
-		return compileBinding(sNonEditableValue);
+		return compileExpression(sNonEditableValue);
 	}
 	const editableExpression = and(not(isReadOnlyExpression(unitProperty)), not(isComputed(unitProperty)));
-	return compileBinding(ifElse(editableExpression, sEditableValue, sNonEditableValue));
+	return compileExpression(ifElse(editableExpression, sEditableValue, sNonEditableValue));
 };
 
 export const getFieldDisplay = function (
 	oPropertyPath: PropertyOrPath<Property>,
 	sTargetDisplayMode: string,
-	oComputedEditMode: ExpressionOrPrimitive<string>
-): BindingExpression<string> {
+	oComputedEditMode: BindingToolkitExpression<string>
+): CompiledBindingToolkitExpression {
 	const oProperty = (isPathExpression(oPropertyPath) && oPropertyPath.$target) || (oPropertyPath as Property);
 
 	return hasValueHelp(oProperty)
-		? compileBinding(sTargetDisplayMode)
-		: compileBinding(ifElse(equal(oComputedEditMode, "Editable"), "Value", sTargetDisplayMode));
+		? compileExpression(sTargetDisplayMode)
+		: compileExpression(ifElse(equal(oComputedEditMode, "Editable"), "Value", sTargetDisplayMode));
 };
 
 export const formatWithTypeInformation = function (
 	oProperty: Property,
-	propertyBindingExpression: Expression<string>,
+	propertyBindingExpression: BindingToolkitExpression<string>,
 	ignoreConstraints?: boolean
-): Expression<string> {
-	const outExpression: BindingExpressionExpression<any> = propertyBindingExpression as BindingExpressionExpression<any>;
+): BindingToolkitExpression<string> {
+	const outExpression: PathInModelExpression<any> = propertyBindingExpression as PathInModelExpression<any>;
 	if (oProperty._type === "Property") {
-		const oTargetMapping = EDM_TYPE_MAPPING[(oProperty as Property).type];
+		const oTargetMapping = EDM_TYPE_MAPPING[oProperty.type];
 		if (oTargetMapping) {
 			outExpression.type = oTargetMapping.type;
 			if (oTargetMapping.constraints && !ignoreConstraints) {
@@ -403,7 +418,7 @@ export const getTypeConfig = function (oProperty: Property | DataFieldAbstractTy
 			isDigitSequence:
 				propertyTypeConfig.type === "sap.ui.model.odata.type.String" &&
 				oTargetMapping.constraints?.["@com.sap.vocabularies.Common.v1.IsDigitSequence"] &&
-				(oProperty as Property).annotations?.Common?.IsDigitSequence
+				oProperty.annotations?.Common?.IsDigitSequence
 					? true
 					: undefined,
 			V4: oTargetMapping.constraints?.$V4 ? true : undefined
@@ -427,9 +442,10 @@ export const getTypeConfig = function (oProperty: Property | DataFieldAbstractTy
 
 export const getBindingWithUnitOrCurrency = function (
 	oPropertyDataModelPath: DataModelObjectPath,
-	propertyBindingExpression: Expression<string>,
-	ignoreUnitConstraint?: boolean
-): Expression<string> {
+	propertyBindingExpression: BindingToolkitExpression<string>,
+	ignoreUnitConstraint?: boolean,
+	formatOptions?: any
+): BindingToolkitExpression<string> {
 	const oPropertyDefinition = oPropertyDataModelPath.targetObject as Property;
 	let unit = oPropertyDefinition.annotations?.Measures?.Unit;
 	const relativeLocation = getPathRelativeLocation(
@@ -445,20 +461,53 @@ export const getBindingWithUnitOrCurrency = function (
 	const unitBindingExpression = (unit as any).$target
 		? formatWithTypeInformation(
 				(unit as any).$target,
-				annotationExpression(unit, relativeLocation) as Expression<string>,
+				getExpressionFromAnnotation(unit, relativeLocation) as BindingToolkitExpression<string>,
 				ignoreUnitConstraint
 		  )
-		: (annotationExpression(unit, relativeLocation) as Expression<string>);
+		: (getExpressionFromAnnotation(unit, relativeLocation) as BindingToolkitExpression<string>);
 
-	return addTypeInformation([propertyBindingExpression, unitBindingExpression], complexType);
+	return addTypeInformation([propertyBindingExpression, unitBindingExpression], complexType, undefined, formatOptions);
 };
 
+export const getBindingForUnitOrCurrency = function (
+	oPropertyDataModelPath: DataModelObjectPath
+): BindingToolkitExpression<string> | string {
+	const oPropertyDefinition = oPropertyDataModelPath.targetObject as Property;
+
+	let unit = oPropertyDefinition.annotations?.Measures?.Unit;
+	if (unit?.toString() === "%") {
+		return constant("%");
+	}
+	const relativeLocation = getPathRelativeLocation(
+		oPropertyDataModelPath.contextLocation,
+		oPropertyDataModelPath.navigationProperties
+	).map((np) => np.name);
+
+	const complexType = unit ? "sap.ui.model.odata.type.Unit" : "sap.ui.model.odata.type.Currency";
+	unit = unit ? unit : oPropertyDefinition.annotations?.Measures?.ISOCurrency;
+	const unitBindingExpression = (unit as any).$target
+		? formatWithTypeInformation(
+				(unit as any).$target,
+				getExpressionFromAnnotation(unit, relativeLocation) as BindingToolkitExpression<string>
+		  )
+		: (getExpressionFromAnnotation(unit, relativeLocation) as BindingToolkitExpression<string>);
+
+	let propertyBindingExpression = pathInModel(
+		getContextRelativeTargetObjectPath(oPropertyDataModelPath)
+	) as BindingToolkitExpression<string>;
+	propertyBindingExpression = formatWithTypeInformation(oPropertyDefinition, propertyBindingExpression, true);
+	return addTypeInformation([propertyBindingExpression, unitBindingExpression], complexType, undefined, {
+		parseKeepsEmptyString: true,
+		emptyString: "",
+		showNumber: false
+	});
+};
 export const getBindingWithTimezone = function (
 	oPropertyDataModelPath: DataModelObjectPath,
-	propertyBindingExpression: Expression<string>,
+	propertyBindingExpression: BindingToolkitExpression<string>,
 	ignoreUnitConstraint?: boolean,
 	hideTimezoneForEmptyValues?: boolean
-): Expression<string> {
+): BindingToolkitExpression<string> {
 	const oPropertyDefinition = oPropertyDataModelPath.targetObject as Property;
 	const timezone = oPropertyDefinition.annotations?.Common?.Timezone;
 	const relativeLocation = getPathRelativeLocation(
@@ -471,10 +520,10 @@ export const getBindingWithTimezone = function (
 	const unitBindingExpression = (timezone as any).$target
 		? formatWithTypeInformation(
 				(timezone as any).$target,
-				annotationExpression(timezone, relativeLocation) as Expression<string>,
+				getExpressionFromAnnotation(timezone, relativeLocation) as BindingToolkitExpression<string>,
 				ignoreUnitConstraint
 		  )
-		: (annotationExpression(timezone, relativeLocation) as Expression<string>);
+		: (getExpressionFromAnnotation(timezone, relativeLocation) as BindingToolkitExpression<string>);
 	let formatOptions;
 	if (hideTimezoneForEmptyValues) {
 		formatOptions = {
@@ -485,19 +534,19 @@ export const getBindingWithTimezone = function (
 };
 
 export const getAlignmentExpression = function (
-	oComputedEditMode: Expression<string>,
+	oComputedEditMode: BindingToolkitExpression<string>,
 	sAlignDisplay: string = "Begin",
 	sAlignEdit: string = "Begin"
-): BindingExpression<string> | Expression<string> {
-	return compileBinding(ifElse(equal(oComputedEditMode, "Display"), sAlignDisplay, sAlignEdit));
+): CompiledBindingToolkitExpression | BindingToolkitExpression<string> {
+	return compileExpression(ifElse(equal(oComputedEditMode, "Display"), sAlignDisplay, sAlignEdit));
 };
 
 /**
  * Formatter helper to retrieve the converterContext from the metamodel context.
  *
- * @param {Context} oContext The original metamodel context
- * @param {ComputedAnnotationInterface} oInterface The current templating context
- * @returns {object} The ConverterContext representing that object
+ * @param oContext The original metamodel context
+ * @param oInterface The current templating context
+ * @returns The ConverterContext representing that object
  */
 export const getConverterContext = function (oContext: MetaModelContext, oInterface: ComputedAnnotationInterface): object | null {
 	if (oInterface && oInterface.context) {
@@ -510,9 +559,9 @@ getConverterContext.requiresIContext = true;
 /**
  * Formatter helper to retrieve the data model objects that are involved from the metamodel context.
  *
- * @param {Context} oContext The original ODataMetaModel context
- * @param {ComputedAnnotationInterface} oInterface The current templating context
- * @returns {object[]} An array of entitysets and navproperties that are involved to get to a specific object in the metamodel
+ * @param oContext The original ODataMetaModel context
+ * @param oInterface The current templating context
+ * @returns An array of entitysets and navproperties that are involved to get to a specific object in the metamodel
  */
 export const getDataModelObjectPath = function (
 	oContext: MetaModelContext,
@@ -525,16 +574,6 @@ export const getDataModelObjectPath = function (
 };
 getDataModelObjectPath.requiresIContext = true;
 
-/**
- * Retrieves the expressionBinding created out of a binding expression.
- *
- * @param {Expression<any>} expression The expression which needs to be compiled
- * @returns {BindingExpression<string>} The expression-binding string
- */
-export const getExpressionBinding = function (expression: Expression<any>): BindingExpression<string> {
-	return compileBinding(expression);
-};
-
 export const isCollectionField = function (oDataModelPath: DataModelObjectPath): boolean {
 	if (oDataModelPath.navigationProperties?.length) {
 		const hasOneToManyNavigation =
@@ -558,39 +597,71 @@ export const isCollectionField = function (oDataModelPath: DataModelObjectPath):
 	}
 	return false;
 };
-
+export const getRequiredExpressionAsObject = function (
+	oPropertyPath: PropertyOrPath<Property>,
+	oDataFieldConverted?: any,
+	forceEditMode: boolean = false
+): BindingToolkitExpression<boolean> {
+	return getRequiredExpression(oPropertyPath, oDataFieldConverted, forceEditMode, true) as BindingToolkitExpression<boolean>;
+};
 export const getRequiredExpression = function (
 	oPropertyPath: PropertyOrPath<Property>,
 	oDataFieldConverted?: any,
 	forceEditMode: boolean = false,
-	bAsObject: boolean = false
-): BindingExpression<boolean> | ExpressionOrPrimitive<boolean> {
+	bAsObject: boolean = false,
+	oRequiredProperties: any = {}
+): CompiledBindingToolkitExpression | BindingToolkitExpression<boolean> {
+	let returnExpression: BindingToolkitExpression<boolean>;
+	const aRequiredPropertiesFromInsertRestrictions = oRequiredProperties.requiredPropertiesFromInsertRestrictions || [];
+	const aRequiredPropertiesFromUpdateRestrictions = oRequiredProperties.requiredPropertiesFromUpdateRestrictions || [];
 	if (!oPropertyPath || typeof oPropertyPath === "string") {
-		return compileBinding(false);
-	}
-
-	let dataFieldRequiredExpression: BindingExpression<boolean> | ExpressionOrPrimitive<boolean> = true;
-	if (oDataFieldConverted !== null) {
-		dataFieldRequiredExpression = isRequiredExpression(oDataFieldConverted);
+		returnExpression = constant(false);
+	} else {
+		let dataFieldRequiredExpression: BindingToolkitExpression<boolean> = constant(true);
+		if (oDataFieldConverted !== null) {
+			dataFieldRequiredExpression = isRequiredExpression(oDataFieldConverted);
+		}
+		let requiredPropertyFromInsertRestrictionsExpression: BindingToolkitExpression<boolean> = constant(false);
+		let requiredPropertyFromUpdateRestrictionsExpression: BindingToolkitExpression<boolean> = constant(false);
+
+		const oProperty: Property = (isPathExpression(oPropertyPath) && oPropertyPath.$target) || (oPropertyPath as Property);
+		// Enablement depends on the field control expression
+		// If the Field control is statically in Inapplicable (disabled) -> not enabled
+		const requiredExpression = isRequiredExpression(oProperty);
+		const editMode = forceEditMode || UI.IsEditable;
+		if (
+			aRequiredPropertiesFromInsertRestrictions.length &&
+			aRequiredPropertiesFromInsertRestrictions.includes((oPropertyPath as any).name)
+		) {
+			requiredPropertyFromInsertRestrictionsExpression = and(constant(true), UI.IsCreateMode);
+		}
+		if (
+			aRequiredPropertiesFromUpdateRestrictions.length &&
+			aRequiredPropertiesFromUpdateRestrictions.includes((oPropertyPath as any).name)
+		) {
+			requiredPropertyFromUpdateRestrictionsExpression = and(constant(true), notEqual(UI.IsCreateMode, true));
+		}
+		returnExpression = or(
+			and(or(requiredExpression, dataFieldRequiredExpression), editMode),
+			requiredPropertyFromInsertRestrictionsExpression,
+			requiredPropertyFromUpdateRestrictionsExpression
+		);
 	}
 
-	const oProperty: Property = (isPathExpression(oPropertyPath) && oPropertyPath.$target) || (oPropertyPath as Property);
-	// Enablement depends on the field control expression
-	// If the Field control is statically in Inapplicable (disabled) -> not enabled
-	const requiredExpression = isRequiredExpression(oProperty);
-	const editMode = forceEditMode || UI.IsEditable;
 	if (bAsObject) {
-		return and(or(requiredExpression, dataFieldRequiredExpression), editMode);
+		return returnExpression;
 	}
-	return compileBinding(and(or(requiredExpression, dataFieldRequiredExpression), editMode));
+	return compileExpression(returnExpression);
 };
 
-export const getRequiredExpressionForConnectedDataField = function (dataFieldObjectPath: DataModelObjectPath): BindingExpression<string> {
+export const getRequiredExpressionForConnectedDataField = function (
+	dataFieldObjectPath: DataModelObjectPath
+): CompiledBindingToolkitExpression {
 	const data = dataFieldObjectPath?.targetObject?.$target?.Data;
 	const keys: Array<string> = Object.keys(data);
 	const dataFields = [];
 	let propertyPath;
-	const isRequiredExpressions: (BindingExpression<boolean> | ExpressionOrPrimitive<boolean>)[] | undefined = [];
+	const isRequiredExpressions: (CompiledBindingToolkitExpression | BindingToolkitExpression<boolean>)[] | undefined = [];
 	for (const key of keys) {
 		if (data[key]["$Type"] && data[key]["$Type"].indexOf("DataField") > -1) {
 			dataFields.push(data[key]);
@@ -624,8 +695,9 @@ export const getRequiredExpressionForConnectedDataField = function (dataFieldObj
 					}
 				}
 				break;
+			// no default
 		}
-		isRequiredExpressions.push(getRequiredExpression(propertyPath, dataField, false, true));
+		isRequiredExpressions.push(getRequiredExpressionAsObject(propertyPath, dataField, false));
 	}
-	return compileBinding(or(...(isRequiredExpressions as ExpressionOrPrimitive<boolean>[])));
+	return compileExpression(or(...(isRequiredExpressions as BindingToolkitExpression<boolean>[])));
 };

package/src/sap/fe/core/type/Email.js

@@ -2,7 +2,7 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/ui/core/Core", "sap/ui/model/odata/type/String", "sap/ui/model/ValidateException", "sap/fe/core/helpers/ClassSupport"], function (Core, ODataStringType, ValidateException, ClassSupport) {
+sap.ui.define(["sap/fe/core/helpers/ClassSupport", "sap/ui/core/Core", "sap/ui/model/odata/type/String", "sap/ui/model/ValidateException"], function (ClassSupport, Core, ODataStringType, ValidateException) {
   "use strict";
 
   var _dec, _class;
@@ -35,4 +35,4 @@ sap.ui.define(["sap/ui/core/Core", "sap/ui/model/odata/type/String", "sap/ui/mod
   }(ODataStringType)) || _class);
   return EmailType;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIkVtYWlsLnRzIl0sIm5hbWVzIjpbImVtYWlsVzNDUmVnZXhwIiwiRW1haWxUeXBlIiwiZGVmaW5lVUk1Q2xhc3MiLCJ2YWxpZGF0ZVZhbHVlIiwic1ZhbHVlIiwidGVzdCIsIlZhbGlkYXRlRXhjZXB0aW9uIiwiQ29yZSIsImdldExpYnJhcnlSZXNvdXJjZUJ1bmRsZSIsImdldFRleHQiLCJPRGF0YVN0cmluZ1R5cGUiXSwibWFwcGluZ3MiOiI7QUFBQTtBQUNBO0FBQ0E7Ozs7Ozs7Ozs7OztBQUlBLE1BQU1BLGNBQWMsR0FBRyxxRUFBdkI7TUFFTUMsUyxXQURMQyxjQUFjLENBQUMsd0JBQUQsQzs7Ozs7Ozs7O1dBRWRDLGEsR0FBQSx1QkFBY0MsTUFBZCxFQUE4QjtBQUM3QixVQUFJLENBQUNKLGNBQWMsQ0FBQ0ssSUFBZixDQUFvQkQsTUFBcEIsQ0FBTCxFQUFrQztBQUNqQyxjQUFNLElBQUlFLGlCQUFKLENBQXVCQyxJQUFELENBQWlCQyx3QkFBakIsQ0FBMEMsYUFBMUMsRUFBeURDLE9BQXpELENBQWlFLDJCQUFqRSxDQUF0QixDQUFOO0FBQ0E7O0FBQ0QsaUNBQU1OLGFBQU4sWUFBb0JDLE1BQXBCO0FBQ0EsSzs7O0lBTnNCTSxlO1NBUVRULFMiLCJzb3VyY2VSb290IjoiLiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBDb3JlIGZyb20gXCJzYXAvdWkvY29yZS9Db3JlXCI7XG5pbXBvcnQgT0RhdGFTdHJpbmdUeXBlIGZyb20gXCJzYXAvdWkvbW9kZWwvb2RhdGEvdHlwZS9TdHJpbmdcIjtcbmltcG9ydCB7IENvcmVFeCB9IGZyb20gXCJ0eXBlcy9leHRlbnNpb25fdHlwZXNcIjtcbmltcG9ydCBWYWxpZGF0ZUV4Y2VwdGlvbiBmcm9tIFwic2FwL3VpL21vZGVsL1ZhbGlkYXRlRXhjZXB0aW9uXCI7XG5pbXBvcnQgeyBkZWZpbmVVSTVDbGFzcyB9IGZyb20gXCJzYXAvZmUvY29yZS9oZWxwZXJzL0NsYXNzU3VwcG9ydFwiO1xuXG5jb25zdCBlbWFpbFczQ1JlZ2V4cCA9IC9eW2EtekEtWjAtOS4hIyQlJuKAmSorLz0/Xl9ge3x9fi1dK0BbYS16QS1aMC05LV0rKD86LlthLXpBLVowLTktXSspKiQvO1xuQGRlZmluZVVJNUNsYXNzKFwic2FwLmZlLmNvcmUudHlwZS5FbWFpbFwiKVxuY2xhc3MgRW1haWxUeXBlIGV4dGVuZHMgT0RhdGFTdHJpbmdUeXBlIHtcblx0dmFsaWRhdGVWYWx1ZShzVmFsdWU6IHN0cmluZykge1xuXHRcdGlmICghZW1haWxXM0NSZWdleHAudGVzdChzVmFsdWUpKSB7XG5cdFx0XHR0aHJvdyBuZXcgVmFsaWRhdGVFeGNlcHRpb24oKENvcmUgYXMgQ29yZUV4KS5nZXRMaWJyYXJ5UmVzb3VyY2VCdW5kbGUoXCJzYXAuZmUuY29yZVwiKS5nZXRUZXh0KFwiVF9FTUFJTFRZUEVfSU5WQUxJRF9WQUxVRVwiKSk7XG5cdFx0fVxuXHRcdHN1cGVyLnZhbGlkYXRlVmFsdWUoc1ZhbHVlKTtcblx0fVxufVxuZXhwb3J0IGRlZmF1bHQgRW1haWxUeXBlO1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIkVtYWlsLnRzIl0sIm5hbWVzIjpbImVtYWlsVzNDUmVnZXhwIiwiRW1haWxUeXBlIiwiZGVmaW5lVUk1Q2xhc3MiLCJ2YWxpZGF0ZVZhbHVlIiwic1ZhbHVlIiwidGVzdCIsIlZhbGlkYXRlRXhjZXB0aW9uIiwiQ29yZSIsImdldExpYnJhcnlSZXNvdXJjZUJ1bmRsZSIsImdldFRleHQiLCJPRGF0YVN0cmluZ1R5cGUiXSwibWFwcGluZ3MiOiI7QUFBQTtBQUNBO0FBQ0E7Ozs7Ozs7Ozs7OztBQUlBLE1BQU1BLGNBQWMsR0FBRyxxRUFBdkI7TUFFTUMsUyxXQURMQyxjQUFjLENBQUMsd0JBQUQsQzs7Ozs7Ozs7O1dBRWRDLGEsR0FBQSx1QkFBY0MsTUFBZCxFQUE4QjtBQUM3QixVQUFJLENBQUNKLGNBQWMsQ0FBQ0ssSUFBZixDQUFvQkQsTUFBcEIsQ0FBTCxFQUFrQztBQUNqQyxjQUFNLElBQUlFLGlCQUFKLENBQXVCQyxJQUFELENBQWlCQyx3QkFBakIsQ0FBMEMsYUFBMUMsRUFBeURDLE9BQXpELENBQWlFLDJCQUFqRSxDQUF0QixDQUFOO0FBQ0E7O0FBQ0QsaUNBQU1OLGFBQU4sWUFBb0JDLE1BQXBCO0FBQ0EsSzs7O0lBTnNCTSxlO1NBUVRULFMiLCJzb3VyY2VSb290IjoiLiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlZmluZVVJNUNsYXNzIH0gZnJvbSBcInNhcC9mZS9jb3JlL2hlbHBlcnMvQ2xhc3NTdXBwb3J0XCI7XG5pbXBvcnQgQ29yZSBmcm9tIFwic2FwL3VpL2NvcmUvQ29yZVwiO1xuaW1wb3J0IE9EYXRhU3RyaW5nVHlwZSBmcm9tIFwic2FwL3VpL21vZGVsL29kYXRhL3R5cGUvU3RyaW5nXCI7XG5pbXBvcnQgVmFsaWRhdGVFeGNlcHRpb24gZnJvbSBcInNhcC91aS9tb2RlbC9WYWxpZGF0ZUV4Y2VwdGlvblwiO1xuaW1wb3J0IHR5cGUgeyBDb3JlRXggfSBmcm9tIFwidHlwZXMvZXh0ZW5zaW9uX3R5cGVzXCI7XG5cbmNvbnN0IGVtYWlsVzNDUmVnZXhwID0gL15bYS16QS1aMC05LiEjJCUm4oCZKisvPT9eX2B7fH1+LV0rQFthLXpBLVowLTktXSsoPzouW2EtekEtWjAtOS1dKykqJC87XG5AZGVmaW5lVUk1Q2xhc3MoXCJzYXAuZmUuY29yZS50eXBlLkVtYWlsXCIpXG5jbGFzcyBFbWFpbFR5cGUgZXh0ZW5kcyBPRGF0YVN0cmluZ1R5cGUge1xuXHR2YWxpZGF0ZVZhbHVlKHNWYWx1ZTogc3RyaW5nKSB7XG5cdFx0aWYgKCFlbWFpbFczQ1JlZ2V4cC50ZXN0KHNWYWx1ZSkpIHtcblx0XHRcdHRocm93IG5ldyBWYWxpZGF0ZUV4Y2VwdGlvbigoQ29yZSBhcyBDb3JlRXgpLmdldExpYnJhcnlSZXNvdXJjZUJ1bmRsZShcInNhcC5mZS5jb3JlXCIpLmdldFRleHQoXCJUX0VNQUlMVFlQRV9JTlZBTElEX1ZBTFVFXCIpKTtcblx0XHR9XG5cdFx0c3VwZXIudmFsaWRhdGVWYWx1ZShzVmFsdWUpO1xuXHR9XG59XG5leHBvcnQgZGVmYXVsdCBFbWFpbFR5cGU7XG4iXX0=

package/src/sap/fe/core/type/Email.ts

@@ -1,8 +1,8 @@
+import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
 import Core from "sap/ui/core/Core";
 import ODataStringType from "sap/ui/model/odata/type/String";
-import { CoreEx } from "types/extension_types";
 import ValidateException from "sap/ui/model/ValidateException";
-import { defineUI5Class } from "sap/fe/core/helpers/ClassSupport";
+import type { CoreEx } from "types/extension_types";
 
 const emailW3CRegexp = /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:.[a-zA-Z0-9-]+)*$/;
 @defineUI5Class("sap.fe.core.type.Email")