@sapui5/sap.fe.core 1.111.1 → 1.113.0

package/src/sap/fe/core/converters/controls/ListReport/FilterBar.ts

@@ -1,5 +1,11 @@
 import type { AnnotationTerm, EntityType, NavigationProperty, Property, PropertyPath } from "@sap-ux/vocabularies-types";
-import type { EntitySetAnnotations_Capabilities } from "@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm";
+import type {
+	FilterExpressionRestrictionType,
+	FilterExpressionType,
+	FilterRestrictions,
+	FilterRestrictionsType
+} from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
+import type { EntityTypeAnnotations, PropertyAnnotations } from "@sap-ux/vocabularies-types/vocabularies/Edm_Types";
 import type {
 	DataField,
 	DataFieldAbstractTypes,
@@ -13,19 +19,31 @@ import type {
 } from "@sap-ux/vocabularies-types/vocabularies/UI";
 import { UIAnnotationTerms, UIAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/UI";
 import type { ChartVisualization } from "sap/fe/core/converters/controls/Common/Chart";
-import type { SelectionVariantConfiguration, TableVisualization } from "sap/fe/core/converters/controls/Common/Table";
+import type { PropertyTypeConfig, SelectionVariantConfiguration, TableVisualization } from "sap/fe/core/converters/controls/Common/Table";
 import { getSelectionVariantConfiguration, getTypeConfig, isFilteringCaseSensitive } from "sap/fe/core/converters/controls/Common/Table";
 import type { VisualFilters } from "sap/fe/core/converters/controls/ListReport/VisualFilters";
 import { getVisualFilters } from "sap/fe/core/converters/controls/ListReport/VisualFilters";
 import type ConverterContext from "sap/fe/core/converters/ConverterContext";
-import type { ConfigurableObject, CustomElement } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import type { ConfigurableObject, CustomElement, Position } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { insertCustomElements, OverrideType, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { IssueCategory, IssueSeverity, IssueType } from "sap/fe/core/converters/helpers/IssueManager";
 import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
 import { compileExpression, getExpressionFromAnnotation } from "sap/fe/core/helpers/BindingToolkit";
 import ModelHelper from "sap/fe/core/helpers/ModelHelper";
-import type { FilterFieldManifestConfiguration, FilterManifestConfiguration, FilterSettings } from "../../ManifestSettings";
-import { AvailabilityType } from "../../ManifestSettings";
+import { isComplexType, isEntitySet, isMultipleNavigationProperty, isNavigationProperty } from "sap/fe/core/helpers/TypeGuards";
+import { enhanceDataModelPath } from "sap/fe/core/templating/DataModelPathHelper";
+import {
+	getAssociatedCurrencyPropertyPath,
+	getAssociatedTextPropertyPath,
+	getAssociatedTimezonePropertyPath,
+	getAssociatedUnitPropertyPath
+} from "sap/fe/core/templating/PropertyHelper";
+import type {
+	AvailabilityType,
+	FilterFieldManifestConfiguration,
+	FilterManifestConfiguration,
+	FilterSettings
+} from "../../ManifestSettings";
 import { getSelectionVariant } from "../Common/DataVisualization";
 //import { hasValueHelp } from "sap/fe/core/templating/PropertyHelper";
 
@@ -37,6 +55,7 @@ export type FilterField = ConfigurableObject & {
 	label?: string;
 	template?: string;
 	group?: string;
+	menu?: string;
 	groupLabel?: string;
 	settings?: FilterSettings;
 	isParameter?: boolean;
@@ -155,7 +174,7 @@ const _getConditionPath = function (entityType: EntityType, propertyPath: string
 		let part = parts.shift() as string;
 		partialPath = partialPath ? `${partialPath}/${part}` : part;
 		const property: Property | NavigationProperty = entityType.resolvePath(partialPath);
-		if (property._type === "NavigationProperty" && property.isCollection) {
+		if (isMultipleNavigationProperty(property)) {
 			part += "*";
 		}
 		key = key ? `${key}/${part}` : part;
@@ -171,18 +190,13 @@ const _createFilterSelectionField = function (
 	converterContext: ConverterContext
 ): FilterField | undefined {
 	// ignore complex property types and hidden annotated ones
-	if (
-		property !== undefined &&
-		property.targetType === undefined &&
-		(includeHidden || property.annotations?.UI?.Hidden?.valueOf() !== true)
-	) {
+	if (property && property.targetType === undefined && (includeHidden || property.annotations?.UI?.Hidden?.valueOf() !== true)) {
 		const targetEntityType = converterContext.getAnnotationEntityType(property);
 		return {
 			key: KeyHelper.getSelectionFieldKeyFromPath(fullPropertyPath),
 			annotationPath: converterContext.getAbsoluteAnnotationPath(fullPropertyPath),
 			conditionPath: _getConditionPath(entityType, fullPropertyPath),
-			availability:
-				property.annotations?.UI?.HiddenFilter?.valueOf() === true ? AvailabilityType.Hidden : AvailabilityType.Adaptation,
+			availability: property.annotations?.UI?.HiddenFilter?.valueOf() === true ? "Hidden" : "Adaptation",
 			label: compileExpression(getExpressionFromAnnotation(property.annotations.Common?.Label?.valueOf() || property.name)),
 			group: targetEntityType.name,
 			groupLabel: compileExpression(
@@ -229,7 +243,7 @@ const _getSelectionFieldsByPath = function (
 			if (property === undefined) {
 				return;
 			}
-			if (property._type === "NavigationProperty") {
+			if (isNavigationProperty(property)) {
 				// handle navigation properties
 				localSelectionFields = _getSelectionFields(
 					entityType,
@@ -238,7 +252,7 @@ const _getSelectionFieldsByPath = function (
 					includeHidden,
 					converterContext
 				);
-			} else if (property.targetType !== undefined && property.targetType._type === "ComplexType") {
+			} else if (isComplexType(property.targetType)) {
 				// handle ComplexType properties
 				localSelectionFields = _getSelectionFields(
 					entityType,
@@ -278,22 +292,21 @@ const _getFilterField = function (
 	}
 	// defined SelectionFields are available by default
 	if (filterField) {
-		filterField.availability =
-			filterField.availability === AvailabilityType.Hidden ? AvailabilityType.Hidden : AvailabilityType.Default;
+		filterField.availability = filterField.availability === "Hidden" ? "Hidden" : "Default";
 		filterField.isParameter = !!entityType.annotations?.Common?.ResultContext;
 	}
 	return filterField;
 };
 
 const _getDefaultFilterFields = function (
-	aSelectOptions: any[],
+	aSelectOptions: SelectOptionType[],
 	entityType: EntityType,
 	converterContext: ConverterContext,
 	excludedFilterProperties: Record<string, boolean>,
 	annotatedSelectionFields: PropertyPath[]
 ): FilterField[] {
 	const selectionFields: FilterField[] = [];
-	const UISelectionFields: any = {};
+	const UISelectionFields: Record<string, boolean> = {};
 	const properties = entityType.entityProperties;
 	// Using entityType instead of entitySet
 	annotatedSelectionFields?.forEach((SelectionField) => {
@@ -301,13 +314,13 @@ const _getDefaultFilterFields = function (
 	});
 	if (aSelectOptions && aSelectOptions.length > 0) {
 		aSelectOptions?.forEach((selectOption: SelectOptionType) => {
-			const propertyName: any = selectOption.PropertyName;
-			const sPropertyPath: string = propertyName.value;
-			const currentSelectionFields: any = {};
+			const propertyName = selectOption.PropertyName;
+			const sPropertyPath = propertyName?.value;
+			const currentSelectionFields: Record<string, boolean> = {};
 			annotatedSelectionFields?.forEach((SelectionField) => {
 				currentSelectionFields[SelectionField.value] = true;
 			});
-			if (!(sPropertyPath in excludedFilterProperties)) {
+			if (sPropertyPath && !(sPropertyPath in excludedFilterProperties)) {
 				if (!(sPropertyPath in currentSelectionFields)) {
 					const FilterField: FilterField | undefined = getFilterField(sPropertyPath, converterContext, entityType);
 					if (FilterField) {
@@ -368,7 +381,7 @@ function _getParameterFields(converterContext: ConverterContext): FilterField[]
  * @param converterContext The converter context
  * @returns The information if the FilterBar search field is hidden or not
  */
-export const getFilterBarhideBasicSearch = function (
+export const getFilterBarHideBasicSearch = function (
 	listReportTables: TableVisualization[],
 	charts: ChartVisualization[],
 	converterContext: ConverterContext
@@ -377,8 +390,10 @@ export const getFilterBarhideBasicSearch = function (
 	const noSearchInCharts = charts.length === 0 || charts.every((chart) => !chart.applySupported.enableSearch);
 
 	// Check if all tables are analytical and none of them allow for search
+	// or all tables are TreeTable and none of them allow for search
 	const noSearchInTables =
-		listReportTables.length === 0 || listReportTables.every((table) => table.enableAnalytics && !table.enableAnalyticsSearch);
+		listReportTables.length === 0 ||
+		listReportTables.every((table) => (table.enableAnalytics || table.control.type === "TreeTable") && !table.enableBasicSearch);
 
 	const contextPath = converterContext.getContextPath();
 	if (contextPath && noSearchInCharts && noSearchInTables) {
@@ -427,7 +442,7 @@ export const getManifestFilterFields = function (
 			template: filterField.template,
 			label: filterField.label,
 			position: filterField.position || { placement: Placement.After },
-			availability: filterField.availability || AvailabilityType.Default,
+			availability: filterField.availability || "Default",
 			settings: filterField.settings,
 			visualFilter: visualFilter,
 			required: filterField.required
@@ -440,33 +455,36 @@ export const getFilterField = function (propertyPath: string, converterContext:
 	return _getFilterField({}, propertyPath, converterContext, entityType);
 };
 
-export const getFilterRestrictions = function (oFilterRestrictionsAnnotation: any, sRestriction: any) {
-	if (sRestriction === "RequiredProperties" || sRestriction === "NonFilterableProperties") {
-		let aProps = [];
-		if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation[sRestriction]) {
-			aProps = oFilterRestrictionsAnnotation[sRestriction].map(function (oProperty: any) {
-				return oProperty.$PropertyPath || oProperty.value;
-			});
-		}
-		return aProps;
-	} else if (sRestriction === "FilterAllowedExpressions") {
-		const mAllowedExpressions = {} as any;
-		if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation.FilterExpressionRestrictions) {
-			oFilterRestrictionsAnnotation.FilterExpressionRestrictions.forEach(function (oProperty: any) {
-				//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
-				if (mAllowedExpressions[oProperty.Property.value]) {
-					mAllowedExpressions[oProperty.Property.value].push(oProperty.AllowedExpressions);
+export const getFilterRestrictions = function (
+	oFilterRestrictionsAnnotation: FilterRestrictionsType | undefined,
+	sRestriction: "RequiredProperties" | "NonFilterableProperties"
+) {
+	let aProps: string[] = [];
+	if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation[sRestriction]) {
+		aProps = oFilterRestrictionsAnnotation[sRestriction].map(function (oProperty) {
+			return oProperty.value;
+		});
+	}
+	return aProps;
+};
+export const getFilterAllowedExpression = function (oFilterRestrictionsAnnotation: FilterRestrictionsType | undefined) {
+	const mAllowedExpressions: Record<string, FilterExpressionType[]> = {};
+	if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation.FilterExpressionRestrictions) {
+		oFilterRestrictionsAnnotation.FilterExpressionRestrictions.forEach(function (oProperty: FilterExpressionRestrictionType) {
+			//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
+			if (oProperty.Property?.value && oProperty.AllowedExpressions) {
+				if (mAllowedExpressions[oProperty.Property?.value]) {
+					mAllowedExpressions[oProperty.Property?.value].push(oProperty.AllowedExpressions.toString());
 				} else {
-					mAllowedExpressions[oProperty.Property.value] = [oProperty.AllowedExpressions];
+					mAllowedExpressions[oProperty.Property?.value] = [oProperty.AllowedExpressions.toString()];
 				}
-			});
-		}
-		return mAllowedExpressions;
+			}
+		});
 	}
-	return oFilterRestrictionsAnnotation;
+	return mAllowedExpressions;
 };
 
-const getSearchFilterPropertyInfo = function () {
+const getSearchFilterPropertyInfo = function (): PropertyInfo {
 	return {
 		name: "$search",
 		path: "$search",
@@ -475,7 +493,7 @@ const getSearchFilterPropertyInfo = function () {
 	};
 };
 
-const getEditStateFilterPropertyInfo = function () {
+const getEditStateFilterPropertyInfo = function (): PropertyInfo {
 	return {
 		name: "$editState",
 		path: "$editState",
@@ -487,31 +505,49 @@ const getEditStateFilterPropertyInfo = function () {
 };
 
 const getSearchRestrictions = function (converterContext: ConverterContext) {
-	let searchRestrictions;
-	if (!ModelHelper.isSingleton(converterContext.getEntitySet())) {
-		const capabilites = converterContext.getEntitySet()?.annotations?.Capabilities as EntitySetAnnotations_Capabilities;
-		searchRestrictions = capabilites?.SearchRestrictions;
-	}
-	return searchRestrictions;
+	const entitySet = converterContext.getEntitySet();
+	return isEntitySet(entitySet) ? entitySet.annotations.Capabilities?.SearchRestrictions : undefined;
 };
 
 export const getNavigationRestrictions = function (converterContext: ConverterContext, sNavigationPath: string) {
-	const oNavigationRestrictions: any = converterContext.getEntitySet()?.annotations?.Capabilities?.NavigationRestrictions;
+	const oNavigationRestrictions = converterContext.getEntitySet()?.annotations?.Capabilities?.NavigationRestrictions;
 	const aRestrictedProperties = oNavigationRestrictions && oNavigationRestrictions.RestrictedProperties;
 	return (
 		aRestrictedProperties &&
-		aRestrictedProperties.find(function (oRestrictedProperty: any) {
+		aRestrictedProperties.find(function (oRestrictedProperty) {
 			return (
 				oRestrictedProperty &&
 				oRestrictedProperty.NavigationProperty &&
-				(oRestrictedProperty.NavigationProperty.$NavigationPropertyPath === sNavigationPath ||
-					oRestrictedProperty.NavigationProperty.value === sNavigationPath)
+				oRestrictedProperty.NavigationProperty.value === sNavigationPath
 			);
 		})
 	);
 };
 
-const _fetchBasicPropertyInfo = function (oFilterFieldInfo: any) {
+type PropertyInfo = {
+	key?: string;
+	annotationPath?: string;
+	conditionPath?: string;
+	name: string;
+	path?: string;
+	label?: string;
+	groupLabel?: string;
+	maxConditions?: number;
+	dataType?: string;
+	group?: string;
+	hiddenFilter?: boolean;
+	display?: string;
+	isParameter?: boolean;
+	caseSensitive?: boolean;
+	availability?: AvailabilityType;
+	position?: Position;
+	type?: string;
+	template?: string;
+	menu?: string;
+	required?: boolean;
+	filterExpression?: string;
+};
+const _fetchBasicPropertyInfo = function (oFilterFieldInfo: FilterField): PropertyInfo {
 	return {
 		key: oFilterFieldInfo.key,
 		annotationPath: oFilterFieldInfo.annotationPath,
@@ -531,7 +567,7 @@ const _fetchBasicPropertyInfo = function (oFilterFieldInfo: any) {
 	};
 };
 
-export const getSpecificAllowedExpression = function (aExpressions: any) {
+export const getSpecificAllowedExpression = function (aExpressions: string[]) {
 	const aAllowedExpressionsPriority = [
 		"SingleValue",
 		"MultiValue",
@@ -541,14 +577,14 @@ export const getSpecificAllowedExpression = function (aExpressions: any) {
 		"MultiRangeOrSearchExpression"
 	];
 
-	aExpressions.sort(function (a: any, b: any) {
+	aExpressions.sort(function (a: string, b: string) {
 		return aAllowedExpressionsPriority.indexOf(a) - aAllowedExpressionsPriority.indexOf(b);
 	});
 
 	return aExpressions[0];
 };
 
-export const displayMode = function (oPropertyAnnotations: any, oCollectionAnnotations: any) {
+export const displayMode = function (oPropertyAnnotations: PropertyAnnotations, oCollectionAnnotations: EntityTypeAnnotations) {
 	const oTextAnnotation = oPropertyAnnotations?.Common?.Text,
 		oTextArrangmentAnnotation =
 			oTextAnnotation &&
@@ -566,7 +602,11 @@ export const displayMode = function (oPropertyAnnotations: any, oCollectionAnnot
 	return oTextAnnotation ? "DescriptionValue" : "Value";
 };
 
-export const fetchPropertyInfo = function (converterContext: ConverterContext, oFilterFieldInfo: any, oTypeConfig: any) {
+export const fetchPropertyInfo = function (
+	converterContext: ConverterContext,
+	oFilterFieldInfo: FilterField,
+	oTypeConfig: Partial<PropertyTypeConfig>
+): PropertyInfo {
 	let oPropertyInfo = _fetchBasicPropertyInfo(oFilterFieldInfo);
 	const sAnnotationPath = oFilterFieldInfo.annotationPath;
 
@@ -588,7 +628,7 @@ export const fetchPropertyInfo = function (converterContext: ConverterContext, o
 	return oPropertyInfo;
 };
 
-export const isMultiValue = function (oProperty: any) {
+export const isMultiValue = function (oProperty: PropertyInfo) {
 	let bIsMultiValue = true;
 	//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
 	switch (oProperty.filterExpression) {
@@ -617,11 +657,86 @@ const _isFilterableNavigationProperty = function (
 	);
 };
 
+/**
+ * Adds the additional property which references to the unit, timezone, textArrangement or currency from a data field.
+ *
+ * @param dataField The data field to be considered
+ * @param converterContext The converter context
+ * @param navProperties The list of navigation properties
+ */
+const addChildNavigationProperties = function (
+	dataField: DataFieldAbstractTypes,
+	converterContext: ConverterContext,
+	navProperties: string[]
+) {
+	const targetProperty = (dataField as DataField).Value?.$target;
+	if (targetProperty) {
+		const additionalPropertyPath =
+			getAssociatedTextPropertyPath(targetProperty) ||
+			getAssociatedCurrencyPropertyPath(targetProperty) ||
+			getAssociatedUnitPropertyPath(targetProperty) ||
+			getAssociatedTimezonePropertyPath(targetProperty);
+		const navigationProperty = additionalPropertyPath
+			? enhanceDataModelPath(converterContext.getDataModelObjectPath(), additionalPropertyPath).navigationProperties
+			: undefined;
+		if (navigationProperty?.length) {
+			const navigationPropertyPath = navigationProperty[0].name;
+			if (!navProperties.includes(navigationPropertyPath)) {
+				navProperties.push(navigationPropertyPath);
+			}
+		}
+	}
+};
+
+/**
+ * Gets used navigation properties for available dataField.
+ *
+ * @param navProperties The list of navigation properties
+ * @param dataField The data field to be considered
+ * @param converterContext The converter context
+ * @returns The list of navigation properties
+ */
+const getNavigationPropertiesRecursively = function (
+	navProperties: string[],
+	dataField: DataFieldAbstractTypes,
+	converterContext: ConverterContext
+) {
+	switch (dataField.$Type) {
+		case UIAnnotationTypes.DataFieldForAnnotation:
+			switch (dataField.Target?.$target?.$Type) {
+				case UIAnnotationTypes.FieldGroupType:
+					dataField.Target.$target.Data?.forEach((innerDataField: DataFieldAbstractTypes) => {
+						getNavigationPropertiesRecursively(navProperties, innerDataField, converterContext);
+					});
+					break;
+				default:
+					break;
+			}
+			break;
+		case UIAnnotationTypes.DataField:
+		case UIAnnotationTypes.DataFieldWithUrl:
+		case UIAnnotationTypes.DataFieldWithNavigationPath:
+			if (_isFilterableNavigationProperty(dataField)) {
+				const navigationPropertyPath = enhanceDataModelPath(converterContext.getDataModelObjectPath(), dataField.Value.path)
+					.navigationProperties[0].name;
+				if (!navProperties.includes(navigationPropertyPath)) {
+					navProperties.push(navigationPropertyPath);
+				}
+			}
+			// Additional property from text arrangement/units/currencies/timezone...
+			addChildNavigationProperties(dataField, converterContext, navProperties);
+			break;
+		default:
+			break;
+	}
+	return navProperties;
+};
+
 const getAnnotatedSelectionFieldData = function (
 	converterContext: ConverterContext,
 	lrTables: TableVisualization[] = [],
-	annotationPath: string = "",
-	includeHidden: boolean = false,
+	annotationPath = "",
+	includeHidden = false,
 	lineItemTerm?: string
 ) {
 	// Fetch all selectionVariants defined in the different visualizations and different views (multi table mode)
@@ -635,15 +750,10 @@ const getAnnotatedSelectionFieldData = function (
 		entityType.annotations?.UI?.SelectionFields ||
 		[]) as PropertyPath[];
 
-	const navProperties: string[] = [];
+	let navProperties: string[] = [];
 	if (lrTables.length === 0 && !!lineItemTerm) {
-		(converterContext.getEntityTypeAnnotation(lineItemTerm).annotation as LineItem)?.forEach((entry) => {
-			if (_isFilterableNavigationProperty(entry)) {
-				const entityPath = entry.Value.path.slice(0, entry.Value.path.lastIndexOf("/"));
-				if (!navProperties.includes(entityPath)) {
-					navProperties.push(entityPath);
-				}
-			}
+		(converterContext.getEntityTypeAnnotation(lineItemTerm).annotation as LineItem)?.forEach((dataField: DataFieldAbstractTypes) => {
+			navProperties = getNavigationPropertiesRecursively(navProperties, dataField, converterContext);
 		});
 	}
 
@@ -661,13 +771,13 @@ const getAnnotatedSelectionFieldData = function (
 			converterContext
 		)
 	};
-	let aSelectOptions: any[] = [];
+	let aSelectOptions: SelectOptionType[] = [];
 	const selectionVariant = getSelectionVariant(entityType, converterContext);
 	if (selectionVariant) {
 		aSelectOptions = selectionVariant.SelectOptions;
 	}
 
-	const propertyInfoFields: any =
+	const propertyInfoFields: FilterField[] =
 		annotatedSelectionFields?.reduce((selectionFields: FilterField[], selectionField) => {
 			const propertyPath = selectionField.value;
 			if (!(propertyPath in excludedFilterProperties)) {
@@ -721,13 +831,13 @@ export const fetchTypeConfig = function (property: Property) {
 };
 
 export const assignDataTypeToPropertyInfo = function (
-	propertyInfoField: any,
+	propertyInfoField: FilterField,
 	converterContext: ConverterContext,
-	aRequiredProps: any,
-	aTypeConfig: any
+	aRequiredProps: unknown[],
+	aTypeConfig: Record<string, Partial<PropertyTypeConfig>>
 ) {
-	let oPropertyInfo: any = fetchPropertyInfo(converterContext, propertyInfoField, aTypeConfig[propertyInfoField.key]),
-		sPropertyPath: string = "";
+	let oPropertyInfo = fetchPropertyInfo(converterContext, propertyInfoField, aTypeConfig[propertyInfoField.key]),
+		sPropertyPath = "";
 	if (propertyInfoField.conditionPath) {
 		sPropertyPath = propertyInfoField.conditionPath.replace(/\+|\*/g, "");
 	}
@@ -743,19 +853,19 @@ export const assignDataTypeToPropertyInfo = function (
 };
 
 export const processSelectionFields = function (
-	propertyInfoFields: any,
+	propertyInfoFields: FilterField[],
 	converterContext: ConverterContext,
-	defaultValuePropertyFields?: any
+	defaultValuePropertyFields?: FilterField[]
 ) {
 	//get TypeConfig function
-	const selectionFieldTypes: any = [];
-	const aTypeConfig: any = {};
+	const selectionFieldTypes: unknown[] = [];
+	const aTypeConfig: Record<string, Partial<PropertyTypeConfig>> = {};
 
 	if (defaultValuePropertyFields) {
 		propertyInfoFields = propertyInfoFields.concat(defaultValuePropertyFields);
 	}
 	//add typeConfig
-	propertyInfoFields.forEach(function (parameterField: any) {
+	propertyInfoFields.forEach(function (parameterField) {
 		if (parameterField.annotationPath) {
 			const propertyConvertyContext = converterContext.getConverterContextFor(parameterField.annotationPath);
 			const propertyTargetObject = propertyConvertyContext.getDataModelObjectPath().targetObject;
@@ -769,16 +879,16 @@ export const processSelectionFields = function (
 	});
 
 	// filterRestrictions
-	let _oFilterrestrictions;
-	if (!ModelHelper.isSingleton(converterContext.getEntitySet())) {
-		_oFilterrestrictions = (converterContext.getEntitySet()?.annotations?.Capabilities as EntitySetAnnotations_Capabilities)
-			?.FilterRestrictions;
-	}
-	const oFilterRestrictions = _oFilterrestrictions;
-	const oRet = {} as any;
-	oRet["RequiredProperties"] = getFilterRestrictions(oFilterRestrictions, "RequiredProperties") || [];
-	oRet["NonFilterableProperties"] = getFilterRestrictions(oFilterRestrictions, "NonFilterableProperties") || [];
-	oRet["FilterAllowedExpressions"] = getFilterRestrictions(oFilterRestrictions, "FilterAllowedExpressions") || {};
+	const entitySet = converterContext.getEntitySet();
+	const oFilterRestrictions = isEntitySet(entitySet) ? entitySet.annotations.Capabilities?.FilterRestrictions : undefined;
+	const oRet: {
+		RequiredProperties?: string[];
+		NonFilterableProperties?: string[];
+		FilterAllowedExpressions?: Record<string, FilterExpressionType[]>;
+	} = {};
+	oRet.RequiredProperties = getFilterRestrictions(oFilterRestrictions, "RequiredProperties") || [];
+	oRet.NonFilterableProperties = getFilterRestrictions(oFilterRestrictions, "NonFilterableProperties") || [];
+	oRet.FilterAllowedExpressions = getFilterAllowedExpression(oFilterRestrictions);
 
 	const sEntitySetPath = converterContext.getContextPath();
 	const aPathParts = sEntitySetPath.split("/");
@@ -787,20 +897,24 @@ export const processSelectionFields = function (
 		aPathParts.splice(-1, 1);
 		const oNavigationRestrictions = getNavigationRestrictions(converterContext, sNavigationPath);
 		const oNavigationFilterRestrictions = oNavigationRestrictions && oNavigationRestrictions.FilterRestrictions;
-		oRet.RequiredProperties.concat(getFilterRestrictions(oNavigationFilterRestrictions, "RequiredProperties") || []);
-		oRet.NonFilterableProperties.concat(getFilterRestrictions(oNavigationFilterRestrictions, "NonFilterableProperties") || []);
+		oRet.RequiredProperties = oRet.RequiredProperties.concat(
+			getFilterRestrictions(oNavigationFilterRestrictions, "RequiredProperties") || []
+		);
+		oRet.NonFilterableProperties = oRet.NonFilterableProperties.concat(
+			getFilterRestrictions(oNavigationFilterRestrictions, "NonFilterableProperties") || []
+		);
 		oRet.FilterAllowedExpressions = {
-			...(getFilterRestrictions(oNavigationFilterRestrictions, "FilterAllowedExpressions") || {}),
+			...(getFilterAllowedExpression(oNavigationFilterRestrictions) || {}),
 			...oRet.FilterAllowedExpressions
 		};
 	}
 	const aRequiredProps = oRet.RequiredProperties;
 	const aNonFilterableProps = oRet.NonFilterableProperties;
-	const aFetchedProperties: any = [];
+	const aFetchedProperties: PropertyInfo[] = [];
 
 	// process the fields to add necessary properties
-	propertyInfoFields.forEach(function (propertyInfoField: any) {
-		let sPropertyPath;
+	propertyInfoFields.forEach(function (propertyInfoField) {
+		const sPropertyPath = propertyInfoField.conditionPath.replace(/\+|\*/g, "");
 		if (aNonFilterableProps.indexOf(sPropertyPath) === -1) {
 			const oPropertyInfo = assignDataTypeToPropertyInfo(propertyInfoField, converterContext, aRequiredProps, aTypeConfig);
 			aFetchedProperties.push(oPropertyInfo);
@@ -856,10 +970,10 @@ export const insertCustomManifestElements = function (
 export const getSelectionFields = function (
 	converterContext: ConverterContext,
 	lrTables: TableVisualization[] = [],
-	annotationPath: string = "",
+	annotationPath = "",
 	includeHidden?: boolean,
 	lineItemTerm?: string
-): any {
+) {
 	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(
 		converterContext,
 		lrTables,
@@ -880,7 +994,7 @@ export const getSelectionFields = function (
 		converterContext,
 		oAnnotatedSelectionFieldData.defaultFilterFields
 	);
-	aFetchedProperties.sort(function (a: any, b: any) {
+	aFetchedProperties.sort(function (a: FilterGroup, b: FilterGroup) {
 		if (a.groupLabel === undefined || a.groupLabel === null) {
 			return -1;
 		}
@@ -974,18 +1088,17 @@ export const getSelectionFields = function (
  *
  * @param converterContext The converter context
  * @param filterRestrictionsAnnotation The FilterRestriction annotation
- * @param valueListAnnotation The ValueList annotation
+ * @param valueList The ValueList annotation
  * @returns The value for expandFilterFields
  */
 export const getExpandFilterFields = function (
 	converterContext: ConverterContext,
-	filterRestrictionsAnnotation: any,
-	valueListAnnotation: any
+	filterRestrictionsAnnotation: FilterRestrictions | undefined,
+	valueList: any
 ): boolean {
 	const requiredProperties = getFilterRestrictions(filterRestrictionsAnnotation, "RequiredProperties");
 	const searchRestrictions = getSearchRestrictions(converterContext);
 	const hideBasicSearch = Boolean(searchRestrictions && !searchRestrictions.Searchable);
-	const valueList = valueListAnnotation.getObject();
 	if (requiredProperties.length > 0 || hideBasicSearch || valueList?.FetchValues === 2) {
 		return true;
 	}