@sapui5/sap.fe.core 1.100.0 → 1.102.0

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

@@ -1,23 +1,23 @@
-import { AvailabilityType, FilterFieldManifestConfiguration, FilterManifestConfiguration, FilterSettings } from "../../ManifestSettings";
 import { EntityType, NavigationProperty, Property } from "@sap-ux/annotation-converter";
-import ConverterContext from "sap/fe/core/converters/ConverterContext";
 import { AnnotationTerm, DataFieldAbstractTypes, DataFieldTypes, ReferenceFacetTypes, UIAnnotationTerms } from "@sap-ux/vocabularies-types";
+import { PropertyPath } from "@sap-ux/vocabularies-types/dist/Edm";
+import { FieldGroup, FieldGroupType, SelectOptionType } from "@sap-ux/vocabularies-types/dist/generated/UI";
+import { ChartVisualization } from "sap/fe/core/converters/controls/Common/Chart";
 import {
 	getSelectionVariantConfiguration,
-	SelectionVariantConfiguration,
-	TableVisualization,
+	getTypeConfig,
 	isFilteringCaseSensitive,
-	getTypeConfig
+	SelectionVariantConfiguration,
+	TableVisualization
 } from "sap/fe/core/converters/controls/Common/Table";
-import { ChartVisualization } from "sap/fe/core/converters/controls/Common/Chart";
-import { ConfigurableObject, CustomElement, insertCustomElements, Placement } from "sap/fe/core/converters/helpers/ConfigurableObject";
 import { getVisualFilters, VisualFilters } from "sap/fe/core/converters/controls/ListReport/VisualFilters";
-import { SelectOptionType, FieldGroupType, FieldGroup } from "@sap-ux/vocabularies-types/dist/generated/UI";
+import ConverterContext from "sap/fe/core/converters/ConverterContext";
+import { ConfigurableObject, CustomElement, insertCustomElements, 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 { annotationExpression, compileBinding } from "sap/fe/core/helpers/BindingExpression";
+import { AvailabilityType, FilterFieldManifestConfiguration, FilterManifestConfiguration, FilterSettings } from "../../ManifestSettings";
 import { getSelectionVariant } from "../Common/DataVisualization";
-import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
-import { IssueType, IssueSeverity, IssueCategory } from "sap/fe/core/converters/helpers/IssueManager";
-import { PropertyPath } from "@sap-ux/vocabularies-types/dist/Edm";
 //import { hasValueHelp } from "sap/fe/core/templating/PropertyHelper";
 
 export type FilterField = ConfigurableObject & {
@@ -74,7 +74,7 @@ function getFieldGroupFilterGroups(fieldGroup: AnnotationTerm<FieldGroupType>):
 
 function getExcludedFilterProperties(selectionVariants: SelectionVariantConfiguration[]): Record<string, boolean> {
 	return selectionVariants.reduce((previousValue: Record<string, boolean>, selectionVariant) => {
-		selectionVariant.propertyNames.forEach(propertyName => {
+		selectionVariant.propertyNames.forEach((propertyName) => {
 			previousValue[propertyName] = true;
 		});
 		return previousValue;
@@ -89,7 +89,7 @@ function getExcludedFilterProperties(selectionVariants: SelectionVariantConfigur
  */
 function checkAllTableForEntitySetAreAnalytical(listReportTables: TableVisualization[], contextPath: string | undefined) {
 	if (contextPath && listReportTables.length > 0) {
-		return listReportTables.every(visualization => {
+		return listReportTables.every((visualization) => {
 			return visualization.enableAnalytics && contextPath === visualization.annotation.collection;
 		});
 	}
@@ -102,13 +102,13 @@ function getSelectionVariants(
 ): SelectionVariantConfiguration[] {
 	const selectionVariantPaths: string[] = [];
 	return lrTableVisualizations
-		.map(visualization => {
+		.map((visualization) => {
 			const tableFilters = visualization.control.filters;
 			const tableSVConfigs: SelectionVariantConfiguration[] = [];
 			for (const key in tableFilters) {
 				if (Array.isArray(tableFilters[key].paths)) {
 					const paths = tableFilters[key].paths;
-					paths.forEach(path => {
+					paths.forEach((path) => {
 						if (path && path.annotationPath && selectionVariantPaths.indexOf(path.annotationPath) === -1) {
 							selectionVariantPaths.push(path.annotationPath);
 							const selectionVariantConfig = getSelectionVariantConfiguration(path.annotationPath, converterContext);
@@ -132,7 +132,7 @@ function getSelectionVariants(
  * @param propertyPath The full path to the target property
  * @returns {string} The formatted condition path
  */
-const _getConditionPath = function(entityType: EntityType, propertyPath: string): string {
+const _getConditionPath = function (entityType: EntityType, propertyPath: string): string {
 	const parts = propertyPath.split("/");
 	let partialPath;
 	let key = "";
@@ -148,7 +148,7 @@ const _getConditionPath = function(entityType: EntityType, propertyPath: string)
 	return key;
 };
 
-const _createFilterSelectionField = function(
+const _createFilterSelectionField = function (
 	entityType: EntityType,
 	property: Property,
 	fullPropertyPath: string,
@@ -242,7 +242,7 @@ export function getModelType(sType: any) {
 	};
 	return sType && sType in mDefaultTypeForEdmType && mDefaultTypeForEdmType[sType].modelType;
 }
-const _getSelectionFields = function(
+const _getSelectionFields = function (
 	entityType: EntityType,
 	navigationPath: string,
 	properties: Array<Property> | undefined,
@@ -263,7 +263,7 @@ const _getSelectionFields = function(
 	return selectionFieldMap;
 };
 
-const _getSelectionFieldsByPath = function(
+const _getSelectionFieldsByPath = function (
 	entityType: EntityType,
 	propertyPaths: Array<string> | undefined,
 	includeHidden: boolean,
@@ -297,12 +297,7 @@ const _getSelectionFieldsByPath = function(
 					converterContext
 				);
 			} else {
-				const navigationPath = propertyPath.includes("/")
-					? propertyPath
-							.split("/")
-							.splice(0, 1)
-							.join("/")
-					: "";
+				const navigationPath = propertyPath.includes("/") ? propertyPath.split("/").splice(0, 1).join("/") : "";
 				localSelectionFields = _getSelectionFields(entityType, navigationPath, [property], includeHidden, converterContext);
 			}
 
@@ -315,13 +310,14 @@ const _getSelectionFieldsByPath = function(
 	return selectionFields;
 };
 
-const _getFilterField = function(
+const _getFilterField = function (
 	filterFields: Record<string, FilterField>,
 	propertyPath: string,
 	converterContext: ConverterContext,
 	entityType: EntityType
 ): FilterField | undefined {
 	let filterField: FilterField | undefined = filterFields[propertyPath];
+	const availability = filterField && filterField.availability;
 	if (filterField) {
 		delete filterFields[propertyPath];
 	} else {
@@ -332,14 +328,13 @@ const _getFilterField = function(
 	}
 	// defined SelectionFields are available by default
 	if (filterField) {
-		filterField.availability = AvailabilityType.Default;
+		filterField.availability = availability === AvailabilityType.Hidden ? AvailabilityType.Hidden : AvailabilityType.Default;
 		filterField.isParameter = !!entityType.annotations?.Common?.ResultContext;
 	}
 	return filterField;
 };
 
-const _getDefaultFilterFields = function(
-	filterFields: Record<string, FilterField>,
+const _getDefaultFilterFields = function (
 	aSelectOptions: any[],
 	entityType: EntityType,
 	converterContext: ConverterContext,
@@ -350,7 +345,7 @@ const _getDefaultFilterFields = function(
 	const UISelectionFields: any = {};
 	const properties = entityType.entityProperties;
 	// Using entityType instead of entitySet
-	annotatedSelectionFields?.forEach(SelectionField => {
+	annotatedSelectionFields?.forEach((SelectionField) => {
 		UISelectionFields[SelectionField.value] = true;
 	});
 	if (aSelectOptions && aSelectOptions.length > 0) {
@@ -358,12 +353,12 @@ const _getDefaultFilterFields = function(
 			const propertyName: any = selectOption.PropertyName;
 			const sPropertyPath: string = propertyName.value;
 			const UISelectionFields: any = {};
-			annotatedSelectionFields?.forEach(SelectionField => {
+			annotatedSelectionFields?.forEach((SelectionField) => {
 				UISelectionFields[SelectionField.value] = true;
 			});
 			if (!(sPropertyPath in excludedFilterProperties)) {
 				if (!(sPropertyPath in UISelectionFields)) {
-					const FilterField: FilterField | undefined = _getFilterField(filterFields, sPropertyPath, converterContext, entityType);
+					const FilterField: FilterField | undefined = getFilterField(sPropertyPath, converterContext, entityType);
 					if (FilterField) {
 						selectionFields.push(FilterField);
 					}
@@ -376,7 +371,7 @@ const _getDefaultFilterFields = function(
 			const PropertyPath = property.name;
 			if (!(PropertyPath in excludedFilterProperties)) {
 				if (defaultFilterValue && !(PropertyPath in UISelectionFields)) {
-					const FilterField: FilterField | undefined = _getFilterField(filterFields, PropertyPath, converterContext, entityType);
+					const FilterField: FilterField | undefined = getFilterField(PropertyPath, converterContext, entityType);
 					if (FilterField) {
 						selectionFields.push(FilterField);
 					}
@@ -395,15 +390,22 @@ const _getDefaultFilterFields = function(
 function _getParameterFields(converterContext: ConverterContext): FilterField[] {
 	const dataModelObjectPath = converterContext.getDataModelObjectPath();
 	const parameterEntityType = dataModelObjectPath.startingEntitySet.entityType;
-	const isParameterized = !!parameterEntityType.annotations?.Common?.ResultContext;
+	const isParameterized = !!parameterEntityType.annotations?.Common?.ResultContext && !dataModelObjectPath.targetEntitySet;
 	const parameterConverterContext =
 		isParameterized && converterContext.getConverterContextFor("/" + dataModelObjectPath.startingEntitySet.name);
 
-	const parameterFields = (parameterConverterContext
-		? parameterEntityType.entityProperties.map(function(property) {
-				return _getFilterField({} as Record<string, FilterField>, property.name, parameterConverterContext, parameterEntityType);
-		  })
-		: []) as FilterField[];
+	const parameterFields = (
+		parameterConverterContext
+			? parameterEntityType.entityProperties.map(function (property) {
+					return _getFilterField(
+						{} as Record<string, FilterField>,
+						property.name,
+						parameterConverterContext,
+						parameterEntityType
+					);
+			  })
+			: []
+	) as FilterField[];
 
 	return parameterFields;
 }
@@ -416,17 +418,17 @@ function _getParameterFields(converterContext: ConverterContext): FilterField[]
  * @param {ConverterContext} converterContext The converter context
  * @returns {boolean} 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
 ): boolean {
 	// Check if charts allow search
-	const noSearchInCharts = charts.length === 0 || charts.every(chart => !chart.applySupported.enableSearch);
+	const noSearchInCharts = charts.length === 0 || charts.every((chart) => !chart.applySupported.enableSearch);
 
 	// Check if all tables are analytical 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.enableAnalyticsSearch);
 
 	const contextPath = converterContext.getContextPath();
 	if (contextPath && noSearchInCharts && noSearchInTables) {
@@ -443,7 +445,7 @@ export const getFilterBarhideBasicSearch = function(
  * @param converterContext The converter context
  * @returns {Record<string, CustomElementFilterField>} The filter fields defined in the manifest
  */
-export const getManifestFilterFields = function(
+export const getManifestFilterFields = function (
 	entityType: EntityType,
 	converterContext: ConverterContext
 ): Record<string, CustomElementFilterField> {
@@ -451,7 +453,7 @@ export const getManifestFilterFields = function(
 	const definedFilterFields: Record<string, FilterFieldManifestConfiguration> = fbConfig?.filterFields || {};
 	const selectionFields: Record<string, FilterField> = _getSelectionFieldsByPath(
 		entityType,
-		Object.keys(definedFilterFields).map(key => KeyHelper.getPathFromSelectionFieldKey(key)),
+		Object.keys(definedFilterFields).map((key) => KeyHelper.getPathFromSelectionFieldKey(key)),
 		true,
 		converterContext
 	);
@@ -482,15 +484,15 @@ export const getManifestFilterFields = function(
 	return filterFields;
 };
 
-export const getFilterField = function(propertyPath: string, converterContext: ConverterContext, entityType: EntityType) {
+export const getFilterField = function (propertyPath: string, converterContext: ConverterContext, entityType: EntityType) {
 	return _getFilterField({}, propertyPath, converterContext, entityType);
 };
 
-export const getFilterRestrictions = function(oFilterRestrictionsAnnotation: any, sRestriction: any) {
+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) {
+			aProps = oFilterRestrictionsAnnotation[sRestriction].map(function (oProperty: any) {
 				return oProperty.$PropertyPath || oProperty.value;
 			});
 		}
@@ -498,7 +500,7 @@ export const getFilterRestrictions = function(oFilterRestrictionsAnnotation: any
 	} else if (sRestriction === "FilterAllowedExpressions") {
 		const mAllowedExpressions = {} as any;
 		if (oFilterRestrictionsAnnotation && oFilterRestrictionsAnnotation.FilterExpressionRestrictions) {
-			oFilterRestrictionsAnnotation.FilterExpressionRestrictions.forEach(function(oProperty: any) {
+			oFilterRestrictionsAnnotation.FilterExpressionRestrictions.forEach(function (oProperty: any) {
 				//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
 				if (mAllowedExpressions[oProperty.Property.value]) {
 					mAllowedExpressions[oProperty.Property.value].push(oProperty.AllowedExpressions);
@@ -512,7 +514,7 @@ export const getFilterRestrictions = function(oFilterRestrictionsAnnotation: any
 	return oFilterRestrictionsAnnotation;
 };
 
-const getSearchFilterPropertyInfo = function() {
+const getSearchFilterPropertyInfo = function () {
 	return {
 		name: "$search",
 		path: "$search",
@@ -521,7 +523,7 @@ const getSearchFilterPropertyInfo = function() {
 	};
 };
 
-const getEditStateFilterPropertyInfo = function() {
+const getEditStateFilterPropertyInfo = function () {
 	return {
 		name: "$editState",
 		path: "$editState",
@@ -532,16 +534,16 @@ const getEditStateFilterPropertyInfo = function() {
 	};
 };
 
-const getSearchRestrictions = function(converterContext: ConverterContext) {
+const getSearchRestrictions = function (converterContext: ConverterContext) {
 	return converterContext.getEntitySet()?.annotations?.Capabilities?.SearchRestrictions;
 };
 
-export const getNavigationRestrictions = function(converterContext: ConverterContext, sNavigationPath: string) {
+export const getNavigationRestrictions = function (converterContext: ConverterContext, sNavigationPath: string) {
 	const oNavigationRestrictions: any = converterContext.getEntitySet()?.annotations?.Capabilities?.NavigationRestrictions;
 	const aRestrictedProperties = oNavigationRestrictions && oNavigationRestrictions.RestrictedProperties;
 	return (
 		aRestrictedProperties &&
-		aRestrictedProperties.find(function(oRestrictedProperty: any) {
+		aRestrictedProperties.find(function (oRestrictedProperty: any) {
 			return (
 				oRestrictedProperty &&
 				oRestrictedProperty.NavigationProperty &&
@@ -552,7 +554,7 @@ export const getNavigationRestrictions = function(converterContext: ConverterCon
 	);
 };
 
-const _fetchBasicPropertyInfo = function(oFilterFieldInfo: any) {
+const _fetchBasicPropertyInfo = function (oFilterFieldInfo: any) {
 	return {
 		key: oFilterFieldInfo.key,
 		annotationPath: oFilterFieldInfo.annotationPath,
@@ -571,7 +573,7 @@ const _fetchBasicPropertyInfo = function(oFilterFieldInfo: any) {
 	};
 };
 
-export const getSpecificAllowedExpression = function(aExpressions: any) {
+export const getSpecificAllowedExpression = function (aExpressions: any) {
 	const aAllowedExpressionsPriority = [
 		"SingleValue",
 		"MultiValue",
@@ -581,14 +583,14 @@ export const getSpecificAllowedExpression = function(aExpressions: any) {
 		"MultiRangeOrSearchExpression"
 	];
 
-	aExpressions.sort(function(a: any, b: any) {
+	aExpressions.sort(function (a: any, b: any) {
 		return aAllowedExpressionsPriority.indexOf(a) - aAllowedExpressionsPriority.indexOf(b);
 	});
 
 	return aExpressions[0];
 };
 
-export const displayMode = function(oPropertyAnnotations: any, oCollectionAnnotations: any) {
+export const displayMode = function (oPropertyAnnotations: any, oCollectionAnnotations: any) {
 	const oTextAnnotation = oPropertyAnnotations?.Common?.Text,
 		oTextArrangmentAnnotation =
 			oTextAnnotation &&
@@ -606,7 +608,7 @@ export const displayMode = function(oPropertyAnnotations: any, oCollectionAnnota
 	return oTextAnnotation ? "DescriptionValue" : "Value";
 };
 
-const _fetchPropertyInfo = function(converterContext: ConverterContext, oFilterFieldInfo: any, oTypeConfig: any) {
+const _fetchPropertyInfo = function (converterContext: ConverterContext, oFilterFieldInfo: any, oTypeConfig: any) {
 	let oPropertyInfo = _fetchBasicPropertyInfo(oFilterFieldInfo);
 	const sAnnotationPath = oFilterFieldInfo.annotationPath;
 
@@ -628,7 +630,7 @@ const _fetchPropertyInfo = function(converterContext: ConverterContext, oFilterF
 	return oPropertyInfo;
 };
 
-export const isMultiValue = function(oProperty: any) {
+export const isMultiValue = function (oProperty: any) {
 	let bIsMultiValue = true;
 	//SingleValue | MultiValue | SingleRange | MultiRange | SearchExpression | MultiRangeOrSearchExpression
 	switch (oProperty.filterExpression) {
@@ -646,10 +648,11 @@ export const isMultiValue = function(oProperty: any) {
 	return bIsMultiValue;
 };
 
-const getAnnotatedSelectionFieldData = function(
+const getAnnotatedSelectionFieldData = function (
 	converterContext: ConverterContext,
 	lrTables: TableVisualization[] = [],
-	annotationPath: string = ""
+	annotationPath: string = "",
+	includeHidden: boolean = false
 ) {
 	// Fetch all selectionVariants defined in the different visualizations and different views (multi table mode)
 	const selectionVariants: SelectionVariantConfiguration[] = getSelectionVariants(lrTables, converterContext);
@@ -665,15 +668,20 @@ const getAnnotatedSelectionFieldData = function(
 	// create a map of all potential filter fields based on...
 	const filterFields: Record<string, FilterField> = {
 		// ...non hidden properties of the entity
-		..._getSelectionFields(entityType, "", entityType.entityProperties, false, converterContext),
+		..._getSelectionFields(entityType, "", entityType.entityProperties, includeHidden, converterContext),
 		// ...additional manifest defined navigation properties
 		..._getSelectionFieldsByPath(
 			entityType,
 			converterContext.getManifestWrapper().getFilterConfiguration().navigationProperties,
-			false,
+			includeHidden,
 			converterContext
 		)
 	};
+	let aSelectOptions: any[] = [];
+	const selectionVariant = getSelectionVariant(entityType, converterContext);
+	if (selectionVariant) {
+		aSelectOptions = selectionVariant.SelectOptions;
+	}
 
 	const propertyInfoFields: any =
 		annotatedSelectionFields?.reduce((selectionFields: FilterField[], selectionField) => {
@@ -689,36 +697,55 @@ const getAnnotatedSelectionFieldData = function(
 			return selectionFields;
 		}, []) || [];
 
+	const defaultFilterFields = _getDefaultFilterFields(
+		aSelectOptions,
+		entityType,
+		converterContext,
+		excludedFilterProperties,
+		annotatedSelectionFields
+	);
+
 	return {
 		excludedFilterProperties: excludedFilterProperties,
 		entityType: entityType,
 		annotatedSelectionFields: annotatedSelectionFields,
 		filterFields: filterFields,
-		propertyInfoFields: propertyInfoFields
+		propertyInfoFields: propertyInfoFields,
+		defaultFilterFields: defaultFilterFields
 	};
 };
-export const processSelectionFields = function(propertyInfoFields: any, converterContext: ConverterContext) {
+export const processSelectionFields = function (
+	propertyInfoFields: any,
+	converterContext: ConverterContext,
+	defaultValuePropertyFields?: any
+) {
 	//get TypeConfig function
-	const aTypeConfig: any = [];
 	const selectionFieldTypes: any = [];
-	const _fnTypeConfig = function(property: Property) {
-		const oTypeConfig = getTypeConfig(property, undefined);
+	const aTypeConfig: any = {};
+	const _fnTypeConfig = function (property: Property, key: string) {
+		const oTypeConfig = getTypeConfig(property, property?.type);
 		selectionFieldTypes.push(property?.type);
-		if (property?.type === sEdmString && (!oTypeConfig.constraints.nullable || oTypeConfig.constraints.nullable === true)) {
+		if (
+			property?.type === sEdmString &&
+			(oTypeConfig.constraints.nullable === undefined || oTypeConfig.constraints.nullable === true)
+		) {
 			oTypeConfig.formatOptions.parseKeepsEmptyString = false;
 		}
-		aTypeConfig.push(oTypeConfig);
+		aTypeConfig[key] = oTypeConfig;
 	};
 
+	if (defaultValuePropertyFields) {
+		propertyInfoFields = propertyInfoFields.concat(defaultValuePropertyFields);
+	}
 	//add typeConfig
-	propertyInfoFields.forEach(function(parameterField: any) {
+	propertyInfoFields.forEach(function (parameterField: any) {
 		if (parameterField.annotationPath) {
 			const propertyConvertyContext = converterContext.getConverterContextFor(parameterField.annotationPath);
 			const propertyTargetObject = propertyConvertyContext.getDataModelObjectPath().targetObject;
-			_fnTypeConfig(propertyTargetObject);
+			_fnTypeConfig(propertyTargetObject, parameterField.key);
 		} else {
 			selectionFieldTypes.push(sEdmString);
-			aTypeConfig.push({ type: sStringDataType });
+			aTypeConfig[parameterField.key] = { type: sStringDataType };
 		}
 	});
 
@@ -750,20 +777,20 @@ export const processSelectionFields = function(propertyInfoFields: any, converte
 	const aFetchedProperties: any = [];
 
 	// process the fields to add necessary properties
-	Object.keys(propertyInfoFields).forEach(function(sFilterFieldKey: string) {
-		const oConvertedProperty = propertyInfoFields[sFilterFieldKey];
+	propertyInfoFields.forEach(function (propertyInfoField: any) {
+		const oConvertedProperty = propertyInfoField;
 		let sPropertyPath;
 		if (oConvertedProperty.conditionPath) {
 			sPropertyPath = oConvertedProperty.conditionPath.replace(/\+|\*/g, "");
 		}
 		if (aNonFilterableProps.indexOf(sPropertyPath) === -1) {
-			oPropertyInfo = _fetchPropertyInfo(converterContext, oConvertedProperty, aTypeConfig[sFilterFieldKey]);
+			oPropertyInfo = _fetchPropertyInfo(converterContext, oConvertedProperty, aTypeConfig[propertyInfoField.key]);
 			if (oPropertyInfo) {
 				oPropertyInfo = Object.assign(oPropertyInfo, {
 					maxConditions: !oPropertyInfo.isParameter && isMultiValue(oPropertyInfo) ? -1 : 1,
 					required: oPropertyInfo.isParameter || aRequiredProps.indexOf(sPropertyPath) >= 0,
 					caseSensitive: isCaseSensitive,
-					dataType: selectionFieldTypes[sFilterFieldKey]
+					dataType: aTypeConfig[propertyInfoField.key].type
 				});
 
 				aFetchedProperties.push(oPropertyInfo);
@@ -787,7 +814,7 @@ export const processSelectionFields = function(propertyInfoFields: any, converte
 	return aFetchedProperties;
 };
 
-export const insertCustomManifestElements = function(
+export const insertCustomManifestElements = function (
 	filterFields: FilterField[],
 	entityType: EntityType,
 	converterContext: ConverterContext
@@ -811,12 +838,13 @@ export const insertCustomManifestElements = function(
  * @param {string} annotationPath
  * @returns {FilterSelectionField[]} An array of selection fields
  */
-export const getSelectionFields = function(
+export const getSelectionFields = function (
 	converterContext: ConverterContext,
 	lrTables: TableVisualization[] = [],
-	annotationPath: string = ""
+	annotationPath: string = "",
+	includeHidden?: boolean
 ): any {
-	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(converterContext, lrTables, annotationPath);
+	const oAnnotatedSelectionFieldData = getAnnotatedSelectionFieldData(converterContext, lrTables, annotationPath, includeHidden);
 	const parameterFields = _getParameterFields(converterContext);
 	let propertyInfoFields: FilterField[] = JSON.parse(JSON.stringify(oAnnotatedSelectionFieldData.propertyInfoFields));
 	const entityType = oAnnotatedSelectionFieldData.entityType;
@@ -825,8 +853,12 @@ export const getSelectionFields = function(
 
 	propertyInfoFields = insertCustomManifestElements(propertyInfoFields, entityType, converterContext);
 
-	const aFetchedProperties = processSelectionFields(propertyInfoFields, converterContext);
-	aFetchedProperties.sort(function(a: any, b: any) {
+	const aFetchedProperties = processSelectionFields(
+		propertyInfoFields,
+		converterContext,
+		oAnnotatedSelectionFieldData.defaultFilterFields
+	);
+	aFetchedProperties.sort(function (a: any, b: any) {
 		if (a.groupLabel === undefined || a.groupLabel === null) {
 			return -1;
 		}
@@ -871,35 +903,17 @@ export const getSelectionFields = function(
 		}, {});
 	}
 
-	let aSelectOptions: any[] = [];
-	const selectionVariant = getSelectionVariant(entityType, converterContext);
-	if (selectionVariant) {
-		aSelectOptions = selectionVariant.SelectOptions;
-	}
-
 	// create a map of all potential filter fields based on...
 	const filterFields: Record<string, FilterField> = oAnnotatedSelectionFieldData.filterFields;
 
-	//Filters which has to be added which is part of SV/Default annotations but not present in the SelectionFields
-	const annotatedSelectionFields = oAnnotatedSelectionFieldData.annotatedSelectionFields;
-	const defaultFilters = _getDefaultFilterFields(
-		filterFields,
-		aSelectOptions,
-		entityType,
-		converterContext,
-		excludedFilterProperties,
-		annotatedSelectionFields
-	);
-
 	// finally create final list of filter fields by adding the SelectionFields first (order matters)...
 	let allFilters = propSelectionFields
-		// To add the FilterField which is not part of the Selection Fields but the property is mentioned in the Selection Variant
-		.concat(defaultFilters || [])
+
 		// ...and adding remaining filter fields, that are not used in a SelectionVariant (order doesn't matter)
 		.concat(
 			Object.keys(filterFields)
-				.filter(propertyPath => !(propertyPath in excludedFilterProperties))
-				.map(propertyPath => {
+				.filter((propertyPath) => !(propertyPath in excludedFilterProperties))
+				.map((propertyPath) => {
 					return Object.assign(filterFields[propertyPath], filterFacetMap[propertyPath]);
 				})
 		);
@@ -912,8 +926,8 @@ export const getSelectionFields = function(
 		// LR to get aggregates (without currency/unit properties since we expect to be able to filter them).
 		const aggregates = lrTables[0].aggregates;
 		if (aggregates) {
-			const aggregatableProperties: string[] = Object.keys(aggregates).map(aggregateKey => aggregates[aggregateKey].relativePath);
-			allFilters = allFilters.filter(filterField => {
+			const aggregatableProperties: string[] = Object.keys(aggregates).map((aggregateKey) => aggregates[aggregateKey].relativePath);
+			allFilters = allFilters.filter((filterField) => {
 				return aggregatableProperties.indexOf(filterField.key) === -1;
 			});
 		}
@@ -923,9 +937,34 @@ export const getSelectionFields = function(
 
 	// Add caseSensitive property to all selection fields.
 	const isCaseSensitive = isFilteringCaseSensitive(converterContext);
-	selectionFields.forEach(filterField => {
+	selectionFields.forEach((filterField) => {
 		filterField.caseSensitive = isCaseSensitive;
 	});
 
 	return { selectionFields, sPropertyInfo };
 };
+
+/**
+ * Determines whether the filter bar inside a value help dialog should be expanded. This is true if one of the following condition holds:
+ * (1) a filter property is mandatory,
+ * (2) no search field exists (entity isn't search enabled),
+ * (3) when the data isn't loaded by default (annotation FetchValues = 2).
+ * @param {ConverterContext} converterContext The converter context
+ * @param {any} filterRestrictionsAnnotation The FilterRestriction annotation
+ * @param {any} valueListAnnotation The ValueList annotation
+ * @returns {boolean} The value for expandFilterFields
+ */
+export const getExpandFilterFields = function (
+	converterContext: ConverterContext,
+	filterRestrictionsAnnotation: any,
+	valueListAnnotation: 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;
+	}
+	return false;
+};