@sapui5/sap.fe.core 1.100.0 → 1.102.0

package/src/sap/fe/core/helpers/BindingExpression.ts

@@ -24,8 +24,8 @@ import {
 	PathConditionExpression,
 	PropertyAnnotationValue
 } from "@sap-ux/vocabularies-types";
-import { ApplyAnnotationExpression, PathAnnotationExpression } from "@sap-ux/vocabularies-types/types/Edm";
 import { EntitySet } from "@sap-ux/vocabularies-types/dist/Converter";
+import { ApplyAnnotationExpression, PathAnnotationExpression } from "@sap-ux/vocabularies-types/types/Edm";
 import { resolveEnumValue } from "./AnnotationEnum";
 
 type PrimitiveType = string | number | bigint | boolean | object | null | undefined;
@@ -185,7 +185,7 @@ function escapeXmlAttribute(inputString: string) {
 }
 
 export function hasUnresolveableExpression(...expressions: Expression<any>[]): boolean {
-	return expressions.find(expr => expr._type === "Unresolvable") !== undefined;
+	return expressions.find((expr) => expr._type === "Unresolvable") !== undefined;
 }
 /**
  * Check two expressions for (deep) equality.
@@ -215,8 +215,8 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
 			return (
 				a.operator === (b as SetExpression).operator &&
 				a.operands.length === (b as SetExpression).operands.length &&
-				a.operands.every(expression =>
-					(b as SetExpression).operands.some(otherExpression => _checkExpressionsAreEqual(expression, otherExpression))
+				a.operands.every((expression) =>
+					(b as SetExpression).operands.some((otherExpression) => _checkExpressionsAreEqual(expression, otherExpression))
 				)
 			);
 
@@ -304,8 +304,8 @@ function flattenSetExpression(expression: SetExpression): SetExpression {
 		(result: SetExpression, operand) => {
 			const candidatesForFlattening =
 				operand._type === "Set" && operand.operator === expression.operator ? operand.operands : [operand];
-			candidatesForFlattening.forEach(candidate => {
-				if (result.operands.every(e => !_checkExpressionsAreEqual(e, candidate))) {
+			candidatesForFlattening.forEach((candidate) => {
+				if (result.operands.every((e) => !_checkExpressionsAreEqual(e, candidate))) {
 					result.operands.push(candidate);
 				}
 			});
@@ -353,7 +353,7 @@ export function and(...operands: ExpressionOrPrimitive<boolean>[]): Expression<b
 		return unresolveableExpression;
 	}
 	let isStaticFalse = false;
-	const nonTrivialExpression = expressions.filter(expression => {
+	const nonTrivialExpression = expressions.filter((expression) => {
 		if (isFalse(expression)) {
 			isStaticFalse = true;
 		}
@@ -397,7 +397,7 @@ export function or(...operands: ExpressionOrPrimitive<boolean>[]): Expression<bo
 		return unresolveableExpression;
 	}
 	let isStaticTrue = false;
-	const nonTrivialExpression = expressions.filter(expression => {
+	const nonTrivialExpression = expressions.filter((expression) => {
 		if (isTrue(expression)) {
 			isStaticTrue = true;
 		}
@@ -438,16 +438,16 @@ export function not(operand: ExpressionOrPrimitive<boolean>): Expression<boolean
 		typeof operand === "object" &&
 		operand._type === "Set" &&
 		operand.operator === "||" &&
-		operand.operands.every(expression => isConstant(expression) || isComparison(expression))
+		operand.operands.every((expression) => isConstant(expression) || isComparison(expression))
 	) {
-		return and(...operand.operands.map(expression => not(expression)));
+		return and(...operand.operands.map((expression) => not(expression)));
 	} else if (
 		typeof operand === "object" &&
 		operand._type === "Set" &&
 		operand.operator === "&&" &&
-		operand.operands.every(expression => isConstant(expression) || isComparison(expression))
+		operand.operands.every((expression) => isConstant(expression) || isComparison(expression))
 	) {
-		return or(...operand.operands.map(expression => not(expression)));
+		return or(...operand.operands.map((expression) => not(expression)));
 	} else if (isComparison(operand)) {
 		// Create the reverse comparison
 		switch (operand.operator) {
@@ -765,13 +765,13 @@ export function annotationExpression<T extends PrimitiveType>(
 			) as Expression<T>;
 		case "Or":
 			return or(
-				...(annotationValue.Or.map(function(orCondition) {
+				...(annotationValue.Or.map(function (orCondition) {
 					return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
 				}) as Expression<boolean>[])
 			) as Expression<T>;
 		case "And":
 			return and(
-				...(annotationValue.And.map(function(andCondition) {
+				...(annotationValue.And.map(function (andCondition) {
 					return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
 				}) as Expression<boolean>[])
 			) as Expression<T>;
@@ -803,15 +803,15 @@ function parseAnnotationCondition<T extends PrimitiveType>(
 		return constant(annotationValue as T);
 	} else if (annotationValue.hasOwnProperty("$Or")) {
 		return or(
-			...(((annotationValue as OrConditionalExpression).$Or.map(function(orCondition) {
+			...((annotationValue as OrConditionalExpression).$Or.map(function (orCondition) {
 				return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
-			}) as unknown) as Expression<boolean>[])
+			}) as unknown as Expression<boolean>[])
 		) as Expression<T>;
 	} else if (annotationValue.hasOwnProperty("$And")) {
 		return and(
-			...(((annotationValue as AndConditionalExpression).$And.map(function(andCondition) {
+			...((annotationValue as AndConditionalExpression).$And.map(function (andCondition) {
 				return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
-			}) as unknown) as Expression<boolean>[])
+			}) as unknown as Expression<boolean>[])
 		) as Expression<T>;
 	} else if (annotationValue.hasOwnProperty("$Not")) {
 		return not(
@@ -1277,7 +1277,7 @@ export function formatResult<T, U extends Fn<T>>(
 	if (!!contextEntityType) {
 		// Otherwise, if the context is required and no context is provided make sure to add the default binding
 		if (!parameterExpressions.some(hasReferenceToDefaultContext)) {
-			contextEntityType.keys.forEach(key => parameterExpressions.push(bindingExpression(key.name, "")));
+			contextEntityType.keys.forEach((key) => parameterExpressions.push(bindingExpression(key.name, "")));
 		}
 	}
 
@@ -1309,7 +1309,8 @@ export function formatResult<T, U extends Fn<T>>(
 export function addTypeInformation<T, U extends Fn<T>>(
 	parameters: WrappedTuple<Parameters<U>>,
 	type: string,
-	contextEntityType?: EntityType
+	contextEntityType?: EntityType,
+	oFormatOptions?: any
 ): Expression<T> {
 	const parameterExpressions = (parameters as any[]).map(wrapPrimitive);
 	if (hasUnresolveableExpression(...parameterExpressions)) {
@@ -1321,16 +1322,17 @@ export function addTypeInformation<T, U extends Fn<T>>(
 	} else if (!!contextEntityType) {
 		// Otherwise, if the context is required and no context is provided make sure to add the default binding
 		if (!parameterExpressions.some(hasReferenceToDefaultContext)) {
-			contextEntityType.keys.forEach(key => parameterExpressions.push(bindingExpression(key.name, "")));
+			contextEntityType.keys.forEach((key) => parameterExpressions.push(bindingExpression(key.name, "")));
 		}
 	}
+	if (!oFormatOptions && (parameters[0] as any)?.type?.indexOf("sap.ui.model.odata.type.Int") === 0) {
+		oFormatOptions = { parseAsString: false, emptyString: "" };
+	}
 
-	const oFormatOptions =
-		(parameters[0] as any)?.type?.indexOf("sap.ui.model.odata.type.Int") === 0 ? { parseAsString: false, emptyString: "" } : {};
 	return {
 		_type: "ComplexType",
 		type: type,
-		formatOptions: oFormatOptions,
+		formatOptions: oFormatOptions || {},
 		parameters: {},
 		bindingParameters: parameterExpressions
 	};
@@ -1400,17 +1402,17 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 	switch (expression._type) {
 		case "Function":
 		case "Formatter":
-			expression.parameters = expression.parameters.map(parameter =>
+			expression.parameters = expression.parameters.map((parameter) =>
 				transformRecursively(parameter, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
 		case "Concat":
-			expression.expressions = expression.expressions.map(subExpression =>
+			expression.expressions = expression.expressions.map((subExpression) =>
 				transformRecursively(subExpression, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
 		case "ComplexType":
-			expression.bindingParameters = expression.bindingParameters.map(bindingParameter =>
+			expression.bindingParameters = expression.bindingParameters.map((bindingParameter) =>
 				transformRecursively(bindingParameter, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
@@ -1433,7 +1435,7 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 			break;
 		case "Set":
 			if (includeAllExpression) {
-				expression.operands = expression.operands.map(operand =>
+				expression.operands = expression.operands.map((operand) =>
 					transformRecursively(operand, expressionType, transformFunction, includeAllExpression)
 				);
 			}
@@ -1461,7 +1463,7 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 
 export type BindingExpression<T> = T | string | undefined;
 
-const needParenthesis = function<T extends PrimitiveType>(expr: ExpressionOrPrimitive<T>): boolean {
+const needParenthesis = function <T extends PrimitiveType>(expr: ExpressionOrPrimitive<T>): boolean {
 	return !isConstant(expr) && !isBinding(expr) && isExpression(expr) && expr._type !== "IfElse" && expr._type !== "Function";
 };
 
@@ -1478,7 +1480,7 @@ function compileConstantObject<T>(expr: ConstantExpression<object>, isNullable =
 	// Objects
 	const o = expr.value as PlainExpressionObject;
 	const properties: string[] = [];
-	Object.keys(o).forEach(key => {
+	Object.keys(o).forEach((key) => {
 		const value = o[key];
 		const childResult = compileBinding(value, true, false, true);
 		if (childResult && childResult.length > 0) {
@@ -1504,7 +1506,7 @@ function compileConstant<T extends PrimitiveType>(expr: ConstantExpression<T>, e
 	}
 	if (typeof expr.value === "object") {
 		if (Array.isArray(expr.value)) {
-			const entries = expr.value.map(expression => compileBinding(expression, true));
+			const entries = expr.value.map((expression) => compileBinding(expression, true));
 			return `[${entries.join(", ")}]`;
 		} else {
 			return compileConstantObject(expr as ConstantExpression<object>, isNullable);
@@ -1646,7 +1648,7 @@ export function compileBinding<T extends PrimitiveType>(
 			return expr.ref || "null";
 
 		case "Function":
-			const argumentString = `${expr.parameters.map(arg => compileBinding(arg, true)).join(", ")}`;
+			const argumentString = `${expr.parameters.map((arg) => compileBinding(arg, true)).join(", ")}`;
 			return expr.obj === undefined
 				? `${expr.fn}(${argumentString})`
 				: `${compileBinding(expr.obj, true)}.${expr.fn}(${argumentString})`;
@@ -1673,11 +1675,11 @@ export function compileBinding<T extends PrimitiveType>(
 			return wrapBindingExpression(ifElseExpression, embeddedInBinding, true);
 
 		case "Set":
-			const setExpression = expr.operands.map(operand => compileBinding(operand, true)).join(` ${expr.operator} `);
+			const setExpression = expr.operands.map((operand) => compileBinding(operand, true)).join(` ${expr.operator} `);
 			return wrapBindingExpression(setExpression, embeddedInBinding, true);
 
 		case "Concat":
-			const concatExpression = expr.expressions.map(nestedExpression => compileBinding(nestedExpression, true, true)).join(" + ");
+			const concatExpression = expr.expressions.map((nestedExpression) => compileBinding(nestedExpression, true, true)).join(" + ");
 			return wrapBindingExpression(concatExpression, embeddedInBinding);
 
 		case "Length":
@@ -1730,7 +1732,7 @@ function compileFormatterExpression<T extends PrimitiveType>(expression: Formatt
 	if (expression.parameters.length === 1) {
 		return `{${compilePathParameter(expression.parameters[0], true)}, formatter: '${expression.fn}'}`;
 	} else {
-		const parts = expression.parameters.map(param => compilePathParameter(param));
+		const parts = expression.parameters.map((param) => compilePathParameter(param));
 		return `{parts: [${parts.join(", ")}], formatter: '${expression.fn}'}`;
 	}
 }