@sapui5/sap.fe.base 1.142.0 → 1.142.2

package/src/sap/fe/base/BindingToolkit.ts

@@ -1,10 +1,17 @@
 import type {
 	ActionParameter,
+	AddAnnotationExpression,
+	AddConditionalExpression,
 	AndAnnotationExpression,
 	AndConditionalExpression,
 	ApplyAnnotationExpression,
 	Boolean,
 	ConditionalCheckOrValue,
+	ConvertedMetadata,
+	DivAnnotationExpression,
+	DivByAnnotationExpression,
+	DivByConditionalExpression,
+	DivConditionalExpression,
 	EntitySet,
 	EntityType,
 	EqAnnotationExpression,
@@ -13,14 +20,24 @@ import type {
 	GeConditionalExpression,
 	GtAnnotationExpression,
 	GtConditionalExpression,
+	HasAnnotationExpression,
+	HasConditionalExpression,
 	IfAnnotationExpression,
 	IfAnnotationExpressionValue,
+	InAnnotationExpression,
+	InConditionalExpression,
 	LeAnnotationExpression,
 	LeConditionalExpression,
 	LtAnnotationExpression,
 	LtConditionalExpression,
+	ModAnnotationExpression,
+	ModConditionalExpression,
+	MulAnnotationExpression,
+	MulConditionalExpression,
 	NeAnnotationExpression,
 	NeConditionalExpression,
+	NegAnnotationExpression,
+	NegConditionalExpression,
 	NotAnnotationExpression,
 	NotConditionalExpression,
 	OrAnnotationExpression,
@@ -29,6 +46,8 @@ import type {
 	PathConditionExpression,
 	Property,
 	PropertyAnnotationValue,
+	SubAnnotationExpression,
+	SubConditionalExpression,
 	ConstantExpression as VocabConstantExpression
 } from "@sap-ux/vocabularies-types";
 import { CommonAnnotationTerms } from "@sap-ux/vocabularies-types/vocabularies/Common";
@@ -157,7 +176,7 @@ export type EmbeddedUI5ExpressionBindingExpression<T> = BaseExpression<T> & {
 	value: string;
 };
 
-export type ComparisonOperator = "===" | "!==" | ">=" | ">" | "<=" | "<";
+export type ComparisonOperator = "===" | "!==" | ">=" | ">" | "<=" | "<" | "Has" | "In";
 export type ComparisonExpression = BaseExpression<boolean> & {
 	_type: "Comparison";
 	operator: ComparisonOperator;
@@ -165,6 +184,13 @@ export type ComparisonExpression = BaseExpression<boolean> & {
 	operand2: BindingToolkitExpression<unknown>;
 };
 
+export type ArithmeticOperator = "+" | "-" | "*" | "/" | "%" | "Neg" | "Floor";
+export type ArithmeticExpression = BaseExpression<number> & {
+	_type: "Arithmetic";
+	operator: ArithmeticOperator;
+	operand1: BindingToolkitExpression<unknown>;
+	operand2: BindingToolkitExpression<unknown>;
+};
 export type IfElseExpression<T> = BaseExpression<T> & {
 	_type: "IfElse";
 	condition: BindingToolkitExpression<boolean>;
@@ -174,6 +200,9 @@ export type IfElseExpression<T> = BaseExpression<T> & {
 export function isProperty(serviceObject: unknown): serviceObject is Property {
 	return (serviceObject as Property)?._type === "Property";
 }
+function isActionParameter(serviceObject: unknown): serviceObject is ActionParameter {
+	return (serviceObject as ActionParameter)?._type === "ActionParameter";
+}
 
 /**
  * An expression that evaluates to type T.
@@ -195,7 +224,8 @@ export type BindingToolkitExpression<T> =
 	| FormatterExpression<T>
 	| ComplexTypeExpression<T>
 	| ReferenceExpression
-	| FunctionExpression<T>;
+	| FunctionExpression<T>
+	| ArithmeticExpression;
 
 type TypeMappingDefinition = {
 	type: string;
@@ -293,7 +323,12 @@ export function _checkExpressionsAreEqual<T>(a: BindingToolkitExpression<T>, b:
 		case "EmbeddedBinding":
 		case "EmbeddedExpressionBinding":
 			return a.value === (b as ConstantExpression<T>).value;
-
+		case "Arithmetic":
+			return (
+				a.operator === (b as ArithmeticExpression).operator &&
+				_checkExpressionsAreEqual(a.operand1, (b as ArithmeticExpression).operand1) &&
+				_checkExpressionsAreEqual(a.operand2, (b as ArithmeticExpression).operand2)
+			);
 		case "Not":
 			return _checkExpressionsAreEqual(a.operand, (b as NotExpression).operand);
 		case "Truthy":
@@ -499,6 +534,138 @@ export function or(...operands: ExpressionOrPrimitive<boolean>[]): BindingToolki
 	}
 }
 
+export function add<T extends PrimitiveType>(
+	leftOperand: ExpressionOrPrimitive<T>,
+	rightOperand: ExpressionOrPrimitive<T>
+): BindingToolkitExpression<number> {
+	return arithmetic("+", leftOperand, rightOperand);
+}
+
+export function subtract<T extends PrimitiveType>(
+	leftOperand: ExpressionOrPrimitive<T>,
+	rightOperand: ExpressionOrPrimitive<T>
+): BindingToolkitExpression<number> {
+	return arithmetic("-", leftOperand, rightOperand);
+}
+
+export function multiply<T extends PrimitiveType>(
+	leftOperand: ExpressionOrPrimitive<T>,
+	rightOperand: ExpressionOrPrimitive<T>
+): BindingToolkitExpression<number> {
+	return arithmetic("*", leftOperand, rightOperand);
+}
+
+export function divide<T extends PrimitiveType>(
+	leftOperand: ExpressionOrPrimitive<T>,
+	rightOperand: ExpressionOrPrimitive<T>
+): BindingToolkitExpression<number> {
+	return arithmetic("/", leftOperand, rightOperand);
+}
+
+export function modulo<T extends PrimitiveType>(
+	leftOperand: ExpressionOrPrimitive<T>,
+	rightOperand: ExpressionOrPrimitive<T>
+): BindingToolkitExpression<number> {
+	return arithmetic("%", leftOperand, rightOperand);
+}
+
+export function negate<T extends PrimitiveType>(operand: ExpressionOrPrimitive<T>): BindingToolkitExpression<number> {
+	return arithmetic("Neg", operand, null);
+}
+
+export function floor<T extends PrimitiveType>(operand: ExpressionOrPrimitive<T>): BindingToolkitExpression<number> {
+	return arithmetic("Floor", operand, null);
+}
+
+/**
+ * Arithmetic expression.
+ * @param operator
+ * @param leftOperand
+ * @param rightOperand
+ * @returns Expression evaluating to number
+ */
+export function arithmetic<T extends PrimitiveType>(
+	operator: ArithmeticOperator,
+	leftOperand: ExpressionOrPrimitive<T>,
+	rightOperand: ExpressionOrPrimitive<T>
+): BindingToolkitExpression<number> {
+	const leftExpression = wrapPrimitive(leftOperand);
+	const rightExpression = wrapPrimitive(rightOperand);
+	if (hasUnresolvableExpression(leftExpression, rightExpression)) {
+		return unresolvableExpression;
+	}
+	if (isConstant(leftExpression) && isConstant(rightExpression)) {
+		switch (operator) {
+			case "+":
+				if (leftExpression.value === null || leftExpression.value === undefined) {
+					return constant(rightExpression.value as number);
+				} else if (rightExpression.value === null || rightExpression.value === undefined) {
+					return constant(leftExpression.value as number);
+				}
+				const sum = (leftExpression.value as number) + (rightExpression.value as number);
+				return constant(sum);
+			case "-":
+				if (leftExpression.value === null || leftExpression.value === undefined) {
+					return constant(rightExpression.value as number);
+				} else if (rightExpression.value === null || rightExpression.value === undefined) {
+					return constant(leftExpression.value as number);
+				}
+				const diff = (leftExpression.value as number) - (rightExpression.value as number);
+				return constant(diff);
+			case "/":
+				if (
+					leftExpression.value === null ||
+					leftExpression.value === undefined ||
+					rightExpression.value === null ||
+					rightExpression.value === undefined
+				) {
+					return constant(0);
+				}
+				const div = (leftExpression.value as number) / (rightExpression.value as number);
+				return constant(div);
+			case "Neg":
+				if (leftExpression.value === null || leftExpression.value === undefined) {
+					return constant(0);
+				}
+				return constant(-leftExpression.value);
+			case "%":
+				if (
+					leftExpression.value === null ||
+					leftExpression.value === undefined ||
+					rightExpression.value === null ||
+					rightExpression.value === undefined
+				) {
+					return constant(0);
+				}
+				const mod = (leftExpression.value as number) % (rightExpression.value as number);
+				return constant(mod);
+			case "Floor":
+				if (leftExpression.value === null || leftExpression.value === undefined) {
+					return constant(0);
+				}
+				return constant(Math.floor(leftExpression.value as number));
+			case "*":
+				if (
+					leftExpression.value === null ||
+					leftExpression.value === undefined ||
+					rightExpression.value === null ||
+					rightExpression.value === undefined
+				) {
+					return constant(0);
+				}
+				const mult = (leftExpression.value as number) * (rightExpression.value as number);
+				return constant(mult);
+		}
+	} else {
+		return {
+			_type: "Arithmetic",
+			operator: operator,
+			operand1: leftExpression,
+			operand2: rightExpression
+		};
+	}
+}
+
 /**
  * Logical `not` operator.
  * @param operand The expression to reverse
@@ -539,6 +706,11 @@ export function not(operand: ExpressionOrPrimitive<boolean>): BindingToolkitExpr
 				return { ...operand, operator: "<=" };
 			case ">=":
 				return { ...operand, operator: "<" };
+			default:
+				return {
+					_type: "Not",
+					operand: operand
+				};
 		}
 	} else if (operand._type === "Not") {
 		return operand.operand;
@@ -849,6 +1021,15 @@ type ComplexAnnotationExpression<P> =
 	| GeAnnotationExpression<P>
 	| LeAnnotationExpression<P>
 	| LtAnnotationExpression<P>
+	| HasAnnotationExpression<P>
+	| InAnnotationExpression<P>
+	| AddAnnotationExpression<P>
+	| SubAnnotationExpression<P>
+	| MulAnnotationExpression<P>
+	| DivAnnotationExpression<P>
+	| ModAnnotationExpression<P>
+	| DivByAnnotationExpression<P>
+	| NegAnnotationExpression<P>
 	| VocabConstantExpression<P>;
 
 function isPrimitiveObject(objectType: object): boolean {
@@ -871,6 +1052,11 @@ function isComplexAnnotationExpression<T>(annotationValue: PropertyAnnotationVal
 	return typeof annotationValue === "object" && !isPrimitiveObject(annotationValue as object);
 }
 
+let CONVERTER_ROOT_SYMBOL: symbol | undefined;
+export function setConverterRootSymbol(converterRootSymbol: symbol): void {
+	CONVERTER_ROOT_SYMBOL = converterRootSymbol;
+}
+
 /**
  * Generate the corresponding annotationValue for a given annotation annotationValue.
  * @template T The target type
@@ -886,6 +1072,11 @@ export function getExpressionFromAnnotation<T extends PrimitiveType>(
 	defaultValue?: ExpressionOrPrimitive<T>,
 	pathVisitor?: Function
 ): BindingToolkitExpression<PrimitiveTypeCast<T>> {
+	let converterRoot: ConvertedMetadata | undefined;
+	if (CONVERTER_ROOT_SYMBOL) {
+		converterRoot = (annotationValue?.[CONVERTER_ROOT_SYMBOL as never] as unknown as Function)?.() as ConvertedMetadata | undefined;
+	}
+
 	if (annotationValue === undefined) {
 		return wrapPrimitive(defaultValue as PrimitiveTypeCast<T>);
 	}
@@ -898,55 +1089,106 @@ export function getExpressionFromAnnotation<T extends PrimitiveType>(
 		case "Path":
 			return pathInModel(annotationValue.path, undefined, visitedNavigationPaths, pathVisitor);
 		case "If":
-			return annotationIfExpression(annotationValue.$If, visitedNavigationPaths, pathVisitor) as BindingToolkitExpression<
-				PrimitiveTypeCast<T>
-			>;
+			return annotationIfExpression(
+				annotationValue.$If,
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Not":
-			return not(parseAnnotationCondition(annotationValue.$Not, visitedNavigationPaths, pathVisitor)) as BindingToolkitExpression<
-				PrimitiveTypeCast<T>
-			>;
+			return not(
+				parseAnnotationCondition(annotationValue.$Not, visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Eq":
 			return equal(
-				parseAnnotationCondition(annotationValue.$Eq[0], visitedNavigationPaths, pathVisitor),
-				parseAnnotationCondition(annotationValue.$Eq[1], visitedNavigationPaths, pathVisitor)
+				parseAnnotationCondition(annotationValue.$Eq[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Eq[1], visitedNavigationPaths, pathVisitor, converterRoot)
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Ne":
 			return notEqual(
-				parseAnnotationCondition(annotationValue.$Ne[0], visitedNavigationPaths, pathVisitor),
-				parseAnnotationCondition(annotationValue.$Ne[1], visitedNavigationPaths, pathVisitor)
+				parseAnnotationCondition(annotationValue.$Ne[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Ne[1], visitedNavigationPaths, pathVisitor, converterRoot)
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Gt":
 			return greaterThan(
-				parseAnnotationCondition(annotationValue.$Gt[0], visitedNavigationPaths, pathVisitor),
-				parseAnnotationCondition(annotationValue.$Gt[1], visitedNavigationPaths, pathVisitor)
+				parseAnnotationCondition(annotationValue.$Gt[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Gt[1], visitedNavigationPaths, pathVisitor, converterRoot)
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Ge":
 			return greaterOrEqual(
-				parseAnnotationCondition(annotationValue.$Ge[0], visitedNavigationPaths, pathVisitor),
-				parseAnnotationCondition(annotationValue.$Ge[1], visitedNavigationPaths, pathVisitor)
+				parseAnnotationCondition(annotationValue.$Ge[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Ge[1], visitedNavigationPaths, pathVisitor, converterRoot)
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Lt":
 			return lessThan(
-				parseAnnotationCondition(annotationValue.$Lt[0], visitedNavigationPaths, pathVisitor),
-				parseAnnotationCondition(annotationValue.$Lt[1], visitedNavigationPaths, pathVisitor)
+				parseAnnotationCondition(annotationValue.$Lt[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Lt[1], visitedNavigationPaths, pathVisitor, converterRoot)
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Le":
 			return lessOrEqual(
-				parseAnnotationCondition(annotationValue.$Le[0], visitedNavigationPaths, pathVisitor),
-				parseAnnotationCondition(annotationValue.$Le[1], visitedNavigationPaths, pathVisitor)
+				parseAnnotationCondition(annotationValue.$Le[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Le[1], visitedNavigationPaths, pathVisitor, converterRoot)
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Or":
 			return or(
 				...annotationValue.$Or.map(function (orCondition) {
-					return parseAnnotationCondition<boolean>(orCondition, visitedNavigationPaths, pathVisitor);
+					return parseAnnotationCondition<boolean>(orCondition, visitedNavigationPaths, pathVisitor, converterRoot);
 				})
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "And":
 			return and(
 				...annotationValue.$And.map(function (andCondition) {
-					return parseAnnotationCondition<boolean>(andCondition, visitedNavigationPaths, pathVisitor);
+					return parseAnnotationCondition<boolean>(andCondition, visitedNavigationPaths, pathVisitor, converterRoot);
 				})
 			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "In":
+			return comparison(
+				"In",
+				parseAnnotationCondition(annotationValue.$In[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$In[1], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "Has":
+			return comparison(
+				"Has",
+				parseAnnotationCondition(annotationValue.$Has[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Has[1], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "Add":
+			return add(
+				parseAnnotationCondition(annotationValue.$Add[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Add[1], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "Sub":
+			return subtract(
+				parseAnnotationCondition(annotationValue.$Sub[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Sub[1], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "Mul":
+			return multiply(
+				parseAnnotationCondition(annotationValue.$Mul[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Mul[1], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "Div":
+			return floor(
+				divide(
+					parseAnnotationCondition(annotationValue.$Div[0], visitedNavigationPaths, pathVisitor, converterRoot),
+					parseAnnotationCondition(annotationValue.$Div[1], visitedNavigationPaths, pathVisitor, converterRoot)
+				)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "DivBy":
+			return divide(
+				parseAnnotationCondition(annotationValue.$DivBy[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$DivBy[1], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "Mod":
+			return modulo(
+				parseAnnotationCondition(annotationValue.$Mod[0], visitedNavigationPaths, pathVisitor, converterRoot),
+				parseAnnotationCondition(annotationValue.$Mod[1], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
+		case "Neg":
+			return negate(
+				parseAnnotationCondition(annotationValue.$Neg[0], visitedNavigationPaths, pathVisitor, converterRoot)
+			) as BindingToolkitExpression<PrimitiveTypeCast<T>>;
 		case "Apply":
 			return annotationApplyExpression(
 				annotationValue as ApplyAnnotationExpression<string>,
@@ -966,60 +1208,122 @@ export function getExpressionFromAnnotation<T extends PrimitiveType>(
  * @param annotationValue The condition or value from the annotation
  * @param visitedNavigationPaths The path from the root entity set
  * @param pathVisitor A function to modify the resulting path
+ * @param converterRoot The root converted metadata
  * @returns An equivalent expression
  */
 function parseAnnotationCondition<T extends PrimitiveType>(
 	annotationValue: ConditionalCheckOrValue,
 	visitedNavigationPaths: string[] = [],
-	pathVisitor?: Function
+	pathVisitor?: Function,
+	converterRoot?: ConvertedMetadata
 ): BindingToolkitExpression<T> {
 	if (annotationValue === null || typeof annotationValue !== "object") {
 		return constant(annotationValue as T);
 	} else if (annotationValue.hasOwnProperty("$Or")) {
 		return or(
 			...((annotationValue as OrConditionalExpression).$Or.map(function (orCondition) {
-				return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
+				return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor, converterRoot);
 			}) as unknown as BindingToolkitExpression<boolean>[])
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$And")) {
 		return and(
 			...((annotationValue as AndConditionalExpression).$And.map(function (andCondition) {
-				return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
+				return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor, converterRoot);
 			}) as unknown as BindingToolkitExpression<boolean>[])
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Not")) {
 		return not(
-			parseAnnotationCondition((annotationValue as NotConditionalExpression).$Not, visitedNavigationPaths, pathVisitor)
+			parseAnnotationCondition((annotationValue as NotConditionalExpression).$Not, visitedNavigationPaths, pathVisitor, converterRoot)
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Eq")) {
 		return equal(
-			parseAnnotationCondition((annotationValue as EqConditionalExpression).$Eq[0], visitedNavigationPaths, pathVisitor),
-			parseAnnotationCondition((annotationValue as EqConditionalExpression).$Eq[1], visitedNavigationPaths, pathVisitor)
+			parseAnnotationCondition(
+				(annotationValue as EqConditionalExpression).$Eq[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as EqConditionalExpression).$Eq[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Ne")) {
 		return notEqual(
-			parseAnnotationCondition((annotationValue as NeConditionalExpression).$Ne[0], visitedNavigationPaths, pathVisitor),
-			parseAnnotationCondition((annotationValue as NeConditionalExpression).$Ne[1], visitedNavigationPaths, pathVisitor)
+			parseAnnotationCondition(
+				(annotationValue as NeConditionalExpression).$Ne[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as NeConditionalExpression).$Ne[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Gt")) {
 		return greaterThan(
-			parseAnnotationCondition((annotationValue as GtConditionalExpression).$Gt[0], visitedNavigationPaths, pathVisitor),
-			parseAnnotationCondition((annotationValue as GtConditionalExpression).$Gt[1], visitedNavigationPaths, pathVisitor)
+			parseAnnotationCondition(
+				(annotationValue as GtConditionalExpression).$Gt[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as GtConditionalExpression).$Gt[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Ge")) {
 		return greaterOrEqual(
-			parseAnnotationCondition((annotationValue as GeConditionalExpression).$Ge[0], visitedNavigationPaths, pathVisitor),
-			parseAnnotationCondition((annotationValue as GeConditionalExpression).$Ge[1], visitedNavigationPaths, pathVisitor)
+			parseAnnotationCondition(
+				(annotationValue as GeConditionalExpression).$Ge[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as GeConditionalExpression).$Ge[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Lt")) {
 		return lessThan(
-			parseAnnotationCondition((annotationValue as LtConditionalExpression).$Lt[0], visitedNavigationPaths, pathVisitor),
-			parseAnnotationCondition((annotationValue as LtConditionalExpression).$Lt[1], visitedNavigationPaths, pathVisitor)
+			parseAnnotationCondition(
+				(annotationValue as LtConditionalExpression).$Lt[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as LtConditionalExpression).$Lt[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Le")) {
 		return lessOrEqual(
-			parseAnnotationCondition((annotationValue as LeConditionalExpression).$Le[0], visitedNavigationPaths, pathVisitor),
-			parseAnnotationCondition((annotationValue as LeConditionalExpression).$Le[1], visitedNavigationPaths, pathVisitor)
+			parseAnnotationCondition(
+				(annotationValue as LeConditionalExpression).$Le[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as LeConditionalExpression).$Le[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Path")) {
 		return pathInModel((annotationValue as PathConditionExpression<T>).$Path, undefined, visitedNavigationPaths, pathVisitor);
@@ -1045,9 +1349,137 @@ function parseAnnotationCondition<T extends PrimitiveType>(
 			pathVisitor
 		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$EnumMember")) {
-		return constant(resolveEnumValue((annotationValue as { $EnumMember?: string }).$EnumMember) as T);
+		return constant(resolveEnumValue((annotationValue as { $EnumMember?: string }).$EnumMember, converterRoot) as T);
+	} else if (annotationValue.hasOwnProperty("$In")) {
+		return comparison(
+			"In",
+			parseAnnotationCondition(
+				(annotationValue as InConditionalExpression).$In[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as InConditionalExpression).$In[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$Has")) {
+		return comparison(
+			"Has",
+			parseAnnotationCondition(
+				(annotationValue as HasConditionalExpression).$Has[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as HasConditionalExpression).$Has[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$Add")) {
+		return add(
+			parseAnnotationCondition(
+				(annotationValue as AddConditionalExpression).$Add[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as AddConditionalExpression).$Add[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$Sub")) {
+		return subtract(
+			parseAnnotationCondition(
+				(annotationValue as SubConditionalExpression).$Sub[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as SubConditionalExpression).$Sub[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$Mul")) {
+		return multiply(
+			parseAnnotationCondition(
+				(annotationValue as MulConditionalExpression).$Mul[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as MulConditionalExpression).$Mul[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$Div")) {
+		return floor(
+			divide(
+				parseAnnotationCondition(
+					(annotationValue as DivConditionalExpression).$Div[0],
+					visitedNavigationPaths,
+					pathVisitor,
+					converterRoot
+				),
+				parseAnnotationCondition(
+					(annotationValue as DivConditionalExpression).$Div[1],
+					visitedNavigationPaths,
+					pathVisitor,
+					converterRoot
+				)
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$DivBy")) {
+		return divide(
+			parseAnnotationCondition(
+				(annotationValue as DivByConditionalExpression).$DivBy[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as DivByConditionalExpression).$DivBy[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$Mod")) {
+		return modulo(
+			parseAnnotationCondition(
+				(annotationValue as ModConditionalExpression).$Mod[0],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			),
+			parseAnnotationCondition(
+				(annotationValue as ModConditionalExpression).$Mod[1],
+				visitedNavigationPaths,
+				pathVisitor,
+				converterRoot
+			)
+		) as BindingToolkitExpression<T>;
+	} else if (annotationValue.hasOwnProperty("$Neg")) {
+		return negate(
+			parseAnnotationCondition((annotationValue as NegConditionalExpression).$Neg, visitedNavigationPaths, pathVisitor, converterRoot)
+		) as BindingToolkitExpression<T>;
 	}
-	return constant(false as T);
+	return constant(annotationValue as T);
 }
 
 /**
@@ -1056,17 +1488,19 @@ function parseAnnotationCondition<T extends PrimitiveType>(
  * @param annotationValue An If expression returning the type T
  * @param visitedNavigationPaths The path from the root entity set
  * @param pathVisitor A function to modify the resulting path
+ * @param converterRoot The root converted metadata
  * @returns The equivalent ifElse expression
  */
 export function annotationIfExpression<T extends PrimitiveType>(
 	annotationValue: IfAnnotationExpressionValue<T>,
 	visitedNavigationPaths: string[] = [],
-	pathVisitor?: Function
+	pathVisitor?: Function,
+	converterRoot?: ConvertedMetadata
 ): BindingToolkitExpression<T> {
 	return ifElse(
-		parseAnnotationCondition(annotationValue[0], visitedNavigationPaths, pathVisitor),
-		parseAnnotationCondition(annotationValue[1] as ConditionalCheckOrValue, visitedNavigationPaths, pathVisitor),
-		parseAnnotationCondition(annotationValue[2] as ConditionalCheckOrValue, visitedNavigationPaths, pathVisitor)
+		parseAnnotationCondition(annotationValue[0], visitedNavigationPaths, pathVisitor, converterRoot),
+		parseAnnotationCondition(annotationValue[1] as ConditionalCheckOrValue, visitedNavigationPaths, pathVisitor, converterRoot),
+		parseAnnotationCondition(annotationValue[2] as ConditionalCheckOrValue, visitedNavigationPaths, pathVisitor, converterRoot)
 	);
 }
 // This type is not recursively transformed from the metamodel content, as such we have some ugly things there
@@ -1205,6 +1639,43 @@ function comparison<T extends PrimitiveType>(
 					return constant(false);
 				}
 				return constant(leftExpression.value >= rightExpression.value);
+
+			case "Has": {
+				if (
+					leftExpression.value === null ||
+					leftExpression.value === undefined ||
+					rightExpression.value === null ||
+					rightExpression.value === undefined
+				) {
+					return constant(false);
+				}
+				const leftValueInt = leftExpression.value as number;
+				const rightValueInt = rightExpression.value as number;
+				return constant(!!(leftValueInt & rightValueInt));
+			}
+			case "In": {
+				if (
+					leftExpression.value === null ||
+					leftExpression.value === undefined ||
+					rightExpression.value === null ||
+					rightExpression.value === undefined
+				) {
+					return constant(false);
+				}
+				// Check all the children of the right expression are constants
+				const allChildrenConstants = (rightExpression.value as T[]).every((item) => isConstant(item));
+				if (allChildrenConstants) {
+					const rightValues = (rightExpression.value as ConstantExpression<T>[]).map((item) => item.value);
+					return constant(rightValues.includes(leftExpression.value));
+				} else {
+					return {
+						_type: "Comparison",
+						operator: operator,
+						operand1: leftExpression,
+						operand2: rightExpression
+					};
+				}
+			}
 		}
 	} else {
 		return {
@@ -1359,6 +1830,20 @@ export function lessThan<T extends DefinedPrimitiveType>(
 	return comparison("<", leftOperand, rightOperand);
 }
 
+/**
+ * Comparison: "Include" (In).
+ * @template T The target type
+ * @param leftOperand The operand on the left side
+ * @param rightOperand The operand on the right side of the comparison
+ * @returns An expression representing the comparison
+ */
+export function includes<T extends DefinedPrimitiveType>(
+	leftOperand: ExpressionOrPrimitive<T>,
+	rightOperand: ExpressionOrPrimitive<T[]>
+): BindingToolkitExpression<boolean> {
+	return comparison("In", leftOperand, rightOperand as ExpressionOrPrimitive<T>);
+}
+
 /**
  * If-then-else expression.
  *
@@ -1584,7 +2069,7 @@ export function formatResult<T, U extends Fn<T>>(
 }
 
 type BindingConstraints = {
-	scale?: number;
+	scale?: number | string;
 	precision?: number;
 	maxLength?: number;
 	nullable?: boolean;
@@ -1664,16 +2149,18 @@ export function formatWithTypeInformation<T>(
 			parseAsString: false
 		});
 	}
-	if (outExpression.type === "sap.ui.model.odata.type.String" && isProperty(property)) {
+	if (outExpression.type === "sap.ui.model.odata.type.String" && (isProperty(property) || isActionParameter(property))) {
 		if (outExpression.constraints?.isDigitSequence || (outExpression.constraints?.nullable !== false && property.nullable === true)) {
 			outExpression.formatOptions.parseKeepsEmptyString = false;
 		} else {
 			outExpression.formatOptions.parseKeepsEmptyString = true;
 		}
-		const fiscalType = getFiscalType(property);
-		if (fiscalType) {
-			outExpression.formatOptions.fiscalType = fiscalType;
-			outExpression.type = "sap.fe.core.type.FiscalDate";
+		if (isProperty(property)) {
+			const fiscalType = getFiscalType(property);
+			if (fiscalType) {
+				outExpression.formatOptions.fiscalType = fiscalType;
+				outExpression.type = "sap.fe.core.type.FiscalDate";
+			}
 		}
 	}
 	const typesSupportingParseEmptyValueToZero = [
@@ -1899,6 +2386,51 @@ export function isEmpty(expression: BindingToolkitExpression<string>): BindingTo
 	});
 	return and(...aBindings);
 }
+/**
+ * Shortcut function to determine if a binding can be statically resolvable.
+ * @param exp The expression to evaluate
+ * @returns A Boolean evaluating if there is no relative path dependent on the current context
+ */
+export function isExpressionStaticallyResolvable<T extends PrimitiveType>(exp: BindingToolkitExpression<T>): boolean {
+	const referencedPaths: string[] = [];
+	transformRecursively(
+		exp,
+		"PathInModel",
+		(pathExp) => {
+			if (pathExp.modelName === undefined && typeof pathExp.path === "string") {
+				referencedPaths.push(pathExp.path);
+			}
+			return pathExp;
+		},
+		true
+	);
+	if (referencedPaths.length === 0) {
+		return true;
+	}
+	return referencedPaths.every((p) => p.startsWith("/"));
+}
+
+export function getStaticallyResolvableExpression<T extends PrimitiveType>(
+	exp: BindingToolkitExpression<T>,
+	defaultValue: BindingToolkitExpression<T>
+): BindingToolkitExpression<T> {
+	if (exp._type === "Set") {
+		const newOperands = exp.operands.map((operand: BindingToolkitExpression<boolean>) => {
+			if (isExpressionStaticallyResolvable(operand) || isConstant(operand)) {
+				return operand;
+			} else {
+				return defaultValue;
+			}
+		});
+
+		if (exp.operator === "||") {
+			return or(...(newOperands as unknown as BindingToolkitExpression<boolean>[])) as unknown as BindingToolkitExpression<T>;
+		} else {
+			return and(...(newOperands as unknown as BindingToolkitExpression<boolean>[])) as unknown as BindingToolkitExpression<T>;
+		}
+	}
+	return isExpressionStaticallyResolvable(exp) ? exp : defaultValue;
+}
 
 export function concat(...inExpressions: ExpressionOrPrimitive<string>[]): BindingToolkitExpression<string> {
 	const expressions = inExpressions.map(wrapPrimitive);
@@ -2048,6 +2580,21 @@ export function transformRecursively<T extends PrimitiveType | unknown, ET exten
 				expression = comparison(expression.operator, operand1, operand2) as BindingToolkitExpression<T>;
 			}
 			break;
+		case "Arithmetic":
+			const operand1 = transformRecursively(
+				expression.operand1 as BindingToolkitExpression<T>,
+				expressionType,
+				transformFunction,
+				includeAllExpression
+			);
+			const operand2 = transformRecursively(
+				expression.operand2 as BindingToolkitExpression<T>,
+				expressionType,
+				transformFunction,
+				includeAllExpression
+			);
+			expression = arithmetic(expression.operator, operand1, operand2) as BindingToolkitExpression<T>;
+			break;
 		case "Constant":
 			const constantValue: Record<string, BindingToolkitExpression<unknown>> = expression.value as Record<
 				string,
@@ -2364,6 +2911,9 @@ export function compileExpression<T extends PrimitiveType>(
 		case "Not":
 			const notExpression = `!${compileExpression(expr.operand, true)}`;
 			return wrapBindingExpression(notExpression, embeddedInBinding);
+		case "Arithmetic":
+			const arithmeticExpression = compileArithmeticExpression(expr);
+			return wrapBindingExpression(arithmeticExpression, embeddedInBinding);
 
 		case "Truthy":
 			const truthyExpression = `!!${compileExpression(expr.operand, true)}`;
@@ -2382,6 +2932,25 @@ export function compileExpression<T extends PrimitiveType>(
 	}
 }
 
+function compileArithmeticExpression(expression: ArithmeticExpression): string {
+	function compileOperand(operand: BindingToolkitExpression<unknown>): CompiledBindingToolkitExpression {
+		const compiledOperand = compileExpression(operand, true) ?? "undefined";
+		return wrapBindingExpression(compiledOperand, true, needParenthesis(operand));
+	}
+	switch (expression.operator) {
+		case "Neg":
+			return `-(${compileOperand(expression.operand1)})`;
+		case "Floor":
+			return `Math.floor(${compileOperand(expression.operand1)})`;
+		case "%":
+		case "/":
+		case "*":
+		case "+":
+		case "-":
+			return `${compileOperand(expression.operand1)} ${expression.operator} ${compileOperand(expression.operand2)}`;
+	}
+}
+
 /**
  * Compile a comparison expression.
  * @param expression The comparison expression.
@@ -2392,8 +2961,25 @@ function compileComparisonExpression(expression: ComparisonExpression): string {
 		const compiledOperand = compileExpression(operand, true) ?? "undefined";
 		return wrapBindingExpression(compiledOperand, true, needParenthesis(operand));
 	}
-
-	return `${compileOperand(expression.operand1)} ${expression.operator} ${compileOperand(expression.operand2)}`;
+	switch (expression.operator) {
+		case "In": {
+			const path = compileOperand(expression.operand1);
+			const collection = compileOperand(expression.operand2) ?? [];
+			return `${collection}.includes(${path})`;
+		}
+		case "Has": {
+			const path = compileOperand(expression.operand1);
+			const flags = compileOperand(expression.operand2) ?? [];
+			return `(${path} & ${flags}) > 0`;
+		}
+		case "===":
+		case "!==":
+		case ">=":
+		case ">":
+		case "<=":
+		case "<":
+			return `${compileOperand(expression.operand1)} ${expression.operator} ${compileOperand(expression.operand2)}`;
+	}
 }
 
 /**