@sapui5/sap.fe.core 1.111.0 → 1.112.0

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

@@ -1,5 +1,12 @@
 import type { AnnotationTerm, EntityType, NavigationProperty, Property, PropertyPath } from "@sap-ux/vocabularies-types";
+import type {
+	FilterExpressionRestrictionType,
+	FilterExpressionType,
+	FilterRestrictions,
+	FilterRestrictionsType
+} from "@sap-ux/vocabularies-types/vocabularies/Capabilities";
 import type { EntitySetAnnotations_Capabilities } from "@sap-ux/vocabularies-types/vocabularies/Capabilities_Edm";
+import type { EntityTypeAnnotations, PropertyAnnotations } from "@sap-ux/vocabularies-types/vocabularies/Edm_Types";
 import type {
 	DataField,
 	DataFieldAbstractTypes,
@@ -13,19 +20,23 @@ 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 type {
+	AvailabilityType,
+	FilterFieldManifestConfiguration,
+	FilterManifestConfiguration,
+	FilterSettings
+} from "../../ManifestSettings";
 import { getSelectionVariant } from "../Common/DataVisualization";
 //import { hasValueHelp } from "sap/fe/core/templating/PropertyHelper";
 
@@ -37,6 +48,7 @@ export type FilterField = ConfigurableObject & {
 	label?: string;
 	template?: string;
 	group?: string;
+	menu?: string;
 	groupLabel?: string;
 	settings?: FilterSettings;
 	isParameter?: boolean;
@@ -171,18 +183,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(
@@ -278,22 +285,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 +307,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 +374,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 +383,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 +435,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 +448,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 +486,7 @@ const getSearchFilterPropertyInfo = function () {
 	};
 };
 
-const getEditStateFilterPropertyInfo = function () {
+const getEditStateFilterPropertyInfo = function (): PropertyInfo {
 	return {
 		name: "$editState",
 		path: "$editState",
@@ -496,22 +507,44 @@ const getSearchRestrictions = function (converterContext: ConverterContext) {
 };
 
 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 +564,7 @@ const _fetchBasicPropertyInfo = function (oFilterFieldInfo: any) {
 	};
 };
 
-export const getSpecificAllowedExpression = function (aExpressions: any) {
+export const getSpecificAllowedExpression = function (aExpressions: string[]) {
 	const aAllowedExpressionsPriority = [
 		"SingleValue",
 		"MultiValue",
@@ -541,14 +574,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 +599,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 +625,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) {
@@ -620,8 +657,8 @@ const _isFilterableNavigationProperty = function (
 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)
@@ -661,13 +698,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 +758,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 +780,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;
@@ -775,10 +812,14 @@ export const processSelectionFields = function (
 			?.FilterRestrictions;
 	}
 	const oFilterRestrictions = _oFilterrestrictions;
-	const oRet = {} as any;
-	oRet["RequiredProperties"] = getFilterRestrictions(oFilterRestrictions, "RequiredProperties") || [];
-	oRet["NonFilterableProperties"] = getFilterRestrictions(oFilterRestrictions, "NonFilterableProperties") || [];
-	oRet["FilterAllowedExpressions"] = getFilterRestrictions(oFilterRestrictions, "FilterAllowedExpressions") || {};
+	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 +828,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 +901,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 +925,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 +1019,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;
 	}